dinsdag 19 juni 2012

I have decided to stop programming in Java

Since the applets no longer work. I have decided to stop programming in Java. I never really gotten used to Java.

I will keep programming but in another language. I was thinking of buying Play Basic but for the moment I do  my programming exercises in Blitz Basic.

(edit:)
I think the google site is returning errorous data from the applets. Maybe this will go away.

maandag 11 juni 2012

Java applets do not work anymore on my pc

I have tried firefox, internet explorer and google chrome but the applets do not show anymore. Also the browsers freeze when I load the pages. This happened before but not with all the browsers. I have no idea what I can do to fix it. I will try to look up what the problem might be.

edit :

I could not find any information yet. I have also tried reinstalling the java runtime. This did not fix it. I also tried another computer and this gives the same error. Also older applet that used to work did not work anymore. I get a magic number error with the applets when they do load. I hope this problem will fix itself in the future. As I have no idea what to do.

Manhattan Distance example



Manhattan distance example. Move the mouse over the applet to see the distance change.

 


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

public class manhattandistanceexample001 extends Applet implements Runnable {
 // Graphics for double buffering.
 Graphics      bufferGraphics;
    Image       offscreen;
 int mousex =     0;
 int mousey =    0;

 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
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

   public boolean mouseMove(Event e, int x, int y){
        mousex = x;
        mousey = y;
  return true;
 }

    public void update(Graphics g){
     bufferGraphics.clearRect( 0 , 0 , getSize().width , getSize().width );
        bufferGraphics.setColor( Color.red );
        bufferGraphics.drawString( "Manhattan Distance " , 10 , 10 );

  for ( int y = 0 ; y < 240/32 ; y++ ){
  for ( int x = 0 ; x < 320/32 ; x++ ){
   bufferGraphics.drawRect( x * 32 , y * 32 , 32 , 32 );
   int dist = mdist( mousex / 32 , mousey / 32 , x , y );
   bufferGraphics.drawString( "" + dist , x * 32 , y * 32 + 16 );
  }
  }

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

 public int mdist( int x1 , int y1 , int x2 , int y2 ){
  return Math.abs( x2 - x1 ) + Math.abs( y2 - y1 );
 }

}


Euclidean Distance example





Euclidean distance example. Move the mouse over the applet to see the distance change.

 


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

public class euclideandistanceexample001 extends Applet implements Runnable {
 // Graphics for double buffering.
 Graphics      bufferGraphics;
    Image       offscreen;
 int mousex =     0;
 int mousey =    0;

 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
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

   public boolean mouseMove(Event e, int x, int y){
        mousex = x;
        mousey = y;
  return true;
 }

    public void update(Graphics g){
     bufferGraphics.clearRect( 0 , 0 , getSize().width , getSize().width );
        bufferGraphics.setColor( Color.red );
        bufferGraphics.drawString( "Euclidean Distance " , 10 , 10 );

  for ( int y = 0 ; y < 240/32 ; y++ ){
  for ( int x = 0 ; x < 320/32 ; x++ ){
   bufferGraphics.drawRect( x * 32 , y * 32 , 32 , 32 );
   int dist = edist( mousex / 32 , mousey / 32 , x , y );
   bufferGraphics.drawString( "" + dist , x * 32 , y * 32 + 16 );
  }
  }

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

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

}



zaterdag 2 juni 2012

The blog still works.

It looks like the email I got from blogger support was wrong. The blog still works. I have 2 examples which I still need to place on the weblog. These are distance formula's examples. I am also stil thinking of what to program next. Though it is summer and I spend a lot of time outside. I have not programmed a lot. But I am reading programming books. I have an old Java 2 book which I am curently reading.

dinsdag 15 mei 2012

This blog might be blocked starting 30 may 2012

I got a reminder in the email that I need to transfer the blogger account into my google account. But my blogger username is not found on the conversion page. This means that my blog might stop after may 30th and that I need to start a new one. I have no idea what the login problem might be. I have a blogger username so why it cannot be found is a mystery to me.

Well if this is one of the last posts then I might have started a new blog about game programming. I might call it about the same name. Java game programming step by step or so.

Edit : I have replied to the support email of the notice that I can not converse so I hope to hear something soon. I hope this works.

Edit2: I did not get a reply from the support email adres of blogger but I did look into the support forum. There was a post about my problem and it said not to worry about this. You automatically are converted to the new method if you used the blog after the new license.

donderdag 19 april 2012

Game Menu Example





Use the s and w keys to move the selection cursor.
 


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

public class gamemenuexample001 extends Applet implements Runnable{

 Graphics bufferGraphics;
 Image offscreen;
 FontMetrics fm;
 int nummenuitems = 4;
 String gamemenu[] = new String[ nummenuitems ];
 int menuchoice = 0;

