cd stresstest
npm install
node main

func collideTwo(a *DynamicObject, b *DynamicObject, delta float64) bool {
	var colided bool

	var response collision2d.Response
	aType := a.shape.shapeType
	bType := b.shape.shapeType
	var overlapX float64
	var overlapY float64
	var v *Vec2
	if aType == SBOX && bType == SBOX {
		colided, response = collision2d.TestPolygonPolygon(a.shape.boxPolygon, b.shape.boxPolygon)
		overlapX = response.OverlapV.X
		overlapY = response.OverlapV.Y
	} else if aType == SCIRCLE && bType == SCIRCLE {
		colided, response = collision2d.TestCircleCircle(a.shape.circle, b.shape.circle)
		overlapX = response.OverlapV.X
		overlapY = response.OverlapV.Y
	} else if aType == SCIRCLE && bType == SBOX {
		v = fastCircleAABB2(&b.shape.boxPolygon, &a.shape.circle, &b.shape.box)
		if v != nil {
			overlapX = v[0]
			overlapY = v[1]
		}
	} else if aType == SBOX && bType == SCIRCLE {
		v = fastCircleAABB2(&a.shape.boxPolygon, &b.shape.circle, &a.shape.box)
		if v != nil {
			overlapX = v[0]
			overlapY = v[1]
		}
	}

	if colided == true || v != nil {
		var dx, dy float64
		if math.IsNaN(overlapX) {
			dx = -10 * delta
		} else {
			dx = overlapX * delta
		}

		if math.IsNaN(overlapY) {
			dy = 10 * delta
		} else {
			dy = overlapY * delta
		}

		if !a.Type.HasFlag(typeWall) {
			a.POS[0] -= dx
			a.POS[1] -= dy
		}

		if !b.Type.HasFlag(typeWall) {
			b.POS[0] += dx
			b.POS[1] += dy
		}
	}

	return v != nil || colided
}


func iterate(af *ActorF, delta float64, iteration int) {
	for _, a := range af.actors {
		a.shape.setPos(&a.POS)
	}

	var res bool
	for _, w := range af.walls {
		for _, a := range af.actors {
			if shouldCollide(w, a) {
			res = collideTwo(w, a, delta)
			if res && iteration == 0 {
				//w.onCollide(a)
				a.onCollide(w)
			}
		   }
		}
	}

	totalActors := len(af.actors)
	for ai, a := range af.actors {
		for i := ai; i < totalActors; i++ {
			b := af.actors[i]
			if a != b {
				col := shouldCollide(a, b)

				if col {
					res = collideTwo(a, b, delta)

					if res && iteration == 0 {
						b.onCollide(a)
						a.onCollide(b)
					}
				}
			}
		}
	}
}

func shouldCollide(a *DynamicObject, b *DynamicObject) bool {
	if (a.shape.collideTypes.HasFlag(b.Type) && 
(b.domain == nil || a.shape.ignoreId != b.domain.player.ID)) ||
		(b.shape.collideTypes.HasFlag(a.Type) && 
(a.domain == nil || b.shape.ignoreId != a.domain.player.ID)) {
		return true
	}
	return false;
}

'use strict';
var Parser = require('../front/cocos/assets/scripts/Parser.js'); //Парсит строку, делает js объект
var W3CWebSocket = require('websocket').w3cwebsocket;
var http = require('http');
var clients = [];

const host = "10.10.0.2:5050";

var packets = 0;

setInterval(function send(){
    console.log(packets + ' packets per second');
    ackets = 0
}, 1000);

function createClient(room) {
  //connecting to random room
    var client = new W3CWebSocket('ws://' + host + '/ws/' + room, null, 'http://localhost/');
    client.clientID = 0;

    clients.push(client)
    console.log('added client to room: ' + room + '; total: ' + clients.length);

    client.onerror = function(e) {
        console.log('Connection Error');
    };

    client.onopen = function() {
        console.log('WebSocket Client Connected');
    };

    client.onclose = function() {
        console.log('echo-protocol Client Closed');
    };
  
//every second player shoot in random direction and change movement speed
    setInterval(function changeDir() {
        if (!client.me) return;
        var v = 300;
        var angle = Math.random()* Math.PI*2;
        client.VX = Math.cos(angle) * v;
        client.VY = Math.sin(angle) * v;

        client.BVX = Math.cos(angle + Math.PI / 2) * v * 2;
        client.BVY = Math.sin(angle + Math.PI / 2) * v * 2;

        client.bullet = {
            ID: -1,
            CID: client.clientID,
            POS: client.me.POS,
            V: [client.BVX, client.BVY],
            TYPE: 4,
            OWNER: client.me.OWNER
        }
        client.clientID++;
    }, 1000);

        client.onmessage = function(e) {
        if (typeof e.data === 'string') {
            if (!client.playerId) {
                client.playerId = e.data;
            } else {
                client.data = Parser.parse(e.data);
                client.me = null
                for (var i = 0 ;i < client.data.objectsToSync.length; ++i) {
                    if (client.data.objectsToSync[i].ID == client.playerId) {
                        client.me = client.data.objectsToSync[i];
                    }
                }

                if (client.me && client.VX && client.VY) {
                    client.me.V[0] = client.VX;
                    client.me.V[1] = client.VY;
                }
            }
        }
    };
}


var CLIENTS_COUNT = 150;
var NUM_ROOMS = 100;
for (var i = 0; i < CLIENTS_COUNT; ++i) {
    var room = Math.floor(Math.random() * (NUM_ROOMS));
    setTimeout(
        createClient.bind(this, room)
    , 200*i)
}

console.time("interval");
setInterval(function send(){
    console.timeEnd("interval")
    console.time("interval")
    var cl = clients.length;
    for (var i = 0; i < cl; ++i) {
        var client = clients[i];
        if (client.me) {
            var str = Parser.serialize(client.me);

            if (client.bullet) {
                str = str + ';'+ Parser.serialize(client.bullet);
                client.bullet = null;
            }
            if (client.readyState == 1) {
                client.send(str);
                packets++;
            }
        }
    }
}, 40);


process.stdin.resume();
process.on('SIGINT', function () {
    console.log('aborted all clients');

    for (var i = 0; i < clients.length; ++i)
        clients[i].close();

    setTimeout(function() {
        process.exit (0);
    })
});

FROM golang

ENV GOPATH /glng/
ENV GOBIN /glng/

ADD . /glng/

RUN go install github.com/dearcj/golangproj

ENTRYPOINT ["/glng/golangproj", "-port", "5050"]
EXPOSE 5050

govendor init 
#govendor initialization
govendor add +external

go get github.com/username/library

govendor fetch github.com/username/library 
#after each package install we need to fetch library into vendor directory