Laissé en plan : players mov through tcp, not pos

Author: MarioVieilledent

main.go

@@ -10,10 +10,6 @@ import (
 func main() {
 	args := os.Args
 
-	for k, a := range args {
-		fmt.Println(k, a)
-	}
-
 	if len(args) >= 3 && args[1] == "server" {
 		host := args[2]
 		port := args[3]

src/game/entity/player.go

@@ -1,8 +1,8 @@
 package entity
 
-const DEFAULT_SPEED float64 = 0.08
-const DEFAULT_JUMP_SPEED float64 = 0.21
-const GRAVITY float64 = 0.0065
+const DEFAULT_SPEED float64 = 0.045
+const DEFAULT_JUMP_SPEED float64 = 0.136
+const GRAVITY float64 = 0.003
 
 type Player struct {
 	// Identification properties
@@ -15,6 +15,7 @@ type Player struct {
 	VerticalVelocity float64
 	MovesLeft        bool
 	MovesRight       bool
+	IsJumping        bool
 
 	// Statistics of player
 	EatBox    [4]float64
@@ -32,6 +33,7 @@ func NewPlayer(pos Pos, nickname, character string) Player {
 		TouchesGround: false,
 		MovesLeft:     false,
 		MovesRight:    false,
+		IsJumping:     false,
 
 		EatBox:    [4]float64{0.1, 0.1, 0.9, 1.95},
 		Speed:     DEFAULT_SPEED,

src/game/entity/playerInfo.go

@@ -1,34 +1,30 @@
 package entity
 
 import (
-	"errors"
-	"strings"
+	"encoding/json"
+	"gopherLand2/src/localInstance/input"
 )
 
 // Used for multiplayer data sharing
 type PlayerInfo struct {
-	Nickname string
-	Pos      Pos
+	Nickname   string           `json:"nickname"`
+	Pos        Pos              `json:"pos"`
+	KeyPressed input.KeyPressed `json:"keyPressed"`
 }
 
-func (pi PlayerInfo) ToString() string {
-	return pi.Nickname + "|" + pi.Pos.ToString()
+func (pi PlayerInfo) Stringify() ([]byte, error) {
+	data, err := json.Marshal(pi)
+	if err != nil {
+		return []byte{}, err
+	}
+	return data, nil
 }
 
-func ParsePlayerInfo(s string) (PlayerInfo, error) {
-	split := strings.Split(s, "|")
-	if len(split) == 2 {
-		pp, err := ParsePos(split[1])
-		if err != nil {
-			return PlayerInfo{}, err
-		} else {
-			pi := PlayerInfo{
-				Nickname: split[0],
-				Pos:      pp,
-			}
-			return pi, nil
-		}
-	} else {
-		return PlayerInfo{}, errors.New("there's extra | symbols in pseudo")
+func Parse(data []byte) (PlayerInfo, error) {
+	var pi PlayerInfo
+	err := json.Unmarshal(data, &pi)
+	if err != nil {
+		return PlayerInfo{}, err
 	}
+	return pi, nil
 }

src/game/entity/pos.go

@@ -1,21 +1,6 @@
 package entity
 
-import "fmt"
-
 type Pos struct {
-	X float64
-	Y float64
-}
-
-func (p Pos) ToString() string {
-	return fmt.Sprintf("(%v, %v)", p.X, p.Y)
-}
-
-func ParsePos(s string) (Pos, error) {
-	var p Pos
-	_, err := fmt.Sscanf(s, "(%f, %f)", &p.X, &p.Y)
-	if err != nil {
-		return Pos{}, err
-	}
-	return p, nil
+	X float64 `json:"x"`
+	Y float64 `json:"y"`
 }

src/game/game.go

@@ -7,7 +7,7 @@ import (
 	"gopherLand2/src/game/entity"
 	"gopherLand2/src/game/gameMap"
 	"gopherLand2/src/game/ressources"
-	"time"
+	"gopherLand2/src/localInstance/input"
 )
 
 type Game struct {
@@ -19,45 +19,44 @@ type Game struct {
 	GameMap    gameMap.GameMap       // A map
 
 	// Local Player
-	Player  entity.Player // Playable player
-	Channel chan string   // Controls the player
-	Tick    int           // Tick of the game
-	TickMS  int           // Delay between each tick in ms
+	Player entity.Player // Playable player
+	Tick   int           // Tick of the game
+	TickMS int           // Delay between each tick in ms
+
+	// PlayerInputChannel for getting input of player
+	PlayerInputChannel chan input.KeyPressed // Controls the player
 
 	// Multiplayer data
-	PlayerPos map[string]entity.Pos
+	PlayerInfos map[string]entity.PlayerInfo
 
 	// Channels for multiplayer
-	PlayerPosChannel     chan entity.PlayerInfo // Channel for sending own player position if multiplayer
-	AllPlayersPosChannel chan []byte            // Channel for receiving all players positions if multiplayer
+	PlayerPosChannel      chan entity.PlayerInfo // Channel for sending own player position if multiplayer
+	AllPlayerInfosChannel chan []byte            // Channel for receiving all players positions if multiplayer
 }
 
 // Create a new game with a channel that receive players' actions
-func New(ch chan string) Game {
+func New(ch chan input.KeyPressed) Game {
 	// Load game's config
 	cfg := loadConfig()
 
 	// Create Game
 	g := Game{
-		Config:     cfg,
-		Ressources: ressources.New(cfg.Size),
-		GameMap:    gameMap.New(),
-		Player:     entity.Player{},
-		Channel:    ch,
-		Tick:       0,
-		TickMS:     cfg.TickMS,
+		Config:             cfg,
+		Ressources:         ressources.New(cfg.Size),
+		GameMap:            gameMap.New(),
+		Player:             entity.Player{},
+		PlayerInputChannel: ch,
+		Tick:               0,
+		TickMS:             cfg.TickMS,
 	}
 
 	return g
 }
 
-// Run the game
+// Run the game, function called by ebiten's Update() function (in file gameWindow.go)
 func (g *Game) Run() {
-	for {
-		g.Tick++
-		time.Sleep(time.Duration(g.TickMS) * time.Millisecond)
-		g.ComputeTick()
-	}
+	g.Tick++
+	g.ComputeTick()
 }
 
 // Add a new player
@@ -79,24 +78,21 @@ func (g *Game) SetPlayerNickname(nickname string) {
 }
 
 // Bind a channel for sending to multiplayer server player's data
-func (g *Game) BindMultiplayerChannels(playerPosChannel chan entity.PlayerInfo, allPlayersPosChannel chan []byte) {
+func (g *Game) BindMultiplayerChannels(playerPosChannel chan entity.PlayerInfo, allPlayerInfosChannel chan []byte) {
 	g.PlayerPosChannel = playerPosChannel
-	g.AllPlayersPosChannel = allPlayersPosChannel
+	g.AllPlayerInfosChannel = allPlayerInfosChannel
 	go g.UpdateAllPlayers()
 }
 
 // Update all player in case of server send data
 func (g *Game) UpdateAllPlayers() {
 	for {
-		data := <-g.AllPlayersPosChannel
-		playersConnected := map[string]entity.Pos{}
+		data := <-g.AllPlayerInfosChannel
+		playersConnected := map[string]entity.PlayerInfo{}
 		err := json.Unmarshal(bytes.Trim(data, string([]byte{0})), &playersConnected)
 		if err != nil {
-			fmt.Println("Error parsing players' data sent by server: " + err.Error())
-
-			fmt.Println(string(data))
+			fmt.Println("Error parsing players' data sent by server: " + string(data) + " - Error:" + err.Error())
 		}
-
-		g.PlayerPos = playersConnected
+		g.PlayerInfos = playersConnected
 	}
 }

src/game/playerMovment.go

@@ -2,6 +2,7 @@ package game
 
 import (
 	"gopherLand2/src/game/entity"
+	"gopherLand2/src/localInstance/input"
 	"math"
 )
 
@@ -13,6 +14,12 @@ func (g *Game) ComputeTick() {
 	if !g.Player.MovesLeft && g.Player.MovesRight {
 		g.moveHorizonally(entity.DEFAULT_SPEED)
 	}
+	if g.Player.IsJumping {
+		if g.Player.TouchesGround {
+			g.Player.TouchesGround = false
+			g.Player.VerticalVelocity -= g.Player.JumpSpeed
+		}
+	}
 
 	if !g.Player.TouchesGround {
 		g.moveVertically(g.Player.VerticalVelocity)
@@ -22,26 +29,26 @@ func (g *Game) ComputeTick() {
 
 // Handle player's control
 func (g *Game) RunPlayer() {
-	var action string
+	var keyPressed input.KeyPressed
 
 	for {
-		action = <-g.Channel
+		keyPressed = <-g.PlayerInputChannel
 
-		switch action {
-		case "left":
+		if keyPressed.Left {
 			g.Player.MovesLeft = true
-		case "right":
-			g.Player.MovesRight = true
-		case "up":
-			if g.Player.TouchesGround {
-				g.Player.TouchesGround = false
-				g.Player.VerticalVelocity -= g.Player.JumpSpeed
-			}
-		case "released_left":
+		} else {
 			g.Player.MovesLeft = false
-		case "released_right":
+		}
+		if keyPressed.Right {
+			g.Player.MovesRight = true
+		} else {
 			g.Player.MovesRight = false
 		}
+		if keyPressed.Up {
+			g.Player.IsJumping = true
+		} else {
+			g.Player.IsJumping = false
+		}
 	}
 }
 

src/localInstance/TCPClient/TCPClient.go

@@ -9,7 +9,7 @@ import (
 
 const TYPE string = "tcp"
 
-func StartTCPClient(host, port, nickname string, playerPosChannel chan entity.PlayerInfo, allPlayersPosChannel chan []byte) {
+func StartTCPClient(host, port, nickname string, playerPosChannel chan entity.PlayerInfo, allPlayerInfosChannel chan []byte) {
 	tcpServer, err := net.ResolveTCPAddr(TYPE, host+":"+port)
 
 	if err != nil {
@@ -36,7 +36,7 @@ func StartTCPClient(host, port, nickname string, playerPosChannel chan entity.Pl
 		fmt.Println("Read data failed:", err.Error())
 		os.Exit(1)
 	} else {
-		allPlayersPosChannel <- received
+		allPlayerInfosChannel <- received
 	}
 
 	fmt.Println("Connected to server " + host + ":" + port)
@@ -50,19 +50,24 @@ func StartTCPClient(host, port, nickname string, playerPosChannel chan entity.Pl
 				fmt.Println("Read data failed:", err.Error())
 				os.Exit(1)
 			} else {
-				allPlayersPosChannel <- received
+				allPlayerInfosChannel <- received
 			}
 		}
 	}()
 
-	// Send own player position
+	// Send own player info
 	for {
-		action := <-playerPosChannel
+		playerInfo := <-playerPosChannel
 
-		_, err = conn.Write([]byte("1" + action.ToString()))
+		pi, err := playerInfo.Stringify()
 		if err != nil {
-			fmt.Println("Write data failed:", err.Error())
-			os.Exit(1)
+			fmt.Println("Cannot parse playerInfo into JSON: " + err.Error())
+		} else {
+			_, err = conn.Write([]byte("1" + string(pi)))
+			if err != nil {
+				fmt.Println("Write data failed:", err.Error())
+				os.Exit(1)
+			}
 		}
 	}
 }

src/localInstance/gameWindow/drawEntities.go

@@ -16,13 +16,13 @@ func (g *Graphics) drawEntities(screen *ebiten.Image) {
 	xPlayer := g.game.Player.Pos.X
 	yPlayer := g.game.Player.Pos.Y
 
-	for nickname, pos := range g.game.PlayerPos {
+	for nickname, pi := range g.game.PlayerInfos {
 		if g.game.Player.Nickname != nickname {
 			op := &ebiten.DrawImageOptions{}
 
 			op.GeoM.Translate(
-				(float64(pos.X)-xPlayer)*g.size+g.halfWidth,
-				(float64(pos.Y)-yPlayer)*g.size+g.halfHeight,
+				(float64(pi.Pos.X)-xPlayer)*g.size+g.halfWidth,
+				(float64(pi.Pos.Y)-yPlayer)*g.size+g.halfHeight,
 			)
 
 			screen.DrawImage(g.game.Ressources.Elements["p"].Img, op)