create-mud 2.0.0-alpha.1.21 → 2.0.0-alpha.1.210

package/README.md

@@ -7,5 +7,5 @@ Create a new MUD project
 ## Usage
 
 ```bash
-yarn create mud <name>
+npm create mud <name>
 ```

package/dist/cli.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-"use strict";var t=require("create-create-app"),a=require("path");var e={name:"create-mud",version:"2.0.0-alpha.1.21+4ad66187",description:"Create a new MUD project",license:"MIT",author:"Lattice <mud@lattice.xyz>",bin:"dist/cli.js",files:["dist"],scripts:{build:"tsup src/cli.ts --minify && ./scripts/copy-templates.sh",clean:"rimraf dist",dev:"tsup src/cli.ts --watch",prepublishOnly:"npm run clean && npm run build",release:"npm publish --access=public",test:"pnpm test:minimal && pnpm test:react","test:minimal":"dist/cli.js test-project --template minimal && rimraf test-project","test:react":"dist/cli.js test-project --template react && rimraf test-project"},dependencies:{"create-create-app":"git+https://github.com/holic/create-create-app#74376c59b48a04aabbe94d9cacfe9cb1cecccd63"},devDependencies:{"@types/node":"^17.0.29",tsup:"^5.12.1",typescript:"^4.9.5"},publishConfig:{access:"public",registry:"https://registry.npmjs.org"},gitHead:"4ad661878bcf916a9ab7fd4d72d051b372af74c5"};var p=(0,a.resolve)(__dirname,"..","dist","templates");(0,t.create)("create-mud",{templateRoot:p,defaultTemplate:"minimal",defaultPackageManager:"pnpm",promptForDescription:!1,promptForAuthor:!1,promptForEmail:!1,promptForLicense:!1,promptForTemplate:!0,caveat:({answers:s,packageManager:r})=>`Done! Play in the MUD with \`cd ${s.name}\` and \`${r} run dev\``,extra:{"mud-version":{type:"input",describe:"The version of MUD packages to use, defaults to latest",default:e.version}}});
+"use strict";var t=require("create-create-app"),a=require("path");var e={name:"create-mud",version:"2.0.0-alpha.1.210+69c126a9",description:"Create a new MUD project",license:"MIT",author:"Lattice <mud@lattice.xyz>",bin:"dist/cli.js",files:["dist"],scripts:{build:"pnpm run build:js","build:js":"tsup && ./scripts/copy-templates.sh",clean:"pnpm run clean:js","clean:js":"rimraf dist",dev:"tsup --watch",prepublishOnly:"npm run clean && npm run build",test:"pnpm run test:vanilla && pnpm run test:react && pnpm run test:phaser && pnpm run test:threejs","test:phaser":"dist/cli.js test-project --template phaser && rimraf test-project","test:react":"dist/cli.js test-project --template react && rimraf test-project","test:threejs":"dist/cli.js test-project --template threejs && rimraf test-project","test:vanilla":"dist/cli.js test-project --template vanilla && rimraf test-project"},dependencies:{"create-create-app":"git+https://github.com/holic/create-create-app#74376c59b48a04aabbe94d9cacfe9cb1cecccd63"},devDependencies:{"@types/node":"^18.15.11",tsup:"^6.7.0",typescript:"^4.9.5"},publishConfig:{access:"public",registry:"https://registry.npmjs.org"},gitHead:"69c126a9e3d95a451b88d36c50e30279cc628a9d"};var c=(0,a.resolve)(__dirname,"..","dist","templates");(0,t.create)("create-mud",{templateRoot:c,defaultTemplate:"vanilla",defaultPackageManager:"pnpm",promptForDescription:!1,promptForAuthor:!1,promptForEmail:!1,promptForLicense:!1,promptForTemplate:!0,caveat:({answers:r,packageManager:s})=>`Done! Play in the MUD with \`cd ${r.name}\` and \`${s} run dev\``,extra:{"mud-version":{type:"input",describe:"The version of MUD packages to use, defaults to latest",default:e.version}}});

package/dist/templates/{minimal/packages/client → phaser}/.eslintrc

