initial commit backend

chat/chat_commands.py

@@ -0,0 +1,79 @@
+import chat.dice as dice
+import chat.response as response
+from chat.command_exception import CommandException
+import re
+
+
+class CommandHandler:
+    def __init__(self):
+        self.commands = {
+            '/roll': self.custom_roll,
+            '/r': self.custom_roll,
+            '/whisper': self.whisper,
+            '/w': self.whisper
+        }
+        self.skill_map = {'Tera': {'Akrobatik': 25,
+                                   'Arkane Kunde': 10}
+                          }
+
+    def handle(self, char, content):
+        message = content.strip('\n')
+        if message[0] == '.':
+            return self.skill_roll(char, message)
+        else:
+            message = message.split(' ', 1)
+            if (len(message) > 1) and (message[0] in self.commands):
+                func = self.commands[message[0]]
+                r = func(char, message)
+                return r
+            return response.build_public_message(char, content)
+
+    def custom_roll(self, char, message):
+        pattern = '(?P<dice_num>\d+)(?:d|w)(?P<dice_val>\d+)(?P<maths>(?:(?:\+|\-)\d+)*)'
+        command = re.sub('\s+', '', message[1])
+
+        match = re.match(pattern, command)
+        if match is None:
+            return response.build_system_message(char,
+                                                 'Ungültige Formatierung des Befehls: {}'.format(' '.join(message)))
+
+        eyes, result = dice.custom_roll(int(match.group('dice_num')),
+                                        int(match.group('dice_val')),
+                                        match.group('maths'))
+        return response.build_dice_roll(char, ' '.join(message), eyes, result)
+
+    def skill_roll(self, char, message):
+        print(char)
+        print(message)
+        print(self.skill_map)
+        if char not in self.skill_map:
+            return response.build_system_message(char, 'Ungültiger Charakter: {}'.format(char))
+
+        pattern = '(?P<skill>[a-zA-ZäöüÄÖÜß .&]+)(?P<maths>(?:\s*(?:\+|\-)\s*\d+)*)(?P<type>[nrs]?)'
+        match = re.match(pattern, message)
+        if match is None:
+            return response.build_system_message(char,
+                                                 'Unültige Formatierung des Befehls: {}'.format(message))
+
+        skills = self.skill_map[char]
+        if match.group('skill')[1:] not in skills:
+            return response.build_system_message(char,
+                                                 '{} hat die Fertigkeit {} nicht.'.format(char, match.group('skill')))
+
+        skill = skills[match.group('skill')[1:]]
+        type_ = match.group('type')
+        if len(type_) == 0 or type_ == 'n':
+            type_ = dice.RollTypes.NORMAL
+        elif type_ == 'r':
+            type_ = dice.RollTypes.RISKY
+        else:
+            type_ = dice.RollTypes.SAFE
+        eyes, result = dice.skill_roll(skill,
+                                       match.group('maths'),
+                                       type_)
+        print(eyes, result)
+        return response.build_dice_roll(char, message, eyes, result)
+
+    def whisper(self, char, message):
+        recipient, message = message.split(' ', 1)
+        return response.build_private_message(char, message, recipient)

chat/command_exception.py

@@ -0,0 +1,3 @@
+class CommandException(Exception):
+    def __init__(self, *args):
+        super().__init__(*args)

chat/dice.py

@@ -0,0 +1,47 @@
+from enum import auto, Enum
+import random
+
+
+class RollTypes(Enum):
+    NORMAL = auto()
+    RISKY = auto()
+    SAFE = auto()
+
+
+def skill_roll(skill, modifiers, type_=RollTypes.NORMAL):
+    eyes, result = roll_dice(type_)
+    result += skill
+    if len(modifiers) > 0:
+        result += eval(modifiers)
+
+    return eyes, result
+
+
+def custom_roll(n, eyes, modifiers=None):
+    eyes = n_random_eyes(n, eyes)
+    result = sum(eyes)
+
+    if len(modifiers) > 0:
+        result += eval(modifiers)
+
+    return eyes, result
+
+
+def roll_dice(type_):
+    if type_ is RollTypes.NORMAL:
+        eyes = n_random_eyes(2)
+        result = sum(eyes)
+    elif type_ is RollTypes.RISKY:
+        eyes = n_random_eyes(4)
+        eyes.sort(reverse=True)
+        result = sum(eyes[:2])
+    else:
+        eyes = n_random_eyes(2)
+        result = max(eyes)
+    return eyes, result
+
+
+def n_random_eyes(n, eyes=10):
+    return [random.randint(1, eyes) for _ in range(n)]
+
+

chat/response.py

@@ -0,0 +1,67 @@
+from abc import ABC
+from dataclasses import dataclass
+from events import Events
+
+
+@dataclass
+class Response(ABC):
+    sender: str
+    event: Events
+
+    def to_json(self) -> dict:
+        d = self.__dict__
+        d.pop('event')
+        return d
+
+
+@dataclass
+class NewCharacter(Response):
+    character: dict
+
+
+@dataclass
+class RemoveActor(Response):
+    message: str
+    name: str
+
+
+@dataclass
+class PublicMessage(Response):
+    message: str
+
+
+@dataclass
+class PrivateMessage(Response):
+    message: str
+    recipient: str
+
+
+@dataclass
+class DiceRoll(Response):
+    message: str
+    dice: list
+    result: int
+
+
+def build_dice_roll(sender, message, dice, result):
+    return DiceRoll(sender, Events.DICE_ROLL, message, dice, result)
+
+
+def build_new_character(sender, char_dict):
+    return NewCharacter(sender, Events.NEW_CHARACTER, char_dict)
+
+
+def build_remove_actor(sender, message, name):
+    return RemoveActor(sender, Events.REMOVE_ACTOR, message, name)
+
+
+def build_private_message(sender, message, recipient):
+    return PrivateMessage(sender, Events.PRIVATE_CHAT, message, recipient)
+
+
+def build_public_message(sender, message):
+    return PublicMessage(sender, Events.PUBLIC_CHAT, message)
+
+
+def build_system_message(user, message):
+    return PrivateMessage('System', Events.SYSTEM_MESSAGE, message, user)