russianaicup thevlad source

import model.*;
import java.util.*;
import java.io.*;
import javax.swing.*;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;

public final class MyStrategy implements Strategy {

    public static class Vector2D
    {
        public double x;
        public double y;

        public Vector2D()
        {
            this.x = 0;
            this.y = 0;
        }

        public Vector2D(double x0, double y0)
        {
            this.x = x0;
            this.y = y0;
        }

        public void normalize()
        {
            double l = Math.sqrt(this.x*this.x + this.y*this.y);
            if (l < 1E-6)
            {
                this.x = 0;
                this.y = 0;
                throw new ArithmeticException("normalize, divide by zero");
            }

            double invL = 1.0 / l;
            this.x *= invL;
            this.y *= invL;
        }

    }

    public static Vector2D fromAngle(double angle)
    {
        if (angle < 0.0)
            angle += 2*Math.PI;
        return new Vector2D(Math.cos(angle), Math.sin(angle));
    }

    public static double length(Vector2D v)
    {
        return Math.sqrt(v.x*v.x + v.y*v.y);
    }

    public static double length(double x, double y)
    {
        return Math.sqrt(x*x + y*y);
    }

    public static double toAngle(Vector2D v)
    {
        return Math.atan2(v.y, v.x);
    }

    public static Vector2D normalize(Vector2D v)
    {
        Vector2D a = new Vector2D(v.x, v.y);
        a.normalize();
        return a;
    }

    public static Vector2D add(Vector2D a, Vector2D b)
    {
        return new Vector2D(a.x + b.x, a.y + b.y);
    }

    public static Vector2D sub(Vector2D a, Vector2D b)
    {
        return new Vector2D(a.x - b.x, a.y - b.y);
    }

    public static Vector2D mul(Vector2D a, double s)
    {
        return new Vector2D(a.x*s, a.y*s);
    }

    public static Vector2D mul(double s, Vector2D a)
    {
        return new Vector2D(a.x*s, a.y*s);
    }

    public static double dotProduct(Vector2D a, Vector2D b)
    {
        return a.x*b.x + a.y*b.y;
    }

    public static double distance(Vector2D a, Vector2D b)
    {
        double x = b.x - a.x;
        double y = b.y - a.y;
        return Math.sqrt(x*x + y*y);
    }

    public static Vector2D perpendicular(Vector2D a)
    {
        return new Vector2D(-a.y, a.x);
    }

    public static boolean isClouse(Vector2D a, Vector2D b, double eps)
    {
        return (Math.abs(a.x - b.x) < eps) && (Math.abs(a.y - b.y) < eps);
    }

    public static final int worldWidth  = 1280;
    public static final int worldHeight = 800;

    public static double median(ArrayList<Double> inputList)
    {
        ArrayList<Double> doubleList = new ArrayList<Double>(inputList);
        Collections.sort(doubleList);
        return doubleList.get((doubleList.size() - 1)/2);
    }

    public static double mean(ArrayList<Double> inputList)
    {
        ArrayList<Double> doubleList = new ArrayList<Double>(inputList);
        if (doubleList.size() == 0)
            return 0.0;

        double sum = 0.0;
        for (int i = 0; i < doubleList.size(); ++i)
        {
            sum += doubleList.get(i);
        }
        return sum/doubleList.size();
    }

    // nearest point on line
    public static double nearestPointAtSegment(Vector2D p, Vector2D a, Vector2D b)
    {
        Vector2D ap = sub(p, a);
        Vector2D ab = sub(b, a);
        double ab2 = ab.x*ab.x + ab.y*ab.y;
        double ap_ab = ap.x*ab.x + ap.y*ab.y;
        double t = ap_ab / ab2;
        if (t >= 0.0 && t <= 1.0)
        {
            return t;
        }
        else
        {
            double distA = distance(p, a);
            double distB = distance(p, b);
            if (distA < distB)
                return 0.0;
            else
                return 1.0;
        }
    }


    public static double nearestPointAtRay(Vector2D p, Vector2D a, Vector2D d)
    {
        Vector2D ap = sub(p, a);
        Vector2D ab = d;
        double ab2 = ab.x*ab.x + ab.y*ab.y;
        double ap_ab = ap.x*ab.x + ap.y*ab.y;
        double t = ap_ab / ab2;
        return t;
    }

    public static double normalizeAngle(double a)
    {
        return toAngle(fromAngle(a));
    }

    public static Vector2D interpolate(Vector2D a, Vector2D b, double t, boolean isClamp)
    {
        if (isClamp)
        {
            if (t > 1.0)
                t = 1.0;
            if (t < 0.0)
                t = 0.0;
        }
        return add(mul((1.0 - t), a), mul(t, b));
    }

    public static double interpolate(double a, double b, double t, boolean isClamp)
    {
        if (isClamp)
        {
            if (t > 1.0)
                t = 1.0;
            if (t < 0.0)
                t = 0.0;
        }

        return (1.0 - t)*a + b*t;
    }

    public static double orientation(Vector2D va, Vector2D vb)
    {
        double c = va.x*vb.y - va.y*vb.x;
        if (c > 0)
            return +1;
        else
            return -1;
    }

    // two normalized vectors
    public static double angleBetween(Vector2D a, Vector2D b)
    {
        Vector2D va = normalize(a);
        Vector2D vb = normalize(b);
        double c = va.x*vb.y - va.y*vb.x;
        if (c > 0)
            return -Math.acos(va.x*vb.x + va.y*vb.y);
        else
            return Math.acos(va.x*vb.x + va.y*vb.y);
    }

    // a - curentAngle, b - targetAngle
    public static double angleBetween(double a, double b)
    {
        Vector2D va = fromAngle(a);
        Vector2D vb = fromAngle(b);
        double c = va.x*vb.y - va.y*vb.x;
        if (c > 0)
            return Math.acos(va.x*vb.x + va.y*vb.y);
        else
            return -Math.acos(va.x*vb.x + va.y*vb.y);
    }

    public static double degToRad(double deg)
    {
        return deg*(Math.PI/180.0);
    }

    public static class DebugCanvas
    {
        public JFrame frame;

        public BufferedImage  buffer;
        public BufferedImage  paintBuffer;
        public BufferedImage  buffer1;
        public BufferedImage  buffer2;
        public Graphics2D     g = null;
        public DebugPanel     panel;

        public class DebugPanel extends JPanel
        {
            public void paintComponent(Graphics pg)
            {
                if (enableDebug)
                {
                    if (g != null)
                    {
                        pg.drawImage(paintBuffer, 0, 0, null);
                        synchronized(DebugCanvas.this)
                        {
                            paintBuffer = null;
                        }
                    }
                }
            }
        }

        public void onBegin()
        {
            if (enableDebug)
            {
                //AffineTransform aft = new AffineTransform();
                //aft.setTransform(1.0, 0.0, 0.0, -1.0, 0.0, this.buffer.getHeight());
                //this.g.setTransform(aft);
                //Font font = new Font("Serif", )
            }
        }

        public void onEnd()
        {
            if (enableDebug)
            {

            }
        }

        public void create(int w, int h)
        {
            if (enableDebug)
            {
                this.panel = new DebugPanel();
                this.frame = new JFrame("DebugCanvas");
                this.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                this.frame.setResizable(false);

                this.panel.setPreferredSize(new Dimension(w, h));
                this.frame.setContentPane(this.panel);
                this.frame.pack();
                this.frame.setVisible(true);

                this.buffer1 = new java.awt.image.BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
                this.buffer2 = new java.awt.image.BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
                this.buffer = this.buffer1;
                this.g = this.buffer.createGraphics();
                this.onBegin();
            }
        }

