Todos

[Dpbm]

Still to do

• fix size_t usage

• understand better the genetic algorithm

• change all the machine components to the "Machine" namespace

• reduce the fitness for those who tried to change the direction in the same axis

• add a food object inside each individual

• improve fitness

• improve selection method

• add a board class

• add a way to load the weights into the nn

• add nn arch to the .wg file

• add a pre-processor to build or not some test parts

• test feedforward

• improve performance

• test random functions

• check if all the players in the next_gen are all the same

• add a screen to let the ai play

• join together namespaces of the same context

• add a key to go back to start screen in ai screen

• Population

  • test select_parents

• AiPlayer

  • setup board usage
  • test constructor passing Chromosome as parameter

• board

  • add tests

• player

  • add tests

• player screen

  • add a reset game function
  • update score text
  • add a win screen

• Helpers

  • add tests
  • test get_angle
  • parse nn arch

• Game

  • add tests
  • abstract to an ai agent class
  • add screen to load ai weights
  • make crossover
  • create punishments and rewards
  • run multiple individuals at the same time
  • add a way to choose between genetic and q learning algorithm
  • add angle with the apple
  • add a way to check when the individual reached the max length (food quantity)
  • add the total of players who got all of the food
  • add new generation

• Weights

  • read from files
  • add test to get_total_weights

• Refactor

  • verify heap-stack usage
  • check the use of constants
  • check the use of references
  • use delete[] when necessary
  • use size_t
  • use uint and int with fixed sizes
  • check memory leaks with valgrind
  • clear the top classes attributes from .cpp files
  • abstract some SDL stuff to functions

• NN

  • load weights
  • add bias (if necessary)
  • test feedforward
  • QLearning

• Chromosome

  • test copy_genes
  • test slice

• Extras

  • use quantum machine learning

    • maybe, put all the board in superposition and the collapse the state, which the square that makes her get close to the food has the biggest probability
    • add constraint to if he dies colliding with either the wall or itself
    • create a python test

  • docker hub

  • docker image

  • docker compose template

  • update readme.md

    • add more images
    • add more details
    • add more about the technologies and how to use it
    • add credits to the font creator

Old todos

• Helpers

  • map weights to genes vector
  • create vector2

• Activations

  • add tests

• Food

  • put it on the stack
  • make a way to set the position

• Layers

  • test is_input and related
  • test set_values
    • test setting values
    • test if the pointer to the values is different from the set before
    • check if statement
  • add a different alias for Layers template matrix

• Game

  • Tail collision
  • set max score
  • add a screen to select better play and AI
  • add fonts
  • fix memory usage
  • show the player's score on screen
    • add for player screen
    • add for ai screen
  • check for SDL errors
  • add screens
    • debug screen
    • add screen for player
    • add screen for ai
      • add sensors
      • add sensors visualization
      • add random direction
      • set the nn to play
      • set up chromosomes
      • reset game for ai agent
      • add spurs to the ai agent using the chromosome points, with which if it's not any better, it gets a higher mutation rate
      • update the score after reset
      • crete a chromosomes array (population)
      • create a individuals score array
      • make epochs
      • update best_individual
      • add best pontuation (update it too)
      • create better sensors
      • understand what data should I pass to it
      • shrink the playable area
      • separate with a line the playable area to the info area
        • check if the left side is enough
      • show the best individual on the left side
      • add a text displaying what generation and individual is that
        • rerender at every change of individual
        • rerender at every change of generation
        • fix an apple position then run the population onto that food position. After everyone has played, get the best, mutate and start again with a new position

• Weights

  • add tests
  • add append to a file
  • ensure that there's a way to add Genes constructor
  • add a different alias for weights template matrix
  • test if genes are in fact random

• Genes

  • change gene values to int
  • update values to double or float
  • add tests
  • test new operators
  • check if the values are not always the same

• Refactor

  • add #pragma once
  • check destructors
  • add using at the top of the files
  • use new SDL_Rect{x, y, w, h}; instead of assign each value individualy
  • extract WIDTH - PLAY_WIDTH to a constant

• NN

  • add neural network
  • feedforward
  • activation functions
  • export weights
  • add a straightforward way to add genes as weights on the network building step add_layer()
  • save weights -> check file creation
  • save weights -> check no file for no and one layer
  • get weight -> check if statement
  • get weight -> check ideal path
  • test if input layers are input or not

• Chromossome

  • set genes as pointers
  • add deconstructor
  • add tests
    • test slice and crossover both with the same and different chromosomes
  • fix genes pointers to delete
  • check stack-heap
  • change it to weight values
  • Change set_genes to another constructor
  • check if the values are not always the same
  • test add_genes and reset_genes
  • remove add_genes and reset_genes
  • remove crossover and slice
  • remove score

• Population [x]

  • set individuals as pointers
  • erase individuals based on their points
  • add deconstructor
    • clear pointers
  • add tests
  • add get highest score
    • test only negative values
    • test mix of values
    • test negatives with zeros
    • test only positive values
  • declare individuals using new []
  • understand why the values are always the same
  • remove it

• Player

  • try to free the memory

• Matrix

  • scalar multiplication
  • add throw error in get_position_value
  • dot product
  • destructor
  • overload the = operator
  • add test to dot product error
  • add test to ones and map_to_a_single_value
  • update matrix multiplication to return Matrix*
  • add genes as values (or as a accepted type)
  • clear the genes from memory
  • add templates
  • add tests for generics
    • update_value
    • get_position_value
    • transpose
  • clear the alias templates
    • add alias for just numbers (for operators like matrix multiplication and scalar multiplication)
    • use a generic type for the rest
    • update MatrixRandomTemplate usage
    • check Layers and Weights constructors
    • fix random for Gene
    • check if it's user is able to create a Matrix<double> and Matrix<Gene> but not Matrix<int> and others
    • check if the inside values are in fact Genes or double
    • Test Gene version
    • check if in fact, Matrix<Gene> is in the heap
  • remove transpose
  • delete pointers from get_column and get_row
  • #4

• Extras

  • add the machine folder to the readme file
  • fix workflows
    • remove old includes from manual_tests.cpp
    • install SDL2_ttf
    • add a script to ensure tests on ci
    • add script to install ubuntu dependencies

[Dpbm]

C++ Parts to test

• Game

  • board
  • Players
    • Player
    • AIPlayer
    • QuboPlayer

• Genetic

  • Chromosome
  • Gene
  • Population

• Helpers

  • Exceptions
  • Utils

• Machine

  • Activations
  • Layer
  • Machine
  • Weights

• Matrix

  • Matrix

• Qubo

Python Parts to test

• Elements

  • board
  • food
  • player
  • position

• qubo