Ejemplo n.º 1
0
    public void GeneticCrossOver()
    {
        if (simManager.genNum == 1) // If this is the first generation
        {
            return;
        }

        int[] parentIndexes = SelectParents();
        basicLayer = simManager.lastSquares[parentIndexes[0]].basicLayer; // Copy one parent's neural network layer to the new one's

        if (basicLayer == null)                                           //parentIndexes[0] < 10)
        {
            print(parentIndexes[0] + ", " + simManager.lastSquares[parentIndexes[0]].id + ", " + simManager.lastSquares[parentIndexes[0]].basicLayer[0, 0]);
        }

        for (int i = 0; i < basicLayer.GetLength(0); i++)
        {
            for (int j = 0; j < basicLayer.GetLength(1); j++)
            {
                if (BetterRandom.betterRandom(0, 1000000) / 1000000f <= SimulationManager.sCrossOverRate) // Cross over
                {
                    basicLayer[i, j] = simManager.lastSquares[parentIndexes[1]].basicLayer[i, j];
                }
            }
        }
    }
Ejemplo n.º 2
0
        public string ThrowGrenade()
        {
            var eligableHalls = _halls.Where(hall => !hall.PartOfTree && !hall.IsDestroyed).ToList();

            if (!eligableHalls.Any())
            {
                return("You fear the whole dungeon would collapse if you threw another grenade.");
            }

            var destroyed = 0;

            while (destroyed < Math.Min(15, eligableHalls.Count) && eligableHalls.Count > 0)
            {
                var index = new BetterRandom().Next(eligableHalls.Count);

                eligableHalls[index].IsDestroyed = true;
                eligableHalls.RemoveAt(index);

                destroyed++;
            }

            // Kill enemy
            Player.Position.Enemy = null;

            DrawCompassRoute();

            return("You hear a trembling in the distance, a part of the dungeon has collapsed.");
        }
Ejemplo n.º 3
0
    /// <summary>
    /// Randomly generate a new enemy type with a certain total power
    /// 1: move
    /// 2: hp
    /// 3: power
    /// 4: range
    /// </summary>
    /// <param name="totalPower"></param>
    /// <returns></returns>
    public EnemyTypeInfo CreateNewEnemyType(int totalPower)
    {
        EnemyTypeInfo newTypeInfo = new EnemyTypeInfo();

        int[] abilityStrength    = { maxEnemyMoveRange, maxEnemyMaxHealth, maxEnemyAttackPower, maxEnemyAttackRange };
        int[] minAbilityStrength = { minEnemyMoveRange, minEnemyMaxHealth, minEnemyAttackPower, minEnemyAttackRange };
        int   targetDifference   = maxEnemyMoveRange + maxEnemyMaxHealth + maxEnemyAttackPower + maxEnemyAttackRange - totalPower;

        // Reduce ability strength to match total power
        while (targetDifference > 0)
        {
            int ability = BetterRandom.betterRandom(0, abilityStrength.Length - 1);

            // If strength can be decreased
            if (abilityStrength[ability] > minAbilityStrength[ability])
            {
                abilityStrength[ability]--;
                targetDifference--;
            }
        }

        newTypeInfo.moveRange   = abilityStrength[0];
        newTypeInfo.maxHealth   = abilityStrength[1];
        newTypeInfo.attackPower = abilityStrength[2];
        newTypeInfo.attackRange = abilityStrength[3];

        return(newTypeInfo);
    }
Ejemplo n.º 4
0
    private double GetRandomGen()
    {
        BetterRandom random = new BetterRandom();

        return(random.Range(genMin, genMax));
        //return Random.Range(genMin, genMax);
    }