 public void init() {
        setBackground(Color.black);
        offscreen = createImage(getSize().width,getSize().height);
        bufferGraphics = offscreen.getGraphics();
  Graphics g;
  g = getGraphics();
  fm = g.getFontMetrics();
        gamemenu[ 0 ] = "New Game";
        gamemenu[ 1 ] = "Load Game";
        gamemenu[ 2 ] = "Options";
        gamemenu[ 3 ] = "Credits";
  new Thread(this).start();
 }
    public void run() {
        for(;;) { // animation loop never ends
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }



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

  String s = "";
  for ( int i = 0 ; i < nummenuitems ; i++ ){
   if ( i == menuchoice ){
          s = "-> " + gamemenu[ i ];
    bufferGraphics.drawString(s,(this.getSize().width-fm.stringWidth(s)) / 2, 80 + i * 20 );
   }else{
    s = gamemenu[ i ];
    bufferGraphics.drawString(s,(this.getSize().width-fm.stringWidth(s)) / 2, 80 + i * 20 );
   }
  }

        bufferGraphics.drawString("Game Menu Screen.",10,10);
  bufferGraphics.drawString("w/s to move cursor.",10,237);

        g.drawImage(offscreen,0,0,this);
     }
  public boolean keyDown (Event e, int key){

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

  // key w
   if ( key == 119 ){
       if ( menuchoice > 0 ){
        menuchoice--;
       }
        }
        // key s
        if ( key == 115 ){
         if ( menuchoice < nummenuitems - 1 ){
          menuchoice++;
         }
        }
  //System.out.println(""+key);
  return true;
 }


}


Topdown patrolling ai example





 


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

public class topdownpatrollingaiexample001 extends Applet implements Runnable{

 Graphics bufferGraphics;
 Image offscreen;
 boolean ismovingleft;
 boolean ismovingright;
 boolean ismovingup;
 boolean ismovingdown;
 int mapwidth = 20;
 int mapheight = 15;
 int cellwidth = 16;
 int cellheight = 16;
 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,0,1},
 {1,0,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1,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,0,1,0,0,1,1,0,0,1,1,0,0,1,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,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1},
 {1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,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,2,0,0,1,0,1,1,1,1,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 playerstartpositionx = playerx = 10*cellwidth;
 int playerstartpositiony = playery = 13*cellheight;
 int playerx = playerstartpositionx;
 int playery = playerstartpositiony;
 // For the pattern movement ai
 int numai = 10;
 int ai[][] = new int[ numai ][ 10 ]; // ,active,x,y,direction[0-up,1-right,2-down,3-left]
 public void init() {
        setBackground(Color.black);
        offscreen = createImage(getSize().width,getSize().height);
        bufferGraphics = offscreen.getGraphics();
        // initiate ai
        ai[ 0 ][ 0 ] = 1;
        ai[ 0 ][ 1 ] = 1 * cellwidth;
        ai[ 0 ][ 2 ] = 1 * cellheight;
        ai[ 0 ][ 3 ] = 1;
  //6 2
  ai[ 1 ][ 0 ] = 1;
  ai[ 1 ][ 1 ] = 6 * cellwidth;
  ai[ 1 ][ 2 ] = 2 * cellheight;
  ai[ 1 ][ 3 ] = 2;
  // 13 10
  ai[ 2 ][ 0 ] = 1;
  ai[ 2 ][ 1 ] = 13 * cellwidth;
  ai[ 2 ][ 2 ] = 10 * cellheight;
  ai[ 2 ][ 3 ] = 2;
  new Thread(this).start();
 }
    public void run() {
        for(;;) { // animation loop never ends
   moveplayer();
   updateai();
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

 public void updateai(){
  for ( int i = 0 ; i < numai ; i++ ){
   if ( ai[ i ][ 0 ] == 1 ){
    // Movement up ( 0 )
    if ( ai[ i ][ 3 ] == 0 ){
     if ( ismapcollision( ai[ i ][ 1 ] , ai[ i ][ 2 ] - 1 ) ){
      ai[ i ][ 3 ] = 2;
     }else{
      ai[ i ][ 2 ]--;
     }
    }
    // Movement right ( 1 )
    if ( ai[ i ][ 3 ] == 1 ){
     if ( ismapcollision( ai[ i ][ 1 ] + 1 , ai[ i ][ 2 ] ) ){
      ai[ i ][ 3 ] = 3;
     }else{
      ai[ i ][ 1 ]++;
     }
    }
    // Movement down ( 2 )
    if ( ai[ i ][ 3 ] == 2 ){
     if ( ismapcollision( ai[ i ][ 1 ] , ai[ i ][ 2 ] + 1 ) ){
      ai[ i ][ 3 ] = 0;
     }else{
      ai[ i ][ 2 ]++;
     }
    }
    // Movement left ( 3 )
    if ( ai[ i ][ 3 ] == 3 ){
     if ( ismapcollision( ai[ i ][ 1 ] - 1 , ai[ i ][ 2 ] ) ){
      ai[ i ][ 3 ] = 1;
     }else{
      ai[ i ][ 1 ]--;
     }
    }
   // Collision with the ai
   Rectangle rec1 = new Rectangle(  playerx ,
             playery ,
             cellwidth ,
             cellheight );
   Rectangle rec2 = new Rectangle(  ai[ i ][ 1 ],
            ai[ i ][ 2 ],
            cellwidth,
            cellheight);
   if( rec1.intersects( rec2 ) ){
     playerx = playerstartpositionx;
     playery = playerstartpositiony;
   }

   }
  }
 }

    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 moveplayer(){
     if (ismovingright == true && ismapcollision(playerx + 1,playery) == false){
      playerx++;
     }
     if (ismovingup == true && ismapcollision(playerx,playery-1) == false){
      playery--;
     }
     if (ismovingdown == true && ismapcollision(playerx,playery+1) == false){
      playery++;
     }
     if (ismovingleft == true && ismapcollision(playerx-1,playery) == false){
      playerx--;
     }

    }

     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++){
          // walls
          if( map[y][x] == 1 ){
     bufferGraphics.setColor( Color.white );
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }
         }
        }
  // Draw ai
  for ( int i = 0 ; i < numai ; i++ ){
   if ( ai[ i ][ 0 ] == 1 ){
    bufferGraphics.setColor( Color.blue );
    bufferGraphics.fillOval(  ai[ i ][ 1 ] ,
           ai[ i ][ 2 ] ,
           cellwidth ,
           cellheight );
   }
  }

     bufferGraphics.setColor(Color.red);

  bufferGraphics.fillOval(playerx,playery,cellwidth,cellheight);

        bufferGraphics.drawString("2D Topdown Patrolling ai.",10,10);
  bufferGraphics.drawString("w/s/a/d to move player.",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;
 }


}


Topdown Portals Example





Portals example. Move into the yellow blocks to switch levels.

 


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

public class topdownportalsexample001 extends Applet implements Runnable{

