bc_tiled_plugin

bc_plugin.js (7182B)

---

 const MAP_WIDTH = 40;
 const MAP_HEIGHT = 40;
 const TILE_SIZE = 100;
 const DIR = FileInfo.path(__filename);
 
 const EXPORT_EMPTY = 100;
 const EMPTY_IDS = new Set([100, 200, 500, 1000, 2000, 3000, 4000]);
 
 const read_clipboard = () =>
 {
   const d = new Dialog();
   const t = d.addTextEdit(null);
   t.paste();
   return t.plainText;
 };
 
 const write_clipboard = (str) =>
 {
   const d = new Dialog();
   const t = d.addTextEdit(null, str);
   t.selectAll();
   t.copy();
 };
 
 const do_layer = (map, name, str, ts_name, has_empty) =>
 {
   const ts_file = `${DIR}/tileset_${ts_name}.tsj`;
   // Using the read method on the tileset format will not mark the tileset as
   // external, so if the user saves the map, it will have a copy of the tileset.
   // tiled.open will properly mark it as external, but it also 1) opens a new
   // tab for the tileset, 2) litters recent files. Closing it at the end solves
   // 1), but not 2).
   //const ts = tiled.tilesetFormat('json').read(ts_file);
   const ts = tiled.open(ts_file);
   try
   {
     map.addTileset(ts);
 
     const layer = new TileLayer(name);
     layer.width = MAP_WIDTH;
     layer.height = MAP_HEIGHT;
     const edit = layer.edit();
     map.addLayer(layer);
 
     for (let y = 0; y < MAP_HEIGHT; ++y)
       for (let x = 0; x < MAP_WIDTH; ++x)
       {
         const id = str.charCodeAt(y*MAP_WIDTH + x);
         if (has_empty && EMPTY_IDS.has(id)) continue;
         edit.setTile(x, y, ts.tile(id));
       }
 
     edit.apply();
   }
   finally { tiled.close(ts); }
 };
 
 const impor = (content) =>
 {
   // accept both compressed and uncompressed input
   if (content[0] !== '{') content = LZString.decompressFromBase64(content);
   const json = JSON.parse(content);
   // {Type: 'Always'/'Hybrid', Tiles: '...', Objects: '...'}
   const map = new TileMap();
   map.setSize(MAP_WIDTH, MAP_HEIGHT);
   map.setTileSize(TILE_SIZE, TILE_SIZE);
   map.setProperty('is_hybrid', json.Type == 'Hybrid');
   do_layer(map, 'Tiles', json.Tiles, 'tile', false);
   do_layer(map, 'Objects', json.Objects, 'object', true);
 
   return map;
 };
 
 const read = (fn) =>
 {
   const file = new TextFile(fn, TextFile.ReadOnly);
   const content = file.readAll();
   file.close();
 
   return impor(content);
 };
 
 const assert = (expr, err) =>
 {
   if (expr) return;
   throw new Error(err);
 };
 
 const get_layer = (map, name) =>
 {
   for (const l of map.layers)
     if (l.name === name)
       return l;
   throw Error(`Missing layer "${name}"`);
 };
 
 const write_layer = (map, name) =>
 {
   const layer = get_layer(map, name);
   const codes = [];
   for (let y = 0; y < MAP_HEIGHT; ++y)
     for (let x = 0; x < MAP_WIDTH; ++x)
     {
       const tile = layer.tileAt(x, y);
       if (tile == null)
         codes.push(EXPORT_EMPTY);
       else
       {
         assert(tile.tileset.name == name,
                `Bad tileset ${tile.tileset.name} on layer ${name} at ${x}, ${y}`);
         codes.push(tile.id);
       }
     }
   return String.fromCharCode(...codes);
 };
 
 const expor = (map, compress = true) =>
 {
   assert(map.width == MAP_WIDTH && map.height == MAP_HEIGHT, 'Invalid map size');
   assert(!map.infinite, 'Map is infinite');
   assert(map.layerCount == 2, 'Invalid layer count');
 
   const json = {
     Type: map.property('is_hybrid') ? 'Hybrid' : 'Always',
     Tiles: write_layer(map, 'Tiles'),
     Objects: write_layer(map, 'Objects'),
   };
   let res = JSON.stringify(json);
   if (compress) res = LZString.compressToBase64(res);
   // force escape non-ascii characters...
   else res = res.replace(/[\u007F-\uFFFF]/g, (chr) =>
     '\\u' + ('0000' + chr.charCodeAt(0).toString(16)).substr(-4));
   return res;
 };
 
 const write = (map, fn) =>
 {
   const text = expor(map);
   const file = new TextFile(fn, TextFile.WriteOnly);
   file.writeLine(text);
   file.commit();
 };
 
 tiled.registerMapFormat(
   'bondageclub', { name: 'BondageClub map', extension: 'txt', read, write });
 
 const validate_layer = (check, layer) =>
 {
   check(layer.width == MAP_WIDTH && layer.height == MAP_HEIGHT,
         `Layer ${layer.name} is not ${MAP_WIDTH}x${MAP_HEIGHT}`);
   const is_objects = layer.name === 'Objects';
 
   for (let y = 0; y < layer.height; ++y)
     for (let x = 0; x < layer.width; ++x)
     {
       const tile = layer.tileAt(x, y);
       if (tile == null)
         check(is_objects, `Empty tile on layer ${layer.name} at ${x}, ${y}`);
       else
       {
         check(tile.tileset.name == layer.name,
               `Bad tileset ${tile.tileset.name} on layer ${layer.name} at ${x}, ${y}`);
       }
     }
 };
 
 const validate = () =>
 {
   let was_error = false;
   const map = tiled.activeAsset;
   const check = (expr, err, func) =>
   {
     if (expr) return;
     was_error = true;
     tiled.warn(err, func);
   };
 
   check(!map.infinite, 'Map is infinite');
   check(map.width == MAP_WIDTH && map.height == MAP_HEIGHT,
          `Map not ${MAP_WIDTH}x${MAP_HEIGHT}`);
   check(map.layerCount == 2, 'Map layer count is not 2');
 
   const layers = {};
   for (const l of map.layers)
   {
     layers[l.name] = l;
     if (l.name === 'Objects' || l.name === 'Tiles')
       validate_layer(check, l);
     else
       check(false, `Layer "${l.name}" has invalid name`);
   }
 
   if (layers.Objects && layers.Tiles &&
       layers.Objects.width === layers.Tiles.width &&
       layers.Objects.height === layers.Objects.height)
     for (let y = 0; y < layers.Objects.height; ++y)
       for (let x = 0; x < layers.Objects.width; ++x)
       {
         const obj = layers.Objects.tileAt(x, y);
         if (obj == null) continue;
         const tile = layers.Tiles.tileAt(x, y);
         if (tile == null) continue; // error'd in validate_layer
 
         const obj_type = obj.property('type');
         const tile_type = tile.property('type');
         // validation logic from ChatRoomMapViewUpdateFlag
         check(obj_type !== 'floor' || tile_type === 'floor',
               `Floor item on not floor at ${x}, ${y}`);
         check(obj_type !== 'wall' || tile_type === 'wall',
               `Wall item on not wall at ${x}, ${y}`);
         if (obj_type === 'door')
         {
           check(tile_type === 'wall', `Door on not wall at ${x}, ${y}`);
           tile_below = layers.Tiles.tileAt(x, y+1);
           check(tile_below == null || tile_below.property('type') !== 'wall',
                 `Place below door is wall at ${x}, ${y}`);
         }
       }
 
   if (was_error) tiled.alert('Validation failed, check issues for details');
 };
 
 {
   const act = tiled.registerAction('bc_validate', validate);
   act.text = 'Validate BC map';
   tiled.extendMenu('Map', [{action: 'bc_validate', before: 'MapProperties'}]);
 }
 
 {
   const imp = tiled.registerAction(
     'bc_from_clipboard', () => tiled.activeAsset = impor(read_clipboard()));
   imp.text = 'BC from clipboard';
   const exp = tiled.registerAction(
     'bc_to_clipboard', () => write_clipboard(expor(tiled.activeAsset)));
   exp.text = 'BC to clipboard';
   const exp2 = tiled.registerAction(
     'bc_to_clipboard2', () => write_clipboard(expor(tiled.activeAsset, false)));
   exp2.text = 'BC to clipboard (uncompressed)';
 
   tiled.extendMenu('File', [
     {action: 'bc_from_clipboard', before: 'Close'},
     {action: 'bc_to_clipboard'},
     {action: 'bc_to_clipboard2'},
     {separator: true},
   ]);
 }