private void Rotate()
 {
     if (!InventoryItem.ItemContentInfo.Rotatable)
     {
         return;
     }
     GridPosR.Orientation newOri = GridPosR.RotateOrientationClockwise90(InventoryItem.GridPos_Matrix.orientation);
     InventoryItem.GridPos_Matrix = new GridPosR(InventoryItem.GridPos_Matrix.x, InventoryItem.GridPos_Matrix.z, newOri);
     SetVirtualGridPos(InventoryItem.GridPos_World);
     dragStartLocalPos += new Vector2(InventoryItem.BoundingRect.x_min * UIInventory.GridSize, -InventoryItem.BoundingRect.z_min * UIInventory.GridSize) - RectTransform.anchoredPosition;
     RefreshView();
 }
        public static MechaInfo GetMechaInfo(this MechaConfig mechaConfig, MechaCamp mechaCamp)
        {
            MechaInfo mechaInfo = new MechaInfo(mechaConfig.MechaConfigName, mechaCamp, mechaConfig.Clone());

            foreach (MechaConfig.Config config in mechaConfig.MechaComponentList)
            {
                MechaComponentConfig mcc      = ConfigManager.Instance.GetMechaComponentConfig(config.MechaComponentKey);
                MechaComponentInfo   mci      = new MechaComponentInfo(mcc, config.MechaComponentQuality, config.MechaComponentAlias);
                GridPosR             finalGPR = config.GridPosR + ConfigManager.EDIT_AREA_HALF_SIZE * GridPosR.One;
                mechaInfo.AddMechaComponentInfo(mci, finalGPR);
            }

            return(mechaInfo);
        }
Exemple #3
0
    public void RotateOccupiedPositions()
    {
        List <GridPos> gps = new List <GridPos>();

        foreach (SkillGrid sg in OccupiedPositions)
        {
            gps.Add(sg.GridPos);
        }

        gps = GridPosR.TransformOccupiedPositions(new GridPosR(0, 0, GridPosR.Orientation.Right), gps);
        for (int index = 0; index < OccupiedPositions.Count; index++)
        {
            OccupiedPositions[index] = new SkillGrid(gps[index], OccupiedPositions[index].SkillGridType);
        }
    }
        private void SetVirtualGridPos(GridPosR gridPos_World)
        {
            UIInventory.UIInventoryPanel.UIInventoryVirtualOccupationQuadRoot.Clear();
            foreach (GridPos gp_matrix in InventoryItem.OccupiedGridPositions_Matrix)
            {
                if (!UIInventory.ContainsGP(gp_matrix))
                {
                    continue;
                }

                UIInventoryVirtualOccupationQuad quad = UIInventory.CreateUIInventoryItemVirtualOccupationQuad(UIInventory.UIInventoryPanel.UIInventoryVirtualOccupationQuadRoot.transform);
                quad.Init(InventoryItem.Inventory.GridSize, gp_matrix, InventoryItem.Inventory);
                UIInventory.UIInventoryPanel.UIInventoryVirtualOccupationQuadRoot.uiInventoryVirtualOccupationQuads.Add(quad);
            }
        }
Exemple #5
0
    private void SetVirtualGridPos(GridPosR gridPos_World)
    {
        City.CityInventoryVirtualOccupationQuadRoot.Clear();
        foreach (GridPos gp_matrix in InventoryItem.OccupiedGridPositions_Matrix)
        {
            if (!CityInventory.ContainsGP(gp_matrix))
            {
                continue;
            }

            CityInventoryVirtualOccupationQuad quad = CityInventory.CreateCityInventoryVirtualOccupationQuad(City.CityInventoryVirtualOccupationQuadRoot.transform);
            quad.Init(InventoryItem.Inventory.GridSize, gp_matrix, InventoryItem.Inventory);
            City.CityInventoryVirtualOccupationQuadRoot.cityInventoryVirtualOccupationQuads.Add(quad);
        }
    }
