예제 #1
0
    public void Simulate(OrganismSetup[] parents)
    {
        currentGenerationData = new GenerationData(ammount);

        for (int i = 0; i < ammount; i++)
        {
            OrganismSetup setup;
            if (parents == null)
            {
                setup = randomizer.Randomize(originalSetup);
            }
            else
            {
                setup = randomizer.Randomize(parents[Random.Range(0, parents.Length)]);
            }

            currentGenerationData.organisms [i] = setup;

            SpawnOrganism(transform.position, setup, i);
        }

        if (onRestartSimulation != null)
        {
            onRestartSimulation();
        }
        Invoke("EndGeneration", simulationTime);
    }
예제 #2
0
 public BarcodeViewModel(BarcodeViewModel barcodeViewModel)
 {
     Title          = barcodeViewModel.Title;
     Description    = barcodeViewModel.Description;
     Barcode        = barcodeViewModel.Barcode.Clone();
     GenerationData = new GenerationData(barcodeViewModel.GenerationData);
 }
예제 #3
0
        public void GenerateWorld(GenerationSettings settings, BackgroundWorker worker = null)
        {
            GenerationData genData = generator.Generate(settings, worker);

            worldData = new WorldData(genData);
            worldData.SetName(settings.name);
        }
예제 #4
0
        public override void Execute(GenerationData data, Random rng, BackgroundWorker worker = null)
        {
            int   width = data.width;
            int   height = data.height;
            int   x, y;
            float dX, dY, t, d;
            float halfHeight = height * 0.5f;

            NoiseWrapper generator = new NoiseWrapper(
                FastNoise.NoiseType.SimplexFractal, FastNoise.FractalType.FBM, 9.5f, 0.9f, 8, rng.Next()
                );

            for (int i = 0; i < data.pointData.Length; i++)
            {
                x  = i % width;
                y  = i / width;
                dX = x / (float)width;
                dY = y / (float)height;

                t = generator.GetValue(dX, dY, 0, true);

                d = 1 - Math.Abs(y / halfHeight - 1);
                t = (3 * d + t) / 4.0f;
                data.pointData[i].temperature = t;
            }
        }
예제 #5
0
        internal void Init(AreaMapComponent inAreaMapComponent, GenerationData inGenData)
        {
            genData          = inGenData;
            areaMapComponent = inAreaMapComponent;

            FillList();
        }
예제 #6
0
        /// <summary>
        /// Use BFS flood fill to identify the main island, and fill in any inaccessible land
        /// </summary>
        /// <param name="data">An object wrapper for information about each tile</param>
        void FillIslands(GenerationData data)
        {
            PointData[] climateData = data.pointData;
            int         width       = data.width;
            int         height      = data.height;
            int         halfIndex   = (height / 2 * width) + (width / 2);
            int         nIndex;

            PointData c;

            if (climateData[halfIndex].land)
            {
                Queue <PointData> q = new Queue <PointData>(climateData.Length);
                climateData[halfIndex].mainland = true;
                q.Enqueue(climateData[halfIndex]);
                while (q.Count > 0)
                {
                    c = q.Dequeue();

                    nIndex = ((c.y + 0) * width) + (c.x + 1);
                    if (nIndex >= 0 && nIndex < climateData.Length && climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }

                    nIndex = ((c.y + 0) * width) + (c.x - 1);
                    if (nIndex >= 0 && nIndex < climateData.Length && climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }

                    nIndex = ((c.y + 1) * width) + (c.x + 0);
                    if (nIndex >= 0 && nIndex < climateData.Length && climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }

                    nIndex = ((c.y - 1) * width) + (c.x + 0);
                    if (nIndex >= 0 && nIndex < climateData.Length && climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }
                }

                for (int i = 0; i < climateData.Length; i++)
                {
                    climateData[i].land     = climateData[i].mainland;
                    climateData[i].mainland = false;
                }
            }
            else
            {
                Debug.WriteLine("Assumed the center would be land, and it wasn't.");
            }
        }
