Example #1
0
    def __init__(self,
                 name,
                 image,
                 frames,
                 directions=1,
                 timing=100,
                 sound=None):
        GameObject.__init__(self)

        assert isinstance(image, Image)

        #if sound:
        #    assert(sound, Sound)

        self.name = name
        self.image = image
        self.images = None
        self.directions = directions
        self.frames = frames
        self.timing = timing

        # TODO: some checking to make sure inputs are the correct length
        if isinstance(self.frames, int):
            self.frames = tuple(range(0, self.frames))
        else:
            self.frames = tuple(self.frames)

        self.real_frames = len(set(self.frames))

        if isinstance(self.timing, int):
            self.timing = tuple([self.timing] * len(self.frames))
        else:
            self.timing = tuple(self.timing)
Example #2
0
    def __init__(self, tmx, size, **kwargs):
        GameObject.__init__(self)

        self.default_image = generateDefaultImage((tmx.tilewidth,
                                                   tmx.tileheight))
        self.tmx = tmx
        self.setSize(size)
Example #3
0
 def __init__(self, p, locked=False, blocks=None, *args, **kwargs):
     GameObject.__init__(self, 'door', location=p, char='+', *args, **kwargs)
     self.tileindex = (0,0)
     self.block_move = True
     self.block_sight = True
     self.blocks = blocks
     self.locked = locked
Example #4
0
    def __init__(self,name,image,frames,directions=1,timing=100,sound=None):
        GameObject.__init__(self)
        self.add(image)

        self.name = name
        self.image = image
        self.images = None
        self.directions = directions
        self.frames = frames
        self.timing = timing

        # TODO: some checking to make sure inputs are the correct length
        if isinstance(self.frames, int):
            self.frames = tuple(range(0, self.frames))
        else:
            self.frames = tuple(self.frames)

        self.real_frames = len(set(self.frames))

        if isinstance(self.timing, int):
            self.timing = tuple([self.timing] * len(self.frames))
        else:
            self.timing = tuple(self.timing)

        if (self.images is not None) and (not force):
            return
Example #5
0
    def __init__(self, tmx, size, **kwargs):
        GameObject.__init__(self)

        self.default_image = generateDefaultImage(
            (tmx.tilewidth, tmx.tileheight))
        self.tmx = tmx
        self.setSize(size)
Example #6
0
    def __init__(self,name,image,frames,directions=1,timing=100,sound=None):
        GameObject.__init__(self)

        assert isinstance(image, Image)

        #if sound:
        #    assert(sound, Sound)


        self.name = name
        self.image = image
        self.images = None
        self.directions = directions
        self.frames = frames
        self.timing = timing

        # TODO: some checking to make sure inputs are the correct length
        if isinstance(self.frames, int):
            self.frames = tuple(range(0, self.frames))
        else:
            self.frames = tuple(self.frames)

        self.real_frames = len(set(self.frames))

        if isinstance(self.timing, int):
            self.timing = tuple([self.timing] * len(self.frames))
        else:
            self.timing = tuple(self.timing)
Example #7
0
 def add(self, other):
     if isinstance(other, Animation):
         self.animations[other.name] = other
         if self.default == None:
             self.setDefault(other)
         
     GameObject.add(self, other)
Example #8
0
 def __init__(self, unlocks, *args, **kwargs):
     GameObject.__init__(self, 'key', char='[', *args, **kwargs)
     self.unlocks = unlocks
     self.facts.append(Solves(self, unlocks.blocks_fact.obj))
     for obj in self.world.player.wants:
         if obj.location_fact.obj == self.unlocks.blocks:
             # Todo: player doesn't *want* us until they know about us!
             self.facts.append(Wants(self.world.player, self))
Example #9
0
    def __init__(self, filename, name, tile=None, size=None):
        GameObject.__init__(self)

        self.filename = filename
        self.name = name
        self.tile = tile
        self.size = size

        self.image = None
Example #10
0
 def __init__(self, data):
     GameObject.__init__(self)
     self.rect = Rect(data.x, data.y, data.width, data.height)
     if hasattr(data, 'points'):
         self.points = data.points
     else:
         self.points = None
     self.name = data.name
     self.properties = data.properties
     self.entered = False
Example #11
0
    def __init__(self, name, image, tile=None, size=None):
        GameObject.__init__(self)

        self.image = image
        self.name = name
        self.tile = tile
        self.size = size

        self.frames = [0]
        self.timing = [-1]
