Page MenuHomeWildfire Games
Differential D825 Diff 11812 source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

Changeset View

Standalone View

View Options

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

Show All 12 Lines
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>. * along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "precompiled.h" #include "precompiled.h"
#include "MessageHandler.h" #include "MessageHandler.h"
#include "../GameLoop.h"
#include "../CommandProc.h" #include "../CommandProc.h"
vladislavbelovUnsubmitted
Done
Inline Actions

Use the alphabet order.

vladislavbelov: Use the alphabet order.
#include "../GameLoop.h"
#include "../MessagePasser.h"
#include "graphics/GameView.h" #include "graphics/GameView.h"
#include "graphics/LOSTexture.h" #include "graphics/LOSTexture.h"
#include "graphics/MapIO.h" #include "graphics/MapIO.h"
#include "graphics/MapWriter.h" #include "graphics/MapWriter.h"
#include "graphics/Patch.h" #include "graphics/Patch.h"
#include "graphics/Terrain.h" #include "graphics/Terrain.h"
#include "graphics/TerrainTextureEntry.h" #include "graphics/TerrainTextureEntry.h"
#include "graphics/TerrainTextureManager.h" #include "graphics/TerrainTextureManager.h"
#include "gui/ObjectTypes/CMiniMap.h"
#include "lib/bits.h" #include "lib/bits.h"
#include "lib/file/vfs/vfs_path.h" #include "lib/file/vfs/vfs_path.h"
#include "lib/status.h" #include "lib/status.h"
#include "maths/MathUtil.h" #include "maths/MathUtil.h"
#include "ps/CLogger.h" #include "ps/CLogger.h"
#include "ps/Filesystem.h" #include "ps/Filesystem.h"
#include "ps/Game.h" #include "ps/Game.h"
#include "ps/GameSetup/GameSetup.h"
#include "ps/Loader.h" #include "ps/Loader.h"
#include "ps/World.h" #include "ps/World.h"
#include "renderer/Renderer.h" #include "renderer/Renderer.h"
#include "renderer/WaterManager.h"
#include "scriptinterface/ScriptInterface.h" #include "scriptinterface/ScriptInterface.h"
#include "simulation2/Simulation2.h" #include "simulation2/Simulation2.h"
#include "simulation2/components/ICmpOwnership.h"
#include "simulation2/components/ICmpPlayer.h" #include "simulation2/components/ICmpPlayer.h"
#include "simulation2/components/ICmpPlayerManager.h" #include "simulation2/components/ICmpPlayerManager.h"
#include "simulation2/components/ICmpPosition.h" #include "simulation2/components/ICmpPosition.h"
#include "simulation2/components/ICmpRangeManager.h" #include "simulation2/components/ICmpRangeManager.h"
#include "simulation2/components/ICmpTemplateManager.h"
#include "simulation2/components/ICmpTerrain.h" #include "simulation2/components/ICmpTerrain.h"
#include "simulation2/system/ParamNode.h"
namespace namespace
{ {
void InitGame() void InitGame()
{ {
if (g_Game) if (g_Game)
{ {
delete g_Game; delete g_Game;
▲ Show 20 Lines • Show All 208 Lines • ▼ Show 20 Lines
{ {
g_Game->GetSimulation2()->LoadPlayerSettings(msg->newplayers); g_Game->GetSimulation2()->LoadPlayerSettings(msg->newplayers);
} }
QUERYHANDLER(GetMapSizes) QUERYHANDLER(GetMapSizes)
{ {
msg->sizes = g_Game->GetSimulation2()->GetMapSizes(); msg->sizes = g_Game->GetSimulation2()->GetMapSizes();
} }
QUERYHANDLER(RasterizeMinimap)
{
const CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
const ssize_t dimension = terrain->GetVerticesPerSide() - 1;
const ssize_t bpp = 24;
const ssize_t buf_size = dimension * dimension * (bpp / 8);
std::vector<u8> imageBytes(buf_size);
vladislavbelovUnsubmitted
Done
Inline Actions

std::vector<u8> imageBytes(buf_size);.

vladislavbelov: `std::vector<u8> imageBytes(buf_size);`.
float shallowPassageHeight = CMiniMap::GetShallowPassageHeight();
vladislavbelovUnsubmitted
Done
Inline Actions

That's bad, we might have a dissynchronization. I suggest to move the original code to a common static function of Minimap and reuse it here.

vladislavbelov: That's bad, we might have a dissynchronization. I suggest to move the original code to a common…
ssize_t w = dimension;
ssize_t h = dimension;
float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
for (ssize_t j = 0; j < h; ++j)
{
// Work backwards to vertically flip the image.
ssize_t position = 3 * (h - j - 1) * dimension;
for (ssize_t i = 0; i < w; ++i)
{
float avgHeight = (terrain->GetVertexGroundLevel(i, j)
+ terrain->GetVertexGroundLevel(i + 1, j)
+ terrain->GetVertexGroundLevel(i, j + 1)
+ terrain->GetVertexGroundLevel(i + 1, j + 1)
) / 4.0f;
if (avgHeight < waterHeight && avgHeight > waterHeight - shallowPassageHeight)
{
// shallow water
imageBytes[position++] = 0x70;
imageBytes[position++] = 0x98;
imageBytes[position++] = 0xc0;
}
else if (avgHeight < waterHeight)
{
// Set water as constant color for consistency on different maps
imageBytes[position++] = 0x50;
imageBytes[position++] = 0x78;
imageBytes[position++] = 0xa0;
}
else
{
u32 color = std::numeric_limits<u32>::max();
vladislavbelovUnsubmitted
Done
Inline Actions

As I said below, raw pointers isn't the good practice for threaded applications. I'd prefer to use std::vector<u8> instead of this C-style.

vladislavbelov: As I said below, raw pointers isn't the good practice for threaded applications. I'd prefer to…
u32 hmap = static_cast<u32>(terrain->GetHeightMap()[j * dimension + i]) >> 8;
float scale = hmap / 3.0f + 170.0f / 255.0f;
CMiniPatch* mp = terrain->GetTile(i, j);
if (mp)
{
CTerrainTextureEntry* tex = mp->GetTextureEntry();
if (tex)
color = tex->GetBaseColor();
}
// Convert
imageBytes[position++] = static_cast<u8>(static_cast<float>(color & 0xff) * scale);
imageBytes[position++] = static_cast<u8>(static_cast<float>((color >> 8) & 0xff) * scale);
imageBytes[position++] = static_cast<u8>(static_cast<float>((color >> 16) & 0xff) * scale);
}
}
}
msg->imageBytes = std::move(imageBytes);
vladislavbelovUnsubmitted
Done
Inline Actions
msg->imageBytes = std::move(imageBytes);
vladislavbelov: ```lang=cpp msg->imageBytes = std::move(imageBytes); ```
msg->dimension = dimension;
}
vladislavbelovUnsubmitted
Done
Inline Actions

Misleading name, it doesn't return display. I'd suggest to call it like DrawMinimap or RasterizeMinimap.

vladislavbelov: Misleading name, it doesn't return display. I'd suggest to call it like `DrawMinimap` or…
QUERYHANDLER(GetRMSData) QUERYHANDLER(GetRMSData)
{ {
msg->data = g_Game->GetSimulation2()->GetRMSData(); msg->data = g_Game->GetSimulation2()->GetRMSData();
} }
QUERYHANDLER(GetCurrentMapSize)
{
msg->size = g_Game->GetWorld()->GetTerrain()->GetTilesPerSide();
}
BEGIN_COMMAND(ResizeMap) BEGIN_COMMAND(ResizeMap)
{ {
int m_OldTiles, m_NewTiles; bool Within(const CFixedVector3D& pos, const int centerX, const int centerZ, const int radius)
{
int dx = abs(pos.X.ToInt_RoundToZero() - centerX);
if (dx > radius)
return false;
int dz = abs(pos.Z.ToInt_RoundToZero() - centerZ);
if (dz > radius)
return false;
if (dx + dz <= radius)
return true;
return (dx * dx + dz * dz <= radius * radius);
}
struct DeletedObject
{
entity_id_t entityId;
CStr templateName;
int32_t owner;
CFixedVector3D pos;
vladislavbelovUnsubmitted
Done
Inline Actions

Useless brackets.

vladislavbelov: Useless brackets.
CFixedVector3D rot;
};
ssize_t m_OldPatches, m_NewPatches;
int m_OffsetX, m_OffsetY;
u16* m_Heightmap;
CPatch* m_Patches;
cResizeMap() std::vector<DeletedObject> m_DeletedObjects;
std::vector<std::pair<entity_id_t, CFixedVector3D>> m_OldPositions;
std::vector<std::pair<entity_id_t, CFixedVector3D>> m_NewPositions;
vladislavbelovUnsubmitted
Done
Inline Actions

I suggest to rename test to position/pos.

vladislavbelov: I suggest to rename `test` to `position`/`pos`.
cResizeMap() : m_Heightmap(nullptr), m_Patches(nullptr)
vladislavbelovUnsubmitted
Done
Inline Actions

Why void* and not u8?

vladislavbelov: Why `void*` and not `u8`?
Clockwork-MuseUnsubmitted
Done
Inline Actions

Because previously I was directly passing it into the destination wxImage, so just was working on the exact type I needed.

Clockwork-Muse: Because previously I was directly passing it into the destination wxImage, so just was working…
{
vladislavbelovUnsubmitted
Done
Inline Actions
cResizeMap() : m_Heightmap(nullptr), m_Patches(nullptr)
{
}
vladislavbelov: ```lang=cpp cResizeMap() : m_Heightmap(nullptr), m_Patches(nullptr) { } ```
}
~cResizeMap()
{ {
delete m_Heightmap;
vladislavbelovUnsubmitted
Done
Inline Actions

A bit dangerous, these pointers aren't default initialized.

vladislavbelov: A bit dangerous, these pointers aren't default initialized.
StanAuthorUnsubmitted
Done
Inline Actions

How should I do that ?

Like this ?

if(m_Heightmap != nullptr)
    delete m_Heightmap;
if(m_Patches!= nullptr)
    delete m_Patches;
Stan: How should I do that ? Like this ? ```lang=cpp if(m_Heightmap != nullptr) delete…
vladislavbelovUnsubmitted
Done
Inline Actions

No, I mean to initialize them in ctor by nullptr.

vladislavbelov: No, I mean to initialize them in ctor by `nullptr`.
delete m_Patches;
} }
void MakeDirty() void MakeDirty()
{ {
CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY); CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
if (cmpTerrain) if (cmpTerrain)
cmpTerrain->ReloadTerrain(); cmpTerrain->ReloadTerrain();
// The LOS texture won't normally get updated when running Atlas // The LOS texture won't normally get updated when running Atlas
// (since there's no simulation updates), so explicitly dirty it // (since there's no simulation updates), so explicitly dirty it
g_Game->GetView()->GetLOSTexture().MakeDirty(); g_Game->GetView()->GetLOSTexture().MakeDirty();
} }
void ResizeTerrain(int tiles) void ResizeTerrain(ssize_t patches, int offsetX, int offsetY)
{ {
CTerrain* terrain = g_Game->GetWorld()->GetTerrain(); CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
terrain->ResizeAndOffset(patches, offsetX, offsetY);
}
const ssize_t newSize = tiles / PATCH_SIZE; void DeleteObjects(const std::vector<DeletedObject>& deletedObjects)
const ssize_t offset = (newSize - terrain->GetPatchesPerSide()) / 2; {
terrain->ResizeAndOffset(newSize, offset, offset); for (const DeletedObject& deleted : deletedObjects)
{
g_Game->GetSimulation2()->DestroyEntity(deleted.entityId);
}
MakeDirty(); g_Game->GetSimulation2()->FlushDestroyedEntities();
}
void RestoreObjects(const std::vector<DeletedObject>& deletedObjects)
vladislavbelovUnsubmitted
Done
Inline Actions

RestoreAll? Also suffix All, why it's used for Delete and here, but not for SetPosition? Though there are no all entities in all these cases, only passed as argument.

vladislavbelov: `RestoreAll`? Also suffix `All`, why it's used for `Delete` and here, but not for `SetPosition`?
{
CSimulation2& sim = *g_Game->GetSimulation2();
for (const DeletedObject& deleted : deletedObjects)
{
entity_id_t ent = sim.AddEntity(deleted.templateName.FromUTF8(), deleted.entityId);
if (ent == INVALID_ENTITY)
{
LOGERROR("Failed to load entity template '%s'", deleted.templateName.c_str());
}
else
{
CmpPtr<ICmpPosition> cmpPosition(sim, deleted.entityId);
if (cmpPosition)
{
cmpPosition->JumpTo(deleted.pos.X, deleted.pos.Z);
cmpPosition->SetXZRotation(deleted.rot.X, deleted.rot.Z);
cmpPosition->SetYRotation(deleted.rot.Y);
}
CmpPtr<ICmpOwnership> cmpOwnership(sim, deleted.entityId);
if (cmpOwnership)
cmpOwnership->SetOwner(deleted.owner);
}
}
}
void SetMovedEntitiesPosition(const std::vector<std::pair<entity_id_t, CFixedVector3D>>& movedObjects)
vladislavbelovUnsubmitted
Done
Inline Actions

Too common name, maybe SetPositionOfMovedEntities?

vladislavbelov: Too common name, maybe `SetPositionOfMovedEntities`?
{
for (std::pair<entity_id_t, CFixedVector3D> const& kv : movedObjects)
{
entity_id_t id = kv.first;
CFixedVector3D position = kv.second;
CmpPtr<ICmpPosition> cmpPosition(*g_Game->GetSimulation2(), id);
ENSURE(cmpPosition);
cmpPosition->JumpTo(position.X, position.Z);
}
} }
void Do() void Do()
{ {
CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY); CSimulation2& sim = *g_Game->GetSimulation2();
CmpPtr<ICmpTemplateManager> cmpTemplateManager(sim, SYSTEM_ENTITY);
ENSURE(cmpTemplateManager);
CmpPtr<ICmpTerrain> cmpTerrain(sim, SYSTEM_ENTITY);
if (!cmpTerrain) if (!cmpTerrain)
{ {
m_OldTiles = m_NewTiles = 0; m_OldPatches = m_NewPatches = 0;
m_OffsetX = m_OffsetY = 0;
}
else
{
m_OldPatches = static_cast<ssize_t>(cmpTerrain->GetTilesPerSide() / PATCH_SIZE);
m_NewPatches = msg->tiles / PATCH_SIZE;
m_OffsetX = msg->offsetX / PATCH_SIZE;
// Need to flip direction of vertical offset, due to screen mapping order.
m_OffsetY = -(msg->offsetY / PATCH_SIZE);
CTerrain* terrain = cmpTerrain->GetCTerrain();
m_Heightmap = new u16[(m_OldPatches * PATCH_SIZE + 1) * (m_OldPatches * PATCH_SIZE + 1)];
std::copy_n(terrain->GetHeightMap(), (m_OldPatches * PATCH_SIZE + 1) * (m_OldPatches * PATCH_SIZE + 1), m_Heightmap);
m_Patches = new CPatch[m_OldPatches * m_OldPatches];
for (ssize_t j = 0; j < m_OldPatches; ++j)
{
for (ssize_t i = 0; i < m_OldPatches; ++i)
{
CPatch& src = *(terrain->GetPatch(i, j));
CPatch& dst = m_Patches[j * m_OldPatches + i];
std::copy_n(&src.m_MiniPatches[0][0], PATCH_SIZE * PATCH_SIZE, &dst.m_MiniPatches[0][0]);
}
}
}
const int radiusInTerrainUnits = m_NewPatches * PATCH_SIZE * TERRAIN_TILE_SIZE / 2 * (1.f - 1e-6f);
// Opposite direction offset, as we move the destination onto the source, not the source into the destination.
const int mapCenterX = (m_OldPatches / 2 - m_OffsetX) * PATCH_SIZE * TERRAIN_TILE_SIZE;
const int mapCenterZ = (m_OldPatches / 2 - m_OffsetY) * PATCH_SIZE * TERRAIN_TILE_SIZE;
// The offset to move units by is opposite the direction the map is moved, and from the corner.
const int offsetX = ((m_NewPatches - m_OldPatches) / 2 + m_OffsetX) * PATCH_SIZE * TERRAIN_TILE_SIZE;
const int offsetZ = ((m_NewPatches - m_OldPatches) / 2 + m_OffsetY) * PATCH_SIZE * TERRAIN_TILE_SIZE;
const CFixedVector3D offset = CFixedVector3D(fixed::FromInt(offsetX), fixed::FromInt(0), fixed::FromInt(offsetZ));
const CSimulation2::InterfaceListUnordered& ents = sim.GetEntitiesWithInterfaceUnordered(IID_Selectable);
for (std::pair<entity_id_t, IComponent*> const& kv : ents)
{
const entity_id_t entityId = kv.first;
CmpPtr<ICmpPosition> cmpPosition(sim, entityId);
if (cmpPosition && cmpPosition->IsInWorld() && Within(cmpPosition->GetPosition(), mapCenterX, mapCenterZ, radiusInTerrainUnits))
{
CFixedVector3D position = cmpPosition->GetPosition();
m_NewPositions.emplace_back(entityId, position + offset);
m_OldPositions.emplace_back(entityId, position);
} }
else else
{ {
m_OldTiles = (int)cmpTerrain->GetTilesPerSide(); DeletedObject deleted;
m_NewTiles = msg->tiles; deleted.entityId = entityId;
deleted.templateName = cmpTemplateManager->GetCurrentTemplateName(entityId);
// If the entity has a position, but the ending position is not valid;
if (cmpPosition)
{
deleted.pos = cmpPosition->GetPosition();
deleted.rot = cmpPosition->GetRotation();
}
CmpPtr<ICmpOwnership> cmpOwnership(sim, entityId);
if (cmpOwnership)
deleted.owner = cmpOwnership->GetOwner();
m_DeletedObjects.push_back(deleted);
}
} }
ResizeTerrain(m_NewTiles); DeleteObjects(m_DeletedObjects);
ResizeTerrain(m_NewPatches, m_OffsetX, m_OffsetY);
SetMovedEntitiesPosition(m_NewPositions);
MakeDirty();
} }
void Undo() void Undo()
{ {
ResizeTerrain(m_OldTiles); if (m_Heightmap == nullptr || m_Patches == nullptr)
{
// If there previously was no data, just resize to old (probably not originally valid).
ResizeTerrain(m_OldPatches, -m_OffsetX, -m_OffsetY);
}
else
vladislavbelovUnsubmitted
Done
Inline Actions

The auto isn't preferred for this cases, because the name or the type doesn't tell about itself.

vladislavbelov: The `auto` isn't preferred for this cases, because the name or the type doesn't tell about…
{
CSimulation2& sim = *g_Game->GetSimulation2();
CmpPtr<ICmpTerrain> cmpTerrain(sim, SYSTEM_ENTITY);
CTerrain* terrain = cmpTerrain->GetCTerrain();
terrain->Initialize(m_OldPatches, m_Heightmap);
// Copy terrain data back.
for (ssize_t j = 0; j < m_OldPatches; ++j)
{
for (ssize_t i = 0; i < m_OldPatches; ++i)
{
CPatch& src = m_Patches[j * m_OldPatches + i];
CPatch& dst = *(terrain->GetPatch(i, j));
std::copy_n(&src.m_MiniPatches[0][0], PATCH_SIZE * PATCH_SIZE, &dst.m_MiniPatches[0][0]);
}
}
}
RestoreObjects(m_DeletedObjects);
SetMovedEntitiesPosition(m_OldPositions);
MakeDirty();
} }
void Redo() void Redo()
{ {
ResizeTerrain(m_NewTiles); DeleteObjects(m_DeletedObjects);
ResizeTerrain(m_NewPatches, m_OffsetX, m_OffsetY);
SetMovedEntitiesPosition(m_NewPositions);
MakeDirty();
} }
}; };
END_COMMAND(ResizeMap) END_COMMAND(ResizeMap)
QUERYHANDLER(VFSFileExists) QUERYHANDLER(VFSFileExists)
{ {
msg->exists = VfsFileExists(*msg->path); msg->exists = VfsFileExists(*msg->path);
} }
QUERYHANDLER(VFSFileRealPath) QUERYHANDLER(VFSFileRealPath)
{ {
VfsPath pathname(*msg->path); VfsPath pathname(*msg->path);
if (pathname.empty()) if (pathname.empty())
return; return;
OsPath realPathname; OsPath realPathname;
if (g_VFS->GetRealPath(pathname, realPathname) == INFO::OK) if (g_VFS->GetRealPath(pathname, realPathname) == INFO::OK)
msg->realPath = realPathname.string(); msg->realPath = realPathname.string();
} }
static Status AddToFilenames(const VfsPath& pathname, const CFileInfo& UNUSED(fileInfo), const uintptr_t cbData) static Status AddToFilenames(const VfsPath& pathname, const CFileInfo& UNUSED(fileInfo), const uintptr_t cbData)
vladislavbelovUnsubmitted
Done
Inline Actions

Won't entities be re-added?

vladislavbelov: Won't entities be re-added?
Clockwork-MuseUnsubmitted
Done
Inline Actions

I don't understand your comment? What are you getting at here?

Clockwork-Muse: I don't understand your comment? What are you getting at here?
{ {
std::vector<std::wstring>& filenames = *(std::vector<std::wstring>*)cbData; std::vector<std::wstring>& filenames = *(std::vector<std::wstring>*)cbData;
filenames.push_back(pathname.string().c_str()); filenames.push_back(pathname.string().c_str());
return INFO::OK; return INFO::OK;
} }
QUERYHANDLER(GetMapList) QUERYHANDLER(GetMapList)
{ {
Show All 12 Lines
Wildfire Games · Phabricator