#
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x76039c7f, pid=3372, tid=588
#
# JRE version: 7.0_07-b11
# Java VM: Java HotSpot(TM) Client VM (23.3-b01 mixed mode, sharing windows-x86 )
# Problematic frame:
# C  [msvcrt.dll+0x9c7f]
#
# Failed to write core dump. Minidumps are not enabled by default on client versions of Windows
#
# An error report file with more information is saved as:
# C:\Users\Trevor\Dropbox\Coding\workspace\LRR\hs_err_pid3372.log
#
# If you would like to submit a bug report, please visit:
#   http://bugreport.sun.com/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#
AL lib: alc_cleanup: 1 device not closed

      Pixmap lightMesh = new Pixmap(width, height, Pixmap.Format.RGBA8888);
      Blending blending = Pixmap.getBlending();
      lightMesh.setColor(0f, 0f, 0f, 0f);
      Pixmap.setBlending(Blending.None);

      int newX = Math.round(x);
      int newY = Math.round(y);

      lightMesh.fillCircle(newX, newY, radius);
      Pixmap.setBlending(blending);
      lightMesh.setColor(Color.BLACK);

public class ExpandableMatrix<T> {
   private T[][] data;
   private boolean locked = false;
   @SuppressWarnings("unchecked")
   public ExpandableMatrix(){
      data = (T[][]) new Object[1][1];
   }
   public T get(int x,int y){
      try{
         return data[x][y];
      }catch(Exception e){
         return null;
      }
   }
   public void fill(T object){
      for(int x = 0; x < getWidth();x++){
         for(int y = 0; y < getHeight();y++){
            put(object, x,y);
         }
      }
   }
   public ExpandableMatrix<T> expand(int newWidth, int newHeight) {
      if(locked){
         new Exception("Matrix cannot be expanded, it is locked.").printStackTrace();
         return this;
      }
      T[][] newData = newMatrix(newWidth, newHeight);
      
      if(newWidth  < getWidth() || getHeight() > newHeight){

         try{
            this.data = getSection(0,0,newWidth, newHeight);
         }catch(Exception e){
            for(int x = 0; x < newWidth; x++){
               for(int y = 0; y < newHeight;y++){
                  newData[x][y] = get(x,y);
               }
            }
            this.data = newData;
         }
         return this;
      }

      for(int x = 0; x < data.length;x++){
         System.arraycopy(data[x],0, newData[x], 0, data[x].length);
      }
      this.data = newData;
      return this;
   }
   public void put(T object, int x, int y){
      if(x < 0 || y < 0)
         throw new IllegalArgumentException("X and Y must be positive");
      if(x > data.length  || y > data[0].length){
         expand(x,y);
      }
      data[x][y] = object;
   }
   @SuppressWarnings("unchecked")
   private T[][] newMatrix(int width, int height){
      return (T[][]) new Object[width][height];
   }
   
   public T[][] getSection(int x, int y, int width, int height){
      if(isValidPosition(x,y) || isValidPosition(x + width, y + height))
         throw new IllegalArgumentException("Unable to get section, section invalid");
      
      T[][] newData = newMatrix(width, height);
      for(int x1 = x;x1 < x + width; x1++){
         for(int y1 = y; y1 < y + height;y1++){
            newData[x1 - x][y1 - y] = get(x1,y1);
         }
      }
      return newData;
   }
   public boolean isValidPosition(int x, int y){
      return (x < 0 || x > data.length || y < 0 || y > data[0].length);
   }
   public void clear(){
      data = newMatrix(1,1);
   }
   public void lock(){
      locked = true;
   }
   public void remove(int x, int y){
      data[x][y] = null;
   }
   public T[][] asMatrix(){
      return data;
   }
   public int getWidth(){
      return data.length;
   }
   public int getHeight(){
      return data[0].length;
   }
}

for(int i = 0;i < projectiles.size();i++){
     Attack a = projectiles.get(i);
     if(a.exists){
          a.update(bg);
     } else {
          projectiles.remove(i);
     }
}

g.rotate(this.rotation, this.pos.x + (this.actor.getImage(....).getWidth() / 2), this.pos.y + (this.actor.getImage(.....).getHeight() / 2)); 

public void draw(Graphics2D g){
     g.rotate(theta, x, y);
     g.drawImage(x,y);
     g.rotate(-theta,x,y);
}

public ArrayList<Entity> getEntitiesInRage(int range, Entity center){
     ArrayList<Entity> inRange = new ArrayList<Entity>();
     for(Entity e: fullList){
          if(e.getDistanceTo(center) >= range)
               inRange.add(e);
     }
     return inRange();

}

   public static Vector2D rotate(Vector2D origin,Vector2D point, double theta){
      double s = Math.sin(theta);
      double c = Math.cos(theta);
      // get the deltaX and deltaY
      point.x -= origin.x;   
       point.y -= origin.y;   

       // rotate point   
         double xnew = point.x * c - point.y * s;   
       double ynew = point.x * s + point.y * c; 

       // translate point back to global coords:
       Vector2D TranslatedPoint = new Vector2D(0,0);
       TranslatedPoint.x = xnew + origin.x;  
       TranslatedPoint.y = ynew + origin.y; 

       return TranslatedPoint;
       
   }