String Compare - Comparing Strings - equals

I needed this to code the Sim City road connection example. I could not get the == thing comaring working so I looked up how to compare strings with each other. This is done with equals. That worked for me. Below you can see how it is done.

 


/**
 * @(#)StringCompare01.java
 *
 * StringCompare01 Applet application
 *
 * @author
 * @version 1.00 2011/7/21
 */

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

public class StringCompare01 extends Applet {

	public void init() {
	}

	public void paint(Graphics g) {

		String banana = "";

		for ( int i = 0 ; i < 9 ; i++){
			banana = banana + "0";
		}
		System.out.println(banana);
		if ( banana.equals("000000000")) {
			g.drawString("String equals 000000000", 50, 90 );
		}

		g.drawString("Welcome to Java!!", 50, 60 );

	}
}

Sim City Road System - Auto Connect roads

I learned to do this in the 90's. I first saw it I think in Sim City. Where you lay roads and they automatically change to connect with each other. It is a magical thing when you see it. It is also used in games like Civilization where roads and railroads connect with each other.

Press the mouse in the applet to see the new road and click near the last road to connect the roads together.

 


import java.applet.*;
import java.awt.*;
import java.util.Random;
import java.awt.image.BufferedImage;


public class SimCityRoadSystem01 extends Applet {
	Random	r = new Random();
	Graphics bufferGraphics;
    Image offscreen;
	short[][] map = new short[20][15];
	short[][] roadmap = new short[20][15];
	BufferedImage roads[] = new BufferedImage[17];


