boolean RayGun::use(byte attackType)
{
this->attackType = attackType;
if(attackType==Player::ATTACK_A)
{
if(!active)
{
active = true;
if(ammo>0)
{
createProjectile(new Ray(getItemHolder(),x,y));
ammo--;
}
activeTime = Global::getWorldTime() + 500;
}
return true;
}
else if(attackType==Player::ATTACK_SIDEA)
{
if(!active)
{
active = true;
if(ammo>0)
{
createProjectile(new Ray(getItemHolder(),x,y));
ammo--;
}
activeTime = Global::getWorldTime() + 400;
}
return true;
}
return false;
}
Aircraft::Aircraft(Type type, const TextureHolder& textures, const FontHolder& fonts)
: Entity(Table[type].hitpoints)
, mType(type), mSprite(textures.get(Table[mType].texture), Table[mType].textRect),mHealthDisplay(nullptr)
, mTravelledDistance(0.f), mDirectionIndex(0), mIsFiring(false), mFireCountdown(sf::Time::Zero)
, mFireRateLevel(1), mFireCommand(), mSpreadLevel(1), mIsMarkedForRemoval(false)
, mMissileCommand(), mIsLaunchMissile(false), mMissileAmmo(2), mDropPickupCommand()
{
if (!isAllied())
mFireRateLevel = 0;
centerOrigin(mSprite);
std::unique_ptr<TextNode> healthDisplay(new TextNode(fonts, ""));
mHealthDisplay = healthDisplay.get();
attachChild(std::move(healthDisplay));
mFireCommand.category = Category::Scene;
mFireCommand.action = [this, &textures](SceneNode& node, sf::Time)
{
createBullet(node, textures);
};
mMissileCommand.category = Category::Scene;
mMissileCommand.action = [this, &textures] (SceneNode& node, sf::Time)
{
createProjectile(node, Projectile::Missile, 0.f, 0.5f, textures);
};
mDropPickupCommand.category = Category::Scene;
mDropPickupCommand.action = [this, &textures] (SceneNode& node, sf::Time)
{
createPickup(node, textures);
};
}
void ProjectileWeapon::fireBurst()
{
if(getAmmoType()!=ammo_unlimited)
{
if(ammo==0)
return;
ammo--;
owner->weapons.updateWeapons();
}
Position ownerPos(owner->getPosition());
const Position *shotOffsets = owner->type->getWeaponMounts(numProjectiles());
doSound();
for(unsigned ii=0; ii<numProjectiles(); ii++)
if(linkedFire() || ii==fireOrder)
{
Position shotPosition(ownerPos);
shotPosition.setX(ownerPos.getX() + shotOffsets[ii].getX()*cos(ownerPos.getR()) + shotOffsets[ii].getY()*sin(ownerPos.getR()));
shotPosition.setY(ownerPos.getY() - shotOffsets[ii].getX()*sin(ownerPos.getR()) + shotOffsets[ii].getY()*cos(ownerPos.getR()));
shotPosition.setR_vel(0);
if(!shotsGetShipVel) {
shotPosition.setX_vel(0);
shotPosition.setY_vel(0);
}
shotPosition.impulse( getSpeed()*cos(shotPosition.getR()), -getSpeed()*sin(shotPosition.getR()) );
createProjectile(&shotPosition);
}
fireOrder++;
if(fireOrder >= numProjectiles())
fireOrder = 0;
}
static cpSpace *initSpace(void) {
int i;
cpBody *staticBody;
cpShape *shape;
cpVect cannonPos;
cpResetShapeIdCounter();
g_Space = cpSpaceNew();
g_Space->iterations = 30;
g_Space->gravity = cpv(0, -300);
staticBody = &g_Space->staticBody;
shape = cpSpaceAddShape(g_Space, cpSegmentShapeNew(staticBody, cpv(-400,-290), cpv(-400,300), 0.0f));
shape->e = 1.0f; shape->u = 0.0f;
shape->collision_type = PLATFORM_TYPE;
cannonPos = cpv(-350, -215);
g_Cannon = createCannon(cannonPos, 30.0f, 6.0f);
g_Cannon->ai = 0;
for (i = 0; i < MAX_PROJECTILES; ++i) {
g_Cannon->ammo[i] = createProjectile(6.0f, 1.0f);
}
platforms[0] = createPlatform(staticBody, cpv(-390, -240), cpv(1600, -240), 10.0f);
fprintf(stderr, "Loading dominoes disabled\n");
InitializeDominoes();
cpSpaceAddCollisionHandler(g_Space, PROJECTILE_TYPE, DOMINO_OBJECT_TYPE,
NULL, NULL, postSolveProjectileDomino, NULL, NULL);
return g_Space;
}
Aircraft::Aircraft(Type type, const TextureHolder& textures, const FontHolder& fonts)
: Entity(Table[type].hitpoints)
, mType(type)
, mFireCommand()
, mMissileCommand()
, mFireCountdown(sf::Time::Zero)
, mIsFiring(false)
, mIsLaunchingMissile(false)
, mShowExplosion(true)
, mSpawnedPickup(false)
, mSprite(textures.get(Table[type].texture), Table[type].textureRect)
, mExplosion(textures.get(Textures::Explosion))
, mFireRateLevel(1)
, mSpreadLevel(1)
, mMissileAmmo(2)
, mDropPickupCommand()
, mTravelledDistance(0.f)
, mDirectionIndex(0)
, mMissileDisplay(nullptr)
{
mExplosion.setFrameSize(sf::Vector2i(256, 256));
mExplosion.setNumFrames(16);
mExplosion.setDuration(sf::seconds(1));
centerOrigin(mSprite);
centerOrigin(mExplosion);
mFireCommand.category = Category::SceneAirLayer;
mFireCommand.action = [this, &textures] (SceneNode& node, sf::Time)
{
createBullets(node, textures);
};
mMissileCommand.category = Category::SceneAirLayer;
mMissileCommand.action = [this, &textures] (SceneNode& node, sf::Time)
{
createProjectile(node, Projectile::Missile, 0.f, 0.5f, textures);
};
mDropPickupCommand.category = Category::SceneAirLayer;
mDropPickupCommand.action = [this, &textures] (SceneNode& node, sf::Time)
{
createPickup(node, textures);
};
std::unique_ptr<TextNode> healthDisplay(new TextNode(fonts, ""));
mHealthDisplay = healthDisplay.get();
attachChild(std::move(healthDisplay));
if (getCategory() == Category::PlayerAircraft)
{
std::unique_ptr<TextNode> missileDisplay(new TextNode(fonts, ""));
missileDisplay->setPosition(0, 70);
mMissileDisplay = missileDisplay.get();
attachChild(std::move(missileDisplay));
}
updateTexts();
}
void initProjectileBuffer(int pSramBulletBuffer) {
int x, y;
for(x = 0; x < (ALIEN_COLS * ALIEN_WIDTH); x++) {
for(y = 0; y < VOID_HEIGHT; y++) {
struct Projectile empty = createProjectile(0, 0, 0, 0);
setProjectile(pSramBulletBuffer, x, y, empty);
}
}
}
void RugbyManAttack::Attack2()
{
int centerX = (this->getComposition()->getX() + (this->getComposition()->getWidth() / 2));
int centerY = (this->getComposition()->getY() + (this->getComposition()->getHeight() / 2));
GameComponents::SpriteComponent *sprite = reinterpret_cast<GameComponents::SpriteComponent*>(getComposition()->getComponent(GameComponents::SPRITE));
glm::vec2 direction = glm::vec2(100.0, 100.0);
if (sprite->revertX) direction = glm::vec2((-60 + centerX) - centerX, (-40 + centerY) - centerY);
else direction = glm::vec2((60 + centerX) - centerX, (-40 + centerY) - centerY);
createProjectile(getComposition(), GameObjects::DROP, 1.0f, glm::normalize(direction), "./assets/sprite/rugby_ball.png");
this->composition->sendMessage(new GameMessage::Message(GameMessage::BASEBALL_SHOOT));
}
void Dragon::update()
{
time = ofGetElapsedTimeMillis() - startTime;
spawnTime = ofGetElapsedTimeMillis() - spawnstartTime;
dragon.update(1.0f/60);
updateHeadPosition();
createProjectile();
dragonBehaviour();
removeProjectiles();
}
void SmashBall::hitSmashBall(Player*collide, byte dir)
{
Console::WriteLine((String)"" + health);
if(((int)collide->getAttacksPriority()) == 4)
{
health-=3;
changeAnimation("hit", FORWARD);
}
else if(((int)collide->getAttacksPriority()) == 5)
{
health-=1;
changeAnimation("hit", FORWARD);
}
else if(((int)collide->getAttacksPriority()) == 6)
{
health-=2;
changeAnimation("hit", FORWARD);
}
else if(collide->getAttacksPriority() > 0)
{
health-=(int)(collide->getAttacksPriority());
changeAnimation("hit", FORWARD);
}
if(collide->getPlayerNo()>0)
{
if(health<=0 && active)
{
active=false;
readyFire = new Projectile(collide->getPlayerNo(), collide->x,collide->y);
readyFire->addAnimation(new Animation("normal",1,"Images/Game/Items/SmashBall/finalsmash_fire.png"));
readyFire->changeAnimation("normal", FORWARD);
readyFire->setAlpha(0.278f);
readyFire->setLayer(Projectile::LAYER_MIDDLEUPPER);
createProjectile(readyFire);
collide->pickUpItem(this);
}
}
}
void Skulls::skullBehaviour()
{
if (spawntime > 120000)
{
GlobalData::enemyType = "skull";
if (skullPos.x < ofGetWidth()/2 || skullPos.x > ofGetWidth()/2)
skullPos.x +=1;
else
{
createProjectile();
if (spawntime >= 155000)
skullPos.x +=1;
}
skull.setPosition(skullPos);
if (skullPos.x >= ofGetWidth()+500)
{
spawnstartTime = ofGetElapsedTimeMillis();
skullPos.x =-500;
GlobalData::enemyType = "dragon";
}
}
}
void Aircraft::createBullet(SceneNode &node, const TextureHolder &textures) const
{
Projectile::Type type = isAllied() ? Projectile::AlliedBullet : Projectile::EnemyBullet;
switch (mSpreadLevel)
{
case 1:
createProjectile(node, type, 0.0f, 0.5f, textures);
break;
case 2:
createProjectile(node, type, -0.33f, 0.33f, textures);
createProjectile(node, type, 0.33f, 0.33f, textures);
break;
case 3:
createProjectile(node, type, -0.33f, 0.33f, textures);
createProjectile(node, type, 0.0f, 0.5f, textures);
createProjectile(node, type, 0.33f, 0.33f, textures);
break;
}
}
void inputActionGame(Input *in,float *move_left,float *move_right,int *jump,int *pause, Character *player, int *acceleration, SDLKey *kc,projectileSet *ps)
{
/*left move*/
if((in->key[kc[L]] || (in->isJoystick&&(in->hat[0] == SDL_HAT_LEFT)))
&& (player->dirY < (-JUMP_HEIGHT + 7) || (player->doubleJump == 0 && player->isOnGround)))
*move_left = 1;
if((!(in->key[kc[L]] || (in->isJoystick&&(in->hat[0]==SDL_HAT_LEFT && in->axes[0]>-10000))) && player->isOnGround)||player->wallJump == 3)
*move_left = 0;
if(in->isJoystick&&(in->axes[0] < - 10000))
{
*move_left = ABS(in->axes[0])*MAX_SPEED/32000;
}
/*right move*/
if((in->key[kc[R]] || (in->isJoystick&&(in->hat[0] == SDL_HAT_RIGHT)))
&& (player->dirY < (-JUMP_HEIGHT + 7) || (player->doubleJump == 0 && player->isOnGround)))
*move_right = 1;
if((!(in->key[kc[R]] || (in->isJoystick&&(in->hat[0]==SDL_HAT_RIGHT && in->axes[0]<10000))) && player->isOnGround)|| player->wallJump == 3)
*move_right = 0;
if(in->isJoystick&&in->axes[0] > 10000)
{
*move_right = ABS(in->axes[0])*MAX_SPEED/32000;
}
/*jump*/
if(in->key[kc[J]] || (in->isJoystick&&in->button[A]))
{
*jump = 1;
}
if((in->key[kc[J]] || (in->isJoystick&&in->button[A])) && player->wallJump == 1
&& (in->key[kc[R]] || (in->isJoystick&&(in->hat[0] == SDL_HAT_RIGHT || in->axes[0] > 10000))) && !in->space)
*jump = 3;
if((in->key[kc[J]] || (in->isJoystick&&in->button[A])) && player->wallJump == 2
&& (in->key[kc[L]] || (in->isJoystick&&(in->hat[0] == SDL_HAT_LEFT || in->axes[0] < -10000))) && !in->space)
*jump = 4;
if((player->location.x < 17 && *jump >0 ))
*jump = 0;
if((!in->key[kc[J]] && (!in->isJoystick||!in->button[A])) && *(jump)==1)
{
*jump = 2;
if(!player->doubleJump)
player->doubleJump = 1;
}
else if((!in->key[kc[J]] && (!in->isJoystick||!in->button[A])) && (*jump==2 || *jump==0 || *jump == 3 || *jump == 4))
*jump = 0;
/*pause*/
if(in->key[kc[3]] || (in->isJoystick&&in->button[START]))
*pause = 1;
/*acceleration*/
if ((!in->key[kc[R]] && !in->key[kc[L]]
&& in->isJoystick&&(in->hat[0] == SDL_HAT_CENTERED)) && player->isOnGround)
*acceleration = 0;
/* projectiles */
if((in->key[kc[H]] || (in->isJoystick&&in->button[R1])) && player->nbProjectile > 0)
{
if(!ps->projectileThrown)
{
if(player->isRight)
createProjectile(ps,"hammer",RIGHT,player->location.x+player->location.w+1,player->location.y+player->location.h/2-11,0);
else
createProjectile(ps,"hammer",LEFT,player->location.x-1,player->location.y+player->location.h/2-11,0);
ps->projectileThrown = 1;
if(--player->nbProjectile <= 0)
player->nbProjectile = 0;
}
}
else
ps->projectileThrown = 0;
if(in->key[SDLK_SPACE] || (in->isJoystick&&in->button[A]))
in->space = 1;
else
in->space = 0;
}
void Turret::shoot (bool playerControlled, Player* targetPlayer)
{
if (data && data->isSustained == false) {
if (data && data->projectile.type == -1)
{
if (!isGhost())
if (const char* script = scriptName("onFire"))
Console->executef(2, script, scriptThis());
}
else
{
float energy = getEnergy();
if (waitTime <= manager->getCurrentTime() && data && energy >= data->minGunEnergy && data->projectile.type != -1)
{
TMat3F muzzleTransform;
getMuzzleTransform(0, &muzzleTransform);
Projectile* bullet = createProjectile(data->projectile);
if (!playerControlled && data->deflection)
{
static Random random;
EulerF angles;
muzzleTransform.angles (&angles);
angles.x += (random.getFloat() - 0.5) * M_2PI * data->deflection;
angles.z += (random.getFloat() - 0.5) * M_2PI * data->deflection;
muzzleTransform.set (angles, muzzleTransform.p);
}
else
if (playerControlled)
{
Point3F start = muzzleTransform.p;
muzzleTransform = getEyeTransform ();
aimedTransform (&muzzleTransform, start);
muzzleTransform.p = start;
}
bullet->initProjectile (muzzleTransform, Point3F (0, 0, 0), getId());
if (bullet->isTargetable() == true) {
if (targetPlayer != NULL) {
if (GameBase* mo = targetPlayer->getMountObject())
bullet->setTarget(static_cast<ShapeBase*>(mo));
else
bullet->setTarget(targetPlayer);
} else if (playerControlled) {
ShapeBase* pClosest = NULL;
Point3F closeHisPos;
float closestVal = -2.0f;
SimSet::iterator itr;
Point3F lookDir;
getEyeTransform().getRow(1, &lookDir);
lookDir.normalize();
SimContainerQuery collisionQuery;
SimCollisionInfo info;
collisionQuery.id = getId();
collisionQuery.type = -1;
collisionQuery.mask = Projectile::csm_collisionMask;
collisionQuery.detail = SimContainerQuery::DefaultDetail;
collisionQuery.box.fMin = getEyeTransform().p;
SimContainer* pRoot = (SimContainer*)manager->findObject(SimRootContainerId);
SimSet* pSet = dynamic_cast<SimSet*>(manager->findObject(PlayerSetId));
AssertFatal(pSet != NULL, "No player set?");
for (itr = pSet->begin(); itr != pSet->end(); itr++) {
Player* pPlayer = dynamic_cast<Player*>(*itr);
if (!pPlayer || pPlayer->getVisibleToTeam(getTeam()) == false)
continue;
collisionQuery.box.fMax = pPlayer->getBoxCenter();
if (pRoot->findLOS(collisionQuery, &info, SimCollisionImageQuery::High) == true) {
if (info.object != (SimObject*)pPlayer)
continue;
}
Point3F hisPos = pPlayer->getBoxCenter();
hisPos -= getLinearPosition();
hisPos.normalize();
float prod = m_dot(hisPos, lookDir);
if (prod > 0.0f && prod > closestVal) {
closestVal = prod;
pClosest = pPlayer;
closeHisPos = hisPos;
}
}
pSet = dynamic_cast<SimSet*>(manager->findObject(MoveableSetId));
AssertFatal(pSet != NULL, "No moveable set?");
for (itr = pSet->begin(); itr != pSet->end(); itr++) {
if (((*itr)->getType() & VehicleObjectType) == 0)
continue;
ShapeBase* pObject = dynamic_cast<ShapeBase*>(*itr);
if (pObject->getVisibleToTeam(getTeam()) == false)
continue;
collisionQuery.box.fMax = pObject->getBoxCenter();
if (pRoot->findLOS(collisionQuery, &info, SimCollisionImageQuery::High) == true) {
if (info.object != (SimObject*)pObject)
continue;
}
Point3F hisPos = pObject->getBoxCenter();
hisPos -= getLinearPosition();
hisPos.normalize();
float prod = m_dot(hisPos, lookDir);
if (prod > 0.0f && prod > closestVal) {
closestVal = prod;
closeHisPos = hisPos;
pClosest = pObject;
}
}
// We need to find the current FOV, and take the percentage of
// it specified in the .dat file for this turret. Only if the
// do product is greater than this, do we allow the target to
// be set...
//
float myFov = (fov / 2.0) * data->targetableFovRatio;
float compCos = cos(myFov);
if (compCos > 0.996f) // hack for single precision math. It's very
compCos = 0.996; // hard to get more precise answers from the dot prod.
if (pClosest != NULL && closestVal > compCos)
bullet->setTarget(pClosest);
}
}
if (data->maxGunEnergy)
{
float e;
e = energy > data->maxGunEnergy ? data->maxGunEnergy : energy;
float pofm = e / float(data->maxGunEnergy);
bullet->setEnergy (e, pofm);
energy -= e;
setEnergy (energy);
}
SimGroup *grp = NULL;
if(SimObject *obj = manager->findObject("MissionCleanup"))
grp = dynamic_cast<SimGroup*>(obj);
if(!manager->registerObject(bullet))
delete bullet;
else
{
if(grp)
grp->addObject(bullet);
else
manager->addObject(bullet);
}
waitTime = manager->getCurrentTime() + data->reloadDelay;
if (animThread)
{
setFireThread ();
animThread->SetPosition (0.0);
}
fireCount++;
setMaskBits (ShootingMask);
}
}
} else {
if (data && data->projectile.type == -1) {
if (!isGhost())
if (const char* script = scriptName("onFire"))
Console->executef(2, script, scriptThis());
}
else {
float energy = getEnergy();
if (waitTime <= manager->getCurrentTime() && data && energy >= data->minGunEnergy && data->projectile.type != -1) {
TMat3F muzzleTransform;
getMuzzleTransform(0, &muzzleTransform);
Projectile* bullet = createProjectile(data->projectile);
if (!playerControlled && data->deflection) {
static Random random;
EulerF angles;
muzzleTransform.angles (&angles);
angles.x += (random.getFloat() - 0.5) * M_2PI * data->deflection;
angles.z += (random.getFloat() - 0.5) * M_2PI * data->deflection;
muzzleTransform.set (angles, muzzleTransform.p);
} else if (playerControlled) {
Point3F start = muzzleTransform.p;
muzzleTransform = getEyeTransform ();
aimedTransform (&muzzleTransform, start);
muzzleTransform.p = start;
}
bullet->initProjectile (muzzleTransform, Point3F (0, 0, 0), getId());
AssertFatal(bullet->isSustained() == true, "Error, must be sustained bullet");
SimGroup *grp = NULL;
if(SimObject *obj = manager->findObject("MissionCleanup"))
grp = dynamic_cast<SimGroup*>(obj);
if(!manager->registerObject(bullet))
delete bullet;
else
{
if(grp)
grp->addObject(bullet);
else
manager->addObject(bullet);
}
if (animThread) {
setFireThread ();
animThread->SetPosition (0.0);
}
fireCount++;
setMaskBits (ShootingMask);
m_fireState = Firing;
m_beganState = wg->currentTime;
m_pProjectile = bullet;
m_pTarget = targetPlayer;
if (m_pTarget)
deleteNotify(m_pTarget);
}
}
}
}
void Ship::createBullets(SceneNode& node, const TextureHolder& textures) const
{
Projectile::Type type = Projectile::AlliedBullet;
createProjectile(node, type, 0.0f, 0.0f, textures);
}
