Platformer Time Dissapearing Tiles Example

In this example you can move the player across tiles that dissapear after 2 seconds after they have been touched.

 


import java.awt.*;
import java.applet.*;

public class tdtilesexample001 extends Applet implements Runnable {
 Graphics     bufferGraphics;
    Image      offscreen;
 private int map[][] =  new int[][]{
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,1,1,1,2,2,2,2,2,2,2,1,1,1},
 {1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,2,2,1,1,1,1,1,1,1,1,1,1,1},
 {1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 };
 int mapwidth = 20;
 int mapheight = 15;
 int cellwidth = 16;
 int cellheight = 16;
 double     px =     132;
 double    py =    200;
 int     pwidth =    cellwidth/2;
 int     pheight =    cellheight;
 boolean    isjumping =   false;
 boolean    isfalling =   false;
 double    gravity =    0;
 boolean    ismovingright =  false;
 boolean    ismovingleft =   false;
 double    jumpforce =   3;
 int     numdoors =   10;
 int     numtdt =   32;
 int[][]    tdt =    new int[ numtdt ][ 3 ]; // active , x , y , timeout
 long[]    tdttimeout =  new long[ numtdt ];

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
     // read time dissapearing tiles
     for ( int y = 0 ; y < mapheight ; y++ ){
     for ( int x = 0 ; x < mapwidth ; x++ ){
      if ( map[ y ][ x ] == 2 ){
       int n = freetdt();
       tdt[ n ][ 0 ] = 1;
       tdt[ n ][ 1 ] = x;
       tdt[ n ][ 2 ] = y;
       tdttimeout[ n ] = -1;
       map[ y ][ x ] = 0;
      }
     }
     }
  new Thread(this).start();
 }

 public int freetdt(){
  for ( int i = 0 ; i < numtdt ; i++ ){
   if ( tdt[ i ][ 0 ] == 0 ){
    return i;
   }
  }
  return -1;
 }

    public void run() {
     for(;;) { // animation loop never ends
         repaint();
         try {
       updateplayer();
    updatetdt();
             Thread.sleep(16);
            }
             catch (InterruptedException e) {
             }
     }
    }
    public void update(Graphics g){
     bufferGraphics.clearRect(0,0,getSize().width,getSize().width);
        // Draw map
        for( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++){
          if( map[y][x] == 1 ){
           bufferGraphics.setColor(Color.white);
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }

         }
        }
        // Draw time dissapearing tiles
        bufferGraphics.setColor(Color.yellow);
        for ( int i = 0 ; i < numtdt ; i++ ){
         if ( tdt[ i ][ 0 ] == 1 ){
          bufferGraphics.fillRect(  tdt[ i ][ 1 ] * cellwidth ,
                 tdt[ i ][ 2 ] * cellheight ,
                 cellwidth ,
                 cellheight );
         }
        }
        // Draw player
        bufferGraphics.setColor(Color.red);
        bufferGraphics.fillRect( (int)px , (int)py , pwidth , pheight );

        bufferGraphics.setColor(Color.red);
        bufferGraphics.drawString("Platformer Time Dissapearing tiles Example.",10,10);
        bufferGraphics.drawString("a - left, d - right, space - jump.",10,240);

       g.drawImage(offscreen,0,0,this);
    }

    public void updatetdt(){
     for ( int i = 0 ; i < numtdt ; i++ ){
      if ( tdt[ i ][ 0 ] == 1 ){
       if ( tdtcollision( (int)px , (int)py + 1 ) == i ){
        tdttimeout[ i ] = System.currentTimeMillis() + 2000;
       }
      }
     }
     for ( int i = 0 ; i < numtdt ; i++ ){
      if ( tdttimeout[ i ] > -1 ){
       if ( tdttimeout[ i ] < System.currentTimeMillis() ){
        tdttimeout[ i ] = -1;
        tdt[ i ][ 0 ] = -1;
       }
      }
     }
    }

 public void updateplayer(){

  if ( isjumping == false && isfalling == false ){
   if(  mapcollision( (int)px , (int)py+1 , pwidth , pheight ) == false &&
     tdtcollision( (int)px , (int)py + 1 ) == -1 ){
    isfalling = true;
    gravity = 0;
   }
  }
  if (ismovingright){
   if (  mapcollision( (int)(px + 1) , (int)py , pwidth , pheight ) == false &&
     tdtcollision( (int)px + 1 , (int)py ) == -1 ){
    px += 1;
   }
  }
  if (ismovingleft){
   if (  mapcollision( (int)(px - 1) , (int)py , pwidth , pheight ) == false &&
     tdtcollision( (int)px - 1 , (int)py ) == -1 ){
    px -= 1;
   }
  }

  if ( isfalling == true && isjumping == false ){
   for ( int i = 0 ; i < gravity ; i++ ){
    if (  mapcollision ( (int)px , (int)(py + 1) , pwidth , pheight ) == false &&
      tdtcollision( (int)px , (int)py + 1) == -1 ){
     py += 1;
    }else{
     gravity = 0;
     isfalling = false;
    }
   }
   gravity += .1;
  }

  if ( isjumping == true && isfalling == false ){
   for ( int i = 0 ; i < gravity ; i++){
    if (  mapcollision ( (int)px , (int)(py - 1) , pwidth , pheight ) == false &&
      tdtcollision( (int)px , (int)py - 1 ) == -1 ){
     py -= 1;
     //System.out.print("still jumping : " + gravity);
    }else{
     gravity = 0;
     isfalling = true;
     isjumping = false;
    }
   }
   if( gravity < 1 ) {
    gravity = 0;
    isfalling = true;
    isjumping = false;
   }
   gravity -= .1;
  }
    }

    public int tdtcollision( int x , int y ){
     for ( int i = 0 ; i < numtdt ; i++ ){
      if ( tdt[ i ][ 0 ] == 1 ){
     Rectangle rec1 = new Rectangle( x , y , pwidth , pheight );
    Rectangle rec2 = new Rectangle( tdt[ i ][ 1 ] * cellwidth,
            tdt[ i ][ 2 ] * cellheight,
            cellwidth,
            cellheight);
    if( rec1.intersects( rec2 )) return i;

      }
     }
     return -1;
    }

  public boolean mapcollision( int x , int y , int width , int height ){
   int mapx = x / cellwidth;
   int mapy = y / cellheight;
   for ( int y1 = mapy - 1 ; y1 < mapy + 2 ; y1++ ){
    for ( int x1 = mapx - 1 ; x1 < mapx + 2 ; x1++ ){
     if ( x1 >= 0 && x1 < mapwidth && y1 >= 0 && y1 < mapheight ){
      if ( map[y1][x1] == 1 ){
       Rectangle rec1 = new Rectangle( x , y , width , height );
      Rectangle rec2 = new Rectangle( x1 * cellwidth,
              y1 * cellheight,
              cellwidth,
              cellheight);
      if( rec1.intersects( rec2 )) return true;
      }
     }
    }
   }
  return false;
  }
  public boolean keyDown (Event e, int key){
    if( key == 97 ) // a key
        {
         ismovingleft = true;
        }
        if(key== 100) // d key
        {
          ismovingright = true;
        }

      if( key == 32 ) // space bar for jump
      {
        if( isfalling == false && isjumping == false )
        {
            isjumping = true;
            gravity = jumpforce;
        }
      }

        System.out.println (" Integer Value: " + key);

   return true;
  }

 public boolean keyUp (Event e, int key){
    if( key == 97 ) // a key
        {
          ismovingleft = false;
        }
        if( key == 100 ) // d key
        {
          ismovingright = false;
        }
  return true;
 }



}

