Python model.Model类代码示例

	def setUp( self ):
		Universe, StarSystem, Planet, Fleet = self.model.use( 'Universe', 'StarSystem', 'Planet', 'Fleet' )

		universe = Universe(
				name = "The Universe",
				size = 10**8,
				age  = 0 )

		system = StarSystem(
				name		= "The Star System",
				parent		= universe,
				position	= Vector3D( 0, 0, 0 ),
				size		= 10**4)

		planet = Planet(
				name		= "The Planet",
				parent		= system,
				position	= Vector3D( system.position.x + 5,
										system.position.y + 7 ),
				size		= 10**2,
				owner		= self.players[0] )

		fleet = Fleet(
				parent   = planet,
				size     = 3,
				name     = "The Fleet",
				ships    = [],
				damage   = 0,
				position = planet.position,
				owner    = self.players[0])

		self.objects = [ universe, system, planet, fleet ]

		Model.add( self.objects )

    def initModel(self):
        Ruleset.initModel(self)

        universe = self.generator.createUniverse(name="The Universe")
        ships = self.generator.createShipClasses()

        Model.add(universe, ships)

    def addPlayer(self, username, password, email="N/A", comment=""):
        """
		Create a player for this game.

		The default function creates a new user, a board for the user and adds a
		welcome message. It returns the newly created user object.
		"""
        Player, Board, Message = self.model.use("Player", "Board", "Message")

        player = Player(username=username, password=password, email=email, comment=comment)

        board = Board(
            owner=player,
            name="Private message board for %s" % username,
            description="This board is used so that stuff you own (such as fleets and planets) can inform you of what is happening in the universe.",
        )

        board.messages.append(
            Message(
                subject="Welcome to the Universe!",
                body="Welcome, %s, to the python Thousand Parsec server. Hope you have fun!"
                "This game is currently playing version %s of %s." % (username, self.version, self.name),
                turn=self.game.turn,
            )
        )

        Model.add(player, board)

        return player

	def __call__( self, request ):
		Object = self.model.use( self.__object__ )

		response = []

		for id in request.ids:
			obj = self.fetch( Object, id )

			# WARNING: This is only for testing purposes!
			Model.refresh( obj )

			if obj:
				if self.authorize( obj ):
					response.append( self.process( request, obj ) )
				else:
					debug( "No permission for %s with id %s.", Object.__origname__, id ) 
					response.append( self.Fail( request, "PermissionDenied", "You cannot access %s with id = %d." % ( Object.__origname__, id ) ) )
			else:
				debug( "No such %s with id %s.", Object.__origname__, id ) 
				response.append( self.Fail( request, "NoSuchThing", "No %s with id = %d." % ( Object.__origname__, id ) ) )

		if len( response ) > 1:
			response.insert( 0, self.Sequence( request, len( response ) ) )

		if not len( response ):
			response.append( self.Fail( request, "Protocol", "List of IDs must be nonempty!" ) )

		return response

	def tearDown( self ):
		Category = self.model.use( 'Category' )

		if Category.ById( self.cat.id ):
			Model.remove( self.cat )

		super( RemovePublicCategory, self ).tearDown()

	def setUp( self ):
		Board = self.model.use( 'Board' )

		board1 = Board(
			owner       = self.players[0],
			name        = "First message board for %s" % self.players[0].username,
			description = "Board for testing purposes." )

		board2 = Board(
			owner       = self.players[0],
			name        = "Second message board for %s" % self.players[0].username,
			description = "Board for testing purposes." )

		board3 = Board(
			owner       = self.players[1],
			name        = "Message board for %s" % self.players[1].username,
			description = "Board for testing purposes." )

		board4 = Board(
			owner		= None,
			name		= "Public message board.",
			description = "Board for testing purposes." )

		self.boards = [ board1, board2, board3, board4 ]

		Model.add( self.boards )

	def __call__( self, request ):
		Container = self.model.use( 'Board' )

		container = Container.ById( request.id )

		if container:
			if self.authorize( container ):
				slot = request.slot if request.slot < len( container.messages ) else -1

				message = self.fromPacket( request ) 

				if slot == -1:
					container.messages.append( message )
				else:
					container.messages.insert( slot, message )

				Model.add( container )

				if slot == -1:
					slot = len( container.messages )

				response = self.Okay( request, "Message posted on %s with id = %d in slot %d." % ( Container.__origname__, request.id, slot ) )
			else:
				debug( "No permission for %s with id %s.", Container.__origname__, request.id ) 
				response = self.Fail( request, "PermissionDenied", "You cannot access %s with id = %d." % ( Container.__origname__, request.id ) )
		else:
			debug( "No such %s with id %s.", Container.__origname__, request.id ) 
			response = self.Fail( request, "NoSuchThing", "No %s with id = %d." % ( Container.__origname__, request.id ) )

		return response 

	def setUp( self ):
		Board, Message = self.model.use( 'Board', 'Message' )

		board = Board(
			owner		= self.players[0],
			name        = "First message board for %s" % self.players[0].username,
			description = "Board for testing purposes." )

		board.messages.append(
			Message(
				subject = "First",
				body	= "Test message generated in first turn",
				turn    = 1 ))

		board.messages.append(
			Message(
				subject = "Second",
				body	= "Test message generated in second turn",
				turn    = 2 ))

		board.messages.append(
			Message(
				subject = "Third",
				body	= "Test message generated in third turn",
				turn    = 3 ))

		self.board = board

		Model.add( board )

	def setUp( self ):
		Category = self.model.use( 'Category' )

		self.cat = Category(
				name = "Public",
				description = "Public category for testing purposes." )

		Model.add( self.cat )

    def initModelConstants(self):
        """
		This method initialises all data which is considered to be constant for
		a ruleset lifetime.
		"""
        Model.create(self.model)

        for loader in self.modelLoaders:
            loader.initModelConstants()

	def initialise( self ):
		Model.add( self.__game )

		self.ruleset.loadModelConstants()
		self.ruleset.initModelConstants()
		self.ruleset.loadModel()
		self.ruleset.initModel()

		info( "Game '%s' initialised successfully.", self.name )

	def __init__( self ):
		Model.init()

		self.__game = {}

		for gamedesc in GameDesc.query().all():
			game = Game( gamedesc )
			game.load()

			self.__game[ game.name ] = game

	def addResourcesToPlanet( self, planet ):
		ResourceType = self.model.use( 'ResourceType' )

		NaturalResourceTypes = [ ResourceType.ByName( name ) for name in [ 'Fruit Tree', 'Weird Artifact', 'Rock', 'Water' ] ]

		# Add a random smattering of resources to planets...
		for Type in self.random.sample( NaturalResourceTypes, self.randint(0, 4) ):
			planet.resources[ Type ] = {
					'accessible'   : self.randint( 0, 10 ),
					'extractable'  : self.randint( 0, 100 ),
					'inaccessible' : self.randint( 0, 1000 ) }

		Model.update( planet )

	def addPlayer( self, username, password, email = 'Unknown', comment = 'A Minisec Player' ):
		"""
		Create a Solar System, Planet, and initial Fleet for the player, positioned randomly within the Universe.
		"""
		user, system, planet, fleet = MinisecRuleset.addPlayer( self, username, password, email, comment )

		ResourceType = self.model.use( 'ResourceType' )

		# Get the player's planet object and add the empire capital
		planet.resources = { 
				ResourceType.ByName('House')          : { 'accessible' : 1 },
				ResourceType.ByName('Empire Capital') : { 'accessible' : 1 } }

		Model.update( planet )

    def initModel(self):
        """ 
		Initialise the database with anything needed for this game.

		The ruleset should do things like,
			- Create any components in the databases
			- Create any resources in the databases
			- etc

		This should not add anything to the players universe. Use the populate
		command for that.

		This command takes no arguments, so it should not do anything which 
		needs information from the user.
		"""
        Model.create(self.model)