Example #12
0
File: zone.py Project: MacLeek/mh
    def __init__(self, data):
        GameObject.__init__(self)
        self.extent = Rect(data.x, data.y, data.width, data.height)
        if hasattr(data, 'points'):
            self.points = data.points
        else:
            self.points = None
        self.name = data.name
        self.properties = data.properties

        self.entered = False
Example #13
0
    def __init__(self, name, description='', location=None, *args, **kwargs):
        self.map_memory = {}

        GameObject.__init__(self, name=name, description=description, location=location, *args, **kwargs)

        self.tiletype = 2
        self.knowledge = set()
        self.wants = []
        self.relationships = None
        self.hp = 1
        self.block_move = True
Example #14
0
File: ani.py Project: bitcraft/mh
    def __init__(self, filename, size, name=None, directions=1):
        GameObject.__init__(self)

        self.filename = filename
        self.size = size

        if name == None:
            self.name = filename

        self.directions = directions  # number of directions for animation
        self.frames = ([],) * directions
Example #15
0
 def door(x=None, y=None):
     tile = Tile('+', "Door", x, y)
     tile.add_trait(traits.Openable(tile))
     tile.add_trait(traits.Destroyable(
         tile,
         [
             lambda: Tile.floor(tile.x, tile.y),
             lambda: GameObject.debris(tile.x + random.randint(-2, 2), tile.y + random.randint(-2, 2)),
             lambda: GameObject.debris(tile.x + random.randint(-2, 2), tile.y + random.randint(-2, 2)),
         ]
     ))
     return tile
Example #16
0
    def __init__(self, name, image):
        GameObject.__init__(self)

        try:
            assert isinstance(image, Image) or isinstance(image, ImageTile)
        except AssertionError:
            print name, image
            raise

        self.image = image
        self.name = name
        self.frames = [0]
        self.timing = [-1]
Example #17
0
    def __init__(self, name, image):
        GameObject.__init__(self)

        try:
            assert isinstance(image, Image) or isinstance(image, ImageTile)
        except AssertionError:
            print name, image
            raise

        self.image = image
        self.name = name
        self.frames = [0]
        self.timing = [-1]
Example #18
0
File: env.py Project: bitcraft/mh
    def __init__(self):
        GameObject.__init__(self)
        self.exits    = {}
        self.geometry = {}       # geometry (for collisions) of each layer
        self.objects = {}        # position and size of objects in 3d space
        self.orientations = {}   # records where the object is facing
        self.extent = None       # absolute boundries of the area
        self.joins = []
        self._oldPositions = {}  # used in collision handling

        self.messages = []

        self.time = 0
Example #19
0
 def wall(x=None, y=None):
     tile = Tile('#', "Wall", x, y, 100, blocks_movement=True, blocks_light=True)
     tile.add_trait(traits.Destroyable(
             tile,
             [ 
                 lambda: Tile.floor(tile.x, tile.y),
                 lambda: GameObject.debris(tile.x + random.randint(-5, 5), tile.y + random.randint(-5, 5)),
                 lambda: GameObject.debris(tile.x + random.randint(-5, 5), tile.y + random.randint(-5, 5)),
                 lambda: GameObject.debris(tile.x + random.randint(-5, 5), tile.y + random.randint(-5, 5)),
                 lambda: GameObject.debris(tile.x + random.randint(-5, 5), tile.y + random.randint(-5, 5)),
             ]
         ))
     return tile
Example #20
0
 def __init__(self):
     GameObject.__init__(self)
     self.default      = None
     self.callback     = None    # called when animation finishes
     self.curImage     = None    # cached for drawing ops
     self.curFrame     = None    # current frame number
     self.curAnimation = None
     self.animations   = {}
     self.loop_frame = 0
     self.looped     = 0
     self.loop       = -1
     self.timer      = 0
     self._prevAngle = None
     self._prevFrame = None
     self._is_paused = False
