- Codechange: make openttdlib a module

Author: yorickvanpelt

newgrfs.grflist

@@ -0,0 +1,14 @@
+# OpenTTD python module
+# http://openttd-python.googlecode.com/
+
+# Ensure the user is running the version of python we require.
+import sys
+if not hasattr(sys, "version_info") or sys.version_info < (2,4):
+    raise RuntimeError("OpenTTD-Python requires Python 2.4 or later.")
+del sys
+
+import client
+import savegame
+from datastorageclass import DataStorageClass
+import date
+import grfdb

openttd/__init__.py

@@ -1,7 +1,6 @@
 #!/bin/env python
 # made by thomas in 5 hours - no guarantees ;)
 import sys, struct
-import logging, logging.config
 import threading
 import socket
 import random
@@ -12,39 +11,19 @@
 import copy
 import traceback
 import StringIO
-import datetime
 from operator import itemgetter
 from struct_zerostrings import *
-from ottd_constants import *
 import signal
 from log import LOG
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib"))
+import constants as const
+from datastorageclass import DataStorageClass
 
 #connection modes
 M_NONE = 0
-M_TCP  = 1 
-M_UDP  = 2
+M_TCP  = 1 << 0
+M_UDP  = 1 << 1
 M_BOTH = M_TCP | M_UDP
 
-class DataStorageClass(object):
-    def __init__(self, dict={}):
-        self.__dict__ = dict
-    def __getitem__(self, key):
-        return self.__dict__[key]
-    def __getattr__(self, key):
-        if key in self.__dict__:
-            return self.__dict__[key]
-        else:
-            raise AttributeError
-    def __setattr__(self, key, value):
-        if not key == "__dict__":
-            self.__dict__[key] = value
-    def __delattr__(self, key):
-        del self.__dict__[key]
-    def getDict(self):
-        return self.__dict__
-
 class DataPacket:
     size=0
     command=0
@@ -112,7 +91,6 @@ def __init__(self, ip, port, debugLevel=0, uid=None):
         self.debuglevel = debugLevel
         self.uid        = uid
 
-        LOG.debug('__init__')
         self.running    = True # sighandler will change this value
         self.lock       = threading.Lock()
         threading.Thread.__init__(self)
@@ -149,7 +127,7 @@ def connect(self, mode=M_BOTH):
 
             #self.throwRandomData()
             #self.packetTest()
-            #self.sendMsg_UDP(PACKET_UDP_CLIENT_FIND_SERVER)
+            #self.sendMsg_UDP(const.PACKET_UDP_CLIENT_FIND_SERVER)
             #self.sendRaw(self.packetTest())
             #data=self.receiveMsg_UDP()
 
@@ -180,10 +158,10 @@ def run(self):
         pass
 
     def getServerList(self):
-        payload = struct.pack("B", NETWORK_MASTER_SERVER_VERSION)
-        self.sendMsg_UDP(PACKET_UDP_CLIENT_GET_LIST, payload)
+        payload = struct.pack("B", const.NETWORK_MASTER_SERVER_VERSION)
+        self.sendMsg_UDP(const.PACKET_UDP_CLIENT_GET_LIST, payload)
         p = self.receiveMsg_UDP(datapacket=True)
-        if p.command == PACKET_UDP_MASTER_RESPONSE_LIST:
+        if p.command == const.PACKET_UDP_MASTER_RESPONSE_LIST:
             protocol_version = p.recv_uint8()
 
             if protocol_version == 1:
@@ -202,7 +180,7 @@ def getServerList(self):
 
 
     def getGRFInfo(self, grfs):
-        p = DataPacket(0, PACKET_UDP_CLIENT_GET_NEWGRFS)
+        p = DataPacket(0, const.PACKET_UDP_CLIENT_GET_NEWGRFS)
         p.send_uint8(len(grfs))
         for grf in grfs:
             p.send_something('4s16s', grf)
@@ -212,7 +190,7 @@ def getGRFInfo(self, grfs):
             LOG.debug("unable to receive UDP packet")
             return None
         newgrfs = []
