示例#1
0
def move(game, x=0, y=0):
    if game.state == game.STATE_NORMAL:
        '''
        Move the player towards the target location.
        '''
        target_x = game.player.x + x
        target_y = game.player.y + y
        
        tile = game.map.get_tile(target_x, target_y)
        if tile is not None and tile.is_passable():
            game.execute_action(actions.action.ActionInstance(
                source = game.current_entity,
                action = actions.misc.Move(), 
                target = (target_x, target_y),
            ))
            game.end_turn(100)
    elif game.state == game.STATE_TARGET:
        '''
        Choose the given location as the target for the current targeting state.
        '''
        game.selection = (game.selection[0] + x, game.selection[1] + y, game.selection[2])
        game.do_update('cursor')
    elif game.state == game.STATE_EXPLORE:
        '''
        Move the user's view towards the given location.
        '''
        hotspot = game.focus
        if hotspot.is_game_layer():
            x = hotspot.mouse_x + x*(hotspot.width / game.map.width)
            y = hotspot.mouse_y + y*(hotspot.height / game.map.height)
            State.window().set_mouse_position(x, y)
            hotspot.on_hover(game, x, y)
            game.do_update('bounds')
示例#2
0
文件: game.py 项目: Ardnived/Regicide
 def update_shadows(self):
     model = State.model()
     
     for x in range(max(0, self.grid_x), min(self.grid_x + self.grid_width, model.map.width)):
         for y in range(max(0, self.grid_y), min(self.grid_y + self.grid_height, model.map.height)):
             tile = model.map.get_tile(x, y)
             if tile is not None: 
                 if tile.entity is None:
                     sprite = tile.ascii
                 else:
                     sprite = tile.entity.ascii
                 
                 player = State.model().player
                 
                 if not tile.explored:
                     sprite.color = [0, 0, 0]
                 elif model.map.has_line_of_sight(player.x, player.y, x, y):
                     if tile.is_opaque():
                         light_x = x
                         light_y = y
                         
                         distance_x = x - player.x
                         distance_y = y - player.y
                         
                         if distance_x == 0:
                             light_y = light_y - int(math.copysign(1, distance_y))
                         elif distance_y == 0:
                             light_x = light_x - int(math.copysign(1, distance_x))
                         else:
                             angle = math.radians(distance_y / distance_y)
                             delta_x = math.cos(angle)
                             delta_y = math.sin(angle)
                             
                             if delta_x >= delta_y:
                                 light_x -= int(math.copysign(1, distance_x))                                
                             if delta_x <= delta_y:
                                 light_y -= int(math.copysign(1, distance_y))
                         
                         light_source = model.map.get_tile(light_x, light_y)
                         if light_source is not None:
                             shadow = light_source.shadow
                         else:
                             shadow = 100
                     else:
                         shadow = tile.shadow
                     
                     if shadow > 0:
                             sprite.opacity = (255 - GameView.MIN_LIGHT) / (shadow + 1) + GameView.MIN_LIGHT
                     else:
                         sprite.opacity = 255
                 else:
                     sprite.opacity = 128
                     sprite.color = [128, 128, 128]
                 
                 if model.state == model.STATE_TARGET:
                     valid = model.is_valid_target(x, y)
                     if valid is None:
                         sprite.opacity *= 0.25
                     elif valid is False:
                         sprite.opacity *= 0.55
示例#3
0
def set_state(game, state):
    '''
    Change the program's current state.
    Specifically, this means switching to a different view,
    so that the player can view a menu, or return to the game view.
    '''
    State.set_current(state)
示例#4
0
 def on_click(self, model, button, modifiers):
     player = State.model().player
     index = self.selection_y
     functions.set_state(model, 'game')
     State.model().execute_action(action.ActionInstance(
         action = player.actions[index],
         source = model.player,
     ))
示例#5
0
文件: main.py 项目: Ardnived/Regicide
def init_states(window):
    game_model = model.game.Game()
    global_controller = controller.controller.Controller()
    
    print("Initializing Game States...")
    State('game',
        window     = window,
        model      = game_model,
        view       = view.game.GameView(window),
        controller = global_controller,
        commands   = controller.game.commands,
    )
    
    State('properties',
        window     = window,
        model      = game_model,
        view       = view.properties.PropertiesView(window),
        controller = global_controller,
        commands   = controller.properties.commands,
    )
    
    State('traits',
        window     = window,
        model      = game_model,
        view       = view.traits.TraitsView(window),
        controller = global_controller,
        commands   = controller.properties.commands,
    )
    
    State('actions',
        window     = window,
        model      = game_model,
        view       = view.actions.ActionsView(window),
        controller = global_controller,
        commands   = controller.properties.commands,
    )
    
    State('inventory',
        window     = window,
        model      = game_model,
        view       = view.inventory.InventoryView(window),
        controller = global_controller,
        commands   = controller.properties.commands,
    )
    
    State('world',
        window     = window,
        model      = game_model,
        view       = view.world.WorldView(window),
        controller = global_controller,
        commands   = controller.properties.commands,
    )
    
    State.set_current('game')
    game_model.next_turn()
