/*
  * since the training is in a couroutine I found that the best way to replicate the
  * results were to put this in one as well
  */
 private IEnumerator PlayAI()
 {
     while (!isDead)
     {
         //NeuralOutput contains all sort of information but it's mainly ment for getting the output (jump or not)
         NeuralOutput nO = Call();
         TryJump(nO.output[0]);
         yield return(null);
     }
 }
    private void Update()
    {
        if (isDead)
        {
            return;
        }
        //training

        if (Input.GetButtonDown("Escape"))
        {
            //this is because of my network, I can't easily disable training yet
            SceneManager.LoadScene("FlappyMenu", LoadSceneMode.Single);
            return;
        }

        if (_PlayType == PlayType.AITraining)
        {
            if (Input.GetButtonDown("Jump")) //saving
            {
                Save(saveData);
                Debug.Log("Saved!");
            }

            nO = Call();
            generationData.text = "Generation " + //updating UI information when training
                                  nO.generation + " " +
                                  (int)nO.progression + "%";
            if (nO.currentlyTrainedNetworkIndex == 0)
            {
                generationData.text += " (Best of generation)";
            }

            Train(); //enable continuation of the training
        }

        //player input
        if (_PlayType == PlayType.Player)
        {
            if (Input.GetButtonDown("Jump"))
            {
                TryJump(1);
            }
        }
    }
Beispiel #3
0
    private void Update()
    {
        NeuralOutput nO = Call();

        if (train)
        {
            Train();
            if (lastGen < nO.generation)
            {
                Save(saveData);
                lastGen++;
                print("Generation score: " + nO.network.score);
            }
        }
        else if (updateTurns < maxTurns)
        {
            updateTurns++;
            Move(nO.output);
            visitedPoints.Add(new Vector2(xPos, yPos));
        }
    }
Beispiel #4
0
    private void Update()
    {
        if (train)
        {
            Train();
        }
        NeuralOutput nO = Call();

        if (train)
        {
            if (oldGeneration < nO.generation)
            {
                print("Generation: " + nO.generation + ", score: " + nO.network.score + "/" + maxScore);
                oldGeneration++;
                Reset(transform);
                Save(saveData);
                return;
            }
        }
        Move(nO.output, transform);
    }
        public Creature Live(ICollection <Food> foodSupply)
        {
            if (IsDeath())
            {
                GetComponent <SpriteRenderer>().enabled = false;
                return(this);
            }

            Life -= LifeCost * Time.deltaTime;

            if (IsDeath())
            {
                Fitness -= 10;
            }

            var closestFood = GetClosestFood(foodSupply);

            // could be that food supply is empty or out of reach
            if (closestFood == null)
            {
//                Debug.Log("no food found o.O");
                return(this);
            }

            if (transform.position.Distance(closestFood) < 0.3)
            {
                Life    += 50;
                Fitness += 10;
                closestFood.SpawnIn(Bounds);
            }

            Input.Values = new double[4];

            var leftSensor  = transform.position.ExtendedPoint(Angle - 45 + 90, .5f);
            var rightSensor = transform.position.ExtendedPoint(Angle + 45 + 90, .5f);

            if (ShowAntenna)
            {
                Debug.DrawLine(transform.position, leftSensor, Color.blue);
                Debug.DrawLine(transform.position, rightSensor, Color.red);
            }

            var closestFoodLeft  = leftSensor.Distance(closestFood);
            var closestFoodRight = rightSensor.Distance(closestFood);

            if (closestFoodLeft > closestFoodRight)
            {
                Input.Values[0] = closestFoodLeft;
                Input.Values[1] = -closestFoodRight;
            }
            else
            {
                Input.Values[0] = -closestFoodLeft;
                Input.Values[1] = closestFoodRight;
            }

            Input.Values[0] /= Bounds.extents.x;
            Input.Values[1] /= Bounds.extents.y;

            Output = Brain.Think(Input);

            var angle = (float)Output.Values[0];

//            Angle += angle*2
            if (angle <= 0.5)
            {
                Angle -= (1 - angle) * 2;
                if (ShowBrainSuggestions)
                {
                    Debug.DrawLine(transform.position, leftSensor, Color.blue);
                }
            }
            else
            {
                Angle += angle * 2;
                if (ShowBrainSuggestions)
                {
                    Debug.DrawLine(transform.position, rightSensor, Color.red);
                }
            }

            if (Output.Values[0] > Output.Values[1])
            {
                Angle -= (float)Output.Values[0];
                if (ShowBrainSuggestions)
                {
                    Debug.DrawLine(transform.position, leftSensor, Color.blue);
                }
            }
            else
            {
                Angle += (float)Output.Values[1];
                if (ShowBrainSuggestions)
                {
                    Debug.DrawLine(transform.position, rightSensor, Color.red);
                }
            }

            // rotate
            transform.rotation = Quaternion.Euler(new Vector3(0, 0, Angle));

            // draw speed
            var speed = (float)Math.Abs(Output.Values[1]) * 5 * Time.deltaTime;

            if (ShowBrainSuggestions)
            {
                var start = transform.position;
                var end   = start.ExtendedPoint(Angle + 90, speed * 10f);
                Debug.DrawLine(start, end, Color.black);
            }

            // move
            previousSpeed       = speed;
            transform.position += transform.up * (speed);

            return(this);
        }