예제 #7
0
    /**
     * Generates GUI elements given a type of generator.
     * The GenData it points to should not be shared by multiple UI elements.
     */
    private void GeneratorGUI(Type generatorType, string buttonName, GenerationData data)
    {
        SpriteGeneratorBuilder builder = ObjectController.GetContext().
                                         AddComponent <SpriteGeneratorBuilder>().CreateBuilder(generatorType);

        GUILayout.BeginHorizontal();

        // A dropdown list which displays all the PNG files that can be used as spites
        // See AssetController for
        IList <string> spriteList = AssetFetcher.GetSprites();

        spriteList.Insert(0, "Default Sprite");

        string[] sprites = spriteList.ToArray <string>();
        GUILayout.Label("Sprite:");
        data.idx = EditorGUILayout.Popup(data.idx, sprites);

        GUILayout.EndHorizontal();

        if (GUILayout.Button(new GUIContent(buttonName)))
        {
            // We use the Builder pattern so that the GUI logic can get updated easily
            builder = builder.ByCoord(0.0f, 0.0f);
            if (data.idx != 0)
            {
                builder = builder.ByPath(sprites [data.idx]);
            }

            if (data.width != "")
            {
                builder = builder.ByWidth(int.Parse(data.width));
            }

            if (data.height != "")
            {
                builder = builder.ByHeight(int.Parse(data.height));
            }

            if (lightsUI.addLight)
            {
                builder = builder.ByLightData(lightsUI.lightData);
            }

            // We append the file name of the sprite at the end so the type of
            // the object is easily identifiable
            string finalName = "object-" + sprites[data.idx].Replace(" ", "-") + fileIncrement++;

            // The Builder is the component that should persist as a Script Component
            // together with the object. All the fields of the Builder *must* be serializable
            // to persist with the saved scene. The Builder can encasulate all behaviour
            // of the generators.
            GameObject gameObject = builder.Build().GenerateObject(finalName);
            gameObject.AddComponent <SpriteGeneratorBuilder>().ByBuilder(builder);
        }

        UnityEngine.Object.DestroyImmediate(builder);
    }
예제 #8
0
        public string GenerateCode(string licenseKey, GenerationData generationData)
        {
            var hw   = Hardware.GetId();
            var body = GenerateRequestBody(licenseKey, hw, generationData);
            var task = RequestHelper.PostAsync(_apiUrl, body);

            task.Wait();

            return(GetResultFromResponse(task.Result));
        }
예제 #9
0
        public void Test()
        {
            var key  = "ta";
            var data = new GenerationData {
                Namespace = "test"
            };
            var code = _client.GenerateCode(key, data);

            Assert.IsNull(code);
        }
예제 #10
0
        public IEnumerable <TemplateLicense> GetAllLicences(GenerationData generationData)
        {
            BuildContextProvider(generationData);

            var userSelection = generationData.ToUserSelection();

            var licences = GenComposer.GetAllLicences(userSelection);

            return(licences);
        }
예제 #11
0
        private string GenerateRequestBody(string licenseKey, string hw, GenerationData generationData)
        {
            var message = new RequestMessage
            {
                Key            = licenseKey,
                Hardware       = hw,
                GenerationData = generationData
            };

            return(Cryptographer.Encrypt(message));
        }
예제 #12
0
        public void Test_FileStoring()
        {
            var documentManager = new WordDocumentManager();

            var simpleFile = new GenerationData();

            var filePath = "C:\\temp\\WordGeneration";
            var fileName = $"{Guid.NewGuid().ToString()}.docx";

            documentManager.SaveDocument(simpleFile, filePath, fileName);
        }