2d Topdown Doors and keys Example

In this example there is a map where you can grab the yellow keys and open the blue doors. The controls hints are shown in the applet window. The sourcecode is below.

 


import java.awt.*;
import java.applet.*;

public class topdowndoorsandkeysexample001 extends Applet implements Runnable{

 Graphics bufferGraphics;
 Image offscreen;
 boolean ismovingleft;
 boolean ismovingright;
 boolean ismovingup;
 boolean ismovingdown;
 private int map[][] =  new int[][]{
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,1},
 {1,0,1,1,1,1,0,1,1,1,0,0,1,1,1,0,1,1,0,1},
 {1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,0,0,1},
 {1,0,1,0,1,0,0,1,0,1,0,1,1,0,1,0,0,1,0,1},
 {1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1},
 {1,0,1,0,2,0,0,1,0,2,0,0,1,0,2,0,0,1,0,1},
 {1,0,1,1,1,0,0,1,1,1,0,1,1,1,1,0,0,0,0,1},
 {1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1},
 {1,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1},
 {1,0,1,0,1,0,0,1,1,0,0,1,1,0,0,1,0,1,0,1},
 {1,0,0,0,1,0,0,1,0,0,0,0,1,0,0,1,0,0,0,1},
 {1,0,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1,1,0,1},
 {1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,1},
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 };
 int mapwidth = 20;
 int mapheight = 15;
 int cellwidth = 16;
 int cellheight = 16;
 int pwidth = 16;
 int pheight = 16;
 int playerx = 10*cellwidth;
 int playery = 13*cellheight;
 int numkeys = 4;
 int[][] keys = new int[ numkeys ][ 3 ]; // active, x , y
 int numdoors = 4;
 int[][] doors = new int[ numdoors ][ 3 ]; // active, x , y
 int playerkeys = 0;

 public void init() {
        setBackground(Color.black);
        offscreen = createImage(getSize().width,getSize().height);
        bufferGraphics = offscreen.getGraphics();
        readkeysanddoors();
  new Thread(this).start();
 }

 public void readkeysanddoors(){
  for ( int y = 0 ; y < mapheight ; y++ ){
  for ( int x = 0 ; x < mapwidth ; x++ ){
   if ( map[ y ][ x ] == 2 ){ // if door
    int n = findfreedoor();
    doors[ n ][ 0 ] = 1;
    doors[ n ][ 1 ] = x;
    doors[ n ][ 2 ] = y;
    map[ y ][ x ] = 0;
   }
   if ( map[ y ][ x ] == 3 ){ // if key
    int n = findfreekey();
    keys[ n ][ 0 ] = 1;
    keys[ n ][ 1 ] = x;
    keys[ n ][ 2 ] = y;
    map[ y ][ x ] = 0;
   }
  }
  }
 }

 public int findfreedoor(){
  for ( int i = 0 ; i < numdoors ; i++ ){
   if ( doors[ i ][ 0 ] == 0 ){
    return i;
   }
  }
  return -1;
 }
 public int findfreekey(){
  for ( int i = 0 ; i < numkeys ; i++ ){
   if ( keys[ i ][ 0 ] == 0 ){
    return i;
   }
  }
  return -1;
 }

    public void run() {
        for(;;) { // animation loop never ends
   moveplayer();
    playerdoors();
   playerkeys();
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

 public int isdoorcollision( int x , int y ){
  for ( int i = 0 ; i < numdoors ; i++ ){
   if ( doors[ i ][ 0 ] == 1 ){
    Rectangle rec1 = new Rectangle(  doors[ i ][ 1 ] * cellwidth ,
              doors[ i ][ 2 ] * cellheight ,
              cellwidth ,
              cellheight );
    Rectangle rec2 = new Rectangle(  x,
             y,
             cellwidth,
             cellheight);
    if(rec1.intersects(rec2)) return i;
   }
  }
  return -1; }

 public int iskeycollision( int x , int y ){
  for ( int i = 0 ; i < numkeys ; i++ ){
   if ( keys[ i ][ 0 ] == 1 ){
    Rectangle rec1 = new Rectangle(  keys[ i ][ 1 ] * cellwidth ,
              keys[ i ][ 2 ] * cellheight ,
              cellwidth ,
              cellheight );
    Rectangle rec2 = new Rectangle(  x,
             y,
             cellwidth,
             cellheight);
    if(rec1.intersects(rec2)) return i;
   }
  }
  return -1;
 }

    public boolean ismapcollision(int x, int y){

  int pcx = x / cellwidth;
  int pcy = y / cellheight;
  for (int y1 = pcy - 1 ; y1 < pcy + 2 ; y1++){
   for (int x1 = pcx - 1 ; x1 < pcx + 2 ; x1++){
    if( x1 >= 0 && x1 < mapwidth && y1 >= 0 && y1 < mapheight ){
     if ( map[y1][x1] == 1 ){
      Rectangle rec1 = new Rectangle(  x1 * cellwidth ,
                y1 * cellheight ,
                cellwidth ,
                cellheight );
      Rectangle rec2 = new Rectangle(  x,
               y,
               cellwidth,
               cellheight);
      if(rec1.intersects(rec2)) return true;
     }
    }
   }
  }
  return false;
    }

 public void playerkeys(){
  if ( ismovingleft ){
   int thekey = iskeycollision( playerx - 1 , playery );
   if ( thekey > -1 ){
    playerkeys++;
    keys[ thekey ][ 0 ] = 0;
   }
  }
  if ( ismovingright ){
   int thekey = iskeycollision( playerx + 1 , playery );
   if ( thekey > -1 ){
    playerkeys++;
    keys[ thekey ][ 0 ] = 0;
   }
  }
  if ( ismovingup ){
   int thekey = iskeycollision( playerx , playery - 1);
   if ( thekey > -1 ){
    playerkeys++;
    keys[ thekey ][ 0 ] = 0;
   }
  }
  if ( ismovingdown ){
   int thekey = iskeycollision( playerx , playery + 1 );
   if ( thekey > -1 ){
    playerkeys++;
    keys[ thekey ][ 0 ] = 0;
   }
  }

 }

 public void playerdoors(){
    if ( ismovingleft == true ){
   if ( playerkeys > 0 ){
    int thedoor = isdoorcollision( playerx - 1 , playery );
    if ( thedoor > -1 ){
     playerkeys--;
     doors[ thedoor ][ 0 ] = 0;
    }
   }
  }
  if ( ismovingright == true ){
   if ( playerkeys > 0 ){
    int thedoor = isdoorcollision( playerx + 1 , playery );
    if ( thedoor > -1 ){
     playerkeys--;
     doors[ thedoor ][ 0 ] = 0;
    }
   }
  }
  if ( ismovingup == true ){
   if ( playerkeys > 0 ){
    int thedoor = isdoorcollision( playerx , playery - 1 );
    if ( thedoor > -1 ){
     playerkeys--;
     doors[ thedoor ][ 0 ] = 0;
    }
   }
  }
  if ( ismovingdown == true ){
   if ( playerkeys > 0 ){
    int thedoor = isdoorcollision( playerx , playery + 1 );
    if ( thedoor > -1 ){
     playerkeys--;
     doors[ thedoor ][ 0 ] = 0;
    }
   }
  }

 }

    public void moveplayer(){
     if (  ismovingright == true &&
       ismapcollision( playerx + 1 , playery ) == false &&
       isdoorcollision( playerx + 1 , playery ) < 0 ){
      playerx++;
     }
     if ( ismovingup == true &&
       ismapcollision( playerx , playery - 1 ) == false &&
       isdoorcollision( playerx , playery - 1 ) < 0 ){
      playery--;
     }
     if ( ismovingdown == true &&
       ismapcollision( playerx , playery + 1 ) == false &&
       isdoorcollision( playerx , playery + 1 ) < 0 ){
      playery++;
     }
     if ( ismovingleft == true &&
       ismapcollision( playerx - 1 , playery ) == false &&
       isdoorcollision( playerx - 1 , playery ) < 0 ){
      playerx--;
     }


    }

     public void update(Graphics g){
     bufferGraphics.clearRect(0,0,getSize().width,getSize().height);

  // Draw map
  bufferGraphics.setColor(Color.white);
        for( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++){
          if( map[y][x] == 1 ){
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }
         }
        }

  // Draw doors
  bufferGraphics.setColor( Color.blue );
  for ( int i = 0 ; i < numdoors ; i++ ){
   if ( doors[ i ][ 0 ] == 1 ){
    bufferGraphics.fillRect(  doors[ i ][ 1 ] * cellwidth ,
           doors[ i ][ 2 ] * cellheight ,
           cellwidth ,
           cellheight );
   }
  }
  // Draw keys
  bufferGraphics.setColor( Color.yellow );
  for ( int i = 0 ; i < numkeys ; i++ ){
   if ( keys[ i ][ 0 ] == 1 ){
    bufferGraphics.fillOval( keys[ i ][ 1 ] * cellwidth ,
           keys[ i ][ 2 ] * cellheight ,
           cellwidth ,
           cellheight );
   }
  }

  // Draw player
     bufferGraphics.setColor(Color.red);
  bufferGraphics.fillOval(playerx,playery,cellwidth,cellheight);

        bufferGraphics.drawString("2D Topdown Doors and keys.",10,10);
        bufferGraphics.drawString("Keys : " + playerkeys , 200 , 10 );
  bufferGraphics.drawString("w/s/a/d = movement, yellow = key, blue = door.",10,237);

        g.drawImage(offscreen,0,0,this);
     }
  public boolean keyDown (Event e, int key){
   if(key==97)
        {
         ismovingleft = true;
        }
        if(key==100)
        {
         ismovingright = true;
        }
        if(key==119)
        {
         ismovingup = true;
        }
        if(key==115)
        {
         ismovingdown = true;
        }

   return true;
  }
 public boolean keyUp (Event e, int key){

   if(key==97)
        {
         ismovingleft = false;
        }
        if(key==100)
        {
         ismovingright = false;
        }
        if(key==119)
        {
         ismovingup = false;
        }
        if(key==115)
        {
         ismovingdown = false;
        }
//  System.out.println(""+key);
  return true;
 }


}

