示例#1
0
        private static void UpdatePolygons()
        {
            foreach (var missile in Missiles)
            {
                var missileInfo =
                    SpellDatabase.GetSpellInfoList(missile.Key.SpellCaster)
                    .FirstOrDefault(s => s.RealSlot == missile.Key.Slot);
                if (missileInfo == null)
                {
                    return;
                }

                switch (missileInfo.Type)
                {
                case SpellType.Self:
                    break;

                case SpellType.Circle:
                    var polCircle = new Geometry.Polygon.Circle(missile.Key.Position, missileInfo.Radius);
                    Missiles[missile.Key] = polCircle;
                    break;

                case SpellType.Line:
                    var polLine = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
                                                                 missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
                    Missiles[missile.Key] = polLine;
                    break;

                case SpellType.Cone:
                    var polCone = new Geometry.Polygon.Sector(missile.Key.StartPosition, missile.Key.EndPosition, missileInfo.Radius, missileInfo.Range, 80);
                    Missiles[missile.Key] = polCone;
                    break;

                case SpellType.Ring:
                    break;

                case SpellType.Arc:
                    break;

                case SpellType.MissileLine:
                    var polMissileLine = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
                                                                        missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
                    Missiles[missile.Key] = polMissileLine;
                    break;

                case SpellType.MissileAoe:
                    var polMissileAoe = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
                                                                       missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
                    Missiles[missile.Key] = polMissileAoe;
                    break;
                }
            }

            var polygons = new List <Geometry.Polygon>();

            polygons.AddRange(Missiles.Values);

            Joined = polygons.JoinPolygons();
        }
示例#2
0
        private void UpdatePolygons()
        {
            Polygons = new List<Geometry.Polygon>();

            foreach (var myMissile in Missiles)
            {
                var missile = myMissile.Missile;
                var info = myMissile.SpellInfo;

                // ReSharper disable once SwitchStatementMissingSomeCases
                switch (info.Type)
                {
                    case SpellType.Self:
                        return;
                    case SpellType.Circle:
                        var polygonCircle = new Geometry.Polygon.Circle(missile.Position,
                            myMissile.SpellInfo.Radius, 80);
                        myMissile.Polygon = polygonCircle;

                        Polygons.Add(polygonCircle);
                        return;
                    case SpellType.Line:
                        var polygonLine = new Geometry.Polygon.Line(missile.StartPosition, missile.EndPosition, 5f);
                        myMissile.Polygon = polygonLine;

                        Polygons.Add(polygonLine);
                        return;
                    case SpellType.Cone:
                        var polygonCone = new Geometry.Polygon.Sector(missile.StartPosition, missile.EndPosition, info.Radius, info.Range, 80);
                        myMissile.Polygon = polygonCone;

                        Polygons.Add(polygonCone);
                        return;
                    case SpellType.Ring:
                        return;
                    case SpellType.Arc:
                        return;
                    case SpellType.MissileLine:
                        var polygonMissileLine = new Geometry.Polygon.Line(missile.StartPosition, missile.EndPosition, 5f);
                        myMissile.Polygon = polygonMissileLine;

                        Polygons.Add(polygonMissileLine);
                        return;
                    case SpellType.MissileAoe:
                        var polygonMissileAOE = new Geometry.Polygon.Line(missile.StartPosition, missile.EndPosition, 5f);
                        myMissile.Polygon = polygonMissileAOE;

                        Polygons.Add(polygonMissileAOE);
                        return;
                }
            }

            Polygons = Polygons.JoinPolygons();
        }
        static void Game_OnGameUpdate(EventArgs args)
        {
            if (_mainMenu.Item("zoomIn").GetValue <KeyBind>().Active)
            {
                _size -= 5;
            }

            if (_mainMenu.Item("zoomOut").GetValue <KeyBind>().Active)
            {
                _size += 5;
            }

            if (!_mainMenu.Item("scan").GetValue <KeyBind>().Active)
            {
                _scan = true;
            }

            if (_mainMenu.Item("Enable").GetValue <bool>() && _mainMenu.Item("scan").GetValue <KeyBind>().Active&& _scan)
            {
                var currentPostion = Game.CursorPos.To2D();

                var tempList = new List <Geometry.Polygon>();

                var rect = new Geometry.Polygon.Rectangle(new Vector2(0, 0), new Vector2(0, 5), 5f);

                for (int x = -_size; x < _size; x += 5)
                {
                    for (int y = -_size; y < _size; y += 5)
                    {
                        var test = rect.MovePolygone(new Vector2(currentPostion.X + x, currentPostion.Y + y));

                        if (NavMesh.GetCollisionFlags(test.Points[0].To3D()).HasFlag(CollisionFlags.Building) && _mainMenu.Item("building").GetValue <bool>())
                        {
                            tempList.Add(test);
                        }

                        if (NavMesh.GetCollisionFlags(test.Points[0].To3D()).HasFlag(CollisionFlags.Grass) && _mainMenu.Item("grass").GetValue <bool>())
                        {
                            tempList.Add(test);
                        }

                        if (NavMesh.GetCollisionFlags(test.Points[0].To3D()).HasFlag(CollisionFlags.Wall) && _mainMenu.Item("wall").GetValue <bool>())
                        {
                            tempList.Add(test);
                        }
                    }
                }

                var temp = Geometry.ClipPolygons(tempList);
                temp.TrimExcess();

                foreach (var polygone in temp)
                {
                    _polygoneList.Add(polygone.ToPolygon());
                }
                _scan = false;
            }

            if (_mainMenu.Item("clip").GetValue <KeyBind>().Active)
            {
                _polygoneList = _polygoneList.JoinPolygons();
            }
        }
