/
coreactor.h
430 lines (352 loc) · 7.85 KB
/
coreactor.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
#pragma once
#include <stdint.h>
#include "maptypes.h"
class DCoreActor : public DObject
{
DECLARE_CLASS(DCoreActor, DObject)
HAS_OBJECT_POINTERS
// common part of the game actors
public:
// These two are needed because we cannot rely on the ones in the sprites for unlinking.
int link_stat;
sectortype* link_sector;
DCoreActor* prevStat, * nextStat;
DCoreActor* prevSect, * nextSect;
spritetype spr;
spriteext_t sprext;
spritesmooth_t spsmooth;
vec3_t opos;
int time;
int16_t oang;
DCoreActor() = default;
virtual ~DCoreActor() = default;
DCoreActor(const DCoreActor& other) = delete; // we also do not want to allow copies.
DCoreActor& operator=(const DCoreActor& other) = delete;
virtual void Serialize(FSerializer& arc);
virtual void BeginPlay() {}
void OnDestroy() override;
size_t PropagateMark() override;
bool exists() const
{
return (unsigned)spr.statnum < MAXSTATUS;
}
int GetIndex() const
{
// This is only identical with the sprite index for items spawned at map start.
return time;
}
int32_t interpolatedx(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(opos.X, spr.pos.X, smoothratio, scale);
}
int32_t interpolatedy(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(opos.Y, spr.pos.Y, smoothratio, scale);
}
int32_t interpolatedz(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(opos.Z, spr.pos.Z, smoothratio, scale);
}
vec2_t interpolatedvec2(double const smoothratio, int const scale = 16)
{
return
{
interpolatedx(smoothratio, scale),
interpolatedy(smoothratio, scale)
};
}
vec3_t interpolatedvec3(double const smoothratio, int const scale = 16)
{
return
{
interpolatedx(smoothratio, scale),
interpolatedy(smoothratio, scale),
interpolatedz(smoothratio, scale)
};
}
int16_t interpolatedang(double const smoothratio)
{
return interpolatedangle(oang, spr.ang, smoothratio, 16);
}
void backupx()
{
opos.X = spr.pos.X;
}
void backupy()
{
opos.Y = spr.pos.Y;
}
void backupz()
{
opos.Z = spr.pos.Z;
}
void backupvec2()
{
opos.vec2 = spr.pos.vec2;
}
void backuppos()
{
opos = spr.pos;
}
void backupang()
{
oang = spr.ang;
}
void backuploc()
{
backuppos();
backupang();
}
sectortype* sector() const
{
return spr.sectp;
}
bool insector() const
{
return spr.sectp != nullptr;
}
void setsector(sectortype* sect)
{
// place for asserts.
spr.sectp = sect;
}
int sectno() const
{
return spr.sectp ? ::sector.IndexOf(spr.sectp) : -1;
}
};
// holds pointers to the game-side actors.
extern TArray<sectortype> sector;
extern TArray<walltype> wall;
// Masking these into the object index to keep it in 16 bit was probably the single most dumbest and pointless thing Build ever did.
// Gonna be fun to globally replace these to finally lift the limit this imposes on map size.
// Names taken from DukeGDX
enum EHitBits
{
kHitNone = 0,
kHitTypeMask = 0xC000,
kHitTypeMaskSW = 0x1C000, // SW has one more relevant bit
kHitIndexMask = 0x3FFF,
kHitSector = 0x4000,
kHitWall = 0x8000,
kHitSprite = 0xC000,
kHitVoid = 0x10000, // SW only
};
// This serves as input/output for all functions dealing with collisions, hits, etc.
// Not all utilities use all variables.
struct HitInfoBase
{
vec3_t hitpos;
sectortype* hitSector;
walltype* hitWall;
DCoreActor* hitActor;
void clearObj()
{
hitSector = nullptr;
hitWall = nullptr;
hitActor = nullptr;
}
};
template<class T>
struct THitInfo : public HitInfoBase
{
T* actor() const { return static_cast<T*>(hitActor); }
};
struct CollisionBase
{
int type;
int exbits; // extended game-side info (only used by Exhumed)
union
{
// can only have one at a time
sectortype* hitSector;
walltype* hitWall;
DCoreActor* hitActor;
};
void invalidate()
{
type = -1; // something invalid that's not a valid hit type.
hitSector = nullptr;
}
int setNone()
{
*this = {};
return kHitNone;
}
int setSector(int num)
{
*this = {};
type = kHitSector;
hitSector = §or[num];
return kHitSector;
}
int setSector(sectortype* num)
{
*this = {};
type = kHitSector;
hitSector = num;
return kHitSector;
}
int setWall(int num)
{
*this = {};
type = kHitWall;
hitWall = &wall[num];
return kHitWall;
}
int setWall(walltype* num)
{
*this = {};
type = kHitWall;
hitWall = num;
return kHitWall;
}
int setSprite(DCoreActor* num)
{
*this = {};
type = kHitSprite;
hitActor = num;
return kHitSprite;
}
int setVoid()
{
hitSector = nullptr;
type = kHitVoid;
return kHitVoid;
}
};
template<class T>
struct TCollision : public CollisionBase
{
T* actor() const
{
return static_cast<T*>(hitActor);
}
// normally collision data is short lived, this is only needed in some very rare circumstances.
T* safeActor()
{
return static_cast<T*>(GC::ReadBarrier(hitActor));
}
auto operator=(const CollisionBase& other)
{
*(CollisionBase*)this = other;
return *this;
}
};
struct ActorStatList
{
DCoreActor* firstEntry, * lastEntry;
};
extern ActorStatList statList[MAXSTATUS];
// Iterator wrappers that return an actor pointer, not an index.
template<class TActor>
class TStatIterator
{
DCoreActor* next;
public:
TStatIterator(int stat)
{
next = statList[stat].firstEntry;
}
void Reset(int stat)
{
next = statList[stat].firstEntry;
}
TActor* Next()
{
auto n = next;
if (next) next = next->nextStat;
return static_cast<TActor*>(n);
}
TActor* Peek()
{
return static_cast<TActor*>(next);
}
};
template<class TActor>
class TSectIterator
{
DCoreActor* next;
public:
//[[deprecated]]
TSectIterator(int stat)
{
next = sector[stat].firstEntry;
}
TSectIterator(sectortype* stat)
{
next = stat->firstEntry;
}
//[[deprecated]]
void Reset(int stat)
{
next = sector[stat].firstEntry;
}
void Reset(sectortype* stat)
{
next = stat->firstEntry;
}
TActor* Next()
{
auto n = next;
if (next) next = next->nextSect;
return static_cast<TActor*>(n);
}
TActor* Peek()
{
return static_cast<TActor*>(next);
}
};
// An iterator to iterate over all sprites.
template<class TActor>
class TSpriteIterator
{
TStatIterator<TActor> it;
int stat = 0;
public:
TSpriteIterator() : it(0) {}
TActor* Next()
{
while (stat < MAXSTATUS)
{
auto ac = it.Next();
if (ac) return ac;
stat++;
if (stat < MAXSTATUS) it.Reset(stat);
}
return nullptr;
}
void Reset()
{
stat = 0;
it.Reset(0);
}
};
using CoreSectIterator = TSectIterator<DCoreActor>;
DCoreActor* InsertActor(PClass* type, sectortype* sector, int stat, bool forcetail = false);
void ChangeActorSect(DCoreActor* actor, sectortype* sector, bool forcetail = false);
int ChangeActorStat(DCoreActor* actor, int nStatus, bool forcetail = false);
void InitSpriteLists();
void SetActorZ(DCoreActor* actor, const vec3_t* newpos);
void SetActor(DCoreActor* actor, const vec3_t* newpos);
inline void SetActor(DCoreActor* actor, const vec3_t& newpos)
{
SetActor(actor, &newpos);
}
inline int clipmove(vec3_t& pos, sectortype** const sect, int xvect, int yvect,
int const walldist, int const ceildist, int const flordist, unsigned const cliptype, CollisionBase& result, int clipmoveboxtracenum = 3)
{
int sectno = *sect ? sector.IndexOf(*sect) : -1;
result = clipmove_(&pos, §no, xvect, yvect, walldist, ceildist, flordist, cliptype, clipmoveboxtracenum);
*sect = sectno == -1 ? nullptr : §or[sectno];
return result.type;
}
inline int pushmove(vec3_t* const vect, sectortype** const sect, int32_t const walldist, int32_t const ceildist, int32_t const flordist,
uint32_t const cliptype, bool clear = true)
{
int sectno = *sect ? sector.IndexOf(*sect) : -1;
int res = pushmove_(vect, §no, walldist, ceildist, flordist, cliptype, clear);
*sect = sectno == -1 ? nullptr : §or[sectno];
return res;
}
tspritetype* renderAddTsprite(tspritetype* tsprite, int& spritesortcnt, DCoreActor* actor);