---

BattleGroup Class Reference

#include <BattleGroup.h>

Collaboration diagram for BattleGroup:

[legend]List of all members.

---

Detailed Description

defines a BattleGroup (1..N units of the same type, moving and acting as a single entity) for the BattleMode.

Definition at line 39 of file BattleGroup.h.

Public Methods
	BattleGroup (Vec3D pos, Vec3D dir, char team, Vec3D color, int unitType, int numUnits, int overheadForceNumber)
void	addWaypoint (const Vec3D pt)
void	moveBattleGroup ()
	move the entire BG entity to its destination (if any)
void	moveUnits ()
	move the individual units in this BG to its appropriate pos in the BG
void	acquireGroupTargets ()
	check all hostile BGs, add them to m_targetGroups if is within range
void	fire ()
	tell the individual units to fire at target if they can
void	fireAntiAir ()
	for launchers. check if there's any enemy jets nearby. if yes, try to shoot it down
void	takeHit (const BattleBullet &b)
	checks each unit in BG if it's hit by the bullet. apply damage accordingly
void	destroyUnit (BattleUnit &u)
	creates explosion, debris etc
bool	isContain2DPoint (Vec2D pt)
void	drawOutlineBox (Vec3D c)
void	render ()
Public Attributes
BattleState *	BS
char	m_team
Vec3D	m_pos
Vec3D	m_size
Vec3D	m_dir
Vec3D	m_color
int	m_unitType
int	m_unitArraySize
int	m_numUnits
FLOAT	m_maxUnitDist
vector< Vec3D >	m_waypoints
vector< int >	m_targetGroups
BattleUnit	m_units [MAX_UNIT]
FLOAT	m_statFiringRange
int	m_primaryTarget
bool	m_isChasePrimaryTarget
bool	m_isStrictPrimaryTarget
int	m_overheadForceNumber

---

Constructor & Destructor Documentation

BattleGroup::BattleGroup (  Vec3D    pos, Vec3D    dir, char    team, Vec3D    color, int    unitType, int    numUnits, int    overheadForceNumber )

Definition at line 78 of file BattleGroup.cpp. References BattleUnitData::armor(), BattleUnitData::firingRange(), Singleton< BattleUnitData >::getObj(), m_color, BattleUnit::m_dir, m_dir, BattleUnit::m_firingDelay, BattleUnit::m_health, m_isChasePrimaryTarget, m_isStrictPrimaryTarget, m_numUnits, m_overheadForceNumber, BattleUnit::m_pos, m_pos, m_primaryTarget, BattleUnit::m_recvHitIndex, m_size, m_statFiringRange, BattleUnit::m_target, m_team, BattleUnit::m_turretDir, m_unitArraySize, m_units, m_unitType, math_translateObjectToWorld(), BattleUnitData::numCols(), BattleUnitData::numRows(), BattleUnitData::tightFormationSize(), and Vec3D. { assert(unitType>=0 && unitType<UnitTypes::COUNT ); m_team = team; m_pos = pos; m_size = BattleUnitData::getObj().tightFormationSize()[unitType]; m_dir = dir; m_color = color; m_unitType = unitType; m_unitArraySize = numUnits; m_numUnits = numUnits; m_overheadForceNumber = overheadForceNumber; Vec3D halfSize = m_size * 0.5f; int rows = BattleUnitData::getObj().numRows()[m_unitType]; int cols = BattleUnitData::getObj().numCols()[m_unitType]; FLOAT backDelta = m_size.x / rows; FLOAT rightDelta = m_size.y / cols; Vec3D frontLeftPt = math_translateObjectToWorld( m_pos, m_dir, Vec3D( halfSize.x,halfSize.y,0.0f) ); Vec3D backVec = math_translateObjectToWorld( m_pos, m_dir, Vec3D( halfSize.x-backDelta,halfSize.y,0.0f) ) - frontLeftPt; Vec3D rightVec = math_translateObjectToWorld( m_pos, m_dir, Vec3D( halfSize.x,halfSize.y-rightDelta,0.0f) ) - frontLeftPt; for( int i=0; i<m_unitArraySize; i++ ) { FLOAT col = (FLOAT)(i%cols) + 0.5f; FLOAT row = (FLOAT)(i/cols) + 0.5f; m_units[i].m_pos = frontLeftPt + backVec*row + rightVec*col; m_units[i].m_dir = m_dir; m_units[i].m_turretDir = Vec3D(0,0,0); m_units[i].m_target = m_units[i].m_pos; m_units[i].m_firingDelay = 0; m_units[i].m_health = BattleUnitData::getObj().armor()[m_unitType]; m_units[i].m_recvHitIndex = 0; } m_statFiringRange = BattleUnitData::getObj().firingRange()[m_unitType]; m_primaryTarget = -1; m_isStrictPrimaryTarget = false; m_isChasePrimaryTarget = false; }

---

Member Function Documentation

void BattleGroup::acquireGroupTargets (    )