-        if p.command == PACKET_UDP_SERVER_NEWGRFS:
+        if p.command == const.PACKET_UDP_SERVER_NEWGRFS:
             reply_count = p.recv_uint8()
             for i in range(0, reply_count):
                 [grfid, md5sum] = p.recv_something('4s16s')
@@ -225,18 +203,18 @@ def getGRFInfo(self, grfs):
 
             return newgrfs
         else:
-            LOG.error("unexpected reply on PACKET_UDP_CLIENT_GET_NEWGRFS: %d" % (p.command))
+            LOG.error("unexpected reply on const.PACKET_UDP_CLIENT_GET_NEWGRFS: %d" % (p.command))
 
     def getCompanyInfo(self):
-        self.sendMsg_UDP(PACKET_UDP_CLIENT_DETAIL_INFO)
+        self.sendMsg_UDP(const.PACKET_UDP_CLIENT_DETAIL_INFO)
         p = self.receiveMsg_UDP(True)
         if p is None:
             return None
-        if p.command == PACKET_UDP_SERVER_DETAIL_INFO:
+        if p.command == const.PACKET_UDP_SERVER_DETAIL_INFO:
             info_version = p.recv_uint8()
             player_count = p.recv_uint8()
 
-            if info_version == NETWORK_COMPANY_INFO_VERSION or info_version == 4:
+            if info_version == const.NETWORK_COMPANY_INFO_VERSION or info_version == 4:
                 companies = []
 
                 for i in range(0, player_count):
@@ -284,26 +262,26 @@ def getCompanyInfo(self):
                     ret.spectators = players
                 return ret
             else:
-                LOG.error("unsupported NETWORK_COMPANY_INFO_VERSION: %d. supported version: %d" % (info_version, NETWORK_COMPANY_INFO_VERSION))
+                LOG.error("unsupported NETWORK_COMPANY_INFO_VERSION: %d. supported version: %d" % (info_version, const.NETWORK_COMPANY_INFO_VERSION))
         else:
-            LOG.error("unexpected reply on PACKET_UDP_CLIENT_DETAIL_INFO: %d" % (command))
+            LOG.error("unexpected reply on const.PACKET_UDP_CLIENT_DETAIL_INFO: %d" % (command))
     def getTCPCompanyInfo(self):
-        self.sendMsg_TCP(PACKET_CLIENT_COMPANY_INFO)
+        self.sendMsg_TCP(const.PACKET_CLIENT_COMPANY_INFO)
         p = self.receiveMsg_TCP(True)
         if res is None:
             return None
-        if p.command == PACKET_SERVER_COMPANY_INFO:
+        if p.command == const.PACKET_SERVER_COMPANY_INFO:
             [info_version, player_count] = p.recv_something('BB')
-            if info_version == NETWORK_COMPANY_INFO_VERSION or info_version == 4: #4 and 5 are the same:
+            if info_version == const.NETWORK_COMPANY_INFO_VERSION or info_version == 4: #4 and 5 are the same:
                 companies = []
                 firsttime = True
                 for i in range(0, player_count):
                     if not firsttime:
                         p = self.receiveMsg_TCP(True)
                         if p is None:
                             return None
-                        if p.command != PACKET_SERVER_COMPANY_INFO:
-                            LOG.error("unexpectged reply on PACKET_CLIENT_COMPANY_INFO: %d" % p.command)
+                        if p.command != const.PACKET_SERVER_COMPANY_INFO:
+                            LOG.error("unexpectged reply on const.PACKET_CLIENT_COMPANY_INFO: %d" % p.command)
                             return None
                         [info_version, player_count] = p.recv_something('BB')
                     firsttime = False
@@ -323,12 +301,12 @@ def getTCPCompanyInfo(self):
                     companies.append(company)
                 return companies
             else:
-                LOG.error("unknown company info version %d, supported: %d" % (info_version, NETWORK_COMPANY_INFO_VERSION))
+                LOG.error("unknown company info version %d, supported: %d" % (info_version, const.NETWORK_COMPANY_INFO_VERSION))
         else:
-            LOG.error("unexpected reply on PACKET_CLIENT_COMPANY_INFO: %d" % (command))
+            LOG.error("unexpected reply on const.PACKET_CLIENT_COMPANY_INFO: %d" % (command))
 
     def getGameInfo(self, encode_grfs=False, short=False):