예제 #13
0
파일: Program.cs 프로젝트: khm1600/CJing
    private static GenerationData ReadFile(string path, bool embeddedPdb)
    {
        try
        {
            var generation = new GenerationData();
            var stream     = File.OpenRead(path);

            if (IsPE(stream))
            {
                var peReader = new PEReader(stream);
                generation.PEReaderOpt = peReader;

                if (embeddedPdb)
                {
                    var embeddedEntries = peReader.ReadDebugDirectory().Where(entry => entry.Type == DebugDirectoryEntryType.EmbeddedPortablePdb).ToArray();
                    if (embeddedEntries.Length == 0)
                    {
                        throw new InvalidDataException("No embedded pdb found");
                    }

                    if (embeddedEntries.Length > 1)
                    {
                        throw new InvalidDataException("Multiple entries in Debug Directory Table of type EmbeddedPortablePdb");
                    }

                    var provider = peReader.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedEntries[0]);
                    generation.MetadataReader = provider.GetMetadataReader();
                    generation.MemoryOwner    = provider;
                }
                else
                {
                    generation.MetadataReader = peReader.GetMetadataReader();
                    generation.MemoryOwner    = peReader;
                }
            }
            else if (IsManagedMetadata(stream))
            {
                var mdProvider = MetadataReaderProvider.FromMetadataStream(stream);
                generation.MetadataReader = mdProvider.GetMetadataReader();
                generation.MemoryOwner    = mdProvider;
            }
            else
            {
                throw new NotSupportedException("File format not supported");
            }

            return(generation);
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error reading '{path}': {e.Message}");
            return(null);
        }
    }
 public static GenerationSettings ToSettings(this GenerationData @this)
 {
     return(new GenerationSettings
     {
         Width = @this.Width,
         DefaultSize = @this.DefaultSize,
         Height = @this.Height,
         Type = @this.Type,
         ValidateCodeText = @this.ValidateCodeText,
     });
 }
 private static string GetDay(int?amountOfDays, GenerationData data)
 {
     if (amountOfDays.HasValue)
     {
         return(amountOfDays > 1 ? DocumentMetadataTexts.GetText(MetadataTexts.CV_DAYS, data.Language) : DocumentMetadataTexts.GetText(MetadataTexts.CV_DAY, data.Language));
     }
     else
     {
         return(string.Empty);
     }
 }
예제 #16
0
        /// <summary>
        /// Use BFS flood fill to identify the main ocean, and fill in any inaccessible water
        /// </summary>
        /// <param name="data">An object wrapper for information about each tile</param>
        void FillLakes(GenerationData data)
        {
            PointData[] climateData = data.pointData;
            int         width       = data.width;
            int         height      = data.height;
            int         nIndex;

            PointData c;

            if (!climateData[0].land)
            {
                Queue <PointData> q = new Queue <PointData>(climateData.Length);
                climateData[0].mainland = true;
                q.Enqueue(climateData[0]);
                while (q.Count > 0)
                {
                    c = q.Dequeue();

                    nIndex = ((c.y + 0) * width) + (c.x + 1);
                    if (nIndex >= 0 && nIndex < climateData.Length && !climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }

                    nIndex = ((c.y + 0) * width) + (c.x - 1);
                    if (nIndex >= 0 && nIndex < climateData.Length && !climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }

                    nIndex = ((c.y + 1) * width) + (c.x + 0);
                    if (nIndex >= 0 && nIndex < climateData.Length && !climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }

                    nIndex = ((c.y - 1) * width) + (c.x + 0);
                    if (nIndex >= 0 && nIndex < climateData.Length && !climateData[nIndex].land && !climateData[nIndex].mainland)
                    {
                        climateData[nIndex].mainland = true;
                        q.Enqueue(climateData[nIndex]);
                    }
                }

                for (int i = 0; i < climateData.Length; i++)
                {
                    climateData[i].land     = !climateData[i].mainland;
                    climateData[i].mainland = false;
                }
            }
        }
 public static StorageBarcode ToStorageBarcode(this GenerationData @this)
 {
     return(new StorageBarcode
     {
         Width = @this.Width,
         Data = @this.Data,
         DefaultSize = @this.DefaultSize,
         Height = @this.Height,
         Type = @this.Type,
         Title = null
     });
 }
