GH-16 support for uploading custom levels

Author: gyorokpeter

README.md

@@ -16,6 +16,7 @@ This project uses Python <b>3.7</b> and the following dependencies:
 - AutoBahn
 - Emoji
 - ConfigParser
+- jsonschema
 
 <b>If you are on Windows, the module <u>pypiwin32</u> may also be required.</b> 
 

levelSchema.json

@@ -0,0 +1,78 @@
+{ "type" : "object",
+  "properties" : {
+    "type" : {"type" : "string", "pattern" : "^game$"},
+    "resource" : {
+        "type" : "array",
+        "items" : {
+            "type" : "object",
+            "properties" : {
+                "id" : {"type":"string", "minLength" : 1},
+                "src" : {"type":"string", "minLength" : 1}
+            },
+            "required" : ["id", "src"]
+        }
+    },
+    "initial" : { "type" : "integer" },
+    "world" : {
+        "type" : "array",
+        "minItems" : 1,
+        "items" : {
+            "type" : "object",
+            "properties" : {
+                "id" : { "type" : "integer" },
+                "name" : { "type" : "string", "minLength" : 1},
+                "initial" : { "type" : "integer" },
+                "zone" : {
+                    "type" : "array",
+                    "minItems" : 1,
+                    "items" : {
+                        "type": "object",
+                        "properties" : {
+                            "id" : { "type" : "integer" },
+                            "initial" : { "type" : "integer" },
+                            "color" : { "type" : "string", "pattern" : "#[0-9a-fA-F]{6}" },
+                            "music" : { "type" : "string", "minLength" : 1},
+                            "data" : {
+                                "type" : "array",
+                                "minItems" : 1,
+                                "items" : {
+                                    "type" : "array",
+                                    "minItems" : 1,
+                                    "items" : {"type" : "integer"}
+                                }
+                            },
+                            "obj" : {
+                                "type" : "array",
+                                "items" : {
+                                    "type" : "object",
+                                    "properties" : {
+                                        "type" : {"type" : "integer"},
+                                        "pos" : {"type" : "integer"},
+                                        "param" : {"type" : "array"}
+                                    },
+                                    "required" : ["type", "pos", "param"]
+                                }
+                            },
+                            "warp" : {
+                                "type" : "array",
+                                "items" : {
+                                    "type" : "object",
+                                    "properties" : {
+                                        "id" : {"type" : "integer"},
+                                        "pos" : {"type" : "integer"},
+                                        "data" : {"type" : "integer"}
+                                    },
+                                    "required" : ["id", "pos", "data"]
+                                }
+                            }
+                        },
+                        "required" : ["id", "initial", "color", "music", "data", "obj", "warp"]
+                    }
+                }
+            },
+            "required": ["id", "name", "initial", "zone"]
+        }
+    }
+  },
+  "required": ["type", "resource", "initial", "world"]
+}

match.py

@@ -1,11 +1,23 @@
 from twisted.internet import reactor
 from buffer import Buffer
 import random
+import json
+import os
+import jsonschema
+
+autoMatchStartTime = 30
+
+levelJsonSchema = json.loads(open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "levelSchema.json"), "r").read())
+level = json.loads(open("D:\\Projects\\github\\MarioRoyale\\game\\world-1.json").read())
+#level = json.loads(open("D:\\Projects\\github\\MarioRoyale\\game\\lobby.json").read())
+jsonschema.validate(instance=level, schema=levelJsonSchema)
 
 class Match(object):
     def __init__(self, server, roomName, private):
         self.server = server
 
+        self.forceLevel = ""
+        self.customLevelData = ""
         self.world = "lobby"
         self.roomName = roomName
         self.closed = False
@@ -81,7 +93,7 @@ def broadBin(self, code, buff, ignore = None):
 
     def broadLoadWorld(self):
         for player in self.players:
-            player.loadWorld(self.world)
+            player.loadWorld(self.world, self.customLevelData)
 
     def broadStartTimer(self, time):
         self.startTimer = time * 30
@@ -114,12 +126,13 @@ def getPlayersData(self):
         return playersData
 
     def onPlayerReady(self, player):
