kelciste/src/esse.py

from common import Directions

# Esse - any interactible object which exists on the esse layer
class esse:
    def __init__(self, x, y):
        self._x = _x
        self._y = _y
    def getX(self):
        return self._x
    def getY(self):
        return self._y
    def setX(self, x):
        self._x = x
    def setY(self, y):
        self._y = y
    def interact(self, game):
        print 'Interacted with an Esse!'
    def __str__(self):
        return "E"
    def passable(self):
        return False
    def getModelName(self):
        return 'tile.pmd'
    def getColors(self):
        return (1.0, 1.0, 1.0)

# Nothing - when esse layer does not contain an esse        
class nothing:
    def interact(self, game):
        print 'Ain\'t nothin\' here!'
    def __str__(self):
        return " "
    def passable(self):
        return True
    def getModelName(self):
        return 'tile.pmd'
    def getColors(self):
        return (1.0, 1.0, 1.0)

# Parse initial player data
def p_pc(L):
    myX, myY = map(int, L[1:3])
    return pc(myX, myY, 100)

# Player - inherits from esse
class pc(esse):
    def __init__(self, x, y, life):
        self._x = x
        self._y = y
        self.life = life
        self.facing = Directions.UP
    def __str__(self):
        if self.facing == Directions.UP:
            return "^"
        if self.facing == Directions.DOWN:
            return "v"
        if self.facing == Directions.LEFT:
            return "<"
        if self.facing == Directions.RIGHT:
            return ">"
        return "P"
    def face(self, dir):
        self.facing = dir
    def getFacing(self):
        return self.facing
    def getModelName(self):
        return 'player.pmd'
    def getColors(self):
        return (0.75, 0.0, 0.0)

# Parse initial sign data        
def p_sign(L):
    myX, myY = map(int, L[0:2])
    myText = ' '.join(L[2:])
    return sign(myX, myY, myText)

# Sign class - displays text
class sign(esse):
    def __init__(self, x, y, text):
        self._x = x
        self._y = y
        self.text = text
    def interact(self, game):
        print self.text
    def __str__(self):
        return "S"
    def getModelName(self):
        return 'sign.pmd'
    def getColors(self):
        return (0.0, 0.0, 1.0)

# NPC class (right now, a glorified signpost)        
class npc(esse):
    def __init__(self, x, y, text):
        self._x = x
        self._y = y
        self.text = text
    def interact(self, game):
        print text
        
# Parse door placement
def p_door(L):
    myX, myY= map(int, L[0:2])
    myE = L[2]
    myDest = L[3]
    return door(myX, myY, myDest, myE)

# Door class (portal to another map)
class door(esse):
    def __init__(self, x, y, destination, entry):
        self._x = x
        self._y = y
        self.dest = destination
        self.entry = entry
    def interact(self, game):
        game.load(self.dest, self.entry)
    def passable(self):
        return self.open
    def __str__(self):
        return "D"
    def getModelName(self):
        return 'door.pmd'
    def getColors(self):
        return (0.0, 1.0, 0.0)
# Esse lookup table - for parsing purposes        
esse_lookup = {'sign': p_sign,
               'entry': p_pc,
               'door': p_door}