Ejemplo n.º 1
0
        public static BPGratBox[] SplitGratBox(BPGratBox box)
        {
            int areaCount = BlueprintUtils.GetAreaCount(box.y, box.w, currentGrid.segment);

            BPGratBox[] areas = new BPGratBox[areaCount];
            SplitGratBoxInTropicAreas(box, areas, currentGrid.segment);
            return(areas);
        }
Ejemplo n.º 2
0
        public static bool IsOnEdgeOfGratBox(this BPGratBox box, float longitudeRad, float latitudeRad, int segmentCount)
        {
            float latPerGrid  = BlueprintUtils.GetLatitudeRadPerGrid(segmentCount);
            float longPerGrid = BlueprintUtils.GetLongitudeRadPerGrid(latitudeRad, segmentCount);

            BPGratBox smallBox = new BPGratBox(box.x + longPerGrid, box.y + latPerGrid, box.z - longPerGrid, box.w - latPerGrid);

            return(!smallBox.InGratBox(longitudeRad, latitudeRad));
        }
Ejemplo n.º 3
0
 public override void _OnClose()
 {
     DismantleQueryRemove();
     ClearSelection();
     ResetBuildPreviews();
     startGroundPosSnapped = lastGroundPosSnapped = castGroundPosSnapped = Vector3.zero;
     lastSelectGratBox     = selectGratBox = selectArcBox = BPGratBox.zero;
     castObjectId          = 0;
     castObjectPos         = Vector3.zero;
     cursorValid           = false;
     cursorTarget          = Vector3.zero;
     waitingForPlayerInput = false;
 }
Ejemplo n.º 4
0
        public static void CheckAfter(BuildTool_BlueprintPaste __instance, ref bool __result, ref bool __state)
        {
            if (__result)
            {
                return;
            }
            if (!BlueprintCopyExtension.isEnabled || !__state)
            {
                return;
            }
            if (!__instance.cannotBuild || reformPreviews.Count <= 0)
            {
                return;
            }

            if (NebulaModAPI.IsMultiplayerActive && NebulaModAPI.MultiplayerSession.Factories.IsIncomingRequest.Value)
            {
                return;
            }

            BPGratBox box = ReformBPUtils.GetBoundingRange(__instance.planet, __instance.actionBuild.planetAux, new int[0], 0, reformPreviews, reformPreviews[0].longitude);

            bool allOk = true;

            for (int i = 0; i < __instance.bpCursor; i++)
            {
                BuildPreview preview = __instance.bpPool[i];
                if (preview.condition == EBuildCondition.NeedGround)
                {
                    Vector3 pos = (preview.lpos + preview.lpos2) * 0.5f;

                    if (box.InGratBox(pos))
                    {
                        preview.condition = EBuildCondition.Ok;
                    }
                }

                if (preview.condition != EBuildCondition.Ok && preview.condition != EBuildCondition.NotEnoughItem)
                {
                    allOk = false;
                }
            }

            if (allOk)
            {
                __result = true;
            }
        }
Ejemplo n.º 5
0
 public override void _OnOpen()
 {
     ClearSelection();
     ResetBuildPreviews();
     castTerrain           = false;
     castGround            = false;
     castGroundPos         = Vector3.zero;
     startGroundPosSnapped = lastGroundPosSnapped = castGroundPosSnapped = Vector3.zero;
     lastSelectGratBox     = selectGratBox = selectArcBox = BPGratBox.zero;
     castObjectId          = 0;
     castObjectPos         = Vector3.zero;
     cursorValid           = false;
     cursorTarget          = Vector3.zero;
     isSelecting           = false;
     waitingForPlayerInput = false;
 }
