mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Clean up remaning usages of Missiles[]

pull/2732/head
Anders Jenbo 5 years ago
parent
fbc64dfe09
commit
866bc56008
3 changed files with 121 additions and 118 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 180
      Source/loadsave.cpp
  2. 27
      Source/missiles.cpp
  3. 32
      Source/scrollrt.cpp

180
Source/loadsave.cpp
Unescape View File

@ -637,53 +637,53 @@ void LoadMonster(LoadHelper *file, MonsterStruct &monster)
void LoadMissile(LoadHelper *file, int i) void LoadMissile(LoadHelper *file, int i)
{ {
MissileStruct *pMissile = &Missiles[i]; auto &missile = Missiles[i];
pMissile->_mitype = static_cast<missile_id>(file->NextLE<int32_t>()); missile._mitype = static_cast<missile_id>(file->NextLE<int32_t>());
pMissile->position.tile.x = file->NextLE<int32_t>(); missile.position.tile.x = file->NextLE<int32_t>();
pMissile->position.tile.y = file->NextLE<int32_t>(); missile.position.tile.y = file->NextLE<int32_t>();
pMissile->position.offset.deltaX = file->NextLE<int32_t>(); missile.position.offset.deltaX = file->NextLE<int32_t>();
pMissile->position.offset.deltaY = file->NextLE<int32_t>(); missile.position.offset.deltaY = file->NextLE<int32_t>();
pMissile->position.velocity.deltaX = file->NextLE<int32_t>(); missile.position.velocity.deltaX = file->NextLE<int32_t>();
pMissile->position.velocity.deltaY = file->NextLE<int32_t>(); missile.position.velocity.deltaY = file->NextLE<int32_t>();
pMissile->position.start.x = file->NextLE<int32_t>(); missile.position.start.x = file->NextLE<int32_t>();
pMissile->position.start.y = file->NextLE<int32_t>(); missile.position.start.y = file->NextLE<int32_t>();
pMissile->position.traveled.deltaX = file->NextLE<int32_t>(); missile.position.traveled.deltaX = file->NextLE<int32_t>();
pMissile->position.traveled.deltaY = file->NextLE<int32_t>(); missile.position.traveled.deltaY = file->NextLE<int32_t>();
pMissile->_mimfnum = file->NextLE<int32_t>(); missile._mimfnum = file->NextLE<int32_t>();
pMissile->_mispllvl = file->NextLE<int32_t>(); missile._mispllvl = file->NextLE<int32_t>();
pMissile->_miDelFlag = file->NextBool32(); missile._miDelFlag = file->NextBool32();
pMissile->_miAnimType = file->NextLE<uint8_t>(); missile._miAnimType = file->NextLE<uint8_t>();
file->Skip(3); // Alignment file->Skip(3); // Alignment
pMissile->_miAnimFlags = static_cast<MissileDataFlags>(file->NextLE<int32_t>()); missile._miAnimFlags = static_cast<MissileDataFlags>(file->NextLE<int32_t>());
file->Skip(4); // Skip pointer _miAnimData file->Skip(4); // Skip pointer _miAnimData
pMissile->_miAnimDelay = file->NextLE<int32_t>(); missile._miAnimDelay = file->NextLE<int32_t>();
pMissile->_miAnimLen = file->NextLE<int32_t>(); missile._miAnimLen = file->NextLE<int32_t>();
pMissile->_miAnimWidth = file->NextLE<int32_t>(); missile._miAnimWidth = file->NextLE<int32_t>();
pMissile->_miAnimWidth2 = file->NextLE<int32_t>(); missile._miAnimWidth2 = file->NextLE<int32_t>();
pMissile->_miAnimCnt = file->NextLE<int32_t>(); missile._miAnimCnt = file->NextLE<int32_t>();
pMissile->_miAnimAdd = file->NextLE<int32_t>(); missile._miAnimAdd = file->NextLE<int32_t>();
pMissile->_miAnimFrame = file->NextLE<int32_t>(); missile._miAnimFrame = file->NextLE<int32_t>();
pMissile->_miDrawFlag = file->NextBool32(); missile._miDrawFlag = file->NextBool32();
pMissile->_miLightFlag = file->NextBool32(); missile._miLightFlag = file->NextBool32();
pMissile->_miPreFlag = file->NextBool32(); missile._miPreFlag = file->NextBool32();
pMissile->_miUniqTrans = file->NextLE<uint32_t>(); missile._miUniqTrans = file->NextLE<uint32_t>();
pMissile->_mirange = file->NextLE<int32_t>(); missile._mirange = file->NextLE<int32_t>();
pMissile->_misource = file->NextLE<int32_t>(); missile._misource = file->NextLE<int32_t>();
pMissile->_micaster = static_cast<mienemy_type>(file->NextLE<int32_t>()); missile._micaster = static_cast<mienemy_type>(file->NextLE<int32_t>());
pMissile->_midam = file->NextLE<int32_t>(); missile._midam = file->NextLE<int32_t>();
pMissile->_miHitFlag = file->NextBool32(); missile._miHitFlag = file->NextBool32();
pMissile->_midist = file->NextLE<int32_t>(); missile._midist = file->NextLE<int32_t>();
pMissile->_mlid = file->NextLE<int32_t>(); missile._mlid = file->NextLE<int32_t>();
pMissile->_mirnd = file->NextLE<int32_t>(); missile._mirnd = file->NextLE<int32_t>();
pMissile->var1 = file->NextLE<int32_t>(); missile.var1 = file->NextLE<int32_t>();
pMissile->var2 = file->NextLE<int32_t>(); missile.var2 = file->NextLE<int32_t>();
pMissile->var3 = file->NextLE<int32_t>(); missile.var3 = file->NextLE<int32_t>();
pMissile->var4 = file->NextLE<int32_t>(); missile.var4 = file->NextLE<int32_t>();
pMissile->var5 = file->NextLE<int32_t>(); missile.var5 = file->NextLE<int32_t>();
pMissile->var6 = file->NextLE<int32_t>(); missile.var6 = file->NextLE<int32_t>();
pMissile->var7 = file->NextLE<int32_t>(); missile.var7 = file->NextLE<int32_t>();
pMissile->limitReached = file->NextBool32(); missile.limitReached = file->NextBool32();
} }
void LoadObject(LoadHelper *file, int i) void LoadObject(LoadHelper *file, int i)
@ -1287,53 +1287,53 @@ void SaveMonster(SaveHelper *file, MonsterStruct &monster)
void SaveMissile(SaveHelper *file, int i) void SaveMissile(SaveHelper *file, int i)
{ {
MissileStruct *pMissile = &Missiles[i]; auto &missile = Missiles[i];
file->WriteLE<int32_t>(pMissile->_mitype); file->WriteLE<int32_t>(missile._mitype);
file->WriteLE<int32_t>(pMissile->position.tile.x); file->WriteLE<int32_t>(missile.position.tile.x);
file->WriteLE<int32_t>(pMissile->position.tile.y); file->WriteLE<int32_t>(missile.position.tile.y);
file->WriteLE<int32_t>(pMissile->position.offset.deltaX); file->WriteLE<int32_t>(missile.position.offset.deltaX);
file->WriteLE<int32_t>(pMissile->position.offset.deltaY); file->WriteLE<int32_t>(missile.position.offset.deltaY);
file->WriteLE<int32_t>(pMissile->position.velocity.deltaX); file->WriteLE<int32_t>(missile.position.velocity.deltaX);
file->WriteLE<int32_t>(pMissile->position.velocity.deltaY); file->WriteLE<int32_t>(missile.position.velocity.deltaY);
file->WriteLE<int32_t>(pMissile->position.start.x); file->WriteLE<int32_t>(missile.position.start.x);
file->WriteLE<int32_t>(pMissile->position.start.y); file->WriteLE<int32_t>(missile.position.start.y);
file->WriteLE<int32_t>(pMissile->position.traveled.deltaX); file->WriteLE<int32_t>(missile.position.traveled.deltaX);
file->WriteLE<int32_t>(pMissile->position.traveled.deltaY); file->WriteLE<int32_t>(missile.position.traveled.deltaY);
file->WriteLE<int32_t>(pMissile->_mimfnum); file->WriteLE<int32_t>(missile._mimfnum);
file->WriteLE<int32_t>(pMissile->_mispllvl); file->WriteLE<int32_t>(missile._mispllvl);
file->WriteLE<uint32_t>(pMissile->_miDelFlag ? 1 : 0); file->WriteLE<uint32_t>(missile._miDelFlag ? 1 : 0);
file->WriteLE<uint8_t>(pMissile->_miAnimType); file->WriteLE<uint8_t>(missile._miAnimType);
file->Skip(3); // Alignment file->Skip(3); // Alignment
file->WriteLE<int32_t>(static_cast<int32_t>(pMissile->_miAnimFlags)); file->WriteLE<int32_t>(static_cast<int32_t>(missile._miAnimFlags));
file->Skip(4); // Skip pointer _miAnimData file->Skip(4); // Skip pointer _miAnimData
file->WriteLE<int32_t>(pMissile->_miAnimDelay); file->WriteLE<int32_t>(missile._miAnimDelay);
file->WriteLE<int32_t>(pMissile->_miAnimLen); file->WriteLE<int32_t>(missile._miAnimLen);
file->WriteLE<int32_t>(pMissile->_miAnimWidth); file->WriteLE<int32_t>(missile._miAnimWidth);
file->WriteLE<int32_t>(pMissile->_miAnimWidth2); file->WriteLE<int32_t>(missile._miAnimWidth2);
file->WriteLE<int32_t>(pMissile->_miAnimCnt); file->WriteLE<int32_t>(missile._miAnimCnt);
file->WriteLE<int32_t>(pMissile->_miAnimAdd); file->WriteLE<int32_t>(missile._miAnimAdd);
file->WriteLE<int32_t>(pMissile->_miAnimFrame); file->WriteLE<int32_t>(missile._miAnimFrame);
file->WriteLE<uint32_t>(pMissile->_miDrawFlag ? 1 : 0); file->WriteLE<uint32_t>(missile._miDrawFlag ? 1 : 0);
file->WriteLE<uint32_t>(pMissile->_miLightFlag ? 1 : 0); file->WriteLE<uint32_t>(missile._miLightFlag ? 1 : 0);
file->WriteLE<uint32_t>(pMissile->_miPreFlag ? 1 : 0); file->WriteLE<uint32_t>(missile._miPreFlag ? 1 : 0);
file->WriteLE<uint32_t>(pMissile->_miUniqTrans); file->WriteLE<uint32_t>(missile._miUniqTrans);
file->WriteLE<int32_t>(pMissile->_mirange); file->WriteLE<int32_t>(missile._mirange);
file->WriteLE<int32_t>(pMissile->_misource); file->WriteLE<int32_t>(missile._misource);
file->WriteLE<int32_t>(pMissile->_micaster); file->WriteLE<int32_t>(missile._micaster);
file->WriteLE<int32_t>(pMissile->_midam); file->WriteLE<int32_t>(missile._midam);
file->WriteLE<uint32_t>(pMissile->_miHitFlag ? 1 : 0); file->WriteLE<uint32_t>(missile._miHitFlag ? 1 : 0);
file->WriteLE<int32_t>(pMissile->_midist); file->WriteLE<int32_t>(missile._midist);
file->WriteLE<int32_t>(pMissile->_mlid); file->WriteLE<int32_t>(missile._mlid);
file->WriteLE<int32_t>(pMissile->_mirnd); file->WriteLE<int32_t>(missile._mirnd);
file->WriteLE<int32_t>(pMissile->var1); file->WriteLE<int32_t>(missile.var1);
file->WriteLE<int32_t>(pMissile->var2); file->WriteLE<int32_t>(missile.var2);
file->WriteLE<int32_t>(pMissile->var3); file->WriteLE<int32_t>(missile.var3);
file->WriteLE<int32_t>(pMissile->var4); file->WriteLE<int32_t>(missile.var4);
file->WriteLE<int32_t>(pMissile->var5); file->WriteLE<int32_t>(missile.var5);
file->WriteLE<int32_t>(pMissile->var6); file->WriteLE<int32_t>(missile.var6);
file->WriteLE<int32_t>(pMissile->var7); file->WriteLE<int32_t>(missile.var7);
file->WriteLE<uint32_t>(pMissile->limitReached ? 1 : 0); file->WriteLE<uint32_t>(missile.limitReached ? 1 : 0);
} }
void SaveObject(SaveHelper *file, int i) void SaveObject(SaveHelper *file, int i)