示例#4
0
        private static void GameObject_OnCreate(GameObject sender, EventArgs args)
        {
            var missile = sender as MissileClient;

            if (missile == null)
            {
                return;
            }

            var missileInfo =
                SpellDatabase.GetSpellInfoList(missile.SpellCaster).FirstOrDefault(s => s.RealSlot == missile.Slot);

            if (missileInfo == null)
            {
                return;
            }

            switch (missileInfo.Type)
            {
            case SpellType.Self:
                break;

            case SpellType.Circle:
                var polCircle = new Geometry.Polygon.Circle(missile.Position, missileInfo.Radius);
                Missiles.Add(missile, polCircle);
                break;

            case SpellType.Line:
                var polLine = new Geometry.Polygon.Rectangle(missile.StartPosition,
                                                             missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
                Missiles.Add(missile, polLine);
                break;

            case SpellType.Cone:
                var polCone = new Geometry.Polygon.Sector(missile.StartPosition, missile.EndPosition, missileInfo.Radius, missileInfo.Range, 80);
                Missiles.Add(missile, polCone);
                break;

            case SpellType.Ring:
                break;

            case SpellType.Arc:
                break;

            case SpellType.MissileLine:
                var polMissileLine = new Geometry.Polygon.Rectangle(missile.StartPosition,
                                                                    missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
                Missiles.Add(missile, polMissileLine);
                break;

            case SpellType.MissileAoe:
                var polMissileAoe = new Geometry.Polygon.Rectangle(missile.StartPosition,
                                                                   missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
                Missiles.Add(missile, polMissileAoe);
                break;
            }

            var polygons = new List <Geometry.Polygon>();

            polygons.AddRange(Missiles.Values);

            Joined = polygons.JoinPolygons();
        }
示例#5
0
        private static void GameObject_OnCreate(GameObject sender, EventArgs args)
        {
            var missile = sender as MissileClient;
            if (missile == null) return;

            var missileInfo =
                SpellDatabase.GetSpellInfoList(missile.SpellCaster).FirstOrDefault(s => s.RealSlot == missile.Slot);
            if (missileInfo == null) return;

            switch (missileInfo.Type)
            {
                case SpellType.Self:
                    break;
                case SpellType.Circle:
                    var polCircle = new Geometry.Polygon.Circle(missile.Position, missileInfo.Radius);
                    Missiles.Add(missile, polCircle);
                    break;
                case SpellType.Line:
                    var polLine = new Geometry.Polygon.Rectangle(missile.StartPosition,
                        missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
                    Missiles.Add(missile, polLine);
                    break;
                case SpellType.Cone:
                    var polCone = new Geometry.Polygon.Sector(missile.StartPosition, missile.EndPosition, missileInfo.Radius, missileInfo.Range, 80);
                    Missiles.Add(missile, polCone);
                    break;
                case SpellType.Ring:
                    break;
                case SpellType.Arc:
                    break;
                case SpellType.MissileLine:
                    var polMissileLine = new Geometry.Polygon.Rectangle(missile.StartPosition,
                        missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
                    Missiles.Add(missile, polMissileLine);
                    break;
                case SpellType.MissileAoe:
                    var polMissileAoe = new Geometry.Polygon.Rectangle(missile.StartPosition,
                        missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
                    Missiles.Add(missile, polMissileAoe);
                    break;
            }

            var polygons = new List<Geometry.Polygon>();
            polygons.AddRange(Missiles.Values);

            Joined = polygons.JoinPolygons();
        }
示例#6
0
        private static void UpdatePolygons()
        {
            foreach (var missile in Missiles)
            {
                var missileInfo =
                    SpellDatabase.GetSpellInfoList(missile.Key.SpellCaster)
                        .FirstOrDefault(s => s.RealSlot == missile.Key.Slot);
                if (missileInfo == null) return;

                switch (missileInfo.Type)
                {
                    case SpellType.Self:
                        break;
                    case SpellType.Circle:
                        var polCircle = new Geometry.Polygon.Circle(missile.Key.Position, missileInfo.Radius);
                        Missiles[missile.Key] = polCircle;
                        break;
                    case SpellType.Line:
                        var polLine = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
                            missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
                        Missiles[missile.Key] = polLine;
                        break;
                    case SpellType.Cone:
                        var polCone = new Geometry.Polygon.Sector(missile.Key.StartPosition, missile.Key.EndPosition, missileInfo.Radius, missileInfo.Range, 80);
                        Missiles[missile.Key] = polCone;
                        break;
                    case SpellType.Ring:
                        break;
                    case SpellType.Arc:
                        break;
                    case SpellType.MissileLine:
                        var polMissileLine = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
                            missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
                        Missiles[missile.Key] = polMissileLine;
                        break;
                    case SpellType.MissileAoe:
                        var polMissileAoe = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
                            missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
                        Missiles[missile.Key] = polMissileAoe;
                        break;
                }
            }

            var polygons = new List<Geometry.Polygon>();
            polygons.AddRange(Missiles.Values);

            Joined = polygons.JoinPolygons();
        }