Пример #1
0
 def __init__(self):
   super(MapUI, self).__init__()
   self.config_manager = self.get_main().config_manager
   self.get_main().fonts.register_font("debug")
   self.debug_font = self.get_main().fonts["debug"]
   self.map = DungeonMap(self.config_manager)
   self.draw_rects = False
   self.draw_debug = self.config_manager.config_data["subscription_config"]["draw_debug"]
   self.speedup = self.config_manager.config_data["video_config"]["speedup"]
   self.demo_mode = self.config_manager.config_data["video_config"]["demo_mode"]
   self.scrolling = []
   self.shaking = 0
   self.init_scrolling = False
   self.event_manager = self.get_main().event_manager
   self.event_manager.add_subscription_event(self, KeyboardHandler)
   self.event_manager.subscriber = self.subscription_id
   self.entity_manager = self.get_main().entity_manager
   self.entity_list = self.entity_manager.entities
   self.backdrop_ui = self.entity_list["animated.backdrop"]()
   self.backdrop_ui.spawn()
   self.player = self.entity_list["animated.moveable.living.player"](self)
   self.player.spawn()
   self.event_funcs = {
     "move_up":     [self.move, (0,-1)],
     "move_down":   [self.move, (0,1)],
     "move_left":   [self.move, (-1,0)],
     "move_right":  [self.move, (1,0)],
     "use_sword":   [self.player.use_sword],
     "place_bomb":  [self.player.place_bomb],
     "open_doors":  [self.open_doors, True],
     "shake":       [lambda:setattr(self, "shaking", 1)],
     "toggle_rects":[self.toggle_draw_rects],
     "show_databin":[self.print_databin],
     "export_dungeon":[self.export_dungeon]
   }
   for k,v in self.entity_manager.get_persistant_entities().iteritems():
     if k not in ["animated.backdrop", "animated.moveable.living.player", "animated.hud", "animated.hud.map"]:
       v().spawn()
   self.clock = Clock()
   self.load_dungeon()