	private short road[][][]={
							// road 0 - connects to all
							{
							{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,0,0,0,0},
							{0,0,0,0,0,0,0,0}
							},

							// road 1 - connects to all
							{
							{0,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,1,1,1,1,0,0},
							{0,0,1,1,1,1,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,0}
							},
							// road 2 - connects top to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,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,0}
							},
							// road 3 - connects right to center
							{
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0},
							{0,0,0,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,0,1,1,1,1,1},
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0}
							},
							// road 4 - connects bottom to center
							{
							{0,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,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 5 - connects left to center
							{
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0},
							{1,1,1,1,1,0,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,0,0,0},
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0}
							},
							// road 6 - connects top and right to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,0,1,1,1,1,1},
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0}
							},
							// road 7 - connects top and bottom to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 8 - connects top and left to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,0,0,0},
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0}
							},
							// road 9 - connects top and bottom and right to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 10- connects top and bottom and left to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 11 - connects right and bottom to center
							{
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0},
							{0,0,0,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,1,1},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 12 - connects left and right to center
							{
							{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,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}
							},
							// road 13 - connects left and bottom to center
							{
							{0,0,0,0,0,0,0,0},
							{0,0,0,0,0,0,0,0},
							{1,1,1,1,1,0,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{1,1,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 14 - connects left and bottom to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{1,1,1,1,1,1,1,1},
							{1,1,1,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}
							},
							// road 15 - connects left and bottom to center
							{
							{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,1,1,1},
							{1,1,1,1,1,1,1,1},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},
							// road 16 - connects top and left and bottom to center
							{
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0},
							{1,1,1,1,1,1,1,1},
							{1,1,1,1,1,1,1,1},
							{1,1,1,1,1,1,1,1},
							{1,1,1,1,1,1,1,1},
							{0,0,1,1,1,1,0,0},
							{0,0,1,1,1,1,0,0}
							},

	};

    public void init(){
        Graphics2D g;

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

		for ( int i = 0 ; i < 17 ; i++){
			roads[i] = new BufferedImage(16,16,BufferedImage.TYPE_INT_ARGB);
 			g = roads[i].createGraphics();
			for ( int y = 0 ; y < 8 ; y++){
				for ( int x = 0 ; x < 8 ; x++){
					if (road[i][x][y] == 1) {
						g.setColor(new Color(150,150,150,255));
					}
					if (road[i][x][y] == 0) {
							g.setColor(new Color(0,0,0,0));
					}
					g.fillRect(y*2,x*2,2,2);
				}
			}
		}

     }

	public boolean doroadmap( int x , int y ){
		if ( x < 0 ) return false;
		if ( x > 19 ) return false;
		if ( y < 0 ) return false;
		if ( y > 14 ) return false;
		String roadsit;

		roadsit = "";

		if ( roadmap[x][y] == 1 ) roadsit=roadsit + "1";

		if ( y - 1 < 0 ) {
			roadsit = roadsit + "0";
		}else{
			if ( roadmap[x][y-1] == 1 ) {
				roadsit=roadsit + "1";
			}else{
				roadsit=roadsit + "0";
			}
		}
		if ( x - 1 < 0 ) {
			roadsit = roadsit + "0";
		}else{
			if ( roadmap[x - 1][y] == 1 ){
				roadsit = roadsit + "1";
			}else{
				roadsit = roadsit + "0";
			}
		}
		if ( x + 1 > 19 ) {
			roadsit = roadsit + "0";
		}else{
			if ( roadmap[ x + 1 ][ y ] == 1 ){
				roadsit = roadsit + "1";
			}else{
				roadsit = roadsit + "0";
				}
		}
		if ( y + 1 > 14 ){
			roadsit = roadsit + "0";
		}else{
			if ( roadmap[x][y+1] == 1 ){
				roadsit = roadsit + "1";
			}else{
				roadsit = roadsit + "0";
			}
		}

		if ( roadsit.equals("10000") ) map[x][y] = 1;
		if ( roadsit.equals("11000") ) map[x][y] = 2;
		if ( roadsit.equals("10010") ) map[x][y] = 3;
		if ( roadsit.equals("10001") ) map[x][y] = 4;
		if ( roadsit.equals("10100") ) map[x][y] = 5;
		if ( roadsit.equals("11010") ) map[x][y] = 6;
		if ( roadsit.equals("11001") ) map[x][y] = 7;
		if ( roadsit.equals("11100") ) map[x][y] = 8;
		if ( roadsit.equals("11011") ) map[x][y] = 9;
		if ( roadsit.equals("11101") ) map[x][y] = 10;
		if ( roadsit.equals("10011") ) map[x][y] = 11;
		if ( roadsit.equals("10110") ) map[x][y] = 12;
		if ( roadsit.equals("10101") ) map[x][y] = 13;
		if ( roadsit.equals("11110") ) map[x][y] = 14;
		if ( roadsit.equals("10111") ) map[x][y] = 15;
		if ( roadsit.equals("11111") ) map[x][y] = 16;



		return true;

	}

 	public boolean mouseDown (Event e, int x, int y) {
        if (e.modifiers == Event.META_MASK) {
        //    info=("Right Button Pressed");
        } else if (e.modifiers == Event.ALT_MASK) {
        //    info=("Middle Button Pressed");
        } else {
        //   info=("Left Button Pressed");
//        	System.out.println( "left mouse pressed ");
        	roadmap[ x / 16 ][ y / 16 ] = 1;
        	for ( int y1 = -1 ; y1 <=1 ; y1++ ){
        		for ( int x1 = -1 ; x1 <=1 ; x1++ ) {
            		doroadmap ( ( x / 16 ) + x1  ,  ( y / 16 ) + y1  );
        		}
        	}
        }
        repaint();
        return true;
    }
	public void paint(Graphics g){
    	bufferGraphics.clearRect(0,0,getSize().width,getSize().height);
    	bufferGraphics.setColor(Color.red);
        bufferGraphics.drawString("Sim City Road System.",10,10);
		bufferGraphics.drawString("Press the mouse on the applet ",10,20);
     	bufferGraphics.drawString("to lay roads.",10,30);


		for ( int x = 0 ; x < 20 ; x++ ) {
			for ( int y = 0 ; y < 15 ; y++ ) {
				bufferGraphics.drawImage( roads[map[ x ][ y ]] , x * 16 , y * 16 , this );
			}
		}


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

     }
    public void update(Graphics g){
          paint(g);
     }
 }