Ejemplo n.º 6
0
        public void DetermineSelectGratBox()
        {
            if (cursorValid)
            {
                float longitudeRad  = BlueprintUtils.GetLongitudeRad(castGroundPosSnapped.normalized);
                float longitudeRad2 = BlueprintUtils.GetLongitudeRad(lastGroundPosSnapped.normalized);
                float latitudeRad   = BlueprintUtils.GetLatitudeRad(castGroundPosSnapped.normalized);
                bool  flag          = latitudeRad >= 1.5707864f || latitudeRad <= -1.5707864f;
                float num           = flag ? 0f : longitudeRad - longitudeRad2;
                num = Mathf.Repeat(num + 3.1415927f, 6.2831855f) - 3.1415927f;
                selectArcBox.endLongitudeRad = selectArcBox.endLongitudeRad + num;
                selectArcBox.endLatitudeRad  = latitudeRad;
                selectGratBox   = selectArcBox;
                selectGratBox.x = selectArcBox.x < selectArcBox.z ? selectArcBox.x : selectArcBox.z;
                selectGratBox.z = selectArcBox.x > selectArcBox.z ? selectArcBox.x : selectArcBox.z;
                if (selectArcBox.x < selectArcBox.z)
                {
                    if (selectGratBox.z > selectGratBox.x + 6.2831855f - 1E-05f - 4E-06f)
                    {
                        selectGratBox.z = selectGratBox.x + 6.2831855f - 1E-05f - 4E-06f;
                    }

                    selectGratBox.z = Mathf.Repeat(selectGratBox.z + 3.1415927f, 6.2831855f) - 3.1415927f;
                }
                else
                {
                    if (selectGratBox.x < selectGratBox.z - 6.2831855f + 1E-05f + 4E-06f)
                    {
                        selectGratBox.x = selectGratBox.z - 6.2831855f + 1E-05f + 4E-06f;
                    }

                    selectGratBox.x = Mathf.Repeat(selectGratBox.x + 3.1415927f, 6.2831855f) - 3.1415927f;
                }

                selectGratBox.y = selectArcBox.y < selectArcBox.w ? selectArcBox.y : selectArcBox.w;
                selectGratBox.w = selectArcBox.y > selectArcBox.w ? selectArcBox.y : selectArcBox.w;
                float longitude = BlueprintUtils.GetLongitudeRadPerGrid(Mathf.Abs(castGroundPosSnapped.y) < Mathf.Abs(startGroundPosSnapped.y)
                    ? castGroundPosSnapped.normalized
                    : startGroundPosSnapped.normalized) * 0.33f;
                selectGratBox.Extend(longitude, 0.002f);
                if (!flag)
                {
                    lastGroundPosSnapped = castGroundPosSnapped;
                }
            }
        }
Ejemplo n.º 7
0
        private void InitSelectGratBox()
        {
            BlueprintUtils.GetMinimumGratBox(startGroundPosSnapped.normalized, ref selectGratBox);
            selectArcBox = selectGratBox;
            if (selectArcBox.y >= 1.5707864f)
            {
                selectArcBox.y = selectArcBox.w = 1.5707964f;
                selectArcBox.z = selectArcBox.x + 628.31854f;
            }
            else if (selectArcBox.y <= -1.5707864f)
            {
                selectArcBox.y = selectArcBox.w = -1.5707964f;
                selectArcBox.z = selectArcBox.x + 628.31854f;
            }

            lastSelectGratBox = selectGratBox;
        }
Ejemplo n.º 8
0
        public static bool IsOnEdgeOfGratBox(this BPGratBox box, Vector3 pos, int segmentCount)
        {
            pos.Normalize();
            float num = pos.y;

            if (num > 0.999999f)
            {
                return(box.w >= 1.5707864f);
            }
            if (num < -0.999999f)
            {
                return(box.y <= -1.5707864f);
            }
            float latitudeRad  = Mathf.Asin(num);
            float longitudeRad = Mathf.Atan2(pos.x, -pos.z);

            return(box.IsOnEdgeOfGratBox(longitudeRad, latitudeRad, segmentCount));
        }
Ejemplo n.º 9
0
        public static bool CreateBox(BuildTool_BlueprintCopy __instance)
        {
            __instance.curActiveAreaGratBoxCursor = 0;

            CopyToTempArray(__instance);
            CopyReforms();

            BPGratBox gratbox = ReformBPUtils.GetBoundingRange(__instance.planet, __instance.actionBuild.planetAux, __instance._tmp_selected_ids, __instance._tmp_selected_cnt, tmpReformList, __instance.divideLineRad);

            if (__instance.selectedObjIds.Count > 0 || reformSelection.Count > 0)
            {
                float longitudeRadPerGrid = BlueprintUtils.GetLongitudeRadPerGrid(gratbox.startLatitudeRad, __instance.segment);
                float latitudeRadPerGrid  = BlueprintUtils.GetLatitudeRadPerGrid(__instance.segment);
                float extend_lng_grid     = Math.Max(3f - Mathf.RoundToInt(gratbox.width / longitudeRadPerGrid) / 2, 1f);
                float extend_lat_grid     = Math.Max(3f - Mathf.RoundToInt(gratbox.height / latitudeRadPerGrid) / 2, 1f);
                gratbox = BlueprintUtils.GetExtendedGratBox(gratbox, extend_lng_grid, extend_lat_grid);
                __instance.curActiveAreaGratBoxCursor = BlueprintUtils.SplitGratBoxInTropicAreas(gratbox, __instance.tropicGratBoxRadRangeArr, __instance.displayGratBoxArr, __instance.segment);


                Array.Clear(__instance._tmp_selected_ids, 0, __instance._tmp_selected_ids.Length);
            }

            return(false);
        }
