Python World.tick方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
def main():
    pygame.init()
    pygame.font.init()
    screen = pygame.display.set_mode((800, 450))
    
    background = pygame.Surface(screen.get_size())
    background = background.convert()
    background.fill((180, 180, 180))
    f = pygame.font.Font(pygame.font.get_default_font(), 20)

    p1 = Player(DARKBLUE, (800, 125))
    p2 = LevelPlayer(DARKRED, (0, 125))
    w = World(p1, p2)
    p2.world = w
    
    clock = pygame.time.Clock()

    contin = True
    while contin or True:
        for event in pygame.event.get():
            if event.type == pygame.constants.QUIT: sys.exit(0)
            elif event.type == pygame.constants.MOUSEBUTTONUP:
                if event.button == 1: w.leftClick(event.pos)
                elif event.button == 3: w.rightClick(event.pos)
                else: print event

        w.tick()
            
        screen.blit(background, (0, 0))
        contin = w.blit(screen, f)
        text = f.render("Frame rate: %.2f"%clock.get_fps(), True, BLACK)
        screen.blit(text, (400-text.get_width()/2, 4))
        pygame.display.flip()
        
        clock.tick(20)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
class Game(object):
    def __init__(self):
        self._ge = GameEngine()
        self._ds = DamageSystem(self._ge)
        self._world = None

    def setup_world(self):
        self._world = World(self._ge)

        player = Character(self._ge, "Player1")
        self._world.add_actor(player)

        hit_event = Event(self._ge, "HitPlayerEvent", 2000, self.event_hit_character, player)
        self._world.add_event(hit_event)

        poison_hit_event = Event(
            self._ge, "HitPlayerWithPoisonEvent", 4000, self.event_hit_character_with_poison, player
        )
        self._world.add_event(poison_hit_event)

    def start(self):
        self.setup_world()

        while True:
            self.game_loop()

    def game_loop(self):
        self._world.tick()

    def event_hit_character(self, character):
        damage = DamageOnHit(50, DamageType.normal)
        self._ds.apply_damage(character, damage)

    def event_hit_character_with_poison(self, character):
        damage = DamageOverTime(self._ge, self._ds, 50, DamageType.poison, duration=10000, interval=500)
        character.add_damage_over_time(damage)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
