AlhamdulIllah

src/Program.java

 // - 1 -
 
 import approach2.window.MainWindowApproach2;
+import approach3.window.MainWindowApproach3;
 
 public class Program {
 
 
     public static void main(String[] args) throws Exception {
 
-        MainWindowApproach2 window = new MainWindowApproach2("Pathfinder v1", 1080, 1080);
+        MainWindowApproach3 window = new MainWindowApproach3("Pathfinder v1", 1080, 1080);
         window.run();
 
     }

src/approach3/parallel/SharedRessources.java

@@ -96,6 +96,10 @@ public class SharedRessources {
         }
     }
 
+    public Int3 getData(int x, int y) {
+        return data[x + y * width];
+    }
+
     public boolean isWall(int x, int y) {
         return walls[x + y * width];
     }
@@ -104,4 +108,12 @@ public class SharedRessources {
         walls[x + y * width] = true;
     }
 
+    public int getWidth() {
+        return this.width;
+    }
+
+    public int getHeight() {
+        return this.height;
+    }
+
 }

src/approach3/parallel/WallBasedPathfinder.java

 package approach3.parallel;
 
+import approach3.parallel.operations.Trace;
+import structs.Int3;
+import structs.Vec3;
+
+import java.awt.*;
+import java.util.ArrayList;
+
 public class WallBasedPathfinder {
 
 
+    public void find() {
+
+        int beginX = SharedRessources.getInstance().getStart().x;
+        int beginY = SharedRessources.getInstance().getStart().y;
+
+        int endX = SharedRessources.getInstance().getEnd().x;
+        int endY = SharedRessources.getInstance().getEnd().y;
+
+
+        SharedRessources
+                .getInstance()
+                .getExecutor()
+                .execute(new Trace(endX, endY, beginX, beginY, 0));
+
+
+    }
+
+
+    ArrayList<Point> debug = new ArrayList<>();
+
+
+    public ArrayList<Point> calculatePath(int startX, int startY, int destX, int destY) {
+
+        int x = startX;
+        int y = startY;
+
+        while (x != destX || y != destY) {
+
+            debug.add(new Point(x, y));
+
+            Int3 currentDir
+                    =
+                    SharedRessources.getInstance().getData(x, y);
+
+            int dx = (int) currentDir.getX();
+            int dy = (int) currentDir.getY();
+
+            if (dx == 0 && dy == 0)
+                break;
+
+            x += dx;
+            y += dy;
+
+
+        }
+
+        System.out.println("Done.");
+
+        return debug;
+    }
+
+
+    public void draw(Graphics g) {
+
+
+        for (int j = 0; j < SharedRessources.getInstance().getHeight(); j++) {
+            for (int i = 0; i < SharedRessources.getInstance().getWidth(); i++) {
+                if (SharedRessources.getInstance().isWall(i, j)) {
+                    g.setColor(Color.blue);
+                    g.fillRect(i * 5, j * 5, 5, 5);
+                } else {
+                    int dx = (int) SharedRessources.getInstance().getData(i, j).getX() * 5;
+                    int dy = (int) SharedRessources.getInstance().getData(i, j).getY() * 5;
+
+                    if (dx != 0 || dy != 0) {
+                        int green = SharedRessources.getInstance().getStep(i, j);
+                        if (green >= 255)
+                            green = 255;
+                        Color color
+                                = new Color(0, 255, 0);
+
+                        g.setColor(color);
+
+                        g.fillRect(i * 5, j * 5, 5, 5);
+
+                        g.setColor(Color.red);
+                        g.drawLine(i * 5, j * 5, i * 5 + dx, j * 5 + dy);
+
+
+                    } else {
+                        g.setColor(Color.black);
+                        g.fillRect(i * 5, j * 5, 5, 5);
+                    }
+                }
+            }
+        }
+
+        if (SharedRessources.getInstance().getEnd() == null || SharedRessources.getInstance().getStart() == null)
+            return;
+
 
+        g.setColor(Color.yellow);
+        g.fillRect(SharedRessources.getInstance().getEnd().x * 5,
+                SharedRessources.getInstance().getEnd().y * 5, 5
+                , 5);
+
+        g.setColor(Color.red);
+        g.fillRect(SharedRessources.getInstance().getStart().x * 5,
+                SharedRessources.getInstance().getStart().y * 5
+                , 5, 5);
+
+
+        g.setColor(Color.red);
+
+        for (int i = 0; i < debug.size(); i++)
+            g.fillRect(debug.get(i).x * 5, debug.get(i).y * 5, 5, 5);
+
+    }
 }

src/approach3/parallel/operations/Flood.java

