import java.awt.*;

import java.util.*;



public class Lander

{

  double gravityAcceleration;

  double rocketAcceleration;

  int attitude;

  boolean landerSpun;

  double lastScale;

  double xDirection;

  double yDirection;

  boolean crashed;

  boolean landed;

  boolean mainRocketOperating;

  double landscapePosX;

  double landscapePosY;

  int screenPosX;

  int screenPosY;

  double deltaX;

  double deltaY;

  float fuel;

  Vector landerLines;

  double maxSafeLandingSpeed;



  double [][] landerArray = {

                           { -2d,   7d,  0d,  10d},

                           {  0d,  10d,  2d,   7d},

                           { -3d, -10d,  3d, -10d},

                           {  3d, -10d,  6d,  -7d},

                           {  6d,  -7d,  6d,  -4d},

                           {  6d,  -4d,  3d,  -1d},

                           { -3d,  -1d, -6d,  -4d},

                           { -6d,  -4d, -6d,  -7d},

                           { -6d,  -7d, -3d, -10d},

                           { -6d,  -1d,  6d,  -1d},

                           {  6d,  -1d,  6d,   4d},

                           {  6d,   1d,  8d,   7d},

                           {  4d,   4d,  8d,   7d},

                           {  8d,   7d,  8d,  10d},

                           {  6d,  10d, 10d,  10d},

                           {  6d,   4d, -6d,   4d},

                           { -6d,  -1d, -6d,   4d},

                           { -6d,   1d, -8d,   7d},

                           { -4d,   4d, -8d,   7d},

                           { -8d,   7d, -8d,  10d},

                           {-10d,  10d, -6d,  10d},

                           {  0d,   4d,  2d,   7d},

                           {  0d,   4d, -2d,   7d},

                           { -2d,   7d,  2d,   7d}

                          };



  int [][] lastScreenDelta = new int [landerArray.length][4];



  public Lander (int startXPosIn, int startYPosIn, double startDeltaXIn, double startDeltaYIn)

   {



    landerLines = new Vector(1);

    for (int i = 0; i < landerArray.length; i++)

     {

      landerLines.addElement( new Line(

                                      landscapePosX + landerArray[i][0],

                                      landscapePosY + landerArray[i][1],

                                      landscapePosX + landerArray[i][2],

                                      landscapePosY + landerArray[i][3]  )  );

     }



     attitude =0;

     mainRocketOperating = false;

     crashed = false;

     landed = false;

     landscapePosX  = startXPosIn;

     landscapePosY  = startYPosIn;

     deltaX = startDeltaXIn;

     deltaY = startDeltaYIn;

     lastScale = 0;



     rocketAcceleration = (.015d);

     maxSafeLandingSpeed = .25;

     fuel = 1;



     mainRocketOff();  // Rocket is off to start

     spinLanderLeft();

     spinLanderRight();

   }





 public void move()

   {

    Line currentElement;



    deltaY += gravityAcceleration;

    if (mainRocketOperating)

    if (!crashed)

     {

      deltaX -= xDirection * rocketAcceleration;

      deltaY -= yDirection * rocketAcceleration;

      fuel-=.001;

      if ( fuel < 0)

        {

         mainRocketOperating = false;

         mainRocketOff();

        }

     }



    landscapePosX += deltaX;

    landscapePosY += deltaY;



    for (int i =0; i < landerLines.size(); i++ )

     {

      if (!crashed) //Set each lines delta V  equal to Landers delta V

       {

        ((Line)landerLines.elementAt(i)).deltaX = deltaX;

        ((Line)landerLines.elementAt(i)).deltaY = deltaY;

       }

      else

       {

        ((Line)landerLines.elementAt(i)).deltaY += gravityAcceleration;

       }

      ((Line)landerLines.elementAt(i)).move();

     }

 }







 public void draw(Graphics graphicsIn, double XDisplacementIn,

                       double YDisplacementIn, double ScaleIn)

