Initial commit

loon/mqtt/handlers/change_password_request.py

@@ -0,0 +1,35 @@
+import json
+
+from sqlmodel import Session, select
+
+from loon.web.db import engine
+from loon.web.users.models import User
+from loon.web.utils.password import hash_password
+
+
+async def change_password_handler(client, userdata, msg):
+    data = json.loads(msg.payload.decode())
+
+    if msg.topic != "loon/register/change_password":
+        return
+
+    uuid = data["uuid"]
+    password = data["password"]
+
+    with Session(engine) as session:
+        statement = select(User).where(User.uuid == uuid)
+        user = session.exec(statement).first()
+
+    if user is None:
+        client.publish(f"loon/register/{uuid}/response",
+                       json.dumps({"success": False, "error": "The user is not registered!"}))
+        return
+
+    with Session(engine) as session:
+        user = session.exec(
+            select(User).where(User.uuid == uuid)
+        ).first()
+        user.password = hash_password(password)
+        session.commit()
+
+    client.publish(f"loon/register/{uuid}/response", json.dumps({"success": True, "error": None}))

loon/mqtt/handlers/marquee.py

@@ -0,0 +1,105 @@
+import json
+import random
+
+from loon.web.users.state import user_threads
+
+PLAYER_EVENT_SUFFIXES = ("died", "joined", "left")
+
+DEATH_BY_DAMAGE = {
+    "fall": (
+        "{username} fell from a high place",
+        "{username} forgot to tie their shoes",
+    ),
+    "fire": (
+        "{username} forgot fire burns",
+        "{username} was engulfed in flames",
+    ),
+    "drown": (
+        "{username} drowned",
+    ),
+    "blast": (
+        "{username} blew up",
+    ),
+    "combat": (
+        "{username} was slain",
+        "{username} was pummeled to death",
+    ),
+    "generic": (
+        "{username} died",
+        "{username} withered away",
+    ),
+}
+
+DEATH_BY_KILLER = {
+    "fall": (
+        "{username} was doomed to fall by {killer}",
+    ),
+    "fire": (
+        "{username} walked into fire whilst fighting {killer}",
+    ),
+    "drown": (
+        "{username} drowned whilst trying to escape {killer}",
+    ),
+    "blast": (
+        "{username} was blown up by {killer}",
+    ),
+    "combat": (
+        "{username} was slain by {killer}",
+        "{username} was killed by {killer}",
+        "{username} was slain by {killer} using magic",
+        "{username} got finished off by {killer}",
+    ),
+    "generic": (
+        "{username} was slain by {killer}",
+        "{username} was killed by {killer}",
+    ),
+}
+
+DEATH_BY_KILLER_DEFAULT = DEATH_BY_KILLER["combat"]
+
+
+def get_random(templates, **kwargs):
+    return random.choice(templates).format(**kwargs)
+
+
+async def marquee_handler(client, userdata, msg):
+    prefix = "loon/player/"
+
+    if not msg.topic.startswith(prefix):
+        return
+
+    rest = msg.topic[len(prefix):]
+    _, _, subtopic = rest.partition("/")
+
+    if subtopic not in PLAYER_EVENT_SUFFIXES:
+        return
+
+    try:
+        data = json.loads(msg.payload.decode())
+    except json.JSONDecodeError:
+        return
+
+    username = data["player"]["username"]
+
+    if subtopic == "died":
+        killer = data.get("killer")
+        damage_type = data.get("damageType")
+
+        if killer:
+            templates = DEATH_BY_KILLER.get(damage_type, DEATH_BY_KILLER_DEFAULT)
+            message = get_random(templates, username=username, killer=killer)
+        elif damage_type in DEATH_BY_DAMAGE:
+            message = get_random(DEATH_BY_DAMAGE[damage_type], username=username)
+        elif damage_type:
+            message = f"{username} died of {damage_type}"
+        else:
+            message = f"{username} died"
+    elif subtopic == "joined":
+        message = f"{username} joined the game"
+    else:
+        message = f"{username} left the game"
+
+    envelope = json.dumps({"topic": "server/marquee", "payload": {"message": message}})
+
+    for queue in list(user_threads.values()):
+        await queue.put(envelope)

loon/mqtt/handlers/player.py

@@ -0,0 +1,19 @@
+import json
+
+from loon.web.users.state import user_threads
+
+
+async def player_handler(client, userdata, msg):
+    data = json.loads(msg.payload.decode())
+
+    prefix = "loon/player/"
+
+    if not msg.topic.startswith(prefix):
+        return
+
+    rest = msg.topic[len(prefix):]
+    player_uuid, _, subtopic = rest.partition("/")
+
+    queue = user_threads.get(player_uuid)
+    if queue is not None:
+        await queue.put(json.dumps({"topic": subtopic, "payload": data}))

loon/mqtt/handlers/register_request.py

@@ -0,0 +1,34 @@
+import json
+
+from sqlmodel import Session, select
+
+from loon.web.db import engine
+from loon.web.users.models import User
+from loon.web.utils.password import hash_password
+
+
+async def register_request_handler(client, userdata, msg):
+    data = json.loads(msg.payload.decode())
+
+    if msg.topic != "loon/register/request":
+        return
+
+    uuid = data["uuid"]
+    password = data["password"]
+    internal_username = data["internalUsername"]
+
+    with Session(engine) as session:
+        statement = select(User).where(User.uuid == uuid)
+        user = session.exec(statement).first()
+
+    if user is not None:
+        client.publish(f"loon/register/{uuid}/response",
+                       json.dumps({"success": False, "error": "The user is already registered!"}))
+        return
+
+    with Session(engine) as session:
+        user = User(uuid=uuid, password=hash_password(password), internal_username=internal_username, admin=False)
+        session.add(user)
+        session.commit()
+
+    client.publish(f"loon/register/{uuid}/response", json.dumps({"success": True, "error": None}))

loon/mqtt/handlers/server.py

@@ -0,0 +1,18 @@
+import json
+
+from loon.web.users.state import user_threads
+
+
+async def server_handler(client, userdata, msg):
+    if msg.topic != "loon/server/info":
+        return
+
+    try:
+        data = json.loads(msg.payload.decode())
+    except json.JSONDecodeError:
+        return
+
+    envelope = json.dumps({"topic": "server/info", "payload": data})
+
+    for queue in list(user_threads.values()):
+        await queue.put(envelope)

loon/mqtt/handlers/world.py

@@ -0,0 +1,34 @@
+import json
+import re
+
+import redis
+
+from config import settings
+from loon.redis.chunk import set_chunk_cache
+from loon.web.users.state import user_threads
+
+
+async def world_handler(client, userdata, msg):
+    chunk_topic = re.compile(r"^loon/world/chunk/(-?\d+)/(-?\d+)$")
+
+    match = chunk_topic.match(msg.topic)
+
+    if not match:
+        return
+
+    try:
+        data = json.loads(msg.payload.decode())
+    except json.JSONDecodeError:
+        return
+
+    x, z = match.group(1), match.group(2)
+    envelope = json.dumps({"topic": f"world/chunk/{x}/{z}", "payload": data})
+
+    if settings.redis.enabled:
+        try:
+            set_chunk_cache(int(x), int(z), data)
+        except redis.RedisError:
+            pass
+
+    for queue in list(user_threads.values()):
+        await queue.put(envelope)