//--------------------------------------------------------------
// Name: init()
// Class: StationaryFireCombat
//
// Description: Initializes the behavior
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void StationaryFireCombat::init( Actor &self )
{
_self = &self;
_animDone = false;
_canAttack = true;
updateEnemy();
}
//--------------------------------------------------------------
// Name: setupStateAdvance()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Sets up the Advance State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateAdvance()
{
Vector selfToEnemy;
float dist;
dist = G_Random ( 64.0f ) + 96.0f;
if ( !_currentEnemy )
{
updateEnemy();
return;
}
// Lets get oriented towards our enemy
selfToEnemy = _currentEnemy->origin - _self->origin;
selfToEnemy = selfToEnemy.toAngles();
_self->setAngles( selfToEnemy );
selfToEnemy.AngleVectors( &selfToEnemy );
_self->movementSubsystem->setMoveDir( selfToEnemy );
_self->movementSubsystem->setAnimDir( selfToEnemy );
_moveRandomDir.SetDistance( dist );
_moveRandomDir.SetAnim( "run" );
_moveRandomDir.SetMode(MoveRandomDirection::RANDOM_MOVE_IN_FRONT);
_moveRandomDir.Begin(*_self);
_moveRandomDir.SetMinDistance( dist * .75 );
}
//--------------------------------------------------------------
void testApp::update(){
m_DTime += ofGetLastFrameTime();
openNIDevice.update();
for ( int i = 0 ; i < NUMBER_OF_SOUND_EFFECTS; ++i)
{
m_SoundEffect[i].update();
}
updateEnemy();
}
//--------------------------------------------------------------
// Name: init()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::init( Actor &self )
{
_self = &self;
transitionToState(CORRIDORCOMBAT_WRW_FINDNODE);
_finishedPostureTransition = true;
_holdPositionTime = 0.0f;
_enemyUpdateTime = 0.0f;
updateEnemy();
}
void Game::Go()
{
frameCount++;
if (kbd.SpaceIsPressed() && !keysPressedLastFrame) {
if (paused) paused = false;
else paused = true;
keysPressedLastFrame = true;
}
//wow to prove exactly when just simple computation (not rendering) can slow shit down.
/*for (int i = 0; i < 5800000; i++)
{
;
}*/
/*for (int i = 0; i < 10000000; i++)
{
;
}*/
/*for (int i = 0; i < 100000000; i++)
{
;
}*/
if (!paused) {
if (!gameOver) {
secondsSinceStart = difftime(time(0), start);
waveTimer = secondsSinceStart;
nextSquadTimer = secondsSinceStart;
setUpShips();
playerShipLogic();
bulletLogic();
updateEnemy();
}
}
//why isnt this working?
//ahh wasnt working because there was a separate make false for if enter wasnt pressed in bullet logic
if (!(kbd.SpaceIsPressed()) && !(kbd.EnterIsPressed())) keysPressedLastFrame = false;
pDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
//2 PROBLEMS:
//1. Mixing of beginscene/endscene unlock/lock rect causes us unable to draw over texture
//2. Logic Is updating faster than we draw
//AHAAA might be able to fix problem 1 by begining and ending the sprite object in the right place. Textures only work when spriteobj has begun
if (pDevice->BeginScene()) {
gfx.BeginFrame();
ComposeFrame();
gfx.EndFrame();
}
}
//--------------------------------------------------------------
// Name: init()
// Class: GeneralCombat
//
// Description: Initializes memeber variables
//
// Parameters: Actor &self -- Actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::init( Actor &self )
{
_self = &self;
_finishedPostureTransition = true;
_randomAdvanceLockOut = false;
_randomRetreatLockOut = false;
_nextRotateTime = 0.0f;
_nextStrafeAttemptTime = 0.0f;
_nextPostureChange = 0.0f;
_nextClearRetreatLockOutTime = 0.0f;
_nextClearAdvanceLockOutTime = 0.0f;
_nextFireTime = 0.0f;
_nextPauseTime = 0.0f;
_randomAdvanceFailures = 0;
_randomRetreatFailures = 0;
transitionToState(GC_WRW_STAND);
updateEnemy();
}
//---------------------------------------------------
void WarManager::update(float time)
{
///如果已经结束就消息
if(hasFlag(F_EndWar))
{
_endWar();
return ;
}
//如果在战争中。
if(hasFlag(F_InWar)==false)
return ;
///更新所有的子弹
size_t size=m_BulletCollect.size();
Ogre::Ray ray;
float rayLenght=0.0f;
for(size_t i=0;i<size;++i)
{
///如果子弹是发射状态就做碰撞检测
if(m_BulletCollect[i]->update(time)&&m_BulletCollect[i]->getState()==Bullet::BS_SHOOT)
{
intersectEnemyQueue(m_BulletCollect[i]);
}
}
updateEnemy(time);
updateEnemyQueue(time);
return ;
}
//--------------------------------------
void Map::Update()
{
//Cập nhật tank người chơi
if (_eagle->getEagleStatus() == EAGLE_STATUS::LIVE)
{
_player->Update();
}
//Cập nhật tank địch
updateEnemy();
//Cập nhật đạn
BulletManager::getInstance()->Update();
//Xét va chạm giữa tank người chơi và căn cứ
CollisionManager::CollisionPreventMove(_player, _eagle);
//Xét va chạm giữa tank địch và căn cứ
int n = _listEnemyOnMap->size();
for (int i = 0; i < n; i++)
{
bool isCollided = CollisionManager::CollisionPreventMove(_listEnemyOnMap->at(i), _eagle);
if (isCollided)
break;
}
//Xét va chạm giữa các xe tank địch với nhau
bool isCollision;
for (int i = 0; i < n-1; i++)
{
for (int j = i+1; j < n; j++)
{
isCollision = CollisionManager::CollisionEnemy(_listEnemyOnMap->at(i), _listEnemyOnMap->at(j));
if (isCollision)
break;
}
}
//Xét va chạm giữa các xe tank địch với tank người chơi
for (int i = 0; i < n; i++)
{
CollisionManager::CollisionChangeDirection(_player, _listEnemyOnMap->at(i));
}
//Xét va chạm giữa đạn với tank địch với tank người chơi
if (_eagle->getEagleStatus() == EAGLE_STATUS::LIVE)
{
if (n == 0)
BulletManager::getInstance()->UpdateCollisionWithDynamicObject(_player, _eagle);
for (int i = 0; i < n; i++)
{
BulletManager::getInstance()->UpdateCollisionWithDynamicObject(_player, _eagle, _powerUpItem, _listEnemyOnMap->at(i));
}
}
//Xét va chạm giữa tank người chơi và powerup item
if(_powerUpItem->IsEnable())
{
CollisionManager::CollisionWithItem(_player, _powerUpItem);
}
//Hồi sinh tank của người chơi
if (_player->_isTerminated)
{
if (_player->getLife() > 0)
{
int pos = CollisionManager::FindRespawnPosition(_playerRespawnPos, DEFINE_ZERO_VALUE, _listEnemyOnMap);
if (pos == 0)
{
_player->Respawn(DEFAULT_PLAYER_POSITION_X, DEFAULT_PLAYER_POSITION_Y);
}
else if (pos == 1)
{
_player->Respawn(DEFAULT_PLAYER_POSITION_X_2, DEFAULT_PLAYER_POSITION_Y);
}
else
{
_player->setPositionX(DEFINE_ZERO_VALUE);
_player->setPositionY(DEFAULT_PLAYER_POSITION_Y);
}
}
else
{
_player->setLife(-1);
_player->setPositionX(DEFINE_ZERO_VALUE);
_player->setPositionY(DEFINE_ZERO_VALUE);
}
}
updatePowerItem();
ClearDestroyedEnemy();
checkEndGame();
}
int main (void)
{
// Golobal Integers
extern int level;
extern int lifes;
extern int score;
extern int health;
// Local Integers
register int mapxoff, mapyoff;
extern int oldpy, oldpx;
extern int facing;
extern int jump;
int n, m;
// DATAFILE *data;
//initilization
allegro_init();
install_timer();
install_keyboard();
set_color_depth(32);
set_gfx_mode(MODE, WIDTH, HEIGHT, 0, 0);
//load data
data = load_datafile("test.dat");
temp = (BITMAP *)data[NEWGUY_BMP].dat;
for (n=0; n<4; n++)
player_image[n] = grabframe(temp,43,77,0,0,4,n);
destroy_bitmap(temp);
temp2 = (BITMAP *)data[BAT1_BMP].dat;
for (m=0; m<2; m++)
bat_img[m] = grabframe(temp2,87,72,0,0,2,m);
destroy_bitmap(temp2);
test_img = load_bitmap("test.bmp", NULL);
gameover:
Start();
first:
//initilize Player
player = malloc(sizeof(SPRITE));
player->x = 80;
player->y = 200;
player->curframe=0;
player->framecount=0;
player->framedelay=11;
player->maxframe=3;
player->width=player_image[0]->w;
player->height=player_image[0]->h;
//initilize Bat
bat = malloc(sizeof(SPRITE));
bat->x = 170;
bat->y = 100;
bat->curframe=0;
bat->framecount=0;
bat->framedelay=11;
bat->maxframe=1;
bat->width=bat_img[0]->w;
bat->height=bat_img[0]->h;
bat->dir = 0;
bat->xspeed = 0;
//ini test
test = malloc(sizeof(SPRITE));
test->x = 270;
test->y = 400;
test->curframe=0;
test->framecount=0;
test->framedelay=11;
test->maxframe=1;
test->width=bat_img[0]->w;
test->height=bat_img[0]->h;
test->dir = 0;
test->xspeed = 0;
loadlevel();
//main loop
while (!key[KEY_ESC])
{
oldpy = player->y;
oldpx = player->x;
if (player->x > 3000)
{level = 2;
goto first;}
if (lifes == 0)
{lifes = 3;
goto gameover;}
if (health < 1)
{lifes -=1;
health =100;
goto first;}
updateEnemy(150, 300, test);
updateEnemy(150, 300, bat);
enemycoll(player->x, player->y, bat);
keyinput();
//collition control
if (!facing)
{
if (collided(player->x, player->y + player->height))
player->x = oldpx;
if (collidedobj(player->x, player->y + player->height))
{ClearCell(player->x, player->y + player->height);
AddScore();}
if (collidedkill(player->x+9, player->y + player->height))
{health -= 25;}
}
else
{
if (collided(player->x + player->width, player->y + player->height))
player->x = oldpx;
if (collidedobj(player->x + player->width, player->y + player->height))
{ClearCell(player->x + player->width, player->y + player->height);
AddScore();}
if (collidedkill(player->x + player->width-15, player->y + player->height))
{health -= 25;}
}
//update the map scroll position
mapxoff = player->x + player->width/2 - WIDTH/2 + 10;
mapyoff = player->y + player->height/2 - HEIGHT/2 + 10;
//avoid moving beyond the map edge
if (mapxoff < 0) mapxoff = 0;
if (mapxoff > (mapwidth * mapblockwidth - WIDTH))
mapxoff = mapwidth * mapblockwidth - WIDTH;
if (mapyoff < 0)
mapyoff = 0;
if (mapyoff > (mapheight * mapblockheight - HEIGHT))
mapyoff = mapheight * mapblockheight - HEIGHT;
//draw the background tiles
MapDrawBG(buffer, mapxoff, mapyoff, 0, 0, WIDTH-1, HEIGHT-1);
//draw foreground tiles
MapDrawFG(buffer, mapxoff, mapyoff, 0, 0, WIDTH-1, HEIGHT-1, 0);
//draw the player's sprite
if (facing)
draw_sprite(buffer, player_image[player->curframe],
(player->x-mapxoff), (player->y-mapyoff+1));
else
draw_sprite_h_flip(buffer, player_image[player->curframe],
(player->x-mapxoff), (player->y-mapyoff));
//blit the double buffer
vsync();
acquire_screen();
if (bat->dir == 1)
draw_sprite(buffer, bat_img[bat->curframe],(bat->x-mapxoff),(bat->y-mapyoff));
else
draw_sprite_h_flip(buffer, bat_img[bat->curframe],(bat->x-mapxoff),(bat->y-mapyoff));
draw_sprite(buffer, test_img,(test->x-mapxoff),(test->y-mapyoff));
textprintf(buffer,font,0,0,9999999,"lifes = %d Score = %d Health = %d",lifes,score,health);
blit(buffer, screen, 0, 0, 0, 0, WIDTH-1, HEIGHT-1);
release_screen();
} //End of game loop
for (n=0; n<4; n++)
destroy_bitmap(player_image[n]);
for (m=0; m<2; m++)
destroy_bitmap(bat_img[m]);
destroy_bitmap(test_img);
free(player);
free(bat);
free(test);
destroy_bitmap(buffer);
MapFreeMem ();
MapFreeMem ();
unload_datafile(data);
allegro_exit();
return 0;
}
//--------------------------------------------------------------
// Name: Evaluate()
// Class: StationaryFireCombat
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t StationaryFireCombat::Evaluate( Actor & )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case STATIONARY_FIRE_AIM:
//---------------------------------------------------------------------
stateResult = evaluateStateAim();
if ( stateResult == BEHAVIOR_SUCCESS )
{
updateEnemy();
if ( _preFireAnim.length() )
transitionToState( STATIONARY_FIRE_PRE_FIRE );
else
transitionToState( STATIONARY_FIRE_ATTACK );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_PRE_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStatePreFire();
if ( stateResult == BEHAVIOR_SUCCESS )
{
transitionToState( STATIONARY_FIRE_ATTACK );
}
if ( stateResult == BEHAVIOR_FAILED )
{
transitionToState( STATIONARY_FIRE_FAILED );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_ATTACK:
//---------------------------------------------------------------------
stateResult = evaluateStateAttack();
if ( stateResult == BEHAVIOR_SUCCESS )
{
_fireWeapon.End( *_self );
if ( _postFireAnim.length() )
transitionToState( STATIONARY_FIRE_POST_FIRE );
else
transitionToState( STATIONARY_FIRE_SUCCESS );
}
if ( stateResult == BEHAVIOR_FAILED )
{
_fireWeapon.End( *_self );
if ( _postFireAnim.length() )
transitionToState( STATIONARY_FIRE_POST_FIRE );
else
transitionToState( STATIONARY_FIRE_SUCCESS );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_POST_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStatePostFire();
if ( stateResult == BEHAVIOR_SUCCESS )
{
transitionToState( STATIONARY_FIRE_SUCCESS );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_SUCCESS:
//---------------------------------------------------------------------
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_FAILED:
//---------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: init()
// Class: TorsoAimAndFireWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void TorsoAimAndFireWeapon::init( Actor &self )
{
_self = &self;
//Set Our Controller Tag and set up our angles
self.SetControllerTag( ActorTorsoTag, gi.Tag_NumForName( self.edict->s.modelindex, "Bip01 Spine1" ) );
_currentTorsoAngles = self.GetControllerAngles( ActorTorsoTag );
_animDone = false;
_canAttack = true;
_aimAnim = "idle";
_preFireAnim = "idle";
_fireAnim = "idle";
_postFireAnim = "idle";
GameplayManager *gpm = GameplayManager::getTheGameplayManager();
if ( !gpm->hasObject(self.getArchetype()) )
return;
str objname = self.combatSubsystem->GetActiveWeaponArchetype();
objname = "Hold" + objname;
if ( gpm->hasProperty(objname, "Aim") )
_aimAnim = gpm->getStringValue( objname , "Aim" );
if ( gpm->hasProperty( objname , "PreFire" ) )
_preFireAnim = gpm->getStringValue( objname , "PreFire" );
if ( gpm->hasProperty( objname , "Fire" ) )
_fireAnim = gpm->getStringValue( objname , "Fire" );
if ( gpm->hasProperty( objname , "PostFire" ) )
_postFireAnim = gpm->getStringValue( objname , "PostFire" );
if ( gpm->hasProperty( objname , "AimTimeMin" ) )
_aimTimeMin = gpm->getFloatValue( objname , "AimTimeMin" );
if ( gpm->hasProperty( objname , "AimTimeMax" ) )
_aimTimeMax = gpm->getFloatValue( objname , "AimTimeMax" );
if ( gpm->hasProperty( objname , "FireTimeMin" ) )
_fireTimeMin = gpm->getFloatValue( objname , "FireTimeMin" );
if ( gpm->hasProperty( objname , "FireTimeMax" ) )
_fireTimeMax = gpm->getFloatValue( objname , "FireTimeMax" );
if ( gpm->hasProperty( objname , "ShotCount" ) )
_shots = (int)gpm->getFloatValue( objname , "ShotCount" );
float spreadX, spreadY;
spreadX = self.combatSubsystem->GetDataForMyWeapon( "spreadx" );
spreadY = self.combatSubsystem->GetDataForMyWeapon( "spready" );
self.combatSubsystem->OverrideSpread( spreadX , spreadY );
//Clear Out Our VolleyCount
_self->shotsFiredThisVolley = 0;
updateEnemy();
}
//--------------------------------------------------------------
// Name: think()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Does any processing required before evaluating states
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::think()
{
updateEnemy();
}
//--------------------------------------------------------------
// Name: init()
// Class: CloseInOnEnemyWhileFiringWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void CloseInOnEnemyWhileFiringWeapon::init( Actor &self )
{
_self = &self;
updateEnemy();
transitionToState(CIWF_APPROACH_SETUP_APPROACH);
}