Example #21
0
    def get_contents(self, coordinates = None):
        """
        Return a list of the contents of a sector at the provided coordinates.
        """
        if not coordinates or not isinstance(coordinates,Coordinates):
            self.log.warning("%s called without proper coordinates: %s (type %s)" % (
                "Game.get_contents()",
                str(coordinates),
                str(coordinates.__class__.__name__),
            ))
            return []

        contents = []
        self.log.debug("Building content list for %s..." % str(coordinates))
        # GameObject -> ManMade or Natural -> Object we want here
        for parent in GameObject.__subclasses__():
            self.log.debug("Processing %s objects..." % str(parent))
            for child in globals()[parent.__name__].__subclasses__():
                self.log.debug("Processing %s objects under %s..." % (str(child),str(parent)))
                # subclasses returns full path, ex: objects.star.Star
                # child.__name__ returns Star
                shared_object = getattr(Game,'_' + globals()[child.__name__]().plural())
                if shared_object and coordinates in shared_object:
                    contents += shared_object[coordinates]
                    self.log.debug("Added %s to contents: %s" % (
                        str(globals()[child.__name__]().plural()),
                        str(shared_object[coordinates]),
                    ))
        self.log.debug("Coordinates %s contents: %s" % (str(coordinates),pprint.pformat(contents)))
        return contents
Example #22
0
    def __init__(self, agent_metadata_queue, quit_event, options):
        super().__init__(agent_metadata_queue, quit_event, options)
        self.logger.info('Initialised!')
        self.team: int = -1

        # A list of cars for both teammates and opponents
        self.friends: [CarObject] = []
        self.foes: [CarObject] = []
        # This holds the carobjects for our agent
        self.drones: [CarObject] = []
        self.ball: BallObject = BallObject()
        self.game: GameObject = GameObject()
        # A list of boosts
        self.boosts: [BoostObject] = []
        # goals
        self.friend_goal: GoalObject = None
        self.foe_goal: GoalObject = None
        # Game time
        self.time: float = 0.0
        self.odd_tick = 0
        # Whether or not GoslingAgent has run its get_ready() function
        self.ready: bool = False
        # a flag that tells us when kickoff is happening
        self.kickoff_flag: bool = False
        self.prev_kickoff_flag: bool = False
        self.conceding: bool = False
        # If true we will go for more stuff
        # Initialized as true since we are always desperate
        self.desperate = False
Example #23
0
    def __init__(self, filename, name, frames, directions=1, timing=None):
        GameObject.__init__(self)

        self.filename = filename
        self.name = name
        self.order = None

        if isinstance(frames, int):
            self.frames = frames
            self.real_frames = frames

        elif isinstance(frames, list):
            self.frames = len(frames)
            self.real_frames = max(frames) + 1
            self.order = frames

        self.directions = directions
        self.timing = timing
        self.images = []
Example #24
0
    def remove(self, other):
        playing = False
        if isinstance(other, (animation.Animation, animation.StaticAnimation)):
            if self.isPlaying(other):
                playing = True
            del self.animations[other.name]
        
        GameObject.remove(self, other)

        # handle when there are no animations left
        if len(self.animations) == 0:
            self.curAnimation = None
            self.curImage = None
            self.curFrame = None
            self.default = None
            self._is_paused = True
        elif playing:
            self.setDefault(self.animations.keys()[0])
            self.reset()
Example #25
0
    def __init__(self, animations):
        GameObject.__init__(self)
        self.default      = None
        self.curImage     = None    # cached for drawing ops
        self.curFrame     = None    # current frame number
        self.curAnimation = None
        self.animations   = {}
        self.looped     = 0
        self.loop       = -1
        self.timer      = 0.0
        self.ttl = 0
        self._prevAngle = None

        for animation in animations:
            self.add(animation)
            self.animations[animation.name] = animation

        self.setDefault(animations[0])
        self.play()
Example #26
0
 def __init_(self):
     GameObject.__init__(
         self,
         components=[
             components.CPosition(),
             components.CPlayerMovement(),
             components.CActorAnimParser(self.pathLists),
         ])
     
     # Create a flipped copy of LEFT_WALK as our RIGHT_WALK animation
     # -- this will be changed when we have more walking animations.
     components.CActorAnimParser.animations[
         enums.ActorAnim.WALK_RIGHT
         ] = tools.AnimCreator.createHorizontallyFlippedAnimation(
                 components.CActorAnimParser.animations[WALK_LEFT])
     # do the same for STANDING_RIGHT with STANDING_LEFT
     components.CActorAnimParser.animations[
         enums.ActorAnim.STANDING_RIGHT
         ] = tools.AnimCreator.createHorizontallyFlippedAnimation(
                 components.CActorAnimParser.animations[
                     STANDING_RIGHT])
Example #27
0
    def __init__(self, animations, axis_offset=(0,0)):
        GameObject.__init__(self)
        self.axis_offset = Vec2d(axis_offset)

        self.curImage     = None    # cached for drawing ops
        self.curFrame     = None    # current frame number
        self.curAnimation = None
        self.animations   = {}
        self.looped     = 0
        self.timer      = 0.0
        self.ttl = 0
        self.flip = 0
        self.speed_mod = 1.0
        self._prevAngle = None
        self._changed = True
        self.axis = Vec2d(0,0)

        for animation in animations:
            self.add(animation)
            self.animations[animation.name] = animation

        self.play(self.animations.keys()[0])