Platformer Doors Example

Platformer Doors Example. The instructions are shown in the applet window. The yellow blocks are the doors. Sourcecode is below.

 


import java.awt.*;
import java.applet.*;

public class platformerdoorsexample001 extends Applet implements Runnable {
 Graphics     bufferGraphics;
    Image      offscreen;
 private int map[][] =  new int[][]{
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1},
 {1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1},
 {1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 };
 int mapwidth = 20;
 int mapheight = 15;
 int cellwidth = 16;
 int cellheight = 16;
 double     px =     132;
 double    py =    200;
 int     pwidth =    cellwidth/2;
 int     pheight =    cellheight;
 boolean    isjumping =   false;
 boolean    isfalling =   false;
 double    gravity =    0;
 boolean    ismovingright =  false;
 boolean    ismovingleft =   false;
 double    jumpforce =   3;
 int     numdoors =   10;
 private int[][] door = new int[ numdoors ][ 4 ]; // door ] active , x , y , teleport_to

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
     // Door 1
     door[ 0 ][ 0 ] = 1;
     door[ 0 ][ 1 ] = 14;
     door[ 0 ][ 2 ] = 13;
     door[ 0 ][ 3 ] = 1;
     // Door 2
     door[ 1 ][ 0 ] = 1;
     door[ 1 ][ 1 ] = 15;
     door[ 1 ][ 2 ] = 10;
     door[ 1 ][ 3 ] = 0;
     // Door 3
     door[ 2 ][ 0 ] = 1;
     door[ 2 ][ 1 ] = 10;
     door[ 2 ][ 2 ] = 10;
     door[ 2 ][ 3 ] = 3;
     // Door 4
     door[ 3 ][ 0 ] = 1;
     door[ 3 ][ 1 ] = 14;
     door[ 3 ][ 2 ] = 3;
     door[ 3 ][ 3 ] = 2;
     //
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
         repaint();
         try {
       updateplayer();
             Thread.sleep(16);
            }
             catch (InterruptedException e) {
             }
     }
    }
    public void update(Graphics g){
     bufferGraphics.clearRect(0,0,getSize().width,getSize().width);
        // Draw map
        for( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++){
          if( map[y][x] == 1 ){
           bufferGraphics.setColor(Color.white);
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }
          if( map[y][x] == 2 ){
           bufferGraphics.setColor(Color.yellow);
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }

         }
        }
        // Draw doors
        bufferGraphics.setColor(Color.yellow);
        for ( int i = 0 ; i < numdoors ; i++ ){
         if ( door[ i ][ 0 ] == 1 ){
          bufferGraphics.fillRect(  door[ i ][ 1 ] * cellwidth ,
                 door[ i ][ 2 ] * cellheight ,
                 cellwidth ,
                 cellheight );
         }
        }
        // Draw player
        bufferGraphics.setColor(Color.red);
        bufferGraphics.fillRect( (int)px , (int)py , pwidth , pheight );

        bufferGraphics.setColor(Color.red);
        bufferGraphics.drawString("Platformer Doors Example.",10,10);
        bufferGraphics.drawString("a - left, d - right, space - jump, w - enter door.",10,240);

       g.drawImage(offscreen,0,0,this);
    }
    public void updateplayer(){

  if ( isjumping == false && isfalling == false ){
   if( mapcollision( (int)px , (int)py+1 , pwidth , pheight ) == false ){
    isfalling = true;
    gravity = 0;
   }
  }
  if (ismovingright){
   if ( mapcollision( (int)(px + 1) , (int)py , pwidth , pheight ) == false ){
    px += 1;
   }
  }
  if (ismovingleft){
   if ( mapcollision( (int)(px - 1) , (int)py , pwidth , pheight ) == false ){
    px -= 1;
   }
  }

  if ( isfalling == true && isjumping == false ){
   for ( int i = 0 ; i < gravity ; i++ ){
    if ( mapcollision ( (int)px , (int)(py + 1) , pwidth , pheight ) == false ){
     py += 1;
    }else{
     gravity = 0;
     isfalling = false;
    }
   }
   gravity += .1;
  }

  if ( isjumping == true && isfalling == false ){
   for ( int i = 0 ; i < gravity ; i++){
    if ( mapcollision ( (int)px , (int)(py - 1) , pwidth , pheight ) == false ){
     py -= 1;
     //System.out.print("still jumping : " + gravity);
    }else{
     gravity = 0;
     isfalling = true;
     isjumping = false;
    }
   }
   if( gravity < 1 ) {
    gravity = 0;
    isfalling = true;
    isjumping = false;
   }
   gravity -= .1;
  }
    }
  public boolean mapcollision( int x , int y , int width , int height ){
   int mapx = x / cellwidth;
   int mapy = y / cellheight;
   for ( int y1 = mapy - 1 ; y1 < mapy + 2 ; y1++ ){
    for ( int x1 = mapx - 1 ; x1 < mapx + 2 ; x1++ ){
     if ( x1 >= 0 && x1 < mapwidth && y1 >= 0 && y1 < mapheight ){
      if ( map[y1][x1] == 1 ){
       Rectangle rec1 = new Rectangle( x , y , width , height );
      Rectangle rec2 = new Rectangle( x1 * cellwidth,
              y1 * cellheight,
              cellwidth,
              cellheight);
      if( rec1.intersects( rec2 )) return true;
      }
     }
    }
   }
  return false;
  }

 public Integer doorcollision( int x , int y , int w , int h ){
  int returnvalue = -1;
  for ( int i = 0 ; i < numdoors ; i++ ){
   if ( door[ i ][ 0 ] == 1 ){
    Rectangle rec1 = new Rectangle( x , y , w , h );
    Rectangle rec2 = new Rectangle( door[ i ][ 1 ]  * cellwidth,
            door[ i ][ 2 ]  * cellheight,
            cellwidth,
            cellheight);
    if( rec1.intersects( rec2 )) return i;
   }
  }
  return returnvalue;
 }

  public boolean keyDown (Event e, int key){
    if( key == 97 ) // a key
        {
         ismovingleft = true;
        }
        if(key== 100) // d key
        {
          ismovingright = true;
        }

      if( key == 32 ) // space bar for jump
      {
        if( isfalling == false && isjumping == false )
        {
            isjumping = true;
            gravity = jumpforce;
        }
      }

        System.out.println (" Integer Value: " + key);

   return true;
  }

 public boolean keyUp (Event e, int key){
    if( key == 97 ) // a key
        {
          ismovingleft = false;
        }
        if( key == 100 ) // d key
        {
          ismovingright = false;
        }
  if( key == 119 ) // w key
  {
   int thedoor = -1;
   thedoor = doorcollision( (int)px , (int)py , pwidth , pheight );
   if ( thedoor > -1 ){
    int tdoor = door[ thedoor ][ 3 ];
    px = door[ tdoor ][ 1 ] * cellwidth + cellwidth / 4;
    py = door[ tdoor ][ 2 ] * cellheight;
   }
  }
  return true;
 }


}

