Create a screenshot of the client in README.md to get people to understand that there is a useful interface.

Depends of #26

Replace empty interface with engine's Object

Create a lightweight dot serialization.

Use bit operations to serialize a dot instead of a representation of a dot as an array json.

[x,y] // now
zzz // want

MarshalJSON:

uint16(d.X)<<8 | uint16(d.Y)

Collect metrics on games' rate to understand how many messages are generated in each game

There is a broadcast message type in websocket connection to send every player in a game a message.

Now it is possible to send a lot of small broadcasts to the game without any delay and so make a lot of spam and ddos the game server.

The task is to make a delay to prevent such a ddos attack via game websocket.
And of cause, create a cli flag to pass a value for the delay.

Rename PlaygroundCMap's files:

• playground/playground.go into playground/playground_cmap.go
• playground/playground_test.go into playground/playground_cmap_test.go

ExperimentalPlayground is designed to receive *engine.Object and pass it through to engine.Map. *engine.Object contains an actual game object. Therefore, there is a necessity to manage *engine.Object somewhere on the layers above ExperimentalPlayground which turned out to be a quite complicated and awkward situation.

Rewrite ExperimentalPlayground to manage *engine.Object inside of ExperimentalPlayground:

1. Rename *engine.Object to *engine.Container with regards to the purpose it serves
2. Define engine.Object interface as an empty interface interface{}
3. Make all methods of ExperimentalPlayground receive actual game objects engine.Object and wrap them into engine.Container before passing to engine.Map
4. Store the mapping of game objects and their containers in ExperimentalPlayground: map[engine.Object]*engine.Container
5. Add sync.RWMutex to regulate access to the map
6. Rewrite tests for ExperimentalPlayground and add some if necessary
7. Conduct a benchmark test to estimate the gains and loses of the new solution
8. Add comments to ExperimentalPlayground
9. Accept empty locations as valid when registering objects

Now there are object identification using GUID strings. Identifiers are encoded to JSON as 36 byte
strings but perhaps identifiers could be more lightweight.

Use instead GUID identifiers some another way to identify objects.

For example integers could be more convenient.

// 8 byte identifier
objectID64 := rand.Int63()
// 4 byte identifier
objectID32 := rand.Int31()

Or short (<=10 bytes) strings could be used. But it would be better use integers because:

objectIDstr = "id" // 16 bit + string

Now WS upgrader uses error handler by default. In case of failure of upgrading of a connection, default error handler will write a status code and log error message and then HTTP handler will try to rewrite status and write new error message. It is necessary to redeclare error handler for upgrader in order to aviod such a messy error processing.

In Dockerfile use scratch as a base image

Update Go version from 1.12 up to 1.14

Also

• Delete unnecessary -mod vendor
• Delete setting of var GO111MODULE=1

Now the server object and routes are initialized in the main function and handlers are defined in the handlers module, which also contains some general business logic.

This scheme is good if there is a small server. However, the Snake-Server has become bigger and now such a scheme of the project is messy.

Refactor and redeclare HTTP handlers and server as following structure:

core/                                                        business logic

(may be)

server/core                                               business logic

server/
server/http/
server/http/utils/                                          WriteResponseJSON here
server/http/handlers/
server/http/handlers/{handler_name}
server/http/middlewares/

Prometheus metrics handler is going to be started on a special separated port which will be only for metrics and controlled by a CLI flag.

The HTTP client's handler is going to be moved from the client/ module to server/http/handlers/.

Find a new http framework which will be better then the current.

Helper:

• WriteResponseJSON(w http.ResponseWriter, statusCode int, response json.Marshaler) error
• bytes writer?

In Benchmark_Playground_UpdateObject add ReportAllocs

Rewrite comments and names if it's necessary to clarify the function of an interface

Now a set of useful middlewares are used only by API handlers. It is necessary to expand using them for all handlers.

Create a version slug in API URL path: /api/v1/...

Migrating to Go Modules:

• Rewrite Dockerfile, Makefile, .travis.yml: create flags if necessary
• Ensure that all the dependencies have been committed correclty

Create mouse object.

