def populate(self, seed, system_min, system_max, planet_min, planet_max):
        """\
		--populate <game> <random seed> <min systems> <max systems> <min planets> <max planets>
		
			Populate a universe with a number of systems and planets.
			The number of systems in the universe is dictated by min/max systems.
			The number of planets per system is dictated by min/max planets.
		"""
        seed, system_min, system_max, planet_min, planet_max = (
            int(seed), int(system_min), int(system_max), int(planet_min),
            int(planet_max))

        dbconn.use(self.game)

        trans = dbconn.begin()
        try:
            # FIXME: Assuming that the Universe and the Galaxy exist.
            r = random.Random()
            r.seed(int(seed))

            # Create this many systems
            for i in range(0, r.randint(system_min, system_max)):
                pos = r.randint(SIZE * -1, SIZE) * 1000, r.randint(
                    SIZE * -1, SIZE) * 1000, r.randint(SIZE * -1, SIZE) * 1000

                # Add system
                system = Object(type='tp.server.rules.base.objects.System')
                system.name = "System %s" % i
                system.size = r.randint(800000, 2000000)
                system.posx = pos[0]
                system.posy = pos[1]
                system.insert()
                ReparentOne(system)
                system.save()
                print "Created system (%s) with the id: %i" % (system.name,
                                                               system.id)

                # In each system create a number of planets
                for j in range(0, r.randint(planet_min, planet_max)):
                    planet = Object(type='tp.server.rules.base.objects.Planet')
                    planet.name = "Planet %i in %s" % (j, system.name)
                    planet.size = r.randint(1000, 10000)
                    planet.parent = system.id
                    planet.posx = pos[0] + r.randint(1, 100) * 1000
                    planet.posy = pos[1] + r.randint(1, 100) * 1000
                    planet.insert()
                    print "Created planet (%s) with the id: %i" % (planet.name,
                                                                   planet.id)

            trans.commit()
        except:
            trans.rollback()
            raise
	def populate(self, seed, system_min, system_max, planet_min, planet_max):
		"""\
		--populate <game> <random seed> <min systems> <max systems> <min planets> <max planets>
		
			Populate a universe with a number of systems and planets.
			The number of systems in the universe is dictated by min/max systems.
			The number of planets per system is dictated by min/max planets.
		"""
		seed, system_min, system_max, planet_min, planet_max = (int(seed), int(system_min), int(system_max), int(planet_min), int(planet_max))

		dbconn.use(self.game)
	
		trans = dbconn.begin()
		try:
			# FIXME: Assuming that the Universe and the Galaxy exist.
			r = random.Random()
			r.seed(int(seed))

			# Create this many systems
			for i in range(0, r.randint(system_min, system_max)):
				pos = r.randint(SIZE*-1, SIZE)*1000, r.randint(SIZE*-1, SIZE)*1000, r.randint(SIZE*-1, SIZE)*1000
				
				# Add system
				system = Object(type='tp.server.rules.base.objects.System')
				system.name = "System %s" % i
				system.size = r.randint(800000, 2000000)
				system.posx = pos[0]
				system.posy = pos[1]
				system.insert()
				ReparentOne(system)
				system.save()
				print "Created system (%s) with the id: %i" % (system.name, system.id)
				
				# In each system create a number of planets
				for j in range(0, r.randint(planet_min, planet_max)):
					planet = Object(type='tp.server.rules.base.objects.Planet')
					planet.name = "Planet %i in %s" % (j, system.name)
					planet.size = r.randint(1000, 10000)
					planet.parent = system.id
					planet.posx = pos[0]+r.randint(1,100)*1000
					planet.posy = pos[1]+r.randint(1,100)*1000
					planet.insert()
					print "Created planet (%s) with the id: %i" % (planet.name, planet.id)

			trans.commit()
		except:
			trans.rollback()
			raise
	def initialise(self):
		"""\
		Minisec 
		"""
		dbconn.use(self.game)

		trans = dbconn.begin()
		try:
			RulesetBase.initialise(self)

			# Need to create the top level universe object...
			universe = Object(type='tp.server.rules.base.objects.Universe')
			universe.id     = 0
			universe.name   = "The Universe"
			universe.size   = SIZE
			universe.parent = 0
			universe.posx   = 0
			universe.posy   = 0
			universe.turn   = 0
			universe.insert()

			trans.commit()
		except:
			trans.rollback()
			raise
    def initialise(self):
        """\
		Minisec 
		"""
        dbconn.use(self.game)

        trans = dbconn.begin()
        try:
            RulesetBase.initialise(self)

            # Need to create the top level universe object...
            universe = Object(type='tp.server.rules.base.objects.Universe')
            universe.id = 0
            universe.name = "The Universe"
            universe.size = SIZE
            universe.parent = 0
            universe.posx = 0
            universe.posy = 0
            universe.turn = 0
            universe.insert()

            trans.commit()
        except:
            trans.rollback()
            raise