Ejemplo n.º 5
0
        public void RandomVector(ref Vector3 start, ref Vector3 end, float offsetAmount, out Vector3 result)
        {
            if (orthographic)
            {
                Vector3 directionNormalized = (end - start).normalized;
                Vector3 side = new Vector3(-directionNormalized.y, directionNormalized.x, directionNormalized.z);
                //float distance = ((float)RandomGenerator.NextDouble() * offsetAmount * 2.0f) - offsetAmount;
                float distance = ((float)BetterRandom.betterRandom(0, 1000000) / 1000000f * offsetAmount * 2.0f) - offsetAmount;
                result = side * distance;
            }
            else
            {
                Vector3 directionNormalized = (end - start).normalized;
                Vector3 side;
                GetPerpendicularVector(ref directionNormalized, out side);

                // generate random distance
                //float distance = (((float)RandomGenerator.NextDouble() + 0.1f) * offsetAmount);
                float distance = (((float)BetterRandom.betterRandom(0, 1000000) / 1000000f + 0.1f) * offsetAmount);

                // get random rotation angle to rotate around the current direction
                //float rotationAngle = ((float)RandomGenerator.NextDouble() * 360.0f);
                float rotationAngle = ((float)BetterRandom.betterRandom(0, 1000000) / 1000000f * 360.0f);

                // rotate around the direction and then offset by the perpendicular vector
                result = Quaternion.AngleAxis(rotationAngle, directionNormalized) * side * distance;
            }
        }
        public ActionResult CreateRandomOrder(OrderInfoDTO orderInfoDTO)
        {
            IRestResponse <OrderResponseDTO> response = null;
            var          toppings = _distributedPizzaDbContext.Toppings.ToList();
            BetterRandom random   = new BetterRandom();

            for (int i = 0; i < orderInfoDTO.NumberOfRequests; i++)
            {
                var orderManager = new OrderManager(toppings, random);
                var order        = orderManager.GenerateRandomOrder();
                order.QueueType          = orderInfoDTO.QueueType;
                order.ReportBackToClient = orderInfoDTO.NumberOfRequests == 1;
                var client  = new RestClient("http://localhost/DistributedPizza.Web.Api");
                var request = new RestRequest("api/orders/create", Method.POST);
                request.AddHeader("Accept", "application/json");
                request.RequestFormat = DataFormat.Json;
                request.AddBody(order);
                response = client.Execute <OrderResponseDTO>(request);
            }

            if (orderInfoDTO.NumberOfRequests == 1 & response != null)
            {
                response.Data.NumberOfRequests = orderInfoDTO.NumberOfRequests;
                return(Json(response.Data));
            }
            else
            {
                return(Json(new OrderResponseDTO {
                    NumberOfRequests = orderInfoDTO.NumberOfRequests
                }));
            }
        }
Ejemplo n.º 7
0
        public static double RandomNext()
        {
            double one = BetterRandom.NextDouble();
            double two = BetterRandom.NextDouble();

            return(Math.Sqrt(-2.0 * Math.Log(one)) * Math.Cos(6.2831853071795862 * two));
        }
Ejemplo n.º 8
0
    /// <summary>
    /// Get the win condition for current game
    /// </summary>
    public void GetWinCondition()
    {
        int requiredEvolvePower = BetterRandom.betterRandom(11, 15);
        int powerDifference     = 16 - requiredEvolvePower;

        int[] targetAbilityPowers = { 4, 4, 4, 4 };

        while (powerDifference > 0)
        {
            int ability = BetterRandom.betterRandom(0, 3);

            if (targetAbilityPowers[ability] > 0)
            {
                targetAbilityPowers[ability]--;
                powerDifference--;
            }
        }

        gameGoal.maxHealth   = playerUnitInitialMaxHealth + targetAbilityPowers[0];
        gameGoal.moveRange   = playerUnitInitialMoveRange + targetAbilityPowers[1];
        gameGoal.attackPower = playerUnitInitialAttackPower + targetAbilityPowers[2];
        gameGoal.attackRange = playerUnitInitialAttackRange + targetAbilityPowers[3];
        gameGoal.CreateCloneLook();
        gameGoal.health = 0; // Hide health bar
    }
Ejemplo n.º 9
0
        private static IEnumerable <StatementSyntax> FindRandomExtractableCode(BaseMethodDeclarationSyntax extractFrom)
        {
            var statementsCount  = extractFrom.Body.Statements.Count;
            var startingPosition = BetterRandom.Between(0, statementsCount - 2);
            var depth            = BetterRandom.Between(1, statementsCount - startingPosition - 1);
            var constraint       = startingPosition + depth;

            if (statementsCount < constraint)
            {
                throw new ArgumentOutOfRangeException($"startingPosition = {startingPosition}, depth = {depth}");
            }

            var returnNodes = new List <StatementSyntax>();

            for (var i = startingPosition; i < constraint; i++)
            {
                var node = extractFrom.Body.Statements[i];
                if (node != null)
                {
                    returnNodes.Add(node);
                }
            }

            return(returnNodes);
        }