示例#6
0
文件: tile.py 项目: Ardnived/Regicide
 def get_target_types(self):
     target_types = set(self.type)
     
     if self.entity is not None:
         target_types.add(Tile.TARGET_ENTITY)
         
         if State.model() is not None and self.entity == State.model().current_entity:
             target_types.add(Tile.TARGET_SELF)
     
     if self.items != []:
         target_types.add(Tile.TARGET_ITEM)
     
     return target_types
示例#7
0
    def update_list(self):
        ItemListLayer.update_list(self)
        
        player = State.model().player

        i = 0
        for item in player.inventory:
            if item not in player.equipment[item.equip_slot]:
                x = i / self.rows
                y = i - self.rows*x
                
                text = ""
                text += " " * (InventoryLayer.NAME_COLUMN - len(text))
                text += item.name
                text += " " * (InventoryLayer.TYPE_COLUMN - len(text))
                text += item.type
                text += " " * (InventoryLayer.SLOT_COLUMN - len(text))
                text += item.equip_slot.name
                text += " " * (InventoryLayer.SIZE_COLUMN - len(text))
                text += str(item.equip_size)
                text += " " * (InventoryLayer.WEIGHT_COLUMN - len(text))
                text += str(item.weight)
                
                self.items[x][y].text = text
                self.items[x][y].item = item
                
                if player.could_equip(item):
                    self.items[x][y].disabled = False
                    self.items[x][y].color = (255, 255, 255, 255)
                else:
                    self.items[x][y].disabled = True
                    self.items[x][y].color = (188, 143, 143, 255)
                
                i += 1
示例#8
0
 def update_list(self):
     ItemListLayer.update_list(self)
     
     player = State.model().player
     
     i = 0
     for equip_slot, items in player.equipment.iteritems():
         n = 0
         for item in items:
             x = i / self.rows
             y = i - self.columns*x
             
             text = ""
             text += " " * (EquipmentLayer.NAME_COLUMN - len(text))
             text += item.name
             text += " " * (EquipmentLayer.TYPE_COLUMN - len(text))
             text += item.type
             text += " " * (EquipmentLayer.SLOT_COLUMN - len(text))
             text += str(item.equip_slot.get_slot_description(n))
             text += " " * (EquipmentLayer.WEIGHT_COLUMN - len(text))
             text += str(item.weight)
             
             self.items[x][y].text = text
             self.items[x][y].item = item
             i += 1
             n += 1
示例#9
0
文件: game.py 项目: Ardnived/Regicide
 def update_shadows(self):
     print('update shadows')
     model = State.model()
     
     for x in range(self.grid_width):
         for y in range(self.grid_height):
             tile = model.map.get_tile(self.grid_x + x, self.grid_y + y)
             if tile is not None:
                 if True: #TODO: Change this check to be opacity vs. pixel shading. via some kind of options class.
                     sprite = self.shadows[x][y]
                     sprite.image = visual.Tile.get_shadow(7)
                     sprite.batch = self.shadow_layer
                 else:
                     if tile.shadow > 0:
                         sprite.opacity = (255 - GameView.MIN_LIGHT) / (tile.shadow + 1) + GameView.MIN_LIGHT
                     else:
                         sprite.opacity = 255
                     
                     if model.state == model.STATE_TARGET:
                         valid = model.is_valid_target(x, y)
                         if valid is None:
                             sprite.opacity *= 0.25
                         elif valid is False:
                             sprite.opacity *= 0.55
             elif True: #TODO: Change this check to be opacity vs. pixel shading. via some kind of options class.
                 self.shadows[x][y].batch = None
