Maze

Normand Briere

2019-11-17 cb37a129d1adb403019c96e798e86e2da9667f15

Maze

 GroupEditor.java
..
..
@@ -2052,6 +2052,8 @@
2052
2052
         }
2053
2053
                 
2054
2054
 		menu.add("-");
2055
+		mazeItem = menu.add(new MenuItem("Maze"));
2056
+		mazeItem.addActionListener(this);
2055
2057
 		parseverticesItem = menu.add(new MenuItem("Multiplicity"));
2056
2058
 		parseverticesItem.addActionListener(this);
2057
2059
 		textureFieldItem = menu.add(new MenuItem("Texture Field"));
..
..
@@ -2247,6 +2249,111 @@
2247
2249
             elem.openEditWindow(this, newWindow); //, false);
2248
2250
             System.out.println("edit : " + elem);
2249
2251
             elem.editWindow.refreshContents(true); // ? new
2252
+    }
2253
+
2254
+    private void GenerateMaze()
2255
+    {
2256
+        if (group.selection.size() == 4)
2257
+        {
2258
+               final double scaleX = SelectionSizeX();
2259
+               final double scaleZ = SelectionSizeZ();
2260
+               
2261
+               final cGroup mazeGroup = new cGroup("Maze");
2262
+               
2263
+               final int dim = 15;
2264
+                
2265
+               Maze maze = new Maze(dim, dim);
2266
+               
2267
+               maze.display(); // console
2268
+               
2269
+               maze.Display(new Maze.Parse()
2270
+               {
2271
+                   public void Tile(int i, int j, boolean north, boolean east, boolean south, boolean west)
2272
+                   {
2273
+                       if ((i == 0 || i == dim-1) && j == dim/2)
2274
+                       {
2275
+                           return;
2276
+                       }
2277
+                       
2278
+                       int v = 0;
2279
+                       if (north)
2280
+                       {
2281
+                            cGroup n = new cGroup("" + i + "," + j);
2282
+                            n.Translate(-j * scaleX, 0, i * scaleZ);
2283
+                            n.add(group.selection.get(0));
2284
+                            mazeGroup.add(n);
2285
+                       }
2286
+                       if (east)
2287
+                       {
2288
+                            cGroup n = new cGroup("" + i + "," + j);
2289
+                            n.Translate(-j * scaleX, 0, i * scaleZ);
2290
+                            n.add(group.selection.get(1));
2291
+                            mazeGroup.add(n);
2292
+                       }
2293
+                       if (south)
2294
+                       {
2295
+                            cGroup n = new cGroup("" + i + "," + j);
2296
+                            n.Translate(-j * scaleX, 0, i * scaleZ);
2297
+                            n.add(group.selection.get(2));
2298
+                            mazeGroup.add(n);
2299
+                       }
2300
+                       if (west)
2301
+                       {
2302
+                            cGroup n = new cGroup("" + i + "," + j);
2303
+                            n.Translate(-j * scaleX, 0, i * scaleZ);
2304
+                            n.add(group.selection.get(3));
2305
+                            mazeGroup.add(n);
2306
+                       }
2307
+                   }
2308
+               }
2309
+               );
2310
+               
2311
+               makeSomething(mazeGroup);
2312
+        }
2313
+    }
2314
+
2315
+    private double SelectionSize()
2316
+    {
2317
+        cVector bbmin = new cVector();
2318
+        cVector bbmax = new cVector();
2319
+        
2320
+        group.selection.getBounds(bbmin, bbmax, true);
2321
+        
2322
+        double dx = bbmax.x - bbmin.x;
2323
+        //double dy = bbmax.y - bbmin.y;
2324
+        double dz = bbmax.z - bbmin.z;
2325
+        
2326
+        return Math.sqrt(dx*dx /*+ dy*dy*/ + dz*dz);
2327
+    }
2328
+        
2329
+    private double SelectionSizeX()
2330
+    {
2331
+        cVector bbmin = new cVector();
2332
+        cVector bbmax = new cVector();
2333
+        
2334
+        group.selection.getBounds(bbmin, bbmax, true);
2335
+        
2336
+        return bbmax.x - bbmin.x;
2337
+    }
2338
+        
2339
+    private double SelectionSizeY()
2340
+    {
2341
+        cVector bbmin = new cVector();
2342
+        cVector bbmax = new cVector();
2343
+        
2344
+        group.selection.getBounds(bbmin, bbmax, true);
2345
+        
2346
+        return bbmax.y - bbmin.y;
2347
+    }
2348
+        
2349
+    private double SelectionSizeZ()
2350
+    {
2351
+        cVector bbmin = new cVector();
2352
+        cVector bbmax = new cVector();
2353
+        
2354
+        group.selection.getBounds(bbmin, bbmax, true);
2355
+        
2356
+        return bbmax.z - bbmin.z;
2250
2357
     }
