SlipstreamTerrainPlugin2.java

Go to the documentation of this file.

package com.fs.starfarer.api.impl.campaign.velfield;
 
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
 
import java.awt.Color;
 
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL14;
import org.lwjgl.util.vector.Vector2f;
 
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.campaign.CampaignEngineLayers;
import com.fs.starfarer.api.campaign.CampaignFleetAPI;
import com.fs.starfarer.api.campaign.SectorEntityToken;
import com.fs.starfarer.api.campaign.TerrainAIFlags;
import com.fs.starfarer.api.combat.ViewportAPI;
import com.fs.starfarer.api.fleet.FleetMemberViewAPI;
import com.fs.starfarer.api.graphics.SpriteAPI;
import com.fs.starfarer.api.impl.campaign.DebugFlags;
import com.fs.starfarer.api.impl.campaign.abilities.ReversePolarityToggle;
import com.fs.starfarer.api.impl.campaign.abilities.SustainedBurnAbility;
import com.fs.starfarer.api.impl.campaign.ghosts.SensorGhost;
import com.fs.starfarer.api.impl.campaign.ghosts.SensorGhostManager;
import com.fs.starfarer.api.impl.campaign.ids.Entities;
import com.fs.starfarer.api.impl.campaign.ids.Stats;
import com.fs.starfarer.api.impl.campaign.ids.Tags;
import com.fs.starfarer.api.impl.campaign.terrain.BaseTerrain;
import com.fs.starfarer.api.impl.campaign.terrain.HyperspaceTerrainPlugin;
import com.fs.starfarer.api.impl.campaign.terrain.HyperspaceTerrainPlugin.CellState;
import com.fs.starfarer.api.loading.Description.Type;
import com.fs.starfarer.api.ui.TooltipMakerAPI;
import com.fs.starfarer.api.util.FaderUtil;
import com.fs.starfarer.api.util.FaderUtil.State;
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.util.MutatingVertexUtil;
import com.fs.starfarer.api.util.WeightedRandomPicker;
 
public class SlipstreamTerrainPlugin2 extends BaseTerrain {
    
    public static float FUEL_USE_MULT = 0.5f;
    public static String FUEL_USE_MODIFIER_DESC = "Inside slipstream";
    
    public static class SlipstreamParams2 {
        public String enteringSlipstreamTextOverride = null;
        public Float enteringSlipstreamTextDurationOverride = null;
        public boolean forceNoWindVisualEffectOnFleets = false;
        public String spriteKey1 = "slipstream0";
        public String spriteKey2 = "slipstream1";
        public String spriteKey3 = "slipstream2";
        public String edgeKey = "slipstream_edge";
        public Color spriteColor = Color.white;
        public Color windGlowColor = new Color(0.65f, 0.5f, 1f, 0.75f);
        public Color edgeColor = Color.white;
        public float baseWidth = 768f;
        public float widthForMaxSpeed = 768f;
        public float edgeWidth = 256f;
        public float areaPerParticle = 10000;
        public int maxParticles = 2000;
        public float minSpeed;
        public float maxSpeed;
        public Color minColor = new Color(0.5f, 0.3f, 0.75f, 0.1f);
        public Color maxColor = new Color(0.5f, 0.6f, 1f, 0.3f);
        public Color mapColor = new Color(0.5f, 0.6f, 1f, 1f);
        //public Color maxColor = new Color(0.5f, 0.6f, 1f, 0.5f);
        public float minDur = 2f;
        public float maxDur = 6f;
        public float particleFadeInTime = 1f;
        public float lineLengthFractionOfSpeed = 0.25f;
        
        public int burnLevel = 30;
        public int maxBurnLevelForTextureScroll = 30;
        public boolean slowDownInWiderSections = true;
        public float widthForMaxSpeedMinMult = 0.67f;
        public float widthForMaxSpeedMaxMult = 1.5f;
        public float accelerationMult = 1f;
        public String name = null;
        
        public float texScrollMult0 = 0f;
        public float texScrollMult1 = -1.13f;
        public float texScrollMult2 = -0.28f;
        
        Object readResolve() {
            if (accelerationMult <= 0f) {
                accelerationMult = 1f;
            }
            return this;
        }
    }
    
    public static class SlipstreamSegment {
        public Vector2f loc = new Vector2f();
        public float width;
        public float bMult = 1f;
        
        transient public Vector2f locB = new Vector2f();
        transient public Vector2f dir = new Vector2f();
        transient public float wobbledWidth;
        transient public int index = 0;
        transient public Vector2f normal = new Vector2f();
        transient public float tx = 0f;
        transient public float txe1 = 0f;
        transient public float txe2 = 0f;
        transient public float totalLength;
        transient public float lengthToPrev;
        transient public float lengthToNext;
        
        transient public MutatingVertexUtil wobble1;
        transient public MutatingVertexUtil wobble2;
        public FaderUtil fader = new FaderUtil(0f, 1f, 1f);
        
        public boolean discovered = false;
        
        public Object readResolve() {
            float minRadius = 0f;
            float maxRadius = width * 0.05f;
            float rate = maxRadius * 0.5f;
            float angleRate = 50f;
            wobble1 = new MutatingVertexUtil(minRadius, maxRadius, rate, angleRate); 
            wobble2 = new MutatingVertexUtil(minRadius, maxRadius, rate, angleRate);
            locB = new Vector2f();
            return this;
        }
    }
    
    public static class SlipstreamParticle {
        float speed;
        float dist;
        float yPos;
        Color color;
        float remaining;
        float elapsed;
    }
    
    public static int MAX_PARTICLES_ADD_PER_FRAME = 250;
    
    public static float RAD_PER_DEG = 0.01745329251f;
    public static Vector2f rotateAroundOrigin(Vector2f v, float cos, float sin) {
        Vector2f r = new Vector2f();
        r.x = v.x * cos - v.y * sin;
        r.y = v.x * sin + v.y * cos;
        return r;
    }
    
 
    
    protected SlipstreamParams2 params = new SlipstreamParams2();
    
    protected List<SlipstreamSegment> segments = new ArrayList<SlipstreamTerrainPlugin2.SlipstreamSegment>();
    protected float totalLength = 0f;
    
    protected transient List<Vector2f> encounterPoints = new ArrayList<Vector2f>();
    
    protected transient List<SlipstreamParticle> particles = new ArrayList<SlipstreamParticle>();
    protected transient int [] lengthToIndexMap;
    protected transient int lengthDivisor;
    
    protected boolean needsRecompute = true;
    transient protected List<BoundingBox> bounds = new ArrayList<BoundingBox>();
    protected int segmentsPerBox;
    
    protected float texProgress0 = 0f;
    protected float texProgress1 = 0f;
    protected float texProgress2 = 0f;
    //protected transient float mapArrowProgress = 0f;
    
    protected float [] despawnNoise = null;
    protected float despawnDelay = 0f;
    protected float despawnDays = 0f;
    protected float despawnElapsed = 0f;
    
    protected float [] spawnNoise = null;
    protected float spawnDays = 0f;
    protected float spawnElapsed = 0f;
    protected boolean dynamic = false;
    
    public SlipstreamTerrainPlugin2() {
    }
    
    public boolean isDespawning() {
        return entity.hasTag(Tags.FADING_OUT_AND_EXPIRING) || despawnNoise != null;
    }
    
    public void spawn(float spawnDays, Random random) {
        //if (true) return;
        this.spawnDays = spawnDays;
        spawnElapsed = 0f;
        
        int numNoisePoints = 32;
        while (numNoisePoints < segments.size()) {
            numNoisePoints *= 2f;
        }
        if (numNoisePoints > 512) numNoisePoints = 512;
        
        float spikes = 0.67f;
        spawnNoise = SlipstreamBuilder.initNoise1D(random, numNoisePoints, spikes); 
        spawnNoise[0] = 0.5f;
        spawnNoise[spawnNoise.length - 1] = 0.5f;
        SlipstreamBuilder.genNoise1D(random, spawnNoise, numNoisePoints, spikes);
        SlipstreamBuilder.normalizeNoise1D(spawnNoise);
    }
    
    protected void advanceSpawn(float amount) {
        if (spawnNoise == null) return;
        if (despawnElapsed > 0 || despawnDays > 0) return;
        
        float days = Global.getSector().getClock().convertToDays(amount);
        
        spawnElapsed += days;
        float f = spawnElapsed / Math.max(0.1f, spawnDays);
        
        float size = segments.size();
        boolean allFadedIn = true;
        for (SlipstreamSegment seg : segments) {
            allFadedIn &= seg.fader.isFadedIn();
            
            float t = (seg.index + 1) / size; 
            float noise = SlipstreamBuilder.getInterpNoise(spawnNoise, t);
            if (noise <= f || f >= 1f) {
                float dur = Math.max(1f, Global.getSector().getClock().convertToSeconds((spawnDays - spawnElapsed) / 2f));
                seg.fader.setDurationIn(dur);
                seg.fader.fadeIn();
            } else {
                seg.fader.fadeOut();
            }
        }
        if (allFadedIn) {
            spawnNoise = null;
            spawnElapsed = 0;
            spawnDays = 0;
        }
    }
    
    public void despawn(float despawnDelay, float despawnDays, Random random) {
        this.despawnDays = despawnDays;
        this.despawnDelay = despawnDelay;
        despawnElapsed = 0f;
        
        int numNoisePoints = 32;
        while (numNoisePoints < segments.size()) {
            numNoisePoints *= 2f;
        }
        if (numNoisePoints > 512) numNoisePoints = 512;
        
        float spikes = 0.67f;
        despawnNoise = SlipstreamBuilder.initNoise1D(random, numNoisePoints, spikes); 
        despawnNoise[0] = 0.5f;
        despawnNoise[despawnNoise.length - 1] = 0.5f;
        SlipstreamBuilder.genNoise1D(random, despawnNoise, numNoisePoints, spikes);
        SlipstreamBuilder.normalizeNoise1D(despawnNoise);
    }
    
    protected void advanceDespawn(float amount) {
//      if (isDespawning()) {
//          System.out.println("3f23f23f32");
//      }
        if (despawnNoise == null) return;
        if (entity.hasTag(Tags.FADING_OUT_AND_EXPIRING)) return;
        
        float days = Global.getSector().getClock().convertToDays(amount);
        despawnDelay -= days;
        if (despawnDelay > 0) return;
        
        despawnElapsed += days;
        float f = despawnElapsed / Math.max(0.1f, despawnDays);
        
        float size = segments.size();
        boolean allFaded = true;
        for (SlipstreamSegment seg : segments) {
            allFaded &= seg.fader.isFadedOut();
            
            float t = (seg.index + 1) / size; 
            float noise = SlipstreamBuilder.getInterpNoise(despawnNoise, t);
            if (noise <= f || f >= 1f) {
                float dur = Math.max(1f, Global.getSector().getClock().convertToSeconds((despawnDays - despawnElapsed) / 2f));
                seg.fader.setDurationOut(dur);
                seg.fader.fadeOut();
            }
        }
        if (allFaded) {
            Misc.fadeAndExpire(entity);
            despawnNoise = null;
        }
    }
    
    public void setNeedsRecompute() {
        this.needsRecompute = true;
    }
 
    public void updateLengthToIndexMap() {
        float minSegmentLength = Float.MAX_VALUE;
        for (SlipstreamSegment curr : segments) {
            if (curr.lengthToNext > 0 && minSegmentLength > curr.lengthToNext) {
                minSegmentLength = curr.lengthToNext;
            }
        }
        if (minSegmentLength < 50f) minSegmentLength = 50f;
        
        lengthDivisor = (int) (minSegmentLength - 1f); 
        int numIndices = (int) (totalLength / lengthDivisor);
        lengthToIndexMap = new int [numIndices];
        
        int lengthSoFar = 0;
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment curr = segments.get(i);
            while (lengthSoFar < curr.totalLength + curr.lengthToNext) {
                int lengthIndex = lengthSoFar / lengthDivisor;
                if (lengthIndex < lengthToIndexMap.length) {
                    lengthToIndexMap[lengthIndex] = i;
                }
                lengthSoFar += lengthDivisor;
            }
        }
    }
    
    public SlipstreamSegment getSegmentForDist(float distAlongStream) {
        if (lengthToIndexMap == null) return null;
        int mapIndex = (int) (distAlongStream / lengthDivisor);
        if (mapIndex < 0 || mapIndex >= lengthToIndexMap.length) return null;
        //System.out.println("Index: " + mapIndex + ", dist: " + distAlongStream);
        int segIndex = lengthToIndexMap[mapIndex];
        SlipstreamSegment segment = segments.get(segIndex);
        while (distAlongStream < segment.totalLength) {
            segIndex--;
            if (segIndex < 0) return null;
            segment = segments.get(segIndex);
        }
        while (distAlongStream > segment.totalLength + segment.lengthToNext) {
            segIndex++;
            if (segIndex >= segments.size()) return null;
            segment = segments.get(segIndex);
        }
        return segment;
    }
    
    public void addSegment(Vector2f loc, float width) {
        SlipstreamSegment s = new SlipstreamSegment();
        s.loc.set(loc);
        s.width = width;
        s.wobbledWidth = width - params.edgeWidth * 2f * 0.25f;
        
        float minRadius = 0f;
        float maxRadius = s.width * 0.05f;
        float rate = maxRadius * 0.5f;
        float angleRate = 50f;
        s.wobble1 = new MutatingVertexUtil(minRadius, maxRadius, rate, angleRate); 
        s.wobble2 = new MutatingVertexUtil(minRadius, maxRadius, rate, angleRate); 
        
        s.fader.fadeIn();
        
        segments.add(s);
        setNeedsRecompute();
    }
    
    public void init(String terrainId, SectorEntityToken entity, Object pluginParams) {
        super.init(terrainId, entity, pluginParams);
        this.params = (SlipstreamParams2) pluginParams;
        readResolve();
    }
    
    public float getRenderRange() {
        return totalLength * 0.6f + 1000f;
        //return totalLength + 1000f;
    }
 
    Object readResolve() {
        particles = new ArrayList<SlipstreamParticle>();
        bounds = new ArrayList<BoundingBox>();
        
        needsRecompute = true;
        layers = EnumSet.of(CampaignEngineLayers.TERRAIN_SLIPSTREAM);
        return this;
    }
    
    public void advance(float amount) {
        super.advance(amount);
        if (amount <= 0) {
            return; // happens during game load
        }
        if (entity.isInCurrentLocation()) {
            applyEffectToEntities(amount);
            doSoundPlayback(amount);
        }
        
//      for (SlipstreamSegment seg : getSegments()) {
//          seg.fader.fadeOut();
//          seg.fader.fadeIn();
//      }
//      float countWithLowBMult = 0f;
//      for (SlipstreamSegment seg : getSegments()) {
//          if (seg.bMult < 1f) {
//              countWithLowBMult++;
//          }
//      }
//      System.out.println("WITH LOW bMult from STP2: " + countWithLowBMult);
        
        
        recomputeIfNeeded();
        advanceNearbySegments(amount);
    
        addParticles();
        advanceParticles(amount);
        
        advanceSpawn(amount);
        advanceDespawn(amount);
        
        if (entity.isInCurrentLocation()) {
            float texSpeed = Misc.getSpeedForBurnLevel(Math.min(params.burnLevel * 0.5f, 
                                                                params.maxBurnLevelForTextureScroll));
            
            SpriteAPI sprite = Global.getSettings().getSprite("misc", params.spriteKey1);
            
            float texelsPerPixel = 1f;
            if (segments.size() > 1) {
                texelsPerPixel = (segments.get(1).tx * sprite.getWidth()) / Math.max(1f, segments.get(1).lengthToPrev);
            }
            
            float unitsPerOneTexIter = sprite.getWidth();
            float texUnitsPerSecondForSpeed = texSpeed / unitsPerOneTexIter * texelsPerPixel;
            texProgress0 -= texUnitsPerSecondForSpeed * amount * params.texScrollMult0;
            texProgress1 += texUnitsPerSecondForSpeed * amount * params.texScrollMult1;
            texProgress2 += texUnitsPerSecondForSpeed * amount * params.texScrollMult2;
            if (texProgress0 > 100000) texProgress0 -= 100000f;
            if (texProgress1 > 100000) texProgress1 -= 100000f;
            if (texProgress2 > 100000) texProgress2 -= 100000f;
        }
    }
    
    public boolean isDynamic() {
        return dynamic;
    }
 
    public void setDynamic(boolean dynamic) {
        this.dynamic = dynamic;
    }
 
    public void recomputeIfNeeded() {
        if (!needsRecompute) return;
        recompute();
    }
    
    public void recompute() {
        needsRecompute = false;
        
        // compute average location, set segment indices
        Vector2f avgLoc = new Vector2f();
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment curr = segments.get(i);
            curr.index = i;
            Vector2f.add(avgLoc, curr.loc, avgLoc);
        }
 
        if (segments.size() > 0) {
            avgLoc.scale(1f / segments.size());
            entity.setLocation(avgLoc.x, avgLoc.y);
        }
 
        
        SpriteAPI sprite = Global.getSettings().getSprite("misc", params.spriteKey1);
        SpriteAPI edge = Global.getSettings().getSprite("misc", params.edgeKey);
        
        // compute texture coordinates etc
        float tx = 0f;
        float txe1 = 0f;
        float txe2 = 0f;
        float totalLength = 0f;
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment prev = null;
            if (i > 0) prev = segments.get(i - 1);
            SlipstreamSegment curr = segments.get(i);
            SlipstreamSegment next = null;
            SlipstreamSegment next2 = null;
            SlipstreamSegment next3 = null;
            if (i < segments.size() - 1) {
                next = segments.get(i + 1);
            }
            if (i < segments.size() - 2) {
                next2 = segments.get(i + 2);
            }
            if (i < segments.size() - 3) {
                next3 = segments.get(i + 3);
            }
 
            if (curr.dir == null) curr.dir = new Vector2f();
            if (curr.normal == null) curr.normal = new Vector2f();
            
            if (next == null) {
                if (prev != null) {
                    curr.dir.set(prev.dir);
                }
            } else {
                Vector2f dir = Vector2f.sub(next.loc, curr.loc, new Vector2f());
                dir = Misc.normalise(dir);
                curr.dir = dir;
            }
 
            Vector2f dir = curr.dir;
            if (prev == null || next == null) {
                curr.normal.set(-dir.y, dir.x);
            } else {
                Vector2f avg = Vector2f.add(prev.dir, curr.dir, new Vector2f());
                avg.scale(0.5f);
                curr.normal.set(-avg.y, avg.x);
            }
