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

Refactor TileHasAny() (#7085)

pull/7096/head
Eric Robinson 2 years ago committed by GitHub
parent
368fa7f7e8
commit
0ac30d101d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 63 additions and 70 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. 6
      Source/debug.cpp
  2. 4
      Source/engine/path.cpp
  3. 14
      Source/engine/render/scrollrt.cpp
  4. 4
      Source/levels/gendung.h
  5. 35
      Source/levels/themes.cpp
  6. 6
      Source/lighting.cpp
  7. 48
      Source/missiles.cpp
  8. 2
      Source/monster.cpp
  9. 14
      Source/objects.cpp

6
Source/debug.cpp
Unescape View File

@ -199,13 +199,13 @@ bool GetDebugGridText(Point dungeonCoords, char *debugGridTextBuffer)
info = dObject[dungeonCoords.x][dungeonCoords.y];
break;
case DebugGridTextItem::Solid:
info = TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::Solid) << 0 | TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::BlockLight) << 1 | TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::BlockMissile) << 2;
info = TileHasAny(dungeonCoords, TileProperties::Solid) << 0 | TileHasAny(dungeonCoords, TileProperties::BlockLight) << 1 | TileHasAny(dungeonCoords, TileProperties::BlockMissile) << 2;
break;
case DebugGridTextItem::Transparent:
info = TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::Transparent) << 0 | TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::TransparentLeft) << 1 | TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::TransparentRight) << 2;
info = TileHasAny(dungeonCoords, TileProperties::Transparent) << 0 | TileHasAny(dungeonCoords, TileProperties::TransparentLeft) << 1 | TileHasAny(dungeonCoords, TileProperties::TransparentRight) << 2;
break;
case DebugGridTextItem::Trap:
info = TileHasAny(dPiece[dungeonCoords.x][dungeonCoords.y], TileProperties::Trap);
info = TileHasAny(dungeonCoords, TileProperties::Trap);
break;
case DebugGridTextItem::AutomapView:
info = AutomapView[megaCoords.x][megaCoords.y];

4
Source/engine/path.cpp
Unescape View File

@ -316,7 +316,7 @@ bool IsTileNotSolid(Point position)
return false;
}
return !TileHasAny(dPiece[position.x][position.y], TileProperties::Solid);
return !TileHasAny(position, TileProperties::Solid);
}
bool IsTileSolid(Point position)
@ -325,7 +325,7 @@ bool IsTileSolid(Point position)
return false;
}
return TileHasAny(dPiece[position.x][position.y], TileProperties::Solid);
return TileHasAny(position, TileProperties::Solid);
}
bool IsTileWalkable(Point position, bool ignoreDoors)

14
Source/engine/render/scrollrt.cpp
Unescape View File