Platformer Ladders Example

Use w s a d to control the player block. Move to the ladders and press w or s to move up or down.

 

import java.awt.*;
import java.applet.*;

public class platformerladdersexample001 extends Applet implements Runnable {
 Graphics bufferGraphics;
    Image offscreen;
 private int map[][] =  new int[][]{
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,1,2,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,1,2,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
 {1,0,0,0,0,0,0,2,1,1,1,1,1,1,1,2,1,0,0,1},
 {1,0,0,0,0,0,0,2,0,0,0,0,1,1,1,2,1,0,0,1},
 {1,0,0,0,1,1,1,2,1,0,0,0,0,0,0,2,0,0,0,1},
 {1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,1},
 {1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2,1,1,1},
 {1,1,1,2,1,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1},
 {1,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1},
 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 };
 int     mapwidth =    20;
 int     mapheight =   15;
 int     cellwidth =   16;
 int     cellheight =   16;
 double     px =     132;
 double    py =    200;
 int     pwidth =    cellwidth/2;
 int     pheight =    cellheight;
 boolean    isjumping =   false;
 boolean    isfalling =   false;
 double    gravity =    0;
 boolean    ismovingright =  false;
 boolean    ismovingleft =   false;
 boolean    ismovingup =  false;
 boolean    ismovingdown =   false;
 double    jumpforce =   3;
 boolean    onladder =    false;

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
     updateplayer();
         repaint();
         try {
             Thread.sleep(16);
            }
             catch (InterruptedException e) {
            }
     }
    }

 public void update (Graphics g) {
  bufferGraphics.clearRect( 0 , 0 , getSize().width , getSize().height );
        // Draw map
        for( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++){
          if( map[ y ][ x ] == 1 ){
        bufferGraphics.setColor ( Color.white );
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }
          if( map[ y ][ x ] == 2 ){ // Draw ladder
           bufferGraphics.setColor ( new Color( 170 , 130 , 0 ) );
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , 3 );
           bufferGraphics.fillRect( x * cellwidth , y * cellheight +6 , cellwidth , 3 );
           bufferGraphics.fillRect( x * cellwidth , y * cellheight + 12 , cellwidth , 3 );

          }
         }
        }
        // Draw player
        bufferGraphics.fillRect( (int)px , (int)py , pwidth , pheight );

     bufferGraphics.setColor ( Color.green );
     bufferGraphics.drawString( "Platformer Ladders Eample." , 10 , 10 );
       g.drawImage(offscreen,0,0,this);
  }
    public void updateplayer(){
  boolean ontheladder = laddercollision( (int)px , (int)py , pwidth , pheight );
  if ( ontheladder ) {
   if ( ismovingup ) {
    py--;
   }
  }
  if (  laddercollision( (int)px , (int)py+pheight , pwidth , 1 ) ||
     mapcollision( (int)px , (int)py+pheight , pwidth , pheight ) == false ) {
   if ( ismovingdown ) {
    py++;
   }
  }

  if ( isjumping == false && isfalling == false && ontheladder == false ){
   if( mapcollision( (int)px , (int)py+1 , pwidth , pheight ) == false ){
    isfalling = true;
    gravity = 0;
   }
  }
  if (ismovingright){
   if ( mapcollision( (int)(px + 1) , (int)py , pwidth , pheight ) == false ){
    px += 1;
   }
  }
  if (ismovingleft){
   if ( mapcollision( (int)(px - 1) , (int)py , pwidth , pheight ) == false ){
    px -= 1;
   }
  }

  if ( isfalling == true && isjumping == false ){
   for ( int i = 0 ; i < gravity ; i++ ){
    if ( mapcollision ( (int)px , (int)(py + 1) , pwidth , pheight ) == false &&
      laddercollision( (int)px , (int)py+1 , pwidth , pheight ) == false ){
     py += 1;
    }else{
     gravity = 0;
     isfalling = false;
    }
   }
   gravity += .1;
  }

  if ( isjumping == true && isfalling == false ){
   for ( int i = 0 ; i < gravity ; i++){
    if ( mapcollision ( (int)px , (int)(py - 1) , pwidth , pheight ) == false ){
     py -= 1;
     //System.out.print("still jumping : " + gravity);
    }else{
     gravity = 0;
     isfalling = true;
     isjumping = false;
    }
   }
   if( gravity < 1 ) {
    gravity = 0;
    isfalling = true;
    isjumping = false;
   }
   gravity -= .1;
  }
    }

 public boolean laddercollision( int x , int y , int width , int height ){
   int mapx = x / cellwidth;
   int mapy = y / cellheight;
   for ( int y1 = mapy - 1 ; y1 < mapy + 2 ; y1++ ){
    for ( int x1 = mapx - 1 ; x1 < mapx + 2 ; x1++ ){
     if ( x1 >= 0 && x1 < mapwidth && y1 >= 0 && y1 < mapheight ){
      if ( map[y1][x1] == 2 ){
       Rectangle rec1 = new Rectangle( x , y , width , height );
      Rectangle rec2 = new Rectangle( x1 * cellwidth,
              y1 * cellheight,
              cellwidth,
              cellheight);
      if( rec1.intersects( rec2 )) return true;
      }
     }
    }
   }
  return false;
 }

  public boolean mapcollision( int x , int y , int width , int height ){
   int mapx = x / cellwidth;
   int mapy = y / cellheight;
   for ( int y1 = mapy - 1 ; y1 < mapy + 2 ; y1++ ){
    for ( int x1 = mapx - 1 ; x1 < mapx + 2 ; x1++ ){
     if ( x1 >= 0 && x1 < mapwidth && y1 >= 0 && y1 < mapheight ){
      if ( map[y1][x1] == 1 ){
       Rectangle rec1 = new Rectangle( x , y , width , height );
      Rectangle rec2 = new Rectangle( x1 * cellwidth,
              y1 * cellheight,
              cellwidth,
              cellheight);
      if( rec1.intersects( rec2 )) return true;
      }
     }
    }
   }
  return false;
  }
  public boolean keyDown (Event e, int key){
    if( key == 97 ) // a key
        {
         ismovingleft = true;
        }
        if(key== 100) // d key
        {
          ismovingright = true;
        }
    if( key == 119 ) // w key
        {
         ismovingup = true;
        }
        if(key== 115) // s key
        {
          ismovingdown = true;
        }

      if( key == 32 ) // space bar for jump
      {
        if( isfalling == false && isjumping == false )
        {
            isjumping = true;
            gravity = jumpforce;
        }
      }

        System.out.println (" Integer Value: " + key);

   return true;
  }

 public boolean keyUp (Event e, int key){
    if( key == 97 ) // a key
        {
          ismovingleft = false;
        }
        if( key == 100 ) // d key
        {
          ismovingright = false;
        }
    if( key == 119 ) // w key
        {
          ismovingup = false;
        }
        if( key == 115 ) // s key
        {
          ismovingdown = false;
        }

  return true;
 }

}

