binaries/data/mods/public/maps/random/rmgen/map.js

   1 /**
   2  * Class for holding map data and providing basic API to change it
   3  *
   4  * @param {int} [size] - Size of the map in tiles
   5  * @param {float} [baseHeight] - Starting height of the map
   6  */
   7 function Map(size, baseHeight)
   8 {
   9         // Size must be 0 to 1024, divisible by patches
  10         this.size = size;
  11
  12         // Create 2D arrays for textures, object, and areas
  13         this.texture = [];
  14         this.terrainObjects = [];
  15         this.area = [];
  16
  17         for (let i = 0; i < size; ++i)
  18         {
  19                 // Texture IDs
  20                 this.texture[i] = new Uint16Array(size);
  21                 // Entities
  22                 this.terrainObjects[i] = [];
  23                 // Area IDs
  24                 this.area[i] = new Uint16Array(size);
  25
  26                 for (let j = 0; j < size; ++j)
  27                         this.terrainObjects[i][j] = [];
  28         }
  29
  30         // Create 2D array for heightmap
  31         let mapSize = size;
  32         if (!TILE_CENTERED_HEIGHT_MAP)
  33                 ++mapSize;
  34
  35         this.height = [];
  36         for (let i = 0; i < mapSize; ++i)
  37         {
  38                 this.height[i] = new Float32Array(mapSize);
  39
  40                 for (let j = 0; j < mapSize; ++j)
  41                         this.height[i][j] = baseHeight;
  42         }
  43
  44         // Create name <-> id maps for textures
  45         this.nameToID = {};
  46         this.IDToName = [];
  47
  48         // Array of objects (entitys/actors)
  49         this.objects = [];
  50         // Array of integers
  51         this.tileClasses = [];
  52
  53         this.areaID = 0;
  54
  55         // Starting entity ID, arbitrary number to leave some space for player entities
  56         this.entityCount = 150;
  57 }
  58
  59 Map.prototype.initTerrain = function(baseTerrain)
  60 {
  61         for (let i = 0; i < this.size; ++i)
  62                 for (let j = 0; j < this.size; ++j)
  63                         baseTerrain.place(i, j);
  64 };
  65
  66 // Return ID of texture (by name)
  67 Map.prototype.getTextureID = function(texture)
  68 {
  69         if (texture in this.nameToID)
  70                 return this.nameToID[texture];
  71
  72         // Add new texture
  73         let id = this.IDToName.length;
  74         this.nameToID[texture] = id;
  75         this.IDToName[id] = texture;
  76
  77         return id;
  78 };
  79
  80 // Return next free entity ID
  81 Map.prototype.getEntityID = function()
  82 {
  83         return this.entityCount++;
  84 };
  85
  86 // Check bounds on tile map
  87 Map.prototype.validT = function(x, z, distance = 0)
  88 {
  89         distance += MAP_BORDER_WIDTH;
  90
  91         if (g_MapSettings.CircularMap)
  92         {
  93                 let halfSize = Math.floor(this.size / 2);
  94                 return Math.round(Math.euclidDistance2D(x, z, halfSize, halfSize)) < halfSize - distance - 1;
  95         }
  96         else
  97                 return x >= distance && z >= distance && x < this.size - distance && z < this.size - distance;
  98 };
  99
 100 // Check bounds on tile map
 101 Map.prototype.inMapBounds = function(x, z)
 102 {
 103         return x >= 0 && z >= 0 && x < this.size && z < this.size;
 104 };
 105
 106 // Check bounds on height map if TILE_CENTERED_HEIGHT_MAP==true then it's (size, size) otherwise (size + 1 by size + 1)
 107 Map.prototype.validH = function(x, z)
 108 {
 109         if (x < 0 || z < 0)
 110                 return false;
 111         if (TILE_CENTERED_HEIGHT_MAP)
 112                 return x < this.size && z < this.size;
 113         return x <= this.size && z <= this.size;
 114 };
 115
 116 // Check bounds on tile class
 117 Map.prototype.validClass = function(c)
 118 {
 119         return c >= 0 && c < this.tileClasses.length;
 120 };
 121
 122 Map.prototype.getTexture = function(x, z)
 123 {
 124         if (!this.validT(x, z))
 125                 throw new Error("getTexture: invalid tile position (" + x + ", " + z + ")");
 126
 127         return this.IDToName[this.texture[x][z]];
 128 };
 129
 130 Map.prototype.setTexture = function(x, z, texture)
 131 {
 132         if (!this.validT(x, z))
 133                 throw new Error("setTexture: invalid tile position (" + x + ", " + z + ")");
 134
 135         this.texture[x][z] = this.getTextureID(texture);
 136 };
 137
 138 Map.prototype.getHeight = function(x, z)
 139 {
 140         if (!this.validH(x, z))
 141                 throw new Error("getHeight: invalid vertex position (" + x + ", " + z + ")");
 142
 143         return this.height[x][z];
 144 };
 145
 146 Map.prototype.setHeight = function(x, z, height)
 147 {
 148         if (!this.validH(x, z))
 149                 throw new Error("setHeight: invalid vertex position (" + x + ", " + z + ")");
 150
 151         this.height[x][z] = height;
 152 };
 153
 154 Map.prototype.getTerrainObjects = function(x, z)
 155 {
 156         if (!this.validT(x, z))
 157                 throw new Error("getTerrainObjects: invalid tile position (" + x + ", " + z + ")");
 158
 159         return this.terrainObjects[x][z];
 160 };
 161
 162 Map.prototype.setTerrainObject = function(x, z, object)
 163 {
 164         if (!this.validT(x, z))
 165                 throw new Error("setTerrainObject: invalid tile position (" + x + ", " + z + ")");
 166
 167         this.terrainObjects[x][z] = object;
 168 };
 169
 170 Map.prototype.placeTerrain = function(x, z, terrain)
 171 {
 172         terrain.place(x, z);
 173 };
 174
 175 Map.prototype.addObject = function(obj)
 176 {
 177         this.objects.push(obj);
 178 };
 179
 180 Map.prototype.createArea = function(placer, painter, constraint)
 181 {
 182         // Check for multiple painters
 183         if (painter instanceof Array)
 184                 painter = new MultiPainter(painter);
 185
 186         if (constraint === undefined || constraint === null)
 187                 constraint = new NullConstraint();
 188         else if (constraint instanceof Array)
 189                 // Check for multiple constraints
 190                 constraint = new AndConstraint(constraint);
 191
 192         let points = placer.place(constraint);
 193         if (!points)
 194                 return undefined;
 195
 196         let newID = ++this.areaID;
 197         let area = new Area(points, newID);
 198         for (let p of points)
 199                 this.area[p.x][p.z] = newID;
 200
 201         painter.paint(area);
 202
 203         return area;
 204 };
 205
 206 Map.prototype.createObjectGroup = function(placer, player, constraint)
 207 {
 208         // Check for null constraint
 209         if (constraint === undefined || constraint === null)
 210                 constraint = new NullConstraint();
 211         else if (constraint instanceof Array)
 212                 constraint = new AndConstraint(constraint);
 213
 214         return placer.place(player, constraint);
 215 };
 216
 217 Map.prototype.createTileClass = function()
 218 {
 219         let newID = this.tileClasses.length;
 220         this.tileClasses.push(new TileClass(this.size, newID));
 221
 222         return newID;
 223 };
 224
 225 // Get height taking into account terrain curvature
 226 Map.prototype.getExactHeight = function(x, z)
 227 {
 228         let xi = Math.min(Math.floor(x), this.size);
 229         let zi = Math.min(Math.floor(z), this.size);
 230         let xf = x - xi;
 231         let zf = z - zi;
 232
 233         let h00 = this.height[xi][zi];
 234         let h01 = this.height[xi][zi + 1];
 235         let h10 = this.height[xi + 1][zi];
 236         let h11 = this.height[xi + 1][zi + 1];
 237
 238         return (1 - zf) * ((1 - xf) * h00 + xf * h10) + zf * ((1 - xf) * h01 + xf * h11);
 239 };
 240
 241 // Converts from the tile centered height map to the corner based height map, used when TILE_CENTERED_HEIGHT_MAP = true
 242 Map.prototype.cornerHeight = function(x, z)
 243 {
 244         let count = 0;
 245         let sumHeight = 0;
 246
 247         for (let dir of [[-1, -1], [-1, 0], [0, -1], [0, 0]])
 248                 if (this.validH(x + dir[0], z + dir[1]))
 249                 {
 250                         ++count;
 251                         sumHeight += this.height[x + dir[0]][z + dir[1]];
 252                 }
 253
 254         if (count == 0)
 255                 return 0;
 256
 257         return sumHeight / count;
 258 };
 259
 260 Map.prototype.getFullEntityList = function(rotateForMapExport = false)
 261 {
 262         // Change rotation from simple 2d to 3d befor giving to engine
 263         if (rotateForMapExport)
 264                 for (let obj of this.objects)
 265                         obj.rotation.y = PI / 2 - obj.rotation.y;
 266
 267         // All non terrain objects
 268         let entities = this.objects;
 269
 270         // Terrain objects e.g. trees
 271         let size = this.size;
 272         for (let x = 0; x < size; ++x)
 273                 for (let z = 0; z < size; ++z)
 274                         if (this.terrainObjects[x][z] !== undefined)
 275                                 entities.push(this.terrainObjects[x][z]);
 276
 277         return entities;
 278 };
 279
 280 Map.prototype.getMapData = function()
 281 {
 282         let data = {};
 283
 284         // Convert 2D heightmap array to flat array
 285         // Flat because it's easier to handle by the engine
 286         let mapSize = this.size + 1;
 287         let height = new Uint16Array(mapSize * mapSize);
 288         for (let x = 0; x < mapSize; ++x)
 289                 for (let z = 0; z < mapSize; ++z)
 290                 {
 291                         let currentHeight;
 292                         if (TILE_CENTERED_HEIGHT_MAP)
 293                                 currentHeight = this.cornerHeight(x, z);
 294                         else
 295                                 currentHeight = this.height[x][z];
 296
 297                         // Correct height by SEA_LEVEL and prevent under/overflow in terrain data
 298                         height[z * mapSize + x] = Math.max(0, Math.min(0xFFFF, Math.floor((currentHeight + SEA_LEVEL) * HEIGHT_UNITS_PER_METRE)));
 299                 }
 300
 301         data.height = height;
 302         data.seaLevel = SEA_LEVEL;
 303
 304         // Terrain, map width in tiles
 305         data.size = this.size;
 306
 307         // Get array of textures used in this map
 308         data.textureNames = this.IDToName;
 309
 310         // Entities
 311         data.entities = this.getFullEntityList(true);
 312         log("Number of entities: "+ data.entities.length);
 313
 314         //  Convert 2D tile data to flat array
 315         let tileIndex = new Uint16Array(this.size * this.size);
 316         let tilePriority = new Uint16Array(this.size * this.size);
 317         for (let x = 0; x < this.size; ++x)
 318                 for (let z = 0; z < this.size; ++z)
 319                 {
 320                         // TODO: For now just use the texture's index as priority, might want to do this another way
 321                         tileIndex[z * this.size + x] = this.texture[x][z];
 322                         tilePriority[z * this.size + x] = this.texture[x][z];
 323                 }
 324
 325         data.tileData = { "index": tileIndex, "priority": tilePriority };
 326
 327         return data;
 328 };