SOLVE WATER PUZZLE TM

21 files changed, 711 insertions, 38 deletions

diff --git a/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPoint.java b/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPoint.java
index ecb3b268..b6497872 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPoint.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPoint.java
@@ -8,10 +8,11 @@ import net.minecraft.block.Block;
 import net.minecraft.util.BlockPos;
 
 import javax.vecmath.Vector2d;
+import java.io.Serializable;
 
 @Data
 @AllArgsConstructor
-public class OffsetPoint implements Cloneable {
+public class OffsetPoint implements Cloneable, Serializable {
     private int x;
     private int y;
     private int z;
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPointSet.java b/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPointSet.java
index c33f7af8..9aea7610 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPointSet.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/dungeon/data/OffsetPointSet.java
@@ -2,11 +2,12 @@ package kr.syeyoung.dungeonsguide.dungeon.data;
 
 import lombok.Data;
 
+import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 
 @Data
-public class OffsetPointSet implements Cloneable{
+public class OffsetPointSet implements Cloneable, Serializable {
     private List<OffsetPoint> offsetPointList = new ArrayList<OffsetPoint>();
 
     @Override
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/dungeon/doorfinder/DoorFinderRegistry.java b/src/main/java/kr/syeyoung/dungeonsguide/dungeon/doorfinder/DoorFinderRegistry.java
index 306b1993..0fb3c89a 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/dungeon/doorfinder/DoorFinderRegistry.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/dungeon/doorfinder/DoorFinderRegistry.java
@@ -8,7 +8,7 @@ public class DoorFinderRegistry {
     private static final Map<Pattern, StartDoorFinder> doorFinders = new HashMap<Pattern, StartDoorFinder>();
 
     static {
-        doorFinders.put(Pattern.compile("The Catacombs F[0-9]"), new CatacombDoorFinder());
+        doorFinders.put(Pattern.compile("The Catacombs (?:F[0-9]|E)"), new CatacombDoorFinder());
     }
 
     public static StartDoorFinder getDoorFinder(String dungeonName) {
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomedit/panes/RoomDataDisplayPane.java b/src/main/java/kr/syeyoung/dungeonsguide/roomedit/panes/RoomDataDisplayPane.java
index 38d57eef..be517e81 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/roomedit/panes/RoomDataDisplayPane.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomedit/panes/RoomDataDisplayPane.java
@@ -76,6 +76,14 @@ public class RoomDataDisplayPane extends MPanel {
         this.setBounds(new Rectangle(5,5,parentWidth-10,parentHeight-10));
     }
 
+    @Override
+    public void keyTyped(char typedChar, int keyCode) {
+        int[][] blocks = dungeonRoom.getDungeonRoomInfo().getBlocks();
+        if (selectedX != -1 && selectedY != -1 && selectedY < blocks.length && selectedX < blocks[0].length) {
+            dungeonRoom.getDungeonRoomInfo().getBlocks()[selectedY][selectedX] = -1;
+        }
+    }
+
     private int lastX;
     private int lastY;
     @Override
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/DefaultRoomProcessor.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/DefaultRoomProcessor.java
deleted file mode 100644
index 596ebb74..00000000
--- a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/DefaultRoomProcessor.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package kr.syeyoung.dungeonsguide.roomprocessor;
-
-import kr.syeyoung.dungeonsguide.dungeon.roomfinder.DungeonRoom;
-
-public class DefaultRoomProcessor implements RoomProcessor {
-
-    public DefaultRoomProcessor(DungeonRoom dungeonRoom) {
-
-    }
-
-    @Override
-    public void tick() {
-
-    }
-
-    @Override
-    public void drawScreen(float partialTicks) {
-
-    }
-
-    public static class Generator implements RoomProcessorGenerator<DefaultRoomProcessor> {
-        @Override
-        public DefaultRoomProcessor createNew(DungeonRoom dungeonRoom) {
-
-            DefaultRoomProcessor defaultRoomProcessor = new DefaultRoomProcessor(dungeonRoom);
-            return defaultRoomProcessor;
-        }
-    }
-}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/GeneralRoomProcessor.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/GeneralRoomProcessor.java
new file mode 100644
index 00000000..f9472791
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/GeneralRoomProcessor.java
@@ -0,0 +1,39 @@
+package kr.syeyoung.dungeonsguide.roomprocessor;
+
+import kr.syeyoung.dungeonsguide.dungeon.roomfinder.DungeonRoom;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.RoomProcessorWaterPuzzle;
+import lombok.Getter;
+import lombok.Setter;
+
+public class GeneralRoomProcessor implements RoomProcessor {
+
+    @Getter
+    @Setter
+    private DungeonRoom dungeonRoom;
+    public GeneralRoomProcessor(DungeonRoom dungeonRoom) {
+        this.dungeonRoom = dungeonRoom;
+    }
+
+    @Override
+    public void tick() {
+
+    }
+
+    @Override
+    public void drawScreen(float partialTicks) {
+
+    }
+
+    @Override
+    public void drawWorld(float partialTicks) {
+
+    }
+
+    public static class Generator implements RoomProcessorGenerator<GeneralRoomProcessor> {
+        @Override
+        public GeneralRoomProcessor createNew(DungeonRoom dungeonRoom) {
+            GeneralRoomProcessor defaultRoomProcessor = new GeneralRoomProcessor(dungeonRoom);
+            return defaultRoomProcessor;
+        }
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/ProcessorFactory.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/ProcessorFactory.java
index 3f65c642..23976fbd 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/ProcessorFactory.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/ProcessorFactory.java
@@ -1,6 +1,7 @@
 package kr.syeyoung.dungeonsguide.roomprocessor;
 
 import kr.syeyoung.dungeonsguide.dungeon.roomfinder.DungeonRoom;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.RoomProcessorWaterPuzzle;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -22,7 +23,8 @@ public class ProcessorFactory {
     }
 
     static {
-        registerRoomProcessor("default", new DefaultRoomProcessor.Generator());
+        registerRoomProcessor("default", new GeneralRoomProcessor.Generator());
         registerRoomProcessor("puzzle_blaze_solver", new RoomProcessorBlazeSolver.Generator());
+        registerRoomProcessor("puzzle_water_solver", new RoomProcessorWaterPuzzle.Generator());
     }
 }
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessor.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessor.java
index ed8a89f7..4498811a 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessor.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessor.java
@@ -5,4 +5,5 @@ import kr.syeyoung.dungeonsguide.dungeon.roomfinder.DungeonRoom;
 public interface RoomProcessor {
     void tick();
     void drawScreen(float partialTicks);
+    void drawWorld(float partialTicks);
 }
\ No newline at end of file
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessorBlazeSolver.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessorBlazeSolver.java
index ec1ed164..54f09010 100644
--- a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessorBlazeSolver.java
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/RoomProcessorBlazeSolver.java
@@ -15,20 +15,20 @@ import net.minecraft.util.Vec3;
 import net.minecraft.world.World;
 import org.jetbrains.annotations.Nullable;
 
+import java.awt.*;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
-public class RoomProcessorBlazeSolver implements RoomProcessor {
+public class RoomProcessorBlazeSolver extends GeneralRoomProcessor {
 
-    private DungeonRoom dungeonRoom;
     private boolean highToLow = false;
 
     private List<EntityArmorStand> entityList = new ArrayList<EntityArmorStand>();
     private EntityArmorStand next;
     public RoomProcessorBlazeSolver(DungeonRoom dungeonRoom) {
-        this.dungeonRoom = dungeonRoom;
+        super(dungeonRoom);
         Object highToLow = dungeonRoom.getDungeonRoomInfo().getProperties().get("order");
         if (highToLow == null) this.highToLow = false;
         else this.highToLow = (Boolean) highToLow;
@@ -36,6 +36,9 @@ public class RoomProcessorBlazeSolver implements RoomProcessor {
 
     @Override
     public void tick() {
+        super.tick();
+
+        DungeonRoom dungeonRoom = getDungeonRoom();
         World w = dungeonRoom.getContext().getWorld();
         final BlockPos low = dungeonRoom.getMin();
         final BlockPos high = dungeonRoom.getMax();
@@ -53,7 +56,7 @@ public class RoomProcessorBlazeSolver implements RoomProcessor {
         for (EntityArmorStand ea : entityList) {
             String name = ea.getName();
             String colorGone = TextUtils.stripColor(name);
-            String health2 = colorGone.split("/")[1];
+            String health2 = TextUtils.keepIntegerCharactersOnly(colorGone.split("/")[1]);
             try {
                 int heal = Integer.parseInt(health2);
                 if (highToLow && heal > health) {
@@ -70,11 +73,14 @@ public class RoomProcessorBlazeSolver implements RoomProcessor {
         next = semi_target;
     }
 
+
     @Override
-    public void drawScreen(float partialTicks) {
+    public void drawWorld(float partialTicks) {
+        super.drawWorld(partialTicks);
         if (next == null) return;
         Vec3 pos = next.getPositionEyes(partialTicks);
         RenderUtils.drawTextAtWorld("NEXT", (float)pos.xCoord, (float)pos.yCoord, (float)pos.zCoord, 0xFFFF0000, 3, true, false, partialTicks);
+        RenderUtils.highlightBlock(next.getPosition(), new Color(0,255,0,50), partialTicks);
     }
 
     public static class Generator implements RoomProcessorGenerator<RoomProcessorBlazeSolver> {
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/RoomProcessorWaterPuzzle.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/RoomProcessorWaterPuzzle.java
new file mode 100644
index 00000000..5cb5502a
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/RoomProcessorWaterPuzzle.java
@@ -0,0 +1,96 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+import kr.syeyoung.dungeonsguide.dungeon.data.OffsetPoint;
+import kr.syeyoung.dungeonsguide.dungeon.data.OffsetPointSet;
+import kr.syeyoung.dungeonsguide.dungeon.roomfinder.DungeonRoom;
+import kr.syeyoung.dungeonsguide.roomprocessor.GeneralRoomProcessor;
+import kr.syeyoung.dungeonsguide.roomprocessor.RoomProcessor;
+import kr.syeyoung.dungeonsguide.roomprocessor.RoomProcessorBlazeSolver;
+import kr.syeyoung.dungeonsguide.roomprocessor.RoomProcessorGenerator;
+import kr.syeyoung.dungeonsguide.utils.RenderUtils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.util.BlockPos;
+
+import java.awt.*;
+
+public class RoomProcessorWaterPuzzle extends GeneralRoomProcessor {
+
+    private boolean argumentsFulfilled = false;
+
+    private WaterBoard waterBoard;
+    private OffsetPointSet doorsClosed;
+    private OffsetPointSet levers;
+    private OffsetPointSet frontBoard;
+    private OffsetPointSet backBoard;
+    private OffsetPoint water_lever;
+
+    public RoomProcessorWaterPuzzle(DungeonRoom dungeonRoom) {
+        super(dungeonRoom);
+        frontBoard = (OffsetPointSet) dungeonRoom.getDungeonRoomInfo().getProperties().get("front");
+        backBoard = (OffsetPointSet) dungeonRoom.getDungeonRoomInfo().getProperties().get("back");
+        levers = (OffsetPointSet) dungeonRoom.getDungeonRoomInfo().getProperties().get("levers");
+        doorsClosed = (OffsetPointSet) dungeonRoom.getDungeonRoomInfo().getProperties().get("doors");
+        water_lever = (OffsetPoint) dungeonRoom.getDungeonRoomInfo().getProperties().get("water-lever");
+
+        if (frontBoard == null || backBoard == null || levers == null || doorsClosed == null ||water_lever == null) {
+           argumentsFulfilled = false;
+        } else {
+            argumentsFulfilled = true;
+
+            try {
+                waterBoard = new WaterBoard(this, frontBoard, backBoard, levers, doorsClosed, water_lever);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        if (!argumentsFulfilled) return;
+        try {
+            waterBoard.tick();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void drawScreen(float partialTicks) {
+        super.drawScreen(partialTicks);
+        if (!argumentsFulfilled) return;
+        FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
+        fr.drawString("To Open: "+waterBoard.getReqOpen(),0,200, 0xFFFFFF);
+        fr.drawString("Target: "+waterBoard.getTarget2(),0,200, 0xFFFFFF);
+    }
+
+    @Override
+    public void drawWorld(float partialTicks) {
+        super.drawWorld(partialTicks);
+        if (!argumentsFulfilled) return;
+        BlockPos target = waterBoard.getTarget();
+        if (target != null) {
+            RenderUtils.highlightBlock(target, new Color(0,255,255,255), partialTicks);
+        }
+        Route route = waterBoard.getCurrentRoute();
+        if (route != null) {
+            for (WaterCondition condition : route.getConditionList()) {
+                SwitchData switchData = waterBoard.getValidSwitches().get(condition.getBlockId());
+                if (switchData.getCurrentState() != condition.isRequiredState()) {
+                    RenderUtils.highlightBlock(switchData.getSwitchLoc(), new Color(0,255,0,50), partialTicks);
+                    RenderUtils.drawTextAtWorld(condition.isRequiredState() ? "on":"off",switchData.getSwitchLoc().getX(), switchData.getSwitchLoc().getY(), switchData.getSwitchLoc().getZ(),  0xFF000000,1.0f, false, false, partialTicks);
+                }
+            }
+        }
+    }
+
+    public static class Generator implements RoomProcessorGenerator<RoomProcessorWaterPuzzle> {
+        @Override
+        public RoomProcessorWaterPuzzle createNew(DungeonRoom dungeonRoom) {
+            RoomProcessorWaterPuzzle defaultRoomProcessor = new RoomProcessorWaterPuzzle(dungeonRoom);
+            return defaultRoomProcessor;
+        }
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/Route.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/Route.java
new file mode 100644
index 00000000..cdff0477
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/Route.java
@@ -0,0 +1,25 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+import lombok.Data;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+@Data
+public class Route implements Cloneable {
+    private Set<WaterNode> nodes = new LinkedHashSet<WaterNode>();
+    private Set<WaterCondition> conditionList = new HashSet<WaterCondition>();
+    private int x, y;
+
+
+    @Override
+    protected Route clone() {
+        Route r = new Route();
+        r.getNodes().addAll(nodes);
+        r.getConditionList().addAll(conditionList);
+        r.x = x;
+        r.y = y;
+        return r;
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/SwitchData.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/SwitchData.java
new file mode 100644
index 00000000..79d0060b
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/SwitchData.java
@@ -0,0 +1,25 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+import kr.syeyoung.dungeonsguide.DungeonsGuide;
+import kr.syeyoung.dungeonsguide.SkyblockStatus;
+import kr.syeyoung.dungeonsguide.dungeon.roomfinder.DungeonRoom;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import net.minecraft.block.BlockLever;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+@Data
+@AllArgsConstructor
+public class SwitchData {
+    private BlockPos switchLoc;
+    private BlockPos blockLoc;
+
+    private String blockId;
+
+    public boolean getCurrentState() {
+        BlockPos switch2 = getSwitchLoc();
+        World w=  DungeonsGuide.getDungeonsGuide().getSkyblockStatus().getContext().getWorld();
+        return w.getBlockState(switch2).getValue(BlockLever.POWERED);
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterBoard.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterBoard.java
new file mode 100644
index 00000000..f0f30f0a
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterBoard.java
@@ -0,0 +1,263 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+import com.google.common.collect.Sets;
+import kr.syeyoung.dungeonsguide.dungeon.data.OffsetPoint;
+import kr.syeyoung.dungeonsguide.dungeon.data.OffsetPointSet;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.nodes.*;
+import lombok.Getter;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockLever;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.world.World;
+
+import javax.vecmath.Vector2d;
+import java.awt.*;
+import java.util.*;
+import java.util.List;
+
+public class WaterBoard {
+    WaterNode[][] board;
+    RoomProcessorWaterPuzzle waterPuzzle;
+
+    private OffsetPointSet frontPlate;
+    private OffsetPointSet backPlate;
+    private OffsetPointSet levers;
+    private OffsetPointSet doors;
+    private OffsetPoint lever;
+
+    @Getter
+    private List<SwitchData> switchData = new ArrayList<SwitchData>();
+    @Getter
+    private Map<String, SwitchData> validSwitches = new HashMap<String, SwitchData>();
+
+    private WaterNodeStart waterNodeStart;
+    private Map<String, WaterNodeEnd> waterNodeEndMap = new HashMap<String, WaterNodeEnd>();
+
+    @Getter
+    private Set<String> reqOpen = new HashSet<String>();
+
+    @Getter
+    private Route currentRoute;
+    @Getter
+    private BlockPos target;
+    @Getter
+    private String target2;
+
+    public WaterBoard(RoomProcessorWaterPuzzle roomProcessorWaterPuzzle, OffsetPointSet frontPlate, OffsetPointSet backPlate, OffsetPointSet levers, OffsetPointSet doors, OffsetPoint leverMain) {
+        this.waterPuzzle = roomProcessorWaterPuzzle;
+        this.frontPlate = frontPlate;
+        this.backPlate = backPlate;
+        this.levers = levers;
+        this.doors = doors;
+        this.lever = leverMain;
+
+        buildLeverStates();
+        buildNodes();
+    }
+
+    private void buildLeverStates(){
+        for (OffsetPoint offsetPoint : levers.getOffsetPointList()) {
+            if (offsetPoint.getBlock(waterPuzzle.getDungeonRoom()) == Blocks.lever){
+                BlockPos pos = offsetPoint.getBlockPos(waterPuzzle.getDungeonRoom());
+                World w=  waterPuzzle.getDungeonRoom().getContext().getWorld();
+                BlockLever.EnumOrientation enumOrientation = w.getBlockState(pos).getValue(BlockLever.FACING);
+                EnumFacing enumFacing = enumOrientation.getFacing();
+                BlockPos newPos = pos.add(enumFacing.getDirectionVec());
+
+                int id = Block.getIdFromBlock(w.getChunkFromBlockCoords(newPos).getBlock(newPos));
+                int data = w.getChunkFromBlockCoords(newPos).getBlockMetadata(newPos);
+
+                SwitchData sw;
+                switchData.add(sw = new SwitchData(pos,newPos,id+":"+data));
+                validSwitches.put(id+":"+data, sw);
+            }
+        }
+        SwitchData sw;
+        switchData.add(sw = new SwitchData(lever.getBlockPos(waterPuzzle.getDungeonRoom()),lever.getBlockPos(waterPuzzle.getDungeonRoom()).add(0,-1,0),"mainStream"));
+        validSwitches.put("mainStream", sw);
+    }
+
+    public void tick() {
+        Set<String> doorsToOpen = new HashSet<String>();
+        for (OffsetPoint offsetPoint : doors.getOffsetPointList()) {
+            Block b =offsetPoint.getBlock(waterPuzzle.getDungeonRoom());
+            if (b != Blocks.air) {
+                doorsToOpen.add(Block.getIdFromBlock(b)+":"+offsetPoint.getData(waterPuzzle.getDungeonRoom()));
+            }
+        }
+
+        if (!(reqOpen.containsAll(doorsToOpen) && doorsToOpen.containsAll(reqOpen))) {
+            reqOpen = doorsToOpen;
+            if (doorsToOpen.size() != 0) {
+                WaterNodeEnd end = waterNodeEndMap.get(doorsToOpen.iterator().next());
+                target = end.getBlockPos();
+                target2 = end.getResultId();
+                currentRoute = pathFind(end);
+            }
+        }
+    }
+
+    private final Set<Point> possibleDir = Sets.newHashSet(new Point(0,-1), new Point(1,0), new Point(-1, 0));
+    public Route pathFind(WaterNodeEnd endNode) {
+        Route start = new Route();
+        start.setX(endNode.getX());
+        start.setY(endNode.getY());
+        start.getNodes().add(endNode);
+        Queue<Route> routes = new LinkedList<Route>();
+        routes.add(start);
+        List<Route> reachedStart = new ArrayList<Route>();
+        while (!routes.isEmpty()) {
+            Route r2 = routes.poll();
+            int x = r2.getX();
+            int y = r2.getY();
+            int size = 0;
+            for (Point vec:possibleDir) {
+                WaterNode node = getNodeAt(x + vec.x, y + vec.y);
+                if (node == null) continue;
+                if (r2.getNodes().contains(node)) continue;;
+                if (!node.canWaterGoThrough()) continue;
+                size ++;
+                Route r = r2.clone();
+                r.getNodes().add(node);
+                r.getConditionList().add(node.getCondition());
+                r.setX(node.getX());
+                r.setY(node.getY());
+
+                WaterNode void2 = getNodeAt(r.getX(), r.getY() + 1);
+                if ((void2 == null || void2.getCondition() == null) && !r.getNodes().contains(void2)) {
+                    continue;
+                }
+
+                if (checkContradiction(r.getConditionList())) {
+                    continue;
+                }
+
+                if (node instanceof WaterNodeStart) {
+                    reachedStart.add(r);
+                } else {
+                    routes.add(r);
+                }
+            }
+        }
+        Iterator<Route> routeIter = reachedStart.iterator();
+        while (routeIter.hasNext()) {
+            Route route = routeIter.next();
+
+            addRouteConditions(route);
+            if (checkContradiction(route.getConditionList()))
+                routeIter.remove();
+        }
+
+        return reachedStart.get(0);
+    }
+
+    public void addRouteConditions(Route r) {
+        int prevY = 0;
+        int startX = -1;
+        for (WaterNode node : r.getNodes()) {
+            int currY = node.getY();
+            if (currY != prevY) {
+                if (startX != -1) {
+                    int offset = node.getX() - startX;
+                    if (offset != 0) {
+                        int start = startX + (offset > 0 ? 1 : -1);
+                        int end = node.getX() + offset;
+                        int y = node.getY() + 2;
+                        int y2 = node.getY() + 1;
+
+                        for (int x = start; (start < end) ? (x <= end) : (x >= end); x += (start < end) ?1:-1){
+                            WaterNode node2 = getNodeAt(x, y2);
+                            if (node2 == null || !node2.canWaterGoThrough()) break;
+                            node2 = getNodeAt(x, y);
+                            if (node2 == null || node2.getCondition() == null) {
+                                r.getConditionList().add(new WaterConditionContradict());
+                                return;
+                            } else {
+                                r.getConditionList().add(node2.getCondition().invert());
+                            }
+                        }
+                    }
+                }
+                startX = node.getX();
+            }
+        }
+    }
+
+    public WaterNode getNodeAt(int x, int y) {
+        if (x < 0 || y < 0) return null;
+        if (x >= board[0].length || y >= board.length) return null;
+        return board[y][x];
+    }
+
+    private void buildNodes() {
+        List<OffsetPoint> frontPoints = frontPlate.getOffsetPointList();
+        List<OffsetPoint> backPoints = backPlate.getOffsetPointList();
+
+        board = new WaterNode[19][25];
+        for (int x = 0; x < 19; x++) {
+            for (int y = 0; y < 25; y++) {
+                OffsetPoint front = frontPoints.get(x *25 +y);
+                OffsetPoint back = backPoints.get(x * 25 +y);
+                int frontId = Block.getIdFromBlock(front.getBlock(waterPuzzle.getDungeonRoom()));
+                int backId = Block.getIdFromBlock(back.getBlock(waterPuzzle.getDungeonRoom()));
+                int frontData = front.getData(waterPuzzle.getDungeonRoom());
+                int backData = back.getData(waterPuzzle.getDungeonRoom());
+                WaterNode node;
+                if (validSwitches.containsKey(backId +":"+backData) && frontId == 0) {
+                    String resId = backId + ":"+backData;
+                    node = new WaterNodeToggleable(resId, isSwitchActive(validSwitches.get(resId)), front.getBlockPos(waterPuzzle.getDungeonRoom()),x,y);
+                } else if (validSwitches.containsKey(frontId +":"+frontData)) {
+                    String resId = frontId +":"+frontData;
+                    node = new WaterNodeToggleable(resId, !isSwitchActive(validSwitches.get(resId)), front.getBlockPos(waterPuzzle.getDungeonRoom()),x,y);
+                } else if (frontId == 0) {
+                    if (y == 24) {
+                        OffsetPoint pos;
+                        if (x != 0) {
+                            pos = frontPoints.get((x-1)*25+y);
+                        } else {
+                            pos = frontPoints.get((x+1) * 25 +y);
+                        }
+
+                        int id = Block.getIdFromBlock(pos.getBlock(waterPuzzle.getDungeonRoom()));
+                        int data= pos.getData(waterPuzzle.getDungeonRoom());
+                        node = new WaterNodeEnd(id+":"+data, front.getBlockPos(waterPuzzle.getDungeonRoom()),x,y);
+                        waterNodeEndMap.put(id+":"+data, (WaterNodeEnd) node);
+                    } else if (y == 0) {
+                        waterNodeStart = (WaterNodeStart) (node = new WaterNodeStart(front.getBlockPos(waterPuzzle.getDungeonRoom()),x,y));
+                    } else {
+                        node = new WaterNodeAir(front.getBlockPos(waterPuzzle.getDungeonRoom()),x,y);
+                    }
+                } else {
+                    node = new WaterNodeWall(front.getBlockPos(waterPuzzle.getDungeonRoom()),x,y);
+                }
+                board[y][x] =node;
+            }
+        }
+    }
+
+    // true if contradiction
+    private boolean checkContradiction(Set<WaterCondition> conditions) {
+        Map<String, Boolean> conditionMap = new HashMap<String, Boolean>();
+        for (WaterCondition condition : conditions) {
+            if (condition instanceof WaterConditionContradict) return true;
+            if (conditionMap.containsKey(condition.getBlockId())) {
+                if (conditionMap.get(condition.getBlockId()) != condition.isRequiredState())
+                    return true;
+            } else {
+                conditionMap.put(condition.getBlockId(), condition.isRequiredState());
+            }
+        }
+        return false;
+    }
+
+    private boolean isSwitchActive(SwitchData switchData) {
+        BlockPos switch2 = switchData.getSwitchLoc();
+        World w=  waterPuzzle.getDungeonRoom().getContext().getWorld();
+        boolean bool = w.getBlockState(switch2).getValue(BlockLever.POWERED);
+        return bool;
+    }
+
+
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterCondition.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterCondition.java
new file mode 100644
index 00000000..26678af3
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterCondition.java
@@ -0,0 +1,15 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class WaterCondition {
+    private String blockId;
+    private boolean requiredState;
+
+    public WaterCondition invert() {
+        return new WaterCondition(blockId, !requiredState);
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterConditionContradict.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterConditionContradict.java
new file mode 100644
index 00000000..64339655
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterConditionContradict.java
@@ -0,0 +1,7 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+public class WaterConditionContradict extends WaterCondition {
+    public WaterConditionContradict() {
+        super("contradict", true);
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterNode.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterNode.java
new file mode 100644
index 00000000..efd872bc
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/WaterNode.java
@@ -0,0 +1,18 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle;
+
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+public interface WaterNode {
+    boolean canWaterGoThrough();
+
+    // condition for water go
+    WaterCondition getCondition();
+
+    boolean isWaterFilled(World w);
+
+    BlockPos getBlockPos();
+
+    int getX();
+    int getY();
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeAir.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeAir.java
new file mode 100644
index 00000000..d22fde2e
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeAir.java
@@ -0,0 +1,37 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.nodes;
+
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterCondition;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterNode;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+@Data
+@AllArgsConstructor
+public class WaterNodeAir implements WaterNode {
+    BlockPos blockPos;
+    @Override
+    public boolean canWaterGoThrough() {
+        return true;
+    }
+
+    @Override
+    public WaterCondition getCondition() {
+        return null;
+    }
+
+    @Override
+    public boolean isWaterFilled(World w) {
+        Block b = w.getChunkFromBlockCoords(blockPos).getBlock(blockPos);
+        return b == Blocks.water || b == Blocks.flowing_water;
+    }
+
+    public BlockPos getBlockPos() {
+        return blockPos;
+    }
+
+    private int x,y;
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeEnd.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeEnd.java
new file mode 100644
index 00000000..1cc079e2
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeEnd.java
@@ -0,0 +1,38 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.nodes;
+
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterCondition;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterNode;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+@Data
+@AllArgsConstructor
+public class WaterNodeEnd implements WaterNode {
+    private String resultId;
+    BlockPos blockPos;
+
+    @Override
+    public boolean canWaterGoThrough() {
+        return true;
+    }
+
+    @Override
+    public WaterCondition getCondition() {
+        return null;
+    }
+
+    @Override
+    public boolean isWaterFilled(World w) {
+        Block b = w.getChunkFromBlockCoords(blockPos).getBlock(blockPos);
+        return b == Blocks.water || b == Blocks.flowing_water;
+    }
+
+    public BlockPos getBlockPos() {
+        return blockPos;
+    }
+    private int x,y;
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeStart.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeStart.java
new file mode 100644
index 00000000..11661fcc
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeStart.java
@@ -0,0 +1,39 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.nodes;
+
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterCondition;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterNode;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+@Data
+@AllArgsConstructor
+public class WaterNodeStart implements WaterNode {
+
+    BlockPos blockPos;
+
+    @Override
+    public boolean canWaterGoThrough() {
+        return true;
+    }
+
+    @Override
+    public WaterCondition getCondition() {
+        return new WaterCondition("mainStream", true);
+    }
+
+    @Override
+    public boolean isWaterFilled(World w) {
+        Block b = w.getChunkFromBlockCoords(blockPos).getBlock(blockPos);
+        return b == Blocks.water || b == Blocks.flowing_water;
+    }
+
+
+    public BlockPos getBlockPos() {
+        return blockPos;
+    }
+    private int x,y;
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeToggleable.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeToggleable.java
new file mode 100644
index 00000000..cc714129
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeToggleable.java
@@ -0,0 +1,42 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.nodes;
+
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterCondition;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterNode;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+@Data
+@AllArgsConstructor
+public class WaterNodeToggleable implements WaterNode {
+    private String blockId;
+    private boolean invert;
+
+    BlockPos blockPos;
+
+    @Override
+    public boolean canWaterGoThrough() {
+        return true;
+    }
+
+    @Override
+    public WaterCondition getCondition() {
+        return new WaterCondition(blockId, invert);
+    }
+
+
+    @Override
+    public boolean isWaterFilled(World w) {
+        Block b = w.getChunkFromBlockCoords(blockPos).getBlock(blockPos);
+        return b == Blocks.water || b == Blocks.flowing_water;
+    }
+    private int x,y;
+
+
+    public BlockPos getBlockPos() {
+        return blockPos;
+    }
+}
diff --git a/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeWall.java b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeWall.java
new file mode 100644
index 00000000..18260adf
--- /dev/null
+++ b/src/main/java/kr/syeyoung/dungeonsguide/roomprocessor/waterpuzzle/nodes/WaterNodeWall.java
@@ -0,0 +1,39 @@
+package kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.nodes;
+
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterCondition;
+import kr.syeyoung.dungeonsguide.roomprocessor.waterpuzzle.WaterNode;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+@Data
+@AllArgsConstructor
+public class WaterNodeWall implements WaterNode {
+
+    BlockPos blockPos;
+    @Override
+    public boolean canWaterGoThrough() {
+        return false;
+    }
+
+    @Override
+    public WaterCondition getCondition() {
+        return null;
+    }
+
+
+    @Override
+    public boolean isWaterFilled(World w) {
+        Block b = w.getChunkFromBlockCoords(blockPos).getBlock(blockPos);
+        return b == Blocks.water || b == Blocks.flowing_water;
+    }
+
+    private int x,y;
+
+    public BlockPos getBlockPos() {
+        return blockPos;
+    }
+}