-        if not self.playing: # Ensure that the game starts even with fewer players
-            try:
-                self.autoStartTimer.cancel()
-            except:
-                pass
-            self.autoStartTimer = reactor.callLater(30, self.start, True)
+        if not self.private:
+            if not self.playing: # Ensure that the game starts even with fewer players
+                try:
+                    self.autoStartTimer.cancel()
+                except:
+                    pass
+                self.autoStartTimer = reactor.callLater(autoMatchStartTime, self.start, True)
 
         if self.world == "lobby" and self.goldFlowerTaken:
             self.broadBin(0x20, Buffer().writeInt16(-1).writeInt8(0).writeInt8(0).writeInt32(458761).writeInt8(0))
@@ -161,8 +174,31 @@ def start(self, forced = False):
         except:
             pass
 
-        self.world = random.choice(self.server.worlds)
+        self.world = self.forceLevel if self.forceLevel != "" else random.choice(self.server.worlds)
         self.broadLoadWorld()
 
         reactor.callLater(1, self.broadStartTimer, self.server.startTimer)
-        
+
+    def validateCustomLevel(self, level):
+        lk = json.loads(level)
+        jsonschema.validate(instance=lk, schema=levelJsonSchema)
+
+    def selectLevel(self, level):
+        if not self.private:
+            return
+        if level == "" or level in self.server.worlds:
+            self.forceLevel = level
+            self.broadLevelSelect()
+
+    def broadLevelSelect(self):
+        for player in self.players:
+            player.sendJSON({"type":"gsl", "name":self.forceLevel, "status":"update", "message":""})
+
+
+    def selectCustomLevel(self, level):
+        if not self.private:
+            return
+        self.validateCustomLevel(level)
+        self.forceLevel = "custom"
+        self.customLevelData = level
+        self.broadLevelSelect()

player.py

@@ -45,13 +45,14 @@ def getSimpleData(self):
     def serializePlayerObject(self):
         return Buffer().writeInt16(self.id).writeInt8(self.level).writeInt8(self.zone).writeShor2(self.posX, self.posY).writeInt16(self.skin).toBytes()
 
-    def loadWorld(self, worldName):
+    def loadWorld(self, worldName, levelData):
         self.dead = True
         self.loaded = False
         self.pendingWorld = worldName
-        self.sendJSON({"packets": [
-            {"game": worldName, "type": "g01"}
-        ], "type": "s01"})
+        msg = {"game": worldName, "type": "g01"}
+        if worldName == "custom":
+            msg["levelData"] = levelData
+        self.sendJSON({"packets": [msg], "type": "s01"})
         self.client.startDCTimer(15)
 
     def setStartTimer(self, time):
@@ -66,7 +67,7 @@ def onEnterIngame(self):
         if self.match.world == "lobby":
             self.lobbier = True
 
-        self.loadWorld(self.match.world)
+        self.loadWorld(self.match.world, self.match.customLevelData)
 
     def onLoadComplete(self):
         if self.loaded or self.pendingWorld is None:

server.cfg

@@ -19,7 +19,7 @@ MaxSimulIP: 3
 
 [Match]
 # Minimum of players to a match start by votes
-PlayerMin: 2
+PlayerMin: 1
 
 # Maximum of players in a match
 PlayerCap: 75

server.py

@@ -195,6 +195,20 @@ def onTextMessage(self, payload):
             elif type == "g51": # (SPECIAL) Force start
                 if self.server.mcode and self.server.mcode in packet["code"]:
                     self.player.match.start(True)
+            elif type == "gsl":  #level select
+                if self.player is not None:
+                    levelName = packet["name"]
+                    if levelName == "custom":
+                        try:
+                            self.player.match.selectCustomLevel(packet["data"])
+                        except Exception as e:
+                            estr = str(e)
+                            estr = "\n".join(estr.split("\n")[:10])
+                            self.sendJSON({"type":"gsl", "name":levelName, "status":"error", "message":estr})
+                            return
+                        self.sendJSON({"type":"gsl", "name":levelName, "status":"success", "message":""})
+                    else:
+                        self.player.match.selectLevel(levelName)
 
     def onBinaryMessage(self):
         pktLenDict = { 0x10: 6, 0x11: 0, 0x12: 12, 0x13: 1, 0x17: 2, 0x18: 4, 0x19: 0, 0x20: 7, 0x30: 7 }