예제 #18
0
        private Generator()
        {
            roomList         = new List <Room>();
            monsterGenerator = new MonsterGenList();

            GenerationData data = GenerationData.getInstance();

            availableSquares = data.gridSquares;

            weightedMin = 4;
            weightedMax = availableSquares / 2;
        }
예제 #19
0
        public override void Execute(GenerationData data, Random rng, BackgroundWorker worker = null)
        {
            int   x, y;
            float dX, dY;
            float ddX, ddY;
            float e1, e2, d;
            float halfHeight = data.height >> 1;

            NoiseWrapper shapeGenerator1 = new NoiseWrapper(
                FastNoise.NoiseType.SimplexFractal, FastNoise.FractalType.Billow, 12f, 0.525f, 8, rng.Next() // 22.5f, 0.575f, 8
                );
            NoiseWrapper shapeGenerator2 = new NoiseWrapper(
                FastNoise.NoiseType.SimplexFractal, FastNoise.FractalType.FBM, 20.0f, .45f, 8, rng.Next() // 25.0f, 0.4f, 8,
                );

            for (int i = 0; i < data.pointData.Length; i++)
            {
                x = i % data.width;
                y = i / data.width;

                dX = x / (float)data.width;
                dY = y / (float)data.height;

                data.pointData[i].x = x;
                data.pointData[i].y = y;

                // Calculate Shape
                e1 = 1 - Math.Abs(shapeGenerator1.GetValue(dX, dY, 0, true));

                e1 *= 0.1f;
                e1  = (e1 * 2) - 1;

                ddX = dX + e1;
                ddY = dY + e1;

                e1 = shapeGenerator2.GetValue(ddX, ddY, 0, true);

                d  = MathEx.EuclideanDistanceCenter(x, y, data.width, data.height);
                e2 = e1 + sA - sB * (float)Math.Pow(d, sC);

                data.pointData[i].land      = e2 > oceanThreshold;
                data.pointData[i].elevation = e2;

                //Report Progress back to Main thread
                if (worker != null)
                {
                    worker.ReportProgress((int)((i / (float)data.pointData.Length) * 100));
                }
            }
            FillIslands(data);
            FillLakes(data);
        }
예제 #20
0
        public string GenerateElements(string path, string elementsNamespace = "")
        {
            var docs = Loader.Load(path);

            Validator.CheckDocuments(docs);
            LocatorRenderer.Run(docs);
            var docsString = docs.Values.Select(x => x.Save());
            var data       = new GenerationData {
                Namespace = elementsNamespace, XmlDocuments = docsString
            };

            return(_apiClient.GenerateCode(_licenseKey, data));
        }
예제 #21
0
        private void GenerateMonsters()
        {
            GenerationData data = GenerationData.getInstance();
            int            monsterCount = 0, monsterLikelyness = 0;

            monsterGenerator = new MonsterGenList();

            // Determine what monster mode we are using and set the variables to act as such
            switch (data.monsterMode)
            {
            case MonsterMode.None:
                monsterCount = monsterLikelyness = 0;
                break;

            case MonsterMode.Few:
                monsterCount      = 5;
                monsterLikelyness = 21;
                break;

            case MonsterMode.Moderate:
                monsterCount      = 10;
                monsterLikelyness = 31;
                break;

            case MonsterMode.Many:
                monsterCount      = 20;
                monsterLikelyness = 61;
                break;
            }

            //check & set level
            monsterGenerator.SetMonsterStats(data.level, data.level + 5);

            for (int i = 0; i < roomList.Count; i++)
            {
                // Needs randomized x coord?
                monsterGenerator.SetMonsterRoomDimensions(roomList[i].posX, roomList[i].posY, roomList[i].width, roomList[i].height);

                //set monsters
                //everything is minions for now
                for (int j = 0; j < monsterCount; j++)
                {
                    int currRand = rndTwo.Next(1, 101);
                    if (currRand < monsterLikelyness)
                    {
                        roomList[i].addToMonsList(monsterGenerator.GenerateMinion());
                    }
                }
            }
        }