@ -474,19 +474,19 @@ void DrawCell(const Surface &out, Point tilePosition, Point targetBufferPosition
tbl = GetPauseTRN();
#endif
bool transparency = TileHasAny(levelPieceId, TileProperties::Transparent) && TransList[dTransVal[tilePosition.x][tilePosition.y]];
bool transparency = TileHasAny(tilePosition, TileProperties::Transparent) && TransList[dTransVal[tilePosition.x][tilePosition.y]];
#ifdef _DEBUG
if ((SDL_GetModState() & KMOD_ALT) != 0)
transparency = false;
#endif
const bool foliage = !TileHasAny(levelPieceId, TileProperties::Solid);
const bool foliage = !TileHasAny(tilePosition, TileProperties::Solid);
const auto getFirstTileMaskLeft = [=](TileType tile) -> MaskType {
if (transparency) {
switch (tile) {
case TileType::LeftTrapezoid:
case TileType::TransparentSquare:
return TileHasAny(levelPieceId, TileProperties::TransparentLeft)
return TileHasAny(tilePosition, TileProperties::TransparentLeft)
? MaskType::Left
: MaskType::Solid;
case TileType::LeftTriangle:
@ -505,7 +505,7 @@ void DrawCell(const Surface &out, Point tilePosition, Point targetBufferPosition
switch (tile) {
case TileType::RightTrapezoid:
case TileType::TransparentSquare:
return TileHasAny(levelPieceId, TileProperties::TransparentRight)
return TileHasAny(tilePosition, TileProperties::TransparentRight)
? MaskType::Right
: MaskType::Solid;
case TileType::RightTriangle:
@ -646,7 +646,7 @@ void DrawMonsterHelper(const Surface &out, Point tilePosition, Point targetBuffe
return;
}
if (!IsTileLit(tilePosition) && (!MyPlayer->_pInfraFlag || TileHasAny(dPiece[tilePosition.x][tilePosition.y], TileProperties::Solid)))
if (!IsTileLit(tilePosition) && (!MyPlayer->_pInfraFlag || TileHasAny(tilePosition, TileProperties::Solid)))
return;
if (static_cast<size_t>(mi) >= MaxMonsters) {
@ -851,7 +851,7 @@ void DrawFloor(const Surface &out, Point tilePosition, Point targetBufferPositio
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
if (InDungeonBounds(tilePosition)) {
if (!TileHasAny(dPiece[tilePosition.x][tilePosition.y], TileProperties::Solid))
if (!TileHasAny(tilePosition, TileProperties::Solid))
DrawFloor(out, tilePosition, targetBufferPosition);
} else {
world_draw_black_tile(out, targetBufferPosition.x, targetBufferPosition.y);
@ -879,7 +879,7 @@ void DrawFloor(const Surface &out, Point tilePosition, Point targetBufferPositio
[[nodiscard]] DVL_ALWAYS_INLINE bool IsWall(Point position)
{
return TileHasAny(dPiece[position.x][position.y], TileProperties::Solid) || dSpecial[position.x][position.y] != 0;
return TileHasAny(position, TileProperties::Solid) || dSpecial[position.x][position.y] != 0;
}
/**

4
Source/levels/gendung.h
Unescape View File

@ -332,9 +332,9 @@ struct Miniset {
}
};
[[nodiscard]] DVL_ALWAYS_INLINE bool TileHasAny(int tileId, TileProperties property)
[[nodiscard]] DVL_ALWAYS_INLINE bool TileHasAny(Point coords, TileProperties property)
{
return HasAnyOf(SOLData[tileId], property);
return HasAnyOf(SOLData[dPiece[coords.x][coords.y]], property);
}
void LoadLevelSOLData();

35
Source/levels/themes.cpp
Unescape View File

@ -43,45 +43,44 @@ size_t themeVar1;
bool TFit_Shrine(int i)
{
int xp = 0;
int yp = 0;
Point position { 0, 0 };
size_t found = 0;
while (found == 0) {
Point testPosition { xp, yp };
if (dTransVal[xp][yp] == themes[i].ttval) {
if (TileHasAny(dPiece[xp][yp - 1], TileProperties::Trap)
Point testPosition = position;
if (dTransVal[position.x][position.y] == themes[i].ttval) {
if (TileHasAny(position + Direction::NorthEast, TileProperties::Trap)
&& IsTileNotSolid(testPosition + Direction::NorthWest)
&& IsTileNotSolid(testPosition + Direction::SouthEast)
&& dTransVal[xp - 1][yp] == themes[i].ttval
&& dTransVal[xp + 1][yp] == themes[i].ttval
&& dTransVal[position.x - 1][position.y] == themes[i].ttval
&& dTransVal[position.x + 1][position.y] == themes[i].ttval
&& !IsObjectAtPosition(testPosition + Direction::North)
&& !IsObjectAtPosition(testPosition + Direction::East)) {
found = 1;
}
if (found == 0
&& TileHasAny(dPiece[xp - 1][yp], TileProperties::Trap)
&& TileHasAny(position + Direction::NorthWest, TileProperties::Trap)
&& IsTileNotSolid(testPosition + Direction::NorthEast)
&& IsTileNotSolid(testPosition + Direction::SouthWest)
&& dTransVal[xp][yp - 1] == themes[i].ttval
&& dTransVal[xp][yp + 1] == themes[i].ttval
&& dTransVal[position.x][position.y - 1] == themes[i].ttval
&& dTransVal[position.x][position.y + 1] == themes[i].ttval
&& !IsObjectAtPosition(testPosition + Direction::North)
&& !IsObjectAtPosition(testPosition + Direction::West)) {
found = 2;
}
}
if (found == 0) {
xp++;
if (xp == MAXDUNX) {
xp = 0;
yp++;
if (yp == MAXDUNY)
position.x++;
if (position.x == MAXDUNX) {
position.x = 0;
position.y++;
if (position.y == MAXDUNY)
return false;
}
}
}
themex = xp;
themey = yp;
themex = position.x;
themey = position.y;
themeVar1 = found;
return true;
}
@ -324,7 +323,7 @@ bool CheckThemeRoom(int8_t tv)
for (int j = 0; j < MAXDUNY; j++) {
for (int i = 0; i < MAXDUNX; i++) {
if (dTransVal[i][j] != tv || TileHasAny(dPiece[i][j], TileProperties::Solid))
if (dTransVal[i][j] != tv || TileHasAny({ i, j }, TileProperties::Solid))
continue;
if (dTransVal[i - 1][j] != tv && IsTileNotSolid({ i - 1, j }))
return false;

6
Source/lighting.cpp
Unescape View File

@ -142,7 +142,7 @@ bool TileAllowsLight(Point position)
{
if (!InDungeonBounds(position))
return false;
return !TileHasAny(dPiece[position.x][position.y], TileProperties::BlockLight);
return !TileHasAny(position, TileProperties::BlockLight);
}
void DoVisionFlags(Point position, MapExplorationType doAutomap, bool visible)
@ -294,7 +294,7 @@ void DoVision(Point position, uint8_t radius, MapExplorationType doAutomap, bool
Point crawl = position + VisionCrawlTable[j][k] * factor;
if (!InDungeonBounds(crawl))
break;
bool blockerFlag = TileHasAny(dPiece[crawl.x][crawl.y], TileProperties::BlockLight);
bool blockerFlag = TileHasAny(crawl, TileProperties::BlockLight);
bool tileOK = !blockerFlag;
if (VisionCrawlTable[j][k].deltaX > 0 && VisionCrawlTable[j][k].deltaY > 0) {
@ -581,7 +581,7 @@ void ProcessLightList()
i--;
continue;
}
if (TileHasAny(dPiece[light.position.tile.x][light.position.tile.y], TileProperties::Solid))
if (TileHasAny(light.position.tile, TileProperties::Solid))
continue; // Monster hidden in a wall, don't spoil the surprise
DoLighting(light.position.tile, light.radius, light.position.offset);
}

48
Source/missiles.cpp
Unescape View File

@ -73,7 +73,7 @@ bool CheckBlock(Point from, Point to)
{
while (from != to) {
from += GetDirection(from, to);
if (TileHasAny(dPiece[from.x][from.y], TileProperties::Solid))
if (TileHasAny(from, TileProperties::Solid))
return true;
}
@ -635,7 +635,7 @@ void AddRune(Missile &missile, Point dst, MissileID missileID)
if (TileContainsMissile(target)) {
return false;
}
if (TileHasAny(dPiece[target.x][target.y], TileProperties::Solid)) {
if (TileHasAny(target, TileProperties::Solid)) {
return false;
}
return true;
@ -694,7 +694,7 @@ bool GrowWall(int id, Point position, Point target, MissileID type, int spellLev
int dp = dPiece[position.x][position.y];
assert(dp <= MAXTILES && dp >= 0);
if (TileHasAny(dp, TileProperties::BlockMissile) || !InDungeonBounds(target)) {
if (TileHasAny(position, TileProperties::BlockMissile) || !InDungeonBounds(target)) {
return false;
}
@ -723,7 +723,7 @@ void SpawnLightning(Missile &missile, int dam)
assert(pn >= 0 && pn <= MAXTILES);
if (!missile.IsTrap() || tile != missile.position.start) {
if (TileHasAny(pn, TileProperties::BlockMissile)) {
if (TileHasAny(tile, TileProperties::BlockMissile)) {
missile._mirange = 0;
return false;
}
@ -733,8 +733,7 @@ void SpawnLightning(Missile &missile, int dam)
});
auto position = missile.position.tile;
int pn = dPiece[position.x][position.y];
if (!TileHasAny(pn, TileProperties::BlockMissile)) {
if (!TileHasAny(position, TileProperties::BlockMissile)) {
if (position != Point { missile.var1, missile.var2 } && InDungeonBounds(position)) {
MissileID type = MissileID::Lightning;
if (missile.sourceType() == MissileSource::Monster
@ -776,7 +775,7 @@ bool IsMissileBlockedByTile(Point tile)
return true;
}
if (TileHasAny(dPiece[tile.x][tile.y], TileProperties::BlockMissile)) {
if (TileHasAny(tile, TileProperties::BlockMissile)) {
return true;
}
@ -1999,9 +1998,7 @@ void AddTownPortal(Missile &missile, AddMissileParameter &parameter)
if (TileContainsMissile(target)) {
return false;
}
int dp = dPiece[target.x][target.y];
if (TileHasAny(dp, TileProperties::Solid | TileProperties::BlockMissile)) {
if (TileHasAny(target, TileProperties::Solid | TileProperties::BlockMissile)) {
return false;
}
return !CheckIfTrig(target);
@ -2115,8 +2112,7 @@ void AddGuardian(Missile &missile, AddMissileParameter &parameter)
return false;
}
int dp = dPiece[target.x][target.y];
if (TileHasAny(dp, TileProperties::Solid | TileProperties::BlockMissile)) {
if (TileHasAny(target, TileProperties::Solid | TileProperties::BlockMissile)) {
return false;
}
@ -3037,18 +3033,18 @@ void ProcessFireball(Missile &missile)
}
if (!TransList[dTransVal[missilePosition.x][missilePosition.y]]
|| (missile.position.velocity.deltaX < 0 && ((TransList[dTransVal[missilePosition.x][missilePosition.y + 1]] && TileHasAny(dPiece[missilePosition.x][missilePosition.y + 1], TileProperties::Solid)) || (TransList[dTransVal[missilePosition.x][missilePosition.y - 1]] && TileHasAny(dPiece[missilePosition.x][missilePosition.y - 1], TileProperties::Solid))))) {
missile.position.tile += Displacement { 1, 1 };
|| (missile.position.velocity.deltaX < 0 && ((TransList[dTransVal[missilePosition.x][missilePosition.y + 1]] && TileHasAny(missilePosition + Direction::SouthWest, TileProperties::Solid)) || (TransList[dTransVal[missilePosition.x][missilePosition.y - 1]] && TileHasAny(missilePosition + Direction::NorthEast, TileProperties::Solid))))) {
missile.position.tile += Direction::South;
missile.position.offset.deltaY -= 32;
}
if (missile.position.velocity.deltaY > 0
&& ((TransList[dTransVal[missilePosition.x + 1][missilePosition.y]] && TileHasAny(dPiece[missilePosition.x + 1][missilePosition.y], TileProperties::Solid))
|| (TransList[dTransVal[missilePosition.x - 1][missilePosition.y]] && TileHasAny(dPiece[missilePosition.x - 1][missilePosition.y], TileProperties::Solid)))) {
&& ((TransList[dTransVal[missilePosition.x + 1][missilePosition.y]] && TileHasAny(missilePosition + Direction::SouthEast, TileProperties::Solid))
|| (TransList[dTransVal[missilePosition.x - 1][missilePosition.y]] && TileHasAny(missilePosition + Direction::NorthWest, TileProperties::Solid)))) {
missile.position.offset.deltaY -= 32;
}
if (missile.position.velocity.deltaX > 0
&& ((TransList[dTransVal[missilePosition.x][missilePosition.y + 1]] && TileHasAny(dPiece[missilePosition.x][missilePosition.y + 1], TileProperties::Solid))
|| (TransList[dTransVal[missilePosition.x][missilePosition.y - 1]] && TileHasAny(dPiece[missilePosition.x][missilePosition.y - 1], TileProperties::Solid)))) {
&& ((TransList[dTransVal[missilePosition.x][missilePosition.y + 1]] && TileHasAny(missilePosition + Direction::SouthWest, TileProperties::Solid))
|| (TransList[dTransVal[missilePosition.x][missilePosition.y - 1]] && TileHasAny(missilePosition + Direction::NorthEast, TileProperties::Solid)))) {
missile.position.offset.deltaX -= 32;
}
missile._mimfnum = 0;
@ -3149,14 +3145,13 @@ void ProcessRingOfFire(Missile &missile)
Point target = Point { missile.var1, missile.var2 } + displacement;
if (!InDungeonBounds(target))
return false;
int dp = dPiece[target.x][target.y];
if (TileHasAny(dp, TileProperties::Solid))
if (TileHasAny(target, TileProperties::Solid))
return false;
if (IsObjectAtPosition(target))
return false;
if (!LineClearMissile(missile.position.tile, target))
return false;
if (TileHasAny(dp, TileProperties::BlockMissile)) {
if (TileHasAny(target, TileProperties::BlockMissile)) {
missile.limitReached = true;
return true;
}
@ -3783,7 +3778,7 @@ void ProcessApocalypse(Missile &missile)
continue;
if (Monsters[mid].isPlayerMinion())
continue;
if (TileHasAny(dPiece[k][j], TileProperties::Solid))
if (TileHasAny(PointOf { k, j }, TileProperties::Solid))
continue;
if (gbIsHellfire && !LineClearMissile(missile.position.tile, { k, j }))
continue;
@ -3812,7 +3807,7 @@ void ProcessFlameWaveControl(Missile &missile)
Point na = src + sd;
int pn = dPiece[na.x][na.y];
assert(pn >= 0 && pn <= MAXTILES);
if (!TileHasAny(pn, TileProperties::BlockMissile)) {
if (!TileHasAny(na, TileProperties::BlockMissile)) {
Direction pdir = Players[id]._pdir;
AddMissile(na, na + sd, pdir, MissileID::FlameWave, TARGET_MONSTERS, id, 0, missile._mispllvl);
na += dira;
@ -3820,7 +3815,7 @@ void ProcessFlameWaveControl(Missile &missile)
for (int j = 0; j < (missile._mispllvl / 2) + 2; j++) {
pn = dPiece[na.x][na.y]; // BUGFIX: dPiece is accessed before check against dungeon size and 0
assert(pn >= 0 && pn <= MAXTILES);
if (TileHasAny(pn, TileProperties::BlockMissile) || f1 || !InDungeonBounds(na)) {
if (TileHasAny(na, TileProperties::BlockMissile) || f1 || !InDungeonBounds(na)) {
f1 = true;
} else {
AddMissile(na, na + sd, pdir, MissileID::FlameWave, TARGET_MONSTERS, id, 0, missile._mispllvl);
@ -3828,7 +3823,7 @@ void ProcessFlameWaveControl(Missile &missile)
}
pn = dPiece[nb.x][nb.y]; // BUGFIX: dPiece is accessed before check against dungeon size and 0
assert(pn >= 0 && pn <= MAXTILES);
if (TileHasAny(pn, TileProperties::BlockMissile) || f2 || !InDungeonBounds(nb)) {
if (TileHasAny(nb, TileProperties::BlockMissile) || f2 || !InDungeonBounds(nb)) {
f2 = true;
} else {
AddMissile(nb, nb + sd, pdir, MissileID::FlameWave, TARGET_MONSTERS, id, 0, missile._mispllvl);
@ -3901,8 +3896,7 @@ void ProcessInfernoControl(Missile &missile)
missile.position.traveled += missile.position.velocity;
UpdateMissilePos(missile);
if (missile.position.tile != Point { missile.var1, missile.var2 }) {
int id = dPiece[missile.position.tile.x][missile.position.tile.y];
if (!TileHasAny(id, TileProperties::BlockMissile)) {
if (!TileHasAny(missile.position.tile, TileProperties::BlockMissile)) {
AddMissile(
missile.position.tile,
missile.position.start,

2
Source/monster.cpp
Unescape View File

@ -4150,7 +4150,7 @@ bool DirOK(const Monster &monster, Direction mdir)
bool PosOkMissile(Point position)
{
return !TileHasAny(dPiece[position.x][position.y], TileProperties::BlockMissile);
return !TileHasAny(position, TileProperties::BlockMissile);
}
bool LineClearMissile(Point startPoint, Point endPoint)

14
Source/objects.cpp
Unescape View File

@ -241,7 +241,7 @@ bool RndLocOk(Point p)
return false;
if (TileContainsSetPiece(p))
return false;
if (TileHasAny(dPiece[p.x][p.y], TileProperties::Solid))
if (TileHasAny(p, TileProperties::Solid))
return false;
return IsNoneOf(leveltype, DTYPE_CATHEDRAL, DTYPE_CRYPT) || dPiece[p.x][p.y] <= 125 || dPiece[p.x][p.y] >= 143;
}
@ -251,14 +251,14 @@ bool IsAreaOk(Rectangle rect)
return c_all_of(PointsInRectangle(rect), &RndLocOk);
}
bool CanPlaceWallTrap(int xp, int yp)
bool CanPlaceWallTrap(Point pos)
{
if (dObject[xp][yp] != 0)
if (dObject[pos.x][pos.y] != 0)
return false;
if (TileContainsSetPiece({ xp, yp }))
if (TileContainsSetPiece(pos))
return false;
return TileHasAny(dPiece[xp][yp], TileProperties::Trap);
return TileHasAny(pos, TileProperties::Trap);
}
void InitRndLocObj(int min, int max, _object_id objtype)
@ -498,7 +498,7 @@ void AddObjTraps()
while (IsTileNotSolid({ xp, j }))
xp--;
if (!CanPlaceWallTrap(xp, j) || i - xp <= 1)
if (!CanPlaceWallTrap({ xp, j }) || i - xp <= 1)
continue;
trapObject = AddObject(OBJ_TRAPL, { xp, j });
@ -507,7 +507,7 @@ void AddObjTraps()
while (IsTileNotSolid({ i, yp }))
yp--;
if (!CanPlaceWallTrap(i, yp) || j - yp <= 1)
if (!CanPlaceWallTrap({ i, yp }) || j - yp <= 1)
continue;
trapObject = AddObject(OBJ_TRAPR, { i, yp });

Write Preview
Loading…
Cancel
Save