Ingame-Karte des Clients *anfragen* / Request client (ingame)map

Huhu,

für ein etwas größeres Projekt würde ich gerne die Karten-Daten der Spieler sammeln während sie diese erkunden. Deshalb wäre es cool wenn man per API den Client nach den Kartendaten (Bilder) des aktuellen chunks befragen könnte (könnte man dann triggern wenn der Spieler einen neuen chunk betritt) Auf dem Client könnte man in den Optionen ja sowas wie "Server erlauben Karten-Daten zu erfragen" einfügen mit denen man als Client bestimmen kann ob diese gesendet werden dürfen oder nicht.
Red hatte mir bereits gesagt das die Karten nur clientseitig erstellt werden, daher müßte man da irgendwie ran

// -------------
Hello,

for a litte bigger sized project i would like to collect all that ingame-map data while players discover new lands. For this reason i would like to have an API call that requests those (image) files from the client (for example when he runs into a new chunk). On the clientside there could be an option to turn this on or off like "Allow server to request ingame-map". Red has already told me that those maps are only generated on the client, so there must be some way to fetch these

@red51 welches Format haben denn die Dateien beim Client unter RisingWorld/Map/__/mx_*_* ? Ich wollte schon mal einen POC bauen bis es möglich ist die Dateien vom Client zu "erbitten" und so auf dem Server zu verarbeiten.

// -------------

@red51 which file format is used for the map files in RisingWorld/Map/__/mx_*_* on the client ? I would like to build a POC until there is a way to request those client-map-files from the server via API.

Quote from Minotorious

Have a look here for the map file format:Map image data and file names

oh k, did not see that thread, that helps thy.

EDIT: Got it

Wrote a Quick and dirty node app for this:

import { readFileSync, createWriteStream } from "fs";
import { Canvas, createCanvas, Image } from 'canvas';


const path = __dirname + "/../mt_34_-1~";
const file = readFileSync(path);


let offset = 0;
let index = 0;
let x = 0, y = 0;


const C: Canvas = createCanvas(256, 256);


const ctx: CanvasRenderingContext2D = C.getContext('2d');




while (offset < file.byteLength) {


    const red = file.readUInt8(offset + 0);
    const green = file.readUInt8(offset + 1);
    const blue = file.readUInt8(offset + 2);
    const alpha = file.readUInt8(offset + 3);


    y = Math.floor(index / 256);
    x = index % 256;


    const idata: ImageData = ctx.getImageData(x, y, 1, 1);


    idata.data[0] = red;
    idata.data[1] = green;
    idata.data[2] = blue;
    idata.data[3] = alpha;
    ctx.putImageData(idata, x, y);


    index++;
    offset = index*4;
}


const imageFileStream = createWriteStream(path + ".jpg");
const stream = C.createJPEGStream({
    quality: 0.95,
    chromaSubsampling: false
});


stream.pipe(imageFileStream);
imageFileStream.on('finish', () => console.log('The JPEG file was created.'));

Just a Quick & dirty POC: https://rw.gi.omega-zirkel.de/ no zoom levels yet, just origins.

DE: Also ich würde so oder so diverse Mechanismen einbauen um den Traffic gering zu halten. Zunächst sollten nur die Maps um den Spieler herum angefordert werden können. Dann sollten zunächst hashwerte und Datum abgeglichen werden um zu vermeiden unnötig Updates zu schicken oder die Karte mit alten Daten zu überschreiben. Dann würde ich noch ein Limit setzen das ein map Part nur alle x Minuten aktualisiert wird. Also wenn ein map Teil von Spieler a schon übertragen wurde, wird es für x Minuten von keinem anderen Spieler angefordert.

EN: Anyway I would implement some mechanism to reduce traffic. First of all only maps around the player should be able to be requested, then filehash and creation date should be compared to avoid updates and overrides with older map data. Then i would implement a limit per tile per x minutes to be requested. So for example if Player A has sent an update for map tile 1,1 nobody else would be requested for 1,1 for the next X minutes.

Das klingt doch schon mal gut, meine aktuelle Lösung arbeitet auch nur mit den komprimierten original-files. Kannst du kurz erläutern wie du es genau implementiert hast wenn du Zeit findest @red51? Meine aktuelle Lösung (Server) merkt sich datum und hash der Dateien und vergleicht erst vor einer Übertragung um Daten zu reduzieren. Und mein aktueller Client sendet onfilechange hash und erstell datum an den Server zum Abgleich bis dieser dann ein ok für die Übertragung gibt.

Super, damit kann ich dann ein Plugin schreiben das meine Fake API ersetzt, werde wohl aber einfach die raw files auf dem server speichern und meine rendering-app dementsprechend anpassen, das diese auf Änderungen im raw Verzeichnis reagiert und dann on-the-fly dekomrimiert und die bilder in allen zoomstufen aktualisiert.

Clientseitig würde ich noch einen Flag in den Einstellungen einbauen (default true), mit dem Spieler der API das anfordern erlauben kann oder nicht (falls jemand Probleme mit seiner Internetleitung und dem feature hat). bei false würde die API immer null senden, fertig.

Quote from PatrickBronke

Du willst eine Live-Map erstellen, die man im Internet aufrufen kann. (Wie Dynmap)
Finde ich persönlich sehr gut. Fehlt nur noch, dass dann die Spieler ihre aktuelle Position gezeigt werden.

Das steht schon auf der ToDo Liste

RW Online-Map Project [WIP]