PXEngine.jack

// Physics Engine
// Handles the movement and collisions of physical objects

class PXEngine {

  field Settings settings;
  field ObjectManager OM;
  field AdvancedMath mathEngine;


  constructor PXEngine new(Settings gameSettings, AdvancedMath newmx, ObjectManager newOM) {
    var int i;

    let settings=gameSettings;
    let OM=newOM;
    let mathEngine=newmx;

    return this;
  }

  method void applyAcceleration(Attributes att, int accelerationValue, int direction) {
    // Adds an acceleration to the existing acceleration
    var int xComp, yComp;
    var int previousX, previousY;

    do att.backup();
    do att.setNeedsUpdate(true);

    let xComp = (mathEngine.sin100(direction)/10 * accelerationValue) /10;
    let yComp = (mathEngine.cos100(direction)/10 * accelerationValue*-1) /10;

    let previousX = att.getAx();
    let previousY = att.getAy();

    do att.setAcceleration(previousX+xComp, previousY+yComp);

    return;
  }

  method void applyCartesianAcceleration(Attributes att, int xComp, int yComp) {
    // Adds an acceleration to the existing acceleration, using x and y components to
    // skip the sine lookup
    var int previousX, previousY;


    do att.backup();
    do att.setNeedsUpdate(true);

    let previousX = att.getAx();
    let previousY = att.getAy();

    do att.setAcceleration(previousX+xComp, previousY+yComp);
    return;
  }

  method void applyRotation(Attributes att, int rotation) {
    do att.backup();
    do att.setNeedsUpdate(true);
    let rotation = rotation + att.getRotation();
    do att.setRotation(rotation);
    return;
  }




  method void stepForward(int timeDelta) {
    // applies accelerations and velocitys to physical objects
    // over a period of timeDelta
    var int i, x1, y1, x2, y2;
    var Bullet thisBullet;
    var int friction10;
    var Attributes currentAttributes;
    var Player playerSpecimen;

    // we're going to divide by a modifier here because a 10 millisecond
    // frame delay might not be what we want for a physics time delta.
    let timeDelta = timeDelta / settings.getphysicsTimeStepModifier();
    let friction10=settings.getSpaceFriction() *timeDelta;

    // do the players
    let i = 0;
    while( ~(OM.getPlayer(i)=0) ) {
      let playerSpecimen=OM.getPlayer(i);
      let currentAttributes = playerSpecimen.getAttributes();


      // Apply accelerations
      let x1 = currentAttributes.getAx();
      let y1 = currentAttributes.getAy();
      let x2 = currentAttributes.getVx();
      let y2 = currentAttributes.getVy();

      // but only apply them if there is something to apply
      if ( ~(x1=0) | ~(x2=0) | ~(y1=0) | ~(y2=0) ){

        // first, apply space friction
        let x2= ((x2*1*friction10)/10);
        let y2= ((y2*1*friction10)/10);


        do currentAttributes.backup();
        do currentAttributes.setNeedsUpdate(true); // redraw on next frame

        do currentAttributes.setVelocity( (x1*timeDelta) + x2,
                            (y1*timeDelta) + y2 );
        // and reset accelerations now that we've applied them.
        do currentAttributes.setAcceleration(0,0);

        // Apply velocitys
        let x1 = currentAttributes.getPx();
        let y1 = currentAttributes.getPy();
        // x2 and y2 already have velocitys assigned
        do currentAttributes.setCoordinates( (x2*timeDelta) + x1,
                               (y2*timeDelta) + y1 );
      }
      let i=i+1;
    }

    // now do the bullets
    let i = 0;
    while( ~(OM.getBullet(i)=0)) {
      let currentAttributes = OM.getBulletAttributes(i);

      // apply gravitation field accelerations
      do applyGravitationalField(currentAttributes);

      // Apply accelerations to velocities
      let x1 = currentAttributes.getAx();
      let y1 = currentAttributes.getAy();
      let x2 = currentAttributes.getVx();
      let y2 = currentAttributes.getVy();

      // no space friction for bullets!

      do currentAttributes.backup();
      do currentAttributes.setNeedsUpdate(true); // redraw on next frame

      do currentAttributes.setVelocity( (x1*timeDelta) + x2,
                          (y1*timeDelta) + y2 );
      // and reset accelerations now that we've applied them.
      do currentAttributes.setAcceleration(0,0);

      // Apply velocitys
      let x1 = currentAttributes.getPx();
      let y1 = currentAttributes.getPy();
      // x2 and y2 already have velocitys assigned
      do currentAttributes.setCoordinates( (x2*timeDelta) + x1,
                             (y2*timeDelta) + y1 );
      let i=i+1;
    }


    return;
  }

