rc3/rc3_notes.md

* rc3-World (== Online CCC-Kongress)
    https://howto.rc3.world/
    https://links.rc3.world/
    Chaosradio über die rc3-World:
        https://chaosradio.de/cr265-rc3-world
    Scraped maps:
        https://github.com/MichaelKreil/rc3-map-scraper

* Software: Workadvanture
    * 2D-Multiplayer-Onlinespielumgebung mit integriertem Ad-Hoc Video-Konferenz-System wenn Spieler sich begegnen (Max. 4 Teilnehmer)
    * Entwickler: The Coding Machine https://www.thecodingmachine.com/
    * https://workadventu.re/
    * https://github.com/thecodingmachine/workadventure
    * Binary-Kitchen Fork:
        * https://git.binary-kitchen.de/noby/workadventure


* Tutorials:
    * https://workadventu.re/map-building
    * https://howto.rc3.world/
    * Videos der Binary Kitchen:
        * https://www.youtube.com/watch?v=NmIT2UYFVzY
        * https://www.youtube.com/watch?v=hPPvZaI97aM


* Engine
    * Basiert auf der Phaser HTML5 Game Engine (https://phaser.io/)
    * Online version (https://play.workadventu.re)
    * Self hosted
    * Other hosts (z.B. https://play.wa.binary-kitchen.de/)
    * 200+ Spieler (lt. Website)
    * Lizensierung erbeten für >= 25 Spieler (aber z.Zt. nicht erzwungen)
    * AGPL Lizenz
        * You cannot offer online subscriptions to a WorkAdventure server you are putting online.
            
* Maps
    * Unabhängig vom engine host
    * Wird über URL in die engine geladen:
        <engine_server>/_/<instance>/<map_server>/<path_to_map>#<start_point>
        z.B. https://play.wa.binary-kitchen.de/_/global/c0c0bird.github.io/chaos-world/main.json#start_alpen
        * <instance>: Beliebiger Bezeichner (typ. "global"). Nur Spieler in derselben Instanz können sich sehen.
    * Achtung: uMatrix o.ä. blockieren eventuell den XMLHTTPRequest
    * Map-Format:
        json (map layer definitions) + png (tiles)
        WICHTIG: Tilesets müssen EMBEDDED werden.
    * Grafischer Editor: Tiled
        https://www.mapeditor.org/
        Tiled tutorial der Binary-Kitchen: 
            https://www.youtube.com/watch?v=NmIT2UYFVzY

    * Struktur:
        * Rechteckige Matrix aus Feldern
        * Mehrere Übereinanderliegende Ebenen (Layer)
        * Layertyp: Tile Layer (außer floorLayer)
        * LAyer Groups werden laut Github noch nicht unterstützt.
        * Jede Ebene kann an jeder Position mit einer 32x32px Kachel (Tile) gefüllt sein
            * Oben liegende Ebenen überdecken darunterliegende (beachte PNG-Transparenz)
            * Tiles organisiert in Tilesets (= PNGs mit mehreren 32x32 Tiles)
            
        * Spezielle Ebenen:
            * "floorLayer": Hier wird die Spielfigur dargestellt.
                * Muss vom Typ Objectlayer sein (als einziger)
            
            * Exitlayer (typ. "exitToXXX"): Ausgänge zu anderen Karten 
                * Jeder Layer mit der Eigenschaft "exitUrl" (string)
                * Inhalt des exitUrl-Strings gibt die Zielkarte an
                    * Auf dem gleichen Map-Server: "<path_to_map>#<start_point>"
                    * Auf anderem Map-Server: "/_/<instance>/<map_server>/<path_to_map>#<start_point>"
                * Jedes beliebige Tile auf einem Exitlayer dient als Ausgang.
                    Good practice: Benutze Tile "EXIT" aus mapUtilities
                * ACHTUNG: Exit- und Startfelder dürfen nicht zusammenfallen. (Sonst stürzt das Spiel ab).
                * Wenn der angegebene Startlayer nicht gefunden wird: Start in der Mitte der Karte
                * exitUrl kann auch auf die aktuelle Karte zeigen --> Sprung auf Karte
                
            * Startlayer: (typ. "startFromXXX"): Einstiegspunkt beim betreten der Karte
                * Jeder Layer mit der Eigenschaft "startLayer" (Typ bool)
                * Einstieg definiert durch ein beliebiges Tile auf dem Startlayer
                    * Good practice: Benutze Tile "START" aus Tileset "mapUtilities".
                * Bei mehreren existierenden Tiles wird eines davon zufällig als Startpunkt gewählt
                * Name des Startlayers wird als <start_point> in Map-URL übergeben
                * Es kann mehrere Startlayer geben (z.B. für verschiedene Eingänge)
            
                    
            * Wände (eigentlich kein spezieller Layer):
                * Jedes Tile mit der Eigenschaft "collide" (bool) wirkt als Wand, 
                    d.h. man kann nicht durchlaufen
                * Üblich: Benutze Tile "BLOCK" aus mapUtilities.
                
            * Silent-Layer:
                * Unterdrückt Ad-hoc Videochats
                * Jeder Layer mit Eigenschaft "silent" (bool)
                * Bereich definiert durch beliebige Tiles
                * Good practice: Banutze Tile "SILENT" aus mapUtilities
            
            * Jitsi-Konferenzbereiche:
                * Erlaubt Video-Konferenzen mit mehr als 4 Teilnehmern
                * Jeder Layer mit Eigenschaft "jitsiRoom" (string)
                * Name des jitsiRooms = <instance>+string
                * Konferenzbereich definiert durch beliebige Tiles
                * Good practice: Benutze Tile "MISC" aus mapUtilities
                * Speziell: Layer-Eigenschaft "jitsiTrigger: onaction"
                    --> Konferenz wird erst nach Drücken von Space beigetreten
                
            * Website öffnen (als iFrame):
                * Layer mit Eigenschaft "openWebsite" (string)
                * Beim betreten eines beliebigen Tiles wird die in Website im string geöffnet.
                    * Für jede Website ist eine eigener Layer nötig.
                    * Lokale Pfade funktionieren anscheinend nicht, nur vollständige URLs.
                    * Nur https://
                    
                * Good practice: Benutze Tile URL aus mapUtilities
                * Speziell: Layer-Eigenschaft "openWebsiteTrigger: onaction"
                    --> Website wird erst nach Drücken von Space geöffnet

            * Audio abspielen:
                * Layer mit Eigenschaft "playAudio" (string)
                * Bei Betreten eines Tiles wird das im string angegeben mp3-file geladen und abgespielt
                * Good practice: Benutze Tile "AUDIO" aus mapUtilities
                * Eigenschaft "playAudioLoop" statt "playAudio":
                    Audio wird in Endlosschleife abgespielt
                    
            * Animationen:
                * Bestehend aus Abfolge von Tiles
                * Editierbar mit Tiled:
                    Teilset anwählen --> Tielset bearbeiten (Schraubenschlüssel-Icon) 
                        --> Animationseditor (Kamera-Icon)
                             
* Maps hosten:
    * Lokaler HTTP-Server zur Entwicklung
    * Webspace
    * github.io, Droppages, GoogleDrive, OneDrive
    * Wie können wir möglichst vielen Nutzern die Möglichkeit geben, einfach eigene Karten zu hosten?
    
    * HTTP-Header:
        * Access-Control-Allow-Origin: *  (Cross-Site-Scripting beim Laden der Karte durch Webbrowser)
        * X-Frame-Options deativieren  (für iFrames)
        * Expires: 0  (Verhindere Caching durch Browser während Entwicklung und ev. für Special-Effects)
        * Cache-Control: no-cache, max-age=0
    
* Hacks:
    * Mapseitige Spielmechanismen
        * Reagiere auf Events
            * Audio
            * iframes
        * Dynamisch veränderte Maps (Änderungen nur bei Mapwechsel möglich)
        * Problem: Phaser-Engine cached alle files,
            Ausnahme: iframes
            --> Ermöglicht Spielmechanismen mit iframes ohne Auswirkungen auf die Maps
            
        * Spielzustand speichern
            * Cookies (Spieler-Spezifisch)
            * In generierter Karte (Spieler-Spezifisch)
            * Auf Map-Server (Global)
        * Problem: Browser akzeptiert keine Cookies via Cross-Site-Scripting
            
            
            
    * Cache aushebeln Mapseitig:
        * HTTP redirect nützt nichts, engine merkt sich die ursprüngliche URL
        * Workaround: Dynamische einamalige Dateinamen für Maps
            * Nachteil: Jeder Spieler bekommt eine andere Map, kein Multiplayer mehr
            * Funktioniert nur für Maps, nicht für Audio-Events
        * Implementierung A:
            (1) Wenn eine Karte map.php aufgerufen wird: 
                * Lade map.json
                * Ersetze alle Exit-URLs der Form  dest.php#start --> dest.timestamp.php#start
                   (dest.json wird so gelassen, damit man wieder in Multiplayer-Maps zurück kann).
            (2) URL-Rewrite rule via .htaccess: Entferne timestamp
                    RewriteRule ^(.+)\.\d+\.php$  $1.php
        * Implementierung B (timestamp-patching ausgelagert in eigenes file):
            (1) URL-Rewrite: Entferne timestamp und übergebe Mapnamen an uncache.php via URL-Parameter
                    RewriteRule ^(.+)\.\d+\.php$  uncache.php?target=$1
            (2) In uncache.php:
                * Wenn es target.php gibt, dann rufe diese auf und fange ihren output ab.
                * sonst lade target.json
                * Patch Exit-URLS mit timestamp.
    

    * Cache deaktivieren Engineseitig:
        * Karten beim betreten neu laden
            * File GameScene.ts, function onMapExit()
                this.cache.tilemap.entries.clear();
        
    * Dynamisch generierte Maps
        * Maze-generator
        * Endless Tower
            * Automatisch generierte Stockwerke (außer das Stockwerk ist schon bewohnt)
            * Treppenhaus
            * Aufzug
    
    * Exit games:
        * Ausgang öffnen durch Rätsel auf iframe
        * Ausgang öffnen durch Event (z.B. Audio-Feld == Druckplatte)
        * Einschränkung:
            Ausgang muss in anderem Raum sein als Auslöser (Mapänderungen nur bei Mapwechsel möglich)
        * Items sammeln und benutzen
        
        
* Engine hosten:
    * Source von github laden
        https://github.com/thecodingmachine/workadventure
    * Fork von binary kitchen
        https://git.binary-kitchen.de/noby/workadventure
    
    * Docker installieren
    * docker-compose installieren (via curl)
    * Eintragungen in /etc/hosts:
        127.0.0.1  workadventure.localhost
        127.0.0.1  pusher.workadventure.localhost (scheint nicht notwendig)
    * sudo dockerd &
    * sudo docker-compose up
        Dauert einige Zeit, kompiliert Zeug und startet dann mehrere Container
    * Webbrowser
        play.workadventure.localhost/_/global....
        Firefox macht Probleme wegen irgendeinem http/https-Forwarding
        Chromium geht, aber ohne Kamera/Mikrofon (nur über HTTPS).
    * Erstmal nur von lokal erreichbar, 
        von außerhalb ip:8080 meldet sich Traefik Reverse Proxy
                      ip:80 nicht erreichbar
    * Erreichbarkeit von außen:
        Konfigurationsfile docker-compose.yaml
            Domainnamen in alle traefik host-rules eintragen
            Domainnamen in front envirnment Variablen eintragen
        Muss über Domain angesprochen werden, damit traefik entsprechend weiterleitet
            Nur IP geht nicht
            Für lokale Tests: Domains in /etc/hosts bzw. C:/windows/system32/drivers/etc/hosts eintragen