Mouse have got one dot and a direction. It must walk around the game map by the random manner.

Mouse would be a food for snakes.

Some example.

{
  "type": "mouse",
  "id": 22,
  "dot": [3, 2],
  "dir": "north"
}

Update embedded JS client up version v1.1.1

Add interface Playground and use it in World structure

Employ new configuration module instead of old flag parsing in main.go

Add metric logging to ConnectionGroupManager to have information about server and games.

Metrics to gather:

• a server's capacity
• games
• players_number

Add tools.go where all tools deps are to be listed

Add tools to the list:

• go-bindata-assetfs
• go-bindata

Commit vendors if it's necessary

Refactor observers: split all the observers for independent modules

Create flag EnableWalls for game creation

With the scratch base image it is unnecessary to have IMAGE_ALPINE variable in Makefile and Dockerfile. Delete the variable

Create benchmarks invocation to CI

• Create Makefile target
• Update .travis.yml

Add openapi.yaml in server routing to make it available for swagger clients

Rewrite README:

• Fix spelling
• Rewrite some topics

Add vendor directory to ignore files:

• .gitignore
• .dockerignore

Tests:

• Add test case for DotMask.Copy when some rows of the table are longer than limit
• Add test for DotMask.TurnRandom with predefined seeds

Target method combination: MSet and MRemove

Rename playground's Playground to PlaygroundCMap

Create embedded lightweight JavaScript client. Compile it into the source code of the server and bind to a URL path using go-bindata-assetfs.

Use Vue.js

Rect.Dot returns invalid dots

Add cli flag to allow or forbid CORS manually --forbid-cors

In playground use struct containing a field of type [][]*unsafe.Pointer

Use atomic compare and swap instead of locks which are used in concurrent map.

Create a flag to set up maximum possible player count in a game to restrict the settings on game creation.

Delete useless tests directory

Tasks to be implemented or thought

Ideas

• Create a core layer to invoke methods from API handlers.
• Create handler with server limits.
• Create a queue of the commands to the snake.
  Create queue in Snake object:

  commandQueue chan snake.Command

  Collect and implement commands:

  ["north", "east", "north", "north", "north", "east"]

• Create guarded API with a secret kay (token):
  For API methods:
  • Broadcast
  • Objects
• Create team fighting mode
• Switch handlers from net/http server to fasthttp:
  • https://github.com/valyala/fasthttp
  • https://github.com/fasthttp/websocket
• Setup cache headers for static files: write or find a negroni middleware for caching
• Create length to snake JSON structure to give to clients opportunity to distinguish dangerous snakes and weak
• Game sessions to allow reconnections

Global TODOs

• Create more tests
• Create more comments

To make tasks

• Create CLI flag to set up max limit value of gamers in a game.
• Create log message with list of addresses to listen and serve.
• Create Prometheus metrics for channels lengths
• Create firing and listening of game events
  • an apple eating
  • a snake killing
  • a death
  • watermelon eating

Fix method's signature: deleteObject receives object interface{} but should work with *engine.Object

Delete vendor directory from repo

Add a module to configurate the server.

The module uses YAML configs and flags.

Flags have bigger priority than YAML directives.

YAML config is stored in a file. The path to the file is defined by an environment variable.

Update OpenAPI specification:

• Update version
• Add summaries
• Correct misspellings

Invalid memory allocation in playground.Playground

• In func UpdateObject keysToRemove allocate not len but cap
• In func UpdateObjectAvailableDots keysToRemove allocate not len but cap

Refactor config:

• Add Flags entity for broadcasts, web and cors settings
• Move seed generation outside the default config definition

Create a cache N seconds for the method API: GET /api/games/{id}/objects.

Use headers to notice a client about caching.

Create a field for time stamp to be returned in result json object

Example:

{
"objects":[],
"time": ...
}

Now a snake can eat another snake if the first snake has eaten at least one apple and the second snake hasn't eaten any food.
It would be better if big long snakes could eat any snake smaller then them but not only the smallest just started snakes.
It seems to be right to use this formula:

can_I_eat = my_len >= a_snake_len^2