        public void drawImage(Image image)
        {
            if (enableDebug)
            {
                Image scaledImage =image.getScaledInstance(this.buffer.getWidth(), this.buffer.getHeight(), Image.SCALE_FAST);
                this.g.drawImage(scaledImage, 0, 0, null);
            }
        }

        public void drawPolyLine(ArrayList<Vector2D> polyLine)
        {
            if (enableDebug)
            {
                for (int i = 0; i + 1 < polyLine.size(); ++i)
                {
                    this.line(polyLine.get(i), polyLine.get(i + 1));
                }
            }
        }

        public void drawWorld(World world)
        {
            if (enableDebug)
            {
                this.setColor(Color.BLACK);
                this.text(String.format("Tick: %d", world.getTick()), 5, 15);

                for (Tank tank: world.getTanks())
                {
                    drawTank(tank);
                }

                for (Shell shell: world.getShells())
                {
                    drawShell(shell);
                }

                for (Bonus bonus: world.getBonuses())
                {
                    drawBonus(bonus);
                }
            }
        }

        public void drawBonus(Bonus bonus)
        {
            if (enableDebug)
            {
                this.setColor(Color.BLACK);
                Vector2D bonusPos = new Vector2D(bonus.getX(), bonus.getY());
                Vector2D bonusTextPos = new Vector2D(bonusPos.x - 20.0, bonusPos.y);
                this.rectangle(bonusPos, bonus.getWidth(), bonus.getHeight(), bonus.getAngle());
                this.setColor(Color.BLACK);
                if (bonus.getType() == BonusType.AMMO_CRATE)
                {
                    this.setColor(Color.BLUE);
                    this.text("ammo", bonusTextPos);
                }
                else if (bonus.getType() == BonusType.MEDIKIT)
                {
                    this.setColor(Color.GREEN);
                    this.text("med", bonusTextPos);
                }
                else if (bonus.getType() == BonusType.REPAIR_KIT)
                {
                    this.setColor(Color.RED);
                    this.text("repair", bonusTextPos);
                }
            }
        }

        public void drawShell(Shell shell)
        {
            if (enableDebug)
            {
                this.setColor(Color.RED);
                Vector2D shellPos = new Vector2D(shell.getX(), shell.getY());
                this.rectangle(shellPos, shell.getWidth(), shell.getHeight(), shell.getAngle());
            }
        }

        public void drawTank(Tank tank)
        {
            if (enableDebug)
            {
                this.setColor(Color.BLACK);
                Vector2D tankPos = new Vector2D(tank.getX(), tank.getY());
                this.rectangle(tankPos, tank.getWidth(), tank.getHeight(), tank.getAngle());

                this.text(String.format("hp (%d, %d) r (%d)", tank.getCrewHealth(), tank.getHullDurability(), tank.getRemainingReloadingTime()),
                        roundInt(tankPos.x - 40), roundInt(tankPos.y - 15));

                this.setColor(Color.MAGENTA);
                Vector2D tankVel = new Vector2D(tank.getSpeedX(), tank.getSpeedY());
                this.vector(tankPos, tankVel, 10.0);

                this.setColor(Color.GREEN);
                double turretAngle = normalizeAngle(tank.getAngle() + tank.getTurretRelativeAngle());
                this.vector(tankPos, fromAngle(turretAngle), tank.getVirtualGunLength());
            }
        }

        public void drawMove(Tank self, Move move)
        {
            double w = self.getWidth();
            double h = self.getHeight();
            Vector2D front = fromAngle(self.getAngle());
            Vector2D flang = normalize(perpendicular(front));
            Vector2D selfPos = new Vector2D(self.getX(), self.getY());

            Vector2D leftP  = add(selfPos, mul(-h*0.5, flang));
            Vector2D leftV  = mul(w*0.5, front);
            Vector2D rightP = add(selfPos, mul(h*0.5, flang));
            Vector2D rightV = mul(w*0.5, front);

            if (move.getLeftTrackPower() < 0.0)
            {
                this.setColor(Color.CYAN);
                this.vector(leftP, mul(self.getEngineRearPowerFactor()*move.getLeftTrackPower(), leftV));
            }
            else
            {
                this.setColor(Color.BLUE);
                this.vector(leftP, mul(move.getLeftTrackPower(), leftV));
            }

            if (move.getRightTrackPower() < 0.0)
            {
                this.setColor(Color.CYAN);
                this.vector(rightP, mul(self.getEngineRearPowerFactor()*move.getRightTrackPower(), rightV));
            }
            else
            {
                this.setColor(Color.BLUE);
                this.vector(rightP, mul(move.getRightTrackPower(), rightV));
            }
        }

        public void rectangle(Vector2D pos, double w, double h, double angle)
        {
            if (enableDebug)
            {
                Vector2D front = fromAngle(angle);
                Vector2D flang = normalize(perpendicular(front));

                Vector2D p0 = add(pos, add(mul(w*0.5, front),  mul(h*0.5, flang)));
                Vector2D p1 = add(pos, add(mul(w*0.5, front),  mul(-h*0.5, flang)));
                Vector2D p2 = add(pos, add(mul(-w*0.5, front), mul(-h*0.5, flang)));
                Vector2D p3 = add(pos, add(mul(-w*0.5, front), mul(h*0.5, flang)));

                this.line(p0, p1);
                this.line(p1, p2);
                this.line(p2, p3);
                this.line(p3, p0);
            }
        }

        public void text(String str, Vector2D pos)
        {
            if (enableDebug)
            {
                this.text(str, roundInt(pos.x), roundInt(pos.y));
            }
        }

        public void text(String str, int x, int y)
        {
            if (enableDebug)
            {
                g.drawString(str, x, y);
            }
        }

        public void text(String str, double x, double y)
        {
            if (enableDebug)
            {
                g.drawString(str, (float)x, (float)y);
            }
        }

        public void clear()
        {
            if (enableDebug)
            {
                this.g.setBackground(Color.WHITE);
                this.g.clearRect(0, 0, this.buffer.getWidth(), this.buffer.getHeight());
            }
        }

        public void present()
        {
            if (enableDebug)
            {
                this.onEnd();
                this.g.dispose();
                boolean spinWait = true;
                while (spinWait)
                {
                    synchronized (this)
                    {
                        if (this.paintBuffer == null)
                        {
                            if (this.buffer == this.buffer1)
                            {
                                this.paintBuffer = this.buffer1;
                                this.buffer = this.buffer2;
                            }
                            else if (this.buffer == this.buffer2)
                            {
                                this.paintBuffer = this.buffer2;
                                this.buffer = this.buffer1;
                            }
                            spinWait = false;
                        }
                    }
                    try
                    {
                        Thread.sleep(1);
                    }
                    catch (Exception ex)
                    {
                    }
                }
                this.g = this.buffer.createGraphics();
                this.onBegin();
                this.panel.repaint();
            }
        }

        public static int roundInt(double x)
        {
            return (int)Math.round(x);
        }

        public void setColor(Color c)
        {
            if (enableDebug)
            {
                this.g.setColor(c);
            }
        }

        public void line(Vector2D a, Vector2D b)
        {
            if (enableDebug)
            {
                this.g.drawLine(roundInt(a.x), roundInt(a.y), roundInt(b.x), roundInt(b.y));
            }
        }

        public void vector(Vector2D pos, Vector2D v)
        {
            if (enableDebug)
            {
                this.vector(pos, v, 1.0);
            }
        }

        public void vector(Vector2D pos, Vector2D v0, double scale)
        {
            if (enableDebug)
            {
                Vector2D v = mul(scale, v0);
                if (length(v) < 1)
                {
                    this.line(pos, pos);
                    return;
                }
                Vector2D endPos = add(pos, v);
                this.line(pos, endPos);
                Vector2D perp = mul(7.0, normalize(perpendicular(v)));
                double l = length(v) - 7.0;
                if (l < 0.0)
                    l = 0.0;
                Vector2D joinPos   = add(pos, mul(l, normalize(v)));
                Vector2D arrowPos1 = add(joinPos, perp);
                Vector2D arrowPos2 = add(joinPos, mul(-1.0, perp));

                this.line(arrowPos1, endPos);
                this.line(arrowPos2, endPos);
            }
        }
    }

