Esempio n. 1
0
    private void CreateOneBuildingNpc(BuildingNpc buildingNpc)
    {
        if (!NpcMissionDataRepository.m_AdRandMisNpcData.ContainsKey(buildingNpc.templateId))
        {
            LogManager.Error("not exist! id = [", buildingNpc.templateId, "] Pos = ", buildingNpc.pos);
            return;
        }

        buildingNpc.pos.y += 0.2f;
        if (PeGameMgr.IsSingleAdventure)
        {
            //AdNpcData adNpcData = NpcMissionDataRepository.m_AdRandMisNpcData[buildingNpc.templateId];
            //int RNpcId = adNpcData.mRnpc_ID;
            //int Qid = adNpcData.mQC_ID;

            PeEntity npc = NpcEntityCreator.CreateNpc(buildingNpc.templateId, buildingNpc.pos, Vector3.one, Quaternion.Euler(0, buildingNpc.rotY, 0));
            if (npc == null)
            {
                Debug.LogError("npc id error: templateId = " + buildingNpc.templateId);
                return;
            }
            if (buildingNpc.isStand)
            {
                VArtifactUtil.SetNpcStandRot(npc, buildingNpc.rotY, true);
                createdNpcIdList.Add(new BuildingNpcIdStand(npc.Id, true, buildingNpc.rotY));
            }
            else
            {
                createdNpcIdList.Add(new BuildingNpcIdStand(npc.Id, false, buildingNpc.rotY));
            }
            //--to do: npc
            //NpcRandom nr = NpcManager.Instance.CreateRandomNpc(RNpcId, buildingNpc.pos);

            //StroyManager.Instance.NpcTakeMission(RNpcId, Qid, buildingNpc.pos, nr, adNpcData.m_CSRecruitMissionList);

            //if(buildingNpc.isStand)
            //{
            //    nr.SetRotY(buildingNpc.rotY);
            //    nr.CloseAi();
            //    createdNpcIdList.Add(new BuildingNpcIdStand(nr.mNpcId, true, buildingNpc.rotY));
            //}
            //else
            //{
            //    createdNpcIdList.Add(new BuildingNpcIdStand(nr.mNpcId, false, buildingNpc.rotY));
            //}
        }
        else if (GameConfig.IsMultiMode)
        {
            //SPTerrainEvent.instance.CreateAdNpcByIndex(buildingNpc.pos, buildingNpc.templateId, 1, buildingNpc.isStand, buildingNpc.rotY);
            PlayerNetwork.mainPlayer.RequestTownNpc(buildingNpc.pos, buildingNpc.templateId, 1, buildingNpc.isStand, buildingNpc.rotY);
        }
    }
    public void GetNpcInfo(out List <BuildingNpc> buildingNpcs)
    {
        buildingNpcs = new List <BuildingNpc>();
        //npc stand
        if (!mNpcIdPosRotStand.Equals("") && mNpcIdPosRotStand.Length > 1)
        {
            string[] npcs = mNpcIdPosRotStand.Split('_');
            for (int i = 0; i < npcs.Count(); i++)
            {
                string[]    npcIdPosRotStr = npcs[i].Split('~');
                int         id             = Convert.ToInt32(npcIdPosRotStr[0]);
                string[]    posRot         = npcIdPosRotStr[1].Split(';');
                string[]    posStr         = posRot[0].Split(',');
                Vector3     pos            = new Vector3(float.Parse(posStr[0]), float.Parse(posStr[1]), float.Parse(posStr[2]));
                float       rot            = float.Parse(posRot[1]);
                BuildingNpc bdnpc          = new BuildingNpc(id, pos, rot, true);
                buildingNpcs.Add(bdnpc);
            }
        }

        //npc move
        if (!mNpcIdPosRotMove.Equals("") && mNpcIdPosRotMove.Length > 1)
        {
            string[] npcs = mNpcIdPosRotMove.Split('_');
            for (int i = 0; i < npcs.Count(); i++)
            {
                string[]    npcIdPosRotStr = npcs[i].Split('~');
                int         id             = Convert.ToInt32(npcIdPosRotStr[0]);
                string[]    posRot         = npcIdPosRotStr[1].Split(';');
                string[]    posStr         = posRot[0].Split(',');
                Vector3     pos            = new Vector3(float.Parse(posStr[0]), float.Parse(posStr[1]), float.Parse(posStr[2]));
                float       rot            = float.Parse(posRot[1]);
                BuildingNpc bdnpc          = new BuildingNpc(id, pos, rot, false);
                buildingNpcs.Add(bdnpc);
            }
        }
    }
    public void GetBuildingInfo(out Vector3 size, out Dictionary <IntVector3, B45Block> blocks, out List <Vector3> npcPosition
                                , out List <CreatItemInfo> itemList, out Dictionary <int, BuildingNpc> npcIdPosRot)
    {
        Bounds bound = new Bounds(Vector3.zero, Vector3.zero);

        blocks      = new Dictionary <IntVector3, B45Block>();
        npcPosition = new List <Vector3>();
        itemList    = new List <CreatItemInfo>();
        npcIdPosRot = new Dictionary <int, BuildingNpc>();

        TextAsset    textFile = Resources.Load(mPath) as TextAsset;
        MemoryStream ms       = new MemoryStream(textFile.bytes);
        BinaryReader _in      = new BinaryReader(ms);

        int readVersion = _in.ReadInt32();

        switch (readVersion)
        {
        case 2:
            int Size = _in.ReadInt32();
            for (int i = 0; i < Size; i++)
            {
                IntVector3 index = new IntVector3(_in.ReadInt32(), _in.ReadInt32(), _in.ReadInt32());
                B45Block   block = new B45Block(_in.ReadByte(), _in.ReadByte());
                if ((block.blockType >> 2) != 0)
                {
                    blocks[index] = block;
                    index         = new IntVector3(index);
                    index.x      += 1;
                    index.z      += 1;
                    bound.Encapsulate(BSBlock45Data.s_Scale * index.ToVector3());
                }
            }
            break;
        }


        _in.Close();
        ms.Close();

        BoundSize = size = bound.size;
        UnityEngine.Object subInfo = Resources.Load(mPath + "SubInfo");
        if (null != subInfo)
        {
            textFile = subInfo as TextAsset;
            ms       = new MemoryStream(textFile.bytes);
            _in      = new BinaryReader(ms);

            int version = _in.ReadInt32();
            int count   = _in.ReadInt32();
            switch (version)
            {
            case 1:
                for (int i = 0; i < count; i++)
                {
                    npcPosition.Add(new Vector3(_in.ReadSingle(), _in.ReadSingle(), _in.ReadSingle()));
                }
                break;

            case 2:
                for (int i = 0; i < count; i++)
                {
                    npcPosition.Add(new Vector3(_in.ReadSingle(), _in.ReadSingle(), _in.ReadSingle()));
                }
                count = _in.ReadInt32();
                for (int i = 0; i < count; i++)
                {
                    CreatItemInfo addItem = new CreatItemInfo();
                    addItem.mPos      = new Vector3(_in.ReadSingle(), _in.ReadSingle(), _in.ReadSingle());
                    addItem.mRotation = Quaternion.Euler(new Vector3(_in.ReadSingle(), _in.ReadSingle(), _in.ReadSingle()));
                    addItem.mItemId   = _in.ReadInt32();
                    itemList.Add(addItem);
                }
                break;
            }
            _in.Close();
            ms.Close();
        }

        //npc stand
        if (!mNpcIdPosRotStand.Equals("") && mNpcIdPosRotStand.Length > 1)
        {
            string[] npcs = mNpcIdPosRotStand.Split('_');
            for (int i = 0; i < npcs.Count(); i++)
            {
                string[]    npcIdPosRotStr = npcs[i].Split('~');
                int         id             = Convert.ToInt32(npcIdPosRotStr[0]);
                string[]    posRot         = npcIdPosRotStr[1].Split(';');
                string[]    posStr         = posRot[0].Split(',');
                Vector3     pos            = new Vector3(float.Parse(posStr[0]), float.Parse(posStr[1]), float.Parse(posStr[2]));
                float       rot            = float.Parse(posRot[1]);
                BuildingNpc bdnpc          = new BuildingNpc(id, pos, rot, true);
                npcIdPosRot.Add(id, bdnpc);
            }
        }

        //npc move
        if (!mNpcIdPosRotMove.Equals("") && mNpcIdPosRotMove.Length > 1)
        {
            string[] npcs = mNpcIdPosRotMove.Split('_');
            for (int i = 0; i < npcs.Count(); i++)
            {
                string[]    npcIdPosRotStr = npcs[i].Split('~');
                int         id             = Convert.ToInt32(npcIdPosRotStr[0]);
                string[]    posRot         = npcIdPosRotStr[1].Split(';');
                string[]    posStr         = posRot[0].Split(',');
                Vector3     pos            = new Vector3(float.Parse(posStr[0]), float.Parse(posStr[1]), float.Parse(posStr[2]));
                float       rot            = float.Parse(posRot[1]);
                BuildingNpc bdnpc          = new BuildingNpc(id, pos, rot, false);
                npcIdPosRot.Add(id, bdnpc);
            }
        }
    }
