Example #1
0
 public void CompareInfo(SpawnerInfo info)
 {
     if (info.hasEnded)
     {
         NotifyManager();
     }
 }
Example #2
0
        private IEnumerator LoadSpawnerInfo()
        {
            var url     = Application.dataPath + @"/Configuration/wavesconf.json";
            var request = new WWW(url);

            yield return(request);

            _spawner = JsonUtility.FromJson <SpawnerInfo>(request.text);
            StartCoroutine(StartSpawning());
        }
Example #3
0
 public void NotifyActivation()
 {
     if (++activationCount == astronautes.Length)
     {
         SpawnerInfo sInfo = new SpawnerInfo();
         sInfo.EventDescription = "Astronautes are gathered";
         sInfo.hasEnded         = true;
         sInfo.spawner          = this;
         EventCallbacks.EventSystem.Current.FireEvent(sInfo);
     }
 }
Example #4
0
    public UnitSpawn(SpawnerInfo info)
    {
        initialStockTime = info.initialTimer;
        restockTime      = info.restockTimer;
        maxStock         = info.maxStock;
        currentStock     = 0;
        Creep creep = info.gameObject.GetComponent <Creep>();

        cost   = creep.cost;
        income = creep.bounty;
        spawn  = creep;
    }
Example #5
0
 private void DropDownChanged()
 {
     try
     {
         var text = File.ReadAllText(_dropdown.options[_dropdown.value].text);
         _spawner    = JsonUtility.FromJson <SpawnerInfo>(text);
         _text.text  = "FILE PARSED SUCCESSFULLY, YOU CAN BEGIN\n";
         _text.text += string.Format("Waveinfo number: {0}", _spawner.WaveInfosCount);
     }
     catch (ArgumentException e)
     {
         _text.text = "YOU HAVE PROBLEMS IN YOUR JSON FILE,\n TRY TO FIX, OR WRITE TO KIRILL";
     }
 }
Example #6
0
        protected virtual void Start()
        {
#if UNITY_WEBGL
            StartCoroutine(LoadSpawnerInfo());
            StartCoroutine(StartSpawning());
#elif UNITY_STANDALONE_WIN
            LoadSpawnerInfo();
            if (!PreviewController.Debug)
            {
                var text = File.ReadAllText("Resources/wavesconf.json");
                _spawner = JsonUtility.FromJson <SpawnerInfo>(text);
                StartCoroutine(StartSpawning());
            }
#endif
        }
        public void Awake()
        {
            particleSystem = GetComponent<ParticleSystem>();

            var angleDiff = (Mathf.PI * 2) / Count;
            for (var i = 0; i < Count; i++)
            {
                var angle = angleDiff * i;

                var info = new SpawnerInfo
                {
                    Angle = angle
                };

                spawners.Add(info);
            }
        }
        private void RemoveGoalClick(object sender, RoutedEventArgs e)
        {
            if (StageListView.SelectedItem == null)
            {
                return;
            }
            if (spawnerList.SelectedItem == null)
            {
                return;
            }
            if (goalList.SelectedItem == null)
            {
                return;
            }

            SpawnerInfo spawnerInfo = spawnerList.SelectedItem as SpawnerInfo;
            int         selected    = (int)goalList.SelectedItem;

            spawnerInfo.PossibleGoals.Remove(selected);
        }
        private void SpawnersComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (StageListView.SelectedItem == null)
            {
                return;
            }
            if (EnemyWaveView.SelectedItem == null)
            {
                return;
            }
            if (WaveItemView.SelectedItem == null)
            {
                return;
            }
            if (SpawnersComboBox.SelectedItem == null)
            {
                return;
            }

            SpawnerInfo spawnerInfo = SpawnersComboBox.SelectedItem as SpawnerInfo;

            GoalComboBox.ItemsSource = spawnerInfo.PossibleGoals;
        }
        private void AddSpawnerClick(object sender, RoutedEventArgs e)
        {
            if (StageListView.SelectedItem == null)
            {
                return;
            }
            if (spawnerBox.Value == null)
            {
                return;
            }

            StageInfoCollection s = StageListView.SelectedItem as StageInfoCollection;
            int selectedValue     = (int)spawnerBox.Value;

            if (s.SpawnerInfos.Where(x => x.Spawner == selectedValue).ToList().Count > 0)
            {
                return;
            }
            SpawnerInfo info = new SpawnerInfo(selectedValue);

            s.SpawnerInfos.Add(info);
            spawnerList.SelectedItem = info;
        }
        private void AddGoalClick(object sender, RoutedEventArgs e)
        {
            if (StageListView.SelectedItem == null)
            {
                return;
            }
            if (spawnerList.SelectedItem == null)
            {
                return;
            }
            if (goalBox.Value == null)
            {
                return;
            }

            SpawnerInfo spawnerInfo   = spawnerList.SelectedItem as SpawnerInfo;
            int         selectedValue = (int)goalBox.Value;

            if (spawnerInfo.PossibleGoals.Contains(selectedValue))
            {
                return;
            }
            spawnerInfo.PossibleGoals.Add(selectedValue);
        }
