// my remote player end step

x = server_x + server_hspeed * global.server_delay;
y = server_y + server_vspeed * global.server_delay;
image_angle = server_angle;

switch(server_sprite)
{
    case 0:
    sprite_index = spr_back;
    break;

    case 1:
        sprite_index = spr_back;
    break;

    case 2:
        sprite_index = spr_base0;
    break;

    case 3:
        sprite_index = spr_forward;
    break;

    case 4:
        sprite_index = spr_tanktop;
    break;

    case 5:
        sprite_index = spr_base;
    break;
}

// My remoteplayer create event

server_x = 0;
server_y = 0;
server_hspeed = 0;
server_vspeed = 0;
server_angle = 0;
title = "blank";
server_sprite = 0;

// my client ibj_controller step event

var s, a, xx, yy, hs, vs, angle, spritenumber;

if global.server_delaystarted {
    global.server_delay += 1;
}

// send position and speed
hbuffer_clear(global.buffer);
hbuffer_write_uint8(global.buffer, 2);
with obj_localplayer {
    if id != other.id {
        hbuffer_write_float32(global.buffer, x);
        hbuffer_write_float32(global.buffer, y);
        hbuffer_write_float32(global.buffer, hspeed);
        hbuffer_write_float32(global.buffer, vspeed);
        hbuffer_write_float32(global.buffer, image_angle);
        switch(sprite_index)
        {
            case spr_back:
                spritenumber = 1
            break;
            case spr_base0:
                spritenumber = 2
            break;
            case spr_forward:
                spritenumber = 3
            break;
            case spr_tanktop:
                spritenumber = 4
            break;
            case spr_base:
                spritenumber = 5
            break;
        }
        hbuffer_write_uint8(global.buffer, spritenumber);

    }
}
socket_write_message(socket, global.buffer);

socket_update_read(socket);

while socket_read_message(socket, global.buffer) {
    a = hbuffer_read_uint8(global.buffer);
    switch(a) {

        case 1: // player id
        obj_localplayer.player_id = hbuffer_read_uint32(global.buffer);
        break;

        case 2: // move remote players
        global.server_delaystarted = true;
        global.server_delay -= 1;
        while !hbuffer_at_end(global.buffer) {
            a = hbuffer_read_uint32(global.buffer);
            xx = hbuffer_read_float32(global.buffer);
            yy = hbuffer_read_float32(global.buffer);
            hs = hbuffer_read_float32(global.buffer);
            vs = hbuffer_read_float32(global.buffer);
            angle = hbuffer_read_float32(global.buffer);
            spritenumber = hbuffer_read_uint8(global.buffer)
            with obj_remoteplayer {
                if server_id = a {
                    server_x = xx;
                    server_y = yy;
                    server_hspeed = hs;
                    server_vspeed = vs;
                    server_angle = angle;
                    server_sprite = spritenumber;
                }
            }
        }
        break;

        case 3: // create remote player
        a = instance_create(0, 0, obj_remoteplayer and obj_remotetop);
        a.server_id = hbuffer_read_uint32(global.buffer);
        a.name = hbuffer_read_string(global.buffer);
        break;

        case 4: // destroy remote player
        a = hbuffer_read_uint32(global.buffer);
        with obj_remoteplayer {
            if server_id = a {
                instance_destroy();
            }
        }
        break;

        case 5:
        var pid = hbuffer_read_uint32(global.buffer);
        var msg = hbuffer_read_string(global.buffer);

        with(obj_remoteplayer)
        {
            if(server_id == pid)
            {
                title =  msg;
            }
        }
        break;
    }
}

s = socket_get_state(socket);
if s = 2 and !connected {
    connected = true;
}
if s = 4 {
    show_message("Connection closed.");
    game_end();
    exit;
}
if s = 5 or socket_get_write_data_length(socket) > max_write_data_length
{
    socket_reset(socket);
    if connected {
        show_message("Connection lost.");
    }
    else
    {
        show_message("Could not connect to server.");
    }
    room_goto(rm_titlescreen);
    exit;
}

global.server_delay = max(-3, min(10, global.server_delay * 0.95));

// my client controller create event

var address, name, port;

address = get_string("Address:", "69.126.187.169");
name = get_string("Nickname:", "");
/*if show_question("Use delay server?#(Press no if you don't know what this means)") {
    port = 39073;
} else {
    port = 39083;
}
*/
port = 39083
socket = socket_create();
socket_connect(socket, address, port);

global.buffer = hbuffer_create();
connected = false;

global.server_delaystarted = false;
global.server_delay = 0;

player_id = 0;

var a = instance_create(0, 0, obj_localplayer);
a. name = name;

