miguel.horta/commandergenius
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
51bc7a8e3e91ab56530e419a1c4526b900934094
commandergenius/project/jni/application/alienblaster/formation.cpp

646 lines
17 KiB
C++
Raw Blame History

/***************************************************************************
alienBlaster
Copyright (C) 2004
Paul Grathwohl, Arne Hormann, Daniel Kuehn, Soenke Schwardt
This program 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 2, or (at your option)
any later version.
This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
***************************************************************************/
#include "formation.h"
#include "enemy.h"
#include "enemys.h"
#include <iostream>
using namespace std;
Formation::Formation( FormationTypes whichFormation, Vector2D centerAtStart,
Vector2D startVel, int nrEnemys,
FormationEnemySets enemyTypes,
int flagsFormationChangePolicy,
FormationShotPatterns shotPattern ) {
formationType = whichFormation;
formationCenter = centerAtStart;
formationSpeed = startVel;
changeOnKill = flagsFormationChangePolicy & FORMATION_CHANGE_ON_KILL;
changeSpontaneous = flagsFormationChangePolicy & FORMATION_CHANGE_SPONTANEOUS;
changeOften = flagsFormationChangePolicy & FORMATION_CHANGE_OFTEN;
changeSeldom = flagsFormationChangePolicy & FORMATION_CHANGE_SELDOM;
if ( changeSpontaneous && !changeSeldom && !changeOften ) changeSeldom = true;
if ( changeOften ) {
nextFormationChange =
FORMATION_CHANGE_OFTEN_DELAY +
rand() % (FORMATION_CHANGE_OFTEN_RAND_DELAY+1);
} else if ( changeSeldom ) {
nextFormationChange =
FORMATION_CHANGE_SELDOM_DELAY +
rand() % (FORMATION_CHANGE_SELDOM_RAND_DELAY+1);
}
if ( nrEnemys > FORMATION_MAX_NR_ENEMYS[ formationType ] )
nrInvolved = FORMATION_MAX_NR_ENEMYS[ formationType ];
else if ( nrEnemys < 0 ) nrInvolved = 0;
else nrInvolved = nrEnemys;
this->shotPattern = shotPattern;
actShootingEnemy = 0;
if ( shotPattern == FORMATION_SP_NONE ) formationFires = false;
else formationFires = true;
vector<Vector2D> targetPos;
fillTargetPos( targetPos );
for ( int i = 0; i < nrInvolved; i++ ) {
Enemy *newOne;
switch ( enemyTypes ) {
case FORMATION_ENEMY_SET_DEFAULT:
case FORMATION_ENEMY_SET_FIGHTER:
{
newOne = new Enemy( formationCenter + targetPos[ i ], formationSpeed, FIGHTER,
true, formationFires );
break;
}
case FORMATION_ENEMY_SET_BOMBER:
{
newOne = new Enemy( formationCenter + targetPos[ i ], formationSpeed, BOMBER,
true, formationFires );
break;
}
case FORMATION_ENEMY_SET_FIGHTER_BOMBER:
{
newOne =
new Enemy( formationCenter + targetPos[ i ], formationSpeed,
(EnemyTypes)(FIGHTER + (i % 2)),
true, formationFires );
break;
}
}
enemys->addEnemy( newOne );
involvedEnemys.push_back( newOne );
}
enemyWasKilled = false;
// wait at least 100 ms before the first shot
nextFirePrimary = 100;
nextFireSecondary = 100;
// cout << "Type: " << formationType << " SP: " << shotPattern << endl;
}
Formation::~Formation() {}
void Formation::enemyKilled( Enemy *killedEnemy ) {
for ( int i = 0; i < nrInvolved; i++ ) {
if ( involvedEnemys[i] == killedEnemy ) {
enemyWasKilled = true;
involvedEnemys.erase( involvedEnemys.begin() + i );
nrInvolved--;
break;
}
}
}
void Formation::update( int dT ) {
if ( changeSpontaneous ) handleSpontaneousFormationChange( dT );
if ( enemyWasKilled ) {
// change the formation?
if ( changeOnKill && (rand() % 100 < 70) ) chooseNewFormationType();
moveEnemyInFormation();
enemyWasKilled = false;
}
formationCenter += formationSpeed * dT / 1000.0;
shoot( dT );
}
void Formation::handleSpontaneousFormationChange( int dT ) {
nextFormationChange -= dT;
if ( changeSpontaneous && nextFormationChange < 0 ) {
chooseNewFormationType();
moveEnemyInFormation();
if ( changeOften ) {
nextFormationChange =
FORMATION_CHANGE_OFTEN_DELAY +
rand() % (FORMATION_CHANGE_OFTEN_RAND_DELAY+1);
} else if ( changeSeldom ) {
nextFormationChange =
FORMATION_CHANGE_SELDOM_DELAY +
rand() % (FORMATION_CHANGE_SELDOM_RAND_DELAY+1);
}
}
}
void Formation::moveEnemyInFormation() {
// calc the target positions in the new formation (relative to the center of the formation)
vector<Vector2D> targetPos;
fillTargetPos( targetPos );
// choose the best mapping from enemy to targetPosition
// (shortest way for enemy to its position is best)
vector<Vector2D> relPosForEnemies;
getBestMapping( targetPos, relPosForEnemies );
// give the enemy its order
for ( int i = 0; i < nrInvolved; i++ ) {
involvedEnemys[i]->setNewRelTargetPos( relPosForEnemies[ i ] );
}
}
void Formation::chooseNewFormationType() {
bool found = false;
int i = 0;
while ( i < 10 && !found ) {
FormationTypes newFormationType = (FormationTypes)(rand() % (NR_FORMATION_TYPES-1));
if ( formationType == newFormationType ) {
newFormationType = (FormationTypes)(NR_FORMATION_TYPES - 1);
}
if ( nrInvolved <= FORMATION_MAX_NR_ENEMYS[ newFormationType ] ) {
formationType = newFormationType;
found = true;
}
i++;
}
}
void Formation::fillTargetPos( vector<Vector2D> &targetPos ) {
switch ( formationType ) {
case FORMATION_V:
{
fillTargetPosFormationV( targetPos );
break;
}
case FORMATION_REVERSE_V:
{
fillTargetPosFormationReverseV( targetPos );
break;
}
case FORMATION_BLOCK:
{
fillTargetPosFormationBlock( targetPos );
break;
}
case FORMATION_LINE:
{
fillTargetPosFormationLine( targetPos );
break;
}
default:
{
for ( int i = 0; i < nrInvolved; i++ ) {
targetPos.push_back( Vector2D(0,0) );
}
break;
}
}
}
void Formation::fillTargetPosFormationV( vector<Vector2D> &targetPos ) {
switch ( nrInvolved ) {
case 1:
{
targetPos.push_back( Vector2D(0,0) );
break;
}
case 2:
{
targetPos.push_back( Vector2D(-30,0) );
targetPos.push_back( Vector2D(30,0) );
break;
}
case 3:
{
targetPos.push_back( Vector2D(-50,25) );
targetPos.push_back( Vector2D(0,-25) );
targetPos.push_back( Vector2D(50,25) );
break;
}
case 4:
{
targetPos.push_back( Vector2D(-80,25) );
targetPos.push_back( Vector2D(-30,-25) );
targetPos.push_back( Vector2D(30,-25) );
targetPos.push_back( Vector2D(80,25) );
break;
}
case 5:
{
targetPos.push_back( Vector2D(-100,50) );
targetPos.push_back( Vector2D(-50,0) );
targetPos.push_back( Vector2D(0,-50) );
targetPos.push_back( Vector2D(50,0) );
targetPos.push_back( Vector2D(100,50) );
break;
}
case 6:
{
targetPos.push_back( Vector2D(-130,50) );
targetPos.push_back( Vector2D(-80,0) );
targetPos.push_back( Vector2D(-30,-50) );
targetPos.push_back( Vector2D(30,-50) );
targetPos.push_back( Vector2D(80,0) );
targetPos.push_back( Vector2D(130,50) );
break;
}
case 7:
{
targetPos.push_back( Vector2D(-150,75) );
targetPos.push_back( Vector2D(-100,25) );
targetPos.push_back( Vector2D(-50,-25) );
targetPos.push_back( Vector2D(0,-75) );
targetPos.push_back( Vector2D(50,-25) );
targetPos.push_back( Vector2D(100,25) );
targetPos.push_back( Vector2D(150,75) );
break;
}
default:
{
cout << "fillTargetPosFormationV: too many enemys involved: " << nrInvolved << endl;
for ( int i = 0; i < nrInvolved; i++ ) {
targetPos.push_back( Vector2D(0,0) );
}
break;
}
}
}
void Formation::fillTargetPosFormationReverseV( vector<Vector2D> &targetPos ) {
switch ( nrInvolved ) {
case 1:
{
targetPos.push_back( Vector2D(0,0) );
break;
}
case 2:
{
targetPos.push_back( Vector2D(-30,0) );
targetPos.push_back( Vector2D(30,0) );
break;
}
case 3:
{
targetPos.push_back( Vector2D(-50,-25) );
targetPos.push_back( Vector2D(0,25) );
targetPos.push_back( Vector2D(50,-25) );
break;
}
case 4:
{
targetPos.push_back( Vector2D(-80,-25) );
targetPos.push_back( Vector2D(-30,25) );
targetPos.push_back( Vector2D(30,25) );
targetPos.push_back( Vector2D(80,-25) );
break;
}
case 5:
{
targetPos.push_back( Vector2D(-100,-50) );
targetPos.push_back( Vector2D(-50,0) );
targetPos.push_back( Vector2D(0,50) );
targetPos.push_back( Vector2D(50,0) );
targetPos.push_back( Vector2D(100,-50) );
break;
}
case 6:
{
targetPos.push_back( Vector2D(-130,-50) );
targetPos.push_back( Vector2D(-80,0) );
targetPos.push_back( Vector2D(-30,50) );
targetPos.push_back( Vector2D(30,50) );
targetPos.push_back( Vector2D(80,0) );
targetPos.push_back( Vector2D(130,-50) );
break;
}
case 7:
{
targetPos.push_back( Vector2D(-150,-75) );
targetPos.push_back( Vector2D(-100,-25) );
targetPos.push_back( Vector2D(-50,25) );
targetPos.push_back( Vector2D(0,75) );
targetPos.push_back( Vector2D(50,25) );
targetPos.push_back( Vector2D(100,-25) );
targetPos.push_back( Vector2D(150,-75) );
break;
}
default:
{
cout << "fillTargetPosFormationReverseV: too many enemys involved: "
<< nrInvolved << endl;
for ( int i = 0; i < nrInvolved; i++ ) {
targetPos.push_back( Vector2D(0,0) );
}
break;
}
}
}
void Formation::fillTargetPosFormationBlock( vector<Vector2D> &targetPos ) {
switch ( nrInvolved ) {
case 1:
{
targetPos.push_back( Vector2D(0,0) );
break;
}
case 2:
{
targetPos.push_back( Vector2D(-30,0) );
targetPos.push_back( Vector2D(30,0) );
break;
}
case 3:
{
targetPos.push_back( Vector2D(-30,25) );
targetPos.push_back( Vector2D(0,-25) );
targetPos.push_back( Vector2D(30,25) );
break;
}
case 4:
{
targetPos.push_back( Vector2D(-30,-25) );
targetPos.push_back( Vector2D(-30,25) );
targetPos.push_back( Vector2D(30,-25) );
targetPos.push_back( Vector2D(30,25) );
break;
}
case 5:
{
targetPos.push_back( Vector2D(-40,-30) );
targetPos.push_back( Vector2D(-40,30) );
targetPos.push_back( Vector2D(0,0) );
targetPos.push_back( Vector2D(40,-30) );
targetPos.push_back( Vector2D(40,30) );
break;
}
case 6:
{
targetPos.push_back( Vector2D(-60,-30) );
targetPos.push_back( Vector2D(-60,30) );
targetPos.push_back( Vector2D(0,-30) );
targetPos.push_back( Vector2D(0,30) );
targetPos.push_back( Vector2D(60,-30) );
targetPos.push_back( Vector2D(60,30) );
break;
}
case 7:
{
targetPos.push_back( Vector2D(-60,-50) );
targetPos.push_back( Vector2D(-60,0) );
targetPos.push_back( Vector2D(0,-50) );
targetPos.push_back( Vector2D(0,0) );
targetPos.push_back( Vector2D(0,50) );
targetPos.push_back( Vector2D(60,-50) );
targetPos.push_back( Vector2D(60,0) );
break;
}
default:
{
cout << "fillTargetPosFormationBlock: too many enemys involved: " << nrInvolved << endl;
for ( int i = 0; i < nrInvolved; i++ ) {
targetPos.push_back( Vector2D(0,0) );
}
break;
}
}
}
void Formation::fillTargetPosFormationLine( vector<Vector2D> &targetPos ) {
switch ( nrInvolved ) {
case 1:
{
targetPos.push_back( Vector2D(0,0) );
break;
}
case 2:
{
targetPos.push_back( Vector2D(-30,0) );
targetPos.push_back( Vector2D(30,0) );
break;
}
case 3:
{
targetPos.push_back( Vector2D(-60,0) );
targetPos.push_back( Vector2D(0,0) );
targetPos.push_back( Vector2D(60,0) );
break;
}
case 4:
{
targetPos.push_back( Vector2D(-90,0) );
targetPos.push_back( Vector2D(-30,0) );
targetPos.push_back( Vector2D(30,0) );
targetPos.push_back( Vector2D(90,0) );
break;
}
case 5:
{
targetPos.push_back( Vector2D(-120,0) );
targetPos.push_back( Vector2D(-60,0) );
targetPos.push_back( Vector2D(0,0) );
targetPos.push_back( Vector2D(60,0) );
targetPos.push_back( Vector2D(120,0) );
break;
}
case 6:
{
targetPos.push_back( Vector2D(-150,0) );
targetPos.push_back( Vector2D(-90,0) );
targetPos.push_back( Vector2D(-30,0) );
targetPos.push_back( Vector2D(30,0) );
targetPos.push_back( Vector2D(90,0) );
targetPos.push_back( Vector2D(150,0) );
break;
}
default:
{
cout << "fillTargetPosFormationLine: too many enemys involved: " << nrInvolved << endl;
for ( int i = 0; i < nrInvolved; i++ ) {
targetPos.push_back( Vector2D(0,0) );
}
break;
}
}
}
///////////////////////////////////////////////
void Formation::getBestMapping( vector<Vector2D> &targetPos,
vector<Vector2D> &relPosForFighters ) {
int actPerm[nrInvolved];
vector<Vector2D> *bestMapping = new vector<Vector2D>();
vector<Vector2D> *testMapping = new vector<Vector2D>();
for ( int i = 0; i < nrInvolved; i++ ) {
bestMapping->push_back( Vector2D( 0,0 ) );
testMapping->push_back( Vector2D( 0,0 ) );
actPerm[ i ] = i;
}
float mapCost = 1000000;
int nrPerm = factorial( nrInvolved );
for ( int perm = 0; perm < nrPerm; perm++ ) {
calcNextPerm( actPerm );
float testMappingCost = calcTestMapping( actPerm, targetPos, testMapping );
if ( mapCost > testMappingCost ) {
vector<Vector2D> *tmpMapping = bestMapping;
bestMapping = testMapping;
testMapping = tmpMapping;
mapCost = testMappingCost;
}
}
for ( int e = 0; e < nrInvolved; e++ ) {
relPosForFighters.push_back( (*bestMapping)[e] );
}
delete bestMapping;
delete testMapping;
}
void Formation::calcNextPerm( int *perm ) {
int n = nrInvolved;
int i = n-1;
int j = n;
int tmp;
while ( i != 0 && perm[ i-1 ] >= perm[ i ] ) {
i--;
}
if ( i == 0 ) {
for ( int k = 0; k < n/2; k++ ) {
tmp = perm[ k ];
perm[ k ] = perm[ n - k - 1 ];
perm[ n - k - 1 ] = tmp;
}
return;
}
while ( perm[ j-1 ] <= perm[ i-1 ] ) {
--j;
}
tmp = perm[ i-1 ];
perm[ i-1 ] = perm[ j-1 ];
perm[ j-1 ] = tmp;
i++;
j = n;
while ( i < j ) {
tmp = perm[ i-1 ];
perm[ i-1 ] = perm[ j-1 ];
perm[ j-1 ] = tmp;
i++;
j--;
}
}
float Formation::calcTestMapping( int *perm, vector<Vector2D> &targetPos,
vector<Vector2D> *mapping ) {
float cost = 0;
for ( int i = 0; i < nrInvolved; i++ ) {
// enemy i shall fly to the position targetPos[perm[i]]
// save the vector from its actual pos to its new targetpos in mapping
(*mapping)[ i ] =
targetPos[ perm[i] ] + formationCenter -
involvedEnemys[ i ]->getPos();
if ( cost < (*mapping)[ i ].getLength() ) {
cost = (*mapping)[ i ].getLength();
}
}
return cost;
}
int Formation::factorial( int n ) {
int result = 1;
for ( int i = 2; i <= n; i++ ) {
result *= i;
}
return result;
}
void Formation::shoot( int dT ) {
if ( shotPattern == FORMATION_SP_NONE ) return;
nextFirePrimary -= dT;
// nextFireSecondary -= dT;
float enemyRatio = FORMATION_MAX_NR_ENEMYS[ formationType ] / (float)nrInvolved;
while ( nextFirePrimary < 0 ) {
switch ( shotPattern ) {
case FORMATION_SP_VOLLEY_FAST:
case FORMATION_SP_VOLLEY_MEDIUM:
case FORMATION_SP_VOLLEY_SLOW:
{
for ( int i = 0; i < nrInvolved; i++ ) {
involvedEnemys[ i ]->firePrimary();
}
break;
}
case FORMATION_SP_RAND_FAST:
case FORMATION_SP_RAND_MEDIUM:
case FORMATION_SP_RAND_SLOW:
{
involvedEnemys[ rand() % nrInvolved ]->firePrimary();
break;
}
case FORMATION_SP_LEFT_RIGHT_FAST:
case FORMATION_SP_LEFT_RIGHT_MEDIUM:
{
actShootingEnemy = (actShootingEnemy + 1) % nrInvolved;
involvedEnemys[ actShootingEnemy ]->firePrimary();
break;
}
case FORMATION_SP_RIGHT_LEFT_FAST:
case FORMATION_SP_RIGHT_LEFT_MEDIUM:
{
actShootingEnemy--;
if ( actShootingEnemy < 0 ) actShootingEnemy = nrInvolved-1;
involvedEnemys[ actShootingEnemy ]->firePrimary();
break;
}
default:
{
break;
}
}
nextFirePrimary +=
lroundf( (FORMATION_SP_PRIMARY_DELAY[ shotPattern ] +
rand() % (FORMATION_SP_PRIMARY_RAND_DELAY[ shotPattern ] + 1)) * enemyRatio );
}
}
Reference in New Issue View Git Blame Copy Permalink