def reregister(self, tran, obj): # nearly identical to register, just now we know the galaxy # to add this information tu AIList log.debug("Reregistering player", obj.oid) counter = 1 while 1: try: obj.name = u'Rebel faction %d' % counter obj.login = '******' % counter # log.debug("Trying", obj.name) password = hashlib.sha1(str(random.randrange(0, 1e10))).hexdigest() tran.gameMngr.registerPlayer(obj.login, obj, obj.oid) log.debug("Player registered") tran.db[OID_UNIVERSE].players.append(obj.oid) tran.gameMngr.clientMngr.createAiAccount(None, obj.login, password, obj.name) break except CreatePlayerException: # log.debug("Name exists") counter += 1 # after succesfull registration, register it to the AI system aiList = AIList(tran.gameMngr.configDir, tran.gameMngr.gameName) aiList.add(obj.login, password, 'ais_rebel') aiList.setGalaxy(obj.login, tran.db[obj.galaxies[0]].name) # grant techs and so on self.cmd(obj).update(tran, obj)
def reset(self): # remove all AI accounts and their records in AI list aiList = AIList(self.configDir) for login in aiList.getLogins(): self.clientMngr.removeAiAccount(login) aiList.removeAll() IGEGameMngr.reset(self) # save informations self.db.checkpoint()
def backup(self, sid, basename): session = self.clientMngr.getSession(sid) if session.login != ADMIN_LOGIN: raise SecurityException('You cannot issue this command.') self.db.backup(basename) self.clientMngr.backup(basename) self.msgMngr.backup(basename) aiList = AIList(self.configDir) aiList.backup(basename) return True, None
def takeOverAIPlayer(self, sid, playerID): log.debug('Creating new player in session', sid) session = self.clientMngr.getSession(sid) log.debug('Creating new player with CID', session.cid) universe = self.db[OID_UNIVERSE] log.debug('Creating transaction') tran = Transaction(self, session.cid, session) # create player log.debug("Morphing AI player", playerID) player = self.db[playerID] if not (player.type == T_AIPLAYER and player.planets): raise GameException('No such starting position.') player.type = T_PLAYER self.cmdPool[T_PLAYER].upgrade(tran, player) self.cmdPool[T_PLAYER].update(tran, player) # remove AI player account from game and its record from the AIlist self.clientMngr.removeAiAccount(player.login) aiList = AIList(self.configDir) aiList.remove(player.login) # reregister player self.removePlayer(player.oid) player.name = session.nick player.login = session.login self.registerPlayer(player.login, player, player.oid) # reset relations player.diplomacyRels.clear() # add player to the universe universe.players.append(playerID) # make sure, there is something useable on the home planet planet = self.db[player.planets[0]] hasOutpost = False for struct in planet.slots: if struct[STRUCT_IDX_TECHID] == Tech.PRIMITIVEOUTPOST: hasOutpost = True if not hasOutpost: # find something to replace finished = False for property in ("prodSci", "prodProd", "prodBio"): for struct in planet.slots: tech = Rules.techs[struct[STRUCT_IDX_TECHID]] if getattr(tech, property) > 0: struct[STRUCT_IDX_TECHID] = Tech.PRIMITIVEOUTPOST struct[STRUCT_IDX_HP] = tech.maxHP finished = True break if finished: break if not finished: # replace last structure struct = planet.slots[-1] struct[STRUCT_IDX_TECHID] = Tech.PRIMITIVEOUTPOST struct[STRUCT_IDX_HP] = tech.maxHP # save game info self.generateGameInfo() return player.oid, None
def runAIPool(options): import copy import sys import os import time import tempfile import multiprocessing import re import copy basepath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) for item in ("libsrvr", "server/lib"): path = os.path.join(basepath, item) if os.path.exists(path): sys.path.insert(0, path) break from ai_parser import AIList games = [] if options.game: games.append(options.game) else: for filename in os.listdir(options.configDir): if re.match('ais_list\.', filename): games.append(filename.split('.')[1]) aiPool = multiprocessing.Pool(processes = options.procs) for gameName in games: aiList = AIList(options.configDir, gameName) for record in aiList.getAll(): if options.galaxies and record.galaxyName not in options.galaxies: continue optAI = copy.copy(options) optAI.configDir = os.path.join(options.configDir, 'ai_data', gameName, record.galaxyName) optAI.login = record.login optAI.password = record.password optAI.ai = record.aiType optAI.game = gameName aiPool.apply_async(runAIClient, [optAI]) aiPool.close() aiPool.join() sys.exit()
def generateAIList(self): aiList = AIList(self.configDir) aiList.removeAll() for login in self.accounts.keys(): account = self.accounts[login] if not account.isAI: continue aiList.add(login, account.passwd, account.aiType) aiList.save() log.message('AI list regenerated')
def runAIPool(options): import copy import sys import os import time import tempfile import traceback import multiprocessing import re import copy from ai_parser import AIList games = [] if options.game: games.append(options.game) else: # support for games autodetect is not implemented raise NotImplementedError aiPool = multiprocessing.Pool(processes=options.procs) results = [] for gameName in games: aiList = AIList(options.configDir) for record in aiList.getAll(): optAI = copy.copy(options) optAI.configDir = os.path.join(options.configDir, 'ai_data', gameName) optAI.login = record.login optAI.password = record.password optAI.ai = record.aiType optAI.game = gameName optAI.test = False results.append(aiPool.apply_async(runAIClient, [optAI])) aiPool.close() for result in results: try: result.get() except Exception as exc: # having pass or continue here prevents exception from being printed # What the actual hell? True aiPool.join() sys.exit()
def runAIPool(options): import copy import sys import os import time import tempfile import traceback import multiprocessing import re import copy from ai_parser import AIList games = [] if options.game: games.append(options.game) else: # support for games autodetect is not implemented raise NotImplementedError aiPool = multiprocessing.Pool(processes = options.procs) results = [] for gameName in games: aiList = AIList(options.configDir) for record in aiList.getAll(): optAI = copy.copy(options) optAI.configDir = os.path.join(options.configDir, 'ai_data', gameName) optAI.login = record.login optAI.password = record.password optAI.ai = record.aiType optAI.game = gameName optAI.test = False results.append(aiPool.apply_async(runAIClient, [optAI])) aiPool.close() for result in results: try: result.get() except Exception as exc: # having pass or continue here prevents exception from being printed # What the actual hell? True aiPool.join() sys.exit()
def takeOverPirate(self, sid, playerID, vipPassword): # limit this now only to the qark session = self.clientMngr.getSession(sid) if vipPassword != self.config.vip.password: raise SecurityException('You cannot issue this command.') # log.debug('Creating pirate in session', sid) session = self.clientMngr.getSession(sid) log.debug('Creating pirate with CID', session.cid) universe = self.db[OID_UNIVERSE] log.debug('Creating transaction') tran = Transaction(self, session.cid, session) # create player #log.debug("Morphing Pirate player", playerID) player = self.db[playerID] log.debug("Player type", player.type) if player.type != T_AIPIRPLAYER: raise GameException('No such starting position.') player.type = T_PIRPLAYER self.cmdPool[T_PIRPLAYER].upgrade(tran, player) self.cmdPool[T_PIRPLAYER].update(tran, player) # remove AI player account from game and its record from the AIlist self.clientMngr.removeAiAccount(player.login) aiList = AIList(self.configDir) aiList.remove(player.login) # reregister player self.removePlayer(player.oid) player.fullName = "Pirate %s" % session.nick player.name = session.nick player.login = session.login self.registerPlayer(player.login, player, player.oid) # add player to the universe universe.players.append(playerID) # initial scan scannerPwr = Rules.techs[9002].scannerPwr for planetID in player.planets: planet = self.db[planetID] system = self.db[planet.compOf] system.scannerPwrs[player.oid] = scannerPwr log.debug('Processing scan phase') galaxy = tran.db[player.galaxies[0]] self.cmdPool[T_GALAXY].processSCAN2Phase(tran, galaxy, None) # save game info self.generateGameInfo() return player.oid, None
def register(self, tran, obj): log.debug("Registering player", obj.oid) counter = 1 while 1: try: obj.name = u'Mutant faction %d' % counter obj.login = '******' % counter password = hashlib.sha1(str(random.randrange(0, 1e10))).hexdigest() tran.gameMngr.registerPlayer(obj.login, obj, obj.oid) tran.db[OID_UNIVERSE].players.append(obj.oid) tran.gameMngr.clientMngr.createAiAccount(None, obj.login, password, obj.name) break except CreatePlayerException: counter += 1 # after succesfull registration, register it to the AI system aiList = AIList(tran.gameMngr.configDir) aiList.add(obj.login, password, 'ais_mutant') # grant techs and so on self.cmd(obj).update(tran, obj)
def delete(self, tran, obj): # check whether it is AI or normal player if obj.type in AI_PLAYER_TYPES: # remove AI account from the game, and record in the AI list log.debug("Removing AI account from the AI list", obj.oid) tran.gameMngr.clientMngr.removeAiAccount(obj.login) aiList = AIList(tran.gameMngr.configDir) aiList.remove(obj.login) log.debug("Deleting player", obj.oid) # delete relations for playerID in tran.db[OID_UNIVERSE].players: player = tran.db[playerID] self.cmd(player).deleteDiplomacyWith(tran, player, obj.oid) # delete fleets for fleetID in obj.fleets: fleet = tran.db[fleetID] self.cmd(fleet).disbandFleet(tran, fleet) try: tran.gameMngr.removePlayer(obj.oid) except Exception: log.warning("Cannot remove player")
def delete(self, tran, obj): log.debug(obj.oid, "GALAXY - delete") universe = tran.db[OID_UNIVERSE] aiList = AIList(tran.gameMngr.configDir, tran.gameMngr.gameName) aiList.finishGalaxy(obj.name) # delete systems and planets for systemID in obj.systems: log.debug("Deleting system", systemID) system = tran.db[systemID] log.debug("-- planets", system.planets) log.debug("-- fleets", system.fleets, system.closeFleets) for planetID in system.planets[:]: planet = tran.db[planetID] self.cmd(planet).changeOwner(tran, planet, OID_NONE, force = 1) del tran.db[planetID] for fleetID in system.closeFleets[:]: fleet = tran.db[fleetID] # this will modify system fleet and closeFleets attrs self.cmd(fleet).disbandFleet(tran, fleet) del tran.db[systemID] # delete all remaining fleets for playerID in universe.players[:]: player = tran.db[playerID] if obj.oid not in player.galaxies: continue if player.fleets: log.debug("Player %d has still fleets" % playerID, player.name, player.fleets) for fleetID in player.fleets: fleet = tran.db[fleetID] log.debug("Fleet NOT DELETED:", fleet) if player.planets: log.debug("Player %d has still planets" % playerID, player.name, player.planets) self.cmd(player).delete(tran, player) # remove this galaxy from the list of the galaxies tran.db[OID_UNIVERSE].galaxies.remove(obj.oid) del tran.db[obj.oid] return 1
def runServer(options): import os import shutil import sys import time # setup system path baseDir = os.path.abspath(os.path.dirname(__file__)) sys.path.insert(0, os.path.join(baseDir, "lib")) sys.path.insert(0, os.path.join(baseDir, "..", "client-ai")) sys.path.insert(0, os.path.join(baseDir, "data")) import os, atexit from ai_parser import AIList #configure gc #import gc #gc.set_debug(gc.DEBUG_STATS | gc.DEBUG_COLLECTABLE | gc.DEBUG_UNCOLLECTABLE | # gc.DEBUG_INSTANCES | gc.DEBUG_OBJECTS) # legacy logger from ige import log log.setMessageLog(os.path.join(options.configDir,'logs/messages.log')) log.setErrorLog(os.path.join(options.configDir,'logs/errors.log')) import ige.version log.message("Outer Space %s" % ige.version.versionString) #~ # standard logger #~ import logging, logging.handlers #~ log = logging.getLogger() #~ log.setLevel(logging.DEBUG) #~ # file handler #~ h = logging.handlers.RotatingFileHandler(os.path.join(options.configDir,'log/server.log'), 'a', 16 * 1024 * 1024, 5) #~ h.setLevel(logging.INFO) #~ h.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s')) #~ log.addHandler(h) #~ # stdout handler (TODO: disable in productin server) #~ h = logging.StreamHandler(sys.stdout) #~ h.setLevel(logging.DEBUG) #~ h.setFormatter(logging.Formatter('%(created)d %(levelname)-5s %(name)-8s %(message)s')) #~ log.addHandler(h) # record my pid pidFd = os.open(os.path.join(options.configDir,"server.pid"), os.O_CREAT | os.O_EXCL | os.O_WRONLY) os.write(pidFd, str(os.getpid())) # TODO: check if server.pid points to the running process game = None msgMngr = None clientMngr = None issueMngr = None # define and register exit function def _save(): # shut down game try: if game: log.message('Shutting down game...') game.shutdown() if msgMngr: log.message('Shutting down message manager...') msgMngr.shutdown() if clientMngr: log.message('Shutting down client manager...') clientMngr.shutdown() if issueMngr: log.message('Shutting down issue manager...') issueMngr.shutdown() except: log.exception("Shutdown of the server failed") log.message('Shutted down') log.message("Cleaning up...") def _cleanup(pidFd): _save() # delete my pid os.close(pidFd) os.remove(os.path.join(options.configDir,"server.pid")) cleanup = _cleanup atexit.register(cleanup, pidFd) #~fh = open(pidFilename, 'w') #~print >> fh, os.getpid() #~fh.close() # startup game log.debug('Importing IGE modules...') # set runtime mode ige.setRuntimeMode(options.mode) import ige.RPCServer as server import ige from ige.ClientMngr import ClientMngr from ige.MsgMngr import MsgMngr from ige.IssueMngr import IssueMngr from ige.ospace.GameMngr import GameMngr # read configuration from ige.Config import Config log.message("Reading configuration from", os.path.join(options.configDir, options.configFilename)) config = Config(os.path.join(options.configDir, options.configFilename)) gameName = 'Alpha' # open database if config.server.dbbackend == "metakit": # Legacy database backend log.message("Using metakit database backend") from ige.MetakitDatabase import Database, DatabaseString else: log.message("Using sqlite3 dabase backend") from ige.SQLiteDatabase import Database, DatabaseString # set type of generated galaxies if not config.server.newgalaxytype: config.server.newgalaxytype = 'Circle42P' log.debug("Creating databases...") gameDB = Database(os.path.join(options.configDir,"db_data"), "game_%s" % gameName, cache = 15000) clientDB = DatabaseString(os.path.join(options.configDir,"db_data"), "accounts", cache = 100) msgDB = DatabaseString(os.path.join(options.configDir,"db_data"), "messages", cache = 1000) if options.restore: gameDB.restore("%s-game_%s.osbackup" % (options.restore, gameName)) clientDB.restore("%s-accounts.osbackup" % options.restore) # TODO: remove afer fix of the message database # the following code imports to the message database only valid entries # and forces mailbox scan incl = [1] incl.extend(gameDB[1].galaxies) incl.extend(gameDB[1].players) def include(k, l = incl): for i in l: if k.startswith("%s-%d-" % (gameName, i)) or (k == "%s-%d" % (gameName, i)): return True return False msgDB.restore("%s-messages.osbackup" % options.restore, include = include) aiList = AIList(options.configDir, options.gameName) aiList.restore("%s-ais.osbackup" % options.restore) metaserver = None if config.wordpressmetaserver.url: from ige.MetaServer import WordpressMetaServer metaserver = WordpressMetaServer(config.wordpressmetaserver.url) assert config.server.authmethod in ("plain", "rsa"), "Only plain and rsa authmethod supported for metaservers" # initialize game log.message('Initializing game \'%s\'...' % gameName) log.debug("Initializing issue manager") issueMngr = IssueMngr() log.debug("Initializing client manager") clientMngr = ClientMngr(clientDB, config.server.authmethod, options.configDir, metaserver) log.debug("Initializing message manager") msgMngr = MsgMngr(msgDB) log.debug("Initializing game manager") game = GameMngr(gameName, config, clientMngr, msgMngr, gameDB, options.configDir) # either forced reset, or uninitialized server if options.reset or not gameDB.keys(): # reset game log.message('Resetting game \'%s\'...' % gameName) game.reset() # remote web directory should be populated for the first time # with contents of server/website # but then, no overwrite should happen, as we want customization # to be painless if not os.path.exists(os.path.join(options.configDir, 'website')): log.debug("Populating website directory") actual_dir = os.path.dirname(os.path.realpath(__file__)) shutil.copytree(os.path.join(actual_dir, 'website'), os.path.join(options.configDir, 'website')) # normal operations game.init() if options.upgrade: game.upgrade() msgMngr.upgrade() game.start() server.init(clientMngr) server.register(game) server.xmlrpcPublish('clientmngr', clientMngr) server.xmlrpcPublish('issuemngr', issueMngr) log.message('Initialized. Starting server...') try: import psyco psyco.full() log.message("Using psyco with full acceleration") except ImportError: log.message("NOT using psyco") server.start(options.configDir)
if options.restore: gameDB.restore("%s-game_Alpha.osbackup" % options.restore) clientDB.restore("%s-accounts.osbackup" % options.restore) # TODO: remove afer fix of the message database # the following code imports to the message database only valid entries # and forces mailbox scan incl = [1] incl.extend(gameDB[1].galaxies) incl.extend(gameDB[1].players) def include(k, l = incl): for i in l: if k.startswith("Alpha-%d-" % i) or (k == "Alpha-%d" % i): return True return False msgDB.restore("%s-messages.osbackup" % options.restore, include = include) aiList = AIList(options.configDir) aiList.restore("%s-ais.osbackup" % options.restore) # initialize game log.message('Initializing game \'%s\'...' % gameName) log.debug("Initializing issue manager") issueMngr = IssueMngr() log.debug("Initializing client manager") clientMngr = ClientMngr(clientDB, options.configDir) log.debug("Initializing message manager") msgMngr = MsgMngr(msgDB) log.debug("Initializing game manager") game = GameMngr(gameName, config, clientMngr, msgMngr, gameDB, options.configDir)
def enableTime(self, tran, obj, force = 0, deleteSP = 0, enable = 1): log.debug('IGalaxy', 'Checking for time...') if not force: if obj.timeEnabled: return canRun = 0 # there must be at least 1/2 positions already assigned #if len(obj.startingPos) <= obj.numOfStartPos / 2 and obj.creationTime < time.time() - 2 * 24 * 3600: # log.debug("Half galaxy populated", len(obj.startingPos), obj.numOfStartPos) # canRun = 1 # at least two days must pass from creation if not obj.startingPos and not obj.bookedCreation: log.debug("All positions taken, starting galaxy") canRun = 1 if obj.creationTime < time.time() - 2 * 24 * 3600: log.debug("Two days passed", obj.creationTime, time.time() - 2 * 24 * 3600) canRun = 1 if not canRun: return 0 # spawn rebel player on all vacant starting positions for positionID in copy.copy(obj.startingPos): obj.startingPos.remove(positionID) # create new player log.debug("Creating new Rebel player", T_AIPLAYER) player = self.new(T_AIPLAYER) self.cmd(player).register(tran, player) player.galaxies.append(obj.oid) playerID = player.oid # finish AI list aiList = AIList(tran.gameMngr.configDir, tran.gameMngr.gameName) aiList.setGalaxy(player.login, obj.name) # TODO tweak more planet's attrs planet = tran.db[positionID] # Grant starting technologies (at medium improvement) for techID in Rules.techs.keys(): if Rules.techs[techID].isStarting: player.techs[techID] = (Rules.techBaseImprovement + Rules.techMaxImprovement) / 2 self.cmd(planet).changeOwner(tran, planet, playerID, 1) planet.slots = [ Utils.newStructure(tran, Tech.PWRPLANTNUK1, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.FARM1, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.FARM1, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.FARM1, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.ANCFACTORY, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.ANCFACTORY, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.ANCRESLAB, playerID, STRUCT_STATUS_ON), Utils.newStructure(tran, Tech.REPAIR1, playerID, STRUCT_STATUS_ON), ] planet.storPop = Rules.startingPopulation planet.storBio = Rules.startingBio planet.storEn = Rules.startingEn planet.scannerPwr = Rules.startingScannerPwr planet.morale = Rules.maxMorale # fleet # add basic ships designs tempTechs = [Tech.FTLENG1, Tech.SCOCKPIT1, Tech.SCANNERMOD1, Tech.CANNON1, Tech.CONBOMB1, Tech.SMALLHULL1, Tech.MEDIUMHULL2, Tech.COLONYMOD2] for techID in tempTechs: player.techs[techID] = 1 dummy, scoutID = tran.gameMngr.cmdPool[T_AIPLAYER].addShipDesign(tran, player, "Scout", Tech.SMALLHULL1, {Tech.FTLENG1:3, Tech.SCOCKPIT1:1, Tech.SCANNERMOD1:1}) dummy, fighterID = tran.gameMngr.cmdPool[T_AIPLAYER].addShipDesign(tran, player, "Fighter", Tech.SMALLHULL1, {Tech.FTLENG1:3, Tech.SCOCKPIT1:1, Tech.CANNON1:1}) dummy, bomberID = tran.gameMngr.cmdPool[T_AIPLAYER].addShipDesign(tran, player, "Bomber", Tech.SMALLHULL1, {Tech.FTLENG1:3, Tech.SCOCKPIT1:1, Tech.CONBOMB1:1}) dummy, colonyID = tran.gameMngr.cmdPool[T_AIPLAYER].addShipDesign(tran, player, "Colony Ship", Tech.MEDIUMHULL2, {Tech.FTLENG1:4, Tech.SCOCKPIT1:1, Tech.COLONYMOD2:1}) for techID in tempTechs: del player.techs[techID] # add small fleet log.debug('Creating fleet') system = tran.db[planet.compOf] fleet = tran.gameMngr.cmdPool[T_FLEET].new(T_FLEET) tran.db.create(fleet) log.debug('Creating fleet - created', fleet.oid) tran.gameMngr.cmdPool[T_FLEET].create(tran, fleet, system, playerID) log.debug('Creating fleet - addShips') tran.gameMngr.cmdPool[T_FLEET].addNewShip(tran, fleet, scoutID) tran.gameMngr.cmdPool[T_FLEET].addNewShip(tran, fleet, scoutID) tran.gameMngr.cmdPool[T_FLEET].addNewShip(tran, fleet, fighterID) tran.gameMngr.cmdPool[T_FLEET].addNewShip(tran, fleet, fighterID) tran.gameMngr.cmdPool[T_FLEET].addNewShip(tran, fleet, colonyID) system.scannerPwrs[playerID] = Rules.startingScannerPwr # do scanner evaluation because of all new players self.cmd(obj).processSCAN2Phase(tran, obj, None) # add player to universe # log.debug('Adding player to universe') # universe = tran.db[OID_UNIVERSE] # universe.players.append(playerID) # ok, enable time log.message('IGalaxy', 'Enabling time for', obj.oid) obj.timeEnabled = enable # close galaxy if deleteSP: obj.startingPos = [] # load new galaxy # TODO # enable time for players for systemID in obj.systems: system = tran.db[systemID] for planetID in system.planets: planet = tran.db[planetID] if planet.owner != OID_NONE: player = tran.db[planet.owner] if player.timeEnabled != enable: player.timeEnabled = enable player.lastLogin = time.time() if enable: Utils.sendMessage(tran, player, MSG_ENABLED_TIME, player.oid, None)
def setupEnvironment(self, tran, obj): # check required players universe = tran.db[OID_UNIVERSE] players = {} for playerType in (T_AIRENPLAYER, T_AIMUTPLAYER, T_AIPIRPLAYER, T_AIEDENPLAYER): found = 0 for playerID in universe.players: player = tran.db[playerID] if obj.oid in player.galaxies and player.type == playerType: players[playerType] = player found = 1 break if found: continue # create new player log.debug("Creating new player", playerType) player = self.new(playerType) self.cmd(player).register(tran, player) aiList = AIList(tran.gameMngr.configDir, tran.gameMngr.gameName) aiList.setGalaxy(player.login, obj.name) player.galaxies.append(obj.oid) players[playerType] = player # great we have all players - scan planets for systemID in obj.systems: system = tran.db[systemID] for planetID in system.planets: planet = tran.db[planetID] # renegades if planet.plStratRes in (SR_TL1A, SR_TL1B) and planet.owner == OID_NONE: # populate planet log.debug("Adding renegades", planetID) self.cmd(planet).changeOwner(tran, planet, players[T_AIRENPLAYER].oid, 1) planet.slots.append(Utils.newStructure(tran, Rules.Tech.RENEGADEBASE, planet.owner)) planet.storPop = 3000 # pirates if planet.plStratRes in (SR_TL3A, SR_TL3B, SR_TL3C) and planet.owner == OID_NONE: # populate planet log.debug("Adding pirates", planetID) self.cmd(planet).changeOwner(tran, planet, players[T_AIPIRPLAYER].oid, 1) planet.slots.append(Utils.newStructure(tran, Rules.Tech.PIRATEBASE, planet.owner)) planet.storPop = 5000 if planet.plSlots > 1: planet.slots.append(Utils.newStructure(tran, Rules.Tech.PIRATEDEN, planet.owner)) planet.storPop += 1000 # EDEN if planet.plStratRes in (SR_TL5A, SR_TL5B, SR_TL5C) and planet.owner == OID_NONE: # populate planet log.debug("Adding EDEN", planetID) self.cmd(planet).changeOwner(tran, planet, players[T_AIEDENPLAYER].oid, 1) if planet.plSlots < 2: planet.plSlots = 2 if planet.plMaxSlots < 2: planet.plMaxSlots = 2 if planet.plDiameter < 2000: planet.plDiameter = 2000 planet.slots.append(Utils.newStructure(tran, Rules.Tech.EDENBASE, planet.owner)) planet.slots.append(Utils.newStructure(tran, Rules.Tech.EDENSTATION, planet.owner)) planet.storPop = 3000 # mutants if planet.plDisease != 0 and planet.owner == OID_NONE: # populate planet log.debug("Adding mutants", planetID) self.cmd(planet).changeOwner(tran, planet, players[T_AIMUTPLAYER].oid, 1) planet.slots.append(Utils.newStructure(tran, Rules.Tech.MUTANTBASE, planet.owner)) planet.storPop = 3000
metavar = "DIRECTORY", default = "var", help = "Override default configuration directory", ) parser.add_option("", "--server", dest = "server", metavar = "HOSTNAME:PORT", default = "localhost:9080", help = "Outer Space server location" ) parser.add_option("", "--procs", dest = "procs", metavar = "PROCS", default = "1", help = "Maximum number of concurrent processes" ) options, args = parser.parse_args() if args: parser.error("No additional arguments are supported") aiList = AIList(options.configDir) procs = [] procQueue = ProcQueue(int(options.procs)) for login, (password, ais, galaxy) in aiList.getAll(): args = shlex.split('python ../client-ai/ai_osc.py --configdir=%s --server=%s --login=%s --password=%s --ai=%s' %\ (os.path.join(options.configDir, 'ai_data', galaxy), options.server, login, password, ais)) procQueue.addProc(args) # os.system('python ../client-ai/ai_osc.py --configdir=%s --server=%s --login=%s --password=%s --ai=%s' %\ # (options.configDir, options.server, login, password, ais)) procQueue.waitForEnd() sys.exit()