Python World.stop方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import stop [as 别名]
class Experiment(object):
    POP_SIZE = 500
    RANDOM_ACTORS_NUMBER = 50
    RANK_PROBABILITY_CONSTANT = 0.2

    def __init__(self):
        self.world = World(self)
        self.population = Population(rank_probability=self.RANK_PROBABILITY_CONSTANT, reverse_sort=False)
        self.pop_index = 1
        self.current_generation = 1

    def start(self):
        for _ in xrange(self.POP_SIZE):
            self.population.append(self.create_actor())
        self.world.start()

    @staticmethod
    def evaluate_fitness(actor):
        if actor.dead:
            return 0xFFFFFFF
        x = actor.position[0] - float(actor.world.point[0])
        y = actor.position[1] - float(actor.world.point[1])
        vec_len = float(math.sqrt((x**2) + (y**2)))
        color_diff = float(abs(0x00F - actor.body.color))
        vertex_handicap = float(len(actor.body.polygon)**3)
        return vec_len + color_diff + vertex_handicap

    def create_actor(self, genotype=None):
        actor = Actor(self.world, self.pop_index, self.evaluate_fitness, genotype=genotype, position=(0, 0))
        self.pop_index += 1
        return actor

    def next_generation(self):
        self.world.stop()
        self.population.evaluate()
        new_pop = Population(rank_probability=self.RANK_PROBABILITY_CONSTANT, reverse_sort=False)
        for _ in xrange(self.RANDOM_ACTORS_NUMBER):
            new_pop.append(self.create_actor())
        for _ in xrange(self.POP_SIZE - self.RANDOM_ACTORS_NUMBER):
            new_genotype = Genotype.reproduce(self.population.select_by_rank().genotype,
                                              self.population.select_by_rank().genotype)
            new_pop.append(self.create_actor(genotype=new_genotype))
        self.population = new_pop
        self.current_generation += 1
        self.world.start()

    def update(self):
        for actor in self.population:
            actor.update()

    def stop(self):
        self.world.stop()
        self.population.select_best_fitness().brain_graph()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import stop [as 别名]
