fork download
copy 
  1. # Examen ALS 16/3/2018 Juego de estrategia Baltasar <baltasarq@gmail.com>
  2. import random as rnd
  3. import time as tm
  4.  
  5.  
  6. class Unidad:
  7. 	"""Clase base para todas las unidades."""
  8. 	def __init__(self, num_soldados):
  9. 		"""Crea una unidad con unos soldados.
  10.  
  11. 			:param num_soldados: Los soldados iniciales.
  12. 		"""
  13. 		self._num_soldados = num_soldados
  14.  
  15. 	@property
  16. 	def num_soldados(self):
  17. 		"""Devuelve los soldados actuales."""
  18. 		return self._num_soldados
  19.  
  20. 	def puntos_defensa(self):
  21. 		"""Devuelve los puntos de defensa."""
  22. 		return 10
  23.  
  24. 	def puntos_ataque(self):
  25. 		"""Devuelve los puntos de ataque."""
  26. 		return round(10 * self.num_soldados * rnd.random())
  27.  
  28. 	def __gt__(self, ud2):
  29. 		"""Devuelve True si esta unidad tiene mayores efectivos."""
  30. 		toret = False
  31. 		if isinstance(ud2, Unidad):
  32. 			toret = self.num_soldados > us2.num_soldados
  33. 		return toret
  34.  
  35. 	def __lt__(self, ud2):
  36. 		"""Devuelve True si esta unidad tiene menors efectivos."""
  37. 		toret = False
  38. 		if isinstance(ud2, Unidad):
  39. 			toret = self.num_soldados < us2.num_soldados
  40. 		return toret
  41.  
  42. 	def combate(self, ud2):
  43. 		"""Resuelve el combate de esta unidad con otra.
  44.  
  45. 			:param ud2: La otra unidad.
  46. 		"""
  47. 		Unidad.ataca(self, ud2)
  48. 		Unidad.ataca(ud2, self)
  49.  
  50. 	@staticmethod
  51. 	def ataca(ud1, ud2):
  52. 		"""Establece el ataque de una unidad a otra.
  53.  
  54. 			:param ud1: La primera unidad combatiente.
  55. 			:param ud2: La segunda unidad combatiente.
  56. 		"""
  57. 		atq = ud2.puntos_ataque()
  58. 		dfs = ud2.puntos_defensa()
  59.  
  60. 		if atq != 0:
  61. 			soldados = (dfs/atq) * rnd.random() * ud1.num_soldados
  62. 			if soldados < ud1.num_soldados:
  63. 				ud1._num_soldados -= round(soldados)
  64.  
  65. 	def __str__(self):
  66. 		return str.format("SLD {} DEF {} ATQ {}",
  67. 							self.num_soldados,
  68. 							self.puntos_defensa(),
  69. 							self.puntos_ataque())
  70.  
  71.  
  72. class Caballeria(Unidad):
  73. 	"""Caballeria (bonifica ataque al 50%, penaliza defensa al 60%)"""
  74. 	def __init__(self, num_soldados):
  75. 		super().__init__(num_soldados)
  76.  
  77. 	def puntos_ataque(self):
  78. 		return round(super().puntos_ataque() * 1.50)
  79.  
  80. 	def puntos_defensa(self):
  81. 		return round(super().puntos_defensa() * 0.4)
  82.  
  83. 	def __str__(self):
  84. 		return "Caballeria " + super().__str__()
  85.  
  86.  
  87. class Arqueros(Unidad):
  88. 	"""Arqueros bonifica ataque 10%, defensa 100%"""
  89. 	def __init__(self, num_soldados):
  90. 		super().__init__(num_soldados)
  91.  
  92. 	def puntos_ataque(self):
  93. 		return round(super().puntos_ataque() * 1.10)
  94.  
  95. 	def puntos_defensa(self):
  96. 		return round(super().puntos_defensa() * 2)
  97.  
  98. 	def __str__(self):
  99. 		return "Arqueros   " + super().__str__()
  100.  
  101.  
  102. class Infanteria(Unidad):
  103. 	"""Infantes, penaliza ataque 30%, bonifica defensa 150%"""
  104. 	def __init__(self, num_soldados):
  105. 		super().__init__(num_soldados)
  106.  
  107. 	def puntos_ataque(self):
  108. 		return round(super().puntos_ataque() * .7)
  109.  
  110. 	def puntos_ataque(self):
  111. 		return round(super().puntos_defensa() * 2.5)
  112.  
  113. 	def __str__(self):
  114. 		return "Infanteria " + super().__str__()
  115.  
  116.  
  117.  
  118. class Maniobra:
  119. 	"""Engloba varias unidades."""
  120. 	def __init__(self):
  121. 		self._unidades = []
  122.  
  123. 	def inserta(self, ud):
  124. 		"""Inserta una unidad ud en la maniobra."""
  125. 		self._unidades.append(ud)
  126.  
  127. 	def __getitem__(self, i):
  128. 		return self._unidades[i]
  129.  
  130. 	def __setitem__(self, i, val):
  131. 		self._unidades[i] = val
  132.  
  133. 	def __len__(self):
  134. 		return len(self._unidades)
  135.  
  136. 	def __str__(self):
  137. 		toret = "UDS: " + str(len(self._unidades)) + '\n'
  138.  
  139. 		for ud in self._unidades:
  140. 			toret += str(ud) + "\n"
  141.  
  142. 		return toret
  143.  
  144. if __name__ == "__main__":
  145. 	rnd.seed(tm.time())
  146. 	m = Maniobra()
  147. 	m.inserta(Infanteria(25))
  148. 	m.inserta(Arqueros(25))
  149. 	m.inserta(Caballeria(25))
  150. 	print(m)
  151. 	m[0].combate(m[1])
  152. 	print(m)
  153.  
Success #stdin #stdout 0.04s 12072KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
UDS: 3
Infanteria SLD 25 DEF 10 ATQ 25
Arqueros   SLD 25 DEF 20 ATQ 154
Caballeria SLD 25 DEF 4 ATQ 189

UDS: 3
Infanteria SLD 23 DEF 10 ATQ 25
Arqueros   SLD 17 DEF 20 ATQ 33
Caballeria SLD 25 DEF 4 ATQ 274
https://ideone.com/z6bNQS
Ejercicio de juego de estrategia
language:
Python 3 (python  3.9.5)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!