@@ -37,20 +37,16 @@ public class Flood implements Runnable {
         while (!openPoints.isEmpty()) {
 
             if (SharedRessources.getInstance().isFound())
-                return;
+                break;
 
             Point cur
                     = openPoints.poll();
 
 
-
             int x = cur.x;
             int y = cur.y;
 
 
-            if(steps >= SharedRessources.getInstance().getStep(x, y))
-                break;
-
             boolean
                     left = SharedRessources.getInstance().isWall(x - 1, y);
             boolean
@@ -64,7 +60,6 @@ public class Flood implements Runnable {
                     SharedRessources.getInstance().isWall(x - 1, y - 1);
             boolean rightUp =
                     SharedRessources.getInstance().isWall(x + 1, y - 1);
-
             boolean leftDown =
                     SharedRessources.getInstance().isWall(x - 1, y + 1);
             boolean rightDown =
@@ -128,6 +123,7 @@ public class Flood implements Runnable {
             }
 
 
+            if (steps % 18 == 0)
                 SharedRessources
                         .getInstance()
                         .getExecutor()
@@ -143,8 +139,5 @@ public class Flood implements Runnable {
         }
 
 
-        System.out.println("Done flooding.");
-
-
     }
 }

src/approach3/parallel/operations/Trace.java

@@ -40,6 +40,7 @@ public class Trace implements Runnable {
             if (SharedRessources.getInstance().isFound())
                 return;
 
+
             oldX = x0;
             oldY = y0;
 
@@ -60,46 +61,69 @@ public class Trace implements Runnable {
                 y0 += sy;
             }
 
-            step++;
-
             int currentStep
                     = SharedRessources.getInstance().getStep(x0, y0);
 
+            if (step < currentStep) {
+                int dirX = x0 - oldX;
+                int dirY = y0 - oldY;
+
+                SharedRessources.getInstance()
+                        .setData(x0, y0, -dirX, -dirY, step);
+
+            }
+
             if (SharedRessources.getInstance().isWall(x0, y0)) {
 
-                if (step < SharedRessources.getInstance().getStep(oldX - 1, oldY))
+                if (step < SharedRessources.getInstance().getStep(oldX - 1, oldY)) {
                     SharedRessources
                             .getInstance()
                             .getExecutor()
                             .execute(new Flood(oldX - 1, oldY, step));
 
-                if (step < SharedRessources.getInstance().getStep(oldX + 1, oldY))
+                    SharedRessources.getInstance()
+                            .setData(oldX - 1, oldY, 1, 0, step);
+                }
+
+
+                if (step < SharedRessources.getInstance().getStep(oldX + 1, oldY)) {
                     SharedRessources
                             .getInstance()
                             .getExecutor()
                             .execute(new Flood(oldX + 1, oldY, step));
 
-                if (step < SharedRessources.getInstance().getStep(oldX, oldY - 1))
+                    SharedRessources.getInstance()
+                            .setData(oldX + 1, oldY, -1, 0, step);
+                }
+
+                if (step < SharedRessources.getInstance().getStep(oldX, oldY - 1)) {
                     SharedRessources
                             .getInstance()
                             .getExecutor()
                             .execute(new Flood(oldX, oldY - 1, step));
 
-                if (step < SharedRessources.getInstance().getStep(oldX, oldY + 1))
+                    SharedRessources.getInstance()
+                            .setData(oldX, oldY - 1, 0, 1, step);
+
+                }
+
+                if (step < SharedRessources.getInstance().getStep(oldX, oldY + 1)) {
                     SharedRessources
                             .getInstance()
                             .getExecutor()
                             .execute(new Flood(oldX, oldY + 1, step));
 
-                break;
-            } else if (step < currentStep) {
-                int dirX = x0 - oldX;
-                int dirY = y0 - oldY;
-
                     SharedRessources.getInstance()
-                        .setData(x0, y0, dirX, dirY, step);
+                            .setData(oldX, oldY + 1, 0, -1, step);
+
+                }
 
+                break;
             }
+
+
+            step++;
+
         }
 
     }

src/approach3/window/MainWindowApproach3.java

 package approach3.window;
 
+import approach3.misc.MapLoader;
+import approach3.parallel.SharedRessources;
+import approach3.parallel.WallBasedPathfinder;
 import framework.Game;
 
+import javax.imageio.ImageIO;
 import java.awt.*;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
 
 public class MainWindowApproach3 extends Game {
     public MainWindowApproach3(String title, int w, int h) {
         super(title, w, h);
     }
 
+
+    private WallBasedPathfinder pathfinder;
+
     @Override
     public void loadGame() {
 
+        SharedRessources.setMaxCores(4);
+        try {
+            MapLoader.getDefault().load(ImageIO.read(new File("examples/maze1.png")));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        pathfinder = new WallBasedPathfinder();
+
     }
 
+
+    private boolean pressed;
+
     @Override
     public void updateGame() {
 
+        if (isMouseKeyDown(MouseEvent.BUTTON1))
+            SharedRessources.getInstance().setStart(this.getMouseX() / 5, this.getMouseY() / 5);
+
+        if (isMouseKeyDown(MouseEvent.BUTTON3))
+            SharedRessources.getInstance().setEnd(this.getMouseX() / 5, this.getMouseY() / 5);
+
+        if (isKeyDown(KeyEvent.VK_ENTER) && !pressed) {
+            pressed = true;
+            pathfinder.find();
+
+
+            while (!SharedRessources.getInstance().isFound());
+
+            int beginX = SharedRessources.getInstance().getStart().x;
+            int beginY = SharedRessources.getInstance().getStart().y;
+
+            int endX = SharedRessources.getInstance().getEnd().x;
+            int endY = SharedRessources.getInstance().getEnd().y;
+
+
+            SharedRessources.getInstance()
+                    .getExecutor()
+                    .execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            pts = pathfinder.calculatePath(beginX, beginY, endX, endY);
+                        }
+                    });
+
         }
 
+        if (isKeyUp(KeyEvent.VK_ENTER))
+            pressed = false;
+
+
+    }
+
+    ArrayList<Point> pts;
+
     @Override
     public void renderGame(Graphics g) {
+        if (pathfinder == null)
+            return;
 
+        pathfinder.draw(g);
     }
 }