    public static class KinematicState
    {
        public double   q;
        public double   f;
        public double   u;
        public double   a;
        public Vector2D p;

        public KinematicState(double q, double f, double u, double a, Vector2D p)
        {
            this.q = q;
            this.f = f;
            this.u = u;
            this.a = a;
            this.p = p;
        }

        //  dx/dt = u*cos(q), dy/dt = u*sin(q), dq/dt = f, du/dt = a
        public KinematicState advance(double t, Tank tank)
        {
            double q1 = normalizeAngle(q + f*t);
            double u1 = u + a*t;
            double a0 = a;
            if (u1 > 4.0)
            {
                u1 = 4.0;
                a0 = (4.0 - u)/t;
            }
            else if (u1 < -2.6)
            {
                u1 = -2.6;
                a0 = (-2.6 - u)/t;
            }

            double x = 0.0;
            double y = 0.0;
            if (Math.abs(f) > 1E-5)
            {
                double x0 = (f*u*Math.sin(q) + a0*Math.cos(q))/(f*f);
                double y0 = (a0*Math.sin(q) - f*u*Math.cos(q))/(f*f);

                double x1 = (f*(a0*t + u)*Math.sin(q + f*t) + a0*Math.cos(q + f*t))/(f*f);
                double y1 = (a0*Math.sin(q + f*t) - f*(a0*t + u)*Math.cos(q + f*t))/(f*f);
                x = x1 - x0;
                y = y1 - y0;
            }
            else
            {
                x = 0.5*a*t*t*Math.cos(q) + u*t*Math.cos(q);
                y = 0.5*a*t*t*Math.sin(q) + u*t*Math.sin(q);
            }

            //return new KinematicState(q1, f, u1, a,  new Vector2D(x, y));

            // try to fix geometry to center of mass
            Vector2D front0    = fromAngle(q);
            Vector2D frontFix0 = mul(tank.getWidth()*0.5, front0);
            Vector2D front1    = fromAngle(q1);
            Vector2D frontFix1 = mul(tank.getWidth()*0.5, front1);
            return new KinematicState(q1, f, u1, a,  new Vector2D(frontFix0.x + p.x + x - frontFix1.x, frontFix0.y + p.y + y - frontFix1.y));
        }
    }

    public void initSystem()
    {
        if (enableDebug == true)
        {
            try
            {
                String userName = System.getProperty("user.name");
                if (!userName.equals("vlad"))
                    enableDebug = false;
            }
            catch (Exception ex)
            {
                enableDebug = false;
            }
        }

        if (enableDebug == true)
        {
            debug.create(worldWidth, worldHeight);
        }
    }


    public DebugCanvas debug = new DebugCanvas();
    static boolean enableDebug = false;


//    public void complexMove(Tank self, World world, Move move)
//    {
//      if (world.getTick() == 0)
//      {
//          init();
//      }
//
//
//      debug.clear();
//      debug.drawWorld(world);
//
//      /*
//        double turretAngle = Util.normalizeAngle(self.getAngle() + self.getTurretRelativeAngle()); //
//
//      Vector2D selfPos = new Vector2D(self.getX(), self.getY());
//      double minDistanceToEnemy = Double.MAX_VALUE;
//      double flyTime = 0.0;
//      Vector2D predictedEnemyPos = new Vector2D(0.0, 0.0);
//      Tank selectedTank = null;
//      for (Tank tank: world.getTanks())
//      {
//          if (!tank.isTeammate())
//          {
//              Vector2D enemyPos = new Vector2D(tank.getX(), tank.getY());
//              Vector2D enemyVel = new Vector2D(tank.getSpeedX(), tank.getSpeedY());
//
//              double distanceToEnemy = Vector2D.distance(selfPos, enemyPos); // + Util.angleBetween(turretAngle, Vector2D.toAngle(Vector2D.sub(enemyPos, selfPos)))/self.getTurretTurnSpeed();\
//              flyTime = distanceToEnemy/19.0;
//              predictedEnemyPos = Vector2D.add(enemyPos, Vector2D.mul(flyTime, enemyVel));
//              if (distanceToEnemy < minDistanceToEnemy)
//              {
//                  selectedTank = tank;
//                  minDistanceToEnemy = distanceToEnemy;
//              }
//
//              if (enemyId != 0 && tank.getId() == enemyId)
//              {
//                  selectedTank = tank;
//                  enemyId = tank.getId();
//              }
//          }
//      }
//
//      Vector2D enemyPos = predictedEnemyPos; // new Vector2D(selectedTank.getX(), selectedTank.getY());
//        double enemyAngle  = Vector2D.toAngle(Vector2D.sub(enemyPos, selfPos));
//        double angleDelta = Util.angleBetween(turretAngle, enemyAngle);
//        double turretTurnSpeed = self.getTurretTurnSpeed();
//
//        if (enableLog)
//        {
//          log(String.format("Turret: enemy (%f, %f), self (%f, %f)", enemyPos.x, enemyPos.y, selfPos.x, selfPos.y));
//          log(String.format("Turret: enemy id %d, turret %f, enemy angle: %f, delta: %f", selectedTank.getId(), turretAngle, enemyAngle, angleDelta));
//        }
//
//
//        if (Math.abs(angleDelta) < 0.05)
//        {
//          move.setFireType(FireType.PREMIUM_PREFERRED);
//          this.prevFireType = FireType.PREMIUM_PREFERRED;
//        }
//        else
//        {
//          if (angleDelta > 0.0)
//              move.setTurretTurn(3.0);
//          else
//              move.setTurretTurn(-3.0);
//
//
//          if (prevFireType != FireType.NONE)
//          {
//              move.setFireType(FireType.NONE);
//              this.prevFireType = FireType.NONE;
//          }
//        }
//        */
//
//        //trajectory.updateStep(self);
//
//      //Vector2D trackPowers = trajectory.getTrackPowers();
//      Vector2D selfPos = new Vector2D(self.getX(), self.getY());
//      this.posHistory.add(selfPos);
//
//      double speed = Vector2D.length(self.getSpeedX(), self.getSpeedY());
//      double deltaSpeed = 0.0;
//      this.speedHistory.add(speed);
//      double deltaAcceleration = 0.0;
//
//      double angularSpeed = self.getAngularSpeed();
//      this.angleHistory.add(self.getAngle());
//      double deltaAngularSpeed = 0.0;
//
//      if (this.posHistory.size() >= 2)
//      {
//          deltaSpeed = Vector2D.length(Vector2D.sub(this.posHistory.get(this.posHistory.size() - 1), this.posHistory.get(this.posHistory.size() - 2)));
//      }
//
//      if (this.angleHistory.size() >= 2)
//      {
//          deltaAngularSpeed = this.angleHistory.get(this.angleHistory.size() - 1) - this.angleHistory.get(this.angleHistory.size() - 2);
//      }
//
//      if (this.speedHistory.size() >= 2)
//      {
//          deltaAcceleration = this.speedHistory.get(this.speedHistory.size() - 1) - this.speedHistory.get(this.speedHistory.size() - 2);
//      }
//
//
//      boolean change = false;
//      if (world.getTick() % 30 == 0)
//      {
//          if (rand.nextBoolean())
//          {
//              this.leftPower = 1.0;
//              this.rightPower = Util.interpolate(0.0, 1.0, rand.nextDouble(), true);
//          }
//          else
//          {
//              this.leftPower = Util.interpolate(0.0, 1.0, rand.nextDouble(), true);
//              this.rightPower = 1.0;
//          }
//          change = true;
//      }
//
//      // override
//      if (world.getTick() < 100)
//      {
//          leftPower = 1.0;
//          rightPower = -self.getEngineRearPowerFactor()*1.0;
//      }
//      else
//      {
//          leftPower = -1.0;
//          rightPower = -1.0;
//      }
//
//      double q = self.getAngle();
//      double u = speed;
//      double f = self.getAngularSpeed();
//
//      Vector2D frontPos = new Vector2D();
//      ArrayList<Vector2D> predictK1 = new ArrayList();
//      for (int i = 0; i < 30; ++i)
//      {
//          double k = 0.043;
//          double pa = 0.0;
//          double pb = 0.0;
//          double kNew = 0.0;
//          if (leftPower > 0)
//              pa = 2.0;
//          else
//              pa = 1.4; // 1.3
//
//          if (rightPower > 0)
//              pb = 2.0;
//          else
//              pb = 1.4; // 1.3
//
//          double uMax = pa*leftPower + pb*rightPower;
//          double fK   = 0.0141;
//          double fMax   = 0.0;
//          if (leftPower > rightPower)
//          {
//              fMax = fK*(leftPower - rightPower);
//          }
//          else
//          {
//              fMax = -fK*(rightPower - leftPower);
//          }
//          double a    = uMax*k;
//          Vector2D p = Kinematic.kinematic(q, u, 0.5*(f + fMax), a, k, i*1.0);
//
//          if (i == 0 && Vector2D.length(p) > 3.0)
//          {
//              int break34 = 0;
//          }
//
//          Vector2D front = Vector2D.fromAngle(self.getAngle());
//          frontPos = Vector2D.add(selfPos, Vector2D.mul(self.getWidth()*0.5, front));
//          predictK1.add(Vector2D.add(frontPos, p));
//      }
//
//      if (change)
//      {
//          double errorD = Vector2D.length(Vector2D.sub(frontPos, new Vector2D(predictX, predictY)));
//          predictX = predictK1.get(predictK1.size() - 1).x;
//          predictY = predictK1.get(predictK1.size() - 1).y;
//      }
//
//      debug.setColor(Color.RED);
//      debug.line(new Vector2D(predictX, predictY), new Vector2D(predictX, predictY));
//      debug.text("p", new Vector2D(predictX, predictY));
//
//      debug.setColor(Color.BLACK);
//      debug.text(String.format("(s: %f, as: %f, da: %f)", speed, angularSpeed, deltaAcceleration), 100, 20);
//
//      debug.setColor(Color.ORANGE);
//      debug.drawPolyLine(this.posHistory);
//
//      debug.setColor(Color.MAGENTA);
//      debug.drawPolyLine(predictK1);
//
//
//      move.setLeftTrackPower(leftPower);
//      move.setRightTrackPower(rightPower);
//
//      debug.drawMove(self, move);
//      debug.present();
//    }