// send name
hbuffer_clear(global.buffer);
hbuffer_write_uint8(global.buffer, 1);
hbuffer_write_string(global.buffer, name);
socket_write_message(socket, global.buffer);

// my server controller step event

var a, name;

global.stepcounter += 1;

while listeningsocket_can_accept(listeningsocket) {

    global.player_id_counter += 1;

    a = instance_create(0, 0, obj_player);
    a.socket = socket_create();
    listeningsocket_accept(listeningsocket, a.socket);
    a.ip = socket_get_peer_address(a.socket);
    a.player_id =  global.player_id_counter;
    a.name = "";

    // send player id
    hbuffer_clear(global.buffer);
    hbuffer_write_uint8(global.buffer, 1);
    hbuffer_write_uint32(global.buffer, a.player_id);
    socket_write_message(a.socket, global.buffer);

}

if !listeningsocket_is_listening(listeningsocket) {
    show_message("Can't listen for incoming connections!");
    game_end();
    exit;
}

// my server controller start event

listeningsocket = listeningsocket_create();
listeningsocket_start_listening(listeningsocket, false, 39083, false);

global.buffer = hbuffer_create();

global.stepcounter = 0;
global.player_id_counter = 0;

// my server player create event

hasstarted = false;

client_delaystarted = false;
client_delay = 0;

client_x = 0;
client_y = 0;
client_hspeed = 0;
client_vspeed = 0;
client_angle = 0;
client_sprite = 0;

// my server player step event

var s, a, message, newname, pid, msg;

// send position and speed of other players
if hasstarted {
    hbuffer_clear(global.buffer);
    hbuffer_write_uint8(global.buffer, 2);
    // don't send the data if the write buffer is already very large
    if socket_get_write_data_length(socket) < limit_write_data_length {
        with obj_player {
            if id != other.id {
                hbuffer_write_uint32(global.buffer, player_id);
                hbuffer_write_float32(global.buffer, x);
                hbuffer_write_float32(global.buffer, y);
                hbuffer_write_float32(global.buffer, client_hspeed);
                hbuffer_write_float32(global.buffer, client_vspeed);
                hbuffer_write_float32(global.buffer, client_angle);
                hbuffer_write_uint8(global.buffer, client_sprite);
            }
        }
    }
    socket_write_message(socket, global.buffer);
}

socket_update_read(socket);

while socket_read_message(socket, global.buffer) {
    a = hbuffer_read_uint8(global.buffer);
    switch(a) {

        case 1:
        name = hbuffer_read_string(global.buffer);
        hasstarted = true;
        // send other player ids
        with obj_player {
            if hasstarted and id != other.id {
                hbuffer_clear(global.buffer);
                hbuffer_write_uint8(global.buffer, 3);
                hbuffer_write_uint32(global.buffer, player_id);
                hbuffer_write_string(global.buffer, name);
                socket_write_message(other.socket, global.buffer);
            }
        }
        // tell the other players that this player has joined
        with obj_player {
            if hasstarted and id != other.id {
                hbuffer_clear(global.buffer);
                hbuffer_write_uint8(global.buffer, 3);
                hbuffer_write_uint32(global.buffer, other.player_id);
                hbuffer_write_string(global.buffer, other.name);
                socket_write_message(socket, global.buffer);
            }
        }
        break;

        case 2:
        client_delaystarted = true;
        client_delay -= 1;
        client_x = hbuffer_read_float32(global.buffer);
        client_y = hbuffer_read_float32(global.buffer);
        client_hspeed = hbuffer_read_float32(global.buffer);
        client_vspeed = hbuffer_read_float32(global.buffer);
        client_angle = hbuffer_read_float32(global.buffer);
        client_sprite = hbuffer_read_uint8(global.buffer);
        break;

        case 5:
        var pid = hbuffer_read_uint32(global.buffer);
        var msg = hbuffer_read_string(global.buffer);
        hbuffer_clear(global.buffer);
        hbuffer_write_uint8(global.buffer, 5);
        hbuffer_write_uint32(global.buffer, pid);
        hbuffer_write_string(global.buffer, msg);

        with(obj_player)
        {
            if (player_id != other.player_id)
            {
                socket_write_message(socket, global.buffer);
            }
        }
        break;

    }
}

s = socket_get_state(socket);
if s = 4 or s = 5 or socket_get_write_data_length(socket) > max_write_data_length {
    // tell the other players that this player has left
    with obj_player {
        if hasstarted and id != other.id {
            hbuffer_clear(global.buffer);
            hbuffer_write_uint8(global.buffer, 4);
            hbuffer_write_uint32(global.buffer, other.player_id);
            socket_write_message(socket, global.buffer);
        }
    }
    instance_destroy();
    exit;
}

if client_delaystarted {
    client_delay += 1;
}

client_delay = max(-3, min(10, client_delay * 0.95));