Gaming and surfing.

I a'm playing games and not doing any programming. I also spend a lot of time surfing the Internet. I have almost 1500 visits to my weblog here since I started. This is quite a lot. Certain code gets a good number of hits.

I have a couple of posts ready to be published. One is a Sim City road thing. In that applet roads automatically connect to the neighbouring road. I learned to do this in the 90's. It is one of the best things I can do. I am not that great a coder.

I do not know when I will start programming again and when I will add those last code posts to the blog. Maybe I will do it next.

The games I have bought with Steam and am playing are not that good. The notebook has a touchpad and it is buggy in games. Civilization 3 was the most adictive game I played in a long time. I can program a couple of features from that game myself. I like spending time figuring out how certain things can be programmed from the games that I play a lot.
At the moment I am listening to music from the Mod archive. I downloaded gigabytes of mod music and am compiling a list of the best music which I will probably blog sometimes when it is big enough. There is not a lot of good music in the gigabytes of music. But sometimes there is a good song to be heared. Some of my own music is in the Mod archive. I already heared one song while listening to the collection in random.

I bought this book on artificial intelligence and am sorry I spend money on it. I sometimes check it and have learned something though. How to correct paths with the pathfinding thing.

I do spend time thinking of programming. I have a 4 thread computer and am not able to find a good source of multithreaded programming programming information. The dual core 2.66 ghz processor I have is fast and I  do not read anything on how to use the speed to the max. I use one thread of the 4 available. This is bad. In a couple of years I will probably have a 4 or 6 core processor so I wonder why I have such a hard time finding multithread examples or a new language that has this automatically done.
Java is the most used language on the planet according to certain sources so there is more on the web about it I guess. I am dissapointed that there is so little good and cool examples and tutorials on how to program things from games. I really would like to program my own Civilization and Command and Conquer and other things. But the Internet is only 20 years old and such and things are hard to find.

Java 7 is out and is broken I read. The loops are not working as they should. I read I should wait a couple of months until the bugs are repaired. What I can find on Java 7 is not that much. Nothing about speed increases of multicore things. Still I will upgrade when the problems are repaired.

I follow a few things on the Internet. One is the P Project. This is a blog about remaking Powermonger. I got the idea to buy that Artificial Intelligence book from that Blog. There is not that much activity in programming on that blog. But I do follow it. Though the graphical direction it is going into is discouraging. I was hoping for a remake of Powermonger with as much as layout and style alikeness as possible.

Not programming for a while

I bought a new notepad. It is a Intel Core i5-480 with 4 gb of ram with Intel HD Graphics. I had a old Steam Account and Halflife 2 ran good on the new notepad. Since Steam has a option that allows me to buy directly from steam I bought a set of games. I have been playing these.

I also installed the Java sdk and Jbuilder but have not really programmed anything yet. I was working on an platformer Ice Sliding example but I have been playing games to much to finish it.

The notepad has a problem though. The cursor keys sometimes do not respond if you keep them pressed in. I have been back to the store but they could not notice it. They said to reinstall the windows and to try a different keyboard to see if that has the same behaviour.

I do read the Java gaming forum daily and check the statistics for this blog. At the moment the isometric example has 18 views. The pathfinding example also usually has a good hit count.

My copy of the book Game ai by Example has come in. I had to mail the bookstore since it took ocer a month to get a link to a download. The book is bad. It is short and not that well written. It has math that I do not understand. I wish there were better books but I have not seen any.

