Python World.run方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [as 别名]
 def __init__(self):
     self.worlds = []
     for i in xrange(3):
         world = World('world%d' %i, self)
         world.run('../server/maps/world_server.json')
         self.worlds.append(world)
     application = Application([
         ('/', Connection, {'gameserver': self}),
     ])
     http_server = HTTPServer(application)
     http_server.listen(8000)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [as 别名]
class Server(object):
	def __init__(self):
		"""
		This is called when mod_pywebsockets imports the _wsh handler.
		
		This is somewhat equivalent to some of the stuff in /server/js/main.js.
		"""
		# TODO: implement configuration.
		# We implement an unsharded world.
		self.world = World(1, 64, self)
		
		
		self.world.run("./server/maps/world_server.json")
		
		
		
		self.clients = []
	
	def add_player(self, player):
		self.clients.append(player)
	
	
	def do_extra_handshake(self, request):
		"""
		TODO: Implement checks on request origins.
		"""
		
		pass
	
	def transfer_data(self, request):
		"""
		This is called when a WebSockets connection is created on the server.
		"""
		#logger.info('running inside of server %s', self)
		player = Player(request.ws_stream, self)
		self.world.on_player_connect(player)
		
		# tell the client it's okay to start sending us stuff
		request.ws_stream.send_message('go')
		
		while True:
			
			data = request.ws_stream.receive_message()
			logger.info('got client message: %r', data)
			if data is None:
				# disconnect
				return
			
			# we don't implement BiSON
			msg = json.loads(data)
			player.handle_message(msg)
			

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [as 别名]
def main():
	app = QtGui.QApplication(sys.argv)
	w = Window()
	w.center()

	# Setup the world
	world = World(w)

	# Show the window
	w.setCentralWidget(world)
	w.show()

	# Run the world
	world.run()

	sys.exit(app.exec_())

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [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 run [as 别名]
def main():

    world = World(WORLD_DIMENSIONS, SCALE, SIMULATION_RATE, MAX_UPDATE)
    world.run = AUTOSTART

    if "--carp" in argv:
        world.population_gen_params["Carp"]["count"] = 5

    if USE_CONTROLLER:
        controller = Controller(world)
        controller.start()

    current_time = time.time()

    last_update = current_time
    update_period = 1/UPDATES_PER_SECOND

    last_draw = current_time
    draw_period = 1/FRAMES_PER_SECOND

    while True:
        current_time = time.time()
        update_delta = current_time - last_update
        draw_delta = current_time - last_draw

        if update_delta > update_period:
            world.do_update(update_delta)
            last_update = current_time

        if draw_delta > draw_period:
            world.do_draw(draw_delta)
            last_draw = current_time

        time.sleep(.01)

    if USE_CONTROLLER:
        controller.join()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [as 别名]
def setupGame():
    # Well, here goes some code
    a_new_world = World()
    a_new_world.run()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [as 别名]
class MainWindow(QWidget):

    group  = None
    labels = []

    def __init__(self,parent=None):
        super().__init__(parent)

        self.parent = parent
        self.width = parent.width
        self.height = parent.height
        self.clicked = False

        self.world = World(self)

        self.Pi = Vector(0,0)
        self.x = 0
        self.y = 0

        self.initUI()

        self.timer = QTimer()
        self.timer.timeout.connect(self.update)
        self.timer.start(20)

        # self.timer2 = QTimer()
        # self.timer2.timeout.connect(self.updateInfo)
        # self.timer2.start(100)

    def initUI(self):

        # self.group = QGroupBox(self)

        # vbox = QVBoxLayout()
        # for k,v in self.world.info:
        #     hbox = QHBoxLayout()
        #     self.labels.append([self.getTextLabel(k,10),self.getTextLabel(v,10)])
        #     hbox.addWidget(self.labels[-1][0])
        #     hbox.addStretch(1)
        #     hbox.addWidget(self.labels[-1][1])
        #     vbox.addLayout(hbox)


        # self.group.setLayout(vbox)
        # self.group.resize(self.width/7,self.height/2)


        self.setMouseTracking(True)
        self.setGeometry(300,300,1280,720)
        self.setWindowTitle("test")
        self.setStyleSheet("background : black")
        self.showMaximized()

    def paintEvent(self,event):

        self.drawBorder()

        self.world.run()
        
        if self.clicked:
            self.drawArrow(self.Pi,Vector(self.x,self.y))

        self.drawMouse()

        self.drawStatus()

    def drawBorder(self):
        qp = QPainter()
        qp.begin(self)
        pen = QPen(QColor(150,150,0))
        pen.setWidth(10)
        pen.setStyle(Qt.DashDotLine)
        pen.setCapStyle(Qt.RoundCap)
        pen.setJoinStyle(Qt.RoundJoin)
        qp.setPen(pen)
        pos = self.world.planet.location
        rad = self.world.planet.radius*2
        qp.drawEllipse(pos[0]-rad,pos[1]-rad,rad*2,rad*2)
        qp.end()

    def drawStatus(self):

        qp = QPainter()
        qp.begin(self)
        qp.setFont(QFont('Consolas',15))

        for i in range(0,len(self.world.info)):
            pen = QPen(QColor('white'))
            qp.setPen(pen)
            qp.drawText(20,100+i*(self.height/20),self.world.info[i][0])

            pen = QPen(self.getColor(i))
            qp.setPen(pen)
            qp.drawText(self.width/8,100+i*(self.height/20),self.world.getInfo(i))
            
        qp.end()

    def drawText(self,x,y,text):
        qp = QPainter()
        pen = QPen(QColor(255,255,255))
#.........这里部分代码省略.........

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

if __name__ == '__main__':
    world = World()
    world.run()

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import run [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")
#.........这里部分代码省略.........

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

if __name__ == '__main__':
    w = World()
    w.run()

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