    public static class TankEntry
    {
        public long                 id;
        public ArrayList<Vector2D>  posHistory = new ArrayList<Vector2D>();
        public ArrayList<Double>    angleHistory = new ArrayList<Double>();
        public ArrayList<Double>    angularSpeedHistory = new ArrayList<Double>();
        public ArrayList<Double>    speedHistory = new ArrayList<Double>();
        public ArrayList<Double>    accelHistory = new ArrayList<Double>();
        public ArrayList<Vector2D>  velocityHistory = new ArrayList<Vector2D>();
        public Tank                 thisTank;
    }

    public void initSelf(Tank self, World world, Move move)
    {
        for (Tank tank: world.getTanks())
        {
            this.tankEntryById.put(tank.getId(), new TankEntry());
        }
    }

    public double getTankSpeed(Tank tank)
    {
        Vector2D velocity = new Vector2D(tank.getSpeedX(), tank.getSpeedY());
        double speed = length(velocity);
        Vector2D front = fromAngle(tank.getAngle());
        if (dotProduct(front, velocity) < 0.0)
            speed = -speed;
        return speed;
    }

    public double getTankAccel(Tank tank)
    {
        ArrayList<Double> accelHistory = this.tankEntryById.get(tank.getId()).accelHistory;
        if (accelHistory.size() >= 1)
        {
            return accelHistory.get(accelHistory.size() - 1);
        }
        return 0.0;
    }

    public double getTankAccelSmooth(Tank tank)
    {
        ArrayList<Double> accelHistory = this.tankEntryById.get(tank.getId()).accelHistory;
        int smoothSize = 5;
        if (accelHistory.size() >= smoothSize)
        {
            double sum = 0.0;
            for (int i = accelHistory.size() - smoothSize; i < accelHistory.size(); ++i)
            {
                sum += accelHistory.get(i);
            }
            return sum/smoothSize;
        }
        else if (accelHistory.size() >= 1)
        {
            return accelHistory.get(accelHistory.size() - 1);
        }
        return 0.0;
    }

    public double getTankRadius(Tank tank)
    {
        return length(new Vector2D(tank.getHeight()*0.5, tank.getWidth()*0.5));
    }

    public KinematicState predictKinematic(Tank tank, double dt)
    {
        KinematicState initialState = new KinematicState(tank.getAngle(), tank.getAngularSpeed(), getTankSpeed(tank), getTankAccelSmooth(tank),
                                                         new Vector2D(tank.getX(), tank.getY()));
        return initialState.advance(dt, tank);
    }

    public double predictSpeed(double a, double b, double u, double t)
    {
        return (1.0/60.0)*(((a*b*(Math.pow(b, t) - 1.0) + (b - 1.0)*u*Math.pow(b, t))/(b - 1.0)));
    }

    public double predictDistance(double a, double b, double u, double t)
    {
        return (1.0/60.0)*((Math.pow(b, t)*(a*b+ (b-1.0)*u)-b*(a*(b-1.0)*t+a+u)+u)/((b-1.0)*(b-1.0)));
    }

    public Vector2D predictMinMax(Tank tank, Vector2D selfPos, double hitTime)
    {
        Vector2D tankPos   = new Vector2D(tank.getX(), tank.getY());

        Vector2D tankVel   = new Vector2D(tank.getSpeedX(), tank.getSpeedY());
        Vector2D tankDir   = fromAngle(tank.getAngle());
        double   tankSpeed = length(tankVel)*Math.signum(dotProduct(tankDir, tankVel));
        double   dist      = length(sub(tankPos, selfPos));

        double health = (1.0*tank.getCrewHealth())/tank.getCrewMaxHealth();
        double frontA = tank.getEnginePower()*(0.5 + 0.5*health)/(10.0*60.0);
        double backA  = -tank.getEnginePower()*tank.getEngineRearPowerFactor()*(0.5 + 0.5*health)/(10.0*60.0);
        double b = 1.0 - (0.5/10.0);

        Vector2D perpRay   = normalize(perpendicular(sub(tankPos, selfPos)));
        if (dotProduct(tankDir, perpRay) < 0.0)
            perpRay = mul(-1.0, perpRay);

        double tankRadius = getTankRadius(tank);
        double frontDistance = dotProduct(perpRay, mul(tankDir,  tankRadius + predictDistance(frontA, b, tankSpeed, hitTime)));
        double backDistance  = dotProduct(perpRay, mul(tankDir, -tankRadius + predictDistance(backA, b, tankSpeed, hitTime)));

        debug.setColor(Color.RED);
        debug.text(String.format("f: %f, b: %f", frontDistance, backDistance), 100, 40);

        debug.setColor(Color.MAGENTA);
        debug.line(add(mul(frontDistance, tankDir), tankPos),  add(mul(backDistance, tankDir), tankPos));

        double delta = (frontDistance - tank.getWidth()) - (backDistance  + tank.getWidth());
        Vector2D p1 = mul(frontDistance - tank.getWidth(), tankDir);
        Vector2D p2 = mul(backDistance  + tank.getWidth(), tankDir);

        Vector2D r;
        if (delta > 0.5*tank.getWidth() && tankSpeed > 0.5)
            r = mul(0.5, add(add(mul(frontDistance, tankDir), tankPos), tankPos));
        else
            r = add(mul(0.5, add(p1, p2)), tankPos);

        debug.setColor(Color.BLUE);
        debug.text("f", add(p1, tankPos));
        debug.text("b", add(p2, tankPos));

        debug.setColor(Color.RED);
        debug.text("o", r);
        return r;
    }