Example #28
0
File: avatar.py Project: MacLeek/mh
    def __init__(self, animations, axis_offset=(0, 0)):
        GameObject.__init__(self)
        self.axis_offset = Vec2d(axis_offset)

        self.curImage = None  # cached for drawing ops
        self.curFrame = None  # current frame number
        self.curAnimation = None
        self.animations = {}
        self.looped = 0
        self.timer = 0.0
        self.ttl = 0
        self.flip = 0
        self.speed_mod = 1.0
        self._prevAngle = None
        self._changed = True
        self.axis = Vec2d(0, 0)

        for animation in animations:
            self.add(animation)
            self.animations[animation.name] = animation

        self.play(self.animations.keys()[0])
Example #29
0
 def __init__(self, world, tree):
     self.world = world
     self.id = tree.get('id')
     self.properties = conv.unpack_properties(tree)
     self.objects = {}
     for obj in tree.findall('object'):
         self.objects[obj.get('id')] = GameObject(obj, self.world)
     self.events = []
     for event in tree.find('events').findall('event'):
         self.events.append(event.get('id'))
         self.world.eventhandler.events[event.get('id')] = self.world.eventhandler.parser.parse_xml(event)
     Room.instances[self.id] = self
     return
Example #30
0
def gen_item_health(coords):

    x, y = coords

    item_comp = Item(use_function=gf.cast_heal)
    item = GameObject(g.settings,
                      "Health Potion",
                      x,
                      y,
                      color=colors.lighter_crimson,
                      img=r.health_potion,
                      item=item_comp)

    return item
Example #31
0
def gen_item_scroll_lightning(coords):

    x, y = coords

    item_comp = Item(use_function=gf.cast_lightning)
    item = GameObject(g.settings,
                      "Scroll of lightning bolt",
                      x,
                      y,
                      color=colors.lightest_sky,
                      img=r.scroll2,
                      item=item_comp)

    return item
Example #32
0
def gen_item_scroll_confuse(coords):

    x, y = coords

    item_comp = Item(use_function=gf.cast_confuse)
    item = GameObject(g.settings,
                      "Scroll of confuse",
                      x,
                      y,
                      color=colors.light_yellow,
                      img=r.scroll,
                      item=item_comp)

    return item
Example #33
0
def gen_equ_shield(coords):

    x, y = coords

    bonus = randint(5, 10)

    equipment_com = Equipment(defense_bonus=bonus, slot='hand2')

    item = GameObject(g.settings,
                      "Shield" + " +" + str(bonus),
                      x,
                      y,
                      color=colors.light_grey,
                      img=r.shield,
                      equipment=equipment_com)

    #g.item_group.add(item)
    return item
Example #34
0
def gen_equ_sword(coords):

    x, y = coords

    bonus = randint(1, 5)

    equipment_com = Equipment(attack_bonus=bonus, slot='hand', slot2="hand2")

    item = GameObject(g.settings,
                      "Sword" + " +" + str(bonus),
                      x,
                      y,
                      color=colors.lighter_grey,
                      img=r.sword,
                      equipment=equipment_com)

    #g.item_group.add(item)
    return item
Example #35
0
def gen_equ_armor(coords):

    x, y = coords

    bonus = randint(1, 5)

    equipment_com = Equipment(defense_bonus=bonus, slot='body')

    item = GameObject(g.settings,
                      "Armor" + " +" + str(bonus),
                      x,
                      y,
                      color=colors.grey,
                      img=r.armor,
                      equipment=equipment_com)

    #g.item_group.add(item)
    return item
Example #36
0
def gen_equ_helmet(coords):

    x, y = coords

    bonus = randint(1, 5)

    equipment_com = Equipment(health_bonus=bonus, slot='head')

    item = GameObject(g.settings,
                      "Helmet" + " +" + str(bonus),
                      x,
                      y,
                      color=colors.light_grey,
                      img=r.helmet,
                      equipment=equipment_com)

    #g.item_group.add(item)
    return item
