1013 lines
39 KiB
Python
1013 lines
39 KiB
Python
#gamemap.py
|
|
import re
|
|
import heapq
|
|
import xml.etree.ElementTree as ET
|
|
import ruamel.yaml
|
|
import math as _mt
|
|
from ruamel.yaml.comments import CommentedMap # for loading classes
|
|
|
|
class Thing(object):
|
|
|
|
def __init__(self, thingType: str, name: str, x: int, y: int, description: str, flags: int, playerx = None, playery = None):
|
|
self.thingType = thingType
|
|
self.name = name
|
|
self.description = description
|
|
self.x = x
|
|
self.y = y
|
|
self.playerx = x
|
|
self.playery = y
|
|
if playerx:
|
|
self.playerx = playerx
|
|
if playery:
|
|
self.playery = playery
|
|
self.passable = bool(flags & 1)
|
|
self.talkable = bool(flags & 2)
|
|
self.lookable = bool(flags & 4)
|
|
self.takeable = bool(flags & 8)
|
|
self.useable = bool(flags & 16)
|
|
self.graphic = ('clear', '#7F7F7F', ' ')
|
|
self.thingID = -1 # ID not assigned
|
|
|
|
def __str__(self):
|
|
"""__str__ is used for look."""
|
|
return self.description
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, Thing):
|
|
return False
|
|
return self.name == other.name
|
|
|
|
class Item(Thing):
|
|
yaml_flag = u'!Item'
|
|
defaultGraphic = ('clear', '#00BF00', '^')
|
|
|
|
def __init__(self, name, x: int, y: int, description: str, useFunc: str, useOnFunc: str, customValues: dict, ranged: bool, graphic = defaultGraphic):
|
|
super(Item, self).__init__('i', name, x, y, description, 13)
|
|
self.useFunc = useFunc
|
|
self.useOnFunc = useOnFunc
|
|
self.customValues = customValues
|
|
self.ranged = ranged
|
|
self.graphic = graphic
|
|
|
|
def use(self):
|
|
pass
|
|
|
|
@classmethod
|
|
def to_yaml(cls, representer, node):
|
|
# save usual things
|
|
ret = {'name': node.name, 'location': (node.x, node.y), 'description': node.description}
|
|
# save graphic
|
|
graphic = {}
|
|
if node.graphic[0] != Item.defaultGraphic[0]:
|
|
graphic['bgc'] = node.graphic[0]
|
|
if node.graphic[1] != Item.defaultGraphic[1]:
|
|
graphic['fgc'] = node.graphic[1]
|
|
if node.graphic[2] != Item.defaultGraphic[2]:
|
|
graphic['shape'] = node.graphic[2]
|
|
if len(graphic) > 0:
|
|
ret['graphic'] = graphic
|
|
# save use functions
|
|
if node.useFunc != '':
|
|
ret['useFunc'] = node.useFunc
|
|
if node.useOnFunc != '':
|
|
ret['useOnFunc'] = node.useOnFunc
|
|
if len(node.customValues) > 0:
|
|
ret['customValues'] = node.customValues
|
|
if node.ranged:
|
|
ret['ranged'] = node.ranged
|
|
return representer.represent_mapping(cls.yaml_flag, ret)
|
|
|
|
@classmethod
|
|
def from_yaml(cls, constructor, node):
|
|
parts = CommentedMap()
|
|
constructor.construct_mapping(node, parts, True)
|
|
# set default values for optional arguments
|
|
useFunc = ''
|
|
useOnFunc = ''
|
|
customValues = {}
|
|
ranged = False
|
|
bgc = Item.defaultGraphic[0]
|
|
fgc = Item.defaultGraphic[1]
|
|
shape = Item.defaultGraphic[2]
|
|
# load graphic
|
|
if 'graphic' in parts:
|
|
if 'bgc' in parts['graphic']:
|
|
bgc = parts['graphic']['bgc']
|
|
if 'fgc' in parts['graphic']:
|
|
fgc = parts['graphic']['fgc']
|
|
if 'shape' in parts['graphic']:
|
|
shape = parts['graphic']['shape']
|
|
graphic = (bgc, fgc, shape)
|
|
# load use functions
|
|
if 'useFunc' in parts:
|
|
useFunc = parts['useFunc']
|
|
if 'useOnFunc' in parts:
|
|
useOnFunc = parts['useOnFunc']
|
|
if 'customValues' in parts:
|
|
customValues = dict(parts['customValues'])
|
|
for v in customValues:
|
|
if isinstance(customValues[v], tuple):
|
|
customValues[v] = list(customValues[v])
|
|
if 'ranged' in parts:
|
|
useOnFunc = parts['ranged']
|
|
return cls(parts['name'], parts['location'][0], parts['location'][1],
|
|
parts['description'], useFunc, useOnFunc, customValues, ranged, graphic)
|
|
|
|
class Useable(Thing):
|
|
yaml_flag = u'!Useable'
|
|
defaultGraphic = ('clear', '#0000FF', '#')
|
|
|
|
def __init__(self, name, x: int, y: int, description: str, useFunc: str, customValues: dict, playerx = None, playery = None, graphic = defaultGraphic):
|
|
super(Useable, self).__init__('u', name, x, y, description, 16, playerx, playery)
|
|
self.useFunc = useFunc
|
|
self.customValues = customValues
|
|
self.graphic = graphic
|
|
|
|
@classmethod
|
|
def to_yaml(cls, representer, node):
|
|
# save usual things
|
|
ret = {'name': node.name, 'location': (node.x, node.y), 'description': node.description}
|
|
# save graphic
|
|
graphic = {}
|
|
if node.graphic[0] != Useable.defaultGraphic[0]:
|
|
graphic['bgc'] = node.graphic[0]
|
|
if node.graphic[1] != Useable.defaultGraphic[1]:
|
|
graphic['fgc'] = node.graphic[1]
|
|
if node.graphic[2] != Useable.defaultGraphic[2]:
|
|
graphic['shape'] = node.graphic[2]
|
|
if len(graphic) > 0:
|
|
ret['graphic'] = graphic
|
|
# save use functions
|
|
if node.useFunc != '':
|
|
ret['useFunc'] = node.useFunc
|
|
if len(node.customValues) > 0:
|
|
ret['customValues'] = node.customValues
|
|
if node.x != node.playerx or node.y != node.playery:
|
|
ret['useLocation'] = (node.playerx, node.playery)
|
|
return representer.represent_mapping(cls.yaml_flag, ret)
|
|
|
|
@classmethod
|
|
def from_yaml(cls, constructor, node):
|
|
parts = CommentedMap()
|
|
constructor.construct_mapping(node, parts, True)
|
|
# set default values for optional arguments
|
|
useFunc = ''
|
|
customValues = {}
|
|
playerx, playery = parts['location']
|
|
bgc = Useable.defaultGraphic[0]
|
|
fgc = Useable.defaultGraphic[1]
|
|
shape = Useable.defaultGraphic[2]
|
|
# load graphic
|
|
if 'graphic' in parts:
|
|
if 'bgc' in parts['graphic']:
|
|
bgc = parts['graphic']['bgc']
|
|
if 'fgc' in parts['graphic']:
|
|
fgc = parts['graphic']['fgc']
|
|
if 'shape' in parts['graphic']:
|
|
shape = parts['graphic']['shape']
|
|
graphic = (bgc, fgc, shape)
|
|
# load use functions
|
|
if 'useFunc' in parts:
|
|
useFunc = parts['useFunc']
|
|
if 'customValues' in parts:
|
|
customValues = dict(parts['customValues'])
|
|
for v in customValues:
|
|
if isinstance(customValues[v], tuple):
|
|
customValues[v] = list(customValues[v])
|
|
if 'useLocation' in parts:
|
|
playerx, playery = parts['useLocation']
|
|
return cls(parts['name'], parts['location'][0], parts['location'][1],
|
|
parts['description'], useFunc, customValues, playerx, playery, graphic)
|
|
|
|
class NPC(Thing):
|
|
yaml_flag = u'!NPC'
|
|
defaultGraphic = ('clear', '#000000', 'o')
|
|
|
|
def __init__(self, name, x: int, y: int, description: str, behavior: str, inventory: list, customValues: dict, playerx = None, playery = None, following = False, graphic = defaultGraphic):
|
|
super(NPC, self).__init__('c', name, x, y, description, 6, playerx, playery)
|
|
self.behavior = behavior
|
|
self.following = following
|
|
self.inventory = inventory
|
|
self.customValues = customValues
|
|
self.graphic = graphic
|
|
self.behaveEvent = None
|
|
|
|
def give(self, item):
|
|
self.inventory.append(item)
|
|
|
|
def drop(self, index):
|
|
return self.inventory.pop(index)
|
|
|
|
def dialog(self):
|
|
pass
|
|
|
|
@classmethod
|
|
def to_yaml(cls, representer, node):
|
|
# save usual things
|
|
ret = {'name': node.name, 'location': (node.x, node.y),
|
|
'description': node.description, 'behavior': node.behavior}
|
|
# save graphic
|
|
graphic = {}
|
|
if node.graphic[0] != NPC.defaultGraphic[0]:
|
|
graphic['bgc'] = node.graphic[0]
|
|
if node.graphic[1] != NPC.defaultGraphic[1]:
|
|
graphic['fgc'] = node.graphic[1]
|
|
if node.graphic[2] != NPC.defaultGraphic[2]:
|
|
graphic['shape'] = node.graphic[2]
|
|
if len(graphic) > 0:
|
|
ret['graphic'] = graphic
|
|
# save use functions
|
|
if node.following:
|
|
ret['following'] = node.following
|
|
if len(node.inventory) > 0:
|
|
ret['inventory'] = node.inventory
|
|
if len(node.customValues) > 0:
|
|
ret['customValues'] = node.customValues
|
|
if node.x != node.playerx or node.y != node.playery:
|
|
ret['useLocation'] = (node.playerx, node.playery)
|
|
return representer.represent_mapping(cls.yaml_flag, ret)
|
|
|
|
@classmethod
|
|
def from_yaml(cls, constructor, node):
|
|
parts = CommentedMap()
|
|
constructor.construct_mapping(node, parts, True)
|
|
# set default values for optional arguments
|
|
following = False
|
|
inventory = []
|
|
customValues = {}
|
|
playerx, playery = parts['location']
|
|
bgc = NPC.defaultGraphic[0]
|
|
fgc = NPC.defaultGraphic[1]
|
|
shape = NPC.defaultGraphic[2]
|
|
# load graphic
|
|
if 'graphic' in parts:
|
|
if 'bgc' in parts['graphic']:
|
|
bgc = parts['graphic']['bgc']
|
|
if 'fgc' in parts['graphic']:
|
|
fgc = parts['graphic']['fgc']
|
|
if 'shape' in parts['graphic']:
|
|
shape = parts['graphic']['shape']
|
|
graphic = (bgc, fgc, shape)
|
|
# load use functions
|
|
if 'following' in parts:
|
|
useFunc = parts['following']
|
|
if 'inventory' in parts:
|
|
inventory = parts['inventory']
|
|
if 'customValues' in parts:
|
|
customValues = dict(parts['customValues'])
|
|
for v in customValues:
|
|
if isinstance(customValues[v], tuple):
|
|
customValues[v] = list(customValues[v])
|
|
if 'useLocation' in parts:
|
|
playerx, playery = parts['useLocation']
|
|
return cls(parts['name'], parts['location'][0], parts['location'][1],
|
|
parts['description'], parts['behavior'], inventory, customValues,
|
|
playerx, playery, following, graphic)
|
|
|
|
class Door(Thing):
|
|
yaml_flag = u'!Door'
|
|
defaultGraphic = ('clear', '#7F3F00', '#')
|
|
|
|
def __init__(self, name, x: int, y: int, locked: bool, description = None, key = None, graphic = defaultGraphic):
|
|
self.descBase = description
|
|
if description == None:
|
|
if locked:
|
|
description = "The {0} is locked.".format(name)
|
|
else:
|
|
description = "The {0} is unlocked.".format(name)
|
|
else:
|
|
if locked:
|
|
description += " It is locked.".format(name)
|
|
else:
|
|
description += " It is unlocked.".format(name)
|
|
super(Door, self).__init__('d', name, x, y, description, 1)
|
|
self.passable = not locked
|
|
self.key = key
|
|
self.graphic = graphic
|
|
|
|
def lock(self, key = None):
|
|
if key == self.key:
|
|
self.passable = not self.passable
|
|
if self.descBase == None:
|
|
if self.passable:
|
|
self.description = "The {0} is unlocked.".format(self.name)
|
|
else:
|
|
self.description = "The {0} is locked.".format(self.name)
|
|
else:
|
|
if self.passable:
|
|
self.description += " It is unlocked.".format(self.name)
|
|
else:
|
|
self.description += " It is locked.".format(self.name)
|
|
return True
|
|
return False
|
|
|
|
@classmethod
|
|
def to_yaml(cls, representer, node):
|
|
# save usual things
|
|
ret = {'name': node.name, 'location': (node.x, node.y)}
|
|
# save graphic
|
|
graphic = {}
|
|
if node.graphic[0] != Door.defaultGraphic[0]:
|
|
graphic['bgc'] = node.graphic[0]
|
|
if node.graphic[1] != Door.defaultGraphic[1]:
|
|
graphic['fgc'] = node.graphic[1]
|
|
if node.graphic[2] != Door.defaultGraphic[2]:
|
|
graphic['shape'] = node.graphic[2]
|
|
if len(graphic) > 0:
|
|
ret['graphic'] = graphic
|
|
# save door state
|
|
if node.passable:
|
|
ret['locked'] = not node.passable
|
|
if node.descBase != None:
|
|
ret['description'] = node.descBase
|
|
if node.key != None:
|
|
ret['key'] = node.key
|
|
return representer.represent_mapping(cls.yaml_flag, ret)
|
|
|
|
@classmethod
|
|
def from_yaml(cls, constructor, node):
|
|
parts = CommentedMap()
|
|
constructor.construct_mapping(node, parts, True)
|
|
# set default values for optional arguments
|
|
description = None
|
|
locked = False
|
|
key = None
|
|
bgc = Door.defaultGraphic[0]
|
|
fgc = Door.defaultGraphic[1]
|
|
shape = Door.defaultGraphic[2]
|
|
# load graphic
|
|
if 'graphic' in parts:
|
|
if 'bgc' in parts['graphic']:
|
|
bgc = parts['graphic']['bgc']
|
|
if 'fgc' in parts['graphic']:
|
|
fgc = parts['graphic']['fgc']
|
|
if 'shape' in parts['graphic']:
|
|
shape = parts['graphic']['shape']
|
|
graphic = (bgc, fgc, shape)
|
|
# load door state
|
|
if 'description' in parts:
|
|
description = parts['description']
|
|
if 'locked' in parts:
|
|
locked = parts['locked']
|
|
if 'key' in parts:
|
|
key = parts['key']
|
|
return cls(parts['name'], parts['location'][0], parts['location'][1],
|
|
locked, description, key, graphic)
|
|
|
|
class MapExit(Thing):
|
|
yaml_flag = u'!MapExit'
|
|
defaultGraphic = ('clear', '#FF0000', 'x')
|
|
|
|
def __init__(self, name, x: int, y: int, exitid: int, destination: str, prefix: None, graphic = defaultGraphic):
|
|
description = name
|
|
if prefix:
|
|
description = "{0} {1}".format(prefix, name)
|
|
super(MapExit, self).__init__('x', name, x, y, description, 5)
|
|
self.exitid = exitid
|
|
self.destination = destination
|
|
self.prefix = prefix
|
|
self.graphic = graphic
|
|
|
|
@classmethod
|
|
def to_yaml(cls, representer, node):
|
|
# save usual things
|
|
ret = {'name': node.name, 'location': (node.x, node.y), 'id': node.exitid, 'destination': node.destination}
|
|
# save graphic
|
|
graphic = {}
|
|
if node.graphic[0] != MapExit.defaultGraphic[0]:
|
|
graphic['bgc'] = node.graphic[0]
|
|
if node.graphic[1] != MapExit.defaultGraphic[1]:
|
|
graphic['fgc'] = node.graphic[1]
|
|
if node.graphic[2] != MapExit.defaultGraphic[2]:
|
|
graphic['shape'] = node.graphic[2]
|
|
if len(graphic) > 0:
|
|
ret['graphic'] = graphic
|
|
if node.prefix != None:
|
|
ret['prefix'] = node.prefix
|
|
return representer.represent_mapping(cls.yaml_flag, ret)
|
|
|
|
@classmethod
|
|
def from_yaml(cls, constructor, node):
|
|
parts = CommentedMap()
|
|
constructor.construct_mapping(node, parts, True)
|
|
# set default values for optional arguments
|
|
prefix = None
|
|
bgc = MapExit.defaultGraphic[0]
|
|
fgc = MapExit.defaultGraphic[1]
|
|
shape = MapExit.defaultGraphic[2]
|
|
# load graphic
|
|
if 'graphic' in parts:
|
|
if 'bgc' in parts['graphic']:
|
|
bgc = parts['graphic']['bgc']
|
|
if 'fgc' in parts['graphic']:
|
|
fgc = parts['graphic']['fgc']
|
|
if 'shape' in parts['graphic']:
|
|
shape = parts['graphic']['shape']
|
|
graphic = (bgc, fgc, shape)
|
|
if 'prefix' in parts:
|
|
prefix = parts['prefix']
|
|
return cls(parts['name'], parts['location'][0], parts['location'][1],
|
|
parts['id'], parts['destination'], prefix, graphic)
|
|
|
|
class MapEntrance(Thing):
|
|
yaml_flag = u'!MapEntrance'
|
|
defaultGraphic = ('clear', 'clear', 'x')
|
|
# no graphic - should not be drawn
|
|
|
|
def __init__(self, x: int, y: int, exitid: int, name = None):
|
|
if name == None:
|
|
name = 'entrance {}'.format(exitid)
|
|
super(MapEntrance, self).__init__('a', name, x, y, description, 1)
|
|
self.exitid = exitid
|
|
|
|
@classmethod
|
|
def to_yaml(cls, representer, node):
|
|
# save usual things
|
|
ret = {'location': (node.x, node.y), 'id': node.exitid}
|
|
return representer.represent_mapping(cls.yaml_flag, ret)
|
|
|
|
@classmethod
|
|
def from_yaml(cls, constructor, node):
|
|
parts = CommentedMap()
|
|
constructor.construct_mapping(node, parts, True)
|
|
# set default values for optional arguments
|
|
return cls(parts['location'][0], parts['location'][1], parts['id'])
|
|
|
|
class MapError(RuntimeError):
|
|
pass
|
|
|
|
class GameMap(object):
|
|
# Matrix tile codes:
|
|
# e: empty (0)
|
|
# w: wall (0)
|
|
|
|
# regular expressions
|
|
tileRegex = re.compile(r'([a-z ])([0-9]+|[ ])')
|
|
matrixRegex = re.compile(r'(?:[ \t]*(?:[a-z ](?:[0-9]+|[ ]))+(\n))+')
|
|
|
|
def __init__(self, name, graph, matrix, dimensions):
|
|
self.name = name
|
|
self.openingText = ""
|
|
self.mapGraph = graph
|
|
self.mapMatrix = matrix
|
|
self.dimensions = dimensions
|
|
self.things = {} # int thingID : thing
|
|
self.thingPos = {} # int location : list of int thingIDs
|
|
self.thingNames = {} # str name: list of int thingIDs
|
|
self.playerStart = (1, 1)
|
|
self.description = "The area is completely blank."
|
|
self.floorColors = []
|
|
self.wallColors = []
|
|
self.persistent = []
|
|
self.enterScript = ''
|
|
|
|
@staticmethod
|
|
def __cleanStr(text: str, end = '\n'):
|
|
if text == None:
|
|
return text
|
|
text = text.strip()
|
|
i = 0
|
|
while True:
|
|
i = text.find('\n', i)
|
|
if i == -1:
|
|
break
|
|
j = i+1
|
|
if len(text) > j:
|
|
while text[j] in ' \t':
|
|
j += 1 # just find the first non-space chartacter
|
|
text = text[:i+1] + text[j:]
|
|
i += 1
|
|
else:
|
|
break
|
|
return text.replace('\n', end)
|
|
|
|
@staticmethod
|
|
def convert(infile: str):
|
|
"""Convert an XML map to a YAML one."""
|
|
data = None
|
|
with open(infile, 'r') as f:
|
|
data = f.read()
|
|
info = ET.fromstring(data)
|
|
layout = info.find('layout')
|
|
ret = {}
|
|
if layout == None:
|
|
raise MapError('No layout in {0}.'.format(infile))
|
|
|
|
# "Layout" needs some work before we convert it.
|
|
ret['layout'] = GameMap.__cleanStr(layout.text.strip())
|
|
|
|
# now the rest of the things
|
|
if 'openingText' in info.attrib:
|
|
ret['openingText'] = info.attrib['openingText']
|
|
else:
|
|
raise MapError('No opening text in {0}.'.format(infile))
|
|
if 'playerStart' in info.attrib:
|
|
ps = info.attrib['playerStart'].split(',')
|
|
ret['playerStart'] = (int(ps[0]), int(ps[1]))
|
|
else:
|
|
raise MapError('No player start position in {0}.'.format(infile))
|
|
if info.text != None:
|
|
ret['description'] = GameMap.__cleanStr(info.text, ' ')
|
|
else:
|
|
raise MapError('No description in {0}.'.format(infile))
|
|
|
|
# get map colors
|
|
floorColors = ['#9F7F5F']
|
|
floorColorsStr = info.find('floorColors')
|
|
if floorColorsStr != None:
|
|
floorColors = floorColorsStr.text.lstrip().split()
|
|
if len(floorColors) == 0:
|
|
floorColors.append('#9F7F5F')
|
|
ret['floorColors'] = floorColors
|
|
wallColors = ['#7F3F0F']
|
|
wallColorsStr = info.find('wallColors')
|
|
if wallColorsStr != None:
|
|
wallColors = wallColorsStr.text.lstrip().split()
|
|
if len(wallColors) == 0:
|
|
wallColors.append('#7F3F0F')
|
|
ret['wallColors'] = wallColors
|
|
|
|
# get things
|
|
ret['loadAlways'] = []
|
|
ret['loadOnce'] = []
|
|
for node in info:
|
|
if node.tag == 'loadOnce':
|
|
# Things in the load-once section are only loaded the first
|
|
# time that the map is loaded, and saved in the player's
|
|
# save file.
|
|
for node1 in node:
|
|
if node1.tag == 'door':
|
|
ret['loadOnce'].append(GameMap.__loadDoor(node1))
|
|
elif node1.tag == 'useable':
|
|
ret['loadOnce'].append(GameMap.__loadUseable(node1))
|
|
elif node1.tag == 'item':
|
|
ret['loadOnce'].append(GameMap.__loadItem(node1))
|
|
elif node.tag == 'exit':
|
|
ret['loadAlways'].append(GameMap.__loadExit(None, node, -1)) # weird arguments: there is no actual level
|
|
elif node.tag == 'door':
|
|
ret['loadAlways'].append(GameMap.__loadDoor(node))
|
|
elif node.tag == 'useable':
|
|
ret['loadAlways'].append(GameMap.__loadUseable(node))
|
|
|
|
#start saving
|
|
outfile = infile[:-3] + 'yml'
|
|
yaml = ruamel.yaml.YAML()
|
|
yaml.indent(mapping=4, sequence=4, offset=2)
|
|
yaml.register_class(Item)
|
|
yaml.register_class(Useable)
|
|
yaml.register_class(Door)
|
|
yaml.register_class(MapExit)
|
|
with open(outfile, 'w') as f:
|
|
f.write('%YAML 1.2\n---\n')
|
|
yaml.dump(ret, f)
|
|
|
|
@staticmethod
|
|
def read(infile = None, prevMap = None, preLoaded = False, nextThing = 0):
|
|
"""Read map data and return a Map object. If infile is not provided, then
|
|
it will read from stdin. Otherwise, it should be a valid file name.
|
|
Entering a map through stdin will be obsolete once testing is over."""
|
|
info = None
|
|
tryToRead = True
|
|
yaml = ruamel.yaml.YAML()
|
|
yaml.register_class(Item)
|
|
yaml.register_class(Useable)
|
|
yaml.register_class(NPC)
|
|
yaml.register_class(Door)
|
|
yaml.register_class(MapExit)
|
|
if infile != None:
|
|
try:
|
|
with open(infile, 'r') as f:
|
|
info = yaml.load(f)
|
|
except OSError as e:
|
|
print("The file could not be read.")
|
|
return None, nextThing
|
|
else:
|
|
raise RuntimeError("No file was specified for loading.")
|
|
|
|
# Now what we do with the data
|
|
mat = None
|
|
if 'layout' not in info:
|
|
raise MapError('No layout in {0}.'.format(infile))
|
|
layout = info['layout']
|
|
if layout != None:
|
|
#print(layout.text)
|
|
match = GameMap.matrixRegex.match(layout.lstrip())
|
|
if match == None:
|
|
raise RuntimeError('Map read a file without a map matrix.')
|
|
mat = match.group()
|
|
else:
|
|
raise RuntimeError('Map read a file without a map matrix.')
|
|
|
|
# generate matrix and graph first
|
|
mapMatrix, mapGraph, dimensions = GameMap.parseMatrix(mat)
|
|
level = GameMap(infile, mapGraph, mapMatrix, dimensions)
|
|
|
|
# Now, load other info
|
|
nextThing = GameMap.loadThings(level, info, prevMap, preLoaded, nextThing)
|
|
|
|
return level, nextThing
|
|
|
|
@staticmethod
|
|
def parseMatrix(matrixStr):
|
|
"""Returns a map graph as an adjacency list, as well as the matrix as a
|
|
list of lists of tuples."""
|
|
# Make the matrix first
|
|
mat = [[]]
|
|
x = 0
|
|
y = 0
|
|
l = 0
|
|
while len(matrixStr) > 0:
|
|
tile = GameMap.tileRegex.match(matrixStr)
|
|
if tile != None:
|
|
tileType = tile.group(1)
|
|
tileNum = tile.group(2)
|
|
if tileType == ' ':
|
|
tileType = 'e'
|
|
if tileNum == ' ':
|
|
tileNum = '0'
|
|
mat[l].append((tileType, int(tileNum)))
|
|
#x += 1
|
|
matrixStr = matrixStr[len(tile.group()):]
|
|
elif matrixStr[0] == '\n':
|
|
if x == 0:
|
|
x = len(mat[l])
|
|
elif x != len(mat[l]):
|
|
raise RuntimeError("Map matrix has jagged edges.")
|
|
l += 1
|
|
#x = 0
|
|
mat.append([])
|
|
i = 1
|
|
while i < len(matrixStr) and matrixStr[i] in ' \t\n':
|
|
i += 1
|
|
if i == len(matrixStr):
|
|
matrixStr = ''
|
|
else:
|
|
matrixStr = matrixStr[i:]
|
|
else: # This should happen when it finishes?
|
|
raise RuntimeError("Unexpected token in map matrix: '{0}'".format(matrixStr))
|
|
y = len(mat) - 1
|
|
|
|
# Now for the graph
|
|
numTiles = x * y
|
|
dim = (x, y)
|
|
graph = [[] for j in range(numTiles)]
|
|
passable = ('e', 'd', 'x', 'p', 'i')
|
|
for j in range(y):
|
|
for i in range(x):
|
|
if mat[j][i][0] in passable:
|
|
here = GameMap.__coordsToInt(i, j, x)
|
|
if i > 0 and mat[j][i-1][0] in passable:
|
|
there = GameMap.__coordsToInt(i-1, j, x)
|
|
graph[here].append(there)
|
|
graph[there].append(here)
|
|
if j > 0 and mat[j-1][i][0] in passable:
|
|
there = GameMap.__coordsToInt(i, j-1, x)
|
|
graph[here].append(there)
|
|
graph[there].append(here)
|
|
|
|
return mat, graph, dim
|
|
|
|
@staticmethod
|
|
def loadThings(level, info, prevMap = None, preLoaded = False, nextThing = 0):
|
|
"""load the things from the xml part of the map file."""
|
|
if 'openingText' in info:
|
|
level.openingText = info['openingText']
|
|
if 'playerStart' in info:
|
|
level.playerStart = info['playerStart']
|
|
if 'description' in info:
|
|
level.description = info['description']
|
|
if 'enterScript' in info:
|
|
level.enterScript = info['enterScript']
|
|
|
|
# get map colors
|
|
if 'floorColors' in info:
|
|
level.floorColors = info['floorColors']
|
|
if 'wallColors' in info:
|
|
level.wallColors = info['wallColors']
|
|
if len(level.floorColors) == 0:
|
|
level.floorColors.append('#9F7F5F')
|
|
if len(level.wallColors) == 0:
|
|
level.wallColors.append('#7F3F0F')
|
|
|
|
# get things
|
|
hasKnownEntrance = False
|
|
if 'loadOnce' in info and not preLoaded:
|
|
for thing in info['loadOnce']:
|
|
#print(type(thing))
|
|
nextThing = level.addThing(thing, nextThing, True)
|
|
if 'loadAlways' in info:
|
|
for thing in info['loadAlways']:
|
|
#print(type(thing))
|
|
nextThing = level.addThing(thing, nextThing)
|
|
if ((thing.thingType == 'x' and not hasKnownEntrance) or thing.thingType == 'a') and prevMap == thing.exitid:
|
|
level.playerStart = (thing.x, thing.y)
|
|
hasKnownEntrance = True
|
|
return nextThing
|
|
|
|
# stuff the gameshell itself might use
|
|
|
|
def addThing(self, thing, nextThing = 0, persist = False):
|
|
if thing == None:
|
|
return nextThing
|
|
#if thing.name in self.thingNames: # resolved
|
|
# raise ValueError("Cannot have two objects named {0}.".format(thing.name))
|
|
if thing.thingID == -1: # This is to ensure that we don't double up IDs.
|
|
thing.thingID = nextThing
|
|
nextThing += 1
|
|
# Some things, like containers, have other things as custom values,
|
|
# so they need IDs as well.
|
|
if thing.thingType in 'iuc':
|
|
nextThing = self.addThingRecursive(thing.customValues, nextThing)
|
|
if thing.thingType == 'c':
|
|
for i in thing.inventory:
|
|
i.thingID = nextThing
|
|
nextThing += 1
|
|
pos = self.coordsToInt(thing.x, thing.y)
|
|
if pos not in self.thingPos:
|
|
self.thingPos[pos] = [thing.thingID]
|
|
else:
|
|
self.thingPos[pos].append(thing.thingID)
|
|
if thing.name not in self.thingNames:
|
|
self.thingNames[thing.name] = [thing.thingID]
|
|
else:
|
|
self.thingNames[thing.name].append(thing.thingID)
|
|
self.things[thing.thingID] = thing
|
|
if persist:
|
|
self.persistent.append(thing.thingID)
|
|
return nextThing
|
|
|
|
def addThingRecursive(self, container, nextThing = 0):
|
|
if isinstance(container, Thing):
|
|
container.thingID = nextThing
|
|
return nextThing + 1
|
|
elif isinstance(container, dict):
|
|
for i in container:
|
|
nextThing = self.addThingRecursive(container[i], nextThing)
|
|
return nextThing
|
|
elif isinstance(container, list):
|
|
for i in container:
|
|
nextThing = self.addThingRecursive(i, nextThing)
|
|
return nextThing
|
|
else:
|
|
return nextThing
|
|
|
|
def getThing(self, **kwargs):
|
|
if 'name' in kwargs:
|
|
return self.getThingByName(kwargs['name'])
|
|
elif 'thingID' in kwargs:
|
|
return self.getThingByID(kwargs['thingID'])
|
|
elif 'pos' in kwargs:
|
|
return self.getThingAtPos(kwargs['pos'])
|
|
elif 'coords' in kwargs:
|
|
return self.getThingAtCoords(kwargs['coords'][0], kwargs['coords'][1])
|
|
else:
|
|
raise ValueError('Thing cannot be found by {}.'.format(str(kwargs)))
|
|
|
|
def removeThing(self, **kwargs):
|
|
if 'name' in kwargs:
|
|
return self.removeThingByName(kwargs['name'])
|
|
elif 'thingID' in kwargs:
|
|
return self.removeThingByID(kwargs['thingID'])
|
|
elif 'pos' in kwargs:
|
|
return self.removeThingAtPos(kwargs['pos'])
|
|
elif 'coords' in kwargs:
|
|
return self.removeThingAtCoords(kwargs['coords'][0], kwargs['coords'][1])
|
|
else:
|
|
raise ValueError('Thing cannot be found by {}.'.format(str(kwargs)))
|
|
|
|
def path(self, x1, y1, x2, y2, closeEnough = True):
|
|
startThing = self.getThingAtCoords(x1, y1)
|
|
if not closeEnough:
|
|
if startThing and not startThing.passable:
|
|
return -1, [] # meaning you can't get there
|
|
dist, prev = self.dijkstra(x1, y1, closeEnough)
|
|
endPoint = self.coordsToInt(x2, y2)
|
|
numVertex = self.dimensions[0] * self.dimensions[1]
|
|
if dist[endPoint] < numVertex + 1:
|
|
return dist[endPoint], prev
|
|
else:
|
|
return -1, [] # meaning you can't get there
|
|
|
|
def dijkstra(self, x1, y1, closeEnough = True):
|
|
"""Uses Dijkstra's Algorithm to find the shortest path from (x1, y1) to (x2, y2)
|
|
The closeEnough parameter will create a path that lands beside the source if necessary."""
|
|
# first test to see that the start point is passable
|
|
startThing = self.getThingAtCoords(x1, y1)
|
|
startPoint = self.coordsToInt(x1, y1)
|
|
#endPoint = self.coordsToInt(x2, y2)
|
|
numVertex = self.dimensions[0] * self.dimensions[1]
|
|
dist = [numVertex + 1 for i in range(numVertex)]
|
|
prev = [-1 for i in range(numVertex)]
|
|
dist[startPoint] = 0
|
|
if closeEnough:
|
|
if startThing and not startThing.passable:
|
|
dist[startPoint] = -1
|
|
queue = []
|
|
heapq.heappush(queue, (dist[startPoint], startPoint))
|
|
|
|
while len(queue) > 0:
|
|
u = heapq.heappop(queue)[1]
|
|
for v in self.mapGraph[u]:
|
|
thing = self.getThingAtPos(v)
|
|
if thing and not thing.passable:
|
|
continue
|
|
tempDist = dist[u] + 1
|
|
if tempDist < dist[v]:
|
|
dist[v] = tempDist
|
|
if dist[u] != -1:
|
|
prev[v] = u
|
|
heapq.heappush(queue, (dist[v], v))
|
|
|
|
return dist, prev
|
|
#if dist[endPoint] < numVertex + 1:
|
|
# return dist[endPoint], prev
|
|
#else:
|
|
# return -1, [] # meaning you can't get there
|
|
|
|
def lineOfSight(self, x1, y1, x2, y2):
|
|
Dx = x2 - x1
|
|
Dy = y2 - y1
|
|
y = y1 + 0.5
|
|
x = x1 + 0.5
|
|
lst = []
|
|
if abs(Dx) >= abs(Dy):
|
|
if Dx < 0:
|
|
x = x2 + 0.5
|
|
y = y2 + 0.5
|
|
dy = Dy / Dx
|
|
while(x < max(x2, x1) - 0.5):
|
|
x += 1
|
|
lst.append(self.coordsToInt(_mt.floor(x), _mt.floor(y)))
|
|
if _mt.floor(y) != _mt.floor(y + dy):
|
|
lst.append(self.coordsToInt(_mt.floor(x), _mt.floor(y + dy)))
|
|
y += dy
|
|
elif abs(Dx) < abs(Dy):
|
|
if Dy < 0:
|
|
x = x2 + 0.5
|
|
y = y2 + 0.5
|
|
dx = Dx / Dy
|
|
while(y < max(y2, y1) - 0.5):
|
|
y += 1
|
|
lst.append(self.coordsToInt(_mt.floor(x), _mt.floor(y)))
|
|
if _mt.floor(x) != _mt.floor(x + dx):
|
|
lst.append(self.coordsToInt(_mt.floor(x + dx), _mt.floor(y)))
|
|
x += dx
|
|
|
|
# Here is where we actually check:
|
|
for space in lst:
|
|
if not self.isPassable(space):
|
|
return False
|
|
return True
|
|
|
|
def isPassable(self, x, y = -1):
|
|
pos = x
|
|
if y == -1:
|
|
x, y = self.intToCoords(x)
|
|
else:
|
|
pos = self.coordsToInt(x, y)
|
|
if self.mapMatrix[y][x][0] == 'w':
|
|
return False
|
|
thingsInSpace = self.getThingsAtPos(pos)
|
|
for thing in thingsInSpace:
|
|
if not thing.passable:
|
|
return False
|
|
return True
|
|
|
|
@staticmethod
|
|
def __coordsToInt(x, y, width):
|
|
return x + y * width
|
|
|
|
def coordsToInt(self, x: int, y: int, width = -1):
|
|
if width < 0:
|
|
return x + y * self.dimensions[0]
|
|
else:
|
|
return x + y * width
|
|
|
|
def intToCoords(self, pos: int):
|
|
return pos % self.dimensions[0], int(pos / self.dimensions[0])
|
|
|
|
def getThingAtCoords(self, x, y):
|
|
return self.getThingAtPos(self.coordsToInt(x, y))
|
|
|
|
def getThingsAtCoords(self, x, y):
|
|
return self.getThingsAtPos(self.coordsToInt(x, y))
|
|
|
|
def getThingAtPos(self, pos):
|
|
if pos in self.thingPos:
|
|
return self.things[self.thingPos[pos][0]]
|
|
else:
|
|
return None
|
|
|
|
def getThingsAtPos(self, pos):
|
|
if pos in self.thingPos:
|
|
ret = []
|
|
for i in self.thingPos[pos]:
|
|
ret.append(self.things[i])
|
|
return ret
|
|
else:
|
|
return []
|
|
|
|
def getThingByName(self, name):
|
|
if name in self.thingNames:
|
|
return self.things[self.thingNames[name][0]]
|
|
else:
|
|
return None
|
|
|
|
def getThingsByName(self, name):
|
|
if name in self.thingNames:
|
|
ret = []
|
|
for i in self.thingNames[name]:
|
|
ret.append(self.things[i])
|
|
return ret
|
|
else:
|
|
return []
|
|
|
|
def getThingByID(self, thingID):
|
|
if thingID in self.things:
|
|
return self.things[thingID]
|
|
else:
|
|
return None
|
|
|
|
def removeThingByThing(self, thing):
|
|
if thing != None:
|
|
oldPos = self.coordsToInt(thing.x, thing.y)
|
|
if oldPos in self.thingPos:
|
|
self.thingPos[oldPos].remove(thing.thingID)
|
|
if len(self.thingPos[oldPos]) == 0:
|
|
del self.thingPos[oldPos]
|
|
oldName = thing.name
|
|
if oldName in self.thingNames:
|
|
self.thingNames[oldName].remove(thing.thingID)
|
|
if len(self.thingNames[oldName]) == 0:
|
|
del self.thingNames[oldName]
|
|
if thing.thingID in self.persistent:
|
|
self.persistent.remove(thing.thingID)
|
|
del self.things[thing.thingID]
|
|
return thing
|
|
else:
|
|
return None
|
|
|
|
def removeThingAtCoords(self, x, y):
|
|
return self.removeThingAtPos(self.coordsToInt(x, y))
|
|
|
|
def removeThingsAtCoords(self, x, y):
|
|
return self.removeThingsAtPos(self.coordsToInt(x, y))
|
|
|
|
def removeThingAtPos(self, pos):
|
|
if pos in self.thingPos:
|
|
return self.removeThingByThing(self.getThingAtPos(pos))
|
|
else:
|
|
return None
|
|
|
|
def removeThingsAtPos(self, pos):
|
|
if pos in self.thingPos:
|
|
ret = []
|
|
for i in self.thingPos[pos]:
|
|
ret.append(self.removeThingByThing(self.things[i]))
|
|
return ret
|
|
else:
|
|
return []
|
|
|
|
def removeThingByName(self, name):
|
|
if name in self.thingNames:
|
|
return self.removeThingByThing(self.getThingByName(name))
|
|
else:
|
|
return None
|
|
|
|
def removeThingsByName(self, name):
|
|
if name in self.thingNames:
|
|
ret = []
|
|
for i in self.thingNames[name]:
|
|
ret.append(self.removeThingByThing(self.things[i]))
|
|
return ret
|
|
else:
|
|
return []
|
|
|
|
def removeThingByID(self, thingID):
|
|
if thingID in self.things:
|
|
return self.removeThingByThing(self.things[thingID])
|
|
else:
|
|
return None
|
|
|
|
def moveThing(self, thing, x, y = -1):
|
|
newPos = x
|
|
if y != -1:
|
|
newPos = self.coordsToInt(x, y)
|
|
else:
|
|
x, y = self.intToCoords(x)
|
|
if thing:
|
|
oldPos = self.coordsToInt(thing.x, thing.y)
|
|
if oldPos in self.thingPos:
|
|
self.thingPos[oldPos].remove(name)
|
|
if len(self.thingPos[oldPos]) == 0:
|
|
del self.thingPos[oldPos]
|
|
if newPos not in self.thingPos:
|
|
self.thingPos[newPos] = [name]
|
|
else:
|
|
self.thingPos[newPos].append(name)
|
|
relPlayerx, relPlayery = thing.playerx - thing.x, thing.playery - thing.y
|
|
thing.x, thing.y = x, y
|
|
thing.playerx, thing.playery = thing.x + relPlayerx, thing.y + relPlayery
|
|
else:
|
|
raise RuntimeError("There is nothing to move.".format(name))
|
|
|