a* (aStar) pathfinding example

I finally made the a* in Java. I spend the last two weeks typing the a* algorithm in Blitz basic. I typed it in about 13 times before I decided to type it into Java. I think I did it without creating errors.
The source code is below.

Anyone may use the code for their own. No credit is required.

Edit : there is a little problem with the code. The arraylist setup lacks the <Integer> parts. You need to add those to the code if you want to run it. It was removed becourse the < characters are HTML codes.

 


import java.awt.*;
import java.applet.*;
import java.util.ArrayList;

public class astarpathfindingexample01 extends Applet {

 int map[][] ={
     {0,0,0,0,0,0,0,0,0,0},
     {0,1,1,1,1,1,1,1,1,0},
     {0,0,0,1,0,1,0,1,0,0},
     {0,0,0,1,0,1,0,1,0,0},
     {0,1,1,1,0,0,0,1,0,0},
     {0,0,0,1,0,1,0,0,0,0},
     {0,0,0,1,0,1,0,1,0,0},
     {0,1,1,1,1,1,0,1,0,0},
     {0,0,0,0,0,1,0,1,1,0},
     {0,0,0,0,0,0,0,0,0,0}
     };
 int mapwidth = 9;
 int mapheight = 9;
 int cellwidth = 32;
 int cellheight = 24;