I am drinking a beer at the moment and still have some housekeeping to do. I also am going to get some food.  Then I will probably surf the Internet for a while and play a couple of games. I also bought Civilization 3 again on steam this time and will maybe play it. I have a game where I am stuck on a desert section of a map. I remember that you can finish the game without fighting. I did have to pay money to a other player once.
I programmed a bunch of Turn based game things and have a bigger turn based game that I wrote. I will write Turn Based game examples for my blog. Civilization 2 is my all time favourite game but they do not sell it online as a download for as far as I can find. I lost my old copy. I am certainly going to buy it again if I find it anywhere.

I am also looking for other games to buy and have used Youtube to view game play footage of games that looked interesting. So far a space strategy game and a Halflife mod looked like a buy.

I do think of programming when I am in my bed. I was thinking of how to make bots but it seems difficult.

Well I am going to finish my beer and will go get some food and start kooking.

Platformer Bump Head into Tiles Example.

I made this example this weekend. In the game mario you can bump your head into tiles and they will spawn presents out of them. Above in the applet I made something like that. Click in the applet to activate it and use the cursor keys and space to move around in the map. Use space to bump into the yellow tiles and after a number of times a presents will be put ontop of it.

 


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

public class PlatformerHitTiles01 extends Applet implements Runnable {
 // Graphics for double buffering.
 Graphics    bufferGraphics;
    Image     offscreen;
 private short map[][]={
      {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,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,0,0,0,0,0,0,0,0,2,0,0,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,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,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,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,1},
      {1,0,0,0,0,0,0,0,0,2,0,0,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,1},
      {1,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}
      };
 int     mapwidth =    20;
 int      mapheight =   13;
 int      cellwidth =   16;
 int      cellheight =   16;
 double     px =     200;
 double    py =    100;
 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;
 short    numhitblocks =  32;
 double[][]   hitblocks =   new double[numhitblocks][9];    // 0 - active , 1 - x
                   // 2 - y , 3 - type
                   // 4 - numhits(how many times to jump into for present)
                   // 5 - jump , 6 - jumpgravity , 7 - falling
                   // 8 - incy;
 int     currenthitblock =  0;
 int     numpresents =   32;
 double[][]   presents =    new double[numpresents][9];  // 0 - active , 1 - x
                   // 2 - y

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

 }

 public void initmap(){
  // initialize the hit tiles (the blocks you jump into)
  int counter = 0;
  for ( int y = 0 ; y < mapheight ; y++ ){
   for ( int x = 0 ; x < mapwidth ; x++ ){
    if ( map[x][y] == 2 ){
     hitblocks[counter][0] = 1;
     hitblocks[counter][1] = x * cellwidth;
     hitblocks[counter][2] = y * cellheight;
     hitblocks[counter][3] = 0;
     hitblocks[counter][4] = 3;
     counter++;
    }
   }
  }
 }

 public void paint(Graphics g) {
 }

    public void run() {
        for(;;) { // animation loop never ends
   updateplayer();
   updatepresents();
   updatehitblocks();
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

    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 ){
     if ( hitblockcollision ( (int)px , (int)(py - 1) , pwidth , pheight ) == false ){
      py -= 1;
     }else{
      gravity = 0;
      isfalling = true;
      isjumping = false;
      hitblocks[currenthitblock][4] -= 1;
      hitblocks[currenthitblock][5] = 1;
      if( hitblocks[currenthitblock][4] < 0 ){
       hitblocks[currenthitblock][0] = 0;
       map[ (int)hitblocks[currenthitblock][1] / cellwidth ][ (int)hitblocks[currenthitblock][2] / cellheight ] = 1;
       newpresent((int)hitblocks[currenthitblock][1] / cellwidth , ((int)hitblocks[currenthitblock][2] / cellheight ) - 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 void updatepresents(){
  for( int i = 0 ; i < numpresents ; i++ ){
   if( presents[i][0] == 1 ){
    Rectangle rec1 = new Rectangle( (int)px,
            (int)py,
            pwidth,
            pheight);
    Rectangle rec2 = new Rectangle( (int)presents[i][1],
            (int)presents[i][2],
            cellwidth,
            cellheight);
    if (rec1.intersects( rec2 )){
     presents[i][0] = 0;
    }
   }
  }
 }

 public boolean hitblockcollision( int x , int y , int width , int height ){
  for ( int i = 0 ; i < numhitblocks ; i++ ){
   if( hitblocks[i][0] == 1 ){
    Rectangle rec1 = new Rectangle( x , y , width , height );
    Rectangle rec2 = new Rectangle( (int)hitblocks[i][1],
            (int)hitblocks[i][2],
            cellwidth,
            cellheight);
    if( rec1.intersects( rec2 )){
     currenthitblock = i;
     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[x1][y1] == 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 newpresent(int x, int y){
  for( int i = 0 ; i < numpresents ; i++){
   if ( presents[i][0] == 0 ) {
    presents[i][1] = x * cellwidth;
    presents[i][2] = y * cellheight;
    presents[i][0] = 1;
    return true;
   }
  }
  return false;
 }

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

 public void updatehitblocks(){
  for ( int i = 0 ; i < numhitblocks ; i++ ){
   if( hitblocks[i][0] == 1 ){
    if( hitblocks[i][5] == 1 ){
     hitblocks[i][6] -= hitblocks[i][8];
     hitblocks[i][8] += .1;
     if( hitblocks[i][6] < -6 ) {
      hitblocks[i][5] = 0;
      hitblocks[i][7] = 1;
      hitblocks[i][8] = 0;
     }
    }
    if( hitblocks[i][7] == 1 ){
     hitblocks[i][6] += hitblocks[i][8];
     hitblocks[i][8] += .1;
     if( hitblocks[i][6] > 0 ){
      hitblocks[i][6] = 0;
      hitblocks[i][7] = 0;
      hitblocks[i][8] = 0;
     }
    }
   }
  }
 }

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

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

  // Draw hitblocks
  bufferGraphics.setColor( new Color(255,255,0));
  for ( int i = 0 ; i < numhitblocks ; i++ ){
   if( hitblocks[i][0] == 1 ) {
    bufferGraphics.fillRect(  (int)hitblocks[i][1],
           (int)hitblocks[i][2] + (int)hitblocks[i][6] ,
           cellwidth,
           cellheight);
   }
  }

  // Draw presents
  bufferGraphics.setColor( new Color(0,255,0));
  for ( int i = 0 ; i < numpresents ; i++){
   if ( presents[i][0] == 1 ){
    bufferGraphics.fillOval( (int)presents[i][1],
           (int)presents[i][2],
           cellwidth,
           cellheight);
   }
  }
        // Draw player
        bufferGraphics.setColor(Color.red);
        bufferGraphics.fillRect( (int)px , (int)py , pwidth , pheight );

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

  public boolean keyDown (Event e, int key){
    if( key == Event.LEFT )
        {
         ismovingleft = true;
        }
        if(key==Event.RIGHT)
        {
          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 == Event.LEFT )
        {
          ismovingleft = false;
        }
        if( key == Event.RIGHT )
        {
          ismovingright = false;
        }

  return true;
 }

}

RTS Selecting Units #1 - Mouse Selecting rectangle

Press Mouse and Drag it on the Applet  to create a selection rectangle which can be used to select the Units in Real Time Strategy Games.

I had a little trouble figuring out how to do this since I forgot to check all the mouse features that Java has and forgot about the Mouse Drag method. Once I found that one I had no trouble creating the selection part. I made things like this before for simple RTS like games.

In the code I change the selection coordinates if they are drawn into negative. Meaning if the x or y starting point is smaller then the drag coordinates. This because you need to draw a rectangle in a certain way.

 

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

public class RTSSelectingUnits01 extends Applet implements Runnable {
 // Graphics for double buffering.
 Graphics      bufferGraphics;
    Image       offscreen;
 int mousebutton =    0;
 int selx1 =     0;
 int sely1 =     0;
 int selx2 =     0;
 int sely2 =     0;
 boolean drawselectrect =  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
         repaint();
         try {
             Thread.sleep(10);
             }
             catch (InterruptedException e) {
             }
     }
    }

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

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

  if(drawselectrect == true ){
   bufferGraphics.setColor(new Color(200,200,200));
   int tx1 = selx1;
   int ty1 = sely1;
   int tx2 = selx2;
   int ty2 = sely2;
   if (selx1 > selx2){
    tx1 = selx2;
    tx2 = selx1;
   }
   if (sely1 > sely2){
    ty1 = sely2;
    ty2 = sely1;
   }
   bufferGraphics.drawRect(tx1,ty1,tx2-tx1,ty2-ty1);
  }
  bufferGraphics.drawString(""+selx2+","+sely2,10,20);
       g.drawImage(offscreen,0,0,this);
    }

  public boolean mouseDown (Event e, int x, int y) {
        if (e.modifiers == Event.META_MASK) {
            //info=("Right Button Pressed");
         mousebutton = 2;
        } else if (e.modifiers == Event.ALT_MASK) {
            //info=("Middle Button Pressed");
        } else {
            //info=("Left Button Pressed");
            mousebutton = 1;
            selx1 = x;
            sely1 = y;
       drawselectrect = true;
        }

        return true;
    }

  public boolean mouseUp (Event e, int x, int y) {
        if (e.modifiers == Event.META_MASK) {
            //info=("Right Button Pressed");
         mousebutton = 0;
        } else if (e.modifiers == Event.ALT_MASK) {
            //info=("Middle Button Pressed");
        } else {
            //info=("Left Button Pressed");
            mousebutton = 0;
            drawselectrect = false;

       }
        return true;
    }
  public boolean mouseDrag(Event e, int x, int y){
   selx2 = x;
   sely2 = y;
   return true;
  }


}

Platformer Spikes Example

Use Cursors Left and Right to move. Space to Jump. Avoid being spiked.

 

import java.awt.*;
import java.applet.*;
import java.util.Random;
import java.awt.geom.Area;

public class PlatformerSpikes01 extends Applet implements Runnable {
 Random    r =     new Random();
 // Graphics for double buffering.
 Graphics    bufferGraphics;
    Image     offscreen;
 Image     spikeimage;
 private short map[][]={
      {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,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,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,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,0,0,0,0,0,0,0,0,0,0,2,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,2,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,2,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,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,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,1},
      {1,1,1,1,1,1,1,1,1,1,1,1,1}
      };
 int     mapwidth =    20;
 int      mapheight =   13;
 int      cellwidth =   16;
 int      cellheight =   16;
 int     pstartx =    32;
 int     pstarty =    128;
 double     px =     pstartx;
 double    py =    pstarty;
 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     sx1 =    3;
 int     sy1 =    0;
 int     sx2 =    7;
 int     sy2 =    32;
 int     sx3 =     0;
 int     sy3 =    32;
 short    maxnumspikes =  32;
 short     spikewidth =   8;
 short    spikeheight =   32;
 double     spikes[][] =   new double[maxnumspikes][9];  // 0 - active , 1 = x
                   // 2 = y , 3 - incx , 4 - incy
                   // 5 - addx , 6 = addy
                   // 7 - spikewait , 8 - up(1)/down(2)

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

  spikeimage = createImage(8,32);
  Graphics test1 = spikeimage.getGraphics();
  int[] XArray = {sx1,sx2,sx3};
     int[] YArray = {sy1,sy2,sy3};
     test1.setColor(Color.red);
     test1.fillPolygon (XArray, YArray, 3);

  initmap();
  new Thread(this).start();

 }

 public void initmap(){
  int cnt = 0;
  for ( int y = 0 ; y < mapheight ; y++){
   for ( int x = 0 ; x < mapwidth ; x++){
    if( map[x][y] == 2 ){ // if map tile is a spike (2)
     spikes[cnt][0] = 1;
     spikes[cnt][1] = x * cellwidth;
     spikes[cnt][2] = y * cellheight;
     spikes[cnt][4] = spikeheight;
     spikes[cnt][7] = r.nextInt(200);
     spikes[cnt][8] = 2;
     cnt++;
    }
   }
  }
 }

 public void paint(Graphics g) {
 }

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

    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 void updatespikes(){

   if ( pspikecollision() ) {
    px = pstartx;
    py = pstarty;
   };

   for ( int i = 0 ; i < maxnumspikes ; i++ ){
    if ( spikes[i][0] == 1 ){ // if spike is active
     if(spikes[i][7] < 0 ){
      if ( spikes[i][8] == 2 ){
       spikes[i][4] -= spikes[i][6];
       if ( spikes[i][4] < 0 ){
        spikes[i][4] = 0; // lowest value
        spikes[i][8] = 1; // go up again
        spikes[i][6] = 0;
        spikes[i][7] = 100;
       }
       spikes[i][6] += .01;
      }
      if ( spikes[i][8] == 1 ){
       spikes[i][4] += spikes[i][6];
       if ( spikes[i][4] > spikeheight ){
        spikes[i][4] = spikeheight; // highest value
        spikes[i][8] = 2; // go down again
        spikes[i][7] = 100;
       }
       spikes[i][6] += .01;
      }
     }
     spikes[i][7]--;
    }
   }
  }

 public boolean pspikecollision(){
  for ( int i = 0 ; i < maxnumspikes ; i++ ){
   if ( spikes[i][0] == 1 ){

    int[] XArray =  {(int)px, (int)px+pwidth, (int)px+pwidth,  (int)px};
       int[] YArray =  {(int)py, (int)py,  (int)py+pheight, (int)py+pheight};
       int[] XArray2 = {(int)spikes[i][1]+sx1, (int)spikes[i][1]+sx2,  (int)spikes[i][1]+sx3};
       int[] YArray2 = {(int)spikes[i][2]+(spikeheight - cellheight) - (int)spikes[i][4]+sy1, (int)spikes[i][2]+sy2, (int)spikes[i][2]+sy3};

       Polygon abc = new Polygon(XArray, YArray, 4);
       Polygon abc2= new Polygon(XArray2,YArray2,3);
       //g.drawPolygon(abc);
       //g.drawPolygon(abc2);

      Area a1 = new Area(abc);
      Area a2 = new Area(abc2);

    a1.intersect(a2);
    if (!a1.isEmpty())
     //g.drawString("Two Polygons collided", 20, 20 );
     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[x1][y1] == 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 mouseMove(Event e, int x, int y){
  return true;
 }

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

        // Draw map
        for( int y = 0 ; y < mapheight ; y++ ){
         for ( int x = 0 ; x < mapwidth ; x++){
          if( map[x][y] == 1 ){
           bufferGraphics.fillRect( x * cellwidth , y * cellheight , cellwidth , cellheight );
          }
         }
        }
  // Draw Spikes
  for ( int i = 0 ; i < maxnumspikes ; i++ ){
   if ( spikes[i][0] == 1 ){
    bufferGraphics.drawImage( spikeimage,
           (int)spikes[i][1],
           (int)spikes[i][2] + (spikeheight - cellheight) - (int)spikes[i][4],
           spikewidth,
           (int)spikes[i][4],
           this);
   }
  }

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

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

  public boolean keyDown (Event e, int key){
    if( key == Event.LEFT )
        {
         ismovingleft = true;
        }
        if(key==Event.RIGHT)
        {
          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 == Event.LEFT )
        {
          ismovingleft = false;
        }
        if( key == Event.RIGHT )
        {
          ismovingright = false;
        }

  return true;
 }

}