import java.awt.*;
public class Maze extends java.applet.Applet implements Runnable {
int[][] maze; // Description of state of maze. The value of maze[i][j]
//รายละเอียดของรัฐของเขาวงกต ค่าของเขาวงกต [i] [j]
// is one of the constants wallCode, pathcode, emptyCode,
//เป็นหนึ่งใน wallCode ค่าคงที่ pathcode, emptyCode,
// or visitedCode. (Value can also be negative, temporarily
//visitedCode หรือ (Value ยังสามารถลบชั่วคราว
// inside createMaze().)
//ภายใน createMaze () . )
// A maze is made up of walls and corridors. maze[i][j]
//เขาวงกตขึ้นจากกำแพงและทางเดิน เขาวงกต [i] [j]
// is either part of a wall or part of a corridor. A cell
//เป็นส่วนหนึ่งของผนังหรือส่วนของทางเดินทั้ง เซลล์
//
//เซลล์ที่เป็นส่วนหนึ่งของ cooridor จะแสดงเป็น pathCode
//
//ถ้ามันเป็นส่วนหนึ่งของเส้นทางปัจจุบันผ่านเขาวงกตโดย
//
//visitedCode หากมีการสำรวจแล้วไม่พบ
// a solution, and by emptyCode if it has not yet been explored.
//โซลูชั่นและโดย emptyCode ถ้ายังไม่ได้สำรวจ
final static int backgroundCode = 0;
final static int wallCode = 1;
final static int pathCode = 2;
final static int emptyCode = 3;
final static int visitedCode = 4;
// the next six items are set up in init(), and can be specified
//ถัดไปหกรายการตั้งค่าใน init () และสามารถระบุ
// using applet parameters
//การใช้พารามิเตอร์แอพเพล็ต
Color[] color = new Color[5];
// colors associated with the preceding 5 constants;
//สีที่เกี่ยวข้องกับค่าคงที่ก่อนหน้า 5
int rows = 21;
// number of rows of cells in maze, including a wall around edges
//จำนวนแถวของเซลล์ในเขาวงกตรวมถึงกำแพงรอบขอบ
int columns = 21;
// number of columns of cells in maze, including a wall around edges
//จำนวนคอลัมน์ของเซลล์ในเขาวงกตรวมถึงกำแพงรอบขอบ
int border = 0;
// minimum number of pixels between maze and edge of applet
//จำนวนต่ำสุดของพิกเซลระหว่างเขาวงกตและขอบของแอพเพล็ต
int sleepTime = 5000;
// wait time after solving one maze before making another
//รอเวลาหลังจากการแก้หนึ่งเขาวงกตก่อนอื่น
int speedSleep = 50;
// short delay between steps in making and solving maze
//ล่าช้าระหว่างขั้นตอนในการทำและการแก้เขาวงกต
Thread mazeThread; // thread for creating and solving maze
//หัวข้อสำหรับการสร้างและแก้ไขเขาวงกต
int width = -1; // width of applet, to be set by checkSize()
//ความกว้างของแอพเพล็ตที่จะกำหนดโดย checkSize
int height = -1; // height of applet, to be set by checkSize()
//ความสูงของแอพเพล็ตที่จะกำหนดโดย checkSize ()
int totalWidth;
// width of applet, minus border area (set in checkSize())
//ความกว้างของแอพเพล็ตพื้นที่ชายแดน, ลบ (ตั้งอยู่ใน checkSize ())
int totalHeight;
// height of applet, minus border area (set in checkSize())
//ความสูงของแอพเพล็ตพื้นที่ชายแดน, ลบ (ตั้งอยู่ใน checkSize ())
int left;
// left edge of maze, allowing for border (set in checkSize())
//ขอบซ้ายของเขาวงกตเพื่อให้สามารถชายแดน (ตั้งอยู่ใน checkSize ())
int top;
// top edge of maze, allowing for border (set in checkSize())
//ขอบด้านบนของเขาวงกตเพื่อให้สามารถชายแดน (ตั้งอยู่ใน checkSize
boolean mazeExists = false;
// set to true when maze[][] is valid; used in
//การตั้งค่าจริงเมื่อเขาวงกต [] [] ถูกต้อง; ใช้ใน
// redrawMaze(); set to true in createMaze(), and
//redrawMaze (); การตั้งค่าจริงใน createMaze () และ
// reset to false in run()
//รีเซ็ตเท็จในระยะ
int status = 0; // A variable used by the applet to control the mazeThread.
//ตัวแปรที่ใช้ในการควบคุมแอปเพล็ mazeThread
final static int GO = 0, //Some constants to be uses as values for status.
//บางคงต้องใช้เป็นค่าสำหรับสถานะ
SUSPEND = 1,
TERMINATE = 2;
Integer getIntParam(String paramName) {
// Utility routine for reading an applet param which is an integer.
//Utility ประจำอ่านพระราม applet ซึ่งเป็นจำนวนเต็ม
// Returns null if there is no such param, or if the value is not
//คืน null ถ้าไม่มีพารามิเตอร์ดังกล่าวหรือถ้าค่าไม่ได้
// a legal integer.
//จำนวนเต็มกฎหมาย
String param = getParameter(paramName);
if (param == null)
return null;
int i;
try {
i = Integer.parseInt(param);
}
catch (NumberFormatException e) {
return null;
}
return new Integer(i);
}
Color getColorParam(String paramName) {
// Utility routine for reading an applet param which is a color.
//Utility ประจำอ่านพระราม applet ซึ่งเป็นสี
// Returns null if there is no such param, or if the value is not
//คืน null ถ้าไม่มีพารามิเตอร์ดังกล่าวหรือถ้าค่าไม่ได้
// a legal color. Colors can be specified as three integers,
//สีตามกฎหมาย สีสามารถระบุเป็นสามจำนวนเต็ม
// separated by spaces, giving RGB components in the range 0 to 255;
//แยกโดยช่องว่างให้ส่วน RGB ในช่วง 0-255;
// the standard Java color names are also acceptable.
//มาตรฐาน Java ชื่อสียังยอมรับ
String param = getParameter(paramName);
if (param == null || param.length() == 0)
return null;
if (Character.isDigit(param.charAt(0))) { // try to parse RGB color
//พยายามที่จะแยกสี RGB
int r=0,g=0,b=0;
int pos=0;
int d=0;
int len=param.length();
while (pos < len && Character.isDigit(param.charAt(pos)) && r < 255) {
d = Character.digit(param.charAt(pos),10);
r = 10*r + d;
pos++;
}
if (r > 255)
return null;
while (pos < len && !Character.isDigit(param.charAt(pos)))
pos++;
if (pos >= len)
return null;
while (pos < len && Character.isDigit(param.charAt(pos)) && g < 255) {
d = Character.digit(param.charAt(pos),10);
g = 10*g + d;
pos++;
}
if (g > 255)
return null;
while (pos < len && !Character.isDigit(param.charAt(pos)))
pos++;
if (pos >= len)
return null;
while (pos < len && Character.isDigit(param.charAt(pos)) && b < 255) {
d = Character.digit(param.charAt(pos),10);
b = 10*b + d;
pos++;
}
if (b > 255)
return null;
return new Color(r,g,b);
}
if (param.equalsIgnoreCase("black"))
return Color.black;
if (param.equalsIgnoreCase("white"))
return Color.white;
if (param.equalsIgnoreCase("red"))
return Color.red;
if (param.equalsIgnoreCase("green"))
return Color.green;
if (param.equalsIgnoreCase("blue"))
return Color.blue;
if (param.equalsIgnoreCase("yellow"))
return Color.yellow;
if (param.equalsIgnoreCase("cyan"))
return Color.cyan;
if (param.equalsIgnoreCase("magenta"))
return Color.magenta;
if (param.equalsIgnoreCase("pink"))
return Color.pink;
if (param.equalsIgnoreCase("orange"))
return Color.orange;
if (param.equalsIgnoreCase("gray"))
return Color.gray;
if (param.equalsIgnoreCase("darkgray"))
return Color.darkGray;
if (param.equalsIgnoreCase("lightgray"))
return Color.lightGray;
return null; // param is not a legal color//พระรามไม่เป็นสีตามกฎหมาย
}
public void init() {
Integer parm;
parm = getIntParam("rows");
if (parm != null && parm.intValue() > 4 && parm.intValue() <= 500) {
rows = parm.intValue();
if (rows % 2 == 0)
rows++;
}
parm = getIntParam("columns");
if (parm != null && parm.intValue() > 4 && parm.intValue() <= 500) {
columns = parm.intValue();
if (columns % 2 == 0)
columns++;
}
parm = getIntParam("border");
if (parm != null && parm.intValue() > 0 && parm.intValue() <= 100)
border = parm.intValue();
parm = getIntParam("sleepTime");
if (parm != null && parm.intValue() > 0)
sleepTime = parm.intValue();
parm = getIntParam("speed");
if (parm != null && parm.intValue() > 0 && parm.intValue() < 6)
switch (parm.intValue()) {
case 1: speedSleep = 1; break;
case 2: speedSleep = 25; break;
case 3: speedSleep = 50; break;
case 4: speedSleep = 100; break;
case 5: speedSleep = 200; break;
}
color[wallCode] = getColorParam("wallColor");
if (color[wallCode] == null)
color[wallCode] = Color.black;
color[pathCode] = getColorParam("pathColor");
if (color[pathCode] == null)
color[pathCode] = new Color(200,0,0);
color[emptyCode] = getColorParam("emptyColor");
if (color[emptyCode] == null)
color[emptyCode] = new Color(128,128,255);
color[backgroundCode] = getColorParam("borderColor");
if (color[backgroundCode] == null)
color[backgroundCode] = Color.white;
color[visitedCode] = getColorParam("visitedColor");
if (color[visitedCode] == null)
color[visitedCode] = color[emptyCode];
setBackground(color[backgroundCode]);
}
void checkSize() {
// Called every time something is about to be drawn to
//สิ่งที่เรียกว่าทุกครั้งที่กำลังจะถูกดึง
// check the applet size and adjust variables that depend
//ตรวจสอบขนาดแอพเพล็ตและปรับตัวแปรที่ขึ้นอยู่กับ
// on the size. //กับขนาด
if (getWidth() != width || getHeight() != height) {
width = getWidth();
height = getHeight();
int w = (width - 2*border) / columns;
int h = (height - 2*border) / rows;
left = (width - w*columns) / 2;
top = (height - h*rows) / 2;
totalWidth = w*columns;
totalHeight = h*rows;
}
}
synchronized public void start() {
status = GO;
if (mazeThread == null || ! mazeThread.isAlive()) {
mazeThread = new Thread(this);
mazeThread.start();
}
else
notify();
}
synchronized public void stop() {
if (mazeThread != null) {
status = SUSPEND;
notify();
}
}
synchronized public void destroy() {
if (mazeThread != null) {
status = TERMINATE;
notify();
}
}
synchronized int checkStatus() {
while (status == SUSPEND) {
try { wait(); }
catch (InterruptedException e) { }
}
return status;
}
public void paint(Graphics g) {
checkSize();
redrawMaze(g);
}
public void update(Graphics g) {
// don't bother filling with background color
//ไม่รำคาญเติมด้วยสีพื้น
paint(g); // because redrawMaze() does that anyway
//เพราะ redrawMaze () ไม่ว่าอย่างไรก็ตาม
}
synchronized void redrawMaze(Graphics g) {
// draws the entire maze //จับเขาวงกตทั้งหมด
g.setColor(color[backgroundCode]);
g.fillRect(0,0,width,height);
if (mazeExists) {
int w = totalWidth / columns; // width of each cell
//ความกว้างของแต่ละเซลล์
int h = totalHeight / rows; // height of each cell
//ความสูงของแต่ละเซลล์
for (int j=0; j<columns; j++)
for (int i=0; i<rows; i++) {
if (maze[i][j] < 0)
g.setColor(color[emptyCode]);
else
g.setColor(color[maze[i][j]]);
g.fillRect( (j * w) + left, (i * h) + top, w, h );
}
}
}
synchronized void putSquare(int row, int col, int colorNum) {
// draw one cell of the maze, to the graphics context "me"
//วาดหนึ่งเซลล์ของเขาวงกตเพื่อบริบทกราฟิก"me"
checkSize();
int w = totalWidth / columns; // width of each cell
//ความกว้างของแต่ละเซลล์
int h = totalHeight / rows; // height of each cell
//ความสูงของแต่ละเซลล์
Graphics me = getGraphics();
me.setColor(color[colorNum]);
me.fillRect( (col * w) + left, (row * h) + top, w, h );
me.dispose();
}
public void run() {
// run method for thread repeatedly makes a maze and then solves it
//วิธีใช้สำหรับหัวข้อซ้ำทำให้เขาวงกตแล้วแก้มัน
try { Thread.sleep(2000); } // wait a bit before starting
//รอสักครู่ก่อนที่จะเริ่ม
catch (InterruptedException e) { }
while (true) {
if (checkStatus() == TERMINATE)
break;
makeMaze();
if (checkStatus() == TERMINATE)
break;
solveMaze(1,1);
if (checkStatus() == TERMINATE)
break;
synchronized(this) {
try { wait(sleepTime); }
catch (InterruptedException e) { }
}
if (checkStatus() == TERMINATE)
break;
mazeExists = false;
checkSize();
Graphics me = getGraphics();
redrawMaze(me); // erase old maze //ลบเขาวงกตเก่า
me.dispose();
}
}
void makeMaze() {
// Create a random maze. The strategy is to start with
//สร้างเขาวงกตแบบสุ่ม กลยุทธ์คือการเริ่มต้นด้วย
// a grid of disconnnected "rooms" separated by walls.
//ตารางของห้อง"disconnnected"แยกจากกันโดยผนัง
// then look at each of the separating walls, in a random
//แล้วมองแต่ละผนังแยกในการสุ่ม
// order. If tearing down a wall would not create a loop
//สั่ง ถ้าฉีกลงผนังจะไม่สร้าง loop
// in the maze, then tear it down. Otherwise, leave it in place.
//ในเขาวงกตแล้วฉีกมันลง มิฉะนั้นทิ้งไว้ในสถานที่
if (maze == null)
maze = new int[rows][columns];
int i,j;
int emptyCt = 0; // number of rooms //จำนวนห้องพัก
int wallCt = 0; // number of walls //จำนวนผนัง
int[] wallrow = new int[(rows*columns)/2];
// position of walls between rooms //ตำแหน่งของผนังระหว่างห้อง
int[] wallcol = new int[(rows*columns)/2];
for (i = 0; i<rows; i++) // start with everything being a wall
//เริ่มต้นด้วยทุกอย่างถูกผนัง
for (j = 0; j < columns; j++)
maze[i][j] = wallCode;
for (i = 1; i<rows-1; i += 2) // make a grid of empty rooms
//ทำตารางของห้องว่าง
for (j = 1; j<columns-1; j += 2) {
emptyCt++;
maze[i][j] = -emptyCt;
// each room is represented by a different negative number
//แต่ละห้องจะแสดงด้วยจำนวนลบที่แตกต่างกัน
if (i < rows-2) { // record info about wall below this room
//บันทึกข้อมูลเกี่ยวกับผนังห้องด้านล่างนี้
wallrow[wallCt] = i+1;
wallcol[wallCt] = j;
wallCt++;
}
if (j < columns-2) {
// record info about wall to right of this room
//บันทึกข้อมูลเกี่ยวกับผนังด้านขวาของห้องนี้
wallrow[wallCt] = i;
wallcol[wallCt] = j+1;
wallCt++;
}
}
mazeExists = true;
checkSize();
if (checkStatus() == TERMINATE)
return;
Graphics me = getGraphics();
redrawMaze(me); // show the maze //แสดงเขาวงกต
me.dispose();
int r;
for (i=wallCt-1; i>0; i--) {
r = (int)(Math.random() * i);
// choose a wall randomly and maybe tear it down
//เลือกผนังสุ่มและอาจขาดลง
if (checkStatus() == TERMINATE)
return;
tearDown(wallrow[r],wallcol[r]);
wallrow[r] = wallrow[i];
wallcol[r] = wallcol[i];
}
for (i=1; i<rows-1; i++)
// replace negative values in maze[][] with emptyCode
//แทนค่าลบในเขาวงกต [] [] กับ emptyCode
for (j=1; j<columns-1; j++)
if (maze[i][j] < 0)
maze[i][j] = emptyCode;
}
synchronized void tearDown(int row, int col) {
// Tear down a wall, unless doing so will form a loop. Tearing down a wall
//ฉีกลงผนังเว้นแต่ทำเช่นนี้จะฟอร์มวง น้ำตาไหลลงมาที่ผนัง
// joins two "rooms" into one "room". (Rooms begin to look like corridors
//รวมสองห้อง""เข้าห้อง"" (ห้องเริ่มมีลักษณะทางเดิน
// as they grow.) When a wall is torn down, the room codes on one side are
//ที่พวกเขาเติบโต . ) เมื่อผนังถูกดึงขาดลงรหัสห้องด้านหนึ่งเป็น
// converted to match those on the other side, so all the cells in a room
//แปลงตรงกับด้านอื่น ๆ เพื่อให้ทุกเซลล์ในห้อง
// have the same code. Note that if the room codes on both sides of a
//มีรหัสเดียวกัน ทราบว่าหากรหัสห้องทั้งสองด้านของ
// wall already have the same code, then tearing down that wall would
//ผนังมีรหัสเดียวกันนั้นฉีกลงผนังที่จะ
// create a loop, so the wall is left in place.
//สร้าง loop ดังนั้นผนังเหลืออยู่ในสถานที่
if (row % 2 == 1 && maze[row][col-1] != maze[row][col+1]) {
// row is odd; wall separates rooms horizontally
//แถวเป็นคี่; ห้องแยกผนังแนวนอน
fill(row, col-1, maze[row][col-1], maze[row][col+1]);
maze[row][col] = maze[row][col+1];
putSquare(row,col,emptyCode);
try { wait(speedSleep); }
catch (InterruptedException e) { }
}
else if (row % 2 == 0 && maze[row-1][col] != maze[row+1][col]) {
// row is even; wall separates rooms vertically
//row is even; wall separates rooms vertically
fill(row-1, col, maze[row-1][col], maze[row+1][col]);
maze[row][col] = maze[row+1][col];
putSquare(row,col,emptyCode);
try { wait(speedSleep); }
catch (InterruptedException e) { }
}
}
void fill(int row, int col, int replace, int replaceWith) {
// called by tearDown() to change "room codes".
//เรียก tearDown () การเปลี่ยนรหัสห้อง""
if (maze[row][col] == replace) {
maze[row][col] = replaceWith;
fill(row+1,col,replace,replaceWith);
fill(row-1,col,replace,replaceWith);
fill(row,col+1,replace,replaceWith);
fill(row,col-1,replace,replaceWith);
}
}
boolean solveMaze(int row, int col) {
// Try to solve the maze by continuing current path from position
//พยายามแก้ปัญหาเขาวงกตอย่างต่อเนื่องโดยในปัจจุบันเส้นทางจากตำแหน่ง
// (row,col). Return true if a solution is found. The maze is
//(แถว, col) กลับจริงถ้าแก้ปัญหาที่พบ เขาวงกตเป็น
// considered to be solved if the path reaches the lower right cell.
//พิจารณาที่จะแก้ไขหากเส้นทางถึงเซลล์ขวาล่าง
if (maze[row][col] == emptyCode) {
maze[row][col] = pathCode; // add this cell to the path
//เพิ่มเซลล์นี้เส้นทาง
if (checkStatus() == TERMINATE)
return false;
putSquare(row,col,pathCode);
if (row == rows-2 && col == columns-2)
return true; // path has reached goal
//เส้นทางได้ถึงเป้าหมาย
try { Thread.sleep(speedSleep); }
catch (InterruptedException e) { }
if ( (solveMaze(row-1,col) && checkStatus() != TERMINATE) ||
// try to solve maze by extending path
//พยายามแก้ปัญหาโดยการขยายเส้นทางเขาวงกต
(solveMaze(row,col-1) && checkStatus() != TERMINATE) ||
// in each possible direction
//ทิศทางในการไปแต่ละ
(solveMaze(row+1,col) && checkStatus() != TERMINATE) ||
solveMaze(row,col+1) )
return true;
if (checkStatus() == TERMINATE)
return false;
// maze can't be solved from this cell, so backtract out of the cell
//เขาวงกตไม่สามารถแก้ไขได้จากเซลล์นี้เพื่อ backtract ออกจากเซลล์
maze[row][col] = visitedCode; // mark cell as having been visited
//เซลล์ทำเครื่องหมายว่าได้รับชม
putSquare(row,col,visitedCode);
synchronized(this) {
try { wait(speedSleep); }
catch (InterruptedException e) { }
}
if (checkStatus() == TERMINATE)
return false;
}
return false;
}
}
Tag : JavaScript, Win (Windows App), Class Library, C#, J#
Load balance : Server 02