    public boolean isAlive(Tank tank)
    {
        return tank.getCrewHealth() > 0 && tank.getHullDurability() > 0;
    }

    // hit probability
    public double hitProb(double dist, double certainHitDistance)
    {
        double prob = certainHitDistance/dist;
        if (prob > 1.0)
            prob = 1.0;

        return prob;
    }

    public double miePhase(double q, double g)
    {
        return (1.0 - g*g)/Math.pow(1.0 + g*g - 2.0*g*Math.cos(q), 3.0/2.0);
    }

    public double phaseHitProb(double q, double g)
    {
        return miePhase(q, g)/miePhase(0.0, g);
    }

    public double dangerHeuristic(World world, Vector2D p, Tank self, boolean isSelf)
    {
        double expectedDamage = 0.0;
        int aliveEnemyCount = 0;
        Vector2D selfPos = new Vector2D(self.getX(), self.getY());
        for (Tank tank: world.getTanks())
        {
            Vector2D tankPos = new Vector2D(tank.getX(), tank.getY());
            if (isAlive(tank) && tank.isTeammate() == false)
            {
                double forwardness = 0.2;
                Vector2D deltaPos = sub(p, tankPos);
                Vector2D selfDir;
                if (isSelf == false)
                {
                    selfDir = sub(p, selfPos);
                }
                else
                {
                    selfDir = fromAngle(self.getAngle());
                }

                Vector2D tankTurret = fromAngle(getTurretAngle(tank));
                double selfHitAngle = angleBetween(selfDir, tankTurret);
                double dist = distance(tankPos, p);
                //double angle = angleBetween(deltaPos, tankTurretV);
                //double phaseHitProb = phaseHitProb(Math.abs(angle), forwardness);
                double distProb = (300.0/dist);
                if (distProb > 1.0)
                    distProb = 1.0;

                double angleProb = 0.0;
                if (Math.abs(angleBetween(deltaPos, tankTurret)) < Math.PI/2.0)
                {
                    angleProb = Math.abs(Math.cos(selfHitAngle));
                }
                else
                {
                    angleProb = 0.7*distProb;
                }

                double hitProbability = 0.0;
                if (dist > 400.0)
                    hitProbability = angleProb*distProb;
                else
                    hitProbability = distProb;


                double tankHealth = (1.0*tank.getCrewHealth())/tank.getCrewMaxHealth();
                //double overpower = selfHealth - tankHealth;
                //if (overpower < 0.0)
                //  overpower = 0.0;
                //double dangerDist = interpolate(250.0, 75.0, 1.5*overpower, true);
                //if (dist < dangerDist)
                //{
                //  hitProbability = interpolate(1.0, 0.8, dist/dangerDist, true);
                //}
                //else
                //{
                //  hitProbability = 0.8*hitProb(dist, 300.0)*phaseHitProb;
                //  hitProbability = 0.8*hitProb(dist, 300.0)*phaseHitProb;
                //}

                if (tank.getPremiumShellCount() > 0)
                    expectedDamage += 35*hitProbability;
                else
                    expectedDamage += 20*hitProbability;

                aliveEnemyCount += 1;
            }
            else if (isAlive(tank) && tank.isTeammate() == true && tank.getId() != self.getId())
            {
                double dist = distance(tankPos, p);
                if      (dist < 100.0)
                    expectedDamage += 20.0*interpolate(1.0, 0.0, dist/100.0, true);
                /*
                else if (dist > 150.0 && dist < 300.0)
                    expectedDamage += 20.0*interpolate(-0.5, 0.0, (dist-150.0)/150.0, true);
                    */
            }
        }

        if (world.getTick() < 250)
        {
            ArrayList<Vector2D>  cornerPoints = new ArrayList<Vector2D>();
            cornerPoints.add(new Vector2D(100.0, 100.0));
            cornerPoints.add(new Vector2D(worldWidth - 100.0, 100.0));
            cornerPoints.add(new Vector2D(100.0, worldHeight - 100.0));
            cornerPoints.add(new Vector2D(worldWidth - 100.0, worldHeight - 100.0));

            Vector2D nearestCorner = new Vector2D(self.getX(), self.getY());
            double   minDist = Double.MAX_VALUE;
            for (Vector2D corner: cornerPoints)
            {
                double dist = distance(corner, p);
                if (dist < minDist)
                {
                    minDist = dist;
                    nearestCorner = corner;
                }
            }

            double dist = distance(p, nearestCorner);
            if (dist < 800.0)
            {
                expectedDamage += 20.0*interpolate(-2.0, 0.0, dist/800.0, true);
            }
        }

        return expectedDamage;
    }

    public enum ObstacleType
    {
        NONE,
        ALIVE_TANK,
        DEAD_TANK,
        TEAMMATE_TANK,
        BONUS,
        OBSTACLE,
    }

    public static class WorldObstacle
    {
        public double x;
        public double y;
        public double width;
        public double height;
        public double angle;
        public long   id;
        public ObstacleType type;
    }

    public ArrayList<WorldObstacle> getWorldObstacles(World world)
    {
        ArrayList<WorldObstacle> worldObstacles = new ArrayList<WorldObstacle>();
        for (Tank tank: world.getTanks())
        {
            WorldObstacle wo = new WorldObstacle();
            wo.x = tank.getX();
            wo.y = tank.getY();
            wo.width = tank.getWidth();
            wo.height = tank.getHeight();
            wo.angle = tank.getAngle();
            wo.id = tank.getId();
            if (isAlive(tank))
            {
                if (tank.isTeammate() == true)
                {
                    wo.type = ObstacleType.TEAMMATE_TANK;
                }
                else
                {
                    wo.type = ObstacleType.ALIVE_TANK;
                }
            }
            else
            {
                wo.type = ObstacleType.DEAD_TANK;
            }

            worldObstacles.add(wo);
        }

        for (Bonus bonus: world.getBonuses())
        {
            WorldObstacle wo = new WorldObstacle();
            wo.x = bonus.getX();
            wo.y = bonus.getY();
            wo.width = bonus.getWidth();
            wo.height = bonus.getHeight();
            wo.angle = bonus.getAngle();
            wo.id = bonus.getId();
            wo.type = ObstacleType.BONUS;

            worldObstacles.add(wo);
        }

        for (Obstacle obstacle: world.getObstacles())
        {
            WorldObstacle wo = new WorldObstacle();
            wo.x = obstacle.getX();
            wo.y = obstacle.getY();
            wo.width = obstacle.getWidth();
            wo.height = obstacle.getHeight();
            wo.angle = obstacle.getAngle();
            wo.id = obstacle.getId();

            wo.type = ObstacleType.OBSTACLE;
            worldObstacles.add(wo);
        }

        return worldObstacles;
    }

    public double travelTimeFront(Tank tank, Vector2D p)
    {
        Vector2D tankPos = new Vector2D(tank.getX(), tank.getY());
        Vector2D deltaPos = sub(p, tankPos);
        double turnAngle = angleBetween(fromAngle(tank.getAngle()), deltaPos);
        double distance = length(deltaPos);

        return distance/(4.0*0.8) + Math.abs(turnAngle)/0.017;
    }

