source: galcon-client/src/com/example/helloandroid/Fleet.java@ 9ef6f68

package com.example.helloandroid;

import java.util.ArrayList;

public class Fleet {
        private int x;
        private int y;
        private double dblX;
        private double dblY;
        private double slope, xIntercept; 
        private double direction;
        private Planet destination;
        private int numShips;
        private int faction;
        private boolean isNextToAPlanet;
        
        /* Optimising: pre-calculate paths */
        public Fleet(Planet source, Planet destination, int numShips, int faction) {
                //Calculate initial coordinates and direction 
                if((destination.getX() - source.getX()) != 0){
                //line formula 
                slope = getSlope(source.getX(),source.getY(),destination.getX(),destination.getY());
                xIntercept = destination.getY() - (slope*destination.getX());
                
                //direction
                direction = Math.atan(slope);
                
                //coordinates for all 4 coordinates
                if((destination.getX() - source.getX()) < 0 )
                        direction += Math.PI;
                
                dblX = ((Math.cos(direction)*(source.radius + 10) + source.getX()));
                dblY = ((Math.sin(direction)*(source.radius + 10) + source.getY()));
                
                } else {
                        if((destination.getY() - source.getY()) > 0 ){
                                direction = Math.PI/2;
                                dblX = destination.getX();
                                dblY = source.getY() + source.radius + 10;
                        } else {
                                direction = 3*Math.PI/2;
                                dblX = destination.getX();
                                dblY = source.getY() - source.radius - 10;
                        }
                }
                
                x = (int)dblX;
                y = (int)dblY;
                
                this.numShips = numShips;
                this.faction = faction;
                this.destination = destination;
                this.isNextToAPlanet = false;
        }
        
                
        public int getX() {
                return x;
        }



        public void setX(int x) {
                this.x = x;
        }



        public int getY() {
                return y;
        }



        public void setY(int y) {
                this.y = y;
        }



        public double getDirection() {
                return direction;
        }



        public void setDirection(double direction) {
                this.direction = direction;
        }



        public Planet getDestination() {
                return destination;
        }



        public void setDestination(Planet destination) {
                this.destination = destination;
        }



        public int getNumShips() {
                return numShips;
        }



        public void setNumShips(int numShips) {
                this.numShips = numShips;
        }



        public int getFaction() {
                return faction;
        }



        public void setFaction(int faction) {
                this.faction = faction;
        }



        public void update(ArrayList<Planet> planets) {
                int speed = 1; //pixels per move
                double distance, tangentDirection, angle;
                Planet temp = null;
                //is the ship going around a planet already
                if(!isNextToAPlanet){
                        /*looks through all the planets to figure out if
                        the ship's path is about to intersect a planet*/
                        for(Planet p: planets){
                                //if two point of intersection are found save planet 
                                distance = getDistanceBetween(dblX,dblY,p.getX(),p.getY());
                                if(distance <= p.radius){
                                        temp = p;
                                        break;
                                }
                        }
                        //if temp planet is not picked move along the direction by #speed
                        if(temp == null){
                                dblY += (Math.sin(direction)*speed);
                                dblX += (Math.cos(direction)*speed);
                                
                                x = (int)dblX;
                                y = (int)dblY;
                        } else 
                        //otherwise
                        {
                                //figure out which way to go clockwise or counter clockwise 
                                tangentDirection = (Math.atan(getSlope(temp.getX(),temp.getY(),dblX,dblY))) + (Math.PI/2);
                                angle = Math.atan((Math.tan(tangentDirection) - Math.tan(direction))/(1 + Math.tan(tangentDirection)*Math.tan(direction)));
                                if (angle <= Math.PI/2)
                                        angle = Math.PI - angle;
                                //get next point and the direction and set it
                        }
                } else {
                        //can you reach the center of the planet by following this direction
                        //if so set isNextToAPlanet to false and move 
                        //otherwise continue moving along the circumferenceds4
                
                }
                
                
        }
        
        // attack the destination planet
        //after the method is called the fleet needs to removed
        public void attack() {
                if(numShips <= destination.getNumShips()){
                        destination.setNumShips(destination.getNumShips() - numShips);
                } else {
                        destination.setNumShips(numShips - destination.getNumShips());
                        destination.setFaction(this.faction);
                }
        }
        
        //helper functions
        private double getDistanceBetween(double x1, double y1, double x2, double y2)
        {
                return Math.sqrt(Math.pow((x2 - x1),2) + Math.pow((y2 - y1),2));
        }
        
        private double getSlope(double x1, double y1, double x2, double y2)
        {
                return ((y1 - y1)/(x2 - x1));
        }
}