Tower Class:

package Engine;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;

public class Tower {

    public int x, y, pixX, pixY, id, id1, id2, id3;
    public int width = Screen.room.blockSize;
    public int height = Screen.room.blockSize;
    public int looseTime = 8000, looseFrame = 0;
    public int shotMob = -1;
    public int towerCircleSize = 130;
    public int resalePrice;
    public int slope;
    public int damage;

    public int targetX;
    public int targetY;

    public long lastIterationTime;
    public int delayTime;
    public int currentAnimationIndex;

    public long shotInterval;

    public double continuousDamage = 0;
    public int hitDamage;

    public int[] radiusUpgradePrice = new int[3];
    public int[] damageUpgradePrice = new int[3];
    public int[] speedUpgradePrice = new int[3];
    public int[] damageUpgradeAmount = new int[3];
    public int urPrice;
    public int udPrice;
    public int usPrice;
    public int offset = 1;

    public static int callCircleSize;

    public boolean shooting = false;
    public boolean drawRadius = false;
    public boolean inGame = false;
    public boolean animated = false;

    public boolean upgradeRadiiFirst = false;
    public boolean upgradeRadiiSecond = false;
    public boolean upgradeRadiiThird = false;

    public boolean upgradeDamageFirst = false;
    public boolean upgradeDamageSecond = false;
    public boolean upgradeDamageThird = false;

    public boolean upgradeSpeedFirst = false;
    public boolean upgradeSpeedSecond = false;
    public boolean upgradeSpeedThird = false;

    public Ellipse2D.Double circle;

    public Tower() {

    }

    public void drawTowerAt(int x, int y, int pixX, int pixY, Tower tower) {
        Screen.room.block[y][x].airID = id;
        if (Screen.room.towers[y][x] == null) {
            Screen.room.towers[y][x] = tower;
            inGame = true;
        }
        this.x = x;
        this.y = y;
        this.pixX = pixX;
        this.pixY = pixY;
        circle = new Ellipse2D.Double(pixX - (towerCircleSize / 2), pixY - (towerCircleSize / 2), width + (towerCircleSize), height + (towerCircleSize));
    }

    public void fight(Graphics g) {

    }

    public void setDamage(int dmg) {
        damage = dmg;
    }

    public void setDamageUpgradeAmount(int d1, int d2, int d3) {
        damageUpgradeAmount[0] = d1;
        damageUpgradeAmount[1] = d2;
        damageUpgradeAmount[2] = d3;
    }

    public void setAnimated(boolean animated) {
        this.animated = animated;
    }

    public void setResalePrice(int price) {
        this.resalePrice = price;
    }

    public void setTowerId(int id) {
        this.id = id;
    }

    public void setTowerId(int id1, int id2, int id3) {
        this.id = id1;
        this.id1 = id1;
        this.id2 = id2;
        this.id3 = id3;
    }

    public void setRadius(int radius) {
        towerCircleSize = radius;
        callCircleSize = radius;
    }

    public void physic() {

    }

    public void getMoney(int mobID) {
        Screen.coinage += Value.deathReward[mobID];
    }

