game.go

//This file deals with concurency, sets up games, and manages websockets in games

package main

import(
    "fmt"
    "time"
    "github.com/gorilla/websocket"
)

//Groups websockets into games when they send the match signal
func grouper(c chan *websocket.Conn, q chan int16){
    fmt.Println("Running")
    mat := Match{make([]*websocket.Conn, 3), make([]*websocket.Conn, 3)}
    var user *websocket.Conn
    var i int16 = -1
    var count int = 0
    for ;i < 0; {
        select{
            case user = <-c:
                fmt.Println("Got one!")
                user.WriteJSON(DataJSON{"matched", ""})
                if count < 3 {
                    mat.ac[count] = user
                }else if count < 6 {
                    mat.dc[count-3] = user
                }
                count++
                if count == 6 {
                    fmt.Println("Setting up...")
                    go setupGame(mat)
                    count = 0
                }
            break
            case i = <-q:
            break
        }
    }
    if count != 0 {
        for k := 0; k < count; k++ {
            if k < 3 {
                mat.ac[k].Close()
            } else {
                mat.dc[k-3].Close()
            }
        }
    }
}

//Creates the board and sets up the websockets on it
func setupGame(mat Match){
    board := newBoard(10)
    k := uint8(0)
    for k = 0; k < 3; k++ {
        mat.ac[k].WriteJSON(DataJSON{"gen", ""})
        mat.dc[k].WriteJSON(DataJSON{"gen", ""})
    }
    fmt.Println("Gen")
    board.genPaths()
    for k = 0; k < 3; k++ {
        mat.ac[k].WriteJSON(DataJSON{"final", ""})
        mat.dc[k].WriteJSON(DataJSON{"final", ""})
    }
    fmt.Println("Final")
    msgs := make(chan Message)
    for k = 0; k < 3; k++ {
        go worker(mat.ac[k], board, board.addPlayer(mat.ac[k], true), msgs)
        go worker(mat.dc[k], board, board.addPlayer(mat.dc[k], false), msgs)
    }
    reporter(board, msgs)
}

//Runs the socket and makes sure that the commands sent are valid
func worker(socket *websocket.Conn, gb *GameBoard, id int8, msgch chan Message){
    msg := DataJSON{"", ""}
    if id < 0 {
        go handleCritical(msgch, gb)
        err := socket.WriteJSON(DataJSON{"err", "err:invalid_id"})
        if err != nil {
            socket.Close()
            return
        }
        go lobby(socket)
        return
    }else{
        err := socket.WriteJSON(Message{id, "success"})
        if err != nil {
            socket.Close()
            go handleError(msgch, gb, id)
            return
        }
    }
    fmt.Println("Grouped!")
    for ;gb.open; {
        err := socket.ReadJSON(&msg)
        if err != nil {
            socket.Close()
            go handleError(msgch, gb, id)
            return
        }
        if gb.checkMove(Message{id, msg.Data}) {
            for i := true;gb.open && i; {
                select {
                    case msgch <- Message{id, msg.Data}:
                    i = false
                    case <-time.After(time.Millisecond * 200):
                }
            }
        }else if msg.Data == "lobby" {
            go handleError(msgch, gb, id)
            go lobby(socket)
            return
        }
    }
}

//Handles an error if something goes wrong in the reporter when trying to send messages
func handleError(msgch chan Message, gb *GameBoard, id int8) {
    fmt.Println("Sending error")
    if id < 3 {
        gb.pla[id].closed = true
    }else{
        gb.pld[id-3].closed = true
    }
    defer fmt.Println("Stop err send")
    for ;gb.open; {
        select {
            case msgch <- Message{id, "quit"}:
            return
            case <-time.After(time.Millisecond * 200):
        }
    }
}

//Handle a critical error
func handleCritical(msgch chan Message, gb *GameBoard){
    fmt.Println("Sending crit")
    defer fmt.Println("Stop crit send")
    for ;gb.open; {
        select {
            case msgch <- Message{-1, "critical"}:
            return
            case <-time.After(time.Millisecond * 200):
        }
    }
}

//Reports what each websocket is doing to the others
func reporter(gb *GameBoard, msgch chan Message){
    fmt.Println("Reporting!")
    var msg Message
    var i int8 = 0
    for ;i >= 0; {
        msg = <-msgch
        for i = 0; i < 3; i++ {
            if gb.pla[i].closed == false {
                err := gb.pla[i].socket.WriteJSON(msg)
                if err != nil {
                    gb.pla[i].socket.Close()
                    go handleError(msgch, gb, i)
                }
            }
            if gb.pld[i].closed == false {
                err := gb.pld[i].socket.WriteJSON(msg)
                if err != nil {
                    gb.pld[i].socket.Close()
                    go handleError(msgch, gb, i+3)
                }
            }
        }
        if msg.T == -1 || msg.Data == "critical"{
            fmt.Println("Critical error")
            i = -1
        }
        for j := 0; j < 3; j++ {
            if gb.pla[j].closed == false || gb.pld[j].closed == false {
                break
            }else if j == 2 {
                fmt.Println("Group over")
                i = -1
            }
        }
    }
    fmt.Println("Closing msgch")
    gb.open = false
}