void ActionManager::checkForCapture(){
//if one of the enemies gets the destination you lose
for(unsigned int i = 0; i < craftPool.size(); i++)
if(craftPool[i]->isMoveFinished()){
craftPool[i]->remove();//remove it from scene
delete craftPool[i];
craftPool.erase(i); //remove it from pool
ISceneNode* fighter = device->getSceneManager()->getSceneNodeFromId(NEWGAME_ELEMENT::NEWGAME_FIGHTER);
fighter->setVisible(false);
createExplosion(fighter->getPosition(), 12);
gameOver();
}
}
bool ObjectType::handleDestruction(GameObjectPtr collidee, GameObjectPtr collider)
{
//---------------------------------------------
// The default reaction of any object in the world
// is to simply explode. This routine will create
// the associated explosions, debris, smoke, fire, etc.
// and then return TRUE, to indicate that the object
// has, in fact, gone south. The object is NOT
// removed from the object list here!! Please don't
// do it here either since it will screw up much code.
Stuff::Vector3D pos = collidee->getPosition();
createExplosion(pos);
return(true);
}
void System::Bomb::bombExplos(unsigned int i) {
Component::PlayerInfo *playerInfo;
std::vector<Entity>::iterator play = _entities.begin();
unsigned int const id = static_cast<Component::Id *>(_entities[i][Component::ID])->getId();
int nb;
unsigned int speed = 52;
for (; play < _entities.end(); ++play) {
if (play->getType() == Entity::PLAYER
&& (playerInfo = static_cast<Component::PlayerInfo *>((*play)[Component::PLAYERINFO]))
&& (playerInfo->getId() == id)) {
nb = static_cast<Component::NbBomb *>((*play)[Component::NBBOMB])->getNb();
static_cast<Component::NbBomb *>((*play)[Component::NBBOMB])->setNb(nb + 1);
speed = static_cast<Component::Move *>((*play)[Component::MOVE])->getSpeed() + 8;
break;
}
}
createExplosion(i, Component::Move::EAST, speed);
createExplosion(i, Component::Move::WEST, speed);
createExplosion(i, Component::Move::NORTH, speed);
createExplosion(i, Component::Move::SOUTH, speed);
_entities.erase(_entities.begin() + i);
}
ParticleEmitter::ParticleEmitter(float emitterX, float emitterY, int emitterType, int assetID, float emitAngle){
_emitterX = emitterX;
_emitterY = emitterY;
_emitterType = emitterType;
_assetID = assetID;
_timeLived = 0;
_timeToLive = 0;
_isAlive = true;
_emitAngle = emitAngle;
if(_emitterType == EXPLOSION)
createExplosion();
if(_emitterType == GEO_TRAIL)
createTrail();
}
void ProjectileManager::update(const float& delta, TankManager* tankMgr){
for (std::set<Projectile*>::iterator it = projectiles.begin();it != projectiles.end();)
{
(*it)->update(delta, gravityValue);
//check if Projectile hit anything
Ogre::Vector3 explosionCtr = (*it)->particleSn->_getDerivedPosition();
explosionSphere.setCenter(explosionCtr);
Ogre::SphereSceneQuery* ssq = mSceneMgr->createSphereQuery(explosionSphere, Ogre::SceneManager::ENTITY_TYPE_MASK);
Ogre::SceneQueryResult& result = ssq->execute();
//projectile hit something
if (result.movables.size() > 0 || explosionCtr.y < 0.5f) //if projectile hit some tank or is just above ground
{
Ogre::SceneQueryResultMovableList::iterator sqrItr;
for (sqrItr = result.movables.begin(); sqrItr != result.movables.end(); ++sqrItr){
//if tank, minus health based on the distance from the explosion center
tankMgr->checkTankExplosion((*sqrItr)->getParentSceneNode(), explosionCtr, (*it)->dmg);
}
createExplosion(explosionCtr);
destroyProjectile(*it);
it = projectiles.erase(it); //erase projectile and get new iterator
} else{
++it;
}
mSceneMgr->destroyQuery(ssq);
}
for (std::set<Explosion*>::iterator it = explosions.begin(); it != explosions.end();)
{
(*it)->existedTime += delta;
if ((*it)->existedTime > (*it)->timeLimit)
{
destroyExplosion((*it));
it = explosions.erase(it);
} else{
it++;
}
}
}
void Bullet::kill(void)
{
zombie=true;
if(getZone().isParticleSystemValid(particleHandle))
{
getZone().getParticleSystem(particleHandle).kill();
}
createExplosion
(
getZone(),
getPos(),
damageValue/2,
1.0f,
owner,
explosionParticleFile,
explosionSoundEffectFile
);
}
void ActionManager::collisionProjectileVsCraft(){
//check for collisions between crafts and projectiles
for(unsigned int i = 0; i < craftPool.size(); i++)
for(unsigned int j = 0; j < projectilePool.size(); j++)
if(collisionCheck(craftPool[i]->getSceneNode(), projectilePool[j]->getAnimatedMeshSceneNode())){
ISceneNode* craftNode = 0;
if(craftPool[i]->getSceneNode()->getID() < ENEMY_CRAFT_THRESHOLD) //define type of craft whether it is enemy or not
craftNode = craftPool[i]->getSceneNode();
ISceneNode* projectileNode = (ISceneNode*)projectilePool[j]->getAnimatedMeshSceneNode();
if(craftNode && projectileNode){
createExplosion(craftNode->getPosition(), 12);
craftPool[i]->remove(); //remove craft
delete craftPool[i]; //release its memory
craftPool.erase(i); //remove from active pool
projectilePool[j]->remove(); //remove projectile
delete projectilePool[j];
projectilePool.erase(j);
updateScore(10);
}
}
}
/*
* if hit_count is enough it explodes it and generates a new shape
*
*/
bool Shape::checkDamage()
{
//shape is not special and has been hit too much = EXPLODE
if((hit_count>4)&&(this!=Shape::board[10])){
createExplosion();
hit_count = 0;
width = ofRandom(50, 200);
height = ofRandom(50, 200);
while(locationError(11,true)){
location_y = ofRandom(TWALL, BWALL-200);
location_x = ofRandom(LWALL, RWALL-200);
}
}
//SPECIAL shape is hit too much = CHANGE THEME
if((hit_count>max_hits)&&(this==Shape::board[10])){
hit_count = 0;
printf("hit special\n");
if(Shape::board[10]->getWidth()>Shape::min_w_white_block)Shape::board[10]->setWidth(Shape::board[10]->getWidth()-10);
if(Shape::board[10]->getHeight()>Shape::min_h_white_block)Shape::board[10]->setHeight(Shape::board[10]->getHeight()-10);
return TRUE;//going to change theme
}
return FALSE;
}
void Blaster::land(){
to_clean = true;
soundPlayAt(g_blaster_explode_sound,loc,1);
if( to_heal ) {
createExplosion(loc, 1, 2 );
} else {
g_fld->burn(loc,this);
}
float r = 0;
for(int i=0;i<8;i++){
Vec2 tov = Vec2::angle(r).normalize(range(100,150) );
r += M_PI/4.0;
if( to_heal ) {
Debri *d = new Debri( loc, B_ATLAS_HP_PARTICLE );
d->rotate_speed = range(7,10);
d->setColor( Color(1,1,1,0.7));
d->setScl( range(0.7,1) *PPC );
} else {
new Beam( loc, loc+tov, BEAMTYPE_BLASTER, -1, 20, shooter_id );
}
}
}
void ActionManager::collisionCraftVsCraft(){
for(unsigned int i = 0; i < craftPool.size(); i++)
for(unsigned int j = i + 1; j < craftPool.size(); j++)
if(collisionCheck(craftPool[i]->getSceneNode(), craftPool[j]->getSceneNode())){
ISceneNode* fighter;
ISceneNode* craft;
bool isFighter = false;
if(craftPool[i]->getSceneNode()->getID() == NEWGAME_ELEMENT::NEWGAME_FIGHTER){
fighter = craftPool[i]->getSceneNode();
craft = craftPool[j]->getSceneNode();
isFighter = true;
} else if (craftPool[j]->getSceneNode()->getID() == NEWGAME_ELEMENT::NEWGAME_FIGHTER){
fighter = craftPool[j]->getSceneNode();
craft = craftPool[i]->getSceneNode();
isFighter = true;
}
if(isFighter){
craft->setVisible(false);
fighter->setVisible(false);
createExplosion(fighter->getPosition(), 12);
gameOver();
}
}
}
void Game::updateInsects() {
//insect kamikaze ship rotation, movement, boundaries, bullet and ship collision
for (int i = 0; i < insectKamikazeFleet.size(); i++) {
findRotation(insectKamikazeFleet[i].x, insectKamikazeFleet[i].y, playerShip.x, playerShip.y, insectKamikazeFleet[i].rotation);
insectKamikazeFleet[i].vx = cos(insectKamikazeFleet[i].rotation) * insectKamikazeFleet[i].speed;
insectKamikazeFleet[i].vy = sin(insectKamikazeFleet[i].rotation) * insectKamikazeFleet[i].speed;
insectKamikazeFleet[i].x += insectKamikazeFleet[i].vx;
insectKamikazeFleet[i].y += insectKamikazeFleet[i].vy;
insectKamikazeFleet[i].frameExposure++;
if (insectKamikazeFleet[i].frameExposure > 4) {
insectKamikazeFleet[i].frame++;
insectKamikazeFleet[i].frameExposure = 0;
if (insectKamikazeFleet[i].frame > 14) insectKamikazeFleet[i].frame = 0;
}
if (insectKamikazeFleet[i].x + (ENEMYDIMENSION * INSECTSCALE) / 2 > RIGHTBOUNDARY) insectKamikazeFleet[i].x = RIGHTBOUNDARY - (ENEMYDIMENSION * INSECTSCALE) / 2;
else if (insectKamikazeFleet[i].x - (ENEMYDIMENSION * INSECTSCALE) / 2 < LEFTBOUNDARY) insectKamikazeFleet[i].x = LEFTBOUNDARY + 5;
if (insectKamikazeFleet[i].y + (ENEMYDIMENSION * INSECTSCALE) / 2 > LOWERBOUNDARY) insectKamikazeFleet[i].y = LOWERBOUNDARY - (ENEMYDIMENSION * INSECTSCALE) / 2;
else if (insectKamikazeFleet[i].y - (ENEMYDIMENSION * INSECTSCALE) / 2 < UPPERBOUNDARY) insectKamikazeFleet[i].y = UPPERBOUNDARY + 5;
if (insectKamikazeFleet[i].ifHit) {
insectKamikazeFleet[i].framesSinceHit++;
if (insectKamikazeFleet[i].framesSinceHit > FRAMESPERFLASH) {
insectKamikazeFleet[i].framesSinceHit = 0;
insectKamikazeFleet[i].ifHit = false;
}
}
}
for (int k = 0; k < insectKamikazeFleet.size(); k++) {
for (int i = 0; i < AMOUNTOFVECTORS; i++) {
for (int j = 0; j < arrayOfVectors[i].size(); j++) {
if (arrayOfVectors[i].at(j).x > insectKamikazeFleet[k].x - (ENEMYDIMENSION * INSECTSCALE) / 2 &&
arrayOfVectors[i].at(j).x < insectKamikazeFleet[k].x + (ENEMYDIMENSION * INSECTSCALE) / 2 &&
arrayOfVectors[i].at(j).y > insectKamikazeFleet[k].y - (ENEMYDIMENSION * INSECTSCALE) / 2 &&
arrayOfVectors[i].at(j).y < insectKamikazeFleet[k].y + (ENEMYDIMENSION * INSECTSCALE) / 2) {
arrayOfVectors[i].erase(arrayOfVectors[i].begin() + j);
insectKamikazeFleet[k].lives -= BULLETDAMAGE;
if (insectKamikazeFleet[k].lives <= 0) {
createExplosion(explosion(), insectKamikazeFleet[k].x, insectKamikazeFleet[k].y, insectKamikazeFleet[k].rotation, 0.55f, 0, 255, 0);
insectKamikazeFleet.erase(insectKamikazeFleet.begin() + k);
totalInsectKillsLevel++;
break;
}
else {
insectKamikazeFleet[k].ifHit = true;
insectKamikazeFleet[k].framesSinceHit = 0;
}
}
}
}
}
/*
Make function that takes in x,y of bullet/weapon and ship, full width and height of both bullet and ship, What type of ship,
will make much easier to change other stuff then.
*/
for (int k = 0; k < insectKamikazeFleet.size(); k++) {
for (int i = 0; i < missileVector.size(); i++) {
if (missileVector[i].x > insectKamikazeFleet[k].x - (ENEMYDIMENSION * INSECTSCALE) / 2 &&
missileVector[i].x < insectKamikazeFleet[k].x + (ENEMYDIMENSION * INSECTSCALE) / 2 &&
missileVector[i].y > insectKamikazeFleet[k].y - (ENEMYDIMENSION * INSECTSCALE) / 2 &&
missileVector[i].y < insectKamikazeFleet[k].y + (ENEMYDIMENSION * INSECTSCALE) / 2) {
missileVector.erase(missileVector.begin() + i);
insectKamikazeFleet[k].lives -= MISSILEDAMAGE;
if (insectKamikazeFleet[k].lives <= 0) {
createExplosion(explosion(), insectKamikazeFleet[k].x, insectKamikazeFleet[k].y, insectKamikazeFleet[k].rotation, 0.55f, 0, 255, 0);
insectKamikazeFleet.erase(insectKamikazeFleet.begin() + k);
totalInsectKillsLevel++;
break;
}
else {
insectKamikazeFleet[k].ifHit = true;
insectKamikazeFleet[k].framesSinceHit = 0;
}
}
}
}
}
void Game::updateEnemyShip1s() {
//rotation, movement, boundaries, bullet and ship collision
for (int i = 0; i < enemyShipFleet.size(); i++) {
findRotation(enemyShipFleet[i].x, enemyShipFleet[i].y, playerShip.x, playerShip.y, enemyShipFleet[i].rotation);
enemyShipFleet[i].x += enemyShipFleet[i].vx;
enemyShipFleet[i].y += enemyShipFleet[i].vy;
/*
**************************************************************************************************************
changes to try(change direction somehow if boundary hit) Talking about enemyship1 (which he is called from now on to avoid ambiguity with the insect with just enemyship itself):
1. Make his y = x * x
2. y = x * x * x, log(x) sqrt(x), sin(x) etc
3. his y = cos(rotation) and x = y * y
4. find circle formula (based on centre maybe)
5. semi circle
6. form function which takes distance close to player and works dynamic circle which changes every frame if player moves. Then try semi circle. Work it maybe with angles, or maybe just come circumference follower
7. Finally work some way finally after doing all that to make him avoid his fellow teammates ships which will be hard.
Function that takes in x and y of every teammate within 200-400 pixels and moves in a direction away from them but towards you if possible. Have them go slow so they can easily plan in a group mentality kinda way?
Maybe have them eventually just go fast and slow. They slow down when clsoe to an enemy ship and eventually move away. They maybe never get too close to an enemy ship because they slow down same with yours.
8. And separate point as to how it will look if you do eventually collide off an enemy ship. Maybe just bounce off and lose health so player avoids hitting them then.
9. make them go in a parade kinda way. or a big s towards you and instead of avoiding you maybe enemyship1s also eventually crash into you but take their time about it.
left all the way then small or mediumu turn towards right
*/
if (enemyShipFleet[i].x + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 > RIGHTBOUNDARY) enemyShipFleet[i].x = RIGHTBOUNDARY - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2;
else if (enemyShipFleet[i].x - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 < LEFTBOUNDARY) enemyShipFleet[i].x = LEFTBOUNDARY + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2;
if (enemyShipFleet[i].y + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 > LOWERBOUNDARY) {
enemyShipFleet[i].y = LOWERBOUNDARY - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2;
enemyShipFleet[i].vy *= -1;
}
else if (enemyShipFleet[i].y - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 < UPPERBOUNDARY) {
enemyShipFleet[i].y = UPPERBOUNDARY + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2;
enemyShipFleet[i].vy *= -1;
}
if (enemyShipFleet[i].ifHit) {
enemyShipFleet[i].framesSinceHit++;
if (enemyShipFleet[i].framesSinceHit > FRAMESPERFLASH) {
enemyShipFleet[i].framesSinceHit = 0;
enemyShipFleet[i].ifHit = false;
}
}
}
for (int k = 0; k < enemyShipFleet.size(); k++) {
for (int i = 0; i < AMOUNTOFVECTORS; i++) {
for (int j = 0; j < arrayOfVectors[i].size(); j++) {
if (arrayOfVectors[i].at(j).x > enemyShipFleet[k].x - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 &&
arrayOfVectors[i].at(j).x < enemyShipFleet[k].x + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 &&
arrayOfVectors[i].at(j).y > enemyShipFleet[k].y - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 &&
arrayOfVectors[i].at(j).y < enemyShipFleet[k].y + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2) {
arrayOfVectors[i].erase(arrayOfVectors[i].begin() + j);
enemyShipFleet[k].lives -= BULLETDAMAGE;
if (enemyShipFleet[k].lives <= 0) {
createExplosion(explosion(), enemyShipFleet[k].x, enemyShipFleet[k].y, enemyShipFleet[k].rotation, 0.6f, rand() % 255, rand() % 255, rand() % 255);
for (int a = 0; a < pShipTargets.size(); a++) {
;//if (pShipTargets[a].ship == &enemyShipFleet[k]) pShipTargets.erase(pShipTargets.begin() + a);
}
enemyShipFleet.erase(enemyShipFleet.begin() + k);
totalEnemyShipKillsLevel++;
break;
}
else {
enemyShipFleet[k].ifHit = true;
enemyShipFleet[k].framesSinceHit = 0;
}
}
}
}
}
for (int k = 0; k < enemyShipFleet.size(); k++) {
for (int i = 0; i < missileVector.size(); i++) {
if (missileVector[i].x > enemyShipFleet[k].x - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 &&
missileVector[i].x < enemyShipFleet[k].x + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 &&
missileVector[i].y > enemyShipFleet[k].y - (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2 &&
missileVector[i].y < enemyShipFleet[k].y + (ENEMYDIMENSION * ENEMYSHIPSCALE) / 2) {
missileVector[i].target = NULL;
missileVector.erase(missileVector.begin() + i);
enemyShipFleet[k].lives -= MISSILEDAMAGE;
if (enemyShipFleet[k].lives <= 0) {
createExplosion(explosion(), enemyShipFleet[k].x, enemyShipFleet[k].y, enemyShipFleet[k].rotation, 0.6f, 255, 255, 255);
for (int a = 0; a < pShipTargets.size(); a++) {
if (pShipTargets[a].ship == &enemyShipFleet[k]) {
//pShipTargets[a].ship = NULL;
//pShipTargets.erase(pShipTargets.begin() + a);
noOfLockedOn--;
break;
}
}
//pShipTargets[k].ship = NULL;
pShipTargets.erase(pShipTargets.begin() + k); //on the way to getting there. Fixes killing 1 guy and another green lock on showing hmm ///wont work with insects
enemyShipFleet.erase(enemyShipFleet.begin() + k);
for (int i = 0; i < pShipTargets.size(); i++) {
pShipTargets[i].ship = &enemyShipFleet[i];
}
totalEnemyShipKillsLevel++;
break;
}
else {
enemyShipFleet[k].ifHit = true;
enemyShipFleet[k].framesSinceHit = 0;
}
}
}
}
if (frameCount % 60 == 0 && enemyShipFleet.size() > 0) createBullet(false);
}
bool ThrowAbility::use() {
if (isOnCooldown()) {
return false;
}
SPtr<Scene> scene = gameObject.getScene().lock();
if (!scene) {
return false;
}
const glm::vec3 &position = gameObject.getCameraComponent().getCameraPosition();
const glm::vec3 &front = gameObject.getCameraComponent().getFrontVector();
const glm::vec3 &right = gameObject.getCameraComponent().getRightVector();
SPtr<GameObject> projectile(std::make_shared<GameObject>());
projectile->setPosition(position + front + right * 0.25f);
projectile->setScale(glm::vec3(PROJECTILE_SCALE));
// Graphics
SPtr<Model> playerModel = gameObject.getGraphicsComponent().getModel();
SPtr<Mesh> mesh = Context::getInstance().getAssetManager().loadMesh("meshes/rock_attack.obj");
glm::vec3 color(1.0f, 0.75f, 0.15f);
PlayerLogicComponent *playerLogic = dynamic_cast<PlayerLogicComponent*>(&gameObject.getLogicComponent());
if (playerLogic) {
color = playerLogic->getColor();
}
SPtr<Material> material(std::make_shared<PhongMaterial>(color * 0.2f, color * 0.6f, glm::vec3(0.2f), color * 0.2f, 50.0f));
SPtr<Model> model(std::make_shared<Model>(playerModel->getShaderProgram(), mesh));
model->attachMaterial(material);
projectile->setGraphicsComponent(std::make_shared<GeometricGraphicsComponent>(*projectile));
projectile->getGraphicsComponent().setModel(model);
// Physics
projectile->setPhysicsComponent(std::make_shared<MeshPhysicsComponent>(*projectile, 0.05f, CollisionGroup::Projectiles, CollisionGroup::Everything));
btRigidBody *projectileRigidBody = dynamic_cast<btRigidBody*>(projectile->getPhysicsComponent().getCollisionObject());
projectileRigidBody->setFriction(1.0f);
projectileRigidBody->setRollingFriction(0.25f);
projectileRigidBody->setRestitution(0.5f);
projectileRigidBody->applyCentralForce(toBt(front * 100.0f));
// Logic
SPtr<ProjectileLogicComponent> logic(std::make_shared<ProjectileLogicComponent>(*projectile));
WPtr<GameObject> wProjectile(projectile);
GameObject &creator = gameObject;
logic->setCollisionCallback([wProjectile, color, &creator](GameObject &gameObject, const btCollisionObject *objectCollidedWidth, const float dt) {
if (objectCollidedWidth == creator.getPhysicsComponent().getCollisionObject()) {
return;
}
SPtr<Scene> scene = gameObject.getScene().lock();
if (!scene) {
return;
}
SPtr<GameObject> projectile = wProjectile.lock();
if (!projectile) {
return;
}
scene->removeObject(projectile);
SPtr<GameObject> explosion(createExplosion(projectile->getPosition(), 1.0f, color));
scene->addLight(explosion);
scene->addObject(explosion);
});
projectile->setLogicComponent(logic);
// Audio
SPtr<AudioComponent> audioComponent(std::make_shared<AudioComponent>(*projectile));
audioComponent->registerSoundEvent(Event::SET_SCENE, SoundGroup::THROW);
projectile->setAudioComponent(audioComponent);
scene->addObject(projectile);
resetTimeSinceLastUse();
return true;
}