    public void draw(Graphics g) {
        if (animated) {
            if ((System.currentTimeMillis() - lastIterationTime) >= (delayTime)) {
                lastIterationTime = System.currentTimeMillis();
                currentAnimationIndex = (currentAnimationIndex + 1) % Screen.room.towers.length;
                if (id == id1) {
                    id = id2;
                } else if (id == id2) {
                    id = id3;
                } else if (id == id3) {
                    id = id1;
                }
                Screen.room.block[y][x].airID = id;
            }
        }

        if (Screen.room.block[y][x].contains(Screen.mscf) && !Screen.isDrawingGui) {
            drawRadius(true);
            Screen.hasSelectedTower = true;
            Screen.selectedTower = this;
            Block.drawFixedOutline = true;
            Block.drawFixedOutline(x, y, g);
            Screen.upgrades.setSelectedTower(this);
        } else {
            Screen.hasSelectedTower = false;
            Screen.selectedTower = null;
            drawRadius(false);
            Block.drawFixedOutline = false;
        }

        if (Screen.room.block[y][x].contains(Screen.mse) && drawRadius) {
            Block.drawOutline = false;
        } else {
            Block.drawOutline = true;
        }

        if (drawRadius) {
            g.setColor(Color.BLACK);
            g.drawOval((int) circle.x, (int) circle.y, (int) circle.width, (int) circle.height);
        }

        Graphics2D g2d = (Graphics2D) g.create();

        double angle = Math.atan2(targetY - pixY, targetX - pixX) * 180 / Math.PI;
        g2d.translate(pixX, pixY);
        g2d.rotate(angle);
        g2d.drawImage(Screen.tileset_air[id], 0, 0, Screen.room.blockSize, Screen.room.blockSize, null);
        // g2d.drawImage(Screen.tileset_air[id], pixX, pixY,
        // Screen.room.blockSize, Screen.room.blockSize, null);
        // g2d.dispose();

        circle = new Ellipse2D.Double(circle.x, circle.y, width + (towerCircleSize), height + (towerCircleSize));
    }

    public void drawRadius(boolean choice) {
        if (choice) {
            drawRadius = true;
        } else {
            drawRadius = false;
        }
    }

    public void setFirstUpgradePrice(int first, int second, int third) {
        radiusUpgradePrice[0] = first;
        radiusUpgradePrice[1] = second;
        radiusUpgradePrice[2] = third;
        urPrice = first;
    }

    public void setSecondUpgradePrice(int first, int second, int third) {
        damageUpgradePrice[0] = first;
        damageUpgradePrice[1] = second;
        damageUpgradePrice[2] = third;
        udPrice = first;
    }

    public void sell() {
        Screen.coinage += resalePrice;
        Screen.room.block[y][x].airID = Value.airAir;
        Screen.room.towers[y][x] = null;
    }

    public int getRadius() {
        return towerCircleSize;
    }

    public void upgradeRadius() {
        if (Screen.coinage >= urPrice) {
            if (!upgradeRadiiFirst) {
                upgradeRadiiFirst = true;
                towerCircleSize += 20;
                offset += 10;
                circle.x -= offset;
                circle.y -= offset;
                Screen.coinage -= radiusUpgradePrice[0];
                urPrice = radiusUpgradePrice[1];
                Screen.upgrades.resalePrice = resalePrice;
                resalePrice += 3;
                return;
            } else if (!upgradeRadiiSecond) {
                upgradeRadiiSecond = true;
                towerCircleSize += 20;
                circle.x -= offset;
                circle.y -= offset;
                urPrice = radiusUpgradePrice[2];
                Screen.upgrades.resalePrice = resalePrice;
                Screen.coinage -= radiusUpgradePrice[1];
                resalePrice += 4;
                return;
            } else if (!upgradeRadiiThird) {
                upgradeRadiiThird = true;
                towerCircleSize += 20;
                circle.x -= offset;
                circle.y -= offset;
                urPrice = 0;
                Screen.upgrades.resalePrice = resalePrice;
                Screen.coinage -= radiusUpgradePrice[2];
                resalePrice += 4;
                return;
            }
        }
    }

    public void upgradeDamage() {
        if (Screen.coinage >= udPrice) {
            if (!upgradeDamageFirst) {
                upgradeDamageFirst = true;
                continuousDamage += .58;
                damage = damageUpgradeAmount[0];
                Screen.coinage -= damageUpgradePrice[0];
                udPrice = damageUpgradePrice[1];
                delayTime -= 100;
                resalePrice += 3;
                return;
            } else if (!upgradeDamageSecond) {
                upgradeDamageSecond = true;
                continuousDamage += .58;
                damage = damageUpgradeAmount[1];
                Screen.coinage -= damageUpgradePrice[1];
                udPrice = damageUpgradePrice[2];
                delayTime -= 100;
                resalePrice += 4;
                return;
            } else if (!upgradeDamageThird) {
                upgradeDamageThird = true;
                continuousDamage += .58;
                damage = damageUpgradeAmount[2];
                Screen.coinage -= damageUpgradePrice[2];
                udPrice = 0;
                delayTime -= 100;
                resalePrice += 4;
                return;
            }
        }
    }