class Main(ShowBase, FSM):
    def __init__(self):
        ShowBase.__init__(self)
        FSM.__init__(self, "FSM-Game")

        #
        # BASIC APPLICATION CONFIGURATIONS
        #
        self.disableMouse()
        self.setBackgroundColor(0, 0, 0)
        self.camLens.setFov(75)
        self.camLens.setNear(0.8)

        # check if the config file hasn't been created
        base.textWriteSpeed = 0.05
        mute = ConfigVariableBool("audio-mute", False).getValue()
        if mute:
            self.disableAllAudio()
        else:
            self.enableAllAudio()
        particles = ConfigVariableBool("particles-enabled", True).getValue()
        if particles:
            self.enableParticles()
        base.textWriteSpeed = ConfigVariableDouble("text-write-speed",0.05).getValue()
        base.controlType = ConfigVariableString("control-type", "Gamepad").getValue()
        base.mouseSensitivity = ConfigVariableDouble("mouse-sensitivity",1.0).getValue()
        if not os.path.exists(prcFile):
            self.__writeConfig()
            # set window properties
            # clear all properties not previously set
            self.win.clearRejectedProperties()
            # setup new window properties
            props = WindowProperties()
            # Fullscreen
            props.setFullscreen(True)
            # window icon
            print props.hasIconFilename()
            props.setIconFilename(windowicon)
            # get the displays width and height
            w = self.pipe.getDisplayWidth()
            h = self.pipe.getDisplayHeight()
            # set the window size to the screen resolution
            props.setSize(w, h)
            # request the new properties
            self.win.requestProperties(props)
        atexit.register(self.__writeConfig)

        # enable collision handling
        base.cTrav = CollisionTraverser("base collision traverser")
        base.pusher = CollisionHandlerPusher()
        base.pusher.addInPattern('%fn-in-%in')
        base.pusher.addOutPattern('%fn-out-%in')

        self.menu = Menu()
        self.options = OptionsMenu()

        self.musicMenu = loader.loadMusic("MayanJingle6_Menu.ogg")
        self.musicMenu.setLoop(True)

        cm = CardMaker("menuFade")
        cm.setFrameFullscreenQuad()
        self.menuCoverFade = NodePath(cm.generate())
        self.menuCoverFade.setTransparency(TransparencyAttrib.MAlpha)
        self.menuCoverFade.setBin("fixed", 1000)
        self.menuCoverFade.reparentTo(render2d)
        self.menuCoverFade.hide()
        self.menuCoverFadeOutInterval = Sequence(
            Func(self.menuCoverFade.show),
            LerpColorScaleInterval(
                self.menuCoverFade,
                1,
                LVecBase4f(0.0,0.0,0.0,1.0),
                LVecBase4f(0.0,0.0,0.0,0.0)),
            Func(self.menuCoverFade.hide))
        self.menuCoverFadeInInterval = Sequence(
            Func(self.menuCoverFade.show),
            LerpColorScaleInterval(
                self.menuCoverFade,
                1,
                LVecBase4f(0.0,0.0,0.0,0.0),
                LVecBase4f(0.0,0.0,0.0,1.0)),
            Func(self.menuCoverFade.hide))
        self.lerpAudioFadeOut = LerpFunc(
            self.audioFade,
            fromData=1.0,
            toData=0.0,
            duration=0.25,
            extraArgs=[self.musicMenu])
        self.fadeMusicOut = Sequence(
            self.lerpAudioFadeOut,
            Func(self.musicMenu.stop))
        self.lerpAudioFadeIn = LerpFunc(
            self.audioFade,
            fromData=0.0,
            toData=1.0,
            duration=1,
            extraArgs=[self.musicMenu])
        self.fadeMusicIn = Sequence(
                Func(self.musicMenu.play),
                self.lerpAudioFadeIn)
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import stop [as 别名]
class Simulation:
  width = 100
  height = 100
  amount_food = 100
  num_worms = 100
  start_health = 100
  smell_range = 10
  controllers = []
  finished = False
  sim_world = None
  slomo = 0
  enable_visualization = False
  test_controller = GreedyController()
  def assign_controllers(self, generation):
    for worm in generation.worms:
      self.controllers[0].control_worm(worm)
  
  def stop_controllers(self):
    for controller in self.controllers:
      controller.stop()
      
  def stop(self):
    self.sim_world.stop()
    
  def start(self):    
    self.controllers.append(self.test_controller)
    
    # this will block until self.finished == True
    if self.enable_visualization:
      self.thread = Thread(None, self.run, "World").start()
      self.sim_visualization = Visualization(self)
      self.sim_visualization.run()
    else:
      self.run()

  def initialize_generation(self):
    # a new world
    self.sim_world = World(self.width, self.height, self.amount_food)
    # a generation to live in it
    self.sim_generation = Generation(self.num_worms, self.sim_world, self.start_health, self.smell_range)
    # some controllers that control the worms
    self.assign_controllers(self.sim_generation)
    
  def run(self):
    # TODO implement generation iteration
    self.initialize_generation()
    self.run_world()
    print("Bye")
    self.stop_controllers()
    self.finished = True
  
  def run_world(self):  
    while True:
      try:
        if self.slomo: sleep(self.slomo)
        self.sim_world.step()
      except:
        print("ERRORRRR")
      if self.sim_world.alive_count == 0: break
    print("WormWorld just became very silent")
    self.sim_world.stop()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import stop [as 别名]
class _Game(object):

    default_triggers = () # empty tuple; a tuple is immutable
    game_type_name = None
    record_replay = True
    allow_cheatmode = True
    must_apply_equivalent_type = False

    def create_replay(self):
        self._replay_file = open(os.path.join(REPLAYS_PATH, "%s.txt" % int(time.time())), "w")
        self.replay_write(self.game_type_name)
        players = " ".join([p.login for p in self.players])
        self.replay_write(self.map.get_name() + " " + players)
        self.replay_write(VERSION)
        self.replay_write(res.mods)
        self.replay_write(compatibility_version())
        if self.game_type_name == "mission":
            self.replay_write(self.map.campaign.path)
            self.replay_write(str(self.map.id))
        else:
            self.replay_write(self.map.pack())
        self.replay_write(players)
        alliances = [p.alliance for p in self.players]
        self.replay_write(" ".join(map(str, alliances)))
        factions = [p.faction for p in self.players]
        self.replay_write(" ".join(factions))
        self.replay_write(str(self.seed))

    def replay_write(self, s):
        self._replay_file.write(s + "\n")
      
    def _game_type(self):
        return "%s/%s/%s" % (VERSION,
                             self.game_type_name + "-" + self.map.get_name(),
                             self.nb_human_players)

    def _record_stats(self, world):
        stats.add(self._game_type(), int(world.time / 1000))

    def run(self, speed=config.speed):
        if self.record_replay:
            self.create_replay()
        self.world = World(self.default_triggers, self.seed, must_apply_equivalent_type=self.must_apply_equivalent_type)
        if self.world.load_and_build_map(self.map):
            self.map.load_style(res)
            try:
                self.map.load_resources()
                update_orders_list() # when style has changed
                self.pre_run()
                if self.world.objective:
                    voice.confirmation(mp.OBJECTIVE + self.world.objective)
                self.interface = clientgame.GameInterface(self.me, speed=speed)
                b = res.get_text_file("ui/bindings", append=True, localize=True)
                b += "\n" + self.map.get_campaign("ui/bindings.txt")
                b += "\n" + self.map.get_additional("ui/bindings.txt")
                try:
                    b += "\n" + open(CUSTOM_BINDINGS_PATH, "U").read()
                except IOError:
                    pass
                self.interface.load_bindings(b)
                self.world.populate_map(self.players)
                self.nb_human_players = self.world.current_nb_human_players()
                t = threading.Thread(target=self.world.loop)
                t.daemon = True
                t.start()
                if PROFILE:
                    import cProfile
                    cProfile.runctx("self.interface.loop()", globals(), locals(), "interface_profile.tmp")
                    import pstats
                    for n in ("interface_profile.tmp", ):
                        p = pstats.Stats(n)
                        p.strip_dirs()
                        p.sort_stats('time', 'cumulative').print_stats(30)
                        p.print_callers(30)
                        p.print_callees(20)
                        p.sort_stats('cumulative').print_stats(50)
                else:
                    self.interface.loop()
                self._record_stats(self.world)
                self.post_run()
            finally:
                self.map.unload_resources()
            self.world.stop()
        else:
            voice.alert(mp.BEEP + [self.world.map_error])
        if self.record_replay:
            self._replay_file.close()

    def pre_run(self):
        pass

    def post_run(self):
        self.say_score()

    def say_score(self):
        for msg in self.me.player.score_msgs:
            voice.info(msg)
        voice.flush()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import stop [as 别名]
