gameshell/gameshell.py

# gameshell.py

from shell import Shell
from gamebase import GameBase
import sys as _sys
#import re
import heapq
#import gamemap
import gameevents
#from os import get_terminal_size
#import random

class GameShell(Shell):
    
    UP = 1
    RIGHT = 2
    DOWN = 4
    LEFT = 8
    WALLS = ('++', '++', ' +', '++', '++', '||', '++', '|+', '+ ', '++',
    '==', '++', '++', '+|', '++', '++')
    
    def __init__(self, gameBase):
        super(GameShell, self).__init__()
        self.outstream = _sys.stdout
        self.gameBase = gameBase
        
        # register functions
        
        self.registerCommand('map', self.showMap)
        self.registerCommand('ls', self.showMap)
        self.registerCommand('go', self.gameBase.go)
        self.registerCommand('move', self.gameBase.go)
        self.registerCommand('walk', self.gameBase.go)
        self.registerCommand('look', self.gameBase.look)
        self.registerCommand('use', self.gameBase.use)
        self.registerCommand('loadMap', self.gameBase.loadMap)
        self.registerCommand('man', self.man)
        self.registerCommand('help', self.man)
        self.registerCommand('save', self.gameBase.saveGame)
        self.registerCommand('load', self.gameBase.loadGame)
        self.registerCommand('take', self.gameBase.take)
        self.registerCommand('get', self.gameBase.take)
        self.registerCommand('drop', self.gameBase.drop)
        self.registerCommand('inv', self.inv)
        self.registerCommand('bag', self.inv)
        self.registerCommand('items', self.inv)
        self.registerCommand('status', self.status)
        self.registerAlias('run', ['go', '-r'])
        
    # Helper functions
        
    def man(self, args):
        super(GameShell, self).man(args)
        heapq.heappush(self.gameBase.eventQueue, (self.gameBase.gameTime, gameevents.NoOpEvent()))
        
    def showMap(self, args):
        """map [-l]
See a map of the local area. "ls" is an alias of map.
"l" and "legend" are aliases of -l.
If -l is given, a map legend will be printed under the map."""
        xAxis = '    ' + ''.join([self.gameBase.numberToLetter(i).ljust(2) for i in range(self.gameBase.level.dimensions[0])]) + '\n'
        rows = []
        index = 0
        exits = {}
        doors = {}
        useables = {}
        items = {}
        for y in range(self.gameBase.level.dimensions[1]):
            rows.append(['{0:2}  '.format(y)])
            for x in range(self.gameBase.level.dimensions[0]):
                pos = self.gameBase.level.mapMatrix[y][x]
                thing = self.gameBase.level.getThingAtPos(index)
                if x == self.gameBase.playerx and y == self.gameBase.playery:
                    rows[-1].append('()')
                elif thing:
                    if thing.thingType == 'x': # exit
                        rows[-1].append('X{0}'.format(thing.exitid))
                        exits[thing.exitid] = thing.name
                    elif thing.thingType == 'd': # door
                        doors[len(doors)+1] = thing.name
                        rows[-1].append('D{0}'.format(len(doors)))
                    elif thing.thingType == 'u': # useable
                        useables[len(useables)+1] = thing.name
                        rows[-1].append('U{0}'.format(len(useables)))
                    elif thing.thingType == 'i': # item
                        items[len(items)+1] = thing.name
                        rows[-1].append('I{0}'.format(len(items)))
                elif pos[0] == 'w':
                    sides = 0
                    if y > 0 and self.gameBase.level.mapMatrix[y-1][x][0] == 'w':
                        sides += GameShell.UP
                    if x < self.gameBase.level.dimensions[0]-1 and self.gameBase.level.mapMatrix[y][x+1][0] == 'w':
                        sides += GameShell.RIGHT
                    if y < self.gameBase.level.dimensions[1]-1 and self.gameBase.level.mapMatrix[y+1][x][0] == 'w':
                        sides += GameShell.DOWN
                    if x > 0 and self.gameBase.level.mapMatrix[y][x-1][0] == 'w':
                        sides += GameShell.LEFT
                    rows[-1].append(GameShell.WALLS[sides])
                else:
                    rows[-1].append('  ')
                index += 1
            rows[-1] = ''.join(rows[-1])
        
        print(xAxis)
        print('\n'.join(rows))
        
        if len(args) > 0:
            if args[0] == '-l' or args[0] == 'l' or args[0] == 'legend':
                legend = ["\n---Legend---\n", "() - {0}".format(self.gameBase.playerName),
                "Xn - Exit to another area"]
                for i in exits:
                    legend.append('  X{0} - {1}'.format(i, exits[i]))
                legend.append("Un - Useable object")
                for i in useables:
                    legend.append('  U{0} - {1}'.format(i, useables[i]))
                legend.append("In - Item")
                for i in items:
                    legend.append('  I{0} - {1}'.format(i, items[i]))
                legend.append("Dn - Door")
                for i in doors:
                    legend.append('  D{0} - {1}'.format(i, doors[i]))
                print('\n'.join(legend))
        heapq.heappush(self.gameBase.eventQueue, (self.gameBase.gameTime, gameevents.NoOpEvent()))
        return
        
    def status(self, args):
        ret = []
        if self.gameBase.level != None:
            ret.append("Level:{0:.>74}".format(self.gameBase.level.name))
        else:
            ret.append("Level:{0:.>74}".format("None"))
        ret.append("Gametime:{0:.>71.3}".format(self.gameBase.gameTime))
        ret.append("Event queue:")
        for i in sorted(self.gameBase.eventQueue):
            ret.append("{0:.<8.3}:{1:.>72}".format(i[0], str(i[1])))
        ret.append("Player name:{0:.>68}".format(self.gameBase.playerName))
        ret.append("Player position:{0:.>64}".format("{0}{1}".format(self.gameBase.numberToLetter(self.gameBase.playerx), self.gameBase.playery)))
        ret.append("Prev. position:{0:.>65}".format("{0}{1}".format(self.gameBase.numberToLetter(self.gameBase.prevx), self.gameBase.prevy)))
        print('\n'.join(ret))
        heapq.heappush(self.gameBase.eventQueue, (self.gameBase.gameTime, gameevents.NoOpEvent()))
        return
        
    def inv(self, args):
        print('\n'.join([i for i in self.gameBase.playerInv]))
        
    def update(self):
        self.gameBase.gameEventLoop()

if __name__ == '__main__':
    sh = GameShell(GameBase())
    sh.run()