mlangkabel/dota_factory
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use WorldCoordinates in ArenaView too

Browse Source
This commit is contained in:
mlangkabel
2026-08-05 19:42:37 +02:00
parent 2af09d9eb1
commit fa9dbd62ad
7 changed files with 208 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
src/balancing/ArenaView.cpp
View File

@@ -176,55 +176,36 @@ void ArenaView::paintGL()
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, false);
drawTiles(painter);
drawBuildings(painter);
drawStations(painter);
drawDebris(painter);
// One transform snapshot for the whole frame; every draw below reads the
// viewport through it.
const WorldCoordinates coordinates = getCoordinates();
drawTiles(painter, coordinates);
drawBuildings(painter, coordinates);
drawStations(painter, coordinates);
drawDebris(painter, coordinates);
if (m_debugDraw)
{
drawDebugSensorRanges(painter);
drawDebugTargetLines(painter);
drawDebugSensorRanges(painter, coordinates);
drawDebugTargetLines(painter, coordinates);
}
drawShips(painter);
drawBeams(painter);
drawShips(painter, coordinates);
drawBeams(painter, coordinates);
}
// ---------------------------------------------------------------------------
// Coordinate helpers
// ---------------------------------------------------------------------------
float ArenaView::getTilePx() const
WorldCoordinates ArenaView::getCoordinates() const
{
// The arena is a fixed, fully visible world — unlike the game view it has no
// scrolling, so the tile size comes from fitting the whole arena in the widget.
const ArenaConfig& ac = m_sim->getArenaConfig();
const int totalWidth = ac.playerBufferWidth_tiles
+ ac.contestZoneWidth_tiles
+ ac.enemyBufferWidth_tiles;
const int totalHeight = ac.heightTiles;
if (totalWidth <= 0 || totalHeight <= 0) { return 1.0f; }
const float pxPerTileH = static_cast<float>(height()) / static_cast<float>(totalHeight);
const float pxPerTileW = static_cast<float>(width()) / static_cast<float>(totalWidth);
return std::min(pxPerTileH, pxPerTileW);
}
QPointF ArenaView::worldToWidget(QVector2D worldPos) const
{
return QPointF(
static_cast<qreal>(worldPos.x() * getTilePx()),
static_cast<qreal>(worldPos.y() * getTilePx()));
}
QPointF ArenaView::tileToWidget(QPoint tile) const
{
return worldToWidget(QVector2D(static_cast<float>(tile.x()),
static_cast<float>(tile.y())));
}
QRectF ArenaView::tileRect(QPoint tile) const
{
const QPointF tl = tileToWidget(tile);
return QRectF(tl.x(), tl.y(),
static_cast<qreal>(getTilePx()), static_cast<qreal>(getTilePx()));
return WorldCoordinates::fitToWorld(size(), totalWidth, ac.heightTiles);
}
std::optional<QVector2D> ArenaView::entityPosition(entt::entity entity) const
@@ -236,19 +217,11 @@ std::optional<QVector2D> ArenaView::entityPosition(entt::entity entity) const
return m_sim->getAdmin().get<PositionComponent>(entity).value;
}
QVector2D ArenaView::widgetToWorld(QPoint widgetPt) const
{
const float px = getTilePx();
if (px < 0.001f) { return QVector2D(0.0f, 0.0f); }
return QVector2D(static_cast<float>(widgetPt.x()) / px,
static_cast<float>(widgetPt.y()) / px);
}
void ArenaView::mousePressEvent(QMouseEvent* event)
{
if (event->button() == Qt::LeftButton)
{
const QVector2D worldPos = widgetToWorld(event->pos());
const QVector2D worldPos = getCoordinates().widgetToWorld(event->pos());
entt::entity hit = entityAtWorldPos(m_sim->getAdmin(), worldPos);
if (hit != entt::null)
@@ -287,7 +260,7 @@ void ArenaView::keyPressEvent(QKeyEvent* event)
// Rendering
// ---------------------------------------------------------------------------
void ArenaView::drawTiles(QPainter& painter)
void ArenaView::drawTiles(QPainter& painter, const WorldCoordinates& coordinates)
{
const ArenaConfig& ac = m_sim->getArenaConfig();
const int totalWidth = ac.playerBufferWidth_tiles
@@ -300,12 +273,12 @@ void ArenaView::drawTiles(QPainter& painter)
{
for (int y = 0; y < totalHeight; ++y)
{
painter.fillRect(tileRect(QPoint(x, y)), m_visuals->space.fill);
painter.fillRect(coordinates.tileRect(QPoint(x, y)), m_visuals->space.fill);
}
}
}
void ArenaView::drawBuildings(QPainter& painter)
void ArenaView::drawBuildings(QPainter& painter, const WorldCoordinates& coordinates)
{
for (const Building& b : getAllBuildings(m_sim->getFactoryState()))
{
@@ -317,13 +290,13 @@ void ArenaView::drawBuildings(QPainter& painter)
painter.setPen(Qt::NoPen);
for (const QPoint& cell : b.bodyCells)
{
painter.fillRect(tileRect(cell), bv.fill);
painter.fillRect(coordinates.tileRect(cell), bv.fill);
}
const QPointF tl = tileToWidget(b.anchor);
const QPointF tl = coordinates.tileToWidget(b.anchor);
const QRectF bboxRect(tl.x(), tl.y(),
b.footprint.width() * static_cast<qreal>(getTilePx()),
b.footprint.height() * static_cast<qreal>(getTilePx()));
b.footprint.width() * static_cast<qreal>(coordinates.getTilePx()),
b.footprint.height() * static_cast<qreal>(coordinates.getTilePx()));
painter.setPen(QPen(bv.outline, 1));
painter.setBrush(Qt::NoBrush);
@@ -337,12 +310,12 @@ void ArenaView::drawBuildings(QPainter& painter)
}
}
void ArenaView::drawDebris(QPainter& painter)
void ArenaView::drawDebris(QPainter& painter, const WorldCoordinates& coordinates)
{
const float r = getTilePx() * 0.2f;
const float r = coordinates.getTilePx() * 0.2f;
for (const DebrisInfo& debris : getAllDebrisInfo(m_sim->getAdmin()))
{
const QPointF center = worldToWidget(debris.position);
const QPointF center = coordinates.worldToWidget(debris.position);
painter.setBrush(QColor(128, 110, 90));
painter.setPen(QPen(QColor(50, 40, 30), 1));
painter.drawEllipse(center,
@@ -350,7 +323,7 @@ void ArenaView::drawDebris(QPainter& painter)
}
}
void ArenaView::drawStations(QPainter& painter)
void ArenaView::drawStations(QPainter& painter, const WorldCoordinates& coordinates)
{
m_sim->getAdmin().forEach<StationBodyComponent, FactionComponent, HealthComponent>(
[&](entt::entity e, const StationBodyComponent& sb, const FactionComponent& f, const HealthComponent& h)
@@ -366,13 +339,13 @@ void ArenaView::drawStations(QPainter& painter)
painter.setPen(Qt::NoPen);
for (const QPoint& cell : sb.bodyCells)
{
painter.fillRect(tileRect(cell), bv.fill);
painter.fillRect(coordinates.tileRect(cell), bv.fill);
}
const QPointF tl = tileToWidget(sb.anchor);
const QPointF tl = coordinates.tileToWidget(sb.anchor);
const QRectF bboxRect(tl.x(), tl.y(),
sb.footprint.width() * static_cast<qreal>(getTilePx()),
sb.footprint.height() * static_cast<qreal>(getTilePx()));
sb.footprint.width() * static_cast<qreal>(coordinates.getTilePx()),
sb.footprint.height() * static_cast<qreal>(coordinates.getTilePx()));
painter.setPen(QPen(bv.outline, 1));
painter.setBrush(Qt::NoBrush);
@@ -381,7 +354,7 @@ void ArenaView::drawStations(QPainter& painter)
if (h.maxHp > 0.0f)
{
const float fraction = std::max(0.0f, h.hp / h.maxHp);
const qreal barH = static_cast<qreal>(getTilePx()) * 0.12;
const qreal barH = static_cast<qreal>(coordinates.getTilePx()) * 0.12;
const qreal barY = bboxRect.bottom() + 1.0;
const qreal barW = bboxRect.width();
painter.fillRect(QRectF(bboxRect.left(), barY, barW, barH),
@@ -399,7 +372,7 @@ void ArenaView::drawStations(QPainter& painter)
});
}
void ArenaView::drawShips(QPainter& painter)
void ArenaView::drawShips(QPainter& painter, const WorldCoordinates& coordinates)
{
m_sim->getAdmin().forEach<ShipIdentityComponent, PositionComponent, FacingComponent,
FactionComponent, HealthComponent>(
@@ -411,12 +384,12 @@ void ArenaView::drawShips(QPainter& painter)
m_visuals->ships.find(si.schematicId);
if (it == m_visuals->ships.end()) { return; }
const QPointF center = worldToWidget(pos.value);
const QPointF center = coordinates.worldToWidget(pos.value);
const QVector2D dir(std::cos(facing.radians), std::sin(facing.radians));
const QVector2D perp(-dir.y(), dir.x());
const float fwd = getTilePx() * 0.45f;
const float side = getTilePx() * 0.25f;
const float fwd = coordinates.getTilePx() * 0.45f;
const float side = coordinates.getTilePx() * 0.25f;
QPolygonF tri;
tri << QPointF(center.x() + static_cast<qreal>(dir.x() * fwd),
@@ -434,7 +407,7 @@ void ArenaView::drawShips(QPainter& painter)
{
const float fraction = std::max(0.0f, h.hp / h.maxHp);
const qreal barW = static_cast<qreal>(fwd) * 2.0;
const qreal barH = static_cast<qreal>(getTilePx()) * 0.12;
const qreal barH = static_cast<qreal>(coordinates.getTilePx()) * 0.12;
const qreal barX = center.x() - static_cast<qreal>(fwd);
const qreal barY = center.y() + static_cast<qreal>(fwd) + 1.0;
painter.fillRect(QRectF(barX, barY, barW, barH), QColor(60, 60, 60));
@@ -444,7 +417,7 @@ void ArenaView::drawShips(QPainter& painter)
if (m_selectedEntity.has_value() && *m_selectedEntity == e)
{
const qreal radius = static_cast<qreal>(getTilePx()) * 0.55;
const qreal radius = static_cast<qreal>(coordinates.getTilePx()) * 0.55;
painter.setPen(QPen(QColor(255, 255, 0), 2));
painter.setBrush(Qt::NoBrush);
painter.drawEllipse(center, radius, radius);
@@ -452,7 +425,8 @@ void ArenaView::drawShips(QPainter& painter)
});
}
void ArenaView::drawDebugSensorRanges(QPainter& painter)
void ArenaView::drawDebugSensorRanges(QPainter& painter,
const WorldCoordinates& coordinates)
{
painter.setBrush(Qt::NoBrush);
m_sim->getAdmin().forEach<ShipIdentityComponent, PositionComponent, SensorRangeComponent>(
@@ -463,9 +437,9 @@ void ArenaView::drawDebugSensorRanges(QPainter& painter)
m_visuals->ships.find(si.schematicId);
if (it == m_visuals->ships.end()) { return; }
const QPointF center = worldToWidget(pos.value);
const QPointF center = coordinates.worldToWidget(pos.value);
const qreal radiusPx = static_cast<qreal>(sensor.value_tiles)
* static_cast<qreal>(getTilePx());
* static_cast<qreal>(coordinates.getTilePx());
QColor circleColor = it->second.outline;
circleColor.setAlpha(77);
painter.setPen(QPen(circleColor, 1));
@@ -473,7 +447,8 @@ void ArenaView::drawDebugSensorRanges(QPainter& painter)
});
}
void ArenaView::drawDebugTargetLines(QPainter& painter)
void ArenaView::drawDebugTargetLines(QPainter& painter,
const WorldCoordinates& coordinates)
{
// Draw a thin translucent line from a ship to a target, colored by the ship's
// team to match the per-side HQ/station colors used elsewhere in the arena
@@ -491,7 +466,8 @@ void ArenaView::drawDebugTargetLines(QPainter& painter)
QColor lineColor = it->second.fill;
lineColor.setAlpha(128);
painter.setPen(QPen(lineColor, 1));
painter.drawLine(worldToWidget(from), worldToWidget(to));
painter.drawLine(coordinates.worldToWidget(from),
coordinates.worldToWidget(to));
};
m_sim->getAdmin().forEach<ShipIdentityComponent, PositionComponent,
@@ -536,7 +512,7 @@ void ArenaView::drawDebugTargetLines(QPainter& painter)
});
}
void ArenaView::drawBeams(QPainter& painter)
void ArenaView::drawBeams(QPainter& painter, const WorldCoordinates& coordinates)
{
for (const ActiveBeam& beam : m_activeBeams)
{
@@ -552,7 +528,7 @@ void ArenaView::drawBeams(QPainter& painter)
case BeamKind::Salvage: color = m_visuals->beams.salvageColor; break;
}
painter.setPen(QPen(color, m_visuals->beams.widthPx));
painter.drawLine(worldToWidget(*shooterPos),
worldToWidget(*targetPos + beam.targetOffset));
painter.drawLine(coordinates.worldToWidget(*shooterPos),
coordinates.worldToWidget(*targetPos + beam.targetOffset));
}
}