예제 #22
0
        private void BuildContextProvider(GenerationData generationData)
        {
            var safeProjectName = generationData.ProjectName.MakeSafeProjectName();
            var combinedPath    = Path.Combine(generationData.GenPath, safeProjectName, safeProjectName);

            ContextProvider provider = new ContextProvider()
            {
                ProjectName          = generationData.ProjectName,
                GenerationOutputPath = combinedPath,
                DestinationPath      = combinedPath,
            };

            GenContext.Current = provider;
        }
예제 #23
0
        /// <summary>
        /// Applies the calculated alphamap to the Terrain.
        /// </summary>
        public void ApplyAlphamap()
        {
            GenerationData gen            = TerraConfig.Instance.Generator;
            int            res            = gen.SplatmapResolution - 1;
            int            maxResPerFrame = TerraConfig.Instance.Generator.CoroutineRes;
            int            splatCount     = Alphamap.GetLength(2);

            _terrain.terrainData.alphamapResolution = res;

//            if (gen.UseCoroutines && Application.isPlaying && res > maxResPerFrame) {
//                _tile.StartCoroutine(ApplyAlphamapCoroutine(res, maxResPerFrame, splatCount));
//            } else {
            _terrain.terrainData.SetAlphamaps(0, 0, Alphamap);
//            }
        }
    public void SaveLastGeneration()
    {
        if (currentGeneration < 1)
        {
            Debug.LogError("Cannot save last generation while on Generation 0.");
            return;
        }

        BinaryFormatter bf   = new BinaryFormatter();
        FileStream      file = File.Open(Application.persistentDataPath + "/savedGeneration.gen", FileMode.OpenOrCreate);

        GenerationData genData = new GenerationData(carData, currentGeneration - 1, bestCar);

        bf.Serialize(file, genData);
        file.Close();
        Debug.Log("Successfully saved last generation.");
    }
예제 #25
0
        // Generation Button, does the magic
        private void generateButton_Click(object sender, EventArgs e)
        {
            // Get the data instance
            GenerationData data = GenerationData.getInstance();

            // Pass in the data
            data.setupData(levelBox.SelectedIndex + 1, roomsBox.SelectedIndex + 1,
                           (TrapMode)trapBox.SelectedIndex, (MonsterMode)monstersBox.SelectedIndex,
                           (DifficultyLevel)difficultyBox.SelectedIndex, (TreasureMode)treasureBox.SelectedIndex);

            // TODO: Run the Generation
            Generator generator = Generator.getInstance();

            generator.GenerateRooms();

            LevelData.getInstance().setupLevelWithData(generator.roomList);
        }
예제 #26
0
        public WorldData(GenerationData genData)
        {
            int chunkWidth  = (genData.width / Config.CHUNK_SIZE);
            int chunkHeight = (genData.height / Config.CHUNK_SIZE);

            chunks       = new Chunk[chunkWidth * chunkHeight];
            loadedChunks = new Dictionary <int, Chunk>();

            header.width     = genData.width;
            header.height    = genData.height;
            header.spawnArea = genData.spawnArea;

            for (int i = 0; i < (chunkWidth * chunkHeight); i++)
            {
                chunks[i] = new Chunk(genData, i % chunkWidth, i / chunkWidth, header.width);
            }
        }
예제 #27
0
        public void GenerateRooms()
        {
            roomList.Clear();
            GenerationData data = GenerationData.getInstance();

            availableSquares = data.gridSquares;

            //check # rooms
            //go through each and make a new room
            while (roomList.Count < data.numberOfRooms)
            {
                GenerateRoom();
            }

            // Add the Monsters to the Room
            GenerateMonsters();
        }
    private bool LoadGenerationFromFile(out GenerationData loadData)
    {
        if (File.Exists(Application.persistentDataPath + "/savedGeneration.gen"))
        {
            // Load file
            BinaryFormatter bf   = new BinaryFormatter();
            FileStream      file = File.Open(Application.persistentDataPath + "/savedGeneration.gen", FileMode.Open);

            loadData = (GenerationData)bf.Deserialize(file);

            return(true);
        }
        else
        {
            loadData = null;
            return(false);
        }
    }
