Exemple #1
0
    void OnMemberDestroy(PeEntity e)
    {
        // Check to destroy group
        foreach (ISceneObjAgent agent in _lstAgents)
        {
            SceneEntityPosAgent sepa = agent as SceneEntityPosAgent;
            if (sepa != null)
            {
                if (sepa.entity != null && sepa.entity != e)
                {
                    return;
                }
            }
            else
            {
//				PeCustom.AIAgent aiagent = agent as PeCustom.AIAgent;
//
//				if(aiagent.entity != null && aiagent.entity != e)
//				{
//					return;
//				}
                PeCustom.SceneEntityAgent sea = agent as PeCustom.SceneEntityAgent;
                if (sea.entity != null && sea.entity != e)
                {
                    return;
                }
            }
        }
        Destroy(gameObject);
    }
Exemple #2
0
 public void CreateNpcAgents(Dictionary <int, NPCSpawnPoint> points)
 {
     foreach (KeyValuePair <int, NPCSpawnPoint> kvp in points)
     {
         SceneEntityAgent agent = new SceneEntityAgent(kvp.Value);
         agent.ScenarioId = kvp.Value.ID;
         kvp.Value.agent  = agent;
         SceneMan.AddSceneObj(agent);
     }
 }
Exemple #3
0
        SceneEntityAgent _createMstAgent(MonsterSpawnPoint _point, bool is_saved, MonsterSpawnArea _area = null, MonsterSpawnPoint[] _groupPoints = null, bool save_to_scene = true)
        {
            SceneEntityAgent agent = new SceneEntityAgent(_point, is_saved, _area, _groupPoints);

            if (save_to_scene)
            {
                SceneMan.AddSceneObj(agent);
            }

            return(agent);
        }
        public void AddMstDeadAgent(SceneEntityAgent agent)
        {
            MonsterSpawnPoint msp = agent.mstPoint;

            if (msp != null)
            {
                if (agent.spawnArea != null)
                {
                    if (agent.spawnArea.MaxRespawnCount != 0)
                    {
                        mMstDeadAgents.Add(agent);
                    }
                }
                else if (agent.mstPoint.MaxRespawnCount != 0)
                {
                    mMstDeadAgents.Add(agent);
                }
            }
        }
        public void Update()
        {
            // Entity Dead
            for (int i = mMstDeadAgents.Count - 1; i >= 0; i--)
            {
                SceneEntityAgent  agent = mMstDeadAgents[i];
                MonsterSpawnPoint msp   = agent.mstPoint;
                if (msp.UpdateRespawnTime(Time.deltaTime))
                {
                    if (agent.spawnArea != null)
                    {
                        if (agent.spawnArea.MaxRespawnCount != 0)
                        {
                            agent.spawnArea.MaxRespawnCount--;
                        }
                        else
                        {
                            mMstDeadAgents.RemoveAt(i);
                            continue;
                        }
                    }
                    else
                    {
                        if (msp.MaxRespawnCount != 0)
                        {
                            msp.MaxRespawnCount--;
                        }
                        else
                        {
                            mMstDeadAgents.RemoveAt(i);
                            continue;
                        }
                    }

                    msp.isDead = false;
                    agent.Respawn();
                    Debug.Log("The Agent [" + agent.Id.ToString() + "] is respawned");
                    mMstDeadAgents.RemoveAt(i);
                }
            }
        }