//          Vector2f normal = new Vector2f(-dir.y, dir.x);
//          curr.normal.set(normal);
            
            float length = 0f;
            float texLength = 0f;
            float e1TexLength = 0f;
            float e2TexLength = 0f;
            if (prev != null) {
                Vector2f dir2 = Vector2f.sub(curr.loc, prev.loc, new Vector2f());
                length = dir2.length();
                texLength = length / sprite.getWidth();
                if (!dynamic) {
                    texLength = Math.min(texLength, sprite.getHeight() / curr.width);
                }
 
                Vector2f edgeCurr = new Vector2f(curr.loc);
                edgeCurr.x += curr.normal.x * curr.width * 0.5f;
                edgeCurr.y += curr.normal.y * curr.width * 0.5f;
 
                Vector2f edgePrev = new Vector2f(prev.loc);
                edgePrev.x += prev.normal.x * prev.width * 0.5f;
                edgePrev.y += prev.normal.y * prev.width * 0.5f;
 
                float length2 = Vector2f.sub(edgeCurr, edgePrev, new Vector2f()).length();
                e1TexLength = length2 / edge.getWidth() * edge.getHeight() / params.edgeWidth;
 
 
                edgeCurr = new Vector2f(curr.loc);
                edgeCurr.x -= curr.normal.x * curr.width * 0.5f;
                edgeCurr.y -= curr.normal.y * curr.width * 0.5f;
 
                edgePrev = new Vector2f(prev.loc);
                edgePrev.x -= prev.normal.x * prev.width * 0.5f;
                edgePrev.y -= prev.normal.y * prev.width * 0.5f;
 
                length2 = Vector2f.sub(edgeCurr, edgePrev, new Vector2f()).length();
                e2TexLength = length2 / edge.getWidth() * edge.getHeight() / params.edgeWidth;
            }
 
            tx += texLength;
            txe1 += e1TexLength;
            txe2 += e2TexLength;
            curr.tx = tx;
            curr.txe1 = txe1;
            curr.txe2 = txe2;
            curr.lengthToPrev = length;
 
            totalLength += length;
            curr.totalLength = totalLength;
            //curr.lengthToNext = Misc.getDistance(curr.loc, next.loc);
            if (prev != null) {
                prev.lengthToNext = length;
            }
 
            if (next != null && next2 != null && next3 != null) {
                Vector2f p0 = curr.loc;
                Vector2f p1 = next.loc;
                Vector2f p2 = next2.loc;
                Vector2f p3 = next3.loc;
 
                float p1ToP2 = Misc.getAngleInDegrees(p1, p2);
                float p2ToP3 = Misc.getAngleInDegrees(p2, p3);
                float diff = Misc.getAngleDiff(p1ToP2, p2ToP3);
                float adjustment = Math.min(diff, Math.max(diff * 0.25f, diff - 10f));
                adjustment = diff * 0.5f;
                //adjustment = diff * 0.25f;
                float angle = p1ToP2 + Misc.getClosestTurnDirection(p1ToP2, p2ToP3) * adjustment * 1f + 180f;
                //angle = Misc.getAngleInDegrees(p3, p2);
                float dist = Misc.getDistance(p2, p1);
                Vector2f p1Adjusted = Misc.getUnitVectorAtDegreeAngle(angle);
                p1Adjusted.scale(dist);
                Vector2f.add(p1Adjusted, p2, p1Adjusted);
                next.locB = p1Adjusted;
            } else if (next != null) {
                next.locB = next.loc;
            }
            if (prev == null) {
                curr.locB = new Vector2f(curr.loc);
            }
        }
        this.totalLength = totalLength;
        
        updateLengthToIndexMap();
        updateBoundingBoxes();
    }
    
    protected void updateBoundingBoxes() {
        segmentsPerBox = (int) Math.sqrt(segments.size()) + 1;
        if (segmentsPerBox < 20) segmentsPerBox = 20;
        
        bounds.clear();
        for (int i = 0; i < segments.size(); i+= segmentsPerBox) {
            List<SlipstreamSegment> section = new ArrayList<SlipstreamSegment>();
            for (int j = i; j < i + segmentsPerBox && j < segments.size(); j++) {
                section.add(segments.get(j));
            }
            if (i + segmentsPerBox < segments.size()) {
                section.add(segments.get(i + segmentsPerBox));
            }
            BoundingBox box = BoundingBox.create(section);
            bounds.add(box);
        }
    }
    
    protected void advanceNearbySegments(float amount) {
//      if (isDespawning()) {
//          System.out.println("3f23f23f32");
//      }
        
        CampaignFleetAPI pf = Global.getSector().getPlayerFleet();
        if (pf == null || !entity.isInCurrentLocation()) {
            if (spawnNoise != null || despawnNoise != null) {
                for (int i = 0; i < segments.size(); i++) {
                    SlipstreamSegment curr = segments.get(i);
                    curr.fader.advance(amount);
                }
            }
            return;
        }
        
//      if (segments.size() > 0) {
//          segments.get(0).fader.forceOut();
//          segments.get(segments.size() - 1).fader.fadeOut();
//      }
        
        ViewportAPI viewport = Global.getSector().getViewport();
        float viewRadius = new Vector2f(viewport.getVisibleWidth() * 0.5f, viewport.getVisibleHeight() * 0.5f).length();
        viewRadius = Math.max(6000f, viewRadius);
        viewRadius += 1000f;
        List<SlipstreamSegment> near = getSegmentsNear(viewport.getCenter(), viewRadius);
        
        // advance faders for all segments, not just nearby, since it's not just aesthetic
        for (int i = 0; i < segments.size(); i++) {
//          if (i == 6) {
//              System.out.println("wefwefwef");
//          }
            SlipstreamSegment curr = segments.get(i);
            curr.fader.advance(amount);
        }
        
        HyperspaceTerrainPlugin plugin = (HyperspaceTerrainPlugin) Misc.getHyperspaceTerrain().getPlugin();
 
//      float [] c = getLengthAndWidthFractionWithinStream(pf.getLocation());
//      if (c != null) {
//          if (getSegmentForDist(c[0]) != null) {
//              System.out.println("efwefwefew");
//              for (int i = 0; i < segments.size() && i < 20; i++) {
//                  System.out.println("bMult: " + segments.get(i).bMult);
//              }
//          }
//      }
            
        // advance wobble, compute wobbledWidth
        for (int i = 0; i < near.size(); i++) {
            SlipstreamSegment curr = near.get(i);
            
            if (entity.isInHyperspace() && !curr.fader.isFadedOut() && 
                    curr.fader.getBrightness() * curr.bMult > 0.05f && curr.bMult > 0f) {
                plugin.setTileState(
                        curr.loc, curr.width * 0.5f + params.edgeWidth + 100f, 
                        CellState.OFF,
                        1f - curr.fader.getBrightness(), -1f);
                //plugin.turnOffStorms(curr.loc, curr.width * 0.5f + params.edgeWidth + 200f);
            }
            
            //curr.fader.advance(amount);
            
            float r1 = 0.5f + (float) Math.random() * 1f;
            float r2 = 0.5f + (float) Math.random() * 1f;
            curr.wobble1.advance(amount * r1);
            curr.wobble2.advance(amount * r2);
//          curr.wobble1.vector.set(0, 0);
//          curr.wobble2.vector.set(0, 0);
            
            Vector2f p1 = new Vector2f(curr.loc);
            Vector2f p2 = new Vector2f(curr.loc);
            p1.x += curr.normal.x * curr.width * 0.5f;
            p1.y += curr.normal.y * curr.width * 0.5f;
            p2.x -= curr.normal.x * curr.width * 0.5f;
            p2.y -= curr.normal.y * curr.width * 0.5f;
            
            p1.x += curr.wobble1.vector.x;
            p1.y += curr.wobble1.vector.y;
            p2.x += curr.wobble2.vector.x;
            p2.y += curr.wobble2.vector.y;
            
            //particles.clear();
            //curr.wobbledWidth = Misc.getDistance(p1, p2);
            float d = Misc.getDistance(p1, p2);
            //curr.wobbledWidth = d - params.edgeWidth * 2f * 0.5f;
            curr.wobbledWidth = d - params.edgeWidth * 2f * 0.25f;
            if (curr.wobbledWidth < d * 0.5f) curr.wobbledWidth = d * 0.5f;
            //curr.wobbledWidth = curr.width;
            
            if (curr.index > 0) {
                SlipstreamSegment prev = segments.get(curr.index - 1);
                Vector2f prev1 = new Vector2f(prev.loc);
                Vector2f prev2 = new Vector2f(prev.loc);
                prev1.x += prev.normal.x * prev.width * 0.5f;
                prev1.y += prev.normal.y * prev.width * 0.5f;
                prev2.x -= prev.normal.x * prev.width * 0.5f;
                prev2.y -= prev.normal.y * prev.width * 0.5f;
                
                float wobbleMult = 0.33f;
                wobbleMult = 0.4f;
                float maxWobbleRadius = Math.min(prev.width, curr.width) * 0.05f;
                float maxWobble1 = Misc.getDistance(p1, prev1) * wobbleMult;
                float maxWobble2 = Misc.getDistance(p2, prev2) * wobbleMult;
                maxWobble1 = Math.min(maxWobbleRadius, maxWobble1);
                maxWobble2 = Math.min(maxWobbleRadius, maxWobble2);
                
                if (curr.index < segments.size() - 1) {
                    SlipstreamSegment next = segments.get(curr.index + 1);
                    Vector2f next1 = new Vector2f(next.loc);
                    Vector2f next2 = new Vector2f(next.loc);
                    next1.x += next.normal.x * next.width * 0.5f;
                    next1.y += next.normal.y * next.width * 0.5f;
                    next2.x -= next.normal.x * next.width * 0.5f;
                    next2.y -= next.normal.y * next.width * 0.5f;
                    maxWobbleRadius = Math.min(next.width, curr.width) * 0.05f;
                    float maxWobble1A = Misc.getDistance(p1, next1) * wobbleMult;
                    float maxWobble2A = Misc.getDistance(p2, next2) * wobbleMult;
                    maxWobble1 = Math.min(maxWobble1, maxWobble1A);
                    maxWobble2 = Math.min(maxWobble2, maxWobble2A);
                }
                
                prev.wobble1.radius.setMax(maxWobble1);
                prev.wobble2.radius.setMax(maxWobble2);
                curr.wobble1.radius.setMax(maxWobble1);
                curr.wobble2.radius.setMax(maxWobble2);
            }
        }
    }
    
    
    
    public void addParticles() {
        if (Global.getSector().getPlayerFleet() == null) {
            particles.clear();
            return;
        }
        
        boolean useNewSpawnMethod = true;
        //useNewSpawnMethod = false;
        
        if (useNewSpawnMethod) {
            boolean inCurrentLocation = entity.isInCurrentLocation();
            boolean inHyperspace = entity.isInHyperspace();
            boolean spawnForAllSegments = false;
            ViewportAPI viewport = Global.getSector().getViewport();
            Vector2f locFrom = viewport.getCenter();
            float viewRadius = new Vector2f(viewport.getVisibleWidth() * 0.5f, viewport.getVisibleHeight() * 0.5f).length();
            viewRadius += 2000f;
            viewRadius = Math.max(viewRadius, 10000f);
            if (!inCurrentLocation) {
                if (inHyperspace) {
                    viewRadius = 5000f;
                    locFrom = Global.getSector().getPlayerFleet().getLocationInHyperspace();
                } else {
                    float dist = Misc.getDistanceToPlayerLY(entity);
                    spawnForAllSegments = dist < 2f;
                }
            }
            Set<SlipstreamSegment> veryNearSet = new LinkedHashSet<SlipstreamTerrainPlugin2.SlipstreamSegment>();
            if (inCurrentLocation) {
                float veryNearRadius = new Vector2f(viewport.getVisibleWidth() * 0.5f, viewport.getVisibleHeight() * 0.5f).length();
                viewRadius += 500f;
                veryNearSet = new LinkedHashSet<SlipstreamTerrainPlugin2.SlipstreamSegment>(
                            getSegmentsNear(viewport.getCenter(), veryNearRadius));
            }
            
    //      viewRadius *= 0.5f;
    //      viewRadius = 500f;
            
            List<SlipstreamSegment> near;
            if (spawnForAllSegments) {
                 near = new ArrayList<SlipstreamSegment>(segments);
            } else {
                near = getSegmentsNear(locFrom, viewRadius);
            }
            Set<SlipstreamSegment> nearSet = new LinkedHashSet<SlipstreamSegment>(near);
            
            Map<SlipstreamSegment, List<SlipstreamParticle>> particleMap = new LinkedHashMap<SlipstreamTerrainPlugin2.SlipstreamSegment, List<SlipstreamParticle>>();
            //for (SlipstreamParticle p : particles) {
            Iterator<SlipstreamParticle> iter = particles.iterator();
            while (iter.hasNext()) {
                SlipstreamParticle p = iter.next();
                SlipstreamSegment seg = getSegmentForDist(p.dist);
                if (seg != null) {
                    if (!nearSet.contains(seg)) {
                        iter.remove();
                        continue;
                    }
                    
                    List<SlipstreamParticle> list = particleMap.get(seg);
                    if (list == null) {
                        list = new ArrayList<SlipstreamTerrainPlugin2.SlipstreamParticle>();
                        particleMap.put(seg, list);
                    }
                    list.add(p);
                }
            }
            
            
            float totalArea = 0f;
            int nearParticles = 0;
            WeightedRandomPicker<SlipstreamSegment> segmentPicker = new WeightedRandomPicker<SlipstreamTerrainPlugin2.SlipstreamSegment>();
            
            // figure out how many particles to add total, and also which segments to add them
            // to to achieve a relatively even distribution
            for (int i = 0; i < near.size(); i++) {
                SlipstreamSegment curr = near.get(i);
                if (curr.lengthToNext <= 0) continue; // last segment, can't have particles in it since the stream is over
    
                float area = curr.lengthToNext * curr.width;
                float desiredParticles =  area / params.areaPerParticle;
                if (desiredParticles < 1) desiredParticles = 1;
                
                float particlesInSegment = 0; 
                List<SlipstreamParticle> list = particleMap.get(curr);
                if (list != null) {
                    particlesInSegment = list.size();
                }
                
                float mult = 1f;
                // spawn more particles in visible/nearly visible areas
                // better to have less visible particles when the player zooms out while paused
                // than to have less visible particles when zoomed in
                if (veryNearSet.contains(curr)) mult = 10f;
                
                float w = desiredParticles - particlesInSegment;
                w *= mult;
                if (w < 5f) w = 5f;
                segmentPicker.add(curr, w);
                //segmentPicker.add(curr, 1f);
                
                totalArea += area;
                nearParticles += particlesInSegment;
            }
            
            
            int numParticlesBasedOnArea = (int) (totalArea / params.areaPerParticle);
            int actualDesired = numParticlesBasedOnArea;
            if (numParticlesBasedOnArea < 10) numParticlesBasedOnArea = 10;
            if (numParticlesBasedOnArea > params.maxParticles) numParticlesBasedOnArea = params.maxParticles;
            //System.out.println("Area: " + totalArea/params.numParticles);
            //numParticlesBasedOnArea = 20000;
            
            
            int particlesToAdd = numParticlesBasedOnArea - nearParticles;
            if (particlesToAdd > MAX_PARTICLES_ADD_PER_FRAME) {
                particlesToAdd = MAX_PARTICLES_ADD_PER_FRAME;
            }
            particlesToAdd = Math.min(particlesToAdd, params.maxParticles - particles.size());
            
            int added = 0;
            while (added < particlesToAdd) {
                added++;
                SlipstreamSegment seg = segmentPicker.pick();
                if (seg == null) continue;
                
                SlipstreamParticle p = new SlipstreamParticle();
                float fLength = (float) Math.random() * 1f;
                float fWidth = (float) Math.random() * 2f - 1f;
                
                float speed = params.minSpeed + (params.maxSpeed - params.minSpeed) * (float) Math.random();
                float dur = params.minDur + (params.maxDur - params.minDur) * (float) Math.random(); 
                
                p.yPos = fWidth;
                //p.dist = totalLength * fLength;
                p.dist = seg.totalLength + seg.lengthToNext * fLength;
                p.speed = speed;
                
                float intensity = getIntensity(p.yPos);
                float wMult = getWidthBasedSpeedMult(p.dist);
    //          if (wMult <= 0) {
    //              getWidthBasedSpeedMult(p.dist);
    //          }
                float speedMult = (0.65f + 0.35f * intensity) * wMult;
                p.speed *= speedMult;
                
                p.remaining = dur;
                p.color = getRandomColor();
                
                particles.add(p);
            }
            
            //System.out.println("Particles: " + particles.size() + " desired based on area: " + actualDesired);
            
        } else {
            float totalArea = 0f;
            for (int i = 0; i < segments.size(); i++) {
                SlipstreamSegment curr = segments.get(i);
                totalArea += curr.lengthToPrev * curr.width;
            }
            
            int numParticlesBasedOnArea = (int) (totalArea / params.areaPerParticle);
            if (numParticlesBasedOnArea < 10) numParticlesBasedOnArea = 10;
            if (numParticlesBasedOnArea > params.maxParticles) numParticlesBasedOnArea = params.maxParticles;
            //System.out.println("Area: " + totalArea/params.numParticles);
            //numParticlesBasedOnArea = 20000;
        
        
            int added = 0;
            //while (particles.size() < params.numParticles && added < MAX_PARTICLES_ADD_PER_FRAME) {
            while (particles.size() < numParticlesBasedOnArea && added < MAX_PARTICLES_ADD_PER_FRAME) {
                added++;
                
                SlipstreamParticle p = new SlipstreamParticle();
                float fLength = (float) Math.random() * 1f;
                float fWidth = (float) Math.random() * 2f - 1f;
                
                float speed = params.minSpeed + (params.maxSpeed - params.minSpeed) * (float) Math.random();
                float dur = params.minDur + (params.maxDur - params.minDur) * (float) Math.random(); 
                
                p.yPos = fWidth;
                p.dist = totalLength * fLength;
                p.speed = speed;
                
                float intensity = getIntensity(p.yPos);
                float wMult = getWidthBasedSpeedMult(p.dist);
    //          if (wMult <= 0) {
    //              getWidthBasedSpeedMult(p.dist);
    //          }
                float speedMult = (0.65f + 0.35f * intensity) * wMult;
                p.speed *= speedMult;
                
                p.remaining = dur;
                p.color = getRandomColor();
                
                particles.add(p);
            }
        }
    }
    
    public void advanceParticles(float amount) {
        Iterator<SlipstreamParticle> iter = particles.iterator();
        while (iter.hasNext()) {
            SlipstreamParticle p = iter.next();
            p.remaining -= amount;
            p.elapsed += amount;
            if (p.remaining <= 0) {
                iter.remove();
                continue;
            }
 
            p.dist += p.speed * amount;
        }
    }
    
    public float getWidthBasedSpeedMult(float distAlong) {
        float mult = 1f;
        if (params.slowDownInWiderSections) {
            SlipstreamSegment curr = getSegmentForDist(distAlong);
            if (curr != null) {
                float width = curr.width;
                if (segments.size() > curr.index + 1) {
                    SlipstreamSegment next = segments.get(curr.index + 1);
                    float f = (distAlong - curr.totalLength) / curr.lengthToNext;
                    if (f < 0) f = 0;
                    if (f > 1) f = 1;
                    width = Misc.interpolate(width, next.width, f);
                    mult = Math.min(params.widthForMaxSpeedMaxMult,
                            params.widthForMaxSpeedMinMult + (1f - params.widthForMaxSpeedMinMult) * params.widthForMaxSpeed / width);
                }
            }
        }
        return mult;
    }
    
    public float getWidth(float distAlong) {
        SlipstreamSegment curr = getSegmentForDist(distAlong);
        if (curr != null) {
            float width = curr.width;
            if (segments.size() > curr.index + 1) {
                SlipstreamSegment next = segments.get(curr.index + 1);
                float f = (distAlong - curr.totalLength) / curr.lengthToNext;
                if (f < 0) f = 0;
                if (f > 1) f = 1;
                width = Misc.interpolate(width, next.width, f);
                return width;
            } else {
                return curr.width;
            }
        }
        return 0f;
    }
    public float getWobbledWidth(float distAlong) {
        SlipstreamSegment curr = getSegmentForDist(distAlong);
        if (curr != null) {
            float width = curr.wobbledWidth;
            if (segments.size() > curr.index + 1) {
                SlipstreamSegment next = segments.get(curr.index + 1);
                float f = (distAlong - curr.totalLength) / curr.lengthToNext;
                if (f < 0) f = 0;
                if (f > 1) f = 1;
                width = Misc.interpolate(width, next.wobbledWidth, f);
                return width;
            } else {
                return curr.wobbledWidth;
            }
        }
        return 0f;
    }
    
    public float getIntensity(float yOff) {
        yOff = Math.abs(yOff);
        float intensity = 1f;
        
        float dropoffAt = 0.5f;
        dropoffAt = 0.33f;
        if (yOff > dropoffAt) {
            intensity = 1f - 1f * (yOff - dropoffAt) / (1f - dropoffAt);
        }
        return intensity;
    }
    
    public float getFaderBrightness(float distAlong) {
        SlipstreamSegment curr = getSegmentForDist(distAlong);
        if (curr != null) {
            if (segments.size() > curr.index + 1) {
                SlipstreamSegment next = segments.get(curr.index + 1);
                float f = (distAlong - curr.totalLength) / curr.lengthToNext;
                if (f < 0) f = 0;
                if (f > 1) f = 1;
                return Misc.interpolate(curr.fader.getBrightness() * curr.bMult,
                                        next.fader.getBrightness() * next.bMult, f);
            } else {
                return 0f;
            }
        }
        return 0f;
    }
    
    protected transient SlipstreamBuilder builder = null;
    public SlipstreamBuilder getBuilder() {
        return builder;
    }
 
    public void setBuilder(SlipstreamBuilder builder) {
        this.builder = builder;
    }
    
    public SlipstreamParams2 getParams() {
        return params;
    }
 
    public void render(CampaignEngineLayers layer, ViewportAPI viewport) {
        //if (true) return;
        recomputeIfNeeded();
        if (lengthToIndexMap == null) return;
        
        float bMult = getAbyssalBMult(false);
        if (bMult <= 0f) return;
        
        if (false && builder != null) {
//          CampaignFleetAPI pf = Global.getSector().getPlayerFleet();
//          Vector2f loc = new Vector2f(pf.getLocation());
//          Vector2f loc = new Vector2f(segments.get(0).loc);
//          loc.x -= 500f;
//          loc.y -= 300f;
//          long seed = 23895464576452L + 4384357483229348234L;
//          seed = 1181783497276652981L ^ seed;
//          Random random = new Random(seed);
            
//          SlipstreamBuilder builder = new SlipstreamBuilder(loc, params, random);
//          builder.buildTest();
            builder.renderDebug(1f);
            return;
        }
        
        
        if (true && false) {
            //BoundingBox box = BoundingBox.create(segments);
            float mx = Mouse.getX();
            float my = Mouse.getY();
            float wmx = Global.getSector().getViewport().convertScreenXToWorldX(mx);
            float wmy = Global.getSector().getViewport().convertScreenYToWorldY(my);
            boolean inside = false;
            for (BoundingBox box : bounds) {
                box.renderDebug(1f);
                inside |= box.pointNeedsDetailedCheck(new Vector2f(wmx, wmy));
            }
            
            GL11.glDisable(GL11.GL_TEXTURE_2D);
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        
            GL11.glPointSize(20f);
            GL11.glEnable(GL11.GL_POINT_SMOOTH);
            if (inside) {
                Misc.setColor(Color.green);
            } else {
                Misc.setColor(Color.gray);
            }
            
            GL11.glBegin(GL11.GL_POINTS);
            GL11.glVertex2f(wmx, wmy);
            GL11.glEnd();
            //return;
        }
        
        
        
        
        float viewRadius = new Vector2f(viewport.getVisibleWidth() * 0.5f, viewport.getVisibleHeight() * 0.5f).length();
        viewRadius += 500f;
        
//      viewRadius *= 0.5f;
//      viewRadius = 500f;
        
        List<SlipstreamSegment> near = getSegmentsNear(viewport.getCenter(), viewRadius);
        Set<SlipstreamSegment> nearSet = new LinkedHashSet<SlipstreamSegment>(near);
        
        List<List<SlipstreamSegment>> subsections = new ArrayList<List<SlipstreamSegment>>();
        int prevIndex = -10;
        List<SlipstreamSegment> subsection = new ArrayList<SlipstreamSegment>();
        for (SlipstreamSegment seg : near) {
            if (prevIndex != seg.index - 1) {
                if (subsection != null && !subsection.isEmpty()) {
                    subsections.add(subsection);
                }
                subsection = new ArrayList<SlipstreamSegment>();
            }
            subsection.add(seg);
            prevIndex = seg.index;
        }
        if (subsection != null && !subsection.isEmpty()) {
            subsections.add(subsection);
        }
        
        SpriteAPI sprite0 = Global.getSettings().getSprite("misc", params.spriteKey1);
        sprite0.setNormalBlend();
        sprite0.setColor(params.spriteColor);
        SpriteAPI sprite1 = Global.getSettings().getSprite("misc", params.spriteKey2);
        sprite1.setNormalBlend();
        sprite1.setColor(params.spriteColor);
        SpriteAPI sprite2 = Global.getSettings().getSprite("misc", params.spriteKey3);
        sprite2.setNormalBlend();
        sprite2.setColor(params.spriteColor);
        
        SpriteAPI edge = Global.getSettings().getSprite("misc", params.edgeKey);
        edge.setNormalBlend();
        edge.setColor(params.edgeColor);
        
        //sprite.setColor(Misc.setAlpha(params.spriteColor1, 255));
        //sprite.setColor(Color.blue);
        for (List<SlipstreamSegment> subsection2 : subsections) {
            renderSegments(sprite0, sprite1, sprite2, edge, viewport.getAlphaMult(), subsection2, 0f, false);
        }
        
        //sprite.setColor(Color.red);
        //renderLayer(sprite, texProgress2, viewport.getAlphaMult());
        //sprite.setColor(Color.green);
        //renderLayer(sprite, texProgress3, viewport.getAlphaMult());
        
//      int state = 0;
//      for (int i = 0; i < segments.size() - 4; i += 2) {
//          //GL11.glBegin(GL11.GL_POINTS);
//          SlipstreamSegment prev = null;
//          if (i > 0) {
//              prev = segments.get(i - 1);
//          }
//          SlipstreamSegment curr = segments.get(i);
//          SlipstreamSegment next = segments.get(i + 1);   
//          SlipstreamSegment next2 = segments.get(i + 2);
//          SlipstreamSegment next3 = segments.get(i + 3);
//          Vector2f p0 = curr.loc;
//          Vector2f p1 = next.loc;
//          Vector2f p2 = next2.loc;
//          Vector2f p3 = next3.loc;
//          
//          if (state == 0) {
//              state = 1;
//              float p1ToP2 = Misc.getAngleInDegrees(p1, p2);
//              float p2ToP3 = Misc.getAngleInDegrees(p2, p3);
//              float diff = Misc.getAngleDiff(p1ToP2, p2ToP3);
//              float angle = p1ToP2 + Misc.getClosestTurnDirection(p1ToP2, p2ToP3) * diff * 0.5f + 180f;
//              angle = Misc.getAngleInDegrees(p3, p2);
//              float dist = Misc.getDistance(p2, p1);
//              Vector2f p1Adjusted = Misc.getUnitVectorAtDegreeAngle(angle);
//              p1Adjusted.scale(dist);
//              Vector2f.add(p1Adjusted, p2, p1Adjusted);
//              curr.locB.set(p1Adjusted);
//          } else if (state == 1) {
//              curr.locB.set(curr.loc);
//          } else if (state == 2) {
//              
//          }
//      }
        
        
        
        
        
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        
        float zoom = Global.getSector().getViewport().getViewMult(); 
 
        //GL11.glLineWidth(2f);
        //GL11.glLineWidth(Math.max(1f, 2f/zoom));
        GL11.glLineWidth(Math.max(1f, Math.min(2f, 2f/zoom)));
        //GL11.glLineWidth(1.5f);
        GL11.glEnable(GL11.GL_LINE_SMOOTH);
        
        Misc.setColor(new Color(1f, 1f, 1f, 0.5f));
        Misc.setColor(Color.white);
        //GL11.glLineWidth(1f);
        
//      for (SlipstreamSegment seg : segments) {
//          if (seg.totalLength <= 0f && segments.indexOf(seg) > 1) {
//              System.out.println("efwefwefwefe");
//          }
//      }
        
        // draw bezier lines for debug
        for (float offset = -1f; false && offset <= 1f; offset += 0.1f) {
        //for (float offset = 0f; offset <= 0f; offset += 0.1f) {
            GL11.glBegin(GL11.GL_LINE_STRIP);
            float incr = 10f;
            for (float len = 0; len < totalLength; len += incr) {
//              if (len > 10000f) {
//                  System.out.println("ewfwefew");
//              }
                /*
                SlipstreamSegment curr = getSegmentForDist(len);
                if (curr == null) continue;
                int index = curr.index;
                if (index >= segments.size() - 2) continue;
                SlipstreamSegment next = segments.get(index + 1);
                SlipstreamSegment next2 = segments.get(index + 2);
                
                if (index % 2 != 0) {
                    curr = segments.get(index - 1);
                    next = segments.get(index);
                    next2 = segments.get(index + 1);
                }
                
                float lenForT = len - curr.totalLength;
                float t = lenForT / (curr.lengthToNext + next.lengthToNext);
                
                //Vector2f p = Misc.bezier(curr.loc, next.loc, next2.loc, t);
                Vector2f p0 = curr.loc;
                Vector2f p1 = next.loc;
                Vector2f p2 = next2.loc;
                
                p0 = new Vector2f(p0);
                p0.x += curr.normal.x * params.width * 0.5f * offset;
                p0.y += curr.normal.y * params.width * 0.5f * offset;
                
                p2 = new Vector2f(p2);
                p2.x += next2.normal.x * params.width * 0.5f * offset;
                p2.y += next2.normal.y * params.width * 0.5f * offset;
                
                p1 = new Vector2f(next.locB);
                p1 = new Vector2f(p1);
                p1.x += next.normal.x * params.width * 0.5f * offset;
                p1.y += next.normal.y * params.width * 0.5f * offset;
                
                Vector2f p = Misc.bezier(p0, p1, p2, t);
                
//              float tPrev = (prev.lengthToNext + len) / (prev.lengthToNext + curr.lengthToNext);
//              Vector2f pPrev = Misc.bezier(prev.loc, curr.loc, next.loc, tPrev);
                //curr.lengthToNext + next.lengthToNext
//              float f = lenForT / curr.lengthToNext;
//              Vector2f perp;
//              if (f < 1f) {
//                  perp = Misc.interpolateVector(curr.normal, next.normal, f);
//              } else {
//                  f = (lenForT - curr.lengthToNext) / next.lengthToNext;
//                  perp = Misc.interpolateVector(next.normal, next2.normal, f);
//              }
//              perp.scale(offset * params.width * 0.5f);
                //perp.set(0, 0);
                
                //p = Misc.interpolateVector(pPrev, p, 0.5f);
                //GL11.glVertex2f(p.x + perp.x, p.y + perp.y);
                 * 
                 */
                
                Vector2f p = getPointAt(len, offset);
                if (p != null) {
                    GL11.glVertex2f(p.x, p.y);
                }
            }
            if (false) {
                Misc.setColor(Color.red);
                for (int i = 0; i < segments.size() - 3; i+=2) {
                    //GL11.glBegin(GL11.GL_POINTS);
                    SlipstreamSegment prev = null;
                    if (i > 0) {
                        prev = segments.get(i - 1);
                    }
                    SlipstreamSegment curr = segments.get(i);
                    SlipstreamSegment next = segments.get(i + 1);   
                    SlipstreamSegment next2 = segments.get(i + 2);
                    SlipstreamSegment next3 = segments.get(i + 3);
                    
        //          GL11.glVertex2f(curr.loc.x, curr.loc.y);
        //          GL11.glVertex2f(next.loc.x, next.loc.y);
        //          GL11.glVertex2f(next2.loc.x, next2.loc.y);
                    
                    Vector2f p0 = curr.loc;
                    Vector2f p1 = next.loc;
                    Vector2f p2 = next2.loc;
                    Vector2f p3 = next3.loc;
                    
    //              float p1ToP2 = Misc.getAngleInDegrees(p1, p2);
    //              float p2ToP3 = Misc.getAngleInDegrees(p2, p3);
    //              float diff = Misc.getAngleDiff(p1ToP2, p2ToP3);
    //              float adjustment = Math.min(diff, Math.max(diff * 0.25f, diff - 10f));
    //              adjustment = diff * 0.5f;
    //              //adjustment = diff * 0.25f;
    //              float angle = p1ToP2 + Misc.getClosestTurnDirection(p1ToP2, p2ToP3) * adjustment * 1f + 180f;
    //              //angle = Misc.getAngleInDegrees(p3, p2);
    //              float dist = Misc.getDistance(p2, p1);
    //              Vector2f p1Adjusted = Misc.getUnitVectorAtDegreeAngle(angle);
    //              p1Adjusted.scale(dist);
    //              Vector2f.add(p1Adjusted, p2, p1Adjusted);
                    
                    //GL11.glVertex2f(p1Adjusted.x, p1Adjusted.y);
                    //GL11.glVertex2f(p1.x, p1.y);
                    
                    p0 = new Vector2f(p0);
                    p0.x += curr.normal.x * curr.width * 0.5f * offset;
                    p0.y += curr.normal.y * curr.width * 0.5f * offset;
                    
                    p2 = new Vector2f(p2);
                    p2.x += next2.normal.x * next2.width * 0.5f * offset;
                    p2.y += next2.normal.y * next2.width * 0.5f * offset;
                    
                    p1 = new Vector2f(next.locB);
                    p1 = new Vector2f(p1);
                    p1.x += next.normal.x * next.width * 0.5f * offset;
                    p1.y += next.normal.y * next.width * 0.5f * offset;
                    
    //              p1ToP2 = Misc.getAngleInDegrees(p1, p2);
    //              p2ToP3 = Misc.getAngleInDegrees(p2, p3);
    //              diff = Misc.getAngleDiff(p1ToP2, p2ToP3);
    //              adjustment = Math.min(diff, Math.max(diff * 0.25f, diff - 10f));
    //              adjustment = diff * 0.5f;
    //              //adjustment = diff * 0.25f;
    //              angle = p1ToP2 + Misc.getClosestTurnDirection(p1ToP2, p2ToP3) * adjustment * 1f + 180f;
    //              //angle = Misc.getAngleInDegrees(p3, p2);
    //              dist = Misc.getDistance(p2, p1);
    //              p1Adjusted = Misc.getUnitVectorAtDegreeAngle(angle);
    //              p1Adjusted.scale(dist);
    //              Vector2f.add(p1Adjusted, p2, p1Adjusted);
                    
                    incr = 10f;
                    for (float len = 0; len < curr.lengthToNext + next.lengthToNext; len += incr) {
                        float t = len / (curr.lengthToNext + next.lengthToNext);
                        //Vector2f p = Misc.bezier(curr.loc, next.loc, next2.loc, t);
                        Vector2f p = Misc.bezier(p0, p1, p2, t);
                        
        //              float tPrev = (prev.lengthToNext + len) / (prev.lengthToNext + curr.lengthToNext);
        //              Vector2f pPrev = Misc.bezier(prev.loc, curr.loc, next.loc, tPrev);
                        
                        float f = len / curr.lengthToNext;
                        Vector2f perp;
                        if (f < 1f) {
                            perp = Misc.interpolateVector(curr.normal, next.normal, f);
                        } else {
                            f = (len - curr.lengthToNext) / next.lengthToNext;
                            perp = Misc.interpolateVector(next.normal, next2.normal, f);
                        }
                        perp.scale(offset * curr.width * 0.5f);
                        perp.set(0, 0);
                        
                        //p = Misc.interpolateVector(pPrev, p, 0.5f);
                        GL11.glVertex2f(p.x, p.y);
                        //GL11.glVertex2f(p.x + perp.x, p.y + perp.y);
                        //GL11.glVertex2f(pPrev.x, pPrev.y);
                    }
                    //if (i == 4) break;
                }
            }
            GL11.glEnd();
        }
        
//      GL11.glBegin(GL11.GL_LINES);
//      for (int i = 0; i < segments.size() - 4; i+=2) {
//          //GL11.glBegin(GL11.GL_POINTS);
//          SlipstreamSegment prev = null;
//          if (i > 0) {
//              prev = segments.get(i - 1);
//          }
//          SlipstreamSegment curr = segments.get(i);
//          SlipstreamSegment next = segments.get(i + 1);   
//          SlipstreamSegment next2 = segments.get(i + 2);
//          SlipstreamSegment next3 = segments.get(i + 3);
//          
//          
//          Vector2f p0 = curr.loc;
//          Vector2f p1 = next.loc;
//          Vector2f p2 = next2.loc;
//          Vector2f p3 = next3.loc;
//          
//          float p1ToP2 = Misc.getAngleInDegrees(p1, p2);
//          float p2ToP3 = Misc.getAngleInDegrees(p2, p3);
//          float diff = Misc.getAngleDiff(p1ToP2, p2ToP3);
//          float adjustment = Math.min(diff, Math.max(diff * 0.25f, diff - 10f));
//          adjustment = diff * 0.5f;
//          //adjustment = diff * 0.25f;
//          float angle = p1ToP2 + Misc.getClosestTurnDirection(p1ToP2, p2ToP3) * adjustment * 1f + 180f;
//          //angle = Misc.getAngleInDegrees(p3, p2);
//          float dist = Misc.getDistance(p2, p1);
//          Vector2f p1Adjusted = Misc.getUnitVectorAtDegreeAngle(angle);
//          p1Adjusted.scale(dist);
//          Vector2f.add(p1Adjusted, p2, p1Adjusted);
//          
//          //skip = diff < 30f;
//          skip = false;
//          if (skip) p1Adjusted.set(p1);
//          skip = !skip;
//          
//          prevAdjustedP1 = p1Adjusted;
//          //GL11.glVertex2f(p1Adjusted.x, p1Adjusted.y);
//          //GL11.glVertex2f(p1.x, p1.y);
//          
//          float incr = 10f;
//          Misc.setColor(new Color(1f, 0.5f, 0f, 1f));
//          for (float len = 0; len < curr.lengthToNext + next.lengthToNext; len += incr) {
//              float t = len / (curr.lengthToNext + next.lengthToNext);
//              //Vector2f p = Misc.bezier(curr.loc, next.loc, next2.loc, t);
//              Vector2f p = Misc.bezier(curr.loc, p1Adjusted, next2.loc, t);
//              
//              float f = len / curr.lengthToNext;
//              Vector2f perp;
//              if (f < 1f) {
//                  perp = Misc.interpolateVector(curr.normal, next.normal, f);
//              } else {
//                  f = (len - curr.lengthToNext) / next.lengthToNext;
//                  perp = Misc.interpolateVector(next.normal, next2.normal, f);
//              }
//              
//              
//              perp.scale(1f * params.width * 0.5f);
//              
//              //p = Misc.interpolateVector(pPrev, p, 0.5f);
//              //GL11.glVertex2f(p.x, p.y);
//              GL11.glVertex2f(p.x + perp.x, p.y + perp.y);
//              GL11.glVertex2f(p.x - perp.x, p.y - perp.y);
//              //GL11.glVertex2f(pPrev.x, pPrev.y);
//          }
//          //if (i == 4) break;
//      }
//      GL11.glEnd();
        
//      GL11.glPointSize(10);
//      GL11.glBegin(GL11.GL_POINTS);
//      for (int i = 0; i < segments.size() - 4; i+=2) {
//          if (i % 4 == 0) {
//              Misc.setColor(Color.red);
//          } else {
//              Misc.setColor(Color.green);
//          }
//          //GL11.glBegin(GL11.GL_POINTS);
//          //SlipstreamSegment prev = segments.get(i);
//          SlipstreamSegment curr = segments.get(i);
//          SlipstreamSegment next = segments.get(i + 1);   
//          SlipstreamSegment next2 = segments.get(i + 2);
//          SlipstreamSegment next3 = segments.get(i + 3);
//          
//          
//          Vector2f p0 = curr.loc;
//          Vector2f p1 = next.loc;
//          Vector2f p2 = next2.loc;
//          Vector2f p3 = next3.loc;
//          
//          float p1ToP2 = Misc.getAngleInDegrees(p1, p2);
//          float p2ToP3 = Misc.getAngleInDegrees(p2, p3);
//          float diff = Misc.getAngleDiff(p1ToP2, p2ToP3);
//          float angle = p1ToP2 + Misc.getClosestTurnDirection(p1ToP2, p2ToP3) * diff * 1f + 180f;
//          //angle = Misc.getAngleInDegrees(p3, p2);
//          float dist = Misc.getDistance(p2, p1);
//          Vector2f p1Adjusted = Misc.getUnitVectorAtDegreeAngle(angle);
//          p1Adjusted.scale(dist);
//          Vector2f.add(p1Adjusted, p2, p1Adjusted);
//          prevAdjustedP1 = p1Adjusted;
//          //GL11.glVertex2f(p1Adjusted.x, p1Adjusted.y);
//          //GL11.glVertex2f(p1.x, p1.y);
//          
//          GL11.glVertex2f(p0.x, p0.y);
//          GL11.glVertex2f(p1Adjusted.x, p1Adjusted.y);
//          GL11.glVertex2f(p2.x, p2.y);
//      }
//      GL11.glEnd();
        
        if (false) {
            float[] place = getLengthAndWidthFractionWithinStream(Global.getSector().getPlayerFleet().getLocation());
            if (place != null) {
                Misc.setColor(Color.red);
                GL11.glPointSize(40f/zoom);
                GL11.glEnable(GL11.GL_POINT_SMOOTH);
                GL11.glBegin(GL11.GL_POINTS);
                Vector2f p = getPointAt(place[0], place[1]);
                
                GL11.glVertex2f(p.x, p.y);
                
                Misc.setColor(Color.blue);
                p = Global.getSector().getPlayerFleet().getLocation();
                GL11.glVertex2f(p.x, p.y);
                
                SlipstreamSegment seg = getSegmentForDist(place[0]);
                if (seg != null) {
                    float withinSeg = place[0] - seg.totalLength;
                    Vector2f p2 = new Vector2f(seg.normal.y, -seg.normal.x);
                    p2.scale(withinSeg);
                    Vector2f.add(p2, seg.loc, p2);
                    float width = seg.wobbledWidth;
                    if (segments.size() > seg.index + 1) {
                        SlipstreamSegment next = segments.get(seg.index + 1);
                        width = Misc.interpolate(seg.wobbledWidth, next.wobbledWidth, 
                                (place[0] - seg.totalLength) / seg.lengthToNext);
                    }
                    p2.x += getNormalAt(place[0]).x * place[1] * width * 0.5f;
                    p2.y += getNormalAt(place[0]).y * place[1] * width * 0.5f;
                    Misc.setColor(Color.green);
                    GL11.glVertex2f(p2.x, p2.y);
                }
                GL11.glEnd();
            }
        }
        
//      GL11.glBegin(GL11.GL_LINE_STRIP);
//      for (int i = 1; i < segments.size() - 2; i++) {
//          SlipstreamSegment prev = segments.get(i);
//          SlipstreamSegment curr = segments.get(i);
//          SlipstreamSegment next = segments.get(i + 1);   
//          SlipstreamSegment next2 = segments.get(i + 2);
//          
//          float incr = 5f;
//          for (float len = 0; len < curr.lengthToNext; len += incr) {
//              float t = len / (curr.lengthToNext + next.lengthToNext);
//              Vector2f p = Misc.bezier(curr.loc, next.loc, next2.loc, t);
//              
//              float tPrev = (prev.lengthToNext + len) / (prev.lengthToNext + curr.lengthToNext);
//              Vector2f pPrev = Misc.bezier(prev.loc, curr.loc, next.loc, tPrev);
//              
//              //p = Misc.interpolateVector(pPrev, p, 0.5f);
//              //GL11.glVertex2f(p.x, p.y);
//              GL11.glVertex2f(pPrev.x, pPrev.y);
//          }
//          if (i == 4) break;
//      }
//      GL11.glEnd();
        
        //if (true) return;
        boolean curvedTrails = true;
        boolean useTex = false;
        useTex = !Global.getSettings().getBoolean("slipstreamUseGLLines");
        //if (zoom > 1.25f) useTex = false;
        //useTex = true;
        //System.out.println("USETEX = " + useTex);
        if (!useTex) {
            GL11.glDisable(GL11.GL_TEXTURE_2D);
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glLineWidth(Math.max(1f, Math.min(2f, 2f/zoom)));
            //GL11.glLineWidth(25f);
            GL11.glEnable(GL11.GL_LINE_SMOOTH);
            GL11.glHint(GL11.GL_LINE_SMOOTH_HINT, GL11.GL_NICEST);
        }
        
        //curvedTrails = false;
        if (!curvedTrails) {
            GL11.glBegin(GL11.GL_LINES);
        }
//      GL11.glEnable(GL11.GL_POINT_SMOOTH);
//      GL11.glPointSize(10f);
//      GL11.glBegin(GL11.GL_POINTS);
        //int index = 0;
        
        if (useTex) {
            GL11.glEnable(GL11.GL_TEXTURE_2D);
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
            
            SpriteAPI line = Global.getSettings().getSprite("graphics/hud/line4x4.png");
            //line = Global.getSettings().getSprite("graphics/hud/line32x32.png");
            line.bindTexture();
        } else {
            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        }
        
        for (SlipstreamParticle p : particles) {
            SlipstreamSegment seg = getSegmentForDist(p.dist);
            if (seg == null || !nearSet.contains(seg)) continue; 
            
//          index++;
//          if (index > 1) break;
            //if (true) break;
            float a = viewport.getAlphaMult();
            if (p.remaining <= 0.5f) {
                a = p.remaining / 0.5f;
            } else if (p.elapsed < params.particleFadeInTime) {
                a = p.elapsed / params.particleFadeInTime;
            }
            
            a *= getFaderBrightness(p.dist);
            a *= bMult;
            
            //a *= 0.5f;
            //a *= 0.1f;
            
            //a = 1f;
            
//          SlipstreamSegment seg = getSegmentForDist(p.dist);
//          if (seg == null) continue;
            float yPos = p.yPos;
            //yPos = 0f;
            
            if (curvedTrails) {
                if (useTex) {
                    GL11.glBegin(GL11.GL_QUAD_STRIP);
                    Vector2f curr = getPointAt(p.dist, yPos);
                    if (curr == null || !viewport.isNearViewport(curr, p.speed * params.lineLengthFractionOfSpeed + 50f)) {
                        GL11.glEnd();
                        continue;
                    }
                    float iter = 5f;
                    float incr = p.speed * params.lineLengthFractionOfSpeed / iter;
                    float lw = 1f;
                    for (float i = 0; i < iter; i++) {
                        float min = incr * 1f;
                        float dist = p.dist - i * incr - min;
                        Vector2f next = getPointAt(dist, yPos);
                        if (next == null) break;
                        
                        Vector2f perp = getNormalAt(dist);
                        if (perp == null) {
                            GL11.glEnd();
                            break;
                        }
                        
                        float a1 = a * (iter - i) / (iter - 1);
                        if (i == 0) a1 = 0f;
                        
                        Misc.setColor(p.color, a1);
                        GL11.glTexCoord2f(0, 0f);
                        GL11.glVertex2f(curr.x + perp.x * lw, curr.y + perp.y * lw);
                        GL11.glTexCoord2f(0, 1f);
                        GL11.glVertex2f(curr.x - perp.x * lw, curr.y - perp.y * lw);
                        curr = next;
                    }
                    GL11.glEnd();
                } else {
                    GL11.glBegin(GL11.GL_LINE_STRIP);
                    //GL11.glBegin(GL11.GL_LINES);
                    Vector2f curr = getPointAt(p.dist, yPos);
                    if (curr == null || !viewport.isNearViewport(curr, p.speed * params.lineLengthFractionOfSpeed + 50f)) {
                        GL11.glEnd();
                        continue;
                    }
                    float iter = 5f;
                    float incr = p.speed * params.lineLengthFractionOfSpeed / iter;
                    for (float i = 0; i < iter; i++) {
                        
                        float min = incr * 0.5f;
                        Vector2f next = getPointAt(p.dist - i * incr - min, yPos);
                        if (next == null) {
                            GL11.glEnd();
                            break;
                        }
                        
                        float a1 = a * (iter - i) / (iter - 1);
                        //float a2 = a * (iter - i - 1) / (iter - 1);
                        if (i == 0) a1 = 0f;
                        
                        Misc.setColor(p.color, a1);
                        GL11.glVertex2f(curr.x, curr.y);
                        //Misc.setColor(p.color, a2);
                        //GL11.glVertex2f(next.x, next.y);
                        curr = next;
                    }
                    GL11.glEnd();
                }
            } else {
                Vector2f start = getPointAt(p.dist + p.speed * params.lineLengthFractionOfSpeed * 0.1f, yPos);
                if (start == null || !viewport.isNearViewport(start, 500)) continue;
                
                Vector2f mid = getPointAt(p.dist, yPos);
                if (mid == null) continue;
                Vector2f end = getPointAt(p.dist - p.speed * params.lineLengthFractionOfSpeed * 0.9f, yPos);
                if (end == null) continue;
                
                Misc.setColor(p.color, 0f);
                GL11.glVertex2f(start.x, start.y);
                Misc.setColor(p.color, a);
                GL11.glVertex2f(mid.x, mid.y);
                GL11.glVertex2f(mid.x, mid.y);
                Misc.setColor(p.color, 0f);
                GL11.glVertex2f(end.x, end.y);
            }
//          
        }
        if (!curvedTrails) {
            GL11.glEnd();
        }
    }
    
    