    public void upgradeSpeed() {
        if (Screen.coinage >= udPrice && continuousDamage == 0) {
            if (!upgradeSpeedFirst) {
                upgradeSpeedFirst = true;
                shotInterval += 1;
                Screen.coinage -= speedUpgradePrice[0];
                udPrice = speedUpgradePrice[1];
                delayTime -= 100;
                resalePrice += 3;
                return;
            } else if (!upgradeSpeedSecond) {
                upgradeSpeedSecond = true;
                shotInterval += 1;
                Screen.coinage -= speedUpgradePrice[1];
                udPrice = speedUpgradePrice[2];
                delayTime -= 100;
                resalePrice += 4;
                return;
            } else if (!upgradeSpeedThird) {
                upgradeSpeedThird = true;
                shotInterval += 1;
                Screen.coinage -= speedUpgradePrice[2];
                udPrice = 0;
                delayTime -= 100;
                resalePrice += 4;
                return;
            }
        }
    }

    public void updateImage(int id) {
        Screen.room.block[y][x].airID = id;
    }
}


TowerCannon class:

package Engine;

import java.awt.Graphics;

public class TowerCannon extends Tower {

    public int fTime = 0;
    public int sTime = 200;

    int xPos = (int) Screen.room.block[y][x].x;
    int yPos = (int) Screen.room.block[y][x].y;

    public TowerCannon(int x, int y) {
        setRadius(200);
        setDamage(10);
        setDamageUpgradeAmount(14, 16, 18);
        setTowerId(Value.airTowerCannonUp);
        setResalePrice(10);
        setFirstUpgradePrice(5, 10, 15);
        setSecondUpgradePrice(5, 10, 15);
        drawTowerAt(x, y, Screen.room.block[y][x].x, Screen.room.block[y][x].y, this);
    }

    public void fight(Graphics g) {
        if (shooting && !Screen.mobs[shotMob].isDead() && Screen.inGame) {
            if (fTime >= sTime) {
                if (Screen.gameSpeed == 3) {
                    sTime = 200;
                } else {
                    sTime = 67;
                }
                shoot(g);
                fTime = 0;
            } else {
                fTime++;
            }
        }
    }

    @Override
    public void physic() {
        if (shooting) {
            for (int i = 0; i < Screen.mobs.length; i++) {
                if (Screen.mobs[i].inGame) {
                    if (Screen.mobs[i] != null && circle != null) {
                        targetX = Screen.mobs[i].x;
                        targetY = Screen.mobs[i].y;

                        /*
                         * if (targetY == x && targetX > x)
                         * updateImage(Value.airTowerCannonRight); if (targetY
                         * == y && x > targetX)
                         * updateImage(Value.airTowerCannonLeft);
                         */
                    }
                }
            }
        }

        if (shotMob != -1 && circle.intersects(Screen.mobs[shotMob])) {
            shooting = true;
        } else {
            shooting = false;
        }

        if (!shooting) {
            if (Screen.room.block[y][x].airID == id) {
                for (int i = 0; i < Screen.mobs.length; i++) {
                    if (Screen.mobs[i].inGame) {
                        if (Screen.mobs[i] != null && circle != null) {
                            if (circle.intersects(Screen.mobs[i])) {
                                shooting = true;
                                shotMob = i;
                            }
                        }
                    }
                }
            }
        }
    }

    public void shoot(Graphics g) {
        new CannonBall(shotMob, Screen.mobs[shotMob].x, Screen.mobs[shotMob].y, this, g);
    }
}