Example #12
0
 private void internalAddSpanwer( SpawnerInfo newSpawner )
 {
     if( !spawners.Contains( newSpawner ) )
         spawners.Add( newSpawner );
 }
Example #13
0
 public static void AddSpawner( SpawnerInfo newSpawner )
 {
     if( instance )
         instance.internalAddSpanwer( newSpawner );
 }
Example #14
0
        protected override void OnUpdate()
        {
            // Check if we have initialized
            EntityQuery queryGroup = GetEntityQuery(typeof(Initialized));

            if (queryGroup.CalculateEntityCount() > 0)
            {
                return;
            }

            var spawners = new NativeArray <SpawnerInfo>(UninitializedSpawners.CalculateEntityCount(), Allocator.TempJob);

            Entities.WithStoreEntityQueryInField(ref UninitializedSpawners).WithNone <Initialized>()
            .ForEach((int entityInQueryIndex, ref FireGridSpawner spawner) =>
            {
                spawners[entityInQueryIndex] = new SpawnerInfo
                {
                    FirePrefab            = spawner.FirePrefab,
                    RandomSeed            = spawner.RandomSeed,
                    CountX                = spawner.FireCountX,
                    CountZ                = spawner.FireCountZ,
                    InitialHeightVariance = spawner.InitialHeightVariance,
                    TotalFireCount        = spawner.FireCountX * spawner.FireCountZ,
                    Center                = spawner.Origin,
                    StartFireAmount       = spawner.StartFireAmount,
                    StartFireVelocity     = spawner.StartFireVelocity,
                    MinInitialFires       = spawner.MinInitialFires,
                    MaxInitialFires       = spawner.MaxInitialFires,
                };
            }).Run();

            SpawnerInfo spanwerInfoInstance = spawners[0];
            Random      random = new Random((uint)spanwerInfoInstance.RandomSeed);

            foreach (var spawner in spawners)
            {
                EntityManager.Instantiate(spawner.FirePrefab, spawner.TotalFireCount, Allocator.Temp);
            }

            EntityManager.AddComponent <Initialized>(UninitializedSpawners);

            var fireBufferEntity = GetSingletonEntity <FireBuffer>();

            EntityManager.AddComponentData(fireBufferEntity, new FireBufferMetaData
            {
                CountX    = spanwerInfoInstance.CountX,
                CountZ    = spanwerInfoInstance.CountZ,
                TotalSize = spanwerInfoInstance.TotalFireCount
            });

            UnityEngine.Debug.Log($"FireGridSpawner initializing grid [{spanwerInfoInstance.CountX}, {spanwerInfoInstance.CountZ}] Total: {spanwerInfoInstance.TotalFireCount}");

            // Grab Fire buffer
            var gridBufferLookup = GetBufferFromEntity <FireBufferElement>();
            var gridBuffer       = gridBufferLookup[fireBufferEntity];

            gridBuffer.ResizeUninitialized(spanwerInfoInstance.TotalFireCount);
            var gridArray = gridBuffer.AsNativeArray();


            // Start initial fires
            int numberOfFires = random.NextInt(spanwerInfoInstance.MinInitialFires, spanwerInfoInstance.MaxInitialFires);

            NativeArray <int> fireIndiciesArr = new NativeArray <int>(numberOfFires, Allocator.TempJob);

            // Pick indicies of fires that should be started, at random
            for (int i = 0; i < numberOfFires; i++)
            {
                int fireIndex = random.NextInt(0, spanwerInfoInstance.TotalFireCount - 1);
                fireIndiciesArr[i] = fireIndex;
            }

            Entities
            .WithDeallocateOnJobCompletion(fireIndiciesArr)
            .WithDeallocateOnJobCompletion(spawners)
            .ForEach((Entity fireEntity, int entityInQueryIndex, ref Translation translation,
                      ref TemperatureComponent temperature, ref StartHeight height, in BoundsComponent bounds) =>
            {
                for (int i = 0; i < spawners.Length; ++i)
                {
                    var spawner = spawners[i];
                    if (entityInQueryIndex < spawner.TotalFireCount)
                    {
                        int x = entityInQueryIndex % spawner.CountX;
                        int z = entityInQueryIndex / spawner.CountZ;

                        // Start pos
                        var posX = spawner.Center.x + bounds.SizeXZ * (x - (spawner.CountX - 1) / 2);
                        var posZ = spawner.Center.z + bounds.SizeXZ * (z - (spawner.CountZ - 1) / 2);

                        // Add random offset on y to debug that the grid spacing is correct
                        var posY = random.NextFloat(-spawner.InitialHeightVariance, spawner.InitialHeightVariance) + spawner.Center.y;

                        height.Value    = posY;
                        height.Variance = random.NextFloat(0.055f, 0.065f);

                        translation.Value = new float3(posX, posY, posZ);

                        // If we should start a fire, start it
                        if (fireIndiciesArr.Contains(entityInQueryIndex))
                        {
                            temperature.Value    = spawner.StartFireAmount;
                            temperature.Velocity = spawner.StartFireVelocity;
                        }

                        // Set initial fire params and variance
                        temperature.StartVelocity    = spawner.StartFireVelocity;
                        temperature.IgnitionVariance = random.NextFloat(0f, 0.5f);
                        temperature.GridIndex        = entityInQueryIndex;

                        gridArray[entityInQueryIndex] = new FireBufferElement {
                            FireEntity = fireEntity
                        };
                        break;
                    }
                    entityInQueryIndex -= spawner.TotalFireCount;
                }
            }).ScheduleParallel();
        }