Exemple #6
0
        public void AddMechaComponentInfo(MechaComponentInfo mci, GridPosR gp_matrix)
        {
            if (IsBuilding)
            {
                _totalLife = 0;
            }
            mci.MechaInfo = this;
            mci.OnRemoveMechaComponentInfoSuc += RemoveMechaComponentInfo;
            MechaComponentInfoDict.Add(mci.GUID, mci);
            if (!string.IsNullOrEmpty(mci.Alias))
            {
                if (MechaComponentInfoDict_Alias.ContainsKey(mci.Alias))
                {
                    MechaComponentInfo tempMCI = MechaComponentInfoDict_Alias[mci.Alias];
                    Debug.LogError($"机甲组件花名重复. " +
                                   $"机甲: {LogIdentityName}, 组件: {mci.LogIdentityName}, 花名: {mci.Alias}" +
                                   $"重复对象组件: {tempMCI.LogIdentityName}");
                }
                else
                {
                    MechaComponentInfoDict_Alias.Add(mci.Alias, mci);
                }
            }

            InventoryItem item = new InventoryItem(mci, MechaEditorInventory, gp_matrix);

            item.AmIRootItemInIsolationCalculationHandler = () => ((MechaComponentInfo)item.ItemContentInfo).MechaComponentType == MechaComponentType.Core;
            mci.SetInventoryItem(item);

            void instantiateMechaComponent()
            {
                item.Inventory = MechaEditorInventory;
                OnAddMechaComponentInfoSuc.Invoke(mci, gp_matrix);
                MechaEditorInventory.TryAddItem(item);
                MechaEditorInventory.RefreshConflictAndIsolation();
            }

            if (MechaEditorInventory != null)
            {
                instantiateMechaComponent();
            }
            else
            {
                OnInstantiated += instantiateMechaComponent;
            }
        }
        private void Initialize(MechaComponentInfo mechaComponentInfo, Mecha parentMecha)
        {
            SetLayer(LayerManager.Instance.GetLayerByMechaCamp(mechaComponentInfo.MechaInfo.MechaCamp));
            mechaComponentInfo.OnRemoveMechaComponentInfoSuc += (mci) =>
            {
                OnRemoveMechaComponentSuc?.Invoke(this);
                PoolRecycle();
            };

            mechaComponentInfo.OnHighLightColorChange += HighLightColorChange;
            HighLightColorChange(QualityManager.GetQuality(mechaComponentInfo.Quality).Color, mechaComponentInfo.CurrentPowerUpgradeData.HighLightColorIntensity);

            {
                mechaComponentInfo.InventoryItem.OnSetGridPosHandler = (gridPos_World) =>
                {
                    GridPosR.ApplyGridPosToLocalTrans(gridPos_World, transform, ConfigManager.GridSize);
                    MechaInfo.MechaEditorInventory.RefreshConflictAndIsolation();
                };
                mechaComponentInfo.InventoryItem.OnIsolatedHandler = (shown) =>
                {
                    if (shown)
                    {
                        MechaComponentModelRoot.SetBuildingBasicEmissionColor(CommonUtils.HTMLColorToColor("#E42835"));
                    }
                    else
                    {
                        MechaComponentModelRoot.ResetBuildingBasicEmissionColor();
                    }

                    MechaComponentGridRoot.SetIsolatedIndicatorShown(shown);
                };
                mechaComponentInfo.InventoryItem.OnConflictedHandler    = MechaComponentGridRoot.SetGridConflicted;
                mechaComponentInfo.InventoryItem.OnResetConflictHandler = MechaComponentGridRoot.ResetAllGridConflict;
            }

            MechaComponentInfo = mechaComponentInfo;
            GridPos.ApplyGridPosToLocalTransXZ(MechaComponentInfo.InventoryItem.GridPos_World, transform, ConfigManager.GridSize);
            Mecha = parentMecha;
            MechaComponentGridRoot.SetInBattle(true);

            Initialize_Fighting();
        }