Пример #2
0
class MapUI(UI):
  def __init__(self):
    super(MapUI, self).__init__()
    self.config_manager = self.get_main().config_manager
    self.get_main().fonts.register_font("debug")
    self.debug_font = self.get_main().fonts["debug"]
    self.map = DungeonMap(self.config_manager)
    self.draw_rects = False
    self.draw_debug = self.config_manager.config_data["subscription_config"]["draw_debug"]
    self.speedup = self.config_manager.config_data["video_config"]["speedup"]
    self.demo_mode = self.config_manager.config_data["video_config"]["demo_mode"]
    self.scrolling = []
    self.shaking = 0
    self.init_scrolling = False
    self.event_manager = self.get_main().event_manager
    self.event_manager.add_subscription_event(self, KeyboardHandler)
    self.event_manager.subscriber = self.subscription_id
    self.entity_manager = self.get_main().entity_manager
    self.entity_list = self.entity_manager.entities
    self.backdrop_ui = self.entity_list["animated.backdrop"]()
    self.backdrop_ui.spawn()
    self.player = self.entity_list["animated.moveable.living.player"](self)
    self.player.spawn()
    self.event_funcs = {
      "move_up":     [self.move, (0,-1)],
      "move_down":   [self.move, (0,1)],
      "move_left":   [self.move, (-1,0)],
      "move_right":  [self.move, (1,0)],
      "use_sword":   [self.player.use_sword],
      "place_bomb":  [self.player.place_bomb],
      "open_doors":  [self.open_doors, True],
      "shake":       [lambda:setattr(self, "shaking", 1)],
      "toggle_rects":[self.toggle_draw_rects],
      "show_databin":[self.print_databin],
      "export_dungeon":[self.export_dungeon]
    }
    for k,v in self.entity_manager.get_persistant_entities().iteritems():
      if k not in ["animated.backdrop", "animated.moveable.living.player", "animated.hud", "animated.hud.map"]:
        v().spawn()
    self.clock = Clock()
    self.load_dungeon()
    
  def load_dungeon(self):
    try:
      map_entity = self.get_main().databin.entity_data.map.sprites()[0]
    except TypeError:pass
    else:
      map_entity.despawn()
    self.map.load_dungeon()
    self.backdrop_ui.load_new_backdrop()
    self.clean_entities()
    self.entity_list["animated.hud.map"](self).spawn()
    self._load_room(self.map.start_node)
    self.player.x, self.player.y = self.screen.get_center()
    if self.demo_mode:
      self.remove_hud()
      
  def export_dungeon(self):
    print "Exporting entire dungeon..."
    map_size = self.map.nodes.map.map_size
    for y in range(map_size[0]+1):
      for x in range(map_size[1]+1):
        room = self.map.map[y][x]
        if room:
          print room
          self.clean_entities()
          self._load_room(room)
          self.init_scrolling = True
          self.bg_image = self.get_pygame().surface.Surface(self.screen.size)
          self.draw()
          self.init_scrolling = False
        else:
          self.bg_image = self.get_pygame().surface.Surface(self.screen.size)
          self.bg_image.fill((0,0,0))
          
        screenshot_path = self.config_manager["path_config", "screenshot_path"]
        alphabet = "abcdefghijklmnopqrstuvwxyz"
        path = self.config_manager.get_path(screenshot_path, "dungeon_%s_%s.png" %(alphabet[map_size[1]-x],alphabet[y]))
        self.get_pygame().image.save(self.bg_image, path)
    print "montage -mode concatenate -tile %ix%i screenshots/dungeon_*.png dungeon.png"%(map_size[0]+1, map_size[1]+1)
      
  def remove_hud(self):
    for entity in self.get_main().databin.entity_data.hud:
      entity.despawn()
    self.player.despawn()
    
  def load_room(self, current_room, room_id, no_scroll = False):
    try:
      no_sword = len(self.get_main().databin.entity_data.sword.sprites()) == 0
    except TypeError:
      no_sword = True
    if not no_sword:
      self.get_main().databin.entity_data.sword.sprites()[0].despawn()
    if not no_scroll:
      self.init_scrolling = True
      self.bg_image = self.get_pygame().surface.Surface(self.screen.size)
      self.draw()
      self.init_scrolling = False
      self.scrolling = (((0,1),(1,0),(0,-1),(-1,0)))[room_id]
    axis = 1-room_id%2
    setattr(self.player, "xy"[axis], self.screen.get_size()[axis]*(1-(room_id>>1))+52*cmp(room_id>>1, 0.5))
    self.clean_entities()
    self.player.invincible = True
    self._load_room(current_room)
  
  def _load_room(self, current_room, no_doors = False, replaced = False):
    self.current_room = current_room
    random.seed(self.current_room.seed)
    self.backdrop_ui.load_current_room()
    if not no_doors:
      self.add_doors()
    self.current_room.visited(replaced)
    self.load_entities()
    if not self.demo_mode:
      self.get_main().databin.entity_data.map.sprites()[0].update_room()
    self.clock.tick()

  def add_doors(self):
    if not self.current_room.been_visited:
      coords = self.map.get_coords(self.current_room)
      for pos_id, d_coord in enumerate(((0,1),(-1,0),(0,-1),(1,0))):
        room = self.map.get_room(map(int.__add__, coords, d_coord))
        if room and room in self.current_room.connections:
          door = self.entity_list["animated.door"](pos_id, room, self.current_room)
          self.current_room.entity_list.append(door)

  def clean_entities(self):
    for entity in self.get_entities():
      if not entity.persistant:
          entity.despawn(killed = False)
  
  def load_entities(self):
    for entity in self.current_room.entity_list:
      entity.spawn()
  
  def room_cleared(self):
    try:
      new_room_list = self.current_room.replace_on_room_clear
    except AttributeError:
      new_room_list = []
    if new_room_list:
      entities = self.get_entities().sprites()[:]
      new_room_name = random.choice(new_room_list)
      self.clean_entities()
      new_room = self.map.replace_node(self.current_room, new_room_name, entities)
      self._load_room(new_room, no_doors = True, replaced = True)
      return
    
    auto_cleared = True
    for entity in self.current_room.entity_list:
      if entity.must_kill:
        auto_cleared = False
    if auto_cleared:
      for door in self.get_main().databin.entity_data.door:
        if not door.locked:
          door.open = True
          door.current_anim = "Opened"
    else:
      self.open_doors()
  
  def call_key_event(self, event_name):
    for event in event_name:
      assert(event in self.event_funcs)
      self.event_funcs[event][0](*self.event_funcs[event][1:])
    
  def move(self, delta_offset):
    self.player.control(delta_offset)
    
  def open_doors(self, all_ = False):
    for door in self.get_main().databin.entity_data.door:
      if (not door.locked) or all_:
        door.locked = False
        door.open = True
        if not all_:
          door.current_anim = "Open"
        
  def toggle_draw_rects(self):
    self.draw_rects = not self.draw_rects

  def calc_scroll(self, in_x_mod, in_y_mod):
    x_mod = self.scrolling[0]
    y_mod = self.scrolling[1]
    sign = map(lambda i: cmp(i, 0), self.scrolling)
    self.scrolling = [i+sign[j]*(200*self.d_time) for j, i in enumerate(self.scrolling)]
    self.screen.blit(self.bg_image, (in_x_mod+x_mod,in_y_mod+y_mod))
    x_mod -= cmp(x_mod, 0)*self.screen.get_size()[0]
    y_mod -= cmp(y_mod, 0)*self.screen.get_size()[1]
    if [cmp(x_mod, 0), cmp(y_mod, 0)] == sign:
      self.scrolling = []
    return in_x_mod+x_mod, in_y_mod+y_mod
      
  def draw(self):
    x_mod = 0
    y_mod = 0
    if self.shaking > 0:
      rs = math.ceil(self.shaking)
      x_mod += random.randrange(-rs,rs)
      y_mod += random.randrange(-rs,rs)
      self.shaking -= self.d_time
      if self.shaking < 0: self.shaking = 0
    if self.scrolling:
      x_mod, y_mod = self.calc_scroll(x_mod, y_mod)
    for entity in self.get_entities():
      if (entity not in self.get_main().databin.entity_data.hud) and entity is not self.player:
        if self.draw_rects and entity is not self.backdrop_ui: self.draw_rect(entity.rect)
        else:entity.blit(x_mod,y_mod)
    if not (self.scrolling or self.init_scrolling):
        if self.draw_rects and entity is not self.backdrop_ui: self.draw_rect(self.player.rect)
        else:self.player.blit(x_mod,y_mod)
    if not self.init_scrolling:
      for entity in self.get_main().databin.entity_data.hud:
        entity.blit()
    if self.draw_debug:
      self.draw_debug_text()
      
  def draw_debug_text(self):
    cur_room = self.debug_font.render("Current room: %s"%self.current_room, True, (255,255,255))
    self.screen.blit(cur_room, (10,50))
    cur_room = self.debug_font.render("Difficulty: %s"%self.current_room.difficulty, True, (255,255,255))
    self.screen.blit(cur_room, (10,70))
    #cur_room = self.debug_font.render("Keys: %d"%self.player.keys, True, (255,255,255))
    #self.screen.blit(cur_room, (10,70))
    
  def print_databin(self, databin = None, no_tabs = 0):
    if databin is None: databin = self.get_main().databin
    for k,v in databin.__dict__.iteritems():
      if isinstance(v, databin.__class__):
        print "%s%s: {"%(" "*no_tabs,k)
        self.print_databin(v, no_tabs+2)
        print "%s}"%(" "*no_tabs)
      elif isinstance(v, self.get_pygame().sprite.LayeredUpdates):
        print "%s%s: %s"%(" "*no_tabs, k,v.sprites())
      else:
        print "%s%s: %s"%(" "*no_tabs, k,v)
    
  def run(self):
    self.d_time = self.clock.tick()
    self.d_time *= self.speedup
    if self.scrolling: return
    room_cleared = True
    for entity in self.get_entities():
      if entity.must_kill:
        room_cleared = False
      if entity.spawned:
        try:
          entity.run(self.d_time)
        except:
          print "Exception raised in %r whilst running"%entity
          raise
    if room_cleared and not self.current_room.cleared and not self.scrolling:
      self.current_room.cleared = True
      self.room_cleared()
    
    #print d_time
  
  def get_blit(self, dirty):
    if self.init_scrolling: return self.blit_bg_im
    if dirty:
      return self.screen.blit
    return self.screen.blit_func
  
  def draw_rect(self, o_rect):
    rect = o_rect.copy()
    rect.x*=2
    rect.y*=2
    rect.height*=2
    rect.width*=2
    self.screen.fill((0,0,0), rect)
    self.screen.blit_rects.append(rect)
  
  def blit_bg_im(self, surf, pos):
    self.bg_image.blit(surf, (pos[0]*2, pos[1]*2))
  
  def get_entities(self):
    return self.get_main().databin.entity_data.entity