Ejemplo n.º 10
0
 public void ClearSelection()
 {
     selectObjIds.Clear();
     edgeObjIds.Clear();
     lastSelectGratBox = selectGratBox = selectArcBox = BPGratBox.zero;
 }
Ejemplo n.º 11
0
        public void Operating()
        {
            if (waitingForPlayerInput)
            {
                return;
            }

            if (!isSelecting && VFInput.blueprintCopyOperate0.onDown && cursorValid)
            {
                isSelecting           = true;
                startGroundPosSnapped = castGroundPosSnapped;
                lastGroundPosSnapped  = startGroundPosSnapped;
                InitSelectGratBox();
                VFInput.UseMouseLeft();
            }

            bool point = (castGroundPosSnapped - startGroundPosSnapped).sqrMagnitude > 0.01f;

            bool onDown = VFInput.blueprintCopyOperate0.onDown || VFInput.blueprintCopyOperate1.onDown;

            if (isSelecting && (onDown && cursorValid || VFInput.blueprintCopyOperate0.onUp && castObjectId != 0 && !point))
            {
                CheckDismantle();
                if (waitingForPlayerInput)
                {
                    return;
                }

                ResetBuildPreviews();
                isSelecting = false;
                VFInput.UseMouseLeft();
                VFInput.UseEnterConfirm();
            }
            else if (isSelecting && VFInput.rtsCancel.onUp)
            {
                isSelecting           = false;
                startGroundPosSnapped = castGroundPosSnapped;
                lastGroundPosSnapped  = startGroundPosSnapped;
                ClearSelection();
                ResetBuildPreviews();
            }

            if (isSelecting)
            {
                DetermineSelectGratBox();
                if (lastSelectGratBox != selectGratBox)
                {
                    DetermineAddSelection();
                    lastSelectGratBox = selectGratBox;
                }
            }
            else
            {
                startGroundPosSnapped = castGroundPosSnapped;
                ReDeterminePreviews();
            }

            if (point)
            {
                ReDeterminePreviews();
            }
        }
Ejemplo n.º 12
0
        public static void SwitchDelete(PlanetFactory factory, List <int> objectIds)
        {
            if (objectIds.Count <= 0)
            {
                return;
            }

            if (NebulaModAPI.IsMultiplayerActive)
            {
                IMultiplayerSession session = NebulaModAPI.MultiplayerSession;
                int planetId = session.Factories.TargetPlanet != NebulaModAPI.PLANET_NONE ? session.Factories.TargetPlanet : factory.planet?.id ?? -1;


                if (session.LocalPlayer.IsHost || !session.Factories.IsIncomingRequest.Value)
                {
                    session.Network.SendPacket(new FastRemoveRequestPacket(planetId, objectIds.ToArray(), Array.Empty <int>(),
                                                                           session.Factories.PacketAuthor == NebulaModAPI.AUTHOR_NONE
                            ? session.LocalPlayer.Id
                            : session.Factories.PacketAuthor, false));
                }

                if (!session.LocalPlayer.IsHost && !session.Factories.IsIncomingRequest.Value)
                {
                    return;
                }
            }

            if (objectIds.Count < 25)
            {
                RegularDeleteEntities(factory, objectIds);
                return;
            }

            if (BlueprintTweaksPlugin.useFastDismantle.Value)
            {
                var player = GameMain.mainPlayer;
                PlayerAction_Build actionBuild = player.controller.actionBuild;

                float         divLine     = GetDivideLine(factory, actionBuild, objectIds);
                BPGratBox     boundingBox = BlueprintUtils.GetBoundingRange(factory.planet, factory.planet.aux, objectIds.ToArray(), objectIds.Count, divLine);
                HashSet <int> edgeObjIds  = new HashSet <int>();

                int segmentCnt = 200;
                if (GameMain.localPlanet?.aux?.activeGrid != null)
                {
                    segmentCnt = GameMain.localPlanet.aux.activeGrid.segment;
                }

                foreach (int objectId in objectIds)
                {
                    if (objectId <= 0 || factory.entityPool[objectId].id != objectId)
                    {
                        continue;
                    }

                    if (boundingBox.IsOnEdgeOfGratBox(factory.entityPool[objectId].pos, segmentCnt))
                    {
                        edgeObjIds.Add(objectId);
                    }
                }

                if (edgeObjIds.Count == 0)
                {
                    foreach (int objectId in objectIds)
                    {
                        if (objectId <= 0 || factory.entityPool[objectId].beltId <= 0)
                        {
                            continue;
                        }

                        RegularDeleteEntities(factory, objectIds);
                        return;
                    }
                }

                FastDeleteEntities(factory, objectIds, edgeObjIds.ToList());
            }
            else
            {
                RegularDeleteEntities(factory, objectIds);
            }
        }
