/// <summary>
    /// 获取建筑属于玩家的哪个基地,不属于,返回NULL
    /// </summary>
    /// <param name="building"></param>
    /// <returns></returns>
    public MainBaseVO GetMainBasePlayerBuildingBelongTo(IBuildingVO building, PlayerVO playerVO)
    {
        if (building.buildingType == E_Building.MainBase)
        {
            return(building as MainBaseVO);
        }

        PlayerVO           player    = playerVO;
        IList <MainBaseVO> mainbases = player.mainBases;
        List <IBuildingVO> buildings = null;
        Vector3Int         downLeft;
        Vector3Int         upRight;
        Vector3Int         downLeftb;
        Vector3Int         upRightb;

        if (mainbases.Count == 0)
        {
            return(null);
        }

        for (int i = 0; i < mainbases.Count; i++)
        {
            downLeft = building.tilePositon - new Vector3Int(building.rect.position.x, 0, building.rect.position.y);
            if (!mainbases[i].IsIn(downLeft))
            {
                continue;
            }
            downLeft.x += building.rect.size.x - 1;
            if (!mainbases[i].IsIn(downLeft))
            {
                continue;
            }
            downLeft.z += building.rect.size.y - 1;
            upRight     = downLeft;
            if (!mainbases[i].IsIn(downLeft))
            {
                continue;
            }
            downLeft.x -= building.rect.size.x - 1;
            if (!mainbases[i].IsIn(downLeft))
            {
                continue;
            }

            buildings = mainbases[i].ownBuildings;
            for (int j = 0; j < buildings.Count; j++)
            {
                downLeftb = buildings[j].tilePositon - new Vector3Int(building.rect.position.x, 0, building.rect.position.y);
                upRightb  = downLeftb + new Vector3Int(buildings[j].rect.width - 1, 0, buildings[j].rect.height - 1);
                if (downLeft.x <= upRightb.x && upRight.x >= downLeftb.x && downLeft.z <= upRightb.z && upRight.z >= downLeftb.z)
                {
                    return(null);
                }
            }
            return(mainbases[i]);
        }

        return(null);
    }
    /// <summary>
    /// 判断建筑是否能够建造
    /// </summary>
    /// <param name="playerID"></param>
    /// <param name="building"></param>
    /// <returns></returns>
    public bool IsCanConstructionUserBuilding(int playerID, IBuildingVO building)
    {
        PlayerVO           player    = _Players[playerID];
        IList <MainBaseVO> mainbases = player.mainBases;
        List <IBuildingVO> buildings = null;
        Vector3Int         downLeft;
        Vector3Int         middle;
        Vector3Int         upRight;
        Vector3Int         downLeftb;
        Vector3Int         upRightb;

        if (mainbases.Count == 0)
        {
            return(false);
        }

        for (int i = 0; i < mainbases.Count; i++)
        {
            downLeft = building.tilePositon - new Vector3Int(building.rect.position.x, 0, building.rect.position.y);
            middle   = downLeft;
            if (!mainbases[i].IsIn(middle))
            {
                continue;
            }
            middle.x += building.rect.size.x - 1;
            if (!mainbases[i].IsIn(middle))
            {
                continue;
            }
            middle.z += building.rect.size.y - 1;
            upRight   = middle;
            if (!mainbases[i].IsIn(middle))
            {
                continue;
            }
            middle.x -= building.rect.size.x - 1;
            if (!mainbases[i].IsIn(middle))
            {
                continue;
            }

            buildings = mainbases[i].ownBuildings;
            for (int j = 0; j < buildings.Count; j++)
            {
                downLeftb = buildings[j].tilePositon - new Vector3Int(building.rect.position.x, 0, building.rect.position.y);
                upRightb  = downLeftb + new Vector3Int(buildings[j].rect.width - 1, 0, buildings[j].rect.height - 1);
                if (downLeft.x <= upRightb.x && upRight.x >= downLeftb.x && downLeft.z <= upRightb.z && upRight.z >= downLeftb.z)
                {
                    return(false);
                }
            }
            return(true);
        }

        return(false);
    }
    public void Build(PlayerVO ower, E_Building buildingType, MainBaseVO mainBaseVO)
    {
        IBuildingVO buildingVO = null;
        Vector3Int  center     = default;
        int         radius     = 0;
        int         count      = 0;

        if (mainBaseVO != null)
        {
            center = mainBaseVO.tilePositon;
            radius = mainBaseVO.radius;
        }
        switch (buildingType)
        {
        case E_Building.None:
            break;

        case E_Building.MainBase:
            buildingVO = new MainBaseVO();
            count      = GetBuildMainbasePositionClose(_ConstructionInfos, ower);
            break;

        case E_Building.FarmLand:
            buildingVO = new FarmLandVO();
            count      = GetBuildPosition(_ConstructionInfos, center, radius, buildingVO.rect);
            break;

        case E_Building.GoldMine:
            buildingVO = new GoldMineVO();
            count      = GetBuildPosition(_ConstructionInfos, center, radius, buildingVO.rect);
            break;

        case E_Building.MilitaryCamp:
            buildingVO = new MilitaryCampVO();
            count      = GetBuildPosition(_ConstructionInfos, center, radius, buildingVO.rect);
            break;

        default:
            break;
        }
        ConstructionInfo constructionInfo = _SelectConstructionHandler(_ConstructionInfos, count, 0);

        if (constructionInfo.isRotation)
        {
            buildingVO.Rotate();
        }
        buildingVO.tilePositon = constructionInfo.position;
        var msgParam = TwoMsgParamsPool <PlayerVO, IBuildingVO> .Instance.Pop();

        msgParam.InitParams(ower, buildingVO);
        sender.Invoke(GlobalSetting.Cmd_ConfirmConstruction, msgParam);
    }
    private void SetOriginData(IBuildingVO buildingVO, MainBaseVO mainBaseVO, PlayerVO player)
    {
        switch (buildingVO.buildingType)
        {
        case E_Building.MainBase:
            var tempMainBaseVO = buildingVO as MainBaseVO;
            SetMainBaseOriginData(tempMainBaseVO);
            player.goldLimit          += tempMainBaseVO.goldLimit;
            player.grainLimit         += tempMainBaseVO.grainLimit;
            player.soldierAmount      += tempMainBaseVO.soldierNum;
            player.soldierAmountLimit += tempMainBaseVO.soldierNumLimit;
            _AllMainBases.Add(tempMainBaseVO);
            OccupiedMainBase(tempMainBaseVO, Time.time);

            SendNotification(GlobalSetting.Msg_MainbaseCreateComplete, tempMainBaseVO);
            break;

        case E_Building.FarmLand:
            var tempFarmLandVO = buildingVO as FarmLandVO;
            //SetFarmLandOriginData(tempFarmLandVO);
            mainBaseVO.grainLimit     += tempFarmLandVO.grainLimit;
            player.grainLimit         += tempFarmLandVO.grainLimit;
            mainBaseVO.grainOutputNum += tempFarmLandVO.grainOutputNum;
            break;

        case E_Building.GoldMine:
            var tempGoldMineVO = buildingVO as GoldMineVO;
            //SetGoldMineOriginData(tempGoldMineVO);
            mainBaseVO.goldLimit     += tempGoldMineVO.goldLimit;
            player.goldLimit         += tempGoldMineVO.goldLimit;
            mainBaseVO.goldOutputNum += tempGoldMineVO.goldOutputNum;
            break;

        case E_Building.MilitaryCamp:
            var tempMilitaryCampVO = buildingVO as MilitaryCampVO;
            //SetMilitaryCampOriginData(tempMilitaryCampVO);
            mainBaseVO.soldierNumLimit += tempMilitaryCampVO.soldierNumLimit;
            player.soldierAmountLimit  += tempMilitaryCampVO.soldierNumLimit;
            mainBaseVO.trainNum        += tempMilitaryCampVO.trainNum;
            break;

        default:
            break;
        }
    }
    public void CreateBuilding(IBuildingVO buildingVO, MainBaseVO mainBaseVO, PlayerVO player)
    {
        if (!_PlayerToMainBase.ContainsKey(player.Id))
        {
            _PlayerToMainBase.Add(player.Id, new List <MainBaseVO>());
        }

        if (buildingVO.buildingType == E_Building.MainBase)
        {
            _PlayerToMainBase[player.Id].Add(mainBaseVO);
        }

        SetOriginData(buildingVO, mainBaseVO, player);

        _BuildingToMainBase.Add(buildingVO, mainBaseVO);

        SendNotification(GlobalSetting.Msg_BuildBuilding, buildingVO);

        if (player.IsUser)
        {
            SendNotification(GlobalSetting.Msg_SetUsersPlayerBattleInfoDirty);
        }
    }
