public void OnFallenObjectSourceAdded(GameObject go)
    {
        List <FallenObjectData> list = null;

        if (!this.m_Data.TryGetValue(go.tag, out list))
        {
            return;
        }
        for (int i = 0; i < list.Count; i++)
        {
            FallenObjectData          src = list[i];
            FallenObjectGeneratorData fallenObjectGeneratorData;
            if (go.GetComponent <FallenObjectGenerator>() == null)
            {
                FallenObjectGenerator fallenObjectGenerator = go.AddComponent <FallenObjectGenerator>();
                fallenObjectGeneratorData             = new FallenObjectGeneratorData();
                fallenObjectGenerator.m_GeneratorData = fallenObjectGeneratorData;
                this.m_Generators.Add(go.GetComponent <FallenObjectGenerator>());
            }
            else
            {
                fallenObjectGeneratorData = go.GetComponent <FallenObjectGenerator>().m_GeneratorData;
            }
            fallenObjectGeneratorData.m_Data.Add(new FallenObjectData(src));
            fallenObjectGeneratorData.m_Object = go;
        }
    }
    private void GenerateObjects(int num_objects)
    {
        if (this.m_Generators.Count == 0)
        {
            return;
        }
        int num = 0;

        while (num < num_objects && this.m_Generators.Count != 0)
        {
            if (this.m_CurrentObjectIdx >= this.m_Generators.Count)
            {
                this.m_CurrentObjectIdx = 0;
            }
            FallenObjectGenerator fallenObjectGenerator = this.m_Generators[this.m_CurrentObjectIdx];
            if (fallenObjectGenerator == null)
            {
                this.m_Generators.RemoveAt(this.m_CurrentObjectIdx);
                this.m_CurrentObjectIdx--;
            }
            else if (fallenObjectGenerator.m_GeneratorData.m_Object && RelevanceTools.GetDistToClosestPlayer2D(fallenObjectGenerator.m_GeneratorData.m_Object) <= FallenObjectsManager.s_MaxDistToPlayer)
            {
                for (int i = 0; i < fallenObjectGenerator.m_GeneratorData.m_Data.Count; i++)
                {
                    bool             flag             = false;
                    FallenObjectData fallenObjectData = fallenObjectGenerator.m_GeneratorData.m_Data[i];
                    if (fallenObjectData.m_ObjectsSpawnNextTime < 0f)
                    {
                        fallenObjectData.m_ObjectsSpawnNextTime = MainLevel.Instance.GetCurrentTimeMinutes() + fallenObjectData.m_Cooldown;
                        flag = true;
                    }
                    int j = 0;
                    while (j < fallenObjectData.m_GeneratedObjects.Count)
                    {
                        if (fallenObjectData.m_GeneratedObjects[j] == null)
                        {
                            fallenObjectData.m_GeneratedObjects.RemoveAt(j);
                        }
                        else
                        {
                            j++;
                        }
                    }
                    if (fallenObjectData.m_GeneratedObjects.Count <= 0 && (!fallenObjectData.m_AlreadySpawned || !fallenObjectData.m_NoRespawn) && (flag || MainLevel.Instance.GetCurrentTimeMinutes() >= fallenObjectData.m_ObjectsSpawnNextTime))
                    {
                        bool flag2 = this.CreateFallenObjects(fallenObjectGenerator.m_GeneratorData.m_Object, fallenObjectData, fallenObjectGenerator.m_GeneratorData, i, fallenObjectGenerator);
                        fallenObjectData.m_ObjectsSpawnNextTime = MainLevel.Instance.GetCurrentTimeMinutes() + fallenObjectData.m_Cooldown;
                        fallenObjectData.m_AlreadySpawned       = true;
                        if (flag2)
                        {
                            this.m_CurrentObjectIdx++;
                            return;
                        }
                    }
                }
            }
            num++;
            this.m_CurrentObjectIdx++;
        }
    }
    private void ParseScript()
    {
        ScriptParser scriptParser = new ScriptParser();

        scriptParser.Parse("FallenObjects/FallenObjects.txt", true);
        for (int i = 0; i < scriptParser.GetKeysCount(); i++)
        {
            Key key = scriptParser.GetKey(i);
            if (key.GetName() == "SourceObject")
            {
                FallenObjectData fallenObjectData = new FallenObjectData();
                fallenObjectData.m_SourceTag        = key.GetVariable(0).SValue;
                fallenObjectData.m_FallenPrefabName = key.GetVariable(1).SValue;
                fallenObjectData.m_QuantityMin      = key.GetVariable(2).IValue;
                fallenObjectData.m_QuantityMax      = key.GetVariable(3).IValue;
                fallenObjectData.m_MinGenRadius     = key.GetVariable(4).FValue;
                fallenObjectData.m_MaxGenRadius     = key.GetVariable(5).FValue;
                fallenObjectData.m_NoRespawn        = key.GetVariable(6).BValue;
                fallenObjectData.m_Chance           = key.GetVariable(7).FValue;
                fallenObjectData.m_Cooldown         = key.GetVariable(8).FValue;
                List <FallenObjectData> list = null;
                if (!this.m_Data.TryGetValue(fallenObjectData.m_SourceTag, out list))
                {
                    this.m_Data[fallenObjectData.m_SourceTag] = new List <FallenObjectData>();
                }
                this.m_Data[fallenObjectData.m_SourceTag].Add(fallenObjectData);
            }
        }
    }
    public void AddObject(GameObject obj, int gen_index, int data_index)
    {
        FallenObjectGenerator fallenObjectGenerator = this.m_Generators[gen_index];
        FallenObjectData      fallenObjectData      = fallenObjectGenerator.m_GeneratorData.m_Data[data_index];

        fallenObjectData.m_GeneratedObjects.Add(obj);
    }
    private bool CreateFallenObjects(GameObject go, FallenObjectData data, FallenObjectGeneratorData generator_data, int data_index, FallenObjectGenerator generator)
    {
        if (UnityEngine.Random.Range(0f, 1f) > data.m_Chance)
        {
            return(false);
        }
        GameObject prefab = GreenHellGame.Instance.GetPrefab(data.m_FallenPrefabName);

        if (!prefab)
        {
            DebugUtils.Assert("[FallenObjectsManager:CreateFallenObjects] Can't load prefab - " + data.m_FallenPrefabName, true, DebugUtils.AssertType.Info);
            return(false);
        }
        bool result = false;
        int  num    = UnityEngine.Random.Range(data.m_QuantityMin, data.m_QuantityMax + 1);

        for (int i = 0; i < num; i++)
        {
            Vector3 vector = this.GenerateRandomPointAround(go.transform.position, data.m_MinGenRadius, data.m_MaxGenRadius);
            Vector3 origin = vector;
            origin.y += 3f;
            RaycastHit raycastHit;
            if (Physics.Raycast(new Ray
            {
                origin = origin,
                direction = Vector3.down
            }, out raycastHit))
            {
                GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(prefab);
                if (!gameObject)
                {
                    DebugUtils.Assert("[FallenObjectsManager:CreateFallenObjects] Can't Instantiate prefab - " + prefab.name, true, DebugUtils.AssertType.Info);
                }
                else
                {
                    vector = raycastHit.point;
                    BoxCollider component = gameObject.GetComponent <BoxCollider>();
                    float       y         = component.bounds.min.y;
                    float       y2        = gameObject.transform.position.y;
                    float       num2      = y2 - y;
                    vector.y += num2;
                    gameObject.transform.position = vector;
                    Quaternion quaternion = gameObject.transform.rotation;
                    quaternion *= Quaternion.Euler(Vector3.up * UnityEngine.Random.Range(0f, 360f));
                    gameObject.transform.rotation = quaternion;
                    Vector3 forward = gameObject.transform.forward - Vector3.Dot(gameObject.transform.forward, raycastHit.normal) * raycastHit.normal;
                    gameObject.transform.rotation = Quaternion.LookRotation(forward, raycastHit.normal);
                    data.m_GeneratedObjects.Add(gameObject);
                    Trigger component2 = gameObject.GetComponent <Trigger>();
                    DebugUtils.Assert(component2 != null, "[FallenObjectsManager:CreateFallenObjects] Generated object is not item!", true, DebugUtils.AssertType.Info);
                    component2.m_FallenObject             = true;
                    component2.m_FallenObjectCreationTime = Time.time;
                    component2.m_FallenObjectGenerator    = generator;
                    result = true;
                }
            }
        }
        return(result);
    }