示例#10
0
 def update_description(self, tile):
     title = ""
     text = ""
     if tile.text != "":
         prop = tile.prop
         player = State.model().player
         modifiers = player.get_property_modifiers(prop)
         title = prop.name+" "+str(player.get(prop))
         
         modifier = str(player.get(prop, True))
         spacing = " "*(2 - len(modifier))
         text += "  "+spacing+modifier+"\n"
         
         if type(prop.base) == properties.Property:
             modifier = str(player.get(prop.base))
             spacing = " "*(2 - len(modifier))
             name = prop.base.name                
             text += " +"+spacing+modifier+", "+name+"\n"
         
         for modifier in modifiers:
             value = modifier[0]
             if value < 0:
                 sign = "-"
                 value = str(abs(value))
             else:
                 sign = "+"
                 value = str(value)
             
             spacing = " "*(2 - len(value))
             source = modifier[1]
             
             text += " "+sign+spacing+value+", "+source+"\n"
     
     self.title.text = title
     self.modifiers.text = text
示例#11
0
 def on_mouse_press(self, x, y, button, modifiers):
     '''
     An event intended to be triggered by the window object.
     Triggers every time the user moves the mouse.
     '''
     for hotspot in State.view().hotspots:
         if hotspot.contains(x, y):
             self.dispatch_event('on_hotspot_click', hotspot, button, modifiers)
示例#12
0
 def update_description(self, tile):
     ItemListLayer.update_description(self, tile)
     
     #TODO: the following isn't working atm
     if State.model().player.could_equip(tile.item) is False:
         text = self.description.text
         text += "You cannot equip this item, because your "+tile.item.equip_slot.name+" slot does not have "+str(tile.item.equip_size)+" space."
         self.description.text = text
示例#13
0
 def trigger_command(self, key, key_type):
     '''
     A key has been pressed. Check if it is mapped to a command, 
     and send the command activation event if so.
     '''
     command = State.commands().get_action(key, key_type)
     
     if command is not None:
         self.dispatch_event('activate_command', command)
示例#14
0
文件: game.py 项目: Ardnived/Regicide
 def on_click(self, model, button, modifiers):
     if button == mouse.LEFT:
         player = State.model().player
         index = self.rows - self.selection_y - 1
         model.execute_action(action.ActionInstance(
             action = player.actions[index],
             source = model.player,
         ))
     elif button == mouse.RIGHT:
         functions.set_state(model, 'actions')
示例#15
0
 def on_mouse_motion(self, x, y, dx, dy):
     '''
     An event intended to be triggered by the window object.
     Triggers every time the user moves the mouse.
     '''
     for hotspot in State.view().hotspots:
         if hotspot.contains(x, y):
             self.dispatch_event('on_mouse_hover', hotspot, x, y)
             return
     
     # If the mouse is not over any hotspot, send an event to clear the hotspots.
     self.dispatch_event('on_mouse_hover', None)
示例#16
0
文件: game.py 项目: Ardnived/Regicide
 def update(self, components = None):
     ActiveListLayer.update(self, components)
     if components is None or 'stance' in components:
         player = State.model().player
         
         for i in range(min(len(player.actions), self.rows)):
             action = player.actions[i]
             
             x = i / self.rows
             y = i
             self.items[x][y].text = action.name
             self.items[x][y].action = action
示例#17
0
    def set(self, prop, value):
        Entity.set(self, prop, value)
        model = State.model()

        max_hp = self.get(properties.max_hp)

        if value <= 3 and prop.type == properties.Property.TYPE_ATTR:
            model.log_message("LOW ATTRIBUTE WARNING: " + prop.name)
            model.do_update("log")
        elif prop == properties.hp and self.get(properties.hp) <= max_hp * 0.4:
            model.log_message("LOW HP WARNING: " + str(self.get(properties.hp)))
            model.do_update("log")
示例#18
0
文件: game.py 项目: Ardnived/Regicide
 def update(self, components = None):
     model = State.model()
     
     if components is None or 'log' in components:
         if model.info:
             for i in range(min(len(model.log), len(self.log))):
                 self.log[i].text = ""
                 
             self.info.text = Log.HTML_FONT + model.info + "</font>"
         else:
             for i in range(min(len(model.log), len(self.log))):
                 self.log[i].text = model.log[i+model.log_offset]
             
             self.info.text = ""
示例#19
0
 def update(self, components = None):
     world = State.model().game
     Layer.update(self, components)
     
     Hotspot.__init__(self, self.x, self.y, self.width, self.height, world.rows, world.columns)
     
     if components is None or 'cursor' in components:
         self.update_cursor();
     elif components == None:
         y = 0
         for depth in xrange(-world.depth, world.height):
             floor = World.FLOORS[depth]
             self.items[0][y].text = floor['name']
             self.items[0][y].depth = depth
             y += 1