2251
2358
         
2252
2359
     /**
..
..
@@ -3590,6 +3697,10 @@
3590
3697
                 {
3591
3698
 			ReverseNormals();
3592
3699
 		} else
3700
+		if (source == mazeItem)
3701
+                {
3702
+                        GenerateMaze();
3703
+		} else
3593
3704
 		if (source == parseverticesItem)
3594
3705
                 {
3595
3706
 			ParseVertices();
..
..
@@ -4874,29 +4985,13 @@
4874
4985
             if (group.selection.size() == 0)
4875
4986
                 return;
4876
4987
             
4877
-            cVector bbmin = new cVector();
4878
-            cVector bbmax = new cVector();
4879
-            
4880
-            group.selection.get(0).getBounds(bbmin, bbmax, true);
4881
-            
4882
-            double dx = bbmax.x - bbmin.x;
4883
-            double dy = bbmax.y - bbmin.y;
4884
-            double dz = bbmax.z - bbmin.z;
4885
-            
4886
-            double scale = Math.sqrt(dx*dx + dy*dy + dz*dz);
4988
+            double scale = SelectionSize();
4887
4989
             
4888
4990
             for (int i=0; i<group.selection.size(); i++)
4889
4991
             {
4890
4992
 		Object3D obj = group.selection.get(i);
4891
4993
                 
4892
-                if (obj.toParent == null)
4893
-                {
4894
-                    obj.toParent = LA.newMatrix();
4895
-                    obj.fromParent = LA.newMatrix();
4896
-                }
4897
-                
4898
-                LA.matTranslate(obj.toParent, i * scale, 0, 0);
4899
-                LA.matTranslateInv(obj.fromParent, -i * scale, 0, 0);
4994
+                obj.Translate(i * scale, 0, 0);
4900
4995
             }
4901
4996
             
4902
4997
             Globals.lighttouched = true;
..
..
@@ -6429,8 +6524,9 @@
6429
6524
 	private MenuItem unstripifyItem;
6430
6525
 	private MenuItem trimItem;
6431
6526
 	private MenuItem untrimItem;
6432
-
6433
6527
         private MenuItem clearColorsItem;
6528
+        
6529
+	private MenuItem mazeItem;
6434
6530
 	private MenuItem parseverticesItem;
6435
6531
 	private MenuItem alignItem;
6436
6532
 	private MenuItem mirrorItem;
 Maze.java
..
..
@@ -0,0 +1,129 @@
1
+
2
+import java.util.Collections;
3
+import java.util.Arrays;
4
+
5
+/*
6
+ * recursive backtracking algorithm
7
+ * shamelessly borrowed from the ruby at
8
+ * http://weblog.jamisbuck.org/2010/12/27/maze-generation-recursive-backtracking
9
+ */
10
+public class Maze
11
+{
12
+    public interface Parse
13
+    {
14
+        void Tile(int i, int j, boolean north, boolean east, boolean south, boolean west);
15
+    };
16
+    
17
+    private int dimx;
18
+    private int dimy;
19
+    private byte[][] maze;
20
+
21
+    public Maze(int x, int y)
22
+    {
23
+        this.dimx = x;
24
+        this.dimy = y;
25
+        maze = new byte[this.dimx][this.dimy];
26
+        generateMaze(0, 0);
27
+    }
28
+
29
+    public void Display(Parse p)
30
+    {
31
+        for (int j = 0; j < dimy; j++)
32
+        {
33
+            for (int i = 0; i < dimx; i++)
34
+            {
35
+                boolean n = (maze[i][j] & 1) == 0;
36
+                boolean e = true;
37
+                if (i < dimx-1)
38
+                    e = (maze[i+1][j] & 8) == 0;
39
+                boolean w = (maze[i][j] & 8) == 0;
40
+                boolean s = true;
41
+                if (j < dimy-1)
42
+                    s = (maze[i][j+1] & 1) == 0;
43
+                p.Tile(i, j, n, e, s, w);
44
+            }
45
+        }
46
+    }
47
+    
48
+    public void display()
49
+    {
50
+        for (int j = 0; j < dimy; j++)
51
+        {
52
+            // draw the north edge
53
+            for (int i = 0; i < dimx; i++)
54
+            {
55
+                System.out.print((maze[i][j] & 1) == 0 ? "+---" : "+   ");
56
+            }
57
+            System.out.println("+");
58
+            // draw the west edge
59
+            for (int i = 0; i < dimx; i++)
60
+            {
61
+                System.out.print((maze[i][j] & 8) == 0 ? "|   " : "    ");
62
+            }
63
+            System.out.println("|");
64
+        }
65
+        
66
+        // draw the bottom line
67
+        for (int j = 0; j < dimx; j++)
68
+        {
69
+            System.out.print("+---");
70
+        }
71
+        System.out.println("+");
72
+    }
73
+
74
+    private void generateMaze(int cx, int cy)
75
+    {
76
+        DIR[] dirs = DIR.values();
77
+        Collections.shuffle(Arrays.asList(dirs)); // Works because of elementData = collection.toArray() in ArrayList constructor.
78
+        for (DIR dir : dirs)
79
+        {
80
+            int nx = cx + dir.dx;
81
+            int ny = cy + dir.dy;
82
+            if (between(nx, dimx) && between(ny, dimy) && (maze[nx][ny] == 0))
83
+            {
84
+                maze[cx][cy] |= dir.bit;
85
+                maze[nx][ny] |= dir.opposite.bit;
86
+                generateMaze(nx, ny);
87
+            }
88
+        }
89
+    }
90
+
91
+    private static boolean between(int v, int upper)
92
+    {
93
+        return (v >= 0) && (v < upper);
94
+    }
95
+
96
+    private enum DIR
97
+    {
98
+        N(1, 0, -1), E(2, 1, 0), S(4, 0, 1), W(8, -1, 0);
99
+        
100
+        private final int bit;
101
+        private final int dx;
102
+        private final int dy;
103
+        private DIR opposite;
104
+
105
+        // use the static initializer to resolve forward references
106
+        static
107
+        {
108
+            N.opposite = S;
109
+            S.opposite = N;
110
+            E.opposite = W;
111
+            W.opposite = E;
112
+        }
113
+
114
+        private DIR(int bit, int dx, int dy)
115
+        {
116
+            this.bit = bit;
117
+            this.dx = dx;
118
+            this.dy = dy;
119
+        }
120
+    };
121
+
122
+    public static void main(String[] args)
123
+    {
124
+        int x = args.length >= 1 ? (Integer.parseInt(args[0])) : 3;
125
+        int y = args.length == 2 ? (Integer.parseInt(args[1])) : 3;
126
+        Maze maze = new Maze(x, y);
127
+        maze.display();
128
+    }
129
+}
 ObjEditor.java
