diff --git a/ArtLogJavaFormat.xml b/ArtLogJavaFormat.xml
new file mode 100644
index 0000000..08cecb0
--- /dev/null
+++ b/ArtLogJavaFormat.xml
@@ -0,0 +1,295 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build.xml b/build.xml
new file mode 100644
index 0000000..34d7b55
--- /dev/null
+++ b/build.xml
@@ -0,0 +1,42 @@
+
+
+ simple example build file
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/documentation/rawformat b/documentation/rawformat
new file mode 100644
index 0000000..736f349
--- /dev/null
+++ b/documentation/rawformat
@@ -0,0 +1,40 @@
+
+Maze/Labyrinth raw format extension .raw
+
+ Model of labyrinth storing only paths not walls. wall are regenerated later on based on adjacent paths.
+ each position (x,y) stores what move can be done from here to go do deeper path.
+ a node is tagged OPEN and contained in openList if all moves from its position have not been resolved
+ a node is tagged CLOSED when fully processed
+
+position is (x,y)
+
+See org.artisanlogiciel.games.WallsProvider
+
+file starts with
+'LAB0'
+32bits Width
+32bits Height
+
+Width * ( 16bits )
+*
+Height.
+
+
+ /** WARNING don't change those values, they are used as it is for optimisation */
+ private final static short FLAGLENGTH=7;
+ private final static short CLEAR=0; // mandatory 0 since array creation is initialized with 0.
+ private final static short HORIZONTAL=1;
+ private final static short VERTICAL=2;
+ private final static short DIRECTION=4; // could we get rid of that to free one bit for other purpose ?
+ private final static short POSITIVE=8;
+ private final static short NEGATIVE=16;
+ private final static short OPEN=32; // can be reused once generation is completed
+ private final static short CLOSED=64; // can be reused once generation is completed
+ private final static short LEFT=Brick.LEFT</dev/null && echo "cleaned classes in source"
@find $(OUT) -name "*.class" -type f -print0|xargs -0 rm 2>/dev/null || echo "nothing to clean"
test:
diff --git a/java/org/artisanlogiciel/games/Brick.java b/java/org/artisanlogiciel/games/Brick.java
index dc4988b..9b238a2 100644
--- a/java/org/artisanlogiciel/games/Brick.java
+++ b/java/org/artisanlogiciel/games/Brick.java
@@ -10,14 +10,15 @@ a is 'H' or '.' or ' '
bcd is 'H' or ' '
*/
-public class Brick {
+public class Brick
+{
- public final static short LEFT=1;
- public final static short DOWN=2;
- public final static short RIGHT=4;
- public final static short UP=8;
- public final static short ENTRY=16;
- public final static short GOAL=32;
+ public final static short LEFT = 1;
+ public final static short DOWN = 2;
+ public final static short RIGHT = 4;
+ public final static short UP = 8;
+ public final static short ENTRY = 16;
+ public final static short GOAL = 32;
char a;
char b;
@@ -25,98 +26,88 @@ public class Brick {
char d;
short walls; // according to LabyModel.getWalls();
- public Brick(char center, char right, char down, char downright,short walls)
+ public Brick(char center, char right, char down, char downright, short walls)
{
- a=center;
- b=right;
- c=down;
- d=downright;
- this.walls=walls;
+ a = center;
+ b = right;
+ c = down;
+ d = downright;
+ this.walls = walls;
}
public Brick(String up, String low, short walls)
{
- a = up.charAt(0);
- b = up.charAt(1);
- c = low.charAt(0);
- d = low.charAt(1);
- this.walls=walls;
+ a = up.charAt(0);
+ b = up.charAt(1);
+ c = low.charAt(0);
+ d = low.charAt(1);
+ this.walls = walls;
}
private boolean check()
{
- // Not Yet Implemented
- return false;
+ // Not Yet Implemented
+ return false;
}
public String getUpString()
{
- return "" + a + b;
+ return "" + a + b;
}
public String getLowString()
{
- return "" + c + d;
+ return "" + c + d;
}
public static String getDirLine()
{
- char dir[] = new char[16];
- String s="";
-
- /*
- dir[LEFT | DOWN | RIGHT | UP]='O';
- dir[LEFT | DOWN | RIGHT]='U';
- dir[LEFT | UP | RIGHT]='M';
- dir[LEFT | UP | DOWN]='[';
- dir[RIGHT | UP | DOWN]=']';
- dir[UP | DOWN]='=';
- dir[LEFT | RIGHT]='|';
- dir[RIGHT | DOWN]='J';
- dir[LEFT | DOWN]='L';
- dir [LEFT | UP]='T';
- dir[UP | RIGHT]='7';
- dir[LEFT] = '!';
- dir[RIGHT] ='|';
- dir[DOWN]= '_';
- dir[UP]= '¨';
- dir[0]=' ';
- */
+ char dir[] = new char[16];
+ String s = "";
- dir[LEFT | DOWN | RIGHT | UP]='O';
- dir[LEFT | DOWN | RIGHT]='U';
- dir[LEFT | UP | RIGHT]='M';
- dir[LEFT | UP | DOWN]='[';
- dir[RIGHT | UP | DOWN]=']';
- dir[UP | DOWN]='=';
- dir[LEFT | RIGHT]=226;
- dir[RIGHT | DOWN]='J';
- dir[LEFT | DOWN]='L';
- dir [LEFT | UP]=169;
- dir[UP | RIGHT]=170;
- dir[LEFT] = 173;
- dir[RIGHT] ='|';
- dir[DOWN]= '_';
- dir[UP]= '¨';
- dir[0]=' ';
-
- for (int i=0;i< 16; i++)
- {
- s=s+dir[i];
- }
+ /*
+ * dir[LEFT | DOWN | RIGHT | UP]='O'; dir[LEFT | DOWN | RIGHT]='U';
+ * dir[LEFT | UP | RIGHT]='M'; dir[LEFT | UP | DOWN]='['; dir[RIGHT | UP
+ * | DOWN]=']'; dir[UP | DOWN]='='; dir[LEFT | RIGHT]='|'; dir[RIGHT |
+ * DOWN]='J'; dir[LEFT | DOWN]='L'; dir [LEFT | UP]='T'; dir[UP |
+ * RIGHT]='7'; dir[LEFT] = '!'; dir[RIGHT] ='|'; dir[DOWN]= '_';
+ * dir[UP]= '¨'; dir[0]=' ';
+ */
- return s;
+ dir[LEFT | DOWN | RIGHT | UP] = 'O';
+ dir[LEFT | DOWN | RIGHT] = 'U';
+ dir[LEFT | UP | RIGHT] = 'M';
+ dir[LEFT | UP | DOWN] = '[';
+ dir[RIGHT | UP | DOWN] = ']';
+ dir[UP | DOWN] = '=';
+ dir[LEFT | RIGHT] = 226;
+ dir[RIGHT | DOWN] = 'J';
+ dir[LEFT | DOWN] = 'L';
+ dir[LEFT | UP] = 169;
+ dir[UP | RIGHT] = 170;
+ dir[LEFT] = 173;
+ dir[RIGHT] = '|';
+ dir[DOWN] = '_';
+ dir[UP] = '¨';
+ dir[0] = ' ';
+
+ for (int i = 0; i < 16; i++)
+ {
+ s = s + dir[i];
+ }
+
+ return s;
}
public char getChar()
{
- // return getDirLine().charAt(walls & 0xFFF0);
- return getDirLine().charAt(walls);
+ // return getDirLine().charAt(walls & 0xFFF0);
+ return getDirLine().charAt(walls);
}
public short getWalls()
{
- return walls;
+ return walls;
}
}
diff --git a/java/org/artisanlogiciel/games/Display.java b/java/org/artisanlogiciel/games/Display.java
index cdecfd9..b910726 100644
--- a/java/org/artisanlogiciel/games/Display.java
+++ b/java/org/artisanlogiciel/games/Display.java
@@ -27,6 +27,8 @@ import javax.swing.KeyStroke;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
+import org.artisanlogiciel.games.stl.Wall3d;
+
/**
* Display
**/
diff --git a/java/org/artisanlogiciel/games/LabyMap.java b/java/org/artisanlogiciel/games/LabyMap.java
index 8cea2a3..324b779 100644
--- a/java/org/artisanlogiciel/games/LabyMap.java
+++ b/java/org/artisanlogiciel/games/LabyMap.java
@@ -2,105 +2,116 @@ package org.artisanlogiciel.games;
import java.util.LinkedList;
-class LabyMap
-implements WallsProvider
+class LabyMap implements WallsProvider
{
Brick[][] tileMap;
- LinkedList exits = new LinkedList();
+ LinkedList exits = new LinkedList();
public LabyMap(Brick[][] tileMap, LinkedList exits)
{
- this.tileMap = tileMap;
- this.exits = exits;
+ this.tileMap = tileMap;
+ this.exits = exits;
}
Brick getAt(int x, int y)
{
- return tileMap[x][y];
+ return tileMap[x][y];
}
public short getWalls(int x, int y)
{
- return getAt(x,y).getWalls();
+ return getAt(x, y).getWalls();
}
-
+
public int getWidth()
{
- return tileMap[0].length;
+ return tileMap[0].length;
}
public int getHeight()
{
- return tileMap.length;
+ return tileMap.length;
}
public String toString()
{
- int entryX = -1;
- int entryY = -1;
- for ( Position exit: exits )
- {
- if ( exit.getX() == -1 )
- {
- entryY = exit.getY();
- }
- if ( exit.getY() == -1 )
- {
- entryX= exit.getX();
- }
- }
- String laby="H";
- for ( int x=0; x < tileMap.length; x ++) {
- if ( entryX == x ) { laby += " H" ; }
- else { laby+="HH";}
- }
- laby+="\n";
- for ( int y=0; y < tileMap[0].length; y++)
- {
- if ( entryY == y ) { laby += ">";}
- else { laby += "H"; }
- for ( int x=0; x < tileMap.length; x ++)
- {
- laby+= tileMap[x][y].getUpString();
- }
- laby+="\n";
- laby += "H";
- for ( int x=0; x < tileMap.length; x ++)
- {
- laby+= tileMap[x][y].getLowString();
- }
- laby+="\n";
- }
- return laby;
+ int entryX = -1;
+ int entryY = -1;
+ for (Position exit : exits)
+ {
+ if (exit.getX() == -1)
+ {
+ entryY = exit.getY();
+ }
+ if (exit.getY() == -1)
+ {
+ entryX = exit.getX();
+ }
+ }
+ String laby = "H";
+ for (int x = 0; x < tileMap.length; x++)
+ {
+ if (entryX == x)
+ {
+ laby += " H";
+ }
+ else
+ {
+ laby += "HH";
+ }
+ }
+ laby += "\n";
+ for (int y = 0; y < tileMap[0].length; y++)
+ {
+ if (entryY == y)
+ {
+ laby += ">";
+ }
+ else
+ {
+ laby += "H";
+ }
+ for (int x = 0; x < tileMap.length; x++)
+ {
+ laby += tileMap[x][y].getUpString();
+ }
+ laby += "\n";
+ laby += "H";
+ for (int x = 0; x < tileMap.length; x++)
+ {
+ laby += tileMap[x][y].getLowString();
+ }
+ laby += "\n";
+ }
+ return laby;
}
-
public String toShortString()
{
- int entryX = -1;
- int entryY = -1;
- for ( Position exit: exits )
- {
- if ( exit.getX() == -1 )
- {
- entryY = exit.getY();
- }
- if ( exit.getY() == -1 )
- {
- entryX= exit.getX();
- }
- }
- String laby="";
- for ( int y=0; y < tileMap[0].length; y++)
- {
- for ( int x=0; x < tileMap.length; x ++)
- {
- laby+= "" + tileMap[x][y].getChar();
- }
- laby+="\n";
- }
- return laby;
+ int entryX = -1;
+ int entryY = -1;
+ for (Position exit : exits)
+ {
+ if (exit.getX() == -1)
+ {
+ entryY = exit.getY();
+ }
+ if (exit.getY() == -1)
+ {
+ entryX = exit.getX();
+ }
+ }
+ String laby = "";
+ for (int y = 0; y < tileMap[0].length; y++)
+ {
+ for (int x = 0; x < tileMap.length; x++)
+ {
+ laby += "" + tileMap[x][y].getChar();
+ }
+ laby += "\n";
+ }
+ return laby;
}
}
diff --git a/java/org/artisanlogiciel/games/LabyModel.java b/java/org/artisanlogiciel/games/LabyModel.java
index 9f5e650..6805472 100644
--- a/java/org/artisanlogiciel/games/LabyModel.java
+++ b/java/org/artisanlogiciel/games/LabyModel.java
@@ -12,805 +12,908 @@ import java.io.DataOutputStream;
import java.io.DataInputStream;
/**
- Model of labyrinth storing only paths not walls. wall are regenerated later on based on adjacent paths.
- each position (x,y) stores what move can be done from here to go do deeper path.
- a node is tagged OPEN and contained in openList if all moves from its position have not been resolved
- a node is tagged CLOSED when fully processed
+ * Model of labyrinth storing only paths not walls. wall are regenerated later
+ * on based on adjacent paths. each position (x,y) stores what move can be done
+ * from here to go do deeper path. a node is tagged OPEN and contained in
+ * openList if all moves from its position have not been resolved a node is
+ * tagged CLOSED when fully processed
**/
-public class LabyModel
-implements WallsProvider
+public class LabyModel implements WallsProvider
{
- /** WARNING don't change those values, they are used as it is for optimisation */
- private final static short FLAGLENGTH=7;
- private final static short CLEAR=0; // mandatory 0 since array creation is initialized with 0.
- private final static short HORIZONTAL=1;
- private final static short VERTICAL=2;
- private final static short DIRECTION=4; // could we get rid of that to free one bit for other purpose ?
- private final static short POSITIVE=8;
- private final static short NEGATIVE=16;
- private final static short OPEN=32; // can be reused once generation is completed
- private final static short CLOSED=64; // can be reused once generation is completed
- private final static short LEFT=Brick.LEFT< openList = new LinkedList();
- //list of entries and exits.
+ // list of entries and exits.
private final LinkedList entryExits = new LinkedList();
- private final Object coherentLock = new Object(); // before getting the lock and after lock release all is coherent ( ie check() is ok ),
+ private final Object coherentLock = new Object(); // before getting the lock
+ // and after lock release
+ // all is coherent ( ie
+ // check() is ok ),
MazeCreationListener listener = null;
-
- public LabyModel(int width, int height,int maxdepth, Random random){
- this.width=width;
- this.height=height;
- this.maxdepth=maxdepth;
- this.random = random;
- // CLEAR == 0 and array is initialized with 0s
- t= new short[width][height];
- }
-
- public LabyModel(MazeParams params, Random random){
- this.width=params.getWidth();
- this.height=params.getHeight();
- this.maxdepth=params.getMaxDepth();
- this.random = random;
- // CLEAR == 0 and array is initialized with 0s
- t= new short[width][height];
- }
-
- public LabyModel(String pFormat, InputStream pIn)
- throws IOException
+ public LabyModel(int width, int height, int maxdepth, Random random)
{
- parseInputStream(pFormat, pIn);
+ this.width = width;
+ this.height = height;
+ this.maxdepth = maxdepth;
+ this.random = random;
+ // CLEAR == 0 and array is initialized with 0s
+ t = new short[width][height];
+ }
+
+ public LabyModel(MazeParams params, Random random)
+ {
+ this.width = params.getWidth();
+ this.height = params.getHeight();
+ this.maxdepth = params.getMaxDepth();
+ this.random = random;
+ // CLEAR == 0 and array is initialized with 0s
+ t = new short[width][height];
+ }
+
+ public LabyModel(String pFormat, InputStream pIn) throws IOException
+ {
+ parseInputStream(pFormat, pIn);
}
public void setMazeListener(MazeCreationListener listener)
{
- this.listener=listener;
+ this.listener = listener;
}
// entry and exit can be outside the model boundaries a one x or one y out.
public boolean addEntryOrExit(int x, int y)
{
- entryExits.add(new Position(x,y));
- if (( x > 0 ) && ( x < width ) && ( y > 0 ) && ( y < height ))
- {
- t[x][y] |= ENTRY;
- }
- return true;
+ entryExits.add(new Position(x, y));
+ if ((x > 0) && (x < width) && (y > 0) && (y < height))
+ {
+ t[x][y] |= ENTRY;
+ }
+ return true;
}
public void debugOut()
{
- for (int y=0; y < height; y++)
- {
- for (int x=0; x < width; x++)
- {
- out4XY(x,y);
- }
- System.out.print('\n');
- }
- }
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ out4XY(x, y);
+ }
+ System.out.print('\n');
+ }
+ }
- public void out4XY(int x,int y)
+ public void out4XY(int x, int y)
{
- int direction=t[x][y];
- if ( ( direction & OPEN ) == OPEN )
- {
- System.out.print("?");
- }
- else if ( ( direction & CLOSED ) == CLOSED )
- {
- System.out.print(".");
- }
- else {
- System.out.print(" ");
- }
- // don't display information about short.
- direction &= ~OPEN;
- direction &= ~GOAL;
- direction &= ~CLOSED;
- switch(direction){
- case LEFT: // left
- System.out.print("<-");
- break;
- case DOWN: // down
- System.out.print("vv");
- break;
- case RIGHT: // right
- System.out.print("->");
- break;
- case UP: // up
- System.out.print("^^");
- break;
- case HORIZONTAL: // -
- System.out.print("--");
- break;
- case VERTICAL: // |
- System.out.print("||");
- break;
- case CLEAR:
- System.out.print(" ");
- break;
- case CLOSED:
- System.out.print("00");
- break;
- case RIGHT|LEFT:
- System.out.print("--");
- break;
- case UP|DOWN:
- System.out.print("||");
- break;
- case RIGHT|UP:
- System.out.print("^>");
- break;
- case RIGHT|DOWN:
- System.out.print("v>");
- break;
- case LEFT|DOWN:
- System.out.print("");
- break;
- case LEFT|RIGHT|UP|DOWN:
- System.out.print("++");
- break;
- case OPEN:
- System.out.print("??");
- break;
- case GOAL:
- System.out.print("**");
- break;
- default:
- System.out.print("..");
- }
+ int direction = t[x][y];
+ if ((direction & OPEN) == OPEN)
+ {
+ System.out.print("?");
+ }
+ else if ((direction & CLOSED) == CLOSED)
+ {
+ System.out.print(".");
+ }
+ else
+ {
+ System.out.print(" ");
+ }
+ // don't display information about short.
+ direction &= ~OPEN;
+ direction &= ~GOAL;
+ direction &= ~CLOSED;
+ switch (direction)
+ {
+ case LEFT: // left
+ System.out.print("<-");
+ break;
+ case DOWN: // down
+ System.out.print("vv");
+ break;
+ case RIGHT: // right
+ System.out.print("->");
+ break;
+ case UP: // up
+ System.out.print("^^");
+ break;
+ case HORIZONTAL: // -
+ System.out.print("--");
+ break;
+ case VERTICAL: // |
+ System.out.print("||");
+ break;
+ case CLEAR:
+ System.out.print(" ");
+ break;
+ case CLOSED:
+ System.out.print("00");
+ break;
+ case RIGHT | LEFT:
+ System.out.print("--");
+ break;
+ case UP | DOWN:
+ System.out.print("||");
+ break;
+ case RIGHT | UP:
+ System.out.print("^>");
+ break;
+ case RIGHT | DOWN:
+ System.out.print("v>");
+ break;
+ case LEFT | DOWN:
+ System.out.print("");
+ break;
+ case LEFT | RIGHT | UP | DOWN:
+ System.out.print("++");
+ break;
+ case OPEN:
+ System.out.print("??");
+ break;
+ case GOAL:
+ System.out.print("**");
+ break;
+ default:
+ System.out.print("..");
+ }
- if ( ( (t[x][y] & RIGHT) == RIGHT ) ||
- ( ( x+ 1 < width) && ( ( t[x+1][y] & LEFT ) == LEFT ) ))
- {
- System.out.print("-");
- }
- else
- {
- System.out.print("H");
- }
+ if (((t[x][y] & RIGHT) == RIGHT) || ((x + 1 < width) && ((t[x + 1][y] & LEFT) == LEFT)))
+ {
+ System.out.print("-");
+ }
+ else
+ {
+ System.out.print("H");
+ }
}
public String outHorizWall2XY(int x, int y)
{
- String freeway= " ";
- if ( (t[x][y] & SOLVED) == SOLVED)
- {
- freeway="*";
- }
- if ( ( x < 0 ) || ( x >width ) )
- {
- return " H";
- }
- if ( ( y < 0 ) || ( y >= height ) )
- {
- return "HH";
- }
+ String freeway = " ";
+ if ((t[x][y] & SOLVED) == SOLVED)
+ {
+ freeway = "*";
+ }
+ if ((x < 0) || (x > width))
+ {
+ return " H";
+ }
+ if ((y < 0) || (y >= height))
+ {
+ return "HH";
+ }
- if ( ( (t[x][y] & DOWN) == DOWN ) || (( y+ 1 < height) && ( ( t[x][y+1] & UP ) == UP )))
- {
- return freeway + "H";
- }
- else
- {
- return "HH";
- }
+ if (((t[x][y] & DOWN) == DOWN) || ((y + 1 < height) && ((t[x][y + 1] & UP) == UP)))
+ {
+ return freeway + "H";
+ }
+ else
+ {
+ return "HH";
+ }
}
- public String out2XY(int x,int y)
+ public String out2XY(int x, int y)
{
- // can check for entry exits.
-
- if ( ( y < 0 ) || ( y >= height ) || ( x < 0 ) || ( x >width ) )
- {
- return " H";
- }
- String low="";
- int direction=t[x][y];
- String freeway= " ";
- if ( (t[x][y] & SOLVED) == SOLVED)
- {
- freeway="*";
- }
- // don't display information about short.
- direction &= ~OPEN;
- direction &= ~GOAL;
- direction &= ~CLOSED;
- direction &= ~SOLVED;
- switch(direction){
- case LEFT:
- case DOWN:
- case RIGHT:
- case UP:
- low=freeway;
- break;
- case HORIZONTAL: // -
- low=" ";
- break;
- case VERTICAL: // |
- low=" ";
- break;
- case CLEAR:
- low=" ";
- break;
- case CLOSED:
- low="0";
- break;
- case RIGHT|LEFT:
- case UP|DOWN:
- case RIGHT|UP:
- case RIGHT|DOWN:
- case LEFT|DOWN:
- case LEFT|UP:
- case LEFT|RIGHT|UP:
- case LEFT|RIGHT|DOWN:
- case LEFT|DOWN|UP:
- case RIGHT|DOWN|UP:
- case LEFT|RIGHT|UP|DOWN:
- low=".";
- break;
- case OPEN:
- low="?";
- break;
- case GOAL:
- low="*";
- break;
- default:
- low=".";
- }
+ // can check for entry exits.
+ if ((y < 0) || (y >= height) || (x < 0) || (x > width))
+ {
+ return " H";
+ }
+ String low = "";
+ int direction = t[x][y];
+ String freeway = " ";
+ if ((t[x][y] & SOLVED) == SOLVED)
+ {
+ freeway = "*";
+ }
+ // don't display information about short.
+ direction &= ~OPEN;
+ direction &= ~GOAL;
+ direction &= ~CLOSED;
+ direction &= ~SOLVED;
+ switch (direction)
+ {
+ case LEFT:
+ case DOWN:
+ case RIGHT:
+ case UP:
+ low = freeway;
+ break;
+ case HORIZONTAL: // -
+ low = " ";
+ break;
+ case VERTICAL: // |
+ low = " ";
+ break;
+ case CLEAR:
+ low = " ";
+ break;
+ case CLOSED:
+ low = "0";
+ break;
+ case RIGHT | LEFT:
+ case UP | DOWN:
+ case RIGHT | UP:
+ case RIGHT | DOWN:
+ case LEFT | DOWN:
+ case LEFT | UP:
+ case LEFT | RIGHT | UP:
+ case LEFT | RIGHT | DOWN:
+ case LEFT | DOWN | UP:
+ case RIGHT | DOWN | UP:
+ case LEFT | RIGHT | UP | DOWN:
+ low = ".";
+ break;
+ case OPEN:
+ low = "?";
+ break;
+ case GOAL:
+ low = "*";
+ break;
+ default:
+ low = ".";
+ }
- for ( Position exit: entryExits )
- {
- if ( ( exit.getX() == x + 1 ) && ( exit.getY() == y ))
- {
- low=low+">";
- return low;
- }
- }
-
- if ( ( (t[x][y] & RIGHT) == RIGHT ) ||
- ( ( x+ 1 < width) && ( ( t[x+1][y] & LEFT ) == LEFT ) ))
- {
- low=low+freeway;
- }
- else
- {
- low=low+"H";
- }
+ for (Position exit : entryExits)
+ {
+ if ((exit.getX() == x + 1) && (exit.getY() == y))
+ {
+ low = low + ">";
+ return low;
+ }
+ }
- return low;
+ if (((t[x][y] & RIGHT) == RIGHT) || ((x + 1 < width) && ((t[x + 1][y] & LEFT) == LEFT)))
+ {
+ low = low + freeway;
+ }
+ else
+ {
+ low = low + "H";
+ }
+
+ return low;
}
public LabyMap toLabyMap()
{
- synchronized (coherentLock)
- {
- Brick[][] brickMap = new Brick[width][height];
- for (int y=0; y< height; y++)
- {
- for ( int x=0; x < width; x++)
- {
- brickMap[x][y]=new Brick(out2XY(x,y), outHorizWall2XY(x, y),getWalls(x,y));
- }
- }
- return new LabyMap(brickMap, (LinkedList) entryExits.clone());
- }
+ synchronized (coherentLock)
+ {
+ Brick[][] brickMap = new Brick[width][height];
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ brickMap[x][y] = new Brick(out2XY(x, y), outHorizWall2XY(x, y), getWalls(x, y));
+ }
+ }
+ return new LabyMap(brickMap, (LinkedList) entryExits.clone());
+ }
}
- public int getWidth(){
- return this.width;
+ public int getWidth()
+ {
+ return this.width;
}
- public int getHeight(){
- return this.height;
+ public int getHeight()
+ {
+ return this.height;
}
public LinkedList getOpenList()
{
- return openList;
+ return openList;
}
public void reset()
{
- depth = 0;
- computeOpenList();
+ depth = 0;
+ computeOpenList();
}
public void fullReset()
{
- depth = 0;
- openList.clear();
- maxreached = false;
- deepest=0;
- deepestEnd=null;
- // clear open
- for (int y=0; y < height; y++)
- {
- for (int x=0; x < width; x++)
- {
- t[x][y] &= ~OPEN;
- }
+ depth = 0;
+ openList.clear();
+ maxreached = false;
+ deepest = 0;
+ deepestEnd = null;
+ // clear open
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ t[x][y] &= ~OPEN;
+ }
- }
+ }
}
/**
- check model coherency and fix
- if model needed a fix it means that algorithm has a problem
-
- @return true if model is ok and no fix was applied.
- **/
+ * check model coherency and fix if model needed a fix it means that
+ * algorithm has a problem
+ *
+ * @return true if model is ok and no fix was applied.
+ **/
public boolean check()
{
- boolean check = true;
- synchronized(coherentLock)
- {
- // node in OPEN should be tagged OPEN and not CLOSED.
- for ( Position p : openList)
- {
- int x = p.getX();
- int y = p.getY();
- if ( (t[x][y] & OPEN ) != OPEN )
- {
- check = false;
- t[x][y] |= OPEN;
- }
- if ( (t[x][y] & CLOSED ) == CLOSED )
- {
- check = false;
- t[x][y] &= ~CLOSED;
- }
- }
- // should do reverse : every node tagged OPEN should be in open list.
- // a little more cpu consuming...
- }
- return check;
+ boolean check = true;
+ synchronized (coherentLock)
+ {
+ // node in OPEN should be tagged OPEN and not CLOSED.
+ for (Position p : openList)
+ {
+ int x = p.getX();
+ int y = p.getY();
+ if ((t[x][y] & OPEN) != OPEN)
+ {
+ check = false;
+ t[x][y] |= OPEN;
+ }
+ if ((t[x][y] & CLOSED) == CLOSED)
+ {
+ check = false;
+ t[x][y] &= ~CLOSED;
+ }
+ }
+ // should do reverse : every node tagged OPEN should be in open
+ // list.
+ // a little more cpu consuming...
+ }
+ return check;
}
public void computeOpenList()
{
- openList.clear();
- for (int y=0; y < height; y++)
- {
- for (int x=0; x < width; x++)
- {
- if ( (t[x][y] & CLOSED ) == CLOSED )
- {
- t[x][y] &= ~OPEN;
- }
- if ( ( (t[x][y] & OPEN) == OPEN ) || ( t[x][y] == CLEAR ))
- {
- openList.add(new Position(x,y));
- }
- }
+ openList.clear();
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ if ((t[x][y] & CLOSED) == CLOSED)
+ {
+ t[x][y] &= ~OPEN;
+ }
+ if (((t[x][y] & OPEN) == OPEN) || (t[x][y] == CLEAR))
+ {
+ openList.add(new Position(x, y));
+ }
+ }
- }
+ }
}
-
- public void generateWithEntry(int x, int y){
- openList.add(new Position(x,y));
- while ( ! openList.isEmpty() )
- {
- step(0); // fixme depth not set
+ public void generateWithEntry(int x, int y)
+ {
- synchronized(coherentLock)
- {
- linearwork ++;
-
- if ( linearwork % maxdepth == 0 )
- {
- coherentLock.notifyAll();
- if (listener != null)
- {
- listener.changed(null,null,this);
- }
- // should not continue in depth first...
- if ( ! openList.isEmpty() )
- {
- // insert head as next position to pick up.
- Position current = openList.removeFirst();
- openList.add(current);
- }
- }
- }
+ openList.add(new Position(x, y));
+ while (!openList.isEmpty())
+ {
+ step(0); // fixme depth not set
- }
-
- if ( deepestEnd != null )
- {
- t[deepestEnd.getX()][deepestEnd.getY()]|=GOAL;
- }
+ synchronized (coherentLock)
+ {
+ linearwork++;
+
+ if (linearwork % maxdepth == 0)
+ {
+ coherentLock.notifyAll();
+ if (listener != null)
+ {
+ listener.changed(null, null, this);
+ }
+ // should not continue in depth first...
+ if (!openList.isEmpty())
+ {
+ // insert head as next position to pick up.
+ Position current = openList.removeFirst();
+ openList.add(current);
+ }
+ }
+ }
+
+ }
+
+ if (deepestEnd != null)
+ {
+ t[deepestEnd.getX()][deepestEnd.getY()] |= GOAL;
+ }
}
public int getDepth()
{
- return depth;
+ return depth;
}
public Position getDeepestEnd()
{
- return deepestEnd;
+ return deepestEnd;
}
public int getDeepestPath()
{
- return deepest;
+ return deepest;
}
public boolean maxReached()
{
- return maxreached;
+ return maxreached;
}
/**
- @param p Position
- @return true if newly added , false if already open.
+ * @param p
+ * Position
+ * @return true if newly added , false if already open.
**/
private boolean open(boolean first, Position p)
{
- int x = p.getX();
- int y = p.getY();
- if ( ( t[x][y] & OPEN ) != OPEN )
- {
- t[x][y]|=OPEN;
- openList.addLast(p);
- return true;
- }
- return false;
+ int x = p.getX();
+ int y = p.getY();
+ if ((t[x][y] & OPEN) != OPEN)
+ {
+ t[x][y] |= OPEN;
+ openList.addLast(p);
+ return true;
+ }
+ return false;
}
/**
- resolve this labrynth using internal representation
- **/
+ * resolve this labrynth using internal representation
+ **/
public LinkedList resolve(int x, int y, MazeResolutionListener rlistener)
{
- int newx=x;
- int newy=y;
- LinkedList backpath = new LinkedList();
+ int newx = x;
+ int newy = y;
+ LinkedList backpath = new LinkedList();
- while ( ! (( newx == 0 ) && ( newy == 0 )))
- {
- Position found=null;
- x = newx;
- y = newy;
- backpath.addFirst( new Position(x,y));
+ while (!((newx == 0) && (newy == 0)))
+ {
+ Position found = null;
+ x = newx;
+ y = newy;
+ backpath.addFirst(new Position(x, y));
- // should find from all direction one that point to this.
- ArrayList freeDirection = new ArrayList();
-
- for (int didx=0; didx < 4; didx ++ ) {
- int delta=0;
- short direction=AllDirections[didx];
- short reversedirection=AllDirections[(didx+2)%4];
- short pointingdirection=DIRECTION;
+ // should find from all direction one that point to this.
+ ArrayList freeDirection = new ArrayList();
- if ( ( direction & POSITIVE ) == POSITIVE ) { delta = 1; pointingdirection |= NEGATIVE ; }
- else { delta = -1; pointingdirection |= POSITIVE ;}
+ for (int didx = 0; didx < 4; didx++)
+ {
+ int delta = 0;
+ short direction = AllDirections[didx];
+ short reversedirection = AllDirections[(didx + 2) % 4];
+ short pointingdirection = DIRECTION;
- if ( ( direction & HORIZONTAL ) == HORIZONTAL ) { newx = x + delta; newy = y; pointingdirection |= HORIZONTAL; }
- else { newy = y + delta; newx = x; pointingdirection |= VERTICAL ;}
+ if ((direction & POSITIVE) == POSITIVE)
+ {
+ delta = 1;
+ pointingdirection |= NEGATIVE;
+ }
+ else
+ {
+ delta = -1;
+ pointingdirection |= POSITIVE;
+ }
- // internal GUARD.
- if ( (reversedirection & pointingdirection) != pointingdirection )
- {
- System.out.println("Internal ERROR. Please check AllDirections order " + ( reversedirection & pointingdirection ) + " " + pointingdirection );
- return backpath;
- }
+ if ((direction & HORIZONTAL) == HORIZONTAL)
+ {
+ newx = x + delta;
+ newy = y;
+ pointingdirection |= HORIZONTAL;
+ }
+ else
+ {
+ newy = y + delta;
+ newx = x;
+ pointingdirection |= VERTICAL;
+ }
- if ( (newx >= 0) && ( newy >= 0 ) && (newx < width) && (newy < height) ) {
- if ( ( t[newx][newy] & reversedirection ) == reversedirection){
- if ( found != null ) {
- // could be a unique parent of two paths...
- // but search from other entry/exits than generated from
- // ie entry(0,0) exit(width-1,height-1) not yet implemented.
- if (rlistener != null)
- {
- rlistener.notifySearchError("Model Error : two parents " + found.toString() + " " + new Position(newx,newy).toString());
- }
- return backpath;
- }
- found = new Position(newx,newy);
- if (rlistener != null)
- {
- rlistener.notifySearch(found);
- }
- break;
- }
- }
- }
- if ( found == null )
- {
- rlistener.notifySearchError("No path found !");
- break;
- }
- // System.out.println(found);
- newx=found.getX();
- newy=found.getY();
- t[newx][newy] |= SOLVED;
- }
- if (rlistener != null)
- {
- rlistener.notifyCompletion(backpath);
- }
- return backpath;
+ // internal GUARD.
+ if ((reversedirection & pointingdirection) != pointingdirection)
+ {
+ System.out.println("Internal ERROR. Please check AllDirections order "
+ + (reversedirection & pointingdirection) + " " + pointingdirection);
+ return backpath;
+ }
+
+ if ((newx >= 0) && (newy >= 0) && (newx < width) && (newy < height))
+ {
+ if ((t[newx][newy] & reversedirection) == reversedirection)
+ {
+ if (found != null)
+ {
+ // could be a unique parent of two paths...
+ // but search from other entry/exits than generated
+ // from
+ // ie entry(0,0) exit(width-1,height-1) not yet
+ // implemented.
+ if (rlistener != null)
+ {
+ rlistener.notifySearchError("Model Error : two parents " + found.toString() + " "
+ + new Position(newx, newy).toString());
+ }
+ return backpath;
+ }
+ found = new Position(newx, newy);
+ if (rlistener != null)
+ {
+ rlistener.notifySearch(found);
+ }
+ break;
+ }
+ }
+ }
+ if (found == null)
+ {
+ rlistener.notifySearchError("No path found !");
+ break;
+ }
+ // System.out.println(found);
+ newx = found.getX();
+ newy = found.getY();
+ t[newx][newy] |= SOLVED;
+ }
+ if (rlistener != null)
+ {
+ rlistener.notifyCompletion(backpath);
+ }
+ return backpath;
}
/**
- @returns wheter process closed current node.
- **/
+ * @returns wheter process closed current node.
+ **/
public boolean step(int depth)
{
- boolean complete = false;
- Position current = null;
+ boolean complete = false;
+ Position current = null;
- synchronized(coherentLock)
- {
+ synchronized (coherentLock)
+ {
- if ( ! openList.isEmpty() )
- {
- // last : in depth before.
- current = openList.getLast();
- }
- else
- {
- return true;
- }
+ if (!openList.isEmpty())
+ {
+ // last : in depth before.
+ current = openList.getLast();
+ }
+ else
+ {
+ return true;
+ }
- if ( current != null )
- {
- int x = current.getX();
- int y = current.getY();
+ if (current != null)
+ {
+ int x = current.getX();
+ int y = current.getY();
- // should find all free positions...
- ArrayList freeDirection = new ArrayList();
-
- for (short direction : AllDirections ) {
- int delta=0;
- int newx = -1;
- int newy = -1;
+ // should find all free positions...
+ ArrayList freeDirection = new ArrayList();
- if ( ( direction & POSITIVE ) == POSITIVE ) { delta = 1; }
- else { delta = -1; }
+ for (short direction : AllDirections)
+ {
+ int delta = 0;
+ int newx = -1;
+ int newy = -1;
- if ( ( direction & HORIZONTAL ) == HORIZONTAL ) { newx = x + delta; newy = y; }
- else { newy = y + delta; newx = x; }
+ if ((direction & POSITIVE) == POSITIVE)
+ {
+ delta = 1;
+ }
+ else
+ {
+ delta = -1;
+ }
- if ( (newx >= 0) && ( newy >= 0 ) && (newx < width) && (newy < height) ) {
- if( (t[newx][newy] ) == CLEAR){
- freeDirection.add(new Short(direction));
- }
- }
- }
+ if ((direction & HORIZONTAL) == HORIZONTAL)
+ {
+ newx = x + delta;
+ newy = y;
+ }
+ else
+ {
+ newy = y + delta;
+ newx = x;
+ }
- if ( ! freeDirection.isEmpty())
- {
- // control random using our own pseudorandom
- short direction = 0;
- if ( freeDirection.size() > 1 )
- {
- direction=freeDirection.get(random.nextInt(freeDirection.size()));
- }
- else
- {
- direction=freeDirection.get(0);
- Position last=openList.removeLast();
- if ( last != current )
- {
- // GUARD, should not happen ( or multi-thread access to model error )
- System.err.println("INTERNAL ERROR 3");
- return false;
- }
- }
+ if ((newx >= 0) && (newy >= 0) && (newx < width) && (newy < height))
+ {
+ if ((t[newx][newy]) == CLEAR)
+ {
+ freeDirection.add(new Short(direction));
+ }
+ }
+ }
- int delta=0;
- int newx = -1;
- int newy = -1;
+ if (!freeDirection.isEmpty())
+ {
+ // control random using our own pseudorandom
+ short direction = 0;
+ if (freeDirection.size() > 1)
+ {
+ direction = freeDirection.get(random.nextInt(freeDirection.size()));
+ }
+ else
+ {
+ direction = freeDirection.get(0);
+ Position last = openList.removeLast();
+ if (last != current)
+ {
+ // GUARD, should not happen ( or multi-thread access
+ // to model error )
+ System.err.println("INTERNAL ERROR 3");
+ return false;
+ }
+ }
- if ( ( direction & POSITIVE ) == POSITIVE ) { delta = 1; }
- else { delta = -1; }
+ int delta = 0;
+ int newx = -1;
+ int newy = -1;
- if ( ( direction & HORIZONTAL ) == HORIZONTAL ) { newx = x + delta; newy = y; }
- else { newy = y + delta; newx = x; }
+ if ((direction & POSITIVE) == POSITIVE)
+ {
+ delta = 1;
+ }
+ else
+ {
+ delta = -1;
+ }
- Position target = new Position(newx,newy,current.getDepth()+1);
- open(false,target);
- if (( t[x][y] & DIRECTION ) == DIRECTION ) { t[x][y] |= direction; }
- else { t[x][y] = direction; } // not a 'direction' ... is it necessary to check ?
- if ( freeDirection.size() > 1 )
- {
- // keep it open at the very same place, previous open did add another node to inspect.
- return false;
- }
- // else this was the unique direction , object already removed ( since if we try to remove it now it is not the last )
+ if ((direction & HORIZONTAL) == HORIZONTAL)
+ {
+ newx = x + delta;
+ newy = y;
+ }
+ else
+ {
+ newy = y + delta;
+ newx = x;
+ }
- // can proceed to close
- }
- else {
- // no free direction remaining => closing
- Position last=openList.removeLast();
- if ( last != current )
- {
- // GUARD, should not happen.
- System.err.println("INTERNAL ERROR 3");
- return false;
- }
- }
- complete = true;
- t[x][y]&=~OPEN;
- t[x][y]|=CLOSED;
- if ( current.getDepth() > deepest )
- {
- deepest = depth;
- deepestEnd = current;
- }
- } // current != null;
- } // synchronized
+ Position target = new Position(newx, newy, current.getDepth() + 1);
+ open(false, target);
+ if ((t[x][y] & DIRECTION) == DIRECTION)
+ {
+ t[x][y] |= direction;
+ }
+ else
+ {
+ t[x][y] = direction;
+ } // not a 'direction' ... is it necessary to check ?
+ if (freeDirection.size() > 1)
+ {
+ // keep it open at the very same place, previous open
+ // did add another node to inspect.
+ return false;
+ }
+ // else this was the unique direction , object already
+ // removed ( since if we try to remove it now it is not the
+ // last )
+
+ // can proceed to close
+ }
+ else
+ {
+ // no free direction remaining => closing
+ Position last = openList.removeLast();
+ if (last != current)
+ {
+ // GUARD, should not happen.
+ System.err.println("INTERNAL ERROR 3");
+ return false;
+ }
+ }
+ complete = true;
+ t[x][y] &= ~OPEN;
+ t[x][y] |= CLOSED;
+ if (current.getDepth() > deepest)
+ {
+ deepest = depth;
+ deepestEnd = current;
+ }
+ } // current != null;
+ } // synchronized
return complete;
}
public short getWalls(int x, int y)
{
- short walls=0;
- for (short direction: AllDirections)
- {
- if (hasWallInDirection(x,y,direction))
- {
- walls |= (direction>>FLAGLENGTH);
- }
- }
- return walls;
+ short walls = 0;
+ for (short direction : AllDirections)
+ {
+ if (hasWallInDirection(x, y, direction))
+ {
+ walls |= (direction >> FLAGLENGTH);
+ }
+ }
+ return walls;
}
- /** is there a wall in that direction ?
+ /**
+ * is there a wall in that direction ?
**/
public boolean hasWallInDirection(int x, int y, short direction)
{
- int newx=0;
- int newy=0;
- int delta=0;
- // best way to find reversedirection ?
- int reversedirection=0;
+ int newx = 0;
+ int newy = 0;
+ int delta = 0;
+ // best way to find reversedirection ?
+ int reversedirection = 0;
- // is this direction on the path ? yes => no wall
- if ( ( t[x][y] & direction ) == direction )
- {
- return false;
- }
+ // is this direction on the path ? yes => no wall
+ if ((t[x][y] & direction) == direction)
+ {
+ return false;
+ }
- // is adjacent tile in direction pointing in reverse direction ? yes => no wall
- if ( ( direction & POSITIVE ) == POSITIVE ) { delta = 1; }
- else { delta = -1; }
+ // is adjacent tile in direction pointing in reverse direction ? yes =>
+ // no wall
+ if ((direction & POSITIVE) == POSITIVE)
+ {
+ delta = 1;
+ }
+ else
+ {
+ delta = -1;
+ }
- if ( ( direction & HORIZONTAL ) == HORIZONTAL ) {
- newx = x + delta;
- newy = y;
- reversedirection = (direction == RIGHT) ? LEFT : RIGHT;
- }
- else {
- newy = y + delta;
- newx = x;
- reversedirection = (direction == UP) ? DOWN : UP;
- }
+ if ((direction & HORIZONTAL) == HORIZONTAL)
+ {
+ newx = x + delta;
+ newy = y;
+ reversedirection = (direction == RIGHT) ? LEFT : RIGHT;
+ }
+ else
+ {
+ newy = y + delta;
+ newx = x;
+ reversedirection = (direction == UP) ? DOWN : UP;
+ }
- if ( (newx >= 0) && ( newy >= 0 ) && (newx < width) && (newy < height) ) {
- return ( (t[newx][newy]&reversedirection) != reversedirection );
- }
- else {
- // outside boundaries.
- // TODO CHECK exits.
- return true;
- }
+ if ((newx >= 0) && (newy >= 0) && (newx < width) && (newy < height))
+ {
+ return ((t[newx][newy] & reversedirection) != reversedirection);
+ }
+ else
+ {
+ // outside boundaries.
+ // TODO CHECK exits.
+ return true;
+ }
}
- public void streamOut( String pFormat, OutputStream pOut)
- throws IOException
+ public void streamOut(String pFormat, OutputStream pOut) throws IOException
{
- if ((pFormat == null ) || (pFormat.equals("raw")))
- {
- // first raw format, not smart.
- DataOutputStream dataOut = new DataOutputStream(pOut);
- // should dump this to stream.
- dataOut.write( new byte[] { (byte) 'L', (byte) 'A', (byte) 'B', (byte) '0' });
- dataOut.writeInt(getWidth());
- dataOut.writeInt(getHeight());
- dataOut.flush();
- for (int y = 0; y < getHeight(); y++)
- {
- for (int x = 0 ; x < getWidth() ; x++)
- {
- dataOut.writeShort(t[x][y]);
- }
- }
- dataOut.flush();
- }
- else
- {
- throw new IOException("Format " + pFormat + " Not yet implemented.");
- }
+ if ((pFormat == null) || (pFormat.equals("raw")))
+ {
+ // first raw format, not smart.
+ DataOutputStream dataOut = new DataOutputStream(pOut);
+ // should dump this to stream.
+ dataOut.write(new byte[] { (byte) 'L', (byte) 'A', (byte) 'B', (byte) '0' });
+ dataOut.writeInt(getWidth());
+ dataOut.writeInt(getHeight());
+ dataOut.flush();
+ for (int y = 0; y < getHeight(); y++)
+ {
+ for (int x = 0; x < getWidth(); x++)
+ {
+ dataOut.writeShort(t[x][y]);
+ }
+ }
+ dataOut.flush();
+ }
+ else
+ {
+ throw new IOException("Format " + pFormat + " Not yet implemented.");
+ }
}
- private void streamIn( String pFormat, InputStream pIn)
- throws IOException
+ private void streamIn(String pFormat, InputStream pIn) throws IOException
{
- throw new IOException("Use correct constructor.");
+ throw new IOException("Use correct constructor.");
}
- private void parseInputStream( String pFormat, InputStream pIn)
- throws IOException
+ private void parseInputStream(String pFormat, InputStream pIn) throws IOException
{
- if (( pFormat == null) || ( pFormat.equals("raw") ))
- {
- byte[] header = new byte[4];
- DataInputStream in = new DataInputStream(pIn);
- in.read(header);
- int rwidth = in.readInt();
- int rheight = in.readInt();
- width=rwidth;
- height=rheight;
- maxdepth=maxdepth;
- random = null;
- // SHOULD CHECK max width and max height...
- // CLEAR == 0 and array is initialized with 0s
- t= new short[width][height];
- for (int y = 0; y < height; y++)
- {
- for (int x = 0 ; x < width ; x++)
- {
- t[x][y] = in.readShort();
- }
- }
- // should be at end of stream ? Not necessary can stream multiple labs ( or tiling ).
- }
- else
- {
- throw new IOException("Format " + pFormat + " Not yet implemented.");
- }
+ if ((pFormat == null) || (pFormat.equals("raw")))
+ {
+ byte[] header = new byte[4];
+ DataInputStream in = new DataInputStream(pIn);
+ in.read(header);
+ int rwidth = in.readInt();
+ int rheight = in.readInt();
+ width = rwidth;
+ height = rheight;
+ maxdepth = maxdepth;
+ random = null;
+ // SHOULD CHECK max width and max height...
+ // CLEAR == 0 and array is initialized with 0s
+ t = new short[width][height];
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ t[x][y] = in.readShort();
+ }
+ }
+ // should be at end of stream ? Not necessary can stream multiple
+ // labs ( or tiling ).
+ }
+ else
+ {
+ throw new IOException("Format " + pFormat + " Not yet implemented.");
+ }
}
diff --git a/java/org/artisanlogiciel/games/Main.java b/java/org/artisanlogiciel/games/Main.java
index 12c82e9..65ace64 100644
--- a/java/org/artisanlogiciel/games/Main.java
+++ b/java/org/artisanlogiciel/games/Main.java
@@ -6,50 +6,50 @@ import java.util.LinkedList;
public class Main
{
- public WallsProvider generate(int width,int height, int maxdepth, MazeResolutionListener listener)
+ public WallsProvider generate(int width, int height, int maxdepth, MazeResolutionListener listener)
{
- LabyModel model = new LabyModel(width, height,maxdepth, new java.util.Random());
- model.generateWithEntry(0, 0);
- LinkedList exits = new LinkedList();
- model.addEntryOrExit(-1,0);
- model.addEntryOrExit(width,height -1);
- if ( ! model.check() )
- {
- System.out.println("Check failed");
- }
- model.resolve(width-1,height-1,listener);
- return model;
+ LabyModel model = new LabyModel(width, height, maxdepth, new java.util.Random());
+ model.generateWithEntry(0, 0);
+ LinkedList exits = new LinkedList();
+ model.addEntryOrExit(-1, 0);
+ model.addEntryOrExit(width, height - 1);
+ if (!model.check())
+ {
+ System.out.println("Check failed");
+ }
+ model.resolve(width - 1, height - 1, listener);
+ return model;
}
- public LabyMap generate2(int width,int height, int maxdepth)
+ public LabyMap generate2(int width, int height, int maxdepth)
{
- LabyModel model = new LabyModel(width, height,maxdepth, new java.util.Random( 1024L));
- model.generateWithEntry(0, 0);
- LinkedList exits = new LinkedList();
- model.addEntryOrExit(-1,0);
- model.addEntryOrExit(width,height -1);
- System.out.println(model.toLabyMap().toString());
- if ( ! model.check() )
- {
- System.out.println("Check failed");
- }
- model.debugOut();
- model.resolve(width-1,height-1,null);
- LabyMap labyMap =model.toLabyMap();
- return labyMap;
+ LabyModel model = new LabyModel(width, height, maxdepth, new java.util.Random(1024L));
+ model.generateWithEntry(0, 0);
+ LinkedList exits = new LinkedList();
+ model.addEntryOrExit(-1, 0);
+ model.addEntryOrExit(width, height - 1);
+ System.out.println(model.toLabyMap().toString());
+ if (!model.check())
+ {
+ System.out.println("Check failed");
+ }
+ model.debugOut();
+ model.resolve(width - 1, height - 1, null);
+ LabyMap labyMap = model.toLabyMap();
+ return labyMap;
}
public static void main(String pArgs[])
{
- System.out.println("enter width height and maxdepth");
- Scanner console = new Scanner(System.in);
- int width = console.nextInt();
- int height = console.nextInt();
- int maxdepth = console.nextInt();
- Main m= new Main();
- LabyMap map = m.generate2(width,height,maxdepth);
- System.out.println(map.toShortString());
- System.out.println(map.toString());
- System.out.println(Brick.getDirLine());
+ System.out.println("enter width height and maxdepth");
+ Scanner console = new Scanner(System.in);
+ int width = console.nextInt();
+ int height = console.nextInt();
+ int maxdepth = console.nextInt();
+ Main m = new Main();
+ LabyMap map = m.generate2(width, height, maxdepth);
+ System.out.println(map.toShortString());
+ System.out.println(map.toString());
+ System.out.println(Brick.getDirLine());
}
}
diff --git a/java/org/artisanlogiciel/games/MazeCreationListener.java b/java/org/artisanlogiciel/games/MazeCreationListener.java
index 7059485..d425a70 100644
--- a/java/org/artisanlogiciel/games/MazeCreationListener.java
+++ b/java/org/artisanlogiciel/games/MazeCreationListener.java
@@ -1,7 +1,7 @@
package org.artisanlogiciel.games;
/**
- MazeCreationListener
+ * MazeCreationListener
**/
interface MazeCreationListener
{
diff --git a/java/org/artisanlogiciel/games/MazeParams.java b/java/org/artisanlogiciel/games/MazeParams.java
index 7850c79..dc0a17c 100644
--- a/java/org/artisanlogiciel/games/MazeParams.java
+++ b/java/org/artisanlogiciel/games/MazeParams.java
@@ -3,22 +3,24 @@ package org.artisanlogiciel.games;
import java.io.File;
/**
- MazeParams was autogenerated by ./generate_newclass.sh
+ * MazeParams was autogenerated by ./generate_newclass.sh
**/
public interface MazeParams
{
public int getWidth();
+
public int getHeight();
+
public int getMaxDepth();
/**
- @return name of Maze, used for creating filename at saving time
+ * @return name of Maze, used for creating filename at saving time
*/
public String getName();
/**
- @return directory owning where to save a maze
+ * @return directory owning where to save a maze
*/
public File getSaveDir();
-
+
}
diff --git a/java/org/artisanlogiciel/games/MazeResolutionListener.java b/java/org/artisanlogiciel/games/MazeResolutionListener.java
index 7c6fd5c..17058db 100644
--- a/java/org/artisanlogiciel/games/MazeResolutionListener.java
+++ b/java/org/artisanlogiciel/games/MazeResolutionListener.java
@@ -3,13 +3,13 @@ package org.artisanlogiciel.games;
import java.util.LinkedList;
/**
- MazeResolutionListener used as interface between resolver and (mostly) GUI
+ * MazeResolutionListener used as interface between resolver and (mostly) GUI
**/
public interface MazeResolutionListener
{
public boolean notifySearch(Position pPosition);
-
+
public void notifySearchError(String error);
public void notifyCompletion(LinkedList solvedPath);
diff --git a/java/org/artisanlogiciel/games/Position.java b/java/org/artisanlogiciel/games/Position.java
index bd23ccb..e4f5007 100644
--- a/java/org/artisanlogiciel/games/Position.java
+++ b/java/org/artisanlogiciel/games/Position.java
@@ -1,38 +1,41 @@
package org.artisanlogiciel.games;
-public class Position {
+public class Position
+{
private int x, y;
private int depth;
- public Position(int x, int y,int depth){
- this.x=x;
- this.y=y;
- this.depth=depth;
+ public Position(int x, int y, int depth)
+ {
+ this.x = x;
+ this.y = y;
+ this.depth = depth;
}
- public Position(int x, int y){
- this.x=x;
- this.y=y;
- this.depth=0;
+ public Position(int x, int y)
+ {
+ this.x = x;
+ this.y = y;
+ this.depth = 0;
}
public int getX()
{
- return this.x;
+ return this.x;
}
public int getY()
{
- return this.y;
+ return this.y;
}
public int getDepth()
{
- return depth;
+ return depth;
}
public String toString()
{
- return "(" + x + "," + y + ")" + "/" + depth ;
+ return "(" + x + "," + y + ")" + "/" + depth;
}
-}
+}
diff --git a/java/org/artisanlogiciel/games/Wall3d.java b/java/org/artisanlogiciel/games/Wall3d.java
deleted file mode 100644
index 76349fe..0000000
--- a/java/org/artisanlogiciel/games/Wall3d.java
+++ /dev/null
@@ -1,220 +0,0 @@
-package org.artisanlogiciel.games;
-
-import java.util.Scanner;
-import java.io.OutputStream;
-import java.io.IOException;
-
-/**
- Wall3d to create walls in 3d
- South, West North East...
- **/
-public class Wall3d
-{
- // 4 triangles in 2 dim space reused 3 times
- final static int BASE[][][] = {{{0,0},{1,0},{0,1}},{{1,0},{1,1},{0,1}},{{0,0},{1,0},{1,1}},{{0,0},{1,1},{0,1}}};
-
- final static short X=1;
- final static short Y=2;
- final static short Z=4;
-
- // final static short AXIS[][]= {{X,Y},{-Z,Y},{X,Y},{Z,Y},{X,-Z},{X,-Z}};
- final static short AXIS[][]= {{X,Y,0},{Z,Y,0},{X,Y,1},{Z,Y,1},{X,Z,0},{X,Z,1}};
-
- public final static Wall3d South = new Wall3d(10,1,10,0,0,0);
- public final static Wall3d West = new Wall3d(1,10,10,0,0,0);
- public final static Wall3d North = new Wall3d(10,1,10,0,10,0);
- public final static Wall3d East = new Wall3d(1,10,10,10,0,0);
-
- int triangle[][][] = null;
-
- public Wall3d(int t[][][])
- {
- triangle = t;
- }
-
- public Wall3d(Wall3d origin, int dx, int dy, int dz)
- {
- triangle=origin.translate(dx,dy,dz);
- }
-
- Wall3d(int xl, int yl, int zl, int dx, int dy, int dz)
- {
- int f=0;
- triangle = new int[12][3][3];
- int[] factor = {xl,yl,zl};
- int[] translate = {dx,dy,dz};
- for (int i=0; i < 12; i++)
- {
- // point in a triangle
- for (int p=0; p<3; p++)
- {
- short uaxis=0;
- for (int axis=0; axis <2; axis++)
- {
- short caxis = AXIS[i/2][axis];
- if ( caxis >0 )
- {
- f=1;
- }
- else
- if ( caxis <0 )
- {
- f=-1;
- caxis=(short) -caxis;
- }
- uaxis|=caxis;
- if ( caxis == X )
- {
- caxis=0;
- }
- else if ( caxis == Y)
- {
- caxis=1;
- }
- else
- {
- caxis=2;
- }
- // if ( f == 0 )
- // {
- // System.out.println("ERROR");
- // }
- //System.out.println("i " + i + " p " + p + " a " + caxis + " , " + BASE[i%4][p][axis] );
- triangle[i][p][caxis]=translate[caxis] + BASE[i%4][p][axis]*f*factor[caxis];
- }
- if ( (uaxis & X) == 0 )
- {
- uaxis=0;
- }
- else if ( (uaxis & Y) == 0)
- {
- uaxis=1;
- }
- else
- {
- uaxis=2;
- }
- triangle[i][p][uaxis]=translate[uaxis] + AXIS[i/2][2]*factor[uaxis];
- }
- }
- }
-
-
- public int[][][] translate(int dx, int dy, int dz)
- {
- int[] translate = {dx,dy,dz};
- int t[][][] = new int[12][3][3];
-
- for (int i=0; i < 12; i++)
- {
- // point in a triangle
- for (int p=0; p<3; p++)
- {
- for (int axis=0; axis <3; axis++)
- {
- t[i][p][axis]=translate[axis] + triangle[i][p][axis];
- }
- }
- }
- return t;
-
- }
-
- public String toString()
- {
- String s = "";
- for (int t=0; t<12; t++)
- {
- s+="facet normal 0 0 0\nouter loop\n";
- for (int p=0; p<3; p++)
- {
- s+="vertex";
- for (int a=0; a<3; a++)
- {
- // s+=" t "+ t + " p " + p + " a " + a + "=" + triangle[t][p][a];
- s+= " " + triangle[t][p][a];
- }
- s+="\n";
- }
- s=s+"endloop\nendfacet\n";
- }
- return s;
- }
-
- public static void prepare()
- {
- System.out.println(South.toString());
- System.out.println(East.toString());
- System.out.println(North.toString());
- System.out.println(West.toString());
- }
-
- public static void streamWallsOut(String name, WallsProvider provider, OutputStream stream)
- throws IOException
- {
- int width = provider.getWidth();
- int height = provider.getHeight();
- int xl = 10;
- int yl = 10;
- int zl = 10;
-
- // WARNING DOWN - UP reversed ( in 2D Y is oriented to lower, in 3D it is to upper ).
- stream.write(("solid " + name + "\n").getBytes());
- for (int x=0; x v <
- U R D L
- p i o e
- g w f
- h n t
- t
+ * See Brick
+ *
+ * Will set bits : 3 2 1 0 (8)(4)(2)(1) ^ > v < U R D L p i o e g w f h n t
+ * t
**/
public short getWalls(int x, int y);
}
diff --git a/java/org/artisanlogiciel/games/stl/Wall3d.java b/java/org/artisanlogiciel/games/stl/Wall3d.java
new file mode 100644
index 0000000..a26ddc2
--- /dev/null
+++ b/java/org/artisanlogiciel/games/stl/Wall3d.java
@@ -0,0 +1,225 @@
+package org.artisanlogiciel.games.stl;
+
+import java.util.Scanner;
+
+import org.artisanlogiciel.games.Brick;
+import org.artisanlogiciel.games.WallsProvider;
+
+import java.io.OutputStream;
+import java.io.IOException;
+
+/**
+ * Wall3d to create walls in 3d for stl conversion South, West North East...
+ **/
+public class Wall3d
+{
+ // 4 triangles in 2 dim space reused 3 times
+ final static int BASE[][][] = { { { 0, 0 }, { 1, 0 }, { 0, 1 } }, { { 1, 0 }, { 1, 1 }, { 0, 1 } },
+ { { 0, 0 }, { 1, 0 }, { 1, 1 } }, { { 0, 0 }, { 1, 1 }, { 0, 1 } } };
+
+ final static short X = 1;
+ final static short Y = 2;
+ final static short Z = 4;
+
+ // final static short AXIS[][]= {{X,Y},{-Z,Y},{X,Y},{Z,Y},{X,-Z},{X,-Z}};
+ final static short AXIS[][] = { { X, Y, 0 }, { Z, Y, 0 }, { X, Y, 1 }, { Z, Y, 1 }, { X, Z, 0 }, { X, Z, 1 } };
+
+ public final static Wall3d South = new Wall3d(10, 1, 10, 0, 0, 0);
+ public final static Wall3d West = new Wall3d(1, 10, 10, 0, 0, 0);
+ public final static Wall3d North = new Wall3d(10, 1, 10, 0, 10, 0);
+ public final static Wall3d East = new Wall3d(1, 10, 10, 10, 0, 0);
+
+ int triangle[][][] = null;
+
+ public Wall3d(int t[][][])
+ {
+ triangle = t;
+ }
+
+ public Wall3d(Wall3d origin, int dx, int dy, int dz)
+ {
+ triangle = origin.translate(dx, dy, dz);
+ }
+
+ Wall3d(int xl, int yl, int zl, int dx, int dy, int dz)
+ {
+ int f = 0;
+ triangle = new int[12][3][3];
+ int[] factor = { xl, yl, zl };
+ int[] translate = { dx, dy, dz };
+ for (int i = 0; i < 12; i++)
+ {
+ // point in a triangle
+ for (int p = 0; p < 3; p++)
+ {
+ short uaxis = 0;
+ for (int axis = 0; axis < 2; axis++)
+ {
+ short caxis = AXIS[i / 2][axis];
+ if (caxis > 0)
+ {
+ f = 1;
+ }
+ else if (caxis < 0)
+ {
+ f = -1;
+ caxis = (short) -caxis;
+ }
+ uaxis |= caxis;
+ if (caxis == X)
+ {
+ caxis = 0;
+ }
+ else if (caxis == Y)
+ {
+ caxis = 1;
+ }
+ else
+ {
+ caxis = 2;
+ }
+ // if ( f == 0 )
+ // {
+ // System.out.println("ERROR");
+ // }
+ // System.out.println("i " + i + " p " + p + " a " + caxis +
+ // " , " + BASE[i%4][p][axis] );
+ triangle[i][p][caxis] = translate[caxis] + BASE[i % 4][p][axis] * f * factor[caxis];
+ }
+ if ((uaxis & X) == 0)
+ {
+ uaxis = 0;
+ }
+ else if ((uaxis & Y) == 0)
+ {
+ uaxis = 1;
+ }
+ else
+ {
+ uaxis = 2;
+ }
+ triangle[i][p][uaxis] = translate[uaxis] + AXIS[i / 2][2] * factor[uaxis];
+ }
+ }
+ }
+
+ public int[][][] translate(int dx, int dy, int dz)
+ {
+ int[] translate = { dx, dy, dz };
+ int t[][][] = new int[12][3][3];
+
+ for (int i = 0; i < 12; i++)
+ {
+ // point in a triangle
+ for (int p = 0; p < 3; p++)
+ {
+ for (int axis = 0; axis < 3; axis++)
+ {
+ t[i][p][axis] = translate[axis] + triangle[i][p][axis];
+ }
+ }
+ }
+ return t;
+
+ }
+
+ public String toString()
+ {
+ String s = "";
+ for (int t = 0; t < 12; t++)
+ {
+ s += "facet normal 0 0 0\nouter loop\n";
+ for (int p = 0; p < 3; p++)
+ {
+ s += "vertex";
+ for (int a = 0; a < 3; a++)
+ {
+ // s+=" t "+ t + " p " + p + " a " + a + "=" +
+ // triangle[t][p][a];
+ s += " " + triangle[t][p][a];
+ }
+ s += "\n";
+ }
+ s = s + "endloop\nendfacet\n";
+ }
+ return s;
+ }
+
+ public static void prepare()
+ {
+ System.out.println(South.toString());
+ System.out.println(East.toString());
+ System.out.println(North.toString());
+ System.out.println(West.toString());
+ }
+
+ public static void streamWallsOut(String name, WallsProvider provider, OutputStream stream) throws IOException
+ {
+ int width = provider.getWidth();
+ int height = provider.getHeight();
+ int xl = 10;
+ int yl = 10;
+ int zl = 10;
+
+ // WARNING DOWN - UP reversed ( in 2D Y is oriented to lower, in 3D it
+ // is to upper ).
+ stream.write(("solid " + name + "\n").getBytes());
+ for (int x = 0; x < width; x++)
+ {
+ short walls = provider.getWalls(x, 0);
+ if ((walls & Brick.UP) != 0)
+ {
+ stream.write(new Wall3d(South, x * xl, 0, 0).toString().getBytes());
+ }
+ if ((walls & Brick.LEFT) != 0)
+ {
+ stream.write(new Wall3d(West, x * xl, 0, 0).toString().getBytes());
+ }
+ }
+
+ for (int y = 0; y < height; y++)
+ {
+ short walls = provider.getWalls(0, y);
+ if ((walls & Brick.LEFT) != 0)
+ {
+ stream.write(new Wall3d(West, 0, y * yl, 0).toString().getBytes());
+ }
+ for (int x = 0; x <