7 files changed, 245 insertions, 43 deletions

@@ -0,0 +1,77 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event;
+
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.Layer;
+import com.fourisland.fourpuzzle.gamestate.mapview.Map;
+import java.awt.Point;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ *
+ * @author hatkirby
+ */
+public final class ImmutableEvent
+{
+    final Event ev;
+    public ImmutableEvent(Event ev)
+    {
+        this.ev = ev;
+    }
+
+    public String getLabel()
+    {
+        return new String(ev.getLabel());
+    }
+
+    public Point getLocation()
+    {
+        return new Point(ev.getLocation());
+    }
+
+    public Direction getDirection()
+    {
+        return ev.getDirection();
+    }
+
+    public boolean isMoving()
+    {
+        return ev.isMoving();
+    }
+
+    public Layer getLayer()
+    {
+        return ev.getLayer();
+    }
+
+    public boolean isOccupyingSpace(int x, int y)
+    {
+        return ev.isOccupyingSpace(x, y);
+    }
+
+    public List<Direction> getLegalMoves()
+    {
+        return Collections.unmodifiableList(ev.getLegalMoves());
+    }
+
+    public int getAnimationStep()
+    {
+        return ev.getAnimationStep();
+    }
+
+    public Map getParentMap()
+    {
+        return ev.getParentMap();
+    }
+
+    public MoveSpeed getMoveSpeed()
+    {
+        return ev.getMoveSpeed();
+    }
+
+}
@@ -99,23 +99,15 @@ public class LayerEvent extends AbstractEvent implements Event {
     
     public void startMoving()
     {
-        Direction toMove = getPossibleEvent().getMovement().nextMovement();
+        Direction toMove = getPossibleEvent().getMovement().nextMovement(new ImmutableEvent(this));
         
         if (toMove != null)
         {
-            startMoving(toMove);
-        }
-    }
-    
-    @Override
-    public boolean startMoving(Direction toMove)
-    {
-        if (!(getPossibleEvent().getGraphic() instanceof MoveableEventGraphic))
-        {
-            return false;
+            if (getPossibleEvent().getGraphic() instanceof MoveableEventGraphic)
+            {
+                startMoving(toMove);
+            }
         }
-        
-        return super.startMoving(toMove);
     }
     
     public Direction getDirection()
@@ -6,6 +6,7 @@
 package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
 
 import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.ImmutableEvent;
 
 /**
  * CustomMovementEvent takes an array of Directions and directions the event
@@ -24,8 +25,8 @@ public class CustomMovementType implements MovementType {
         this.moves = moves;
     }
     
-    public Direction nextMovement()
-    {        
+    public Direction nextMovement(ImmutableEvent ev)
+    {
         if (step >= moves.length)
         {
             step = 0;
@@ -0,0 +1,142 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
+
+import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.Game;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.Event;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.ImmutableEvent;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.LayerEvent;
+import java.awt.Point;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+
+/**
+ * FollowMovementType allows an Event to continually walk toward a specified
+ * Event.
+ *
+ * @author hatkirby
+ */
+public class FollowMovementType implements MovementType {
+    
+    String name = null;
+    Event event = null;
+    Point lastLoc = new Point();
+    Deque<Direction> moves = new ArrayDeque<Direction>();
+    List<Point> attempts = new ArrayList<Point>();
+    
+    public FollowMovementType() {}
+    
+    public FollowMovementType(String name)
+    {
+        this.name = name;
+    }
+    
+    private boolean search(ImmutableEvent ev)
+    {
+        for (Direction d : Direction.values())
+        {
+            Point loc = d.to(ev.getLocation());
+            if (lastLoc.equals(loc))
+            {
+                return true;
+            }
+        }
+        
+        List<Direction> ds = ev.getLegalMoves();
+        List<Direction> tempd = new ArrayList<Direction>();
+        
+        if (lastLoc.x < ev.getLocation().x)
+        {
+            tempd.add(Direction.West);
+        } else if (lastLoc.x > ev.getLocation().x)
+        {
+            tempd.add(Direction.East);
+        } else {
+            if (!ds.contains(Direction.North) || !ds.contains(Direction.South))
+            {
+                tempd.add(Direction.West);
+                tempd.add(Direction.East);
+            }
+        }
+        
+        if (lastLoc.y < ev.getLocation().y)
+        {
+            tempd.add(Direction.North);
+        } else if (lastLoc.y > ev.getLocation().y)
+        {
+            tempd.add(Direction.South);
+        } else {
+            if (!ds.contains(Direction.West) || !ds.contains(Direction.East))
+            {
+                tempd.add(Direction.North);
+                tempd.add(Direction.South);
+            }
+        }
+        
+        tempd.retainAll(ds);
+        Collections.shuffle(tempd);
+        
+        for (Direction d : tempd)
+        {
+            Point loc = d.to(ev.getLocation());
+            
+            if (attempts.contains(loc))
+            {
+                continue;
+            }
+            
+            Event temp = new LayerEvent(loc.x, loc.y);
+            temp.setParentMap(ev.getParentMap());
+            attempts.add(loc);
+            
+            if (search(new ImmutableEvent(temp)))
+            {
+                moves.push(d);
+                return true;
+            }
+        }
+        
+        return false;
+    }
+    
+    public Direction nextMovement(ImmutableEvent ev)
+    {
+        if (event == null)
+        {
+            if (name == null)
+            {
+                event = Game.getHeroEvent();
+            } else {
+                event = ev.getParentMap().getEvent(name);
+            }
+        } else if ((name != null) && !(event.getParentMap().equals(ev.getParentMap())))
+        {
+            event = ev.getParentMap().getEvent(name);
+        }
+        
+        if (!event.getLocation().equals(lastLoc))
+        {
+            lastLoc.setLocation(event.getLocation());
+        
+            moves.clear();
+            attempts.clear();
+        
+            search(ev);
+        }
+        
+        if (!moves.isEmpty())
+        {
+            return moves.pop();
+        }
+        
+        return null;
+    }
+
+}
\ No newline at end of file
@@ -6,6 +6,7 @@
 package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
 
 import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.ImmutableEvent;
 
 /**
  * A MovementType is an object that specifies the type of AI a non-hero event
@@ -17,6 +18,6 @@ import com.fourisland.fourpuzzle.Direction;
  */
 public interface MovementType {
     
-    public Direction nextMovement();
+    public Direction nextMovement(ImmutableEvent ev);
     
 }
\ No newline at end of file
@@ -6,6 +6,9 @@
 package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
 
 import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.ImmutableEvent;
+import com.fourisland.fourpuzzle.util.Interval;
+import java.util.List;
 import java.util.Random;
 
 /**
@@ -15,34 +18,19 @@ import java.util.Random;
  */
 public class RandomMovementType implements MovementType {
 
-    public Direction nextMovement()
+    Interval in = Interval.createTickInterval(10);
+    public Direction nextMovement(ImmutableEvent ev)
     {
-        Random r = new Random();
-        int ra = r.nextInt(1000);
-        Direction toMove = null;
-        boolean letsMove = false;
-
-        if (ra < 25)
-        {
-            toMove = Direction.North;
-            letsMove = true;
-        } else if (ra < 50)
-        {
-            toMove = Direction.West;
-            letsMove = true;
-        } else if (ra < 75)
-        {
-            toMove = Direction.South;
-            letsMove = true;
-        } else if (ra < 100)
-        {
-            toMove = Direction.East;
-            letsMove = true;
-        }
-
-        if (letsMove)
+        if (in.isElapsed())
         {
-            return toMove;
+            List<Direction> moves = ev.getLegalMoves();
+            Random r = new Random();
+            int ra = r.nextInt(moves.size());
+            
+            if (ra != moves.size())
+            {
+                return moves.get(ra);
+            }
         }
         
         return null;
@@ -6,6 +6,7 @@
 package com.fourisland.fourpuzzle.gamestate.mapview.event.movement;
 
 import com.fourisland.fourpuzzle.Direction;
+import com.fourisland.fourpuzzle.gamestate.mapview.event.ImmutableEvent;
 
 /**
  * StayStillMovementType keeps the event stationary.
@@ -14,7 +15,7 @@ import com.fourisland.fourpuzzle.Direction;
  */
 public class StayStillMovementType implements MovementType {
 
-    public Direction nextMovement()
+    public Direction nextMovement(ImmutableEvent ev)
     {
         return null; // Do nothing, stay still
     }