示例#20
0
文件: game.py 项目: Ardnived/Regicide
 def update(self, components = None):
     if components is None or 'playercard' in components:
         player = State.model().player
         self.portrait.image = player.portrait
         self.name.text = player.name
         self.hp.text = "HP: "+str(player.get(properties.hp))+" / "+str(player.get(properties.max_hp))
         self.mana.text = "MN: "+str(player.get(properties.mana))+" / "+str(player.get(properties.max_mana))
         
         self.attributes.text = ''
         self.attributes.text += "Dexterity   "+str(player.get(properties.dexterity))+"\n"
         self.attributes.text += "Agility     "+str(player.get(properties.agility))+"\n"
         self.attributes.text += "Mobility    "+str(player.get(properties.mobility))+"\n"
         self.attributes.text += "Wits        "+str(player.get(properties.wits))+"\n"
         self.attributes.text += "Perception  "+str(player.get(properties.perception))
         
         '''
示例#21
0
文件: game.py 项目: Ardnived/Regicide
 def update(self, components = None):
     if components is None or 'effects' in components:
         player = State.model().player
         
         for i in range(min(len(player.effects), len(self.items))):
             effect = player.effects[i]
             index = self.line_quantity - i - 1
             
             name = effect.name
             spacing = " " * (12 - len(name))
             duration = effect.duration
             self.items[index].text = name + spacing + str(duration)
             self.items[index].effect = effect
     
     if components is None or 'cursor' in components:
         self.update_cursor();
示例#22
0
文件: game.py 项目: Ardnived/Regicide
 def update_tiles(self):
     if self.tile_layer is not None:
         self.batches.remove(self.tile_layer)
     
     self.tile_layer = graphics.Batch()
     self.batches.append(self.tile_layer)
     model = State.model()
     grid = model.map.grid
     
     for x in range(max(0, self.grid_x), min(self.grid_x + self.grid_width, len(grid))):
         for y in range(max(0, self.grid_y), min(self.grid_y + self.grid_height, len(grid[x]))):
             tile = grid[x][y]
             if tile is not None:
                 sprite = tile.sprite
                 sprite.batch = self.tile_layer
                 sprite.x = x*self.tile_width - self.grid_x*self.tile_width + self.x
                 sprite.y = y*self.tile_height - self.grid_y*self.tile_width + self.y
示例#23
0
 def update(self, components = None):
     ActiveListLayer.update(self, components)
     
     player = State.model().player
     
     slots = self.rows * self.columns
     i = 0
     for trait in player.traits:
         if (i < slots):
             x = i / self.rows
             y = i - self.columns*x
             
             self.items[x][y].text = trait.name
             self.items[x][y].trait = trait
             i += 1
         else:
             break;
示例#24
0
 def update(self, components = None):
     ActiveListLayer.update(self, components)
     
     player = State.model().player
     
     slots = self.rows * self.columns
     i = 0
     for action in player.actions:
         if i < slots:
             x = i / self.rows
             y = i - self.columns*x
             
             self.items[x][y].text = action.name
             self.items[x][y].action = action
             i += 1
         else:
             break;
示例#25
0
文件: game.py 项目: Ardnived/Regicide
 def update(self, components = None):
     ActiveListLayer.update(self, components)
     if components is None or 'inventory' in components:
         player = State.model().player
         
         for i in range(min(len(player.inventory), self.rows)):
             x = i / self.rows
             y = i
             item = player.inventory[i]
             
             text = ""
             if item in player.equipment[item.equip_slot]:
                 text += "e "
             else:
                 text += "  "
             
             text += item.name
             self.items[x][y].text = text
             self.items[x][y].item = item
示例#26
0
 def update(self, components = None):
     ActiveListLayer.update(self, components)
     
     player = State.model().player
     
     slots = self.rows * self.columns
     i = 0
     for prop in properties.Property.all:
         if i < slots:
             x = i / self.rows
             y = i - self.rows*x
             
             name = prop.name
             value = str(player.get(prop))
             spacing = " "*(19 - len(prop.name) + 3 - len(value))
             
             self.items[x][y].text = name + spacing + value
             self.items[x][y].prop = prop
             i += 1
         else:
             break;
示例#27
0
文件: game.py 项目: Ardnived/Regicide
 def update_cursor(self):
     model = State.model()
     
     if self.has_focus:
         self.update_game_bounds()
         
         if model.state == model.STATE_EXPLORE:
             x = self.columns / 2
             y = self.rows / 2
         else:
             x = self.selection_x
             y = self.selection_y
             
         absolute_x = self.grid_x + x
         absolute_y = self.grid_y + y - 1
         
         valid = model.is_valid_target(absolute_x, absolute_y)
         if valid is None:
             self.cursor.image = visual.Cursor.get(visual.Cursor.TARGET)
         elif valid:
             self.cursor.image = visual.Cursor.get(visual.Cursor.YELLOW)
         else:
             self.cursor.image = visual.Cursor.get(visual.Cursor.SELECT)
         
         if valid is not None and (absolute_x != model.player.x or absolute_y != model.player.y):
             path = model.map.find_path(model.map.ALGORITHM_ASTAR, model.player.x, model.player.y, absolute_x, absolute_y)
             
             if path is not None:
                 for path_x, path_y in path:
                     self.highlight_tile(path_x, path_y)
             
                 self.highlight_tile(model.player.x, model.player.y)
                 self.highlight_tile(absolute_x, absolute_y)
         
         self.cursor.x = x * self.tile_width + self.x
         self.cursor.y = (self.rows - y - 1) * self.tile_height + self.y
         self.show_cursor = True
     else:
         self.show_cursor = False
示例#28
0
文件: game.py 项目: Ardnived/Regicide
 def update_grid(self):
     self.batches = graphics.Batch()
     model = State.model()
     
     for x in range(max(0, self.grid_x), min(self.grid_x + self.grid_width, model.map.width)):
         for y in range(max(0, self.grid_y), min(self.grid_y + self.grid_height, model.map.height)):
             tile = model.map.get_tile(x, y)
             if tile is not None:
                 if tile.entity is None:
                     sprite = tile.ascii
                     
                     if tile.is_opaque():
                         sprite.color = [255, 100, 100]
                     else:
                         sprite.color = [255, 255, 255]
                 else:
                     sprite = tile.entity.ascii
                     sprite.color = [100, 100, 255]
                 
                 sprite.batch = self.batches
                 sprite.x = self.x + (x*self.tile_width - self.grid_x*self.tile_width)
                 sprite.y = self.y + (y*self.tile_height - self.grid_y*self.tile_height)
示例#29
0
 def draw(self):
     Layer.draw(self)
     game = State.model()
     world = game.world
     
     cell_width = self.width / world.columns
     cell_height = self.height / world.rows
     
     depth = 0
     
     x = self.x
     for col in xrange(world.columns):
         y = self.y
         for row in xrange(world.rows):
             floor = world.get_floor(col, row, depth)
             
             color = (1.0, 1.0, 1.0)
             
             if game.current_floor_coords == (col, row, depth):
                 color = (0.7, 0.7, 1.0)
             
             if floor is None:
                 opacity = 0
             elif floor.known:
                 opacity = 0.5
             elif floor.explored:
                 opacity = 1.0
             else:
                 opacity = 0
             
             if opacity > 0:
                 self.set_color(*color, opacity=opacity)
                 
                 gl.glRectf(x, y, x + cell_width, y + cell_height)
             
             y += cell_height
         x += cell_width
示例#30
0
def init_states(window):
    game_model = model.game.Game()
    global_controller = controller.controller.Controller()

    print("Initializing Game States...")
    State(
        'game',
        window=window,
        model=game_model,
        view=view.game.GameView(window),
        controller=global_controller,
        commands=controller.game.commands,
    )

    State(
        'properties',
        window=window,
        model=game_model,
        view=view.properties.PropertiesView(window),
        controller=global_controller,
        commands=controller.properties.commands,
    )

    State(
        'traits',
        window=window,
        model=game_model,
        view=view.traits.TraitsView(window),
        controller=global_controller,
        commands=controller.properties.commands,
    )

    State(
        'actions',
        window=window,
        model=game_model,
        view=view.actions.ActionsView(window),
        controller=global_controller,
        commands=controller.properties.commands,
    )

    State(
        'inventory',
        window=window,
        model=game_model,
        view=view.inventory.InventoryView(window),
        controller=global_controller,
        commands=controller.properties.commands,
    )

    State(
        'world',
        window=window,
        model=game_model,
        view=view.world.WorldView(window),
        controller=global_controller,
        commands=controller.properties.commands,
    )

    State.set_current('game')
    game_model.next_turn()
示例#31
0
文件: game.py 项目: Ardnived/Regicide
 def on_click(self, model, button, modifiers):
     action = State.commands().get(CommandBar.ACTIONS[self.selection_x]).action
     if action is not None:
         action(model)