 int sx,sy,ex,ey;

 // Open list ( x, y, f, g, h, parentx, parenty )
 ArrayList olx = new ArrayList();
 ArrayList oly = new ArrayList();
 ArrayList olf = new ArrayList();
 ArrayList olg = new ArrayList();
 ArrayList olh = new ArrayList();
 ArrayList olpx = new ArrayList();
 ArrayList olpy = new ArrayList();
 // Closed list ( x, y, f, g, h, parentx, parenty )
 ArrayList clx = new ArrayList();
 ArrayList cly = new ArrayList();
 ArrayList clf = new ArrayList();
 ArrayList clg = new ArrayList();
 ArrayList clh = new ArrayList();
 ArrayList clpx = new ArrayList();
 ArrayList clpy = new ArrayList();
 // Path
 ArrayList px = new ArrayList();
 ArrayList py = new ArrayList();

 public void init() {
  setBackground(Color.black);

 }

 public void findpathback(){
  boolean exitloop = false;
  int x = ex;
  int y = ey;
  while ( exitloop == false ){
   for ( int i = 0 ; i < clx.size() ; i++ ){
    if ( clx.get( i ) == x && cly.get( i ) == y ){
     x = clpx.get( i );
     y = clpy.get( i );
     px.add( x );
     py.add( y );
    }
   }
   if ( x == sx && y == sy ) {
    exitloop = true;
   }
  }
 }

