public abstract class RangedWeapon extends Weapon {
   protected double maxRange;
   protected int clipSize;
   protected int clip;
   protected double projectileVelocity;
   
   protected double coolDown;   //number of seconds to reduce from maximum to minimum bloom
   protected double heatUp;   //number of bullets to reach maximum bloom
   
   protected double reloadtime;
   protected double reload;
   
   protected double direction;
   
   protected HashMap<Attack, ArrayList<Sprite>> hits;
   
   public RangedWeapon(Sprite owner){
      super(owner);
      hits = new HashMap<Attack, ArrayList<Sprite>>();
      this.clip = 0;
   }

   
   
   
   public double getProjectileVelocity(){
      return projectileVelocity;
   }
   
   @Override
   public void use(double mouseX, double mouseY) {
      if(!(atkTime < speed) && clip != 0){
         atkTime = 0;
         direction = Math.atan2(mouseX - getOwner().getAX(), mouseY - getOwner().getAY());
         attack();
         clip -= 1;
         //Send threat
         t.threaten(getOwner().getWorld(), 0);
         
         accuracyModifier += (accuracy/2)/heatUp;
         if(accuracyModifier > accuracy/2){
            accuracyModifier = accuracy/2;
         }
      } else if(clip == 0 && !(reload < reloadtime)){
         getOwner().requestReload(this);
      }

   }
   
   public void attack(){
      attacks.add(new RangedAttack(getOwner().getAX(), getOwner().getAY(), this, direction + (Math.random()*2 -1)*(accuracy/2 + accuracyModifier + getOwner().getMoveAccuPenalty()*accuracy/2)));
   }
   
   @Override
   public void tick(double d){
      if(reload < reloadtime){
         reload += d;
         if(reload >= reloadtime){
            clip = clipSize;
         }
      }
      if(accuracyModifier > 0){
         accuracyModifier -= (accuracy/2)/coolDown*d;
      } else {
         accuracyModifier = 0;
      }
         
      if(atkTime < speed){
         atkTime += d;
      }
//      System.out.println(attacks.size());
      for(Attack a : attacks){
         ((RangedAttack) a).tick(d);
      }
   
      for(Attack a : attacks){
         CollisionReport cr = getOwner().getWorld().getCollisionReportForAttack(a);
         if(!hits.containsKey(a)){
            hits.put(a, new ArrayList<Sprite>());
         }
         for(Sprite s : cr.getCollidees()){
//            System.out.println(s);
            if(!hits.get(a).contains(s)){
               hits.get(a).add(s);
               s.receiveDamage(damage);
               s.receiveKnockBack(knockback, a.getX1(), a.getY1());
            }
         }
      }
   }

   
   public void removeAttack(RangedAttack a) {
//      System.out.println("removing attack");
      hits.remove(a);
      attacks.remove(a);
   }
   
   
   public void setReload(){
      reload = 0;
   }
   
   @Override
   public void reload(){
      getOwner().requestReload(this);
   }
   
   public Item equip(){
      if(reload < reloadtime){
         reload = 0;
      }
      return this;
   }
}

public boolean collision( Vector3f other, double dist )
   {
      if(this.loc.dist(other) > dist )
         return false;
      else 
         return true; 
   }

public double dist( Vector3f other )
   {
      return Math.sqrt(Math.pow(other.x - this.x, 2) + Math.pow(other.y - this.y, 2));
   }

 for(int x=0;x<bullets.size();x++)
       {
for(int z=0;z<enemyContainer.size();z++)
           {
           
                if(bullets.get(x).x > enemyContainer.get(z).x && bullets.get(x).x < enemyContainer.get(z).x + 64 
                && bullets.get(x).y > enemyContainer.get(z).y && bullets.get(x).y < enemyContainer.get(z).y + 32 )
                {
                    enemyContainer.get(z).hp=enemyContainer.get(z).hp-1;
                }
            }
}

public interface ShotListener {
              public boolean shotPerformed(ShotEvent event);
}

public class ShotEvent {
            private Bullet bullet;

            public ShotEvent(Bullet bullet) {
                        this.bullet = bullet;
            }

            public int getX() { return bullet.getX(); }
            public int getY() { return bullet.getY(); }
}