27
src/balancing/ArenaView.h
View File

@@ -17,6 +17,7 @@
#include "Tick.h"
#include "TickDriver.h"
#include "VisualsConfig.h"
#include "WorldCoordinates.h"
class ArenaSimulation;
class QPainter;
@@ -47,22 +48,22 @@ private slots:
private:
void handleEvent(std::shared_ptr<const BeamFiredEvent> event) override;
void drawTiles(QPainter& painter);
void drawBuildings(QPainter& painter);
void drawStations(QPainter& painter);
void drawDebris(QPainter& painter);
void drawShips(QPainter& painter);
void drawDebugSensorRanges(QPainter& painter);
void drawDebugTargetLines(QPainter& painter);
void drawBeams(QPainter& painter);
void drawTiles(QPainter& painter, const WorldCoordinates& coordinates);
void drawBuildings(QPainter& painter, const WorldCoordinates& coordinates);
void drawStations(QPainter& painter, const WorldCoordinates& coordinates);
void drawDebris(QPainter& painter, const WorldCoordinates& coordinates);
void drawShips(QPainter& painter, const WorldCoordinates& coordinates);
void drawDebugSensorRanges(QPainter& painter, const WorldCoordinates& coordinates);
void drawDebugTargetLines(QPainter& painter, const WorldCoordinates& coordinates);
void drawBeams(QPainter& painter, const WorldCoordinates& coordinates);
float getTilePx() const;
QPointF worldToWidget(QVector2D worldPos) const;
QPointF tileToWidget(QPoint tile) const;
QRectF tileRect(QPoint tile) const;
// The world <-> widget transform for the current viewport size. The arena
// shows the whole world at once and never scrolls, so this fits the arena's
// full extent into the widget; like GameWorldView's, it is a per-frame
// snapshot rather than cached state.
WorldCoordinates getCoordinates() const;
std::optional<QVector2D> entityPosition(entt::entity entity) const;
QVector2D widgetToWorld(QPoint widgetPt) const;
struct ActiveBeam
{