«

[Kon-Tiki]

Tadaa! Loop works fine, except that it draw black spots instead of the boxes, but it knows where they have to come. Probably just named them wrong. Borders of any level are set too. Now the next part: Giving properties to each part (so that he won't walk through walls anymore)

[Kon-Tiki]

Eep, third post after each other.

Assignment so far

[Rogue]

you have to post the code trough forum. I have only VJ.net on this computer.

Also, can you explain in plain english what you like to accomplishe.

While you do this, here is my recomendation for code (In example I'll write the pseudo code):

[code]
move up:
check if cell is empty
if yes, just move up
if no, check if is the end of the world ()
if yes, don't move, put something , or play some bad sound (perhaps fart )
if no, check what colort is the first box you hitting
check the next box
if is empty, move only that one box
if is not empty, check if next box is same color
if it is, do the same check with next cell
if not, play that bad sound again.

in this checks, you should also make sure that you don't move world's blocks.

also, can you tell how do you check win situation

[Kon-Tiki]

Well, that already works fine (but I like the fart-sound thing ) Main problem now is the winning condition. This's the code:

import bvp.*;
import java.io.*;
public class VoorbeeldPijltjes {
 * *public static void main(String[] args) {


String bestandsnaam;
bestandsnaam = "Voorbeeld.txt";

BestandsInvoer bi = new BestandsInvoer (bestandsnaam);

String regel = bi.leesRegel();


// ********************************
// ** De begin-coordinaten lezen **
// ********************************

int Checker = 0;
Checker = Counting(regel, Checker)+1;
int Temp = Counting(regel, Checker);

String tempX = regel.substring(4,Temp);
int dimX = Integer.parseInt(tempX);

Checker = Counting(regel, Checker)+1;
int TempStart = Temp + 1;
Temp = Counting(regel, Checker);
String tempY = regel.substring(TempStart);
int dimY = Integer.parseInt(tempY);
	

// *************************
// ** Nieuw bord plaatsen **
// *************************

Bus bus=new Bus();
Figuren verz = new Figuren("dozo2.fig");
int e=verz.getEenheid("grid");
Bord bord=new Bord("Dozo World", dimX*e, dimY*e, bus);

int plaatsX;
int plaatsY = 0;
int x = 0;
int y = 0;
int[] spelbord;
spelbord = new int[dimX*dimY];


// ***************************
// ** Plaatsen van de items **
// ***************************

for (plaatsY = 0; plaatsY < dimY; plaatsY++) {
	regel = bi.leesRegel();
	for (plaatsX = 0; plaatsX < dimX; plaatsX++) {
 *switch(regel.charAt(plaatsX)) {
 *	case '.': spelbord[(plaatsY*dimX) + plaatsX] = 0;
 * * * bord.plaatsFiguur("vloer", verz, plaatsX*e, plaatsY*e);
 * * * break;
 *	case 'B': spelbord[(plaatsY*dimX) + plaatsX] = 1;
 * * * bord.plaatsFiguur("doos1", verz, plaatsX*e, plaatsY*e);
 * * * break;
 *	case 'R': spelbord[(plaatsY*dimX) + plaatsX] = 2;
 * * * bord.plaatsFiguur("doos2", verz, plaatsX*e, plaatsY*e);
 * * * break;
 *	case '#': spelbord[(plaatsY*dimX) + plaatsX] = 3;
 * * * bord.plaatsFiguur("muur", verz, plaatsX*e, plaatsY*e);
 * * * break;
 *	case '@': spelbord[(plaatsY*dimX) + plaatsX] = 4;
 * * * bord.plaatsFiguur("mannetje", verz, plaatsX*e, plaatsY*e);
 * * * x=plaatsX; *y=plaatsY;
 * * * break;
 *}
	}
}
 * * * *bord.toonVeranderingen();


// *********************
// ** Bewegen + duwen **
// *********************

 * * * *while (true) {
 * * * * * *Boodschap boodschap=bus.getBoodschap();
 * * * * * *if (boodschap.getType().equals("toetsenbord")) {
 * * * * * * * *String data=boodschap.getData();
 * * * * * * * *if (data.startsWith("!-")) {

 * *int oldx=x; int oldy=y;
 * *int object;
 * *int d;


// ** Naar links

 * *if (data.equals("!-Left") && x>1) { 
 *d=x;
 *d--;
 *if (spelbord[(y*dimX)+d] == 0) {
 * *spelbord[(y*dimX)+x] = 0;
 * * * * * *	x--;
 *}
 *if (spelbord[(y*dimX)+d] == 1 || spelbord[(y*dimX)+d] == 2) {
 *	object = spelbord[(y*dimX)+d];
 *	System.out.println("Object = "+ object);
 *	do {
 * *d--;
 *	} while (spelbord[(y*dimX)+d] == object);

 * *if (spelbord[(y*dimX)+d] == 0) {
 * *	spelbord[(y*dimX)+d] = object;
 * *	bord.plaatsFiguur("doos"+ object, verz, d*e, y*e);
 * *	bord.plaatsFiguur("vloer", verz, x*e, y*e);
 * *	spelbord[(y*dimX)+x] = 0;
 * *	x--;
 * *	bord.plaatsFiguur("mannetje", verz, x*e, y*e);
 * *	spelbord[(y*dimX)+x] = 4;
 *	}
 *	
 *} *	

 * *}	


// ** Naar rechts

 * *if (data.equals("!-Right") && x<(dimX-1)) {
 *d=x;
 *d++;
 *if (spelbord[(y*dimX)+d] == 0) {
 * *spelbord[(y*dimX)+x] = 0;
 * * * * * *	x++;
 *}
 *if (spelbord[(y*dimX)+d] == 1 || spelbord[(y*dimX)+d] == 2) {
 *	object = spelbord[(y*dimX)+d];
 *	System.out.println("Object = "+ object);
 *	do {
 * *d++;
 *	} while (spelbord[(y*dimX)+d] == object);
 *	if (spelbord[(y*dimX)+d] == 0) {
 * *spelbord[(y*dimX)+d] = object;
 * *bord.plaatsFiguur("doos"+ object, verz, d*e, y*e);
 * *bord.plaatsFiguur("vloer", verz, x*e, y*e);
 * *spelbord[(y*dimX)+x] = 0;
 * *x++;
 * *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
 * *spelbord[(y*dimX)+x] = 4;
 *	}
 *} *	

 * *}	
 * *
 * *
// ** Naar boven

 * *if (data.equals("!-Up") && y>1) {
 *d=y;
 *d--;
 *if (spelbord[(d*dimX)+x] == 0) {
 * *spelbord[(y*dimX)+x] = 0;
 * * * * * *	y--;
 *}
 *if (spelbord[(d*dimX)+x] == 1 || spelbord[(d*dimX)+x] == 2) {
 *	object = spelbord[(d*dimX)+x];
 *	System.out.println("Object = "+ object);
 *	do {
 * *d--;
 *	} while (spelbord[(d*dimX)+x] == object);
 *	if (spelbord[(d*dimX)+x] == 0) {
 * *spelbord[(d*dimX)+x] = object;
 * *bord.plaatsFiguur("doos"+ object, verz, x*e, d*e);
 * *bord.plaatsFiguur("vloer", verz, x*e, y*e);
 * *spelbord[(y*dimX)+x] = 0;
 * *y--;
 * *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
 * *spelbord[(y*dimX)+x] = 4;
 *	}
 *	
 *} *	

 * *}	


// ** Naar beneden

 * *if (data.equals("!-Down") && y<(dimY-1)) {
 *d=y;
 *d++;
 *if (spelbord[(d*dimX)+x] == 0) {
 * *spelbord[(y*dimX)+x] = 0;
 * * * * * *	y++;
 *}
 *if (spelbord[(d*dimX)+x] == 1 || spelbord[(d*dimX)+x] == 2) {
 *	object = spelbord[(d*dimX)+x];
 *	System.out.println("Object = "+ object);
 *	do {
 * *d++;
 *	} while (spelbord[(d*dimX)+x] == object);
 *	if (spelbord[(d*dimX)+x] == 0) {
 * *spelbord[(d*dimX)+x] = object;
 * *bord.plaatsFiguur("doos"+ object, verz, x*e, d*e);
 * *bord.plaatsFiguur("vloer", verz, x*e, y*e);
 * *spelbord[(y*dimX)+x] = 0;
 * *y++;
 * *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
 * *spelbord[(y*dimX)+x] = 4;
 *	}
 *	
 *} *	

 * *}	
 * *
 * *bord.plaatsFiguur("vloer", verz, oldx*e, oldy*e);
 * *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
 * *bord.toonVeranderingen();


// *********************************************
// ** Checken voor dozen die mogen verdwijnen ** *-> Nog aan aan't werken
// *********************************************

	int g;
	int h;
	int doos;
	int teller = 0;
	int[] groep;
	groep = new int[dimX*dimY];
	for (doos = 1; doos <=2; doos++) {
 *for (g=0; g < dimX; g++) {
 *	for (h=0; h < dimY; h++) {
 * *if (spelbord[(h*dimX)+g] == doos) {
 * *	teller ++;
 * *	groep[teller] = (h*dimX)+g;
 * *}
 * *else {
 * *	teller = 0;
 * *}
 * *if (teller == 4 && doos == 1) {
 * *	System.out.println("Voldoende dozen 1");
 * *}
 * *if (teller == 3 && doos == 2) {
 * *	System.out.println("Voldoende dozen 2");
 * *}
 * *	
 *	} *	
 *}
	}








 * * * * * * * *}
 * * * * * *}
 * * * *}





 * *}


// ******************************************************************
// ** Tellen tot'n spatie komt (voor de eerste regel van'n wereld) **
// ******************************************************************

public static int Counting(String regel, int Checker) {
	int counter = regel.length()-1;
	int StartCount = Checker;
	for (int c=StartCount; c<=counter; c++) {
 *char Temp = regel.charAt(c);
 *	if (Temp == ' ') {
 * * *break;
 *	}
 *	else {
 * * *Checker ++;
 *	}
	}
	return Checker;
}
}

[Rogue]

Can you explain what are you trying to accoplish with each code?

[Kon-Tiki]

import bvp.*;
import java.io.*;
public class VoorbeeldPijltjes {
* *public static void main(String[] args) {

This loads the necessary libraries and starts the main class

String bestandsnaam;
bestandsnaam = "Voorbeeld.txt";

BestandsInvoer bi = new BestandsInvoer (bestandsnaam);

String regel = bi.leesRegel();

This one reads the world-file

// ********************************
// ** De begin-coordinaten lezen **
// ********************************

int Checker = 0;
Checker = Counting(regel, Checker)+1;
int Temp = Counting(regel, Checker);

String tempX = regel.substring(4,Temp);
int dimX = Integer.parseInt(tempX);

Checker = Counting(regel, Checker)+1;
int TempStart = Temp + 1;
Temp = Counting(regel, Checker);
String tempY = regel.substring(TempStart);
int dimY = Integer.parseInt(tempY);

// ******************************************************************
// ** Tellen tot'n spatie komt (voor de eerste regel van'n wereld) **
// ******************************************************************

public static int Counting(String regel, int Checker) {
int counter = regel.length()-1;
int StartCount = Checker;
for (int c=StartCount; c<=counter; c++) {
*char Temp = regel.charAt(c);
* if (Temp == ' ') {
* * *break;
* }
* else {
* * *Checker ++;
* }
}
return Checker;
}

The first one reads the dimensions of the world as described in the first line of the world-file (being DIM x y, DIM 12 5 for example) It does this by calling the second code, which runs through the line until it finds a space, then returns how many characters it's got to run along. It takes that part (from the beginning of the checker until the first space) and tosses it away at first (as it's DIM, which we don't need), then turns the string it receives for the x-dimension into the int dimX and the string for the y-dimension into the int dimY

// *************************
// ** Nieuw bord plaatsen **
// *************************

Bus bus=new Bus();
Figuren verz = new Figuren("dozo2.fig");
int e=verz.getEenheid("grid");
Bord bord=new Bord("Dozo World", dimX*e, dimY*e, bus);

int plaatsX;
int plaatsY = 0;
int x = 0;
int y = 0;
int[] spelbord;
spelbord = new int[dimX*dimY];

This one initializes the board and input (both done through the bvp.jar library), as well as it loads the graphical tiles and readies some variables for the next part. The world is stored as an array, called spelbord.

// ***************************
// ** Plaatsen van de items **
// ***************************

for (plaatsY = 0; plaatsY < dimY; plaatsY++) {
regel = bi.leesRegel();
for (plaatsX = 0; plaatsX < dimX; plaatsX++) {
*switch(regel.charAt(plaatsX)) {
* case '.': spelbord[(plaatsY*dimX) + plaatsX] = 0;
* * * bord.plaatsFiguur("vloer", verz, plaatsX*e, plaatsY*e);
* * * break;
* case 'B': spelbord[(plaatsY*dimX) + plaatsX] = 1;
* * * bord.plaatsFiguur("doos1", verz, plaatsX*e, plaatsY*e);
* * * break;
* case 'R': spelbord[(plaatsY*dimX) + plaatsX] = 2;
* * * bord.plaatsFiguur("doos2", verz, plaatsX*e, plaatsY*e);
* * * break;
* case '#': spelbord[(plaatsY*dimX) + plaatsX] = 3;
* * * bord.plaatsFiguur("muur", verz, plaatsX*e, plaatsY*e);
* * * break;
* case '@': spelbord[(plaatsY*dimX) + plaatsX] = 4;
* * * bord.plaatsFiguur("mannetje", verz, plaatsX*e, plaatsY*e);
* * * x=plaatsX; *y=plaatsY;
* * * break;
*}
}
}
* * * *bord.toonVeranderingen();

This part of the code reads the game's world line per line and puts the right tiles on the right spot, and gives the corresponding number in the array the right value. Here's a list of which means which:

• 0 = Floor
• 1 = Box type 1
• 2 = Box type 2
• 3 = Wall
• 4 = player

After that, it shows the changes to the world by calling the method (still from the bvp-library) bord.toonVeranderingen.

You might notice some confusing thing in the array index... this formula: (y*dimX)+x. It's because before, when I just used x*y for the array index, x = 2, y = 5 had the same index as x = 5, y = 2, x = 1, y = 10 and x = 10, y = 1, as example. Too buggy. This formula's kinda the same as Row*maxColumns + Column from the Connect Four assignment (with difference that this matrix's point 0 is at the top left, not the bottom left)

// *********************
// ** Bewegen + duwen **
// *********************

* * * *while (true) {
* * * * * *Boodschap boodschap=bus.getBoodschap();
* * * * * *if (boodschap.getType().equals("toetsenbord")) {
* * * * * * * *String data=boodschap.getData();
* * * * * * * *if (data.startsWith("!-")) {

* *int oldx=x; int oldy=y;
* *int object;
* *int d;


// ** Naar links

* *if (data.equals("!-Left") && x>1) { 
*d=x;
*d--;
*if (spelbord[(y*dimX)+d] == 0) {
* *spelbord[(y*dimX)+x] = 0;
* * * * * * x--;
*}
*if (spelbord[(y*dimX)+d] == 1 || spelbord[(y*dimX)+d] == 2) {
* object = spelbord[(y*dimX)+d];
* System.out.println("Object = "+ object);
* do {
* *d--;
* } while (spelbord[(y*dimX)+d] == object);

* *if (spelbord[(y*dimX)+d] == 0) {
* * spelbord[(y*dimX)+d] = object;
* * bord.plaatsFiguur("doos"+ object, verz, d*e, y*e);
* * bord.plaatsFiguur("vloer", verz, x*e, y*e);
* * spelbord[(y*dimX)+x] = 0;
* * x--;
* * bord.plaatsFiguur("mannetje", verz, x*e, y*e);
* * spelbord[(y*dimX)+x] = 4;
* }
* 
*} * 

* *} 


// ** Naar rechts

* *if (data.equals("!-Right") && x<(dimX-1)) {
*d=x;
*d++;
*if (spelbord[(y*dimX)+d] == 0) {
* *spelbord[(y*dimX)+x] = 0;
* * * * * * x++;
*}
*if (spelbord[(y*dimX)+d] == 1 || spelbord[(y*dimX)+d] == 2) {
* object = spelbord[(y*dimX)+d];
* System.out.println("Object = "+ object);
* do {
* *d++;
* } while (spelbord[(y*dimX)+d] == object);
* if (spelbord[(y*dimX)+d] == 0) {
* *spelbord[(y*dimX)+d] = object;
* *bord.plaatsFiguur("doos"+ object, verz, d*e, y*e);
* *bord.plaatsFiguur("vloer", verz, x*e, y*e);
* *spelbord[(y*dimX)+x] = 0;
* *x++;
* *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
* *spelbord[(y*dimX)+x] = 4;
* }
*} * 

* *} 
* *
* *
// ** Naar boven

* *if (data.equals("!-Up") && y>1) {
*d=y;
*d--;
*if (spelbord[(d*dimX)+x] == 0) {
* *spelbord[(y*dimX)+x] = 0;
* * * * * * y--;
*}
*if (spelbord[(d*dimX)+x] == 1 || spelbord[(d*dimX)+x] == 2) {
* object = spelbord[(d*dimX)+x];
* System.out.println("Object = "+ object);
* do {
* *d--;
* } while (spelbord[(d*dimX)+x] == object);
* if (spelbord[(d*dimX)+x] == 0) {
* *spelbord[(d*dimX)+x] = object;
* *bord.plaatsFiguur("doos"+ object, verz, x*e, d*e);
* *bord.plaatsFiguur("vloer", verz, x*e, y*e);
* *spelbord[(y*dimX)+x] = 0;
* *y--;
* *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
* *spelbord[(y*dimX)+x] = 4;
* }
* 
*} * 

* *} 


// ** Naar beneden

* *if (data.equals("!-Down") && y<(dimY-1)) {
*d=y;
*d++;
*if (spelbord[(d*dimX)+x] == 0) {
* *spelbord[(y*dimX)+x] = 0;
* * * * * * y++;
*}
*if (spelbord[(d*dimX)+x] == 1 || spelbord[(d*dimX)+x] == 2) {
* object = spelbord[(d*dimX)+x];
* System.out.println("Object = "+ object);
* do {
* *d++;
* } while (spelbord[(d*dimX)+x] == object);
* if (spelbord[(d*dimX)+x] == 0) {
* *spelbord[(d*dimX)+x] = object;
* *bord.plaatsFiguur("doos"+ object, verz, x*e, d*e);
* *bord.plaatsFiguur("vloer", verz, x*e, y*e);
* *spelbord[(y*dimX)+x] = 0;
* *y++;
* *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
* *spelbord[(y*dimX)+x] = 4;
* }
* 
*} * 

* *} 
* *
* *bord.plaatsFiguur("vloer", verz, oldx*e, oldy*e);
* *bord.plaatsFiguur("mannetje", verz, x*e, y*e);
* *bord.toonVeranderingen();

This one's for moving. I'll discuss one direction, as the rest's the same principle. Each direction exists out of two main parts: one for if the spot the player moves to is a floortile, one to see if it's either type of box. It stores that value in the variable object, which is then used to check for boxes of the same type. The loop loops through the direction the player moved to and either increases or decreases the d-variable, according to the direction it goes to, until the value of that array index is not that type of box anymore. Then it checks to see if, at the spot in front of all the boxes, is an empty floortile. If it is, it changes that spot's property to that box type, changes the property of the spot you moved from to floor and the property of the spot you moved into to player, then changes the graphics for it.

// *********************************************
// ** Checken voor dozen die mogen verdwijnen ** *-> Nog aan aan't werken
// *********************************************

int g;
int h;
int doos;
int teller = 0;
int[] groep;
groep = new int[dimX*dimY];
for (doos = 1; doos <=2; doos++) {
*for (g=0; g < dimX; g++) {
* for (h=0; h < dimY; h++) {
* *if (spelbord[(h*dimX)+g] == doos) {
* * teller ++;
* * groep[teller] = (h*dimX)+g;
* *}
* *else {
* * teller = 0;
* *}
* *if (teller == 4 && doos == 1) {
* * System.out.println("Voldoende dozen 1");
* *}
* *if (teller == 3 && doos == 2) {
* * System.out.println("Voldoende dozen 2");
* *}
* * 
* } * 
*}
}

This's the part where it should be checking to win, but it's not working yet. This was just an attempt to see how well it'd work. Works fine, but only for the exact amount of boxes, not that amount of boxes or more, and only if they're all hooked up vertically.

[Rogue]

The move part has to be done in different way.

You have to have a lot of if statements.


You start to move (no mather of direction)

1 - if is floor, move

2. if is not floor - check if is the wall

3. if is wall, don't move

4. if is box, check next space

now same procedure (same stuff) with next box

1. if is floor, move

2. if is not floor, check if is the wall

3. if is wall, don't move

4. if is box, check the color

5. if is same color go to next box

6 if is different color color, don't move

You can move only in 4 directions, this make it easy!

[Kon-Tiki]

Uhhhmmm... the moving works smoothly... everything's just fine, except for the winning condition.

[Rogue]

how big is the world?

[Kon-Tiki]

It's dimX, dimY big. It should be able to read any world-file. A world-file looks like this:

DIM 10 6 -> Defines the dimensions, in this case x = 10, y = 6
...######. -> . = floor
..#.....#. -> # = wall
.#@.B.R..# -> @ = player
#BB..R..R# -> B = Box 1 (or box 2, I don't remember off the top of my head)
#R.....B.# -> R = Other type of box
##########

Of course, the comments to the right aren't included. It should be able to read worlds of 2x3 dimensions as well as worlds of 1234567890x1234567890 dimensions (which it can... tested that If it's 12345678901, it gives an error)

Edit: just tested that world. It's impossible to win. That's what you get for throwing those characters around randomly