예제 #29
0
        private void InitializeGenerationData()
        {
            _generationData = _generationDataService.Get();

            OrganizerPdfTextBox.Text   = _generationData.Organizer?.FieldName;
            OrganizerExcelTextBox.Text = _generationData.Organizer?.Cell;
            EventPdfTextBox.Text       = _generationData.Event?.FieldName;
            EventExcelTextBox.Text     = _generationData.Event?.Cell;
            PlacePdfTextBox.Text       = _generationData.Place?.FieldName;
            PlaceExcelTextBox.Text     = _generationData.Place?.Cell;
            DatePdfTextBox.Text        = _generationData.Date?.FieldName;
            DateExcelTextBox.Text      = _generationData.Date?.Cell;
            TimePdfTextBox.Text        = _generationData.Time?.FieldName;
            TimeExcelTextBox.Text      = _generationData.Time?.Cell;
            PapsPdfTextBox.Text        = _generationData.Paps?.FieldName;
            TeamNumberPdfTextBox.Text  = _generationData.TeamNumber?.FieldName;
            LocalPdfTextBox.Text       = _generationData.Local?.FieldName;
            MealPdfTextBox.Text        = _generationData.Meal?.FieldName;
        }
예제 #30
0
        public static string Generate(GenerationData data)
        {
            data.Namespace = string.IsNullOrWhiteSpace(data.Namespace) ? "ZennoFramework.Generated" : data.Namespace;

            var result = Header.Create().NewLine();

            result += "namespace " + data.Namespace.NewLine();
            result += "{".NewLine();

            foreach (var xml in data.XmlDocuments)
            {
                var document = XDocument.Parse(xml.Trim('\uFEFF', '\u200B'));
                var root     = document.ToGenerationElements();
                result  = result.NewLineSafe();
                result += WriteElements(root, "    ");
            }

            return(result + "}".NewLine());
        }