    public double travelTimeBack(Tank tank, Vector2D p)
    {
        Vector2D tankPos = new Vector2D(tank.getX(), tank.getY());
        Vector2D deltaPos = sub(p, tankPos);
        double turnAngle = angleBetween(mul(-1.0, fromAngle(tank.getAngle())), deltaPos);
        double distance = length(deltaPos);
        return distance/(2.6*0.9) + Math.abs(turnAngle)/0.017;
    }

    public ArrayList<Vector2D> samplePotentialTargetPoints(Tank self, int n)
    {
        Vector2D selfPos = new Vector2D(self.getX(), self.getY());
        int i = 0;
        int c = 0;
        ArrayList<Vector2D> pointList = new ArrayList<Vector2D>();

        while (i < n && c < 10*n)
        {
            c += 1;
            double angle = rand.nextGaussian()*Math.PI/4.0;
            if (angle > Math.PI/2.0)
                angle = Math.PI/2.0;
            else if (angle < -Math.PI/2.0)
                angle = -Math.PI/2.0;

            if (rand.nextBoolean())
            {
                angle += Math.PI;
                angle = normalizeAngle(angle);
            }

            double dist = rand.nextDouble()*500.0 + 70.0;

            Vector2D p = add(selfPos, mul(dist, fromAngle(angle)));
            double ribbonX = 100.0;
            double ribbonY = 100.0;
            if (p.x < (worldWidth - ribbonX) && p.x > ribbonX && p.y < (worldHeight - ribbonY) && p.y > ribbonY && dist > selfRadius)
            {
                pointList.add(p);
                i += 1;
            }
        }

        return pointList;
    }

    public Image drawDangerHeuristic(World world, Tank self)
    {
        double scale = 32.0;
        int width  = (int)Math.round(worldWidth/scale);
        int height = (int)Math.round(worldHeight/scale);
        BufferedImage heuristicImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        for (int y = 0; y < height; ++y)
        {
            for (int x = 0; x < width; ++x)
            {
                Vector2D p = new Vector2D(x*scale, y*scale);
                double heuristic = this.dangerHeuristic(world, p, self, false);
                heuristicImage.setRGB(x, y, grayRgb(heuristic/100.0));
            }
        }

        return heuristicImage;
    }

    public int grayRgb(double a)
    {
        int c = (int)(255.0*a);
        if (a > 255)
            a = 255;
        if (a < 0)
            a = 0;

        return (c << 16) + (c << 8) + c;
    }

    public double getTurretAngle(Tank tank)
    {
        return normalizeAngle(tank.getAngle() + tank.getTurretRelativeAngle());
    }

    enum MoodState
    {
        DEFENCIVE,
        AGRESSIVE,
    }

    public enum TargetType
    {
        NONE,
        BONUS_MEDIKIT,
        BONUS_REPAIR,
        BONUS_AMMO,
    }

    public static class UtilityTarget
    {
        public Vector2D   pos;
        public double     utilityFront;
        public double     utilityBack;
        public TargetType type;

        public UtilityTarget(Vector2D pos)
        {
            this.pos = pos;
            this.utilityFront = 0.0;
            this.utilityBack  = 0.0;
            this.type = TargetType.NONE;
        }
    }

    public double        selfRadius;
    public double        selfWidth;
    public double        selfHeight;
    public double        selfHealth;
    public double        selfDurability;
    public Random        rand = new Random(1234);
    Map<Long, TankEntry> tankEntryById = new LinkedHashMap<Long, TankEntry>();
    public long          selfId;
    public static long       enemyTargetId = -1;
    public static  boolean   updateTargetsFlag = false;

    public ArrayList<UtilityTarget> potentialTargets = new ArrayList<UtilityTarget>();
    public ArrayList<UtilityTarget> utilityTargets = new ArrayList<UtilityTarget>();
    public double bonusUtilityScale = 600.0;
    public double damageUtilityScale = 100.0;
    public Vector2D firePredcitedPos = new Vector2D(0.0, 0.0);

    public void updateUtility(World world, Tank self)
    {
        this.utilityTargets = new ArrayList<UtilityTarget>(potentialTargets);

        for (UtilityTarget uT: this.utilityTargets)
        {
            uT.utilityFront = 0.0;
            uT.utilityBack  = 0.0;
        }

        // add bonuses to targets
        for (Bonus bonus: world.getBonuses())
        {
            UtilityTarget uT = new UtilityTarget(new Vector2D(bonus.getX(), bonus.getY()));
            uT.type = TargetType.NONE;
            double travelCostFront = travelTimeFront(self, uT.pos);
            double travelCostBack  = travelTimeBack(self, uT.pos);

            if (bonus.getType() == BonusType.MEDIKIT)
            {
                uT.type = TargetType.BONUS_MEDIKIT;
                double utility = 1.5*(2.0 - selfHealth)*bonusUtilityScale;
                uT.utilityFront = utility/travelCostFront;
                uT.utilityBack  = utility/travelCostBack;
            }
            else if (bonus.getType() == BonusType.REPAIR_KIT)
            {
                uT.type = TargetType.BONUS_REPAIR;
                double utility = 1.5*(1.7 - selfDurability)*bonusUtilityScale;
                uT.utilityFront = utility/travelCostFront;
                uT.utilityBack  = utility/travelCostBack;
            }
            else if (bonus.getType() == BonusType.AMMO_CRATE)
            {
                uT.type = TargetType.BONUS_AMMO;
                double utility = 1.5*(1.0 - (1.0 - selfHealth)*(1.0 - selfDurability))*bonusUtilityScale;
                uT.utilityFront = utility/travelCostFront;
                uT.utilityBack  = utility/travelCostBack;
            }

            this.utilityTargets.add(uT);
        }

        // evaluate potential damage utility
        Vector2D selfPos = new Vector2D(self.getX(), self.getY());
        double   selfDamage = dangerHeuristic(world, selfPos, self, true);
        for (UtilityTarget uT: this.utilityTargets)
        {
            double travelCostFront = travelTimeFront(self, uT.pos);
            double travelCostBack  = travelTimeBack(self, uT.pos);
            double utilityFront = damageUtilityScale*(selfDamage - dangerHeuristic(world, uT.pos, self, false))/travelCostFront;
            double utilityBack  = damageUtilityScale*(selfDamage - dangerHeuristic(world, uT.pos, self, false))/travelCostBack;
            uT.utilityFront += utilityFront;
            uT.utilityBack  += utilityBack;
            if (enableDebug)
            {
                debug.setColor(Color.GREEN);
                debug.text(String.format("* (%.3f; %.3f)", dangerHeuristic(world, uT.pos, self, false), uT.utilityFront), uT.pos);
            }
        }
    }

    public double tankPathLength(Tank self, int k)
    {
        TankEntry entry = this.tankEntryById.get(self.getId());
        ArrayList<Vector2D>  posHistory = entry.posHistory;

        int s = posHistory.size() - k;
        if (s < 0)
            s = 0;

        if (posHistory.size() < 3)
            return 0.0;

        double distSum = 0.0;
        for (int i = s; i + 1 < posHistory.size(); ++i)
        {
            distSum += distance(posHistory.get(i), posHistory.get(i + 1));
        }
        return distSum;
    }

    public int antiStuckFix = 0;


    double shellHitTime(double dist, ShellType shellType)
    {
        if (shellType == ShellType.REGULAR)
        {
            /*
            double a = 1.0 - dist*0.005/16.666666;
            if (a < 1E-3)
                return 500.0;
            return Math.log(a)/Math.log(0.995);
            */
            return dist/16.0;
        }
        else
        {
            /*
            double a = 1.0 - dist*0.01/13.333333;
            if (a < 1E-3)
                return 500.0;
            return Math.log(a)/Math.log(0.99);
            */
            return dist/13.0;
        }
    }