class Game(Enableable, Completable, Inputable):
    def __init__(self, levels):
        super().__init__()

        # --- Inits
        os.environ["SDL_VIDEO_CENTERED"] = "1"
        pygame.mixer.pre_init(44100, 16, 2, 4096)
        pygame.init()
        pygame.font.init()

        pygame.display.set_caption(const.gameName)
        self._surface = pygame.display.set_mode((const.screenSize[0] * const.res,
                                                 const.screenSize[1] * const.res))
        self._clock = pygame.time.Clock()
        self._levAttr = levels
        self._world = None
        self._paused = False

        self._menu = Menu(surface=self._surface,
                          pos=(const.screenSize[0] * const.res / 2 - 50,
                               const.screenSize[1] * const.res / 2 - 100),
                          inputStream=self.getInputStream())
        self._menu.addItem("resume", (0, 0, 100, 48), MColor((255, 0, 0), (0, 0, 255)),
                           MText("Resume", (0, 255, 0)), MAction(self._resume))
        self._menu.addItem("start", (0, 50, 100, 48), MColor((255, 0, 0), (0, 0, 255)),
                           MText("Start", (0, 255, 0)), MAction(self.start))
        self._menu.addItem("editor", (0, 100, 100, 48), MColor((255, 0, 0), (0, 0, 255)),
                           MText("Editor", (0, 255, 0)), MAction(self._editor))
        self._menu.addItem("exit", (0, 150, 100, 48), MColor((255, 0, 0), (0, 0, 255)),
                           MText("Exit", (0, 255, 0)), MAction(self.setFinished))

        self._input = Input(inputStream=self.getInputStream())
        self._input.set(pygame.KEYDOWN, self._menuToggle, pygame.K_m)
        self._input.set(pygame.KEYDOWN, self._pause, pygame.K_p)

    def start(self):
        self.enable()
        self._world = World(self._surface, self._levAttr, inputStream=self.getInputStream())
        self._world.nextLevel()
        self._menu.disable()

    def _pause(self):
        self._paused = not self._paused

    def _resume(self):
        if self._world is not None and not self._world.isComplete():
            self.enable()
        else:
            self.start()
        self._menu.disable()

    def _editor(self):
        if self._world:
            self._world.level.editor.enabled()
            self._menu.disable()

    def _menuToggle(self):
        self._menu.toggleEnabled()
        self.toggleEnabled()

    def tick(self):
        self.getEvents()
        self._input()

        if self._menu.enabled():
            self._menu.tick()
            self._menu.draw()
        elif self.enabled:
            if self._world.isComplete():
                if self._world.isFinished():
                    self._win()
                elif self._world.isLost():
                    self._gameOver()
            else:
                if not self._paused:
                    self._world.tick()
        self.clearInputStream()

        self._clock.tick(const.FPS)
        pygame.display.flip()

    def _win(self):
        self._endGame("YOU WIN!")

    def _gameOver(self):
        self._endGame("GAME OVER!")

    def _endGame(self, text):
        try:
            self.__gameOverCount += 1
        except AttributeError:
            self.__gameOverCount = 1
            self.__goText = pygame.font.Font(None, 100).render(text, 1, (255, 0, 0))
            self.__gameOverX = int(self._surface.get_width() / 2 - self.__goText.get_width() / 2)
            self.__gameOverY = int(self._surface.get_height() / 2 - self.__goText.get_height() / 2)

        if self.__gameOverCount < (const.FPS * 5):
            self._surface.fill((0, 0, 0))
            self._surface.blit(self.__goText, (self.__gameOverX, self.__gameOverY))
        else:
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
    def play():
        keys = defaultdict(lambda: False)
        clock = pygame.time.Clock()
        paused = False

        world = World((50, 50), default=Tile.GRASS)
        px, py = world.random_position()
        player = Player((px, py), loadimage("player.png"))
        world.add_entity(player)
        MOVE_SPEED = 3
        for i in range(1):
            world.spawn_clock()
        for i in range(3):
            world.spawn_fastenemy()
        for i in range(5):
            world.spawn_slowenemy()

        ticks = 0
        started = False

        while True:
            for ev in pygame.event.get():
                if ev.type == QUIT:
                    pygame.quit()
                    sys.exit(0)
                elif ev.type == KEYDOWN:
                    keys[ev.key] = True
                    if ev.key == K_SPACE:
                        if not started:
                            started = True
                        else:
                            paused = not paused
                    if ev.key in [K_UP, K_LEFT, K_DOWN, K_RIGHT]:
                        slash.play()
                    if ev.key == K_e and player.bombs > 0:
                        world.bomb((player.x, player.y))
                        player.bombs -= 1
                elif ev.type == KEYUP:
                    keys[ev.key] = False

            if keys[K_ESCAPE]:
                pygame.quit()
                sys.exit(0)

            if started and not paused:
                if keys[K_w]:
                    player.move((player.x           , player.y-MOVE_SPEED))
                if keys[K_s]:
                    player.move((player.x           , player.y+MOVE_SPEED))
                if keys[K_a]:
                    player.move((player.x-MOVE_SPEED, player.y           ))
                if keys[K_d]:
                    player.move((player.x+MOVE_SPEED, player.y           ))

                if keys[K_UP]:
                    player.attack("UP")
                elif keys[K_LEFT]:
                    player.attack("LEFT")
                elif keys[K_DOWN]:
                    player.attack("DOWN")
                elif keys[K_RIGHT]:
                    player.attack("RIGHT")

                world.tick()

            if player.health <= 0 or world.timer <= 0:
                return player.score, ticks

            px, py = player.x, player.y
            xo = SWIDTH/2 - player.x
            yo = SHEIGHT/2 - player.y

            #screen.fill(BLACK)
            screen.blit(bg, (0, 0))

            # Draw world
            world.render(screen, (xo, yo), (TWIDTH, THEIGHT))

            # Draw HUD
            for e in world.entities:
                if isinstance(e, Clock):
                    ex = e.x + xo
                    ey = e.y + yo
                    if (ex < 0 or ex > SWIDTH or
                        ey < 0 or ey > SHEIGHT):
                        ang = math.atan2(ey - SHEIGHT/2, ex - SWIDTH/2)
                        icon = pygame.transform.rotate(arrow, -ang*180/math.pi)
                        w = icon.get_width()/2
                        h = icon.get_height()/2
                        dx = math.cos(ang) * 50 - h
                        dy = math.sin(ang) * 50 - w
                        screen.blit(icon, (SWIDTH/2 + dx, SHEIGHT/2 + dy))

            msg = regfont.render("{} fps".format(int(clock.get_fps())), 1,
                                 WHITE, BLACK)
            blitfont(screen, msg, (0, 0))
            msg = regfont.render("{:.1f} seconds".format(world.timer / 60.0), 1,
                                 WHITE, BLACK)
            blitfont(screen, msg, (SWIDTH-1, 0), align="RIGHT")
            msg = regfont.render("Bombs: {}".format(player.bombs), 1,
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
class Game(object):
    def __init__(self):
        # Initialize
        pygame.init()
        Keyboard.init()
        Sound.init()
        Sound.cycleMusic()
        pygame.display.set_icon(pygame.image.load('LD34-small.bmp'))

        # Center window
        info = pygame.display.Info()
        cx = info.current_w // 2 - Constants.WIDTH // 2
        cy = info.current_h // 2 - Constants.HEIGHT // 2
        os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (cx, cy)

        # Create window and buffer
        self.screen = pygame.display.set_mode((Constants.WIDTH, Constants.HEIGHT))
        self.buffer = pygame.surface.Surface((Constants.WIDTH, Constants.HEIGHT), pygame.SRCALPHA)
        pygame.display.set_caption(Constants.TITLE)

        # Create variables objects. These will be populated in reset
        self.player = None
        self.world = None
        self.messages = []

        # Initialize font map
        self.fontmap = {"hud": pygame.font.Font("saxmono.ttf", 14),
                        "title": pygame.font.Font("saxmono.ttf", 48),
                        "option": pygame.font.Font("saxmono.ttf", 28),
                        "score": pygame.font.Font("saxmono.ttf", 28),
                        "msgtitle": pygame.font.Font("saxmono.ttf", 26),
                        "msgbody": pygame.font.Font("saxmono.ttf", 22)}

        # Initialize main menu
        screens.MainMenu.register_option("Play", Constants.GAME_SCREEN)
        screens.MainMenu.register_option("Info", screens.Info)
        screens.MainMenu.register_option("Settings", screens.SettingsScreen)
        screens.MainMenu.register_option("Credits", screens.Credits)
        screens.MainMenu.register_option("Exit", Constants.EXIT_SCREEN)

        # Game Loop
        self.gamescreen = screens.MainMenu()
        self.clock = pygame.time.Clock()
        self.running = True
        while self.running:
            delta = self.clock.tick(Constants.FPS)
            map(self.event, pygame.event.get())
            self.tick(delta)

    def event(self, e):
        if e.type == pygame.QUIT:
            self.running = False
        elif e.type == SONG_END:
            Sound.cycleMusic()

    def reset(self):
        # Create the player
        self.player = Player()

        # Create the world
        self.world = World()

        # Empty messages
        self.messages = []

    def tick(self, delta):
        # Poll input
        Mouse.update()
        Keyboard.update()

        # Clear the buffer
        self.buffer.fill(pygame.Color(0, 0, 0, 255))

        # Tick the correct game screen
        if self.gamescreen == Constants.GAME_SCREEN:
            # Tick the world
            self.world.tick(self.buffer, delta if (self.player.ready and self.player.health > 0) else 0)

            # Tick the objects
            msgs = self.player.tick(self.buffer, delta, self.world.platforms)
            if len(msgs) > 0:
                map(self.messages.append, msgs)

            # Draw messages
            self.messages = [msg for msg in self.messages if msg.alive]
            for msg in self.messages:
                msg.tick(self.buffer, delta, self.fontmap,
                         {"msgtitle": pygame.color.Color("#FFFFFF"),
                          "msggood": pygame.color.Color("#00FF00"),
                          "msgneutral": pygame.color.Color("#FFFF00"),
                          "msgbad": pygame.color.Color("#FF0000")})

            # If the player is fallen in, close the "hatch" and show distance
            if self.player.rect.top >= 50:
                pygame.draw.rect(self.buffer, pygame.color.Color("#111111"), (0, 0, Constants.WIDTH, 50))

                # Draw distance
                txt = "%0.1fkm" % (self.world.fallen / 1000)
                dist = self.fontmap["score"].render(txt, True, pygame.color.Color("#FFFFFF"))
                (w, h) = self.fontmap["score"].size(txt)
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
'''
num_runs = 3 # Number of runs per combination
agent_count = 100
task_speeds = [1, 2, 4, 8, 16]
for run in range(num_runs):
  for task_speed in task_speeds:
      config = {"initial_configuration": "Random1",
                "agent_count": agent_count,
                "max_clock": agent_count * 2,
                "collection_intervals": agent_count/50,
                "task_speed": task_speed
                }
      print "New Run:", task_speed
      w = World(config)
      w.init_schedules()
      while w.tick() is not None:
          if w.clock % 10 == 0: print w.clock
      w.data_collector.export()
print "Done!"

'''
End Pass 3
----------
'''



'''
Pass 3 - Evening May 07
----------------------------

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import tick [as 别名]
class ModelSocket(tornado.websocket.WebSocketHandler):
    def open(self):
        '''
        Called when the browser connects and opens a new websocket.
        '''
        print "Socket open!"
        #self.launch_model(model_config)


    def launch_model(self, config):
        '''
        Launch the model with the given config dictionary.
        '''
        self.last_network = None
        self.model = World(config)
        self.model.init_schedules()
        self.initialize_visualization()
        self.run_model()
    
    def run_model(self):
        '''
        Run the model until reaching a data collection point.
        '''
        if self.model.clock > self.model.max_clock:
            return None

        while True:
            self.model.tick()
            if self.model.clock % 2 == 0 and self.model.clock > 0:
                break
        #print self.model.clock
        self.send_update()

    def on_message(self, message):
        '''
        When the browser sends a Ready message
        '''
        #print message
        if message == "Ready!":
            self.run_model()
        else:
            params = json.loads(message)
            config = {"initial_configuration": "None",
                        "agent_count": params['agent_count'],
                        "max_clock": params['agent_count'] * 2,
                        "collection_intervals": 4,
                        "task_speed": params['task_speed']}
            self.launch_model(config)

    def initialize_visualization(self):
        '''
        Send the nodes only.
        '''
        data = json_graph.node_link_data(self.model.network)
        data['clock'] = 0
        self.write_message(data)


    def send_update(self):
        '''
        Send the updates to the task network to the browser.
        '''
        full_data = self.model.data_collector.data[self.model.clock]
        

        if "task_network" not in full_data:
            return None

        task_network = full_data["task_network"]
        if self.last_network is not None:
            out_graph = compare_graphs(self.last_network, task_network)
        else:
            out_graph = task_network
        self.last_network = task_network

        #data = json_graph.node_link_data(task_network)
        data = json_graph.node_link_data(out_graph)
        data = {'links': data["links"], 'clock': self.model.clock}
        self.write_message(data)

        #self.run_model() # Go back to running the model.


    def on_close(self):
        print "Socket closed!"