This commit is contained in:
@@ -39,7 +39,15 @@ const MapSchema = new Schema({
|
||||
ref: 'Folder',
|
||||
default: null
|
||||
},
|
||||
// The Foundry scene this map mirrors, set by the scene sync only
|
||||
// (see routes/foundry-link.js). Only the picture and the grid follow the world.
|
||||
foundrySceneId: { type: String },
|
||||
date: { type: Date, default: Date.now }
|
||||
});
|
||||
|
||||
MapSchema.index(
|
||||
{ campaign: 1, foundrySceneId: 1 },
|
||||
{ unique: true, partialFilterExpression: { foundrySceneId: { $type: 'string' } } }
|
||||
);
|
||||
|
||||
module.exports = mongoose.model('Map', MapSchema);
|
||||
|
||||
@@ -6,10 +6,13 @@ const router = express.Router();
|
||||
const Campaign = require('../models/Campaign');
|
||||
const Actor = require('../models/Actor');
|
||||
const Item = require('../models/Item');
|
||||
// Not `Map`: this route builds plain `Map`s of its own to mirror the world's folder tree.
|
||||
const MapModel = require('../models/Map');
|
||||
const Folder = require('../models/Folder');
|
||||
const Note = require('../models/Note');
|
||||
const { foundryActorToCharacter } = require('../services/actor-foundry');
|
||||
const { foundryItemToItemData } = require('../services/item-foundry');
|
||||
const { foundrySceneToMapData } = require('../services/map-foundry');
|
||||
const { joinFoundryAssetUrl } = require('../services/foundry-icons');
|
||||
|
||||
// Upper bound for the Foundry names remembered per synced item (see Item model).
|
||||
@@ -269,6 +272,47 @@ function resolveFoundryItemFolder(source, folders) {
|
||||
return folders.get(foundryFolderId.trim())?._id || null;
|
||||
}
|
||||
|
||||
// --- Maps -------------------------------------------------------------------
|
||||
// A scene of the world becomes one of the campaign's maps (Syndria98/dragonroll#99):
|
||||
// services/map-foundry.js says what of a scene travels — its background picture and the
|
||||
// grid laid over it, and nothing else, so the map's pins, its tokens, the folder it
|
||||
// stands in and what one of its cells means stay the campaign's own.
|
||||
|
||||
async function saveFoundryScene(campaign, source, fullSync = false) {
|
||||
const foundrySceneId = String(source?._id || source?.id || '').trim().slice(0, 120);
|
||||
const fields = foundrySceneToMapData(source || {});
|
||||
if (!foundrySceneId || !fields) return null;
|
||||
resolveWorldAssets(fields, campaign);
|
||||
|
||||
let map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId });
|
||||
const dragonrollMapId = source?.flags?.['dragonroll-foundry']?.mapId;
|
||||
if (!map && mongoose.isValidObjectId(dragonrollMapId)) {
|
||||
const flagged = await MapModel.findOne({ _id: dragonrollMapId, campaign: campaign._id });
|
||||
// Only adopt a flagged map while no other scene owns its mapping.
|
||||
if (flagged && (!flagged.foundrySceneId || flagged.foundrySceneId === foundrySceneId)) map = flagged;
|
||||
}
|
||||
if (!map) {
|
||||
// The campaign drew this place by hand before the scene of it ever arrived: a scene
|
||||
// naming the one unmapped map the campaign holds folds into that row instead of
|
||||
// adding a second copy of the same room.
|
||||
const sameName = await MapModel.find({
|
||||
campaign: campaign._id,
|
||||
name: fields.name,
|
||||
foundrySceneId: { $exists: false }
|
||||
}).limit(2);
|
||||
map = sameName.length === 1 ? sameName[0] : new MapModel({ campaign: campaign._id });
|
||||
}
|
||||
|
||||
map.foundrySceneId = foundrySceneId;
|
||||
// `created` says whether this row is new, like the actor and item writers answer it.
|
||||
const created = map.isNew;
|
||||
// A full snapshot runs when a GM reconnects: the grid the campaign lined up for a map
|
||||
// it already has survives that. Live scene edits continue to overwrite normally.
|
||||
if (!fullSync || map.isNew) Object.assign(map, fields);
|
||||
await map.save();
|
||||
return { foundrySceneId, mapId: map.id, created };
|
||||
}
|
||||
|
||||
|
||||
// Linking a world to a campaign happens through the sign-up link every service
|
||||
// uses (routes/service-link.js); what stays here is the sync that world keeps up
|
||||
@@ -439,6 +483,59 @@ router.post('/sync/item-delete', async (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
// The world's scenes, upserted as the campaign's maps (Syndria98/dragonroll#99). Like a
|
||||
// world item push, this one prunes only when it is told it carries every scene: that push
|
||||
// alone sees the whole scene list, so it alone knows which synced maps the world has let go
|
||||
// of. A map the campaign made by hand has no scene of its own and is never pruned.
|
||||
router.post('/sync/scenes', async (req, res) => {
|
||||
try {
|
||||
const campaign = await syncCampaign(req, res);
|
||||
if (!campaign) return;
|
||||
if (!requestMatchesWorld(campaign, req.body.worldId) || !Array.isArray(req.body.scenes)) {
|
||||
return res.json({ status: 'error', msg: 'errors.missing-data' });
|
||||
}
|
||||
|
||||
const fullSync = req.body.fullSync === true;
|
||||
const maps = [];
|
||||
for (const source of req.body.scenes) {
|
||||
const mapping = await saveFoundryScene(campaign, source, fullSync);
|
||||
if (mapping) maps.push(mapping);
|
||||
}
|
||||
if (fullSync) {
|
||||
const currentIds = req.body.scenes
|
||||
.map((source) => String(source?._id || source?.id || '').trim())
|
||||
.filter(Boolean);
|
||||
await MapModel.deleteMany({
|
||||
campaign: campaign._id,
|
||||
foundrySceneId: { $exists: true, $nin: currentIds }
|
||||
});
|
||||
}
|
||||
res.json({ status: 'ok', maps });
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
res.json({ status: 'error', msg: 'errors.internal' });
|
||||
}
|
||||
});
|
||||
|
||||
// A scene the world deleted takes its map with it. Only the world says so; deleting a map
|
||||
// in the campaign leaves the world's scene alone, which is the campaign's own to do.
|
||||
router.post('/sync/scene-delete', async (req, res) => {
|
||||
try {
|
||||
const campaign = await syncCampaign(req, res);
|
||||
if (!campaign) return;
|
||||
const foundrySceneId = String(req.body.foundrySceneId || '').trim();
|
||||
if (!requestMatchesWorld(campaign, req.body.worldId) || !foundrySceneId) {
|
||||
return res.json({ status: 'error', msg: 'errors.missing-data' });
|
||||
}
|
||||
|
||||
await MapModel.deleteOne({ campaign: campaign._id, foundrySceneId });
|
||||
res.json({ status: 'ok' });
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
res.json({ status: 'error', msg: 'errors.internal' });
|
||||
}
|
||||
});
|
||||
|
||||
// The item list the world reconciles against, together with the folders its rows are
|
||||
// grouped into — the same shape the campaign's own `/item/list` answers with. The folders
|
||||
// travel back for their colour: the world owns the tree's name and nesting, while whoever
|
||||
|
||||
49
backend/src/services/map-foundry.js
Normal file
49
backend/src/services/map-foundry.js
Normal file
@@ -0,0 +1,49 @@
|
||||
const { numberOr, asText } = require('./foundry-fields');
|
||||
|
||||
// A Foundry scene is one of the campaign's maps (Syndria98/dragonroll#99): its background
|
||||
// picture and the grid laid over it travel to Dragonroll. Everything else a scene holds —
|
||||
// its padding, its lighting, the tokens standing on it — belongs to the world's table, and
|
||||
// so does what one of its cells stands for (`gridDistance` with its units): the campaign
|
||||
// sets its own scale and keeps it.
|
||||
|
||||
// The scene's background picture: `background.src` since Foundry V13, plain `img` before.
|
||||
function sceneImage(scene) {
|
||||
return asText(scene?.background?.src).trim() || asText(scene?.img).trim();
|
||||
}
|
||||
|
||||
// How many pixels of the picture one grid cell covers. Foundry keeps it under `grid.size`
|
||||
// since V13 and under plain `grid` before; 50 px is its own default cell size, and
|
||||
// Dragonroll's is the same, so a scene that says nothing gets the grid it draws.
|
||||
function sceneGridSize(scene) {
|
||||
const size = numberOr(scene?.grid?.size ?? scene?.grid, 0);
|
||||
return size >= 1 ? Math.round(size) : 50;
|
||||
}
|
||||
|
||||
// Where that grid starts on the picture. A world shifts it with the core flags of its own
|
||||
// (`flags.core.shiftX` / `.shiftY`, what it uses to line a hexagonal grid up); one that says
|
||||
// nothing has its grid at the corner of the picture. The scene's padding is blank canvas
|
||||
// *outside* the picture, so it is no part of the grid the campaign lays on the picture itself.
|
||||
function sceneGridOffset(scene, axis) {
|
||||
return Math.round(numberOr(scene?.flags?.core?.[`shift${axis}`], 0));
|
||||
}
|
||||
|
||||
// Returns null for a scene that is not a map: one with no name, or with no background
|
||||
// picture. A Dragonroll map without a picture is an empty viewer, so those scenes stay in
|
||||
// the world — their id is still listed by the snapshot that carries them, so nothing of the
|
||||
// campaign is pruned because of one.
|
||||
function foundrySceneToMapData(scene) {
|
||||
const name = asText(scene?.name).trim();
|
||||
const image = sceneImage(scene);
|
||||
if (!name || !image) return null;
|
||||
|
||||
return {
|
||||
name,
|
||||
// The module sends Foundry's picture as an absolute URL, like actors do.
|
||||
image,
|
||||
gridSize: sceneGridSize(scene),
|
||||
offsetX: sceneGridOffset(scene, 'X'),
|
||||
offsetY: sceneGridOffset(scene, 'Y')
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = { foundrySceneToMapData };
|
||||
Reference in New Issue
Block a user