Example #37
0
def gen_equ_two_handed_sword(coords):

    x, y = coords

    bonus = randint(5, 10)

    equipment_com = Equipment(attack_bonus=bonus,
                              slot='hand',
                              slot_block="hand2")

    item = GameObject(g.settings,
                      "Two-Handed Sword" + " +" + str(bonus),
                      x,
                      y,
                      color=colors.light_grey,
                      img=r.two_handed_sword,
                      equipment=equipment_com)

    #g.item_group.add(item)
    return item
Example #38
0
def gen_monster_troll(coords):

    x, y = coords

    fighter_comp = Fighter(hp=16,
                           defense=1,
                           power=4,
                           death_function=gf.monster_death)

    ai_comp = BasicMonster()

    monster = GameObject(g.settings,
                         "Troll",
                         x,
                         y,
                         color=colors.darker_green,
                         blocks=True,
                         fighter=fighter_comp,
                         ai=ai_comp,
                         img=r.troll)

    return monster
Example #39
0
def gen_monster_zombie(coords):

    x, y = coords

    fighter_comp = Fighter(hp=10,
                           defense=0,
                           power=3,
                           death_function=gf.monster_death)

    ai_comp = BasicMonster()

    monster = GameObject(g.settings,
                         "Zombie",
                         x,
                         y,
                         color=colors.darker_violet,
                         blocks=True,
                         fighter=fighter_comp,
                         ai=ai_comp,
                         img=r.zombie)

    return monster
Example #40
0
def run_game():
    #Initialize game and create a screen object.
    pygame.init()
    settings = Settings()
    g.settings = Settings()

    g.settings_g = Settings()

    pygame.display.set_caption(settings.title)

    # Initialize Map
    grid = Grid(settings)
    g.tiles = Group()

    # Map Matrix initialisieren und Tiles hinzufügen
    tiles_init(settings, g.tiles)

    #Player
    fighter_comp = Fighter(hp=30,
                           defense=2,
                           power=5,
                           death_function=gf.player_death)
    g.player = GameObject(settings,
                          "player",
                          1,
                          1,
                          colors.gold,
                          img=r.player,
                          blocks=True,
                          fighter=fighter_comp)

    # Create Random Map
    make_map()

    # Initialize GUI and Inventory
    g.gui_elements = GUI(settings)
    g.inventory_menu = InventoryMenu(settings)

    #Print Welcome Message
    print_message("Welcome to the BEIDL", colors.black, colors.dark_red)

    #Initialize groups
    g.monster_group = Group()
    g.item_group = Group()
    g.dead_group = Group()
    g.inventory = Group()
    g.graphics_group = Group()
    """F**K AROUND"""
    #vvvvvvvvvvv#

    for i in range(10):
        testi_place_objects('item')

    for i in range(50):
        testi_place_objects('enemy')

    # """Test: Dummy Walls"""
    # g.map_matrix[4][5].blocked = True
    # g.map_matrix[4][5].block_sight = True
    # g.map_matrix[4][6].blocked = True
    # g.map_matrix[4][6].block_sight = True
    #
    # g.map_matrix[15][21].blocked = True
    # g.map_matrix[15][21].block_sight = True
    # g.map_matrix[16][21].blocked = True
    # g.map_matrix[16][21].block_sight = True

    #^^^^^^^^^#
    """F**K AROUND"""

    # Start the main loop for the game.
    while True:
        """MENU"""
        # Menu Screen
        #while settings.game_state == "menu":
        #gf.check_events_menu(settings, all_groups)
        #gf.update_screen_menu(settings, all_groups)
        """GAME"""
        #while g.game_state == "playing":
        while True:

            g.clock.tick(FPS)
            # ticks = pygame.time.get_ticks()

            gf.update_screen(settings)

            # Check game_state for Contol Setup
            # TODO game state control handling like this?
            if g.game_state == 'inventory':
                player_action = gf.controls_inventory(settings)
            else:
                player_action = gf.controls(settings, g.player)

            # Let Enemys take turns
            if g.game_state == 'playing' and player_action != "noturn":
                for obj in g.monster_group:
                    if obj.ai:
                        obj.ai.take_turn()

            # TODO Turn for using inventory item, redundant, use in game state?
            if player_action == "turn":
                for obj in g.monster_group:
                    if obj.ai:
                        obj.ai.take_turn()
Example #41
0
File: env.py Project: bitcraft/mh
 def __init__(self):
     GameObject.__init__(self)
Example #42
0
 def gen_game_objects(self):
     for obj_addr in self.gen_objects_addr():
         if self.pm.read_int(obj_addr + Offset.Object.type) == 5:
             yield GameObject(self, obj_addr)