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
Split 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)
{
MissileStruct *pMissile = &Missiles[i];
pMissile->_mitype = static_cast<missile_id>(file->NextLE<int32_t>());
pMissile->position.tile.x = file->NextLE<int32_t>();
pMissile->position.tile.y = file->NextLE<int32_t>();
pMissile->position.offset.deltaX = file->NextLE<int32_t>();
pMissile->position.offset.deltaY = file->NextLE<int32_t>();
pMissile->position.velocity.deltaX = file->NextLE<int32_t>();
pMissile->position.velocity.deltaY = file->NextLE<int32_t>();
pMissile->position.start.x = file->NextLE<int32_t>();
pMissile->position.start.y = file->NextLE<int32_t>();
pMissile->position.traveled.deltaX = file->NextLE<int32_t>();
pMissile->position.traveled.deltaY = file->NextLE<int32_t>();
pMissile->_mimfnum = file->NextLE<int32_t>();
pMissile->_mispllvl = file->NextLE<int32_t>();
pMissile->_miDelFlag = file->NextBool32();
pMissile->_miAnimType = file->NextLE<uint8_t>();
auto &missile = Missiles[i];
missile._mitype = static_cast<missile_id>(file->NextLE<int32_t>());
missile.position.tile.x = file->NextLE<int32_t>();
missile.position.tile.y = file->NextLE<int32_t>();
missile.position.offset.deltaX = file->NextLE<int32_t>();
missile.position.offset.deltaY = file->NextLE<int32_t>();
missile.position.velocity.deltaX = file->NextLE<int32_t>();
missile.position.velocity.deltaY = file->NextLE<int32_t>();
missile.position.start.x = file->NextLE<int32_t>();
missile.position.start.y = file->NextLE<int32_t>();
missile.position.traveled.deltaX = file->NextLE<int32_t>();
missile.position.traveled.deltaY = file->NextLE<int32_t>();
missile._mimfnum = file->NextLE<int32_t>();
missile._mispllvl = file->NextLE<int32_t>();
missile._miDelFlag = file->NextBool32();
missile._miAnimType = file->NextLE<uint8_t>();
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
pMissile->_miAnimDelay = file->NextLE<int32_t>();
pMissile->_miAnimLen = file->NextLE<int32_t>();
pMissile->_miAnimWidth = file->NextLE<int32_t>();
pMissile->_miAnimWidth2 = file->NextLE<int32_t>();
pMissile->_miAnimCnt = file->NextLE<int32_t>();
pMissile->_miAnimAdd = file->NextLE<int32_t>();
pMissile->_miAnimFrame = file->NextLE<int32_t>();
pMissile->_miDrawFlag = file->NextBool32();
pMissile->_miLightFlag = file->NextBool32();
pMissile->_miPreFlag = file->NextBool32();
pMissile->_miUniqTrans = file->NextLE<uint32_t>();
pMissile->_mirange = file->NextLE<int32_t>();
pMissile->_misource = file->NextLE<int32_t>();
pMissile->_micaster = static_cast<mienemy_type>(file->NextLE<int32_t>());
pMissile->_midam = file->NextLE<int32_t>();
pMissile->_miHitFlag = file->NextBool32();
pMissile->_midist = file->NextLE<int32_t>();
pMissile->_mlid = file->NextLE<int32_t>();
pMissile->_mirnd = file->NextLE<int32_t>();
pMissile->var1 = file->NextLE<int32_t>();
pMissile->var2 = file->NextLE<int32_t>();
pMissile->var3 = file->NextLE<int32_t>();
pMissile->var4 = file->NextLE<int32_t>();
pMissile->var5 = file->NextLE<int32_t>();
pMissile->var6 = file->NextLE<int32_t>();
pMissile->var7 = file->NextLE<int32_t>();
pMissile->limitReached = file->NextBool32();
missile._miAnimDelay = file->NextLE<int32_t>();
missile._miAnimLen = file->NextLE<int32_t>();
missile._miAnimWidth = file->NextLE<int32_t>();
missile._miAnimWidth2 = file->NextLE<int32_t>();
missile._miAnimCnt = file->NextLE<int32_t>();
missile._miAnimAdd = file->NextLE<int32_t>();
missile._miAnimFrame = file->NextLE<int32_t>();
missile._miDrawFlag = file->NextBool32();
missile._miLightFlag = file->NextBool32();
missile._miPreFlag = file->NextBool32();
missile._miUniqTrans = file->NextLE<uint32_t>();
missile._mirange = file->NextLE<int32_t>();
missile._misource = file->NextLE<int32_t>();
missile._micaster = static_cast<mienemy_type>(file->NextLE<int32_t>());
missile._midam = file->NextLE<int32_t>();
missile._miHitFlag = file->NextBool32();
missile._midist = file->NextLE<int32_t>();
missile._mlid = file->NextLE<int32_t>();
missile._mirnd = file->NextLE<int32_t>();
missile.var1 = file->NextLE<int32_t>();
missile.var2 = file->NextLE<int32_t>();
missile.var3 = file->NextLE<int32_t>();
missile.var4 = file->NextLE<int32_t>();
missile.var5 = file->NextLE<int32_t>();
missile.var6 = file->NextLE<int32_t>();
missile.var7 = file->NextLE<int32_t>();
missile.limitReached = file->NextBool32();
}
void LoadObject(LoadHelper *file, int i)
@ -1287,53 +1287,53 @@ void SaveMonster(SaveHelper *file, MonsterStruct &monster)
void SaveMissile(SaveHelper *file, int i)
{
MissileStruct *pMissile = &Missiles[i];
file->WriteLE<int32_t>(pMissile->_mitype);
file->WriteLE<int32_t>(pMissile->position.tile.x);
file->WriteLE<int32_t>(pMissile->position.tile.y);
file->WriteLE<int32_t>(pMissile->position.offset.deltaX);
file->WriteLE<int32_t>(pMissile->position.offset.deltaY);
file->WriteLE<int32_t>(pMissile->position.velocity.deltaX);
file->WriteLE<int32_t>(pMissile->position.velocity.deltaY);
file->WriteLE<int32_t>(pMissile->position.start.x);
file->WriteLE<int32_t>(pMissile->position.start.y);
file->WriteLE<int32_t>(pMissile->position.traveled.deltaX);
file->WriteLE<int32_t>(pMissile->position.traveled.deltaY);
file->WriteLE<int32_t>(pMissile->_mimfnum);
file->WriteLE<int32_t>(pMissile->_mispllvl);
file->WriteLE<uint32_t>(pMissile->_miDelFlag ? 1 : 0);
file->WriteLE<uint8_t>(pMissile->_miAnimType);
auto &missile = Missiles[i];
file->WriteLE<int32_t>(missile._mitype);
file->WriteLE<int32_t>(missile.position.tile.x);
file->WriteLE<int32_t>(missile.position.tile.y);
file->WriteLE<int32_t>(missile.position.offset.deltaX);
file->WriteLE<int32_t>(missile.position.offset.deltaY);
file->WriteLE<int32_t>(missile.position.velocity.deltaX);
file->WriteLE<int32_t>(missile.position.velocity.deltaY);
file->WriteLE<int32_t>(missile.position.start.x);
file->WriteLE<int32_t>(missile.position.start.y);
file->WriteLE<int32_t>(missile.position.traveled.deltaX);
file->WriteLE<int32_t>(missile.position.traveled.deltaY);
file->WriteLE<int32_t>(missile._mimfnum);
file->WriteLE<int32_t>(missile._mispllvl);
file->WriteLE<uint32_t>(missile._miDelFlag ? 1 : 0);
file->WriteLE<uint8_t>(missile._miAnimType);
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->WriteLE<int32_t>(pMissile->_miAnimDelay);
file->WriteLE<int32_t>(pMissile->_miAnimLen);
file->WriteLE<int32_t>(pMissile->_miAnimWidth);
file->WriteLE<int32_t>(pMissile->_miAnimWidth2);
file->WriteLE<int32_t>(pMissile->_miAnimCnt);
file->WriteLE<int32_t>(pMissile->_miAnimAdd);
file->WriteLE<int32_t>(pMissile->_miAnimFrame);
file->WriteLE<uint32_t>(pMissile->_miDrawFlag ? 1 : 0);
file->WriteLE<uint32_t>(pMissile->_miLightFlag ? 1 : 0);
file->WriteLE<uint32_t>(pMissile->_miPreFlag ? 1 : 0);
file->WriteLE<uint32_t>(pMissile->_miUniqTrans);
file->WriteLE<int32_t>(pMissile->_mirange);
file->WriteLE<int32_t>(pMissile->_misource);
file->WriteLE<int32_t>(pMissile->_micaster);
file->WriteLE<int32_t>(pMissile->_midam);
file->WriteLE<uint32_t>(pMissile->_miHitFlag ? 1 : 0);
file->WriteLE<int32_t>(pMissile->_midist);
file->WriteLE<int32_t>(pMissile->_mlid);
file->WriteLE<int32_t>(pMissile->_mirnd);
file->WriteLE<int32_t>(pMissile->var1);
file->WriteLE<int32_t>(pMissile->var2);
file->WriteLE<int32_t>(pMissile->var3);
file->WriteLE<int32_t>(pMissile->var4);
file->WriteLE<int32_t>(pMissile->var5);
file->WriteLE<int32_t>(pMissile->var6);
file->WriteLE<int32_t>(pMissile->var7);
file->WriteLE<uint32_t>(pMissile->limitReached ? 1 : 0);
file->WriteLE<int32_t>(missile._miAnimDelay);
file->WriteLE<int32_t>(missile._miAnimLen);
file->WriteLE<int32_t>(missile._miAnimWidth);
file->WriteLE<int32_t>(missile._miAnimWidth2);
file->WriteLE<int32_t>(missile._miAnimCnt);
file->WriteLE<int32_t>(missile._miAnimAdd);
file->WriteLE<int32_t>(missile._miAnimFrame);
file->WriteLE<uint32_t>(missile._miDrawFlag ? 1 : 0);
file->WriteLE<uint32_t>(missile._miLightFlag ? 1 : 0);
file->WriteLE<uint32_t>(missile._miPreFlag ? 1 : 0);
file->WriteLE<uint32_t>(missile._miUniqTrans);
file->WriteLE<int32_t>(missile._mirange);
file->WriteLE<int32_t>(missile._misource);
file->WriteLE<int32_t>(missile._micaster);
file->WriteLE<int32_t>(missile._midam);
file->WriteLE<uint32_t>(missile._miHitFlag ? 1 : 0);
file->WriteLE<int32_t>(missile._midist);
file->WriteLE<int32_t>(missile._mlid);
file->WriteLE<int32_t>(missile._mirnd);
file->WriteLE<int32_t>(missile.var1);
file->WriteLE<int32_t>(missile.var2);
file->WriteLE<int32_t>(missile.var3);
file->WriteLE<int32_t>(missile.var4);
file->WriteLE<int32_t>(missile.var5);
file->WriteLE<int32_t>(missile.var6);
file->WriteLE<int32_t>(missile.var7);
file->WriteLE<uint32_t>(missile.limitReached ? 1 : 0);
}
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++) {
int mx = ActiveMissiles[i];
if (&Missiles[mx] != &missile) {
MissileStruct *mis = &Missiles[mx];
if (mis->var1 == missile._misource && mis->_mitype == MIS_SEARCH) {
auto &other = Missiles[mx];
if (other.var1 == missile._misource && other._mitype == MIS_SEARCH) {
int r1 = missile._mirange;
int r2 = mis->_mirange;
int r2 = other._mirange;
if (r2 < INT_MAX - r1)
mis->_mirange = r1 + r2;
other._mirange = r1 + r2;
missile._miDelFlag = true;
break;
}
@ -2093,10 +2093,11 @@ void AddMisexp(MissileStruct &missile, Point /*dst*/, Direction /*midir*/)
int mx = FindParent(missile);
assert(mx != -1); // AddMisexp will always be called with a parent associated to the missile.
missile.position.tile = Missiles[mx].position.tile;
missile.position.start = Missiles[mx].position.start;
missile.position.offset = Missiles[mx].position.offset;
missile.position.traveled = Missiles[mx].position.traveled;
auto &parent = Missiles[mx];
missile.position.tile = parent.position.tile;
missile.position.start = parent.position.start;
missile.position.offset = parent.position.offset;
missile.position.traveled = parent.position.traveled;
missile._mirange = missile._miAnimLen;
}
@ -2147,8 +2148,9 @@ void AddTown(MissileStruct &missile, Point dst, Direction /*midir*/)
missile.var1 = missile._mirange - missile._miAnimLen;
for (int i = 0; i < ActiveMissileCount; i++) {
int mx = ActiveMissiles[i];
if (Missiles[mx]._mitype == MIS_TOWN && (&Missiles[mx] != &missile) && Missiles[mx]._misource == missile._misource)
Missiles[mx]._mirange = 0;
auto &other = Missiles[mx];
if (other._mitype == MIS_TOWN && (&other != &missile) && other._misource == missile._misource)
other._mirange = 0;
}
PutMissile(missile);
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++) {
int mx = ActiveMissiles[i];
if (Missiles[mx]._mitype == MIS_GOLEM) {
if ((&Missiles[mx] != &missile) && Missiles[mx]._misource == playerId) {
auto &other = Missiles[mx];
if (other._mitype == MIS_GOLEM) {
if ((&other != &missile) && other._misource == playerId) {
return;
}
}

32
Source/scrollrt.cpp
Unescape View File

@ -316,31 +316,31 @@ void DrawCursor(const Surface &out)
* @param sy Output buffer coordinate
* @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;
if (m->_miAnimData == nullptr) {
Log("Draw Missile 2 type {}: NULL Cel Buffer", m->_mitype);
if (missile._miAnimData == nullptr) {
Log("Draw Missile 2 type {}: NULL Cel Buffer", missile._mitype);
return;
}
int nCel = m->_miAnimFrame;
const auto *frameTable = reinterpret_cast<const uint32_t *>(m->_miAnimData);
int nCel = missile._miAnimFrame;
const auto *frameTable = reinterpret_cast<const uint32_t *>(missile._miAnimData);
int frames = SDL_SwapLE32(frameTable[0]);
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;
}
int mx = sx + m->position.offsetForRendering.deltaX - m->_miAnimWidth2;
int my = sy + m->position.offsetForRendering.deltaY;
CelSprite cel { m->_miAnimData, m->_miAnimWidth };
if (m->_miUniqTrans != 0)
Cl2DrawLightTbl(out, mx, my, cel, m->_miAnimFrame, m->_miUniqTrans + 3);
else if (m->_miLightFlag)
Cl2DrawLight(out, mx, my, cel, m->_miAnimFrame);
int mx = sx + missile.position.offsetForRendering.deltaX - missile._miAnimWidth2;
int my = sy + missile.position.offsetForRendering.deltaY;
CelSprite cel { missile._miAnimData, missile._miAnimWidth };
if (missile._miUniqTrans != 0)
Cl2DrawLightTbl(out, mx, my, cel, missile._miAnimFrame, missile._miUniqTrans + 3);
else if (missile._miLightFlag)
Cl2DrawLight(out, mx, my, cel, missile._miAnimFrame);
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 });
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