test-client rewrites

client/game.go

@@ -4,18 +4,13 @@ import (
     "log"
 
     "github.com/mechmind/ttti-server/message"
+    "github.com/mechmind/ttti-server/client/game"
 )
 
 
-type Game struct {}
-
-func (g *Game) HandleMessage(message.Message) message.Message {
-    return nil
-}
-
 func runGame(c *Client) error {
     c.Start()
-    game := &Game{}
+    g := game.NewGame(c.glyph[0])
     for msg := range c.connection.Read {
         log.Println("game: recieved message: ", msg)
 
@@ -24,11 +19,24 @@ func runGame(c *Client) error {
             c.connection.Write <- pong
         } else if msg.GetType() == "pong" {
         } else {
-            answer := game.HandleMessage(msg)
-            if answer != nil {
-                c.connection.Write <- answer
-            }
+            handleMessage(g, msg)
         }
     }
     return nil
 }
+
+func handleMessage(game *game.Game, msg message.Message) error {
+    switch msg.GetType() {
+    case "game-state":
+        // load state
+    case "turn":
+        // opponent made turn
+    case "game-over":
+        // game is over
+    case "error":
+        // got error
+    default:
+        log.Println("Unknown message: ", msg)
+    }
+    return nil
+}

client/game/field.go

@@ -0,0 +1,19 @@
+package game
+
+type Field []BigSquare
+
+type BigSquare []Square
+
+type Square byte
+
+const SIZE = 3
+
+
+func NewField() Field {
+    size := SIZE * SIZE
+    field := make([]BigSquare, size)
+    for i := 0; i < size; i++ {
+        field[i] = make([]Square, size)
+    }
+    return field
+}

client/game/game.go

@@ -4,15 +4,22 @@ import (
     "github.com/mechmind/ttti-server/message"
 )
 
-type gameConnector struct {
-    Input, Output chan message.Message
+const (
+    STATE_WAITING = iota
+    STATE_RUNNING
+)
+
+type Game struct {
+    state int
+    myGlyph byte
+    field Field
 }
 
-func makeGameConnector() gameConnector {
-    return gameConnector{make(chan message.Message), make(chan message.Message)}
+func NewGame(glyph byte) *Game {
+    return &Game{0, glyph, NewField()}
 }
 
 
-type Game interface {
-    Start()
+func (g *Game) HandleMessage(m message.Message) message.Message {
+    return m
 }

client/httpapi.go

@@ -66,52 +66,57 @@ func (hc *HttpAdminClient) CreateSession() (string, error) {
     return session_id, nil
 }
 
-func (hc *HttpAdminClient) AttachPlayer(session string) (string, error) {
+func (hc *HttpAdminClient) AttachPlayer(session string) (string, string, error) {
     s_url := "http://" + hc.server + "/attach_player"
     resp, err := http.PostForm(s_url, url.Values{"session_id": {session}})
     if err != nil {
         log.Println("http-admin-client: unable to attach player", err)
-        return "", err
+        return "", "", err
     }
     defer resp.Body.Close()
     answer, err := ioutil.ReadAll(resp.Body)
     if err != nil {
         log.Println("http-admin-client: unable to read response", err)
-        return "", err
+        return "", "", err
     }
     var data = make(map[string]string)
     err = json.Unmarshal(answer, &data)
     if err != nil {
         log.Println("http-admin-client: unable to parse json", err)
-        return "", err
+        return "", "", err
     }
     resp_type, ok := data["type"]
     if !ok {
         log.Println("http-admin-client: invalid json")
-        return "", errors.New("invalid json")
+        return "", "", errors.New("invalid json")
     }
     if resp_type == "error" {
         log.Println("http-admin-client: server error", data["message"])
-        return "", errors.New(data["message"])
+        return "", "", errors.New(data["message"])
     }
     if resp_type != "response" {
         log.Println("http-admin-client: invalid json type")
-        return "", errors.New("invalid json type")
+        return "", "", errors.New("invalid json type")
     }
     session_id, ok := data["session_id"]
     if !ok {
         log.Println("http-admin-client: invalid json - no session_id")
-        return "", errors.New("invalid json - no session_id")
+        return "", "", errors.New("invalid json - no session_id")
     }
     if session_id != session {
         log.Println("http-admin-client: invalid response - session id mismatch")
-        return "", errors.New("invalid response - session id mismatch")
+        return "", "", errors.New("invalid response - session id mismatch")
     }
     player_id, ok := data["player_id"]
     if !ok {
         log.Println("http-admin-client: invalid json - no player_id")
-        return "", errors.New("invalid json - no player_id")
+        return "", "", errors.New("invalid json - no player_id")
+    }
+    player_glyph, ok := data["player_glyph"]
+    if !ok {
+        log.Println("http-admin-client: invalid json - no player_glyph")
+        return "", "", errors.New("invalid json - no player_glyph")
     }
-    return player_id, nil
+    return player_id, player_glyph, nil
 }
 

client/main.go

@@ -22,14 +22,14 @@ func main() {
         }
         log.Println("main: created session", *session)
     }
-    player, err := hc.AttachPlayer(*session)
+    player, glyph, err := hc.AttachPlayer(*session)
     if err != nil {
         log.Println("main: failed to attach to session", err)
         return
     }
-    log.Printf("main: attached to session '%s' as player '%s'", *session, player)
+    log.Printf("main: attached to session '%s' as player '%s', glyph %s", *session, player, glyph)
 
-    c := NewClient(*host, *session, player)
+    c := NewClient(*host, *session, player, glyph)
     err = c.Connect()
     if err != nil {
         log.Println("main: cannot establish connection", err)

client/session.go

@@ -14,11 +14,12 @@ type Client struct {
     host string
     session string
     player string
+    glyph string
     connection *connection.PlayerConnection
 }
 
-func NewClient(host string, session string, player string) *Client {
-    return &Client{host, session, player, nil}
+func NewClient(host string, session string, player string, glyph string) *Client {
+    return &Client{host, session, player, glyph, nil}
 }
 
 func (c *Client) Connect() error {
@@ -57,7 +58,7 @@ func (c *Client) handshake(socket *net.TCPConn) (*connection.PlayerConnection, e
         switch hello.GetType() {
         case "error":
             errmsg := hello.(message.MsgError)
-            return nil, errors.New("server kiks us with error: " + errmsg.Message)
+            return nil, errors.New("server kicks us with error: " + errmsg.Message)
         default:
             return nil, errors.New("server going mad! Type is: " + hello.GetType())
         }