Exemplo n.º 5
0
    def do(self, action):
        # We are going to have to modify the object so lets load it
        obj = Object(self.oid)

        # Work out what the maximum speed of this object is
        speed = obj.speed()

        xd, yd, zd = self.pos[0] - obj.posx, self.pos[1] - obj.posy, self.pos[
            2] - obj.posz

        if action == 'finalise':
            # Make sure that we haven't missed the object
            if (obj.velx, obj.vely, obj.velz) != (0, 0, 0):
                if xd * obj.velx < 0 or yd * obj.vely < 0 or zd * obj.velz < 0:
                    print "Object %i (%s) has overshot destination %s to (%i, %i, %i)" % \
                     (obj.id, obj.name, self.pos, obj.velx, obj.vely, obj.velz)
                    obj.posx, obj.posy, obj.posz = self.pos
                    ReparentOne(obj)
                    obj.save()

            # Have we reached our destination?
            if self.pos == (obj.posx, obj.posy, obj.posz):
                print "Object %i (%s) has arrived at destination (%i, %i, %i)" % \
                  (obj.id, obj.name, obj.posx, obj.posy, obj.posz)
                obj.velx = obj.vely = obj.velz = 0
                obj.save()

                self.remove()

                # Send a message to the owner that the object has arrived...
                message = Message()
                message.bid = obj.owner
                message.slot = -1
                message.subject = "%s arrived" % obj.name
                message.body = """%s has arrive at it's destination (%i, %i, %i).""" % \
                     (obj.name, obj.posx, obj.posy, obj.posz)
                message.insert()
            return

        elif action == 'prepare':
            distance = math.sqrt(xd**2 + yd**2 + zd**2)

            if distance == 0:
                return

            # Set the velocity so we are moving towards self.pos at speed
            velx = away(closest(speed * xd / distance, xd))
            vely = away(closest(speed * yd / distance, yd))
            velz = away(closest(speed * zd / distance, zd))

            if (velx, vely, velz) != (obj.velx, obj.vely, obj.velz):
                print "Setting velocity of object %i to %r currently at %r destination %r" % (
                    obj.id, (velx, vely, velz),
                    (obj.posx, obj.posy, obj.posz), self.pos)
                obj.velx, obj.vely, obj.velz = velx, vely, velz
                obj.save()
            return
        else:
            raise Exception("Unknown action!")
Exemplo n.º 6
0
	def do(self, action):
		# We are going to have to modify the object so lets load it
		obj = Object(self.oid)

		# Work out what the maximum speed of this object is
		speed = obj.speed()

		xd, yd, zd = self.pos[0] - obj.posx, self.pos[1] - obj.posy, self.pos[2] - obj.posz

		if action == 'finalise':
			# Make sure that we haven't missed the object
			if (obj.velx, obj.vely, obj.velz) != (0,0,0):
				if xd*obj.velx < 0 or yd*obj.vely < 0 or zd*obj.velz < 0:
					print "Object %i (%s) has overshot destination %s to (%i, %i, %i)" % \
						(obj.id, obj.name, self.pos, obj.velx, obj.vely, obj.velz)
					obj.posx, obj.posy, obj.posz = self.pos
					ReparentOne(obj)
					obj.save()
	
			# Have we reached our destination?
			if self.pos == (obj.posx, obj.posy, obj.posz):
				print "Object %i (%s) has arrived at destination (%i, %i, %i)" % \
						(obj.id, obj.name, obj.posx, obj.posy, obj.posz)
				obj.velx = obj.vely = obj.velz = 0
				obj.save()
				
				self.remove()
	
				# Send a message to the owner that the object has arrived...
				message = Message()
				message.bid = obj.owner
				message.slot = -1
				message.subject = "%s arrived" % obj.name
				message.body = """%s has arrive at it's destination (%i, %i, %i).""" % \
									(obj.name, obj.posx, obj.posy, obj.posz)
				message.insert()
			return
		
		elif action == 'prepare':
			distance = math.sqrt(xd**2 + yd**2 + zd**2)
			
			if distance == 0:
				return
	
			# Set the velocity so we are moving towards self.pos at speed
			velx = away(closest(speed * xd/distance, xd))
			vely = away(closest(speed * yd/distance, yd))
			velz = away(closest(speed * zd/distance, zd))
			
			if (velx, vely, velz) != (obj.velx, obj.vely, obj.velz):
				print "Setting velocity of object %i to %r currently at %r destination %r" % (obj.id, 
					(velx, vely, velz),
					(obj.posx, obj.posy, obj.posz),
					self.pos)
				obj.velx, obj.vely, obj.velz = velx, vely, velz
				obj.save()
			return
		else:
			raise Exception("Unknown action!")
