Python World.add_entity方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import add_entity [as 别名]
def run():
    WIDTH = 640
    HEIGHT = 480

    running = True
    clock = pygame.time.Clock()
    screen = pygame.display.set_mode( (WIDTH,HEIGHT) )
    w = World()

    c = Camera(screen, (0,0), 3.0, HEIGHT)
    c.set_world(w)

    b = BallEntity((100,100), {'radius': 10, 'density': 10, 'restitution': 0.1,
                               'static': True, 'line-width': 5})
    w.add_entity(b)

    b2 = BallEntity((100,60), {'radius': 20, 'density': 100, 'restitution': 1.0})
    w.add_entity(b2)
    b2.body.SetLinearVelocity((0,40))

    base = BoxEntity((20,20), {'width': 100, 'height': 10})#, 'static': True})
    w.add_entity(base)

    while running:
        screen.fill((255,255,255))
        c.draw()
        pygame.display.flip()

        w.step(dt)
        clock.tick(hz)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import add_entity [as 别名]
    def run_simulations(self, only_condition=None, only_trigger_condition=None, only_controllers=None, number=None):
        for setting in self.create_all_settings():
            print "running {0}-{1}".format(setting.condition, setting.trigger_condition)

            # Skip if this is not one of the conditions we want to simulate
            if only_condition is not None and setting.condition != only_condition:
                print "skipping {0}".format(only_condition)
                continue
            if only_controllers is not None:
                is_match = True
                for e in only_controllers:
                    if only_controllers[e] != setting.controllers[e][0]:
                        is_match = False

                if not is_match:
                    print "skipping {0}, {1}".format(only_condition, only_controllers)
                    continue

            world = World(self.visualizer)
            file_name = setting.condition + "-" + setting.trigger_condition

            for entity_name in setting.entities:
                entity = setting.entities[entity_name]()
                if entity_name in setting.controllers:
                    entity.set_agent(setting.controllers[entity_name][1]())
                    file_name += "-{0}-{1}".format(entity_name, setting.controllers[entity_name][0])

                world.add_entity(entity)

            for trigger in setting.initial_triggers:
                world.add_trigger(*trigger)

            if only_trigger_condition is not None and setting.trigger_condition != only_trigger_condition:
                print "skipping {0}".format(only_trigger_condition)
                continue
            world.run(self.simulation_length, add_triggers=setting.trigger_additions, remove_triggers=setting.trigger_removals)

            log = world.log
            log.make_data(file_name, self.constant_data_collection, number)
            Log.make_bins(file_name, self.constant_data_collection.values(), self.bins, number)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import add_entity [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 add_entity [as 别名]
class InGameState(GameState):
    def __init__(self):
        self.done = False
        self.world = World()

        self.ambient = pygame.mixer.Sound("audio/generic_ambient1.wav")        
        self.ambient.play(-1)
        
        self.fire_images = []
        self.hare_images_rf = []
        self.water_images = []

        self.player = MusicPlayer()       
        self.wait_for_song = 1200
        self.music_playing = False

        self.hare_timer = 1.0
        self.hare_timer_add = 1.0
        
        self.fire_timer = 1.0
        self.fire_timer_add = 1.0

        for i in xrange(3):
            filename = "images/fire%i.png" % (i+1)
            image = pygame.image.load(filename).convert_alpha()
            self.fire_images.append(image)

        for i in xrange(2):
            filename = "images/hare%i.png" % (i+1)
            image = pygame.image.load(filename).convert_alpha()
            self.hare_images_rf.append(image)

        for i in xrange(2):
            filename = "images/water%i.png" % (i+1)
            image = pygame.image.load(filename).convert_alpha()
            self.water_images.append(image)

        self.hare_images_lf = map(lambda i: pygame.transform.flip(i, 1, 0), self.hare_images_rf)

        self.humans = []
        self.viewports = []
        
        loader = ImageStripLoader("images/hunger_strip.png")
        self.world.hunger_images = []
        self.world.hunger_images = loader.images_from_coordinates((
            (0,0,64,64),(64,0,64,64),(128,0,64,64),(192,0,64,64),(256,0,64,64),(320,0,64,64),
        ))
        loader = ImageStripLoader("images/thirst_strip.png")
        self.world.thirst_images = []
        self.world.thirst_images = loader.images_from_coordinates((
            (0,0,64,64),(64,0,64,64),(128,0,64,64),(192,0,64,64),(256,0,64,64),(320,0,64,64),
        ))
        loader = ImageStripLoader("images/warmth_strip.png")
        self.world.warmth_images = []
        self.world.warmth_images = loader.images_from_coordinates((
            (0,0,64,64),(64,0,64,64),(128,0,64,64),(192,0,64,64),(256,0,64,64),(320,0,64,64),
        ))

        for human_count in xrange(2):
            human_red = Human(self.world, human_count+1)
            human_red.location = self.get_safe_spot()
            self.world.add_entity(human_red)
            self.humans.append(human_red)
            offset = human_count*SCREEN_SIZE[0]/2+1
            r = pygame.Rect(offset, 0, SCREEN_SIZE[0]/2-1, SCREEN_SIZE[1])
            viewport = Viewport(r, human_red)
            self.viewports.append(viewport)

        for fire_count in xrange(randint(10,50)):
            fire = Fire(self.world, self.fire_images)
            fire.location = self.get_safe_spot()
            self.world.add_entity(fire)
            self.world.fire_count += 1

        for water_count in xrange(randint(5, 10)):
            water = Water(self.world, self.water_images)
            water.location = self.get_safe_spot()
            self.world.add_entity(water)
            self.world.hare_count += 1

    def onEvent(self, event):
        if event.type == KEYDOWN and event.key == pygame.K_ESCAPE:
            self.done = True
        if event.type == AudioSystem.SONG_END:
            self.music_playing = False
            
    def get_safe_spot(self):
        while True:
            p = (randint(1, WORLD_SIZE[0]-1), randint(1, WORLD_SIZE[1]-1))
            if not self.world.grid.getBlock(p[0], p[1]):
                return Vector2(p[0], p[1]) * BLOCK_SIZE

    def update(self, passed_time, state_list):
        if self.world.human_count < 1:
            done = True
            state_list.pop()
            state_list.append(EndState(self.humans[0].age, self.humans[1].age))
            return
        if self.done:
            state_list.pop()
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import add_entity [as 别名]
def runLevel(screen, level_number, cat_number):
    soundChannel = pygame.mixer.Channel(0)
    finishSound = pygame.mixer.Sound('../sounds/finish.ogg')  
    
    builder = LevelBuilder()
    level = builder.buildLevelFromFile('../levels/level%s.txt' % level_number)
    world = World(SCREEN_SIZE, level)
    
    car = Car(Vector2(100,100))
    player = Player(Vector2(100, 180))
    
    world.add_entity(player)
    world.add_entity(car)
    world.setFocus(player)
    
    worldobserver = WorldObserver(world)
    clock = pygame.time.Clock()
    
    for i in range(cat_number):
        cat = Cat(Vector2(randint(0, world.dimension[0]), 
                          randint(0, world.dimension[1])), 
                  world)
        world.add_entity(cat)
    
    countdown_to_next_level = LEVEL_INTERMEDIATE_TIME
    while True:
        
        for event in pygame.event.get():
            if event.type == QUIT:
                exit()
            if event.type == KEYDOWN:
                if event.key == K_LEFT:
                    player.move(LEFT)
                elif event.key == K_RIGHT:
                    player.move(RIGHT)
                elif event.key == K_UP:
                    player.move(UP)
                elif event.key == K_DOWN:
                    player.move(DOWN)
                elif event.key == K_SPACE:
                    food = player.dropFood()
                    if food is not None:
                        world.add_entity(food)
                elif event.key == K_c:
                    player.switchVehicle(car)
                    world.setFocus(player.vehicle or player)
                elif event.key == K_m:
                    world.toggleMinimap()
                        
        time_passed = clock.tick(30)
        
        world.process(time_passed)
        world.render(screen)
        worldobserver.writeMessages(screen)
        
        if worldobserver.levelFinished:
            if countdown_to_next_level == LEVEL_INTERMEDIATE_TIME:
                soundChannel.play(finishSound)
            countdown_to_next_level -= 2
            if countdown_to_next_level <= 0:
                return
            
            for r in range(countdown_to_next_level+1, LEVEL_INTERMEDIATE_TIME, 8):
                pygame.draw.circle(screen, (0, 0, 0), (SCREEN_SIZE[0]/2, SCREEN_SIZE[1]/2), r, 1)
        
        pygame.display.update()