ocadotechnology/aimmo

A python-based multi-player online educational game for students to play in a class or club setting.

Kurono (codename: aimmo)

LICENCE

In accordance with the Terms of Use of the Code for Life website, all copyright, trademarks, and other intellectual property rights in and relating to Code for Life (including all content of the Code for Life website, the Rapid Router application, the Kurono application, related software (including any drawn and/or animated avatars, whether or not such avatars have any modifications) and any other games, applications or any other content that we make available from time to time) are owned by Ocado Innovation Limited.

The source code of the Code for Life portal, the Rapid Router application and the Kurono/aimmo application are licensed under the GNU Affero General Public License. All other assets including images, logos, sounds etc., are not covered by this licence and no-one may copy, modify, distribute, show in public or create any derivative work from these assets.

Kurono

Code for Life has been developed by Ocado Technology as a free, open-source project to inspire the next generation of computer scientists and to help teachers deliver the computing curriculum.

Kurono is a Code for Life project, aimed at teaching students and keen adults programming with Python. The game is designed to be played in a class or a group setting, as it simulates a multiplayer online game.

We are open to contributors from anywhere around the world. Please read ahead if you'd like to get involved.

To get started

• Developer Guide

• Good First Issues

• Setting up your work environment: common setup and aimmo specific setup

• Testing

aimmo's Issues

Implement registration / login

Selected tab in the top bar

Regardless of which tab is selected in the top bar, 'Program' tab seems to be the only one that ever is visibly selected.

Ensure generate_map has at least one habitable cell on at least one edge

And don't break graph connectivity. This is required for #23 in order to make sure resizing map actually increases habitable area.

Make scoring blocks actually cause players to gain score

Switch 'code' field back to Avatar model from Player model

To support versioning functionality e.g. undo/redo. Also, implement undo/redo.

Consider changing GameStateProvider to snapshot rather than lock

There are pros and cons in terms of efficiency and functionality

Improve handling of code submission responses

Use http status codes to denote success and failure for code submission and change the returned data to be in some form of data structure (probably json) rather than checking whether string.slice(0, prefix.length) == prefix.

Add key to avatars

Show nick for each avatar

Make it work in Kubernetes

Add projection cost to shortest path between and use priority queue for branches

To make it scale to vast maps

• Implement priority queue
• Implement A*
• Check for bisection by checking that all neighbours of a newly added obstacle cell can reach each other (implementable by checking that one neighbour is reachable by all neighbours). This should greatly improve locality.

Split the game (the simulation) and the workers (the sandbox running the players' code)

After splitting, the two components/systems should communicate via HTTP APIs. Entities that need to be serializable/deserializable between the two components are:

1. Actions
2. the world state communicated to players (or at least the player's view of the world).

Worker should have two implementations, one that spawns a sandbox, and one that runs locally (for development purposes).

Ensure all cells that an avatar can_move_to are connected

I.e. no areas of the map are cut off from others. In world_map.generate_map.

Simulate the environment

dependant on #1 #2 #3

Rename 'api_watch.py' to something more djangoey or merge with views.py

Move all views that just render a template over to using django generic views

Fog of War

Don't send the entire map to the workers, have a configurable distance limit.
Open question: Manhattan distance, or rectangle?

Design some game mechanics

Dependant on #1 and #2.

Implement Tutorial

Probably with lots of popup help, and a cut down world (or several) with just the one avatar in it, before letting the user go through to the main world. This would also help deter people from signing up with loads of accounts, so it should be lengthy and useful the first time around, but arduous the second.

Possibly worth waiting for the game to get more nailed down first, as the tutorial may have to change a lot otherwise?

Confirmation of code saving

When you submit your program for the avatar, you are never really sure whether you succeeded, it takes long time to load or you lost connection halfway through.
Some popup or a change of state that would notify of successful submission (or otherwise) would be nice.

Warning about missing logging handlers

The following warning is emitted by example_project/manage.py (which is executed by ./run):

No handlers could be found for logger "django_autoconfig.environment_settings.autoconfig"

Once this is fixed, a logged error message is revealed:

WARNING:django_autoconfig.environment_settings.autoconfig:Unable to parse setting SETTINGS_MODULE=example_project.settings (malformed string)

Fix warning about deprecation of TEMPLATE_DEBUG

When starting aimmo locally the following message is displayed:

WARNINGS:
?: (1_8.W001) The standalone TEMPLATE_* settings were deprecated in Django 1.8 and the TEMPLATES dictionary takes precedence. You must put the values of the following settings into your default TEMPLATES dict: TEMPLATE_DEBUG.

The value in question is in aimmo/example_project/example_project/settings.py:
TEMPLATE_DEBUG = DEBUG

The TEMPLATES dictionary maybe the one here aimmo/players/autoconfig.py (?):

'TEMPLATES': [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                ]
            }
        }
    ],

Switch to always deal in fixed coord space rather than floating origin

As it will likely be easier for players to work with. Look in WorldMap.get_world_view_centred_at.

Change the way the UI receives game updates

The UI currently polls the frontend server constantly for updates.

Implement a solution where the game simulation server pushes updates instead - e.g. using web sockets (or some other better solution that you can think of!)

Possible server-side solutions:

