Ejemplo n.º 1
0
 public float GetDistanceTo(Location l)
 {
     float dx = x - l.X;
     float dy = y - l.Y;
     float dz = z - l.Z;
     return (float)Math.Sqrt(dx * dx + dy * dy + dz * dz);
 }
Ejemplo n.º 2
0
        public MoveResult move()
        {
            if (GiveUpIfUnsafe) // fixme
            {
                //if (!pather.IsItSafeAt(Me.Target, Me.Location))
                //    return MoveResult.Unsafe;
            }
            if (PathTimeout.IsReady)
            {
                MoveAlong = null;
            }
            BoogieCore.Log(LogType.System, "[Mover] MoveAlong = {0}", MoveAlong);
            if (MoveAlong == null)
            {
                Location from = new Location(Me.Location);
                mover.Stop();
                Path path = world.CreatePath(from, target, (float)4.5, PPather.radar); //fixme
                PathTimeout.Reset();
                BoogieCore.Log(LogType.System, "[Mover (New)] PathCount = {0}", path.Count());
                if (path == null || path.Count() == 0)
                {
                    //Context.Log("EasyMover: Can not create path . giving up");
                    mover.MoveRandom();
                    Thread.Sleep(200);
                    mover.Stop();
                    return MoveResult.CantFindPath;
                }
                else
                {
                    //Context.Log("Save path to " + pathfile);
                    //path.Save(pathfile);
                    MoveAlong = new MoveAlonger(pather, path);
                }
            }

            if (MoveAlong != null)
            {
                Location from = new Location(Me.Location);
                BoogieCore.Log(LogType.System, "[Mover ] PathCount = {0}", MoveAlong.path.Count());

                if (MoveAlong.path.Count() == 0 || from.GetDistanceTo(target) < (float)5.0)
                {
                    BoogieCore.Log(LogType.System, "[Mover] Count = 0 or Dist < 5.0");
                    MoveAlong = null;
                    mover.Stop();
                    return MoveResult.GotThere;
                }
                else if (!MoveAlong.MoveAlong())
                {
                    BoogieCore.Log(LogType.System, "[Mover] Stuck!!");
                    MoveAlong = null; // got stuck!
                    if (GiveUpIfStuck) return MoveResult.Stuck;
                }
            }
            return MoveResult.Moving;
        }
Ejemplo n.º 3
0
 public EasyMover(PPather pather, Location target, bool GiveUpIfStuck, bool GiveUpIfUnsafe)
 {
     this.target = target;
     this.Me = BoogieCore.Player;
     this.world = pather.world;
     mover = PPather.mover;
     this.GiveUpIfStuck = GiveUpIfStuck;
     this.GiveUpIfUnsafe = GiveUpIfUnsafe;
     this.pather = pather;
 }
Ejemplo n.º 4
0
        public void MarkBlockedAt(Location loc)
        {
            Spot s = new Spot(loc);
            s = AddSpot(s);
            s.SetFlag(Spot.FLAG_BLOCKED, true);
            // Find all paths leading though this one

            List<Spot> sl = FindAllSpots(loc, 5.0f);
            foreach (Spot sp in sl)
            {
                List<Location> paths = sp.GetPaths();
                foreach (Location to in paths)
                {
                    if (LineCrosses(sp.location, to, loc))
                    {
                        sp.RemovePathTo(to);
                    }
                }
            }
        }
Ejemplo n.º 5
0
 public Spot(Location l)
 {
     this.X = l.X;
     this.Y = l.Y;
     this.Z = l.Z;
 }
Ejemplo n.º 6
0
 public void AddLast(Location l)
 {
     locations.Add(l);
 }
Ejemplo n.º 7
0
 public MoveAlonger(PPather pather, Path path)
 {
     this.Me = BoogieCore.Player;
     this.path = path;
     this.world = pather.world;
     mover = PPather.mover;
     sd = new StuckDetecter(pather, 1, 2);
     prev = null;
     current = path.GetFirst();
     next = path.GetSecond();
 }