-        self.sendMsg_UDP(PACKET_UDP_CLIENT_FIND_SERVER)
+        self.sendMsg_UDP(const.PACKET_UDP_CLIENT_FIND_SERVER)
         result = self.receiveMsg_UDP()
         if result is None:
             LOG.debug("unable to receive UDP packet")
@@ -441,7 +419,7 @@ def packetTest(self):
         format_payload = '15s80sbb33s'
         payload = struct.pack(format_payload, serverversion, playername, playas, netlang, uniqueid)
 
-        self.sendMsg_TCP(PACKET_CLIENT_JOIN, payload)
+        self.sendMsg_TCP(const.PACKET_CLIENT_JOIN, payload)
 
     def createPacketHeader(self, command, payload):
         return struct.pack(self.header_format, self.header_size + len(payload), command)
@@ -478,7 +456,7 @@ def receiveMsg_UDP(self, datapacket = False):
             LOG.error('receiveMsg_UDP error: '+str(e))
             errorMsg = StringIO.StringIO()
             traceback.print_exc(file=errorMsg)
-            logging.error(errorMsg.getvalue())
+            LOG.error(errorMsg.getvalue())
             if not str(e) in self.errors:
                 self.errors.append(str(e))
 
@@ -492,9 +470,9 @@ def receiveMsg_TCP(self, datapacket = False):
             note += "HEADER SEGMENTED INTO %s SEGMENTS!" % readcounter
 
         size, command = self.parsePacketHeader(data)
-        if not command in (PACKET_SERVER_FRAME, PACKET_SERVER_SYNC):
-            if command in packet_names:
-                LOG.debug("received size: %d, command: %s (%d)"% (size, packet_names[command], command))
+        if not command in (const.PACKET_SERVER_FRAME, const.PACKET_SERVER_SYNC):
+            if command in const.packet_names:
+                LOG.debug("received size: %d, command: %s (%d)"% (size, const.packet_names[command], command))
             else:
                 LOG.debug("received size: %d, command: %d"% (size, command))
         size -= self.header_size # remove size of the header ...
@@ -516,10 +494,5 @@ def receiveMsg_TCP(self, datapacket = False):
         #content = content[0]
 
         #LOG.debug(size, command, content)
-    def dateToYMD(self, date):
-        if date == 0:
-            return (0, 0, 0)
-        ymddate = datetime.date.fromordinal(date - 365)
-        return (ymddate.year, ymddate.month, ymddate.day)
 
 

ottd_lib.py renamed to openttd/client.py

@@ -1,8 +1,8 @@
 #!/bin/env python
 # reading openttd .sav files with python
 # made by yorickvanpelt {AT} gmail {DOT} com
-from struct_zerostrings import unpackFromExt, packExt
-from ottd_constants import saveload_chunk_types
+import struct
+from constants import saveload_chunk_types
 import array
 
 class LoadException(Exception):
@@ -27,7 +27,13 @@ def read_something(self, type):
         @rtype:      list
         @returns:    list with unpacked stuff
         """
-        ret, size = unpackFromExt(type, self.data[self.offset:])
+        try:
+            s = struct.Struct(type)
+            size = s.size
+            ret = s.unpack(self.data[self.offset:self.offset+size])
+        except AttributeError:
+            size = struct.calcsize(type)
+            ret = struct.unpack(type, self.data[self.offset:self.offset+size])
         self.offset += size
         return ret
     def write_something(self, type, something):
@@ -38,14 +44,17 @@ def write_something(self, type, something):
         @param something: list with stuff to be packed
         @type  something: list
         """
-        buf = packExt(type, *something)
-        self.size += len(buf)
+        try:
+            s = struct.Struct(type)
+            buf = s.pack(*something)
+            size = s.size
+        except AttributeError:
+            buf = struct.pack(type, *something)
+            size = len(buf)
+        self.size += size
         self.data += buf
-    def read_str(self, len=None):
-        if not len is None:
-            return self.read_something(str(len)+'s')[0]
-        else:  
-            return self.read_something('z')[0]
+    def read_str(self, len):
+        return self.read_something(str(len)+'s')[0]
     def read_uint8(self):
         return self.read_something('>B')[0]
     def read_int8(self):
