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
        self.colorMode = 0
        
        # 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.registerCommand('options', self.options)
        self.registerCommand('colorTest', self.colorTest)
        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 options(self, args):
        i = 0
        while i < len(args):
            if args[i] == 'color':
                i += 1
                if args[i] in ('0', '3', '4', '8', '24'):
                    self.colorMode = int(args[i])
            i += 1
            
    def __colorTestRoutine(self, lower, upper):
        colors = []
        step = int((upper - lower) / 8)
        #print(step)
        for g in range(lower, upper, step):
            colors.append(self.color(upper-1, g, lower, False))
        #print(len(colors))
        colors.append(self.color(upper-1, upper-1, lower, False))
        for r in range(upper-step, lower-1, -step):
            colors.append(self.color(r, upper-1, lower, False))
        #print(len(colors))
        for b in range(lower+step, upper, step):
            colors.append(self.color(lower, upper-1, b, False))
        #print(len(colors))
        colors.append(self.color(lower, upper-1, upper-1, False))
        for g in range(upper-step, lower-1, -step):
            colors.append(self.color(lower, g, upper-1, False))
        #print(len(colors))
        for r in range(lower+step, upper, step):
            colors.append(self.color(r, lower, upper-1, False))
        colors.append(self.color(upper-1, lower, upper-1, False))
        #print(len(colors))
        for b in range(upper-step, lower, -step):
            colors.append(self.color(upper-1, lower, b, False))
        #print(len(colors))
        colors.append('\x1b[0m')
        print(' '.join(colors))
            
    def colorTest(self, args):
        for i in (3, 4, 8, 24):
            print(i)
            self.colorMode = i
            self.__colorTestRoutine(0, 128) # dark
            self.__colorTestRoutine(0, 256) # medium
            self.__colorTestRoutine(128, 256) # light
        
    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 = {}
        level = self.gameBase.level
        textColor = level.wallColors[0]
        floorColor = level.floorColors[0]
        for y in range(level.dimensions[1]):
            rows.append(['{0}{1:2}  {2}{3}'.format(self.clearColor(), y, self.color(textColor[1:]), self.color(floorColor[1:], fg = False))])
            rows[-1].append(self.color(textColor[1:]))
            for x in range(level.dimensions[0]):
                pos = level.mapMatrix[y][x]
                thing = level.getThingAtPos(index)
                if x == self.gameBase.playerx and y == self.gameBase.playery:
                    if '#0000FF' != textColor:
                        textColor = '#0000FF'
                        rows[-1].append(self.color(textColor[1:]))
                    rows[-1].append('()')
                elif thing:
                    if thing.graphic[1] != textColor:
                        textColor = thing.graphic[1]
                        rows[-1].append(self.color(textColor[1:]))
                    if thing.thingType == 'x': # exit
                        rows[-1].append('X{0}'.format(thing.exitid))
                        exits[thing.exitid] = (thing.name, thing.graphic[1])
                    elif thing.thingType == 'd': # door
                        doors[len(doors)+1] = (thing.name, thing.graphic[1])
                        rows[-1].append('D{0}'.format(len(doors)))
                    elif thing.thingType == 'u': # useable
                        useables[len(useables)+1] = (thing.name, thing.graphic[1])
                        rows[-1].append('U{0}'.format(len(useables)))
                    elif thing.thingType == 'i': # item
                        items[len(items)+1] = (thing.name, thing.graphic[1])
                        rows[-1].append('I{0}'.format(len(items)))
                elif pos[0] == 'w':
                    if level.wallColors[level.mapMatrix[y][x][1]] != textColor:
                        textColor = level.wallColors[level.mapMatrix[y][x][1]]
                        rows[-1].append(self.color(textColor[1:]))
                    sides = 0
                    if y > 0 and level.mapMatrix[y-1][x][0] == 'w':
                        sides += GameShell.UP
                    if x < level.dimensions[0]-1 and level.mapMatrix[y][x+1][0] == 'w':
                        sides += GameShell.RIGHT
                    if y < level.dimensions[1]-1 and level.mapMatrix[y+1][x][0] == 'w':
                        sides += GameShell.DOWN
                    if x > 0 and 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('{0}\n'.format(self.clearColor()).join(rows) + self.clearColor())
        self.clearColor()
        
        if len(args) > 0:
            if args[0] == '-l' or args[0] == 'l' or args[0] == 'legend':
                legend = ["\n---Legend---\n", "{0}(){1} - {2}".format(self.color('0000FF'), self.clearColor(), self.gameBase.playerName),
                "Xn - Exit to another area"]
                for i in exits:
                    legend.append('  {0}X{1}{2} - {3}'.format(self.color(exits[i][1][1:]), i, self.clearColor(), exits[i][0]))
                legend.append("Un - Useable object")
                for i in useables:
                    legend.append('  {0}U{1}{2} - {3}'.format(self.color(useables[i][1][1:]), i, self.clearColor(), useables[i][0]))
                legend.append("In - Item")
                for i in items:
                    legend.append('  {0}I{1}{2} - {3}'.format(self.color(items[i][1][1:]), i, self.clearColor(), items[i][0]))
                legend.append("Dn - Door")
                for i in doors:
                    legend.append('  {0}D{1}{2} - {3}'.format(self.color(doors[i][1][1:]), i, self.clearColor(), doors[i][0]))
                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()