xref: /dports/games/spacejunk/spacejunk-1.0.5/src/starship.cpp

/*
  Copyright (C) 2009 Facundo Domínguez

  This file is part of Spacejunk.

  Spacejunk 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 3 of the License, or
  (at your option) any later version.

  Foobar 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "starship.h"
#include <math.h>
#include "runtimeopts.h"
#include "soundcollection.h"

#include <iostream>
#include <iomanip>

using namespace std;

extern SoundCollection * sounds;

// This is an interesting velocity (-sqrt(G*2.5e14),0)
Starship::Starship(const string & graphicid,Vector2d pos,Vector2d vel,real m,real w)
        :GameBody(graphicid,pos,vel,m,w),GraphicSeq(&flame), power(false), flame("flame") {
    maxFuel=timeToFuel(1000);
    fuel=maxFuel*0.8;
    shipMass=mass;
    mass+=fuel;
    setAngle(getAngle());
    flame.setFrame(flame.getImageCount());
    initcount=0;
};

void Starship::turn_on_engine() {
    if (power || fuel<=0)
        return;
    power=true;
    hold=true;
    setFrameSequence(0,flame.getImageCount()-1,false,true);
    if (sounds) {
        sounds->engineinit.play();
        initcount=150;
    }
}

void Starship::turn_off_engine() {
    if (!power)
        return;
    power=false;
    hold=false;
    setFrameSequence(flame.getImageCount()-1,0,false,false);
    if (sounds) {
        /*if (initcount)*/
        sounds->engineinit.stop();
        /*else*/
        sounds->engine.stop();
        sounds->engineend.play();
    }
}


//#define ANGLE_ACC 0.00005
#define ANGLE_VEL 0.5

// Velocity at which the fuel is fired
#define FUEL_VEL 3

// Rate of mass of fuel burned
#define MASS_PER_MILLISECOND 0.025

void Starship::turn_left() {
    w=-ANGLE_VEL;
}

void Starship::turn_right() {
    w=ANGLE_VEL;
}

void Starship::stop_turning() {
    w=0;
}

void Starship::setAngle(real a) {
    real x,y;
    sincos((a-90)*M_PI/180,&y,&x);
    dir.x=x;
    dir.y=y;
    GameBody::setAngle(a);
};

real Starship::timeToFuel(real delta) {
    return MASS_PER_MILLISECOND*delta;
};

real Starship::fuelToTime(real fuel) {
    return fuel/MASS_PER_MILLISECOND;
};

void Starship::stepShip(int delta) {
    stepSeq(delta);
    if (power) {
        real tempfuel=timeToFuel(delta);
        real oldfuel=fuel/maxFuel;
        if (fuel<=tempfuel) {
            setFuel(0);
            turn_off_engine();
        } else
            setFuel(getFuel()-tempfuel);
        if (sounds && oldfuel>=0.25 && 0.25>fuel/maxFuel)
            sounds->lowFuel.play(1);
        if (initcount>0 && sounds) {
            if (initcount<=int(delta)) {
                initcount=0;
                sounds->engine.play(-1);
            } else
                initcount-=delta;
        }
    }
}

Vector2d Starship::getDirection() {
    return dir;
}

Vector2d Starship::getAcceleration(real delta) {
    if (power) {
        if (fuel>0) {
            real tempfuel=timeToFuel(delta);
            if (fuel<tempfuel) {
                tempfuel=fuel;
                delta=fuelToTime(fuel);
            }
            real temp=MASS_PER_MILLISECOND/(mass-delta*MASS_PER_MILLISECOND)*FUEL_VEL;
            return dir*temp;
        };
    }
    return Vector2d();
}

void Starship::saveState() {
    GameBody::saveState();
}

PhysicBody * Starship::clone() {
    Starship *s=new Starship(*this);
    s->seqg=&s->flame;
    return s;
};

void Starship::copy(PhysicBody * pb) const {
    Starship *s=dynamic_cast<Starship*>(pb);
    *s=*this;
    s->seqg=&s->flame;
};

void Starship::collectTrash(GameBody* t) {
    collected.push_front(TrashData(t->mass));
    mass+=t->mass;
};

TrashData Starship::popTrash() {
    TrashData temp=collected.front();
    collected.pop_front();
    mass-=temp.mass;
    return temp;
};

int Starship::getTrashCount() {
    return collected.size();
};

void Starship::draw(int x,int y,real zoom,real angle) {
    flame.draw(int(x-dir.x*(getWidth()+7)*zoom),int(y-dir.y*(getWidth()+7)*zoom),zoom,angle);
    GameBody::draw(x,y,zoom,angle);
}

void Starship::setFuel(real fuel) {
    mass -= this->fuel;
    this->fuel = fuel;
    mass += fuel;
}

void Starship::setFuelNoMass(real fuel) {
    this->fuel = fuel;
}

real Starship::getFuel() {
    return fuel;
}