- List Comprehensions nutzen, wenn möglich
- pythonische Lösungen (z.B. zip() und any()) gegenüber klassischen Ansätzen bevorzugen
- bei Factory-Methoden das erstellte Objekt liefern oder None anstatt True/False
- ...
Bei weitem nicht alles, was ich verbessern würde, aber hier ein paar Ansätze (ungetestet):
Code: Alles auswählen
#!/usr/bin/python3
from random import randrange
def _randpos(size):
return randrange(size), randrange(size)
class Game():
def __init__(
self, game_size, planet_size, num_planets, num_players, building_types
):
if num_players > num_planets:
raise ValueError('num_players must not exceed num_planets')
self.planets = [
Planet(_randpos(game_size), planet_size)
for _ in range(num_planets)
]
for i, planet in zip(range(num_players), self.planets):
planet.place_commando_center(i)
self.building_types = {tp.__name__: tp for tp in building_types}
self.turn = 0
self.undetermined_commands = []
def _show_all_planets(self):
# Only meant for testing purposes
for plnt in self.planets:
plnt._show()
def get_home_planet(self, player):
return self.planets[player]
def build_object(self, planet_id, player_id, position, object_type):
planet = self.planets[planet]
if object_type.is_buildable(planet, player_id, position):
field = planet.get_field(position)
obj = object_type(planet_id, player, position)
planet.set_field(position, (field[0], obj))
return obj
def turn_end(self):
while self.undetermined_commands:
command = self.undetermined_commands.pop(random.randrange(len(
self.undetermined_commands)))
self.run_command(command)
self.undetermined_commands = []
def add_command(self, command):
self.undetermined_commands.append(command)
def run_command(self, command):
name = command[0]
if name == "build":
self.build_object(command[1], command[2], command[3],
self.registered_buildings[command[4]])
class Planet():
def __init__(self, position, size):
self.position = position
self.size = size
self.map = [
[('d', None) for _ in range(size)] for _ in range(size)
]
def __repr__(self):
class_name = type(self).__name__
x, y = self.position
return '{}(x={}, y={})'.format(class_name, x, y)
def place_commando_center(self, player_id):
position = _randpos(self.size)
field = self.get_field(pos)
commando_center = CommandoCenter(self, player_id, position)
self.set_field(position, (field[0], commando_center))
def has_commando_center(self, player_id):
return any(
field[1].owner == player_id and isinstance(field[1], CommandoCenter)
for row in self.map for field in row
)
def get_field(self, position):
x, y = position
return self.map[x][y]
def set_field(self, position, field):
x, y = position
self.map[x][y] = field
def _show(self):
print(self)
print('\n'.join(self.map))
class Building():
__name__ = "Building"
def __init__(self, planet, owner, pos):
self.owner = owner
self.planet = planet
@staticmethod
def is_buildable(planet, owner, pos):
return True
class CommandoCenter(Building):
__name__ = "Commando Center"
class House(Building):
__name__ = "House"
@staticmethod
def is_buildable(planet, owner, pos):
#TODO: make it only buildable near CommandoCenter
return True
buildings = []
buildings.append(CommandoCenter)
buildings.append(House)
class SpaceShip():
def __init__(self, pos, target):
self.dir_vector = dir_vector
self.pos = pos
self.target = target
def on_step():
pass#NotImplementedYet
##test section
print(buildings)
g = Game(10, 3, 5, 3, buildings)
print("NEW GAME", end="\n"*3)
g.add_command(("build", 0, 0, (0, 0), "House"))
g.turn_end()
g._show_all_planets()
