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 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 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()