Exemple #8
0
        public void Draggable_OnMousePressed(DragArea dragArea, Vector3 diffFromStart, Vector3 deltaFromLastFrame)
        {
            if (dragArea.Equals(Backpack.DragArea))
            {
                if (Backpack.RotateItemKeyDownHandler != null && Backpack.RotateItemKeyDownHandler.Invoke())
                {
                    Rotate();
                }

                if (diffFromStart.magnitude <= Draggable_DragMinDistance)
                {
                    // stay
                }
                else
                {
                    Vector2  diffLocal       = RectTransform.parent.InverseTransformVector(diffFromStart);
                    Vector2  currentLocalPos = dragStartLocalPos + diffLocal;
                    GridPosR diff_world      = GridPos.GetGridPosByPointXY(diffLocal, Backpack.GridSize);
                    diff_world.orientation = InventoryItem.GridPos_Matrix.orientation;
                    GridPosR diff_matrix = Backpack.CoordinateTransformationHandler_FromPosToMatrixIndex(diff_world);
                    GridPosR gp_matrix   = dragStartGridPos_Matrix + diff_matrix;
                    gp_matrix.orientation = InventoryItem.GridPos_Matrix.orientation;
                    InventoryItem.SetGridPosition(gp_matrix);
                    RectTransform.anchoredPosition = currentLocalPos;
                }
            }
            else
            {
                if (Backpack.DragItemOutBackpackCallback != null)
                {
                    Backpack.BackpackPanel.BackpackItemVirtualOccupationRoot.Clear();
                    if (Backpack.DragItemOutBackpackCallback.Invoke(this))
                    {
                        InventoryItem.GridPos_Matrix = dragStartGridPos_Matrix;
                        Backpack.RemoveItem(InventoryItem, true);
                        PoolRecycle();
                    }
                }
            }
        }
        public void SetConnection(GridPosR.OrientationFlag adjacentConnection, GridPosR.OrientationFlag diagonalConnection)
        {
            foreach (GridPosR.Orientation orientation in Enum.GetValues(typeof(GridPosR.Orientation)))
            {
                MainImageBorders[(int)orientation].enabled = !adjacentConnection.HasFlag(orientation.ToFlag());

                GridPosR.Orientation next = GridPosR.RotateOrientationClockwise90(orientation);
                if (!adjacentConnection.HasFlag(orientation.ToFlag()) && !adjacentConnection.HasFlag(next.ToFlag()))
                {
                    SideImageBorders[((int)orientation) * 2].enabled     = false;
                    SideImageBorders[((int)orientation) * 2 + 1].enabled = false;
                }
                else if (adjacentConnection.HasFlag(orientation.ToFlag()) && adjacentConnection.HasFlag(next.ToFlag()))
                {
                    if (diagonalConnection.HasFlag(orientation.ToFlag()))
                    {
                        SideImageBorders[((int)orientation) * 2].enabled     = false;
                        SideImageBorders[((int)orientation) * 2 + 1].enabled = false;
                    }
                    else
                    {
                        SideImageBorders[((int)orientation) * 2].enabled     = true;
                        SideImageBorders[((int)orientation) * 2 + 1].enabled = true;
                    }
                }
                else
                {
                    if (adjacentConnection.HasFlag(orientation.ToFlag()))
                    {
                        SideImageBorders[((int)orientation) * 2].enabled     = true;
                        SideImageBorders[((int)orientation) * 2 + 1].enabled = false;
                    }
                    else
                    {
                        SideImageBorders[((int)orientation) * 2].enabled     = false;
                        SideImageBorders[((int)orientation) * 2 + 1].enabled = true;
                    }
                }
            }
        }
Exemple #10
0
        public void SetGridPosition(GridPosR gp_matrix)
        {
            if (!gp_matrix.Equals(GridPos_Matrix))
            {
                GridPosR oriGPR = GridPos_Matrix;
                GridPos_Matrix = gp_matrix;
                foreach (GridPos gp in OccupiedGridPositions_Matrix)
                {
                    if (gp.x >= Inventory.Columns)
                    {
                        GridPos_Matrix = oriGPR;
                        SetGridPosition(new GridPosR(gp_matrix.x - 1, gp_matrix.z, gp_matrix.orientation));
                        return;
                    }

                    if (gp.x < 0)
                    {
                        GridPos_Matrix = oriGPR;
                        SetGridPosition(new GridPosR(gp_matrix.x + 1, gp_matrix.z, gp_matrix.orientation));
                        return;
                    }

                    if (gp.z >= Inventory.Rows)
                    {
                        GridPos_Matrix = oriGPR;
                        SetGridPosition(new GridPosR(gp_matrix.x, gp_matrix.z - 1, gp_matrix.orientation));
                        return;
                    }

                    if (gp.z < 0)
                    {
                        GridPos_Matrix = oriGPR;
                        SetGridPosition(new GridPosR(gp_matrix.x, gp_matrix.z + 1, gp_matrix.orientation));
                        return;
                    }
                }

                OnSetGridPosHandler?.Invoke(GridPos_World);
            }
        }
Exemple #11
0
 public void Initialize()
 {
     Orientation = GridPosR.GetGridPosByLocalTrans(transform, ConfigManager.GridSize).orientation;
 }