Exemple #6
0
        EntityGrp CreateMonsterGroup(SpawnPoint grp_sp, MonsterSpawnPoint[] points, MonsterSpawnArea area)
        {
            int       noid = Pathea.WorldInfoMgr.Instance.FetchNonRecordAutoId();
            EntityGrp grp  = EntityMgr.Instance.Create(noid, sMonsterGroupPath, Vector3.zero, Quaternion.identity, Vector3.one) as EntityGrp;


            if (grp == null)
            {
                Debug.LogError("Load Prefab Error");
                return(null);
            }

            grp._protoId = grp_sp.Prototype;
            grp._cntMin  = area.AmountPerSocial;
            grp._cntMax  = area.AmountPerSocial;


            for (int i = 0; i < points.Length; i++)
            {
                MonsterSpawnPoint sp = points[i];

                Pathea.WorldInfoMgr.Instance.FetchNonRecordAutoId();
                SceneEntityAgent agent = new SceneEntityAgent(sp, false, area, null);
                agent.ScenarioId = area.ID;
                grp.scenarioId   = area.ID;
                agent.entityGp   = grp;
                sp.agent         = agent;

                AddMstDeadAgent(agent);

                if (!sp.isDead)
                {
                    SceneMan.AddSceneObj(agent);
                }
            }

            return(grp);
        }
        /// <summary>
        /// Accept the notification for Views.
        /// </summary>
        /// <param name="msg_type">Msg_type.</param>
        /// <param name="data">Data.</param>
        public void OnNotification(ESceneNoification msg_type, params object[] data)
        {
            SpawnDataSource ds = mBinder.Get <SpawnDataSource>();

            switch (msg_type)
            {
            case ESceneNoification.SceneBegin:
                if (PeGameMgr.IsSingle)
                {
                    CreateAgents(ds);
                }
                break;

            case ESceneNoification.CreateAgent:
            {
                if (data.Length == 0)
                {
                    Debug.LogError("Create Agent notification parameters error");
                    break;
                }

                SpawnPoint sp = data[0] as SpawnPoint;

                CreateAgent(ds, sp);
            }
            break;

                #region SPAWNPOINT_CASE
            case ESceneNoification.RemoveSpawnPoint:
            {
                if (data.Length == 0)
                {
                    Debug.LogError("Remove SpawnPoint notification parameters error");
                    break;
                }

                SpawnPoint sp = data[0] as SpawnPoint;
                // Monster
                if (sp as MonsterSpawnPoint != null)
                {
                    MonsterSpawnPoint msp = sp as MonsterSpawnPoint;

                    // Destroy Entity First
                    if (msp.EntityID != -1)
                    {
                        CreatureMgr.Instance.Destory(sp.EntityID);
                    }

                    // Remove Agent
                    if (msp.agent != null)
                    {
                        SceneMan.RemoveSceneObj(msp.agent);
                    }

                    // Remove Spawn Point
                    ds.RemoveMonster(msp.ID);
                }
                // Npc
                else if (sp as NPCSpawnPoint != null)
                {
                    NPCSpawnPoint nsp = sp as NPCSpawnPoint;

                    // Destroy Entity First
                    if (nsp.EntityID != -1)
                    {
                        CreatureMgr.Instance.Destory(sp.EntityID);
                    }

                    if (nsp.agent != null)
                    {
                        SceneMan.RemoveSceneObj(nsp.agent);
                    }

                    ds.RemoveMonster(nsp.ID);
                }
                // Doodad
                else if (sp as DoodadSpawnPoint != null)
                {
                    DoodadSpawnPoint dsp = sp as DoodadSpawnPoint;

                    if (dsp.EntityID != -1)
                    {
                        CreatureMgr.Instance.Destory(sp.EntityID);
                    }

                    if (dsp.agent != null)
                    {
                        SceneMan.RemoveSceneObj(dsp.agent);
                    }

                    ds.RemoveMonster(dsp.ID);
                }
                // Item
                else if (sp as ItemSpwanPoint != null)
                {
                    ItemSpwanPoint isp = sp as ItemSpwanPoint;

                    List <ISceneObjAgent> agents = SceneMan.GetSceneObjs <DragArticleAgent>();
                    for (int i = 0; i < agents.Count; i++)
                    {
                        DragArticleAgent drag_agent = agents[i] as DragArticleAgent;
                        if (drag_agent != null && drag_agent.itemDrag.itemObj.instanceId == isp.ItemObjId)
                        {
                            ItemAsset.ItemMgr.Instance.DestroyItem(isp.ItemObjId);
                            SceneMan.RemoveSceneObj(drag_agent);
                            break;
                        }
                    }
                }
            }
            break;

            case ESceneNoification.EnableSpawnPoint:
            {
                if (data.Length < 1)
                {
                    Debug.LogError("Enable SpawnPoint notification parameters error");
                    break;
                }

                SpawnPoint sp     = data[0] as SpawnPoint;
                bool       enable = (bool)data[1];

                if (sp as MonsterSpawnArea != null)
                {
                    MonsterSpawnArea area = sp as MonsterSpawnArea;
                    for (int i = 0; i < area.Spawns.Count; i++)
                    {
                        for (int j = 0; j < area.Spawns[i].spawnPoints.Count; j++)
                        {
                            area.Spawns[i].spawnPoints[j].Enable = enable;
                        }
                    }
                }
                sp.Enable = enable;
            }
            break;
                #endregion

                #region CREATE_CASE
            case ESceneNoification.CreateMonster:
            {
                if (data.Length < 2)
                {
                    Debug.LogError("The [CreateMonster] notification parameter is wrong");
                    break;
                }

                SceneEntityAgent agent = data[0] as SceneEntityAgent;
                bool             save  = (bool)data[1];

                bool need_check = true;
                if (data.Length > 2)
                {
                    need_check = (bool)data[2];
                }

                Vector3 pos = agent.spawnPoint.spawnPos;
                if (!need_check || CheckPos(out pos, pos, agent.spawnPoint, agent.spawnArea))
                {
                    agent.spawnPoint.spawnPos = pos;

                    // Is Group Root?
                    if (agent.groupPoints != null)
                    {
                        agent.entityGp          = CreateMonsterGroup(agent.spawnPoint, agent.groupPoints, agent.spawnArea);
                        agent.entity            = agent.entityGp;
                        agent.entity.scenarioId = agent.ScenarioId;

                        break;
                    }

                    agent.entity            = CreateMonster(agent.mstPoint, save);
                    agent.entity.scenarioId = agent.ScenarioId;

                    if (agent.entityGp != null)
                    {
                        agent.entity.transform.parent = agent.entityGp.transform;
                    }

                    Debug.Log("Create the Monster ");
                }
            } break;

            case ESceneNoification.CreateNpc:
            {
                if (data.Length == 0)
                {
                    Debug.LogError("The [CreateNpc] notification parameters are wrong");
                    break;
                }

                SceneEntityAgent agent = data[0] as SceneEntityAgent;

                bool need_check = true;
                if (data.Length > 1)
                {
                    need_check = (bool)data[1];
                }

                Vector3 pos = agent.spawnPoint.spawnPos;
                if (!need_check || CheckPos(out pos, pos, agent.spawnPoint, agent.spawnArea))
                {
                    agent.spawnPoint.spawnPos = pos;
                    agent.entity = CreateNpc(agent.spawnPoint as NPCSpawnPoint);

                    if (agent.entity == null)
                    {
                        agent.entity.scenarioId = agent.ScenarioId;
                        Debug.LogError("[SceneEntityCreator]Failed to create npc:" + agent.protoId);
                    }
                    else
                    {
                        Debug.Log("Create the Npc [" + agent.entity.Id.ToString() + "]");
                    }
                }
            } break;

            case ESceneNoification.CreateDoodad:
            {
                if (data.Length < 2)
                {
                    Debug.LogError("The [CreateNpc] notification parameters are wrong");
                    break;
                }

                SceneStaticAgent agent = data[0] as SceneStaticAgent;
                //bool is_save = (bool)data[1];

                agent.entity            = CreadteDoodad(agent.spawnPoint as DoodadSpawnPoint, agent.IsSave);
                agent.entity.scenarioId = agent.ScenarioId;
            }
            break;
                #endregion


                #region DEAD_CASE
            case ESceneNoification.MonsterDead:
            {
                if (data.Length == 0)
                {
                    Debug.LogError("The [MonsterDead] notification parameters are wrong ");
                    break;
                }

                SceneEntityAgent agent = data[0] as SceneEntityAgent;

                MonsterSpawnPoint msp = agent.mstPoint;
                if (msp == null)
                {
                    Debug.LogError("he [MonsterDead] notification : the point is not a MonsterSpawnPoint");
                    break;
                }


                msp.isDead   = true;
                msp.EntityID = -1;

                Debug.Log("The monster [" + agent.entity.Id.ToString() + "] is Dead");
                agent.entity = null;

                if (agent.spawnArea != null)
                {
                    if (agent.spawnArea.MaxRespawnCount != 0)
                    {
                        AddMstDeadAgent(agent);
                    }
                }
                else if (msp.MaxRespawnCount != 0)
                {
                    AddMstDeadAgent(agent);
                }
            } break;

            case ESceneNoification.DoodadDead:
            {
                if (data.Length == 0)
                {
                    Debug.LogError("The [DoodadDead] notification parameters are wrong ");
                    break;
                }

                SceneStaticAgent agent = data[0] as SceneStaticAgent;

                DoodadSpawnPoint dsp = agent.spawnPoint as DoodadSpawnPoint;
                if (dsp == null)
                {
                    Debug.LogError("he [DoodadDead] notification : the point is not a DoodadSpawnPoint");
                    break;
                }

                dsp.isDead   = true;
                dsp.EntityID = -1;
            }
            break;

                #endregion
            case ESceneNoification.EntityDestroy:
            {
                if (data.Length < 2)
                {
                    Debug.LogError("The [EntityDestroy] notification parameters are wrong ");
                    break;
                }

                SpawnPoint sp     = data[0] as SpawnPoint;
                PeEntity   entity = data[1] as PeEntity;

                bool remove_data = false;
                if (data.Length > 2)
                {
                    remove_data = (bool)data[2];
                }

                if (remove_data)
                {
                    entity.Export();
                    CreatureMgr.Instance.Destory(sp.EntityID);
                    sp.EntityID = -1;
                }
                else
                {
                    CreatureMgr.Instance.DestroyAndDontRemove(sp.EntityID);
                }
            } break;
            }
        }
