void EnemyBug::Update(const orxCLOCK_INFO &_rstInfo)
{
// Always initialize thy variables
orxVECTOR speed = orxVECTOR_0;
// Set rotation, flip, and speed based on the object's
// current direction of movement.
switch (m_direction)
{
orxBOOL flipX, flipY;
case NORTH:
speed.fY = -m_movementSpeed;
SetRotation (270 * orxMATH_KF_DEG_TO_RAD);
SetFlip (false, false);
break;
case SOUTH:
speed.fY = m_movementSpeed;
SetRotation (90 * orxMATH_KF_DEG_TO_RAD);
SetFlip (false, false);
break;
case WEST:
speed.fX = -m_movementSpeed;
SetRotation (0 * orxMATH_KF_DEG_TO_RAD);
SetFlip (true, false);
GetFlip (flipX, flipY);
break;
case EAST:
speed.fX = m_movementSpeed;
SetRotation (0);
SetFlip (false, false);
GetFlip (flipX, flipY);
break;
default:
orxASSERT (false);
}
// Update object's speed of movement
SetSpeed (speed);
// Time since direction change exceeds interval of direction change?
if ((m_timeSinceDirectionChange += _rstInfo.fDT) >= m_directionChangeInterval)
{
// Reset time
m_timeSinceDirectionChange = 0;
// Pick random number between bounds of Direction enum
orxU32 randomNum = orxMath_GetRandomU32 (0, highDirection);
// Update object's direction of movement
m_direction = static_cast<Direction> (randomNum);
}
}
void Label::SetFlip(Flip flip)
{
if (GetFlip() == flip) return;
_flip = flip;
XAGUI::SetRequestRedraw(true);
}
void Label::Render()
{
if (!IsVisible()) return;
XAGUI::GetRenderer()->Render(GetStaticText(), GetAbsX(), GetAbsY(), GetFlip());
Control::Render();
}
std::vector<uint8_t>
CC_point::Serialize() const
{
// how many reference points are we going to write?
uint8_t num_ref_pts = 0;
for (auto j = 1; j <= CC_point::kNumRefPoints; j++)
{
if (GetPos(j) != GetPos(0))
{
++num_ref_pts;
}
}
uint8_t size_of_each_point_data = (num_ref_pts * 5) + 2 + 2 + 1 + 1 + 1;
// Point positions
std::ostringstream stream("");
// Write block size
Write(stream, &size_of_each_point_data, sizeof(size_of_each_point_data));
// Write POSITION
Coord crd;
put_big_word(&crd, GetPos().x);
Write(stream, &crd, 2);
put_big_word(&crd, GetPos().y);
Write(stream, &crd, 2);
// Write REF_POS
Write(stream, &num_ref_pts, 1);
if (num_ref_pts)
{
for (auto j = 1; j <= CC_point::kNumRefPoints; j++)
{
if (GetPos(j) != GetPos(0))
{
uint8_t which = j;
Write(stream, &which, 1);
Coord crd;
put_big_word(&crd, GetPos(j).x);
Write(stream, &crd, 2);
put_big_word(&crd, GetPos(j).y);
Write(stream, &crd, 2);
}
}
}
// Write POSITION
uint8_t tmp = GetSymbol();
Write(stream, &tmp, 1);
// Point labels (left or right)
tmp = (GetFlip()) ? true : false;
Write(stream, &tmp, 1);
auto sdata = stream.str();
std::vector<uint8_t> data;
std::copy(sdata.begin(), sdata.end(), std::back_inserter(data));
return data;
}
void BattleView::InitializeCameraPosition()
{
const std::vector<Unit*>& units = _simulator->GetUnits();
glm::vec2 friendlyCenter;
glm::vec2 enemyCenter;
int friendlyCount = 0;
int enemyCount = 0;
for (Unit* unit : units)
{
if (!unit->state.IsRouting())
{
if (unit->commander == _commander)
{
friendlyCenter += unit->state.center;
++friendlyCount;
}
else
{
enemyCenter += unit->state.center;
++enemyCount;
}
}
}
if (enemyCount == 0)
{
enemyCenter = glm::vec2(512, 512);
enemyCount = 1;
}
if (friendlyCount != 0 && enemyCount != 0)
{
friendlyCenter /= friendlyCount;
enemyCenter /= enemyCount;
glm::vec2 friendlyScreen = ContentToSurface(glm::vec2(0, GetFlip() ? 0.15 : -0.15));
glm::vec2 enemyScreen = ContentToSurface(glm::vec2(0, GetFlip() ? -0.65 : 0.65));
Zoom(glm::vec3(friendlyCenter, 0), glm::vec3(enemyCenter, 0), friendlyScreen, enemyScreen, 0);
ClampCameraPosition();
}
}
void ScrollBar::Render()
{
if (!IsVisible()) return;
XAGUI::GetRenderer()->Render(XAGUI::GetSkin(), GetAbsX(), GetAbsY(), Slider::GetWidth(),
Slider::GetHeight(), GetSrcX(GetState()), GetSrcY(GetState()), GetSrcWidth(), GetSrcHeight(),
GetColorRed(GetState()), GetColorGreen(GetState()), GetColorBlue(GetState()),
GetColorAlpha(GetState()), GetFlip());
Control::Render();
}
void BattleView::Render(const glm::mat4& transformx)
{
glm::mat4 containerTransform = transformx * glm::inverse(GetContentTransform());
glm::mat4 terrainTransform = GetTerrainTransform();
glm::mat4 adjustmentTransform;
adjustmentTransform = glm::scale(adjustmentTransform, glm::vec3(GetSize(), 1));
adjustmentTransform = glm::scale(adjustmentTransform, glm::vec3(0.5f, 0.5f, 1));
adjustmentTransform = glm::translate(adjustmentTransform, glm::vec3(1, 1, 0));
glm::mat4 contentTransform = transformx * adjustmentTransform * terrainTransform;
glm::mat4 facingTransform = transformx * glm::translate(glm::mat4(), glm::vec3(-GetFrame().min, 0));
glm::vec2 facing = vector2_from_angle(GetCameraFacing() - 2.5f * (float)M_PI_4);
_lightNormal = glm::normalize(glm::vec3(facing, -1));
// Terrain Sky
glDisable(GL_DEPTH_TEST);
if (_smoothTerrainSky != nullptr)
{
_smoothTerrainSky->RenderBackgroundLinen(containerTransform, _renderers, GetFrame(), GetFlip());
_smoothTerrainSky->Render(containerTransform, _renderers, GetFrame(), GetCameraDirection().z, GetFlip());
}
// Terrain Surface
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
if (_smoothTerrainSurface != nullptr)
_smoothTerrainSurface->Render(contentTransform, _lightNormal);
if (_tiledTerrainRenderer != nullptr)
_tiledTerrainRenderer->Render(contentTransform, _lightNormal);
// Terrain Water
glDisable(GL_CULL_FACE);
if (_smoothTerrainWater != nullptr)
_smoothTerrainWater->Render(contentTransform);
// Fighter Weapons
glDepthMask(false);
_plainLineRenderer->Reset();
for (UnitCounter* marker : _unitMarkers)
marker->AppendFighterWeapons(_plainLineRenderer);
_plainLineRenderer->Draw(contentTransform, glm::vec4(0.4, 0.4, 0.4, 0.6));
// Color Billboards
_colorBillboardRenderer->Reset();
_casualtyMarker->RenderCasualtyColorBillboards(_colorBillboardRenderer);
_colorBillboardRenderer->Draw(contentTransform, GetCameraUpVector(), GetFrame().height());
// Texture Billboards
_billboardModel->dynamicBillboards.clear();
_casualtyMarker->AppendCasualtyBillboards(_billboardModel);
for (UnitCounter* marker : _unitMarkers)
marker->AppendFighterBillboards(_billboardModel);
for (SmokeCounter* marker : _smokeMarkers)
marker->AppendSmokeBillboards(_billboardModel);
_textureBillboardRenderer->Render(_billboardModel, contentTransform, GetCameraUpVector(), glm::degrees(GetCameraFacing()), GetFrame().height(), GetFlip());
// Range Markers
for (Unit* unit : _simulator->GetUnits())
{
if (unit->commander == _commander)
{
RangeMarker marker(_simulator, unit);
_gradientTriangleStripRenderer->Reset();
marker.Render(_gradientTriangleStripRenderer);
_gradientTriangleStripRenderer->Draw(contentTransform);
}
}
// Unit Facing Markers
glDisable(GL_DEPTH_TEST);
_textureTriangleRenderer->Reset();
for (UnitCounter* marker : _unitMarkers)
if (marker->GetUnit()->commander == _commander)
marker->AppendFacingMarker(_textureTriangleRenderer, this);
for (UnitMovementMarker* marker : _movementMarkers)
if (marker->GetUnit()->commander == _commander)
marker->AppendFacingMarker(_textureTriangleRenderer, this);
for (UnitTrackingMarker* marker : _trackingMarkers)
if (marker->GetUnit()->commander == _commander)
marker->AppendFacingMarker(_textureTriangleRenderer, this);
_textureTriangleRenderer->Draw(facingTransform, _textureUnitMarkers);
// Unit Markers
_textureBillboardRenderer1->Reset();
_textureBillboardRenderer2->Reset();
for (UnitCounter* marker : _unitMarkers)
marker->AppendUnitMarker(_textureBillboardRenderer2, GetFlip());
for (UnitMovementMarker* marker : _movementMarkers)
marker->RenderMovementMarker(_textureBillboardRenderer1);
for (UnitTrackingMarker* marker : _trackingMarkers)
marker->RenderTrackingMarker(_textureBillboardRenderer1);
bounds1f sizeLimit = GetUnitIconSizeLimit();
_textureBillboardRenderer1->Draw(_textureUnitMarkers, contentTransform, GetCameraUpVector(), glm::degrees(GetCameraFacing()), GetFrame().height(), sizeLimit);
_textureBillboardRenderer2->Draw(_textureUnitMarkers, contentTransform, GetCameraUpVector(), glm::degrees(GetCameraFacing()), GetFrame().height(), sizeLimit);
// Tracking Markers
glDisable(GL_DEPTH_TEST);
for (UnitTrackingMarker* marker : _trackingMarkers)
{
_textureBillboardRenderer1->Reset();
marker->RenderTrackingShadow(_textureBillboardRenderer1);
_textureBillboardRenderer1->Draw(_textureTouchMarker, contentTransform, GetCameraUpVector(), glm::degrees(GetCameraFacing()), GetFrame().height(), bounds1f(64, 64));
}
// Movement Paths
glEnable(GL_DEPTH_TEST);
_gradientTriangleRenderer->Reset();
for (UnitMovementMarker* marker : _movementMarkers)
marker->RenderMovementPath(_gradientTriangleRenderer);
_gradientTriangleRenderer->Draw(contentTransform);//, glm::vec4(0.5, 0.5, 1, 0.25));
// Tracking Path
glDisable(GL_DEPTH_TEST);
for (UnitTrackingMarker* marker : _trackingMarkers)
{
_gradientTriangleRenderer->Reset();
marker->RenderTrackingPath(_gradientTriangleRenderer);
marker->RenderOrientation(_gradientTriangleRenderer);
_gradientTriangleRenderer->Draw(contentTransform);
}
// Tracking Fighters
glEnable(GL_DEPTH_TEST);
_colorBillboardRenderer->Reset();
for (UnitTrackingMarker* marker : _trackingMarkers)
marker->RenderTrackingFighters(_colorBillboardRenderer);
_colorBillboardRenderer->Draw(contentTransform, GetCameraUpVector(), GetFrame().height());
// Movement Fighters
_colorBillboardRenderer->Reset();
for (UnitMovementMarker* marker : _movementMarkers)
marker->RenderMovementFighters(_colorBillboardRenderer);
_colorBillboardRenderer->Draw(contentTransform, GetCameraUpVector(), GetFrame().height());
// Shooting Counters
_gradientLineRenderer->Reset();
for (ShootingCounter* shootingCounter : _shootingCounters)
shootingCounter->Render(_gradientLineRenderer);
_gradientLineRenderer->Draw(contentTransform);
// Mouse Hint
_plainLineRenderer->Reset();
RenderMouseHint(_plainLineRenderer);
_plainLineRenderer->Draw(contentTransform, glm::vec4(0, 0, 0, 0.5f));
glDepthMask(true);
glDisable(GL_DEPTH_TEST);
}