Ejemplo n.º 8
0
        private bool LineCrosses(Location line0, Location line1, Location point)
        {
            float LineMag = line0.GetDistanceTo(line1); // Magnitude( LineEnd, LineStart );

            float U =
                (((point.X - line0.X) * (line1.X - line0.X)) +
                  ((point.Y - line0.Y) * (line1.Y - line0.Y)) +
                  ((point.Z - line0.Z) * (line1.Z - line0.Z))) /
                (LineMag * LineMag);

            if (U < 0.0f || U > 1.0f)
                return false;

            float InterX = line0.X + U * (line1.X - line0.X);
            float InterY = line0.Y + U * (line1.Y - line0.Y);
            float InterZ = line0.Z + U * (line1.Z - line0.Z);

            float Distance = point.GetDistanceTo(new Location(InterX, InterY, InterZ));
            if (Distance < 0.5f)
                return true;
            return false;
        }
Ejemplo n.º 9
0
 public void BlacklistStep(Location from, Location to)
 {
     Spot froms = GetSpot(from);
     if (froms != null)
         froms.RemovePathTo(to);
 }
Ejemplo n.º 10
0
 public Path CreatePath(Location origin, Location destination, float dist, float hight, float radius)
 {
     this.toonHeight = hight;
     this.toonSize = radius;
     return CreatePath(origin, destination, dist);
 }
Ejemplo n.º 11
0
        public List<Spot> FindAllSpots(Location l, float max_d)
        {
            List<Spot> sl = new List<Spot>();

            int d = 0;
            while ((float)d <= max_d + 0.1f)
            {
                for (int i = -d; i <= d; i++)
                {
                    float x_up = l.X + (float)d;
                    float x_dn = l.X - (float)d;
                    float y_up = l.Y + (float)d;
                    float y_dn = l.Y - (float)d;

                    Spot s0 = GetSpot2D(x_up, l.Y + i);
                    Spot s2 = GetSpot2D(x_dn, l.Y + i);

                    Spot s1 = GetSpot2D(l.X + i, y_dn);
                    Spot s3 = GetSpot2D(l.X + i, y_up);
                    Spot[] sv = { s0, s1, s2, s3 };
                    foreach (Spot s in sv)
                    {
                        Spot ss = s;
                        while (ss != null)
                        {
                            float di = ss.GetDistanceTo(l);
                            if (di < max_d)
                            {
                                sl.Add(ss);
                            }
                            ss = ss.next;

                            if (Cancel)
                                goto loop_end;
                        }
                    }
                }
                d++;
            }
            loop_end:
            return sl;
        }
Ejemplo n.º 12
0
        public Path CreatePath(Location fromLoc, Location toLoc,
							   float howClose)
        {
            return CreatePath(fromLoc, toLoc, howClose, null);
        }
Ejemplo n.º 13
0
        public Path CreatePath(Location fromLoc, Location toLoc,
							   float howClose,
							   ILocationHeuristics locationHeuristics)
        {
            System.DateTime t = System.DateTime.Now;
            Spot from = FindClosestSpot(fromLoc, MinStepLength);
            Spot to = FindClosestSpot(toLoc, MinStepLength);

            if (from == null)
            {
                from = AddAndConnectSpot(new Spot(fromLoc));
            }
            if (to == null)
            {
                to = AddAndConnectSpot(new Spot(toLoc));
            }

            Path rawPath = CreatePath(from, to, to.location, howClose, true, locationHeuristics);

            if (rawPath != null && paint != null)
            {
                Location prev = null;
                for (int i = 0; i < rawPath.Count; i++)
                {
                    Location l = rawPath.Get(i);
                    paint.AddBigMarker(l.X, l.Y, l.Z);
                    if (prev != null)
                    {
                        paint.PaintPath(l.X, l.Y, l.Z + 3, prev.X, prev.Y, prev.Z + 3);
                    }
                    prev = l;
                }
            }
            Console.WriteLine("CreatePath took {0}", System.DateTime.Now.Subtract(t).Seconds);
            if (rawPath == null)
            {
                return null;
            }
            else
            {
                Location last = rawPath.GetLast();
                if (last.GetDistanceTo(toLoc) > 1.0)
                    rawPath.AddLast(toLoc);
            }
            return rawPath;
        }
Ejemplo n.º 14
0
        public Path CreatePath(Spot from, Spot to, Location realDst,
							   float minHowClose, bool AllowInvented,
							   ILocationHeuristics locationHeuristics)
        {
            Spot newTo = search(from, to, realDst, minHowClose, AllowInvented,
                                locationHeuristics);
            if (newTo != null)
            {
                if (newTo.GetDistanceTo(to) <= minHowClose)
                {
                    List<Spot> path = FollowTraceBack(from, newTo);
                    return new Path(path);
                }
            }
            return null;
        }