    public void simpleMove(Tank self, World world, Move move)
    {
        if (world.getTick() == 0)
        {
            initSystem();
            initSelf(self, world, move);
        }

        Vector2D selfPos = new Vector2D(self.getX(), self.getY());
        selfId = self.getId();
        selfWidth  = self.getWidth();
        selfHeight = self.getHeight();
        selfRadius = length(new Vector2D(self.getHeight()*0.5, self.getWidth()*0.5));
        this.selfHealth  = (1.0*self.getCrewHealth())/self.getCrewMaxHealth();
        this.selfDurability = (1.0*self.getHullDurability())/self.getHullMaxDurability();
        ArrayList<Bonus> bonusList = new ArrayList<Bonus>(Arrays.asList(world.getBonuses()));
        ArrayList<Tank>  tankList = new ArrayList<Tank>(Arrays.asList(world.getTanks()));

        debug.clear();

        // update history
        for (Tank tank: world.getTanks())
        {
            TankEntry entry = this.tankEntryById.get(tank.getId());
            entry.thisTank = tank;
            entry.posHistory.add(new Vector2D(tank.getX(), tank.getY()));
            entry.angleHistory.add(tank.getAngle());
            entry.angularSpeedHistory.add(tank.getAngularSpeed());
            entry.speedHistory.add(getTankSpeed(tank));
            entry.velocityHistory.add(new Vector2D(tank.getSpeedX(), tank.getSpeedY()));

            if (entry.speedHistory.size() >= 2)
            {
                int sz = entry.speedHistory.size();
                entry.accelHistory.add(entry.speedHistory.get(sz - 1) - entry.speedHistory.get(sz - 2));
            }
            else
            {
                entry.accelHistory.add(0.0);
            }
        }

        // draw kinematic prediction
        if (enableDebug)
        {
            for (Tank tank: world.getTanks())
            {
                ArrayList<Vector2D> predictLine = new ArrayList<Vector2D>();

                Vector2D tankPos  = new Vector2D(tank.getX(), tank.getY());
                Vector2D front    = fromAngle(tank.getAngle());
                Vector2D frontPos = add(tankPos, mul(self.getWidth()*0.5, front));

                double   timeToHit = distance(selfPos, tankPos)/15.0;
                Vector2D hitPoint = predictKinematic(tank, timeToHit).p;

                ArrayList<Vector2D> predictPath = new ArrayList<Vector2D>();
                for (int t = 0; t < 30; t += 1)
                {
                    predictPath.add(predictKinematic(tank, t).p);
                }

                if (tank.getId() != self.getId())
                {
                    debug.setColor(Color.RED);
                    debug.text("h", hitPoint);
                }

                debug.setColor(Color.GREEN);
                debug.drawPolyLine(predictPath);
            }
        }


        // evaluate world state and make planing
        updateTargetsFlag = false;
        if (world.getTick() % 150 == 0)
        {
            updateTargetsFlag = true;
            this.potentialTargets.clear();
            for (Vector2D p:  samplePotentialTargetPoints(self, 50))
            {
                this.potentialTargets.add(new UtilityTarget(p));
            }
        }

        // find new enemy
        // enemyTargetId - static, so all tanks attack same target
        if (updateTargetsFlag || isAlive(this.tankEntryById.get(this.enemyTargetId).thisTank) == false)
        {

            long newEnemyTargetId = 0;
            Tank teamMate = self;
            for (Tank tank: world.getTanks())
            {
                if (tank.isTeammate() == true && tank.getId() != self.getId() && isAlive(tank) == true)
                {
                    teamMate = tank;
                }
            }

            // find target with minimal distance sum to self and team mate
            Vector2D teamMatePos = new Vector2D(teamMate.getX(), teamMate.getY());
            double minDistance = Double.MAX_VALUE;
            for (Tank tank: world.getTanks())
            {
                if (isAlive(tank) && tank.isTeammate() == false)
                {
                    Vector2D tankPos = new Vector2D(tank.getX(), tank.getY());

                    double dist = distance(selfPos, tankPos) + distance(teamMatePos, tankPos);
                    if (dist < minDistance)
                    {
                        minDistance = dist;
                        newEnemyTargetId = tank.getId();
                    }
                }
            }

            // if we already have enemy target
            if (this.enemyTargetId != -1)
            {
                Tank oldEnemy = this.tankEntryById.get(this.enemyTargetId).thisTank;
                Vector2D oldEnemyPos = new Vector2D(oldEnemy.getX(), oldEnemy.getY());
                Tank newEnemy = this.tankEntryById.get(newEnemyTargetId).thisTank;
                Vector2D newEnemyPos = new Vector2D(newEnemy.getX(), newEnemy.getY());
                double distNew = distance(selfPos, newEnemyPos) + distance(teamMatePos, newEnemyPos);
                double distOld = distance(selfPos, oldEnemyPos) + distance(teamMatePos, oldEnemyPos);

                // evaluate is better to switch or keep old target
                if ((distNew < distOld*0.7) || (isAlive(oldEnemy) == false))
                {
                    this.enemyTargetId = newEnemyTargetId;
                }
            }
            else
            {
                this.enemyTargetId = newEnemyTargetId;
            }

            updateTargetsFlag = false;
        }

        debug.drawImage(this.drawDangerHeuristic(world, self));

        debug.drawWorld(world);

        // update utility calculations
        updateUtility(world, self);

        // find max utility target, for two movement choice: moving frontal, or moving back
        // each utility target calculated "utility" base on this two movement choices
        UtilityTarget maxFrontUtilityTarget = new UtilityTarget(selfPos);
        double maxFrontUtility = -Double.MAX_VALUE;
        for (UtilityTarget uT: this.utilityTargets)
        {
            if (uT.utilityFront > maxFrontUtility)
            {
                maxFrontUtilityTarget = uT;
                maxFrontUtility       = uT.utilityFront;
            }
        }

        UtilityTarget maxBackUtilityTarget = new UtilityTarget(selfPos);
        double maxBackUtility = -Double.MAX_VALUE;
        for (UtilityTarget uT: this.utilityTargets)
        {
            if (uT.utilityBack > maxBackUtility)
            {
                maxBackUtilityTarget = uT;
                maxBackUtility = uT.utilityBack;
            }
        }

        // some debug visualisation
        debug.setColor(Color.RED);
        debug.text("*", maxFrontUtilityTarget.pos);

        debug.setColor(Color.MAGENTA);
        debug.text("O", maxBackUtilityTarget.pos);

        // find enemy tank by id
        Tank       enemyTank = this.tankEntryById.get(this.enemyTargetId).thisTank;
        Vector2D   enemyPos = new Vector2D(enemyTank.getX(), enemyTank.getY());

        debug.setColor(Color.MAGENTA);
        debug.text("E", enemyPos);

        double moveAngleDelta = 0.0;
        double leftPower  = 0.0;
        double rightPower = 0.0;
        boolean isMoveBack = false;

        debug.setColor(Color.BLACK);
        debug.text(String.format("(%f, %f)", maxFrontUtility, maxBackUtility), 100, 20);


        // find max utility and choose movment type
        if (maxFrontUtility > maxBackUtility)
        {
            debug.setColor(Color.GREEN);
            debug.text("FRONT", selfPos.x, selfPos.y + 20);
            Vector2D moveError = sub(maxFrontUtilityTarget.pos, selfPos);
            moveAngleDelta = angleBetween(self.getAngle(), toAngle(moveError));

            // move
            isMoveBack = false;
        }
        else
        {
            debug.setColor(Color.BLUE);
            debug.text("BACK", selfPos.x, selfPos.y + 20);
            Vector2D moveError = sub(maxBackUtilityTarget.pos, selfPos);
            moveAngleDelta = angleBetween(mul(-1.0, fromAngle(self.getAngle())), moveError);

            isMoveBack = true;
        }

        // basic movement
        if (isMoveBack)
        {
            if (moveAngleDelta < 0.0)
            {
                rightPower = -1.0;
                leftPower =interpolate(-1.0, 0.75, 3.0*Math.abs(moveAngleDelta)/Math.PI, true);
            }
            else
            {
                rightPower = interpolate(-1.0, 0.75, 3.0*Math.abs(moveAngleDelta)/Math.PI, true);
                leftPower = -1.0;
            }
        }
        else
        {
            if (moveAngleDelta > 0.0)
            {
                leftPower  = 1.0;
                rightPower = interpolate(1.0, -1.0, 2.5*Math.abs(moveAngleDelta)/Math.PI, true);
            }
            else
            {
                leftPower  = interpolate(1.0, -1.0, 2.5*Math.abs(moveAngleDelta)/Math.PI, true);
                rightPower = 1.0;
            }
        }

        //Vector2D moveTarget = maxUtilityTarget.pos;


        // try to predict enemy movement, ie point that our tank turret try to target
        double shellSpeed = 16.0;
        if (self.getPremiumShellCount() > 0)
            shellSpeed = 13.0;

        double   distanceToEnemy = distance(selfPos, enemyPos);
        double   hitTime = distanceToEnemy/shellSpeed;
        Vector2D turretTargetPos = enemyPos;
        if (distanceToEnemy < 700.0)
        {
            turretTargetPos = predictMinMax(enemyTank, selfPos, hitTime);
        }
        else
        {
            turretTargetPos = interpolate(enemyPos, predictKinematic(enemyTank, hitTime).p, 0.7, true);
        }

        double turretTargetAngle = angleBetween(sub(turretTargetPos, selfPos), fromAngle(getTurretAngle(self)));
        double turretSpeed = 3.14/180.0;
        double turretTurn = 0.0;

        // simple move turret base on angle delta
        if (turretTargetAngle > 0.0)
        {
            turretTurn = +1.0;
        }
        else
        {
            turretTurn = -1.0;
        }

        move.setTurretTurn(turretTurn);


        boolean isFire = false;
        // move turret
        // use angular speed to improve accuracy

        // calculate error if fire with current turret orientation and target position
        // if error to large, wait for next tick
        Vector2D turretD = fromAngle(getTurretAngle(self));
        double turretT = nearestPointAtRay(turretTargetPos, selfPos, turretD);
        if (turretT > 0)
        {
            Vector2D pointAtRay = add(selfPos, mul(turretT, turretD));
            if (distance(pointAtRay, turretTargetPos) < 5.0)
            {
                isFire = true;
            }
        }

        // check if path of fired shell free from obstacles (bonuses, dead tanks, teammates, etc)
        boolean haveObstacle = false;
        for (WorldObstacle obstacle: getWorldObstacles(world))
        {
            if (obstacle.id == selfId)
                continue;

            if (obstacle.type == ObstacleType.ALIVE_TANK)
                continue;

            Vector2D obstaclePos = new Vector2D(obstacle.x, obstacle.y);
            double obstacleRadius = length(new Vector2D(obstacle.height*0.5, obstacle.width*0.5));

            Vector2D td = fromAngle(getTurretAngle(self));
            double tt = nearestPointAtRay(obstaclePos, selfPos, td);
            if (tt > 0)
            {
                Vector2D pointAtRay = add(selfPos, mul(tt, td));
                if (distance(pointAtRay, obstaclePos) < obstacleRadius)
                {
                    haveObstacle = true;
                    break;
                }
            }
        }




        if (isFire && self.getRemainingReloadingTime() == 0)
        {
            this.firePredcitedPos = turretTargetPos;
        }

        debug.setColor(Color.BLUE);
        debug.text("o", this.firePredcitedPos);

        // fire if we can
        if (isFire == true && haveObstacle == false)
        {
            move.setFireType(FireType.PREMIUM_PREFERRED);
        }
        else
        {
            move.setFireType(FireType.NONE);
        }

        // shell avoidance logic
        // find shell ray with nearest distance to self
        double nearestShellDistance = Double.MAX_VALUE;
        Vector2D nearestShellRayPoint = new Vector2D(0.0, 0.0);
        Shell  nearestShell = null;
        for (Shell shell: world.getShells())
        {
            Vector2D d  = fromAngle(shell.getAngle());
            Vector2D sp = new Vector2D(shell.getX(), shell.getY());

            double t = nearestPointAtRay(selfPos, sp, d);
            if (t > 0.0)
            {
                Vector2D rp = add(sp, mul(t, d));
                Vector2D delta = sub(rp, selfPos);
                double dist = length(delta);
                if (dist < nearestShellDistance)
                {
                    nearestShellRayPoint = rp;
                    nearestShell = shell;
                    nearestShellDistance = dist;
                }
            }
        }


        if (nearestShell != null)
        {
            debug.setColor(Color.CYAN);
            debug.line(selfPos, nearestShellRayPoint);

            // check if distance to shell ray is really near
            if (nearestShellDistance < selfRadius*1.5)
            {
                // try to calculate two variants of actions
                // 1. move front at full speed
                // 2. move back at full speed
                // partially based on physic reverse engeenering at gamedev.ru
                Vector2D d  = fromAngle(nearestShell.getAngle());
                Vector2D sp = new Vector2D(nearestShell.getX(), nearestShell.getY());
                Vector2D selfDir   = fromAngle(self.getAngle());
                Vector2D selfVel   = new Vector2D(self.getSpeedX(), self.getSpeedY());
                double   selfSpeed = length(selfVel)*Math.signum(dotProduct(selfDir, selfVel));

                double   nt = nearestPointAtRay(selfPos, sp, d);
                Vector2D np = add(sp, mul(nt, d));
                double   nd   = dotProduct(selfDir, sub(np, selfPos));
                double  dist = distance(selfPos, sp);
                double  ht = this.shellHitTime(dist, nearestShell.getType());

                double health = (1.0*self.getCrewHealth())/self.getCrewMaxHealth();
                double frontA = self.getEnginePower()*(0.5 + 0.5*health)/(10.0*60.0);
                double backA  = -self.getEnginePower()*self.getEngineRearPowerFactor()*(0.5 + 0.5*health)/(10.0*60.0);
                double b = 1.0 - (0.5/10.0);


                double frontDelta = predictDistance(frontA, b, selfSpeed, ht) - self.getWidth() - nd;
                double backDelta  = predictDistance(backA, b, selfSpeed, ht) + self.getWidth() - nd;
                if (frontDelta > 0.0)
                {
                    leftPower = 1.0;
                    rightPower = 1.0;
                }
                else if (backDelta < 0.0)
                {
                    leftPower = -1.0;
                    rightPower = -1.0;
                }
                else if (nd > 0.5*self.getWidth())
                {
                    leftPower  = -1.0;
                    rightPower = -1.0;
                }
                else
                {
                    leftPower  = 1.0;
                    rightPower = 1.0;
                }

                debug.setColor(Color.MAGENTA);
                debug.text(String.format("(%f, %f), %f", frontDelta, backDelta, nd), 40, 200);
            }
        }


        // at start always move back
        if (world.getTick() < 10.0)
        {
            leftPower = -1.0;
            rightPower = -1.0;
        }

        move.setLeftTrackPower(leftPower);
        move.setRightTrackPower(rightPower);

        debug.drawMove(self, move);
        debug.present();
    }

    @Override
    public void move(Tank self, World world, Move move)
    {
        try
        {
            this.simpleMove(self, world, move);
        }
        catch (Exception ex)
        {
            enableDebug = false;
        }
    }


    @Override
    public TankType selectTank(int tankIndex, int teamSize)
    {
        return TankType.MEDIUM;
    }
}