Exemple #8
0
        /// <summary>
        /// Create a agent for a spawn point and add sp to the spawn data source
        /// </summary>
        void CreateAgent(SpawnDataSource ds, SpawnPoint sp)
        {
            // Create Monster Agent
            if (sp as MonsterSpawnPoint != null)
            {
                MonsterSpawnPoint msp = sp as MonsterSpawnPoint;

                if (ds.AddMonster(msp))
                {
                    SceneEntityAgent agent = _createMstAgent(msp, true, null, null, !msp.isDead);
                    msp.agent        = agent;
                    agent.ScenarioId = sp.ID;
                    AddMstDeadAgent(agent);
                }
                else
                {
                    Debug.LogError("Add Monster spawn point error");
                }
            }
            // Create Npc Agent
            else if (sp as NPCSpawnPoint != null)
            {
                NPCSpawnPoint nsp = sp as NPCSpawnPoint;
                if (ds.AddNpc(nsp))
                {
                    SceneEntityAgent agent = new SceneEntityAgent(nsp);
                    nsp.agent        = agent;
                    agent.ScenarioId = sp.ID;
                    SceneMan.AddSceneObj(agent);
                }
                else
                {
                    Debug.LogError("Add npc spawn point error");
                }
            }
            // Create Doodad Agent
            else if (sp as DoodadSpawnPoint != null)
            {
                DoodadSpawnPoint dsp = sp as DoodadSpawnPoint;
                if (ds.AddDoodad(dsp))
                {
                    SceneStaticAgent agent = new SceneStaticAgent(dsp, true);
                    dsp.agent        = agent;
                    agent.ScenarioId = sp.ID;
                    SceneMan.AddSceneObj(agent);
                }
                else
                {
                    Debug.LogError("Add doodad spawn point error");
                }
            }
            // Create Item
            else if (sp as ItemSpwanPoint != null)
            {
                ItemSpwanPoint isp = sp as ItemSpwanPoint;
                if (ds.AddItem(isp))
                {
                    DragArticleAgent agent = DragArticleAgent.PutItemByProroId(isp.Prototype
                                                                               , isp.spawnPos
                                                                               , isp.Scale
                                                                               , isp.Rotation
                                                                               , isp.CanPickup
                                                                               , isp.IsTarget);
                    if (agent != null)
                    {
                        isp.isNew        = false;
                        isp.ItemObjId    = agent.itemDrag.itemObj.instanceId;
                        agent.ScenarioId = sp.ID;
                    }
                }
                else
                {
                    Debug.LogError("Add item spawn point error");
                }
            }
            // Create Effect
            else if (sp as EffectSpwanPoint != null)
            {
            }
        }