1. client ==> proxy (on Kubernetes) ==> game simulation (on Kubernetes)
   Here we only need one public IP address for the proxy, no matter how many game simulation servers we spawn.
2. client ==> game simulation (on Kubernetes)
   We need a public IP address per game simulation. We need to investigate whether this would be a problem (e.g. can't be done dynamically, or is expensive).

Update avatar_examples for new api

Implement avatar code submission

Add an `aimmo-game` implementation that spawns workers locally

i.e. replace the current method of speculatively starting 4 workers.
Some work here: jishi9@9c86291

Add concept of a player's avatar

dependent on #1 #2 #3 #4

Choose a game genre

Candidates include:

• Strategy - where you automate your base / city's expansion, development, resource harvesting.
• Trading - where you automate a single avatar, with the aim of efficiently travelling between good places to buy and sell.
• RPG - where you automate a single avatar to react to their environment in terms of combat, and seek out the completion of goals.
• Some combination of the above.
• And many more...

Submitting empty code leads to server error

When sending empty program, we are getting:

Traceback:
File "/Library/Python/2.7/site-packages/django/core/handlers/base.py" in get_response

1.                 response = wrapped_callback(request, _callback_args, *_callback_kwargs)
   

   File "/Library/Python/2.7/site-packages/django/contrib/auth/decorators.py" in _wrapped_view

2.             return view_func(request, _args, *_kwargs)
   

   File "/Users/paulina.koch/Documents/C4L/forks/aimmo/ui/players/views.py" in code

3.         world.player_changed_code(request.user.id, request.user.player.code)
   

   File "/Users/paulina.koch/Documents/C4L/forks/aimmo/simulation/game_state.py" in player_changed_code

4.         avatar.set_code(code)
   

   File "/Users/paulina.koch/Documents/C4L/forks/aimmo/simulation/avatar/avatar_wrapper.py" in set_code

5.     self.avatar = Avatar()
   

Exception Type: TypeError at /api/code/
Exception Value: 'NoneType' object is not callable

Simple check should be enough, but we could use it as a chance to implement an extension of validation or error handling/printing when submitting code.

Expose sub-set of game state to player's avatar

dependent on #5

Dynamically resize world based on number of avatars

When a new avatar is started, or when a player has been inactive for a while a is removed.

Investigate changing 'row' and 'col' in Direction and Location to 'x' and 'y'

Because it is more intuitive to use.

Implement creation of sandboxed python environment to run avatar code

When player registers or updates their avatar code.

Example code to show how to access world objects

Was thinking we could have code showing how to do things like check if cell is obstacle, check other player locations and get score square and pick up locations.
On the program page

Implement a proxy in Kubernetes

Premises:

• We want the UI to pull updates over a well known port, so it gets through firewalls
• We can't afford to have a large number of public IPs (and google probably won't let us)
  Thus, we need a proxy that can run on a limited set of public IPs, that the UI talks to, and it can connect to the private IPs inside the cluster

Add an `aimmo-game implementation` that spawns workers using kubernetes

Choose a game theme

Choice might depend on #1.

Candidates include:

• Space / Sci-Fi
• Fantasy
• Something "Ocado"
  • Supply chain
  • Vehicle routing
  • Warehousing
• Any many more...

Make "power-ups" be applied to Avatars that step on them

Depends on #26

Cope with negative coords

This will currently break WorldMap.can_move_to, but possibly more.

Move get_avatars_at to AvatarManager

Currently in WorldState.

Find the TODOs I added as part of the code review on Wed and turn them into issues

TODOs can be found in 59ce4b8

Add avatar actions

dependent on #5

Add ability for user to choose nick, fill color and stroke color

The nick may need to be moderated by admin to prevent inappropriate content?

Warning about changing default value of 'RedirectView.permanent'

The following warning is displayed when running aimmo locally:

$HOME/.virtualenvs/aimmo/lib/python2.7/site-packages/django_autoconfig/autoconfig.py:205: RemovedInDjango19Warning: Default value of 'RedirectView.permanent' will change from True to False in Django 1.9. Set an explicit value to silence this warning.
url(r'^$', RedirectView.as_view(pattern_name=index_view)),

Looking at this github issue and the referenced commit which fixes this, it seems that we need to add url(r'^$', RedirectView.as_view(pattern_name=index_view)) or similar to aimmo/players/urls.py.

Make "power-ups" randomly appear and disappear

Similar to how scoring cells should in #25

• Probably start with a "health" pickup
• Then an attack damage power up designed to last a number of turns
• Then an invulnerability power up designed to last a number of turns

Make scoring blocks randomly appear

Amount of scoring blocks should be based on number of players. Place randomly. Maybe try to avoid it starting too close to players? Decide on when to remove them. After a random amount of turns? After a player has accrued a certain amount of score from it?

Also remove the scoring blocks from the initial map generation.

Errors when going to 'Watch' without 'Start Game' before

Results in lots of errors, or rather repeated one error, when you click on 'Watch' before first starting the game by pressing 'Start Game'.
Probably also needs explaining.

Add view of game for players to watch their avatars

Investigte switch from numpy to 2d lists for map

To avoid making players have to know numpy, and to avoid devs having to install it (painful on windows)

Randomly generate world