Ejemplo n.º 10
0
    public void PlaySFXOneShot(AudioClip sfx)
    {
        sfxPlayer.Stop();
        float k = BetterRandom.betterRandom(-100, 100) / 1000;// avoid machine gun sound

        sfxPlayer.volume = masterVolume + masterVolume * k;
        sfxPlayer.PlayOneShot(sfx);
    }
Ejemplo n.º 11
0
    /// <summary>
    /// Place down enemy units
    /// </summary>
    public void PlaceNewEnemies()
    {
        // Get a list of empty map border tiles
        List <GridTileInfo> emptyBorderTiles = MapManager.sMapManager.GetEmptyBorderTiles();

        // Get number of enemies to be generated
        int maxEnemyAmount = Mathf.Clamp(Mathf.FloorToInt(GameManager.playerTotalPower / EnemyManager.minEnemyPower), 0, emptyBorderTiles.Count);
        int minEnemyAmount = Mathf.Clamp(Mathf.CeilToInt(GameManager.playerTotalPower / EnemyManager.maxEnemyPower), 1, maxEnemyAmount); // Make sure there is at least one enemy being generated
        int enemyAmount    = BetterRandom.betterRandom(minEnemyAmount, maxEnemyAmount);

        // Get individual power for each enemy
        int[] individualEnemyPower = new int[enemyAmount];

        for (int i = 0; i < individualEnemyPower.Length; i++)
        {
            individualEnemyPower[i] = EnemyManager.maxEnemyPower;
        }

        int powerDifference = enemyAmount * EnemyManager.maxEnemyPower - GameManager.playerTotalPower; // Get power difference

        while (powerDifference > 0)                                                                    // Randomly decrease enemy power
        {
            int selectedEnemy = BetterRandom.betterRandom(0, individualEnemyPower.Length - 1);         // Randomly select an enemy

            // Decrement selected enemy power if it has not reached minEnemyPower
            if (individualEnemyPower[selectedEnemy] > EnemyManager.minEnemyPower)
            {
                individualEnemyPower[selectedEnemy]--;
                powerDifference--;
            }
        }

        // Assign spawn positions
        List <int> spawnPosition = new List <int>();

        for (int i = 0; i < enemyAmount; i++)
        {
            int newPosition = BetterRandom.betterRandom(0, emptyBorderTiles.Count - 1);

            while (spawnPosition.Contains(newPosition))
            {
                newPosition = BetterRandom.betterRandom(0, emptyBorderTiles.Count - 1);
            }

            spawnPosition.Add(newPosition);
        }

        // Create new enemies
        for (int i = 0; i < enemyAmount; i++)
        {
            EnemyManager.sEnemyManager.CreateEnemy(EnemyManager.sEnemyManager.CreateNewEnemyType(individualEnemyPower[i]), emptyBorderTiles[spawnPosition[i]].xCoord, emptyBorderTiles[spawnPosition[i]].zCoord);
        }

        // Test
        //EnemyManager.sEnemyManager.CreateEnemy(EnemyManager.EnemyType.Test, 4, 4);
    }
Ejemplo n.º 12
0
 void Awake()
 {
     betterRandom = new BetterRandom();
     if (instance == null)
     {
         instance = this;
     }
     else if (instance != this)
     {
         Destroy(gameObject);
     }
 }
Ejemplo n.º 13
0
    public float[] Noise(float frequency) // Generate a shifted sine wave
    {
        float[] newWave    = new float[actualTerrainSize];
        float   phaseShift = BetterRandom.betterRandom(0, Mathf.RoundToInt(20000000 * Mathf.PI)) / 10000000f;

        for (int i = 0; i < map.GetLength(0); i++)
        {
            newWave[i] = Mathf.Sin(2 * Mathf.PI * frequency * i / actualTerrainSize + phaseShift);
        }

        return(newWave);
    }
