From 81327d3d9c9cf4fed8c9f268eecde2df6110e4c3 Mon Sep 17 00:00:00 2001 From: Timofejs Maksimovs Date: Mon, 12 Feb 2024 09:12:29 +0000 Subject: [PATCH] Upload files to "/" --- Custom_floor.png | Bin 0 -> 4687 bytes Default_floor.png | Bin 0 -> 10846 bytes Wall_tops.png | Bin 0 -> 4239 bytes data.json | 148 ++++++++++++++ world0_code.py | 479 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 627 insertions(+) create mode 100644 Custom_floor.png create mode 100644 Default_floor.png create mode 100644 Wall_tops.png create mode 100644 data.json create mode 100644 world0_code.py diff --git a/Custom_floor.png b/Custom_floor.png new file mode 100644 index 0000000000000000000000000000000000000000..4d1cbc3f28966edbebd10667f26dd0def98ddfdc GIT binary patch literal 4687 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 z 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 literal 0 HcmV?d00001 diff --git a/Wall_tops.png b/Wall_tops.png new file mode 100644 index 0000000000000000000000000000000000000000..70d92eb62c211f7aeeba713b9441d0d844ee1173 GIT binary patch literal 4239 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 GI`uDA@5;yk literal 0 HcmV?d00001 diff --git a/data.json b/data.json new file mode 100644 index 0000000..ce14f08 --- /dev/null +++ b/data.json @@ -0,0 +1,148 @@ +{ + "identifier": "World_Level_0", + "uniqueIdentifer": "d53f9950-c640-11ed-8430-4942c04951ff", + "x": 256, + "y": 0, + "width": 512, + "height": 256, + "bgColor": "#404255", + "neighbourLevels": [ + { + "levelIid": "5b1771e0-c640-11ed-8430-9b64f8cc95ad", + "dir": "w" + }, + { + "levelIid": "e06b8660-c640-11ed-8430-7b6fcb3e9e6b", + "dir": "e" + } + ], + "customFields" : {}, + "layers": [ + "Default_floor.png", + "Custom_floor.png", + "Collisions.png", + "Wall_tops.png" + ], + "entities": { + "Door": [ + { + "id": "Door", + "iid": "8ac5dda0-c640-11ed-8430-8169bab5952b", + "layer": "Entities", + "x": 160, + "y": 112, + "width": 32, + "height": 16, + "color": 12087120, + "customFields": { + "lockedWith": null + } + }, + { + "id": "Door", + "iid": "8d4360c0-c640-11ed-8430-abb21cbec6c0", + "layer": "Entities", + "x": 288, + "y": 112, + "width": 32, + "height": 16, + "color": 12087120, + "customFields": { + "lockedWith": null + } + }, + { + "id": "Door", + "iid": "a1e0c860-c640-11ed-8430-e927d6a72261", + "layer": "Entities", + "x": 112, + "y": 144, + "width": 16, + "height": 48, + "color": 12087120, + "customFields": { + "lockedWith": "KeyA" + } + }, + { + "id": "Door", + "iid": "c8d51610-3b70-11ee-b655-5116b3326bb0", + "layer": "Entities", + "x": 128, + "y": 64, + "width": 16, + "height": 32, + "color": 12087120, + "customFields": { + "lockedWith": null + } + } + ], + "Item": [ + { + "id": "Item", + "iid": "c3c403c0-c640-11ed-8430-cd4fd5179384", + "layer": "Entities", + "x": 296, + "y": 56, + "width": 20, + "height": 20, + "color": 16711748, + "customFields": { + "type": "KeyA" + } + }, + { + "id": "Item", + "iid": "c75e4180-c640-11ed-8430-ebd1fb662306", + "layer": "Entities", + "x": 56, + "y": 72, + "width": 20, + "height": 20, + "color": 16711748, + "customFields": { + "type": "Health" + } + } + ], + "Button": [ + { + "id": "Button", + "iid": "cb7d3fa0-c640-11ed-8430-97bfc67769ff", + "layer": "Entities", + "x": 184, + "y": 40, + "width": 10, + "height": 10, + "color": 16711680, + "customFields": { + "targets": [ + { + "entityIid": "8d4360c0-c640-11ed-8430-abb21cbec6c0", + "layerIid": "d53f9951-c640-11ed-8430-3f3f71a3daf1", + "levelIid": "d53f9950-c640-11ed-8430-4942c04951ff", + "worldIid": "c9ef2d10-c640-11ed-ad34-f553e1d803f9" + } + ] + } + } + ], + "Player": [ + { + "id": "Player", + "iid": "6edc8020-b0a0-11ee-b6c1-d71cc2f0432a", + "layer": "Entities", + "x": 168, + "y": 152, + "width": 16, + "height": 16, + "color": 248700, + "customFields": { + "ammo": 50, + "life": 100 + } + } + ] + } +} \ No newline at end of file diff --git a/world0_code.py b/world0_code.py new file mode 100644 index 0000000..aebff28 --- /dev/null +++ b/world0_code.py @@ -0,0 +1,479 @@ +from typing import Any, List, Optional, TypeVar, Callable, Type, cast +from uuid import UUID + + +T = TypeVar("T") + + +def from_list(f: Callable[[Any], T], x: Any) -> List[T]: + assert isinstance(x, list) + return [f(y) for y in x] + + +def to_class(c: Type[T], x: Any) -> dict: + assert isinstance(x, c) + return cast(Any, x).to_dict() + + +def from_str(x: Any) -> str: + assert isinstance(x, str) + return x + + +def from_int(x: Any) -> int: + assert isinstance(x, int) and not isinstance(x, bool) + return x + + +def from_none(x: Any) -> Any: + assert x is None + return x + + +def from_union(fs, x): + for f in fs: + try: + return f(x) + except: + pass + assert False + + +class WelcomeCustomFields: + pass + + def __init__(self, ) -> None: + pass + + @staticmethod + def from_dict(obj: Any) -> 'WelcomeCustomFields': + assert isinstance(obj, dict) + return WelcomeCustomFields() + + def to_dict(self) -> dict: + result: dict = {} + return result + + +class Target: + entity_iid: UUID + layer_iid: UUID + level_iid: UUID + world_iid: UUID + + def __init__(self, entity_iid: UUID, layer_iid: UUID, level_iid: UUID, world_iid: UUID) -> None: + self.entity_iid = entity_iid + self.layer_iid = layer_iid + self.level_iid = level_iid + self.world_iid = world_iid + + @staticmethod + def from_dict(obj: Any) -> 'Target': + assert isinstance(obj, dict) + entity_iid = UUID(obj.get("entityIid")) + layer_iid = UUID(obj.get("layerIid")) + level_iid = UUID(obj.get("levelIid")) + world_iid = UUID(obj.get("worldIid")) + return Target(entity_iid, layer_iid, level_iid, world_iid) + + def to_dict(self) -> dict: + result: dict = {} + result["entityIid"] = str(self.entity_iid) + result["layerIid"] = str(self.layer_iid) + result["levelIid"] = str(self.level_iid) + result["worldIid"] = str(self.world_iid) + return result + + +class ButtonCustomFields: + targets: List[Target] + + def __init__(self, targets: List[Target]) -> None: + self.targets = targets + + @staticmethod + def from_dict(obj: Any) -> 'ButtonCustomFields': + assert isinstance(obj, dict) + targets = from_list(Target.from_dict, obj.get("targets")) + return ButtonCustomFields(targets) + + def to_dict(self) -> dict: + result: dict = {} + result["targets"] = from_list(lambda x: to_class(Target, x), self.targets) + return result + + +class Button: + id: str + iid: UUID + layer: str + x: int + y: int + width: int + height: int + color: int + custom_fields: ButtonCustomFields + + def __init__(self, id: str, iid: UUID, layer: str, x: int, y: int, width: int, height: int, color: int, custom_fields: ButtonCustomFields) -> None: + self.id = id + self.iid = iid + self.layer = layer + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + self.custom_fields = custom_fields + + @staticmethod + def from_dict(obj: Any) -> 'Button': + assert isinstance(obj, dict) + id = from_str(obj.get("id")) + iid = UUID(obj.get("iid")) + layer = from_str(obj.get("layer")) + x = from_int(obj.get("x")) + y = from_int(obj.get("y")) + width = from_int(obj.get("width")) + height = from_int(obj.get("height")) + color = from_int(obj.get("color")) + custom_fields = ButtonCustomFields.from_dict(obj.get("customFields")) + return Button(id, iid, layer, x, y, width, height, color, custom_fields) + + def to_dict(self) -> dict: + result: dict = {} + result["id"] = from_str(self.id) + result["iid"] = str(self.iid) + result["layer"] = from_str(self.layer) + result["x"] = from_int(self.x) + result["y"] = from_int(self.y) + result["width"] = from_int(self.width) + result["height"] = from_int(self.height) + result["color"] = from_int(self.color) + result["customFields"] = to_class(ButtonCustomFields, self.custom_fields) + return result + + +class DoorCustomFields: + locked_with: Optional[str] + + def __init__(self, locked_with: Optional[str]) -> None: + self.locked_with = locked_with + + @staticmethod + def from_dict(obj: Any) -> 'DoorCustomFields': + assert isinstance(obj, dict) + locked_with = from_union([from_none, from_str], obj.get("lockedWith")) + return DoorCustomFields(locked_with) + + def to_dict(self) -> dict: + result: dict = {} + result["lockedWith"] = from_union([from_none, from_str], self.locked_with) + return result + + +class Door: + id: str + iid: UUID + layer: str + x: int + y: int + width: int + height: int + color: int + custom_fields: DoorCustomFields + + def __init__(self, id: str, iid: UUID, layer: str, x: int, y: int, width: int, height: int, color: int, custom_fields: DoorCustomFields) -> None: + self.id = id + self.iid = iid + self.layer = layer + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + self.custom_fields = custom_fields + + @staticmethod + def from_dict(obj: Any) -> 'Door': + assert isinstance(obj, dict) + id = from_str(obj.get("id")) + iid = UUID(obj.get("iid")) + layer = from_str(obj.get("layer")) + x = from_int(obj.get("x")) + y = from_int(obj.get("y")) + width = from_int(obj.get("width")) + height = from_int(obj.get("height")) + color = from_int(obj.get("color")) + custom_fields = DoorCustomFields.from_dict(obj.get("customFields")) + return Door(id, iid, layer, x, y, width, height, color, custom_fields) + + def to_dict(self) -> dict: + result: dict = {} + result["id"] = from_str(self.id) + result["iid"] = str(self.iid) + result["layer"] = from_str(self.layer) + result["x"] = from_int(self.x) + result["y"] = from_int(self.y) + result["width"] = from_int(self.width) + result["height"] = from_int(self.height) + result["color"] = from_int(self.color) + result["customFields"] = to_class(DoorCustomFields, self.custom_fields) + return result + + +class ItemCustomFields: + type: str + + def __init__(self, type: str) -> None: + self.type = type + + @staticmethod + def from_dict(obj: Any) -> 'ItemCustomFields': + assert isinstance(obj, dict) + type = from_str(obj.get("type")) + return ItemCustomFields(type) + + def to_dict(self) -> dict: + result: dict = {} + result["type"] = from_str(self.type) + return result + + +class Item: + id: str + iid: UUID + layer: str + x: int + y: int + width: int + height: int + color: int + custom_fields: ItemCustomFields + + def __init__(self, id: str, iid: UUID, layer: str, x: int, y: int, width: int, height: int, color: int, custom_fields: ItemCustomFields) -> None: + self.id = id + self.iid = iid + self.layer = layer + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + self.custom_fields = custom_fields + + @staticmethod + def from_dict(obj: Any) -> 'Item': + assert isinstance(obj, dict) + id = from_str(obj.get("id")) + iid = UUID(obj.get("iid")) + layer = from_str(obj.get("layer")) + x = from_int(obj.get("x")) + y = from_int(obj.get("y")) + width = from_int(obj.get("width")) + height = from_int(obj.get("height")) + color = from_int(obj.get("color")) + custom_fields = ItemCustomFields.from_dict(obj.get("customFields")) + return Item(id, iid, layer, x, y, width, height, color, custom_fields) + + def to_dict(self) -> dict: + result: dict = {} + result["id"] = from_str(self.id) + result["iid"] = str(self.iid) + result["layer"] = from_str(self.layer) + result["x"] = from_int(self.x) + result["y"] = from_int(self.y) + result["width"] = from_int(self.width) + result["height"] = from_int(self.height) + result["color"] = from_int(self.color) + result["customFields"] = to_class(ItemCustomFields, self.custom_fields) + return result + + +class PlayerCustomFields: + ammo: int + life: int + + def __init__(self, ammo: int, life: int) -> None: + self.ammo = ammo + self.life = life + + @staticmethod + def from_dict(obj: Any) -> 'PlayerCustomFields': + assert isinstance(obj, dict) + ammo = from_int(obj.get("ammo")) + life = from_int(obj.get("life")) + return PlayerCustomFields(ammo, life) + + def to_dict(self) -> dict: + result: dict = {} + result["ammo"] = from_int(self.ammo) + result["life"] = from_int(self.life) + return result + + +class Player: + id: str + iid: UUID + layer: str + x: int + y: int + width: int + height: int + color: int + custom_fields: PlayerCustomFields + + def __init__(self, id: str, iid: UUID, layer: str, x: int, y: int, width: int, height: int, color: int, custom_fields: PlayerCustomFields) -> None: + self.id = id + self.iid = iid + self.layer = layer + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + self.custom_fields = custom_fields + + @staticmethod + def from_dict(obj: Any) -> 'Player': + assert isinstance(obj, dict) + id = from_str(obj.get("id")) + iid = UUID(obj.get("iid")) + layer = from_str(obj.get("layer")) + x = from_int(obj.get("x")) + y = from_int(obj.get("y")) + width = from_int(obj.get("width")) + height = from_int(obj.get("height")) + color = from_int(obj.get("color")) + custom_fields = PlayerCustomFields.from_dict(obj.get("customFields")) + return Player(id, iid, layer, x, y, width, height, color, custom_fields) + + def to_dict(self) -> dict: + result: dict = {} + result["id"] = from_str(self.id) + result["iid"] = str(self.iid) + result["layer"] = from_str(self.layer) + result["x"] = from_int(self.x) + result["y"] = from_int(self.y) + result["width"] = from_int(self.width) + result["height"] = from_int(self.height) + result["color"] = from_int(self.color) + result["customFields"] = to_class(PlayerCustomFields, self.custom_fields) + return result + + +class Entities: + door: List[Door] + item: List[Item] + button: List[Button] + player: List[Player] + + def __init__(self, door: List[Door], item: List[Item], button: List[Button], player: List[Player]) -> None: + self.door = door + self.item = item + self.button = button + self.player = player + + @staticmethod + def from_dict(obj: Any) -> 'Entities': + assert isinstance(obj, dict) + door = from_list(Door.from_dict, obj.get("Door")) + item = from_list(Item.from_dict, obj.get("Item")) + button = from_list(Button.from_dict, obj.get("Button")) + player = from_list(Player.from_dict, obj.get("Player")) + return Entities(door, item, button, player) + + def to_dict(self) -> dict: + result: dict = {} + result["Door"] = from_list(lambda x: to_class(Door, x), self.door) + result["Item"] = from_list(lambda x: to_class(Item, x), self.item) + result["Button"] = from_list(lambda x: to_class(Button, x), self.button) + result["Player"] = from_list(lambda x: to_class(Player, x), self.player) + return result + + +class NeighbourLevel: + level_iid: UUID + dir: str + + def __init__(self, level_iid: UUID, dir: str) -> None: + self.level_iid = level_iid + self.dir = dir + + @staticmethod + def from_dict(obj: Any) -> 'NeighbourLevel': + assert isinstance(obj, dict) + level_iid = UUID(obj.get("levelIid")) + dir = from_str(obj.get("dir")) + return NeighbourLevel(level_iid, dir) + + def to_dict(self) -> dict: + result: dict = {} + result["levelIid"] = str(self.level_iid) + result["dir"] = from_str(self.dir) + return result + + +class Welcome: + identifier: str + unique_identifer: UUID + x: int + y: int + width: int + height: int + bg_color: str + neighbour_levels: List[NeighbourLevel] + custom_fields: WelcomeCustomFields + layers: List[str] + entities: Entities + + def __init__(self, identifier: str, unique_identifer: UUID, x: int, y: int, width: int, height: int, bg_color: str, neighbour_levels: List[NeighbourLevel], custom_fields: WelcomeCustomFields, layers: List[str], entities: Entities) -> None: + self.identifier = identifier + self.unique_identifer = unique_identifer + self.x = x + self.y = y + self.width = width + self.height = height + self.bg_color = bg_color + self.neighbour_levels = neighbour_levels + self.custom_fields = custom_fields + self.layers = layers + self.entities = entities + + @staticmethod + def from_dict(obj: Any) -> 'Welcome': + assert isinstance(obj, dict) + identifier = from_str(obj.get("identifier")) + unique_identifer = UUID(obj.get("uniqueIdentifer")) + x = from_int(obj.get("x")) + y = from_int(obj.get("y")) + width = from_int(obj.get("width")) + height = from_int(obj.get("height")) + bg_color = from_str(obj.get("bgColor")) + neighbour_levels = from_list(NeighbourLevel.from_dict, obj.get("neighbourLevels")) + custom_fields = WelcomeCustomFields.from_dict(obj.get("customFields")) + layers = from_list(from_str, obj.get("layers")) + entities = Entities.from_dict(obj.get("entities")) + return Welcome(identifier, unique_identifer, x, y, width, height, bg_color, neighbour_levels, custom_fields, layers, entities) + + def to_dict(self) -> dict: + result: dict = {} + result["identifier"] = from_str(self.identifier) + result["uniqueIdentifer"] = str(self.unique_identifer) + result["x"] = from_int(self.x) + result["y"] = from_int(self.y) + result["width"] = from_int(self.width) + result["height"] = from_int(self.height) + result["bgColor"] = from_str(self.bg_color) + result["neighbourLevels"] = from_list(lambda x: to_class(NeighbourLevel, x), self.neighbour_levels) + result["customFields"] = to_class(WelcomeCustomFields, self.custom_fields) + result["layers"] = from_list(from_str, self.layers) + result["entities"] = to_class(Entities, self.entities) + return result + + +def welcome_from_dict(s: Any) -> Welcome: + return Welcome.from_dict(s) + + +def welcome_to_dict(x: Welcome) -> Any: + return to_class(Welcome, x)