예제 #31
0
	// 

	public void InitializeNewGenerationDataArrays(int generationIndex) {
        if (recordScoresTrialDataArray == null) { // if first time:
            // USE THIS STUFF TO STORE GLOBAL RECORD SCORES PER-FITNESSCOMPONENT!!!
            // This will then be used to help score each generation in the future
            // I'm just re-using the data classes here but this might need a more custom solution later.
            // as with the rest of this system, it can't handle drastic changes to number/type of Trials, or adding/deleting fitness components.
            // Eventually I'll have to build a very flexible system that can handle gen0 being totally different from currentGen....
            recordScoresTrialDataArray = new List<TrialData>();
            int numActiveTrials = 0;
            for (int i = 0; i < playerRef.masterTrialsList.Count; i++) { // First loop needed just to Count
                if (playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) {  // if active trial
                    numActiveTrials++;
                }
            }
            // Loop through all Trials:
            for (int trialIndex = 0; trialIndex < numActiveTrials; trialIndex++) {
                // Get numFitnessComponents:
                int numFitnessComponents = playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList.Count;
                TrialData newTrialData = new TrialData(numFitnessComponents);

                for (int fitCompIndex = 0; fitCompIndex < numFitnessComponents; fitCompIndex++) {
                    FitnessComponentData newFitnessComponentData = new FitnessComponentData();
                    newTrialData.fitnessComponentDataArray[fitCompIndex] = newFitnessComponentData;
                }
                recordScoresTrialDataArray.Add(newTrialData);
            }
        }

		// For This Player:
		if(generationIndex >= generationDataList.Count) { // if new generation needs to be created

            // !!!!!!!@!@!#$!@$#!$!@@@@@@@@@@@@@@@@@@@@@@@!@$#!#############!!!!!!!!!!!!!!!!!!!!!!^^^^^^^^^^^^^$%&###############%***********************$$$$$$$$##########
            // Calculate total TrialWeights and totalFitnessComponentWeights per Trial for later use somewhere in this function!!!!
            int numAgents = playerRef.masterPopulation.populationMaxSize;
            //     Get number of Trials:
            int numActiveTrials = 0;
			for(int i = 0; i < playerRef.masterTrialsList.Count; i++) { // First loop needed just to Count
				if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) {  // if active trial
					numActiveTrials++;
				}
			}
            GenerationData newGenerationData = new GenerationData(numActiveTrials);
            
            // Loop through all Trials:
            for(int trialIndex = 0; trialIndex < numActiveTrials; trialIndex++) {
                // Get numFitnessComponents:
                int numFitnessComponents = playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList.Count;
                TrialData newTrialData = new TrialData(numFitnessComponents);
                
                for(int fitCompIndex = 0; fitCompIndex < numFitnessComponents; fitCompIndex++) {
                    FitnessComponentData newFitnessComponentData = new FitnessComponentData(numAgents);

                    for(int a = 0; a < numAgents; a++) {
                        AgentData newAgentData = new AgentData();

                        newFitnessComponentData.agentDataArray[a] = newAgentData;
                    }
                    newTrialData.totalSumOfWeights += playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList[fitCompIndex].weight;
                    newTrialData.fitnessComponentDataArray[fitCompIndex] = newFitnessComponentData;
                }
                newGenerationData.totalSumOfWeights += playerRef.masterTrialsList[trialIndex].weight;
                newGenerationData.trialDataArray[trialIndex] = newTrialData; // actually assign the new AgentData instance to generationData
                newGenerationData.totalNumFitnessComponents = numFitnessComponents;
            }

            // AvgGenome:
            // Calculate Generation average genome:  // BROKEN BECAUSE USING NEW GENOMES!!!
            /*Genome avgGenome = new Genome();
            avgGenome.genomeBiases = new float[playerRef.masterPopulation.masterAgentArray[0].genome.genomeBiases.Length];
            avgGenome.genomeWeights = new float[playerRef.masterPopulation.masterAgentArray[0].genome.genomeWeights.Length];
            avgGenome.ZeroGenome(); // set all values to 0f;
            for (int i = 0; i < numAgents; i++) {
                // iterate through Bias Arrays and add each agent's bias value to the avg
                for (int b = 0; b < avgGenome.genomeBiases.Length; b++) {
                    avgGenome.genomeBiases[b] += playerRef.masterPopulation.masterAgentArray[i].genome.genomeBiases[b] / (float)numAgents;
                }
                // iterate through Weight Arrays and add each agent's weight value to the avg
                for (int w = 0; w < avgGenome.genomeWeights.Length; w++) {
                    avgGenome.genomeWeights[w] += playerRef.masterPopulation.masterAgentArray[i].genome.genomeWeights[w] / (float)numAgents;
                }
            }
            // Save the genome values to this generation Data:
            newGenerationData.genAvgGenome = avgGenome;*/
            //newGenerationData.genAvgGenome.genomeBiases = avgGenome.genomeBiases;
            //newGenerationData.genAvgGenome.genomeWeights = avgGenome.genomeWeights;

            generationDataList.Add(newGenerationData); // Add the newly created generation data to the master list



            // OLD BELOW v v v v v v v v v v v v
            // Loop over all agents
            /*int numAgents = playerRef.masterPopulation.populationMaxSize;
            for (int j = 0; j < numAgents; j++) {
				AgentData newAgentData = new AgentData(numActiveTrials);

				// Fill the AgentData's TrialsList:		
				int curTrialIndex = 0;
				int totalNumComponents = 0;
				for(int i = 0; i < playerRef.masterTrialsList.Count; i++) {
					if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) {  // if active trial
						//     For each Trial, Get number of FitnessComponents & GameRounds
						int numGameRounds = playerRef.masterTrialsList[i].numberOfPlays;
						int totalFitnessComponents = playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count + 
														playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count;
						int numActiveFitnessComponents = 0;
						// Brain Components:
						for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
							if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
								numActiveFitnessComponents++;
								totalNumComponents++;
							}
						}
						// Game Components:
						for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
							if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
								numActiveFitnessComponents++;
								totalNumComponents++;
							}
						}
						
						int curFitnessComponentIndex = 0;
						TrialData newTrialData = new TrialData(numActiveFitnessComponents);
						for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
							if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
								newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
								curFitnessComponentIndex++;
							}
						}
						for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
							if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
								newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
								curFitnessComponentIndex++;
							}
						}
						newAgentData.trialDataArray[curTrialIndex] = newTrialData; // Set AgentData for this agent.
						//Debug.Log ("curTrialIndex= " + curTrialIndex.ToString() + ", numGameRounds= " + numGameRounds.ToString() + ", numFitnessComponents= " + totalFitnessComponents.ToString() + ", numActiveFitnessComponents= " + numActiveFitnessComponents.ToString());
						curTrialIndex++; // before or after?
							
					}
				}
				newGenerationData.agentDataArray[j] = newAgentData; // actually assign the new AgentData instance to generationData
				newGenerationData.totalNumFitnessComponents = totalNumComponents;
			}	
			//
			generationDataList.Add (newGenerationData); // Add the newly created generation data to the master list
            */
		}               
	}