 Graphics bufferGraphics;
 Image offscreen;
 boolean ismovingleft;
 boolean ismovingright;
 boolean ismovingup;
 boolean ismovingdown;
 int isonmap = 1;
 boolean isonportal =  false;
 long portaltimeout = 0;
 int mapwidth = 20;
 int mapheight = 15;
 int cellwidth = 16;
 int cellheight = 16;
 private int map[][] = new int[ mapheight ][ mapwidth ];
 private int map2[][] = 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,0,1},
 {1,0,1,1,1,1,0,1,1,1,1,1,1,0,1,1,1,1,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,0,0,0,0,0,0,0,0,0,0,1,0,1},
 {1,0,1,0,0,0,0,1,0,1,1,0,1,0,0,0,0,1,0,1},
 {1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1},
 {1,0,1,1,1,1,0,1,0,2,0,0,1,0,1,1,1,1,0,1},
 {1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1},
 {1,0,1,0,0,0,0,1,0,1,1,0,1,0,0,0,0,1,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,0,0,0,0,0,0,0,0,0,0,1,0,1},
 {1,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,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},
 };
 private int map1[][] =  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,0,1},
 {1,0,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1,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,0,1,0,0,1,1,0,0,1,1,0,0,1,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,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1},
 {1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,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,2,0,0,1,0,1,1,1,1,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 playerx = 10*cellwidth;
 int playery = 13*cellheight;
 public void init() {
        setBackground(Color.black);
        offscreen = createImage(getSize().width,getSize().height);
        bufferGraphics = offscreen.getGraphics();
  // Copy map1 to map so that we have something to show
        for ( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++ ){
          map[ y ][ x ] = map1[ y ][ x ];
         }
        }
  new Thread(this).start();
 }
    public void run() {
        for(;;) { // animation loop never ends
   moveplayer();
   updateportals();
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

    public void updateportals(){
      if ( isportalcollision( playerx , playery ) == true ){
       boolean selected = false;
       if ( isonmap == 1 ){
        selected = true;
        for ( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++ ){
          map[ y ][ x ] = map2[ y ][ x ];
         }
        }
        isonmap = 2;
       }
       if ( isonmap == 2 && selected == false ){
        for ( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++ ){
          map[ y ][ x ] = map1[ y ][ x ];
         }
        }
        isonmap = 1;
       }
      }
    }

    public boolean isportalcollision( 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] == 2 ){
      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 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 moveplayer(){
     if (ismovingright == true && ismapcollision(playerx + 1,playery) == false){
      playerx++;
     }
     if (ismovingup == true && ismapcollision(playerx,playery-1) == false){
      playery--;
     }
     if (ismovingdown == true && ismapcollision(playerx,playery+1) == false){
      playery++;
     }
     if (ismovingleft == true && ismapcollision(playerx-1,playery) == false){
      playerx--;
     }

    }

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

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

     bufferGraphics.setColor(Color.red);

  bufferGraphics.fillOval(playerx,playery,cellwidth,cellheight);

        bufferGraphics.drawString("2D Topdown Portals.",10,10);
  bufferGraphics.drawString("w/s/a/d to move player.",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;
 }


}


