389 lines
14 KiB
Python
389 lines
14 KiB
Python
# Asci (1.7.1)
|
|
|
|
class Asci:
|
|
def __init__(self, maps, events_mapping, keys_mapping, behaviors=None, screen_width=21, screen_height=6):
|
|
# Load maps
|
|
self.maps = [Map(*i) for i in maps]
|
|
|
|
# Custom functions
|
|
self._legend = list(events_mapping.keys())
|
|
self._game_events_mapping = [events_mapping[i] for i in self._legend]
|
|
self._game_keys_mapping = {key: keys_mapping[key] for key in keys_mapping if not key in (1, 2, 3, 5)}
|
|
|
|
# Custom entities behavior
|
|
self._behaviors = {"stand by": stand_by, "follow": follow, "walk": walk}
|
|
if behaviors:
|
|
for i in behaviors: self._behaviors[i] = behaviors[i]
|
|
|
|
# Screen initialisation
|
|
self.screen = Screen(screen_width, screen_height)
|
|
self.current_map = None
|
|
self.visible_entities = []
|
|
|
|
def _looked_case(self, direction):
|
|
if direction == 1: # Left
|
|
return self.data[2] - 1, self.data[3]
|
|
|
|
elif direction == 3: # Right
|
|
return self.data[2] + 1, self.data[3]
|
|
|
|
elif direction == 5: # Up
|
|
return self.data[2], self.data[3] - 1
|
|
|
|
elif direction == 2: # Down
|
|
return self.data[2], self.data[3] + 1
|
|
|
|
return self.data[2], self.data[3]
|
|
|
|
def _cell_test(self, direction):
|
|
if direction == 1:
|
|
if self.data[2] - 1 < 0: return -1
|
|
else: cell = self.screen.get_cell(self.data[2] - 1, self.data[3])
|
|
if direction == 3:
|
|
if self.data[2] + 1 >= self.map_width: return -1
|
|
else: cell = self.screen.get_cell(self.data[2] + 1, self.data[3])
|
|
if direction == 5:
|
|
if self.data[3] - 1 < 0: return -1
|
|
else: cell = self.screen.get_cell(self.data[2], self.data[3] - 1)
|
|
if direction == 2:
|
|
if self.data[3] + 1 >= self.map_height: return -1
|
|
else: cell = self.screen.get_cell(self.data[2], self.data[3] + 1)
|
|
|
|
cell_patterns = self._legend
|
|
for pattern_index in range(len(cell_patterns)):
|
|
if cell in cell_patterns[pattern_index]: return pattern_index
|
|
|
|
return -1
|
|
|
|
def _keyboard(self, key, interaction=True):
|
|
# Interaction while moving
|
|
if key in (1, 3, 5, 2):
|
|
cell_test = self._cell_test(key)
|
|
|
|
# Move
|
|
if cell_test == len(self._legend) - 1:
|
|
if key == 1: self.data[2] -= 1
|
|
if key == 3: self.data[2] += 1
|
|
if key == 5: self.data[3] -= 1
|
|
if key == 2: self.data[3] += 1
|
|
|
|
# Change map
|
|
elif interaction and cell_test == len(self._legend) - 2:
|
|
new_map, self.data[2], self.data[3] = self._get_map(key)
|
|
self._change_map(new_map)
|
|
|
|
# Interaction
|
|
elif interaction and cell_test >= 0: self._interaction(key, cell_test)
|
|
|
|
# Custom functions
|
|
elif key in self._game_keys_mapping:
|
|
self.screen.clear()
|
|
self._game_keys_mapping[key](self.data, self.stat)
|
|
|
|
def _get_map(self, direction):
|
|
current_coords = self._looked_case(direction)
|
|
|
|
for coords in self.current_map.coords:
|
|
if coords[:2] == current_coords:
|
|
return coords[2], coords[3], coords[4]
|
|
|
|
return self.data[1], self.data[2], self.data[3]
|
|
|
|
def _change_map(self, new_map):
|
|
# Update entities
|
|
if self.current_map:
|
|
for i in range(len(self.current_map.entities)):
|
|
entity = self.current_map.entities[i]
|
|
if entity.behavior == "follow":
|
|
self.maps[new_map].entities.append(entity)
|
|
self.maps[self.data[1]].entities.pop(i)
|
|
|
|
# Update current map
|
|
self.data[1] = new_map
|
|
self.current_map = self.maps[self.data[1]]
|
|
|
|
# Update screen configuration
|
|
self.screen.set_world(self.current_map.map_data)
|
|
self.map_width, self.map_height = self.screen.get_map_size()
|
|
self._get_visible_entities()
|
|
|
|
def _interaction(self, direction, cell_content):
|
|
x, y = self._looked_case(direction)
|
|
data_copy = [self.data[0], self.data[1], x, y, self.data[4]]
|
|
|
|
# Get the event
|
|
entities = {entity.entity_id: entity for entity in self.current_map.entities}
|
|
event = self._game_events_mapping[cell_content](data_copy, self.stat, entities, self._get_entity_id(x, y))
|
|
if type(event) == tuple:
|
|
quest, event = event
|
|
else:
|
|
quest = "main"
|
|
|
|
# data modification
|
|
self.data[0] = data_copy[0]
|
|
if self.data[1] != data_copy[1]:
|
|
self._change_map(data_copy[1])
|
|
|
|
if data_copy[2] != x: self.data[2] = data_copy[2]
|
|
if data_copy[3] != y: self.data[3] = data_copy[3]
|
|
|
|
if not event: return
|
|
event = read_event(self.data, event, quest)
|
|
|
|
# XP and stat modification
|
|
self.data[0][quest] += event.xp
|
|
for index, value in event.stat:
|
|
self.stat[index] += value
|
|
|
|
# Display and get answer
|
|
if event.text:
|
|
answer_selected = convert(self.screen.display_text(event.text), True)
|
|
if event.answer and (0 < answer_selected <= event.answer):
|
|
self.data[0][quest] += answer_selected
|
|
self._interaction(direction, cell_content)
|
|
|
|
# Entities gestion
|
|
def _get_visible_entities(self):
|
|
self.visible_entities = {}
|
|
for entity in self.current_map.entities:
|
|
if (0 <= entity.pos_x - self.data[2] + 10 < self.screen.screen_width) and (0 <= entity.pos_y - self.data[3] + 3 < self.screen.screen_height):
|
|
self.visible_entities[entity.entity_id] = entity
|
|
|
|
def _get_entity_id(self, x, y):
|
|
for entity_id in self.visible_entities:
|
|
entity = self.visible_entities[entity_id]
|
|
if entity.pos_x == x and entity.pos_y == y:
|
|
return entity_id
|
|
|
|
def _run_entities_behaviors(self):
|
|
for entity in self.current_map.entities:
|
|
data_copy = get_data_copy(self.data)
|
|
self._behaviors[entity.behavior](entity, data_copy, self.stat, self.screen, self.walkable)
|
|
self._get_visible_entities()
|
|
|
|
# Mainloop
|
|
def mainloop(self, end_game, stat=None, data=None, routine=None, player="@", door="^", walkable=" ", exit_key=9, multi_move="."):
|
|
if exit_key in self._game_keys_mapping:
|
|
raise ValueError("'{}' is already assigned to a function.".format(exit_key))
|
|
|
|
# Load save ; data = [XP, map_id, x, y]
|
|
if not stat or type(stat) != list: self.stat = [100]
|
|
else: self.stat = stat
|
|
|
|
if not data: self.data = [{"main": 0}, 0, 0, 0, 0]
|
|
else: self.data = [data[0], data[1], data[2], data[3], 0]
|
|
|
|
# Configuration
|
|
self.walkable = walkable
|
|
self._legend.append(door)
|
|
self._legend.append(walkable)
|
|
self._change_map(data[1])
|
|
self.screen.load_data(self.data)
|
|
|
|
key = 0
|
|
|
|
while key != exit_key and self.stat[0] > 0 and self.data[0]["main"] < end_game:
|
|
# Update the map
|
|
self.screen.set_screen(self.data[2], self.data[3])
|
|
|
|
# Compute the player's and entities' positions
|
|
self.screen.set_cell(self.data[2], self.data[3], player)
|
|
self._run_entities_behaviors()
|
|
for entity in self.visible_entities.values():
|
|
self.screen.set_cell(entity.pos_x, entity.pos_y, entity.symbol)
|
|
|
|
# Display map and get the key
|
|
key = convert(self.screen.display())
|
|
|
|
if not key: key = self.data[4]
|
|
else: self.data[4] = key
|
|
|
|
if type(key) == str and key[0] == multi_move:
|
|
for i in list(key[1:]):
|
|
self._keyboard(convert(i), False)
|
|
self.data[4] = convert(key[-1])
|
|
else:
|
|
self._keyboard(key)
|
|
|
|
# Launching the game routine
|
|
if routine:
|
|
data_copy = get_data_copy(self.data)
|
|
routine(data_copy, self.stat)
|
|
|
|
if self.stat[0] <= 0: self.stat[0] = 100
|
|
return self.stat, self.data[:-1]
|
|
|
|
|
|
# Classes used by Asci
|
|
class Screen:
|
|
def __init__(self, screen_width=21, screen_height=6):
|
|
# Screen configuration
|
|
self.screen_width = screen_width
|
|
self.screen_height = screen_height
|
|
self._on_screen = [[" " for _ in range(screen_width)] for _ in range(screen_height)]
|
|
self._asci_data = []
|
|
|
|
def load_data(self, data):
|
|
self._asci_data = data
|
|
|
|
def get_map_size(self):
|
|
return self.map_width, self.map_height
|
|
|
|
def set_world(self, world):
|
|
self._world = [[char for char in line] for line in world.split("\n")[1:]]
|
|
self.map_width = max([len(line) for line in self._world])
|
|
self.map_height = len(self._world)
|
|
|
|
def set_screen(self, x, y):
|
|
x -= 10 ; y -= 3
|
|
for x_map in range(x, x + self.screen_width):
|
|
for y_map in range(y, y + self.screen_height):
|
|
self._on_screen[y_map - y][x_map - x] = " "
|
|
if 0 <= x_map < self.map_width and 0 <= y_map < self.map_height:
|
|
try: self._on_screen[y_map - y][x_map - x] = self._world[y_map][x_map]
|
|
except: pass
|
|
|
|
def display(self, return_input=True):
|
|
for line in self._on_screen:
|
|
print("".join(line))
|
|
|
|
if return_input: return input(">")
|
|
|
|
def clear(self):
|
|
print("\n" * self.screen_height)
|
|
|
|
def display_text(self, string):
|
|
paragraphs = [i for i in text_formater(string) if i]
|
|
nb_par = len(paragraphs)
|
|
for index in range(nb_par):
|
|
self.clear()
|
|
print(paragraphs[index])
|
|
if index + 1 == nb_par: return input(">")
|
|
else: input()
|
|
|
|
def set_cell(self, x, y, value):
|
|
x = x - (self._asci_data[2] - 10)
|
|
y = y - (self._asci_data[3] - 3)
|
|
self._on_screen[y][x] = value
|
|
|
|
def get_cell(self, x, y):
|
|
x = x - (self._asci_data[2] - 10)
|
|
y = y - (self._asci_data[3] - 3)
|
|
if 0 <= x < self.screen_width and 0 <= y <= self.screen_height:
|
|
return self._on_screen[y][x]
|
|
else: return " "
|
|
|
|
class Event:
|
|
def __init__(self, xp, text, answer=0, *stat):
|
|
self.xp = xp
|
|
self.text = text
|
|
self.answer = answer
|
|
self.stat = stat
|
|
|
|
|
|
class Map:
|
|
def __init__(self, map_data, entities, *coords):
|
|
self.map_data = map_data
|
|
if entities: self.entities = [Entity(*i) for i in entities]
|
|
else: self.entities = []
|
|
self.coords = coords
|
|
|
|
class Entity:
|
|
def __init__(self, entity_id, symbol, x, y, behavior, *args):
|
|
self.entity_id = entity_id
|
|
self.symbol = symbol
|
|
self.pos_x = x
|
|
self.pos_y = y
|
|
self.behavior = behavior
|
|
self.args = list(args)
|
|
|
|
def change_behavior(self, new_behavior):
|
|
self.behavior = new_behavior
|
|
|
|
|
|
# Functions used by Asci
|
|
def convert(string, force_int=False):
|
|
try: return int(string)
|
|
except:
|
|
if force_int: return 0
|
|
else: return string
|
|
|
|
|
|
def text_formater(string, screen_width=21, screen_height=6):
|
|
|
|
def line_formater(string, screen_width):
|
|
if len(string) <= screen_width: return string
|
|
|
|
stop_index = screen_width
|
|
while stop_index > 0 and not string[stop_index].isspace(): stop_index -= 1
|
|
if not stop_index: stop_index = screen_width
|
|
|
|
return string[:stop_index].strip() + "\n" + line_formater(string[stop_index:].strip(), screen_width)
|
|
|
|
def paragraph_formater(lines, screen_height):
|
|
if len(lines) < screen_height: return "\n".join(lines)
|
|
|
|
return "\n".join(lines[:screen_height]) + "\n\n" + paragraph_formater(lines[screen_height:], screen_height)
|
|
|
|
lines = []
|
|
for line in string.split("\n"):
|
|
for formated_line in line_formater(line, screen_width).split("\n"):
|
|
lines.append(formated_line)
|
|
|
|
return paragraph_formater(lines, screen_height).split("\n\n")
|
|
|
|
|
|
def read_event(data, event, quest):
|
|
if not quest in data[0]:
|
|
data[0][quest] = 0
|
|
|
|
if type(event) == dict:
|
|
if data[0][quest] in event: event = event[data[0][quest]]
|
|
else: event = event["base"]
|
|
|
|
if type(event) != list:
|
|
raise TypeError("event is of type {} instead of list".format(type(event)))
|
|
|
|
return Event(*event)
|
|
|
|
|
|
def get_data_copy(data):
|
|
return [data[0], data[1], data[2], data[3], data[4]]
|
|
|
|
|
|
# Extra functions
|
|
def print_text(text, min_value=0, max_value=0, default_value=0):
|
|
paragraphs = [i for i in text_formater(text) if i]
|
|
nb = len(paragraphs)
|
|
for index in range(nb):
|
|
print("\n" * 7)
|
|
print(paragraphs[index])
|
|
|
|
if index + 1 == nb and (min_value or max_value or default_value) and min_value <= max_value:
|
|
result = input(">")
|
|
try: result = int(result)
|
|
except: result = default_value
|
|
if not (min_value <= result <= max_value): result = default_value
|
|
|
|
return result
|
|
|
|
else: input()
|
|
|
|
|
|
def stand_by(entity, data, stat, screen, walkable):
|
|
pass
|
|
|
|
def follow(entity, data, stat, screen, walkable):
|
|
if data[4] == 1 and screen.get_cell(data[2] + 1, data[3]) in walkable: entity.pos_x, entity.pos_y = data[2] + 1, data[3]
|
|
elif data[4] == 2 and screen.get_cell(data[2], data[3] - 1) in walkable: entity.pos_x, entity.pos_y = data[2], data[3] - 1
|
|
elif data[4] == 3 and screen.get_cell(data[2] - 1, data[3]) in walkable: entity.pos_x, entity.pos_y = data[2] - 1, data[3]
|
|
elif data[4] == 5 and screen.get_cell(data[2], data[3] + 1) in walkable: entity.pos_x, entity.pos_y = data[2], data[3] + 1
|
|
|
|
def walk(entity, data, stat, screen, walkable):
|
|
frame = (entity.args[0] + 1) % len(entity.args[1])
|
|
new_x, new_y = entity.args[1][frame]
|
|
print(new_x, new_y)
|
|
if screen.get_cell(new_x, new_y) in walkable:
|
|
entity.pos_x, entity.pos_y = new_x, new_y
|
|
entity.args[0] = frame
|