yvt/openspades
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openspades/Sources/Client/GameMapWrapper.cpp
Tomoaki Kawada ebd79c0099 Change #include style 
All `#include`s to other subsystem now use angle brackets, e.g., `#include <Core/Math.h>`.
2016-12-03 18:49:07 +09:00

368 lines
11 KiB
C++
Raw Blame History

/*
Copyright (c) 2013 yvt
This file is part of OpenSpades.
OpenSpades is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSpades is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSpades. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cstring>
#include <deque>
#include <set>
#include <vector>
#include <Core/Debug.h>
#include <Core/Debug.h>
#include <Core/Deque.h>
#include <Core/Stopwatch.h>
#include "GameMap.h"
#include "GameMapWrapper.h"
namespace spades {
namespace client {
GameMapWrapper::GameMapWrapper(GameMap *mp) : map(mp) {
SPADES_MARK_FUNCTION();
width = mp->Width();
height = mp->Height();
depth = mp->Depth();
linkMap = new uint8_t[width * height * depth];
memset(linkMap, 0, width * height * depth);
}
GameMapWrapper::~GameMapWrapper() {
SPADES_MARK_FUNCTION();
delete[] linkMap;
}
void GameMapWrapper::Rebuild() {
SPADES_MARK_FUNCTION();
Stopwatch stopwatch;
GameMap *m = map;
memset(linkMap, 0, width * height * depth);
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
SetLink(x, y, depth - 1, Root);
Deque<CellPos> queue(width * height * 2);
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
if (m->IsSolid(x, y, depth - 2)) {
SetLink(x, y, depth - 2, PositiveZ);
queue.Push(CellPos(x, y, depth - 2));
}
while (!queue.IsEmpty()) {
CellPos p = queue.Front();
queue.Shift();
int x = p.x, y = p.y, z = p.z;
if (p.x > 0 && m->IsSolid(x - 1, y, z) && GetLink(x - 1, y, z) == Invalid) {
SetLink(x - 1, y, z, PositiveX);
queue.Push(CellPos(x - 1, y, z));
}
if (p.x < width - 1 && m->IsSolid(x + 1, y, z) && GetLink(x + 1, y, z) == Invalid) {
SetLink(x + 1, y, z, NegativeX);
queue.Push(CellPos(x + 1, y, z));
}
if (p.y > 0 && m->IsSolid(x, y - 1, z) && GetLink(x, y - 1, z) == Invalid) {
SetLink(x, y - 1, z, PositiveY);
queue.Push(CellPos(x, y - 1, z));
}
if (p.y < height - 1 && m->IsSolid(x, y + 1, z) &&
GetLink(x, y + 1, z) == Invalid) {
SetLink(x, y + 1, z, NegativeY);
queue.Push(CellPos(x, y + 1, z));
}
if (p.z > 0 && m->IsSolid(x, y, z - 1) && GetLink(x, y, z - 1) == Invalid) {
SetLink(x, y, z - 1, PositiveZ);
queue.Push(CellPos(x, y, z - 1));
}
if (p.z < depth - 1 && m->IsSolid(x, y, z + 1) && GetLink(x, y, z + 1) == Invalid) {
SetLink(x, y, z + 1, NegativeZ);
queue.Push(CellPos(x, y, z + 1));
}
}
SPLog("%.3f msecs to rebuild", stopwatch.GetTime() * 1000.);
}
void GameMapWrapper::AddBlock(int x, int y, int z, uint32_t color) {
SPADES_MARK_FUNCTION();
GameMap *m = map;
if (GetLink(x, y, z) != Invalid) {
SPAssert(m->IsSolid(x, y, z));
return;
}
m->Set(x, y, z, true, color);
if (GetLink(x, y, z) != Invalid) {
return;
}
LinkType l = Invalid;
if (x > 0 && m->IsSolid(x - 1, y, z) && GetLink(x - 1, y, z) != Invalid) {
l = NegativeX;
SPAssert(GetLink(x - 1, y, z) != PositiveX);
}
if (x < width - 1 && m->IsSolid(x + 1, y, z) && GetLink(x + 1, y, z) != Invalid) {
l = PositiveX;
SPAssert(GetLink(x + 1, y, z) != NegativeX);
}
if (y > 0 && m->IsSolid(x, y - 1, z) && GetLink(x, y - 1, z) != Invalid) {
l = NegativeY;
SPAssert(GetLink(x, y - 1, z) != PositiveY);
}
if (y < height - 1 && m->IsSolid(x, y + 1, z) && GetLink(x, y + 1, z) != Invalid) {
l = PositiveY;
SPAssert(GetLink(x, y + 1, z) != NegativeY);
}
if (z > 0 && m->IsSolid(x, y, z - 1) && GetLink(x, y, z - 1) != Invalid) {
l = NegativeZ;
SPAssert(GetLink(x, y, z - 1) != PositiveZ);
}
if (z < depth - 1 && m->IsSolid(x, y, z + 1) && GetLink(x, y, z + 1) != Invalid) {
l = PositiveZ;
SPAssert(GetLink(x, y, z + 1) != NegativeZ);
}
SetLink(x, y, z, l);
if (l == Invalid)
return;
// if there's invalid block around this block,
// rebuild tree
Deque<CellPos> queue(1024);
queue.Push(CellPos(x, y, z));
while (!queue.IsEmpty()) {
CellPos p = queue.Front();
queue.Shift();
int x = p.x, y = p.y, z = p.z;
SPAssert(m->IsSolid(x, y, z));
LinkType thisLink = GetLink(x, y, z);
if (p.x > 0 && m->IsSolid(x - 1, y, z) && GetLink(x - 1, y, z) == Invalid &&
thisLink != NegativeX) {
SetLink(x - 1, y, z, PositiveX);
queue.Push(CellPos(x - 1, y, z));
}
if (p.x < width - 1 && m->IsSolid(x + 1, y, z) && GetLink(x + 1, y, z) == Invalid &&
thisLink != PositiveX) {
SetLink(x + 1, y, z, NegativeX);
queue.Push(CellPos(x + 1, y, z));
}
if (p.y > 0 && m->IsSolid(x, y - 1, z) && GetLink(x, y - 1, z) == Invalid &&
thisLink != NegativeY) {
SetLink(x, y - 1, z, PositiveY);
queue.Push(CellPos(x, y - 1, z));
}
if (p.y < height - 1 && m->IsSolid(x, y + 1, z) &&
GetLink(x, y + 1, z) == Invalid && thisLink != PositiveY) {
SetLink(x, y + 1, z, NegativeY);
queue.Push(CellPos(x, y + 1, z));
}
if (p.z > 0 && m->IsSolid(x, y, z - 1) && GetLink(x, y, z - 1) == Invalid &&
thisLink != NegativeZ) {
SetLink(x, y, z - 1, PositiveZ);
queue.Push(CellPos(x, y, z - 1));
}
if (p.z < depth - 1 && m->IsSolid(x, y, z + 1) && GetLink(x, y, z + 1) == Invalid &&
thisLink != PositiveZ) {
SetLink(x, y, z + 1, NegativeZ);
queue.Push(CellPos(x, y, z + 1));
}
}
}
template <typename T> static inline bool EqualTwoCond(T a, T b, T c, bool cond) {
return a == b || (cond && a == c);
}
std::vector<CellPos> GameMapWrapper::RemoveBlocks(const std::vector<CellPos> &cells) {
SPADES_MARK_FUNCTION();
if (cells.empty())
return std::vector<CellPos>();
GameMap *m = map;
// solid, but unlinked cells
std::vector<CellPos> unlinkedCells;
Deque<CellPos> queue(1024);
// unlink children
for (size_t i = 0; i < cells.size(); i++) {
CellPos pos = cells[i];
m->Set(pos.x, pos.y, pos.z, false, 0);
// if(GetLink(pos.x, pos.y, pos.z) == Invalid){
// this block is already disconnected.
// }
if (GetLink(pos.x, pos.y, pos.z) == Marked) {
continue;
}
SPAssert(GetLink(pos.x, pos.y, pos.z) != Root);
SetLink(pos.x, pos.y, pos.z, Invalid);
queue.Push(pos);
while (!queue.IsEmpty()) {
pos = queue.Front();
queue.Shift();
if (m->IsSolid(pos.x, pos.y, pos.z))
unlinkedCells.push_back(pos);
// don't "continue;" when non-solid
int x = pos.x, y = pos.y, z = pos.z;
if (x > 0 && EqualTwoCond(GetLink(x - 1, y, z), PositiveX, Invalid,
m->IsSolid(x - 1, y, z))) {
SetLink(x - 1, y, z, Marked);
queue.Push(CellPos(x - 1, y, z));
}
if (x < width - 1 && EqualTwoCond(GetLink(x + 1, y, z), NegativeX, Invalid,
m->IsSolid(x + 1, y, z))) {
SetLink(x + 1, y, z, Marked);
queue.Push(CellPos(x + 1, y, z));
}
if (y > 0 && EqualTwoCond(GetLink(x, y - 1, z), PositiveY, Invalid,
m->IsSolid(x, y - 1, z))) {
SetLink(x, y - 1, z, Marked);
queue.Push(CellPos(x, y - 1, z));
}
if (y < height - 1 && EqualTwoCond(GetLink(x, y + 1, z), NegativeY, Invalid,
m->IsSolid(x, y + 1, z))) {
SetLink(x, y + 1, z, Marked);
queue.Push(CellPos(x, y + 1, z));
}
if (z > 0 && EqualTwoCond(GetLink(x, y, z - 1), PositiveZ, Invalid,
m->IsSolid(x, y, z - 1))) {
SetLink(x, y, z - 1, Marked);
queue.Push(CellPos(x, y, z - 1));
}
if (z < depth - 1 && EqualTwoCond(GetLink(x, y, z + 1), NegativeZ, Invalid,
m->IsSolid(x, y, z + 1))) {
SetLink(x, y, z + 1, Marked);
queue.Push(CellPos(x, y, z + 1));
}
}
}
// remove "visited" mark
for (size_t i = 0; i < unlinkedCells.size(); i++) {
const CellPos &pos = unlinkedCells[i];
if (GetLink(pos.x, pos.y, pos.z) == Marked)
SetLink(pos.x, pos.y, pos.z, Invalid);
}
SPAssert(queue.IsEmpty());
// start relinking
for (size_t i = 0; i < unlinkedCells.size(); i++) {
const CellPos &pos = unlinkedCells[i];
int x = pos.x, y = pos.y, z = pos.z;
if (!m->IsSolid(x, y, z)) {
// notice: (x,y,z) may be air, so
// don't use SPAssert()
continue;
}
LinkType newLink = Invalid;
if (z < depth - 1 && GetLink(x, y, z + 1) != Invalid) {
newLink = PositiveZ;
} else if (x > 0 && GetLink(x - 1, y, z) != Invalid) {
newLink = NegativeX;
} else if (x < width - 1 && GetLink(x + 1, y, z) != Invalid) {
newLink = PositiveX;
} else if (y > 0 && GetLink(x, y - 1, z) != Invalid) {
newLink = NegativeY;
} else if (y < height - 1 && GetLink(x, y + 1, z) != Invalid) {
newLink = PositiveY;
} else if (z > 0 && GetLink(x, y, z - 1) != Invalid) {
newLink = NegativeZ;
}
if (newLink != Invalid) {
SetLink(x, y, z, newLink);
queue.Push(pos);
}
}
while (!queue.IsEmpty()) {
CellPos p = queue.Front();
queue.Shift();
int x = p.x, y = p.y, z = p.z;
LinkType thisLink = GetLink(x, y, z);
if (p.x > 0 && m->IsSolid(x - 1, y, z) && GetLink(x - 1, y, z) == Invalid &&
thisLink != NegativeX) {
SetLink(x - 1, y, z, PositiveX);
queue.Push(CellPos(x - 1, y, z));
}
if (p.x < width - 1 && m->IsSolid(x + 1, y, z) && GetLink(x + 1, y, z) == Invalid &&
thisLink != PositiveX) {
SetLink(x + 1, y, z, NegativeX);
queue.Push(CellPos(x + 1, y, z));
}
if (p.y > 0 && m->IsSolid(x, y - 1, z) && GetLink(x, y - 1, z) == Invalid &&
thisLink != NegativeY) {
SetLink(x, y - 1, z, PositiveY);
queue.Push(CellPos(x, y - 1, z));
}
if (p.y < height - 1 && m->IsSolid(x, y + 1, z) &&
GetLink(x, y + 1, z) == Invalid && thisLink != PositiveY) {
SetLink(x, y + 1, z, NegativeY);
queue.Push(CellPos(x, y + 1, z));
}
if (p.z > 0 && m->IsSolid(x, y, z - 1) && GetLink(x, y, z - 1) == Invalid &&
thisLink != NegativeZ) {
SetLink(x, y, z - 1, PositiveZ);
queue.Push(CellPos(x, y, z - 1));
}
if (p.z < depth - 1 && m->IsSolid(x, y, z + 1) && GetLink(x, y, z + 1) == Invalid &&
thisLink != PositiveZ) {
SetLink(x, y, z + 1, NegativeZ);
queue.Push(CellPos(x, y, z + 1));
}
}
std::vector<CellPos> floatingBlocks;
floatingBlocks.reserve(unlinkedCells.size());
for (size_t i = 0; i < unlinkedCells.size(); i++) {
const CellPos &p = unlinkedCells[i];
if (!m->IsSolid(p.x, p.y, p.z))
continue;
if (GetLink(p.x, p.y, p.z) == Invalid) {
floatingBlocks.push_back(p);
}
}
return floatingBlocks;
}
}
}
Reference in New Issue View Git Blame Copy Permalink