zaterdag 7 april 2012

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;
 }



}

donderdag 5 april 2012

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;
 }


}


woensdag 4 april 2012

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;
 }

}


vrijdag 16 maart 2012

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 );
  }

 }
}


dinsdag 6 maart 2012

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.

zondag 4 maart 2012

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 );
  }

 }
}


woensdag 29 februari 2012

I received a new book - Ai for game developers.

I ordered a book yesterday. Today I got it. It is a book about Artificial Intelligence. It is for Novice programmers. There is a whole chapter on a* in it. I think I will be making more artificial intelligence examples for the weblog in the future.

On google books you can read through a large part of the book. Last year I made a random obstacle avoidance example in another language from this book. This method is great for moving ai through forrest map parts.

woensdag 22 februari 2012

The Gimp - investing time in art creation.

It has been years ago that I last draw art for games. Sometimes I get the idea to spend time in drawing programs. I now downloaded the latest version of Gimp after looking around for drawing programs. I could find nothing better then the Gimp. I already found my favourite brush, the Smudge brush. This one can be used to smear the pixels around. It is easy to make clouds with the smudge brush for instance.
I want to spend time in the future drawing. I want to get good at it. This means getting to the 10.000 hours of experience with it. This means it will probably be old before I am good enough.

In blogger you can upload png files so I will be placing example drawings and step by step drawings in posts in the future. I hope that I will be productive. I also still think of things that I want to code.

zaterdag 18 februari 2012

Copperbar Example



In the code below you can see how the copperbar shown above is made. Copperbars were used in games to create a filled background. The effect looks quite nice.


 

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

public class CopperBarExample001 extends Applet {

 public void init() {
  // Set the applet background color to black.
  setBackground(Color.black);
 }

 public void paint(Graphics g) {
  g.setColor( Color.white );
  g.drawString( "Copperbar Example" , 10, 10 );
  int y = 50;
  double col = 0;
  while ( y < 100 ){ // draw the first 50 lines of the copperbar , dark to light
   g.setColor( new Color( 0 , 0 , (int)col ) );
   col += 255 / 50;
   g.drawLine( 0 , y , getSize().width , y );
   y++;
  }
  while ( y < 150 ){ // draw the last 50 lines of the copperbar, light to dark.
   g.setColor( new Color( 0 , 0 , (int)col ) );
   col -= 255 / 50;
   g.drawLine( 0 , y , getSize().width , y );
   y++;
  }

 }


}


Sidescrolling Shooter Shooting Example



In this example you can control a block that shoots 3 types of blocks. The control instructions are on the applet screen.


 

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

