codegame 0.7.0

CodeGame framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

'use strict';

const StreamWrapper = require('./stream-wrapper');
const Socket = require('net').Socket;

const model = require('./model/index');
const MyStrategy = require('./my-strategy').MyStrategy;
const DebugInterface = require('./debug-interface').DebugInterface;

class Runner {
    constructor(host, port, token) {
        this.socket = new Socket({ readable: true, writable: true });
        this.socket
            .setNoDelay(true)
            .on('error', (error) => {
                console.error('Socket error: ' + error.message);
                process.exit(1);
            });
        this.streamWrapper = new StreamWrapper(this.socket);
        this.host = host;
        this.port = port;
        this.token = token;
    }

    async connect() {
        const _this = this;
        await new Promise(function (resolve, reject) {
            _this.socket.connect({
                host: _this.host,
                port: _this.port
            }, function () {
                resolve();
            });
        });
        await this.streamWrapper.writeString(this.token);
    }

    async run() {
        try {
            await this.connect();
            let message, playerView, actions;
            const strategy = new MyStrategy();
            const debugInterface = new DebugInterface(this.streamWrapper);
            while (true) {
                message = await model.ServerMessage.readFrom(this.streamWrapper);
                if (message instanceof model.ServerMessage.GetAction) {
                    await (new model.ClientMessage.ActionMessage(await strategy.getAction(message.playerView, message.debugAvailable ? debugInterface : null)).writeTo(this.streamWrapper));
                    // TODO: only flush stream once here?
                } else if (message instanceof model.ServerMessage.Finish) {
                    break;
                } else if (message instanceof model.ServerMessage.DebugUpdate) {
                    await strategy.debugUpdate(message.playerView, debugInterface);
                    await (new model.ClientMessage.DebugUpdateDone().writeTo(this.streamWrapper));
                    // TODO: only flush stream once here?
                } else {
                    throw new Error("Unexpected server message");
                }
            }
        } catch (e) {
            console.error(e);
            process.exit(1);
        }
    }
}


const argv = process.argv;
const argc = argv.length;
const host = argc < 3 ? '127.0.0.1' : argv[2];
const port = argc < 4 ? 31001 : parseInt(argv[3]);
const token = argc < 5 ? '0000000000000000' : argv[4];
(new Runner(host, port, token)).run();