Esempio n. 4
0
    public void RenderPrefebBuilding(VABuildingInfo buildinginfo)
    {
        int bid = buildinginfo.id;

        Quaternion rotation = Quaternion.Euler(0, buildinginfo.rotation, 0);

        if (PeGameMgr.IsSingleAdventure)
        {
            if (buildinginfo.buildingId.buildingNo != VArtifactTownConstant.NATIVE_TOWER_BUILDING_ID)
            {
                if (!BlockBuilding.s_tblBlockBuildingMap.ContainsKey(bid))
                {
                    LogManager.Error("bid = [", bid, "] not exist in database!");
                    return;
                }

                int campId   = SceneDoodadDesc.c_neutralCamp;
                int damageId = SceneDoodadDesc.c_neutralDamage;
                if (buildinginfo.vau.vat.type == VArtifactType.NpcTown)
                {
                    if (!buildinginfo.vau.vat.IsPlayerTown)
                    {
                        if (bid == ColonyNoMgrMachine.DOODAD_ID_REPAIR || bid == ColonyNoMgrMachine.DOODAD_ID_SOLARPOWER)
                        {
                            return;
                        }
                        campId   = AllyConstants.EnemyNpcCampId;
                        damageId = AllyConstants.EnemyNpcDamageId;
                    }
                }
                else
                {
                    if (buildinginfo.vau.vat.nativeType == NativeType.Puja)
                    {
                        campId   = AllyConstants.PujaCampId;
                        damageId = AllyConstants.PujaDamageId;
                    }
                    else
                    {
                        campId   = AllyConstants.PajaCampId;
                        damageId = AllyConstants.PajaDamageId;
                    }
                }
                int playerId = VATownGenerator.Instance.GetPlayerId(buildinginfo.vau.vat.AllyId);
                if (!buildinginfo.vau.isDoodadNpcRendered)
                {
                    VArtifactTownManager.Instance.AddAliveBuilding(buildinginfo.vau.vat.townId,
                                                                   DoodadEntityCreator.CreateRandTerDoodad(BlockBuilding.s_tblBlockBuildingMap[bid].mDoodadProtoId, buildinginfo.root, Vector3.one, rotation, buildinginfo.buildingId.townId, campId, damageId, playerId).Id);
                }

                //building npc
                if (!mCreatedNpcBuildingID.ContainsKey(buildinginfo.buildingId))
                {
                    BlockBuilding      building = BlockBuilding.s_tblBlockBuildingMap[bid];
                    List <BuildingNpc> buildingNpcs;
                    building.GetNpcInfo(out buildingNpcs);
                    for (int bni = 0; bni < buildingNpcs.Count; bni++)
                    {
                        BuildingNpc bn = buildingNpcs[bni];
                        VArtifactUtil.GetPosRotFromPointRot(ref bn.pos, ref bn.rotY, buildinginfo.root, buildinginfo.rotation);
                    }
                    if (buildingNpcs != null && buildingNpcs.Count > 0)
                    {
                        if (buildinginfo.vau.vat.IsPlayerTown)
                        {
                            if (!buildinginfo.vau.isDoodadNpcRendered)
                            {
                                StartCoroutine(CreateBuildingNpcList(buildingNpcs));
                                mCreatedNpcBuildingID.Add(buildinginfo.buildingId, 0);
                            }
                        }
                        else
                        {
                            GenEnemyNpc(buildingNpcs, buildinginfo.vau.vat.townId, buildinginfo.vau.vat.AllyId);
                        }
                    }
                }
            }
            else if (buildinginfo.buildingId.buildingNo == VArtifactTownConstant.NATIVE_TOWER_BUILDING_ID)
            {
                //tower
                if (!buildinginfo.vau.isDoodadNpcRendered)
                {
                    int playerId = VATownGenerator.Instance.GetPlayerId(buildinginfo.vau.vat.AllyId);
                    VArtifactTownManager.Instance.AddAliveBuilding(buildinginfo.vau.vat.townId,
                                                                   DoodadEntityCreator.CreateRandTerDoodad(buildinginfo.pathID, buildinginfo.root, Vector3.one, rotation, buildinginfo.vau.vat.townId, buildinginfo.campID, buildinginfo.damageID, playerId).Id
                                                                   );
                }
            }
            if (missionBuilding.ContainsKey(0))
            {
                if (buildinginfo.buildingId != missionBuilding[0])
                {
                    RemoveBuilding(buildinginfo.buildingId);
                }
            }
            else
            {
                RemoveBuilding(buildinginfo.buildingId);
            }
        }
        else if (PeGameMgr.IsMulti)
        {
            if (buildinginfo.buildingId.buildingNo != VArtifactTownConstant.NATIVE_TOWER_BUILDING_ID)
            {
                if (!BlockBuilding.s_tblBlockBuildingMap.ContainsKey(bid))
                {
                    LogManager.Error("bid = [", bid, "] not exist in database!");
                    return;
                }
                Debug.Log("RenderPrefebBuilding():" + bid);
                //              int campId = SceneDoodadDesc.c_neutralCamp;
                int campId   = SceneDoodadDesc.c_neutralCamp;
                int damageId = SceneDoodadDesc.c_neutralDamage;
                if (buildinginfo.vau.vat.type == VArtifactType.NpcTown)
                {
                    if (!buildinginfo.vau.vat.IsPlayerTown)
                    {
                        if (bid == ColonyNoMgrMachine.DOODAD_ID_REPAIR || bid == ColonyNoMgrMachine.DOODAD_ID_SOLARPOWER)
                        {
                            return;
                        }
                        campId   = AllyConstants.EnemyNpcCampId;
                        damageId = AllyConstants.EnemyNpcDamageId;
                    }
                }
                else
                {
                    if (buildinginfo.vau.vat.nativeType == NativeType.Puja)
                    {
                        campId   = AllyConstants.PujaCampId;
                        damageId = AllyConstants.PujaDamageId;
                    }
                    else
                    {
                        campId   = AllyConstants.PajaCampId;
                        damageId = AllyConstants.PajaDamageId;
                    }
                }
                int playerId = VATownGenerator.Instance.GetPlayerId(buildinginfo.vau.vat.AllyId);
                if (!buildinginfo.vau.isDoodadNpcRendered)
                {
                    PlayerNetwork.RequestServer(EPacketType.PT_Common_TownDoodad, buildinginfo.buildingId, BlockBuilding.s_tblBlockBuildingMap[bid].mDoodadProtoId, buildinginfo.root, Vector3.one, rotation, buildinginfo.vau.vat.townId, campId, damageId, playerId);
                }
                //building npc
                if (!mCreatedNpcBuildingID.ContainsKey(buildinginfo.buildingId))
                {
                    BlockBuilding      building = BlockBuilding.s_tblBlockBuildingMap[bid];
                    List <BuildingNpc> buildingNpcs;
                    building.GetNpcInfo(out buildingNpcs);
                    for (int bni = 0; bni < buildingNpcs.Count; bni++)
                    {
                        BuildingNpc bn = buildingNpcs[bni];
                        VArtifactUtil.GetPosRotFromPointRot(ref bn.pos, ref bn.rotY, buildinginfo.root, buildinginfo.rotation);
                    }
                    if (buildingNpcs != null && buildingNpcs.Count > 0)
                    {
                        if (buildingNpcs != null && buildingNpcs.Count > 0)
                        {
                            if (buildinginfo.vau.vat.IsPlayerTown)
                            {
                                if (!buildinginfo.vau.isDoodadNpcRendered)
                                {
                                    StartCoroutine(CreateBuildingNpcList(buildingNpcs));
                                    mCreatedNpcBuildingID.Add(buildinginfo.buildingId, 0);
                                }
                            }
                            else
                            {
                                GenEnemyNpc(buildingNpcs, buildinginfo.vau.vat.townId, buildinginfo.vau.vat.AllyId);
                            }
                        }
                    }
                }
            }
            else if (buildinginfo.buildingId.buildingNo == VArtifactTownConstant.NATIVE_TOWER_BUILDING_ID)
            {
                if (!buildinginfo.vau.isDoodadNpcRendered)
                {
                    int playerId = VATownGenerator.Instance.GetPlayerId(buildinginfo.vau.vat.AllyId);
                    PlayerNetwork.RequestServer(EPacketType.PT_Common_NativeTowerCreate, buildinginfo.buildingId, buildinginfo.pathID, buildinginfo.root, Vector3.one, rotation, buildinginfo.vau.vat.townId, buildinginfo.campID, buildinginfo.damageID, playerId);
                }
            }
            RemoveBuilding(buildinginfo.buildingId);
        }
    }