//  public void renderSegments(SpriteAPI sprite, SpriteAPI edge, float alpha, List<SlipstreamSegment> segments) {
//      renderSegments(sprite, edge, alpha, segments, 0f);
//  }
    
    public float getAbyssalBMult(boolean forMap) {
        if (forMap) return 1f;
        if (entity.hasTag(Tags.SLIPSTREAM_VISIBLE_IN_ABYSS)) return 1f;
        float bMult = 1f;
        if (!forMap) {
            CampaignFleetAPI playerFleet = Global.getSector().getPlayerFleet();
            if (playerFleet != null) {
                float depth = Misc.getAbyssalDepth(playerFleet);
                if (depth > 0) {
                    bMult = Math.max(0f, 1f - depth);
                }
            }
        }
        return bMult;
    }
    
    public void renderSegments(SpriteAPI sprite0, SpriteAPI sprite1, SpriteAPI sprite2, 
                               SpriteAPI edge, float alpha, List<SlipstreamSegment> segments, float extraTX, boolean forMap) {
        //if (true) return;
        
        float bMult = getAbyssalBMult(forMap);
        if (bMult <= 0f) return;
        
        
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_BLEND);
        //GL11.glDisable(GL11.GL_BLEND);
        //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
 
        //color = Misc.interpolateColor(color, Color.black, 0.5f);
        //color = Color.black;
        //color = Misc.scaleColorOnly(color, 0.25f);
        //color = Misc.setAlpha(color, 100);
 
        boolean wireframe = false;
        //wireframe = true;
        if (wireframe) {
            GL11.glLineWidth(1f);
            GL11.glEnable(GL11.GL_LINE_SMOOTH);
            GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
            GL11.glDisable(GL11.GL_TEXTURE_2D);
            GL11.glDisable(GL11.GL_BLEND);
            
            Misc.setColor(Color.yellow);
            GL11.glEnable(GL11.GL_LINE_SMOOTH);
            //GL11.glLineWidth(3f);
            GL11.glBegin(GL11.GL_LINE_STRIP);
            for (SlipstreamSegment curr : segments) {
                GL11.glVertex2f(curr.loc.x, curr.loc.y);
            }
            GL11.glEnd();
        }
        
        boolean subtract = false;
        //subtract = true;
        if (subtract) {
            GL14.glBlendEquation(GL14.GL_FUNC_REVERSE_SUBTRACT);
        }
        
        // main background
        if (!wireframe) {
            GL11.glEnable(GL11.GL_TEXTURE_2D);
            GL11.glEnable(GL11.GL_BLEND);
        }
        //GL11.glDisable(GL11.GL_BLEND);
        //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        
        if (!forMap) extraTX = texProgress0;
        
        sprite0.bindTexture();
        Color color = sprite0.getColor();
        GL11.glBegin(GL11.GL_QUAD_STRIP);
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment curr = segments.get(i);
            float a = curr.fader.getBrightness() * curr.bMult * bMult;
            if (i == 0 || i == segments.size() - 1) a = 0f;
            
            Vector2f p1 = new Vector2f(curr.loc);
            p1.x += curr.normal.x * curr.width * 0.5f;
            p1.y += curr.normal.y * curr.width * 0.5f;
            Vector2f p2 = new Vector2f(curr.loc);
            p2.x -= curr.normal.x * curr.width * 0.5f;
            p2.y -= curr.normal.y * curr.width * 0.5f;
            
            if (!forMap) {
                p1.x += curr.wobble1.vector.x;
                p1.y += curr.wobble1.vector.y;
                p2.x += curr.wobble2.vector.x;
                p2.y += curr.wobble2.vector.y;
            }
            
            Misc.setColor(color, alpha * 1f * a);
            GL11.glTexCoord2f(curr.tx + extraTX, 0f);
            GL11.glVertex2f(p1.x, p1.y);
            GL11.glTexCoord2f(curr.tx + extraTX, 1f);
            GL11.glVertex2f(p2.x, p2.y);
        }
        GL11.glEnd();
        
        if (!forMap) {
            sprite1.bindTexture();
            color = sprite1.getColor();
            GL11.glBegin(GL11.GL_QUAD_STRIP);
            for (int i = 0; i < segments.size(); i++) {
                SlipstreamSegment curr = segments.get(i);
                float a = curr.fader.getBrightness() * curr.bMult * bMult;
                if (i == 0 || i == segments.size() - 1) a = 0f;
                
                Vector2f p1 = new Vector2f(curr.loc);
                p1.x += curr.normal.x * curr.width * 0.5f;
                p1.y += curr.normal.y * curr.width * 0.5f;
                Vector2f p2 = new Vector2f(curr.loc);
                p2.x -= curr.normal.x * curr.width * 0.5f;
                p2.y -= curr.normal.y * curr.width * 0.5f;
                
                p1.x += curr.wobble1.vector.x;
                p1.y += curr.wobble1.vector.y;
                p2.x += curr.wobble2.vector.x;
                p2.y += curr.wobble2.vector.y;
                
                Misc.setColor(color, alpha * 1f * a);
                GL11.glTexCoord2f(curr.tx + texProgress1, 0f);
                GL11.glVertex2f(p1.x, p1.y);
                GL11.glTexCoord2f(curr.tx + texProgress1, 1f);
                GL11.glVertex2f(p2.x, p2.y);
            }
            GL11.glEnd();
            
            sprite2.bindTexture();
            color = sprite2.getColor();
            GL11.glBegin(GL11.GL_QUAD_STRIP);
            for (int i = 0; i < segments.size(); i++) {
                SlipstreamSegment curr = segments.get(i);
                float a = curr.fader.getBrightness() * curr.bMult * bMult;
                if (i == 0 || i == segments.size() - 1) a = 0f;
 
                Vector2f p1 = new Vector2f(curr.loc);
                p1.x += curr.normal.x * curr.width * 0.5f;
                p1.y += curr.normal.y * curr.width * 0.5f;
                Vector2f p2 = new Vector2f(curr.loc);
                p2.x -= curr.normal.x * curr.width * 0.5f;
                p2.y -= curr.normal.y * curr.width * 0.5f;
                
                p1.x += curr.wobble1.vector.x;
                p1.y += curr.wobble1.vector.y;
                p2.x += curr.wobble2.vector.x;
                p2.y += curr.wobble2.vector.y;
                
                Misc.setColor(color, alpha * 1f * a);
                GL11.glTexCoord2f(curr.tx + texProgress2, 0f);
                GL11.glVertex2f(p1.x, p1.y);
                GL11.glTexCoord2f(curr.tx + texProgress2, 1f);
                GL11.glVertex2f(p2.x, p2.y);
            }
            GL11.glEnd();
        }
        
        
        // edges
        color = edge.getColor();
        float wobbleMult = 0.5f;
        edge.bindTexture();
        //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        
        GL11.glBegin(GL11.GL_QUAD_STRIP);
        
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment curr = segments.get(i);
            float a = curr.fader.getBrightness() * curr.bMult * bMult;
            if (i == 0 || i == segments.size() - 1) a = 0f;
            
