Python World.start方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import start [as 别名]
class Test(unittest.TestCase):
    def setUp(self):
        self.world = World(None)
        self.world.start()
        
        
    def testWorld(self):
        self.world.loader.filename = 'ballformation.sim'
        self.world.loadSimulation(True)
        amount = len(self.world.objects)
        first_item = self.world.objects.keys()[0]
        self.world.deleteObject(first_item)
        amount2 = len(self.world.objects)
        self.assertEqual(amount-1, amount2)
        
        self.world.addObject(AstronomicalObject(vector(0,0,0), vector(0,0,0),0,sphere(position=(0,0,0), make_trail=False),0), 'newObject')
        self.assertEqual(len(self.world.objects), amount)
        self.world.close()
        scene.visible = 0

    def testSimulation(self):
        self.world.loader.filename = 'ballformation.sim'
        self.world.loadSimulation(True)
        self.world.startSimulation()
        sleep(3)
        self.world.stopSimulation()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import start [as 别名]
    def create_world(self):
        from creatures import Predator, Herbivore, Plant

        if self.density < 1 or self.density > 100:
            sys.exit()
        world = World(cols=self.cols, rows=self.rows)
        cnt = int(world.cols * world.rows * 0.01 * self.density / 3)

        for i in xrange(cnt):
            pos = world.get_rnd_free_space()
            if pos is None:
                break
            creature = Predator(x=pos[0], y=pos[1])
            world.queue.append((i * 21, creature))

        for i in xrange(cnt):
            pos = world.get_rnd_free_space()
            if pos is None:
                break
            creature = Herbivore(x=pos[0], y=pos[1])
            world.queue.append((i * 22, creature))

        for i in xrange(cnt):
            pos = world.get_rnd_free_space()
            if pos is None:
                break
            creature = Plant(x=pos[0], y=pos[1])
            world.queue.append((i * 23, creature))

        world.start(0.1)
        return world

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import start [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 start [as 别名]
from gui import NodeGUI, DroneGUI, FloorGUI
from actor import NodeActor, DroneActor, FloorActor
from world import World

# Application entry point
if __name__ == '__main__':
    world_definition = [
        {
            "name": "floor",
            "position": [0, 0, 0, 0],
            "gui_constructor": FloorGUI,
            "actor_constructor": FloorActor,
        },
        {
            "name": "node1",
            "position": [0, 0, 0, 0],
            "gui_constructor": NodeGUI,
            "actor_constructor": NodeActor,
        },
        {
            "name": "drone",
            "position": [100, 100, 100, 0],
            "gui_constructor": DroneGUI,
            "actor_constructor": DroneActor,
        },
    ]
    w = World(world_definition)
    w.start()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import start [as 别名]

#.........这里部分代码省略.........
            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)

        self.seqFade = None
        self.acceptAll()

        self.request("Intro")

    def acceptAll(self):
        self.accept("escape", self.__escape)
        self.accept("menu_quit", self.quit)
        self.accept("menu_start", self.__fadeToStart)
        self.accept("menu_options", self.__fadeToOptions)
        self.accept("options_back", self.__fadeToMain)

    def __fadeToOptions(self):
        if self.seqFade != None:
            if self.seqFade.isPlaying(): return
        self.ignoreAll()
        self.seqFade = Sequence(
            self.menuCoverFadeOutInterval,
            Func(self.request, "Options"),
            Func(self.acceptAll))
        self.seqFade.start()
    def __fadeToStart(self):
        if self.seqFade != None:
            if self.seqFade.isPlaying(): return
        self.ignoreAll()
        self.seqFade = Sequence(
            Parallel(
                self.menuCoverFadeOutInterval,
                self.fadeMusicOut),
            Func(self.request, "Start"),
            Func(self.acceptAll))
        self.seqFade.start()
    def __fadeToMain(self):
        if self.seqFade != None:
            if self.seqFade.isPlaying(): return
        self.ignoreAll()
        self.seqFade = Sequence(
            self.menuCoverFadeOutInterval,
            Func(self.request, "Menu"),
            Func(self.acceptAll))
        self.seqFade.start()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import start [as 别名]
 def makeWorld(self):
   print "Creating GUI"
   world = World(self.game, self.state, self.DumpState(), robot.STEP_TIME)
   world.start()
   return world

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import start [as 别名]
class ControlWindow(QtGui.QWidget):
    def __init__(self):
        super(ControlWindow, self).__init__()
        self.world = World(self)
        self.simulation_on = False  # used to set the simulation speed display to zero if False
        self.add_object_window = None
        self.selector = None
        self.collision = False
        self.collision_text = ''
        self.initUI()

    def initUI(self):

        self.setGeometry(820, 30, 300, 0)
        self.setWindowTitle('Control Window')

        # create informational elements
        self.statusbar = QtGui.QStatusBar(self)
        self.statusbar.showMessage('Ready')
        self.sim_speed_label = QtGui.QLabel('Simulation speed: ')
        self.sim_speed_value = QtGui.QLabel('0 /s')
        velocity_scale = QtGui.QLabel('Velocity scale')
        acceleration_scale = QtGui.QLabel('Acceleration scale')
        self.reference_label = QtGui.QLabel('Default')
        
        # create control elements
        # buttons
        btn_start = QtGui.QPushButton('Start/Stop', self)
        btn_load = QtGui.QPushButton('Load simulation', self)
        btn_reload = QtGui.QPushButton('Reload simulation', self)
        btn_clear = QtGui.QPushButton('Clear', self)
        btn_camera = QtGui.QPushButton('Camera', self)
        
        # sliders
        velocity_vector_scale = QtGui.QSlider(QtCore.Qt.Horizontal, self)
        acceleration_vector_scale = QtGui.QSlider(QtCore.Qt.Horizontal, self)
        acceleration_vector_gain = QtGui.QSlider(QtCore.Qt.Horizontal, self)  # sets the gain value for acceleration
        acceleration_vector_gain.setMinimum(1)
        acceleration_vector_gain.setMaximum(100000)

        # add object window
        self.add_object_window = AddObjectWindow(self.world)

        # time step settings
        timestep_label = QtGui.QLabel('Timestep:')
        self.timestep_value_label = QtGui.QLabel('{}'.format(self.world.getTimeStep()))
        timestep_set_button = QtGui.QPushButton('Set', self)
        self.timestep_edit = QtGui.QLineEdit(self)

        # checkboxes
        self.chkbx_trails = QtGui.QCheckBox('Show trails', self)
        self.chkbx_vectors = QtGui.QCheckBox('Show vectors', self)

        # set timers
        self.speedtimer = QtCore.QTimer()   # updates the updates per second value
        self.speedtimer.setInterval(1000)
        self.speedtimer.start()
        
        # set widget layout
        grid = QtGui.QGridLayout()
        grid.addWidget(btn_start, 0, 0)
        grid.addWidget(btn_load, 0, 1)
        grid.addWidget(btn_reload, 0, 2)
        grid.addWidget(btn_clear, 0, 3)
        
        grid.addWidget(self.sim_speed_label, 1, 0)
        grid.addWidget(self.sim_speed_value, 1, 1)
        
        grid.addWidget(timestep_label, 3,0)
        grid.addWidget(self.timestep_value_label, 3, 1)
        grid.addWidget(self.timestep_edit, 3, 2)
        grid.addWidget(timestep_set_button, 3, 3)
        
        grid.addWidget(self.chkbx_trails, 4,0)
        grid.addWidget(btn_camera, 4, 2)
        grid.addWidget(self.reference_label, 4, 3)
        grid.addWidget(self.chkbx_vectors, 4, 1)

        grid.addWidget(velocity_scale, 6,0)
        grid.addWidget(velocity_vector_scale, 6,1)
        grid.addWidget(acceleration_scale, 7, 0)
        grid.addWidget(acceleration_vector_scale, 7, 1)
        grid.addWidget(acceleration_vector_gain, 7, 2)
        grid.addWidget(self.add_object_window,8,0,1,-1)
        grid.addWidget(self.statusbar, 9,0,1,-1)

        
        self.setLayout(grid)


        # set button tooltips
        btn_start.setToolTip('Start/pause simulation')
        timestep_set_button.setToolTip('Set simulation timestep')
        btn_clear.setToolTip('Clear all objects')

        # connect controls
        btn_load.clicked.connect(self.loadSimulation)
        btn_reload.clicked.connect(self.reloadSimulation)
        btn_start.clicked.connect(self.startStop)
        btn_clear.clicked.connect(self.clearObjects)
#.........这里部分代码省略.........