/*** This should be called when Objects colided. If 1/2 of the object height is > the other objects minY
it will hurt the other object with damage dmg.***/
void EnemyObject::simpleWalkerHurt(GameObject* pPlayer, const uint32_t otherType) {
auto player = pPlayer->getHitbox();
auto rThis = getHitbox();
if (rThis->getMidY() > player->getMinY()) {
pPlayer->hurt(dmg, Vec2(getVelocityX(), fSimpleHurtForce));
}
}
void Mogh::collision(gen::Sprite* other, gen::World* w){
if(Troll* ch = dynamic_cast<Troll*>(other)){
damaged = true;
setCurrentAnimationVector("DAMAGED");
setHealth(getHealth() - 10);
setTimer( SDL_GetTicks() + 2000 );
setCollidable(false);
setVelocityX(getVelocityX()*2);
setVelocityY(getVelocityY()*2);
}
else if(gen::Object* o = dynamic_cast<gen::Object*>(other)){
std::string direction = getKeyOfCurrentAnimationVector();
if(direction == "LEFT"){
setMovementX(getVelocityX());
moveX(w);
}
else if(direction == "RIGHT"){
setMovementX(-getVelocityX());
moveX(w);
}
else if(direction == "BACK"){
setMovementY(getVelocityY());
moveY(w);
}
else if(direction == "FRONT"){
setMovementY(-getVelocityY());
moveY(w);
}
}
else if(SeaStar* s = dynamic_cast<SeaStar*>(other)){
damaged = true;
setCurrentAnimationVector("DAMAGED");
setHealth(getHealth() - s->getDamage());
setTimer( SDL_GetTicks() + 2000 );
setCollidable(false);
setVelocityX(getVelocityX()*2);
setVelocityY(getVelocityY()*2);
}
}
void Ground::update(int deltaTime)
{
setOffsetX(getOffsetX() - (getVelocityX() * (deltaTime/1000.0f)));
//cout << "Ground Offset X: " << getOffsetX() << endl;
if (getOffsetX() <= -808.0f)
{
setOffsetX(0.0f);
}
//Shift the collision boxes
shiftCollisionBoxes();
}
//A stupid Walk algorithm. Change Direction When The Objects X-velocity is == 0
void EnemyObject::stupidWalk(const float delta) {
if (getVelocityX() == 0) {
if (getPrevDir() == GO_LEFT) {
setVelocityX(speed);
setPrevDir(GO_RIGHT);
objectSprite->setScaleX(1 * abs(objectSprite->getScale()));;
}
else {
setVelocityX(-speed);
setPrevDir(GO_LEFT);
objectSprite->setScaleX(-1 * abs(objectSprite->getScale()));;
}
}
}
void UfoObject::deadState(){
HP = 0;
plingSFX->play(0.3f);
addGravityToObject(true);
this->bWallCollisions = false;
setVelocityY(70);
this->unschedule(schedule_selector(UfoObject::AIUpdate));
this->unschedule(schedule_selector(UfoObject::update));
removeWhenBelowZero();
setVelocityX(getVelocityX()*0.1);
setVelocityY(getVelocityY()*0.1);
objectSprite->setRotation(25);
dropCoin(3);
}
/*** Add this function to the objects update function to make it turn at edges. This Algorithm was not designed For slopes.
If the objects path includes slopes use a predefined zone instead***/
void EnemyObject::turnAtEdge(const float delta) {
const float lookAhead = 0.5f*getVelocityX() / delta;
auto const hitbox = getHitbox();
if (!isBlocked((uint32_t)((hitbox->getMidX() + lookAhead) / 16.0), (uint32_t)(hitbox->getMinY() - 1) / 16.0)) {
if (getPrevDir() == GO_LEFT) {
setVelocityX(speed);
setPrevDir(GO_RIGHT);
objectSprite->setScaleX(1);
}
else {
setVelocityX(-speed);
setPrevDir(GO_LEFT);
objectSprite->setScaleX(-1);
}
}
}
void Mogh::tick(gen::GameEngine* ge){
if(getHealth() < 1){
SDL_Flip(gen::global.screen);
SDL_Delay(4000);
ge->setGameOver(true);
return;
}
if(damaged){
if(SDL_GetTicks() > getTimer()){
setCollidable(true);
setVelocityX(getVelocityX()/2);
setVelocityY(getVelocityY()/2);
damaged = false;
}
}
Hero::tick(ge);
if(hpText == 0){
hpText = gen::Text::createText("c:\\WINDOWS\\Fonts\\arial.ttf", 30, "0", 0, 0, 0);
hpText->setPositions(10, 10);
}
std::stringstream s;
s << "HP: ";
s << getHealth();
hpText->setMessage(s.str());
if(amountKilled == 0){
amountKilled = gen::Text::createText("c:\\WINDOWS\\Fonts\\arial.ttf", 30, "0", 0, 0, 0);
amountKilled->setPositions(200, 10);
}
std::stringstream s2;
s2 << "Killscore: ";
s2 << Character::getAmountRemoved();
amountKilled->setMessage(s2.str());
hpText->tick(ge);
amountKilled->tick(ge);
}
void Enemy::updateMovement(float timeStep) {
//Get target X,Y so we can ignore sprite sizes
int targetYCompare = (int)(currentTarget->getY() - ((getHeight() - currentTarget->getHeight()) / 2.f));
int targetXCompare = (int)(currentTarget->getX() - ((getWidth() - currentTarget->getWidth()) / 2.f));
bool tmp_movingY = m_movingY;
bool tmp_movingX = m_movingX;
float delta_x = 0.0;
float delta_y = 0.0;
//Move vertical
if( tmp_movingY &&
((getY() < targetYCompare - (config::W_HEIGHT / m_diagonalSensitivity)) ||
(getY() > targetYCompare + (config::W_HEIGHT / m_diagonalSensitivity))
))
tmp_movingX = true;
if ( tmp_movingX &&
((getX() < targetXCompare - (config::W_WIDTH / m_diagonalSensitivity)) ||
(getX() > targetXCompare + (config::W_WIDTH / m_diagonalSensitivity))
))
tmp_movingY = true;
if(tmp_movingY && (getY() == targetYCompare)) tmp_movingX = true;
if(tmp_movingX && (getX() == targetXCompare)) tmp_movingY = true;
if(tmp_movingY) {
if ( getY() < targetYCompare ) {
delta_y += (getVelocityY() * timeStep);
if ( (getY() + delta_y) + getHeight() > config::W_HEIGHT) {
setY(static_cast<float>(config::W_HEIGHT - getHeight())); //Prevent from going out of screen
delta_y = 0.0;
}
if ( (getY() + delta_y) > targetYCompare) {
setY(float(targetYCompare));
delta_y = 0.0;
}
if (tmp_movingX == false) {
m_direction = DOWN;
}
} else if ( getY() > targetYCompare) {
delta_y -= (getVelocityY() * timeStep);
if ( (getY() + delta_y) < 0) {
setY(0);
delta_y = 0.0;
}
if ( (getY() + delta_y) < targetYCompare) {
setY(float(targetYCompare));
delta_y = 0.0;
}
if( tmp_movingX == false ) {
m_direction = UP;
}
}
}
//Move horizontal
if(tmp_movingX) {
if (getX() < targetXCompare) {
delta_x += (getVelocityX() * timeStep);
if ( (getX() + delta_x) + getWidth() > config::W_WIDTH) {
setX(static_cast<float>(config::W_WIDTH - getWidth()));
delta_x = 0.0;
}
if ( (getX() + delta_x) > targetXCompare) {
setX(float(targetXCompare));
delta_x = 0.0;
}
if( tmp_movingY == false ) {
m_direction = RIGHT;
}
} else if (getX() > targetXCompare) {
delta_x -= (getVelocityX() * timeStep);
if ( (getX() + delta_x) < 0) {
setX(0);
delta_x = 0.0;
}
if ( (getX() + delta_x) < targetXCompare) {
setX(float(targetXCompare));
delta_x = 0.0;
}
if( tmp_movingY == false ) {
m_direction = LEFT;
}
}
}
// Update the calculated position
if (delta_x != 0.0 && delta_y != 0.0 && !config::OLD_DIAGONAL_SPEED) {
/* Going to explain the multiplier value here
* |
* / |
* sqrt(2*2 + 3*3)/ |
* / | 3
* / |
* / - - - - |
* 2
* And the value I want is ((2+3)/2) / sqrt(2*2 + 3*3)
* which is : 2.5 / sqrt(13)
* 2.5 / 3.605551275463989 = 0.69~
* However in our case we can assume the enemy always moves with equal speed in both X and Y,
* because FPS::FPSControl.GetSpeedFactor() doesn't change between the modifications of delta_x and delta_y.
* The formula would look like (x / sqrt( 2(x*x) )
* ... which is 0.7071067811865475.
*/
/*
float d = abs(delta_x);
float multiplier = d / sqrt(2*(d*d));
*/
float multiplier = 0.7071068f; //fast-forward to answer, skipping calculation
delta_x *= multiplier;
delta_y *= multiplier;
}
setX(getX() + delta_x);
setY(getY() + delta_y);
}
void testCannonball()
{
const double feilmargin = 0.0001;
//AcclX
assert(avvik(0.0,
acclX()) < feilmargin);
//AcclY
assert(avvik(-9.81,
acclY()) < feilmargin);
//velX
assert(avvik(50.0,
velX(50.0, 0)) < feilmargin);
assert(avvik(50.0,
velX(50.0, 2.5)) < feilmargin);
assert(avvik(50.0,
velX(50.0, 5.0)) < feilmargin);
//velY
assert(avvik(25.0,
velY(25.0, 0)) < feilmargin);
assert(avvik(0.475,
velY(25.0, 2.5)) < feilmargin);
assert(avvik(-24.05,
velY(25.0, 5.0)) < feilmargin);
//velIntY
assert(avvik(25.0,
velIntY(25.0, 0)) < feilmargin);
assert(avvik(0.475,
velIntY(25.0, 2.5)) < feilmargin);
assert(avvik(-24.05,
velIntY(25.0, 5.0)) < feilmargin);
//posX
assert(avvik(0.0,
posX(50.0, 0)) < feilmargin);
assert(avvik(125.0,
posX(50.0, 2.5)) < feilmargin);
assert(avvik(250.0,
posX(50.0, 5.0)) < feilmargin);
//posIntX
assert(avvik(0.0,
posIntX(50.0, 0)) < feilmargin);
assert(avvik(125.0,
posIntX(50.0, 2.5)) < feilmargin);
assert(avvik(250.0,
posIntX(50.0, 5.0)) < feilmargin);
//posY
assert(avvik(0.0,
posY(25.0, 0)) < feilmargin);
assert(avvik(31.84,
posY(25.0, 2.5)) < feilmargin);
assert(avvik(2.375,
posY(25.0, 5.0)) < feilmargin);
//posIntY
assert(avvik(0.0,
posIntY(25.0, 0)) < feilmargin);
assert(avvik(31.84,
posIntY(25.0, 2.5)) < feilmargin);
assert(avvik(2.375,
posIntY(25.0, 5.0)) < feilmargin);
//flightTime
assert(avvik(2.03874,
flightTime(10.0)) < feilmargin);
//getVelocityX
assert(avvik(7.071067812, getVelocityX(
asin(1) / 2, 10.0
)) < feilmargin);
//getVelocityY
assert(avvik(7.071067812, getVelocityY(
asin(1) / 2, 10.0
)) < feilmargin);
//getDistanceTraveled
assert(avvik(20.3874, getDistanceTraveled(
10.0, 10.0
)) < feilmargin);
//optimalAngleForMaxDistance
assert(avvik(0.7853981634, optimalAngleForMaxDistance(
10.0
)) < feilmargin);
//getDistanceTraveled
assert(avvik(-0.3874, targetPractice(
20.0, 10.0, 10.0
)) < feilmargin);
}