예제 #32
0
    //
    public void InitializeNewGenerationDataArrays(int generationIndex)
    {
        // For This Player:
        if(generationIndex >= generationDataList.Count) { // if new generation needs to be created
            //Debug.Log ("InitializeNewGenerationDataArrays" + generationIndex.ToString());

            int numAgents = playerRef.masterPopulation.populationMaxSize;
            GenerationData newGenerationData = new GenerationData(numAgents); // Now I have a generationData wrapper and an array of AgentData's

            //     Get number of Trials
            int numActiveTrials = 0;
            for(int i = 0; i < playerRef.masterTrialsList.Count; i++) { // First loop needed just to Count
                if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) {  // if active trial
                    numActiveTrials++;
                }
            }
            //Debug.Log ("NumActiveTrials= " + numActiveTrials.ToString() + ", NumAgents= " + numAgents.ToString());
            // Loop over all agents?
            for(int j = 0; j < numAgents; j++) {
                AgentData newAgentData = new AgentData(numActiveTrials);

                // Fill the AgentData's TrialsList:
                int curTrialIndex = 0;
                int totalNumComponents = 0;
                for(int i = 0; i < playerRef.masterTrialsList.Count; i++) {
                    if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) {  // if active trial
                        //     For each Trial, Get number of FitnessComponents & GameRounds
                        int numGameRounds = playerRef.masterTrialsList[i].numberOfPlays;
                        int totalFitnessComponents = playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count +
                                                        playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count;
                        int numActiveFitnessComponents = 0;
                        // Brain Components:
                        for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
                            if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
                                numActiveFitnessComponents++;
                                totalNumComponents++;
                            }
                        }
                        // Game Components:
                        for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
                            if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
                                numActiveFitnessComponents++;
                                totalNumComponents++;
                            }
                        }

                        int curFitnessComponentIndex = 0;
                        TrialData newTrialData = new TrialData(numActiveFitnessComponents);
                        for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
                            if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
                                newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
                                curFitnessComponentIndex++;
                            }
                        }
                        for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
                            if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
                                newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
                                curFitnessComponentIndex++;
                            }
                        }
                        newAgentData.trialDataArray[curTrialIndex] = newTrialData; // Set AgentData for this agent.
                        //Debug.Log ("curTrialIndex= " + curTrialIndex.ToString() + ", numGameRounds= " + numGameRounds.ToString() + ", numFitnessComponents= " + totalFitnessComponents.ToString() + ", numActiveFitnessComponents= " + numActiveFitnessComponents.ToString());
                        curTrialIndex++; // before or after?

                    }
                }
                newGenerationData.agentDataArray[j] = newAgentData; // actually assign the new AgentData instance to generationData
                newGenerationData.totalNumFitnessComponents = totalNumComponents;
            }
            //
            generationDataList.Add (newGenerationData); // Add the newly created generation data to the master list
        }
    }