..
..
@@ -563,7 +563,7 @@
563
563
 //                }
564
564
                 cameraView.transformMode = objectTabbedPane.getSelectedIndex() == transformTabIndex;
565
565
                 
566
-                if (copy.selection.size() == 1)
566
+                if (copy.selection.size() == 1 && objectTabbedPane.getSelectedIndex() > 1) // Not backgrounds and objects
567
567
                 {
568
568
                     copy.selection.get(0).tabIndex = objectTabbedPane.getSelectedIndex() + 1;
569
569
                 }
 Object3D.java
..
..
@@ -6957,8 +6957,8 @@
6957
6957
 
6958
6958
         //javax.media.opengl.GL gl = display.GetGL();
6959
6959
 
6960
-        if (CameraPane.BOXMODE && //!Link2Support()) //
6961
-                                !selected) // || CameraPane.movingcamera)
6960
+        if (CameraPane.BOXMODE && !Link2Support()) //
6961
+                                //!selected) // || CameraPane.movingcamera)
6962
6962
         {
6963
6963
             int fc = bRep.FaceCount();
6964
6964
             int vc = bRep.VertexCount();
..
..
@@ -9266,5 +9266,17 @@
9266
9266
 	return -1;
9267
9267
     }
9268
9268
      */
9269
+    
9270
+    void Translate(double x, double y, double z)
9271
+    {
9272
+        if (toParent == null)
9273
+        {
9274
+            toParent = LA.newMatrix();
9275
+            fromParent = LA.newMatrix();
9276
+        }
9277
+        
9278
+        LA.matTranslate(toParent, x, y, z);
9279
+        LA.matTranslateInv(fromParent, -x, -y, -z);
9280
+    }
9269
9281
 }
9270
9282