Ejemplo n.º 15
0
 public float GetDistanceTo(Location l)
 {
     float dx = l.X - X;
     float dy = l.Y - Y;
     float dz = l.Z - Z;
     return (float)Math.Sqrt(dx * dx + dy * dy + dz * dz);
 }
Ejemplo n.º 16
0
 public void AddPathTo(Location l)
 {
     AddPathTo(l.X, l.Y, l.Z);
 }
Ejemplo n.º 17
0
        public void MarkStuckAt(Location loc, float heading)
        {
            // TODO another day...
            Location inf = loc.InFrontOf(heading, 1.0f);
            MarkBlockedAt(inf);

            // TODO
        }
Ejemplo n.º 18
0
 // this can be slow...
 public Spot FindClosestSpot(Location l_d)
 {
     return FindClosestSpot(l_d, 30.0f, null);
 }
Ejemplo n.º 19
0
        public Spot TryAddSpot(Spot wasAt, Location isAt)
        {
            Spot isAtSpot = FindClosestSpot(isAt, WantedStepLength);
            if (isAtSpot == null)
            {
                isAtSpot = GetSpot(isAt);
                if (isAtSpot == null)
                {
                    Spot s = new Spot(isAt);
                    s = AddSpot(s);
                    isAtSpot = s;
                }
                if (isAtSpot.GetFlag(Spot.FLAG_BLOCKED))
                {
                    isAtSpot.SetFlag(Spot.FLAG_BLOCKED, false);
                    Log("Cleared blocked flag");
                }
                if (wasAt != null)
                {
                    wasAt.AddPathTo(isAtSpot);
                    isAtSpot.AddPathTo(wasAt);
                }

                List<Spot> sl = FindAllSpots(isAtSpot.location, MaxStepLength);
                int connected = 0;
                foreach (Spot other in sl)
                {
                    if (other != isAtSpot)
                    {
                        other.AddPathTo(isAtSpot);
                        isAtSpot.AddPathTo(other);
                        connected++;
                        // Log("  connect to " + other.location);
                    }
                }
                Log("Learned a new spot at " + isAtSpot.location + " connected to " + connected + " other spots");
                wasAt = isAtSpot;
            }
            else
            {
                if (wasAt != null && wasAt != isAtSpot)
                {
                    // moved to an old spot, make sure they are connected
                    wasAt.AddPathTo(isAtSpot);
                    isAtSpot.AddPathTo(wasAt);
                }
                wasAt = isAtSpot;
            }

            return wasAt;
        }
Ejemplo n.º 20
0
 public Spot FindClosestSpot(Location l_d, Set<Spot> Not)
 {
     return FindClosestSpot(l_d, 30.0f, Not);
 }