Exemplo n.º 7
0
    def player(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.
		"""
        dbconn.use(self.game)

        trans = dbconn.begin()
        try:
            user = RulesetBase.player(self, username, password, email, comment)

            # FIXME: Hack! This however means that player x will always end up in the same place..
            r = random.Random()
            r.seed(user.id)

            pos = r.randint(SIZE * -1, SIZE) * 1000, r.randint(
                SIZE * -1, SIZE) * 1000, r.randint(SIZE * -1, SIZE) * 1000

            system = Object(type='tp.server.rules.base.objects.System')
            system.name = "%s Solar System" % username
            system.parent = 0
            system.size = r.randint(800000, 2000000)
            (system.posx, system.posy, junk) = pos
            ReparentOne(system)
            system.owner = user.id
            system.save()

            planet = Object(type='tp.server.rules.timtrader.objects.Planet')
            planet.name = "%s Planet" % username
            planet.parent = system.id
            planet.size = 100
            planet.posx = system.posx + r.randint(1, 100) * 1000
            planet.posy = system.posy + r.randint(1, 100) * 1000
            planet.owner = user.id

            # Get the player's planet object and add the empire capital
            planet.resources_add(Resource.byname('Header Quarter'), 1)
            planet.resources_add(Resource.byname('Credit'), 10000)

            planet.save()

            fleet = Object(type='tp.server.rules.minisec.objects.Fleet')
            fleet.parent = planet.id
            fleet.size = 3
            fleet.name = "%s First Fleet" % username
            fleet.ships = {1: 3}
            (fleet.posx, fleet.posy, fleet.posz) = (planet.posx, planet.posy,
                                                    planet.posz)
            fleet.owner = user.id
            fleet.save()

            trans.commit()
        except:
            trans.rollback()
            raise
	def player(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.
		"""
		dbconn.use(self.game)
	
		trans = dbconn.begin()
		try:
			user = RulesetBase.player(self, username, password, email, comment)

			# FIXME: Hack! This however means that player x will always end up in the same place..
			r = random.Random()
			r.seed(user.id)

			pos = r.randint(SIZE*-1, SIZE)*1000, r.randint(SIZE*-1, SIZE)*1000, r.randint(SIZE*-1, SIZE)*1000

			system = Object(type='tp.server.rules.base.objects.System')
			system.name = "%s Solar System" % username
			system.parent = 0
			system.size = r.randint(800000, 2000000)
			(system.posx, system.posy, junk) = pos
			ReparentOne(system)
			system.owner = user.id
			system.save()

			planet = Object(type='tp.server.rules.timtrader.objects.Planet')
			planet.name = "%s Planet" % username
			planet.parent = system.id
			planet.size = 100
			planet.posx = system.posx+r.randint(1,100)*1000
			planet.posy = system.posy+r.randint(1,100)*1000
			planet.owner = user.id

			# Get the player's planet object and add the empire capital
			planet.resources_add(Resource.byname('Header Quarter'), 1)
			planet.resources_add(Resource.byname('Credit'), 10000)

			planet.save()

			fleet = Object(type='tp.server.rules.minisec.objects.Fleet')
			fleet.parent = planet.id
			fleet.size = 3
			fleet.name = "%s First Fleet" % username
			fleet.ships = {1:3}
			(fleet.posx, fleet.posy, fleet.posz) = (planet.posx, planet.posy, planet.posz)
			fleet.owner = user.id
			fleet.save()

			trans.commit()
		except:
			trans.rollback()
			raise
Exemplo n.º 9
0
	def do(self):
		builder = Object(self.oid)

		if not hasattr(builder, "owner"):
			print "Could not do a build order because it was on an unownable object."
			self.remove()
		
		if self.turns() > 1:
			# Add another year to worked...
			self.worked += 1
			print "Worked %s, %s left until built." % (self.worked, self.turns())
			self.save()
			return
			
		# Build new fleet object
		fleet = Object(type='tp.server.rules.minisec.objects.Fleet')

		# Type Fleet
		fleet.parent = builder.id
		fleet.posx = builder.posx
		fleet.posy = builder.posy
		fleet.posz = builder.posz
		fleet.size = 1
		fleet.owner = builder.owner
		fleet.ships = self.ships
		fleet.insert()
		fleet.name = self.name
		fleet.save()

		message = Message()
		message.slot = -1
		message.bid = builder.owner
		message.subject = "Fleet built"
		
		message.body = """\
A new fleet (%s) has been built and is orbiting %s.
It consists of:
""" % (fleet.name, builder.name)

		for type, number in fleet.ships.items():
			if number > 1:
				message.body += "%s %ss" % (number, Fleet.ship_types[type])
			else:
				message.body += "%s %s" % (number, Fleet.ship_types[type])

		message.insert()

		self.remove()
Exemplo n.º 10
0
	def do(self):
		builder = Object(self.oid)

		# FIXME: Check that this is a planet
		# FIXME: Check that this planet has the headquarter resource
		if False:
			print "Could not do a build order because it was on a planet headquaters. (This should not happen.)"
			self.remove()

		# Check that there are enough components to build this ship...
			
		# Build new fleet object
		fleet = Object(type='tp.server.rules.minisec.objects.Fleet')

		# Check if there is a design which matches this amount of components. If not create it...

		# Type Fleet
		fleet.parent = builder.id
		fleet.posx = builder.posx
		fleet.posy = builder.posy
		fleet.posz = builder.posz
		fleet.size = 1
		fleet.owner = builder.owner
		fleet.ships = self.ships
		fleet.insert()
		fleet.name = self.name
		fleet.save()

		message = Message()
		message.slot = -1
		message.bid = builder.owner
		message.subject = "Fleet built"
		
		message.body = """\
A new ship (%s) has been built and is orbiting %s.
""" % (fleet.name, builder.name)

		message.insert()

		self.remove()
Exemplo n.º 11
0
    def initialise(self, seed=None):
        """\
		TIM Trader
		"""
        trans = dbconn.begin()
        try:
            RulesetBase.initialise(self)

            # Need to create the top level universe object...
            universe = Object(type='tp.server.rules.base.objects.Universe')
            universe.id = 0
            universe.name = "The Universe"
            universe.size = SIZE
            universe.parent = 0
            universe.posx = 0
            universe.posy = 0
            universe.turn = 0
            universe.insert()

            # Create all the resources, they consist of,
            #   - One resource for each resource specified in resources.csv
            #   - One resource for each factory specified  in prodcon.csv
            reader = csv.DictReader(
                open(os.path.join(self.files, "resources.csv"), "r"))
            for row in reader:
                if row['namesingular'] is '':
                    continue

                r = Resource()
                for name, cell in row.iteritems():
                    if cell is '':
                        continue
                    try:
                        setattr(r, name,
                                convert(getattr(Resource.table.c, name), cell))
                    except AttributeError, e:
                        # FIXME: These shouldn't really occur...
                        pass

                r.transportable = bool(row['transportable'])

                r.insert()

            import ProducersConsumers
            for factory in ProducersConsumers.loadfile(
                    os.path.join(self.files, "prodcon.csv")):
                # FIXME: Make these auto generated resources much nicer...
                # Ignore the special case factories which are also goods.
                try:
                    r = Resource(Resource.byname(factory.name))
                    r.desc += "\n"
                except NoSuch:
                    r = Resource()
                    r.namesingular = factory.name
                    r.nameplural = factory.name
                    r.desc = ""
                    r.weight = 1000
                    r.size = 1000

                r.desc += "Converts"
                for product in factory.products:
                    # FIXME: Should also display if usage of this resource is required to grow....
                    r.desc += "\n\t%s -> %s" % product

                r.products = factory.products
                r.save()

            trans.commit()
Exemplo n.º 12
0
    def populate(self, seed, system_min, system_max, planet_min, planet_max):
        """\
		--populate <game> <random seed> <min systems> <max systems> <min planets> <max planets>
		
			Populate a universe with a number of systems and planets.
			The number of systems in the universe is dictated by min/max systems.
			The number of planets per system is dictated by min/max planets.
		"""
        # Convert arguments to integers
        seed, system_min, system_max, planet_min, planet_max = (
            int(seed), int(system_min), int(system_max), int(planet_min),
            int(planet_max))

        dbconn.use(self.game)
        trans = dbconn.begin()
        try:
            RulesetBase.populate(self, seed)

            r = Resource(Resource.byname('Ship Parts Factory'))

            # FIXME: Assuming that the Universe and the Galaxy exist.
            r = random.Random()
            r.seed(seed)

            # Create the actual systems and planets.
            for i in range(0, r.randint(system_min, system_max)):
                pos = r.randint(SIZE * -1, SIZE) * 1000, r.randint(
                    SIZE * -1, SIZE) * 1000, r.randint(SIZE * -1, SIZE) * 1000

                # Add system
                system = Object(type='tp.server.rules.base.objects.System')
                system.name = "System %s" % i
                system.size = r.randint(800000, 2000000)
                system.posx = pos[0]
                system.posy = pos[1]
                system.insert()
                ReparentOne(system)
                system.save()
                print "Created system (%s) with the id: %i" % (system.name,
                                                               system.id)

                # In each system create a number of planets
                for j in range(0, r.randint(planet_min, planet_max)):
                    planet = Object(
                        type='tp.server.rules.timtrader.objects.Planet')
                    planet.name = "Planet %i in %s" % (j, system.name)
                    planet.size = r.randint(1000, 10000)
                    planet.parent = system.id
                    planet.posx = pos[0] + r.randint(1, 100) * 1000
                    planet.posy = pos[1] + r.randint(1, 100) * 1000
                    planet.insert()
                    print "Created planet (%s) with the id: %i" % (planet.name,
                                                                   planet.id)

                    # FIXME: Add minerals Iron, Uranium
                    mine = False
                    for mineral in minerals:
                        # Does this planet have this mineral
                        if r.random() * 100 > mineral.probability:
                            # Add a smattering of minerals
                            planet.resources_add(id,
                                                 r.randint(0, mineral.density),
                                                 Planet.MINEABLE)
                            mine = True

                    # Add a mine to each planet which has minerals
                    if mine:
                        planet.resources_add(Resource.byname('Mine'), 1,
                                             Planet.ACCESSABLE)

                    # FIXME: Add growing resources
                    for grow in growing:
                        if r.random() * 100 > grow.probability:
                            # Add a smattering of breeding grounds
                            planet.resources_add(Resource.byname(''), 1,
                                                 Planet.ACCESSABLE)

                            # Add a smattering of the same stocks
                            planet.resources_add(Resource.byname(''),
                                                 r.randint(0, grow.density),
                                                 Planet.MINEABLE)

                            # Add 1 fishery/slaughter house to each location

                    # FIXME: Add a other industries in random locations
                    for factory in factories:
                        pass

                    # FIXME: Add a bunch of cities
                    planet.save()

            trans.commit()
        except:
            trans.rollback()
            raise
Exemplo n.º 13
0
	def initialise(self, seed=None):
		"""\
		TIM Trader
		"""
		trans = dbconn.begin()
		try:
			RulesetBase.initialise(self)

			# Need to create the top level universe object...
			universe = Object(type='tp.server.rules.base.objects.Universe')
			universe.id     = 0
			universe.name   = "The Universe"
			universe.size   = SIZE
			universe.parent = 0
			universe.posx   = 0
			universe.posy   = 0
			universe.turn   = 0
			universe.insert()

			# Create all the resources, they consist of,
			#   - One resource for each resource specified in resources.csv
			#   - One resource for each factory specified  in prodcon.csv
			reader = csv.DictReader(open(os.path.join(self.files, "resources.csv"), "r"))
			for row in reader:
				if row['namesingular'] is '':
					continue

				r = Resource()
				for name, cell in row.iteritems():
					if cell is '':
						continue
					try:
						setattr(r, name, convert(getattr(Resource.table.c, name), cell))
					except AttributeError, e:
						# FIXME: These shouldn't really occur...
						pass

				r.transportable = bool(row['transportable'])

				r.insert()

			import ProducersConsumers
			for factory in ProducersConsumers.loadfile(os.path.join(self.files, "prodcon.csv")):
				# FIXME: Make these auto generated resources much nicer...
				# Ignore the special case factories which are also goods.
				try:
					r = Resource(Resource.byname(factory.name))
					r.desc += "\n"
				except NoSuch:
					r = Resource()
					r.namesingular = factory.name
					r.nameplural   = factory.name
					r.desc         = ""				
					r.weight = 1000
					r.size   = 1000

				r.desc  += "Converts"
				for product in factory.products:
					# FIXME: Should also display if usage of this resource is required to grow....
					r.desc += "\n\t%s -> %s" % product

				r.products = factory.products
				r.save()

			trans.commit()
Exemplo n.º 14
0
	def populate(self, seed, system_min, system_max, planet_min, planet_max):
		"""\
		--populate <game> <random seed> <min systems> <max systems> <min planets> <max planets>
		
			Populate a universe with a number of systems and planets.
			The number of systems in the universe is dictated by min/max systems.
			The number of planets per system is dictated by min/max planets.
		"""
		# Convert arguments to integers
		seed, system_min, system_max, planet_min, planet_max = (int(seed), int(system_min), int(system_max), int(planet_min), int(planet_max))

		dbconn.use(self.game)
		trans = dbconn.begin()
		try:
			RulesetBase.populate(self, seed)

			r = Resource(Resource.byname('Ship Parts Factory'))

			# FIXME: Assuming that the Universe and the Galaxy exist.
			r = random.Random()
			r.seed(seed)

			# Create the actual systems and planets.
			for i in range(0, r.randint(system_min, system_max)):
				pos = r.randint(SIZE*-1, SIZE)*1000, r.randint(SIZE*-1, SIZE)*1000, r.randint(SIZE*-1, SIZE)*1000
				
				# Add system
				system = Object(type='tp.server.rules.base.objects.System')
				system.name = "System %s" % i
				system.size = r.randint(800000, 2000000)
				system.posx = pos[0]
				system.posy = pos[1]
				system.insert()
				ReparentOne(system)
				system.save()
				print "Created system (%s) with the id: %i" % (system.name, system.id)
				
				# In each system create a number of planets
				for j in range(0, r.randint(planet_min, planet_max)):
					planet = Object(type='tp.server.rules.timtrader.objects.Planet')
					planet.name = "Planet %i in %s" % (j, system.name)
					planet.size = r.randint(1000, 10000)
					planet.parent = system.id
					planet.posx = pos[0]+r.randint(1,100)*1000
					planet.posy = pos[1]+r.randint(1,100)*1000
					planet.insert()
					print "Created planet (%s) with the id: %i" % (planet.name, planet.id)

					# FIXME: Add minerals Iron, Uranium
					mine = False
					for mineral in minerals:
						# Does this planet have this mineral
						if r.random()*100 > mineral.probability:
							# Add a smattering of minerals 
							planet.resources_add(id, r.randint(0, mineral.density), Planet.MINEABLE)
							mine = True

					# Add a mine to each planet which has minerals
					if mine:
						planet.resources_add(Resource.byname('Mine'), 1, Planet.ACCESSABLE)
						
					# FIXME: Add growing resources
					for grow in growing:
						if r.random()*100 > grow.probability:
							# Add a smattering of breeding grounds
							planet.resources_add(Resource.byname(''), 1, Planet.ACCESSABLE)
							
							# Add a smattering of the same stocks
							planet.resources_add(Resource.byname(''), r.randint(0, grow.density), Planet.MINEABLE)
						

							# Add 1 fishery/slaughter house to each location

					# FIXME: Add a other industries in random locations
					for factory in factories:
						pass

					# FIXME: Add a bunch of cities					
					planet.save()

			trans.commit()
		except:
			trans.rollback()
			raise