Ejemplo n.º 14
0
        public static List <double> RandomDoubles(int length)
        {
            Random r          = BetterRandom.NewRandom();
            var    result     = new List <double>(length);
            double multiplier = Math.Pow(10.0, Math.Floor(Math.Log10(length) + 1.0));

            for (int i = 0; i < length; i++)
            {
                result.Add(Math.Floor(r.NextDouble() * multiplier));
            }
            return(result);
        }
    public void Start()
    {
        offsetX = Random.Range(0, 99999);
        offsetY = Random.Range(0, 99999);

        Random.InitState(System.DateTime.Now.Millisecond);
        randomGradientVector2D = new Vector2[width, height];
        for (int i = 0; i < width; i++)
        {
            for (int j = 0; j < height; j++)
            {
                //randomGradientVector2D[i, j] = new Vector2(Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f));
                //print(randomGradientVector2D[i, j]);
                do
                {
                    randomGradientVector2D[i, j] = new Vector2(BetterRandom.betterRandom(-50000, 50000) / 100000f, BetterRandom.betterRandom(-50000, 50000) / 100000f);
                } while (randomGradientVector2D[i, j].x == 0 || randomGradientVector2D[i, j].y == 0 || randomGradientVector2D[i, j].x == randomGradientVector2D[i, j].y);
            }
        }

        do
        {
            randomVector = new Vector2(BetterRandom.betterRandom(-10000000, 10000000) / 100000f, BetterRandom.betterRandom(-10000000, 10000000) / 100000f);
        } while (randomVector.x == 0 || randomVector.y == 0 || randomVector.x == randomVector.y);
        randomSinMulti = BetterRandom.betterRandom(10000, 100000) + (BetterRandom.betterRandom(1000000, 10000000) / 10000000f);
        //randomSinMulti = 1;

        randomWarpStartCoords = new Vector2[20];
        for (int i = 0; i < 10; i++) // Generate random start coorinations for each warping
        {
            randomWarpStartCoords[i]      = new Vector2(BetterRandom.betterRandom(0, 1000) / 100f, BetterRandom.betterRandom(0, 1000) / 100f);
            randomWarpStartCoords[i + 10] = new Vector2(BetterRandom.betterRandom(0, 1000) / 100f, BetterRandom.betterRandom(0, 1000) / 100f);
        }

        terrain = GetComponent <Terrain>();      //for Terrain Data
        terrain.terrainData.heightmapResolution = width;
        terrain.terrainData.alphamapResolution  = width;
        terrain.terrainData.size = new Vector3(width, depth, height);

        map = new float[width, height]; // Storing the heightmap data (for the noise combination)
        if (useAlone)
        {
            terrain.terrainData = GenerateTerrain(terrain.terrainData);
        }
        else if (!useAlone)
        {
            terrain.terrainData = GenerateTerrain(terrain.terrainData);
            map = GenerateHeights(); // Storing the heightmap data (for the noise combination)
        }

        domainWarpingFBM = GetComponent <DomainWarpingFBM>();
    }
Ejemplo n.º 16
0
        public IHttpActionResult Post(OrderDTO orderDTO)
        {
            Order order = _mapper.Map <OrderDTO, Order>(orderDTO);

            order.Status     = Status.Started;
            order.CreateDate = DateTime.Now;
            BetterRandom random       = new BetterRandom();
            var          toppings     = _distributedPizzaDbContext.Toppings.ToList();
            var          orderManager = new OrderManager(toppings, random);

            order.OrderReferenceId = GetNextSeqAPI();
            //order.OrderReferenceId  = Guid.NewGuid().ToString();
            foreach (var pizza in order.Pizza)
            {
                int toppingsTogenerate = random.Next(1, 3);

                for (var x = 0; x < toppingsTogenerate; x++)
                {
                    int index   = random.Next(toppings.Count);
                    var topping = toppings[index];
                    pizza.Toppings.Add(topping);
                }
            }

            _distributedPizzaDbContext.Orders.Add(order);
            _distributedPizzaDbContext.SaveChanges();

            IStreamProcessingQueue queue;

            switch (order.QueueType)
            {
            case QueueType.Kafka:
                queue = new KafkaStreamProcessing();
                break;

            case QueueType.AmazonSQS:
                queue = new AmazonSQSProcessingQueue();
                break;

            default:
                queue = new KafkaStreamProcessing();
                break;
            }

            queue.QueueOrder(order);



            return(Ok(new OrderResponseDTO {
                OrderReferenceId = order.OrderReferenceId
            }));
        }
        public void GenerateRandomCustomer()
        {
            var             random          = new BetterRandom();
            var             customerManager = new CustomerManager(random);
            List <Customer> customers       = new List <Customer>();

            for (var x = 0; x < 9; x++)
            {
                var customer = customerManager.GetRandomCustomer(random.Next(0, 6));
                customers.Add(customer);
            }
            var count = customers.Count;
        }
        public void GenerateRandomOrder()
        {
            IKernel _Kernal = new StandardKernel();

            _Kernal.Load(Assembly.GetExecutingAssembly());
            IDistributedPizzaDbContext dbContext = _Kernal.Get <DistributedPizzaDbContext>();

            var          toppings     = dbContext.Toppings.ToList();
            BetterRandom random       = new BetterRandom();
            var          orderManager = new OrderManager(toppings, random);

            var order  = orderManager.GenerateRandomOrder();
            var order2 = orderManager.GenerateRandomOrder();
        }