public class ShooterShootingExample001 extends Applet implements Runnable {
 Graphics bufferGraphics;
    Image offscreen;
 int px; // player x coordinate.
 int py; // player y coordinate.
 int pw = 16; // player width.
 int ph = 16; // player height.
 boolean pmoveup = false; // player move up.
 boolean pmovedown = false; // player move down.
 int shoottype = 0; // shooting , 0 = no shot, 1 = type 1, 2 = type 2, 3 = type 3
 long lastshottime = 0;
 int numshots = 32;
 double shots[][] = new double[ numshots ][ 5 ]; //active, x, y, mx, my
 int shotw = 3; // shot width.
 int shoth = 3; // shot height.

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
     px = 16;
     py = getSize().height / 2 - ph / 2;
     // Start the runnable thread.
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
   moveplayer();
   playershoot();
   updateshots();
         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( "Sidescroller Shooter Shooting Example." , 10 , 10 );
  bufferGraphics.drawString( "use : w and s to move up and down." , 10 , 20 );
  bufferGraphics.drawString( "use : i , o and p to shoot." , 10 , 30 );
  bufferGraphics.setColor( Color.red );
  // draw shots.
  for ( int i = 0 ; i < numshots ; i++ ){
   if ( shots[ i ][ 0 ] == 1 ){
    bufferGraphics.fillOval( (int)shots[ i ][ 1 ] , (int)shots[ i ][ 2 ] , shotw , shoth );
   }
  }
  // draw player.
  bufferGraphics.fillRect( px , py , pw , ph );
     g.drawImage(offscreen,0,0,this);
  }
  public boolean keyUp (Event e, int key){
  if ( key == 119 ){ // w key, up
   pmoveup = false;
  }
  if ( key == 115 ){ // s key, down
   pmovedown = false;
  }
  if ( key == 105 ){ // i key, fire 1
   shoottype = 0;
  }
  if ( key == 111 ){ // o key, fire 2
   shoottype = 0;
  }
  if ( key == 112 ){ // p key, fire 3
   shoottype = 0;
  }
    return true;
  }

   public boolean keyDown (Event e, int key){
  if ( key == 119 ){ // w key, up
   pmoveup = true;
  }
  if ( key == 115 ){ // s key, down
   pmovedown = true;
  }
  if ( key == 105 ){ // i key, fire 1
   shoottype = 1;
  }
  if ( key == 111 ){ // o key, fire 2
   shoottype = 2;
  }
  if ( key == 112 ){ // p key, fire 3
   shoottype = 3;
  }
        System.out.println ("Charakter: " + (char)key + " Integer Value: " + key);
        return true;
  }

 public void moveplayer(){
  if ( pmoveup ){
   if ( py > 30 ){
    py--;
   }
  }
  if ( pmovedown ){
   if ( py < getSize().height - ph ){
    py++;
   }
  }
 }

 public void playershoot(){
  int n = -1;
  if ( lastshottime < System.currentTimeMillis() ){
   if ( shoottype == 1 ){
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = 0;
    }
   }
   if ( shoottype == 2 ){
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = 0;
    }
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = -2;
    }
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = 2;
    }
   }
   if ( shoottype == 3 ){
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = 0;
    }
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = -2;
    }
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 3;
     shots[ n ][ 4 ] = 2;
    }
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 0;
     shots[ n ][ 4 ] = -3;
    }
    n = getemptyshot();
    if ( n > -1 ){
     shots[ n ][ 0 ] = 1;
     shots[ n ][ 1 ] = px + pw;
     shots[ n ][ 2 ] = py + ph / 2;
     shots[ n ][ 3 ] = 0;
     shots[ n ][ 4 ] = 3;
    }

   }
   lastshottime = System.currentTimeMillis() + 300;
  }

 }

 public int getemptyshot(){
  for ( int i = 0 ; i < numshots ; i++ ){
   if ( shots[ i ][ 0 ] == 0 ){
    return i;
   }
  }
  return -1;
 }

 public void updateshots(){
  for ( int i = 0 ; i < numshots ; i++ ){
   if ( shots[ i ][ 0 ] == 1 ){
    // Update the shots location on the screen.
    shots[ i ][ 1 ] += shots[ i ][ 3 ];
    shots[ i ][ 2 ] += shots[ i ][ 4 ];
    // If the shots get outside of the screen then disable them.
    if ( shots[ i ][ 1 ] > getSize().width ){
     shots[ i ][ 0 ] = 0;
    }
    if ( shots[ i ][ 2 ] < 0 - shoth ){
     shots[ i ][ 0 ] = 0;
    }
    if ( shots[ i ][ 2 ] > getSize().height ){
     shots[ i ][ 0 ] = 0;
    }

   }
  }
 }

}

vrijdag 17 februari 2012

Rotating Side Scrolling Shooter Attack Wave Example




I made another example. This time a group of enemies fly in a circular pattern through the screen. In a shooter this would be a interesting challenge. When the enemies are done flying through the screen another wave starts. The code below shows how it is made.


 

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

public class SideScrollingAttackWave001 extends Applet implements Runnable {
 Graphics bufferGraphics;
    Image offscreen;
 int numenemies = 16;
 double enemies[][] = new double[ numenemies ][ 8 ]; // active, x , y , mx , angle , radius , locx,locy