check all hostile BGs, add them to m_targetGroups if is within range Definition at line 259 of file BattleGroup.cpp. References absf, BS, clipAngle(), BattleUnitData::firingArc(), Singleton< BattleUnitData >::getObj(), BattleState::groups, m_dir, m_isChasePrimaryTarget, m_isStrictPrimaryTarget, m_numUnits, m_pos, m_primaryTarget, m_statFiringRange, m_targetGroups, m_team, m_unitType, math_dist3D(), math_distPlanar3D(), UINT, and Vec3D. { if(m_numUnits==0) return; m_targetGroups.resize(0); for( UINT i=0; i<BS->groups.size(); i++ ) if( m_team!=BS->groups[i].m_team && BS->groups[i].m_numUnits > 0) // check if of different team if( BS->groups[i].m_numUnits > 0 ) { FLOAT dist = math_dist3D( m_pos, BS->groups[i].m_pos ); if( dist < m_statFiringRange*1.3f ) // check if near firing range { Vec3D dirVec = BS->groups[i].m_pos - m_pos; FLOAT angle = clipAngle( 90-D3DXToDegree( atan2f( dirVec.x, dirVec.y ) ) ); FLOAT delta; if(angle>m_dir.x) { delta = angle - m_dir.x; if(delta>180.0f) delta = delta - 360.0f; } else { delta = angle - m_dir.x; if(delta<-180.0f) delta = 360.0f - delta; } if( absf(delta) < BattleUnitData::getObj().firingArc()[m_unitType] ) // check if in firing arc m_targetGroups.push_back(i); } } if( (m_primaryTarget==-1 && m_targetGroups.size()>0) // if have no primary target, pick one randomly || !m_isStrictPrimaryTarget ) { FLOAT minDist = 999999.0f; int bestIndex = 0; for( int i=0; i<(int)m_targetGroups.size(); i++ ) { int targetIndex = m_targetGroups[i]; FLOAT dist = math_distPlanar3D( m_pos, BS->groups[targetIndex].m_pos ); if( dist < minDist ) { bestIndex = targetIndex; minDist = dist; } } m_isChasePrimaryTarget = false; m_isStrictPrimaryTarget = false; m_primaryTarget = bestIndex; } if( m_targetGroups.size()==0 && !m_isStrictPrimaryTarget ) m_primaryTarget = -1; }

void BattleGroup::addWaypoint (  const Vec3D    pt )

Definition at line 119 of file BattleGroup.cpp. References m_waypoints. { if(m_waypoints.size()<12 ) m_waypoints.push_back(pt); }

void BattleGroup::destroyUnit (  BattleUnit &    u )

creates explosion, debris etc Definition at line 313 of file BattleGroup.cpp. References GameState::activeBattle(), BS, camera_addVibration(), Globals::currGameTick, BattleState::debris, BattleEntry::getBSPtr(), Sound::getMasterSFXVol(), m_color, m_numUnits, BattleUnit::m_pos, Sound::play(), playVoicePanick(), playVoiceStress(), BattleState::sprites, BattleState::synch_firstKillTick, sys_console(), sys_randFloat(), sys_randInt(), BattleState::teamAColor, BattleState::teamBColor, BattleState::terrain, terrain_getHeight(), and Vec3D. Referenced by fire(), and takeHit(). { if( BS->synch_firstKillTick == -1 ) { BS->synch_firstKillTick = currGameTick; sys_console() << "BATTLE First Kill at tick = " << currGameTick << endl; } sys_console() << "BATTLE Boom pos=" << u.m_pos.x << ' ' << u.m_pos.y << ' ' << u.m_pos.z << endl; bool isActive = false; // if this battle is active (player's watching it) if( GameState::activeBattle() ) if( GameState::activeBattle()->getBSPtr() == BS ) isActive = true; float vol = Sound::getMasterSFXVol(); if( !isActive ) vol *= 0.92f; Vec3D playerCol( GameState::consolePlayer()->color() ); if( BS->teamAColor!=playerCol && BS->teamBColor!=playerCol ) vol = 0.0f; // conditional voice Vec3D playerColor( GameState::consolePlayer()->color() ); if( m_numUnits < 10 && m_color==playerColor ) playVoicePanick(*BS,isActive); if( m_numUnits < 20 && m_color==playerColor ) playVoiceStress(*BS,isActive); Vec3D pos = u.m_pos; pos.z += terrain_getHeight(BS->terrain, pos.x, pos.y ); BS->sprites.push_back( BattleSprite( pos, 45, BattleSpriteTypes::EXPLO_LARGE )); BS->sprites.push_back( BattleSprite( pos, 75, BattleSpriteTypes::SMOKE_LARGE )); int numParticles = 2 + sys_randInt()%4; int numSmokes = 2 + sys_randInt()%3; for( int i=0; i<numParticles; i++ ) { Vec3D pos2 = pos + Vec3D( 4*sys_randFloat(), 4*sys_randFloat(), sys_randFloat() ); BS->sprites.push_back( BattleSprite( pos2, 20, BattleSpriteTypes::EXPLO_SMALL )); } for( int i=0; i<numSmokes; i++ ) { Vec3D pos2 = pos + Vec3D( 6*sys_randFloat(), 6*sys_randFloat(), 2*sys_randFloat() ); BS->sprites.push_back( BattleSprite( pos2, 65, BattleSpriteTypes::SMOKE_SMALL )); } // debris int debrisType = sys_randInt()%2; Vec3D speed = Vec3D( 0.3f*sys_randFloat(), 0.3f*sys_randFloat(), 0.16f*(sys_randFloat()+1.0f) ); FLOAT dirSpeed = 3.5f; BS->debris.push_back( BattleDebris(pos,speed,dirSpeed,debrisType) ); // vibration if( GameState::activeBattle() ) if( GameState::activeBattle()->getBSPtr() == BS ) // we're participating in this battle camera_addVibration(5.0f); // sound effect Sound::play(Sound::SMPL_SFX_EXPLOSION_LARGE,vol); }

void BattleGroup::drawOutlineBox (  Vec3D    c )

Definition at line 587 of file BattleGroup.cpp. References BS, m_numUnits, m_size, math_translateObjectToWorld(), math_translateWorldToScreen(), overlay_line(), BattleState::terrain, terrain_getHeight(), Vec2D, and Vec3D. Referenced by BattleEntry::renderGroups(), and BattleEntry::renderInterface(). { if(m_numUnits==0) return; // calc the 4 corner pts of the box Vec3D halfSize = m_size * 0.5f; Vec3D pt3D1 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( -halfSize.x, -halfSize.y,0.0f) ); Vec3D pt3D2 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( +halfSize.x, -halfSize.y,0.0f) ); Vec3D pt3D3 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( +halfSize.x, +halfSize.y,0.0f) ); Vec3D pt3D4 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( -halfSize.x, +halfSize.y,0.0f) ); pt3D1.z += terrain_getHeight( BS->terrain, pt3D1.x, pt3D1.y ); pt3D2.z += terrain_getHeight( BS->terrain, pt3D2.x, pt3D2.y ); pt3D3.z += terrain_getHeight( BS->terrain, pt3D3.x, pt3D3.y ); pt3D4.z += terrain_getHeight( BS->terrain, pt3D4.x, pt3D4.y ); Vec2D pt2D1 = math_translateWorldToScreen(pt3D1); Vec2D pt2D2 = math_translateWorldToScreen(pt3D2); Vec2D pt2D3 = math_translateWorldToScreen(pt3D3); Vec2D pt2D4 = math_translateWorldToScreen(pt3D4); overlay_line(pt2D1, pt2D2, c ); overlay_line(pt2D2, pt2D3, c ); overlay_line(pt2D3, pt2D4, c ); overlay_line(pt2D4, pt2D1, c ); }

void BattleGroup::fire (    )

tell the individual units to fire at target if they can Definition at line 389 of file BattleGroup.cpp. References GameState::activeBattle(), BattleState::addBullet(), BattleUnitData::baseDamage(), BS, Player::color(), GameState::consolePlayer(), Globals::currGameTick, destroyUnit(), BattleUnitData::firingArc(), BattleUnitData::firingDelay(), BattleEntry::getBSPtr(), Sound::getMasterSFXVol(), Singleton< BattleUnitData >::getObj(), BattleState::groups, m_color, BattleUnit::m_dir, BattleUnit::m_firingDelay, BattleUnit::m_health, m_numUnits, BattleUnit::m_pos, m_primaryTarget, BattleUnit::m_recvHitIndex, BattleUnit::m_recvHits, m_statFiringRange, m_targetGroups, BattleUnit::m_turretDir, m_unitArraySize, m_units, m_unitType, math_deltaDir(), math_distPlanar3D(), math_getDir(), MAX_RECV_HIT, Sound::play(), playVoiceContact(), BattleState::synch_firstShotTick, sys_console(), sys_randInt(), BattleState::teamAColor, BattleState::teamBColor, BattleState::terrain, terrain_getHeight(), and Vec3D. { if(m_numUnits==0) return; //if(m_unitType==UnitTypes::LAUNCHER) fireAntiAir(); // launchers fire at jets if( m_primaryTarget==-1 ) return; if( BS->groups[m_primaryTarget].m_numUnits == 0 ) // need new target { m_primaryTarget = -1; return; } if(m_targetGroups.size()==0) return; BattleGroup &targetGroup = BS->groups[m_primaryTarget]; if( targetGroup.m_numUnits <= 0 ) return; bool isActive = false; // if this battle is active (player's watching it) if( GameState::activeBattle() ) if( GameState::activeBattle()->getBSPtr() == BS ) isActive = true; float vol = Sound::getMasterSFXVol(); if( !isActive ) vol *= 0.92f; Vec3D playerCol( GameState::consolePlayer()->color() ); if( BS->teamAColor!=playerCol && BS->teamBColor!=playerCol ) vol = 0.0f; const bool hasTurretArray[5] = { true, true, false, true, false }; bool hasTurret = hasTurretArray[ m_unitType]; FLOAT firingArc = BattleUnitData::getObj().firingArc()[m_unitType]; for( int i=0; i<m_unitArraySize; i++ ) { BattleUnit &b = m_units[i]; if( b.m_health<=0 ) continue; if( b.m_firingDelay>0 ) continue; if( sys_randInt()%10 < 9 ) continue; // add randomness so that not everyone fires at the same time int targetNum = sys_randInt() % targetGroup.m_unitArraySize; int attempt = 12; while( targetGroup.m_units[targetNum].m_health <= 0 && attempt-->0 ) targetNum = (targetNum+1) % targetGroup.m_unitArraySize; if( attempt <= 0 ) continue; // can't find a non-dead target BattleUnit &target = targetGroup.m_units[targetNum]; FLOAT targetDir = math_getDir( b.m_pos, target.m_pos ); // check if in firing arc + rotate turret FLOAT turretDir = b.m_dir.x + b.m_turretDir.x; FLOAT deltaDir = math_deltaDir( turretDir, targetDir ); if( hasTurret ) { const FLOAT turretArc = 5.0f; const FLOAT turretTurnRate = 3.0f; if( deltaDir < -turretArc || deltaDir > turretArc ) // rotate turret { deltaDir = min(deltaDir,turretTurnRate); deltaDir = max(deltaDir,-turretTurnRate); b.m_turretDir.x += deltaDir; b.m_turretDir.x = min( b.m_turretDir.x, firingArc ); b.m_turretDir.x = max( b.m_turretDir.x, -firingArc ); continue; } } else { if( deltaDir < -firingArc || deltaDir > firingArc ) continue; // out of firing arc } if( math_distPlanar3D(b.m_pos, target.m_pos) > m_statFiringRange ) continue; // only fire if in range if( m_color == GameState::consolePlayer()->color() ) playVoiceContact(*BS,isActive); if( BS->synch_firstShotTick == -1 ) { BS->synch_firstShotTick = currGameTick; sys_console() << "BATTLE First Shot Fired at tick = " << currGameTick << endl; } //sys_console() << "BATTLE Firing pos=" << b.m_pos.x << ' ' << b.m_pos.y << ' ' << b.m_pos.z // << " turret = " << b.m_turretDir.x << endl; Vec3D bulletPos = b.m_pos; bulletPos.z += terrain_getHeight( BS->terrain, b.m_pos.x, b.m_pos.y ); Vec3D targetPos = target.m_pos; targetPos.z += terrain_getHeight( BS->terrain, target.m_pos.x, target.m_pos.y ); switch(m_unitType) { case UnitTypes::LIGHT_TANK : { target.m_health -= BattleUnitData::getObj().baseDamage()[m_unitType]; target.m_recvHits[ target.m_recvHitIndex ] = RecvHitEntry( b.m_pos, BattleUnitData::getObj().lightTankHitFlareTime() ); target.m_recvHitIndex = (target.m_recvHitIndex+1) % MAX_RECV_HIT; if( target.m_health<=0 ) { destroyUnit(target); targetGroup.m_numUnits--; } b.m_firingDelay = BattleUnitData::getObj().firingDelay()[ m_unitType ]; Sound::play(Sound::SMPL_SFX_FIRE_LIGHTTANK,vol); } break; case UnitTypes::HEAVY_TANK : { target.m_health -= BattleUnitData::getObj().baseDamage()[m_unitType]; target.m_recvHits[ target.m_recvHitIndex ] = RecvHitEntry( b.m_pos, BattleUnitData::getObj().lightTankHitFlareTime() ); target.m_recvHitIndex = (target.m_recvHitIndex+1) % MAX_RECV_HIT; if( target.m_health<=0 ) { destroyUnit(target); targetGroup.m_numUnits--; } b.m_firingDelay = BattleUnitData::getObj().firingDelay()[ m_unitType ]; Sound::play(Sound::SMPL_SFX_FIRE_LIGHTTANK,vol); } break; case UnitTypes::LAUNCHER : { BS->addBullet( BattleBullet( BulletTypes::ROCKET, m_team, m_primaryTarget, bulletPos, targetPos )); b.m_firingDelay = BattleUnitData::getObj().firingDelay()[ m_unitType ]; Sound::play(Sound::SMPL_SFX_FIRE_LAUNCHER,vol); } break; case UnitTypes::ARTILLERY : { BS->addBullet( BattleBullet( BulletTypes::SHELL, m_team, m_primaryTarget, bulletPos, targetPos )); b.m_firingDelay = BattleUnitData::getObj().firingDelay()[ m_unitType ]; Sound::play(Sound::SMPL_SFX_FIRE_ARTILLERY,vol); } break; case UnitTypes::JET : break; } } }

void BattleGroup::fireAntiAir (    )

for launchers. check if there's any enemy jets nearby. if yes, try to shoot it down Definition at line 367 of file BattleGroup.cpp. References BattleState::addBullet(), BS, BattleUnitData::firingDelay(), Singleton< BattleUnitData >::getObj(), BattleState::jets, BattleUnit::m_firingDelay, BattleUnit::m_health, BattleUnit::m_pos, BattleJets::m_pos, m_unitArraySize, m_units, math_distPlanar3D(), sys_randInt(), BattleState::terrain, terrain_getHeight(), UINT, and Vec3D. { for( UINT i=0; i<BS->jets.size(); i++ ) { BattleJets &J = BS->jets[i]; if( math_distPlanar3D( m_pos, J.m_pos) < 100.0f ) { for( int i=0; i<m_unitArraySize; i++ ) { BattleUnit &b = m_units[i]; if( b.m_health<=0 ) continue; if( b.m_firingDelay>0 ) continue; if( sys_randInt()%10 < 9 ) continue; Vec3D bulletPos = b.m_pos; bulletPos.z += terrain_getHeight( BS->terrain, b.m_pos.x, b.m_pos.y ); BS->addBullet( BattleBullet( BulletTypes::ANTIAIR, m_team, i, bulletPos, J.m_pos )); b.m_firingDelay = BattleUnitData::getObj().firingDelay()[ UnitTypes::LAUNCHER ]; } } } }

bool BattleGroup::isContain2DPoint (  Vec2D    pt )

Definition at line 557 of file BattleGroup.cpp. References BS, m_numUnits, m_size, math_translateObjectToWorld(), math_translateWorldToScreen(), BattleState::terrain, terrain_getHeight(), triArea(), Vec2D, and Vec3D. { if(m_numUnits==0) return false; // calc the 4 corner pts of the box Vec3D halfSize = m_size * 0.5f; Vec3D pt3D1 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( -halfSize.x, -halfSize.y,0.0f) ); Vec3D pt3D2 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( +halfSize.x, -halfSize.y,0.0f) ); Vec3D pt3D3 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( +halfSize.x, +halfSize.y,0.0f) ); Vec3D pt3D4 = math_translateObjectToWorld( m_pos, m_dir, Vec3D( -halfSize.x, +halfSize.y,0.0f) ); pt3D1.z += terrain_getHeight( BS->terrain, pt3D1.x, pt3D1.y ); pt3D2.z += terrain_getHeight( BS->terrain, pt3D2.x, pt3D2.y ); pt3D3.z += terrain_getHeight( BS->terrain, pt3D3.x, pt3D3.y ); pt3D4.z += terrain_getHeight( BS->terrain, pt3D4.x, pt3D4.y ); Vec2D pt2D1 = math_translateWorldToScreen(pt3D1); Vec2D pt2D2 = math_translateWorldToScreen(pt3D2); Vec2D pt2D3 = math_translateWorldToScreen(pt3D3); Vec2D pt2D4 = math_translateWorldToScreen(pt3D4); int outsideCount = 0; if( pt2D1.x<0 || pt2D1.x>1 || pt2D1.y<0 || pt2D1.y>1 ) outsideCount++; if( pt2D2.x<0 || pt2D2.x>1 || pt2D2.y<0 || pt2D2.y>1 ) outsideCount++; if( pt2D3.x<0 || pt2D3.x>1 || pt2D3.y<0 || pt2D3.y>1 ) outsideCount++; if( pt2D4.x<0 || pt2D4.x>1 || pt2D4.y<0 || pt2D4.y>1 ) outsideCount++; if(outsideCount==4) return false; FLOAT triAreas = triArea(pt2D1,pt2D2,pt) + triArea(pt2D2,pt2D3,pt) + triArea(pt2D3,pt2D4,pt) + triArea(pt2D4,pt2D1,pt); FLOAT rectArea = triArea(pt2D1,pt2D2,pt2D3) + triArea(pt2D3,pt2D4,pt2D1); return triAreas <= rectArea * 1.05f; }

void BattleGroup::moveBattleGroup (    )

move the entire BG entity to its destination (if any) Definition at line 124 of file BattleGroup.cpp. References absf, BattleUnitData::BGFullSpeed(), BattleUnitData::BGHalfSpeed(), BattleUnitData::BGTurnRate(), BS, clipAngle(), Singleton< BattleUnitData >::getObj(), BattleState::groups, m_dir, m_isChasePrimaryTarget, m_maxUnitDist, m_numUnits, m_pos, m_primaryTarget, m_unitType, m_waypoints, math_dist3D(), and Vec3D. { // TEMP DEBUG INFO //sys_console() << "BG " << m_pos.x << ' ' << m_pos.y << ' ' << terrain_getHeight(BS->terrain,m_pos.x,m_pos.y) // << ' ' << m_dir.x << endl; if(m_numUnits==0) return; if( m_primaryTarget!=-1 && m_isChasePrimaryTarget ) // home in on primary target { Vec3D pt( BS->groups[ m_primaryTarget ].m_pos ); m_waypoints.resize(0); m_waypoints.push_back(pt); } if( m_waypoints.size() == 0 ) return; Vec3D targetVec = m_waypoints[0] - m_pos; FLOAT targetDir = clipAngle( 90-D3DXToDegree( atan2f( targetVec.x, targetVec.y ) ) ); FLOAT currentDir = m_dir[0]; FLOAT delta; // signed (+CW,-CCW) smallest-magnitude difference in angle if( targetDir<0.0f ) targetDir += 360.0f; else if( targetDir>=360.0f ) targetDir -= 360.0f; if(targetDir>currentDir) { delta = targetDir - currentDir; if(delta>180.0f) delta = delta - 360.0f; } else { delta = targetDir - currentDir; if(delta<-180.0f) delta = 360.0f - delta; } const FLOAT turnRate = BattleUnitData::getObj().BGTurnRate()[m_unitType]; FLOAT turnAngle = delta; if( delta > turnRate ) turnAngle = turnRate; else if( delta < -turnRate ) turnAngle = -turnRate; else turnAngle = delta; m_dir[0] = clipAngle( currentDir + turnAngle ); // turn // move if we're heading roughly the right way FLOAT speed = 0.0f; if( absf(delta)<10.0f ) speed = BattleUnitData::getObj().BGFullSpeed()[m_unitType]; else if( absf(delta)<30.0f ) speed = BattleUnitData::getObj().BGHalfSpeed()[m_unitType]; if( m_maxUnitDist > 4.0f ) speed = speed * 0.25f; // slow down if units are out of formation if(speed>0.0f) { FLOAT rad = D3DXToRadian( m_dir[0] ); m_pos += speed * Vec3D( cosf(rad), sinf(rad), 0.0f ); // delete waypoint once we reach it if( math_dist3D(m_pos,m_waypoints[0]) < 1.0f ) m_waypoints.erase( m_waypoints.begin() ); } }

void BattleGroup::moveUnits (    )

move the individual units in this BG to its appropriate pos in the BG Definition at line 184 of file BattleGroup.cpp. References absf, clipAngle(), BattleUnitData::fullSpeed(), Singleton< BattleUnitData >::getObj(), BattleUnitData::halfSpeed(), m_dir, BattleUnit::m_dir, BattleUnit::m_firingDelay, BattleUnit::m_health, m_maxUnitDist, m_numUnits, BattleUnit::m_pos, BattleUnit::m_recvHits, m_size, BattleUnit::m_target, m_unitArraySize, m_units, m_unitType, math_dist3D(), math_translateObjectToWorld(), MAX_RECV_HIT, BattleUnitData::numCols(), BattleUnitData::numRows(), RecvHitEntry::timeRemaining, BattleUnitData::turnRate(), and Vec3D. { if(m_numUnits==0) return; // update each unit's target Vec3D halfSize = m_size * 0.5f; int rows = BattleUnitData::getObj().numRows()[m_unitType]; int cols = BattleUnitData::getObj().numCols()[m_unitType]; FLOAT backDelta = m_size.x / rows; FLOAT rightDelta = m_size.y / cols; Vec3D frontLeftPt = math_translateObjectToWorld( m_pos, m_dir, Vec3D( halfSize.x,halfSize.y,0.0f) ); Vec3D backVec = math_translateObjectToWorld( m_pos, m_dir, Vec3D( halfSize.x-backDelta,halfSize.y,0.0f) ) - frontLeftPt; Vec3D rightVec = math_translateObjectToWorld( m_pos, m_dir, Vec3D( halfSize.x,halfSize.y-rightDelta,0.0f) ) - frontLeftPt; for( int i=0; i<m_unitArraySize; i++ ) { FLOAT col = (FLOAT)(i%cols) + 0.5f; FLOAT row = (FLOAT)(i/cols) + 0.5f; m_units[i].m_target = frontLeftPt + backVec*row + rightVec*col; } m_maxUnitDist = 0.0f; for( int i=0; i<m_unitArraySize; i++ ) { BattleUnit &u = m_units[i]; if( u.m_health<=0 ) continue; // dec firing delay u.m_firingDelay--; // dec hit flare time for( int i=0; i<MAX_RECV_HIT; i++ ) u.m_recvHits[i].timeRemaining--; FLOAT dist = math_dist3D(u.m_pos, u.m_target); if( dist > m_maxUnitDist ) m_maxUnitDist = dist; if( dist > 0.1f ) { Vec3D targetVec = u.m_target - u.m_pos; FLOAT targetDir = clipAngle( 90-D3DXToDegree( atan2f(targetVec.x,targetVec.y) )); FLOAT currentDir = u.m_dir[0]; FLOAT delta; if(targetDir>currentDir) { delta = targetDir - currentDir; if(delta>180.0f) delta = delta - 360.0f; } else { delta = targetDir - currentDir; if(delta<-180.0f) delta = 360.0f - delta; } const FLOAT turnRate = BattleUnitData::getObj().turnRate()[m_unitType]; FLOAT turnAngle = delta; if( delta > turnRate ) turnAngle = turnRate; else if( delta < -turnRate ) turnAngle = -turnRate; else turnAngle = delta; u.m_dir[0] = clipAngle( currentDir + turnAngle ); // turn // move if we're heading roughly the right way FLOAT speed = 0.0f; if( absf(delta)<10.0f ) speed = BattleUnitData::getObj().fullSpeed()[m_unitType]; else if( absf(delta)<30.0f ) speed = BattleUnitData::getObj().halfSpeed()[m_unitType]; if(speed>0.0f) { FLOAT rad = D3DXToRadian( u.m_dir[0] ); u.m_pos += speed * Vec3D( cosf(rad), sinf(rad), 0.0f ); } } else // we're already close enough to target { u.m_dir = u.m_dir*0.99f + m_dir*0.01f; } } }

void BattleGroup::render (    )

Definition at line 610 of file BattleGroup.cpp. References AMesh, BattleUnitData::artillerySize(), BattleUnitData::artilleryTurretSize(), Globals::artWork, ATexture, BS, camera_getVec(), BattleUnitData::firingDelay(), flare_addParticle(), RecvHitEntry::from, Singleton< BattleUnitData >::getObj(), BattleState::groups, BattleUnitData::heavyTankSize(), BattleUnitData::heavyTankTurretSize(), BattleUnitData::jetSize(), BattleUnitData::launcherSize(), BattleUnitData::lightTankSize(), BattleUnitData::lightTankTurretSize(), BattleUnit::m_dir, BattleUnit::m_firingDelay, BattleUnit::m_health, m_numUnits, m_pos, BattleUnit::m_pos, m_primaryTarget, BattleUnit::m_recvHits, BattleUnit::m_turretDir, m_unitArraySize, m_units, m_unitType, m_waypoints, math_translateWorldToScreen(), MAX_RECV_HIT, mesh_render(), overlay_line(), overlay_point(), sprite_add(), BattleState::terrain, terrain_getHeight(), RecvHitEntry::timeRemaining, UINT, Vec2D, Vec3D, and Vec4D. { if( m_numUnits<=0 ) return; AMesh chasis=-1, turret=-1; ATexture texture=-1; Vec3D chasisSize, turretSize; Vec3D shadowVec = camera_getVec(); // offset for shadow position FLOAT shadowSize; shadowVec.z = 0.0f; switch(m_unitType) { case UnitTypes::LIGHT_TANK : chasis = artWork->lightTank_mesh; turret = artWork->lightTankTurret_mesh; texture = artWork->lightTank_texture; chasisSize = BattleUnitData::getObj().lightTankSize(); turretSize = BattleUnitData::getObj().lightTankTurretSize(); shadowSize = 6.0f; break; case UnitTypes::HEAVY_TANK : chasis = artWork->heavyTank_mesh; turret = artWork->heavyTankTurret_mesh; texture = artWork->heavyTank_texture; chasisSize = BattleUnitData::getObj().heavyTankSize(); turretSize = BattleUnitData::getObj().heavyTankTurretSize(); shadowSize = 7.0f; break; case UnitTypes::LAUNCHER : chasis = artWork->launcher_mesh; texture = artWork->launcher_texture; chasisSize = BattleUnitData::getObj().launcherSize(); shadowSize = 6.0f; break; case UnitTypes::ARTILLERY : chasis = artWork->artillery_mesh; turret = artWork->artilleryTurret_mesh; texture = artWork->artillery_texture; chasisSize = BattleUnitData::getObj().artillerySize(); turretSize = BattleUnitData::getObj().artilleryTurretSize(); shadowSize = 6.0f; break; case UnitTypes::JET : chasis = artWork->jet_mesh; texture = artWork->jet_texture; chasisSize = BattleUnitData::getObj().jetSize(); shadowSize = 6.0f; break; } for( int i=0; i<m_unitArraySize; i++ ) { BattleUnit &u = m_units[i]; if( u.m_health<=0 ) continue; Vec3D pos = u.m_pos; pos.z += 0.32f + terrain_getHeight(BS->terrain,pos.x, pos.y); // chasis & (optional) turret mesh_render( chasis, pos, chasisSize, u.m_dir, texture, NULL, m_color ); if(turret!=-1) mesh_render( turret, pos, turretSize, u.m_dir+u.m_turretDir, texture, NULL, m_color ); // unit shadow const Vec4D mult(1,1,1,0.33f); sprite_add(artWork->shadow, BlendModes::MIX, pos+shadowVec, mult, shadowSize ); // firing flare const Vec4D noBlend(1.0f,1.0f,1.0f,1.0f); int fireDelay = BattleUnitData::getObj().firingDelay()[ m_unitType]; if( (m_unitType==UnitTypes::LIGHT_TANK && u.m_firingDelay > fireDelay-5) || (m_unitType==UnitTypes::HEAVY_TANK && u.m_firingDelay > fireDelay-5) ) { FLOAT rad = D3DXToRadian( u.m_dir[0] ); Vec3D target = pos + Vec3D( cosf(rad), sinf(rad), 0.5f ); flare_addParticle( pos, target, noBlend, 3.0f, 0.3f*(fireDelay-u.m_firingDelay) ); flare_addParticle( pos, target, noBlend, 5.0f, 0.5f*(fireDelay-u.m_firingDelay) ); } // hit flare for( int i=0; i<MAX_RECV_HIT; i++ ) { static Vec4D mult(1,1,1,1); RecvHitEntry &e = u.m_recvHits[i]; mult.w = (20.0f-e.timeRemaining) / 32.0f; if( e.timeRemaining > 0 ) flare_addParticle( pos, e.from, mult, 2.0f, 6.0f ); } } // battle group icon //mesh_render( artWork->battleGroupMesh, m_pos - Vec3D(0.0f,0.0f,0.6f), m_size,m_dir, artWork->battleGroupTexture ); Vec3D prevPt = m_pos; // waypoints for( UINT i=0; i<m_waypoints.size(); i++ ) { Vec3D pt13D(prevPt), pt23D(m_waypoints[i]), pt33D(m_waypoints[i]); pt13D.z += terrain_getHeight(BS->terrain, pt13D.x, pt13D.y ); pt23D.z += terrain_getHeight(BS->terrain, pt23D.x, pt23D.y ); Vec2D pt1 = math_translateWorldToScreen( pt13D ); Vec2D pt2 = math_translateWorldToScreen( pt23D ); Vec2D pt3 = math_translateWorldToScreen( pt33D ); overlay_line( pt1, pt2, Colors::green ); overlay_line( pt2, pt3, Colors::gray ); overlay_point( pt2, 2.0f, Colors::red ); prevPt = m_waypoints[i]; } // primary target if( m_primaryTarget!=-1 ) { Vec3D pt13D( m_pos ); pt13D.z += terrain_getHeight(BS->terrain, pt13D.x, pt13D.y ); Vec2D pt1 = math_translateWorldToScreen( pt13D ); Vec3D pt23D( BS->groups[ m_primaryTarget ].m_pos ); pt23D.z += terrain_getHeight(BS->terrain, pt23D.x, pt23D.y ); Vec2D pt2 = math_translateWorldToScreen( pt23D ); overlay_line( pt1, pt2, Colors::red ); } }

void BattleGroup::takeHit (  const BattleBullet &    b )

checks each unit in BG if it's hit by the bullet. apply damage accordingly Definition at line 527 of file BattleGroup.cpp. References BS, destroyUnit(), BattleUnit::m_health, m_numUnits, BattleUnit::m_pos, BattleBullet::m_pos, BattleUnit::m_recvHitIndex, BattleUnit::m_recvHits, BattleBullet::m_type, m_unitArraySize, m_units, MAX_RECV_HIT, BattleState::sprites, and Vec3D. { if(b.m_type==BulletTypes::SHELL) BS->sprites.push_back( BattleSprite( b.m_pos, 15, BattleSpriteTypes::ARTIL_SHELL )); if(m_numUnits==0) return; for( int i=0; i<m_unitArraySize; i++ ) { BattleUnit &u = m_units[i]; if( u.m_health<=0 ) continue; Vec3D delta = u.m_pos - b.m_pos; FLOAT dist = sqrtf( delta.x*delta.x + delta.y*delta.y ); if( dist<8.0f ) { u.m_health -= 50000; u.m_recvHits[ u.m_recvHitIndex ] = RecvHitEntry( b.m_pos, 20 ); u.m_recvHitIndex = (u.m_recvHitIndex+1) % MAX_RECV_HIT; if( u.m_health<=0 ) { destroyUnit(u); m_numUnits--; } } } }

---

Member Data Documentation

BattleState* BattleGroup::BS

Definition at line 74 of file BattleGroup.h. Referenced by acquireGroupTargets(), destroyUnit(), drawOutlineBox(), fire(), fireAntiAir(), isContain2DPoint(), moveBattleGroup(), render(), and takeHit().

Vec3D BattleGroup::m_color

Definition at line 77 of file BattleGroup.h. Referenced by BattleGroup(), BattleEntry::countGroupsBelongingToPlayer(), destroyUnit(), fire(), BattleEntry::maySendGroundReinforcement(), BattleEntry::renderGroups(), BattleEntry::renderInterface(), and BattleEntry::renderMiniMap().

Vec3D BattleGroup::m_dir

Definition at line 77 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), moveBattleGroup(), moveUnits(), and BattleEntry::renderMiniMap().

bool BattleGroup::m_isChasePrimaryTarget

Definition at line 92 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), moveBattleGroup(), and BattleEntry::processQueuedInput().

bool BattleGroup::m_isStrictPrimaryTarget

Definition at line 93 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), and BattleEntry::processQueuedInput().

FLOAT BattleGroup::m_maxUnitDist

Definition at line 83 of file BattleGroup.h. Referenced by moveBattleGroup(), and moveUnits().

int BattleGroup::m_numUnits

Definition at line 81 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), BattleEntry::countGroupsBelongingToPlayer(), destroyUnit(), drawOutlineBox(), fire(), BattleEntry::isBattleFinished(), isContain2DPoint(), BattleEntry::maySendGroundReinforcement(), moveBattleGroup(), moveUnits(), render(), BattleEntry::renderMiniMap(), and takeHit().

int BattleGroup::m_overheadForceNumber

Definition at line 96 of file BattleGroup.h. Referenced by BattleGroup(), and BattleEntry::isBattleFinished().

Vec3D BattleGroup::m_pos

Definition at line 77 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), moveBattleGroup(), render(), BattleEntry::renderGroups(), and BattleEntry::renderMiniMap().

int BattleGroup::m_primaryTarget

Definition at line 91 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), fire(), moveBattleGroup(), BattleEntry::processQueuedInput(), and render().

Vec3D BattleGroup::m_size

Definition at line 77 of file BattleGroup.h. Referenced by BattleGroup(), drawOutlineBox(), isContain2DPoint(), and moveUnits().

FLOAT BattleGroup::m_statFiringRange

Definition at line 89 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), and fire().

vector<int> BattleGroup::m_targetGroups

Definition at line 86 of file BattleGroup.h. Referenced by acquireGroupTargets(), and fire().

char BattleGroup::m_team

Definition at line 76 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), and BattleEntry::isBattleFinished().

int BattleGroup::m_unitArraySize

Definition at line 79 of file BattleGroup.h. Referenced by BattleGroup(), fire(), fireAntiAir(), moveUnits(), render(), and takeHit().

BattleUnit BattleGroup::m_units[MAX_UNIT]

Definition at line 87 of file BattleGroup.h. Referenced by BattleGroup(), fire(), fireAntiAir(), moveUnits(), render(), and takeHit().

int BattleGroup::m_unitType

Definition at line 78 of file BattleGroup.h. Referenced by acquireGroupTargets(), BattleGroup(), fire(), BattleEntry::isBattleFinished(), moveBattleGroup(), moveUnits(), render(), and BattleEntry::renderMiniMap().

vector<Vec3D> BattleGroup::m_waypoints

Definition at line 85 of file BattleGroup.h. Referenced by addWaypoint(), moveBattleGroup(), BattleEntry::processQueuedInput(), and render().

---

The documentation for this class was generated from the following files:

• BattleGroup.h
• BattleGroup.cpp

---