== Vision ==
* Detect grabbed balls to know whether to chase (forward + turn) or block (strafe) to chase ball.
* New Kernel Classifier.
* Spectator feed as visual Objects.
* Vision calibration
* Basic colour.
* Ring & linear shift.
* Sanity checks.
* Subsampling (like Germans).
* Blob search (around subsampled features)?
* Active field line localisation.
* Game with no beacons.
* Topleft/centre based image coordinate offsets (share/Common.h). (FIXME).
== Behaviour ==
* Kick off strategy.
* Update the ball out position using a hint of some kind.
* Ryan's Goalie needs to clear.
* Use head IR for dodgy dog on approach to ball (as well as dodge once we have the ball)?
* Obstacles.
* After green backoff we should spin and localise.
* Gather data for approach ball.
* Gradually ramp down speed during grab corrections.
* Lining up on goal is screwed up, shooting NOT at the goal!
* Get out of way dodges with the attacker blocking him off. Make sure that they dodge different way.
* Get back into position when defender may use sidestepping and not backstepping, too slow.
* Use side-stepping to get on line between goal and ball, then use backstepping.
* Set play defense is broken, middle robot should stay back.
* Offset defender and Goal Keeper so that they are not in line.
* Edge and corner behaviours!
* Goal/beacon obstacle avoidance (particularly goalie).
* UTS (or better) kicks/grabs.
* Grab/turn/shoot.
* Goal shooting.
* Position behind ball fast.
* Find Ball
* Get behind switching into avoid own goal is very slow.
* Changing spin directions for no reason.
* Go into spin too quickly, we need to scan first, IR sensor in grab doesn’t reset last ball seen counter?
* When the ball is close and we spin and find it its broken, fishtailing lots.
* fishtailing, switching from get behind to velocity based get behind, smooth the transition.
* Striker is broken after get out of the way, looks/turns away from the ball.
* Kick Selection
* Copy the Newcastle straight kick.
* Put the ball near the goal box with a soft kick rather than dribbling.
* Dodging/dribbling has problems, do it for no reason and sometimes in wrong direction, calibrate IR properly?
* More than calibrating the IR, we decided we should be much more careful about when we grab-dribble. We should walk at the ball, and then:
* If we’re lined up for a kick, and no obstacles, then kick.
* Otherwise grab.
* Once grabbed, then turn, dodge and kick (possibly softly - not always on goal).
* If we’ve close enough to kick (and we haven’t already kicked because we’re not well enough lined up) and have been trying to grab for a while but the ball is still just out of reach, then we’re probably hooked on someone. In that case try kicking from where we are.
* We should pretty much remove the forward dribble and grab-dribble.
* Head kick should be more reliable and variable strength.
* Double kicking, upenn kick at the wrong time, etc etc.
== Locomotion ==
* Walking Faster.
* Fix n-gon locus.
* Stuttering when forward is combined with left.
* Move to an intantaneous centre of motion model of movement.
* Use lower PG walk in already placed defender/striker to lower current drain?
* New turning stuff.
== GPS ==
* Goal box lines misslocalising the grabbed attacker?
* Turn up ball friction and/or observation variance when you have high head motion and/or turnccw?
* Turn visual confidence into weight not variance.
* Block should stop ball.
* Gather data for curvy ball modelling.
* Handle ball-out signal.
* Weight generated symmetries by match value.
* Monte carlo.
* Check localisation while grabbing.
* Fix the way grabs and kicks are handled.
* Using GPS for Odometry Calibration.
* Calculate the ball position and velocity for the next N frames forward, and allow access to it in python. We should do this because it is useful to have in alot of places in python, but faster to calculate it in C.
== Challenges ==
* Passing Challenge.
* Penalty Shooter/New goal challenge.
* Open Challenge.
* 11x11 game.
== Tools ==
* Master log file format.
* Policy visualisation.
* World model with history snail trails.
* C++ CPlaneDisplay needs to parse its own log files.
* Port more development tools to Python/C++.
== Others (and yet to be categorised) ==
* Obstacle / Opponent detection
* Near (done?) (for dodging)
* Far (for knowing open regions on field)
* Passing
* Dodging / Blocking
* Learning
* Python / Behaviours
* Policy Gradient
* Kicks
* Grab
* Walk in a diagonal instead of straight for maximise speed.
* Can we use compiled python on the dogs? Eric uses compiled python for the simulator, possible to use on the dogs?
* When possible, instead of pointing the head straight at the ball, turn it so that the ball is still visible (but might be off centre), but also any possible beacons/goals are also visible.
* Dog discovery protocol.
* Move cross-platform/language constants to one file and have makefile auto-generate language dependent files.
== Done ==
* Use the chest IR for stuck detection
* Position selection in pReady
* Find Ball
* Looking/Spinning to the right after a release
* Role Assignment
* Bunching
* Fix attacker bonus after a kick in role switching and try generally lowering the attacker bonus
* Role assignment allow multiple attackers if they are heading at the ball from different angles, upfield/downfield
* Allow the defender to run in if it is close to being the attacker as long as the attacker hasn’t actually grabbed the ball
* Get back into position faster if youre upfield, not enough defense
* Move the defender back some
* Switching roles causes dog to look away
* Defender and striker should drop out of bird if the ball is close
* A possible bug in offvision, doesn't see beacon, but can localise itself properly
* Ball distance observation using point projection of ball centre (DID NOT WORK)
* Block fast moving balls like the goalie does, but use it on pForward as well