Ejemplo n.º 19
0
 /// <summary>
 /// Set start point and exit point randomly
 /// </summary>
 private void SetRandomStartAndExit()
 {
     while (true)
     {
         startPointXcoord = BetterRandom.betterRandom(0, currentLevel.width - 1);
         startPointYcoord = BetterRandom.betterRandom(0, currentLevel.height - 1); //get a random start point
         exitPointXcoord  = BetterRandom.betterRandom(0, currentLevel.width - 1);
         exitPointYcoord  = BetterRandom.betterRandom(0, currentLevel.height - 1); //get a random exit point
         if (startPointXcoord != exitPointXcoord || startPointYcoord != exitPointYcoord)
         {
             break;//check if player was born at exit
         }
     }
 }
Ejemplo n.º 20
0
    public DNA(int size, Func <T> getRandomGene, Func <int, float> fitnessFunction, bool shouldInitGenes = true)
    {
        Genes = new T[size];
        this.getRandomGene   = getRandomGene;
        this.fitnessFunction = fitnessFunction;
        betterRandom         = new BetterRandom();

        if (shouldInitGenes)
        {
            for (int i = 0; i < Genes.Length; i++)
            {
                Genes[i] = getRandomGene();
            }
        }
    }
Ejemplo n.º 21
0
        private void SelectOffsetFromAnimationMode()
        {
            int index;

            if (AnimationMode == LightningBoltAnimationMode.None)
            {
                lineRenderer.material.mainTextureOffset = offsets[0];
                return;
            }
            else if (AnimationMode == LightningBoltAnimationMode.PingPong)
            {
                index = animationOffsetIndex;
                animationOffsetIndex += animationPingPongDirection;
                if (animationOffsetIndex >= offsets.Length)
                {
                    animationOffsetIndex       = offsets.Length - 2;
                    animationPingPongDirection = -1;
                }
                else if (animationOffsetIndex < 0)
                {
                    animationOffsetIndex       = 1;
                    animationPingPongDirection = 1;
                }
            }
            else if (AnimationMode == LightningBoltAnimationMode.Loop)
            {
                index = animationOffsetIndex++;
                if (animationOffsetIndex >= offsets.Length)
                {
                    animationOffsetIndex = 0;
                }
            }
            else
            {
                //index = RandomGenerator.Next(0, offsets.Length);
                index = BetterRandom.betterRandom(0, offsets.Length);
            }

            if (index >= 0 && index < offsets.Length)
            {
                lineRenderer.material.mainTextureOffset = offsets[index];
            }
            else
            {
                lineRenderer.material.mainTextureOffset = offsets[0];
            }
        }
Ejemplo n.º 22
0
 public void GeneticMutation()
 {
     for (int i = 0; i < basicLayer.GetLength(0); i++)
     {
         for (int j = 0; j < basicLayer.GetLength(1); j++)
         {
             if (BetterRandom.betterRandom(0, 100000000) / 100000000f <= SimulationManager.sMutationRate) // Mutate
             {
                 basicLayer[i, j] = BetterRandom.betterRandom(SimulationManager.sMinWeightValue * 10000, SimulationManager.sMaxWeightValue * 10000) / 10000f;
             }
             else if (simManager.genNum == 1) // If this is the first generation
             {
                 basicLayer[i, j] = BetterRandom.betterRandom(SimulationManager.sMinWeightValue * 10000, SimulationManager.sMaxWeightValue * 10000) / 10000f;
             }
         }
     }
 }
