simdata.py

Air Traffic Controller这个游戏旨于将你放置到飞机交通控制器的位置上。指导飞机飞到它们正确的目的地。这是一个后勤学的游戏且要提前思考

# $Id: simdata.py,v 1.12 2002/02/18 13:04:17 marijn Exp $

# An air traffic simulation game. This is the simulation server.
# Copyright (C) 2000,1,2  Marijn Vriens <[e-mail]>
#
# 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 random
import math
import time
import UserDict
import CORBA, SimulationServer, SimulationServer__POA

class SimData(UserDict.UserDict):
    _idmax = pow(2, 30)
    def __init__(self):
        UserDict.UserDict.__init__(self)
        self.dataDeleted = {}
    def add(self, value):
        value.id = self._genId()
        self.data[value.id] = value
    def delete(self, key):
        value = self.data[key]
        value.markAsDeleted()
        self.dataDeleted[key] = value
        del self.data[key]
    def genIdlObjsEntryList(self, lastEntryListTime):
        r = []
        for i in self.data.values():
            if i.changedAfter(lastEntryListTime):
                r.append(i.genIdlReduced())
        return r
    def genIdlObjsLeaveList(self, lastLeaveListTime):
        r = []
        for i in self.dataDeleted.values():
            if i.deletedAfter(lastLeaveListTime):
                r.append(i.genIdlReduced())
        return r
    def reapDeleted(self, LastClientGotListsTime):
        l = []
        for k in self.dataDeleted.keys():
            if self.dataDeleted[k].deletedBefore(LastClientGotListsTime):
                l.append(k)
        for i in l:
            del(self.dataDeleted[i])
    def _genId(self):
        k = random.randint(0, self._idmax)
        while(self.data.has_key(k)):
            k = random.randint(0, self._idmax)
        return k
    def __setitem__(self, key, value):
        raise "NOT_SUPPORTED"

       
class Entity:
    def __init__(self):
        self.id = None
        self.pos = _Position
        self._timeCreated = time.time()
        self._timeChange  = time.time()
        self._timeDeleted = -1
    def createdAfter(self, t):
        if t <= self._timeCreated: return self
        else: return None
    def markAsChanged(self):
        self._timeCange = time.time()
    def changedAfter(self, t):
        if t <= self._timeChange:
            return self
        else: return None
    def markAsDeleted(self):
        self._timeDeleted = time.time()
    def deletedAfter(self, t):
        if self._timeDeleted == -1: raise "ObjectNotDeleted"
        if t <= self._timeDeleted: return self
        else: return None
    def deletedBefore(self, t):
        if self._timeDeleted == -1: raise "ObjectNotDeleted"
        if t > self._timeDeleted: return self
        else: return None        
    def update(self):
        raise "AbstractMethod", "Should be re-implented in sub-class"
    def genIdlFull(self):
        raise "AbstractMethod", "Should be re-implented in sub-class"
    def genIdlReduced(self):
        objTypeNameList = {
            Plane: 'plane'
        }
        r = SimulationServer.SimObjType()
        r.objTypeName = objTypeNameList[self.__class__]
        r.id = self.id
        r.pos = self.pos.genIdlReduced()
        return r


class Plane(Entity):
    def __init__(self): #, lat, lon, vert):
        Entity.__init__(self)
        self.pos = _Vector()
        self._order = None
    def update(self):
        if(self._order):
            dheading = self._order.heading - self.pos.heading()
            if dheading > 180:
                dheading = dheading - 360
            elif dheading < -180:
                dheading = dheading + 360
            dspeed   = self._order.speed - self.pos.speed()
            dheight  = self._order.height - self.pos.height()
            
            #print "\theading, speed, height"
            #print "Curren: ", self.pos.heading(), self.pos.speed(), self.pos.height()
            #print "Orders: ", self._order.heading, self._order.speed, self._order.height
            #print "Deltas: ", dheading, dspeed, dheight
            if(dheading == 0) and (dspeed == 0) and (dheight == 0):
                #print "Order completed"
                self._order = None
                return
            self.pos.changeHeading(dheading)
            self.pos.changeSpeed(dspeed)
            self.pos.changeHeight(dheight)
        self.pos.move(1)
    def genIdlFull(self):
        r = SimulationServer.PlaneType()
        r.id = self.id
        r.pos = self.pos.genIdlFull()
        return r
    def processOrder(self, order):
        self._order = order
        return order    
        