 int enemyw = 16;
 int enemyh = 16;

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
  initiateattackwave();
     // Start the runnable thread.
  new Thread(this).start();
 }
 public void initiateattackwave(){
  // initiate the attack wave
     for ( int i = 0 ; i < 7 ; i++ ){
      enemies[ i ][ 0 ] = 1;
      enemies[ i ][ 1 ] = 0;
      enemies[ i ][ 2 ] = 0;
      enemies[ i ][ 3 ] = -.2;
      enemies[ i ][ 4 ] = i * 16;
      enemies[ i ][ 5 ] = 100;
      enemies[ i ][ 6 ] = getSize().width;
      enemies[ i ][ 7 ] = getSize().height / 2 - 8;
     }
 }
    public void run() {
     boolean noleft;
     for(;;) { // animation loop never ends

   // update the enemies
   for ( int i = 0 ; i < numenemies ; i++ ){
    if ( enemies[ i ][ 0 ] == 1 ){
     enemies[ i ][ 6 ] += enemies[ i ][ 3 ];
     enemies[ i ][ 4 ] += .5;
     if ( enemies[ i ][ 4 ] > 360 ){
      enemies[ i ][ 4 ] = 0;
     }
     enemies[ i ][ 1 ] = Math.sin(  Math.toRadians(
             enemies[ i ][ 4 ] ) )
             * enemies[ i ][ 5 ]
             + enemies[ i ][ 6 ];
     enemies[ i ][ 2 ] = Math.cos(  Math.toRadians(
             enemies[ i ][ 4 ] ) )
             * enemies[ i ][ 5 ]
             + enemies[ i ][ 7 ];

     if ( enemies[ i ][ 6 ] < -70 ){
      enemies[ i ][ 0 ] = 0;
     }
    }
   }

   // if there are no more active enemies then initiate new wave.
   noleft = true;
   for ( int i = 0 ; i < numenemies ; i++ ){
    if ( enemies[ i ][ 0 ] == 1 ){
     noleft = false;
    }
   }
         if ( noleft ){
          initiateattackwave();
         }

         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( "Sidescroller Attack Wave Example." , 10 , 10 );
  bufferGraphics.setColor( Color.red );
  // Draw the enemies
  for ( int i = 0 ; i < numenemies ; i++ ){
   if ( enemies[ i ][ 0 ] == 1 ){
    bufferGraphics.fillRect(  (int)enemies[ i ][ 1 ] ,
           (int)enemies[ i ][ 2 ] ,
           enemyw ,
           enemyh );
   }
  }
     g.drawImage(offscreen,0,0,this);

 }


}

3 Attack Waves for Side Scrolling Shooter Example



I created an example where 3 attack waves are shown. The code checks if there are no enemies left and then creates a new attack wave. The enemies fly through the screen from right to left.


 

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

public class ThreeAttackWavesExample001 extends Applet implements Runnable {
 Graphics bufferGraphics;
    Image offscreen;
    int numenemies = 64;
    int enemyw = 16; // enemy width
    int enemyh = 16; // enemy height
 double enemies[][] = new double[ numenemies ][ 4 ]; // active,x,y,mx

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
     createattackwave3();
     // Start the runnable thread.
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends


   if ( noenemiesareleft() == true ){
    int n = (int)( Math.random() * 4 );
    if ( n == 1 ){
     createattackwave1();
    }
    if ( n == 2 ){
     createattackwave2();
    }
    if ( n == 3 ){
     createattackwave3();
    }

   }

      moveenemies();
         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( "Sidescroller Shooter 3 attack waves Example." , 10 , 10 );

  // Draw enemies
     bufferGraphics.setColor ( Color.red );
  for ( int i = 0 ; i < numenemies ; i++ ) {
   if ( enemies[ i ][ 0 ] == 1 ){
    bufferGraphics.fillRect(  (int)enemies[ i ][ 1 ],
            (int)enemies[ i ][ 2 ],
            enemyw,
            enemyh );
   }
  }

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

 }

 public boolean noenemiesareleft(){
  boolean noleft = true;
  for ( int i = 0 ; i < numenemies ; i++ ){
   if ( enemies[ i ][ 0 ] == 1 ){
    noleft = false;
   }
  }
  return noleft;
 }

 public void createattackwave1(){
  int n;
  for ( int i = 0 ; i < 4 ; i++ ){
   n = findemptyenemy();
         //System.out.println ("slot : " + n );
   if ( n > -1 ){
    enemies[ n ][ 0 ] = 1;
    enemies[ n ][ 1 ] = getSize().width + 32 + 4 * enemyw - ( i * enemyw ) + ( enemyw * 3 );
    enemies[ n ][ 2 ] = i * ( enemyh * 1.5 ) + 32;
    enemies[ n ][ 3 ] = .5;
   }
  }
 }

 public void createattackwave2(){
  int n;
  for ( int i = 0 ; i < 4 ; i++ ){
   n = findemptyenemy();
         //System.out.println ("slot : " + n );
   if ( n > -1 ){
    enemies[ n ][ 0 ] = 1;
    enemies[ n ][ 1 ] = getSize().width + 32 + ( i * enemyw ) + ( enemyw * 3 );
    enemies[ n ][ 2 ] = i * ( enemyh * 1.5 ) + 132;
    enemies[ n ][ 3 ] = .5;
   }
  }
 }

 public void createattackwave3(){
  int n;
  for ( int i = 0 ; i < 4 ; i++ ){
   n = findemptyenemy();
         //System.out.println ("slot : " + n );
   if ( n > -1 ){
    enemies[ n ][ 0 ] = 1;
    enemies[ n ][ 1 ] = getSize().width + (int)(Math.random() * getSize().width / 2);
    enemies[ n ][ 2 ] = (int)(Math.random() * (getSize().height - 100 ) + 50);
    enemies[ n ][ 3 ] = .5;
   }
  }
 }


 public int findemptyenemy(){
  for ( int i = 0 ; i < numenemies ; i++ ){
   if ( enemies[ i ][ 0 ] == 0 ){
    return i;
   }
  }
  return -1;
 }

 public void moveenemies(){
  for ( int i = 0 ; i < numenemies ; i++ ){
   if ( enemies[ i ][ 0 ] == 1 ){
    enemies[ i ][ 1 ] -= enemies[ i ][ 3 ];
    if ( enemies[ i ][ 1 ] < 0 - enemyw ){
     enemies[ i ][ 0 ] = 0;
    }
   }
  }
 }


}