   {

    Line currentElement;

    screenPosX  = (int) ((landscapePosX - XDisplacementIn) * ScaleIn);

    screenPosY =  (int) ((landscapePosY - YDisplacementIn) * ScaleIn);



    if ( landerSpun  || ScaleIn != lastScale || crashed)

     {

      landerSpun = false;

      for (int ktr =0; ktr < landerLines.size(); ktr++ )

       {

        currentElement = (Line)landerLines.elementAt(ktr);

        currentElement.calculateScreenCoordinates( XDisplacementIn,

                                 YDisplacementIn, ScaleIn);

        currentElement.drawLine(graphicsIn);

        lastScreenDelta[ktr][0] = currentElement.screenStartX - screenPosX;

        lastScreenDelta[ktr][1] = currentElement.screenStartY - screenPosY;

        lastScreenDelta[ktr][2] = currentElement.screenEndX   - screenPosX;

        lastScreenDelta[ktr][3] = currentElement.screenEndY   - screenPosY;

       }

     }

    else

     {

      for (int ktr =0; ktr < landerLines.size(); ktr++ )

       {

        currentElement = (Line)landerLines.elementAt(ktr);

        currentElement.screenStartX = lastScreenDelta[ktr][0] + screenPosX;

        currentElement.screenStartY = lastScreenDelta[ktr][1] + screenPosY;

        currentElement.screenEndX   = lastScreenDelta[ktr][2] + screenPosX;

        currentElement.screenEndY   = lastScreenDelta[ktr][3] + screenPosY;

        currentElement.drawLine(graphicsIn);

       }

     }

    lastScale = ScaleIn;

   }











 public void mainRocketOff()

   {

    mainRocketOperating = false;

    //First two lines are flame from rocket make them invisible

    ( (Line)(landerLines.elementAt(0)) ).visible = false;

    ( (Line)(landerLines.elementAt(1)) ).visible = false;

   }







 public void mainRocketOn()

   {

    if ( fuel > 0 )

     {

      mainRocketOperating = true;

      //First two lines are flame from rocket, make them visible

      ( (Line)(landerLines.elementAt(0)) ).visible = true;

      ( (Line)(landerLines.elementAt(1)) ).visible = true;

     }

   }





 public void spinLanderLeft()

   {

    attitude += 1;

    if (attitude > 23) attitude =0;

    rotate();

    landerSpun = true;

   }



 public void spinLanderRight()

   {

    attitude -= 1;

    if (attitude < 0) attitude = 23;

    rotate();

    landerSpun = true;

   }



 public void setExplosionDeltas()

   {

    Random generator = new Random();

    double r;

    //Increase gravity to make debris curve down more dramtically

    gravityAcceleration *= 10d;



    generator.setSeed(System.currentTimeMillis());

    for (int ktr =0; ktr < landerLines.size(); ktr++ )

     {

      r = generator.nextDouble();

      r -= .5d;

      r *= 3d;

      ((Line)landerLines.elementAt(ktr)).deltaX += r;

      ((Line)landerLines.elementAt(ktr)).deltaX *= -1d;

      r = generator.nextDouble();

      r -= .5d;

      r *= 3d;

      ((Line)landerLines.elementAt(ktr)).deltaY += r;

     ((Line)landerLines.elementAt(ktr)).deltaY *= -1d;

     }

    deltaX =0d;

    deltaY =0d;

   }



 public void rotate()

   {

    double radian;

    double totalDirection;

    Line l;

    double cos;

    double sin;

    double negativeSin;



    radian = attitude * 0.2617993877991d;  //15 degrees



    cos = Math.cos(radian);

    sin = Math.sin(radian);

    negativeSin = sin * -1;



    totalDirection = Math.abs(sin) + Math.abs(cos);

    yDirection =  cos / totalDirection;

    xDirection =  sin / totalDirection;



    for (int i =0; i < landerLines.size(); i++ )

     {



      l = (Line)landerLines.elementAt(i);



      l.startX = landscapePosX + ( (cos * landerArray[i][0]) + (sin * landerArray[i][1]) );

      l.startY = landscapePosY + ( (negativeSin * landerArray[i][0]) + (cos * landerArray[i][1]) );

      l.endX = landscapePosX   + ( (cos * landerArray[i][2]) + (sin * landerArray[i][3]) );

      l.endY = landscapePosY   + ( (negativeSin * landerArray[i][2]) + (cos * landerArray[i][3]) );



     }





   }









}