@@ -1,7 +1,5 @@
 {
-  "env": {
-    "node": true
-  },
+  "root": true,
   "parser": "@typescript-eslint/parser",
   "plugins": ["@typescript-eslint"],
   "extends": [

package/dist/templates/phaser/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "mud-template-phaser",
+  "private": true,
+  "scripts": {
+    "build": "pnpm recursive run build",
+    "dev": "concurrently -n contracts,client -c cyan,magenta \"cd packages/contracts && pnpm run dev\" \"cd packages/client && pnpm run dev\"",
+    "dev:client": "pnpm --filter 'client' run dev",
+    "dev:contracts": "pnpm --filter 'contracts' dev",
+    "foundry:up": "curl -L https://foundry.paradigm.xyz | bash && bash $HOME/.foundry/bin/foundryup",
+    "initialize": "pnpm recursive run initialize",
+    "mud:up": "pnpm recursive exec mud set-version -v canary && pnpm install",
+    "prepare": "(forge --version || pnpm foundry:up)",
+    "test": "pnpm recursive run test"
+  },
+  "devDependencies": {
+    "@latticexyz/cli": "{{mud-version}}",
+    "@typescript-eslint/eslint-plugin": "5.46.1",
+    "@typescript-eslint/parser": "5.46.1",
+    "concurrently": "^8.0.1",
+    "eslint": "8.29.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.9.5"
+  },
+  "engines": {
+    "node": "18.x",
+    "pnpm": "8.x"
+  }
+}

package/dist/templates/phaser/packages/art/README.md

@@ -0,0 +1,33 @@
+# Art Tooling
+
+This package provides a set of tools for working with sprite sheets and tilesets.
+
+## Sprites
+
+To create a new Sprite animation you need to define a new folder structure inside of the `sprites` folder. Inside of that folder, create a series of images defining the frames of the animation. The name of the folder will be the name of the animation. The names of the images should be the frame number.
+
+Example:
+```
+  sprites/
+    player/
+      walk/
+        0.png
+        1.png
+        2.png
+        3.png
+        4.png
+```
+
+## Tilesets
+
+Tilesets are generated using the (Tiled Map Editor)[https://www.mapeditor.org/]. An example is provided in `tilesets/world.tsx`.
+
+## Exporting
+
+Export does a few things:
+  1. Creates a single image sprite atlas for all of your animations
+  2. Creates an atlas manifest json file that maps the animation names to the frames in the atlas
+  3. Creates Typescript types for your Tilesets
+  4. Moves all created files into your game client package
+
+To export, run `pnpm export` from the root of this project.

package/dist/templates/phaser/packages/art/config-sprites.json

@@ -0,0 +1,21 @@
+{
+  "savePath": "../client/public/assets/atlases",
+  "folders": ["sprites"],
+  "images": [],
+  "packOptions": {
+    "allowTrim": false,
+    "textureName": "atlas",
+    "width": 2048,
+    "height": 2048,
+    "fixedSize": true,
+    "powerOfTwo": true,
+    "padding": 0,
+    "allowRotation": false,
+    "detectIdentical": true,
+    "exporter": "Phaser3",
+    "removeFileExtension": false,
+    "prependFolderName": true,
+    "packer": "MaxRectsPacker",
+    "method": "Smart"
+  }
+}

package/dist/templates/phaser/packages/art/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "art",
+  "version": "1.0.0",
+  "license": "MIT",
+  "types": "./types",
+  "scripts": {
+    "compile-extensions": "tsc ./tiled/extensions/*.ts --outDir ./tiled/extensions/",
+    "export": "yarn generate-multiatlas-sprites && yarn export-tiled-types",
+    "export-tiled-types": "ts-node ./scripts/export-tiled-types.ts && cp tilesets/images/* ../client/public/assets/tilesets/",
+    "generate-multiatlas-sprites": "node ./scripts/cli.mjs --project ./config-sprites.json"
+  },
+  "devDependencies": {
+    "@mapeditor/tiled-api": "^1.8.2",
+    "@types/ejs": "^3.1.1",
+    "@types/glob": "^7.2.0",
+    "@types/node": "^18.0.3",
+    "ejs": "^3.1.8",
+    "ethers": "^5.7.0",
+    "free-tex-packer-cli": "^0.3.0",
+    "free-tex-packer-core": "^0.3.4",
+    "glob": "^8.0.3",
+    "optimist": "^0.6.1",
+    "ts-node": "^10.8.2",
+    "typescript": "^4.7.4",
+    "xml-js": "^1.6.11"
+  }
+}

package/dist/templates/phaser/packages/art/scripts/cli.mjs

@@ -0,0 +1,190 @@
+import { existsSync, statSync, readdirSync, readFileSync, readFile, writeFileSync } from "fs";
+import { resolve, dirname } from "path";
+import optimist from "optimist";
+import chalk from "chalk";
+const { yellowBright, redBright, white, magentaBright, greenBright } = chalk;
+import texturePacker from "free-tex-packer-core";
+
+import appInfo from "../package.json" assert { type: "json" };
+
+function isExists(path) {
+  return existsSync(path);
+}
+
+function fixPath(path) {
+  return path.trim().split("\\").join("/");
+}
+
+function getNameFromPath(path) {
+  return path.trim().split("/").pop();
+}
+
+function isNumeric(str) {
+  if (typeof str != "string") return false; // we only process strings!
+  return (
+    !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+    !isNaN(parseFloat(str))
+  ); // ...and ensure strings of whitespace fail
+}
+
+function isFolder(path) {
+  if (isExists(path)) {
+    return statSync(path).isDirectory();
+  } else {
+    path = fixPath(path);
+    let name = getNameFromPath(path);
+    let parts = name.split(".");
+    return parts.length === 1;
+  }
+}
+
+function getFolderFilesList(dir, base = "", list = []) {
+  let files = readdirSync(dir);
+  for (let file of files) {
+    let p = resolve(dir, file);
+    if (isFolder(p) && p.toUpperCase().indexOf("__MACOSX") < 0) {
+      list = getFolderFilesList(p, base + file + "/", list);
+    } else {
+      list.push({
+        name: (base ? base : "") + file,
+        path: p,
+      });
+    }
+  }
+
+  return list;
+}
+
+function loadImages(images, files) {
+  for (let image of images) {
+    try {
+      files.push({ path: image.name, contents: readFileSync(image.path) });
+    } catch (e) {}
+  }
+}
+
+// console.log(yellowBright("Free Texture Packer CLI v" + _version));
+const argv = optimist.argv;
+
+let projectPath = argv.project;
+if (!projectPath) {
+  console.log(redBright("Choose project, using --project argument"));
+  process.exit();
+}
+
+readFile(projectPath, (err, content) => {
+  if (err) {
+    console.error(err.toString());
+    return;
+  }
+
+  content = content.toString();
+  let project = null;
+  try {
+    project = JSON.parse(content);
+  } catch (e) {
+    console.log(redBright("Unsupported project format " + projectPath));
+    process.exit();
+  }
+
+  let outputPath = argv.output;
+
+  if (!outputPath) {
+    outputPath = project.savePath;
+  }
+
+  if (!outputPath) {
+    outputPath = dirname(projectPath);
+  }
+
+  let files = [];
+
+  loadImages(project.images, files);
+
+  for (let folder of project.folders) {
+    if (isExists(folder)) {
+      let list = getFolderFilesList(folder, getNameFromPath(folder) + "/");
+      loadImages(list, files);
+    }
+  }
+
+  let options = project.packOptions;
+
+  //Map exporters to core format
+  if (options.exporter === "JSON (hash)") options.exporter = "JsonHash";
+  if (options.exporter === "JSON (array)") options.exporter = "JsonArray";
+  if (options.exporter === "XML") options.exporter = "XML";
+  if (options.exporter === "css (modern)") options.exporter = "Css";
+  if (options.exporter === "css (old)") options.exporter = "OldCss";
+  if (options.exporter === "pixi.js") options.exporter = "Pixi";
+  if (options.exporter === "Phaser (hash)") options.exporter = "PhaserHash";
+  if (options.exporter === "Phaser (array)") options.exporter = "PhaserArray";
+  if (options.exporter === "Phaser 3") options.exporter = "Phaser3";
+  if (options.exporter === "Spine") options.exporter = "Spine";
+  if (options.exporter === "cocos2d") options.exporter = "Cocos2d";
+  if (options.exporter === "UnrealEngine") options.exporter = "Unreal";
+  if (options.exporter === "Starling") options.exporter = "Starling";
+  if (options.exporter === "Unity3D") options.exporter = "Unity3D";
+  if (options.exporter === "Godot (atlas)") options.exporter = "GodotAtlas";
+  if (options.exporter === "Godot (tileset)") options.exporter = "GodotTileset";
+
+  if (options.exporter === "custom") {
+    console.log(redBright("CLI does not support a custom exporter"));
+    process.exit();
+  }
+
+  options.appInfo = appInfo;
+
+  console.log(white("Start packing ") + magentaBright(projectPath));
+  
+  texturePacker(files, options, (f, error) => {
+    if (error) {
+      console.log(redBright(error));
+      process.exit();
+    }
+
+    let outputJson = {
+      meta: {
+        app: "",
+        version: "1.0.0",
+      },
+    };
+    const textures = [];
+    let lastImageName;
+    for (const file of f) {
+      if (file.name.includes(".json")) {
+        const outJson = file.buffer.toString("utf-8", 0, file.buffer.length);
+        const out = JSON.parse(outJson);
+        textures.push(out.textures[0]);
+        console.log(
+          white("Adding to output json ") + greenBright(file.name)
+        );
+      } else {
+        lastImageName = file.name;
+        let out = resolve(outputPath, file.name);
+        console.log(white("Writing ") + greenBright(out));
+        writeFileSync(out, file.buffer);
+      }
+    }
+    const fileName = lastImageName.split(".")[0];
+    let jsonFileName;
+    if (isNumeric(fileName[fileName.length - 1])) {
+      console.log("multipart detected!!");
+      jsonFileName = fileName.split("-")[0] + ".json";
+    } else {
+      jsonFileName = fileName + ".json";
+    }
+    const atlasJsonOut = resolve(outputPath, jsonFileName);
+    // sort textures
+    textures.sort((a, b) => a.image.localeCompare(b.image));
+    outputJson.textures = textures;
+    // add timestamp to atlas image to avoid browser cache
+    outputJson.textures[0].image = "atlas.png?timestamp=" + Date.now();
+    writeFileSync(
+      atlasJsonOut,
+      Buffer.from(JSON.stringify(outputJson, null, 4), "utf-8")
+    );
+
+    console.log(yellowBright("Done"));
+  });
+});

package/dist/templates/phaser/packages/art/scripts/export-tiled-types.ts

@@ -0,0 +1,292 @@
+import xlmJs from "xml-js";
+import fs from "fs";
+import glob from "glob";
+import ejs from "ejs";
+import path from "path";
+
+const tilemaps = glob.sync("./tilesets/*.tsx");
+enum PropertyName {
+  Name = "name",
+  Frame = "frame",
+}
+interface Tile {
+  index: number;
+  name: string;
+  frameNumber?: number;
+}
+
+interface WangTile {
+  index: number;
+  wangId: number;
+}
+
+interface WangSet {
+  name: string;
+  wangTiles: WangTile[];
+}
+
+interface AnimatedTile {
+  name: string;
+  frames: number[];
+}
+
+interface Tilemap {
+  name: string;
+  tiles?: Tile[];
+  animatedTiles?: AnimatedTile[];
+  wangSets?: WangSet[];
+}
+
+const dumpObjectAsError = (obj: any) =>
+  console.error(JSON.stringify(obj, null, 2));
+
+const readTilemap = (filename: string) => {
+  const content = fs.readFileSync(filename, { encoding: "utf-8" });
+  const tilemapParsed = xlmJs.xml2js(content, { compact: true });
+  return tilemapParsed;
+};
+
+const capitalize = (s: string) => {
+  return `${s[0].toUpperCase()}${s.slice(1)}`;
+};
+interface WithName {
+  name: string;
+}
+function removeDuplicate<A extends WithName>(v: A, i: number, a: A[]) {
+  return a.findIndex((v2) => v2.name === v.name) === i;
+}
+
+const kebabToCamel = (kebab: string) => {
+  const parts = kebab.split("-");
+  let s = parts[0];
+  for (const p of parts.slice(1)) {
+    s = s + capitalize(p);
+  }
+  return s;
+};
+
+const processTilemap = (filename: string) => {
+  const name = kebabToCamel(filename.split(path.sep).at(-1)!.split(".")[0]);
+  console.log(`Processing ${name}`);
+  const tilemap = readTilemap(filename);
+  const elements = parseTilemap(name, tilemap);
+  return elements;
+};
+
+const parseTilemap = (name: string, tilemap: xlmJs.ElementCompact): Tilemap => {
+  const tileset = tilemap.tileset;
+  const tiles = tileset.tile;
+  const wangsets = tileset.wangsets?.wangset;
+  let tileObjects;
+  let animatedTiles;
+  let wangsetObjects;
+  if (tiles) {
+    if (Array.isArray(tiles)) {
+      console.log(`Parsing ${tiles.length} tiles`);
+      tileObjects = tiles.filter(checkTile).map(parseTile);
+      animatedTiles = buildAnimatedTileList(tileObjects);
+      console.log(`Found ${animatedTiles.length} animated tiles`);
+      tileObjects = tileObjects.filter((t: Tile) => !t.frameNumber);
+      console.log(`Found ${tileObjects.length} tiles`);
+    } else {
+      console.log(`Parsing 1 tile`);
+      tileObjects = [tiles].filter(checkTile).map(parseTile);
+      animatedTiles = buildAnimatedTileList(tileObjects);
+      console.log(`Found ${animatedTiles.length} animated tiles`);
+      tileObjects = tileObjects.filter((t: Tile) => !t.frameNumber);
+      console.log(`Found ${tileObjects.length} tiles`);
+    }
+  }
+  if (wangsets) {
+    if (Array.isArray(wangsets)) {
+      console.log(`Parsing ${wangsets.length} wangsets`);
+      wangsetObjects = wangsets.map(parseWangset);
+    } else {
+      console.log(`Parsing 1 wangset`);
+      wangsetObjects = [parseWangset(wangsets)];
+    }
+  }
+  return {
+    name,
+    tiles: tileObjects?.filter(removeDuplicate),
+    animatedTiles: animatedTiles?.filter(removeDuplicate),
+    wangSets: wangsetObjects?.filter(removeDuplicate),
+  };
+};
+
+const findProperty = (element: xlmJs.ElementCompact, name: string) => {
+  const properties: any = element.properties;
+  const property = properties.property;
+  if (Array.isArray(property)) {
+    for (const p of property) {
+      const n = p._attributes.name;
+      if (n === name) {
+        return p._attributes.value;
+      }
+    }
+  } else {
+    const n = property._attributes.name;
+    if (n === name) {
+      return property._attributes.value;
+    }
+  }
+};
+
+const checkTile = (tile: xlmJs.ElementCompact): boolean => {
+  const indexUnparsed = tile._attributes!.id!;
+  const index =
+    indexUnparsed != undefined && typeof indexUnparsed === "string"
+      ? parseInt(indexUnparsed)
+      : undefined;
+  if (index == undefined) {
+    return false;
+  }
+  const name: string | undefined = findProperty(tile, PropertyName.Name);
+  if (!name) {
+    return false;
+  }
+  return true;
+};
+
+const parseTile = (tile: xlmJs.ElementCompact) => {
+  const indexUnparsed = tile._attributes!.id!;
+  const index =
+    indexUnparsed && typeof indexUnparsed === "string"
+      ? parseInt(indexUnparsed)
+      : undefined;
+  if (index == undefined) {
+    dumpObjectAsError(tile);
+    throw new Error("Tile has no index!");
+  }
+  const name: string | undefined = findProperty(tile, PropertyName.Name);
+  if (!name) {
+    dumpObjectAsError(tile);
+    throw new Error("Tile has no name!");
+  }
+  const frameNumberUnparsed = findProperty(tile, PropertyName.Frame);
+  const frameNumber = frameNumberUnparsed != undefined
+    ? parseInt(frameNumberUnparsed)
+    : undefined;
+  const tileObject: Tile = {
+    index,
+    name,
+    frameNumber,
+  };
+  return tileObject;
+};
+
+const parseWangtile = (wangtile: xlmJs.ElementCompact): WangTile => {
+  const indexUnparsed = wangtile._attributes!.tileid!;
+  const index =
+    indexUnparsed !== undefined && typeof indexUnparsed === "string"
+      ? parseInt(indexUnparsed)
+      : undefined;
+  if (index == undefined) {
+    dumpObjectAsError(wangtile);
+    throw new Error("Wangtile has no tileid!");
+  }
+
+  const wangIdUnparsed = wangtile._attributes!.wangid!;
+  if ((wangIdUnparsed == undefined) || typeof wangIdUnparsed !== "string") {
+    dumpObjectAsError(wangtile);
+    throw new Error("Wangtile has no tileid!");
+  }
+  const binaryString = wangIdUnparsed.split(",").reverse().join("");
+  const wangId = parseInt(binaryString, 2);
+  return {
+    index,
+    wangId,
+  };
+};
+
+const parseWangset = (wangset: xlmJs.ElementCompact): WangSet => {
+  const name = wangset._attributes!.name!;
+  if (!name || typeof name !== "string") {
+    dumpObjectAsError(wangset);
+    throw new Error("Wangset has no name!");
+  }
+  const wangtiles = wangset.wangtile;
+  const wangtileObjects = wangtiles.map(parseWangtile);
+  return {
+    name,
+    wangTiles: wangtileObjects,
+  };
+};
+
+const buildAnimatedTileList = (tileObjects: Tile[]) => {
+  const animatedTiles: AnimatedTile[] = [];
+  const tilesWithSameNameAndFrameNumber: { [key: string]: Tile[] } = {};
+  for (const tile of tileObjects) {
+    if (tile.name && tile.frameNumber !== undefined) {
+      if (tilesWithSameNameAndFrameNumber[tile.name]) {
+        tilesWithSameNameAndFrameNumber[tile.name].push(tile);
+      } else {
+        tilesWithSameNameAndFrameNumber[tile.name] = [tile];
+      }
+    }
+  }
+  for (const [k, v] of Object.entries(tilesWithSameNameAndFrameNumber)) {
+    animatedTiles.push({
+      frames: v
+        .sort((a, b) => a.frameNumber! - b.frameNumber!)
+        .map((t) => t.index),
+      name: k,
+    });
+  }
+  return animatedTiles;
+};
+
+const tilemapObjects = tilemaps.map(processTilemap);
+
+const TILEMAP_TYPE_TEMPLATE = `// GENERATED CODE - DO NOT MODIFY BY HAND
+
+<% if(tiles){ -%>
+export enum Tileset {
+<% tiles.forEach(tile => { -%>
+  <%= tile.name %> = <%= tile.index %>,
+<% }) -%>
+}
+<% } -%>
+<% if(animatedTiles){ -%>
+export enum TileAnimationKey {
+<% animatedTiles.forEach(animatedTile => { -%>
+  <%= animatedTile.name %> = "<%= animatedTile.name %>",
+<% }) -%>
+}
+export const TileAnimations: { [key in TileAnimationKey]: number[] } = {
+<% animatedTiles.forEach(animatedTile => { -%>
+  [TileAnimationKey.<%= animatedTile.name %>]: [<%= animatedTile.frames.join(", ") %>],
+<% }) -%>
+};
+<% } -%>
+<% if(wangSets){ -%>
+export enum WangSetKey {
+<% wangSets.forEach(wangSet => { -%>
+  <%= wangSet.name %> = "<%= wangSet.name %>",
+<% }) -%>
+}
+export const WangSets: { [key in WangSetKey]: { [key: number]: number } } = {
+<% wangSets.forEach(wangSet => { -%>
+  [WangSetKey.<%= wangSet.name %>]: {
+  <% wangSet.wangTiles.forEach(wangTile => { -%>
+    <%= wangTile.wangId %>: <%= wangTile.index %>,
+  <% }) -%>
+  },
+<% }) -%>
+};
+<% } -%>`;
+
+const renderTilemapTypes = (tilemap: Tilemap) => {
+  return ejs.render(TILEMAP_TYPE_TEMPLATE, tilemap);
+};
+
+const tilemapTypes = tilemapObjects.map((t) => ({
+  type: renderTilemapTypes(t),
+  name: t.name,
+}));
+for (const tilemapType of tilemapTypes) {
+  fs.writeFileSync(
+    path.join(__dirname, "..", "..", "client", "src", "artTypes", `${tilemapType.name}.ts`),
+    tilemapType.type
+  );
+}

package/dist/templates/phaser/packages/art/tilesets/world.tsx

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tileset version="1.9" tiledversion="1.9.0" name="world" tilewidth="32" tileheight="32" tilecount="3" columns="3">
+ <image source="images/world.png" width="96" height="32"/>
+ <tile id="0">
+  <properties>
+   <property name="name" value="Grass"/>
+  </properties>
+ </tile>
+ <tile id="1">
+  <properties>
+   <property name="name" value="Mountain"/>
+  </properties>
+ </tile>
+ <tile id="2">
+  <properties>
+   <property name="name" value="Forest"/>
+  </properties>
+ </tile>
+</tileset>