Sin Wavy Movement Example



I got the idea to program parts of a SideScrolling Shooter. I downloaded several video's of game footage for it that I will be studying. I already noticed one type of enemy ship that flew in in a wavy pattern. I recreated that in this example. It uses the Java sin command. The enemy ship starts from the right and flies to the left and does this again if it gets outside of the screen.


 

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

public class SinWavyMovementExample001 extends Applet implements Runnable {
 Graphics bufferGraphics;
    Image offscreen;

 int angle = 0;
 double blockx;
 double blocky;
 double offsety = 0;

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
     blockx = getSize().width;
     blocky = getSize().height / 2 - 16;
     // Start the runnable thread.
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
         angle+= 3;
         if ( angle > 360 ) {
          angle = 0;
         }
         offsety = Math.sin(Math.toRadians(angle)) * 12;
   blockx -= 0.5;
   if ( blockx < -32 ){
    blockx = getSize().width;
   }
         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( "Sin Wavy Movement Example" , 10 , 10 );

  bufferGraphics.fillRect ( (int)blockx , (int)blocky + (int)offsety , 32 , 32 );

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

 }


}

dinsdag 14 februari 2012

Turrican Style Shooting Example



I have the Turrican remake on my notebook. In this game you can shoot around yourself. I remade this in Java. Shoot and then use the left and right keys to shoot around yourself.


 


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

public class TurricanShootingExample001 extends Applet implements Runnable{
 Graphics bufferGraphics;
    Image offscreen;
  boolean playerMoveRight = false;
  boolean playerMoveLeft = false;
   double playershootangle = 90-45;
   boolean shootlaser = false;
   long shootingdelay;
    double xPos=100;
    double yPos=100;
    boolean isFalling = false;
    boolean isJumping = false;
 double gravity;
 double groundLevel = 100;
 boolean isShooting;
 boolean playerFacingLeft;
 boolean playerFacingRight=true;
 int numlasers = 50;
 double lasers[][] = new double[ numlasers ][ 4 ]; // 0-active,1-x,2-y,3-angle
 long lasertimeout[] = new long[ numlasers ]; // when does the laser end

