BlueGit

timfa raytracer

Files

raytracer / src / world.js

world.js

world.js 4.0 KiB Download Raw
1var World =
2{
3 size: 32,
4 level: null,
5 pack: null,
6 levelIndex: 0,
7
8 loadPack: function (pack)
9 {
10 this.pack = pack;
11 },
12
13 loadLevel: function (indexOrId)
14 {
15 if (!this.pack)
16 { throw new Error("World: geen level-pack geladen"); }
17 var idx = typeof indexOrId === "number"
18 ? indexOrId
19 : LevelFormat.findLevelIndex(this.pack, indexOrId);
20 if (idx < 0 || idx >= this.pack.levels.length)
21 { throw new Error("World: level niet gevonden: " + indexOrId); }
22 this.levelIndex = idx;
23 this.level = LevelFormat.toRuntimeLevel(this.pack.levels[idx]);
24 this.size = this.level.cellSize || 32;
25 },
26
27 spawnPoint: function ()
28 {
29 return {
30 x: this.level.spawnX * this.size + this.size / 2,
31 y: this.level.spawnY * this.size + this.size / 2,
32 yaw: this.level.spawnYaw || 0
33 };
34 },
35
36 rayCast: function (x, y, radian)
37 {
38 var maxDist = this.level.width + this.level.height;
39 var cell = this.size;
40 var tileXpercentage = 0;
41 var tileXp = 0;
42 var tileYp = 0;
43
44 var hrayX, hrayY, hoffX, hoffY, distDone, hmapX, hmapY, htileHit;
45 var hDir = "north";
46 distDone = 0;
47 var aTan = -1 / Math.tan(radian);
48
49 if (radian > Math.PI)
50 {
51 hrayY = Math.floor(y / cell) * cell - 0.01;
52 hrayX = (y - hrayY) * aTan + x;
53 hoffY = -cell;
54 hoffX = -hoffY * aTan;
55 }
56 else if (radian < Math.PI)
57 {
58 hrayY = Math.floor(y / cell) * cell + cell;
59 hrayX = (y - hrayY) * aTan + x;
60 hoffY = cell;
61 hoffX = -hoffY * aTan;
62 hDir = "south";
63 }
64 else
65 {
66 hrayX = x;
67 hrayY = y;
68 distDone = maxDist;
69 }
70
71 while (distDone < maxDist)
72 {
73 tileXp = ((hrayX % cell) + cell) % cell / cell;
74 tileYp = ((hrayY % cell) + cell) % cell / cell;
75 hmapX = Math.floor(hrayX / cell);
76 hmapY = Math.floor(hrayY / cell);
77 var htileHitId = this.level.tiles[hmapX + hmapY * this.level.width];
78 htileHit = Tiles.findByID(htileHitId);
79 if (htileHit && htileHit.Solid)
80 { distDone = maxDist; }
81 else
82 {
83 hrayX += hoffX;
84 hrayY += hoffY;
85 distDone += 1;
86 }
87 }
88
89 switch (hDir)
90 {
91 case "north": tileXpercentage = tileXp; break;
92 case "south": tileXpercentage = 1 - tileXp; break;
93 case "east": tileXpercentage = 1 - tileYp; break;
94 case "west": tileXpercentage = tileYp; break;
95 }
96
97 var hResult = {
98 tile: htileHit,
99 tileX: tileXpercentage,
100 endX: hrayX,
101 endY: hrayY,
102 dir: hDir
103 };
104
105 var rayX, rayY, offX, offY, mapX, mapY, tileHit;
106 var vDir = "east";
107 var nTan = -Math.tan(radian);
108 distDone = 0;
109
110 if (radian > Math.PI / 2 && radian < Math.PI * 1.5)
111 {
112 rayX = Math.floor(x / cell) * cell - 0.01;
113 rayY = (x - rayX) * nTan + y;
114 offX = -cell;
115 offY = -offX * nTan;
116 }
117 else if (radian < Math.PI / 2 || radian > Math.PI * 1.5)
118 {
119 rayX = Math.floor(x / cell) * cell + cell;
120 rayY = (x - rayX) * nTan + y;
121 offX = cell;
122 offY = -offX * nTan;
123 vDir = "west";
124 }
125 else
126 {
127 rayX = x;
128 rayY = y;
129 distDone = maxDist;
130 }
131
132 while (distDone < maxDist)
133 {
134 tileXp = ((rayX % cell) + cell) % cell / cell;
135 tileYp = ((rayY % cell) + cell) % cell / cell;
136 mapX = Math.floor(rayX / cell);
137 mapY = Math.floor(rayY / cell);
138 var tileHitId = this.level.tiles[mapX + mapY * this.level.width];
139 tileHit = Tiles.findByID(tileHitId);
140 if (tileHit && tileHit.Solid)
141 { distDone = maxDist; }
142 else
143 {
144 rayX += offX;
145 rayY += offY;
146 distDone += 1;
147 }
148 }
149
150 switch (vDir)
151 {
152 case "north": tileXpercentage = tileXp; break;
153 case "south": tileXpercentage = 1 - tileXp; break;
154 case "east": tileXpercentage = 1 - tileYp; break;
155 case "west": tileXpercentage = tileYp; break;
156 }
157
158 var vResult = {
159 tile: tileHit,
160 tileX: tileXpercentage,
161 endX: rayX,
162 endY: rayY,
163 dir: vDir
164 };
165
166 var dxH = hResult.endX - x;
167 var dyH = hResult.endY - y;
168 var dxV = vResult.endX - x;
169 var dyV = vResult.endY - y;
170 hResult.distance = Math.sqrt(dxH * dxH + dyH * dyH);
171 vResult.distance = Math.sqrt(dxV * dxV + dyV * dyV);
172
173 if (hResult.distance < vResult.distance)
174 { return hResult; }
175 return vResult;
176 }
177};
178
179if (typeof module !== "undefined" && module.exports)
180{
181 module.exports = { World: World };
182}