Exemple #6
0
    public override void Execute(INotification notification)
    {
        var msgParam = notification.Body as TwoMsgParams <PlayerVO, IBuildingVO>;

        if (msgParam != null && msgParam.first != null && msgParam.second != null)
        {
            PlayerVO        playerVo      = msgParam.first;
            IBuildingVO     building      = msgParam.second;
            PlayerVOProxy   playerVOProxy = Facade.RetrieveProxy(PlayerVOProxy.NAME) as PlayerVOProxy;
            MapVOProxy      mapVOProxy    = Facade.RetrieveProxy(MapVOProxy.NAME) as MapVOProxy;
            BuildingVOProxy buildingProxy = Facade.RetrieveProxy(BuildingVOProxy.NAME) as BuildingVOProxy;

            //判断资源是否满足创建需求
            if (playerVo.gold < building.createCostGold || playerVo.grain < building.createCostGrain)
            {
                return;
            }

            playerVo.gold  -= building.createCostGold;
            playerVo.grain -= building.createCostGrain;

            switch (building.buildingType)
            {
            case E_Building.None:
                break;

            case E_Building.MainBase:
                //判断是否可以被添加....
                MainBaseVO mainBaseVO = building as MainBaseVO;
                if (mainBaseVO != null)
                {
                    if (mapVOProxy.IsCanOccupedArea(mainBaseVO.tilePositon, mainBaseVO.radius))
                    {
                        mainBaseVO.SetOwer(playerVo);
                        buildingProxy.CreateBuilding(mainBaseVO, mainBaseVO, playerVo);
                        //更新地图建筑信息
                        mapVOProxy.SetBuildingInfo(true, building.tilePositon, building.rect);
                        //更新占领信息
                        mapVOProxy.SetOccupiedInfo(true, building.tilePositon, mainBaseVO.radius);
                    }
                }
                break;

            case E_Building.FarmLand:
            case E_Building.GoldMine:
            case E_Building.MilitaryCamp:
                MainBaseVO mainBase = playerVOProxy.GetMainBasePlayerBuildingBelongTo(building, playerVo);
                if (mainBase != null)
                {
                    //添加建筑
                    mainBase.AddBuilding(building);
                    //更新地图建筑信息
                    mapVOProxy.SetBuildingInfo(true, building.tilePositon, building.rect);
                    buildingProxy.CreateBuilding(building, mainBase, playerVo);
                }
                break;

            default:
                break;
            }

            TwoMsgParamsPool <PlayerVO, IBuildingVO> .Instance.Push(msgParam);
        }

        BattleManager.Instance.CancelConstraction();
    }