  method bool detectCollision(bool executeKill) {
    // returns true if there are overlapping objects.
    // when executeKill is true, this function will set the
    // isDead flag on every attribute that is party to a collision
    var int i,j, res, dist;
    var int x1, y1, x2, y2;
    var int r1, r2;
    var bool collisionOccured;
    var Attributes att1, att2;

    let i=0;
    let att1 = OM.getAttributes(i);
    let collisionOccured = false;

    // iterate throuh all objects.
    while (~(att1=0) ) {
      let x1=att1.getPx();
      let y1=att1.getPy();
      let r1=att1.getRadius();

      let j=0;
      let att2 = OM.getAttributes(j);

      // check against all other objects (skipping itself)
      // also, skip dead objects.
      while( ~(att2=0) & ~(j=i) ) {
        let x2=att2.getPx();
        let y2=att2.getPy();
        let r2=att2.getRadius();

        if ( ~(att1.getIsDead()) & ~(att2.getIsDead()) ) {
          let dist = getDistance(x1,y1,x2,y2,r1+r2);
          if (dist < (r1+r2)) {
            let collisionOccured=true;

            if (executeKill) {
              // add velocities together to make cooler explosions. (but not for gravity sinks)
              if (~(att1.getType()=2) & ~(att2.getType()=2) ) {
                do att2.setVelocity( att1.getVx() + att2.getVx(), att1.getVy() + att2.getVy() );
              }
              // dont kill gravity sinks
              if (~(att1.getType()=2)) { do att1.setIsDead(true); }
              if (~(att2.getType()=2)) { do att2.setIsDead(true); }
            }
          }
        }

        let j=j+1;

        let att2=OM.getAttributes(j);
      } // next j

      // Now check if the object it outside the game bounds.
      // x1 and y1 are still the object from the outside loop.
      // x2 and y2 are now being overwritten to study the screen bounds.
      let res=settings.getworldResolutionX();
      let x1=x1/res;
      let res=settings.getworldResolutionY();
      let y1=y1/res;

      let x2 = 0;
      if ((x1-r1)<x2 & (~att1.getIsDead()) ){
        let collisionOccured=true;
        if (executeKill){ do att1.setIsDead(true); }
        }

      let x2 = settings.getscreenSizeX();
      if ((x1+r1)>x2 & (~att1.getIsDead()) ){
        let collisionOccured=true;
        if (executeKill){ do att1.setIsDead(true); }
      }

      let y2 = 0;
      if ((y1-r1)<y2 & (~att1.getIsDead()) ){
        let collisionOccured=true;
        if (executeKill){ do att1.setIsDead(true); }
      }

      let y2 = settings.getscreenSizeY();
      if ((y1+r1)>y2 & (~att1.getIsDead()) ){
        let collisionOccured=true;
        if (executeKill){ do att1.setIsDead(true); }
      }

      // i++
      let i=i+1;
      let att1=OM.getAttributes(i);
    }
  //return false;
    return collisionOccured;
  }

  method bool withinDistanceOfAnotherPlayer(Player passedPlayer, int distance) {
    var int i;
    var bool isWithinDistance;
    var Player comparisonPlayer;
    var Attributes att1, att2;

    let isWithinDistance = false;
    let att1 = passedPlayer.getAttributes();

    let i=0;
    let comparisonPlayer = OM.getPlayer(i);

    while (~(comparisonPlayer=0) & (~(comparisonPlayer = passedPlayer)))
    {
        let comparisonPlayer = OM.getPlayer(i);
        let att2 = comparisonPlayer.getAttributes();
        if ( getDistance( att1.getPx(), att1.getPy(),
                          att2.getPx(), att2.getPy(),distance+1 ) < distance ) {
          let isWithinDistance = true;

        }
        let i=i+1;
        let comparisonPlayer = OM.getPlayer(i);
    }
      return isWithinDistance;
  }

  method int getDistance(int x1,int y1,int x2,int y2, int envelope) {
    // gets the distance between two cartesian coordinates.
    // To prevent overflows when squaring large numbers, we only
    // calculate the actual distance if the two points are close to the
    // envelope
    var int ratio;

    let x1 = Math.abs(x1-x2);
    let y1 = Math.abs(y1-y2);
    // now x1 and y1 are the x and y components of the distance


    // convert to pixel space, since that's what units our radii are in.
    let x1 = x1 / settings.getworldResolutionX();
    let y1 = y1 / settings.getworldResolutionY();



    // To avoid overflow, we divide by ten until our calculations
    // can be done in 15 bits and then remultiply after the calculation
    let ratio=1;

    // the biggest distances we can calculate are 128 so the function
    // scales down the request
    while ( (x1>128) | (y1>128) )
    {
      let x1 = x1/2;
      let y1 = y1/2;
      let ratio = ratio*2.8;
    }

    //do Output.printString("<");
    //do Output.printInt(x1);
    //do Output.printString(",");
    //do Output.printInt(y1);
    //do Output.printString(">");

    let x1 = Math.sqrt( (x1*x1) + (y1*y1) );
    // now x1 has the total distance calculation
    let x1=x1*ratio;

    return x1;
  }

  method void applyGravitationalField(Attributes att) {
    // Applies acceleration to a specific object based on the
    // proximity to gravitational sinks
    var int i, m1, m2,d,f;
    var int x1,y1,x2,y2;
    var int xComp, yComp;
    var Attributes currentAttributes;
    var GravitySink currentGS;

    let m1 = att.getMass();
    let x1=att.getPx();
    let y1 = att.getPy();

    let i = 0;
    while(~(OM.getGravitySink(i)=0) & (i<settings.getMaxGravitySinks()) ) {
      let currentGS = OM.getGravitySink(i);
      let currentAttributes = currentGS.getAttributes();
      let x2=currentAttributes.getPx();
      let y2=currentAttributes.getPy();
      let m2 = currentAttributes.getMass();
      // if the distance between two objects is > 10000 then it's negligable
      let d= getDistance(x1,y1,x2,y2,1000);

      // Universal gravitational formula: F=(m1*m2)/d
      let f = (m1*m2)/d;
      // now we're going to skip a few sine calculations by realizing that
      // Fx=F*sin(theta) and sin(theta) = Dx/D, which are two values we know.
      let xComp = f*( (x2-x1)/settings.getworldResolutionX()/d); // x component
      let yComp = f*( (y2-y1)/settings.getworldResolutionY()/d); // y component
      // now apply this gravitational pull to our object
      do applyCartesianAcceleration(att, xComp,yComp);
      let x2=att.getAx();
      let y2 = att.getAy();

      let i=i+1;
    }
    return;
  }

  method void dispose() {
    do Memory.deAlloc(mathEngine);
    do Memory.deAlloc(this);
    return; }

}