@@ -111,7 +120,7 @@ def read_OTTDSimpleGamma(self):
         return i
     def read_array(self, format, number):
         a = array.array(format)
-        end_offs = self.offset + number
+        end_offs = self.offset + struct.calcsize(format) * number
         a.fromstring(self.data[self.offset:end_offs])
         self.offset = end_offs
         return a.tolist()

ottd_constants.py renamed to openttd/constants.py

@@ -1,17 +1,20 @@
 #!/bin/env python
+import sys
 import os
 import os.path
 import StringIO
 import traceback
 import time
 from log import LOG
-from ottd_lib import M_TCP, M_UDP, M_BOTH, Client
+from openttd.client import M_TCP, M_UDP, M_BOTH, Client
 from ottd_config import config, LoadConfig 
 from struct_zerostrings import packExt, unpackExt, unpackFromExt
 from ottd_client_event import IngameChat, IRCPublicChat, IRCPrivateChat, IRCPrivateNoticeChat, Broadcast, IngameToIRC, InternalCommand, IRCPublicActionChat, IRCPrivateActionChat, IRCToIngame
 
 import plugins
-import ottd_constants as const
+import openttd.constants as const
+
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib"))
 
 SVNREVISION = "$Rev$"
 
@@ -545,7 +548,7 @@ def joinGame(self):
                         offset += size2
 
                         if command2 == const.MAP_PACKET_START:
-                            LOG.info("starting downloading map!")
+                            LOG.info("start downloading map!")
                             [framecounter], size2 = unpackFromExt('I', content[offset:])
                             offset += size2
 

ottd_grfs.py renamed to openttd/grfdb.py

@@ -1,7 +1,9 @@
 #!/bin/env python
 # made by thomas {AT} thomasfischer {DOT} biz
-from ottd_lib import *
-from ottd_grfs import GrfDB
+from openttd.client import Client, M_UDP
+from openttd.grfdb import GrfDB
+import openttd.date
+import sys
 
 def printUsage():
     print "usage: %s <ip:port>" % sys.argv[0]
@@ -24,6 +26,8 @@ def main():
     if not gi is None:
         for k in ["companies_max","companies_on", "spectators_max", "server_name", "server_revision", "server_lang", "use_password", "clients_max", "clients_on", "spectators_on", "map_name", "map_width", "map_height", "map_set", "dedicated"]:
             print "%20s: %s" % (k, getattr(gi, k))
+        print "%20s: %s" % ("game_date", str(openttd.date.OpenTTDDate(ottddate=gi.game_date).toDate()))
+        print "%20s: %s" % ("start_date", str(openttd.date.OpenTTDDate(ottddate=gi.start_date).toDate()))
     else:
         return
     if gi.companies_on > 0:
@@ -36,7 +40,7 @@ def main():
                 cis = client.getTCPCompanyInfo()
                 using_tcp = True
             except:
-                cisi = client.getCompanyInfo(True)
+                cisi = client.getCompanyInfo()
                 cis = cisi.companies
                 using_tcp = False
         else:
@@ -54,7 +58,7 @@ def main():
                     print "%20s:"%("Clients")
                     for cli in ci.clients:
                         if cli.join_date > 0:
-                            jd = client.dateToYMD(cli.join_date)
+                            jd = openttd.date.OpenTTDDate(ottddate=cli.join_date).toYMD()
                         else:
                             jd = [0,0,0]
                         print "%30s, joined %d - %d - %d" % (cli.client_name, jd[2], jd[1], jd[0])

ottd_savegame.py renamed to openttd/savegame.py

@@ -1,11 +1,10 @@
 #!/bin/env python
 # made by yorickvanpelt {AT} gmail {DOT} com
 # ottd_lib by thomas {AT} thomasfischer {DOT} biz
-from ottd_lib import *
+from openttd.client import *
+import openttd.constants as const
 from struct_zerostrings import packExt, unpackExt, unpackFromExt
 
-import ottd_constants as const
-
 if platform.system() == 'Windows':
     # See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winprog/winprog/windows_api_reference.asp
     # for information on Windows APIs.