Ejemplo n.º 21
0
        private Spot search(Spot src, Spot dst, Location realDst, float minHowClose, bool AllowInvented, ILocationHeuristics locationHeuristics)
        {
            searchID++;
            int count = 0;
            Cancel = false;
            int prevCount = 0;
            int currentSearchID = searchID;
            float heuristicsFactor = 1.3f;
            System.DateTime pre = System.DateTime.Now;
            System.DateTime lastSpam = pre;

            // lowest first queue
            PriorityQueue<Spot, float> q = new PriorityQueue<Spot, float>(); // (new SpotSearchComparer(dst, score)); ;
            q.Enqueue(src, -src.GetDistanceTo(dst) * heuristicsFactor);
            Spot BestSpot = null;

            //Set<Spot> closed      = new Set<Spot>();
            //SpotData<float> score = new SpotData<float>();

            src.SearchScoreSet(currentSearchID, 0.0f);
            src.traceBack = null;

            // A* -ish algorithm

            while ((q.Count != 0) && !Cancel) // && count < 100000)
            {
                float prio;
                Spot spot = q.Dequeue(out prio); // .Value;
                //q.Remove(spot);

                if (spot.SearchIsClosed(currentSearchID))
                    continue;
                spot.SearchClose(currentSearchID);

                if (count % 100 == 0)
                {
                    System.TimeSpan span = System.DateTime.Now.Subtract(lastSpam);
                    if (span.Seconds != 0 && BestSpot != null)
                    {
                        Thread.Sleep(50); // give glider a chance to stop us
                        int t = span.Seconds * 1000 + span.Milliseconds;
                        if (t == 0)
                            Log("searching.... " + (count + 1) + " d: " + BestSpot.location.GetDistanceTo(realDst));
                        else
                            Log("searching.... " + (count + 1) + " d: " + BestSpot.location.GetDistanceTo(realDst) + " " + (count - prevCount) * 1000 / t + " steps/s");
                        lastSpam = System.DateTime.Now;
                        prevCount = count;
                    }
                }
                count++;

                if (spot.Equals(dst) || spot.location.GetDistanceTo(realDst) <= minHowClose)
                {
                    System.TimeSpan ts = System.DateTime.Now.Subtract(pre);
                    int t = ts.Seconds * 1000 + ts.Milliseconds;
                    /*if(t == 0)
                        Log("  search found the way there. " + count);
                    else
                        Log("  search found the way there. " + count + " " + (count * 1000) / t + " steps/s");
                      */
                    return spot; // got there
                }

                if (BestSpot == null ||
                   spot.location.GetDistanceTo(realDst) < BestSpot.location.GetDistanceTo(realDst))
                {
                    BestSpot = spot;
                }
                {
                    System.TimeSpan ts = System.DateTime.Now.Subtract(pre);
                    if (ts.Seconds > 120)
                    {
                        Log("too long search, aborting");
                        break;
                    }
                }

                float src_score = spot.SearchScoreGet(currentSearchID);

                //Console.WriteLine("inspect: " + c + " score " + s);

                int new_found = 0;
                List<Spot> ll = spot.GetPathsToSpots(this);
                foreach (Spot to in ll)
                {
                    //Spot to = GetSpot(l);

                    if (to != null && !to.IsBlocked() && !to.SearchIsClosed(currentSearchID))
                    {
                        float old_score = 1E30f;

                        float new_score = src_score + spot.GetDistanceTo(to) + TurnCost(spot, to);
                        if (locationHeuristics != null)
                            new_score += locationHeuristics.Score(spot.X, spot.Y, spot.Z);
                        if (to.GetFlag(Spot.FLAG_WATER))
                            new_score += 30;

                        if (to.SearchScoreIsSet(currentSearchID))
                        {
                            old_score = to.SearchScoreGet(currentSearchID);
                        }

                        if (new_score < old_score)
                        {
                            // shorter path to here found
                            to.traceBack = spot;
                            //if (q.Contains(to))
                            //   q.Remove(to); // very sloppy to not dequeue it
                            to.SearchScoreSet(currentSearchID, new_score);
                            q.Enqueue(to, -(new_score + to.GetDistanceTo(dst) * heuristicsFactor));
                            new_found++;
                        }
                    }

                    if (Cancel)
                        break;
                }

                //hmm search the triangles :p
                if (!spot.GetFlag(Spot.FLAG_MPQ_MAPPED))
                {

                    float PI = (float)Math.PI;

                    spot.SetFlag(Spot.FLAG_MPQ_MAPPED, true);
                    for (float a = 0; a < PI * 2; a += PI / 8)
                    {
                        float nx = spot.X + (float)Math.Sin(a) * WantedStepLength;// *0.8f;
                        float ny = spot.Y + (float)Math.Cos(a) * WantedStepLength;// *0.8f;
                        Spot s = GetSpot(nx, ny, spot.Z);
                        if (s == null)
                            s = FindClosestSpot(new Location(nx, ny, spot.Z), MinStepLength); // TODO: this is slow
                        if (s != null)
                        {
                            // hmm, they should already be connected
                        }
                        else
                        {
                            float new_z;
                            int flags;
                            // gogo find a new one
                            //Console.WriteLine("gogo brave new world");
                            if (!triangleWorld.FindStandableAt(nx, ny,
                                                               spot.Z - WantedStepLength * .75f, spot.Z + WantedStepLength * .75f,
                                                               out new_z, out flags, toonHeight, toonSize))
                            {
                                //Spot blocked = new Spot(nx, ny, spot.Z);
                                //blocked.SetFlag(Spot.FLAG_BLOCKED, true);
                                //AddSpot(blocked);
                            }
                            else
                            {
                                s = FindClosestSpot(new Location(nx, ny, new_z), MinStepLength);
                                if (s == null)
                                {
                                    if (!triangleWorld.IsStepBlocked(spot.X, spot.Y, spot.Z, nx, ny, new_z,
                                                                     toonHeight, toonSize, null))
                                    {

                                        Spot n = new Spot(nx, ny, new_z);
                                        Spot to = AddAndConnectSpot(n);
                                        if ((flags & ChunkedTriangleCollection.TriangleFlagDeepWater) != 0)
                                        {
                                            to.SetFlag(Spot.FLAG_WATER, true);
                                        }
                                        if (((flags & ChunkedTriangleCollection.TriangleFlagModel) != 0) ||
                                            ((flags & ChunkedTriangleCollection.TriangleFlagObject) != 0))
                                        {
                                            to.SetFlag(Spot.FLAG_INDOORS, true);
                                        }
                                        if (to != n || to.SearchIsClosed(currentSearchID))
                                        {
                                            // Console.WriteLine("/sigh");
                                        }
                                        else
                                        {
                                            // There should be a path from source to this one now
                                            if (spot.HasPathTo(to.location))
                                            {
                                                float old_score = 1E30f;

                                                float new_score = src_score + spot.GetDistanceTo(to) + TurnCost(spot, to);
                                                if (locationHeuristics != null)
                                                    new_score += locationHeuristics.Score(spot.X, spot.Y, spot.Z);

                                                if (to.GetFlag(Spot.FLAG_WATER))
                                                    new_score += 30;

                                                if (to.SearchScoreIsSet(currentSearchID))
                                                {
                                                    old_score = to.SearchScoreGet(currentSearchID);
                                                }

                                                if (new_score < old_score)
                                                {
                                                    // shorter path to here found
                                                    to.traceBack = spot;
                                                    //if (q.Contains(to))
                                                    //    q.Remove(to);
                                                    to.SearchScoreSet(currentSearchID, new_score);
                                                    q.Enqueue(to, -(new_score + to.GetDistanceTo(dst) * heuristicsFactor));
                                                    new_found++;
                                                }
                                            }
                                            else
                                            {
                                                // woot! I added a new one and it is not connected!?!?
                                                //Console.WriteLine("/cry");
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        if (Cancel)
                            break;
                    }

                }

            }
            {
                System.TimeSpan ts = System.DateTime.Now.Subtract(pre);
                int t = ts.Seconds * 1000 + ts.Milliseconds;
                if (t == 0)
                    t = 1;
                Log("  search failed. " + (count * 1000) / t + " steps/s");

            }
            return BestSpot; // :(
        }
Ejemplo n.º 22
0
 public Spot FindClosestSpot(Location l, float max_d)
 {
     return FindClosestSpot(l, max_d, null);
 }
Ejemplo n.º 23
0
 public void AddFirst(Location l)
 {
     locations.Insert(0, l);
 }
Ejemplo n.º 24
0
        // this can be slow...
        public Spot FindClosestSpot(Location l, float max_d, Set<Spot> Not)
        {
            Spot closest = null;
            float closest_d = 1E30f;
            int d = 0;

            while ((float)d <= max_d + 0.1f)
            {
                for (int i = -d; i <= d; i++)
                {
                    float x_up = l.X + (float)d;
                    float x_dn = l.X - (float)d;
                    float y_up = l.Y + (float)d;
                    float y_dn = l.Y - (float)d;

                    Spot s0 = GetSpot2D(x_up, l.Y + i);
                    Spot s2 = GetSpot2D(x_dn, l.Y + i);

                    Spot s1 = GetSpot2D(l.X + i, y_dn);
                    Spot s3 = GetSpot2D(l.X + i, y_up);
                    Spot[] sv = { s0, s1, s2, s3 };
                    foreach (Spot s in sv)
                    {
                        Spot ss = s;
                        while (ss != null)
                        {
                            float di = ss.GetDistanceTo(l);
                            if (di < max_d && !ss.IsBlocked() &&
                                (di < closest_d))
                            {
                                closest = ss;
                                closest_d = di;
                            }
                            ss = ss.next;

                            if (Cancel)
                                goto loop_end;
                        }
                    }
                }

                if (closest_d < d) // can't get better
                {
                    //Log("Closest2 spot to " + l + " is " + closest);
                    return closest;
                }
                d++;
            }
            loop_end:
            //Log("Closest1 spot to " + l + " is " + closest);
            return closest;
        }
Ejemplo n.º 25
0
 public void SetNewTarget(Location target)
 {
     MoveAlong = null;
     this.target = target;
 }
Ejemplo n.º 26
0
 public void RemovePathTo(Location l)
 {
     RemovePathTo(l.X, l.Y, l.Z);
 }
Ejemplo n.º 27
0
        public bool MoveAlong()
        {
            double max = 3.0;
            Coordinate loc = Me.Location;
            Location isAt = new Location(loc.X, loc.Y, loc.Z);
            /*
            while (isAt.GetDistanceTo(current) < max && next != null)
            {
                //Context.Log(current + " - " + next);
                path.RemoveFirst();
                if (path.Count() == 0)
                {
                    //Context.Log("ya");
                    //return true; // good in some way
                }
                else
                {
                    prev = current;
                    current = path.GetFirst();
                    next = path.GetSecond();
                }
            }
            */
            bool consume = false;
            do
            {

                bool blocked = false;

                consume = false;
                if (next != null)
                    world.triangleWorld.IsStepBlocked(loc.X, loc.Y, loc.Z, next.X, next.Y, next.Z,
                                                      PathGraph.toonHeight, PathGraph.toonSize, null);
                double d = isAt.GetDistanceTo(current);
                if ((d < max && !blocked) ||
                   d < 1.5)
                    consume = true;

                if (consume)
                {
                    //GContext.Main.Log("Consume spot " + current + " d " + d + " block " + blocked);
                    path.RemoveFirst();
                    if (path.Count() == 0)
                    {
                        break;
                    }
                    else
                    {
                        prev = current;
                        current = path.GetFirst();
                        next = path.GetSecond();
                    }
                }

            } while (consume);

            {
                //Context.Log("Move towards " + current);
                Coordinate gto = new Coordinate((float)current.X, (float)current.Y, (float)current.Z);
                Coordinate face;
                if (next != null)
                    face = new Coordinate(next.X, next.Y, next.Z);
                else
                    face = gto;

                if (!mover.moveTowardsFacing(gto, 0.5, face))
                {
                    //Context.Log("Can't move " + current);
                    world.BlacklistStep(prev, current);
                    //world.MarkStuckAt(loc, Me.Heading);
                    mover.MoveRandom();
                    Thread.Sleep(500);
                    mover.Stop();
                    return false;
                    // hmm, mover does not want to move, must be up or down
                }

                {
                    double h; double speed;
                    h = mover.GetMoveHeading(out speed);
                    float stand_z = 0.0f;
                    int flags = 0;
                    float x = isAt.X + (float)Math.Cos(h) * 1.0f;
                    float y = isAt.Y + (float)Math.Sin(h) * 1.0f;
                    float z = isAt.Z;
                    bool aheadOk = world.triangleWorld.FindStandableAt(x, y,
                                                                       z - 4,
                                                                       z + 6,
                                                                       out stand_z, out flags, 0, 0);
                    if (!aheadOk)
                    {
                        blockCount++;
                        world.MarkStuckAt(isAt, Me.Location.O);

                        if (prev != null)
                        {
                            Coordinate gprev = new Coordinate((float)prev.X, (float)prev.Y, (float)prev.Z);

                            if (!mover.moveTowardsFacing(gprev, 0.5, face))
                            {
                                mover.Stop();
                                return false;
                            }
                        }
                        if (blockCount > 1)
                        {
                            world.BlacklistStep(prev, current);
                            return false;
                        }

                        return true;
                    }
                    else
                        blockCount = 0;
                }

                if (sd.checkStuck())
                {
                    //Context.Log("Stuck at " + isAt);
                    world.MarkStuckAt(isAt, (float)Me.Heading);
                    world.BlacklistStep(prev, current);
                    mover.Stop();
                    return false;
                }
            }
            return true;
        }
Ejemplo n.º 28
0
 public bool IsUnderwaterOrInAir(Location l)
 {
     int flags;
     float z;
     if (triangleWorld.FindStandableAt(l.X, l.Y, l.Z - 50.0f, l.Z + 5.0f, out z, out  flags, toonHeight, toonSize))
     {
         if ((flags & ChunkedTriangleCollection.TriangleFlagDeepWater) != 0)
             return true;
         else
             return false;
     }
     //return true;
     return false;
 }
Ejemplo n.º 29
0
 public Spot GetSpot(Location l)
 {
     if (l == null)
         return null;
     return GetSpot(l.X, l.Y, l.Z);
 }
Ejemplo n.º 30
0
 public void SetLocation(Location l)
 {
     X = l.X;
     Y = l.Y;
     Z = l.Z;
     if (chunk != null)
         chunk.modified = true;
 }