Ejemplo n.º 23
0
    public int[] SelectParents()
    {
        int[] parentIndexes = new int[2]; // Index in square array for parent A and B

        float totalFitness = 0;

        for (int i = 0; i < simManager.lastSquares.Length; i++) // Add up total fitness
        {
            totalFitness += simManager.lastSquares[i].fitnessScore;
        }

        // Select first parent
        float parent   = BetterRandom.betterRandom(0, Mathf.RoundToInt(totalFitness * 10000)) / 10000f;
        float selector = 0;

        for (int i = 0; i < simManager.lastSquares.Length; i++)
        {
            selector += simManager.lastSquares[i].fitnessScore;
            if (selector >= parent)
            {
                parentIndexes[0] = i;
                break;
            }
        }

        // Select second parent
        parentIndexes[1] = parentIndexes[0];
        while (parentIndexes[1] == parentIndexes[0])
        {
            parent   = BetterRandom.betterRandom(0, Mathf.RoundToInt(totalFitness * 10000)) / 10000f;
            selector = 0;

            for (int i = 0; i < simManager.lastSquares.Length; i++)
            {
                selector += simManager.lastSquares[i].fitnessScore;
                if (selector >= parent)
                {
                    parentIndexes[1] = i;
                    break;
                }
            }
        }

        return(parentIndexes);
    }
Ejemplo n.º 24
0
        public static double RandomInDiscrete(List <double> probabilities)
        {
            double r   = BetterRandom.NewRandom().NextDouble();
            double sum = 0.0;
            double result;

            for (int i = 0; i < probabilities.Count; i++)
            {
                sum += probabilities[i];
                if (sum >= r)
                {
                    result = i;
                    return(result);
                }
            }
            result = -1.0;
            return(result);
        }
Ejemplo n.º 25
0
    public void GenerateMap()
    {
        for (int f = 0; f < frequencies.Length; f++)
        {
            for (int c = 0; c < counts[f]; c++)
            {
                float phaseShift = BetterRandom.betterRandom(0, Mathf.RoundToInt(20000000 * Mathf.PI)) / 10000000f;
                int   centerI    = BetterRandom.betterRandom(0, actualTerrainSize - 1);
                int   centerJ    = BetterRandom.betterRandom(0, actualTerrainSize - 1);

                for (int i = 0; i < actualTerrainSize; i++)
                {
                    for (int j = 0; j < actualTerrainSize; j++)
                    {
                        map[i, j] += (Mathf.Sin(Mathf.Pow(Mathf.Pow(2 * Mathf.PI * frequencies[f] * (i - centerI) / actualTerrainSize + phaseShift, 2) +
                                                          Mathf.Pow(2 * Mathf.PI * frequencies[f] * (j - centerJ) / actualTerrainSize + phaseShift, 2), 0.5f)) * amplitudes[f]) / (float)counts[f];
                    }
                }
            }
        }

        for (int i = 0; i < frequencies.Length; i++) // Calculating the scale of the height map
        {
            heightScale += amplitudes[i];            // * counts[i];
        }

        for (int i = 0; i < actualTerrainSize; i++) // Normalize height map data to a scale of 1
        {
            for (int k = 0; k < actualTerrainSize; k++)
            {
                map[k, i] /= heightScale;
            }
        }

        for (int i = 0; i < actualTerrainSize; i++) // Convert negative value to positive
        {
            for (int k = 0; k < actualTerrainSize; k++)
            {
                map[k, i] = Mathf.Abs(map[k, i]);
            }
        }
    }
        public void CreateChild_Given2DifferentParents_ReturnsAChild()
        {
            var random       = new BetterRandom(1);
            var childFactory = new ChildFactory(new BiologyFactory(new Blender(random, 1, 2, 1), random));

            var fathersBiology = new Biology(Sex.Male, 81.0m, 182.88m, new Color(42, 42, 9), new Color(42, 42, 0),
                                             new Color(210, 210, 155), 180, 90, 80);

            var father = new Person(null, null, fathersBiology);

            var mothersBiology = new Biology(Sex.Female, 54m, 165m, new Color(230, 230, 90), new Color(5, 135, 60),
                                             new Color(210, 185, 120), 130, 150, 130);

            var mother = new Person(null, null, mothersBiology);

            var child = childFactory.CreateChild(father, mother);

            Assert.IsType <Person>(child);
            Assert.NotNull(child);
        }
Ejemplo n.º 27
0
    public GeneticAlgorithm(int populationSize, int dnaSize, Func <T> getRandomGene, Func <int, float> fitnessFunction,
                            int elitism, float mutationRate = 0.01f)
    {
        Generation           = 1;
        Elitism              = elitism;
        MutationRate         = mutationRate;
        Population           = new List <DNA <T> >(populationSize);
        newPopulation        = new List <DNA <T> >(populationSize);
        this.dnaSize         = dnaSize;
        this.getRandomGene   = getRandomGene;
        this.fitnessFunction = fitnessFunction;
        betterRandom         = new BetterRandom();

        BestGenes = new T[dnaSize];

        for (int i = 0; i < populationSize; i++)
        {
            Population.Add(new DNA <T>(dnaSize, getRandomGene, fitnessFunction, shouldInitGenes: true));
        }
    }