27
Source/missiles.cpp
Unescape View File

@ -1750,12 +1750,12 @@ void AddSearch(MissileStruct &missile, Point /*dst*/, Direction /*midir*/)
for (int i = 0; i < ActiveMissileCount; i++) { for (int i = 0; i < ActiveMissileCount; i++) {
int mx = ActiveMissiles[i]; int mx = ActiveMissiles[i];
if (&Missiles[mx] != &missile) { if (&Missiles[mx] != &missile) {
MissileStruct *mis = &Missiles[mx]; auto &other = Missiles[mx];
if (mis->var1 == missile._misource && mis->_mitype == MIS_SEARCH) { if (other.var1 == missile._misource && other._mitype == MIS_SEARCH) {
int r1 = missile._mirange; int r1 = missile._mirange;
int r2 = mis->_mirange; int r2 = other._mirange;
if (r2 < INT_MAX - r1) if (r2 < INT_MAX - r1)
mis->_mirange = r1 + r2; other._mirange = r1 + r2;
missile._miDelFlag = true; missile._miDelFlag = true;
break; break;
} }
@ -2093,10 +2093,11 @@ void AddMisexp(MissileStruct &missile, Point /*dst*/, Direction /*midir*/)
int mx = FindParent(missile); int mx = FindParent(missile);
assert(mx != -1); // AddMisexp will always be called with a parent associated to the missile. assert(mx != -1); // AddMisexp will always be called with a parent associated to the missile.
missile.position.tile = Missiles[mx].position.tile; auto &parent = Missiles[mx];
missile.position.start = Missiles[mx].position.start; missile.position.tile = parent.position.tile;
missile.position.offset = Missiles[mx].position.offset; missile.position.start = parent.position.start;
missile.position.traveled = Missiles[mx].position.traveled; missile.position.offset = parent.position.offset;
missile.position.traveled = parent.position.traveled;
missile._mirange = missile._miAnimLen; missile._mirange = missile._miAnimLen;
} }
@ -2147,8 +2148,9 @@ void AddTown(MissileStruct &missile, Point dst, Direction /*midir*/)
missile.var1 = missile._mirange - missile._miAnimLen; missile.var1 = missile._mirange - missile._miAnimLen;
for (int i = 0; i < ActiveMissileCount; i++) { for (int i = 0; i < ActiveMissileCount; i++) {
int mx = ActiveMissiles[i]; int mx = ActiveMissiles[i];
if (Missiles[mx]._mitype == MIS_TOWN && (&Missiles[mx] != &missile) && Missiles[mx]._misource == missile._misource) auto &other = Missiles[mx];
Missiles[mx]._mirange = 0; if (other._mitype == MIS_TOWN && (&other != &missile) && other._misource == missile._misource)
other._mirange = 0;
} }
PutMissile(missile); PutMissile(missile);
if (missile._misource == MyPlayerId && !missile._miDelFlag && currlevel != 0) { if (missile._misource == MyPlayerId && !missile._miDelFlag && currlevel != 0) {
@ -2452,8 +2454,9 @@ void AddGolem(MissileStruct &missile, Point dst, Direction /*midir*/)
for (int i = 0; i < ActiveMissileCount; i++) { for (int i = 0; i < ActiveMissileCount; i++) {
int mx = ActiveMissiles[i]; int mx = ActiveMissiles[i];
if (Missiles[mx]._mitype == MIS_GOLEM) { auto &other = Missiles[mx];
if ((&Missiles[mx] != &missile) && Missiles[mx]._misource == playerId) { if (other._mitype == MIS_GOLEM) {
if ((&other != &missile) && other._misource == playerId) {
return; return;
} }
} }

32
Source/scrollrt.cpp
Unescape View File

@ -316,31 +316,31 @@ void DrawCursor(const Surface &out)
* @param sy Output buffer coordinate * @param sy Output buffer coordinate
* @param pre Is the sprite in the background * @param pre Is the sprite in the background
*/ */
void DrawMissilePrivate(const Surface &out, const MissileStruct *m, int sx, int sy, bool pre) void DrawMissilePrivate(const Surface &out, const MissileStruct &missile, int sx, int sy, bool pre)
{ {
if (m->_miPreFlag != pre || !m->_miDrawFlag) if (missile._miPreFlag != pre || !missile._miDrawFlag)
return; return;
if (m->_miAnimData == nullptr) { if (missile._miAnimData == nullptr) {
Log("Draw Missile 2 type {}: NULL Cel Buffer", m->_mitype); Log("Draw Missile 2 type {}: NULL Cel Buffer", missile._mitype);
return; return;
} }
int nCel = m->_miAnimFrame; int nCel = missile._miAnimFrame;
const auto *frameTable = reinterpret_cast<const uint32_t *>(m->_miAnimData); const auto *frameTable = reinterpret_cast<const uint32_t *>(missile._miAnimData);
int frames = SDL_SwapLE32(frameTable[0]); int frames = SDL_SwapLE32(frameTable[0]);
if (nCel < 1 || frames > 50 || nCel > frames) { if (nCel < 1 || frames > 50 || nCel > frames) {
Log("Draw Missile 2: frame {} of {}, missile type=={}", nCel, frames, m->_mitype); Log("Draw Missile 2: frame {} of {}, missile type=={}", nCel, frames, missile._mitype);
return; return;
} }
int mx = sx + m->position.offsetForRendering.deltaX - m->_miAnimWidth2; int mx = sx + missile.position.offsetForRendering.deltaX - missile._miAnimWidth2;
int my = sy + m->position.offsetForRendering.deltaY; int my = sy + missile.position.offsetForRendering.deltaY;
CelSprite cel { m->_miAnimData, m->_miAnimWidth }; CelSprite cel { missile._miAnimData, missile._miAnimWidth };
if (m->_miUniqTrans != 0) if (missile._miUniqTrans != 0)
Cl2DrawLightTbl(out, mx, my, cel, m->_miAnimFrame, m->_miUniqTrans + 3); Cl2DrawLightTbl(out, mx, my, cel, missile._miAnimFrame, missile._miUniqTrans + 3);
else if (m->_miLightFlag) else if (missile._miLightFlag)
Cl2DrawLight(out, mx, my, cel, m->_miAnimFrame); Cl2DrawLight(out, mx, my, cel, missile._miAnimFrame);
else else
Cl2Draw(out, mx, my, cel, m->_miAnimFrame); Cl2Draw(out, mx, my, cel, missile._miAnimFrame);
} }
/** /**
@ -356,7 +356,7 @@ void DrawMissile(const Surface &out, int x, int y, int sx, int sy, bool pre)
{ {
const auto range = MissilesAtRenderingTile.equal_range(Point { x, y }); const auto range = MissilesAtRenderingTile.equal_range(Point { x, y });
for (auto it = range.first; it != range.second; it++) { for (auto it = range.first; it != range.second; it++) {
DrawMissilePrivate(out, it->second, sx, sy, pre); DrawMissilePrivate(out, *it->second, sx, sy, pre);
} }
} }

Write Preview
Loading…
Cancel
Save