Exemple #9
0
        /// <summary>
        /// Creates all the agents from data source
        /// </summary>
        void CreateAgents(SpawnDataSource ds)
        {
            foreach (KeyValuePair <int, MonsterSpawnPoint> kvp in ds.monsters)
            {
                SceneEntityAgent agent = _createMstAgent(kvp.Value, true, null, null, !kvp.Value.isDead);
                agent.ScenarioId = kvp.Value.ID;
                kvp.Value.agent  = agent;

                AddMstDeadAgent(agent);
            }


            foreach (KeyValuePair <int, MonsterSpawnArea> kvp in ds.areas)
            {
                for (int i = 0; i < kvp.Value.Spawns.Count; i++)
                {
                    MonsterSpawnArea.SocialSpawns mss = kvp.Value.Spawns[i];

                    if (!mss.isSocial)
                    {
                        for (int j = 0; j < mss.spawnPoints.Count; j++)
                        {
                            MonsterSpawnPoint sp    = mss.spawnPoints[j];
                            SceneEntityAgent  agent = _createMstAgent(sp, true, kvp.Value, null, !sp.isDead);
                            agent.ScenarioId = kvp.Value.ID;
                            sp.agent         = agent;

                            AddMstDeadAgent(agent);
                        }
                    }
                    else
                    {
                        _createMstAgent(mss.centerSP, false, kvp.Value, mss.spawnPoints.ToArray());
                    }
                }
            }

            CreateNpcAgents(ds.npcs);
            CreateDoodadAgents(ds.doodads);


            foreach (KeyValuePair <int, EffectSpwanPoint> kvp in ds.effects)
            {
                SceneStaticEffectAgent agent = SceneStaticEffectAgent.Create(kvp.Value.Prototype, kvp.Value.spawnPos, kvp.Value.Rotation, kvp.Value.Scale);
                agent.ScenarioId = kvp.Value.ID;
                SceneMan.AddSceneObj(agent);
            }

            foreach (KeyValuePair <int, ItemSpwanPoint> kvp in ds.items)
            {
                if (kvp.Value.isNew)
                {
                    DragArticleAgent agent = DragArticleAgent.PutItemByProroId(kvp.Value.Prototype
                                                                               , kvp.Value.spawnPos
                                                                               , kvp.Value.Scale
                                                                               , kvp.Value.Rotation
                                                                               , kvp.Value.CanPickup
                                                                               , kvp.Value.IsTarget);
                    if (agent != null)
                    {
                        agent.ScenarioId    = kvp.Value.ID;
                        kvp.Value.isNew     = false;
                        kvp.Value.ItemObjId = agent.itemDrag.itemObj.instanceId;
                    }
                }
            }
        }
Exemple #10
0
 public void MonsterDeadEvent(SceneEntityAgent agent, MonsterSpawnPoint msp)
 {
 }