Exemple #12
0
 public void CameraRightRotate()
 {
     RotateDirection            = GridPosR.RotateOrientationAntiClockwise90(RotateDirection);
     TargetConfigData.HorAngle -= 90f;
 }
Exemple #13
0
 public void CameraLeftRotate()
 {
     RotateDirection            = GridPosR.RotateOrientationClockwise90(RotateDirection);
     TargetConfigData.HorAngle += 90f;
 }
Exemple #14
0
 public InventoryItem(IInventoryItemContentInfo itemContentInfo, Inventory inventory, GridPosR gp_matrix)
 {
     GUID            = GetGUID();
     Inventory       = inventory;
     GridPos_Matrix  = gp_matrix;
     ItemContentInfo = itemContentInfo;
 }
Exemple #15
0
 public void Rotate()
 {
     SetGridPosition(new GridPosR(GridPos_Matrix.x, GridPos_Matrix.z, GridPosR.RotateOrientationClockwise90(GridPos_Matrix.orientation)));
 }
Exemple #16
0
    public void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            CurrentSelectedBuildingKey = BuildingKey.None;
        }

        City.CityEditAreaIndicator.GetMousePosOnThisArea(out Vector3 pos_world, out Vector3 pos_local, out Vector3 pos_matrix, out GridPos gp_matrix);

        if (CurrentSelectedBuildingKey != BuildingKey.None && !EventSystem.current.IsPointerOverGameObject())
        {
            // add preview
            if (City.CityInventory.InventoryInfo.PreviewInventoryItem == null)
            {
                BuildingInfo  bi = BuildingInfoDict[CurrentSelectedBuildingKey].Clone();
                InventoryItem ii = new InventoryItem(bi, City.CityInventory, gp_matrix);
                City.CityInventory.AddPreviewItem(ii);
            }

            // move with cursor
            if (City.CityInventory.InventoryInfo.PreviewInventoryItem != null)
            {
                GridPosR newGPR = gp_matrix;
                newGPR.orientation = City.CityInventory.InventoryInfo.PreviewInventoryItem.GridPos_Matrix.orientation;
                City.CityInventory.InventoryInfo.PreviewInventoryItem?.SetGridPosition(newGPR);

                City.RefreshBuildingCoverMaskMatrix(true);
                City.RefreshBuildingRangeGridView(CurrentSelectedBuildingKey);
            }
        }

        // put down building
        if (Input.GetMouseButtonDown(0) && !EventSystem.current.IsPointerOverGameObject())
        {
            InventoryItem previewItem = City.CityInventory.InventoryInfo.PreviewInventoryItem;
            if (previewItem != null)
            {
                bool sucPutDown = false;
                if (City.CityInventory.CheckSpaceAvailable(previewItem.OccupiedGridPositions_Matrix))
                {
                    bool needAllOccupationValid = BuildingInfoDict[CurrentSelectedBuildingKey].NeedAllOccupationValid;
                    if (needAllOccupationValid)
                    {
                        sucPutDown = true;
                        foreach (GridPos gp in previewItem.OccupiedGridPositions_Matrix)
                        {
                            if (!City.CityInventory.InventoryValidMatrix[gp.x, gp.z])
                            {
                                sucPutDown = false;
                            }
                        }
                    }

                    else
                    {
                        if (City.CityInventory.InventoryValidMatrix[previewItem.GridPos_Matrix.x, previewItem.GridPos_Matrix.z])
                        {
                            sucPutDown = true;
                        }
                    }

                    if (sucPutDown)
                    {
                        City.CityInventory.PutDownItem(previewItem);
                        BuildingInfo buildingInfo = BuildingInfoDict[City.GetBuilding(previewItem.GUID).BuildingInfo.buildingKey];
                        Budget -= buildingInfo.BudgetCost;
                        Oxygen -= buildingInfo.OxygenCost;
                        City.RefreshResourcesInfo();
                        RecheckResourcesMeetCurrentSelectBuilding();
                        City.RefreshBuildingCoverMaskMatrix(false);
                        City.RefreshValidGridView(CurrentSelectedBuildingKey);
                        City.RefreshBuildingCoverMaskMatrix(true);
                        City.RefreshBuildingRangeGridView(CurrentSelectedBuildingKey);
                        City.CityInventoryVirtualOccupationQuadRoot.Clear();
                    }
                }

                if (!sucPutDown)
                {
                    City.CityInventory.RemoveItem(previewItem, true);
                }
            }
        }

        if (City.CityInventory.RotateItemKeyDownHandler != null && City.CityInventory.RotateItemKeyDownHandler.Invoke())
        {
            InventoryItem previewItem = City.CityInventory.InventoryInfo.PreviewInventoryItem;
            if (previewItem != null)
            {
                Building building = City.GetBuilding(previewItem.GUID);
                if (building != null)
                {
                    building.Rotate();
                    City.RefreshBuildingCoverMaskMatrix(true);
                    City.RefreshBuildingRangeGridView(CurrentSelectedBuildingKey);
                }
            }
        }
    }
        public void Draggable_OnMousePressed(DragAreaIndicator dragAreaIndicator, Vector3 diffFromStart, Vector3 deltaFromLastFrame)
        {
            void ResumePausedDrag()
            {
                InventoryItem.GridPos_Matrix = dragStartGridPos_Matrix;
                UIInventory.RemoveItem(InventoryItem, true);
                Destroy(gameObject);
                DragManager.Instance.ResumePausedDrag();
            }

            if (dragAreaIndicator == UIInventory.DragAreaIndicator)
            {
                if (UIInventory.RotateItemKeyDownHandler != null && UIInventory.RotateItemKeyDownHandler.Invoke())
                {
                    Rotate();
                }

                if (diffFromStart.magnitude > Draggable_DragMinDistance)
                {
                    Vector2  diffLocal       = RectTransform.parent.InverseTransformVector(diffFromStart);
                    Vector2  currentLocalPos = dragStartLocalPos + diffLocal;
                    GridPosR diff_world      = GridPos.GetGridPosByPointXY(diffLocal, UIInventory.GridSize);
                    diff_world.orientation = InventoryItem.GridPos_Matrix.orientation;
                    GridPosR diff_matrix = UIInventory.CoordinateTransformationHandler_FromPosToMatrixIndex(diff_world);
                    GridPosR gp_matrix   = dragStartGridPos_Matrix + diff_matrix;
                    gp_matrix.orientation        = InventoryItem.GridPos_Matrix.orientation;
                    InventoryItem.GridPos_Matrix = gp_matrix;
                    SetVirtualGridPos(InventoryItem.GridPos_World);
                    RectTransform.anchoredPosition = currentLocalPos;
                }
            }
            else
            {
                Vector2 diffLocal       = RectTransform.parent.InverseTransformVector(diffFromStart);
                Vector2 currentLocalPos = dragStartLocalPos + diffLocal;
                RectTransform.anchoredPosition = currentLocalPos;
                UIInventory.UIInventoryPanel.UIInventoryVirtualOccupationQuadRoot.Clear();
                if (dragAreaIndicator != null) // drag to other DragAreas
                {
                    if (DragManager.Instance.PausedDrag != null)
                    {
                        ResumePausedDrag();
                    }
                    else
                    {
                        // only when mouse move to available grid then generate previewItem
                        if (dragAreaIndicator is UIInventoryDragAreaIndicator uiDAI)
                        {
                            uiDAI.UIInventory.UIInventoryPanel.UIInventoryDragAreaIndicator.GetMousePosOnThisArea(out Vector3 pos_world, out Vector3 pos_local, out Vector3 pos_matrix, out GridPos gp_matrix);
                            GridPosR gpr = gp_matrix;
                            gpr.orientation = InventoryItem.GridPos_Matrix.orientation;
                            InventoryItem previewItem = new InventoryItem(InventoryItem.Clone().ItemContentInfo, uiDAI.UIInventory, gpr);
                            uiDAI.UIInventory.AddPreviewItem(previewItem);
                            UIInventoryItem uiInventoryItem = uiDAI.UIInventory.UIInventoryPanel.GetUIInventoryItem(previewItem.GUID);
                            DragManager.Instance.PauseDrag();
                            DragManager.Instance.CurrentDrag = uiInventoryItem.Draggable;
                            uiInventoryItem.Draggable.SetOnDrag(true, uiDAI.UIInventory.UIInventoryPanel.UIInventoryDragAreaIndicator.BoxCollider, UIInventory.DragProcessor);
                        }
                    }
                }
                else // drag to non-DragArea
                {
                    if (DragManager.Instance.PausedDrag != null)
                    {
                        ResumePausedDrag();
                    }
                }
            }
        }