Exemple #6
0
 public FallenObjectData(FallenObjectData src)
 {
     this.m_SourceTag            = src.m_SourceTag;
     this.m_FallenPrefabName     = src.m_FallenPrefabName;
     this.m_Chance               = src.m_Chance;
     this.m_QuantityMin          = src.m_QuantityMin;
     this.m_QuantityMax          = src.m_QuantityMax;
     this.m_MinGenRadius         = src.m_MinGenRadius;
     this.m_MaxGenRadius         = src.m_MaxGenRadius;
     this.m_ObjectsSpawnNextTime = src.m_ObjectsSpawnNextTime;
     this.m_Cooldown             = src.m_Cooldown;
 }
    private void GenerateObjects(int num_objects)
    {
        if (this.m_Generators.Count == 0)
        {
            return;
        }
        Vector3 position = Player.Get().gameObject.transform.position;

        position.y = 0f;
        int i = 0;

        while (i < num_objects)
        {
            if (this.m_CurrentObjectIdx >= this.m_Generators.Count)
            {
                this.m_CurrentObjectIdx = 0;
            }
            FallenObjectGenerator fallenObjectGenerator = this.m_Generators[this.m_CurrentObjectIdx];
            if (fallenObjectGenerator == null)
            {
                this.m_Generators.RemoveAt(this.m_CurrentObjectIdx);
            }
            else if (fallenObjectGenerator.m_GeneratorData.m_Object)
            {
                Vector3 position2 = fallenObjectGenerator.m_GeneratorData.m_Object.transform.position;
                position2.y = 0f;
                if (position.Distance(position2) <= FallenObjectsManager.s_MaxDistToPlayer)
                {
                    for (int j = 0; j < fallenObjectGenerator.m_GeneratorData.m_Data.Count; j++)
                    {
                        bool             flag             = false;
                        FallenObjectData fallenObjectData = fallenObjectGenerator.m_GeneratorData.m_Data[j];
                        if (fallenObjectData.m_ObjectsSpawnNextTime < 0f)
                        {
                            fallenObjectData.m_ObjectsSpawnNextTime = MainLevel.Instance.GetCurrentTimeMinutes() + fallenObjectData.m_Cooldown;
                            flag = true;
                        }
                        int k = 0;
                        while (k < fallenObjectData.m_GeneratedObjects.Count)
                        {
                            if (fallenObjectData.m_GeneratedObjects[k] == null)
                            {
                                fallenObjectData.m_GeneratedObjects.RemoveAt(k);
                            }
                            else
                            {
                                k++;
                            }
                        }
                        if (fallenObjectData.m_GeneratedObjects.Count <= 0)
                        {
                            if (!fallenObjectData.m_AlreadySpawned || !fallenObjectData.m_NoRespawn)
                            {
                                if (flag || MainLevel.Instance.GetCurrentTimeMinutes() >= fallenObjectData.m_ObjectsSpawnNextTime)
                                {
                                    bool flag2 = this.CreateFallenObjects(fallenObjectGenerator.m_GeneratorData.m_Object, fallenObjectData, fallenObjectGenerator.m_GeneratorData, j, fallenObjectGenerator);
                                    fallenObjectData.m_ObjectsSpawnNextTime = MainLevel.Instance.GetCurrentTimeMinutes() + fallenObjectData.m_Cooldown;
                                    fallenObjectData.m_AlreadySpawned       = true;
                                    if (flag2)
                                    {
                                        this.m_CurrentObjectIdx++;
                                        return;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            i++;
            this.m_CurrentObjectIdx++;
        }
    }