Ejemplo n.º 28
0
    public float[,] map;         // Storing the heightmap data (for the noise combination)

    public void Start()
    {
        offsetX = Random.Range(0, 99999);
        offsetY = Random.Range(0, 99999);

        do
        {
            randomVector2D = new Vector2(BetterRandom.betterRandom(-10000000, 10000000) / 100000f, BetterRandom.betterRandom(-10000000, 10000000) / 100000f);
        } while (randomVector2D.x == 0 || randomVector2D.y == 0 || randomVector2D.x == randomVector2D.y);

        randomSinMulti = BetterRandom.betterRandom(10000, 100000) + (BetterRandom.betterRandom(1000000, 10000000) / 10000000f);

        if (!useAlone)
        {
            map = new float[width, height];             // Storing the heightmap data (for the noise combination)
            map = GenerateHeights();                    // Storing the heightmap data (for the noise combination)

            Terrain terrain = GetComponent <Terrain>(); //for Terrain Data
            terrain.terrainData = GenerateTerrain(terrain.terrainData);
        }
    }
Ejemplo n.º 29
0
    public void IfMakeNewPlatform() // Should we make new platforms? (new random seed)
    {
        avgBestTime = 0;
        for (int i = 0; i < bestSquares.Length; i++) // Add up best fitness scores
        {
            avgBestTime += bestSquares[i].timeBeforeDrop;
        }
        avgBestTime /= (float)bestSquares.Length; // Take the average

        if (avgBestTime >= cycleDuration * 0.75f) // If the average fitness score is greater than some value then get new random seed
        {
            randomSeed = BetterRandom.betterRandom(0, Mathf.RoundToInt(Mathf.Infinity));
            Random.InitState(randomSeed);

            for (int i = 0; i < bestSquares.Length; i++) // Decrease every best squares' fitness score from the last platform layout
            {
                bestSquares[i].timeBeforeDrop = 0;
                bestSquares[i].fitnessScore  *= 0.8f;
            }
        }
    }
Ejemplo n.º 30
0
        ///  <summary>
        ///  Randomizes the list, be arbitrarily reordering
        ///  sublists of stride elements. As the stride approaches
        ///  the size of the list, the options become very
        ///  limited.
        ///  </summary>
        ///  <remarks>
        ///  This could take a while for very large list
        ///  sizes.
        ///  </remarks>

        public LSL_List llListRandomize(LSL_List src, int stride)
        {
            LSL_List result;
            BetterRandom rand = new BetterRandom();

            int   chunkk;
            int[] chunks;

            m_host.AddScriptLPS(1);

            if (stride <= 0)
            {
                stride = 1;
            }

            // Stride MUST be a factor of the list length
            // If not, then return the src list. This also
            // traps those cases where stride > length.

            if (src.Length != stride && src.Length % stride == 0)
            {
                chunkk = src.Length/stride;

                chunks = new int[chunkk];

                for (int i = 0; i < chunkk; i++)
                {
                    chunks[i] = i;
                }

                // Knuth shuffle the chunkk index
                for (int i = chunkk - 1; i > 0; i--)
                {
                    // Elect an unrandomized chunk to swap
                    int index = rand.Next(i + 1);

                    // and swap position with first unrandomized chunk
                    int tmp = chunks[i];
                    chunks[i] = chunks[index];
                    chunks[index] = tmp;
                }

                // Construct the randomized list

                result = new LSL_List();

                for (int i = 0; i < chunkk; i++)
                {
                    for (int j = 0; j < stride; j++)
                    {
                        result.Add(src.Data[chunks[i] * stride + j]);
                    }
                }
            }
            else {
                object[] array = new object[src.Length];
                Array.Copy(src.Data, 0, array, 0, src.Length);
                result = new LSL_List(array);
            }

            return result;
        }
Ejemplo n.º 31
0
        public static int RandomInUniform(int a)
        {
            Random r = BetterRandom.NewRandom();

            return((int)(r.NextDouble() * a));
        }