• create a track border
• create a track
• create track rewards
• remove the blit of the track border
• integrate scaling of images

• implement the physics and make appropriate changes to vector2d.py
• implement a default car class that uses the drifting functionality

FIXME

Create a visual using icons/drawings to show what arrow keys the driver is hitting

• build SensorBuilder class to generate sensors
• implement get_sensors()
• implement set_sensors() with the input being a list of angles (ints)

def __init__(self, depth, color=(0, 0, 0), width=2, pointer=True)

• ensure proper models are being saved out correctly
• ensure that models can be loaded properly

• add quick key to restart the simulation while incrementing the iteration count
• add a quick key to reward (positive/negative) the driver

Unimplemented feature: the simulation should keep track of whether or not the car has collided with the track. This should be checked by the car and the simulation should hold the information.

note: the vehicle class should keep track of how many times the entity has collided and the simulation should reset when this event has occurred.

Create a timed one time message that can pop up on the simulation to notify the observer (of the simulation) that an event has occurred (such as a reward collision).

Build a class that can manage the timed fade along with a simplistic post method to the simulation.

• Implement a heuristic for determining how well the model is doing
• Implement a method for determining whether or not the model is done
• Implement a test suite to manage simulations
• Implement a genetic simulation that can operate headless and then display progress

With the current implementation of the sensors, if the sensor overlaps two points of the map, the sensor will choose the furthest point.

• sensor should "observe" the closest point to the vehicle

After the simulator interface is 'fully functional', the readme should reflect all major changes and instructions for use.

As objects are changed throughout the main loop, only the objects that are changed should be rendered using the update() method as opposed to the flip() method.

Design/build a simulation that is customized for running batches of cars.

• create a genetic car class that will have a label to identify parents
• create GA simulation

• SensorBuilder class should contain an attribute holding how many sensors exist.
• Also ensure that SensorBuilder allows for multiple cars to access the same 'sensors' without concurrent issues

Add a label to the top of the simulation that displays the number of iterations that the simulation has been through.

Current implementation doesn't allow for AI to do nothing as an action.

Current state implementation:
0 - Turn Left
1 - Accelerate
2 - Turn Right
3 - Break

Change to:
0 - Turn Left
1 - Accelerate
2 - Turn Right
3 - Break
Default - Nothing

When displaying circles that represent an intersection with the track, the circles are placed (technically) in the wrong location.
Instead of being displayed by their upper left "placement point", they should be displayed by their center accounting for their radius.

The loading of the vehicle images should be optimized and user friendly. Currently the user of the framework is responsible for calling convert() on the images, this should be fixed.

• all 359 rotations should be loaded and cached when the simulation is started
• use cached images when turning vehicle

• create CNN using tensorflow
• create Deep QL

Add a property to the Simulation class that will allow the current simulation to quit if the car hasn't moved x distance within y amount of time.

This feature is needed for most machine learning algorithms such as Q-Learning or Genetic Algorithm.

Implement GitHub Workflow for automated deployment.

With the current state of the project convert() cannot be called until Simulation has been initialized. This is because convert() cannot be called until pygame.init() has been called.

• create a more user friendly solution to this problem

got below error while trying to run example.py
from keras.optimizer_v2.adam import Adam
ModuleNotFoundError: No module named 'keras.optimizer_v2'

installed keras version
Name: keras
Version: 2.10.0
Summary: Deep learning for humans.
Home-page: https://keras.io/
Author: Keras team
Author-email: [email protected]
License: Apache 2.0
Location: /Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages
Requires:
Required-by: tensorflow

The vehicle class should check to see if it has collided with a reward.

• the car should keep track of whether this is a first time collision or not
• the simulation should know about the collision

Allow for the following logging levels/types:

1. Debug:

• Any information

2. Trace:

• Important processing information

3. Error:

• System encounters a non-crashing problem that should be fixed

4. Fatal:

• System encounters a crashing problem that must be resolved

Lower levels log anything (including itself) higher that itself. (e.g. if debug mode is set, all 4 levels are displayed, whereas if Error is set then only Errors and Fatal messages will appear in the logs).

The current calculated FPS shouldn't be displayed every frame. Instead a custom component should be created that only refreshes once per second using the calculated fps.

Fix description:

Masks take up a lot of time to generate, so cache all the possible masks and place them in the correct location.

Implement sensor feature

• If no collision occurs, a default value should be set as the value of the sensor
• If a collision does occur, the two coordinate pairs (for the sensor display) should be the car position (with offset) and the collision point

• Create the border, rewards and track-bg for multiple tracks for testing

As the vehicle moves throughout the track, print tire tracks that follow the cars path and fade over time.

The current implementation has all inputs being normalized simultaneously. Research normalization techniques to improve performance.

• odometer vs. training iteration
• speed vs. time
• number of restarts required
• number of rewards hit
• average speed
• average distance
• model convergence
• model loss