class _Position:
    def __init__(self):
        self._latitude = 0.0
        self._longitude = 0.0
        self._height = 0.0
    def latitude(self, latitude=None): # North - South distance.
        if(latitude == None): return self._latitude
        else:
            if(latitude >  90
            or latitude < -90):
                raise "DataOutOfBounds"
            self._latitude = latitude
    def longitude(self, longitude=None): # East - West distance.
        if(longitude == None): return self._longitude
        else:
            if(longitude >  180
            or longitude < -180):
                raise "DataOutOfBounds"
            self._longitude = longitude
    def height(self, height=None):
        if(height == None): return self._height
        else: self._height = height
    def genIdlReduced(self, r=None):
        if r == None:
            r = SimulationServer.Point()
        r.lat  = self._latitude
        r.lon  = self._longitude
        r.vert = self._height
        return r

class _Vector(_Position):
    def __init__(self):
        _Position.__init__(self)
        self._speed = 0.0
        self._heading = 0.0
        self._dheading_per_turn = 5
        self._dspeed_per_turn   = 1
        self._dheight_per_turn  = 5
    def speed(self, speed=None): # speed in meters per second
        if(speed == None): return self._speed
        else: self._speed = speed
    def changeSpeed(self, change):
        if(abs(change) < self._dspeed_per_turn):
            self.speed(self.speed() + change)
        else:
            newspeed = (_direction(change) * self._dspeed_per_turn) + self.speed()
            self.speed(newspeed)
    def heading(self, heading=None):
        if(heading == None): return self._heading

        else:
            if(heading >= 360): heading = heading - 360
            if(heading <    0): heading = heading + 360
            self._heading = heading
    def changeHeading(self, change):
        if(abs(change) < self._dheading_per_turn):
            self.heading(self.heading() + change)
        else:
            newheading = (_direction(change) * self._dheading_per_turn) + self.heading()
            self.heading(newheading)
    def changeHeight(self, change):
        if(abs(change) < self._dheight_per_turn):
            self.height(self.height() + change)
        else:
            newheight = (_direction(change) * self._dheight_per_turn) + self.height()
            self.height(newheight)
    def move(self, timeInSecs):
        vspeed = self._speed * math.cos(_degrees2pi(self._heading))
        hspeed = self._speed * math.sin(_degrees2pi(self._heading))
        vdistance = vspeed * timeInSecs
        hdistance = hspeed * timeInSecs
        # border handling... bs at the moment,
        # but... so is all of this function right now.
        lat = self.latitude()  + vdistance
        lon = self.longitude() + hdistance
        if lat >  90:
            lat = lat - 180
        if lat < -90:
            lat = lat + 180
        if lon >  180:
            lon = lon - 360
        if lon < -180:
            lon = lon + 360
        self.latitude(lat)
        self.longitude(lon)
    def genIdlFull(self):
        r = SimulationServer.Vector()
        _Position.genIdlReduced(self, r)
        r.heading = self.heading()
        r.speed   = self.speed()
        return r        

def _degrees2pi(deg): return deg * ( math.pi / 180 )
def _knotsHour2meterSec(kmh): return kmh * ( 1852 / (60*60) )
def _direction(value):
    if(value >= 0):
        return 1
    else:
        return -1



# $Log: simdata.py,v $
# Revision 1.12  2002/02/18 13:04:17  marijn
# Changed rate of speed changes
#
# Revision 1.11  2002/02/17 21:41:38  marijn
# Improved turning direction
#
# Revision 1.10  2002/02/07 16:28:07  marijn
# Fixed order handling
#
# Revision 1.9  2002/02/04 15:50:34  marijn
# Added order receiving methods
#
# Revision 1.8  2002/02/01 15:07:36  marijn
# updated copyright information
#
# Revision 1.7  2002/01/13 16:05:56  marijn
# All updates now go via getUpdate(). Split genIdl into Full and Reduced
#
# Revision 1.6  2002/01/12 23:49:50  marijn
# Refactored simdata and added basic coordinate system
#
# Revision 1.5  2001/12/26 01:24:43  marijn
# Added Plane class
#
# Revision 1.4  2001/12/25 02:00:08  marijn
# various fixes and updates.
#
# Revision 1.3  2001/11/27 20:59:06  marijn
# sending of simple sim objcts
#
# Revision 1.2  2001/11/19 00:25:58  marijn
# py merged back into HEAD
#
# Revision 1.1.2.1  2001/11/07 20:08:09  marijn
# Added SimServer and threading
#