Ejemplo n.º 13
0
        public static int SplitGratBoxInTropicAreas(BPGratBox _gratbox, BPGratBox[] _areaBoxes, int _segmentCnt = 200)
        {
            float startLong = _gratbox.x;
            float startLat  = _gratbox.y;
            float endLong   = _gratbox.z;
            float endLat    = _gratbox.w;

            if (endLong < startLong - 1E-05f)
            {
                endLong += 6.2831855f;
            }

            int   endIdx     = BlueprintUtils.GetSnappedLatitudeGridIdx(endLat, _segmentCnt);
            int   startIdx   = BlueprintUtils.GetSnappedLatitudeGridIdx(startLat, _segmentCnt);
            float radPerGrid = BlueprintUtils.GetLatitudeRadPerGrid(_segmentCnt);
            int   index      = 0;
            int   index1     = -1;
            float curLat     = _gratbox.y;

            _areaBoxes[index]   = BPGratBox.zero;
            _areaBoxes[index].y = _areaBoxes[index].w = curLat;
            int startSegCount = BlueprintUtils.GetLongitudeSegmentCount(startIdx, _segmentCnt);

            for (int i = startIdx; i <= endIdx; i++)
            {
                int curIdx = i + 1 > endIdx ? endIdx : i + 1;
                curLat = curIdx * radPerGrid;
                int curSegCount  = startSegCount;
                int segmentCount = BlueprintUtils.GetLongitudeSegmentCount(curIdx, _segmentCnt);
                startSegCount = segmentCount;
                bool different = curSegCount != segmentCount;
                if (index1 < index)
                {
                    float radPerGrid2     = BlueprintUtils.GetLongitudeRadPerGrid(curSegCount, _segmentCnt);
                    float startCount      = startLong / radPerGrid2;
                    float endCount        = endLong / radPerGrid2;
                    float roundStartCount = BlueprintUtils._round(startCount);
                    endCount = BlueprintUtils._round(endCount);
                    float startLong2 = roundStartCount * radPerGrid2;
                    float endLong2   = endCount * radPerGrid2;
                    if (endLong2 > startLong2 + 6.2831855f - 1E-05f - 4E-06f)
                    {
                        endLong2 = startLong2 + 6.2831855f - radPerGrid2;
                    }

                    if (startLong2 < -3.1415927f)
                    {
                        startLong2 += 6.2831855f;
                    }

                    if (startLong2 > 3.1415927f)
                    {
                        startLong2 -= 6.2831855f;
                    }

                    if (endLong2 < -3.1415927f)
                    {
                        endLong2 += 6.2831855f;
                    }

                    if (endLong2 > 3.1415927f)
                    {
                        endLong2 -= 6.2831855f;
                    }

                    _areaBoxes[index].x = startLong2;
                    _areaBoxes[index].z = endLong2;
                    index1 = index;
                }

                if (different)
                {
                    if (curIdx > 0)
                    {
                        curIdx = i > endIdx ? endIdx : i;
                        curLat = curIdx * radPerGrid;
                    }

                    index++;
                    _areaBoxes[index]   = BPGratBox.zero;
                    _areaBoxes[index].y = _areaBoxes[index].w = curLat;
                }
                else
                {
                    if (curIdx < 0)
                    {
                        curIdx = i + 2 > endIdx ? endIdx : i + 2;
                        curLat = curIdx * radPerGrid;
                    }

                    _areaBoxes[index].w = curLat;
                }
            }

            return(index + 1);
        }