class FSMGame(FSM):
    def __init__(self):
        FSM.__init__(self, "FSM-Game")
        self.menu = Menu()
        self.gameResult = Result()
        self.numNPCs = 7

        self.musicMenu = loader.loadMusic("Eraplee Noisewall Orchestra - Bermuda Fire.ogg")
        self.musicMenu.setLoop(True)
        self.musicGame = loader.loadMusic("Echovolt - Nothing to Fear.ogg")
        self.musicGame.setLoop(True)

    def enterMenu(self):
        helper.show_cursor()
        self.menu.show()
        self.musicMenu.play()

    def exitMenu(self):
        self.menu.hide()
        self.musicMenu.stop()

    def enterSingleplayer(self):
        helper.hide_cursor()

        self.musicGame.play()

        self.world = World()

        self.player = Player()
        self.player.setPos(self.world.getStartPos(1))
        self.player.setTeam("Yellow")
        self.player.setColor(LPoint3f(1, 1, 0))

        #self.player.setSpectator(self.world.getSpectatorNode())

        # create non player characters
        self.npcs = []
        for i in range(self.numNPCs):
            self.npcs.append(NPC())
            self.npcs[i].setPos(self.world.getStartPos(i+2))
            self.npcs[i].setBunker(self.world.getBunker())
            if i < self.numNPCs/2:
                self.npcs[i].setTeam("Yellow")
                self.npcs[i].setColor(LPoint3f(1, 1, 0))
            else:
                self.npcs[i].setTeam("Blue")
                self.npcs[i].setColor(LPoint3f(0, 0, 1))

        for i in range(self.numNPCs):
            el = []
            if self.npcs[i].playerTeam != self.player.playerTeam:
                el.append(self.player)
            for j in range(self.numNPCs):
                if self.npcs[i].playerTeam != self.npcs[j].playerTeam:
                    el.append(self.npcs[j])
            self.npcs[i].setEnemies(el)


        number = OnscreenText(
            text = "",
            scale = 0.75,
            pos = (0, -0.1875),
            fg = (1,1,1,1),
            align = TextNode.ACenter)

        def startSingleplayer():
            number.destroy()
            self.world.run()
            self.player.run()
            for npc in self.npcs:
                npc.run()
            taskMgr.add(self.checkGameOver, "checkGameOver")

        def setNumber(num):
            number["text"] = str(num)
            number["scale"] = 0.75
        inter = number.scaleInterval(1.0, 0)
        # setup a sequence that will count down for us
        self.countdownSeq = Sequence(
            Func(setNumber, 3),
            inter,
            Func(setNumber, 2),
            inter,
            Func(setNumber, 1),
            inter,
            Func(setNumber, "GO"),
            inter,
            Func(startSingleplayer))
        self.countdownSeq.start()

    def exitSingleplayer(self):
        self.countdownSeq.finish()
        self.player.stop()
        for i in range(len(self.npcs)):
            self.npcs[i].stop()
        self.npcs = []
        self.world.stop()
        del self.world
        self.gameResult.hide()
        taskMgr.remove("checkGameOver")
#.........这里部分代码省略.........