Example #15
0
    public Store()
    {
        carier = new Carier();

        //<<TEST DATA

        WeaponInfo weapon1 = new WeaponInfo();

        weapon1.force      = 3;
        weapon1.radius     = 1f;
        weapon1.reloadTime = 1f;

        WeaponInfo weapon2 = new WeaponInfo();

        weapon2.force      = 2;
        weapon2.radius     = 1f;
        weapon2.reloadTime = 4f;

        UnitInfo unit1 = new UnitInfo();

        unit1.life       = 10;
        unit1.prefabName = "SimpleUnit";
        unit1.id         = 0;
        unit1.armor      = 1;
        unit1.moveSpeed  = 2f;
        unit1.weapon     = weapon1;
        unit1.killCash   = 1;
        unit1.killScore  = 2;
        unit1.viewRadius = 4;

        UnitInfo unit2 = new UnitInfo();

        unit2.life       = 5;
        unit2.prefabName = "FriendlyUnit";
        unit2.id         = 1;
        unit2.armor      = 1;
        unit2.moveSpeed  = 1.1f;
        unit2.weapon     = weapon2;
        unit2.killCash   = 1;
        unit2.killScore  = 2;
        unit2.viewRadius = 4;

        units.Add(unit1);
        units.Add(unit2);

        //SPAWNER
        SpawnerInfo spawner = new SpawnerInfo();

        spawner.waves = new SpawnWave[1];

        SpawnWave wave1 = new SpawnWave();

        wave1.time  = 0f;
        wave1.units = new SpawnUnit[1];

        SpawnUnit spawnUnit = new SpawnUnit();

        spawnUnit.unitId = 0;
        spawnUnit.time   = 1f;
        spawnUnit.count  = 5;

        /*SpawnUnit spawnUnit2 = new SpawnUnit ();
         * spawnUnit2.unitId = 0;
         * spawnUnit2.time = 3;
         * spawnUnit2.count = 1;*/

        wave1.units.SetValue(spawnUnit, 0);
        //wave1.units.SetValue (spawnUnit,1);

        spawner.waves.SetValue(wave1, 0);
        //spawner.waves.SetValue (wave1, 1);

        //LEVELS

        LeveInfo levelInfo = new LeveInfo();

        levelInfo.id    = 1;
        levelInfo.info  = "TestLevel1";
        levelInfo.spawn = spawner;
        levels.Add(levelInfo);

        levelInfo       = new LeveInfo();
        levelInfo.id    = 2;
        levelInfo.info  = "TestLevel2";
        levelInfo.spawn = spawner;
        levels.Add(levelInfo);

        //LEVEL PROGRESS
        LevelProgress level = new LevelProgress();

        level.id = 1;
        carier.levelsProgress.SetValue(level, 1);

        //PLAYER
        playerInfo                  = new PlayerInfo();
        playerInfo.lifes            = 3;
        playerInfo.spawner.spawners = new TeamSpawner[1];
        TeamSpawner teamSpawner = new TeamSpawner();

        teamSpawner.id     = 0;
        teamSpawner.unitId = 1;
        teamSpawner.time   = 0.5f;
        playerInfo.spawner.spawners.SetValue(teamSpawner, 0);


        playerInfo.weaponInfo       = new PlayerWeaponInfo();
        playerInfo.weaponInfo.force = 4;

        carier.playerInfo = playerInfo;

        //TEST DATA>>
    }