//          float width = getWidth(curr.totalLength);
//          float wobbled = getWobbledWidth(curr.totalLength);
//          float yOff = width / wobbled; 
//          Vector2f p1 = getPointAt(curr.totalLength, yOff);
//          Vector2f p2 = getPointAt(curr.totalLength, yOff);
//          if (p1 == null) {
//              System.out.println("efwefwefew");
//              p1 = getPointAt(curr.totalLength, yOff);
//          }
//          p2 = new Vector2f(p1);
            
            Vector2f p1 = new Vector2f(curr.loc);
            Vector2f p2 = new Vector2f(curr.loc);
            p1.x += curr.normal.x * curr.width * 0.5f;
            p1.y += curr.normal.y * curr.width * 0.5f;
            p2.x += curr.normal.x * (curr.width * 0.5f - params.edgeWidth);
            p2.y += curr.normal.y * (curr.width * 0.5f - params.edgeWidth);
            
//          p2.x += curr.normal.x * -params.edgeWidth;
//          p2.y += curr.normal.y * -params.edgeWidth;
            
            if (!forMap) {
                p1.x += curr.wobble1.vector.x * wobbleMult;
                p1.y += curr.wobble1.vector.y * wobbleMult;
                p2.x += curr.wobble1.vector.x * wobbleMult;
                p2.y += curr.wobble1.vector.y * wobbleMult;
            }
            
            Misc.setColor(color, alpha * 1f * a);
            GL11.glTexCoord2f(curr.txe1, 1f);
            GL11.glVertex2f(p1.x, p1.y);
            GL11.glTexCoord2f(curr.txe1, 0f);
            GL11.glVertex2f(p2.x, p2.y);
        }
        GL11.glEnd();
        
        //edge2.bindTexture();
        GL11.glBegin(GL11.GL_QUAD_STRIP);
        
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment curr = segments.get(i);
            float a = curr.fader.getBrightness() * curr.bMult * bMult;
            if (i == 0 || i == segments.size() - 1) a = 0f;
            
            Vector2f p1 = new Vector2f(curr.loc);
            p1.x -= curr.normal.x * curr.width * 0.5f;
            p1.y -= curr.normal.y * curr.width * 0.5f;
            Vector2f p2 = new Vector2f(curr.loc);
            p2.x -= curr.normal.x * (curr.width * 0.5f - params.edgeWidth);
            p2.y -= curr.normal.y * (curr.width * 0.5f - params.edgeWidth);
            
            if (!forMap) {
                p1.x += curr.wobble2.vector.x * wobbleMult;
                p1.y += curr.wobble2.vector.y * wobbleMult;
                p2.x += curr.wobble2.vector.x * wobbleMult;
                p2.y += curr.wobble2.vector.y * wobbleMult;
            }
            
            Misc.setColor(color, alpha * 1f * a);
            GL11.glTexCoord2f(curr.txe2, 1f);
            GL11.glVertex2f(p1.x, p1.y);
            GL11.glTexCoord2f(curr.txe2, 0f);
            GL11.glVertex2f(p2.x, p2.y);
        }
        GL11.glEnd();
        
        
        if (subtract) {
            GL14.glBlendEquation(GL14.GL_FUNC_ADD);
        }
        
        if (wireframe) GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
    }
 
    
    
    
    
    public Color getRandomColor() {
        return Misc.interpolateColor(params.minColor, params.maxColor, (float) Math.random());
    }
    
    public float getTotalLength() {
        return totalLength;
    }
    
 
    public float [] getLengthAndWidthFractionWithinStream(Vector2f loc) {
        return getLengthAndWidthFractionWithinStream(loc, 0f, false, 0f);
    }
    public float [] getLengthAndWidthFractionWithinStream(Vector2f loc, float extraRangeForCheck, boolean allowOutsideStream, float extraWidthForSegments) {
        recomputeIfNeeded();
        
        float dist = Misc.getDistance(loc, entity.getLocation());
        if (dist > getRenderRange()) return null;
        
        List<SlipstreamSegment> near = getSegmentsNear(loc, extraRangeForCheck);
        
        for (SlipstreamSegment curr : near) {
            SlipstreamSegment next = null;
            if (segments.size() > curr.index + 1) {
                next = segments.get(curr.index + 1);
            } else {
                next = new SlipstreamSegment();
                //next2.width = next.width;
                next.wobbledWidth = curr.wobbledWidth;
                
                next.normal = curr.normal;
                //next2.dir = next.dir;
                next.loc = new Vector2f(curr.dir);
                next.loc.scale(curr.lengthToPrev);
                Vector2f.add(next.loc, curr.loc, next.loc);
                //next2.locB = next2.loc;
                next.lengthToPrev = curr.lengthToPrev;
                //continue;
            }
                
            Vector2f p3 = loc;
            Vector2f p1 = curr.loc;
            Vector2f p2 = next.loc;
            
            Vector2f currNormalP1 = new Vector2f(curr.loc);
            Vector2f currNormalP2 = new Vector2f(curr.normal);
            currNormalP2.scale(100f);
            Vector2f.add(currNormalP2, currNormalP1, currNormalP2);
            
            Vector2f nextNormalP1 = new Vector2f(next.loc);
            Vector2f nextNormalP2 = new Vector2f(next.normal);
            nextNormalP2.scale(100f);
            Vector2f.add(nextNormalP2, nextNormalP1, nextNormalP2);
            
            //Vector2f dir = Misc.getUnitVectorAtDegreeAngle(Misc.getAngleInDegrees(p1, p2));
            Vector2f dir = new Vector2f(curr.dir);
            dir.scale(100f);
            Vector2f p4 = Vector2f.add(p3, dir, new Vector2f());
            
            Vector2f currNormalP = Misc.intersectLines(currNormalP1, currNormalP2, p3, p4);
            if (currNormalP == null) continue;
            Vector2f nextNormalP = Misc.intersectLines(nextNormalP1, nextNormalP2, p3, p4);
            if (nextNormalP == null) continue;
            
            float u = (p3.x - currNormalP.x) * (nextNormalP.x - currNormalP.x) + 
                            (p3.y - currNormalP.y) * (nextNormalP.y - currNormalP.y);
            float denom = Vector2f.sub(nextNormalP, currNormalP, new Vector2f()).length();
            denom *= denom;
            if (denom == 0) continue;
            u /= denom;
            
            if (u >= 0 && u <= 1) { // p3 is between the two points on the normals
                Vector2f normalAtP3 = Misc.interpolateVector(curr.normal, next.normal, u);
                normalAtP3.scale(100f);
                Vector2f p3PlusNormal = Vector2f.add(p3, normalAtP3, new Vector2f());
                
                Vector2f intersect = Misc.intersectLines(p1, p2, p3, p3PlusNormal);
                if (intersect == null) continue;
                
                float distFromLine = Vector2f.sub(intersect, p3, new Vector2f()).length();
                float width = Misc.interpolate(curr.wobbledWidth, next.wobbledWidth, u);
                width += extraWidthForSegments;
                if (distFromLine >= width / 2f && !allowOutsideStream) return null;
                
                float [] result = new float[2];
                //result[0] = curr.totalLength + u * curr.lengthToNext;
                result[0] = curr.totalLength + u * next.lengthToPrev;
                result[1] = distFromLine / (width / 2f);
                
                float currToLoc = Misc.getAngleInDegrees(p1, p3);
                float segDir = Misc.getAngleInDegrees(p1, p2);
                if (Misc.getClosestTurnDirection(segDir, currToLoc) < 0) {
                    result[1] = -result[1]; 
                }
                
                return result;
            }
        }
        return null;
    }
    
    public void applyEffectToEntities(float amount) {
        if (entity.getContainingLocation() == null) return;
        
        float days = Global.getSector().getClock().convertToDays(amount);
        for (CampaignFleetAPI fleet : entity.getContainingLocation().getFleets()) {
            if (isPreventedFromAffecting(fleet)) continue;
            applyEffect(fleet, days);
        }
        //for (SectorEntityToken entity : entity.getContainingLocation().getEntitiesWithTag(Tags.GHOST)) {
        for (SectorEntityToken entity : entity.getContainingLocation().getCustomEntities()) {
            if (entity.hasTag(Tags.GHOST)) {
                if (isPreventedFromAffecting(entity)) continue;
                applyEffectToGhost(entity, days);
            } else if (Entities.WRECK.equals(entity.getCustomEntityType())) {
                if (isPreventedFromAffecting(entity)) continue;
                applyEffectToWreck(entity, days);
            }
            
        }
    }
    
    //protected boolean playerWasInSlipstream = false;
    protected int playerWasInSlipstreamFramesAgo = 1000;
    protected float playerDesiredYOffset = 1000;
    protected void playerNoLongerinSlipstream() {
        playerWasInSlipstreamFramesAgo++;
        if (playerWasInSlipstreamFramesAgo > 1000) {
            playerWasInSlipstreamFramesAgo = 1000;
        }
        playerDesiredYOffset = 1000;
    }
    public void applyEffect(SectorEntityToken other, float days) {
        if (other.hasTag(Tags.UNAFFECTED_BY_SLIPSTREAM)) return;
        
        if (!containsPoint(other.getLocation(), 0f)) {
            if (other.isPlayerFleet()) {
                playerNoLongerinSlipstream();
            }
            return;
        }
        
        if (other instanceof CampaignFleetAPI) {
            CampaignFleetAPI fleet = (CampaignFleetAPI) other;
            
//          if (fleet.isPlayerFleet()) {
//              if (getLengthAndWidthFractionWithinStream(fleet.getLocation()) == null) {
//                  System.out.println("wefwefwefe");
//              }
//              System.out.println("efwefwef");
//          }
            
            float [] offset = getLengthAndWidthFractionWithinStream(fleet.getLocation());
            if (offset == null) {
                if (fleet.isPlayerFleet()) {
                    playerNoLongerinSlipstream();
                }
                return;
            }
            
//          if (fleet.isPlayerFleet()) {
//              System.out.println("Location in stream: " + offset[0] + ", " + offset[1]);
//          }
            
            //params.burnLevel = 10;
            
            float distAlong = offset[0];
            float yOff = offset[1];
            
//          float intensity = 1f;
//          if (Math.abs(yOff) > 0.5f) {
//              intensity *= (1f - Math.abs(yOff)) / 0.5f;
//          }
            float intensity = getIntensity(yOff);
            float wMult = getWidthBasedSpeedMult(distAlong);
            //System.out.println("wMult: " + wMult);
            intensity *= wMult;
            intensity *= getFaderBrightness(distAlong);
            //intensity *= intensity;
            //System.out.println(intensity);
            
            if (intensity <= 0.05f) {
                if (fleet.isPlayerFleet()) {
                    playerNoLongerinSlipstream();
                }
                return;
            }
            
            preventOtherTerrainFromAffecting(fleet);
            fleet.getMemoryWithoutUpdate().set(SustainedBurnAbility.SB_NO_STOP, true, 0.1f);
            fleet.getMemoryWithoutUpdate().set(SustainedBurnAbility.SB_NO_SLOW, true, 0.1f);
            
            if (fleet.isPlayerFleet()) {
                //if (!playerWasInSlipstream) {
                //  playerWasInSlipstream = true;
                if (playerWasInSlipstreamFramesAgo > 5) {
                    String text = "Entering slipstream";
                    if (params.enteringSlipstreamTextOverride != null) {
                        text = params.enteringSlipstreamTextOverride;
                    }
                    float dur = 0.5f;
                    if (params.enteringSlipstreamTextDurationOverride != null) {
                        dur = params.enteringSlipstreamTextDurationOverride;
                    }
                    if (!text.isEmpty()) {
                        fleet.addFloatingText(text, Misc.setAlpha(fleet.getIndicatorColor(), 255), dur);
                    }
                }
                playerWasInSlipstreamFramesAgo = 0;
            }
            
            //System.out.println("Intensity: " + intensity);
 
            // "wind" effect - adjust velocity
            float maxFleetBurn = fleet.getFleetData().getBurnLevel();
            float currFleetBurn = fleet.getCurrBurnLevel();
            
            boolean reversePolarity = Misc.isReversePolarity(fleet);
            
            float maxWindBurn = params.burnLevel * 2f;
            float currWindBurn = intensity * maxWindBurn;
            float maxFleetBurnIntoWind = maxFleetBurn - Math.abs(currWindBurn);
            float seconds = days * Global.getSector().getClock().getSecondsPerDay();
            
            
//          float angle = Misc.getAngleInDegreesStrict(this.entity.getLocation(), fleet.getLocation()) + 180f;
//          Vector2f windDir = Misc.getUnitVectorAtDegreeAngle(angle);
            Vector2f p1 = getPointAt(distAlong, yOff);
            Vector2f p2 = getPointAt(distAlong + 1f, yOff);
            if (reversePolarity) {
                p1 = getPointAt(distAlong, yOff);
                p2 = getPointAt(distAlong - 1f, yOff);
            }
            if (p1 == null || p2 == null) {
                if (fleet.isPlayerFleet()) {
                    playerNoLongerinSlipstream();
                }
                return;
            }
            
            
            //Vector2f windDir = Misc.getUnitVectorAtDegreeAngle(entity.getFacing());
            Vector2f windDir = Misc.getUnitVectorAtDegreeAngle(Misc.getAngleInDegrees(p1, p2));
            if (currWindBurn < 0) {
                windDir.negate();
            }
            
            Vector2f velDir = Misc.normalise(new Vector2f(fleet.getVelocity()));
            //float baseFleetAccel = Misc.getSpeedForBurnLevel(fleet.getFleetData().getMinBurnLevel());
            float baseFleetAccel = fleet.getTravelSpeed();
            if (baseFleetAccel < 10f) baseFleetAccel = 10f;
            
            boolean fleetTryingToMove = fleet.getMoveDestination() != null && 
                    Misc.getDistance(fleet.getLocation(), fleet.getMoveDestination()) > fleet.getRadius() + 10f;
            if (fleet.isPlayerFleet()) {
                fleetTryingToMove &= (
                        Global.getSector().getCampaignUI().isPlayerFleetFollowingMouse() ||
                        fleet.wasSlowMoving()
                        );
                
                String key = "$slipstream_moveToYOffset";
                if (fleetTryingToMove && fleet.getMoveDestination() != null) {
//                  float mx = Mouse.getX();
//                  float my = Mouse.getY();
                    // this accounts for screen scaling
                    float mx = Global.getSettings().getMouseX();
                    float my = Global.getSettings().getMouseY();
                    float wmx = Global.getSector().getViewport().convertScreenXToWorldX(mx);
                    float wmy = Global.getSector().getViewport().convertScreenYToWorldY(my);
                    float [] desired = getLengthAndWidthFractionWithinStream(new Vector2f(wmx, wmy));
                    if (desired != null) {
                        playerDesiredYOffset = desired[1];
                        fleet.getMemoryWithoutUpdate().set(key, true, 0.2f);
                    } else {
                        playerDesiredYOffset = 1000f;
                    }
                }
                if (!fleet.getMemoryWithoutUpdate().getBoolean(key)) {
                    playerDesiredYOffset = 1000f;
                }
            }
            
            //System.out.println("PDY: " + playerDesiredYOffset);
            float windSpeedReduction = 0f;
            if (!fleetTryingToMove) {
                Vector2f dest = new Vector2f(windDir);
                dest.scale(1000f);
                if (playerDesiredYOffset <= 1f && playerDesiredYOffset >= -1f) {
                    float currOffset = offset[1];
                    float diff = playerDesiredYOffset - currOffset;
                    float sign = Math.signum(diff);
                    if (reversePolarity) {
                        sign = -sign;
                    }
                    float mult = Math.min(Math.abs(diff) * 1f, 1f);
                    dest = Misc.rotateAroundOrigin(dest, Math.min(60f, 60f * mult * 1f) * sign);
                }
                Vector2f.add(dest, fleet.getLocation(), dest);
                fleet.setMoveDestination(dest.x, dest.y);
            } else {
                Vector2f moveDir = Misc.getUnitVectorAtDegreeAngle(
                                Misc.getAngleInDegrees(fleet.getLocation(), fleet.getMoveDestination()));
                float dot = Vector2f.dot(windDir, moveDir);
                if (fleet.wasSlowMoving()) dot = -1f;
                if (dot < 0) {
                    float accelBasedMult = fleet.getAcceleration() / baseFleetAccel;
                    accelBasedMult *= accelBasedMult;
                    if (accelBasedMult > 1f) accelBasedMult = 1f;
                    if (accelBasedMult < 0.1f) accelBasedMult = 0.1f;
                    windSpeedReduction = -dot * fleet.getFleetData().getBurnLevel() * accelBasedMult;
                }
            }
            
            //float burnBonus = fleet.getFleetData().getBurnLevel() - fleet.getFleetData().getMinBurnLevelUnmodified();
            float burnBonus = fleet.getFleetData().getBurnLevel() - fleet.getFleetData().getMinBurnLevel();
            if (burnBonus < 0) burnBonus = 0;
            //float maxSpeedWithWind = Misc.getSpeedForBurnLevel(params.burnLevel + burnBonus);
            float maxSpeedWithWind = Misc.getSpeedForBurnLevel((params.burnLevel * intensity) + burnBonus);
            if (windSpeedReduction > 0) {
                maxSpeedWithWind = Misc.getSpeedForBurnLevel(
                            Math.max(params.burnLevel  * 0.5f * intensity, params.burnLevel * intensity - windSpeedReduction));
            }
            
            if (reversePolarity) {
                float polarityMult = fleet.getMemoryWithoutUpdate().getFloat(ReversePolarityToggle.POLARITY_SPEED_MULT);
                maxSpeedWithWind *= polarityMult;
                //System.out.println("MSWW: " + maxSpeedWithWind + ", mult: " + polarityMult);
                //maxSpeedWithWind *= ReversePolarity.SLIPSTREAM_SPEED_MULT;
            }
            
            float fleetSpeedAlongWind = Vector2f.dot(windDir, fleet.getVelocity());
            if (fleetSpeedAlongWind >= maxSpeedWithWind) {
//              float dotPlayerAndWindVel = Vector2f.dot(windDir, velDir);
//              if (dotPlayerAndWindVel > 0.98f) {
                    return;
                //}
            }
            
            velDir.scale(currFleetBurn);
            
            //float fleetBurnAgainstWind = -1f * Vector2f.dot(windDir, velDir);
            
            
            float windSpeed = Misc.getSpeedForBurnLevel(currWindBurn);
            //float fleetSpeed = fleet.getTravelSpeed();
            Vector2f windVector = new Vector2f(windDir);
            windVector.scale(windSpeed);
            
            Vector2f vel = fleet.getVelocity();
//          Vector2f diff = Vector2f.sub(windVector, vel, new Vector2f());
//          //windDir.scale(seconds * fleet.getAcceleration());
//          float max = diff.length();
//          diff = Misc.normalise(diff);
//          //diff.scale(Math.max(windSpeed * seconds, fleet.getAcceleration() * 1f * seconds));
//          diff.scale(fleet.getAcceleration() * 3f * seconds);
//          //diff.scale(fleet.getTravelSpeed() * 5f * seconds);
//          //diff.scale(accelMult);
//          if (diff.length() > max) {
//              diff.scale(max / diff.length());
//          }
            //System.out.println("Applying diff: " + diff);
            //fleet.setVelocity(vel.x + diff.x, vel.y + diff.y);
            
            
//          Vector2f velDir = Misc.normalise(new Vector2f(fleet.getVelocity()));
//          velDir.scale(currFleetBurn);
//          
//          float fleetBurnAgainstWind = -1f * Vector2f.dot(windDir, velDir);
            //System.out.println("fleetBurnAgainstWind: " + fleetBurnAgainstWind);
            float accelMult = 0.5f + 2f * intensity;
            accelMult += 0.25f * 20f * intensity;
//          if (fleetBurnAgainstWind > maxFleetBurnIntoWind) {
//              //accelMult += 0.75f + 0.25f * (fleetBurnAgainstWind - maxFleetBurnIntoWind);
//              accelMult += 0.25f * (fleetBurnAgainstWind - maxFleetBurnIntoWind);
//          } else {
//          }
            
            //if (fleetTryingToMove) accelMult *= 0.15f;
            //if (accelMult < 2f) accelMult = 2f;
            //wefwefwefew
            
            //Vector2f vel = fleet.getVelocity();
            //windDir.scale(seconds * fleet.getAcceleration() * accelMult);
            //float baseFleetAccel = Math.max(fleet.getTravelSpeed(), fleet.getAcceleration());
 
            float extraAccelMult = params.accelerationMult;
            windDir.scale(seconds * baseFleetAccel * accelMult * extraAccelMult);
            
            if (extraAccelMult > 1f) {
                float windAccelAmountThisFrame = windDir.length();
                float maxAccelThisFrame = maxSpeedWithWind - fleetSpeedAlongWind;
                
                if (windAccelAmountThisFrame > maxAccelThisFrame) {
                    float accelThisFrameMult = maxAccelThisFrame / Math.max(1f, windAccelAmountThisFrame);
                    if (accelThisFrameMult > 1f) accelThisFrameMult = 1f;
                    windDir.scale(accelThisFrameMult);
                }
            }
            
            fleet.setVelocity(vel.x + windDir.x, vel.y + windDir.y);
            
            fleet.getStats().addTemporaryModMult(0.1f, getModId() + "_1",
                    FUEL_USE_MODIFIER_DESC, FUEL_USE_MULT, 
                    fleet.getStats().getDynamic().getStat(Stats.FUEL_USE_NOT_SHOWN_ON_MAP_MULT));
                    //fleet.getStats().getFuelUseHyperMult());
            
            
            boolean withGlow = true;
            withGlow = !params.forceNoWindVisualEffectOnFleets;
            //withGlow = false;
            if (withGlow) {
                Color glowColor = params.windGlowColor;
                if (fleet.getMemoryWithoutUpdate().contains(ReversePolarityToggle.POLARITY_WIND_GLOW_COLOR_KEY)) {
                    glowColor = (Color) fleet.getMemoryWithoutUpdate().get(ReversePolarityToggle.POLARITY_WIND_GLOW_COLOR_KEY);
                }
                
                int alpha = glowColor.getAlpha();
                if (alpha < 75) {
                    glowColor = Misc.setAlpha(glowColor, 75);
                }
                // visual effects - glow, tail
                
                p1 = getNoWobblePointAt(distAlong, yOff);
                p2 = getNoWobblePointAt(distAlong + 100f, yOff);
                if (reversePolarity) {
                    p1 = getNoWobblePointAt(distAlong, yOff);
                    p2 = getNoWobblePointAt(distAlong - 100f, yOff);
                }
                if (p1 != null && p2 != null) {
                    windDir = Misc.getUnitVectorAtDegreeAngle(Misc.getAngleInDegrees(p1, p2));
                    
//                  float fleetSpeedAlongWind = Vector2f.dot(windDir, fleet.getVelocity());
//                  //float fleetSpeed = fleet.getVelocity().length();
//                  
//                  windSpeed = Misc.getSpeedForBurnLevel(params.burnLevel);
//                  float matchingWindFraction = fleetSpeedAlongWind/windSpeed;
//                  float effectMag = 1f - matchingWindFraction;
//                  if (effectMag < 0f)  effectMag = 0f;
                    //if (effectMag < 0.25f) effectMag = 0.25f;
                    //effectMag = 0.5f;
                    
                    String modId = "slipstream_" + entity.getId();
                    float durIn = 1f;
                    float durOut = 3f;
                    //durIn = 0.5f;
                    //float sizeNormal = (15f + 30f * effectMag * effectMag) * (intensity);
                    float sizeNormal = 5f + 10f * intensity;
                    for (FleetMemberViewAPI view : fleet.getViews()) {
                        view.getWindEffectDirX().shift(modId, windDir.x * sizeNormal, durIn, durOut, 1f);
                        view.getWindEffectDirY().shift(modId, windDir.y * sizeNormal, durIn, durOut, 1f);
                        view.getWindEffectColor().shift(modId, glowColor, durIn, durOut, 1f);
                    }
                }
            }
        }
    }
    
    
    public void applyEffectToGhost(SectorEntityToken other, float days) {
//      /if (true) return;
        //if (!(other.getCustomPlugin() instanceof SensorGhost)) return;
        
        SensorGhost ghost = SensorGhostManager.getGhostFor(other);
        if (ghost == null) return;
        
        if (other.hasTag(Tags.UNAFFECTED_BY_SLIPSTREAM)) return;
        
        //SensorGhost ghost = (SensorGhost) other.getCustomPlugin();
        if (!containsPoint(other.getLocation(), 0f)) {
            return;
        }
        
        float [] offset = getLengthAndWidthFractionWithinStream(other.getLocation());
        if (offset == null) {
            return;
        }
            
        float distAlong = offset[0];
        float yOff = offset[1];
            
        float intensity = getIntensity(yOff);
        float wMult = getWidthBasedSpeedMult(distAlong);
        intensity *= wMult;
        intensity *= getFaderBrightness(distAlong);
            
        if (intensity <= 0) {
            return;
        }
            
        float maxFleetBurn = ghost.getMaxBurn();
        float currFleetBurn = ghost.getCurrBurn();
            
        float maxWindBurn = params.burnLevel * 2f;
            
        float currWindBurn = intensity * maxWindBurn;
        float maxFleetBurnIntoWind = maxFleetBurn - Math.abs(currWindBurn);
        float seconds = days * Global.getSector().getClock().getSecondsPerDay();
            
        Vector2f p1 = getPointAt(distAlong, yOff);
        Vector2f p2 = getPointAt(distAlong + 1f, yOff);
        if (p1 == null || p2 == null) {
            return;
        }
            
        Vector2f windDir = Misc.getUnitVectorAtDegreeAngle(Misc.getAngleInDegrees(p1, p2));
        if (currWindBurn < 0) {
            windDir.negate();
        }
        Vector2f velDir = Misc.normalise(new Vector2f(other.getVelocity()));
        float baseFleetAccel = ghost.getAcceleration();
        if (baseFleetAccel < 10f) baseFleetAccel = 10f;
            
        velDir.scale(currFleetBurn);
            
        float fleetBurnAgainstWind = -1f * Vector2f.dot(windDir, velDir);
            
            
        float windSpeed = Misc.getSpeedForBurnLevel(currWindBurn);
        Vector2f windVector = new Vector2f(windDir);
        windVector.scale(windSpeed);
            
        Vector2f vel = other.getVelocity();
        Vector2f diff = Vector2f.sub(windVector, vel, new Vector2f());
        float max = diff.length();
        diff = Misc.normalise(diff);
        diff.scale(ghost.getAcceleration() * 3f * seconds);
        if (diff.length() > max) {
            diff.scale(max / diff.length());
        }
        float accelMult = 0.5f + 2f * intensity;
        if (fleetBurnAgainstWind > maxFleetBurnIntoWind) {
            accelMult += 0.25f * (fleetBurnAgainstWind - maxFleetBurnIntoWind);
        }
        windDir.scale(seconds * baseFleetAccel * accelMult);
        
        ghost.getMovement().getVelocity().set(vel.x + windDir.x, vel.y + windDir.y);
    }
    
    
    public void applyEffectToWreck(SectorEntityToken other, float days) {
        if (other.hasTag(Tags.UNAFFECTED_BY_SLIPSTREAM)) return;
        
        if (!containsPoint(other.getLocation(), 0f)) {
            return;
        }
        
        float [] offset = getLengthAndWidthFractionWithinStream(other.getLocation());
        if (offset == null) {
            return;
        }
            
        float distAlong = offset[0];
        float yOff = offset[1];
            
        float intensity = getIntensity(yOff);
        float wMult = getWidthBasedSpeedMult(distAlong);
        intensity *= wMult;
        intensity *= getFaderBrightness(distAlong);
            
        if (intensity <= 0) {
            return;
        }
            
        float maxWindBurn = params.burnLevel * 0.5f;
        float currWindBurn = intensity * maxWindBurn;
            
        Vector2f p1 = getPointAt(distAlong, yOff);
        Vector2f p2 = getPointAt(distAlong + 1f, yOff);
        if (p1 == null || p2 == null) {
            return;
        }
            
        Vector2f windDir = Misc.getUnitVectorAtDegreeAngle(Misc.getAngleInDegrees(p1, p2));
        if (currWindBurn < 0) {
            windDir.negate();
        }
        
        float windSpeed = Misc.getSpeedForBurnLevel(currWindBurn);
        Vector2f windVector = new Vector2f(windDir);
        windVector.scale(windSpeed);
        Vector2f vel = other.getVelocity();
        float f = 0.95f;
        other.getVelocity().set(vel.x * f + windVector.x * (1 - f), vel.y * f + windVector.y * (1 - f));
    }
    
    
    public Vector2f getPointAt(float lengthAlongStream, float offset) {
        recomputeIfNeeded();
        
        SlipstreamSegment curr = getSegmentForDist(lengthAlongStream);
        if (curr == null) return null;
        int index = curr.index;
        
        SlipstreamSegment next = null;
        SlipstreamSegment next2 = null;
 
        if (index >= segments.size() - 1) return null;
        
        if (index % 2 == 0) {
            next = segments.get(index + 1);
            if (index >= segments.size() - 2) {
                next2 = new SlipstreamSegment();
                //next2.width = next.width;
                next2.wobbledWidth = next.wobbledWidth;
                
                next2.normal = next.normal;
                //next2.dir = next.dir;
                next2.loc = new Vector2f(next.dir);
                next2.loc.scale(next.lengthToPrev);
                Vector2f.add(next2.loc, next.loc, next2.loc);
                //next2.locB = next2.loc;
                next2.lengthToPrev = next.lengthToPrev;
            } else {
                next2 = segments.get(index + 2);
            }
        }
        if (index % 2 != 0) {
            if (index >= segments.size() - 1) return null;
            curr = segments.get(index - 1);
            next = segments.get(index);
            next2 = segments.get(index + 1);
        }
        
        float lenForT = lengthAlongStream - curr.totalLength;
        //float t = lenForT / (curr.lengthToNext + next.lengthToNext);
        float t = lenForT / (curr.lengthToNext + next2.lengthToPrev);
//      if (t < 0) {
//          System.out.println("wefwefe");
//      }
        
        Vector2f p0 = new Vector2f(curr.loc);
        Vector2f p1 = new Vector2f(next.locB);
        Vector2f p2 = new Vector2f(next2.loc);
        
//      offset *= 0.7f;
//      p0.x += curr.normal.x * curr.width * 0.5f * offset;
//      p0.y += curr.normal.y * curr.width * 0.5f * offset;
//      
//      p2.x += next2.normal.x * next2.width * 0.5f * offset;
//      p2.y += next2.normal.y * next2.width * 0.5f * offset;
//      
//      p1.x += next.normal.x * next.width * 0.5f * offset;
//      p1.y += next.normal.y * next.width * 0.5f * offset;
        
        p0.x += curr.normal.x * curr.wobbledWidth * 0.5f * offset;
        p0.y += curr.normal.y * curr.wobbledWidth * 0.5f * offset;
        
        p2.x += next2.normal.x * next2.wobbledWidth * 0.5f * offset;
        p2.y += next2.normal.y * next2.wobbledWidth * 0.5f * offset;
        
        p1.x += next.normal.x * next.wobbledWidth * 0.5f * offset;
        p1.y += next.normal.y * next.wobbledWidth * 0.5f * offset;
        
        //System.out.println("T: " + t);
        Vector2f p = Misc.bezier(p0, p1, p2, t);
        
        return p;
    }
    
    public Vector2f getNoWobblePointAt(float lengthAlongStream, float offset) {
        SlipstreamSegment curr = getSegmentForDist(lengthAlongStream);
        if (curr == null) return null;
        int index = curr.index;
        if (index >= segments.size() - 2) return null;
        
        SlipstreamSegment next = segments.get(index + 1);
        SlipstreamSegment next2 = segments.get(index + 2);
        
        if (index % 2 != 0) {
            curr = segments.get(index - 1);
            next = segments.get(index);
            next2 = segments.get(index + 1);
        }
        
        float lenForT = lengthAlongStream - curr.totalLength;
        float t = lenForT / (curr.lengthToNext + next.lengthToNext);
//      if (t < 0) {
//          System.out.println("wefwefe");
//      }
        
        Vector2f p0 = new Vector2f(curr.loc);
        Vector2f p1 = new Vector2f(next.locB);
        Vector2f p2 = new Vector2f(next2.loc);
        
        float edges = params.edgeWidth * 2f * 0.5f;
        p0.x += curr.normal.x * (curr.width - edges) * 0.5f * offset;
        p0.y += curr.normal.y * (curr.width - edges) * 0.5f * offset;
        
        p2.x += next2.normal.x * (next2.width - edges) * 0.5f * offset;
        p2.y += next2.normal.y * (next2.width - edges) * 0.5f * offset;
        
        p1.x += next.normal.x * (next.width - edges) * 0.5f * offset;
        p1.y += next.normal.y * (next.width - edges) * 0.5f * offset;
        
        Vector2f p = Misc.bezier(p0, p1, p2, t);
        
        return p;
    }
    
    
    public Vector2f getNormalAt(float lengthAlongStream) {
        SlipstreamSegment curr = getSegmentForDist(lengthAlongStream);
        if (curr == null) return null;
        int index = curr.index;
        if (index >= segments.size() - 2) return null;
        
        SlipstreamSegment next = segments.get(index + 1);
        SlipstreamSegment next2 = segments.get(index + 2);
        
        if (index % 2 != 0) {
            curr = segments.get(index - 1);
            next = segments.get(index);
            next2 = segments.get(index + 1);
        }
        
        float lenForT = lengthAlongStream - curr.totalLength;
        
        float f = lenForT / curr.lengthToNext;
        Vector2f perp;
        if (f < 1f) {
            perp = Misc.interpolateVector(curr.normal, next.normal, f);
        } else {
            f = (lenForT - curr.lengthToNext) / next.lengthToNext;
            perp = Misc.interpolateVector(next.normal, next2.normal, f);
        }
        return perp;
    }
    
    public List<SlipstreamSegment> getSegmentsNear(Vector2f loc, float range) {
        //List<SlipstreamSegment> potential = new ArrayList<SlipstreamEntityPlugin2.SlipstreamSegment>();
        List<SlipstreamSegment> result = new ArrayList<SlipstreamTerrainPlugin2.SlipstreamSegment>();
        int boxIndex = 0;
        for (BoundingBox box : bounds) {
            if (box.pointNeedsDetailedCheck(loc, range)) {
                int min = boxIndex * segmentsPerBox;
                for (int i = min; i < min + segmentsPerBox && i < segments.size(); i++) {
                    SlipstreamSegment curr = segments.get(i);
                    float distSq = Misc.getDistanceSq(curr.loc, loc);
                    float r = range + curr.width + Math.max(curr.lengthToPrev, curr.lengthToNext);
                    if (distSq < r * r) {
                        result.add(curr);
                    }
                }
            }
            boxIndex++;
        }
        return result;
    }
 
    @Override
    protected boolean shouldCheckFleetsToApplyEffect() {
        return false; // handled directly in advance(); also does sensor ghosts etc
    }
    
    public boolean hasAIFlag(Object flag) {
        return flag == TerrainAIFlags.BREAK_OTHER_ORBITS ||
                flag == TerrainAIFlags.MOVES_FLEETS;
    }
    
    @Override
    public boolean containsEntity(SectorEntityToken other) {
        //if (true) return false;
        if (other.getContainingLocation() != this.entity.getContainingLocation()) return false;
        return other != null && containsPoint(other.getLocation(), 0f) && !isPreventedFromAffecting(other);
    }
 
    /* 
     * The way this check works - using getLengthAndWidthFractionWithinStream() - means it can't
     * work with a radius > 0 - or, rather, the passed in radius value is ignored.
     * Update: can sort of fake it by pretending segments have extra width. Will not catch cases where something is
     * at the end/start of a stream, though, and might miss cases where the "wider" segments overlap
     * (non-Javadoc)
     * @see com.fs.starfarer.api.impl.campaign.terrain.BaseTerrain#containsPoint(org.lwjgl.util.vector.Vector2f, float)
     */
    @Override
    public boolean containsPoint(Vector2f point, float radius) {
        //if (true) return false;
        boolean doDetailedCheck = false;
        for (BoundingBox box : bounds) {
            doDetailedCheck |= box.pointNeedsDetailedCheck(point, radius);
        }
        if (!doDetailedCheck) return false;
        
        float [] coords = getLengthAndWidthFractionWithinStream(point, 0f, false, radius);
        if (coords == null) return false;
        
        float b = getFaderBrightness(coords[0]);
        
        return b > 0;
    }
    
    public List<BoundingBox> getBounds() {
        return bounds;
    }
 
    transient private EnumSet<CampaignEngineLayers> layers = EnumSet.of(CampaignEngineLayers.TERRAIN_7);
    public EnumSet<CampaignEngineLayers> getActiveLayers() {
        return layers;
    }
    
    public void createTooltip(TooltipMakerAPI tooltip, boolean expanded) {
        float opad = 10f;
        
        tooltip.addTitle(getNameForTooltip());
        tooltip.addPara(Global.getSettings().getDescription(getTerrainId(), Type.TERRAIN).getText1(), opad);
        
        tooltip.addPara("Most slipstreams are temporary, and in recent memory their ebb and flow has been "
                + "unusually synchronized with the standard Domain cycle.", opad);
        
        tooltip.addPara("Fleets traveling inside a slipstream use %s less fuel for the distance covered.",
                opad, Misc.getHighlightColor(),
                "" + (int)Math.round((1f - FUEL_USE_MULT) * 100f) + "%");
        
        tooltip.addPara("In addition, traveling at burn levels above %s is even more fuel-efficient. "
                + "For example, a fleet traveling at burn %s will consume half as much fuel "
                + "for the distance it covers.",
                opad,
                Misc.getHighlightColor(), "20", "40", "half");
        
        tooltip.addPara("These fuel use reductions are not reflected by the fuel range indicator on the map.", opad);
        
//      tooltip.addPara("Fleets traveling at burn levels above %s become even more fuel-efficient. "
//              + "For example, a fleet traveling at burn %s will consume %s less fuel for the "
//              + "distance it covers.",
//              opad,
//              Misc.getHighlightColor(), "20", "40", "50%");
    }
    
    @Override
    public boolean hasTooltip() {
        return true;
    }
 
    public boolean isTooltipExpandable() {
        return false;
    }
    
    public float getTooltipWidth() {
        return super.getTooltipWidth();
    }
    
    public String getTerrainName() {
        if (params.name != null) return params.name;
        return "Slipstream";
    }
    
    public String getNameForTooltip() {
        return "Slipstream";
    }
    
    public String getEffectCategory() {
        return "slipstream";
    }
 
    @Override
    public void renderOnRadar(Vector2f radarCenter, float factor, float alphaMult) {
        GL11.glPushMatrix();
        GL11.glTranslatef(-radarCenter.x * factor, -radarCenter.y * factor, 0);
        renderOnMap(factor, alphaMult, true, radarCenter);
        GL11.glPopMatrix();
    }
 
    public List<SlipstreamSegment> getSegments() {
        return segments;
    }
    
    
    @Override
    public void renderOnMap(float factor, float alphaMult) {
        renderOnMap(factor, alphaMult, false, null);
    }
 
    public void renderOnMap(float factor, float alphaMult, boolean forRadar, Vector2f radarCenter) {
        recomputeIfNeeded();
        //if (true) return;
        
        Set<SlipstreamSegment> nearSet = new LinkedHashSet<SlipstreamSegment>();
        if (forRadar) {
            //float radius = Global.getSettings().getFloat("campaignRadarRadius") + 1000f;
            float radius = Global.getSettings().getFloat("campaignRadarRadius");
            nearSet = new LinkedHashSet<SlipstreamSegment>(getSegmentsNear(radarCenter, radius));
            for (SlipstreamSegment curr : nearSet) {
                curr.discovered = true;
            }
            if (nearSet.isEmpty()) return;
        }
        
        List<SlipstreamSegment> list = new ArrayList<SlipstreamSegment>();
        int incr = Math.min(segments.size() / 10, 5);
        incr = 1;
        if (incr < 1) incr = 1;
        for (int i = 0; i < segments.size(); i+=incr) {
            SlipstreamSegment curr = segments.get(i);
            if (forRadar && !nearSet.contains(curr)) continue;
            if (!forRadar && !curr.discovered && Global.getSettings().isCampaignSensorsOn() &&
                    (!DebugFlags.SLIPSTREAM_DEBUG || DebugFlags.USE_SLIPSTREAM_VISIBILITY_IN_DEBUG_MODE)) continue;
            //if (!forRadar && !curr.discovered && !Global.getSettings().isDevMode()) continue;
            //if (!forRadar && !curr.discovered) continue;
            list.add(curr);
            if (i + incr >= segments.size() && i + 1 < segments.size()) {
                list.add(segments.get(segments.size() - 1));
            }
        }
        
        List<List<SlipstreamSegment>> subsections = new ArrayList<List<SlipstreamSegment>>();
        int prevIndex = -10;
        List<SlipstreamSegment> subsection = new ArrayList<SlipstreamSegment>();
        for (SlipstreamSegment seg : list) {
            if (prevIndex != seg.index - 1) {
                if (subsection != null && !subsection.isEmpty()) {
                    subsections.add(subsection);
                }
                subsection = new ArrayList<SlipstreamSegment>();
            }
            subsection.add(seg);
            prevIndex = seg.index;
        }
        if (subsection != null && !subsection.isEmpty()) {
            subsections.add(subsection);
        }
        
        float texOffset = 0f;
        FaderUtil fader = Global.getSector().getCampaignUI().getSharedFader();
        float b = fader.getBrightness();
        b *= 0.5f;
        //b *= 2f;
        if (fader.getState() == State.IN) {
            texOffset = b;
        } else if (fader.getState() == State.OUT) {
            texOffset = 1f - b;
        }
        //texOffset = mapArrowProgress;
        //texOffset = -texOffset;
        //texOffset *= 0.5f;
        //texOffset = 0f;
        
        GL11.glPushMatrix();
        GL11.glScalef(factor, factor, 1f);
        //renderSegments(sprite, null, null, edge, alphaMult, list, texOffset % 1, true);
        for (List<SlipstreamSegment> subsection2 : subsections) {
            renderSegmentsForMap(subsection2, factor, alphaMult, forRadar, texOffset % 1);
        }
        
        // debug: rendering encounter points 
//      if (true) {
//          GL11.glDisable(GL11.GL_TEXTURE_2D);
//          GL11.glEnable(GL11.GL_BLEND);
//          GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
//      
//          GL11.glPointSize(20f);
//          GL11.glEnable(GL11.GL_POINT_SMOOTH);
//          GL11.glBegin(GL11.GL_POINTS);
//          Misc.setColor(Color.yellow);
//          for (Vector2f p : getEncounterPoints()) {
//              GL11.glVertex2f(p.x, p.y);
//          }
//          GL11.glEnd();
//      }
        
        GL11.glPopMatrix();
    }
    
    protected void renderSegmentsForMap(List<SlipstreamSegment> segments, float factor, float alphaMult, boolean forRadar, float phase) {
        //if (true) return;
        if (segments.isEmpty()) return;
        
        //System.out.println(factor);
        float widthMult = 1f;
        float lengthPerArrowMult = 1f;
        float minFactor = 0.012f;
        if (factor < minFactor) {
            widthMult = minFactor / factor;
            lengthPerArrowMult = 2f;
        }
        
        float lengthPerArrow = 700f;
        //lengthPerArrow *= sizeMult;
        lengthPerArrow *= lengthPerArrowMult;
        float start = segments.get(0).totalLength;
        float end = segments.get(segments.size() - 1).totalLength;
        
        start = (float) (Math.floor(start / lengthPerArrow) * lengthPerArrow);
        end = (float) (Math.ceil(end/ lengthPerArrow) * lengthPerArrow);
        if (end - start < lengthPerArrow) return;
        
        //Color color = Misc.setAlpha(params.maxColor, 255);
        Color color = params.mapColor;
        Color orig = color;
        
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        
        GL11.glEnable(GL11.GL_POLYGON_SMOOTH);
        GL11.glHint(GL11.GL_POLYGON_SMOOTH_HINT, GL11.GL_NICEST);
        
        float fadeDist = 500f;
        //phase = 0f;
        GL11.glBegin(GL11.GL_TRIANGLES);
        for (float len = start; len < end; len += lengthPerArrow) {
            Vector2f p0 = getPointAt(len + phase * lengthPerArrow, 0f);
            Vector2f p1 = getPointAt(len + phase * lengthPerArrow + 10f, 0f);
            if (p0 == null || p1 == null) continue;
            
            float w = getWidth(len + phase * lengthPerArrow) * widthMult;
            float triLength = lengthPerArrow * 0.33f;
            triLength = lengthPerArrow * 1f;
            triLength = Math.min(lengthPerArrow, (w + lengthPerArrow) / 2f);
            
            
            float a = getFaderBrightness(len + phase * lengthPerArrow + triLength/2f);
            if (len + phase * lengthPerArrow - start < fadeDist) {
                a *= (len + phase * lengthPerArrow - start) / fadeDist;
            }
            if (len + phase * lengthPerArrow > end - fadeDist) {
                a *= (end - (len + phase * lengthPerArrow)) / fadeDist;
            }
            if (a <= 0f) continue;
            
//          Vector2f t0 = new Vector2f(p0);
//          t0.x += dir.x * triLength/2f;
//          t0.y += dir.y * triLength/2f;
            Vector2f t0 = getPointAt(len + phase * lengthPerArrow + triLength/2f, 0f);
            if (t0 == null) continue;
            
            Vector2f dir = Misc.getUnitVector(p0, t0);
            Vector2f perp = new Vector2f(-dir.y, dir.x);
            
            Vector2f t1 = new Vector2f(p0);
            Vector2f t2 = new Vector2f(p0);
            Vector2f t3 = new Vector2f(p0);
            float backOffset = 0f;
            //offset = triLength * -0.1f;
            backOffset = triLength * 0.1f;
            t3.x -= dir.x * backOffset;
            t3.y -= dir.y * backOffset;
            
            t1.x += perp.x * w/2f;
            t1.y += perp.y * w/2f;
            t1.x -= dir.x * triLength/2f;
            t1.y -= dir.y * triLength/2f;
            
            t2.x -= perp.x * w/2f;
            t2.y -= perp.y * w/2f;
            t2.x -= dir.x * triLength/2f;
            t2.y -= dir.y * triLength/2f;
            
//          float f = (len - start) / (end - start);
//          f = 1f - f;
//          f *= 4f;
//          f += phase * 1f;
//          f = ((float) Math.sin(f * Math.PI * 2f) + 1f) * 0.5f;
//          color = Misc.interpolateColor(orig, Color.white, f * 0.67f);
            
            
            
            Misc.setColor(color, alphaMult * 1f * a);
            GL11.glVertex2f(t0.x, t0.y);
            Misc.setColor(color, alphaMult * 0f * a);
            GL11.glVertex2f(t1.x, t1.y);
            GL11.glVertex2f(t3.x, t3.y);
            
            Misc.setColor(color, alphaMult * 1f * a);
            GL11.glVertex2f(t0.x, t0.y);
            Misc.setColor(color, alphaMult * 0f * a);
            GL11.glVertex2f(t2.x, t2.y);
            GL11.glVertex2f(t3.x, t3.y);
            
            //float a2 = alphaMult * 0.5f;
//          float a2 = (float) (Math.pow(alphaMult, 0.33f) * 0.5f);
//          for (float off = -1f; off <= 1f; off += 1f) {
//              float off2 = off / factor;
//              off2 *= 0.5f;
//              Misc.setColor(color, a2 * 1f * a);
//              GL11.glVertex2f(t0.x + off2, t0.y + off2);
//              Misc.setColor(color, a2 * 0f * a);
//              GL11.glVertex2f(t1.x + off2, t1.y + off2);
//              GL11.glVertex2f(t3.x + off2, t3.y + off2);
//              
//              Misc.setColor(color, a2 * 1f * a);
//              GL11.glVertex2f(t0.x + off2, t0.y + off2);
//              Misc.setColor(color, a2 * 0f * a);
//              GL11.glVertex2f(t2.x + off2, t2.y + off2);
//              GL11.glVertex2f(t3.x + off2, t3.y + off2);
//          }
            
            color = orig;
            
        }
        GL11.glEnd();
        
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        SpriteAPI line = Global.getSettings().getSprite("graphics/hud/line4x4.png");
        line.bindTexture();
        
        float incr = 100f;
        float lineW = 50f;
        GL11.glBegin(GL11.GL_QUAD_STRIP);
        for (float len = start; len < end; len += incr) {
            Vector2f p0 = getPointAt(len, 0f);
            Vector2f p1 = getPointAt(len + 10f, 0f);
            if (p0 == null || p1 == null) continue;
            
            Vector2f dir = Misc.getUnitVector(p0, p1);
            Vector2f perp = new Vector2f(-dir.y, dir.x);
            float w = lineW;
            
            Vector2f p2 = new Vector2f(p0);
            Vector2f p3 = new Vector2f(p0);
            p2.x += perp.x * w * 0.5f;
            p2.y += perp.y * w * 0.5f;
            p3.x -= perp.x * w * 0.5f;
            p3.y -= perp.y * w * 0.5f;
            
            float a = getFaderBrightness(len);
            if (len - start < fadeDist) {
                a *= (len - start) / fadeDist;
            }
            if (len > end - fadeDist) {
                a *= (end - len) / fadeDist;
            }
            
            Misc.setColor(color, alphaMult * a * 0.5f);
            GL11.glTexCoord2f(0f, 0f);
            GL11.glVertex2f(p2.x, p2.y);
            GL11.glTexCoord2f(0f, 1f);
            GL11.glVertex2f(p3.x, p3.y);
        }
        GL11.glEnd();
        
        GL11.glDisable(GL11.GL_POLYGON_SMOOTH);
    }
    
    
    protected void doSoundPlayback(float amount) {
        //if (true) return;
        
        CampaignFleetAPI fleet = Global.getSector().getPlayerFleet();
        if (fleet != null && entity.isInCurrentLocation()) {
            Vector2f loc = fleet.getLocation();
            
            float outerPlaybackRange = (float) getSpec().getCustom().optDouble("outsideSoundRange", 1000f);
            float [] coords = getLengthAndWidthFractionWithinStream(loc, outerPlaybackRange + 2000f, true, 0f);
            
            float innerVolume = 0f;
            float innerPitch = 1f;
            float outerVolume = 0f;
            float outerPitch = 1f;
            
            SlipstreamSegment segment = null;
            List<SlipstreamSegment> near = getSegmentsNear(loc, outerPlaybackRange + 2000f);
            float pointProximityOuterVolume = 0f;
            for (SlipstreamSegment curr : near) {
                float dist = Misc.getDistance(loc, curr.loc);
                float check = curr.wobbledWidth / 2f + outerPlaybackRange;
                if (dist < check) {
                    float volume = 1f - dist / check;
                    volume *= curr.bMult * curr.fader.getBrightness();
                    if (volume > pointProximityOuterVolume) {
                        pointProximityOuterVolume = volume;
                        segment = curr;
                    }
                }
            }
            
            float fMult = coords == null ? 0f : getFaderBrightness(coords[0]);
            if (fMult <= 0f) {
                outerVolume = pointProximityOuterVolume;
            } else {
                float wMult = getWidthBasedSpeedMult(coords[0]);
                float f = Math.abs(coords[1]);
                
                if (f <= 1f) {
                    float intensity = getIntensity(f);
                    float minPitch = (float) getSpec().getCustom().optDouble("minPitch", 0.5f);
                    float maxPitch = (float) getSpec().getCustom().optDouble("maxPitch", 1.25f);
                    //innerVolume = 0f + 1f * (intensity * wMult);
                    innerVolume = 0f + 1f * (Math.min(1f, intensity * 2f) * wMult);
                    innerPitch = minPitch + (1f - minPitch) * intensity * wMult;
                    if (innerPitch > maxPitch) innerPitch = maxPitch;
                    outerVolume = 1f;
                    if (intensity >= 0.5f) {
                        outerVolume = 0f;
                    }
                } else {
                    float distFromStream = 0f;
                    distFromStream = getWidth(coords[0]) * 0.5f * (f - 1f);
                    if (distFromStream < outerPlaybackRange) {
                        float intensity = 1f - distFromStream / outerPlaybackRange;
                        outerVolume = 0f + 1f * (intensity * wMult);
                    }
                }
                
                innerVolume *= fMult;
                outerVolume *= fMult;
                outerVolume = Math.max(outerVolume, pointProximityOuterVolume);
            }
            outerVolume = Math.min(outerVolume, 1f - innerVolume);
            //outerVolume = Math.min(outerVolume, 1f - Math.max(0f, innerVolume - 0.25f) * (1f / .75f));
            
            if (innerVolume < 0) innerVolume = 0;
            if (innerVolume > 1) innerVolume = 1;
            if (outerVolume > 1) outerVolume = 1;
            if (outerVolume < 0) outerVolume = 0;
 
//          if (innerVolume > 0) {
//              outerVolume = 0;
//              innerVolume = 1;
//          }
//          if (innerVolume != 0 || outerVolume != 0) {
//              System.out.println("inner: " + innerVolume + ", outer: " + outerVolume);
//          }
 
            float loopFade = 0.5f;
            //loopFade = 5f;
            String soundId = getSpec().getLoopOne();
            
            float filterMult = innerVolume;
            if (innerVolume > 0f) {
                filterMult = 1f;
//          } else if (outerVolume > 0f) {
//              filterMult = Math.min(1f, outerVolume * 2f);
//              if (filterMult < 0.5f) filterMult *= filterMult;
//          }
            } else if (outerVolume > 0.5f) {
                filterMult = Math.min(1f, (outerVolume - 0.5f) * 4f);
            }
            //System.out.println("Filter: " + filterMult);
            if (innerVolume > 0) {
                float gain = (float) getSpec().getCustom().optDouble("gain", 0.75f);
                float gainHF = (float) getSpec().getCustom().optDouble("gainHF", 0.5f);
                
                Global.getSoundPlayer().applyLowPassFilter(
                        Math.max(0f, 1f - (1f - gain) * innerVolume),
                        Math.max(0f, 1f - Math.min(1f - gainHF, innerVolume)));
//                      Math.max(0f, 1f - 0.25f * innerVolume),
//                      Math.max(0f, 1f - Math.min(0.5f, innerVolume)));
            }
            
            if (soundId != null && innerVolume > 0f) {
                Global.getSoundPlayer().playLoop(soundId, fleet, innerPitch,
                        getLoopOneVolume() * innerVolume, fleet.getLocation(), Misc.ZERO, loopFade, loopFade);
            }
            soundId = getSpec().getLoopTwo();
            if (soundId != null && outerVolume > 0f) {
                Vector2f playbackLoc = fleet.getLocation();
                if (segment != null) playbackLoc = segment.loc;
                Global.getSoundPlayer().playLoop(soundId, fleet, outerPitch,
                        getLoopTwoVolume() * outerVolume, playbackLoc, Misc.ZERO, loopFade, loopFade);
            }
            
            float suppressionMult = innerVolume;
            suppressionMult = filterMult;
            Global.getSector().getCampaignUI().suppressMusic(getSpec().getMusicSuppression() * suppressionMult);
        }
    }
    
    
    @Override
    protected boolean shouldPlayLoopOne() {
        return false;
    }
 
    @Override
    protected boolean shouldPlayLoopTwo() {
        return false;
    }
 
    public List<Vector2f> getEncounterPoints() {
        if (encounterPoints == null) {
            encounterPoints = new ArrayList<Vector2f>();
            recomputeEncounterPoints();
        }
        return encounterPoints;
    }
    
    public void recomputeEncounterPoints() {
        encounterPoints = new ArrayList<Vector2f>();
        
        List<List<SlipstreamSegment>> sections = new ArrayList<List<SlipstreamSegment>>();
        
        boolean currSectionIsBreak = false;
        List<SlipstreamSegment> list = new ArrayList<SlipstreamSegment>();
        for (int i = 0; i < segments.size(); i++) {
            SlipstreamSegment curr = segments.get(i);
            boolean currSegmentIsBreak = curr.bMult <= 0f;
            if (list.isEmpty()) {
                currSectionIsBreak = currSegmentIsBreak;
            }
            if (currSectionIsBreak == currSegmentIsBreak) {
                list.add(curr);
            } else {
                if (!list.isEmpty()) {
                    sections.add(list);
                }
                list = new ArrayList<SlipstreamSegment>();
                i--;
            }
        }
        
        boolean prevSectionWasLongEnough = false;
        for (List<SlipstreamSegment> section : sections) {
            boolean sectionIsBreak = section.get(0).bMult <= 0;
            float sectionLength = section.get(section.size() - 1).totalLength - section.get(0).totalLength;
            //if (sectionIsBreak && prevSectionWasLongEnough && section.size() > 5f) {
            if (sectionIsBreak && prevSectionWasLongEnough && sectionLength >= 1000f) {// && sectionLength < 4000f) {
                Vector2f loc = new Vector2f(section.get(0).loc);
                Vector2f dir = new Vector2f(section.get(0).dir);
                dir.scale(Math.min(1000f, sectionLength * 0.4f));
                Vector2f.add(dir, loc, loc);
                encounterPoints.add(loc);
            }
            
            if (!sectionIsBreak && section.size() >= 10f) {
                prevSectionWasLongEnough = true;
            } else {
                prevSectionWasLongEnough = false;
            }
        }
        if (prevSectionWasLongEnough) {
            List<SlipstreamSegment> section = sections.get(sections.size() - 1);
            Vector2f loc = new Vector2f(section.get(section.size() - 1).loc);
            Vector2f dir = new Vector2f(section.get(section.size() - 1).dir);
            dir.scale(1000f);
            Vector2f.add(dir, loc, loc);
            encounterPoints.add(loc);
        }
    }
    
    
}