Das deutsche Python-Forum

Code: Alles auswählen

def register_building(name, image, ...):
    class Building:
        def __init__(self, position, owner):
            self.position = position
            self.owner = owner
            self.name = name
            self.image = image
            self..... =...
    return Building

Code: Alles auswählen

class Building:
    def __init__(selfposition, owner):
        self.owner = owner
        self.position = position
    def can_build(self):
        return True
    def on_turn_start(self, turn):
        do_something()

Code: Alles auswählen

class Building:
    def __init__(self, ...):
        # ...

    # Some methods

    @staticmethod
    def is_buildable(game_map):
        # Only concrete buildings are buildable
        return False


class Farm(Building):
    # ...

    @staticmethod
    def is_buildable(game_map):
        # Check the map
        # Return True or False

Code: Alles auswählen

Farm.is_buildable(game_map)

Code: Alles auswählen

class GameMap:
    # ...

    def build_object(self, object_type, position, *optargs):
        if not object_type.is_buildable(self):
            # entsprechende Darstellung, z.B. roter Bereich
            # als eigene Methode auslagern
        else:
            # Erzeuge Exemplar von Gebäudetyp
            # Gib die Map (d.h. dich selbst) als Argument mit
            # Optionale Argumente für Anzahl, Farbe, ... möglich
            obj = object_type(self, *optargs)
            self.register(obj)
            return obj

Code: Alles auswählen

game_map.build_object(Farm, (pos_x, pos_y))

# Oder mit optionalen Argumenten
game_map.build_object(Farm, (pos_x, pos_y), weiteres_arg, noch_eins)

Code: Alles auswählen

#!/usr/bin/python3
import random

class Game():
    def __init__(self, size, planetcount, planetmapsize, playercount, buildings):
        self.registered_buildings = {} 
        for building_class in buildings:
            self.register_building(building_class)

        self.turn = 0
        self.undetermined_commands = []

        #place planets
        self.planets = []
        for plnt in range(planetcount):
            x, y = [random.randrange(size) for i in range(2)]
            pos = (x, y)
            self.planets.append(Planet(pos, planetmapsize))
        ##init player
        if planetcount < playercount:
            raise ValueError("planetcount less then playercount")
        #give every player one planet:
        for player in range(playercount):
            self.planets[player].place_commando_center(player)
            #we can do this because all planets where placed randomly
           
    def _show_all_planets(self): #only for Test
        for plnt in self.planets:
            plnt._show()
    
    def get_player_first_planet(self, player):
        return self.planets[player]

    def build_object(self, planet, player, pos, object):
        planet = self.planets[planet] 
        if not object.is_buildable(planet, player, pos):
            return False
        field = planet.get_field(pos)
        planet.set_field(pos, [field[0], object(planet, player, pos)])
        return True

    def register_building(self, building_class):
        self.registered_buildings[building_class.__name__] = building_class

    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, pos, size):
        self.x, self.y = pos
        self.map = []
        self.map_size = size
        for row in range(size):
            self.map.append([])
        for row in self.map:
            for column in range(size):
                row.append(["d", None])

    def place_commando_center(self, player):
        pos = [random.randrange(self.map_size) for i in range(2)]
        field = self.get_field(pos)
        self.set_field(pos, [field[0], CommandoCenter(self, player, pos)])

    def has_commando_center(self, player):
        for y in map:
            for x in y:
                if type(x[1]) == CommandoCenter:
                    if x[1].owner == player:
                        return True
        return False

    def get_field(self, pos):
        return self.map[pos[0]][pos[1]]
    
    def set_field(self, pos, field):
        self.map[pos[0]][pos[1]] = field
    
    def _show(self):
        print("planet", (self.x, self.y))
        for i in self.map:
            print(i)
    

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()

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()