ptkei-1.12/src/CenWin.py0100600000076500007650000006157206777245476014155 0ustar kevinkevin"""Maintains graphical censor window.""" # Copyright (C) 1998-1999 Kevin O'Connor # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import Tkinter import string import types import Tk_List import empDb import empSector import MapWin ## def gridClear(win): ## win['height'] = win.winfo_reqheight() ## win['width'] = win.winfo_reqwidth() ## win.grid_propagate(0) ## def packClear(win): ## def after_f(win=win): ## h, w = win.winfo_reqheight(), win.winfo_reqwidth() ## win.pack_propagate(0) ## win['height'], win['width'] = h, w ## win.after_idle(after_f) ########################################################################### ############################# Censor window ############################# def enterLabel(label): label.OldRelief = label['relief'] label['relief'] = 'groove' def leaveLabel(label): if hasattr(label, 'OldRelief'): label['relief'] = label.OldRelief del label.OldRelief ## label['relief'] = 'sunken' def bindLabel(label): label.bind('', (lambda e, label=label: enterLabel(label))) label.bind('', (lambda e, label=label: leaveLabel(label))) class LabPair(Tkinter.Frame): """Create a label/value pair for HDL with description LABEL.""" def __init__(self, master, deflist, name, **kw): # label, command, hide, default self.name = name self.default = kw.get('default') self.hide = kw.get('hide') label = kw.get('label', string.upper(name[:1]) + name[1:]) self.label = Tkinter.Label(master, name="label", text=label, width=7, anchor='ne') self.label.pack(side='top', expand=1, fill='both') self.value = Tkinter.Label(master, name="value", ## relief='sunken', anchor='ne') anchor='ne') self.value.pack(side='top', expand=1, fill='both') try: self.value.bind('', (lambda e, c=kw['command'], n=name: c(n))) bindLabel(self.value) except KeyError: pass self.value.bind('', (lambda e, self=self: viewer.cen.EditField(self.name))) deflist[name] = self.update def update(self, val, db): if callable(self.default): val = self.default(val, db) elif val == self.default: val = "" if ((callable(self.hide) and self.hide(val, db)) or val == self.hide): self.label.pack_forget() self.value.pack_forget() elif ((callable(self.hide) and self.hide(self.value['text'])) or self.value['text'] == str(self.hide)): self.label.pack(expand=1, fill='both') self.value.pack(expand=1, fill='both') self.value['text'] = val class LabPairIdx: """Same as LabPair, but take two values and create an x/y index.""" def __init__(self, master, deflist, name, **kw): # takes label, command, hide as possible parameters: self.default = kw.get('default') self.hide = kw.get('hide') label = kw.get('label', string.upper(name[:1]) + name[1:]) self.coord = ["", ""] self.label = Tkinter.Label(master, name="label", text=label, width=7, anchor='ne') self.value = Tkinter.Label(master, name="value", ## width=4, relief='sunken', anchor='ne') width=4, anchor='ne') self.label.pack(side='top', expand=1, fill='both') self.value.pack(side='top', expand=1, fill='both') if kw.get('command') is not None: self.value.bind('', (lambda e, c=kw['command'], n=name: c(n))) bindLabel(self.value) self.value.bind('<3>', self.goSect) deflist[name+"x"] = (lambda val, db, self=self: self.update(0, val, db)) deflist[name+"y"] = (lambda val, db, self=self: self.update(1, val, db)) def update(self, pos, val, db): self.coord[pos] = val val = "%s,%s" % (self.coord[0], self.coord[1]) if callable(self.default): val = self.default(val, db) elif val == self.default or val == ",": val = "" if ((callable(self.hide) and self.hide(val, db)) or val == self.hide): self.label.pack_forget() self.value.pack_forget() elif ((callable(self.hide) and self.hide(self.value['text'])) or self.value['text'] == str(self.hide)): self.label.pack(expand=1, fill='both') self.value.pack(expand=1, fill='both') self.value['text'] = val def goSect(self, event): try: x, y = self.coord viewer.cen.SetSect((x, x, y, y)) except ValueError: pass def update(win, val, db): """Update a commodity attribute label.""" if val == 0 or val == '.': val = "" win['text'] = val class ComdQuad: """Create 4 fields for a commodity.""" def __init__(self, master, deflist, comd, vhdl=None, dhdl=None, chdl=None, ahdl=None): frame = Tkinter.Frame(master, name=comd, class_="Commodity") frame.pack(side='top') f = comd[0] label = Tkinter.Label(frame, name="label", text=string.upper(f)+comd[1:], width=4, anchor='ne') label.pack(side='left') for i in ((comd, 4, vhdl, 'value'), (f+"_dist", 4, dhdl, 'thresh'), (f+"_cut", 4, chdl, 'cutoff'), (f+"_del", 1, ahdl, 'deliver')): tmp = Tkinter.Label(frame, name=i[3], width=i[1], relief='sunken', anchor='ne') tmp.pack(side='left') if i[2]: tmp.bind('', i[2]) bindLabel(tmp) deflist[i[0]] = (lambda val, db, u=update, t=tmp: u(t, val, db)) def DoWinList(rframe, hookList, lablist): """Create a frame of label/value pairs from a list description.""" printSeperator = 0 row = col = 0 for i in lablist: if not i: # make sure empty rows still take space. rframe.grid_rowconfigure(row, minsize='1c') row = row + 1 printSeperator = 0 continue if printSeperator: Tkinter.Frame(rframe, borderwidth=2, relief='raised', height=2 ).grid(row=row, column=0, columnspan=5, sticky='we') row = row + 1 for j in i: if j: if j[0] is LabPairIdx: name=j[1]+"sect" else: name=j[1] tmp = Tkinter.Frame(rframe, name=name, class_="Resources") ## tmp = Tkinter.Frame(rframe, class_="Resources") tmp.grid(column=col, row=row) if type(j[-1]) == types.DictType: apply(j[0], (tmp, hookList)+j[1:-1], j[-1]) else: apply(j[0], (tmp, hookList)+j[1:]) ## packClear(tmp) col = col + 1 row = row + 1 col = 0 printSeperator = 1 def translateOwner(val, db): """Given an owner id, return a name/id.""" if val == empDb.CN_OWNED: return "" return empDb.megaDB['countries'].getName(val)[:7] def translateDist(val, db): """Return a dist sector if it differs from the current sector.""" if val == ",": return "" sect = "%s,%s" % (db.get('x'), db.get('y')) if val == sect: return "" return val class cenWin: """Censor Window""" class SectorCensus: """Subwindow in the censor window that displays sector resources.""" def __init__(self, master): self.key = (0, 0) self.db = 'SECTOR' self.name = 'sector' # Sector resources rframe = Tkinter.Frame(master, name="resources", class_="SubCensor") rframe.pack(side='top') self.Rlist = {} # x y des sdes eff mob * off min gold fert ocontent uran work # avail terr civ mil uw food shell gun pet iron dust bar oil # lcm hcm rad u_del f_del s_del g_del p_del i_del d_del b_del # o_del l_del h_del r_del u_cut f_cut s_cut g_cut p_cut i_cut # d_cut b_cut o_cut l_cut h_cut r_cut dist_x dist_y c_dist # m_dist u_dist f_dist s_dist g_dist p_dist i_dist d_dist # b_dist o_dist l_dist h_dist r_dist road rail defense fallout # coast c_del m_del c_cut m_cut DoWinList(rframe, self.Rlist, ( ((LabPairIdx, "", {'label':"Sector"}), (LabPair, "owner", { 'default':translateOwner, 'hide':""}), (LabPair, "oldown", { 'label':"OldOwn", 'default':(lambda val, db: (val != db.get('owner')) and empDb.megaDB['countries'].getName(val)[:7] or ""), 'hide':""}), (LabPair, "sdes", { 'label':"NewDes", 'command':self.SetDes, 'default':"_", 'hide':""}), (LabPair, "des", {'command':self.SetDes})), ((LabPair, "eff"), (LabPair, "mob"), (LabPair, "avail"), (LabPair, "work"), (LabPair, "off", { 'label':"Stop", 'default':0, 'command': self.toggleStart})), ((LabPair, "terr", {'command':self.SetTerr}), (LabPair, "coast"), (LabPair, "fallout", {'default':0, 'hide':""})), ((LabPair, "min"), (LabPair, "gold"), (LabPair, "fert"), (LabPair, "ocontent", {'label':"Oil"}), (LabPair, "uran")), ((LabPair, "road", {'command': (lambda comd, self=self: viewer.queryCommand( "Improve road of sector %s,%s to ?" % self.key, "eval %s,%s improve road [sect] [%%s-road]" % self.key, "rdbe", "rdbPe"))}), (LabPair, "rail", {'command': (lambda comd, self=self: viewer.queryCommand( "Improve rail of sector %s,%s to ?" % self.key, "eval %s,%s improve rail [sect] [%%s-rail]" % self.key, "rdbe", "rdbPe"))}), (LabPair, "defense", {'command': (lambda comd, self=self: viewer.queryCommand( "Improve defense of sector %s,%s to ?" % self.key, "eval %s,%s improve def [sect] [%%s-dfense]" % self.key, "rdbe", "rdbPe"))}), (), (LabPairIdx, "dist_", {'label':"Dist", 'default':translateDist, 'command':self.SetDist})), (), )) self.predictVar = Tkinter.StringVar() predict = Tkinter.Label(master, height=1, width=1, anchor='nw', justify='left', relief='flat', textvariable=self.predictVar) predict.pack(side='bottom', fill='both', expand=1) viewer.Balloon.bind(predict, "Guesses about the next update") cframe = Tkinter.Frame(master, name="commodities") cframe.pack(side='left', anchor='ne') lcframe = Tkinter.Frame(cframe, name="label") lcframe.pack() Tkinter.Label(lcframe, name="label", text="Type", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="value", text="Qty", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="thresh", text="Thr", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="cutoff", text="Del", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="direction", width=1, anchor='w').pack(side='left') for i in ("civ", "mil", "uw", "food", "shell", "gun", "pet"): ComdQuad(cframe, self.Rlist, i, (lambda e, h=self.SetCurrent, i=i: h(i)), (lambda e, h=self.SetThresh, i=i: h(i)), (lambda e, h=self.SetDel, i=i: h(i)), (lambda e, h=self.SetDir, i=i: h(i))) cframe = Tkinter.Frame(master, name="commodities2") cframe.pack(side='left', anchor='ne') lcframe = Tkinter.Frame(cframe, name="label") lcframe.pack() Tkinter.Label(lcframe, name="label", text="Type", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="value", text="Qty", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="thresh", text="Thr", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="cutoff", text="Del", width=4, anchor='w').pack(side='left') Tkinter.Label(lcframe, name="direction", width=1, anchor='w').pack(side='left') for i in ("iron", "dust", "bar", "oil", "lcm", "hcm", "rad"): ComdQuad(cframe, self.Rlist, i, (lambda e, h=self.SetCurrent, i=i: h(i)), (lambda e, h=self.SetThresh, i=i: h(i)), (lambda e, h=self.SetDel, i=i: h(i)), (lambda e, h=self.SetDir, i=i: h(i))) def SetSect(self, range): self.key = (range[0], range[2]) viewer.markSectors([(range[0], range[2])]) viewer.map.see((range[0], range[2])) self.redraw(1) def getKey(self): return "%s,%s"%self.key def EditField(self, name): if viewer.stsList: viewer.Root.bell() return def f(val, db=self.db, key=self.key, name=name): if not val: return db = empDb.megaDB[db] t = {} for i in range(len(key)): t[db.primary_keytype[i]] = key[i] t[name] = val db.update(t) viewer.redraw(0) viewer.bufferStatus( "Manually edit %s value at %s,%s to ?" % ((name,) + self.key), f) def SetDist(self, name): viewer.queryCommand( "New dist sector for %s,%s ?" % self.key, "dist %s,%s %%s" % self.key, "rdbe") def SetDes(self, name): viewer.queryCommand( "New designation for %s,%s ?" % self.key, "des %s,%s %%s" % self.key, "rdbe") def toggleStart(self, name): if empDb.megaDB['SECTOR'][self.key].get('off') == 0: cmd = "stop" else: cmd = "start" viewer.ioq.Send(cmd + " %s,%s; rdbe" % self.key) def SetTerr(self, name): viewer.queryCommand( "New territory value for %s,%s ?" % self.key, "territory %s,%s %%s" % self.key, "rdbe") def SetCurrent(self, comd): DB = empDb.megaDB['SECTOR'][self.key] dx = DB.get('dist_x'); dy = DB.get('dist_y') if dx is not None and dy is not None and (dx, dy) != self.key: dist = (dx, dy) else: dist = None MapWin.MoveMode(viewer.map, comd, self.key, None, dist) ## viewer.queryCommand( ## "Resupply %s commodity at %s,%s to?" % ((comd,) + self.key), ## (("eval %s,%s move %s [%%s>%s and dist+' '+`%%s-%s`+' '+sect" ## +" or sect+' '+`%s-%%s`+' '+dist]") ## % (self.key + (comd, comd, comd, comd))), ## "rdbe", "rdbPe") def SetThresh(self, comd): viewer.queryCommand( "New %s threshold for %s,%s ?" % ((comd,) + self.key), "thresh %s %s,%s %%s" % ((comd,) + self.key), "rdbe") def SetDel(self, comd): viewer.queryCommand( "New %s cutoff for %s,%s ?" % ((comd,) + self.key), "deli %s %s,%s +%%s" % ((comd,) + self.key), "rdbe") def SetDir(self, comd): viewer.queryCommand( "New %s direction for %s,%s ?" % ((comd,) + self.key), "eval %s,%s deli %s [sect] [%s] %%s" % ( self.key + (comd, comd[0]+'_del')), "rdbe", "rdbPe") def redraw(self, total): if not total and not empDb.updateDB[self.db].has_key(self.key): # Nothing has been updated return DB = empDb.megaDB[self.db] DBs = DB.get(self.key, {}) for i, j in self.Rlist.items(): j(DBs.get(i, ""), DBs) self.predictVar.set(empSector.sectorPredictions(DBs)) class UnitCensus: """Generic class that Land/Ship/Plane classes descend from.""" def doStartup(self, master): self.key = 0 self.sect = () sframe = Tkinter.Frame(master, name=self.name, class_="SubCensor") sframe.pack(side='bottom', fill='both', expand=1) scrollY = Tkinter.Scrollbar(sframe, name="scrollY") scrollY.pack(side='right', fill='y') self.List = Tk_List.MyListbox(sframe, name="list", height=4, command=self.SetId, yscrollcommand=scrollY.set) self.List.pack(side='left', fill='both', expand=1) scrollY['command'] = self.List.yview rframe = Tkinter.Frame(master, name="resources") rframe.pack(side='top') self.Rlist = {} DoWinList(rframe, self.Rlist, self.winList) def redrawWin(self, total=0): if not total and not empDb.updateDB[self.db].has_key(self.key): # Nothing has been updated return DB = empDb.megaDB[self.db] DBs = DB.get(self.key, {}) for i, j in self.Rlist.items(): j(DBs.get(i, ""), DBs) def getKey(self): return str(self.key[0]) def SetId(self, info): if info: self.key = (info[0],) else: self.key = () self.redrawWin(1) def SetSect(self, range): self.sect = range viewer.markSectors([(range[0], range[2])]) viewer.map.see((range[0], range[2])) self.redraw() def EditField(self, name): if viewer.stsList: viewer.Root.bell() return def f(val, db=self.db, key=self.key, name=name): if not val: return db = empDb.megaDb[db] t = {} for i in len(self.key): t[db.primary_keytype[i]] = self.key[i] t[name] = val db.update(t) viewer.bufferStatus( "Manually edit %s value of %s to ?" % (name, self.key[0]), f) def redraw(self, total=0): self.redrawWin(total) sts = self.List.getStatus() DB = empDb.megaDB.get(self.db, {}) self.List.delete() list = [] for i, j in DB.items(): if self.sect: x = j['x']; y = j['y'] if (x < self.sect[0] or x > self.sect[1] or y < self.sect[2] or y > self.sect[3]): continue ## if j.get('owner') != empDb.CN_OWNED: ## continue if j.get('owner') == empDb.CN_UNOWNED: continue addi = "" if j.get('owner') != empDb.CN_OWNED: addi = "owner:%-3s" % (j.get('owner'),) list.append( ("%-3s@ %-8s type: %-3s%10s" % (j['id'], ("%s,%s" % (j['x'], j['y'])),j['type'], addi), j['id'])) list.sort() for i in list: self.List.insert('end', i) apply(self.List.setStatus, sts) def GoLand(self, name): k = empDb.megaDB.get(self.db, {}).get(self.key, {}).get('land') if k is None or k == -1: return viewer.cen.blist['Land'].handle.key = ( k, ) viewer.cen.newWin(viewer.cen.blist['Land']) def GoShip(self, range): k = empDb.megaDB.get(self.db, {}).get(self.key, {}).get('ship') if k is None or k == -1: return viewer.cen.blist['Ship'].handle.key = ( k, ) viewer.cen.newWin(viewer.cen.blist['Ship']) class ShipCensus(UnitCensus): """Subwindow within the censor window that displays ships.""" def __init__(self, master): self.db = 'SHIPS' self.name = 'ship' cc = {'command':self.LoadComd} # id type x y flt eff civ mil uw food pln he xl land mob fuel tech # shell gun petrol iron dust bar oil lcm hcm rad # def spd vis rng fir origx origy name self.winList = ( ((LabPair, "id"), (LabPair, "type"), (LabPair, "owner", {'default':translateOwner, 'hide':""}), (LabPairIdx, "", {'label':"Sector", 'command':self.GoSect}), (LabPair, "flt", {'label':"Fleet", 'command':self.SetFleet})), ((LabPair, "eff"), (LabPair, "mob"), (LabPair, "fuel"), (LabPair, "tech")), ((LabPair, "def"), (LabPair, "spd", {'label':"Speed"}), (LabPair, "vis"), (LabPair, "rng", {'label':"Range"}), (LabPair, "fir")), ((LabPair, "pln", {'label':"Planes"}), (LabPair, "land"), (LabPair, "he"), (LabPair, "xl")), ((LabPairIdx, "orig"), (LabPair, "name", {'command':self.SetName})), (), # List of commodities ((LabPair, "civ", cc), (LabPair, "mil", cc), (LabPair, "uw", cc), (LabPair, "food", cc), (LabPair, "shell", cc)), ((LabPair, "gun", cc), (LabPair, "petrol", cc), (LabPair, "iron", cc), (LabPair, "dust", cc), (LabPair, "bar", cc)), ((LabPair, "oil", cc), (LabPair, "lcm", cc), (LabPair, "hcm", cc), (LabPair, "rad", cc)), ) self.doStartup(master) def GoSect(self, name): viewer.queryCommand( "Navigate ship %s to ?" % self.key, "navi %s %%s" % self.key, "rdbs") def SetFleet(self, name): viewer.queryCommand( "Add ship %s to fleet ?" % self.key, "fleet %%s %s" % self.key, "rdbs") def SetName(self, name): viewer.queryCommand( "New name for ship %s ?" % self.key, 'name %s "%%s"' % self.key, "rdbs") def LoadComd(self, comd): viewer.queryCommand( "Set %s cargo on ship %s to ?" % (comd, self.key[0]), "load %s %s -%%s" % (comd, self.key[0]), "rdbes") class LandCensus(UnitCensus): """Subwindow within the censor window that displays land units.""" def __init__(self, master): self.db = 'LAND UNITS' self.name = 'land' cc = {'command':self.LoadComd} # id type x y army eff mil fort mob food fuel tech retr react xl # nland land ship shell gun petrol iron dust bar oil lcm hcm rad # att def vul spd vis spy radius frg acc dam amm aaf self.winList = ( ((LabPair, "id"), (LabPair, "type"), (LabPair, "owner", {'default':translateOwner, 'hide':""}), (LabPairIdx, "", {'label':"Sector", 'command':self.GoSect}), (LabPair, "army", {'command':self.SetArmy})), ((LabPair, "eff"), (LabPair, "mob"), (LabPair, "fuel"), (LabPair, "tech")), ((LabPair, "fort"), (LabPair, "retr"), (LabPair, "react", {'command':self.SetRange}), (LabPair, "att"), (LabPair, "def")), ((LabPair, "vul"), (LabPair, "spd"), (LabPair, "vis"), (LabPair, "spy"), (LabPair, "radius")), ((LabPair, "frg"), (LabPair, "acc"), (LabPair, "dam"), (LabPair, "amm"), (LabPair, "aaf")), ((LabPair, "xl"), (LabPair, "nland"), (), (LabPair, "land", {'default':-1, 'command':self.GoLand}), (LabPair, "ship", {'default':-1, 'command':self.GoShip})), (), # List of commodities ((LabPair, "civ", cc), (LabPair, "mil", cc), (LabPair, "uw", cc), (LabPair, "food", cc), (LabPair, "shell", cc)), ((LabPair, "gun", cc), (LabPair, "petrol", cc), (LabPair, "iron", cc), (LabPair, "dust", cc), (LabPair, "bar", cc)), ((LabPair, "oil", cc), (LabPair, "lcm", cc), (LabPair, "hcm", cc), (LabPair, "rad", cc)), ) self.doStartup(master) def GoSect(self, name): viewer.queryCommand( "March land unit %s to ?" % self.key, "march %s %%s" % self.key, "rdbl") def SetArmy(self, name): viewer.queryCommand( "Add land unit %s to army ?" % self.key, "army %%s %s" % self.key, "rdbl") def SetRange(self, name): viewer.queryCommand( "Set reaction range of land unit %s to ?" % self.key, "lrange %s %%s" % self.key, "rdbl") def LoadComd(self, comd): viewer.queryCommand( "Set %s cargo on land unit %s to ?" % (comd, self.key[0]), "lload %s %s -%%s" % (comd, self.key[0]), "rdbel") class PlaneCensus(UnitCensus): """Subwindow within the censor window that displays planes.""" def __init__(self, master): self.db = 'PLANES' self.name = 'plane' # id type x y wing eff mob tech att def acc react range load # fuel hard ship land laun orb nuke grd self.winList = ( ((LabPair, "id"), (LabPair, "type"), (LabPair, "owner", {'default':translateOwner, 'hide':""}), (LabPairIdx, "", {'label':"Sector", 'command':self.GoSect}), (LabPair, "wing", {'command':self.SetWing})), ((LabPair, "eff"), (LabPair, "mob"), (LabPair, "fuel"), (LabPair, "tech")), ((LabPair, "hard"), (LabPair, "react", {'command':self.SetRange}), (LabPair, "att"), (LabPair, "def")), ((LabPair, "acc"), (LabPair, "range"), (LabPair, "load"), (LabPair, "laun"), (LabPair, "orb")), ((LabPair, "nuke"), (LabPair, "grd"), (), (LabPair, "land", {'default':-1, 'command':self.GoLand}), (LabPair, "ship", {'default':-1, 'command':self.GoShip})), ) self.doStartup(master) def GoSect(self, name): viewer.queryCommand( "Transport plane %s to ?" % self.key, "transp plane %s %%s" % self.key, "rdbp") def SetWing(self, name): viewer.queryCommand( "Add plane %s to wing ?" % self.key, "wing %%s %s" % self.key, "rdbp") def SetRange(self, name): viewer.queryCommand( "Set reaction range of plane %s to ?" % self.key, "range %s %%s" % self.key, "rdbp") #################### # Main censor window def __init__(self, master): self.master = master self.blist = {} self.sect = (0,0,0,0) buttons = Tkinter.Frame(master, name="buttons") buttons.pack(side='top', fill='x') for i in (#('Nuke', self.SectorCensus, 'NUKES'), ('Plane', self.PlaneCensus, 'PLANES', "View planes"), ('Land', self.LandCensus, 'LAND UNITS', "View land units"), ('Ship', self.ShipCensus, 'SHIPS', "View ships"), ('Sector', self.SectorCensus, 'SECTOR', "View sector information.")): frm = Tkinter.Frame(master, name="f"+i[0], class_="Buttons", relief='raised', borderwidth=2) frm.handle = i[1](frm) frm.db = i[2] frm.button = Tkinter.Button(buttons, name="b"+i[0], text=i[0], relief='flat', command=(lambda self=self, cls=frm: self.newWin(cls))) frm.button.pack(side='right', fill='y', expand=1) viewer.Balloon.bind(frm.button, i[3]) self.blist[i[0]] = frm self.subWindow = frm frm.button['relief'] = 'raised' frm.pack(fill='both', expand=1) self.SetSect((0,0,0,0)) # Register automatic updating viewer.updateList.append(self) def newWin(self, ofType): if self.subWindow is not ofType: self.subWindow.button['relief'] = 'flat' self.subWindow.pack_forget() self.subWindow = ofType self.subWindow.button['relief'] = 'raised' self.subWindow.pack(fill='both', expand=1) # Hack! Reset the sectors for units, but not sectors. if self.subWindow.handle.__class__ is self.SectorCensus: self.subWindow.handle.SetSect(self.sect) else: self.subWindow.handle.sect = () self.redraw(1) def redraw(self, total): self.subWindow.handle.redraw(total) def getKey(self): return self.subWindow.handle.getKey() def getSect(self): return self.sect def SetSect(self, range): self.sect = range self.subWindow.handle.SetSect(range) def EditField(self, field): self.subWindow.handle.EditField(field) ptkei-1.12/src/empCmd.py0100600000076500007650000011571707007747446014167 0ustar kevinkevin"""Synthetic client side command interface.""" # Copyright (C) 1998-1999 Kevin O'Connor # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys import os import string import re import bisect import empQueue import empDb import empParse import empEval import empPath import empSector # Key Ideas: # What is contained within this file: # This file holds much of the client-side synthetic command interface. The # main code implements a command checker that parses outgoing commands and # determines if they are synthetic. The main class is EmpParse; it # performs these aliasing/redirection capabilities. This file also # contains a couple of high-level parse classes. Please see the individual # class documentation for more information. # Sending a command to the server: # To send an outgoing command, the standard method is to invoke # viewer.ioq.Send(). (Because viewer.ioq points to the only instance of # EmpParse, in many cases viewer.ioq will be replaced with self. In # general, "closer" references should be used in place of references to the # global variable viewer.) See the documentation with EmpParse.Send() for # more info on the syntax and options available. # Creating a new command: # Use the following five steps to define a new command: # # 1 Create a new class that descends from the baseCommand class. # # 2 Define a class variable 'description' for the new class. This should # be a brief one-line description - it is printed when the user issues the # 'define' command. # # 3 Set the class variable 'defaultBinding' to a list of commands to bind # the class to. The list must contain one or more 2-tuples that contain # name/length pairs. The length parameter sets the minimum length that # must be matched for the command. For example, if ("execute", 3) were # used, then the command "exe" would match. If the length is negative, # then a command will also match if it has more characters than the total # length of the command. For example, if ("execute", -3) were used, then # both the commands "exe" and "executes" would match. # # 4 Optionally set the class variable 'defaultPreList' to a true value. # Setting this option causes the command-line checker to scan for this # command before it does syntax checking. So for example, if a new command # called "newcommand" were bound and defaultPreList were set, then the # command "newcommand echo 1 ; echo 2" would cause the class to be invoked # with parameters "echo 1 ; echo 2". However, if defaultPreList was not # set, then the class would be invoked with parameters "echo 1" and a # second command ("echo 2") would be buffered separately. # # 5 Define one or more of the following methods: invoke, receive, transmit. # There can be three different callbacks associated with a command due to # the asynchronous nature of the command queue. Ptkei supports # command-buffering - that is, if a user issues a series of commands faster # than the server can receive and respond to them, the client will # automatically queue the commands. One side-effect of this, is that if # there are commands buffered when a synthetic client-side command is # received, the client must decide whether to run the command instantly or # to run it when the server finishes its processing. To accomplish this, # each command can set callbacks to be invoked under different conditions. # Normally only one of the above callbacks is used per-command. (But the # client is not limited to only one callback.) Each callback has its own # effect: # # invoke: This method is called the instant the user completes the command. # (There is no synchronization performed.) Never use this type of callback # for commands that send data to the output window or that use the internal # database. This command is most useful for performing GUI events that are # not related to the internal database or the command queue (EG. wread, # Login). One other noteworthy use, is for commands that only buffer # additional commands on the queue (EG. alias, execute). In this case it # is acceptable to use invoke, as the synchronization will be performed by # the newly added commands. (These commands are only acting as # "translators" - they don't need synchronization.) # # receive: Defining this method causes a special location marker to be # inserted into the command-queue. Once the server/client transmit all the # commands prior to this marker, the callback is invoked. This mechanism # provides for synchronization in the command-queue. This is the standard # callback used anytime a command uses the internal database. (If a user # issues a command "rdb" followed "mmove", the rdb command needs to be # processed before calculating moves - else the moves wont utilize the # latest database information.) It is also the standard callback for # commands that send date to the output window. (If the user issues "map # # ; define", the command listing must come only after all the map output # has been displayed.) # # transmit: This callback is invoked just before the command-queue would # send the command (had it been a real command). This is a limited use # callback - it is currently only used by the rdb command. The rdb command # uses it to delay deciding on which commands to send until it is # absolutely necessary to decide. It uses this mechanism to gain some # synchronization while still keeping the benefits of bursted commands. # Chances are, this isn't the callback you want. class EmpParse: """Implements a set of aliasing commands. This class is used as a wrapper around empQueue.EmpIOQueue. Outgoing commands are sent here, and if they are not client synthetic commands, they are sent to the server via the empQueue module. This class is more 'user-friendly' then the empQueue stuff. The major interaction with this class is done via the Send() module which is passed simple ASCII strings that are to be transmitted. Also in this class are some smart-features. Check for the methods that are labeled 'CmdXXX' for these functions. In all likelihood these functions will be separated in the future.. Note: This class generally only has one instantiation - viewer.ioq """ def __init__(self, queue): # Pointer to the actual low-level socket manager. self.sock = queue # Copies of methods so that this class can "double" for # empQueue.EmpIOQueue. self.HandleInput = self.sock.HandleInput self.fileno = self.sock.fileno self.SendNow = self.sock.SendNow # Default command transmission flags: self.preFlag = self.postFlag = empQueue.QU_SYNC ## self.preFlag = self.postFlag = empQueue.QU_BURST self.raw = 0 # History substitution: self.hisList = [""] self.hisPos = 0 # Setup the syntax list: self.preList = [] self.postList = [] self.syntaxList = ( (re.compile( r"^(?P.*?)\s+" +r"(?P\||(?:>>?!?))" +r"\s*(?P.*?)\s*$"), self.SyntaxRedirect), (re.compile(r"(?P.*)\s*;\s*(?P.*)"), self.SyntaxMulti), ) # Set the default commands: self.registerCmds(CmdAlias, CmdNull, CmdEval, CmdForEach , CmdBurst, CmdDefList, CmdRefresh, CmdExec , CmdOut, CmdNova, CmdPredict, CmdMover , CmdRaw, CmdOrigin, CmdMMove, CmdEMove) def registerCmds(self, *args): """Register a list of commands.""" for cmdclass in args: cmds = cmdclass.defaultBinding if cmdclass.defaultPreList: lst = self.preList else: lst = self.postList for cmd in cmds: bisect.insort(lst, cmd + (cmdclass,)) commandFormat = re.compile( r"^\s*(?P\S+)(?:\s+(?P.*))?$") def Send(self, cmd, disp=None, prepend=0, preFlag=None, postFlag=None, raw=None): """Search command line for smart commands. This method is the main way of interacting with this class. Send will search the given command for known smart-commands. If one is found, its associated code block is run. Otherwise, the command is sent unaltered to EmpIOQueue for normal server execution. This method has grown to include a number of options that may be specified for each outgoing command. disp = the display parser to associate with the outgoing command (None indicates that the standard viewer should be used). Setting prepend will instruct the command to be prepended to the queue - this causes the command to be the next command sent regardless of other waiting commands. preFlags/postFlags = the empQueue pre & post flags that should be requested for the command (assuming it is not a client-command). Setting raw will force this method to send the command unaltered - thus ignoring possible client-side commands. """ if disp is None: disp = viewer if raw is None: raw = self.raw # Find root word if not raw: mm = self.commandFormat.match(cmd) if mm: arg0 = mm.group('command') # Check pre-syntax list f = empQueue.findCmd(self.preList, arg0) if f is not None: f(self, mm, disp) return # Check syntax list for i in self.syntaxList: test = i[0].match(cmd) if test is not None: i[1](test, disp) return # Check post-syntax list f = empQueue.findCmd(self.postList, arg0) if f is not None: f(self, mm, disp) return # Command not aliased - send raw if preFlag is None: preFlag = self.preFlag if postFlag is None: postFlag = self.postFlag hdlr = empQueue.NormalHandler(cmd, disp, preFlag, postFlag) if prepend: self.sock.AddHandler(hdlr, 0) else: self.sock.AddHandler(hdlr) def HistSend(self, cmd): """Send the command with support for history substitution.""" if cmd[:2] == "!!": cmd = self.hisList[1] del self.hisList[1] elif cmd[:1] == "!": cmd = cmd[1:] l = len(cmd) for i in range(1, len(self.hisList)): val = self.hisList[i] if val[:l] == cmd: cmd = val del self.hisList[i] break else: raise IndexError else: if cmd[:1] == "^": pos = string.find(cmd, "^", 1) if pos == -1: raise IndexError cmd = string.replace(self.hisList[1], cmd[1:pos], cmd[pos+1:], 1) if cmd == self.hisList[1]: raise IndexError # Remove duplicate commands from the history list del self.hisList[0] try: self.hisList.remove(cmd) except ValueError: pass # Add the command to the history list self.hisList[:0] = ["", cmd] self.hisPos = 0 del self.hisList[100:] self.Send(cmd) def HistMove(self, offset, cmd): """Note an up/down arrow command-line request; returns new cmdline.""" if ((offset == 1 and self.hisPos >= len(self.hisList)-1) or (offset == -1 and self.hisPos <= 0)): raise IndexError if (offset == 1 and self.hisPos == 0): self.hisList[0] = cmd self.hisPos = self.hisPos + offset return self.hisList[self.hisPos] def SyntaxMulti(self, match, out): """Multi-Command line.""" self.Send(match.group('cmd1'), out) self.Send(match.group('cmd2'), out) def SyntaxRedirect(self, match, out): """Redirect output to a file.""" ## print "redirect" flags = match.group('flags') if flags == "|": type = "pipe" elif flags[:2] == ">>": type = "append" elif flags[-1] == "!": type = "force" else: type = "" self.Send(match.group('cmd'), RedirectOutput(out, match.group('name'), type)) class baseCommand: """Base class for synthetic commands. (Does little by itself.) This class is used as a base-class for creating new synthetic commands in the client. To define a new client-side command create a class that descends from this class, and then pass the new class to EmpParse.registerCmds(). The following class values are supported: description - a short text description that is printed when 'define' is called. commandFormat - if defined, it must be a regular expression that specifies the parameters for the command. The following class attributes are not used by this base-class, but are used by EmpParse when the command is 'registered': defaultPreList - Sets the 'parse ordering' of the command. defaultBindings - A list of name/length pairs to bind the command to. The following methods are supported: invoke - Callback invoked the moment the user types the command. receive - Callback invoked when the outbound command queue reaches this command. transmit - Callback invoked when the command queue is ready to send the command to the server. """ description = "No help available." defaultPreList = defaultBindings = None sendRefresh = None invoke = receive = transmit = None commandFormat = None def __init__(self, ioq, match, disp): # Establish defaults for all the standard command class commands. self.out = disp self.ioq = ioq self.Send = ioq.Send self.commandMatch = match # If commandFormat is defined check command parameters now. if self.commandFormat is not None: args = match.group('args') if not args: args = "" self.parameterMatch = self.commandFormat.match(args) if not self.parameterMatch: viewer.Error("Invalid parameters. Form should be: %s" % self.commandFormat.pattern) return # Call invoke method immediately if self.invoke is not None: self.invoke() # Add receive/transmit method as a callback if self.receive is not None or self.transmit is not None: flags = empQueue.QU_FULLSYNC if self.transmit is not None: flags = empQueue.QU_BURST ## # Send DB update commands ## if self.sendRefresh: ## ioq.Send("rdb"+self.sendRefresh, self.out) # Arrange for callback from queue code ioq.sock.AddHandler(empQueue.DummyHandler( match.string, self.out, self.receive, self.transmit, flags)) class CmdDefList(baseCommand): description = "List all online commands." defaultBinding = (('define', 6),) def receive(self): if not self.out.data: return self.out.data('Pre-syntax:') for i, k, j in self.ioq.preList: self.out.data("%-10s - %s" % (i, j.description)) self.out.data("") self.out.data("Syntax:") for i in self.ioq.syntaxList: self.out.data("%-35s - %s" % (i[0].pattern, i[1].__doc__)) self.out.data("") self.out.data("Post-syntax:") for i, k, j in self.ioq.postList: self.out.data("%-10s - %s" % (i, j.description)) class CmdAlias(baseCommand): description = "Generate a definition for a simple alias." defaultPreList = 1 defaultBinding = (('alias', 5),) EAliasFormat = re.compile(r"\$(\$|\*|\d+)") commandFormat = re.compile( r"^(?P\S+)\s+(?P.*?)\s*$") def invoke(self): newcmd = self.parameterMatch.group('value') name = self.parameterMatch.group('newName') lst = self.EAliasFormat.split(newcmd) class dummyclass(baseCommand): def invoke(self): """Evaluate an alias for a given command.""" sublst = self.substitutions args = self.commandMatch.group('args') if args is None: args = "" argl = string.split(self.commandMatch.string) cmd = "" for part in range(len(sublst)): val = sublst[part] if part & 1: # Odd value - this is a parameter substitution. if val == '*': cmd = cmd + args elif val == '$': cmd = cmd + '$' else: try: cmd = cmd + argl[string.atoi(val)] except IndexError: viewer.Error("Not enough arguments for alias.") return else: cmd = cmd + val self.Send(cmd, self.out, 1) dummyclass.description = "Aliased to "+repr(newcmd) dummyclass.defaultBinding = ((name, len(name)),) dummyclass.substitutions = lst self.ioq.registerCmds(dummyclass) class CmdOrigin(baseCommand): description = "Block unsupported server command." defaultBinding = (('origin', -3),) def receive(self): viewer.Error("Sorry, the origin command is not supported.") viewer.Error("Please see TIPS.html for more information.") class CmdRaw(baseCommand): description = "Send a command without client interpretation." defaultPreList = 1 defaultBinding = (('raw', 3),) def invoke(self): self.ioq.Send(self.commandMatch.group('args'), raw=1) class CmdBurst(baseCommand): description = "Send a multi-command line without syncing server output." defaultPreList = 1 defaultBinding = (('burst', 5),) def invoke(self): args = self.commandMatch.group('args') if not args: return pre, post = self.ioq.preFlag, self.ioq.postFlag ## self.preFlag = empQueue.QU_SYNC ## self.postFlag = empQueue.QU_FORCEBURST self.ioq.preFlag = self.ioq.postFlag = empQueue.QU_BURST ## self.Send(args, out, preFlag=pre, postFlag=post) self.Send(args, self.out) self.ioq.preFlag, self.ioq.postFlag = pre, post class CmdExec(baseCommand): description = "Run commands from a file." defaultBinding = (('execute', -3), ('runfeed', 7)) def invoke(self): args = self.commandMatch.group('args') if not args: return try: if self.commandMatch.group('command')[:1] == 'r': # Runfeed command file = os.popen(args, 'r') else: # Execute command file = open(args) except IOError: viewer.Error("Unable to open file [%s]." % args) return lst = file.readlines() file.close() for i in lst: i = string.strip(i) if not i or i[0] == '#': continue self.Send(i, self.out) ## class ReallySilentDisp(empQueue.baseDisp): ## """Display class that discards all input.""" ## Begin = data = Answer = End = empQueue.doNothing ## class QuietDisp(empQueue.baseDisp): ## """Display class that discards some input.""" ## data = empQueue.doNothing class SilentDisp(empQueue.baseDisp): """Display class that discards most input.""" def __init__(self, disp, name): empQueue.baseDisp.__init__(self, disp) self.name = name def __del__(self): if self.End is empQueue.doNothing: self.out.End(self.name) def Begin(self, cmd): if self.Begin is not empQueue.doNothing: self.out.Begin(self.name) self.Begin = empQueue.doNothing def End(self, cmd): self.End = empQueue.doNothing data = empQueue.doNothing class CmdNull(baseCommand): description = "Run command with no output." defaultPreList = 1 defaultBinding = (('null', 4),) def invoke(self): self.Send(self.commandMatch.group('args') , SilentDisp(self.out, self.commandMatch.string)) class CmdPredict(baseCommand): description = "Get predictions for a sector." sendRefresh = "e" defaultBinding = (('Predict', 7),) def receive(self): try: coord = empParse.str2Coords(self.commandMatch.group('args')) except ValueError: viewer.Error("Invalid coordinates.") return DB = empDb.megaDB['SECTOR'][coord] for i in string.split(empSector.sectorPredictions(DB), "\n"): self.out.data(i) class CmdMover(baseCommand): description = "Issue a multi-stage move." sendRefresh = "e" defaultBinding = (('Mover', 5),) commandFormat = re.compile( r"^(?P\S+)\s+(?P[+-@]?\d+)\s+(?P.*)$") def receive(self): mm = self.parameterMatch try: sectors = map(empParse.str2Coords, string.split(mm.group('sectors'))) if len(sectors) < 2: raise ValueError commodity = empEval.commodityTransform[mm.group('comd')] quantity = getMoveQuantity(mm.group('val'), commodity, sectors) except (ValueError, KeyError): viewer.Error("Move invalid input failure.") if quantity < 0: quantity = -quantity sectors.reverse() for i in range(len(sectors)-1, 0, -1): last = sectors[i-1] cur = sectors[i] self.Send("move %s %d,%d %d %d,%d" % ( commodity, last[0], last[1], quantity, cur[0], cur[1]), self.out, 1) class CmdRefresh(baseCommand): description = "Refresh client databases." defaultBinding = (('rdb', -3), ('rerdb', -5)) syncFormat = re.compile( r"^(?Pre)?rdb(?P
P)?(?P[eslpno]*)$")

    commandFlags = [('e', 'SECTOR', 'dump'),
		    ('l', 'LAND UNITS', 'ldump'),
		    ('s', 'SHIPS', 'sdump'),
		    ('p', 'PLANES', 'pdump'),
		    ('n', 'NUKES', 'ndump'),
		    ('o', 'LOST ITEMS', 'lost')]

    def invoke(self):
	match = self.syncFormat.match(self.commandMatch.group('command'))
	if not match:
	    viewer.Error("refresh regex failure.")
	    return

	# Set the display class class to the null-parser
	self.out = SilentDisp(self.out, match.string)

##  	self.dumpList = match.group('flags') or "elspno"
	self.dumpList = match.group('flags') or "elspo"
	self.persistent = (match.group('pre') != None)
	self.totalDump = (match.group('total') != None)

    def checkPending(self, qElem):
	"""empQueue scan callback: Don't send redundant commands."""
	if (qElem is empQueue.DummyHandler
	    and qElem.tcallback.__class__ is self.__class__):
	    # Found a refresh command pending - don't send any repeated dumps
	    for i in qElem.callback.dumpList:
		pos = string.find(self.dumpList, i)
		if pos != -1:
		    self.dumpList = self.dumpList[:pos] + self.dumpList[pos+1:]
		    if not self.dumpList:
			# No dump commands left - end scan
			return 1

    def transmit(self, qPos):
	# Check if parts of this dump can be picked up by a pending dump.
	if not self.persistent:
	    self.ioq.sock.scanQueue(self.checkPending, start=qPos+1)

	for dumpInfo in self.commandFlags:
	    # Check if this kind of dump is requested.
	    if not dumpInfo[0] in self.dumpList:
		continue

	    # Set the timestamp.
	    ts = ""
	    if (not self.totalDump
		# HACK!	 Always do a full dump of the nuke database
		and dumpInfo[0] != 'n'):
		time = empDb.megaDB[dumpInfo[1]].unofficial_timestamp
		if time != 0:
		    ts = " ?timestamp>%s" % time

	    # Generate the command.
	    qPos = qPos + 1
	    self.ioq.sock.AddHandler(empQueue.NormalHandler(
		dumpInfo[2] + " *" + ts, self.out, pre=empQueue.QU_SYNC
		, post=empQueue.QU_FORCEBURST)
				     , pos=qPos)

s_var = r"(?P\w+)"
s_val = r"(?P\w+)"
s_command = r"(?P.*)"

class CmdEval(baseCommand):

    description = "Evaluate an expression for a sector/database."

    sendRefresh = "e"
    defaultPreList = 1
    defaultBinding = (('eval', 4),)

    commandFormat = re.compile(
	r"^(?P"+empParse.s_sector+"|nation|version)\s+"+s_command+"$")
    def receive(self):
	mm = self.parameterMatch
	type = mm.group('type')
	if type == 'nation' or type == 'version':
	    db = empDb.megaDB[type]
	else:
	    type = 'SECTOR'
	    key = tuple(map(string.atoi, mm.group('sectorX', 'sectorY')))
	    try:
		db = empDb.megaDB['SECTOR'][key]
	    except KeyError:
		viewer.Error("Could not find sector.")
		return
	try:
	    self.Send(empEval.evalString(
		empEval.estrToExpr(mm.group('command')),
		type, db),
		      self.out, 1)
	except empEval.error, e:
	    viewer.Error(e)

class CmdForEach(baseCommand):

    description = "Run given command on specified sectors."

    sendRefresh = "e"
    defaultPreList = 1
    defaultBinding = (('foreach', 7),)

    commandFormat = re.compile(
	r"^(?P\S+)\s+(?:\?(?P\S+)\s+)?"
	+s_command+"$")
    def receive(self):
	mm = self.parameterMatch
	try:
	    list = empEval.foreach(
		"owner==-1 and "+empEval.selectToExpr(mm.group('sectors'),
						      mm.group('selectors')),
		empEval.estrToExpr(mm.group('command')),
		'SECTOR')
	except empEval.error, e:
	    viewer.Error(e)
	else:
	    for i in list:
		self.Send(i, self.out, 1)

class CmdOut(baseCommand):

    description = "Debugging tool - dumps database."

    defaultBinding = (('out', 3),)

##      outFormat = re.compile(r"\s+(\S+)\s*$")
    def receive(self):
	self.out.data(str(empDb.megaDB))
##	cmds = [('e', 'SECTOR', 'dump'),
##		('l', 'LAND UNITS', 'ldump'),
##		('s', 'SHIPS', 'sdump'),
##		('p', 'PLANES', 'pdump'),
## #		('n', 'NUKES', 'ndump'),
##		('o', 'LOST ITEMS', 'lost')]
##	c = match.group(1)
##	if not c:
##	    c = 'elspno'

##	mm = self.match_out.search(match.string)

##	if not mm:
##	    val = '*'
##	else:
##	    val = mm.group(1)

##	for dbt in cmds:
##	    if not dbt[0] in c:
##		continue

##	    out.data(dbt[1]+":" + `self.getSectors(val, "", dbt[1])`)

class CmdMMove(baseCommand):

    description = "Ulf Larsson's multi-move tool."

    sendRefresh = "e"
    defaultBinding = (('mmove', 5),)

    commandFormat = re.compile(
	"^"+empParse.s_comm+"\s+"
	r"(?P\S+)(?:\s+\?(?P\S+))?\s+"
	r"(?P\S+)\s+(?P\S+)\s+"
	r"(?P\S+)(?:\s+\?(?P\S+))?\s+"
	r"(?P\S+)\s*$")
    def receive(self):
	mm = self.parameterMatch
	commodity, slevel, mob, dlevel = mm.group(
	    'comm', 'level1', 'mob', 'level2')
	try: commodity = empEval.commodityTransform[commodity]
	except KeyError:
	    viewer.Error("Unknown commodity.")
	    return

	# Call the empEval.foreach function.  empEval.foreach tests every
	# sector in the database to see if arg1 tests true.  If it does, then
	# arg2 is evaluated and inserted into the list.
	try:
	    # Return a list for source sectors that contains tuples of the
	    # form: ((x, y), sectDB, amount, mobility)
	    slist = empEval.foreach(
		("owner==-1 and "+empEval.selectToExpr(
		    mm.group('sectors'), mm.group('selectors'))),
		("(xloc+0,yloc+0), __db[1], int("+commodity+"-("+slevel
		 +")), int(mob-("+mob+"))"),
		'SECTOR')
	    # Return a list for destination sectors that contains tuples of the
	    # form: ((x, y), sectDB, amount)
	    dlist = empEval.foreach(
		("owner==-1 and "+empEval.selectToExpr(
		    mm.group('sectors2'), mm.group('selectors2'))),
		"(xloc+0,yloc+0), __db[1], int(("+dlevel+")-"+commodity+")",
		'SECTOR')
	except empEval.error, e:
	    viewer.Error(e)
	    return

	# Create usable dictionaries from the returned list.
	ddict = {}
	for coord, db, amount in dlist:
	    if amount > 0 and empSector.is_movable_into(db, commodity):
		ddict[coord] = amount
	sdict = {}
	for coord, db, amount, mobility in slist:
	    if (amount > 0 and mobility > 0
		and not ddict.has_key(coord)
		and empSector.is_movable_from(db, commodity)):
		sdict[coord] = (amount, mobility,
				empSector.move_weight(db, commodity))
##  	print "%s\n%s" % (sdict, ddict)

	# Send the dictionaries to the move generator
	mmove = empPath.MoveGenerator(commodity, sdict, ddict)

	# Extract the moves and pass to the command queue.
	while not mmove.empty() :
	    comm, path, amount = mmove.move()
	    self.Send("move %s %d,%d %s %d,%d" % (
		comm, path.start[0], path.start[1], amount,
		path.end[0], path.end[1]),
		      self.out, 1)
	    mmove.next()

class CmdEMove(baseCommand):

    description = "Ulf Larsson's multi-move explore tool."

    sendRefresh = "e"
    defaultBinding = (('emove', 5),)

    commandFormat = re.compile(
	"^"+empParse.s_comm+"\s+"
	r"(?P\S+)(?:\s+\?(?P\S+))?\s+"
	r"(?P\S+)\s+(?P\S+)\s+"
	r"(?P\S+)(?:\s+\?(?P\S+))?\s*$")
    def receive(self):
	mm = self.parameterMatch
	commodity, slevel, mob = mm.group(
	    'comm', 'level1', 'mob')
	try: commodity = empEval.commodityTransform[commodity]
	except KeyError:
	    viewer.Error("Unknown commodity.")
	    return

	# Call the empEval.foreach function.  empEval.foreach tests every
	# sector in the database to see if arg1 tests true.  If it does, then
	# arg2 is evaluated and inserted into the list.
	try:
	    # Return a list for source sectors that contains tuples of the
	    # form: ((x, y), sectDB, amount, mobility)
	    slist = empEval.foreach(
		("owner==-1 and "+commodity+">0 and "+empEval.selectToExpr(
		    mm.group('sectors'), mm.group('selectors'))),
		("(xloc+0,yloc+0), __db[1], int("+commodity+"-("+slevel
		 +")), int(mob-("+mob+"))"),
		'SECTOR')
	    # Return a list for destination sectors that contains tuples of the
	    # form: ((x, y), sectDB)
	    dlist = empEval.foreach(
		("owner!=-1 and "+empEval.selectToExpr(
		    mm.group('sectors2'), mm.group('selectors2'))),
		"(xloc+0,yloc+0), __db[1]",
		'SECTOR')
	except empEval.error, e:
	    viewer.Error(e)
	    return

	# Create usable dictionaries from the returned list.
	ddict = {}
	for coord, db in dlist:
	    if empSector.is_explorable_into(db):
		ddict[coord] = 1
	sdict = {}
	for coord, db, amount, mobility in slist:
	    if (amount > 0 and mobility > 0
		and not ddict.has_key(coord)
		and empSector.is_movable_from(db, commodity)):
		sdict[coord] = (amount, mobility, 1.0)
##  	print "%s\n%s" % (sdict, ddict)

	# Send the dictionaries to the move generator
	mmove = empPath.MoveGenerator(commodity, sdict, ddict,
				      empPath.ExplMobCost())

	# Extract the moves and pass to the command queue.
	while not mmove.empty() :
	    comm, path, amount = mmove.move()
	    self.Send("explore %s %d,%d %s %sh" % (
		comm, path.start[0], path.start[1], amount, path.directions),
		      self.out, 1)
	    mmove.next()

class CmdNova(baseCommand):

    description = "Auto-explore sectors."

    sendRefresh = "e"
    defaultBinding = (('nova', 4),)

    commandFormat = re.compile(
	"^"+empParse.s_comm+"\s+"+empParse.s_sector
	+"\s*(?:"+empParse.s_sector2+")?\s*$")
    def receive(self):
	mm = self.parameterMatch
	start = map(string.atoi, mm.group('sectorX', 'sectorY'))
	if mm.group('sector2X'):
	    dest = map(string.atoi, mm.group('sector2X', 'sector2Y'))
	else:
	    dest = start
	if dest == start:
	    estr = "%s,%s 1" % tuple(start)
	else:
	    estr = "%s,%s 1 %s,%s" % tuple(start+dest)
	db = empDb.megaDB['SECTOR']
	# Check if there are wilderness sectors around destination.
	CN_UNOWNED = empDb.CN_UNOWNED
	for newcoord in empDb.sectorNeighbors(dest):
	    sect = db.get(newcoord, {})
	    des = sect.get('des')
	    own = sect.get('owner')
	    if ((own == 0 or own is None or own == CN_UNOWNED)
		and des is not None and des not in ".?s\\"):
## 		print "exploring to %s,%s a (%s) owned by (%s)" % (
## 		    newcoord+(sect.get('des'), sect.get('owner')))
		break
	else:
	    # No sectors to explore
	    return
	self.Send("explore " + mm.group('comm') + " " + estr,
		  HandleNova(self.out, self.ioq, mm.group('comm'), start, dest),
		  1, empQueue.QU_SYNC, empQueue.QU_FULLSYNC)
	self.Send("des * ?newdes=-&mob<1 +", self.out,
##  		  preFlag=empQueue.QU_SYNC,
		  postFlag=empQueue.QU_FORCEBURST)
##	self.Send("esync")

class HandleNova(empQueue.baseDisp):
    """Parse class for nova handled explores.

    This class receives output after the empParse.ParseMove class.
    Basically, it automatically generates moves based on the information
    contained in the prompts.
    """

    def __init__(self, disp, slf, comd, start, dest):
	empQueue.baseDisp.__init__(self, disp)
	self.slf = slf
	self.comd = comd
	self.start = start
	self.dest = dest
	self.oldflush = None
	self.direc = 0
    promptFormat = empParse.ParseMove.promptFormat
    def flush(self, msg, hdl):
	mm = self.promptFormat.match(msg)
	if not mm:
	    # Encountered an unknown prompt
	    self.out.flush(msg, hdl)
	    return
	if self.oldflush is not None and msg != self.oldflush:
	    # Looks like we succeeded in moving.
	    self.out.flush(msg, None)
	    hdl('h')
	    return
	self.oldflush = msg
	db = empDb.megaDB['SECTOR']
	CN_UNOWNED = empDb.CN_UNOWNED
	# Failed to move.
	neighbors = empDb.sectorNeighbors(self.dest)
	pathDirections = empDb.pathDirections
	while 1:
	    if self.direc >= len(pathDirections):
		# No more directions left
		self.out.flush(msg, None)
		hdl('h')
		return
	    newcoord = neighbors[self.direc]
	    sect = db.get(newcoord, {})
	    des = sect.get('des')
	    own = sect.get('owner')
	    if (((own == 0 or own is None) and des is not None
		 and des not in ".\\")
		or (own == CN_UNOWNED and des not in "?s")):
		self.out.flush(msg, None)
		hdl(pathDirections[self.direc])
		break
	    self.direc = self.direc + 1
	self.direc = self.direc + 1
    ownSector = empParse.ParseMove.ownSector
    def data(self, msg):
	self.out.data(msg)
	mm = self.ownSector.match(msg)
	if mm:
	    if self.direc < len(empDb.pathDirections):
		CmdNova(
		    self.slf,
		    EmpParse.commandFormat.match(
			"nova %s %s,%s %s,%s" % (
			    self.comd, self.start[0], self.start[1],
			    self.dest[0], self.dest[1])),
		    self.out)
	    self.slf.Send(
		"nova %s %s,%s %s,%s" % (
		    (self.comd, self.start[0], self.start[1],
		    mm.group('sectorX'), mm.group('sectorY'))),
		self.out)

##  class HandleFlush(empQueue.baseDisp):
##      """Class to handle programable sub-prompts."""
##      def __init__(self, disp, prompts):
##  	empQueue.baseDisp.__init__(self, disp)
##  	self.prompts = list(prompts)
##      def flush(self, msg):
##  	for i in range(prompts):
##  	    val = prompts[i]
##  	    if type(val) == types.tuple:
##  		match, val = val
##  		mm = match.match(msg)
##  		if mm:
##  		    if callable(val):
##  			viewer.SendNow(val(mm))
##  		    else:
##  			viewer.SendNow(val)
##  		    break
##  	    elif callable(val):
##  		viewer.SendNow(val(msg))
##  		del self.prompts[i]
##  		break
##  	    else:
##  		viewer.SendNow(val)
##  		del self.prompts[i]
##  		break
##  	else:
##  	    self.out.flush(msg)

class ParseShow(empQueue.baseDisp):
    """Rearrange output from multiple commands into a set of columns.

    This is a hack!  - It is really only usefull for show XXX YYY.
    Now this hack got hacked by Bernhard to let capability listings
	not grow to big. So it is special for cshow. :-)
	It is important that "cap" are the last char of the last command
	which this class is called with.

    Kevin has arranged a list Body. The last element is printed first,
    so that commands with more overhead lines can append to the list.
    """

    def __init__(self, disp):
	empQueue.baseDisp.__init__(self, disp)

	self.CBody = []
	self.Body = []
	self.first = 1
	self.foundheader = 0

    def __del__(self):
	# do the output
	for i in range(1, len(self.Body)+1):
	    self.out.data(self.Body[-i])

    def End(self, cmd):
	self.out.End(cmd)
	# stuff to do at the end of each block, put CBody in Body

	if self.Body:
	    mx = max(map(len, self.Body))
	else:
	    mx = 0

	# next lines just to test that i have understood this --Bernhard
## 	sys.stdout.write('cmd=' + cmd + "\n")
	if  cmd[-3:] == "cap" :
## 	    sys.stdout.write('found cap cmd\n')
## 	    sys.stdout.flush()
	    mfc=140-mx-1  # max width for cap output (should be determined dynmc)

	al=0 	# added lines, only >0 when formatting cap output
	for i in range(len(self.CBody)):
	    if cmd[-3:] == "cap":
		while len(self.CBody[i])>mfc:
		    # insert enough additional lines in Body and truncate CBody
		    # a better approach would be to find a word to split
		    ll= len(self.CBody[i])
		    if (ll/mfc)*mfc==ll:
			ii=(ll/mfc - 1)*mfc
		    else:
			ii=(ll/mfc)*mfc
		    self.Body.insert(i+al,' '*mx + ' ' + self.CBody[i][ii:])
		    self.CBody[i]= self.CBody[i][:ii]
		    al=al+1

	    if i+1 > len(self.Body):
		self.Body.append(' '*mx + self.CBody[i])
	    else:
		self.Body[i+al] =  ( self.Body[i+al]
					+ ' '*(mx-len(self.Body[i+al]))
					+ self.CBody[i])
	self.CBody = []
	self.Bpos = -1
	self.first = 0
	self.foundheader = 0

    def data(self, msg):
	# prepend message to CBody
	if not self.foundheader:
	    if string.lstrip(msg[:25]) == '':
		self.foundheader = 1
	    else:
		return
	if self.first:
	    self.CBody[0:0] = [ msg ]
	else:
	    self.CBody[0:0] = [ msg[25:] ]

class RedirectOutput(empQueue.baseDisp):
    """Redirect a command to a file or program."""
    def __init__(self, disp, name, type):
	empQueue.baseDisp.__init__(self, disp)
	self.name = name
	self.type = type
    def Begin(self, cmd):
##  	print "opening"
	if self.out.Begin is empQueue.doNothing:
	    # File already opened.
	    return
	self.out.Begin(cmd)
	try:
	    if self.type == "pipe":
		self.file = os.popen(self.name, 'w')
	    else:
		if self.type == "append":
		    flags = "a"
		elif self.type != "force" and os.path.exists(self.name):
		    raise IOError, "File %s already exists." % self.name
		else:
		    flags = "w"
		self.file = open(self.name, flags)
	except:
	    viewer.Error('Exception %s with detail:\n"%s".'
			 % tuple(sys.exc_info()[:2]))
	    self.file = None
    def End(self, cmd):
##  	print 'end'
	self.out.End(cmd)
	if self.file is not None:
	    self.file.close()
    def data(self, msg):
##  	print 'data'
	if self.file is not None:
	    self.file.write(msg+"\n")
	else:
	    self.out.data(msg)

def getMoveQuantity(txt, commodity, sectors):
    var = string.lstrip(txt)
    flag = 0
    if var and var[0] in '-+@':
	if var[0] == '@':
	    flag = 1
	    var = var[1:]
	else:
	    flag = 2

    val = string.atoi(var)

    # Check for reverse paths.
    if flag == 2:
	# Absolute move.
	quantity = val
    elif flag == 1:
	# Reverse "smart" move.
	db = empDb.megaDB['SECTOR'][sectors[-1]]
	quantity = val - db.get(commodity, 0)
    else:
	# Normal "smart" move.
	db = empDb.megaDB['SECTOR'][sectors[0]]
	quantity = db.get(commodity, 0) - val

    return quantity

##  class telegramParser(empQueue.baseDisp):
##      def __init__(self, cmd, msg):
##  	empQueue.baseDisp.__init__(self, viewer)
##  	self.cmd = cmd
##  	self.msg = string.split(string.rstrip(msg), '\n')
##      prompt = empParse.ParseTele.prompt
##      def flush(self, msg, hdl):
##  	# Get the characters remaining in this message
##  	mm = self.prompt.match(msg)
##  	if not mm:
##  	    self.out.flush(msg, hdl)
##  	else:
##  	    response = ""
##  	    left = string.atoi(mm.group('left'))
##  	    if len(self.msg) == 0:
##  		response = "."
##  	    elif len(self.msg[0]) > left:
##  		if len(self.msg[0]) > 1024:
##  		    # Force out a partial string
##  		    response = self.msg[0][:left]
##  		    self.msg[0] = self.msg[0][left:]
##  		else:
##  		    # Finish this message
##  		    viewer.ioq.Send(self.cmd, self, 1)
##  		    response = "."
##  	    else:
##  		response = self.msg[0]
##  		del self.msg[0]
##  	    self.out.flush(msg, None)
##  	    hdl(response)

def sendTelegram(cmd, msg):
    """Send a telegram to the server.

    This function takes a telegram/announcement command stored in cmd, and
    a multi-line string stored in msg and then bursts the telegram command
    and the body of the message to the server.  The results of this command
    are not synchronized or checked in any way.  Assumptions are made about
    the form and acceptable content of a telegram, and then all the info is
    bursted out.  The advantage of bursting telegrams, is that it makes the
    transmission extremely fast.
    """
    msg = string.split(string.rstrip(msg), '\n')
    if not msg:
	return
    tot = 0
    QU_BURST = empQueue.QU_BURST
    Send = viewer.ioq.Send
    # Start the tele command
    Send(cmd, postFlag=QU_BURST)
    while msg:
	val = msg[0]
	del msg[0]
	# Alter any suspicious lines so the server doesn't choke on them.
	if val in ("~u", "~p", "~q", "."):
	    val = val+" "
	l = len(val)
	# Assume the total bytes in a telegram is 1024.
	if l > 1024:
	    l = 1024-l
	    msg[:0].insert(val[l:], 0)
	    val = val[:l]
	elif tot + l > 1024:
	    # Continue message on another tele command
	    Send(".", preFlag=QU_BURST, postFlag=QU_BURST, raw=1)
	    Send(cmd, preFlag=QU_BURST, postFlag=QU_BURST)
	    tot = 0
	Send(val, preFlag=QU_BURST, postFlag=QU_BURST, raw=1)
	tot = tot + l + 1
    Send(".", preFlag=QU_BURST, raw=1)
ptkei-1.12/src/empCurses.py0100600000076500007650000001430506655766103014716 0ustar  kevinkevin"""Curses support."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import curses
import termios, TERMIOS

import select
import sys

import empDb
import empQueue
import empCmd

###########################################################################
#############################  Curses support #############################
class Curses:
    """Simple Curses based interface."""

    def __init__(self):
	self.loginCallback = self
	self.login_kill = 0
	self.stayOnline = 0
	self.atPrompt = 0

	self.origState = termios.tcgetattr(sys.stdin.fileno())
	self.stdscr=curses.initscr()
	y, x = self.stdscr.getmaxyx()
	self.outwin = curses.newwin(y-1, x, 0, 0)
	self.outwin.scrollok(1)
	self.promptwin = curses.newwin(1, x, y-1, 0)

    def setprompt(self, prompt):
	"""Set the prompt window to the standard empire prompt."""
	self.promptwin.clear()
	self.promptwin.addstr(0, 0, prompt)
	self.promptwin.refresh()
#	pass

    def Begin(self, cmd):
	"""empQueue handler: Note the beginning of a command."""
	if self.atPrompt:
	    self.outwin.addstr(cmd)
	else:
	    self.outwin.addstr("\n"+empDb.GetPrompt()+cmd)
	    self.atPrompt = 0

    def data(self, msg):
	"""empQueue handler: Process a line of server data."""
	self.outwin.addstr("\n"+msg)
	self.atPrompt = 0

##      def flush(self, msg, hdl):
##  	"""empQueue handler: Handle a subprompt."""
##  	if hdl is None:
##  	    print msg
##  	    return
##  	try:
##  	    cmd = raw_input(msg)
##  	except KeyboardInterrupt:
##  	    cmd = "ctlc"
##  	    print
##  	hdl(cmd)
##  	self.atPrompt = 0

    def End(self, cmd):
	"""empQueue handler: Note the end of a command."""
	p = empDb.GetPrompt()
	self.outwin.addstr("\n" + p)
	self.setprompt(p)
	self.atPrompt = 1

    flush = Answer = updateDB = empQueue.doNothing

    def inform(self):
	"""empQueue handler: Process an asynchronous prompt update."""
	p = empDb.GetPrompt()
	if self.atPrompt == 1:
	    self.outwin.addstr("\n" + p)
	self.setprompt(p)

    def flash(self, msg):
	"""empQueue handler: Process an asynchronous line of data."""
	self.outwin.addstr("\n" + msg)
	self.atPrompt = 0

    Error = flash

    def login_error(self, msg):
	"""empQueue/login handler: Report a login error."""
	print msg
	# HACK! See if we are online..
	if self.ioq.sock.flags >= empQueue.QU_DISCONNECT:
	    ldb = empDb.megaDB['login']
	    t = raw_input("host[%s]: " % ldb['host'])
	    if t:
		ldb['host'] = t
	    while 1:
		t = raw_input("port[%s]: " % ldb['port'])
		if t:
		    try: t = string.atoi(t)
		    except ValueError:
			continue
		    ldb['port'] = t
		break
	# Hack! Check if we need to kill
	if msg[:22] == "[3] country in use by ":
	    t = raw_input("Try to issue a kill? [n] ")
	    if t[:1] == 'y' or t[:1] == 'Y':
		self.login_kill = 1
		self.loginHandler.retry()
		return
	    self.login_kill = 0
	ldb = empDb.megaDB['login']
	t = raw_input("Country? [%s] " % ldb['coun'])
	if t:
	    ldb['coun'] = t
	t = raw_input("Representative? [%s] " % ldb['repr'])
	if t:
	    ldb['repr'] = t
	self.loginHandler.retry()

    def login_success(self):
	"""empQueue/login handler: Note a successful login."""
	pass

    def connect_success(self):
	"""empQueue/login handler: Note a server connection."""
	self.stayOnline = 1

    def connect_terminate(self):
	"""empQueue/login handler: Note a server disconnect."""
	self.stayOnline = 0

    def main(self):
	"""empire.py callback: Start the main input/output loop."""
	try:
	    # Start curses
#	    self.promptwin.nodelay(1)
#	    curses.intrflush(1)
	    curses.noecho()
	    curses.cbreak()
	    self.promptwin.keypad(1)

	    self.cmd = ""
	    while self.stayOnline:
		pending = select.select([self.ioq, sys.stdin], [], [])[0]
		if pending and pending[0] == self.ioq:
		    self.ioq.HandleInput()
		    del pending[0]
#		    self.outwin.refresh()
		if pending and pending[0] == sys.stdin:
##  		    cmd = self.promptwin.getstr()
##  		    try:
##  			self.ioq.HistSend(cmd)
##  		    except IndexError:
##  			print "History substitution error."
##  		    self.promptwin.move(0,0)
##  		    self.promptwin.clrtoeol()
#		    buf = sys.stdin.read()
#		    map(curses.ungetch, map(ord, buf))
#		    while 1:
		    ch = self.promptwin.getch()
		    if ch < 0:
			break
		    if ch == ord("\n"):
			try:
			    self.ioq.HistSend(self.cmd)
			except IndexError:
			    curses.beep()
			self.promptwin.move(0,0)
			self.promptwin.clrtoeol()
			self.cmd = ""
		    elif ch > 255:
			# Function key
			if ch == curses.KEY_UP or ch == curses.KEY_DOWN:
			    if ch == curses.KEY_UP:
				offset = 1
			    else:
				offset = -1
			    try:
				self.cmd = self.ioq.HistMove(offset, self.cmd)
			    except IndexError:
				curses.beep()
			    else:
				self.promptwin.clear()
				self.promptwin.addstr(0, 0, empDb.GetPrompt()
						      + self.cmd)
		    else:
#			print 'got ' + chr(ch)
#			self.stdscr.addstr(0, 0, cmd)
			self.cmd = self.cmd + chr(ch)
			self.promptwin.addstr(chr(ch))
##  			self.promptwin.move(0,0)
##  			self.promptwin.clrtoeol()
##  			self.promptwin.addstr(0, 0, empDb.GetPrompt() + cmd)
		self.outwin.refresh()
		self.promptwin.refresh()
	finally:
#	    self.promptwin.nodelay(0)
	    self.promptwin.keypad(0)
	    curses.flushinp()
	    curses.echo()
	    curses.nocbreak()
	    curses.endwin()
#	    termios.tcsetattr(sys.stdin.fileno(), TERMIOS.TCSANOW, self.origState)
#	    termios.tcflush(sys.stdin.fileno(), TERMIOS.TCIOFLUSH)
#	    termios.tcflush(sys.stdout.fileno(), TERMIOS.TCIOFLUSH)
#	    termios.tcflush(sys.stderr.fileno(), TERMIOS.TCIOFLUSH)
#	    sys.stdin.flush()
#	    sys.stdout.flush()
#	    while 1:
#		pass
ptkei-1.12/src/empDb.py0100600000076500007650000005753207007753363014004 0ustar  kevinkevin"""Routines to manage and store data from a local database."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import sys
import string
import cPickle
import operator
import time
import traceback

# Key Ideas:

# What is contained within this file:

# This file supports all the functions and classes that are necessary to
# import the empire database.  There are three main classes defined within
# this file: dictDB, Countries, and EmpTime.  See the documentation for
# each of these classes for more information on what they do.  This file
# can be used independently from the rest of the program.  To load the
# database, import this module and then call loadDB(name_of_file).


# Global variables:

# megaDB : This is the main data store for the current connection.
#
# DBIO : This is an instance of class DatabaseSaver.  It is used to
# load/save the global database.  (Since it only works on a global
# variable, it may as well be a global variable.)


# Accessing the empire database:

# The empire database is stored in the global variable megaDB.  It is
# generally accessed using empDb.megaDB.  This is a "mega" database - it is
# comprised of a number of sub-databases.  (megaDB is actually a dictionary
# with string keys that correspond to the various data that has been
# accumulated.)  In addition to the land, ship, plane, and sector data that
# is acquired via the dump commands, the megaDB also contains country
# information, telegrams, version data, etc.  (See the resetDB() routine
# for a complete list.)  An example - lets say the designation of a sector
# would like to be accessed - the reference is
# empDb.megaDB['SECTOR'][(x,y)]['des'].  empDb.megaDB refers to the mega
# database.  'SECTOR' is a reference to the sector sub-database.  (For
# historical reasons, those databases that can be dumped via a dump command
# have the same name as the corresponding dump identifier.)  (x,y) is a
# tuple that comprises the key for the sector.  'des' is for the
# designation.  (For those databases that have a corresponding dump, the
# variable names are from the dump header.  For databases that do not have
# a dump, see the resetDB() function.)


# The update database:

# Many of the database helper classes and all of the empire parsers utilize
# the update database that is stored in the global variable updateDB.
# Basically, whenever an _actual_ change is made to the mega database, the
# update database will also reflect that change.  The updateDB and megaDB
# look and behave identically.  The only difference is that megaDB will
# always contain a full set of data while the updateDB frequently only
# contains a small subset of the total data.  (That which has been updated
# recently.)  This feature is used by the Tk graphical interface to detect
# when an actual change to the database occurs, and to redraw where
# appropriate.  It is the responsibility of the interface to periodically
# check for updates.  Also, it is the interface's responsibility to clear
# the updateDB when done.


###########################################################################
#############################  dictDB class   #############################
class dictDB:
    """Store information for server databases.

    This class mimics a standard dictionary type in many ways.  (It defines
    the getitem, get, keys, values, and items methods.)  However, it is
    specifically tailored for the server databases.  (IE. data from a
    dump/pdump/sdump/etc. - the sector and unit databases.)  This tailoring
    is done in two ways.

    First, there is a seamless tracking of secondary indexes.  Any series
    of keys may be used to designate any number of secondary index at the
    creation time of this class.  When an update is made, not only is the
    item inserted into the primary database, but a reference is updated in
    the secondary databases.  (EG. The plane/ship/land units use a
    secondary database that is indexed by x and y.)

    Second, there is an automatic detection of updated items.  Any time an
    update is made to the database, an entry is filed in a special 'update'
    database.  This is used by the Tk graphics routines to ensure that only
    updated information is redrawn.  Since Tk redraws tend to be very time
    consuming, partial redraws become extremely important.

    Note: Don't manually update the dictionaries with inserts,
    modifications, or deletes.  All changes should be done through the
    updates() method.  (To delete a value, update its value to None.)
    """
    def __getstate__(self):
	"""Pickle module handler: determines what will be saved."""
	# Compress dictionary to header and value tuples.
	headers = self.__arrangeHeaders()
	# Preallocate the lists
	revrng = range(len(headers)-1, 0, -1)
	totalList = [None]*len(self.primary)
	i = 0
	for dict in self.primary.values():
	    subList = map(dict.get, headers)
	    # Eliminate trailing None values.
	    for j in revrng:
		if subList[j] is not None:
		    break
	    del subList[j+1:]
	    totalList[i] = subList
	    i = i + 1

	return {'primary_keytype': self.primary_keytype,
		'primary_headers' : headers,
		'primary_values': totalList,
		'timestamp': self.timestamp,
		'secondary_keys': self.secondary.keys()}
    def __setstate__(self, state):
	"""Pickle module handler: restore a saved class."""
	pri_keytype = self.primary_keytype = state['primary_keytype']
	self.timestamp = state['timestamp']
	self.unofficial_timestamp = state['timestamp']
	seckeys = state['secondary_keys']

	headers = state['primary_headers']
	valueList = state['primary_values']

	# Convert compressed header/value tuples to a dictionary
	self.primary = primary = {}
	for valTuple in valueList:
	    pri_val = {}
	    for i in range(len(valTuple)):
		val = valTuple[i]
		if val is not None:
		    pri_val[headers[i]] = val
	    pri_key = tuple(map(operator.getitem,
				(pri_val,)*len(pri_keytype),
				pri_keytype))
	    primary[pri_key] = pri_val

	# rebuild secondary indexes
	self.secondary = secondary = {}
	for sec_type in seckeys:
	    secondary[sec_type] = secIndex = {}
	    for pri_key, pri_val in primary.items():
		sec_key = tuple(map(pri_val.get, sec_type))
		try: secIndex[sec_key][pri_key] = pri_val
		except KeyError: secIndex[sec_key] = {pri_key: pri_val}

	# List of items that have recently changed
	self.uDB = {}

	# Initialize some handlers
	self.get = primary.get
	self.items = primary.items
	self.values = primary.values
	self.keys = primary.keys
	self.has_key = primary.has_key
    def __init__(self, key, *seckeys):
	# Initialization the class - called at creation time only.
	self.__setstate__({'primary_keytype': key,
			   'primary_headers': [],
			   'primary_values' : [],
			   'timestamp': 0,
			   'secondary_keys': seckeys})
    def __getitem__(self, k):
	return self.primary[k]

    def __arrangeHeaders(self):
	"""Return a list of all headers sorted by frequency."""
	headers = {}
	for dict in self.primary.values():
	    for j in dict.keys():
		if headers.has_key(j):
		    headers[j] = headers[j] + 1
		else:
		    headers[j] = 1
	lst = map(list, headers.items())
	for i in lst:
	    i.reverse()
	lst.sort()
	lst.reverse()
	lst = map(operator.getitem, lst, (1,) * len(lst))
	return lst

    def updates(self, list, returnRemaining=0):
	"""Update the database with the items stored in LIST.

	Given a list of dictionary types, extract the primary key from each
	dict, and add the item to the primary, secondary, and update
	databases.
	"""
	# Python optimization - copy frequently used variables into
	# local namespace.
	self__primary=self.primary;self__primary_keytype=self.primary_keytype
	self__secondary__items=self.secondary.items();self__uDB=self.uDB
	operator__delitem=operator.delitem;operator__getitem=operator.getitem
	__tuple=tuple;__map=map;__len=len

	if returnRemaining:
	    # This flag instructs the routine to return all items in the
	    # database that were _not_ updated during this call.
	    remainingList = self__primary.copy()
	for dict in list:
	    # find the key
	    pri_key = __tuple(__map(operator__getitem,
				    (dict,)*__len(self__primary_keytype),
				    self__primary_keytype))

	    # list all items being deleted
	    dict__items = dict.items()
	    keys = __map(operator__getitem, dict__items
			 , (0,)*__len(dict__items))
	    values = __map(operator__getitem, dict__items
			   , (1,)*__len(dict__items))
	    delList = []
	    try:
		while 1:
		    pos = values.index(None)
		    delList.append(keys[pos])
		    del keys[:pos+1], values[:pos+1]
	    except ValueError:
		pass

	    # find dictionary corresponding to key, and place
	    # in local variable d
	    try:
		d = self__primary[pri_key]
	    except KeyError:
		# New key
		d = self__primary[pri_key] = {}
	    else:
		# Key already present

		# Remove this item from the returnRemaining list
		if returnRemaining:
		    del remainingList[pri_key]

		# Don't update entries if no changes are made.  Although
		# this may be an expensive operation, the most expensive
		# operations (by far) are screen redraws - any code that
		# reduces redraws will improve performance.
		for key, value in dict__items:
		    try:
			if d[key] != value:
			    break
		    except KeyError:
			break
		else:
		    # The 'for loop' completed without an exception,
		    # and without any differences encountered - no
		    # changes present.
		    continue

		# Remove key from the secondary indexes
		for sec_type, sec_db in self__secondary__items:
		    sec_key = __tuple(__map(d.get, sec_type))
		    del sec_db[sec_key][pri_key]
		    if not sec_db[sec_key]:
			del sec_db[sec_key]

	    # Add item to the primary database
	    self__primary[pri_key].update(dict)
	    # Remove items selected for deletion
	    __map(operator__delitem, (self__primary[pri_key],)*__len(delList)
		  , delList)
	    # Add item to the updateDB
	    self__uDB[pri_key] = d
	    # Add key to the secondary indexes
	    for sec_type, sec_db in self__secondary__items:
		sec_key = __tuple(__map(d.get, sec_type))
		try: sec_db[sec_key][pri_key] = d
		except KeyError: sec_db[sec_key] = {pri_key:d}
	if returnRemaining:
	    return remainingList
    def getSec(self, sec_type):
	"""Return the secondary index (a dictionary) for SEC_TYPE."""
	return self.secondary[sec_type]
    def __repr__(self):
	return repr(self.primary)
    def __str__(self):
	return string.join(map(str, self.primary.items()), "\n")

###########################################################################
#############################  Country class  #############################

# Country id for the current player.
CN_OWNED = -1
# Country id for non-owned, and non-deity owned items.
CN_ENEMY = -2
# Country id for non-owned items.
CN_UNOWNED = -3

class Countries:
    """Track empire countries by name or number.

    Note: There will generally be only one instance of this class -
    megaDB['countries'].

    This class is used to solve one basic problem of tracking empire
    countries - sometimes the server returns a country name, other times it
    returns a country number, and other times it will returns both.  To
    solve this, the local databases store owners solely by country number;
    code can call back to this class when the name is desired.  When a
    country is identified by the server solely as a name, this class will
    attempt to resolve it to a number, or if that is not possible it will
    track the name until a number can be resolved for it.
    """
    uDB = {}

    def __getstate__(self):
	return {'unresolved':self.unresolved,
		'nameList':self.nameList,
		'idList': self.idList,
		'player': self.player}
    def __setstate__(self, state):
	self.unresolved = state['unresolved']
	self.nameList = state['nameList']
	self.idList = state['idList']
	self.player = state['player']
    def __init__(self):
	self.__setstate__({'unresolved': {},
			   'nameList': {},
			   'idList': {CN_OWNED:"Owned", CN_ENEMY:"Enemy",
				      CN_UNOWNED:"Unowned", None:"Unknown",
				      0:"Deity"},
			   'player': CN_OWNED})

    def getName(self, id):
	"""Return a name for a country identified by ID."""
	uid = id
	if id == -1:
	    uid = self.player
	try:
	    return "(%s) %s" % (uid, self.idList[id])
	except KeyError:
	    return "(%s)" % uid

    def getId(self, id):
	"""Return an empire Id for the country represented by token ID."""
	if id == CN_OWNED:
	    return self.player
	return id

    def getList(self):
	"""Return a list of all countries."""
	max = megaDB['version']['maxCountries']
	rng = range(max)
	lst = map(None, rng, map(self.idList.get, rng, [""]*max))
	lst.sort
	return lst

    def resolveName(self, name, dbname, key):
	"""Return a token for the country represented by name."""
	try:
	    return self.nameList[name]
	except KeyError:
	    # A country name with no currently available country Id.
	    try: list = self.unresolved[name]
	    except KeyError: list = self.unresolved[name] = []
	    list.append((dbname, key))
	    return name

    def resolveId(self, id):
	"""Return a token for the country represented by ID."""
	if id == self.player:
	    return CN_OWNED
	return id

    def resolveNameId(self, name, id):
	"""Return a token for the country; resolve any outstanding names."""
	if id == self.player:
	    self.foundResolotion(name, CN_OWNED)
	    return CN_OWNED
	self.foundResolotion(name, id)
	return id

    def resolvePlayer(self, name, id):
	"""Note the current player's id and name."""
	self.player = id
	self.foundResolotion(name, CN_OWNED)
	return CN_OWNED

    def foundResolotion(self, name, id):
	"""Attempt to resolve a name/id pair."""
	# Check if there are any outstanding names in the database
	# that should be updated with the newly found id.
	if self.unresolved.has_key(name):
	    list = self.unresolved[name]
	    for dbname, key in list:
		db = megaDB[dbname][key]
		# HACK++
		if db['owner'] == name:
		    db['owner'] = id
	    del self.unresolved[name]
	# Update the actual database.
	self.nameList[name] = id
	self.idList[id] = name

###########################################################################
#############################  Time class     #############################
s_time = (r"(?P\S\S\S) (?P\S\S\S) +(?P\d+) (?P\d+)"
	  +r":(?P\d+):(?P\d+)(?: (?P\d\d\d\d))?")
class EmpTime:
    """Track the empire server time.

    Note: There will generally be only one instance of this class -
    megaDB['time'].

    This code is used to guess at what time it is at the server.  It is
    mainly used to try and approximate when the next update will trigger.
    Times are noted by the various parsers, and sent to this class (via
    megaDB['time']) to note the time.
    """
    Months = {"Jan":1, "Feb":2, "Mar":3, "Apr":4, "May":5, "Jun":6,
	      "Jul":7, "Aug":8, "Sep":9, "Oct":10, "Nov":11, "Dec":12}
    Days = {"Mon":0, "Tue":1, "Wed":2, "Thu":3, "Fri":4, "Sat":5, "Sun":6}
    def __getstate__(self):
	return {'nextUpdate': self.nextUpdate}
    def __setstate__(self, state):
	self.nextUpdate = state['nextUpdate']

	self.uDB = {}
	self.observedDrift = None
	self.guessYear = time.localtime(time.time())[0]
    def __init__(self):
	self.__setstate__({'nextUpdate': None})
## 	self.timeDiff = 0.0

    def translateTime(self, match):
	"""Convert a regular expression processed time string to local time."""
	year = match.group('year')
	if year is None:
	    year = self.guessYear
	else:
	    year = self.guessYear = string.atoi(year)
	tt = tuple(map(string.atoi,
		       match.group('date', 'hour', 'minute', 'second')))
	tt = (year, self.Months[match.group('month')]) + tt + (
	    self.Days[match.group('day')], 0, 0)
	tt = time.mktime(tt)
	return tt
    def noteTime(self, match):
	"""Note the time from an empire server string."""
## 	tt = self.translateTime(match) + self.timeDiff
	tt = self.translateTime(match)
	ct = time.time()
	drift = ct - tt
	if self.observedDrift is None:
	    self.observedDrift = drift
	    self.uDB['drift'] = drift
	else:
	    variance = self.observedDrift - drift
	    if variance < -300.0 or variance > 300.0:
		# Something odd is happenining - reset the drift
		viewer.Error("PTkEI - time oddity..")
		self.observedDrift = drift
		self.uDB['drift'] = drift
	    elif self.observedDrift > drift:
		self.observedDrift = drift
		if variance > 0.5:
		    self.uDB['drift'] = drift
## 	    print "local:%s server:%s drift:%s offset:%s" % (
## 		ct, tt, self.observedDrift[0], self.timeDiff)

    def printTime(self, epoch):
	"""Print a server time using localtimes."""
	drift = self.observedDrift
	if drift is None:
	    drift = 0.0
	return time.ctime(epoch+drift)

##     def noteTimestamp(self, match, ts):
## 	tt = self.translateTime(match)
## 	self.timeDiff = ts-tt
## 	self.noteTime(match)
    def noteNextUpdate(self, match):
	"""Make a note of the next update."""
## 	self.nextUpdate = self.translateTime(match) + self.timeDiff
	self.nextUpdate = self.translateTime(match)
    def getCountDown(self):
	"""Return a tuple containing the time until the next update."""
	if self.nextUpdate is None:
	    # No time received from server yet.
	    return (None, None, None)
	drift = self.observedDrift
	if drift is None:
	    drift = 0.0
	count = self.nextUpdate - time.time() + drift
	count = divmod(count, (megaDB['version']['ETUSeconds']
			       * megaDB['version']['updateETUs']))[1]
	r, seconds = divmod(count, 60)
	hours, minutes = divmod(r, 60)
	return (int(hours), int(minutes), int(seconds))

###########################################################################
#############################  Useful functions ###########################

# Check for broken string.atoi function.
try:
    string.atoi('-')
except ValueError:
    # Working atoi
    fixedAtoI = string.atoi
else:
    # Broken atoi
    def fixedAtoI(s):
	"""Fixed string.atoi with +/- checking."""
	if s == '+' or s == '-':
	    raise ValueError
	return string.atoi(s)

#######  Tools for working with sectors.
#######

pathDirections = "ujnbgy"
pathReverseDirections = "bgyujn"
pathOffsets = ((1, -1), (2, 0), (1, 1), (-1, 1), (-2, 0), (-1, -1))

def sectorWrap(coord):
    """Return a unique (x,y) pair from an arbitrary (x,y) pair."""
    maxx, maxy = megaDB['version']['worldsize']
    halfx = maxx/2
    halfy = maxy/2
    return ((coord[0] + halfx)%maxx - halfx,
	    (coord[1] + halfy)%maxy - halfy)

def sectorNeighbors(coord):
    """Return a list of all the sectors surrounding COORD."""
    x, y = coord
    maxx, maxy = megaDB['version']['worldsize']
    halfx = maxx/2
    halfy = maxy/2
    neighbors = []
    for xoff, yoff in pathOffsets:
	neighbors.append(((x + xoff + halfx)%maxx - halfx,
			  (y + yoff + halfy)%maxy - halfy))
    return neighbors

def directionToSector(coord, direc):
    """Return a new sector from a sector and ascii direction."""
    offset = pathOffsets[string.index(pathDirections, direc)]
    maxx, maxy = megaDB['version']['worldsize']
    halfx = maxx/2
    halfy = maxy/2
    return ((coord[0] + offset[0] + halfx)%maxx - halfx,
	    (coord[1] + offset[1] + halfy)%maxy - halfy)

#######  Tools for interacting with the database.
#######

def GetPrompt():
    """Return a string with the main prompt."""
    ndb = megaDB['prompt']
    inform, minutes, btus = ndb['inform'], ndb['minutes'], ndb['BTU']
    if inform:
	return "(%s) [%d:%d] Command : " % (inform, minutes, btus)
    return "[%d:%d] Command : " % (minutes, btus)

###########################################################################
#############################  Useful functions ###########################

class DatabaseSaver:
    """Wrapper class for database IO.

    This class is used as a wrapper when reading/writing the database to
    disk.  It isn't used when accessing the database - calls to megaDB hit
    the database directly.  This class is used only for disk IO.

    This class has three public attributes:
	filename - the name of the file that stores the database.
	newDatabase - Boolean flag determines if this is a new database.
	needSave - Boolean flag that determines if the database should be
		saved upon exiting the client.

    The attributes newDatabase and needSave are both set externally from
    this class.  They are reset in the empQueue module when a connection is
    made to an empire server.

    Note: There is generally only one instance of this class - empDb.DBIO.
    """
    dbError = "Error saving/loading the database."
    DBVersion = 32.2

    def reset(self):
	"""Reset the main database to an initial state.

	This function should only be used when off-line.

	Note: This should be used with care - it will wipe all known
	information.
	"""
	global megaDB
	megaDB = {
	    'DB_Version': self.DBVersion,
	    'SECTOR': dictDB(('x', 'y')),
	    'SHIPS': dictDB(('id',), ('x', 'y')),
	    'PLANES': dictDB(('id',), ('x', 'y')),
	    'LAND UNITS': dictDB(('id',), ('x', 'y')),
	    'NUKES': dictDB(('x', 'y', 'type'), ('x', 'y')),
	    'LOST ITEMS': dictDB(('type', 'id', 'x', 'y')),
	    'login': {'host':"empire.idlpaper.com", 'port':5678,
		      'coun':"visitor", 'repr':"visitor"},
	    'version': {
		'worldsize':(255,255), 'maxCountries':255, 'ETUSeconds':1024,
		'updateETUs':1024, 'minutesOnline':0, 'BTURate':1.0,
		'growRate':1.0, 'harvestRate':1.0, 'birthRate':1.0,
		'UBirthRate':1.0, 'eatRate':1.0, 'BEatRate':1.0,
		'barInterest':1.0, 'civTax':1.0, 'UWTax':1.0, 'milCost':1.0,
		'reserveCost':1.0, 'happyRatio':1, 'educationRatio':1,
		'happyAverage':1, 'educationAverage':1, 'techBoost':1.0,
		'levelDecline':1, 'techLog':1.0, 'techBase':1.0,
		'objectMax':[1,1,1,1], 'objectMob':[1,1,1,1],
		'objectEff':[1,1,1,1], 'fireRange':1.0,
		'enabledOptions':[], 'disabledOptions':[]
		},

	    'nation':{'status':"", 'capital':(),
		      'budget':0.0, 'reserves':0, 'education':0.0,
		      'happiness':0.0, 'technology':0.0, 'research':0.0,
		      'techFactor':0.0, 'plagueFactor':0.0,
		      'maxPopulation':9999,
		      'maxCiv':9999, 'maxUW':9999, 'happyNeeded':0.0},
	    'realm': {},
	    'announcements': {'last':(), 'list':[]},
	    'telegrams': {'last':(), 'list':[]},
	    'countries': Countries(),
	    'prompt': {'minutes':0, 'BTU':0, 'inform':""},
	    'time': EmpTime(),
	    }
	self.resetUpdate()
	self.newDatabase = 1
	self.needSave = 0

    def resetUpdate(self):
	"""Reset the update database."""
	global updateDB
	updateDB = {
	    'SECTOR': megaDB['SECTOR'].uDB,
	    'SHIPS': megaDB['SHIPS'].uDB,
	    'PLANES': megaDB['PLANES'].uDB,
	    'LAND UNITS': megaDB['LAND UNITS'].uDB,
	    'NUKES': megaDB['NUKES'].uDB,
	    'LOST ITEMS': megaDB['LOST ITEMS'].uDB,
	    'version': {},
	    'nation': {},
	    'realm': {},
	    'announcements': {},
	    'telegrams': {},
	    'countries': megaDB['countries'].uDB,
	    'prompt': {},
	    'time': megaDB['time'].uDB
	    }

    def load(self, filename):
	"""Load database from FILE.

	If the file doesn't exist, create a default database.

	This function should only be used when off-line.
	"""
	self.filename = filename
	global megaDB
	try:
	    fl = open(filename, "rb")
	except IOError:
	    self.reset()
	else:
	    megaDB = cPickle.load(fl)
	    if megaDB['DB_Version'] != self.DBVersion:
		raise self.dbError, (
		    "PTkEI: Database has an incorrect version number.")
	    fl.close()
	    self.newDatabase = 0
	    self.needSave = 0
	    self.resetUpdate()

    def save(self):
	"""Write the database back to disk."""
	if not self.needSave:
	    # No need to save anything
	    return
	print "PTkEI: Saving DB to '%s'.." % self.filename
	fl = open(self.filename, 'wb')
	cPickle.dump(megaDB, fl, 1)
	fl.close()

DBIO = DatabaseSaver()
ptkei-1.12/src/empEval.py0100600000076500007650000004151306655766073014350 0ustar  kevinkevin"""Allows embedded python expressions to reference the internal database."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import string
import re
import operator
import sys

import empDb
import empParse


# Key Ideas:

# What is contained within this file:

# This file supports execution of arbitrary python expression that are
# embedded in strings.  Basically, this means queries like "foreach *
# ?civ=9 move c [sect] [civ/2] [dist]" can be made.  There are two main
# parts to the processing of python expressions.  The first is the
# conversion of empire selectors into python expressions.  The string "*
# ?civ=9" can be converted to a valid python expression by selectToExpr().
# The string "move c [sect] [civ/2] [dist]" is converted in the function
# estrToExpr().  The second major part is the application of these
# expressions to the database.  The function getSectors() takes a valid
# python expression, tests every sector in a given database, and then
# returns a list of all sectors that tested true for that expression.  The
# function evalString takes an embedded python expression and returns a
# string result.  The function foreach() is a combination of getSectors()
# and evalString() - given an arbitrary python test-expression and an
# arbitrary python string-expression, for every element in a database that
# tests true it returns an evaluation of the string.


# How the evaluation occurs:

# For performance reasons, the method used to achieve these evaluations is
# rather cumbersome.  For each database that can be queried, an instance of
# the class delayedBinding is created.  The delayedBinding class basically
# defines all the operator-overloading methods supported by python
# (__add__, __mul__, etc.).  When one of these class methods is invoked,
# the actual variable reference is extracted from a class variable
# (delayedValue).  (The variable delayedValue is essentially a global
# variable - this class is not multi-threaded safe.)  The instance then
# simulates the requested operation with this extracted variable. By
# delaying the binding of delayedValue until the actual time of the desired
# operation, the class can get away with delaying or avoiding the cost of
# an entire database conversion.  This leads to a significant improvement
# in performance; however, the methods used are questionable at best - it
# may be replaced sometime in the future.

###########################################################################
#############################  Evaluate Class   ###########################

class delayedBinding:
    """Delays a binding of a variable until runtime.

    This is a total hack!
    """
    delayedValue = None
    operator = operator
    for i, j in [
	('__add__', 'self.operator.add'), ('__sub__', 'self.operator.sub'),
	('__mul__', 'self.operator.mul'), ('__div__', 'self.operator.div'),
	('__mod__', 'self.operator.mod'),
	('__lshift__', 'self.operator.lshift'),
	('__rshift__', 'self.operator.__rshift__'),
	('__and__', 'self.operator.__and__'),
	('__or__', 'self.operator.__or__'), ('__xor__', 'self.operator.xor'),
	('__concat__', 'self.operator.concat'),
	('__repeat__', 'self.operator.repeat'),
	('__cmp__', 'cmp'), #('__coerce__', 'coerce'),
	]:
	exec ("def "+i+"(self, other):\n"
	      +" return "+j+"(self.convertField(), other)\n")
    for i, j in [
	('__radd__', 'self.operator.add'), ('__rsub__', 'self.operator.sub'),
	('__rmul__', 'self.operator.mul'), ('__rdiv__', 'self.operator.div'),
	('__rmod__', 'self.operator.mod'),
	('__rlshift__', 'self.operator.lshift'),
	('__rrshift__', 'self.operator.__rshift__'),
	('__rand__', 'self.operator.__and__'),
	('__ror__', 'self.operator.__or__'), ('__rxor__', 'self.operator.xor'),
	]:
	exec ("def "+i+"(self, other):\n"
	      +" return "+j+"(other, self.convertField())\n")
    for i, j in [
	('__neg__', 'self.operator.neg'), ('__pos__', 'self.operator.pos'),
	('__abs__', 'self.operator.abs'), ('__invert__', 'self.operator.inv'),
	('__not__', 'self.operator.__not__'),
	('__int__', 'int'), ('__long__', 'long'), ('__float__', 'float'),
	('__oct__', 'oct'), ('__hex__', 'hex'),
	('__nonzero__', 'self.operator.truth'),
	('__hash__', 'hash'), ('__str__', 'str'), ('__repr__', 'repr')
	]:
	exec ("def "+i+"(self):\n"
	      +" return "+j+"(self.convertField())\n")
    def __init__(self, name):
	self.name = name
    def convertField(self):
	try:
	    if callable(self.name):
		val = self.name(self.delayedValue)
	    else:
		val = self.delayedValue[self.name]
	except KeyError, e:
	    raise NameError, e
##  	try:
##  	    val = empDb.fixedAtoI(val)
##  	except ValueError:
##  	    try:
##  		val = string.atof(val)
##  	    except ValueError:
##  		pass
##  	except TypeError:
##  	    pass
	return val

###########################################################################
#############################  Empire Selectors ###########################

# Conversion of empire selectors to local database format.
# Note: This was taken from the html info pages.
def initializeSelectors():
    baseConversion = [
	('xloc', 2, 'x'), ('yloc', 2, 'y'), ('owner', 2),
	##	('timestamp',),

	# Added identifier:
	('sect', 3, (lambda ldb:
		     ("%s,%s" % (ldb['x'], ldb['y']))))
	]

    commodityConversion = [
	('civil', 2, 'civ'), ('milit', 3, 'mil'), ('shell', 2), ('gun', 2),
	# Yuck, sometimes this is 'pet', othertimes 'petrol'
	##	('petrol',),
	('iron', 2), ('dust', 2), ('bar', 2), ('food', 2), ('oil', 2),
	('lcm', 2), ('hcm', 2), ('uw', 2), ('rad', 3),
	]

    sectorConversion = baseConversion + commodityConversion + [
	('des', 2),
	('effic', 2, 'eff'), ('mobil', 2, 'mob'),
	('terr', 2),
	('road', 2), ('rail', 2), ('dfense', 2, 'defense'),
	('work', 2), ('coastal', 2, 'coast'),
	('newdes', 2, (lambda ldb:
		       (ldb['sdes'] == '_' and ldb['des'] or ldb['sdes']))),
    ##     ('newdes', 2, "(sdes != '_' and sdes or des)"),
	('min', 2), ('gold', 2),
	('fert', 2), ('ocontent', 2), ('uran', 2),
	('oldown', 2),
	('off', 2), ('xdist', 2, 'dist_x'), ('ydist', 2, 'dist_y'),
	('avail', 2),

	('petrol', 2, 'pet'),

	('c_dist', 4), ('m_dist', 4), ('u_dist', 4), ('s_dist', 4),
	('g_dist', 4), ('p_dist', 4), ('i_dist', 4), ('d_dist', 4),
	('b_dist', 4), ('f_dist', 4), ('o_dist', 4), ('l_dist', 4),
	('h_dist', 4), ('r_dist', 4),
	('c_del', 4, 'c_cut'), ('m_del', 4, 'm_cut'), ('u_del', 4, 'u_cut'),
	('s_del', 4, 's_cut'), ('g_del', 4, 'g_cut'),
	('p_del', 4, 'p_cut'), ('i_del', 4, 'i_cut'), ('d_del', 4, 'd_cut'),
	('b_del', 4, 'b_cut'), ('f_del', 4, 'f_cut'),
	('o_del', 4, 'o_cut'), ('l_del', 4, 'l_cut'), ('h_del', 4, 'h_cut'),
	('r_del', 4, 'r_cut'),

	# Added identifier:
	('dist', 2, (lambda ldb:
		     ("%s,%s" % (ldb['dist_x'], ldb['dist_y']))))
	]

    unitsConversion = baseConversion + [
	('type', 2),
	('effic', 2, 'eff'), ('mobil', 2, 'mob'),
	##  ('sell',),
	('tech', 2), ('uid', 2, 'id'),

	##	('group',) # Hrmm. this really should be in each subgroup

	##	('opx',), ('opy',), ('mission'),
	]

    shipConversion = commodityConversion + unitsConversion + [
	('fleet', 2, 'flt'), ('nplane', 2, 'pln'), ('fuel', 2),
	('nxlight', 2,'xl'), ('nchoppers', 3, 'he'),
	##	('autonav'),

	('group', 2, 'flt'),
	('petrol', 2),
	]

    planeConversion = unitsConversion + [
	('wing', 2), ('range', 2), ('ship', 2), ('att', 2),
	('def', 2), ('harden', 2, 'hard'), ('nuketype', 2, 'nuke'),
	##	('flags',),
	('land', 2),

	('group', 2, 'wing'),
	]

    landConversion = commodityConversion + unitsConversion + [
	('att', 2), ('def', 2), ('army', 4), ('ship', 2),
	('harden', 2, 'fort'), ('retreat', 2, 'retr'), ('fuel', 2),
	('land', 2), ('nxlight', 2, 'xl'),

	('group', 2, 'army'),
	('petrol', 2),
	]

    nukeConversion = baseConversion + [
	('number', 2, 'num'),
	##	('ship',), ('trade',), ('timestamp'),
	]

    versionDB = [
	('xmax', 2, (lambda ldb: ldb['worldsize'][0])),
	('ymax', 2, (lambda ldb: ldb['worldsize'][1])),
	]

    nationDB = [
	('cmax', 2, 'maxCiv'),
	('umax', 2, 'maxUW'),
	]

    def createConversionDB(list):
	dict = {}
	for i in list:
	    if len(i) < 3:
		val = i[0]
	    else:
		val = i[2]
	    delayedVar = delayedBinding(val)
	    for j in range(i[1], len(i[0])+1):
		dict[i[0][:j]] = delayedVar
	return dict

    # Initialize the execution eviornments for database evaluations.
    global selectors
    selectors = {
	'SECTOR': createConversionDB(sectorConversion),
	'SHIPS': createConversionDB(shipConversion),
	'PLANES': createConversionDB(planeConversion),
	'LAND UNITS': createConversionDB(landConversion),
	'NUKES': createConversionDB(nukeConversion),
	'nation': createConversionDB(nationDB),
	'version': createConversionDB(versionDB),
	}

    # Initialize a commodity transformation dictionary:
    global commodityTransform
    commodityTransform = {}
    for i in (
	('civil', 'civ'), ('milit', 'mil'), ('shell', 'shell'),
	('gun', 'gun'), ('petrol', 'pet'), ('iron', 'iron'),
	('dust', 'dust'), ('bar', 'bar'), ('food', 'food'),
	('oil', 'oil'), ('lcm', 'lcm'), ('hcm', 'hcm'), ('uw', 'uw'),
	('rad', 'rad')):
	for j in range(len(i[0])):
	    commodityTransform[i[0][:j+1]] = i[1]

initializeSelectors()


error = "empEval error"


###########################################################################
############################# Convert functions ###########################

s_realm = r"#(?P\d*)"
s_sectors = (r"(?P"+empParse.ss_sect+")(?::(?P"
	     +empParse.ss_sect+"))?,(?P"+empParse.ss_sect
	     +")(?::(?P"+empParse.ss_sect+"))?")
sectorsFormat = re.compile("^\*$|^"+s_realm+"$|^"+s_sectors+"$")
conditionsFormat = re.compile(
    r"^(?P\S+?)(?P[=<>#])(?P\S+?)(?:&(?P\S+))?$")
def selectToExpr(range, cond):
    """Convert a standard empire range/selectors to a python expression.

    This takes a range of the form 'x1:x2,y1:y2', 'x,y', '#?', or '*' (all
    the possible empire ranges) and a cond of the form 'var[#=<>]var&...',
    and converts it to a valid python expression.  (IE. 'xl>=x1 and xl<=x2
    and yl>=y1 and yl<=y2 and var==var and ...').  The result of this can
    then be passed to getSectors or foreach to return a list of db items
    that apply.

    Note: This function does not check for ownership.  Frequently, the
    string 'owner==-1 and ' is preprended to the output of this function to
    force it to only apply to owned objects.
    """
    mc = sectorsFormat.match(range)
    if not mc:
	raise error, "Coordinate regexp failure."

    if mc.group('realm') is not None:
	# Realm
	if mc.group('realm') == "":
	    rm = 0
	else:
	    rm = string.atoi(mc.group('realm'))
	try: val = empDb.megaDB['realm'][rm]
	except KeyError:
	    raise error, "Realm not in database."
	conditions = map(operator.add, ("xl>=", "xl<=", "yl>=", "yl<="),
			 map(str, val))
    elif mc.group('minX'):
	# Range
	if mc.group('maxX'):
	    conditions = map(operator.add, ("xl>=", "xl<="),
			     mc.group('minX', 'maxX'))
	else:
	    conditions = ["xl==" + mc.group('minX')]
	if mc.group('maxY'):
	    conditions[len(conditions):] = map(operator.add, ("yl>=", "yl<="),
					       mc.group('minY', 'maxY'))
	else:
	    conditions.append("yl==" + mc.group('minY'))
    else:
	# All ('*') selection
	conditions = []

    # Convert selectors into an eval string
    while cond:
	mc = conditionsFormat.match(cond)
	if not mc:
	    raise error, "Condition regexp failure."
	# Convert the two variables
	vars = []
	for i in mc.group('var', 'val'):
	    if len(i) == 1 and not i in string.digits:
		vars.append(repr(i))
	    else:
		vars.append(i)
	conditions.append("%s%s%s" % (
	    vars[0],
	    {'=':'==', '#':'!=', '<':'<', '>':'>'}[mc.group('opr')],
	    vars[1]))
	cond = mc.group('next')

    if not conditions:
	return "1"
    return string.join(conditions, " and ")

ss_normal = "[^\]\"']"
ss_quoted1 = "'.*?'"
ss_quoted2 = '".*?"'
s_pre = r"(?P
.*?)"
s_eval = r"(?P(?:"+ss_normal+"|"+ss_quoted1+"|"+ss_quoted2+")*)"
s_post = r"(?P.*)"
exprFormat = re.compile("^"+s_pre+"\["+s_eval+"\]"+s_post+"$")
def estrToExpr(txt):
    """Convert a string with embedded python expressions to an expression.

    This takes a string of the form 'text_1 [expr1] text_2 [expr2] ...' and
    converts it to ('text_1 '+str(expr1)+' text_2 '+str(expr2)+' ...').
    """
    cmd = ""
    while txt:
	mc = exprFormat.match(txt)
	if not mc:
	    cmd = cmd + "+"+`txt`
	    break
	cmd = cmd + "+"+`mc.group('pre')`
	e = mc.group('eval')
	txt = mc.group('post')
	cmd = cmd + "+str(("+e+"))"
    return cmd[1:]

###########################################################################
#############################  Eval functions   ###########################

def evalString(expr, dbname, db):
    """Evaluate an expression and return the result."""
    envio = selectors[dbname]
    delayedBinding.delayedValue = db
    try:
	return eval(expr, envio)
    except:
	raise error, (
	    'Evaluate error!\n"%s" raised %s with detail:\n"%s".'
	    % ((expr,)+tuple(sys.exc_info()[:2])))

def execCodeblock(dbname, execStr):
    """Execute a string for every item in a database.

    This is an internal function that is called by several functions below.
    This is really just useful for code consolidation.  The execStr
    parameter is very specific to the code block found within this
    function.
    """
    # Find every sector that applies
    envio = selectors[dbname]
    exec("def __func(__db, __class):\n"
	 +" __list = []\n"
	 +" __db = __db.items()\n"
	 +" __db.sort()\n"
	 +" for __db in __db:\n"
	 +"  __class.delayedValue = __db[1]\n"
	 +"  try:\n"
	 +execStr
	 +"  except NameError, e:\n"
	 +"   pass\n"
	 +" return __list\n", envio)
    f = envio['__func']
    del envio['__func']
    return f(empDb.megaDB[dbname], delayedBinding)

def getSectors(expr, dbname):
    """Given a python expression, return all db keys that apply.

    This functions takes a valid python expression (expr), evaluates it for
    every item in empDb.megaDB[dbname] and then returns a list of all the
    keys that tested true.
    """
    try:
	return execCodeblock(
	    dbname,
	    "   if ("+expr+"): __list.append(__db[0])\n")
    except:
	raise error, (
	    'GetSectors error in "%s"!\nException %s with detail:\n"%s".'
	    % ((expr,) + tuple(sys.exc_info()[:2])))

def getSectorDBs(expr, dbname):
    """Given a python expression, return a database with all that apply.

    This functions takes a valid python expression (expr), evaluates it for
    every item in empDb.megaDB[dbname] and then returns a database containg
    all the sector key/value pairs that tested true for the expression.
    """
    try:
	list = execCodeblock(
	    dbname,
	    "   if (%s): __list.append(__db)\n" % expr)
    except:
	raise error, (
	    'GetSectorDBs error in "%s"!\nException %s with detail:\n"%s".'
	    % ((expr,) + tuple(sys.exc_info()[:2])))
    dict = {}
    map(apply, [operator.setitem]*len(list),
	map(operator.add, ((dict,),)*len(list), list))
    return dict

##  def getMMoveInfo(commodity, sourceSelect, sourceLevel, sourceMob,
##  		 destSelect, destLevel, move_to, move_from, move_weight):
##      """Specialized data retriever for the mmove class."""
##      try:
##  	slist = execCodeblock(
##  	    'SECTOR',
##  	    "   if ("+sourceSelect+"): "
##  	    +"__list.append(((xloc+0, yloc+0), __db[1], int("
##  	    +commodity+"-("+sourceLevel+")), int(mob-("+sourceMob+"))))\n")
##  	dlist = execCodeblock(
##  	    'SECTOR',
##  	    "   if ("+destSelect+"): "
##  	    +"__list.append(((xloc+0, yloc+0), __db[1], int("
##  	    +destLevel+"-("+commodity+"))))\n")
##      except:
##  	raise error, (
##  	    'GetMMoveInfo error\nException %s with detail:\n"%s".'
##  	    % tuple(sys.exc_info()[:2]))
##      ddict = {}
##      for coord, db, amount in dlist:
##  	if amount > 0 and move_to(db, commodity):
##  	    ddict[coord] = amount
##      sdict = {}
##      for coord, db, amount, mobility in slist:
##  	if (amount > 0 and mobility > 0
##  	    and not ddict.has_key(coord)
##  	    and move_from(db, commodity)):
##  	    sdict[coord] = (amount, mobility,
##  			    move_weight(db, commodity))
##      return (sdict, ddict)

def foreach(cond_expr, txt_expr, dbname):
    """Combination of getSectors and evalString."""
    try:
	return execCodeblock(
	    dbname,
	    "   if ("+cond_expr+"): __list.append("+txt_expr+")\n")
    except:
	raise error, (
	    'Foreach error in "%s"/"%s"!\nException %s with detail:\n"%s".'
	    % ((cond_expr, txt_expr) + tuple(sys.exc_info()[:2])))
ptkei-1.12/src/empParse.py0100600000076500007650000015520106775577703014536 0ustar  kevinkevin"""Routines used to parse information from the server."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import string
import re
import operator

import empQueue
import empDb

# Key Ideas:

# What is contained within this file:

# This file contains all the standard low-level parsers.  For each client
# understood command there is a line in empQueue.standardParsers that
# points to a parser in this file.  In actuality, empQueue.standardParsers
# is really established in this file - in the initialize().  For more
# information on the classes, please see their individual documentation.


# How to setup a parser class:

# A parser class is a class that interprets data received from a command.
# The first thing that needs to be done is to setup a class that descends
# from empQueue.baseDisp.  The new class should define methods for some,
# none, or all of Begin(), data(), flush(), and End().  See the base class
# empQueue.baseDisp for more info on how this works.  Basically, if one of
# the above methods is not defined, empQueue.baseDisp will create a dummy
# reference that just passes the information to the next parser.  If a
# method is defined for any of the above, it is the responsibility of the
# class to pass the data onto the next parser.  This is usually done by
# invoking the appropriate method of self.out.  For example, to send a data
# line on, use self.out.data(msg).

# Begin() is invoked just before the command starts receiving data.  It is
# passed the name of the command as its only argument.

# flush() is invoked when the command receives a subprompt.  It is passed
# two arguments: The first is the string prompt, the second is either None
# or a function that should be called with the desired response.  If the
# second argument (the callback function) is the value None then no
# response is possible.  (This occurs when a bursted command answers a
# subprompt line.  In such cases, the Answer() method is called
# immediately after flush() with the text that answered the line.)

# Answer() is invoked when one of the command's subprompts is answered.  It
# is passed one argument - the string response.

# End() is called after the last line of data is received.  It is passed
# the same argument as Begin().


# Binding a command to a parse class:

# There are two ways to bind a command.  The first is to add the parser to
# list found in standardParsers (which is defined below in initialize()).
# This defines a low-level parser that will be called every time the
# command is sent to the server.  The second method is to assign the parser
# on a per-command basis.  This is done by specifying the parse class when
# invoking viewer.ioq.Send().  (See empCmd.EmpParse for more info on this
# command.)  To assign a parser to a specific command use
# viewer.ioq.Send("cmd_text_here", ParseClassHere()).  When "cmd_text_here"
# is sent to the server, ParseClassHere will receive the output from it.
# Note: binding a class on a per-command basis does not override a
# low-level parser.  If the command is also associated with a low-level
# parser, then the binded class will receive the data after the low-level
# parser.


CN_OWNED = empDb.CN_OWNED
CN_UNOWNED = empDb.CN_UNOWNED
CN_ENEMY = empDb.CN_ENEMY

###########################################################################
#############################  Map Functions  #############################
def updateDesignations(lst, mapType):
    """Update map designations from a list of (x,y,designation) triples.

    This function is complex, because it must determine when a designation
    change should be honored, and when it should be ignored.  Depending on
    mapType, it may be necessary to distrust the information.
    """
##     print lst
    DB = empDb.megaDB['SECTOR']
    changes = []
    for col, row, t in lst:
	if t in '0$' or string.lower(t) != t:
	    # Letters in map with uppercase letters are
	    # unit designators, and dont reveal any useful info.
	    continue
	ldict = DB.get((col, row), {})
	oldown = ldict.get('owner')
	olddes = ldict.get('des')
	ndict = {}
	if mapType in ('bmap', 'land'):
	    # bmap
	    if t == ' ':
		continue
	    if t == '?':
		if not olddes or (mapType == 'bmap' and olddes == '-'):
		    ndict['des'] = t
	    elif not olddes or oldown != CN_OWNED:
		ndict['des'] = t
	else:
	    if t == ' ':
		if oldown == CN_OWNED:
		    ndict['owner'] = CN_UNOWNED
		else:
		    continue
	    elif t == '?':
		if oldown is None or oldown == CN_OWNED:
		    ndict['owner'] = CN_UNOWNED
		# Hack for bridges
		if olddes == '.':
		    ndict['des'] = '='
		if not olddes:
		    ndict['des'] = t
	    elif t == '.' or t == '\\':
		if oldown != 0:
		    ndict['owner'] = 0
		ndict['des'] = t
	    elif t == '^':
		ndict['des'] = t
	    elif mapType == 'newdes':
		# future designations
		if t != '-':
		    ndict['owner'] = CN_OWNED
		if olddes == t:
		    ndict['sdes'] = '_'
		else:
		    ndict['sdes'] = t
	    elif mapType == 'radar':
		# radar maps
		ndict['des'] = t
	    else:
		# normal maps
		if t != '-':
		    ndict['owner'] = CN_OWNED
		ndict['des'] = t
	ndict['x'] = col
	ndict['y'] = row
	changes.append(ndict)
    DB.updates(changes)

def parseStarMap(sects, coord, mapType):
    """Handle a map that is returned from a radar or prompt."""
    worldx, worldy = empDb.megaDB['version']['worldsize']
    l = len(sects)
    hl = l/2
    tl = l*2

    lst = []
    for i in range(l):
	y = (coord[1]-hl+i + worldy/2) % worldy - worldy/2
	for j in range(abs(hl-i), tl-abs(hl-i), 2):
	    x = (coord[0]-l+j+1 + worldx/2) % worldx - worldx/2
	    lst.append((x, y, sects[i][j]))
    updateDesignations(lst, mapType)

###########################################################################
###########################  Header functions   ###########################
def sectToCoords(s, field):
    """Convert a string of the form 'x,y' to its x and y values."""
    try:
	idx = string.index(s, ',')
	return {'x':string.atoi(s[:idx]),
		'y':string.atoi(s[idx+1:])}
    except ValueError:
	return {}

def newdesToDes(s, field):
    """Convert a 'xy' string to designation x, and newdesignation y."""
    if len(s) == 2:
	return {'des':s[0], 'sdes':s[1]}
    return {'des':s[0], 'sdes':'_'}

def zeroIsOne(s, field):
    """Convert a 0 to 1."""
    if s == 0:
	return {field:1}
    return {field:s}

def convertOwner(s, field):
    return {'owner':empDb.megaDB['countries'].resolveId(s)}

def convertOldOwner(s, field):
    return {'oldown':empDb.megaDB['countries'].resolveId(s)}

def composeHeader(translations, *args):
    """Convert a series of string headers into a list of named qualifiers."""
    num = len(args)
    lastColumns = string.split(args[-1], ' ')
    startcut = 0
    new = []

    # Convert a set of header lines ('num' lines in 'args') to a list of
    # table column names.  This assumes the last line of the header will
    # always have the largest length.  (It breaks up the header rows by
    # column using the last row's field spacing as a guide.)
    for segment in lastColumns:
	endcut = startcut + len(segment)
	new.append(string.lstrip(string.join(
	    map(string.strip,
		map(operator.getslice, args, (startcut,)*num, (endcut,)*num)),
	    "\n")))
	startcut = endcut + 1
    new = filter(None, new)
##     print new

    # Now create a list of database keys for each of the header lines from
    # the translations mapping.  This also supports special translation
    # functions that handle header lines that don't have a one-to-one
    # mapping to a database field.
    final = []
    for i in new:
	try:
	    idx = translations[i]
	except KeyError:
	    final.append(None)
	else:
	    if callable(idx):
		final.append((lambda s, field=i, f=idx:
			      f(s, field)))
	    else:
		final.append(idx)
##     print final
    return final

def composeBody(hdr, msg):
    """Convert the body of a message that has a header HDR."""
    strs = string.split(msg)
    convertList(strs)
    if len(strs) == len(hdr):
	# Standard table format
	new = {}
	for field, value in map(None, hdr, strs):
	    if field is None:
		continue
	    if callable(field):
		new.update(field(value))
	    else:
		new[field] = value
## 	print new
	return new

def composePreamble(lst, mtch, str, translations=None):
    """Convert info of the form 'type val, type val, ...' to a list."""
    while str:
	mt = mtch.match(str)

	var, val = mt.group('comd', 'val')
	temp = [val]; convertList(temp); val = temp[0]
	if translations is None:
	    lst[var] = val
	else:
	    try:
		tran = translations[var]
	    except KeyError:
		pass
	    else:
		if callable(tran):
		    lst.update(tran(val, var))
		else:
		    lst[tran] = val
	str = mt.group('next')
    return lst

###########################################################################
#############################  Empire Constants ###########################

# Translate abbreviations to their full sector names.
# This is from the html info pages.
sectorDesignationConvert = {
    # BASICS
    '.': 'sea', '^': 'mountain', 's': 'sanctuary', '\\': 'wasteland',
    '-': 'wilderness', 'g': 'gold mine', 'c': 'capital', 'p': 'park',
    # COMMUNICATIONS
    '+': 'highway', ')': 'radar installation',
    '#': 'bridge head', '=': 'bridge span', '@': 'bridge tower',
    # INDUSTRIES
    'd': 'defense plant', 'i': 'shell industry', 'm': 'mine',
    'g': 'gold mine', 'h': 'harbor', 'w': 'warehouse',
    'u': 'uranium mine', '*': 'airfield', 'a': 'agribusiness',
    'o': 'oil field', 'j': 'light manufacturing', 'k': 'heavy manufacturing',
    '%': 'refinery',
    # MILITARY / SCIENTIFIC
    't': 'technical center', 'f': 'fortress', 'r': 'research lab',
    'n': 'nuclear plant', 'l': 'library/school',
    'e': 'enlistment center', '!': 'headquarters',
    # FINANCIAL
    'b': 'bank',
##      'v': 'trading post',
    }

# Translate full sector names to their abbreviations.
sectorNameConvert = {}
map(operator.setitem,
    (sectorNameConvert,) * len(sectorDesignationConvert),
    sectorDesignationConvert.values(),
    sectorDesignationConvert.keys())

# Create a regular expression that accepts full sector names.
s_sectorName = (r"(?P"+
		string.join(sectorDesignationConvert.values(), '|')+")")

try:
    # Ughh.  There is a bug in python 1.5.1 and earlier...
    string.atoi('-')
except ValueError:
    # Correct version
    def convertList(dlist):
	"""Convert a list of strings to native types."""
	string__atof = string.atof
	string__atoi = string.atoi
	string__atol = string.atol
	for i in range(len(dlist)):
	    val = dlist[i]
	    if '.' in val:
		try:
		    val = string__atof(val)
		except ValueError:
		    continue
	    else:
		try:
		    val = string__atoi(val)
		except OverflowError:
		    val = string__atol(val)
		except ValueError:
		    continue
	    dlist[i] = val
else:
    # Bug fix version
    def convertList(dlist):
	"""Convert a list of strings to native types."""
	string__atof = string.atof
	string__atoi = string.atoi
	string__atol = string.atol
	bugtest = ('+', '-')
	for i in range(len(dlist)):
	    val = dlist[i]
	    if val in bugtest:
		# Python 1.5.1 bug - converts '+'/'-' to 0..
		continue
	    if '.' in val:
		try:
		    val = string__atof(val)
		except ValueError:
		    continue
	    else:
		try:
		    val = string__atoi(val)
		except OverflowError:
		    val = string__atol(val)
		except ValueError:
		    continue
	    dlist[i] = val

###########################################################################
#############################  Parse classes  #############################
s_time = empDb.s_time
atoi = string.atoi
curtimeFormat = re.compile("^"+s_time+"$")


class ParseDump(empQueue.baseDisp):
    """Parse output from dump command."""
    dumpcommand = re.compile(r"^\s*\S+\s+(\S+)(?:\s+(\S+)\s*)?$")
##     timestamp = re.compile(r"^(?:\?timestamp>(\d+))?$")
    def Begin(self, cmd):
	self.out.Begin(cmd)

	self.getheader = 0
	self.Hlist = None
	self.updateList = []
	self.sett = self.full = 0
	self.DB = None

	# Determine if the timestamp should be set for this dump
	mm = self.dumpcommand.match(cmd)
	if (mm and mm.group(1) == '*'):
	    if not mm.group(2):
		# This is a total dump
		self.full = 1
		self.sett = 1
	    elif mm.group(2)[:3] == '?ti':
		# This is a timestamp dump
		self.sett = 1

    dumpheader = re.compile(
	r"^DUMP (?P.*) (?P\d+)$")
    def data(self, msg):
	self.out.data(msg)
	if self.Hlist is None:
	    # check time
	    mtch = curtimeFormat.match(msg)
	    if mtch:
##		   self.ctime = mtch
		empDb.megaDB['time'].noteTime(mtch)
		return
	    # parse header
	    mtch = self.dumpheader.match(msg)
	    if mtch:
		tp = mtch.group('dumpName')
		self.lost = (tp == 'LOST ITEMS')
		self.DB = empDb.megaDB[tp]
		ts = string.atoi(mtch.group('timeStamp'))
##		   empDb.megaDB['time'].noteTimestamp(self.ctime, float(ts))
		if self.sett:
		    # It is possible for the server to process a command
		    # during the same second it calculates the current
		    # timestamp.  This results in a timestamp that wont
		    # cover the last command.  Therefore, it is safest to
		    # assume the timestamp is always one second less than
		    # the value received from the server.
		    self.timestamp = ts-1

		# Set the "unoficial timestamp".  This is the timestamp
		# used for any dump commands requested.  It differs from
		# the official timestamp in that the offical one is only
		# updated after a complete dump has been fully processed -
		# it is the timestamp that is stored to disk.
		if self.sett:
		    self.DB.unofficial_timestamp = self.timestamp

		self.getheader = 1
	    elif self.getheader == 1:
		self.Hlist = string.split(msg)
		self.getheader = 0
		# HACK! Check for the existence of "difficult" fields
		self.oldownerHack = []
		self.nameHack = []
		for fieldname, pos in map(None, self.Hlist,
					  range(len(self.Hlist))):
		    if fieldname == "*":
			self.Hlist[pos] = "oldown"
			self.oldownerHack.append(pos)
		    elif fieldname == "name":
			self.nameHack.append(pos)
	    return

	# parse each line
	Dlist = string.split(msg)
	l = len(Dlist)
	# HACK! Fix problem with 'name' field
	if l >= len(self.Hlist):
	    for i in self.nameHack:
		start = end = i
		if len(Dlist[start]) == 1:
		    end = end + 1
		while Dlist[end][-1] != '"':
		    end = end + 1
##  		print start, end, string.join(Dlist[start:end+1])
		Dlist[start:end+1] = [string.join(Dlist[start:end+1])[1:-1]]
		l = l - (end-start)
	if l == len(self.Hlist):
	    # Normal line

	    # Convert string listing to native format
	    convertList(Dlist)

	    DDict = {'owner':CN_OWNED}
	    map(operator.setitem, [DDict]*l, self.Hlist, Dlist)
	    # HACK! Fix annoying '*' field
	    if self.oldownerHack:
		if DDict['oldown'] == '.':
		    DDict['oldown'] = CN_OWNED
		else:
		    DDict['oldown'] = CN_ENEMY

##  	    self.updateList.append(Dlist)
	    self.updateList.append(DDict)
	else:
	    # End of dump
	    self.Hlist = None

    def End(self, cmd):
	self.out.End(cmd)
	if self.DB is None:
	    # Something odd happened - no dump lines at all.
	    return

	# Update the database
	if not self.full:
	    # simple update
	    self.DB.updates(self.updateList)
##  	    self.DB.updates(listDict)
	else:
	    # A full dump
	    others = self.DB.updates(self.updateList, 1)
##  	    others = self.DB.updates(listDict, 1)
	    list = []
	    for i in others.values():
		if i.get('owner') == CN_OWNED:
		    dict = i.copy()
		    dict.update({'owner':CN_UNOWNED})
		    list.append(dict)
	    self.DB.updates(list)
	# Merge lost database with normal databases.
	if self.lost:
	    for i in empDb.updateDB['LOST ITEMS'].values():
		subDB = (('SECTOR', 'x', 'y'), ('SHIPS', 'id'),
			 ('PLANES', 'id'), ('LAND UNITS', 'id'),
			 ('NUKES', 'x', 'y'))[i['type']]
		key = []
		d = {}
		for j in subDB[1:]:
		    key.append(i[j])
		    d[j] = i[j]
		if empDb.megaDB[subDB[0]].get(tuple(key),
					{}).get('owner') == CN_OWNED:
		    d['owner'] = CN_UNOWNED
		    empDb.megaDB[subDB[0]].updates([d])
	    empDb.updateDB['LOST ITEMS'].clear()

	# Update the official timestamp.  (The timestamp stored on disk.)
	if self.sett:
	    self.DB.timestamp = self.timestamp

class ParseMap(empQueue.baseDisp):
    """Parse output from various map commands."""
    mapcommand = re.compile(r"^\s*(\S?)map")
    def Begin(self, cmd):
	self.out.Begin(cmd)
	self.Mpos = 0
	self.Mheader = []

	# Determine the type of map
	mm = self.mapcommand.match(cmd)
	if mm:
	    try:
		self.mapType = {'n':'newdes', 'b':'bmap'}[mm.group(1)]
	    except KeyError:
		self.mapType = ''
	else:
	    self.mapType = ''

    def data(self, msg):
	self.out.data(msg)
	# parse header
	msg_a = msg[:5]
	msg_b = msg[5:]
	if msg_a == "     ":
	    # Header or trailer
	    if self.Mpos == 2:
		# End of map
		self.Mpos = -1
		updateDesignations(self.lst, self.mapType)
		return
	    elif self.Mpos == 0:
		# First line of header
		self.Mhead = msg_b
		self.Mpos = 1
	    elif self.Mpos == 1:
		# Additional lines of header
		msg_b = string.replace(msg_b, "-", "0")
		self.Mhead = map(operator.add, self.Mhead, msg_b)
	else:
	    if self.Mpos == 1:
		# First line of data - convert alphanumeric columns to numeric
		self.Mpos = 2
		cols = map(string.atoi, self.Mhead)
		if len(cols) == 1:
		    # Can't accurately parse maps with 1 column
		    self.Mpos = -1
		    return
		# Fix negative values
		if cols[-1] < cols[-2]:
		    cols[-1] = - cols[-1]
		for i in range(len(cols)-1):
		    if cols[i] > cols[i+1]:
			cols[i] = - cols[i]
		self.oddcol = (cols[0] & 1)
		self.lst = []
		self.Mhead = cols
##  		print self.Mhead
	    elif self.Mpos != 2:
		# Ignore line
		return
	    # Must be a data line
	    row = string.atoi(msg_a)
	    # Parse map
	    oddstart = (row & 1) ^ self.oddcol
	    for i in range(oddstart, len(self.Mhead), 2):
		self.lst.append((self.Mhead[i], row, msg_b[i]))

ss_sect = r"-?\d+"
s_sector = r"(?P"+ss_sect+"),(?P"+ss_sect+")"
s_sector2 = r"(?P"+ss_sect+"),(?P"+ss_sect+")"
s_comm = r"(?P\S+)"
class ParseMove(empQueue.baseDisp):
    """Parse an explore prompt."""
    def __init__(self, disp):
	empQueue.baseDisp.__init__(self, disp)
	self.map = []

    ownSector = re.compile("^Sector "+s_sector+" is now yours\.$")
    def data(self, msg):
	mm = self.ownSector.match(msg)
	if mm:
	    x, y = map(string.atoi, mm.group('sectorX', 'sectorY'))
	    empDb.megaDB['SECTOR'].updates(
		[{'x': x, 'y': y, 'owner':CN_OWNED}])
	self.map.append(msg)
	self.out.data(msg)

    s_mob = r"(?P\d+\.\d+)"
    s_des = r"(?P.)"
    promptFormat = re.compile("^<"+s_mob+": "+s_des+" "+s_sector+"> $")
    def flush(self, msg, hdl):
	self.out.flush(msg, hdl)
	mm = self.promptFormat.match(msg)
	if mm:
	    # Extract map from last three lines of data
	    sects = []
	    for i in self.map[-3:]:
		sects.append(i[3:8])
	    coord = map(string.atoi, mm.group('sectorX', 'sectorY'))
	    parseStarMap(sects, coord, '')

s_landIdent = r"(?P\S+)(?:.+)? #(?P\d+)"
s_shipIdent = r"(?P\S+)(?:.+)? \(#(?P\d+)\)"
s_shipOrLand = r"(?:"+s_shipIdent+"|"+s_landIdent+")"
s_counName = r"(?P.*?)"
s_counId = r"\(#(?P\d+)\)"
s_counIdent = s_counName + " " + s_counId
s_eff = r"(?P\d+)%"
class ParseUnits(empQueue.baseDisp):
    """Parse info from a variety of unit type commands."""
    def Begin(self, cmd):
	self.out.Begin(cmd)
	self.num = None
	self.Map = []
    s_dist = r"(?P\d+)"
    start_radar = re.compile(r"^(?:"+s_shipOrLand+" at )?"
			     +s_sector+" efficiency "+s_eff
			     +", max range "+s_dist+"$")
    s_sectorStats = r"(?P(?: with (?:approx )?\d+ \S+)*)"
    s_shipOrSector = ("(?:"+s_shipIdent+"|"
		      +s_sectorName+" "+s_eff+" efficient"+s_sectorStats+")")
    view_info = re.compile(r"^(?:\[(?P.*?)\] )?"+s_shipIdent+" @ "
			   +s_sector+" "+s_eff+" "+s_sectorName+"$")
    view_stats = re.compile(
	r"^(?P\S+):(?P\d+)(?P)$")
    look_info = re.compile(r"^(?:Your|"+s_counIdent+") "+s_shipOrSector
			   +" @ "+s_sector+"$")
    look_stats = re.compile(
	r"^ with (?:approx )?(?P\d+) (?P\S+)(?P.*)$")
    unit_stop = re.compile(
	"^"+s_shipOrLand+" (?:stopped at|is out of mobility & stays in) "
	+s_sector+"$")
    def data(self, msg):
	self.out.data(msg)
	if self.num is not None:
	    # In a pre-established radar
	    self.Map.append(msg)
	    if len(self.Map) == self.num:
		parseStarMap(self.Map, self.coord, 'radar')
		del self.coord
		self.Map = []
		self.num = None
	    return
	# Check for start of radar
	mm = self.start_radar.match(msg)
	if mm:
	    self.coord = map(string.atoi, mm.group('sectorX', 'sectorY'))
	    self.num = string.atoi(mm.group('dist'))*2+1
	    self.Map = []
	    return
	# Check for view
	mm = self.view_info.match(msg)
	if mm:
	    lst = {}
	    composePreamble(lst, self.view_stats, mm.group('viewStats'),
			    {'oil':'ocontent','fert':'fert'})
	    x, y, eff = map(string.atoi,
			    mm.group('sectorX', 'sectorY', 'eff'))
	    lst.update({'des': sectorNameConvert[mm.group('sectorName')],
			'eff': eff, 'owner': CN_OWNED, 'x': x, 'y': y})
	    empDb.megaDB['SECTOR'].updates([lst])
	    self.Map = []
	    return
	# Check for lookout
	mm = self.look_info.match(msg)
	if mm:
	    own = mm.group('counId')
	    if own is None:
		own = CN_OWNED
	    else:
		own = empDb.megaDB['countries'].resolveNameId(
		    mm.group('counName'), string.atoi(own))
	    if mm.group('shipId'):
		# A ship
		x, y, id = map(string.atoi,
			       mm.group('sectorX', 'sectorY', 'shipId'))
		empDb.megaDB['SHIPS'].updates([
		    {'id': id, 'type':mm.group('shipType'),
		     'x': x, 'y': y, 'owner':own}])
	    else:
		lst = {'civ':0, 'mil':0}
		composePreamble(lst, self.look_stats, mm.group('sectorStats'),
				{'civ':zeroIsOne, 'mil':zeroIsOne})
		x, y, eff = map(string.atoi,
				mm.group('sectorX', 'sectorY', 'eff'))
		lst.update({'des': sectorNameConvert[mm.group('sectorName')],
			    'eff': eff, 'owner': own,
			    'x': x, 'y': y})
		empDb.megaDB['SECTOR'].updates([lst])
		self.Map = []
	    return
	# Check for unit stop
	mm = self.unit_stop.match(msg)
	if mm:
	    if mm.group('shipId'):
		# A ship
		x, y, id = map(string.atoi,
			       mm.group('sectorX', 'sectorY', 'shipId'))
		empDb.megaDB['SHIPS'].updates(
		    [{'id': id, 'type':mm.group('shipType'),
		      'owner':CN_OWNED, 'x': x, 'y': y}])
	    else:
		# A land unit
		x, y, id = map(string.atoi,
			       mm.group('sectorX', 'sectorY', 'landId'))
		empDb.megaDB['LAND UNITS'].updates(
		    [{'id': id, 'type':mm.group('landType'),
		      'owner':CN_OWNED, 'x': x, 'y': y}])
	    self.Map = []
	    return
	# Add to generic map prompt queue
	self.Map.append(msg)
    ss_mob = r"-?\d+\.\d"
    s_minMob = r"(?P"+ss_mob+")"
    s_maxMob = r"(?P"+ss_mob+")"
    nav_prompt = re.compile(r"^<"+s_minMob+":"+s_maxMob+": "+s_sector+"> $")
    def flush(self, msg, hdl):
	self.out.flush(msg, hdl)
	mm = self.nav_prompt.match(msg)
	if mm:
	    coord = map(string.atoi, mm.group('sectorX', 'sectorY'))
	    if len(self.Map) == 3:
		parseStarMap(self.Map, coord, 'radar')
	self.Map = []
	self.num = None

class ParseSimpleTime(empQueue.baseDisp):
    """Simple class that will extract the time from the first line."""
    def Begin(self, cmd):
	self.out.Begin(cmd)
	self.done = 0
    def data(self, msg):
	if not self.done:
	    mm = curtimeFormat.match(msg)
	    if mm:
		empDb.megaDB['time'].noteTime(mm)
	    self.done = 1
	self.out.data(msg)

class ParseSpy(empQueue.baseDisp):
    """Handle spy reports."""

    # Translations from header names to dump names:
    headerConvert = {
	'sect': sectToCoords, 'de': newdesToDes,
	'own': convertOwner, 'old\nown': convertOldOwner,
	'sct\neff': 'eff', 'rd\neff': 'road',
	'rl\neff': 'rail', 'def\neff': 'defense',
	'civ': 'civ', 'mil': 'mil', 'shl': 'shell', 'gun': 'gun',
	'pet': 'pet', 'food': 'food', 'bars': 'bar',
	#    'lnd': xxx, 'pln': xxx,
	}

    def __init__(self, disp):
	empQueue.baseDisp.__init__(self, disp)
	self.pos = 0
	self.changes = []

    s_unitStats = r"(?P\S+ \d+(?:, \S+ \d+)*)"
    unitInfo = re.compile("^(?:Enemy|Neutral) \("+s_counName
			  +"\) unit in "+s_sector+":  "+s_landIdent
			  +"(?: \("+s_unitStats+"\))?$")
    unitStats = re.compile(
	r"(?P\S+) (?P\d+)(?:, (?P.*))?")
    def data(self, msg):
	self.out.data(msg)
	if self.pos == 0:
	    if msg == 'SPY report':
		self.pos = 1
	elif self.pos == 1:
	    # Note date
	    mm = curtimeFormat.match(msg)
	    if mm:
		empDb.megaDB['time'].noteTime(mm)
		self.pos = 2
	elif self.pos == 2:
	    # first header
	    self.hdr = msg
	    self.pos = 3
	elif self.pos == 3:
	    # second line of header
	    self.hdr = composeHeader(self.headerConvert, self.hdr, msg)
	    self.pos = 4
	elif self.pos == 4:
	    # Meat of message
	    mt = self.unitInfo.match(msg)
	    if mt:
		lst = {}
		composePreamble(lst, self.unitStats, mt.group('unitStats'))
		lst['x'], lst['y'], id = map(
		    string.atoi,
		    mt.group('sectorX', 'sectorY', 'landId'))
		lst['id'] = id
		lst['type'] = mt.group('landType')
		lst['owner'] = empDb.megaDB['countries'].resolveName(
		    mt.group('counName'), 'LAND UNITS', (id,))
		empDb.megaDB['LAND UNITS'].updates([lst])
	    else:
		info = composeBody(self.hdr, msg)
		if info:
		    self.changes.append(info)
    def End(self, cmd):
	self.out.End(cmd)
	empDb.megaDB['SECTOR'].updates(self.changes)

class ParseAttack(empQueue.baseDisp):
    # 8,0 is a 100% AUJ highway with approximately 150 military.
    # 21 of your troops now occupy -10,12
    s_mil = "(?P\d+)"
    attackInfo = re.compile("^"+s_sector
			    +" is a "+s_eff+" "+s_counName+" "+s_sectorName
			    +r" with approximately "+s_mil+" military\.$")
    sectorTake = re.compile(r"^We have (?:captured|secured a beachhead at) "
			    +s_sector+", sir!$")
    unitMove = re.compile("^"+s_landIdent
			  +" (?:moves in to occupy|now occupies) "
			  +s_sector+"$")
    milMove = re.compile(
	"^"+s_mil+" (?:mil from (?:"+s_shipIdent+"|"+s_sector2
	+") moves into|of your troops now occupy) "+s_sector+"$")
    def data(self, msg):
	self.out.data(msg)
	mm = self.attackInfo.match(msg)
	if mm:
	    x, y, eff, mil = map(string.atoi,
				 mm.group('sectorX', 'sectorY', 'eff', 'mil'))
	    empDb.megaDB['SECTOR'].updates([{
		'x': x, 'y': y,
		'owner':empDb.megaDB['countries'].resolveName(
		    mm.group('counName'), 'SECTOR', (x, y)),
		'des':sectorNameConvert[mm.group('sectorName')],
		'eff': eff, 'mil': mil}])
	    return
	mm = self.sectorTake.match(msg)
	if mm:
	    x, y = map(string.atoi, mm.group('sectorX', 'sectorY'))
	    empDb.megaDB['SECTOR'].updates([{
		'x': x, 'y': y, 'owner': CN_OWNED}])
	    return
	mm = self.unitMove.match(msg)
	if mm:
	    x, y, id = map(string.atoi,
			   mm.group('sectorX', 'sectorY', 'landId'))
	    empDb.megaDB['LAND UNITS'].updates([{
		'id': id, 'type':mm.group('landType'),
		'owner':CN_OWNED, 'x': x, 'y': y}])
	    return
	mm = self.milMove.match(msg)
	if mm:
	    x, y, mil = map(string.atoi,
			    mm.group('sectorX', 'sectorY', 'mil'))
	    empDb.megaDB['SECTOR'].updates([{
		'x': x, 'y': y, 'owner':CN_OWNED, 'mil': mil}])

class ParseCoastWatch(empQueue.baseDisp):
    """Handle the coastwatch command."""
##   ptkei-0.21 (#  1) bb   battleship (#12) @ 0,-4
    s_counIdent = s_counName + r" \(#\s*(?P\d+)\)"
    line = re.compile("^\s*"+s_counIdent+" "+s_shipIdent+" @ "+s_sector)
    def data(self, msg):
	self.out.data(msg)
	mm = self.line.match(msg)
	if mm:
	    x, y, id, coun = map(
		string.atoi,
		mm.group('sectorX', 'sectorY', 'shipId', 'counId'))
	    empDb.megaDB['SHIPS'].updates([
		{'id': id, 'type':mm.group('shipType'),
		 'x': x, 'y': y,
		 'owner':empDb.megaDB['countries'].resolveNameId(
		     mm.group('counName'), coun)}])

class ParseSate(empQueue.baseDisp):
    def Begin(self, cmd):
	self.out.Begin(cmd)
	self.pos = 0
    # Translations from header names to dump names:
    conversion = (
	("Satellite sector report", 'SECTOR', 2, {
	    'sect': sectToCoords, 'type': 'des',
	    'own': convertOwner,
	    'sct\neff': 'eff', 'rd\neff': 'road',
	    'rl\neff': 'rail', 'def\neff': 'defense',
	    'civ': 'civ', 'mil': 'mil', 'shl': 'shell', 'gun': 'gun',
	    'iron': 'iron', 'pet': 'pet', 'food': 'food'}),
##  	("Satellite ship report", 'SHIPS', 1, {
##  	    'own', convertOwner, 'shp#':'id', 'ship type':
##  	    }),
##  	("Satellite unit report", 'LAND UNITS', 1, {
##  	    })
	)

    typeLine = re.compile(r"^Satellite (?PMap|Spy) Report:$")
    rangeLine = re.compile("^"+s_landIdent+" at "+s_sector
			   +" efficiency "+s_eff
			   +", max range (?P\d+)$")
    def data(self, msg):
	self.out.data(msg)
	if self.pos == 0:
	    mm = self.typeLine.match(msg)
	    if mm:
		type = mm.group('type')
		if type == 'Map':
		    self.type = 'land'
		else:
		    self.type = 'radar'
		self.pos = 1
	elif self.pos == 1:
	    mm = self.rangeLine.match(msg)
	    if mm:
		self.coord = map(string.atoi, mm.group('sectorX', 'sectorY'))
		self.range = string.atoi(mm.group('range'))*2+1
		self.pos = 2
	elif self.pos == 2:
	    for i in self.conversion:
		if i[0] == msg:
		    self.pos = 4
		    self.subpos = i
		    return
	    if msg == "Satellite radar report":
		self.buf = []
		self.pos = 3
	elif self.pos == 3:
	    self.buf.append(msg)
	    if len(self.buf) == self.range:
		parseStarMap(self.buf, self.coord, self.type)
		self.pos = -1
	elif self.pos == 4:
	    # Ignore date line
	    self.pos = 5
	    self.buf = [self.subpos[3]]
	elif self.pos == 5:
	    # Get the header
	    self.buf.append(msg)
	    if len(self.buf)-1 == self.subpos[2]:
		self.hdr = apply(composeHeader, tuple(self.buf))
##  		print self.buf, self.hdr
		self.buf = []
		self.pos = 6
	elif self.pos == 6:
	    if msg == "":
		# End of body
		empDb.megaDB[self.subpos[1]].updates(self.buf)
		self.pos = 2
		return
	    # Process a body line
	    info = composeBody(self.hdr, msg)
##  	    print info
	    if info:
		self.buf.append(info)

class ParseBuild(empQueue.baseDisp):
    """Parse build command."""
    buildItems = re.compile(r"^(?:Bridge span built over|"
			    "(?PBridge tower built in)|"
			    +s_shipOrLand+" built in sector) "
			    +s_sector+"$")
    def data(self, msg):
	self.out.data(msg)
	mm = self.buildItems.match(msg)
	if mm:
	    if mm.group('shipId'):
		# A ship
		x, y, id = map(
		    string.atoi,
		    mm.group('sectorX', 'sectorY', 'shipId'))
		empDb.megaDB['SHIPS'].updates(
		    [{'id': id, 'type':mm.group('shipType'),
		      'owner':CN_OWNED, 'x': x, 'y': y}])
	    elif mm.group('landId'):
		# Argh, can't distinguish between land units and planes..
		pass
## 		empDb.megaDB['LAND UNITS'].updates([{'id':mm.group('landId'),
## 					       'type':mm.group('landType'),
## 					       'owner':CN_OWNED,
## 					       'x':mm.group('sectorX'),
## 					       'y':mm.group('sectorY')}])
	    else:
		# A bridge
		if mm.group('tower'):
		    des = '@'
		else:
		    des = '='
		x, y = map(string.atoi, mm.group('sectorX', 'sectorY'))
		empDb.megaDB['SECTOR'].updates(
		    [{'owner':0, 'x': x, 'y': y, 'des':des}])

class ParseCapital(empQueue.baseDisp):
    """Parse output from capital command."""
    moveCapital = re.compile(r"^Capital now at "+s_sector+"\.$|"
			     +"^"+s_sector2+" is already your capital\.$")
    def data(self, msg):
	self.out.data(msg)
	mm = self.moveCapital.match(msg)
	if mm:
	    if mm.group('sectorX') is not None:
		loc = tuple(map(string.atoi, mm.group('sectorX', 'sectorY')))
	    else:
		loc = tuple(map(string.atoi, mm.group('sector2X', 'sector2Y')))
	    checkUpdated('nation', 'capital', loc)

class ParseReport(empQueue.baseDisp):
    """Parse output from report command."""
    def data(self, msg):
	mm = curtimeFormat.match(msg)
	if mm:
	    empDb.megaDB['time'].noteTime(mm)
	    return
	self.out.data(msg)
	line = string.split(msg)
	try:
	    id = string.atoi(line[0])
	except ValueError:
	    pass
	else:
	    empDb.megaDB['countries'].resolveNameId(line[1], id)

class ParseRelations(empQueue.baseDisp):
    """Parse output from relations."""
    s_yourRelation = r"(?P\S+)"
    s_theirRelation = r"(?P\S+)"
    header = re.compile("^\s*"+s_counName
			+" Diplomatic Relations Report\t"+s_time+"$")
    line = re.compile("^\s*"+s_counId+"\) "+s_counName+"\s+"
		      +s_yourRelation+"\s+"+s_theirRelation+"$")
    def data(self, msg):
	self.out.data(msg)
	mm = self.line.match(msg)
	if mm:
	    empDb.megaDB['countries'].resolveNameId(mm.group('counName'),
		string.atoi(mm.group('counId')))

class ParseRealm(empQueue.baseDisp):
    """Parse output from realm command."""
    s_range = (r"(?P"+ss_sect+"):(?P"+ss_sect
	       +"),(?P"+ss_sect+"):(?P"+ss_sect+")")
    s_realm = r"#(?P\d+)"
    rm = re.compile(r"^Realm " + s_realm + " is " + s_range + "$")
    def data(self, msg):
	self.out.data(msg)
	mtch = self.rm.match(msg)
	if mtch:
	    vals = tuple(map(string.atoi, mtch.groups()))
	    realm = vals[0]
	    vals = vals[1:]
	    checkUpdated('realm', realm, vals)

class ParseTele(empQueue.baseDisp):
    """Parse outgoing telegrams for future reference."""
    def Begin(self, cmd):
	self.out.Begin(cmd)
	self.to = None
	self.buf = ""
	self.pos = None
	self.max = None
    init = re.compile("^Enter telegram for "+s_counName+"$")
    def data(self, msg):
	self.out.data(msg)
	if self.to is None:
	    mm = self.init.match(msg)
	    if mm:
		self.to = mm.group('counName')
		return
	if msg == "Telegram aborted":
	    self.pos = None
	    return
    prompt = re.compile(r"^\s*(?P\d+) left: $")
    def flush(self, msg, hdl):
	try:
	    mm = self.prompt.match(msg)
	    if mm:
		left = string.atoi(mm.group('left'))
		if self.max is None:
		    self.max = left
		self.pos = self.max - left
	    else:
		self.pos = None
	finally:
	    self.out.flush(msg, hdl)
    def Answer(self, msg):
	self.out.Answer(msg)
	if msg is not None and self.pos is not None:
	    self.buf = self.buf[:self.pos] + msg + '\n'
    def End(self, cmd):
	self.out.End(cmd)
	if self.to is not None and self.pos is not None:
	    msg = string.split(self.buf, '\n')
	    del msg[-1]
	    msg[:0] = ["> Telegram to "+self.to]
	    if msg[-1] == '.':
		del msg[-1]
	    empDb.megaDB['telegrams']['list'].append(msg)
	    try:
		empDb.updateDB['telegrams']['list'].append(msg)
	    except KeyError:
		empDb.updateDB['telegrams']['list'] = [msg]

class ParseRead(empQueue.baseDisp):
    """Parse and store telegrams and announcements.

    This parser is responsible for making a copy of all correspondence that
    is received.  It then stores these telegrams and annoucements in the
    database.
    """
    def Begin(self, cmd):
	self.out.Begin(cmd)

	# Storage for the current telegram
	self.stor = None
	# List of all telegrams received that have not been processed.
	self.tlist = []

	c = string.lstrip(cmd)
	if c[:3] == 'wir':
	    self.dbname = 'announcements'
	else:
	    self.dbname = 'telegrams'

	# The latest telegram header.
	self.last = empDb.megaDB[self.dbname]['last']

    headerInfo = re.compile(
	r"^> (?P.*?)(?: from "
	+s_counName+", "+s_counId+")?  dated "+s_time+"$")
    def data(self, msg):
	self.out.data(msg)
	if msg[:1] == '>':
	    # A message header
	    mm = self.headerInfo.match(msg)
	    if mm:
		counId = mm.group('counId')
		if counId is not None:
		    counId = empDb.megaDB['countries'].resolveNameId(
			mm.group('counName'), string.atoi(counId))
		msg = (mm.group('type'), counId,
		       empDb.megaDB['time'].translateTime(mm))
	    # Check if this message is a duplicate.
	    if msg == self.last:
		self.stor = None
		self.tlist = []
		return
	    # Remove the annoying empty line at the end of each message.
	    if self.stor is not None and self.stor[-1] == '':
		del self.stor[-1]
	    self.stor = [msg]
	    self.tlist.append(self.stor)
	elif self.stor is not None:
	    # message body
	    self.stor.append(msg)
    def process(self):
	"""Merge the internal list of telegrams with the main database."""
	if not self.tlist:
	    return
	db = empDb.megaDB[self.dbname]
	udb = empDb.updateDB[self.dbname]
	db['last'] = udb['last'] = self.tlist[-1][0]
	lst = db['list']
	lst[len(lst):] = self.tlist
	try:
	    lst = udb['list']
	    lst[len(lst):] = self.tlist
	except KeyError:
	    udb['list'] = self.tlist
    def End(self, cmd):
	self.out.End(cmd)
	# Remove the annoying empty line at the end of each message.
	if self.stor is not None and self.stor[-1] == "":
	    del self.stor[-1]
	self.process()
    def flush(self, msg, hdl):
	self.out.flush(msg, hdl)
	self.process()
	self.stor = None
	self.tlist = []

ss_flt = r"\d+(?:\.\d+)?"

class ParseVersion(empQueue.baseDisp):
    """Parse the version info."""
    def Begin(self, cmd):
	self.out.Begin(cmd)
	self.pos = 0
    versionVars = re.compile(
	r"^World size is (?P\d+) by (?P\d+)\.$|"
	r"^There can be up to (?P\d+) countries\.$|"

	# An Empire time unit is 75 seconds long.
	r"^An Empire time unit is (?P\d+) seconds long\.$|"
	# The current time is Sun Sep 6 18:15:49.
	r"^The current time is "+s_time+r"\.$|"
	# An update consists of 48 empire time units.
	r"^An update consists of (?P\d+) empire time units\.$|"
	# Each country is allowed to be logged in 1440 minutes a day.
	r"^Each country is allowed to be logged in "
	r"(?P\d+) minutes a day\.$|"
	# It takes 8.33 civilians to produce a BTU in one time unit.
	r"^It takes (?P"+ss_flt
	+r") civilians to produce a BTU in one time unit\.$|"

	# A non-aggi, 100 fertility sector can grow 0.12 food per etu.
	r"^A non-aggi, 100 fertility sector can grow (?P"
	+ss_flt+r") food per etu\.$|"
	#  1000 civilians will harvest 1.3 food per etu.
	r"^1000 civilians will harvest (?P"+ss_flt
	+r") food per etu\.$|"
	#  1000 civilians will give birth to 5.0 babies per etu.
	r"^1000 civilians will give birth to (?P"+ss_flt
	+r") babies per etu\.$|"
	#  1000 uncompensated workers will give birth to 2.5 babies.
	r"^1000 uncompensated workers will give birth to (?P"+ss_flt
	+r") babies\.$|"
	#  In one time unit, 1000 people eat 0.5 units of food.
	r"^In one time unit, 1000 people eat (?P"+ss_flt
	+r") units of food\.$|"
	#  1000 babies eat 6.0 units of food becoming adults.
	r"^1000 babies eat (?P"+ss_flt
	+r") units of food becoming adults\.$|"

	# Banks pay $250.00 in interest per 1000 gold bars per etu.
	r"^Banks pay \$(?P"+ss_flt
	+r") in interest per 1000 gold bars per etu\.$|"
	# 1000 civilians generate $8.33, uncompensated workers $1.78 each time unit.
	r"^1000 civilians generate \$(?P"+ss_flt
	+r"), uncompensated workers \$(?P"+ss_flt
	+r") each time unit\.$|"
	# 1000 active military cost $83.33, reserves cost $8.33.
	r"^1000 active military cost \$(?P"+ss_flt
	+r"), reserves cost \$(?P"+ss_flt+r")\.$|"
	# Happiness p.e. requires 1 happy stroller per 5000 civ.
	r"^Happiness p\.e\. requires 1 happy stroller per "
	r"(?P\d+) civ\.$|"
	# Education p.e. requires 1 class of graduates per 4000 civ.
	r"^Education p\.e\. requires 1 class of graduates per "
	r"(?P\d+) civ\.$|"
	# Happiness is averaged over 48 time units.
	r"^Happiness is averaged over (?P\d+) time units\.$|"
	# Education is averaged over 192 time units.
	r"^Education is averaged over (?P\d+) time units\.$|"
	# The technology/research boost you get from the world is 50.00%.
	r"^The technology/research boost you get from the world is "
	r"(?P"+ss_flt+")%\.$|"
	# Nation levels (tech etc.) decline 1% every 96 time units.
	r"^Nation levels \(tech etc\.\) decline 1% every "
	r"(?P\d+) time units\.$|"
	# Tech Buildup is limited to logarithmic growth (base 2.00) after 1.00.
	r"^Tech Buildup is limited to logarithmic growth \(base (?P"
	+ss_flt+r")\) after (?P"+ss_flt+r")\.$|"

	# Maximum mobility		127	127	127	127
	r"^Maximum mobility\s+(?P.*)$|"
	# Max mob gain per update		48	72	48	48
	r"^Max mob gain per update\s+(?P.*)$|"
	# Max eff gain per update		--	100	96	96
	r"^Max eff gain per update\s+(?P.*)$|"

	# Fire ranges are scaled by 1.00
	r"^Fire ranges are scaled by (?P"+ss_flt+r")$|"

	r"^(?P)Options enabled in this game:$|"
	r"^(?P)Options disabled in this game:$"
	)
    def data(self, msg):
	self.out.data(msg)
	if self.pos > 0:
	    if msg == "":
		name = {1:'enabledOptions', 2:'disabledOptions'}[self.pos]
		self.opts.sort()
		checkUpdated('version', name, self.opts)
		self.pos = 0
	    self.opts[:0] = filter(
		None, map(string.strip, string.split(msg, ',')))
	    return
	mm = self.versionVars.match(msg)
	if mm is None:
	    return
	(maxX, maxY, coun,
	 etu, date, updt, minutes, btu,
	 grow, harv, birth, ubirth, eat, baby,
	 interest, tax, utax, milcost, rescost, stroll,
	 grad, havg, eavg, boost, decline, tbase, tafter,
	 Omax, Omob, Oeff, fire, goOptions, goNoOptions) = mm.group(
	     'maxX', 'maxY', 'coun',
	     'etu', 'date', 'updt', 'minutes', 'btu',
	     'grow', 'harv', 'birth', 'ubirth', 'eat', 'baby',
	     'interest', 'tax', 'utax', 'milcost', 'rescost', 'stroll',
	     'grad', 'havg', 'eavg', 'boost', 'decline', 'tbase', 'tafter',
	     'Omax', 'Omob', 'Oeff', 'fire', 'goOptions', 'goNoOptions')
	if maxX is not None:
	    checkUpdated('version', 'worldsize',
			 (string.atoi(maxX), string.atoi(maxY)))
	elif coun is not None:
	    checkUpdated('version', 'maxCountries', string.atoi(coun))
	elif etu is not None:
	    checkUpdated('version', 'ETUSeconds', string.atoi(etu))
	elif date is not None:
	    empDb.megaDB['time'].noteTime(mm)
	elif updt is not None:
	    checkUpdated('version', 'updateETUs', string.atoi(updt))
	elif minutes is not None:
	    checkUpdated('version', 'minutesOnline', string.atoi(minutes))
	elif btu is not None:
	    checkUpdated('version', 'BTURate', string.atof(btu))
	elif grow is not None:
	    checkUpdated('version', 'growRate', string.atof(grow))
	elif harv is not None:
	    checkUpdated('version', 'harvestRate', string.atof(harv)/1000.0)
	elif birth is not None:
	    checkUpdated('version', 'birthRate', string.atof(birth)/1000.0)
	elif ubirth is not None:
	    checkUpdated('version', 'UBirthRate', string.atof(ubirth)/1000.0)
	elif eat is not None:
	    checkUpdated('version', 'eatRate', string.atof(eat)/1000.0)
	elif baby is not None:
	    checkUpdated('version', 'BEatRate', string.atof(baby)/1000.0)
	elif interest is not None:
	    checkUpdated('version', 'barInterest',
			 string.atof(interest)/1000.0)
	elif tax is not None:
	    checkUpdated('version', 'civTax', string.atof(tax)/1000.0)
	elif utax is not None:
	    checkUpdated('version', 'UWTax', string.atof(utax)/1000.0)
	elif milcost is not None:
	    checkUpdated('version', 'milCost', string.atof(milcost)/1000.0)
	elif rescost is not None:
	    checkUpdated('version', 'reserveCost', string.atof(rescost)/1000.0)
	elif stroll is not None:
	    checkUpdated('version', 'happyRatio', string.atoi(stroll))
	elif grad is not None:
	    checkUpdated('version', 'educationRatio', string.atoi(grad))
	elif havg is not None:
	    checkUpdated('version', 'happyAverage', string.atoi(havg))
	elif eavg is not None:
	    checkUpdated('version', 'educationAverage', string.atoi(eavg))
	elif boost is not None:
	    checkUpdated('version', 'techBoost', string.atof(boost))
	elif decline is not None:
	    checkUpdated('version', 'levelDecline', string.atoi(decline))
	elif tbase is not None:
	    checkUpdated('version', 'techLog', string.atof(tbase))
	elif tafter is not None:
	    checkUpdated('version', 'techBase', string.atof(tafter))
	elif Omax is not None:
	    val = []
	    for i in string.split(Omax):
		if i == '--': val.append(99999)
		else: val.append(string.atoi(i))
	    checkUpdated('version', 'objectMax', val)
	elif Omob is not None:
	    val = []
	    for i in string.split(Omob):
		if i == '--': val.append(99999)
		else: val.append(string.atoi(i))
	    checkUpdated('version', 'objectMob', val)
	elif Oeff is not None:
	    val = []
	    for i in string.split(Oeff):
		if i == '--': val.append(99999)
		else: val.append(string.atoi(i))
	    checkUpdated('version', 'objectEff', val)
	elif fire is not None:
	    checkUpdated('version', 'fireRange', string.atof(fire))
	elif goOptions is not None:
	    self.opts = []
	    self.pos = 1
	elif goNoOptions is not None:
	    self.opts = []
	    self.pos = 2

class ParseNation(empQueue.baseDisp):
    """Parse nation command."""
    nationVars = re.compile(
	# (#6) TestPtkei Nation Report	Thu Nov 12 13:27:43 1998
	"^"+s_counId+" "+s_counName+" Nation Report\t"+s_time+"$|"
	# Nation status is ACTIVE     Bureaucratic Time Units: 640
	r"^Nation status is (?P.*?)\s+|"
	# 100% eff capital at 0,-2 has 805 civilians & 5 military
	+s_eff+r" eff (?:mountain )?capital at "+s_sector
	+r" has (?P\d+) civilians? & (?P\d+) military$|"
	"^No capital\. \(was at "+s_sector2+"\)$|"
	#  The treasury has $35703.00     Military reserves: 2769
	r"^ The treasury has \$(?P"+ss_flt
	+r")\s+Military reserves: (?P\d+)$|"
	# Education.......... 78.35       Happiness.......  0.00
	r"^Education\.*\s*(?P"+ss_flt
	+r")\s+Happiness\.*\s*(?P"+ss_flt+")$|"
	# Technology.........251.80       Research........  0.00
	r"^Technology\.*\s*(?P"+ss_flt
	+r")\s*Research\.*\s*(?P"+ss_flt+")$|"
	# Technology factor : 66.80%     Plague factor :   0.00%
	r"^Technology factor :\s*(?P"+ss_flt
	+r")%\s+Plague factor :\s*(?P"+ss_flt+")%$|"
	# Max population : 999
	r"^Max population :\s*(?P\d+)$|"
	# Max safe population for civs/uws: 805/891
	r"^Max safe population for civs/uws: (?P\d+)/(?P\d+)$|"
	# Happiness needed is 31.410360
	r"^Happiness needed is (?P"+ss_flt+")$")

    def data(self, msg):
	self.out.data(msg)
	mm = self.nationVars.match(msg)
	if mm is None:
	    return
	(counId, counName, date, status, eff, sectorX,
	 sectorY, sector2X, sector2Y, cciv, cmil, bud,
	 resv, edu, hap, tech, res, tfact, pfact,
	 pop, civs, uws, nhap) = mm.group(
	     'counId', 'counName', 'date', 'status', 'eff', 'sectorX',
	     'sectorY', 'sector2X', 'sector2Y', 'cciv', 'cmil', 'bud',
	     'resv', 'edu', 'hap', 'tech', 'res', 'tfact', 'pfact',
	     'pop', 'civs', 'uws', 'nhap')
	if counId is not None:
	    empDb.megaDB['time'].noteTime(mm)
	    empDb.megaDB['countries'].resolvePlayer(
		counName, string.atoi(counId))
	elif status is not None:
	    checkUpdated('nation', 'status', status)
	elif eff is not None:
	    checkUpdated('nation', 'capital',
			 (string.atoi(sectorX), string.atoi(sectorY)))
	    empDb.megaDB['SECTOR'].updates([{
		'x':string.atoi(sectorX), 'y':string.atoi(sectorY),
		'eff': string.atoi(eff), 'mil':string.atoi(cmil),
		'civ': string.atoi(cciv)}])
	elif sector2X is not None:
	    checkUpdated('nation', 'capital', ())
	elif bud is not None:
	    checkUpdated('nation', 'budget', string.atof(bud))
	    checkUpdated('nation', 'reserves', string.atoi(resv))
	elif edu is not None:
	    checkUpdated('nation', 'education', string.atof(edu))
	    checkUpdated('nation', 'happiness', string.atof(hap))
	elif tech is not None:
	    checkUpdated('nation', 'technology', string.atof(tech))
	    checkUpdated('nation', 'research', string.atof(res))
	elif tfact is not None:
	    checkUpdated('nation', 'techFactor', string.atof(tfact))
	    checkUpdated('nation', 'plagueFactor', string.atof(pfact))
	elif pop is not None:
	    checkUpdated('nation', 'maxPopulation', string.atoi(pop))
	elif civs is not None:
	    checkUpdated('nation', 'maxCiv', string.atoi(civs))
	    checkUpdated('nation', 'maxUW', string.atoi(uws))
	elif nhap is not None:
	    checkUpdated('nation', 'happyNeeded', string.atof(nhap))

class ParseUpdate(empQueue.baseDisp):
    """Parser for the update command.

    Grab info that will allow the client to calculate when the next update
    will occur.
    """
## The next update is at Sun Sep  6 20:00:00.
## The current time is	 Sun Sep  6 19:07:38.
    getTimes = re.compile(
	r"^(?:(?P)The next update is at|The current time is  ) "
	+s_time+r"\.$")
    def data(self, msg):
	self.out.data(msg)
	mm = self.getTimes.match(msg)
	if mm is None:
	    return
	if mm.group('next') is not None:
	    empDb.megaDB['time'].noteNextUpdate(mm)
	else:
	    empDb.megaDB['time'].noteTime(mm)

class ParseSpyPlane(empQueue.baseDisp):
    """Handle spy plane reports."""

    # Translations from header names to dump names:
    headerConvert = {
        'sect': sectToCoords, 'type': newdesToDes,
        'own': convertOwner, 'sct\neff': 'eff', 'rd\neff': 'road',
        'rl\neff': 'rail', 'def\neff': 'defense',
        'civ': 'civ', 'mil': 'mil', 'shl': 'shell', 'gun': 'gun',
        'iron': 'iron', 'pet': 'pet', 'food': 'food',
        }

    def __init__(self, disp):
        empQueue.baseDisp.__init__(self, disp)
        self.mode = 0
        self.sect_changes = []
        self.ship_changes = []
        self.land_changes = []

    seaSect = re.compile(r"^flying over sea at "+s_sector)
    shipHeader = re.compile(r"^\s*own\s+shp\#")
    landHeader = re.compile(r"^\s*own\s+lnd\#")
    uStats = re.compile(r"^\s*(?P\d+)\s+(?P\d+)\s+(?P\S+)\s+"+
                        r"\S+\s+"+s_sector+"\s+"+s_eff)
    def data(self, msg):
        self.out.data(msg)
        if self.mode == 0:
            if msg == 'SPY Plane report':
                self.mode = 1
        elif self.mode == 1:
            # Note date
            mm = curtimeFormat.match(msg)
            if mm:
                empDb.megaDB['time'].noteTime(mm)
                self.mode = 2
        elif self.mode == 2:
            # first header
            self.hdr = msg
            self.mode = 3
        elif self.mode == 3:
            # second line of header
            self.hdr = composeHeader(self.headerConvert, self.hdr, msg)
            self.mode = 4
        elif self.mode == 4:
            if self.shipHeader.match(msg):
                self.mode = 5
            elif self.landHeader.match(msg):
                self.mode = 6
            else:
                info = self.seaSect.match(msg)
                if info:
                    x, y = map(string.atoi, info.group('sectorX', 'sectorY'))
                    info = {'owner': 0, 'des': '.', 'x': x, 'y': y}
		    self.sect_changes.append(info)
# for some reason spy planes can't see ships at sea. is this a server bug?
                else:
                   info = composeBody(self.hdr, msg)
                   if info:
                       self.sect_changes.append(info)
# the other case that could come up is flak a message of the form:
# "firing 9 flak guns in 26,2..."
# I'm not sure what if any useful info we can derive from this other than the
# recon report that said there weren't any guns in that sector was wrong.
        elif self.mode == 5:
            info = self.uStats.match(msg)
            if info:
                id, x, y, owner, eff = map(string.atoi,
                                           info.group('id', 'sectorX',
                                                      'sectorY', 'own', 'eff'))
                if owner == empDb.megaDB['countries'].player:
                    owner = CN_OWNED
                ship_info = {'id': id, 'type':info.group('type'), 'x': x,
                             'y': y, 'owner':owner}
		self.ship_changes.append(ship_info)
            else:
# assume this is the blank line that marks the end of the sub section.
                self.mode = 4
        elif self.mode == 6:
            info = self.uStats.match(msg)
            if info:
                id, x, y, owner, eff = map(string.atoi,
                                           info.group('id', 'sectorX',
                                                      'sectorY', 'own', 'eff'))
                if owner == empDb.megaDB['countries'].player:
                    owner = CN_OWNED
                land_info = {'id': id, 'type':info.group('type'), 'x': x,
                             'y': y, 'owner':owner}
		self.land_changes.append(land_info)
            else:
# assume this is the blank line that marks the end of the sub section.
                self.mode = 4

    def End(self, cmd):
        self.out.End(cmd)
        empDb.megaDB['SHIPS'].updates(self.ship_changes)
        empDb.megaDB['LAND UNITS'].updates(self.land_changes)
        empDb.megaDB['SECTOR'].updates(self.sect_changes)

###########################################################################
#############################  Parser list    #############################

DB_SECTOR = 1
DB_LAND = 2
DB_SHIP = 4
DB_PLANE = 8
DB_NUKE = 16
DB_LOST = 32

DB_ALL = DB_SECTOR|DB_LAND|DB_SHIP|DB_PLANE|DB_NUKE|DB_LOST

def initialize():
    commandUpdates = []
    standardParsers = []
    for i in (
	(ParseRead,
	 ('read', 4, 0), ('wire', -3, 0)),
	(ParseTele,
	 ('telegram', -3, 0)),
	(ParseDump,
	 ('dump', -2, 0), ('pdump', -2, 0), ('ldump', -2, 0),
	 ('sdump', -2, 0), ('ndump', -2, 0), ('lost', 3, 0)),
	(ParseMap,
	 ('map', -3, 0), ('nmap', -2, 0), ('bmap', -2, 0)),
	(ParseRealm,
	 ('realm', -4, 0)),
	(ParseMove,
	 ('explore', -3, 1), ('move', -3, 1),
	 ('transport', -4, 1), ('test', -3, 0)),
	(ParseVersion,
	 ('version', 1, 0)),
	(ParseUpdate,
	 ('update', 3, 0)),
	(ParseNation,
	 ('nation', 3, 0)),
	(ParseCapital,
	 ('capital', -3, 0)),
	(ParseSpy,
	 ('spy', -2, 1)),
	(ParseAttack,
	 ('attack', -2, 1), ('assault', -2, 1)),
	(ParseUnits,
	 ('radar', -3, 0), ('lradar', -4, 0), ('lookout', -3, 0),
	 ('llookout', -4, 0), ('navigate', -3, 1), ('march', -4, 1)),
    ##     (ParsePathSetting,
	(None,
	 ('sail', -3, 1), ('bomb', -3, 1), ('fly', -3, 1),
	 ('paradrop', -3, 1), ('sweep', -2, 1)),
	(ParseSpyPlane,
	 ('recon', -3, 1)),
	(ParseReport,
	 ('report', -4, 0)),
	(ParseRelations,
	 ('relations', -3, 0)),
	(ParseCoastWatch,
	 ('coastwatch', 3, 0)),
	(ParseBuild,
	 ('build', -3, 1)),
	(ParseSimpleTime,
	 ('census', -2, 0), ('resource', -4, 0), ('cutoff', -2, 0),
	 ('sinfrastructure', -2, 0),
	 ('commodity', -3, 0), ('level', -3, 0), ('neweff', -4, 0),
	 ('production', -3, 0),
	 ('strength', -3, 0), ('stop', -3, 1), ('start', -5, 1),
	 ('anti', -3, 1)),
	(ParseSate,
	 ('satellite', -3, 0)),
	(None,
	 ('motd', 3, 0)),
	):
	for j in i[1:]:
	    if i[0] is not None:
		standardParsers.append(j[:2]+i[:1])
	    commandUpdates.append(j)
    standardParsers.sort()
    commandUpdates.sort()
    empQueue.standardParsers = standardParsers
## 	for k in range(abs(j[1]), len(j[0])+1):
## 	    if i[0] != None:
## 		standardParsers[j[0][:k]] = i[0]
## 	    commandUpdates[j[0][:k]] = j[2]

initialize()

###########################################################################
#############################  Functions      #############################

def str2Coords(s):
    idx = string.index(s, ',')
    return (string.atoi(s[:idx]), string.atoi(s[idx+1:]))

def checkUpdated(dbname, item, val):
    """Update the value in the main/update databases iff a change is made."""
    megaDB = empDb.megaDB
    if megaDB[dbname].get(item) != val:
	megaDB[dbname][item] = empDb.updateDB[dbname][item] = val
ptkei-1.12/src/empPath.py0100600000076500007650000004125606777246040014351 0ustar  kevinkevin#    Copyright (C) 1998 Ulf Larsson

#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import string
import empDb
import empSector
import math


move_directions = "ujnbgy"
move_reverse_directions ="bgyujn"

def norm_coords( coords, world_size ) :
    """ normalize coordinates according to world size"""
    x , y  = coords
    size_x, size_y  = world_size
    return ( ( x + size_x / 2 ) % size_x - size_x / 2,
	     ( y + size_y / 2 ) % size_y - size_y / 2  )


def neighbours( coords ) :
    """ neighbours ordered as directions """
    world = empDb.megaDB['version']['worldsize']
    x , y  = coords

    return  [ norm_coords( ( x + 1, y - 1) , world ) ,
	      norm_coords( ( x + 2, y    ) , world ) ,
	      norm_coords( ( x + 1, y + 1) , world ) ,
	      norm_coords( ( x - 1, y + 1) , world ) ,
	      norm_coords( ( x - 2, y    ) , world ) ,
	      norm_coords( ( x - 1, y - 1) , world ) ]



def coords_to_str( coords ) :
    x , y  = coords
    return `x` + ',' + `y`



##  MobCost is used in the bestpath algorithm.
##  Bestpath for navigating, marching and
##  exploring needs their own version of
##  this class

class MobCost:
    """ Mobility cost using the move cmd """
    def __init__( self ) :
	pass

    def cost( self, coords ) :
	""" cost for moving into sector """
	result = 2.0 * empSector.infinite_mob_cost
	sect = empDb.megaDB['SECTOR'].get( coords , {} )

	if sect and sect.get( 'owner' ) == empDb.CN_OWNED :
	    result = empSector.mob_cost( sect )
	return result

class ExplMobCost:
    """ Mobility cost using the expl cmd """
    def __init__( self ) :
	pass

    def cost( self, coords ) :
	""" cost for moving into sector """
	result = 2.0 * empSector.infinite_mob_cost
	sect = empDb.megaDB['SECTOR'].get( coords, {} )

	if sect and ( sect.get( 'owner' ) == empDb.CN_OWNED
		      or empSector.is_explorable_into( sect ) ) :
	    result = empSector.mob_cost( sect )
	return result



##  Path is used in bestpath calculation to keep track of
##  start point, end point , path string and path cost.
##  These are public members right now but should be
##  private.

class Path :
    """ Empire path between sectors in a hex map """
    def __init__( self, sect, mob_cost ) :
	self.start = sect
	self.end = sect
	self.directions = ""
	self.cost = mob_cost

    def append( self, tail, dir ) :
	""" concatinate two paths """
	result = Path( self.start, self.cost + tail.cost )
	result.directions = self.directions + dir + tail.directions
	result.end = tail.end
	return result

    def post_extend( self, sect , mob_cost , dir ) :
	""" add a step at the end of the path """
	result = Path( self.start, self.cost + mob_cost )
	result.directions = self.directions + dir
	result.end = sect
	return result

    def pre_extend( self, sect , mob_cost , dir ) :
	""" add a step at the beginning of the path """
	result = Path( sect, self.cost + mob_cost )
	result.directions = dir + self.directions
	result.end = self.end;
	return result



##  Paths -- bestpath generator between sets of sectors.
##
##
##  Paths has the following data members
##  __mob :      mobility cost object
##  __visited :  dictonary of sector we have calculated a path to
##  __heads :    list of paths starting at a source sector
##  __tails :    list of paths endinging at a destination sector
##  __complete : list of paths starting at a source sector
##               and ends at a destination sector.
##
##  __heads, __tails and __complete are sorted wrt the path cost
##
##  Paths has two main parts. One is to build up paths
##  and the second part deals with removing a source or
##  destination sector.
##
##  Building up paths is done by taking the best head ( or tail) path
##  and create new paths to the neighbours of the path's end point.
##  If the neigbouring sector is *not* in __visited we add the new
##  path, otherwise we try to create a __complete path. This ends
##  when the total cost of the best head and tail path is higher
##  then the best complete path.
##
##  Removing source or destination sector is done by looping through
##  __visited sectors and remove those origin from the removed sector.
##  Same for the lists of paths.
##
##

class Paths :
    """ Paths between two sets of sectors """
    def __init__( self, from_sect, to_sect, mcost ):
	self.__mob = mcost
	self.__visited = {}
	self.__starting_at = {}
	self.__ending_at = {}
	self.__heads = []
	self.__tails = []
	self.__complete = []

	for sect in from_sect:
	    path = Path( sect, 0.0 )
	    self.__visited[ path.start ] = ( path , 1 )
	    self.__starting_at[ path.start ] = [ path ]
	    self.__insert_path( self.__heads , path )

	for sect in to_sect :
	    path = Path( sect, self.__mob.cost( sect ) )
	    self.__visited[ path.end ] = ( path , 0 )
	    self.__ending_at[ path.end ] = [ path ]

	    self.__insert_path( self.__tails , path )

	self.__make_paths()

    def empty( self ) :
	""" no path exits """
	return ( len( self.__complete ) == 0
		 or self.__complete[ 0 ].cost >= empSector.infinite_mob_cost )

    def best( self ) :
	""" the best path ( lowest cost ) between any two sectors """
	return self.__complete[ 0 ]

    def __found_best_path( self ) :
	""" have we found the best path """
	done_search =  not self.__heads  or  not self.__tails
	if not done_search :
	    best_so_far = empSector.infinite_mob_cost

	    if self.__complete :
		best_so_far = self.__complete[ 0 ].cost

	    best_possible = self.__heads[ 0 ].cost + self.__tails[ 0 ].cost
	    done_search = best_possible > best_so_far
	return done_search

    def __insert_path( self, path_list, path ) :
	""" insert path in a sorted list """
	index = 0
	for elem in path_list :
	    if path.cost <= elem.cost :
		break
	    else :
		index = index + 1;
	path_list.insert( index, path )


    def __make_paths( self ):
	""" expand tail and head paths """
	expand_heads = not 0
	while not self.__found_best_path():
	    if expand_heads:
		self.__expand_heads()
	    else :
		self.__expand_tails()
	    expand_heads = not expand_heads

    def __expand_heads( self ) :
	""" expand best head path """
	path = self.__heads[ 0 ];
	## print "expand head path " + path_str( path )
	del self.__heads[ 0 ]
	i = 0
	for sect in neighbours( path.end ) :
	    dir = move_directions[ i ]
	    if not self.__visited.has_key( sect ) :
		new_path = path.post_extend( sect ,
					     self.__mob.cost( sect ),
					     dir )
		self.__insert_path( self.__heads, new_path )
		self.__visited[ sect ] = ( new_path, 1 )
		self.__starting_at[ path.start ].append( new_path )
	    else :
		tail, is_head_path  = self.__visited[ sect ]
		if not is_head_path :
		    self.__insert_path( self.__complete,
					path.append( tail, dir ) )
	    i = i + 1


    def __expand_tails( self ) :
	""" expand best tail path """

	path = self.__tails[ 0 ]
	## print "expand tail path " + path_str( path )
	del self.__tails[ 0 ]

	i = 0
	for sect in neighbours( path.start ) :
	    dir = move_reverse_directions[ i ]
	    if not self.__visited.has_key( sect ) :
		new_path = path.pre_extend( sect,
					    self.__mob.cost( sect ),
					    dir )
		self.__insert_path( self.__tails, new_path )
		self.__visited[ sect ] = ( new_path , 0 )
		self.__ending_at[ path.end ].append( new_path )
	    else :
		head, is_head_path  = self.__visited[ sect ]
		if is_head_path :
		    self.__insert_path( self.__complete,
					head.append( path, dir ) )
	    i = i + 1



## code below deals with removing sectors

    def remove_from( self, coords ) :
	""" remove a sector from the set of source sectors """

	removed = []
	for path in self.__starting_at[ coords ] :
	    del self.__visited[ path.end ]
	    removed.append( path.end )
	del self.__starting_at[ coords ]
	self.__heads = self.__not_starting_at( self.__heads,
					       coords )

	self.__complete = self.__not_starting_at( self.__complete,
						  coords )
	self.__activate_neighbours_of( removed )
	self.__make_paths()


    def remove_to( self, coords ) :
	""" remove a sector from the set of destination sectors """

	removed = []
	for path in self.__ending_at[ coords ] :
	    del self.__visited[ path.start ]
	    removed.append( path.start )
	del self.__ending_at[ coords ]
	self.__tails = self.__not_ending_at( self.__tails,
					     coords )
	self.__complete = self.__not_ending_at( self.__complete,
						coords )
	self.__activate_neighbours_of( removed )
	self.__make_paths()

    def __not_starting_at( self,
			   path_list,
			   coords ) :
	""" filter out path not starting at coords """
	result = []
	for path in path_list :
	    if path.start != coords  :
		result.append( path )
	return result

    def __not_ending_at( self,
			 path_list,
			 coords ) :
	""" filter out path not starting at coords """
	result = []
	for path in path_list :
	    if path.end != coords  :
		result.append( path )
	return result


    def __activate_neighbours_of( self, removed_list ) :
	""" enable neighbouring paths to expand into unvisited sectors """
	for removed in removed_list :
	    ## print "activate " + removed.str() + " neighbours"
	    for sect in neighbours( removed ) :
		if self.__visited.has_key( sect) :
		     self.__activate_path_end( sect )

    def __activate_path_end( self, sect ) :
	""" insert path to head_paths or tail_paths """
	path , is_head_path = self.__visited[ sect ];
	if is_head_path :
	    if path not in self.__heads :
	    ## print "activate head path " + path_str( path )
		self.__insert_path( self.__heads, path )
	else :
	    if path not in self.__tails :
	    ## print "activate tail path " + path_str( path )
		self.__insert_path( self.__tails, path )



## only used in debug printing
def path_str( path ) :
    """ make a  string out of a path """
    return ( coords_to_str( path.start ) + ' ' + path.directions
	     + ' ' + coords_to_str( path.end )
	     + ' (' + `path.cost` + ')' )



## MultiMove use two dictonaries to keep track of mobility
## and amount of commodities in source and destination sectors.
## Paths is used to calculate the best path. For each of these
## paths we check wether we shall remove a source sector or
## a destination sector in the Paths object depending on how
## much we can move.



def best_path( src, dst, mob_cost = MobCost() ) :
    result = None
    paths = Paths( [ src ], [ dst ], mob_cost )
    if not paths.empty() :
	result = paths.best()
    return result



class MoveGenerator :
    """ generator of moves  """
    def __init__( self,
		  commodity,
		  src_secs,
		  dst_secs,
		  mcost = MobCost() ) :

	self.__from_map  = src_secs
	self.__to_map    = dst_secs
	self.__move      = None
	self.__commodity = commodity

	## print len( src_secs ) , " source sectors",
	## print len( dst_secs ) , " destination sectors",

	self.__paths = Paths( self.__from_map.keys(),
			      self.__to_map.keys(),
			      mcost )

	## print "use ", len( self.__from_map ) , " source sectors",
	## print len( self.__to_map ) , " destination sectors",

	self.next()

    def empty( self ) :
	""" no more move commands """
	return not self.__move

    def next( self ) :
	""" proceede to next move command """
	self.__move = None
	while not ( self.__paths.empty() or self.__move ) :
	    path = self.__paths.best()
	    ## print "best path = " + path_str( path )
	    amount, mob , weight  = self.__from_map[ path.start ]
	    if weight * path.cost < mob :
		## print amount, mob, weight
		move_amount = math.floor( mob / ( weight * path.cost ) )
		if move_amount > amount : move_amount = amount

		to_amount = self.__to_map[ path.end ]
		if move_amount > to_amount : move_amount = to_amount

		amount    = amount - move_amount;
		to_amount = to_amount - move_amount;

		mob = math.floor( mob - weight * path.cost * move_amount )
		self.__move = ( self.__commodity,
				path,
				move_amount )

		if to_amount > 0 :
		    self.__to_map[ path.end ] = to_amount
		else :
		    self.__paths.remove_to( path.end )

		if amount > 0 and mob > 0 :
		    self.__from_map[ path.start ] = ( amount ,
						      mob ,
						      weight)
		else :
		    self.__paths.remove_from( path.start )
	    else :
		self.__paths.remove_from( path.start )




    def move( self ) :
	""" current move command """
	return self.__move


class MultiMove :
    """ generator of move commands """
    def __init__( self,
		  commodity,
		  from_secs,
		  from_amount,
		  mob_limit,
		  to_secs,
		  to_amount ) :

	## print len( from_secs ) , " source sectors",
	## print len( to_secs ) , " destination sectors",

	if from_amount < 0 : from_amount = 0
	if mob_limit   < 0 : mob_limit   = 0
	if to_amount   < 0 : to_amount   = 0

	src = self.__create_src_map( commodity,
				     from_secs,
				     from_amount,
				     mob_limit )

	dst = self.__create_dst_map( commodity,
				     to_secs,
				     to_amount )


	for coords in dst.keys() :
	    if src.has_key( coords ) :
		del src[ coords ]

	self.__mover = MoveGenerator( commodity,
				      src,
				      dst,
				      MobCost() )


    def empty( self ) :
	""" no more move commands """
	return self.__mover.empty()

    def next( self ) :
	""" proceede to next move command """
	self.__mover.next()

    def move_cmd_str( self ) :
	""" construct a move command string """
	result = ""
	if not self.__mover.empty() :
	    commodity, path, amount = self.__mover.move();
	    result = ( 'move ' + commodity + ' '
		       + coords_to_str( path.start ) + ' ' + `amount`
		       + ' ' + coords_to_str( path.end ) )
	return result


    def __create_src_map( self, commodity, from_secs, from_amount, mob_limit ):
	""" create  source sectors dictionary """
	result = {}
	for sect in from_secs.values() :
	    coords  = empSector.to_coord( sect )
	    if empSector.is_movable_from( sect, commodity ) :

		mob    = empSector.value( sect, 'mob' ) - mob_limit;
		amount = empSector.value( sect, commodity  ) - from_amount

		if  mob > 0 and amount > 0  :
		    weight = empSector.move_weight( sect, commodity )
		    result[ coords ] = ( amount , mob , weight)

		    ## print "src += " + coords.str() + " " + `amount` + " ",
		    ## print `mob` + " " + `weight`
	return result

    def __create_dst_map( self, commodity, to_secs, to_amount ):
	""" create  destination sectors dictionary """
	result =  {}
	for sect in to_secs.values() :
	    coords = empSector.to_coord( sect )
	    if empSector.is_movable_into( sect, commodity )  :
		amount = to_amount - empSector.value( sect, commodity )
		if  amount > 0  :
		    result[ coords ] = amount
		    ## print "dst += " + coords.str() + " " + `amount`
	return result


class MultiExplore :
    """ generator of explore commands """
    def __init__( self,
		  commodity,
		  from_secs,
		  from_amount,
		  mob_limit,
		  to_secs ) :

	if from_amount < 0 : from_amount = 0
	if mob_limit   < 0 : mob_limit   = 0

	src = self.__create_src_map( commodity,
				     from_secs,
				     from_amount,
				     mob_limit )

	dst = self.__create_dst_map( to_secs )
	self.__explore = MoveGenerator( commodity,
					src,
					dst,
					ExplMobCost() )




    def empty( self ) :
	""" no more explore commands """
	return self.__explore.empty()

    def next( self ) :
	""" proceede to next explore command """
	self.__explore.next()

    def explore_cmd_str( self ) :
	""" construct a expl command string """
	result = ""
	if not self.__explore.empty() :
	    commodity, path, amount = self.__explore.move();
	    result = ( 'expl ' + commodity + ' '
		       + coords_to_str( path.start ) + ' ' + `amount`
		       + ' ' + path.directions + 'h' )
	    return result


    def __create_src_map( self, commodity, from_secs, from_amount, mob_limit ):
	""" init source sectors dictionary """
	result = {};
	for sect in from_secs.values() :
	    coords  = empSector.to_coord( sect )
	    if empSector.is_movable_from( sect, commodity ) :

		mob    = empSector.value( sect, 'mob' ) - mob_limit;
		amount = empSector.value( sect, commodity ) - from_amount

		if mob > 0 and amount > 0 :
		    weight = 1.0
		    result[ coords ] = ( amount ,
					 mob ,
					 weight)
		    ## print "src += " + coords.str() + " " + `amount` + " ",
		    ## print `mob` + " " + `weight`
	return result;


    def __create_dst_map( self, to_secs ):
	""" init destination sectors dictionary """
	result = {}
	for sect in to_secs.values() :
	    if empSector.is_explorable_into( sect ) :
		coords = empSector.to_coord( sect )
		result[ coords ] = 1
	return result

ptkei-1.12/src/empQueue.py0100600000076500007650000007763207007754750014547 0ustar  kevinkevin"""Code to start and maintain empire connection"""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import sys
import socket
import errno
import select
import string
import re
import traceback
import bisect

import empDb

# Key Ideas:


# What is contained within this file:

# This file contains the underlying socket code.  Code to handle all the
# incoming data and broker all the outgoing data is contained within the
# class EmpIOQueue.  EmpIOQueue uses a number of other classes to handle
# the incoming/outgoing data.  This file also contains these other classes
# and contains the basic building block for the chained display classes.  A
# quick glance at the other files in this distribution will show that this
# is the only file that references any of the low-level empire protocols
# (EG. C_PROMPT) - all that protocol stuff is handled here.

# Note: To actually send commands, the standard method is to use the class
# empCmd.EmpParse.  Please see the documentation in empCmd for more info.


# Global variables:

# empQueue : This always points to the only instance of EmpIOQueue.  Its a
# convenience aid that probably isn't necessary..
#
# NormalHandler.msgQueue : Stores messages that the client thinks may be
# server broadcasts (EG. new telgram notifications).  It could just as
# easily be non-global - it's global for optimization/simplicity.


# The purpose of the low-level data managers:

# The "data managers" are helper classes for EmpIOQueue.  These helper
# classes essentially manage output from the server.  They strip the
# low-level empire protocol stuff from the information and transmit the
# data using a variety of classes and methods.  The classes AsyncHandler,
# LoginHandler, NormalHandler, and DummyHandler, are these "data managers".
# It is important to note that AsyncHandler and LoginHandler have special
# properties.  Both of these classes will normally have exactly one
# instance associated with them.  These single instances are associated
# with EmpIOQueue at its instantiation, and are stored in the variables
# defParse and loginParser.  To the contrary, the NormalHandler and
# DummyHandler classes will generally have multiple instances associated
# with them - one instance per queued command.


# The purpose of the chained display classes:

# Associated with many of the server commands will be client parsers.  (For
# example, the server command "read" will be transmitted to the class
# empDb.ParseRead.)  These classes are referred to as "chained" because
# they generally form a linked-list of parsers.  More than one parser might
# have interest in the server output of any given command, so a chain is
# formed where each low-level parser transmits the information to the next
# parser.  The chaining is performed by the individual parsers - a lower
# level parser might decide to not send information up the chain, thus
# hiding info.  (Which, BTW, is the basis for the "null" command - "null"
# just associates the given command with a parser that discards its input.)
# At the highest level of this parse chain, is generally the main viewer.
# The global variable viewer must support the same methods of an ordinary
# display class.  (In addition to its special methods - see
# AsyncHandler/LoginHandler for more info.)


# The use of the Queue Flags:

# The queue flags describe the current state of the command queue.  They
# determine if the connection is open/closed/paused/etc..  The more
# interesting flags, however, are the per-command transmission flags.
# These flags (QU_BURST, QU_SYNC, QU_FORCEBURST, and QU_FULLSYNC) determine
# how each command is transmitted to the server.  If empQueue.flags is set
# to one of these per-command flags, that means the connection is open,
# stable, and ready to send a command in accordance with these per-command
# flags.  empQueue.flags is set by bitwise or'ing a command's pre-flags
# with the previous command's post-flags.  The pre-flags are used to
# determine when a command should be transmitted.  The post-flags determine
# the command's environment (IE. should it secure its potential
# sub-prompts, does it need to prevent further commands from being executed
# while processing the current, etc.)  If there are zero or one commands on
# the queue, then empQueue.flags will always equal QU_BURST.

# With QU_BURST, the command is transmitted immediately; no checks are made
# to determine if the command will be sent to a sub-prompt or a command
# line.

# With QU_SYNC (the most interesting and complex mode), the command is
# guaranteed to be sent to a command-line, but can be sent prior to the
# completed processing of the previous command.  This is done by forcing
# the socket reader to pre-scan all the server data.  When a C_PROMPT
# protocol is detected, the socket reader will transmit the next command
# immediately.  This pre-scanning of the server data can significantly
# reduce the connection's latency.  (Certain commands can cause a Tk
# redraw, which may take several seconds - by sending the next command
# prior to trudging through the chained display classes, it is possible to
# keep the server busy while the client works on other processing.)

# QU_FORCEBURST is a modification of QU_BURST and QU_SYNC.  QU_FORCEBURST
# is a pledge that the command will not create any subprompts.  This is
# used by the rdb command to force QU_SYNC commands following a 'dump *' to
# downgrade to QU_BURST.  Since a 'dump *' will never create a subprompt,
# this squeezes a little more performance from the frequently used rdb
# commands.

# With QU_FULLSYNC, the command is not sent until the previous command is
# fully processed, completed, and dequeued.  This is used by smart commands
# that require either the output in entirety from the previous command or
# the ability to send commands to the server immediately.  (For example,
# the client-command 'foreach' would set QU_FULLSYNC to ensure that it can
# place a command on the queue right after it is completed - it would not
# be ideal to have a command following 'foreach xxx' pop in front of the
# foreach commands due to QU_SYNC's behavior.)


# Empire Protocol IDs
C_CMDOK	 = "0"
C_DATA	 = "1"
C_INIT	 = "2"
C_EXIT	 = "3"
C_FLUSH	 = "4"
C_NOECHO = "5"
C_PROMPT = "6"
C_ABORT	 = "7"
C_REDIR	 = "8"
C_PIPE	 = "9"
C_CMDERR = "a"
C_BADCMD = "b"
C_EXECUTE= "c"
C_FLASH	 = "d"
C_INFORM = "e"
C_LAST	 = "e"

C_ASYNCS = (C_INFORM, C_FLASH)

# Queue flags
QU_BURST = 0
QU_SYNC = 1
QU_FORCEBURST = 3
QU_FULLSYNC = 7

QU_CONNECTING = 32
QU_PAUSED = 40
QU_LOGIN = 48
QU_DISCONNECT = 64
QU_OFFLINE = 72

QU_BURSTS = (QU_BURST, QU_FORCEBURST)

class EmpIOQueue:
    """Broker all input and output to/from server.

    This class generally has only one instance associated with it.  It is
    used mainly as a code/data container.
    """

    def __init__(self, async, login):
	global empQueue
	empQueue = self

	# Storage area for partial socket reads.  (Reads that contain a
	# string that is not terminated by a newline.)  This info has to be
	# stored somewhere until the next read reveals the trailing
	# information.
	self.InpBuf = ""

	# Storage for the command queue.  Each command is queued by
	# associating it with a "data manager" class
	# (NormalHandler/DummyHandler), and placing it in the queue stored
	# in FuncList.  The integers FLWaitLev and FLSentLev are indexes
	# into this queue.  FuncList[FLWaitLev] points to the command that
	# is currently receiving data.  FuncList[FLSentLev] points to the
	# next command that needs to be sent to the server.
	self.FuncList = []
	self.FLWaitLev = self.FLSentLev = 0

	# Special data manager classes.  defParser (which is associated
	# with the class AsyncHandler) is used for all asynchronous data -
	# data that is received when there are exactly zero commands
	# waiting on the queue.  loginParser (which is associated with the
	# class LoginHandler) is used when the queue needs to reestablish a
	# server connection.
	self.defParser = async
	self.loginParser = login

	self.flags = QU_OFFLINE

    def SendNow(self, cmd):
	"""Immediately send CMD to socket."""
	# Paranoia check
	if string.find(cmd, "\n") != -1:
	    # Ugh, there should be no newlines in the cmd
	    viewer.Error("Send error - embedded newline: " + `cmd`)
	    cmd = cmd[:string.find(cmd, "\n")]
##  	self.debug(cmd, 'send')
	try:
	    self.socket.send(cmd+"\n")
	except socket.error, e:
	    self.loginParser.Disconnect()
	    viewer.Error("Socket write error: " + str(e))

##      def debug(*args):
##  	pass

##      # To enable debuging, change this function to debug and alter the above
##      # definition.
##      def debugcc(self, msg, type=None):

##  	if type == 'send':
##  	    print "## %s" % msg
##  	elif type == 'get':
##  	    print "-- %s" % msg
##  	else:
##  	    print "%-30s @ len:%-2d wait:%-2d sent:%-2d flags:%-2d" % (
##  		msg, len(self.FuncList), self.FLWaitLev,
##  		self.FLSentLev, self.flags)

    def doFlags(self):
	"""Set the queue flags depending on the current state of the queue."""
	if self.flags >= QU_CONNECTING:
	    return
	ls = self.FLSentLev
	if len(self.FuncList) == ls or ls == 0:
	    self.flags = QU_BURST
	else:
	    self.flags = (self.FuncList[ls-1].postFlags
			  | self.FuncList[ls].preFlags)
##  	self.debug("Leave doflags")

    def sendCommand(self):
	"""Send a command to the server."""
	while 1:
	    qElem = self.FuncList[self.FLSentLev]
	    # Check for dynamic command-string manipulator
	    if qElem.sending is not None:
		qElem.sending()
	    # Send command
	    cmd = qElem.command
	    if cmd is None:
		self.FLWaitLev = self.FLWaitLev + 1
	    else:
		self.SendNow(cmd)
	    self.FLSentLev = self.FLSentLev + 1
	    # HACK++
	    if (cmd is not None
		and self.FuncList[0].__class__ is NormalHandler
		and self.FuncList[0].atSubPrompt):
		# This command was sent to a known sub-prompt. Checking
		# this here totally defies a good OO design!
		self.FLSentLev = self.FLSentLev - 1
		del self.FuncList[self.FLSentLev]
		self.FuncList[0].atSubPrompt = 0
		self.FuncList[0].out.Answer(cmd)
	    # Update flags
	    self.doFlags()
	    if (self.flags not in QU_BURSTS
		or self.FLSentLev >= len(self.FuncList)):
		break

    def beginParser(self):
	while 1:
	    if (self.FLSentLev == 0 and self.flags <= QU_FULLSYNC):
##  		self.debug("Planned send")
		self.sendCommand()
	    # Send parser start signal
##  	    self.debug("Parser start")
	    try: self.FuncList[0].start()
	    except: flashException()
	    if self.FuncList[0].command is not None:
		break
	    # Dummy command - remove it and try again
	    del self.FuncList[0]
	    self.FLWaitLev = self.FLWaitLev - 1
	    self.FLSentLev = self.FLSentLev - 1
	    if not self.FuncList:
		break

    def offlineSendCommand(self):
	"""Handle commands on queue when off-line."""
	while 1:
	    qElem = self.FuncList[0]
	    # Check for dynamic command-string manipulator
	    if qElem.sending is not None:
		qElem.sending()
	    # Send command
	    cmd = qElem.command
	    if cmd is not None:
		self.loginParser.Connect()
		return
	    self.FLWaitLev = self.FLWaitLev + 1
	    self.FLSentLev = self.FLSentLev + 1
	    # Send parser start signal
	    try: self.FuncList[0].start()
	    except: flashException()
	    # Dummy command - remove it and try again
	    del self.FuncList[0]
	    self.FLWaitLev = self.FLWaitLev - 1
	    self.FLSentLev = self.FLSentLev - 1
	    if not self.FuncList:
		# Create dummy lull signal.
		try: self.defParser.lull()
		except: flashException()
		break

    def popHandler(self, pos):
	"""Forcibly remove a command from the queue."""
	if pos < self.FLSentLev:
	    self.FLSentLev = self.FLSentLev - 1
##  	self.debug("force delete @ %s : '%s'"
##  		   % (pos, self.FuncList[pos].command))
	del self.FuncList[pos]
	if pos == self.FLSentLev:
	    self.doFlags()
	    if (self.FLSentLev < len(self.FuncList)
		and (self.flags in QU_BURSTS
		     or (self.flags == QU_SYNC
			 and self.FLWaitLev == self.FLSentLev))):
		self.sendCommand()

    def AddHandler(self, handler, pos=None):
	"""Add a command to the output queue.

	Normally, this will add a command to the end of the queue.
	However, it is possible to customize the location for the command
	via the pos argument.
	"""
	l = len(self.FuncList)
	FLSentLev = self.FLSentLev
	if pos is None or pos > l:
	    pos = l
	elif pos < FLSentLev:
	    pos = FLSentLev
	self.FuncList.insert(pos, handler)
##  	self.debug("Add '%s'" % handler.command)
	if pos == self.FLSentLev:
	    self.doFlags()
	    if (self.flags == QU_OFFLINE):
		self.offlineSendCommand()
	    elif (self.flags in QU_BURSTS
		  or (self.flags == QU_SYNC
		      and self.FLWaitLev == self.FLSentLev)):
##  		self.debug("Force send")
		self.sendCommand()
		if not pos:
		    self.beginParser()
		    if not self.FuncList:
			# Was a dummy command - create dummy lull signal.
			try: self.defParser.lull()
			except: flashException()

    def HandleInput(self):
	"""Parse input from socket; send all data to function list.

	This method does all the actual reading of the socket.  It reads
	and stores the server information, and delegates complete lines of
	data to the data-managers.  It also checks for the special sequence
	C_PROMPT which always indicates the end of a command.

	This method is made significantly more complex because of the
	heterogeneous mixture of command priorities.  Tracking of
	FLWaitLev, and FLSentLev is an arduous task.
	"""
	cache = []
	error = ""
	# HACK!  Obscure python optimization - make local copies of global
	# variables.
	__C_PROMPT = C_PROMPT; __QU_SYNC = QU_SYNC
	__QU_FULLSYNC = QU_FULLSYNC; __QU_DISCONNECT = QU_DISCONNECT
	__len = len; __None = None; select__select = select.select
	string__count = string.count; string__split = string.split
	self__InpBuf = self.InpBuf; self__FuncList = self.FuncList
	self__sendCommand = self.sendCommand; self__socket = self.socket
	self__socket__recv = self.socket.recv
	# Dummy exception - used for unusual flow control
	StopRead = "Internal Break"
	while 1:
	    # Make sure socket is available and readable.
	    if self.flags >= __QU_DISCONNECT:
		# Socket disconnected sometime during the cycle
		# Remove all sent items from the queue
		del self__FuncList[:self.FLSentLev]
		self.FLSentLev = self.FLWaitLev = 0
		if error:
		    # It was an error - send error to login code
		    self.loginParser.Error(error)
		elif self__FuncList and self.flags == QU_OFFLINE:
		    self.offlineSendCommand()
		break
	    try:
		# Begin unconventional flow control.
		# StopRead is used here to "break out" of the read if any
		# of the socket conditions are "bad".  It is possible to do
		# this more conventionally, but I find it "ugly", and less
		# intuitive.
		sts = select__select([self__socket], [], [self__socket], 0)
		if sts[2]:
		    error = "Exceptional condition on socket!"
		    self.loginParser.Disconnect()
		    raise StopRead
		if not sts[0]:
		    # Nothing left to read
		    if not cache:
			# cache is empty - break from main loop and return.
			break
		    # There is info on the cache, process it first.
		    raise StopRead
		# Socket is Ok to read - now read a large block.
		try:
		    tmp = self__socket__recv(4096)
		except socket.error, e:
		    error = "Socket read exception: " + str(e)
		    self.loginParser.Disconnect()
		    raise StopRead
		if not tmp:
		    # Ughh.
		    error = "Zero read on socket!"
		    self.loginParser.Disconnect()
		    raise StopRead
		# If a prompt is encountered anywhere in the buffered data,
		# send the next command immediately in QU_SYNC mode.
		cnt = string__count(tmp, "\n"+__C_PROMPT)
		if not self__InpBuf and tmp[:1] == __C_PROMPT:
		    cnt = cnt + 1
		self.FLWaitLev = self.FLWaitLev + cnt
		if (self.flags == __QU_SYNC
		    and self.FLWaitLev == self.FLSentLev):
##  		    self.debug("Pre-send")
		    self__sendCommand()
		# Convert input to line cache
		l = __len(cache)
		cache[l:] = string__split(tmp, "\n")
		cache[l] = self__InpBuf + cache[l]
		self__InpBuf = cache[-1]
		del cache[-1]
	    except StopRead:
		# End of unconventional flow control.  If StopRead is
		# raised, process what is on the cache.  (If the socket was
		# closed, we are guaranteed to exit at the start of the
		# next loop, because the queue flags are checked there.)
		pass

	    while cache:
		data = cache[0]
		del cache[0]
##  		self.debug(data, 'get')

		if not self__FuncList:
		    # Asynchronous line of data
		    try: self.defParser.line(data)
		    except: flashException()
		    continue
		# call the handler
		try: self__FuncList[0].line(data)
		except: flashException()
		# Check for prompt
		if data[:1] == __C_PROMPT:
		    del self__FuncList[0]
		    self.FLWaitLev = self.FLWaitLev - 1
		    self.FLSentLev = self.FLSentLev - 1
##  		    self.debug("removed")
		    if self__FuncList:
			self.beginParser()
		# In QU_SYNC mode, the socket is checked for new data at
		# the end of every line of data processed.  This may cause
		# some overhead, but generally network response time is
		# significantly more important than cpu time.
		if self.flags == __QU_SYNC:
		    break
	# Processing has ended.	 Copy local variables back to their originals.
	self.InpBuf = self__InpBuf

	# Signal handlers of the lull in data.
	if not self__FuncList:
	    # No parsers.
	    try: self.defParser.lull()
	    except: flashException()
	else:
	    try: self__FuncList[0].lull()
	    except: flashException()

    def fileno(self):
	"""Return the socket descriptor."""
	if self.flags >= QU_DISCONNECT:
	    return None
	return self.socket.fileno()

    def GetStatusMsg(self):
	"""Return a string that describes the current queue."""
	msg = ""
	if self.flags >= QU_CONNECTING:
	    msg = {QU_DISCONNECT:"Disconnected",
		   QU_OFFLINE:"Off-line",
		   QU_CONNECTING:"Connecting",
		   QU_PAUSED:"Paused",
		   QU_LOGIN:"Logging in",
		   }[self.flags]
	tot = len(self.FuncList)
	sent = self.FLSentLev
	if tot != 0: msg = msg + " " + str(tot)
	if sent != 0: msg = msg + "/" + str(sent)
	if msg == "": msg = "Idle"
	return msg

    def clearQueue(self):
	"""Permanently delete all commands that have not been sent."""
	del self.FuncList[self.FLSentLev:]
	if self.flags < QU_CONNECTING:
	    self.flags = QU_BURST

    def pauseQueue(self, pause):
	"""Pause/unpause all further outgoing commands."""
	if pause:
	    # Pause the connection
	    if self.flags < QU_CONNECTING:
		self.flags = QU_PAUSED
	    elif self.flags == QU_OFFLINE:
		self.flags = QU_DISCONNECT
	else:
	    # Restart a paused connection
	    if self.flags == QU_PAUSED:
		self.flags = QU_BURST
		self.doFlags()
		if (self.FLSentLev < len(self.FuncList)
		    and (self.flags in QU_BURSTS
			 or (self.flags == QU_SYNC
			     and self.FLWaitLev == self.FLSentLev))):
		    self.sendCommand()
		    if not self.FLSentLev:
			self.beginParser()
	    elif self.flags == QU_DISCONNECT:
		self.flags = QU_OFFLINE
		if self.FuncList:
		    self.offlineSendCommand()

    def scanQueue(self, callback, start=0, end=None):
	"""Execute a callback function on each element in the queue."""
	l = len(self.FuncList)
	if end is None or end > l:
	    end = l

	for i in self.FuncList[start:end]:
	    ret = callback(i)
	    if ret:
		return ret

class LoginHandler:
    """Aid EmpIOQueue with all login/logout requests.

    This class requires the global viewer class to contain the class
    viewer.loginHandler.  The class viewer.loginHandler must contain the
    following methods/objects:
    login_error(), login_success(), connect_success(), connect_terminate(),
    and login_kill
    """

    def __init__(self, callback, username):
	self.callback = callback
	callback.loginHandler = self
	self.firstConnect = 1
	self.srcStart = 1
	self.username = username
	self.postFlags = QU_FULLSYNC
##  	self.command = "\t\t-=-"
	self.command = ""
## 	preFlags = QU_BURST
## 	self.pos = 0

##     def start(self):
##	pass

    def Connect(self):
	"""Connect to specified host/port as coun/repr."""
	ldb = empDb.megaDB['login']
	if empDb.DBIO.newDatabase and self.firstConnect:
	    # On a new database, open the login window so that users may
	    # enter the socket/country information.
	    self.firstConnect = 0
	    self.callback.login_error("Enter connect information.")
	    return
	try:
	    empQueue.socket = socket.socket(socket.AF_INET,
					    socket.SOCK_STREAM)
	    # Attempt to start the connection in non-blocking mode.
	    # Hopefully this will allow the client to function while the
	    # address is being looked up.
	    empQueue.socket.setblocking(0)
	    empQueue.socket.connect(ldb['host'], ldb['port'])
	except socket.error, e:
	    if e[0] not in (errno.EINPROGRESS, errno.EWOULDBLOCK):
		self.callback.login_error("Connect error: " + str(e))
		return
	self.pos = 0
	empQueue.flags = QU_CONNECTING
	empQueue.FuncList[:0] = [ self ]
	empQueue.FLWaitLev = 0
	empQueue.FLSentLev = 1
	self.callback.connect_success()

    def Error(self, msg):
	"""Note an error."""
	self.callback.login_error(msg)

    def Disconnect(self):
	"""Break the connection with the server."""
	if empQueue.flags >= QU_DISCONNECT:
	    # Already disconnected
	    return
	self.callback.connect_terminate()
	empQueue.socket.close()
	del empQueue.socket
	empQueue.flags = QU_OFFLINE

    def line(self, line):
	"""EmpIOQueue Handler: Process a line of data."""
	proto = line[:1]
	msg = line[1:]
	if empQueue.flags == QU_CONNECTING:
	    empQueue.flags = QU_LOGIN

	# Ughh..  It appears we can get these async messages at any time..
	if proto in C_ASYNCS:
	    empQueue.defParser.line(line)
	    return

	ldb = empDb.megaDB['login']
	if (self.pos == 0):
	    if proto != C_INIT:
		self.callback.login_error("[%s]%s" % (proto, msg))
		return
	    self.pos = 1
	    empQueue.SendNow("user %s" % self.username)
	elif (self.pos == 1):
	    if proto != C_CMDOK:
		self.callback.login_error("[%s]%s" % (proto, msg))
		return
	    self.pos = 2
	    empQueue.SendNow("coun %s" % ldb['coun'])
	elif (self.pos == 2):
	    if proto != C_CMDOK:
		self.callback.login_error("[%s]%s" % (proto, msg))
		return
	    self.pos = 3
	    empQueue.SendNow("pass %s" % ldb['repr'])
	elif (self.pos == 3):
	    if proto != C_CMDOK:
		self.callback.login_error("[%s]%s" % (proto, msg))
		return
	    if self.callback.login_kill:
		self.pos = 4
		empQueue.SendNow("kill")
	    else:
		self.pos = 5
		empQueue.SendNow("play")
	elif (self.pos == 4):
	    if proto != C_EXIT:
		self.callback.login_error("[%s]%s" % (proto, msg))
		return
	    self.pos = 5
	    empQueue.SendNow("play")
	elif (self.pos == 5):
	    if proto != C_INIT:
		self.callback.login_error("[%s]%s" % (proto, msg))
		return
	    # Login successful!
	    self.pos = 99
	    # Arghh - the flags must be set to FullSync, because FLWaitLev
	    # may have already been encountered..
	    empQueue.flags = QU_FULLSYNC
	    empQueue.doFlags()
	    # run the initialization script
	    if empDb.DBIO.newDatabase:
		viewer.ioq.Send("exec "+pathPrefix("first.emp"))
		empDb.DBIO.newDatabase = 0
	    # Note the change in the database.
	    empDb.DBIO.needSave = 1
	    # Start boot-up script
	    if self.srcStart:
		viewer.ioq.Send("exec "+pathPrefix("start.emp"))
		self.firstConnect = 0
		self.srcStart = 0
	    # Start connect script
	    viewer.ioq.Send("exec "+pathPrefix("connect.emp"))
	    self.callback.login_success()
	    self.out = NormalHandler(self.command, viewer)
	    self.out.start()
	else:
	    self.out.line(line)

    def lull(self):
	viewer.Process()

    def retry(self):
	"""Try to connect to the server again.

	Calling this function is the natural conclusion of a call to the
	login_error() method described above.
	"""
	if empQueue.flags >= QU_DISCONNECT:
	    self.Connect()
	elif empQueue.flags >= QU_CONNECTING:
## 	else:
	    self.pos = 0
	    self.line(C_INIT)
	else:
	    viewer.Error("Unknown internal error.")

class AsyncHandler:
    """Handle asyncrounous server data.

    Data received that is not associated with a command is processed by
    this class.  The class requires the global viewer class to support the
    following methods:

    flash(), and inform()
    """
    def line(self, line):
	"""EmpIOQueue Handler: Process a line of data."""
	if line[:1] == C_DATA:
	    viewer.flash(line[2:])
	elif line[:1] == C_EXIT:
	    viewer.Error("Server exiting (%s)." % (line[2:],))
	    empQueue.loginParser.Disconnect()
##	    # HACK++
##	    if empQueue.FuncList:
##		del empQueue.FuncList[:1]
##		empQueue.FLSentLev = empQueue.FLSentLev - 1
	elif line[:1] == C_INFORM:
	    empDb.megaDB['prompt']['inform'] = line[2:]
	    viewer.inform()
	elif line[:1] == C_FLASH:
	    viewer.flash(line[2:])
	else:
	    viewer.Error('PTkEI: Bad protocol "%s"' % (line,))

    def lull(self):
	viewer.Process()

class NormalHandler:
    """Handle server data that is received during most normal operations.

    This class will invoke the chained display class associated with the
    command.  It will also detect built-in parsers from empDb.py, and bind
    those parsers with the display chain.
    """
    # The server sends telegram/annoucement/etc. messages to the client as
    # if they were normal C_DATA messages.  Store these messages
    # seperately, and send them all at once using the viewer.flash method.
    # This way, the individual parsers dont have to worry about detecting
    # these messages.
    msgqueue = []

#You have a new telegram waiting ...
#You have three new announcements waiting ...
#You lost your capital... better designate one
    msgMatch = re.compile(
	r"^You lost your capital\.\.\. better designate one$|"
	+r"^You have .* new (?:telegram|announcement)s? waiting \.\.\.$")

    def __init__(self, command, disp, pre=QU_SYNC, post=None):
	self.command = command
	self.out = disp
	self.sending = None
	self.preFlags = pre
	if post is None:
	    post = pre
	self.postFlags = post
	self.atSubPrompt = 0

    def start(self):
	"""EmpIOQueue Handler: Previous command completed; start this one."""
	# Check for lowlevel parsers
	lst = string.split(self.command)
	if lst:
	    parser = findCmd(standardParsers, lst[0])
	    if parser:
		self.out = parser(self.out)
	self.out.Begin(self.command)

    def line(self, line):
	"""EmpIOQueue Handler: Process a line of data."""
	proto = line[:1]
	msg = line[2:]

	if proto not in (C_DATA, C_PROMPT, C_FLUSH):
	    # Can't handle the proto - send to async class.
	    empQueue.defParser.line(line)
	    return

	if self.atSubPrompt:
	    # Ughh.  Something must have interrupted the sub-prompt.
	    self.atSubPrompt = 0
	    self.out.Answer(None)

	if proto == C_DATA:
	    if (self.msgMatch.match(msg)):
		self.msgqueue.append(msg)
	    else:
		# If there are messages on the msgqueue, then we have
		# been spoofed - send them along to the parsers normally.
		for i in self.msgqueue:
		    self.out.data(i)
		self.out.data(msg)
		del self.msgqueue[:]
	elif proto == C_PROMPT:
	    # If there are messages on the msgqueue then flash them out.
	    for i in self.msgqueue:
		viewer.flash(i)
	    del self.msgqueue[:]
	    ndb = empDb.megaDB['prompt']
	    ndb['minutes'], ndb['BTU'] = map(string.atoi, string.split(msg))
	    self.out.End(self.command)
##	elif msg[0] == C_REDIR:
##	    print "PE: Server Redirect requested:", msg[2:]
##	elif msg[0] == C_PIPE:
##	    print "PE: Server Pipe requested:", msg[2:]
##	elif msg[0] == C_EXECUTE:
##	    print "PE: Server Execute requested:", msg[2:]
	else:
	    # Must be a C_FLUSH sub-prompt.
	    eq = empQueue
	    for i in range(1, eq.FLSentLev):
		if eq.FuncList[i].__class__ is NormalHandler:
		    # HACK!  It appears a Burst'd command answered a
		    # sub-prompt.  That command will have to be deleted
		    # from the queue.
		    cmd = eq.FuncList[i].command
		    eq.popHandler(i)
		    self.out.flush(msg, None)
		    self.out.Answer(cmd)
		    break
	    else:
		self.atSubPrompt = 1
		self.out.flush(msg, self.handleFlush)

    def lull(self):
	self.out.Process()

    def handleFlush(self, response):
	"""Chained viewer class callback: Respond to a prompt."""
	eq = empQueue
	if not self.atSubPrompt:
	    # Ughh.  No longer at the subprompt.
	    viewer.Error("Sync error: Can not send sub-prompt.")
	    return
	empQueue.SendNow(response)
	self.atSubPrompt = 0
	self.out.Answer(response)

class DummyHandler:
    """Dummy class - useful as a place marker.

    This class does not handle input/output; it is placed within the queue
    to note a specific location.  When this class' start() method is
    invoked, it generally triggers a client smart command.
    """
    def __init__(self, command, disp, mcallback, tcallback, post=QU_BURST):
	self.command = None
	self.out = disp
	self.id = command
	self.mainCallback = mcallback
	self.transmitCallback = tcallback

	if mcallback is None:
	    # Override default start method
	    self.start = doNothing

	if tcallback is None:
	    # Override default sending method
	    self.sending = None

        # preFlags is used to determine when a command is to be sent.
        # Since dummy commands don't send anything, it does not make sense
        # to use a value other than QU_BURST.
        self.preFlags = QU_BURST
        # postFlags should be either QU_BURST, or QU_FULLSYNC.  (Since
        # there is no actual command, it doesn't make sense to use
        # QU_SYNC.)
        self.postFlags = post

    def start(self):
	"""EmpIOQueue Handler: Previous command completed; start this one."""
	self.out.Begin(self.id)
	self.mainCallback()
	self.out.End(self.id)

    def sending(self):
	"""EmpIOQueue Handler: Command about to be sent."""
	self.transmitCallback(empQueue.FLSentLev)

def flashException():
    """Send an exception message directly to the display.

    This should be used in a block: try: ... except: flashException().
    """
    viewer.Error('Internal error!\nException %s with detail:\n"%s".'
		 % tuple(sys.exc_info()[:2]))
    traceback.print_exc()

def doNothing(*args, **kw):
    """Do absolutely nothing.  (Used as a dummy function.)"""
    pass

class baseDisp:
    """Base class for the chained display classes.  (Does little by itself.)

    Basically, this class just insures that all the sub-classes support the
    standard chained display class protocols:

    Begin() - notes the beginning of a command.
    data() - notes a line of data.
    flush() - notes a sub-prompt.
    Answer() - notes the response to a sub-prompt.
    End() - notes the termination of a command.
    Process() - notes a lull in server output.

    This class also defines self.out - a handy reference to the next parser
    in the display chain.

    Note: Because the global viewer class is generally at the top of the
    chain, it must support all of the above methods.  (But because this
    class is used for chaining, the global viewer is not an ancestor of
    this class.)
    """
    def __init__(self, disp):
	# Establish defaults for all the standard display class commands.
	self.out = disp
	for i in ('Begin', 'data', 'flush', 'Answer', 'End', 'Process'):
	    if not hasattr(self, i):
		setattr(self, i, getattr(disp, i))

def EmpData(username):
    """Initialize EmpIOQueue with default values."""
    return EmpIOQueue(AsyncHandler(),
		      LoginHandler(viewer.loginCallback, username))

def findCmd(lst, cmd):
    """Search command list for a given CMD."""
    l = len(cmd)
    pos = bisect.bisect(lst, (cmd, 0))
    if (pos < len(lst) and lst[pos][0][:l] == cmd
	and abs(lst[pos][1]) <= l):
	return lst[pos][2]
    if pos > 0:
	prev = lst[pos-1]
	if prev[0] == cmd[:len(prev[0])] and prev[1] < 0:
	    return lst[pos-1][2]

# Hack!  There is a function pathPrefix that is not defined in this module,
# but is setup for this module in empire.py.  See the line
# "empQueue.pathPrefix = pathPrefix" in the initialize function of
# empire.py.

# Hack 2!  The global parser list standardParsers is available from this
# module; however, it is really defined in empParse.py.
ptkei-1.12/src/empSector.py0100600000076500007650000004330006777245743014715 0ustar  kevinkevin"""Routines for empire sector units."""

#    Copyright (C) 1998 Ulf Larsson

#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import string
import math

import empDb
import empParse

## to be used for sectors you can't move into
infinite_mob_cost = 99999.9

def to_coord( sect ) :
    """ create Coords type from sector """
    return ( sect[ 'x' ] ,
	     sect[ 'y' ] )


def mob_cost( sect ) :
    """ mobility cost to move into a sector """
    min_mob_cost = 0.01
    result = 2.0 * infinite_mob_cost
    d = sect.get( 'des' )
    if is_land( d ) and d != 's' and d != '\\' :
	des_mob = type_mcost( d )
	road = value( sect, 'road' )
	result = des_mob / ( 1.0 + road / 122 )
	eff = value( sect, 'eff'  )
	if des_mob < 25 :
	    result = ( result * 100.0 - eff ) / 500.0
	else :
	    result = ( result * 10 - eff  ) / 115.0
    if result < min_mob_cost :
	result = min_mob_cost
    return result

def type_mcost( des ) :
    """ sector type mobility cost """
    result = 2
    if des == '+' or des == '=' or des == '#' :
	result = 1
    elif des == '-' :
	result = 3
    elif des == '^' :
	result = 25
    return result

def is_land( des ) :
    """ is this a land sector """
    return des and des != ' ' and des != '.' and des != 'x' and des != 'X'

def is_sea( des) :
    """ is this a water sector """
    return des and ( des == '.' or des == 'x' or des == 'X' )

def is_oldowned( sect ) :
    """ are we  oldowner of this sector """
    return sect.get( 'oldown' ) == empDb.CN_OWNED

def is_movable_into( sect, commodity ) :
    """ is it possible to move commodity into sect  """
    return commodity != 'civ' or is_oldowned( sect )

def is_movable_from( sect, commodity ) :
    """ is it possible to move commodity from sect  """
    result = 0
    if is_oldowned( sect ) or commodity == 'mil' :
	result = 1
    else :
	mil = value( sect, 'mil' )
	civ = value( sect, 'civ' )
	result = mil * 10 >= civ
    return result

def is_explorable_into( sect ) :

    des   = sect.get( 'des' )
    owner = sect.get( 'owner' )
    mil   = sect.get( 'mil' )
    civ   = sect.get( 'civ' )

    return ( is_land( des ) and des != '\\' and des != 's'
	     and ( ( civ  == 0 and mil == 0 )
		   or ( ( owner == 0 or not owner )
			and (des == '-' or des == '=' or des == '^' ) ) ) )

def value( sect, what ) :
    """ atoi that returns 0 on null string """
    return sect.get(what, 0)


def commodity_weight( commodity ) :
    """ weight for different kinds of commodities"""
    result = 1.0
    if commodity == 'bar' :
	result = 50.0
    elif commodity == 'gun' :
	result = 10.0
    elif commodity == 'rad' :
	result = 8.0
    elif commodity == 'dust' :
	result = 5.0
    elif commodity == 'uw' :
	result = 2.0
    return result

def packing_bonus( sect, commodity ) :
    """ packing bonus when moving commodity"""
    result = 1.0
    eff = value( sect, 'eff' )
    des = sect.get( 'des' )
    if des and eff >= 60 :
	if commodity == 'civ' :
	    result = 10.0
	elif commodity == 'mil' :
	    result = 1.0
	elif des == 'b' and commodity == 'bar' :
	    result = 4.0
	elif des == 'w' or des == 'h' :
	    if commodity == 'uw' :
		result = 2.0
	    else :
		result = 10.0
    return result

def move_weight( sect, commodity ) :
    """ mobility cost multiplier for moving gods out of sector """
    return commodity_weight( commodity ) / packing_bonus( sect,
							  commodity )

def new_designation( sect ) :
    new_des = sect.get( 'sdes' )
    if not new_des or new_des == ' ' or new_des == '_' :
	new_des = sect.get( 'des' )
    return new_des

def max_pop( sect ) :
    result = 0
    des = sect.get( 'des' )

    ## ** BUG ** isn't correct with RES_POP or BIG_CITY
    ## option enabled

    if is_land( des ) :
	if des == '^' :
	    result = 99
	elif des == '~' :
	    result = 50 ## or is it 49 ?
	else :
	    result = 999
    return result



def food_needed_for_breed( sect ) :
    """ food needed for maximum growth """
    result = 0
    if 'NOFOOD' not in empDb.megaDB['version']['enabledOptions']:
	etu        = version_value( 'UpdateTime' )
	eat_rate   = version_value( 'eat_rate' )
	baby_eat   = version_value( 'baby_eat' )
	uw_brate   = version_value( 'uw_brate' )
	o_brate    = version_value( 'o_brate' )

	civ_eat = ( ( eat_rate + 2.0 * baby_eat * o_brate  )
		    * value( sect, 'civ' ) )
	uw_eat  = ( ( eat_rate + 2.0 * baby_eat * uw_brate )
		    * value( sect, 'uw'  ) )
	mil_eat = eat_rate  * value( sect, 'mil' )
##  	result = math.floor( 1.0 + etu * ( civ_eat + uw_eat + mil_eat ) )
	result = -math.floor( -etu * ( civ_eat + uw_eat + mil_eat ) )

    return result


##
## All functions below assume that there is enough with food.
##

def civ_new( sect ) :
    """ number of civilians after the update """
    etu        = version_value( 'UpdateTime' )
    o_brate    = version_value( 'o_brate' )
    result = math.floor( ( o_brate * etu + 1.0 ) * value( sect, 'civ' ) )

    if result > max_pop( sect ) :
	result = max_pop( sect )

    return result


def uw_new( sect ) :
    """ number of unemployed workers after the update """
    etu        = version_value( 'UpdateTime' )
    uw_brate   = version_value( 'uw_brate' )

    result = math.floor( ( uw_brate * etu + 1.0 ) * value( sect, 'uw' ) )

    if result > max_pop( sect ) :
	result = max_pop( sect )

    return result


def civ_work( sect ) :
    """ work done by civs during the update """
    etu        = version_value( 'UpdateTime' )
    return  ( etu / 100.0 * civ_new( sect )
	      * value( sect, 'work' ) / 100.0 )



def uw_work( sect ) :
    """ work done by uw during the update """
    etu        = version_value( 'UpdateTime' )
    return  etu / 100.0 * uw_new( sect )


def mil_work( sect ) :
    """ work done by mil during the update """
    etu        = version_value( 'UpdateTime' )
    return  etu / 100.0 * value( sect, 'mil' ) * 2.0 / 5.0


def work_force( sect ) :
    """ total amount of available work during the update """
    return civ_work( sect ) + uw_work( sect ) + mil_work( sect )


def eff_new( sect ) :
    """ efficiency of the sector after next update """

    ##             ** BUG **
    ##  This code is wrong since some sector types
    ##  needs hcm and/or lcm to increase effeciency
    ##

    work = work_force( sect )
    eff, work = eff_work_new( sect, work )
    return eff



def eff_work_new( sect, work ) :
    """ new efficiency and remaining available work of 'work' """
    eff = value( sect, 'eff' )

    if new_designation( sect ) != sect.get( 'des' ) :
	eff = - ( eff + 3 ) / 4


    if work / 2 + eff > 100  :
	work = work - ( 100 - eff )
	eff  = 100

    else :
	work_on_eff = work / 2
	eff         = eff + work_on_eff
	work        = work - work_on_eff

    if eff < 0 :
	eff = 4 * eff

    return ( eff , work )



def work_needed_for_eff( sect, new_eff ) :
    """ work needed to increase efficiency to new_eff """
    old_eff = value( sect, 'eff' )
    if new_designation( sect ) != sect.get( 'des' ) :
	old_eff = - ( old_eff + 3 ) / 4

    return new_eff - old_eff





def civ_needed_for_eff( sect, new_eff ) :
    """ civ needed to increase efficiency to new_eff

    returns zero or a negative value if there is enough
    mil and uw to increase efficincy to new_eff without
    any civ """

    etu        = version_value( 'UpdateTime' )
    o_brate    = version_value( 'o_brate' )

    civ_work_needed = ( 2.0 * work_needed_for_eff( sect, new_eff )
			- uw_work( sect ) - mil_work( sect ) )

    civ_work_fact = (1.0 + etu * o_brate ) * etu / 100.0

##      return math.floor( civ_work_needed  / civ_work_fact + 1.0 )
    return -math.floor( - civ_work_needed  / civ_work_fact )



def uw_needed_for_eff( sect, new_eff ) :
    """ uw needed to increase efficiency to new_eff

    returns zero or a negative value if there is enough
    civ and mil to increase efficincy to new_eff without
    any uws """

    etu        = version_value( 'UpdateTime' )
    uw_brate   = version_value( 'uw_brate' )

    uw_work_needed = ( 2.0 * work_needed_for_eff( sect, new_eff )
		       - civ_work( sect ) - mil_work( sect ) )

    uw_work_fact = ( 1.0 + etu * uw_brate ) * etu / 100.0

##      return math.floor( uw_work_needed  / uw_work_fact + 1.0 )
    return -math.floor( - uw_work_needed  / uw_work_fact )


def mil_needed_for_eff( sect, new_eff ) :
    """ mil needed to increase efficiency to new_eff

    returns zero or a negative value if there is enough
    civ and uw to increase efficincy to new_eff without
    any mil """

    etu         = version_value( 'UpdateTime' )

    mil_work_needed = ( 2.0 * work_needed_for_eff( sect, new_eff )
			- civ_work( sect ) - uw_work( sect ) )
    mil_work_fact = ( 2.0 / 5.0 ) * etu / 100.0

##      return math.floor( mil_work_needed  / mil_work_fact + 1.0 )
    return -math.floor( - mil_work_needed  / mil_work_fact )





def work_needed_for_prod( sect ) :
    """ work needed to produce as much as possible """
    prod_work = 0.0
    des = new_designation( sect )

    if des == 'm' :
	mine_cont = value( sect, 'min' );
	if mine_cont > 0.0 :
	    prod_work = ( 999.0 * 100.0 ) / mine_cont

    ## work needed to deplete all resources
    ## ** BUG ** isn't correct with GO_RENEW option
    elif des == 'g':
	if value( sect, 'gold' ) > 0.0 :
	    prod_work = 500.0

    elif des == 'u':
	if value( sect, 'uran' ) > 0.0 :
	    prod_work = 500.0

    elif des == 'o':
	if value( sect,  'ocontent' ) > 0.0 :
	    prod_work = 1000.0

    elif des == 'j':
	prod_work = value( sect, 'iron' )
	if prod_work > 999.0 :
	    prod_work = 999.0

    elif des == 'k':
	prod_work = value( sect, 'iron' )
	if prod_work > 2.0*999.0 :
	    prod_work = 2.0 * 999.0;

    elif des == '%':
	tech = nation_value( 'tech' )
	if tech > 20.0 :
	    prod_work = value( sect, 'oil' );
	    if prod_work * 10.0 > 999.0 :
		prod_work = 999.0 / 10.0;

    elif des == 'b':
	prod_work = value( sect, 'dust' )
	if prod_work > 5.0 * 999.0  :
	    prod_work = 5.0 * 999.0;

    elif des == 'l' or des == 'p':
	prod_work = value( sect, 'lcm' );
	if prod_work > 999.0 :
	    prod_work = 999.0;

    elif des == 'i':
	tech = nation_value( 'tech' )
	if tech > 20.0 :
	    hcm_max = value( sect, 'hcm' )
	    if 2.0 * hcm_max > value ( sect, 'lcm' ) :
		hcm_max = value( sect, 'lcm' ) / 2.0
	    if hcm_max > 999.0 :
		hcm_max = 999.0
	    prod_work = 3.0 * hcm_max

    elif des == 'd':
	tech = nation_value( 'tech' )
	if tech > 20.0 :
	    oil_max = value( sect, 'oil' )
	    if  5.0 * oil_max > value( sect, 'lcm' )  :
		oil_max = value( sect, 'lcm' ) / 5.0

	    if 10.0 * oil_max > value( sect, 'hcm' ) :
		oil_max = value( sect, 'hcm' ) / 10.0
	    if oil_max > 999.0 :
		oil_max = 999.0
	    prod_work = ( 1.0 + 5.0 + 10.0 ) * oil_max;

    elif des == 't' or des == 'r':
	edu = nation_value( 'edu' )
	dust_max = 0.0
	if edu > 5.0 :
	    dust_max = value( sect, 'dust' )
	    if 5.0 * dust_max > value( sect, 'oil' ) :
		dust_max = value( sect, 'oil' ) / 5.0
	    if 10.0 * dust_max > value( sect, 'lcm' ) :
		dust_max = value( sect, 'lcm' ) / 10.0
	    if dust_max > 999.0 :
		dust_max = 999.0;
	prod_work = ( 1.0 + 5.0 + 10.0 ) * dust_max;

    elif des == 'a' :
	fert = value( sect, 'fert' )
	if fert > 0.0:
	    tech = nation_value( 'tech' )
	    pe = ( tech + 10.0 ) / ( tech + 20.0 );
	    prod_work = 999.0 * 100.0 / ( 9.0 * fert * pe )

    ## other sector types do not produce anything
    result = 0
    if prod_work > 0.0 :
	##  compensate for work that is needed to increas efficiency
	##
	## we have 3 case depending on the new efficiency
	##  new eff = 100        : add work for getting to 100 eff
	##  new eff = 60         : 2 times work for getting 60 eff
	##  new eff = 60 - 100   : see below

	work_100_eff = work_needed_for_eff( sect, 100 )
	if prod_work > work_100_eff :
	    result = prod_work + work_100_eff
	else :
	    work_60_eff = work_needed_for_eff( sect, 60 )
	    if prod_work / 0.6 < work_60_eff :
		result = 2.0 * work_60_eff
	    else :
	##
	## how much work is needed for production depends on new eff
	##
	## total work neeeded is
	## total work = "work for prod" / ( new_eff / 100 ) + "work for eff"
	## with new_eff = old_eff + work / 2
	##
	## tot_work = prod_work*100/(tot_work/2 + old_eff) + tot_work/2
	##
	##
		old_eff = 100.0 - work_100_eff;
		result = - old_eff + math.sqrt( old_eff * old_eff
						+ 400.0 * prod_work )
    return result


def civ_needed_for_prod( sect ) :
    """ civ needed to produce as much as possible

    returns zero or a negative value if there is enough
    mil and uw for production """


    etu        = version_value( 'UpdateTime' )
    o_brate    = version_value( 'o_brate' )
    civ_growth_fact = ( 1.0 + etu * o_brate )
    result = 0

    if new_designation( sect ) == 'e' :

	new_civ = etu + value( sect, 'mil' ) * ( 2.0 + etu / 10.0)
	work_for_60_eff = ( 2.0 * work_needed_for_eff( sect, 60 )
			    - uw_work( sect ) - mil_work( sect ) )

	if new_civ * etu / 100.0 < work_for_60_eff :

	    new_civ = math.ceil( math.ceil( work_for_60_eff )
				 * 100.0 / etu )

##  	result = math.floor( new_civ / civ_growth_fact + 1.0 )
	result = -math.floor( - new_civ / civ_growth_fact )

    else :
	civ_work_needed = ( work_needed_for_prod( sect )
			    - uw_work( sect ) - mil_work( sect ) )

	civ_work_fact = civ_growth_fact * etu / 100.0
##  	print civ_work_needed
##  	print civ_work_fact
##  	result = math.floor( civ_work_needed  / civ_work_fact + 1.0 )
	result = -math.floor( - civ_work_needed  / civ_work_fact )

    return result



def uw_needed_for_prod( sect ) :
    """ uw needed to produce as much as possible

    returns zero or a negative value if there is enough
    mil and civ for production """

    etu        = version_value( 'UpdateTime' )
    uw_brate   = version_value( 'uw_brate' )

    uw_work_needed = 0.0

    if new_designation( sect ) == 'e' :
	if civ_new( sect ) > 2 * value( sect, 'mil' ) :
	    uw_work_needed = ( 2.0 * work_needed_for_eff( sect, 60 )
			       - uw_work( sect ) - mil_work( sect ) )
	else :
	    uw_work_needed = - uw_work( sect ) - mil_work( sect )
    else :
	uw_work_needed = ( work_needed_for_prod( sect )
			   - civ_work( sect ) - mil_work( sect ) )

    uw_work_fact = ( 1.0 + etu * uw_brate ) * etu / 100.0
##      return  math.floor( uw_work_needed  / uw_work_fact + 1.0 )
    return  -math.floor( - uw_work_needed / uw_work_fact )




def version_value( what ) :
    """ read some game specific data """
    result = 0
    versionDB = empDb.megaDB['version']
    if what == 'UpdateTime' :
	result = versionDB['updateETUs']
    elif what == 'eat_rate' :
	result = versionDB['eatRate']
    elif what == 'baby_eat' :
	result = versionDB['BEatRate']
    elif what == 'uw_brate' :
	result = versionDB['UBirthRate']
    elif what == 'o_brate' :
	result = versionDB['birthRate']
    return result

def nation_value( what ) :
    """ read nation levels  """
    result = 0
    nationDB = empDb.megaDB['nation']
    if what == 'tech' :
	result = nationDB['technology']
    elif what == 'edu' :
	result = nationDB['education']
    return result

def sectorPredictions(ldb):
    """Return a string containing the sector predictions for LDB."""
    versionDB = empDb.megaDB['version']
    s = ""

    # Population growth predictions
    civs = ldb.get('civ', 0)
    uws = ldb.get('uw', 0)

    newcivs = civ_new(ldb)
    newuws = uw_new(ldb)
    popstr = ""
    if newcivs != civs:
	popstr = "%d civs" % newcivs
    if newuws != uws:
	if popstr:
	    popstr = popstr + ", "
	popstr = popstr + "%d uws" % newuws
    food = food_needed_for_breed(ldb)
    if food:
	s = s + " Eats %d" % food
	if popstr:
	    s = s + " becoming %s" % popstr
	s = s + ".\n"
	diff = food - ldb.get('food', 0)
	if diff > 0:
	    s = s + " NEEDS %d MORE FOOD FOR FULL GROWTH!\n" % diff
    elif popstr:
	s = s + " Expands to %s.\n" % popstr

    # New efficiency:
    sdes = ldb.get('sdes', '_')
    eff = ldb.get('eff', 100)
    if sdes != '_' or eff < 100:
	neweff = eff_new(ldb)
	if neweff > 0 and sdes != '_':
	    newdes = sdes
	else:
	    if neweff < 0:
		neweff = -neweff
	    newdes = ldb['des']
	newdes = empParse.sectorDesignationConvert[newdes]
	s = s + " Builds to a %d%% %s.\n" % (neweff, newdes)
	civ_for_100_eff = civ_needed_for_eff( ldb, 100 ) - civs
	if civ_for_100_eff > 0 :
	   s = s + ( " Needs %d more civs to become 100%%.\n"
		     % civ_for_100_eff )
    # Extras
    estr = ""
    des = ldb.get('sdes', '')
    newdes = sdes == '_' and des or sdes
    max_civs = empDb.megaDB['nation']['maxCiv']
    max_uws = empDb.megaDB['nation']['maxUW']

    if newdes == '*' or newdes == '!' or newdes == 'h' :
	# as much available workforce ( = 'avail' ) as possible for
	# harbours, airports and headquarters.
	civ_limit = max_civs
	uw_limit = max_uws
    else:
	civ_limit = civ_needed_for_prod(ldb)
	if civ_limit > max_civs: civ_limit = max_civs
	elif civ_limit < 0: civ_limit = 0

	uw_limit = uw_needed_for_prod(ldb)
	if uw_limit > max_uws: uw_limit = max_uws
	elif uw_limit < 0: uw_limit = 0

	civ_limit = civs - civ_limit
	uw_limit = uws - uw_limit

    if civ_limit > 0:
	s = s + " %d civs not working for production.\n" % civ_limit
    elif civ_limit < 0:
	s = s + " %d civs needed for max production.\n" % -civ_limit
    if uw_limit > 0:
	s = s + " %d uws not working for production.\n" % uw_limit
    elif uw_limit < 0:
	s = s + " %d uws needed for max production.\n" % -uw_limit

    if s:
	s = "\nPredictions:\n" + s
    return s
ptkei-1.12/src/empText.py0100600000076500007650000001160207007752727014372 0ustar  kevinkevin"""Text-only support."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import select
import sys
import string
# Readline is not practical because there is no way to interleave terminal
# input and socket input using the current Python implementation of readline.
#import readline

import empDb
import empQueue
import empCmd

# Key Ideas:

# What is contained within this file:

# This file contains the simple text viewer interface.  The text viewer is
# a fall back for the graphical interface.  The text interface is designed
# for compatibility of the Tk interface, not vice-versa.  Please see the
# documentation of empQueue.py for information on the structure of the
# viewer class.


# Global variables:

# viewer : For Text clients, viewer is an instance of class SText.

###########################################################################
#############################  Text interface #############################
class SText:
    """Simple ASCII Text interface."""

    def __init__(self):
	self.loginCallback = self
	self.login_kill = 0
	self.stayOnline = 0
	self.atPrompt = 0

    def Begin(self, cmd):
	"""empQueue handler: Note the beginning of a command."""
	if self.atPrompt:
	    sys.stdout.write("")
	    print "[[%s]]" % cmd
	    self.atPrompt = 0

    def data(self, msg):
	"""empQueue handler: Process a line of server data."""
	print msg
	self.atPrompt = 0

    def flush(self, msg, hdl):
	"""empQueue handler: Handle a subprompt."""
	if hdl is None:
	    print msg
	    return
	try:
	    cmd = raw_input(msg)
	except KeyboardInterrupt:
	    cmd = "ctlc"
	    print
	hdl(cmd)
	self.atPrompt = 0

    def End(self, cmd):
	"""empQueue handler: Note the end of a command."""
	if self.atPrompt:
	    print
	print empDb.GetPrompt(),
	sys.stdout.flush()
	self.atPrompt = 1

    Answer = Process = empQueue.doNothing

    def inform(self):
	"""empQueue handler: Process an asynchronous prompt update."""
	if self.atPrompt:
	    sys.stdout.write("")
	    print "\n"+empDb.GetPrompt(),
	    sys.stdout.flush()

    def flash(self, msg):
	"""empQueue handler: Process an asynchronous line of data."""
	if self.atPrompt:
	    sys.stdout.write("")
	    print
	    self.atPrompt = 0
	print msg

    Error = flash

    def login_error(self, msg):
	"""empQueue/login handler: Report a login error."""
	print msg
	# HACK! See if we are online..
	if self.ioq.sock.flags >= empQueue.QU_DISCONNECT:
	    ldb = empDb.megaDB['login']
	    t = raw_input("host[%s]: " % ldb['host'])
	    if t:
		ldb['host'] = t
	    while 1:
		t = raw_input("port[%s]: " % ldb['port'])
		if t:
		    try: t = string.atoi(t)
		    except ValueError:
			continue
		    ldb['port'] = t
		break
	# Hack! Check if we need to kill
	if msg[:22] == "[3] country in use by ":
	    t = raw_input("Try to issue a kill? [n] ")
	    if t[:1] == 'y' or t[:1] == 'Y':
		self.login_kill = 1
		self.loginHandler.retry()
		return
	    self.login_kill = 0
	ldb = empDb.megaDB['login']
	t = raw_input("Country? [%s] " % ldb['coun'])
	if t:
	    ldb['coun'] = t
	t = raw_input("Representative? [%s] " % ldb['repr'])
	if t:
	    ldb['repr'] = t
	self.loginHandler.retry()

    def login_success(self):
	"""empQueue/login handler: Note a successful login."""
	pass

    def connect_success(self):
	"""empQueue/login handler: Note a server connection."""
	self.stayOnline = 1

    def connect_terminate(self):
	"""empQueue/login handler: Note a server disconnect."""
	self.stayOnline = 0

    def main(self):
	"""empire.py callback: Start the main input/output loop."""
	# Hack!  Wait for the connect before continuing.
	while not self.stayOnline:
	    cmd = raw_input("Off-line: ")
	    try:
		self.ioq.HistSend(cmd)
	    except IndexError:
		print "History substitution error."
	# Ok, we are online now.
	while self.stayOnline:
	    pending = select.select([self.ioq, sys.stdin], [], [])[0]
	    if pending and pending[0] == self.ioq:
		self.ioq.HandleInput()
		del pending[0]
	    if pending and pending[0] == sys.stdin:
		try:
		    cmd = raw_input()
		except EOFError:
		    cmd = "ctld"
		    print
		if self.atPrompt:
		    sys.stdout.write("")
		    self.atPrompt = 0
		try:
		    self.ioq.HistSend(cmd)
		except IndexError:
		    print "History substitution error."
		del pending[0]
ptkei-1.12/src/empTk.py0100600000076500007650000005423207007752666014034 0ustar  kevinkevin"""Module that interacts with Python/Tk."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import Tkinter
import Pmw
import select
import string
import types
import re
import operator
import os

import Tk_Pane
import Tk_VDB
import MapWin
import CenWin
import LoginWin

import OutWin
import TeleWin

import empQueue
import empDb
import empParse
import empCmd
import empEval
import empPath

# Key Ideas:

# What is contained within this file:

# This file contains the main viewer class that is created by empire.py
# when a Tk connection is used.  The mainWin class defined below is
# instanciated and stored in the global variable "viewer".  viewer should
# then be accessible from all the major modules in this package.  The
# mainWin class supports all the standard callbacks that the empire queue
# (see the file empQueue.py) expects "viewer" to support.  In addition to
# these standard features, mainWin also contains the code and Tk callbacks
# for much of the main root window that is opened on the display.  It
# directly controls the sub-prompt window, the command-line window, the
# command-output window, and the root window itself.  The censor window is
# controlled by code within the CenWin.py file; the map window is
# controlled by MapWin.py, and much of the status-line is controlled by
# LoginWin.py.


# Global variables:

# viewer : For Tk clients, viewer is an instance of class mainWin.


# Relationship to the other Tk files in this package:

# The map window in the main root window is controlled by code within
# MapWin.py.  Additional map windows may be popped up using the command
# "Map" (See the method CmdMap() for more info).

# The censor window in the main root window is controlled by code from
# CenWin.py.

# An arbitrary number of output windows may be popped up at any time.  The
# command "wind" is controlled by the method CmdWind.  These output windows
# are controlled via the OutWin.py file.  Also, the output from the "cshow"
# command (see the method CmdCShow) is sent to one of these output windows.

# The login window may be opened via the command "Login" (see the CmdLogin
# method), or directly via an empQueue.py callback.  The class attribute
# viewer.loginCallback is a pointer to the loginWin class stored in the
# file LoginWin.py.  The LoginWin.py file supports the Tk interface to the
# login window, and it also supports the login callbacks needed by the
# empire queue.  In addition to login requests, the LoginWin.py file
# currently also supports code to handle the status line (see the
# QueueStatus class contained in LoginWin.py).

# There is a telegram window that may be popped up via the command "wread"
# (see CmdWRead() ).  All the functions necessary to support the telegram
# window are contained within the file TeleWin.py.

# The file Tk_Pane.py contains the low-level functionality that supports
# the paned interface in the root window.  (The drag-and-drop box that
# allows the map window and command-line to be resized.)

# The file Tk_VDB.py contains the low-levl code that currently reads in
# entries from the Tk options list and attempts to convert them to
# meaningful ptkei client data.  This is still fairly primitive.

# The file Tk_List.py supports a listbox that is more powerful than the
# standard Tk listbox.  It is not called directly from this file, but it is
# used by the telegram window and the censor window.


###########################################################################
#############################  Main window    #############################
class mainWin:
    """Tk interface"""

    def __init__(self):
	global viewer
	MapWin.viewer = CenWin.viewer = LoginWin.viewer = \
			TeleWin.viewer = OutWin.viewer = \
			viewer = self

	# Setup the balloon help.
	self.Balloon = Pmw.Balloon(Display)

	self.msgQueue = []
	self.stsList = []
	self.updateList = []
	self.atPrompt = 0

	self.Root = Display
	self.Root.title("Python/Tk Empire Interface")

	self.coord = Tkinter.StringVar()

	statusbar = Tkinter.Frame(self.Root, name="statusbar")
	statusbar.pack(side='bottom', anchor='s', fill='both')
	coordLabel = Tkinter.Label(self.Root, name="coord",
				   textvariable=self.coord, width=20,
				   relief="sunken")
	coordLabel.pack(in_=statusbar, fill='both', side='right')
	self.Balloon.bind(coordLabel, "Empire coordinates")
	self.queueStatus = LoginWin.QueueStatus(statusbar)

	self.Status = Tkinter.Entry(self.Root, name="status", relief='sunken')
	self.Status.pack(in_=statusbar, fill='both', expand=1)
	self.Status.bind('', self.DoStatus)
	self.Status.insert(0, "Welcome to empire!")
	self.Status['state']='disabled'

##  	# Create a main PanedWidget with top and bottom panes.
##  	pane = Pmw.PanedWidget(self.Root, hull_width='7i', hull_height=800)
##  	pane.pack(side='right', expand=1, fill='both')

	mapframe = Tkinter.Frame(self.Root, name="mapframe", class_="Map")
##  	mapframe = Tkinter.Frame(self.Root, name="mapframe", class_="Map")
##  	mapframe.pack(in_=pane.add('top'), expand=1, fill='both')
##  	mapframe = Tkinter.Frame(pane.pane('top'), name="mapframe", class_="Map")
##  	mapframe.pack(expand=1, fill='both')
##  	mapframe = pane.add('mapframe')

	self.map = MapWin.mapSubWin(mapframe)
	self.mapList = [self.map]

	infoframe = Tkinter.Frame(self.Root, name="infoframe")
	infoframe.pack(side='left', fill='both')
	self.CmdPrompt = Tkinter.Label(self.Root, name="cmdprompt",
				       anchor='ne')
	self.CmdPrompt.pack(in_=infoframe, side='bottom', anchor='s',
			    fill='x')
	self.CmdPrompt.bind('',
			    (lambda e, cp=self.CmdPrompt:
			     cp.configure({'wraplength': e.width})))
	self.Balloon.bind(self.CmdPrompt, "Empire prompt")
	self.cen = CenWin.cenWin(infoframe)

	ioframe = Tkinter.Frame(self.Root, name="ioframe", class_="Censor")
##  	ioframe.pack(in_=pane.add('bottom', size=400), expand=1, fill='both')
##  	ioframe = Tkinter.Frame(pane.pane('bottom'), name="ioframe",
##  				class_="Censor")
##  	ioframe.pack(expand=1, fill='both')
##  	ioframe = pane.add('ioframe')

	self.Prompt = Tkinter.Entry(self.Root, name="prompt")
	self.Prompt.pack(in_=ioframe, side='bottom', anchor='s', fill='x')
	self.Prompt.bind('', self.DoCmd)
	self.Prompt.bind('', self.DoCtld)
	self.Prompt.bind('', (lambda e, s=self: s.DoHistoryMove(1)))
	self.Prompt.bind('', (lambda e, s=self: s.DoHistoryMove(-1)))
	self.Prompt.focus()

	scrollY = Tkinter.Scrollbar(self.Root, name="ioscrollbar")
	scrollY.pack(in_=ioframe, side='right', anchor='e', fill='y')
	self.Output = Tkinter.Text(self.Root, name="iobox", state='disabled',
				   yscrollcommand=scrollY.set)
	self.Output.pack(in_=ioframe, side='left', anchor='se',
			 expand=1, fill='both')
##  	scrollY = Tkinter.Scrollbar(ioframe, name="ioscrollbar")
##  	scrollY.pack(side='right', anchor='e', fill='y')
##  	self.Output = Tkinter.Text(ioframe, name="iobox", state='disabled',
##  				   yscrollcommand=scrollY.set)
##  	self.Output.pack(side='left', anchor='se',
##  			 expand=1, fill='both')
	scrollY['command'] = self.Output.yview
	self.Output.bind('',
			 (lambda e, s=self.Output:
			  s.focus_get().insert('insert', s.selection_get())))
	self.Output.bind('', self.DoLocateSector)
	self.Output.bind('', (lambda e, s=self.Output:
					 s.see('end')))
##  	# Windows hack!
##  	bindFocus(self.Output)

	pane = Tk_Pane.paned(self.Root, mapframe, ioframe)
	self.Balloon.bind(pane.Grip, "Resize window")

	self.Root.bind('',
		       (lambda e, s=self.Output:
			s.yview('scroll', -1, 'page')))
	self.Root.bind('',
		       (lambda e, s=self.Output:
			s.yview('scroll', 1, 'page')))
	self.Root.bind('',
		       (lambda e, s=self:
			s.insertText(s.cen.getKey()) or "break"))
	self.Root.bind('', self.DoAltHandler)

	# Establish default bindings for text prompts
	Tk_VDB.setTextOptions(self.Output,
			      ('data', 'prompt', 'command', 'flush',
			       'subcommand', 'flash', 'inverse', 'error'))
##	self.lwrite(('data', 'data'), "\n", ('prompt :', 'prompt'),
##		    ('command', 'command'), "\n",
##		    ('subprompt :', 'subprompt'),
##		    ('subcommand', 'subcommand'), "\n", ('flash', 'flash'))

	self.loginCallback = LoginWin.loginWin()
	self.telegramWindow = TeleWin.teleWin()
	self.Root.update_idletasks()
	self.Root.pack_propagate(0)
	infoframe.pack_propagate(0)

    #
    # Tk callbacks - Bindings for keypresses/mouse events:
    #

    def DoHistoryMove(self, offset):
	"""Move up or down the command-line history list."""
	try:
	    cmd = self.ioq.HistMove(offset, self.Prompt.get())
	except IndexError:
	    self.Root.bell()
	else:
	    self.Prompt.delete(0, 'end')
	    self.Prompt.insert(0, cmd)

    def DoCmd(self, event):
	"""Tk callback:  Accept the command, and send to server."""
	cmd = self.Prompt.get()
	self.Prompt.delete(0, 'end')
	try:
	    self.ioq.HistSend(cmd)
	except IndexError:
	    self.Root.bell()

    def DoAltHandler(self, event):
	"""Tk callback:  Handle Alt+key events."""
	key = event.keysym
	if len(key) != 1 or key not in empDb.pathDirections:
	    return
	# Put the key into the input window.
	self.Root.focus_lastfor().insert('insert', key)
	# Find the new location.
	range = self.cen.getSect()
	sect1 = empDb.directionToSector((range[0], range[2]), key)
	sect2 = empDb.directionToSector((range[1], range[3]), key)
	# Change the censor window.
	self.cen.SetSect((sect1[0], sect2[0], sect1[1], sect2[1]))
	# Ouch - something massive is also attached to these keys..  Must
	# "break" to prevent cpu hogging..
	return "break"

    def DoCtld(self, event):
	self.ioq.Send("ctld")

    sectorFormat = re.compile(empParse.s_sector)
    def DoLocateSector(self, event):
	"""Tk callback:  Highlight a sector from its text description.

	This function will grab a sector designation (of the form x,y) from
	a text output window and highlight the sector on the map.  It works
	with any text output window; in addition to the main command-line
	window, this function is called from the telegram/output windows.
	"""
	win = event.widget
	pos = "@%s,%s" % (event.x, event.y)
	start = win.search("^|[^-0-9,]", pos+" + 1 chars",
			   regexp=1, backwards=1)
	end = win.search("[^-0-9,]|$", pos, regexp=1)
	mm = self.sectorFormat.search(win.get(start, end))
	if mm:
	    x, y = map(string.atoi, mm.groups())
	    self.cen.SetSect((x, x, y, y))
	else:
	    self.Root.bell()

    #
    # Output window functions:
    #

    def displayMsgs(self):
	"""Send the internal message queue to the Tk interface."""
	self.Output['state']='normal'
	self.msgQueue[:0] = ['end']
	apply(self.Output.insert, tuple(self.msgQueue))

	# Delete any lines in excess of 1000
	self.Output.delete('1.0', 'end - 1000 lines')

	self.Output['state']='disabled'
	self.Output.see('end')
	del self.msgQueue[:]

    def Begin(self, cmd):
	"""empQueue handler: Note the beginning of a command."""
	# If there are no messages on the msgQueue, then force the display
	# to output the begin line.  This should give a little better
	# feedback to the user - if it is not done, no acknowledgement of
	# the sent command is shown until the server starts sending data.
	forceOutput = not self.msgQueue

	if self.atPrompt:
	    self.msgQueue[len(self.msgQueue):] = [cmd, 'command']
	    self.atPrompt = 0
	else:
	    self.msgQueue[len(self.msgQueue):] = [
		"\n", '',
		empDb.GetPrompt(), 'prompt',
		cmd, 'command']
	if forceOutput:
	    self.displayMsgs()

    def data(self, msg):
	"""empQueue handler: Process a line of server data."""
	# Check for empire display protocols.
	ochr = map(ord, msg)
	if 7 in ochr:
	    # Found bell characters
	    num = ochr.count(7)
	    for i in range(num):
		ochr.remove(7)
		self.Root.bell()
	    # Remove bell characters from input
	    msg = string.join(map(chr, ochr), '')
	l = len(ochr)
	t = map(operator.and_, [128]*l, ochr)
	if 128 in t:
	    # Found inverse video characters
	    ochr = map(chr, map(operator.and_, [~128]*l, ochr))
	    names = (('data', 128), ('inverse', 0))
	    n = 0
	    cont = 1
	    lst = ["\n", '']
	    while cont:
		try:
		    pos = t.index(names[n][1])
		except ValueError:
		    pos = len(t)
		    cont = 0
		lst[len(lst):] = [string.join(ochr, "")[:pos], names[n][0]]
		del t[:pos], ochr[:pos]
		n = n ^ 1
	    self.msgQueue[len(self.msgQueue):] = lst
	else:
	    self.msgQueue[len(self.msgQueue):] = [
		"\n", '', msg, 'data']
	self.atPrompt = 0

    def flush(self, msg, hdl):
	"""empQueue handler: Handle a subprompt."""
	mm = self.sectorFormat.search(msg)
	if mm:
	    self.markSectors([map(string.atoi, mm.groups())], 'prompt')
	self.msgQueue[len(self.msgQueue):] = [
	    "\n", '', msg, 'flush']
	if hdl is not None:
	    self.bufferStatus(msg, hdl, 'subprompt',
			      # Hack! Only move to subprompt when syncing
			      not self.queueStatus.burst.get())
	self.atPrompt = 2

    def Answer(self, msg):
	"""empQueue handler: Note the answer to a subprompt."""
	# Check if bufferStatus is requesting a sub-prompt
	if (self.delStatus('subprompt')
	    # Hack! Only beep when syncing
	    and not self.queueStatus.burst.get()):
	    self.Root.bell()
## 	self.delStatus('subprompt')
	if msg is not None:
	    self.msgQueue[len(self.msgQueue):] = [msg, 'subcommand']
	self.atPrompt = 0

    def End(self, cmd):
	"""empQueue handler: Note the end of a command."""
	p = empDb.GetPrompt()
	self.msgQueue[len(self.msgQueue):] = [
	    "\n", '', p, 'prompt']
	self.markSectors([], 'prompt')
	self.setprompt(p)
	self.atPrompt = 1

    def Process(self):
	"""empQueue handler: Note a lull in socket activity."""
	# Send output to screen
	if self.msgQueue:
	    self.displayMsgs()

	# Update the graphical displays.
	if filter(None, empDb.updateDB.values()):
	    self.redraw()

    def inform(self):
	"""empQueue handler: Process an asynchronous prompt update."""
	p = empDb.GetPrompt()
	if self.atPrompt == 1:
	    self.msgQueue[len(self.msgQueue):] = [
		"\n", '', p, 'prompt']
	elif self.stsList:
	    # The prompt window is in use - write prompt anyway
	    self.msgQueue[len(self.msgQueue):] = [
		"\n", '',
		empDb.megaDB['prompt']['inform'], 'prompt']
	self.setprompt(p)

    def flash(self, msg):
	"""empQueue handler: Process an asynchronous line of data."""
	self.msgQueue[len(self.msgQueue):] = [
	    "\n", '', msg, 'flash']
	self.atPrompt = 0

    def Error(self, msg):
	"""empQueue handler: Process an internal error notification."""
	self.msgQueue[len(self.msgQueue):] = [
	    "\n", '', msg, 'error']
	self.atPrompt = 0
	self.displayMsgs()

    #
    # Subprompt manipulators:
    #

    def setprompt(self, prompt=None):
	"""Set the prompt window to the standard empire prompt."""
	if self.stsList:
	    # Dont update the prompt if the status window is in use.
	    return
	if prompt is None:
	    prompt = empDb.GetPrompt()
	self.CmdPrompt['text'] = prompt

    def bufferStatus(self, prompt, hdl, id=None, focus=1):
	"""Place a subprompt query on a queue."""
	self.stsList.append((prompt, hdl, id))
	if len(self.stsList) == 1:
	    self.CmdPrompt['anchor'] = 'nw'
	    self.CmdPrompt['text'] = self.stsList[0][0]
	    self.Status['state'] = 'normal'
##  	    self.Status['relief'] = 'sunken'
	    self.Status.delete(0, 'end')
	    if focus:
		self.Status.focus()

    def DoStatus(self, event):
	"""Tk callback:  Accept a subcommand, and send to calling process."""
	cmd = self.Status.get()
	hdl = self.stsList[0][1]
	self.delStatus(self.stsList[0][2])
	hdl(cmd)

    def delStatus(self, id):
	"""Find a prompt request with ID and delete it."""
	for i in range(len(self.stsList)):
	    if self.stsList[i][2] != id:
		continue
	    del self.stsList[i]
	    self.Status.delete(0, 'end')
	    if self.stsList:
		self.CmdPrompt['text'] = self.stsList[0][0]
	    else:
		self.Status['state'] = 'disabled'
##  		self.Status['relief'] = 'flat'
		self.CmdPrompt['anchor'] = 'ne'
		self.CmdPrompt['text'] = ""
		self.Prompt.focus()
	    return 1
	return 0

    def queryCommand(self, msg, cmd, post=None, pre=None):
	"""Query the user for a value; don't buffer if prompt is in-use."""
	if self.stsList:
	    # Dont buffer additional commands.
	    self.Root.bell()
	    return
	def f(msg, self=self, cmd=cmd, pre=pre, post=post):
	    """Function to be called when status window finishes."""
	    if not msg:
		return
	    if pre:
		self.ioq.Send(pre)
	    self.ioq.Send(cmd % ((msg,)*string.count(cmd, '%s')))
	    if post:
		self.ioq.Send(post)
	self.bufferStatus(msg, f)

    #
    # Login callbacks:
    #

    def startConn(self):
	"""Login callback:  Establish the socket connection."""
	Tkinter.tkinter.createfilehandler(self.ioq,
					  Tkinter.tkinter.READABLE,
					  self.HandleSock)

    def stopConn(self):
	"""Login callback:  Disengage the socket connection."""
	Tkinter.tkinter.deletefilehandler(self.ioq)

    #
    # Misc. utilities:
    #

    def transferKeys(self, win):
	"""Set the window WIN to redirect keystrokes to the root window."""
	win.bind('', (lambda e:
			   (not e.char or
			    e.widget.focus_get().__class__ in (
				Tkinter.Text, Tkinter.Entry))
			   or viewer.Root.focus_lastfor().focus()
			   or viewer.Root.event_generate('',
							 state=e.state,
							 keysym=e.keysym,
							 keycode=e.keycode)))

    def insertText(self, txt):
	"""Insert TXT into the current position in the command-line."""
	inpbox = self.Root.focus_lastfor()
	cmd = inpbox.get()
	idx = inpbox.index('insert')
	end = inpbox.index('end')
	if idx > 1 and cmd[idx-1] != ' ':
	    txt = " " + txt
	if idx == end or cmd[idx] != ' ':
	    txt = txt + " "
	inpbox.insert('insert', txt)

    def redraw(self, total=0):
	"""DB handler: Database has changed - update the displays."""
	# Inform all subwindows of the update.
	for i in self.updateList:
	    i.redraw(total)
	# Clear the update database.
	for i in filter(None, empDb.updateDB.values()):
	    i.clear()

    def markSectors(self, *args):
	"""Send markSectors request to all maps."""
	for i in self.mapList:
	    apply(i.markSectors, args)

    def HandleSock(self, file, mask):
	"""Tk file callback:  Process pending socket data."""
	self.ioq.HandleInput()

    #
    # empire.py callbacks:
    #

    def main(self):
	"""empire.py callback: Start the main input/output loop."""
	# Register the Tk commands.
	self.ioq.registerCmds(OutWin.CmdWind, LoginWin.CmdLogin
			      , TeleWin.CmdWRead, MapWin.CmdMap
			      , OutWin.CmdCShow, CmdSect
			      , MapWin.CmdBestpath)

	# Hack! Start the queue checking timer.
	self.queueStatus.checkQueue()

	# Enter Tk mainloop.
	self.Root.mainloop()

## 	while 1:
## 	    pending = select.select([self.ioq], [], [], .1)[0]
## 	    self.root.update()
## 	    if pending:
## 		self.HandleSock()

# # The following commands are callback functions for the EmpCmd
# # interface.  They define client-side synthetic commands that are
# # dependent on the Tk interface.

class CmdSect(empCmd.baseCommand):
    description = "Highlight specified sectors on main map."

    defaultBinding = (('Sect', 4),)

    commandFormat = re.compile(
	r"^(?P\S+)(?:\s+\?(?P\S+))?\s*$|^$")
    def receive(self):
	mm = self.parameterMatch
	if not mm.group('sectors'):
	    # Disable highlighting
	    viewer.markSectors([], "sect")
	    return
	try:
	    list = empEval.getSectors(
		"owner==-1 and " + empEval.selectToExpr(
		    mm.group('sectors'),
		    mm.group('selectors')),
		'SECTOR')
	except empEval.error, e:
	    viewer.Error(e)
	else:
	    viewer.markSectors(list, "sect")

##     def CmdBurstAll(self, ioq, match, out):
## 	"""Put the Tk interface into burst mode."""
## 	if match.args == 'on':
## 	    ioq.preFlags = ioq.postFlags = empQueue.QU_BURST
## 	elif match.args == 'off':
## 	    ioq.preFlags = ioq.postFlags = empQueue.QU_SYNC
## 	    if self.atPrompt == 2:
## 		self.delStatus('subprompt')

###########################################################################
#############################  Startup	      #############################

# Open the display
Display = Tkinter.Tk(None, None, "Ptkei")
Pmw.initialise(Display)

##  bindFocus = empQueue.doNothing

# Read in options database
Display.option_readfile(empQueue.pathPrefix('TkOption'),
			'startupFile')

# HACK!  Platform specific initialization.

if os.name == 'posix':
    # X11 initialization
    file = empQueue.pathPrefix('TkOption.x11')
    if file:
	Display.option_readfile(file, 'startupFile')
    del file

    # Hack! Set the default font for entry/listbox to be the same as the text
    # box.
    f = Tkinter.Text()
    Display.option_add("*Entry.font", f['font'], 'widgetDefault')
    Display.option_add("*Listbox.font", f['font'], 'widgetDefault')
    f.destroy()
    del f
elif os.name == 'nt':
    # Windows initialization
    file = empQueue.pathPrefix('TkOption.w32')
    if file:
	Display.option_readfile(file, 'startupFile')
    del file

##      print "PTkEI: Using Windows text selection hack."
##      def setFocus(event):
##  	event.widget.OldFocus = event.widget.focus_lastfor()
##  	event.widget.focus()

##      def unsetFocus(event):
##  	if hasattr(event.widget, 'OldFocus'):
##  	    event.widget.OldFocus.focus()
##  	    del event.widget.OldFocus

##      def bindFocus(win):
##  	win.bind('', setFocus)
##  	win.bind('', unsetFocus)


# Handle platforms that don't support the Tcl file handler
if Tkinter.tkinter.createfilehandler is None:
    print "PTkEI: Using emulated file handlers."
    def bogusFileHandler(file, mask, hdlr):
	global bogusFileTimer
	def hdl(file=file, mask=mask, hdlr=hdlr):
	    if (file.fileno() is not None
		and select.select([file], [], [], 0)[0]):
		hdlr(file, mask)
	    bogusFileHandler(file, mask, hdlr)
	bogusFileTimer = Tkinter.tkinter.createtimerhandler(50, hdl)

    def bogusDelFileHandler(fileno):
	bogusFileTimer.deletetimerhandler()

    Tkinter.tkinter.createfilehandler = bogusFileHandler
    Tkinter.tkinter.deletefilehandler = bogusDelFileHandler
ptkei-1.12/src/LoginWin.py0100600000076500007650000003077306775764365014520 0ustar  kevinkevin"""Get host/port and country/representative information graphically."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import Tkinter
import Pmw
import tkMessageBox
import tkFileDialog

import string
import sys
import os
import traceback

import empDb
import empQueue
import empCmd

###########################################################################
#############################  Login window   #############################
class loginWin:
    """Get host/port and coun/rep info in a graphical manner."""
    def __init__(self):
	# Create root window
	self.Root = Tkinter.Toplevel(name="login")
	self.Root.withdraw()
	# Windows HACK!
	if os.name == 'nt':
	    self.Root.transient(viewer.Root)
	self.Root.title("Empire login")
	self.Root.iconname("Empire login")
	self.Root.bind('', self.DoPlay)
	self.Root.protocol('WM_DELETE_WINDOW', self.handleDelete)

	self.Status = Tkinter.Label(self.Root, name="status", width=40,
				    anchor='w', text="hrmm")
	self.Status.pack(side='bottom', fill='x', expand=1)

	# Allow the database to be selected.
	dbGroup = Pmw.Group(self.Root,
			    tag_text = "Database File")
	dbGroup.pack(fill='x', expand=1)
	dbframe = dbGroup.interior()
	self.FileInfo = Tkinter.Label(dbframe, name="filename",
				      text="File:\n "+empDb.DBIO.filename,
				      justify='left', anchor='w')
	self.FileInfo.pack(side='top', fill='x', expand=1)
	self.ResetB = Tkinter.Button(dbframe, name="reset",
				     text="Reset", command=self.DoReset)
	self.ResetB.pack(side='right')
	self.SaveB = Tkinter.Button(dbframe, name="save",
				      text="Save As", command=self.DoSave)
	self.SaveB.pack(side='right')
	self.LoadB = Tkinter.Button(dbframe, name="load",
				      text="Load", command=self.DoLoad)
	self.LoadB.pack(side='right')
	self.NewB = Tkinter.Button(dbframe, name="new",
				   text="New", command=self.DoNew)
	self.NewB.pack(side='right')

	# Create network info section.
	netGroup = Pmw.Group(self.Root,
			     tag_text = "Server Information")
##  			     tag_pyclass=Pmw.OptionMenu,
##  			     tag_labelpos='w',
##  			     tag_labelmargin=10,
##  			     tag_label_text="Server",
##  			     tag_items=("Cheetah", "Zebra", "Changeling"))
	netGroup.pack(side='top', fill='x', expand=1)
	netFrame = netGroup.interior()
	lhost = Tkinter.Label(netFrame, name="lhost",
			      anchor='w', text="Host:")
	lhost.pack(fill='x', expand=1)
	self.Host = Tkinter.Entry(netFrame, name="host")
	self.Host.pack(fill='x', expand=1)
	lport = Tkinter.Label(netFrame, name="lport",
			      anchor='w', text="Port:")
	lport.pack(fill='x', expand=1)
	self.Port = Tkinter.Entry(netFrame, name="port")
	self.Port.pack(fill='x', expand=1)
	self.DisconnectB = Tkinter.Button(netFrame, name="disconnect",
					  text="Disconnect", state='disabled',
					  command=self.DoDisconnect)
	self.DisconnectB.pack(anchor='e')

	# Create player info section.
	playerGroup = Pmw.Group(self.Root,
				tag_text = "Player Information")
	playerGroup.pack(side='top', fill='x', expand=1)
	pframe = playerGroup.interior()
	lcoun = Tkinter.Label(pframe, name="lcoun",
			      anchor='w', text="Country:")
	lcoun.pack(fill='x', expand=1)
	self.Coun = Tkinter.Entry(pframe, name="coun")
	self.Coun.pack(fill='x', expand=1)
	lrep = Tkinter.Label(pframe, name="lrep",
			     anchor='w', text="Password:")
	lrep.pack(fill='x', expand=1)
	self.Rep = Tkinter.Entry(pframe, name="rep")
	self.Rep.pack(fill='x', expand=1)
	self.killV = Tkinter.StringVar()
	killCB = Tkinter.Checkbutton(pframe, name="kill", text="Kill",
				     variable=self.killV,
				     command=self.DoKill)
	killCB.pack(anchor='w')
	self.PlayB = Tkinter.Button(pframe, name="play",
				    text="Play", command=self.DoPlay)
	self.PlayB.pack(anchor='e')

	self.getDBValues()

    def setDBValues(self):
	"""Set the database login values from the login window."""
	port = string.atoi(self.Port.get())
	vals = {'host':self.Host.get(), 'port':port,
		'coun':self.Coun.get(),	'repr':self.Rep.get()}
	loginDb = empDb.megaDB['login']
	if (loginDb['host'] != vals['host'] or loginDb['port'] != vals['port']
	    or loginDb['coun'] != vals['coun']):
	    empDb.DBIO.newDatabase = 1
	loginDb.update(vals)

    def getDBValues(self):
	"""Get the database login values and set them in the login window."""
	self.login_kill = 0
	ldict = empDb.megaDB["login"]
	self.Host.delete(0, 'end')
	self.Host.insert(0, ldict['host'])
	self.Port.delete(0, 'end')
	self.Port.insert(0, ldict['port'])
	self.Coun.delete(0, 'end')
	self.Coun.insert(0, ldict['coun'])
	self.Rep.delete(0, 'end')
	self.Rep.insert(0, ldict['repr'])

    def DoPlay(self, event=None):
	"""Tk callback: Process Play button request."""
	try:
	    self.setDBValues()
	except ValueError:
	    self.Status['text'] = "Could not convert port to an integer."
	    return
	self.Status['text'] = "Attempting connection.."
	self.Root.update_idletasks()
	self.loginHandler.retry()

    def DoReset(self):
	"""Tk callback: Process Reset button request."""
	if not tkMessageBox.askokcancel(
	    "Reset Database?",
	    "This command will reset all known information."
	    "  Really continue?"):
	    return
	DBIO = empDb.DBIO
	DBIO.reset()
	try: self.setDBValues()
	except ValueError:
	    pass
	viewer.redraw(1)

    def DoSave(self):
	"""Tk callback: Process Save button request."""
	DBIO = empDb.DBIO
	newfile = tkFileDialog.SaveAs(title="Save Database",
				      initialfile=DBIO.filename).show()
	if not newfile:
	    return
	DBIO.filename = newfile
	DBIO.needSave = 1
	self.FileInfo['text'] = "File:\n " + newfile
	try:
	    DBIO.save()
	except:
	    empQueue.flashException()
	    return

    def DoLoad(self):
	"""Tk callback: Process Load button request."""
	newfile = tkFileDialog.Open(title="Load Database").show()
	if not newfile:
	    return
	DBIO = empDb.DBIO
	try:
	    DBIO.save()
	except:
	    empQueue.flashException()
	    return
	self.FileInfo['text'] = "File:\n " + newfile
	try:
	    DBIO.load(newfile)
	except:
	    viewer.Error("PTkEI: Encountered error while loading database.\n"
			 "PTkEI: Perhaps this is an old database?\n")
	    traceback.print_exc()
	    return
	self.getDBValues()
	self.Status['text'] = "Loading Database.."
	self.Root.update_idletasks()
	viewer.redraw(1)
	self.Status['text'] = ""

    def DoNew(self):
	"""Tk callback: Process New button request."""
	newfile = tkFileDialog.SaveAs(title="New Database").show()
	if not newfile:
	    return
	DBIO = empDb.DBIO
	try:
	    DBIO.save()
	except:
	    empQueue.flashException()
	    return
	DBIO.filename = newfile
	self.FileInfo['text'] = "File:\n " + newfile
	DBIO.reset()
	viewer.redraw(1)

    def DoKill(self):
	"""Tk callback: Process Kill button request."""
	self.login_kill = (self.killV.get() == "1")

    def DoDisconnect(self):
	"""Tk callback: Process Disconnect button request."""
	# HACK++
	viewer.ioq.sock.loginParser.Disconnect()

    def handleDelete(self):
	"""Tk callback: Remove the window from the display."""
	self.Root.withdraw()

    def login_error(self, msg):
	"""empQueue/login handler: Report a login error."""
	self.Status['text'] = msg
	self.Root.deiconify()
	self.Root.lift()

    def login_success(self):
	"""empQueue/login handler: Note a successful login."""
	self.Root.withdraw()
	self.Coun['state'] = self.Rep['state'] = \
			     self.PlayB['state'] = \
			     self.LoadB['state'] = self.SaveB['state'] = \
			     self.NewB['state'] = self.ResetB['state'] = \
			     'disabled'
	self.login_kill = 0
	self.killV.set("0")

    def connect_success(self):
	"""empQueue/login handler: Note a server connection."""
	viewer.startConn()
	self.Host['state'] = self.Port['state'] = 'disabled'
	self.DisconnectB['state'] = 'normal'

    def connect_terminate(self):
	"""empQueue/login handler: Note a server disconnect."""
	self.Host['state'] = self.Port['state'] = \
			     self.Coun['state'] = self.Rep['state'] = \
			     self.PlayB['state'] = \
			     self.LoadB['state'] = self.SaveB['state'] = \
			     self.NewB['state'] = self.ResetB['state'] = \
			     'normal'
	self.DisconnectB['state'] = 'disabled'
	viewer.stopConn()

class CmdLogin(empCmd.baseCommand):
    description = "Re-open the login window."

    defaultBinding = (('Login', 5),)

    def invoke(self):
	viewer.loginCallback.login_error("")


###########################################################################
#############################  Queue Menu     #############################
class QueueStatus:
    def __init__(self, root):
	# Create the queue status menubutton
	self.queueStatus = Tkinter.StringVar()
	self.queueStatus.set("Starting")
	menubutton = Tkinter.Menubutton(viewer.Root, name="socket",
					textvariable=self.queueStatus,
					width=20,
					relief="sunken")
	try:
	    # Tk 8.0 option
	    menubutton['direction'] = 'above'
	except Tkinter.TclError:
	    pass
	menubutton.pack(in_=root, fill='both', side='right')
	viewer.Balloon.bind(menubutton, "Queue status\n"
			    +"Click for Queue Menu")

	# Create the queue status menu
	menu = Tkinter.Menu(menubutton, name="queueMenu",
			    tearoffcommand=self.DoTearoff)
	menu.add_command(label='Clear Queue', command=self.DoClearQueue)
	self.paused = Tkinter.IntVar()
	self.paused.set(0)
	menu.add_checkbutton(label='Pause Queue',
			     command=self.DoSetPause,
			     variable=self.paused, onvalue=1, offvalue=0)
	menu.add_separator()
	self.raw = Tkinter.IntVar()
	self.raw.set(0)
	menu.add_checkbutton(label='Raw Mode',
			     command=self.DoSetRaw,
			     variable=self.raw, onvalue=1, offvalue=0)
	menu.add_separator()

	self.burst = Tkinter.IntVar()
	self.burst.set(0)
##  	menu.add_radiobutton(label='Burst Mode',
##  			     command=self.DoSetBurst,
##  			     variable=self.burst, value=1)
##  	menu.add_radiobutton(label='Synchronous Mode',
##  			     command=self.DoSetBurst,
##  			     variable=self.burst, value=2)
	menu.add_checkbutton(label='Burst Mode',
			     command=self.DoSetBurst,
			     variable=self.burst, onvalue=1, offvalue=0)
	menubutton['menu']=menu

	# Create the update countdown timer
	self.updateStatus = Tkinter.StringVar()
	self.updateStatus.set("--:--:--")
	updateS = Tkinter.Label(viewer.Root, name="countdown",
				textvariable=self.updateStatus, width=10,
				relief="sunken"
				)
	updateS.pack(in_=root, fill='both', side='right')
	self.lasttime = (None, None, None)
	viewer.Balloon.bind(updateS, "Time until next update")

    def checkQueue(self):
	"""Tk timer callback:  Show the queue status."""
	Tkinter.tkinter.createtimerhandler(500, self.checkQueue)
	newtime = empDb.megaDB['time'].getCountDown()
	if newtime != self.lasttime:
	    hours, minutes, seconds = newtime
	    if hours is None:
		self.lasttime = (None, None, None)
		self.updateStatus.set("--:--:--")
	    else:
		lasthours, lastminutes, lastseconds = self.lasttime
		if (lasthours is None or minutes < 5 or seconds == 0
		    or minutes > lastminutes or minutes < lastminutes-1
		    or (minutes != lastminutes and lastseconds != 0)
		    or hours != lasthours):
		    self.lasttime = tuple(map(int, newtime))
		    self.updateStatus.set("%d:%02d:%02d" % newtime)

	ioq = viewer.ioq
	flags = ioq.sock.flags
	self.paused.set(flags in (empQueue.QU_PAUSED, empQueue.QU_DISCONNECT))

	status = ioq.sock.GetStatusMsg()

	raw = (ioq.raw != 0)
	self.raw.set(raw)
	if raw:
	    status = "Raw "+status
	burst = (ioq.preFlag == empQueue.QU_BURST)
	self.burst.set(burst)
	if burst:
	    status = "Burst "+status

	self.queueStatus.set(status)

    def DoSetRaw(self):
	viewer.ioq.raw = (self.raw.get() == 1)

    def DoSetBurst(self):
	ioq = viewer.ioq
	if self.burst.get() == 1:
	    ioq.preFlag = ioq.postFlag = empQueue.QU_BURST
	else:
	    ioq.preFlag = ioq.postFlag = empQueue.QU_SYNC

    def DoSetPause(self):
	viewer.ioq.sock.pauseQueue(self.paused.get() == 1)

    def DoClearQueue(self):
	viewer.ioq.sock.clearQueue()

    def DoTearoff(self, queueMenu, newWin):
	# Hrmm.  Tkinter doesn't seem to support this fully.
	viewer.Root.tk.call("wm", "title", newWin, "Queue Options")
	viewer.Root.tk.call("wm", "iconname", newWin, "Queue Options")
ptkei-1.12/src/MapWin.py0100600000076500007650000006411306777245253014150 0ustar  kevinkevin"""Maintains graphical map window display."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import Tkinter
import string
import operator
import math

import Tk_VDB

import empDb
import empSector
import empPath
import empParse
import empCmd

###########################################################################
#############################  Map window     #############################
class mapSubWin:
    """Maintain map display"""

    def __init__(self, master):
	self.maxCoord = empDb.megaDB['version']['worldsize']
	self.origin = (self.maxCoord[0]/2, self.maxCoord[1]/2)
	self.cursor = self.start = ()
	self.dimen = []

	scrollX = Tkinter.Scrollbar(master, name="scrollX",
				    orient='horizontal')
	scrollX.grid(row=1, sticky='wes')
	scrollY = Tkinter.Scrollbar(master, name="scrollY",
				    orient='vertical')
	scrollY.grid(column=1, row=0, sticky='nse')
	self.Map = Tkinter.Canvas(master, name="sectors",
				  xscrollcommand=scrollX.set,
				  yscrollcommand=scrollY.set)
	self.Map.grid(column=0, row=0, sticky='nwes')
	scrollX['command'] = self.Map.xview
	scrollY['command'] = self.Map.yview

	master.rowconfigure(0, weight=1)
	master.columnconfigure(0, weight=1)

	self.Map.bind('', self.DoCoordEndBox, "+")
	self.Map.bind('', self.DoCoord)
	self.Map.bind('', self.DoCoord)
	self.Map.bind('', self.DoCoordClear)

	self.Map.bind('', self.DoCoordBox)
	self.Map.bind('', self.DoSelect)
	self.Map.bind('', self.DoCoordBox)
	self.Map.bind('', self.DoSelect)

	self.Map.bind('',
		      (lambda e, self=self:
		       self.adjustSector(0.90)))
	self.Map.bind('',
		      (lambda e, self=self:
		       self.adjustSector(1.10)))
	self.Map.bind('',
		      (lambda e, self=self:
		       self.adjustSector(0.50)))
	self.Map.bind('',
		      (lambda e, self=self:
		       self.adjustSector(2.00)))
	self.Map.bind('',
		      (lambda e, self=self:
		       self.redraw(1)))

	self.Map.bind('', self.DoCensor)
	self.Map.bind('', self.DoOrigin)
	self.Map.bind('', self.DoResize)

	# getting Default Mapsize from "TkOption"
	try:
	    self.gridsize = map(string.atof, string.split(
		self.Map.option_get("defaultSize", "")))
	    self.gridsize[1] = self.gridsize[1] * 3.0/2.0
	except (ValueError, IndexError):
	    self.gridsize = [18.0, 24.0]

	# getting default for when to start the Combat Mode, when zooming
	try:
	    self.combatModeStartSize = map(string.atof, string.split(
		self.Map.option_get("combatModeStartSize", "")))
	    self.combatModeStartSize[1] = self.combatModeStartSize[1] * 3.0/2.0
	except (ValueError, IndexError):
	    self.combatModeStartSize = [60.0, 80.0]

	#getting default font for Combat Mode XXX(will be changed in the future)
	try:
	    self.combatModeFont = self.Map.option_get("combatModeFont", "")
	except ValueError:
	    self.combatModeFont = "courier"

	# activating/deactivating combat mode
	if (self.gridsize[0]>self.combatModeStartSize[0] and
	    self.gridsize[1]>self.combatModeStartSize[1]):
		self.combatmode=1
	else:
		self.combatmode=0

	self.optionsDict = {}

	# Register automatic updating
	viewer.updateList.append(self)

	self.redraw(1)

    def adjustSector(self, ratio):
	"""Scale the size of the map by RATIO."""
	self.gridsize = map(operator.mul, [ratio]*len(self.gridsize),
			    self.gridsize)
	# activating/deactivating combat mode
	if (self.gridsize[0]>self.combatModeStartSize[0] and
	    self.gridsize[1]>self.combatModeStartSize[1]):
		self.combatmode=1
	else:
		self.combatmode=0

	# Redisplay sectors without forcing a redraw.
	xview = self.Map.xview()
	yview = self.Map.yview()
	winWidth = (xview[1] - xview[0])/2.0
	winHeight = (yview[1] - yview[0])/2.0
	ws = self.maxCoord
	self.Map['scrollregion'] = (-self.gridsize[0], -self.gridsize[1],
				    ws[0]*self.gridsize[0],
				    ws[1]*self.gridsize[1])
	self.Map.scale('all', 0, 0, ratio, ratio)
	self.Map.xview('moveto', xview[0]+winWidth*(1-1.0/ratio))
	self.Map.yview('moveto', yview[0]+winHeight*(1-1.0/ratio))

    def DoResize(self, event):
	"""Tk callback: Note a resize, and adjust the window accordingly."""
	new = (event.width, event.height)
	if not self.dimen:
	    # The window is being drawn for the first time
##  	    self.redraw(1)
	    self.center()
	    self.dimen = new
	    return
	xview = self.Map.xview()
	yview = self.Map.yview()
	win = map(string.atof, string.split(self.Map['scrollregion']))
	scrWidth, scrHeight = win[2]-win[0], win[3]-win[1]
	self.Map.xview('moveto', xview[0]
		       +(self.dimen[0]-new[0])/2.0/scrWidth)
	self.Map.yview('moveto', yview[0]
		       +(self.dimen[1]-new[1])/2.0/scrHeight)
	self.dimen = new

    def getCoord(self, coord):
	"""Convert empire coords to screen coordinates."""
	return ((coord[0]+self.origin[0])%self.maxCoord[0]*self.gridsize[0],
		(coord[1]+self.origin[1])%self.maxCoord[1]*self.gridsize[1])

    def see(self, coord):
	"""If COORD isn't currently viewable, scroll window so that it is."""
	win = map(string.atof, string.split(self.Map['scrollregion']))
	scrWidth, scrHeight = win[2]-win[0], win[3]-win[1]
	xview = self.Map.xview()
	yview = self.Map.yview()
	x, y = self.getCoord(coord)
	xpos, ypos = (x-win[0])/scrWidth, (y-win[1])/scrHeight
	if (xpos < xview[0] or xpos > xview[1]
	    or ypos < yview[0] or ypos > yview[1]):
	    winWidth = (xview[1] - xview[0])/2.0
	    winHeight = (yview[1] - yview[0])/2.0
	    self.Map.xview('moveto', xpos - winWidth)
	    self.Map.yview('moveto', ypos - winHeight)

    def center(self):
	"""Center window."""
	xview = self.Map.xview()
	yview = self.Map.yview()
	winWidth = (xview[1] - xview[0])/2
	winHeight = (yview[1] - yview[0])/2
	self.Map.xview('moveto', 0.5 - winWidth)
	self.Map.yview('moveto', 0.5 - winHeight)

    def setOrigin(self, loc):
	"""Change origin to LOC; the origin is the center of the window."""
	# Center window
	self.center()

	# Set origin for future redraws
	loc = (loc[0]-self.maxCoord[0]/2,
	       loc[1]-self.maxCoord[1]/2)
	if self.origin == (-loc[0], -loc[1]):
	    # Nothing has changed
	    return
	x, y = self.getCoord(loc)
	self.origin = (-loc[0], -loc[1])

	# Redisplay sectors without forcing a redraw.
	win = map(string.atof, string.split(self.Map['scrollregion']))
	scrWidth, scrHeight = win[2], win[3]
	self.Map.addtag_enclosed('move_a',
				 -99999, -99999,
				 x+1, 99999)
	self.Map.addtag_enclosed('move_b',
				 x, -99999,
				 99999, 99999)
	# It is not possible to capture all the x coordinates by drawing a
	# vertical line.  (The x coordinate of every other row is
	# staggered.)  This loop catches these odd starting coordinates.
	for i in (range(y, scrHeight+1, self.gridsize[1])+
		  range(y, -1, -self.gridsize[1])):
	    self.Map.addtag_enclosed('move_b',
				     x-self.gridsize[0],
				     i-self.gridsize[1]*2/3,
				     x+self.gridsize[0]+1,
				     i+self.gridsize[1]*2/3+1)
	self.Map.dtag('move_b', 'move_a')
	self.Map.move('move_a', scrWidth-x, 0)
	self.Map.move('move_b', -x, 0)
	self.Map.dtag('move_a')
	self.Map.dtag('move_b')
	self.Map.addtag_enclosed('move_a',
				 -99999, -99999,
				 99999, y-self.gridsize[1]/3+1)
	self.Map.addtag_enclosed('move_b',
				 -99999, y-self.gridsize[1]*2/3,
				 99999, 99999)
	self.Map.move('move_a', 0, scrHeight-y)
	self.Map.move('move_b', 0, -y)
	self.Map.dtag('move_a')
	self.Map.dtag('move_b')

    def redraw(self, total=0):
	"""DB update handler:  Redraw the window."""
	megaDB = empDb.megaDB
	updateDB = empDb.updateDB

	if total or updateDB['version'].has_key('worldsize'):
	    ws = self.maxCoord = megaDB['version']['worldsize']
	    self.Map['scrollregion'] = (-self.gridsize[0], -self.gridsize[1],
					ws[0]*self.gridsize[0],
					ws[1]*self.gridsize[1])
	    self.Map.delete('outline')
	    self.Map.create_rectangle(-self.gridsize[0], -self.gridsize[1],
				      ws[0]*self.gridsize[0]-1,
				      ws[1]*self.gridsize[1]-1,
				      tags='outline')
	    self.origin = (ws[0]/2, ws[1]/2)
	    self.center()
	    total = 1

	CN_OWNED = empDb.CN_OWNED
	CN_ENEMY = empDb.CN_ENEMY
	CN_UNOWNED = empDb.CN_UNOWNED

	if total:
	    db = megaDB['SECTOR']
	    self.Map.delete('SECTOR')
	else:
	    db = updateDB['SECTOR']
	for i, j in db.items():
	    des = j.get('des')
	    if not des:
		continue
	    own = j.get('owner')
	    oldown = j.get('oldown')
	    # color for oldownermarks if any shall be drawn
	    oldownName="";
	    x, y = self.getCoord(i)
	    if not total:
		# Delete old sector
		group = self.Map.find_enclosed(x-self.gridsize[0],
					       y-self.gridsize[1],
					       x+self.gridsize[0]+1,
					       y+self.gridsize[1]+1)
		for i in group:
		    if "SECTOR" in self.Map.gettags(i):
			self.Map.delete(i)
	    if own == CN_OWNED:
		mob = j.get('mob')
		if mob is None or mob == 0:
		    hexName = "nomobSector"
		else:
		    hexName = "ownedSector"
		if oldown is not None and oldown != own:
		    oldownName="oldownerEnemy"
	    elif own == CN_ENEMY or own > 0:
		hexName = "enemySector"
		if oldown is not None and oldown != own:
			if oldown == CN_OWNED:
				oldownName="oldownerMyself"
			else:
				oldownName="oldownerUnknown"
	    elif own == CN_UNOWNED:
		hexName = "unownedSector"
	    elif des in ".\\":
		hexName = "seaSector"
	    else:
		hexName = "unknownSector"

	    sdes = j.get('sdes', '_')
	    if sdes != '_':
		des = des + sdes

	    # draw hex around sector
	    self.drawItem(x, y, hexName, "Sector", tags='SECTOR')
	    # Draw text description
	    self.drawItem(x, y, hexName+"Text", "SectorText",
			  tags='SECTOR', text=des)

	    # Draw a small circle if oldowner!=owner
	    if oldownName:
		self.drawItem(x, y, oldownName, "Oldowner", tags='SECTOR')

	# 0,0 axis decoration
	if total:
	    x, y = self.getCoord((0,0))
	    self.Map.delete("origin")
	    self.drawItem(x, y, "origin", "Decoration", tags="origin")
	else:
	    self.Map.lift("origin")

	# Capital decoration
	if total or updateDB['nation'].has_key('capital'):
	    coord = megaDB['nation']['capital']
	    self.Map.delete("capital")
	    if coord:
		x, y = self.getCoord(coord)
		self.drawItem(x, y, "capital", "Decoration", tags="capital")
	else:
	    self.Map.lift("capital")

	# display infos about units, ships, planes and nukes
	for dbname, tagName, ownedInfo, enemyInfo in (
	    ('LAND UNITS', "LAND", "landUnits", "enemyLandUnits"),
	    ('SHIPS', "SHIP", "ships", "enemyShips"),
	    ('PLANES', "PLANE", "planes", "enemyPlanes"),
	    ('NUKES', "NUKE", "nukes", "enemyNukes")):
	    if not total and not updateDB[dbname]:
		# No objects in this database have been updated.
		self.Map.lift(ownedInfo)
		self.Map.lift(enemyInfo)
		continue
#	    print "Dealing with " + dbname +":",
	    db = megaDB.get(dbname, {})
	    self.Map.delete(tagName)
	    for i in db.getSec(('x', 'y')).values():
		nu={}
		allUnits=i.values()
		if allUnits:
		    x, y = self.getCoord((allUnits[0]['x'],
					  allUnits[0]['y']))
		for j in allUnits:
		    owner = j.get('owner')
		    id    = j.get('id')
		    type  = j.get('type')
#		    print "#" + str(id), type,
		    key=()
		    if owner == CN_OWNED:
			key=CN_OWNED
		    elif owner != CN_UNOWNED:
			key=CN_ENEMY

		    if key:
			if nu.has_key(key):
				nu[key]=nu[key]+1
			else: nu[key]=1
			if self.combatmode:
			    self.displayUnit(x,y,nu[key]-1,0.07,
					     key,id,type,tagName)
		else:
		    if not nu:
			# No units here.
			continue
		if nu.has_key(CN_OWNED):
		    self.drawItem(x, y, ownedInfo, "Unit",
				  tags=tagName)
		if nu.has_key(CN_ENEMY):
		    self.drawItem(x, y, enemyInfo, "EnemyUnit",
				  tags=tagName)

    def displayUnit(self, x,y, number, scale, owner, id, type, tagName):
	"""Display one (additional) Land Unit/Ship/Plane/Nuke for Combat Mode"""

	# Get the start position and color, depending on owner and tagName
	# XXX This is a hack until a configuration method can be added
	if owner==empDb.CN_OWNED:
		textcolor='Black'
	else:
		textcolor='SaddleBrown'

	offset={"LAND":(.433 ,-.483),"SHIP":(-.233 ,-.533),
		"PLANE":(-.233,.133),"NUKE":(.433,.133)}
	nx=offset[tagName][0] + 0
	ny=offset[tagName][1] + scale*number
	# find coords to start
	coords = (nx,ny)
	# Convert the internal coords to screen locations
	l = len(coords)/2
	coords = map(operator.add, (x, y)*l, map(
	    operator.mul, self.gridsize*l, coords))

#	print "*g*"
	self.Map.create_text(coords[0],coords[1], tags=tagName,
			     text="#" + str(id) + " " + type ,
			     anchor="nw",
			     font=self.combatModeFont,
			     fill=textcolor)

    def drawItem(self, x, y, name, group, **kw):
	# Get the item
	try:
	    item = self.optionsDict[name]
	except KeyError:
	    item = self.optionsDict[name] = Tk_VDB.getCanvasObject(
		self.Map, name, group)
##  	    print "Item", name, item
	if item is None:
	    # Item known to be invalid
	    return
	# Convert the internal coords to screen locations
	coords = item[1]
	l = len(coords)/2
	coords = map(operator.add, (x, y)*l, map(
	    operator.mul, (self.gridsize[0], self.gridsize[1]*2.0/3.0)*l,
	    coords))
	dict = {}
	dict.update(item[2])
	dict.update(kw)
	# Draw it
	return apply(item[0], tuple(coords), dict)

    def drawPath(self, *coords, **kw):
	"""Draw the bestpath between a set of sectors."""
	if coords:
	    opts = {'tags':'path', 'smooth':1, 'arrow':'last', 'width':3}
	    opts.update(kw)
	    coords = map(self.getCoord, coords)
	    apply(self.Map.create_line, tuple(coords), opts)
	else:
	    self.Map.delete('path')

    def markSectors(self, coords, name="mark"):
	"""Mark the specified COORDS with a small circle."""
	self.Map.delete(name)
	for coord in coords:
	    x, y = self.getCoord(tuple(coord))
	    self.drawItem(x, y, name, "Mark", tags=name)

    def DoCoord(self, event):
	"""Tk callback: Mouse has moved; update the current-sector box."""
	# convert screen coords to empire coordinates
	x, y = self.ploc = [
	    self.Map.canvasx(event.x)/self.gridsize[0]+0.5,
	    self.Map.canvasy(event.y)/self.gridsize[1]+0.5]

	if self.start:
	    # Set box to contain the coordinates in proper order
	    if x > self.start[0]:
		box = [self.start[0], x]
	    else:
		box = [x, self.start[0]]
	    if y > self.start[1]:
		box = box + [self.start[1], y]
	    else:
		box = box + [y, self.start[1]]
	else:
	    box = [x, x, y, y]

	odd_origin = self.origin[0] ^ self.origin[1]
	floor = math.floor

	# Fix bogus ranges
	if floor(box[2]) == floor(box[3]):
	    odd_row = (int(floor(box[2])) ^ odd_origin) & 1
	    if floor(box[0]) == floor(box[1]):
		box[0] = box[1] = floor((x-0.5+(odd_row^1))/2)*2+odd_row
	    else:
		box[0] = floor((box[0]+(odd_row^1))/2)*2+odd_row
		box[1] = floor((box[1]-1+(odd_row^1))/2)*2+odd_row
	if floor(box[0]) == floor(box[1]):
	    odd_col = (int(floor(box[0])) ^ odd_origin) & 1
	    box[2] = box[2]+((int(floor(box[2]))&1)^odd_col)
	    box[3] = box[3]-((int(floor(box[3]))&1)^odd_col)

	box = map(int, map(floor, box))

	# Compensate for the origin
	for box_pos, coord in [[0, 0], [1, 0], [2, 1], [3, 1]]:
	    box[box_pos] = ((box[box_pos]-self.origin[coord]
			     +self.maxCoord[coord]/2)
			    %self.maxCoord[coord]-self.maxCoord[coord]/2)

	# Set st to contain a string representation of box
	if box[2] == box[3]:
	    st = ",%d" % (box[2],)
	else:
	    st = ",%d:%d" % tuple(box[2:])
	if box[0] == box[1]:
	    st = "%d" % (box[0],) + st
	else:
	    st = "%d:%d" % tuple(box[:2]) + st

	if box == self.cursor:
	    # Nothing has changed
	    return
	self.cursor = box

	# Display new entry in coord box
	viewer.coord.set(st)

	# redraw box
	self.Map.delete('rubberbox')
	if self.start:
	    x1, y1 = self.getCoord((box[0], box[2]))
	    x2, y2 = self.getCoord((box[1], box[3]))
	    self.CoordBox = self.Map.create_rectangle(
		x1 - self.gridsize[0]/2,
		y1 - self.gridsize[1]/2,
		x2 + self.gridsize[0]/2,
		y2 + self.gridsize[1]/2,
		tags='rubberbox')

    def DoCoordClear(self, event):
	"""Tk callback: Clear a range selection."""
	if self.start:
	    # When a box is "stretched" beyond the window boundaries a
	    # dummy leave event is generated - just ignore it.
	    return
	self.cursor = self.start = ()
	viewer.coord.set("")
	self.Map.delete('rubberbox')

    def DoCoordBox(self, event):
	"""Tk callback: Start a box for range selection."""
	if self.start:
	    # If a button press occurs while "stretching" a box around
	    # sectors, cancel all buttons.  (This allows the user to
	    # cancel a bad range.)
	    self.start = self.cursor = ()
	else:
	    self.cursor = ()
	    self.start = self.ploc
	self.DoCoord(event)

    def DoCoordEndBox(self, event):
	"""Tk callback: End a range selection."""
	self.start = self.cursor = ()
	self.DoCoord(event)

    def DoCensor(self, event):
	"""Tk callback: Set the censor window's current sector."""
	if self.start:
	    # If the client is selecting a range, just interrupt it and quit.
	    self.start = self.cursor = ()
	    self.DoCoord(event)
	    return
	viewer.cen.SetSect(self.cursor)
	self.DoCoordEndBox(event)

    def DoOrigin(self, event):
	"""Tk callback: Center the map window around the current sector."""
	if self.start:
	    # If the client is selecting a range, just interrupt it and quit.
	    self.start = self.cursor = ()
	    self.DoCoord(event)
	    return
	self.setOrigin((self.cursor[0], self.cursor[2]))

    def DoSelect(self, event):
	"""Tk callback: Insert a sector/range into the command-line."""
	if not self.start:
	    return
	rng = viewer.coord.get()
	viewer.insertText(rng)
	self.DoCoordEndBox(event)

##      def DoPopup(self, event):
##          if self.start:
##              # If the client is selecting a range, just interrupt it and quit.
##              self.start = self.cursor = ()
##              self.DoCoord(event)
##              return
##  	menu = Tkinter.Menu(self.Map, name="OptionsMenu")
##  	for i in (
##  	    ("Center", (lambda e, s=self.center: s())),
##  	    ("Move", (lambda e, )))
##  	menu.add_command()


class CmdMap(empCmd.baseCommand):
    description = "Open additional map window."

    defaultBinding = (('Map', 3),)

    def invoke(self):
	self.Root = root = Tkinter.Toplevel(class_="Map")
	root.title("Empire map")
	root.iconname("Empire map")

	# Forward key events to main window.
	viewer.transferKeys(root)

	self.Map = mapSubWin(root)
	viewer.mapList.append(self.Map)

	root.protocol('WM_DELETE_WINDOW', self.handleDelete)

    def handleDelete(self):
	"""Tk callback: Remove the window from the display."""
	viewer.updateList.remove(self.Map)
	viewer.mapList.remove(self.Map)
	self.Root.destroy()

class CmdBestpath(empCmd.baseCommand):
    description = "Display a graphical best path."

    defaultBinding = (('Bestpath', 4),)

    def invoke(self):
	args = self.commandMatch.group('args')
	if not args:
	    coords = ()
	else:
	    try:
		coords = map(empParse.str2Coords, string.split(args))
	    except ValueError:
		viewer.Error("Bad coords.")
	    pos = []
	    start = coords[0]
	    pos.append(coords[0])
	    for i in range(1, len(coords)):
		path = empPath.best_path(coords[i-1], coords[i])
		if path is None:
		    viewer.Error("Path could not be completed.")
		    return
		for i in path.directions:
		    start = empDb.directionToSector(start, i)
		    pos.append(start)
	    coords = pos

	apply(viewer.map.drawPath, tuple(coords))

###########################################################################
############################# Map major modes #############################

class MoveMode:
    def __init__(self, mapClass, commodity, source, quantity=None, dest=None):
	self.map = mapClass
	self.Map = mapClass.Map

	# HACK! Test if already in a major mode.
	if self.Map.master.grid_size()[1] > 2:
	    viewer.Root.bell()
	    return

	# Set up the display area.
	self.Area = Tkinter.Frame(mapClass.Map.master, name="modeInfo")
	self.Area.grid(row=2, sticky="swe")
	self.lblVar = Tkinter.StringVar()
	label = Tkinter.Label(self.Area, name="label", anchor='w',
			      justify='left', textvariable=self.lblVar)
	label.pack(anchor='w')
	self.Quantity = Tkinter.StringVar()
	self.Quantity.trace_variable("w",
				     (lambda var, o, mode, self=self:
				      self.redraw()))
	entry = Tkinter.Entry(self.Area, name="quantity",
			      textvariable=self.Quantity)
	entry.pack(anchor='w')
	entry.bind('', self.DoOk)
	entry.bind('', self.finish)
	entry.focus()
	self.okB = Tkinter.Button(self.Area, name="ok", text="Ok",
				  command=self.DoOk)
	self.okB.pack(side='left', expand=1, fill='x')
	self.cancelB = Tkinter.Button(self.Area, name="cancel", text="Cancel",
				      command=self.finish)
	self.cancelB.pack(side='right', expand=1, fill='x')

	# Set new bindings for the map window.
	self.oldBindings = []
	for action, command in (
	    ('', self.CreateSpot),
	    ('', self.MoveSpot),
	    ('', self.DelSpot),
	    ('', self.SetSpot)):
	    self.oldBindings.append((action, self.Map.bind(action)))
	    self.Map.bind(action, command)

	# Initialize variables
	self.commodity = commodity
	self.source = source
	self.sectors = []
	self.pathList = []
	self.flags = 0

	if quantity is not None:
	    self.Quantity.set(quantity)

	self.lblVar.set("")
	self.AddSpot(source)
	if dest is not None:
	    self.AddSpot(dest)

	# Register automatic updating
	viewer.updateList.append(self)

    def finish(self, event=None):
	"""Unmap the window, and reset the mouse bindings."""
	self.Area.destroy()
	self.map.drawPath()
	self.Map.delete("MoveSector")
	for action, command in self.oldBindings:
	    self.Map.tk.call("bind", self.Map, action, command)
	viewer.Prompt.focus()
	viewer.updateList.remove(self)

    def DoOk(self, event=None):
	scts = ""
	for i in self.sectors:
	    scts = scts + (" %d,%d" % i)
	viewer.ioq.Send("rdbPe;Mover %s %s%s;rdbe" % (
	    self.commodity, self.Quantity.get(), scts))
	self.finish()

    def getSpot(self, coord):
	x, y = self.map.getCoord(coord)
	group = self.Map.find_enclosed(x-self.map.gridsize[0],
				       y-self.map.gridsize[1],
				       x+self.map.gridsize[0]+1,
				       y+self.map.gridsize[1]+1)
	for i in group:
	    if "MoveSector" in self.Map.gettags(i):
		return i

    def AddSpot(self, coord, pos=None):
	if pos is None:
	    pos = len(self.sectors)
	self.sectors[pos:pos] = [coord]
	x, y = self.map.getCoord(coord)
	self.map.drawItem(x, y, "destSector", "MoveSector",
			    tag="MoveSector")
	self.redraw()

    def CreateSpot(self, event):
	loc = (self.map.cursor[0], self.map.cursor[2])
	if loc in self.sectors:
	    # Moving a known spot
	    self.pos = self.sectors.index(loc)
	else:
	    # See if location is in the current path
	    for i in range(len(self.pathList)):
		if loc in self.pathList[i]:
		    self.pos = i+1
		    break
	    else:
		# Add spot to end of path
		self.pos = len(self.sectors)
	    self.AddSpot(loc, self.pos)
##  	self.start = (event.x, event.y)
	self.start = self.map.getCoord(loc)
	self.spot = self.getSpot(loc)

    def MoveSpot(self, event):
	self.map.DoCoord(event)
	loc = (self.Map.canvasx(event.x), self.Map.canvasy(event.y))
	self.Map.move(self.spot, loc[0]-self.start[0], loc[1]-self.start[1])
	self.start = loc

    def DelSpot(self, event):
	if self.pos is None:
	    return
	del self.sectors[self.pos]
	self.Map.delete(self.spot)
	self.redraw()
	self.pos = None

    def SetSpot(self, event):
	if self.pos is None:
	    return
##  	del self.sectors[self.pos]
##  	self.Map.delete(self.spot)
	coord = (self.map.cursor[0], self.map.cursor[2])
	newlist = list(self.sectors)
	del newlist[self.pos]
	if coord in newlist:
	    self.DelSpot(event)
	else:
	    self.sectors[self.pos] = coord
	    loc = self.map.getCoord(coord)
	    self.Map.move(self.spot, loc[0]-self.start[0],
			  loc[1]-self.start[1])
	    self.redraw()

    def redraw(self, total=1):
	if not total and not empDb.updateDB.has_key('SECTOR'):
	    # Nothing changed.
	    return

	# Remove any existing path.
	self.map.drawPath()

	sectors = self.sectors
	if len(sectors) < 2:
	    self.lblVar.set("Select sectors with the right mouse button.\n")
	    return
	sDB = empDb.megaDB['SECTOR']
	try:
	    quantity = empCmd.getMoveQuantity(self.Quantity.get(),
					      self.commodity, sectors)
	except ValueError:
	    msg = "Enter a valid quantity.\n"
	    self.pathList = []
	    quantity = 0
	else:
	    first = sectors[0]
	    last = sectors[-1]
	    msg = "Move %d %s: (%d,%d has %s)  (%d,%d has %s)\n" % (
		quantity, self.commodity,
		first[0], first[1], sDB[first].get(self.commodity, "??"),
		last[0], last[1], sDB[last].get(self.commodity, "??"))

	reverse = quantity < 0
	if reverse:
	    sectors = list(sectors)
	    sectors.reverse()
	    quantity = -quantity

	start = sectors[0]
	sectorList = [start]
	newPathList = []
	for i in range(1, len(sectors)):
	    last = sectors[i-1]
	    path = empPath.best_path(last, sectors[i])
	    color = "black"

	    newPathList.append([last])
	    if path is None:
		# No path between the two sectors.
		color = "red"
		start = sectors[i]
		newPathList[-1].append(start)
		newmob = "??"
##  		return
	    else:
		# Calculate new mobility.
		db = sDB[last]
		newmob = int(math.floor(
		    (db.get('mob', 0)
		     - empSector.move_weight(db, self.commodity)
		     * path.cost*quantity)))
		if newmob < 0:
		    color = "yellow"

		# Turn path into list of sector coordinates.
		for i in path.directions:
		    start = empDb.directionToSector(start, i)
		    sectorList.append(start)
		    newPathList[-1].append(start)

	    # Update text description.
	    msg = msg + "%d,%d=>%s    " % (last[0], last[1], newmob)

	    # Draw path
	    apply(self.map.drawPath, tuple(newPathList[-1]), {"fill":color})

	if reverse:
	    newPathList.reverse()

	self.pathList = newPathList
##  	apply(self.map.drawPath, tuple(sectorList), {"color":color})
	msg = msg + "%d,%d " % sectors[-1]
	self.lblVar.set(msg)
ptkei-1.12/src/OutWin.py0100600000076500007650000000623006775745014014174 0ustar  kevinkevin"""Maintains arbitrary output windows."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import Tkinter
import string
import re

import empQueue
import empCmd

###########################################################################
#############################  Simple window  #############################
class SimpDisp(empQueue.baseDisp):
    """Display command output in its own window."""
    def __init__(self, disp, title = "Empire output", width=None):
	empQueue.baseDisp.__init__(self, disp)

	# Create root window
	self.Root = Tkinter.Toplevel(class_="Output")
	self.Root.title(title)
	self.Root.iconname(title)

	title = string.lower(string.split(title, None, 1)[0])

	# Create text box and scrollbar
	scrollY = Tkinter.Scrollbar(self.Root, name="scrollY")
	scrollY.pack(side='right', fill='y')
	self.Text = Tkinter.Text(self.Root, name=title, setgrid=1, state='disabled',
			 yscrollcommand=scrollY.set)
	self.Text.pack(side='left', expand=1, fill='both')
	scrollY['command'] = self.Text.yview

	# Forward key events to main window.
	viewer.transferKeys(self.Root)

	# Allow configurable width
	if width is not None:
	    self.Text['width']=width

	self.Text.bind('', viewer.DoLocateSector)
	self.Root.protocol('WM_DELETE_WINDOW', self.goAway)

    def goAway(self):
	"""Tk callback: Remove the window from the display."""
	self.data = empQueue.doNothing
	self.Root.destroy()

    def data(self, line):
	if self.data is empQueue.doNothing:
	    # Window was closed
	    return
	self.Text['state'] = 'normal'
	self.Text.insert('end', line+"\n")
	self.Text['state'] = 'disabled'

class CmdWind(empCmd.baseCommand):
    description = "Output arbitrary command to its own Tk Window."

    defaultPreList = 1
    defaultBinding = (('wind', 4),)

    def invoke(self):
	args = self.commandMatch.group('args')
	self.Send(args, SimpDisp(self.out, args))

class CmdCShow(empCmd.baseCommand):
    description = "Display 'show X bui;show X sta;show X cap' in its own window."

    defaultBinding = (('cshow', 5),)

    commandFormat = re.compile(r"^(?P\S+)(?P.*)$")
    def invoke(self):
	mm = self.parameterMatch
	new = empCmd.ParseShow(SimpDisp(
	    self.out, self.commandMatch.string, 140))
	if mm.group('techLevel') is None:
	    tl = ""
	else:
	    tl = mm.group('techLevel')
	self.Send("show "+mm.group('unitType')+" build"+tl, new)
	self.Send("show "+mm.group('unitType')+" stat"+tl, new)
	self.Send("show "+mm.group('unitType')+" cap"+tl, new)
ptkei-1.12/src/TeleWin.py0100600000076500007650000002502706770233630014312 0ustar  kevinkevin"""Graphical telegram/announcment tool."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import re
import string
import types

import Tkinter
import Pmw

import Tk_List

import empQueue
import empDb
import empParse
import empCmd

###########################################################################
#############################  Telegrams      #############################
class teleWin:
    """Handle communications in a graphical manner."""
    def __init__(self):
	title = "Empire Correspondence"
	# Create root window
	self.Root = Tkinter.Toplevel(name="telegram")
	self.Root.withdraw()
	self.Root.title(title)
	self.Root.iconname(title)

	# Forward key events to main window.
	viewer.transferKeys(self.Root)

	# TCL variables
	self.type = Tkinter.StringVar()
	self.type.set('telegrams')

	# Create options bar
	oframe = Tkinter.Frame(self.Root, name="oframe")
	oframe.pack(side='bottom', fill='x', expand=1)
	orframe = Tkinter.Frame(oframe, name="orframe")
	orframe.pack(side='left', fill='y', expand=1)
	self.AnnoB = Tkinter.Radiobutton(
	    orframe, name="anno", text="Announcements",
	    anchor='w', variable=self.type,
	    value='announcements',
	    command=self.redraw)
	self.AnnoB.pack(fill='both', expand=1)
	self.TeleB = Tkinter.Radiobutton(
	    orframe, name="tele", text="Telegrams",
	    anchor='w',
	    variable=self.type, value='telegrams',
	    command=self.redraw)
	self.TeleB.pack(fill='both', expand=1)
	self.SendB = Tkinter.Button(
	    oframe, name="send",
	    text="Send", command=self.DoSend)
	self.SendB.pack(side='left', fill='y', expand=1)
	self.AbortB = Tkinter.Button(
	    oframe, name="abort",
	    text="Abort", command=self.DoAbort,
	    state='disabled')
	self.AbortB.pack(side='left', fill='y', expand=1)
	self.ReplyB = Tkinter.Button(
	    oframe, name="reply",
	    text="Reply", command=self.DoReply)
	self.ReplyB.pack(side='left', fill='y', expand=1)
	self.RemoveB = Tkinter.Button(
	    oframe, name="delete",
	    text="Delete", command=self.DoRemove)
	self.RemoveB.pack(side='left', fill='y', expand=1)

	# Create search box
	self.SearchMsg = Tkinter.StringVar()
	self.StringRE = Tkinter.StringVar()
	self.TypeRE = Tkinter.IntVar()
	self.TypeRE.set(0)
	sframe = Tkinter.Frame(self.Root, name="sframe")
	sframe.pack(side='top', fill='both', expand=1)
	srframe = Tkinter.Frame(sframe, name="srframe")
	srframe.pack(side='right')
	hsearch = Tkinter.Radiobutton(srframe, name="headerSearch",
				      text="Header Search", anchor='w',
				      variable=self.TypeRE, value=0)
	hsearch.pack(fill='both', expand=1)
	viewer.Balloon.bind(hsearch, "Search only the first\n"
			    +"line of text")
	fsearch = Tkinter.Radiobutton(srframe, name="fullSearch",
				      text="Full Search", anchor='w',
				      variable=self.TypeRE, value=1)
	fsearch.pack(fill='both', expand=1)
	viewer.Balloon.bind(fsearch, "Search the entire message")
	listall = Tkinter.Button(sframe, name="listAll",
				 command=self.DoListAll, text="List All")
	listall.pack(side='right')
	viewer.Balloon.bind(listall, "Undo a previous search")
	search = Tkinter.Button(sframe, name="search",
				command=self.DoSearch, text="Search")
	search.pack(side='right')
	viewer.Balloon.bind(search, "Search for string")
	Tkinter.Label(sframe, name="slabel",
		      textvariable=self.SearchMsg,
		      anchor='sw'
		      ).pack(side='top', fill='x', expand=1)
	searchRE = Tkinter.Entry(sframe, name="regexp",
				 textvariable=self.StringRE)
	searchRE.pack(side='top', fill='x', expand=1)
	viewer.Balloon.bind(searchRE, "Click to enter a search string")

	# Create list box
	lframe = Tkinter.Frame(self.Root, name="lframe")
	lframe.pack(side='top', fill='both', expand=1)
	scrollY = Tkinter.Scrollbar(lframe, name="scrollY")
	scrollY.pack(side='right', fill='y')
	self.List = Tk_List.MyListbox(lframe, name="list",
				      height=8, selectmode='extended',
				      command=self.SetMsg,
				      yscrollcommand=scrollY.set)
	self.List.pack(side='left', fill='both', expand=1)
	scrollY['command'] = self.List.yview

	# Create text box and scrollbar
	scrollY = Tkinter.Scrollbar(self.Root, name="scrollY")
	scrollY.pack(side='right', anchor='e', fill='y')
	self.Text = Tkinter.Text(self.Root, name="text", state='disabled',
			 yscrollcommand=scrollY.set)
	self.Text.pack(side='left', anchor='w', expand=1, fill='both')
	scrollY['command'] = self.Text.yview
	self.Text.bind('', viewer.DoLocateSector)

	# Draw
	self.DoListAll()

	# Create a special country input box
	self.CInput = Pmw.ComboBoxDialog(viewer.Root,
					 title = "Country Selection",
					 buttons = ("OK", "Cancel"),
					 defaultbutton = "OK",
					 combobox_labelpos = 'n',
					 label_text= "Select Country:")
	self.CInput.withdraw()

	# Register automatic updating
	viewer.updateList.append(self)
	self.Root.protocol('WM_DELETE_WINDOW', self.handleDelete)

    def handleDelete(self):
	"""Tk callback: Remove the window from the display."""
	self.Root.withdraw()

    def mapWindow(self):
	"""Force window to display."""
	self.Root.deiconify()
	self.Root.lift()

    def SetMsg(self, msg):
	"""Tk/Listbox callback: Note a change in current message."""
	if self.Text['state'] == 'normal':
	    return
	self.Text['state'] = 'normal'
	self.Text.delete('1.0', 'end')
	printTime = empDb.megaDB['time'].printTime
	getName = empDb.megaDB['countries'].getName
	for i in msg:
	    if type(i[0]) == types.TupleType:
		hdr = "> %s%s  dated %s\n" % (
		    i[0][0],
		    (i[0][1] is not None
		     and " from %s"%getName(i[0][1]) or ""),
		    printTime(i[0][2]))
	    else:
		hdr = i[0]+"\n"
	    self.Text.insert('end', hdr)
	    for j in i[1:]:
		self.Text.insert('end', str(j)+"\n")
	self.Text['state'] = 'disabled'

    def redraw(self, total=1):
	"""DB update handler:  Redraw the window."""
	if total or empDb.updateDB['time']:
	    sts = self.List.getStatus()
	    self.List.delete()
	    db = empDb.megaDB[self.type.get()]['list']
	else:
	    db = empDb.updateDB[self.type.get()].get('list', [])
	printTime = empDb.megaDB['time'].printTime
	getName = empDb.megaDB['countries'].getName
	compRE = self.compRE
	fullSearch = self.TypeRE.get()
	for i in db:
	    hdr = i[0]
	    if type(hdr) == types.TupleType:
		hdr = "> %-40s %s" % (
		    (hdr[1] is not None
		     and "%s from %s"%(hdr[0], getName(hdr[1]))
		     or hdr[0]),
		    printTime(hdr[2]))
	    # Check if it matches the regular expression
	    if compRE is not None and not compRE.search(hdr):
		if not fullSearch:
		    continue
		for j in i[1:]:
		    if compRE.search(j):
			break
		else:
		    # Match not found
		    continue
	    self.List.insert(0, (hdr, i))
	if total:
	    apply(self.List.setStatus, sts)
## 	else:
## 	    self.List.see('end')

    def DoSearch(self):
	"""Tk callback: Process Search button request."""
	try:
	    self.compRE = re.compile(self.StringRE.get())
	except re.error, e:
	    self.SearchMsg.set("Regular Expression Error: %s" % e[0])
	    self.Root.bell()
	else:
	    self.redraw(1)
##  	    viewer.grabFocus()
	    self.Root.focus()

    def DoListAll(self):
	"""Tk callback: Process ListAll button request."""
	self.compRE = None
	self.SearchMsg.set("Regular Expression Search:")
	self.redraw(1)
##  	viewer.grabFocus()
	self.Root.focus()

    teleMatch = re.compile("(?P\d+)")
    def DoSend(self):
	"""Tk callback: Process Send button request."""
	if self.Text['state'] == 'normal':
	    # Sending after a reply button.
	    self.Text['state'] = self.AbortB['state'] = 'disabled'
	    self.ReplyB['state'] = self.RemoveB['state'] = \
				   self.AnnoB['state'] = \
				   self.TeleB['state'] = 'normal'
	    empCmd.sendTelegram(self.sendCmd, self.Text.get('1.0', 'end'))
##  	    viewer.ioq.Send(self.sendCmd, telegramParser(
##  		self.sendCmd, self.Text.get('1.0', 'end')))
	    del self.sendCmd
##  	    viewer.grabFocus()
	    self.Root.focus()
	    self.SetMsg(self.List.curselection())
	    return
	# Sending a new message
	if self.type.get() == 'announcements':
	    self.sendCmd = "anno"
	else:
	    self.CInput.component('scrolledlist').setlist(
		empDb.megaDB['countries'].getList())
	    result = self.CInput.activate()
	    if result != "OK":
		return
	    who = self.CInput.get()
	    mm = self.teleMatch.match(who)
	    if mm is not None:
		who = mm.group('num')
	    self.sendCmd = "tele " + who
	self.ReplyB['state'] = self.RemoveB['state'] = \
			       self.AnnoB['state'] = \
			       self.TeleB['state'] = 'disabled'
	self.Text['state'] = self.AbortB['state'] = 'normal'
	self.Text.delete('0.0', 'end')
	self.Text.focus()

    def DoAbort(self):
	"""Tk callback: Process Abort button request."""
	self.Text['state'] = self.AbortB['state'] = 'disabled'
	self.ReplyB['state'] = self.RemoveB['state'] = \
			       self.AnnoB['state'] = \
			       self.TeleB['state'] = 'normal'
	del self.sendCmd
##  	viewer.grabFocus()
	self.Root.focus()
	self.SetMsg(self.List.curselection())

    def DoReply(self):
	"""Tk callback: Process Reply button request."""
	which = self.List.curselection()
	if not which or len(which) > 1:
	    self.Root.bell()
	    return
	if self.type.get() == 'announcements':
	    self.sendCmd = "anno"
	else:
	    if (not type(which[0][0]) == types.TupleType
		or which[0][0][1] is None):
		self.Root.bell()
		return
	    self.sendCmd = "tele " + str(
		empDb.megaDB['countries'].getId(which[0][0][1]))
	self.ReplyB['state'] = self.RemoveB['state'] = \
			       self.AnnoB['state'] = \
			       self.TeleB['state'] = 'disabled'
	self.Text['state'] = self.AbortB['state'] = 'normal'
	for i in range(len(which[0])):
	    self.Text.insert("%s.0"%(i+1), " >")
	self.Text.focus()
##	self.List['state'] = 'disabled'

    def DoRemove(self):
	"""Tk callback: Process Delete button request."""
	which = self.List.curselection()
	self.List.delete(which)
	for i in which:
	    empDb.megaDB[self.type.get()]['list'].remove(i)

class CmdWRead(empCmd.baseCommand):

    description = "Open the telegram window."

    defaultBinding = (('wread', 5),)

    def invoke(self):
	viewer.telegramWindow.mapWindow()
ptkei-1.12/src/Tk_List.py0100600000076500007650000000655706655766126014340 0ustar  kevinkevin"""Enhancement to built-in Tk Listbox."""

#    Copyright (C) 1998-1999 Kevin O'Connor
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import Tkinter
import string
import operator

###########################################################################
#############################  My Listbox     #############################
class MyListbox(Tkinter.Listbox):
    """Ughh..  The standard Tk Listbox is essentially useless in its
    current form.  This is an attempt to add at least some functionality."""
    def __init__(self, master=None, cnf={}, **kw):
	defset = {'exportselection':0} #, 'takefocus':0}
	cnf.update(kw)
	self.cmd1 = cnf.get('command')
	if self.cmd1 is not None:
	    del cnf['command']
	defset.update(cnf)
	Tkinter.Listbox.__init__(self, master, defset)
	if self.cmd1 is not None:
	    btags = self.bindtags()
	    self.bindtags((btags[1], btags[0]) + btags[2:])
	    self.bind('