 public boolean removefromopenlist( int x , int y ){
  for ( int i = 0 ; i < olx.size() ; i++ ){
   if ( olx.get(i) == x && oly.get(i) == y ){
    olx.remove(i);
    oly.remove(i);
    olf.remove(i);
    olg.remove(i);
    olh.remove(i);
    olpx.remove(i);
    olpy.remove(i);
    return true;
   }
  }
  return false;
 }

 public boolean isonclosedlist( int x , int y ){
  for ( int i = 0 ; i < clx.size() ; i++ ){
   if ( clx.get(i) == x && cly.get(i) == y ) {
    return true;
   }
  }
  return false;
 }

 public boolean isonopenlist( int x , int y ){
  for ( int i = 0 ; i < olx.size() ; i++){
   if ( olx.get(i) == x && oly.get(i) == y ){
    return true;
   }
  }
  return false;
 }

 public boolean openlistisempty(){
  if ( olx.size() > 0 ) {
   return false;
  }
  return true;
 }

 public void setcoordinates(){
  boolean exitloop = false;
  while ( exitloop == false ){
   sx = (int)( Math.random() * mapwidth );
   sy = (int)( Math.random() * mapheight );
   ex = (int)( Math.random() * mapwidth );
   ey = (int)( Math.random() * mapheight );
   if ( map[ sy ][ sx ] == 0 && map[ ey ][ ex ] == 0 ){
    if ( sx != ex && sy != ey ){
     exitloop = true;
    }
   }
  }
 }

 public void findpath(){
  // Clear all the pathfinding data
  olx.clear();
  oly.clear();
  olf.clear();
  olg.clear();
  olh.clear();
  olpx.clear();
  olpy.clear();
  //
  clx.clear();
  cly.clear();
  clf.clear();
  clg.clear();
  clh.clear();
  clpx.clear();
  clpy.clear();
  //
  px.clear();
  py.clear();
  //
  // Move the start position onto the open list
  olx.add( sx );
  oly.add( sy );
  olf.add( 0 );
  olg.add( 0 );
  olh.add( 0 );
  olpx.add( 0 );
  olpy.add( 0 );
  //
  boolean exitloop = false;
  int tx = 0;
  int ty = 0;
  int tf = 0;
  int tg = 0;
  int th = 0;
  int tpx = 0;
  int tpy = 0;
  int newx = 0;
  int newy = 0;
  int lowestf = 0;
  while ( exitloop == false ){
   // If the open list is empty then exit loop
   if ( openlistisempty() == true ){
    exitloop = true;
   }
   // Get the lowest f value position from the
   // open list and use that.
   lowestf = 100000;
   for ( int i = 0 ; i < olx.size() ; i++ ){
    if ( olf.get( i ) < lowestf ) {
     lowestf = olf.get( i );
     tx = olx.get( i );
     ty = oly.get( i );
     tf = olf.get( i );
     tg = olg.get( i );
     th = olh.get( i );
     tpx = olpx.get( i );
     tpy = olpy.get( i );
    }
   }
   // if the current position is the end position then
   // path was found.
   if ( tx == ex && ty == ey ){
    exitloop = true;
    clx.add( tx );
    cly.add( ty );
    clf.add( tf );
    clg.add( tg );
    clh.add( th );
    clpx.add( tpx );
    clpy.add( tpy );
    findpathback();
   }else{
    // Move the current position onto the closed list
    clx.add( tx );
    cly.add( ty );
    clf.add( tf );
    clg.add( tg );
    clh.add( th );
    clpx.add( tpx );
    clpy.add( tpy );
    // Remove the current position from the open is
    removefromopenlist( tx , ty );
    // Get the eight positions from around the current
    // position and move them onto the open list.
    //
    newx = tx - 1;
    newy = ty - 1;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx;
    newy = ty - 1;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx + 1;
    newy = ty - 1;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx - 1;
    newy = ty;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx + 1;
    newy = ty;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx - 1;
    newy = ty + 1;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx;
    newy = ty + 1;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }
    //
    newx = tx + 1;
    newy = ty + 1;
    if ( newx > -1 && newy > -1 && newx < mapwidth + 1 && newy < mapheight + 1 ){
    if ( isonopenlist( newx , newy ) == false ){
    if ( isonclosedlist( newx , newy ) == false ){
    if ( map[ newy ][ newx ] == 0 ){
     olx.add( newx );
     oly.add( newy );
     olg.add( tg + 1 );
     olh.add( distance( newx , newy , ex , ey ));
     olf.add( ( tg + 1 ) + distance( newx , newy , ex , ey ) );
     olpx.add( tx );
     olpy.add( ty );
    }
    }
    }
    }

   }

  }
 }

 public int distance( int x1 , int y1 , int x2 , int y2 ){
  int distance=(int)Math.sqrt( ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ) ) ;
  return distance;
 }

 public void paint(Graphics g) {

  setcoordinates();
  findpath();
  // Draw the map on the applet window
  g.setColor( Color.blue );
  for ( int y = 0 ; y < mapheight ; y++ ){
  for ( int x = 0 ; x < mapwidth ; x++ ){
   if ( map[ y ][ x ] == 1 ){
    g.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
   }
  }
  }
  // Draw the start position on the applet window
  g.setColor( Color.green );
  g.fillOval( sx * cellwidth + 4 , sy * cellheight + 4 , 8 , 8 );
  g.setColor( Color.red );
  g.fillOval( ex * cellwidth + 4 , ey * cellheight + 4 , 8 , 8 );

  // Draw the path
  g.setColor( Color.yellow );
  for ( int i = 0 ; i < px.size() ; i++ ){
   g.fillOval( px.get( i ) * cellwidth + 8 , py.get( i ) * cellheight + 8 , 8 , 8 );
  }

 }
}