 public void init() {
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();

     // Start the runnable thread.
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
         updateplayer();
         updatelasers();
         repaint();
         try {
             Thread.sleep(16);
            }
             catch (InterruptedException e) {
             }
     }
    }
    public void updatelasers(){
     if ( shootlaser == true ) {
      if ( shootingdelay < System.currentTimeMillis() ) {
       shootingdelay = System.currentTimeMillis() + 60;
       newlaser();
      }
     }
  for ( int i = 0 ; i < numlasers ; i++ ) {
   if ( lasers[ i ][ 0 ] == 1 ) {
    lasers[ i ][ 1 ] += Math.sin( Math.toRadians( 2 * lasers[ i ][ 3 ] ));
    lasers[ i ][ 2 ] += Math.cos( Math.toRadians( 2 * lasers[ i ][ 3 ] ));
    if ( lasertimeout[ i ] < System.currentTimeMillis() ) {
     lasers[ i ][ 0 ] = 0;
    }
    if ( lasers[ i ] [ 2 ] - 16 > groundLevel ) {
     lasers[ i ][ 0 ] = 0;
    }
   }
  }
    }
    public void newlaser(){
     for ( int i = 0 ; i < numlasers ; i++ ) {
      if ( lasers[ i ][ 0 ] == 0 ) {
       lasers[ i ][ 3 ] = playershootangle;
       lasers[ i ][ 0 ] = 1;
       lasers[ i ][ 1 ] =  xPos + 8
            + 10 * Math.sin( Math.toRadians( 2 * lasers[ i ][ 3 ] )) ;
       lasers[ i ][ 2 ] = yPos + 8
            + 10 * Math.cos( Math.toRadians( 2 * lasers[ i ][ 3 ] )) ;
       lasertimeout[ i ] = System.currentTimeMillis() + 1300;
    break;
      }
     }
    }
 public void updateplayer(){

   if( playerMoveRight && xPos < getSize().width - 16 && !shootlaser )
   {
    xPos++;
   }
   if( playerMoveLeft && xPos  > 0 && !shootlaser )
   {
    xPos--;
   }
   if ( playerMoveRight && shootlaser ) {
    playershootangle -= 2;
    if ( playershootangle < 0 ) {
     playershootangle = 360;
    }
   }
   if ( playerMoveLeft && shootlaser ) {
    playershootangle += 2;
    if ( playershootangle > 360 ) {
     playershootangle = 0;
    }
   }
   if( isJumping )
   {
    yPos = (int)yPos - gravity;
    gravity = gravity - .1;
    if( gravity < 0 )
    {
     isJumping = false;
     isFalling = true;
    }
   }
   if( isFalling )
   {
    yPos = (int)yPos + gravity;
    gravity = gravity + .1;
    if( yPos  >groundLevel )
    {
     isFalling = false;
     yPos = groundLevel;
     gravity  =0;
    }
   }
 }

  public boolean keyUp (Event e, int key){
    if ( key == 97 )
        {
          playerMoveLeft = false;
        }
        if ( key == 100 )
        {
          playerMoveRight = false;
        }
  if ( key == 109 ) { // m key
   shootlaser = false;
   // when the player releases the fire key then reset the shooting angle.
   if ( playerFacingLeft ) {
    playershootangle = 90+45;
   }
   if ( playerFacingRight ) {
    playershootangle = 45;
   }

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

    if ( key == 97 )
        {
         playerMoveLeft = true;
         playerFacingLeft = true;
         playerFacingRight = false;
        }
        if ( key == 100 )
        {
          playerMoveRight = true;
          playerFacingRight = true;
          playerFacingLeft = false;
        }

      if ( key == 120 ) // x character jump
      {
        if( isFalling == false && isJumping == false )
        {
            isJumping = true;
            gravity = 3;
        }
      }

  if ( key == 109 ){ // m shoot
   shootlaser = true;
  }

        System.out.println ("Charakter: " + (char)key + " Integer Value: " + key);
        return true;
  }

 public void update (Graphics g)
  {
  bufferGraphics.clearRect( 0 , 0 , getSize().width , getSize().height );
     bufferGraphics.setColor ( Color.white );
     bufferGraphics.drawString( "Turrican Shooting Example" , 10 , 10 );
     bufferGraphics.drawString( "a - left , d - right , x jump , m - shoot" , 10 , 20 );

  // draw lasers
  for ( int i = 0 ; i < numlasers ; i++ ) {
   if ( lasers[ i ][ 0 ] == 1 ) {
    bufferGraphics.fillOval( (int)lasers[ i ][ 1 ] , (int)lasers[ i ][ 2 ] , 4 , 4 );
   }
  }


     int x = (int) xPos;
     int y = (int) yPos;
     bufferGraphics.fillRect (x, y, 16, 16);



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

 }


}

stringWidth Example





stringWidth is used to see what the width of a string is that is drawn to the screen using drawString. You can easily center a string on the screen with this.

 
 


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

public class stringWidthExample001 extends Applet implements Runnable{
 Graphics bufferGraphics;
    Image offscreen;
 FontMetrics fm;

 public void init() {
  Graphics g;
  g=getGraphics();
  fm = g.getFontMetrics();
  setBackground(Color.black);
     offscreen = createImage(getSize().width,getSize().height);
     bufferGraphics = offscreen.getGraphics();
     // Start the runnable thread.
  new Thread(this).start();
 }
    public void run() {
     for(;;) { // animation loop never ends
         repaint();
         try {
             Thread.sleep(16);
            }
             catch (InterruptedException e) {
             }
     }
    }
    public void update(Graphics g){
     String s;
     bufferGraphics.clearRect(0,0,getSize().width,getSize().width);
        bufferGraphics.setColor(Color.red);
        bufferGraphics.drawString("Stringwidth Example",10,10);
        bufferGraphics.setColor(Color.white);
        s = "This text";
  bufferGraphics.drawString(s,(this.getSize().width-fm.stringWidth(s)) / 2, 80);
        s = "is centered";
  bufferGraphics.drawString(s,(this.getSize().width-fm.stringWidth(s)) / 2, 90);
  s = "on the screen";
  bufferGraphics.drawString(s,(this.getSize().width-fm.stringWidth(s)) / 2, 100);


  // Draw the Graphics buffer
       g.drawImage(offscreen,0,0,this);
    }
}

Exclamation Boolean Example



I was reading through sourcecode and found that I was not that familiar with the shown method of using a boolean. When placing a ! before a variable you can see if it is set to false.

 


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

public class exclamationbooleanvalueExample001 extends Applet {

 // create a boolean and set its value to false
 boolean the = false;

 public void init() {
 }

 public void paint(Graphics g) {
  g.drawString( "! Example" , 10, 10 );
  g.drawString( "boolean the = false;" , 10 , 30 );
  g.drawString( "if ( !the ) { " , 10 , 40 );

  // if the is false then draw a message on the screen.
  if ( !the ) {
   g.drawString( "the value is false." , 10 , 70 );
  }

 }


}