Add common pathing code and SimplePathing module

src/main/java/com/replaymod/pathing/impl/PathImpl.java

@@ -0,0 +1,175 @@
+package com.replaymod.pathing.impl;
+
+import com.google.common.base.Optional;
+import com.replaymod.pathing.interpolation.InterpolationParameters;
+import com.replaymod.pathing.interpolation.Interpolator;
+import com.replaymod.pathing.path.Keyframe;
+import com.replaymod.pathing.path.Path;
+import com.replaymod.pathing.path.PathSegment;
+import com.replaymod.pathing.path.Timeline;
+import com.replaymod.pathing.property.Property;
+import com.replaymod.pathing.property.PropertyPart;
+
+import java.util.*;
+
+public class PathImpl implements Path {
+    private final Timeline timeline;
+    private Map<Long, Keyframe> keyframes = new TreeMap<>();
+    private List<PathSegment> segments = new LinkedList<>();
+
+    public PathImpl(Timeline timeline) {
+        this.timeline = timeline;
+    }
+
+    @Override
+    public Timeline getTimeline() {
+        return timeline;
+    }
+
+    @Override
+    public Collection<Keyframe> getKeyframes() {
+        return Collections.unmodifiableCollection(keyframes.values());
+    }
+
+    @Override
+    public Collection<PathSegment> getSegments() {
+        return Collections.unmodifiableCollection(segments);
+    }
+
+    @Override
+    public void update() {
+        update(false);
+    }
+
+    @Override
+    public void updateAll() {
+        update(false);
+    }
+
+    private void update(boolean force) {
+        Interpolator interpolator = null;
+        Map<PropertyPart, InterpolationParameters> parameters = new HashMap<>();
+        for (PathSegment segment : segments) {
+            if (segment.getInterpolator() != interpolator) {
+                interpolator = segment.getInterpolator();
+                if (force || interpolator.isDirty()) {
+                    parameters = interpolator.bake(parameters);
+                }
+            }
+        }
+    }
+
+    @Override
+    public <T> Optional<T> getValue(Property<T> property, long time) {
+        PathSegment segment = getSegment(time);
+        if (segment != null) {
+            Interpolator interpolator = segment.getInterpolator();
+            if (interpolator != null) {
+                if (interpolator.getKeyframeProperties().contains(property)) {
+                    return interpolator.getValue(property, time);
+                }
+            }
+        }
+        return Optional.absent();
+    }
+
+    @Override
+    public Keyframe insert(long time) {
+        Keyframe keyframe = new KeyframeImpl(time);
+        insert(keyframe);
+        return keyframe;
+    }
+
+    @Override
+    public Keyframe getKeyframe(long time) {
+        return keyframes.get(time);
+    }
+
+    @Override
+    public void insert(Keyframe keyframe) {
+        if (keyframes.containsKey(keyframe.getTime())) {
+            throw new IllegalStateException("A keyframe at " + keyframe.getTime() + " already exists.");
+        }
+        keyframes.put(keyframe.getTime(), keyframe);
+
+        if (segments.isEmpty()) {
+            if (keyframes.size() >= 2) {
+                Iterator<Keyframe> iter = keyframes.values().iterator();
+                segments.add(new PathSegmentImpl(iter.next(), iter.next()));
+            }
+            return;
+        }
+
+        ListIterator<PathSegment> iter = segments.listIterator();
+        PathSegment next = iter.next();
+        if (keyframe.getTime() < next.getStartKeyframe().getTime()) {
+            iter.previous();
+            iter.add(new PathSegmentImpl(keyframe, next.getStartKeyframe(), next.getInterpolator()));
+        }
+
+        while (true) {
+            if (next.getStartKeyframe().getTime() <= keyframe.getTime()
+                    && next.getEndKeyframe().getTime() >= keyframe.getTime()) {
+                iter.remove();
+                next.setInterpolator(null);
+                iter.add(new PathSegmentImpl(next.getStartKeyframe(), keyframe, next.getInterpolator()));
+                iter.add(new PathSegmentImpl(keyframe, next.getEndKeyframe(), next.getInterpolator()));
+                return;
+            }
+            if (iter.hasNext()) {
+                next = iter.next();
+            } else {
+                iter.add(new PathSegmentImpl(next.getEndKeyframe(), keyframe, next.getInterpolator()));
+                return;
+            }
+        }
+    }
+
+    @Override
+    public void remove(Keyframe keyframe, boolean useFirstInterpolator) {
+        if (keyframes.get(keyframe.getTime()) != keyframe) {
+            throw new IllegalArgumentException("The keyframe " + keyframe + " is not part of this path.");
+        }
+        keyframes.remove(keyframe.getTime());
+
+        if (segments.size() < 2) {
+            for (PathSegment segment : segments) {
+                segment.setInterpolator(null);
+            }
+            segments.clear();
+            return;
+        }
+
+        ListIterator<PathSegment> iter = segments.listIterator();
+        while (iter.hasNext()) {
+            PathSegment next = iter.next();
+            if (next.getEndKeyframe() == keyframe) {
+                iter.remove();
+                if (iter.hasNext()) {
+                    PathSegment next2 = iter.next();
+                    iter.remove();
+                    iter.add(new PathSegmentImpl(next.getStartKeyframe(), next2.getEndKeyframe(),
+                            (useFirstInterpolator ? next : next2).getInterpolator()));
+                } else {
+                    next.setInterpolator(null);
+                }
+                return;
+            }
+            if (next.getStartKeyframe() == keyframe) {
+                next.setInterpolator(null);
+                iter.remove();
+                return;
+            }
+        }
+        throw new AssertionError("No segment for keyframe found!");
+    }
+
+    private PathSegment getSegment(long time) {
+        for (PathSegment segment : segments) {
+            if (segment.getStartKeyframe().getTime() <= time && segment.getEndKeyframe().getTime() >= time) {
+                return segment;
+            }
+        }
+        return null;
+    }
+}