finally did it. a* working

I finally have a working a* function working on my computer and made it myself. I had bought the book "ai for game developers" and read through the chapter on pathfinding. I had a few mistypes that caused bugs but I was able to repair those. The code is in another language at the moment. In blitz basic 3d. This since I have more experience with that language. I will code the a* in Java in the future.

I will make a applet with a* pathfinding I think this weekend.

Random Obstacle Avoidance Example

From the book ai for game developers. Random Obstacle Avoidance. The white block moves through the map and avoids the green trees. Below the code that shows how it is done.

 

import java.awt.*;
import java.applet.*;
public class RandomObstacleAvoidanceExample001 extends Applet implements Runnable{
 Graphics bufferGraphics;
    Image offscreen;
 int sx , sy , ex , ey; // start and end position
 int px , py; // player position
 long delay;
 private int map[][] =  new int[][]{
 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0},
 {0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0},
 {0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0},
 {0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0},
 {0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0},
 {0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0},
 {0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 };
 public void init(){
  setBackground( Color.black );
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
  setstartposition();
  setendposition();
  px = sx;
  py = sy;
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
         moveplayer();
         repaint();
         try {
             Thread.sleep(16);
            }
             catch (InterruptedException e) {
             }
     }
    }
 public void update (Graphics g)
  {
  bufferGraphics.clearRect( 0 , 0 , getSize().width , getSize().height );
     bufferGraphics.setColor ( Color.white );
     bufferGraphics.drawString( "Random Obstacle Avoidance." , 10 , 10 );
  bufferGraphics.setColor( Color.green );
  // draw map
  for ( int y = 0 ; y < 15 ; y++ ){
   for ( int x = 0 ; x < 20 ; x++ ){
    if ( map[ y ][ x ] == 1 ){
     bufferGraphics.fillOval( x * 16 , y * 16 , 16 , 16 );
    }
   }
  }
  // draw end and start position
  bufferGraphics.setColor( Color.red );
  bufferGraphics.fillRect( sx * 16 , sy * 16 , 16 , 16 );
  bufferGraphics.setColor( Color.yellow );
  bufferGraphics.fillRect( ex * 16 , ey * 16 , 16 , 16 );
  // draw player
  bufferGraphics.setColor( Color.white );
  bufferGraphics.fillRect( px * 16 , py * 16 , 16 , 16 );

     g.drawImage(offscreen,0,0,this);

  }
  public void moveplayer(){
   if ( delay < System.currentTimeMillis() ){
    int newx = px;
    int newy = py;
    if ( px < ex ){
     newx++;
    }
    if ( px > ex ){
     newx--;
    }
    if ( py < ey ){
     newy++;
    }
    if ( py > ey ){
     newy--;
    }
    if ( map[ newy ][ newx ] == 1 ){
     boolean newposfound = false;
     newx = px;
     newy = py;
     while ( newposfound == false ){
      if ( (int)(Math.random() * 2 ) == 0 ){
       newx--;
      }else{
       newx++;
      }
      if ( (int)(Math.random() * 2 ) == 0 ){
       newy--;
      }else{
       newy++;
      }
      if ( map[ newy ][ newx ] == 0 ){
       newposfound = true;
      }
     }
    }
    px = newx;
    py = newy;
    if ( px == ex && py == ey ){
    setstartposition();
    setendposition();
    px = sx;
    py = sy;
    }
    delay = System.currentTimeMillis() + 200;
   }
  }
 public void setstartposition(){
  if (  (int)( Math.random() * 2 ) == 0 ){
   sx = ( int )( Math.random() * 6 );
   sy = 0;
  }else{
   sx = 0;
   sy = ( int )( Math.random() * 6 );
  }
 }
 public void setendposition(){
  if (  (int)( Math.random() * 2 ) == 0 ){
   ex = 20 - ( int )( Math.random() * 6 );
   ey = 14;
  }else{
   ex = 19;
   ey = 14 - ( int )( Math.random() * 6 );
  }

 }
}