BlueGit

timfa raytracer

Files

raytracer / src / levelFormat.js

levelFormat.js

levelFormat.js 6.5 KiB Download Raw
1/**
2 * Level pack format (schema v1) for raytracer + editor.
3 * walls: tile type ids; floors/ceilings: texture id string or null (black).
4 * lights: reserved list (not rendered yet).
5 */
6var LevelFormat =
7{
8 CURRENT_VERSION: 1,
9 MAX_SIZE: 128,
10 MAX_LEVELS: 64,
11 KNOWN_TEXTURES: ["stone", "wood"],
12
13 emptyLevel: function (name, width, height)
14 {
15 width = Math.max(3, Math.min(this.MAX_SIZE, width || 10));
16 height = Math.max(3, Math.min(this.MAX_SIZE, height || 10));
17 var n = width * height;
18 var walls = [];
19 var floors = [];
20 var ceilings = [];
21 for (var i = 0; i < n; i++)
22 {
23 var x = i % width;
24 var y = Math.floor(i / width);
25 var border = x === 0 || y === 0 || x === width - 1 || y === height - 1;
26 walls.push(border ? 1 : 0);
27 floors.push(border ? null : "stone");
28 ceilings.push(border ? null : "stone");
29 }
30 return {
31 id: "level-" + Date.now().toString(36),
32 name: name || "Nieuw level",
33 width: width,
34 height: height,
35 cellSize: 32,
36 spawn: { tileX: 1, tileY: 1, yawRad: 0 },
37 walls: walls,
38 floors: floors,
39 ceilings: ceilings,
40 npcs: [],
41 lights: []
42 };
43 },
44
45 defaultPack: function ()
46 {
47 return {
48 format_version: this.CURRENT_VERSION,
49 textures: [
50 { id: "stone", url: "images/stone.png" },
51 { id: "wood", url: "images/wood.png" }
52 ],
53 levels: []
54 };
55 },
56
57 /** Migrate legacy Levels[] (tiles only) into a pack. */
58 fromLegacyLevels: function (legacyArr, npcsByLevel)
59 {
60 var pack = this.defaultPack();
61 for (var i = 0; i < (legacyArr || []).length; i++)
62 {
63 var L = legacyArr[i];
64 var n = L.width * L.height;
65 var floors = [];
66 var ceilings = [];
67 for (var t = 0; t < n; t++)
68 {
69 var solid = L.tiles[t] === 1 || L.tiles[t] === 3;
70 floors.push(solid ? null : "stone");
71 ceilings.push(solid ? null : "stone");
72 }
73 pack.levels.push({
74 id: "level-" + (i + 1),
75 name: L.name || ("Level " + (i + 1)),
76 width: L.width,
77 height: L.height,
78 cellSize: 32,
79 spawn: {
80 tileX: L.spawnX,
81 tileY: L.spawnY,
82 yawRad: 0
83 },
84 walls: L.tiles.slice(),
85 floors: floors,
86 ceilings: ceilings,
87 npcs: (npcsByLevel && npcsByLevel[i]) || [],
88 lights: []
89 });
90 }
91 return pack;
92 },
93
94 validateTextureId: function (tex, allowNull)
95 {
96 if (tex == null || tex === "")
97 { return !!allowNull; }
98 return this.KNOWN_TEXTURES.indexOf(tex) >= 0;
99 },
100
101 validateLevel: function (level, index)
102 {
103 var prefix = "level[" + (index == null ? "?" : index) + "]";
104 if (!level || typeof level !== "object")
105 { throw new Error(prefix + ": moet een object zijn"); }
106 if (!level.id || typeof level.id !== "string")
107 { throw new Error(prefix + ": id verplicht"); }
108 if (!level.name || typeof level.name !== "string")
109 { throw new Error(prefix + ": name verplicht"); }
110 var w = level.width | 0;
111 var h = level.height | 0;
112 if (w < 3 || h < 3 || w > this.MAX_SIZE || h > this.MAX_SIZE)
113 { throw new Error(prefix + ": width/height 3.." + this.MAX_SIZE); }
114 var n = w * h;
115 if (!Array.isArray(level.walls) || level.walls.length !== n)
116 { throw new Error(prefix + ": walls lengte ≠ width*height"); }
117 if (!Array.isArray(level.floors) || level.floors.length !== n)
118 { throw new Error(prefix + ": floors lengte ≠ width*height"); }
119 if (!Array.isArray(level.ceilings) || level.ceilings.length !== n)
120 { throw new Error(prefix + ": ceilings lengte ≠ width*height"); }
121 for (var i = 0; i < n; i++)
122 {
123 var wall = level.walls[i];
124 if (typeof wall !== "number" || wall !== (wall | 0) || wall < 0 || wall > 3)
125 { throw new Error(prefix + ": walls[" + i + "] ongeldig"); }
126 if (!this.validateTextureId(level.floors[i], true))
127 { throw new Error(prefix + ": floors[" + i + "] onbekende textuur"); }
128 if (!this.validateTextureId(level.ceilings[i], true))
129 { throw new Error(prefix + ": ceilings[" + i + "] onbekende textuur"); }
130 }
131 if (!level.spawn || typeof level.spawn.tileX !== "number" || typeof level.spawn.tileY !== "number")
132 { throw new Error(prefix + ": spawn.tileX/tileY verplicht"); }
133 if (level.spawn.tileX < 0 || level.spawn.tileY < 0 || level.spawn.tileX >= w || level.spawn.tileY >= h)
134 { throw new Error(prefix + ": spawn buiten de map"); }
135 if (typeof level.spawn.yawRad !== "number")
136 { level.spawn.yawRad = 0; }
137 if (!Array.isArray(level.npcs))
138 { throw new Error(prefix + ": npcs moet een array zijn"); }
139 if (!Array.isArray(level.lights))
140 { level.lights = []; }
141 if (level.cellSize == null)
142 { level.cellSize = 32; }
143 return level;
144 },
145
146 validatePack: function (pack)
147 {
148 if (!pack || typeof pack !== "object")
149 { throw new Error("pack: root moet een object zijn"); }
150 var ver = pack.format_version;
151 if (ver !== 1)
152 { throw new Error("pack: format_version " + ver + " niet ondersteund (wel: 1)"); }
153 if (!Array.isArray(pack.levels))
154 { throw new Error("pack: levels moet een array zijn"); }
155 if (pack.levels.length > this.MAX_LEVELS)
156 { throw new Error("pack: te veel levels"); }
157 if (pack.levels.length < 1)
158 { throw new Error("pack: minstens één level"); }
159 var ids = {};
160 for (var i = 0; i < pack.levels.length; i++)
161 {
162 this.validateLevel(pack.levels[i], i);
163 if (ids[pack.levels[i].id])
164 { throw new Error("pack: dubbele level-id " + pack.levels[i].id); }
165 ids[pack.levels[i].id] = true;
166 }
167 if (!Array.isArray(pack.textures))
168 { pack.textures = this.defaultPack().textures; }
169 return pack;
170 },
171
172 parse: function (jsonText)
173 {
174 var doc;
175 try
176 { doc = typeof jsonText === "string" ? JSON.parse(jsonText) : jsonText; }
177 catch (e)
178 { throw new Error("levels.json: ongeldige JSON (" + e.message + ")"); }
179 return this.validatePack(doc);
180 },
181
182 /** Runtime view used by World (tiles = walls). */
183 toRuntimeLevel: function (level)
184 {
185 return {
186 id: level.id,
187 name: level.name,
188 width: level.width,
189 height: level.height,
190 cellSize: level.cellSize || 32,
191 spawnX: level.spawn.tileX,
192 spawnY: level.spawn.tileY,
193 spawnYaw: level.spawn.yawRad || 0,
194 tiles: level.walls,
195 floors: level.floors,
196 ceilings: level.ceilings,
197 npcs: level.npcs || [],
198 lights: level.lights || []
199 };
200 },
201
202 findLevelIndex: function (pack, query)
203 {
204 if (query == null || query === "")
205 { return 0; }
206 var asNum = Number(query);
207 if (!isNaN(asNum) && asNum === (asNum | 0) && asNum >= 0 && asNum < pack.levels.length)
208 { return asNum; }
209 for (var i = 0; i < pack.levels.length; i++)
210 {
211 if (pack.levels[i].id === query || pack.levels[i].name === query)
212 { return i; }
213 }
214 return -1;
215 },
216
217 cloneLevel: function (level)
218 {
219 return JSON.parse(JSON.stringify(level));
220 }
221};
222
223if (typeof module !== "undefined" && module.exports)
224{ module.exports = LevelFormat; }