Ejemplo n.º 14
0
        public static void ItterateOnReform(BuildTool_BlueprintCopy __instance, BPGratBox box, Action <int, ReformData> action, bool fullCircle = false)
        {
            if (Mathf.Abs(box.y - box.w) < 0.005f)
            {
                return;
            }

            PlatformSystem platform = __instance.factory.platformSystem;

            if (platform == null)
            {
                return;
            }
            platform.EnsureReformData();

            GetSegmentCount(box.startLatitudeRad, box.startLongitudeRad, out float startLatCount, out float startLongCount, out int startCount);
            GetSegmentCount(box.endLatitudeRad, box.endLongitudeRad, out float endLatCount, out float endLongCount, out int endCount);

            startLatCount  = GridSnappingPatches.Snap(startLatCount);
            startLongCount = GridSnappingPatches.Snap(startLongCount);
            endLatCount    = GridSnappingPatches.Snap(endLatCount);
            endLongCount   = GridSnappingPatches.Snap(endLongCount);

            startLatCount  = Mathf.Round(startLatCount * 10f);
            endLatCount    = Mathf.Round(endLatCount * 10f);
            startLongCount = Mathf.Round(startLongCount * 10f);
            endLongCount   = Mathf.Round(endLongCount * 10f);

            float latDelta = endLatCount - startLatCount;
            int   segmentCount;

            float longDelta;

            if (startCount != endCount)
            {
                Vector2 center = GetSphericalCenter(box.startLatitudeRad, box.startLongitudeRad, box.endLatitudeRad, box.endLongitudeRad);

                GetSegmentCount(center.x, center.y, out float _, out float _, out int midCount);
                segmentCount = midCount;
                if (startCount == midCount)
                {
                    GetSegmentCount(box.startLatitudeRad, box.endLongitudeRad, out float _, out float nlongCount);
                    nlongCount = Mathf.Round(nlongCount * 10f);
                    longDelta  = nlongCount - startLongCount;
                }
                else
                {
                    GetSegmentCount(box.endLatitudeRad, box.startLongitudeRad, out float _, out float nlongCount);
                    nlongCount     = Mathf.Round(nlongCount * 10f);
                    longDelta      = endLongCount - nlongCount;
                    startLongCount = nlongCount;
                }
            }
            else
            {
                segmentCount = startCount;
                longDelta    = endLongCount - startLongCount;
            }

            if (fullCircle)
            {
                longDelta = segmentCount * 10;
            }

            if (longDelta < 0)
            {
                longDelta = segmentCount * 10 + longDelta;
            }

            int latSize  = Mathf.RoundToInt(latDelta) / 2;
            int longSize = Mathf.RoundToInt(longDelta) / 2;

            if (latSize == 0)
            {
                latSize = 1;
            }
            if (longSize == 0)
            {
                longSize = 1;
            }

            startLatCount  += 1;
            startLongCount += 1;

            int latOffset   = 0;
            int longOffset  = 0;
            int longCounter = 0;

            float latCount = platform.latitudeCount / 10f;

            for (int i = 0; i < longSize * latSize; i++)
            {
                longCounter++;
                float currentLat  = (startLatCount + latOffset) / 10f;
                float currentLong = (startLongCount + longOffset) / 10f;

                currentLong = Mathf.Repeat(currentLong, segmentCount);

                float latRad  = (currentLat + 0.1f) / currentGrid.segment * 6.2831855f;
                float longRad = (currentLong + 0.1f) / segmentCount * 6.2831855f;

                longOffset += 2;
                if (longCounter % longSize == 0)
                {
                    longOffset = 0;
                    latOffset += 2;
                }

                if (currentLat >= latCount || currentLat <= -latCount)
                {
                    continue;
                }

                int reformIndex = platform.GetReformIndexForSegment(currentLat, currentLong);

                int reformType  = platform.GetReformType(reformIndex);
                int reformColor = platform.GetReformColor(reformIndex);

                if (!platform.IsTerrainReformed(reformType))
                {
                    continue;
                }

                ReformData reform = new ReformData
                {
                    latitude  = latRad,
                    longitude = longRad,
                    type      = reformType,
                    color     = reformColor
                };

                action(reformIndex, reform);
            }
        }