366 lines
8.3 KiB
Go
366 lines
8.3 KiB
Go
package pong
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"log/slog"
|
|
"net"
|
|
"strings"
|
|
"time"
|
|
|
|
"golang.org/x/exp/rand"
|
|
)
|
|
|
|
type GameClient struct {
|
|
Username string
|
|
Conn net.Conn
|
|
}
|
|
|
|
const posXBound = 52
|
|
const negXBound = posXBound * -1
|
|
const posYBound = 50
|
|
const negYBound = posYBound * -1
|
|
|
|
func StartGame(conn1, conn2 net.Conn, username1, username2 string) {
|
|
|
|
var player1 GameClient
|
|
var player2 GameClient
|
|
|
|
egress := make(chan StateUpdate)
|
|
ingress := make(chan StateUpdate)
|
|
|
|
player1 = GameClient{
|
|
Username: username1,
|
|
Conn: conn1,
|
|
}
|
|
|
|
p1msg := StateUpdate{
|
|
FieldPath: "isPlayer1",
|
|
Value: []byte{1},
|
|
}
|
|
b, err := json.Marshal(p1msg)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = player1.Conn.Write(b)
|
|
if err != nil {
|
|
fmt.Println("Error writing player1 msg to player1")
|
|
return
|
|
}
|
|
|
|
player2 = GameClient{
|
|
Username: username2,
|
|
Conn: conn2,
|
|
}
|
|
|
|
p2msg := StateUpdate{
|
|
FieldPath: "isPlayer1",
|
|
Value: []byte{0},
|
|
}
|
|
b, err = json.Marshal(p2msg)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = player2.Conn.Write(b)
|
|
if err != nil {
|
|
fmt.Println("Error writing player1 msg to player2")
|
|
return
|
|
}
|
|
|
|
time.Sleep(1 * time.Second)
|
|
broadcastUpdate(StateUpdate{
|
|
FieldPath: "Message",
|
|
Value: []byte("Ready..."),
|
|
}, player1, player2)
|
|
time.Sleep(1 * time.Second)
|
|
broadcastUpdate(StateUpdate{
|
|
FieldPath: "Message",
|
|
Value: []byte("Set..."),
|
|
}, player1, player2)
|
|
time.Sleep(1 * time.Second)
|
|
broadcastUpdate(StateUpdate{
|
|
FieldPath: "Message",
|
|
Value: []byte("Go!"),
|
|
}, player1, player2)
|
|
time.Sleep(1 * time.Second)
|
|
bv := float32(rand.Intn(2)*2 - 1)
|
|
|
|
state := GameState{
|
|
Score: map[string]int{player1.Username: 0, player2.Username: 0},
|
|
Player1: Player{
|
|
client: player1,
|
|
Pos: Vector{
|
|
X: -50,
|
|
Y: 0,
|
|
},
|
|
Size: Vector{
|
|
X: 1,
|
|
Y: 10,
|
|
},
|
|
},
|
|
Player2: Player{
|
|
client: player2,
|
|
Pos: Vector{
|
|
X: 50,
|
|
Y: 0,
|
|
},
|
|
Size: Vector{
|
|
X: 1,
|
|
Y: 10,
|
|
},
|
|
},
|
|
Ball: Ball{
|
|
Pos: Vector{
|
|
X: 0,
|
|
Y: 0,
|
|
},
|
|
Vel: Vector{
|
|
X: bv,
|
|
Y: 0,
|
|
},
|
|
},
|
|
}
|
|
go gameLoop(&state, ingress, egress, player1, player2)
|
|
}
|
|
|
|
func gameLoop(state *GameState, ingress, egress chan (StateUpdate), player1, player2 GameClient) {
|
|
// Player 1 read loop
|
|
go func() {
|
|
for {
|
|
|
|
bytes := make([]byte, 512)
|
|
n, err := state.Player1.client.Conn.Read(bytes)
|
|
msg := StateUpdate{}
|
|
err = json.Unmarshal(bytes[:n], &msg)
|
|
if err != nil {
|
|
log.Println("error reading player 1's update request:", err)
|
|
return
|
|
}
|
|
ingress <- msg
|
|
if msg.FieldPath == "Winner" {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Player 2 read loop
|
|
go func() {
|
|
for {
|
|
|
|
bytes := make([]byte, 512)
|
|
n, err := state.Player2.client.Conn.Read(bytes)
|
|
msg := StateUpdate{}
|
|
err = json.Unmarshal(bytes[:n], &msg)
|
|
if err != nil {
|
|
log.Println("error reading player 2's update request:", err)
|
|
return
|
|
}
|
|
ingress <- msg
|
|
if msg.FieldPath == "Winner" {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
go func() {
|
|
for {
|
|
msg := <-egress
|
|
broadcastUpdate(msg, player1, player2)
|
|
if msg.FieldPath == "Winner" {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
ticker := time.NewTicker(time.Second / 64)
|
|
|
|
for {
|
|
select {
|
|
case msg := <-ingress:
|
|
err := handlePlayerRequest(msg, state)
|
|
if err != nil {
|
|
fmt.Println("FUCK!~", err)
|
|
}
|
|
if msg.FieldPath == "Winner" {
|
|
slog.Debug("Closing game loop on winner message")
|
|
return
|
|
}
|
|
|
|
case _ = <-ticker.C:
|
|
update := process(state, player1, player2)
|
|
egress <- update
|
|
if update.FieldPath == "Winner" {
|
|
slog.Debug("Closing game loop")
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func process(state *GameState, player1, player2 GameClient) StateUpdate {
|
|
// Move players
|
|
// Check if player edge is out of bounds
|
|
// If out of bounds reset velocity to zero and position to edge
|
|
|
|
if state.Player1.Pos.Y+state.Player1.Size.Y/2 > posYBound {
|
|
state.Player1.Pos.Y = posYBound - state.Player1.Size.Y/2 - 1
|
|
}
|
|
if state.Player1.Pos.Y-state.Player1.Size.Y/2 < negYBound {
|
|
state.Player1.Pos.Y = negYBound + state.Player1.Size.Y/2 + 1
|
|
}
|
|
|
|
if state.Player2.Pos.Y+state.Player2.Size.Y/2 > posYBound {
|
|
state.Player2.Pos.Y = posYBound - state.Player2.Size.Y/2 - 1
|
|
}
|
|
if state.Player2.Pos.Y-state.Player2.Size.Y/2 < negYBound {
|
|
state.Player2.Pos.Y = negYBound + state.Player2.Size.Y/2 + 1
|
|
}
|
|
|
|
// Move ball
|
|
// Check if ball is out of bounds
|
|
// if out of bounds y,
|
|
// bounce by inverting y velocity and finding difference from bounds to out and reflect distance
|
|
// if out of bounds x,
|
|
// check if paddle is nearby, bounce by inverting and finding the remaining distance to the new position.
|
|
// or adjust score and ball position
|
|
|
|
state.Ball.Pos.X = state.Ball.Pos.X + state.Ball.Vel.X
|
|
state.Ball.Pos.Y = state.Ball.Pos.Y + state.Ball.Vel.Y
|
|
|
|
if state.Ball.Pos.Y >= posYBound-1 && state.Ball.Vel.Y > 0 {
|
|
state.Ball.Pos.Y = (posYBound - 1) - (state.Ball.Pos.Y - (posYBound - 1))
|
|
state.Ball.Vel.Y = state.Ball.Vel.Y * -1
|
|
}
|
|
if state.Ball.Pos.Y <= negYBound+1 && state.Ball.Vel.Y < 0 {
|
|
state.Ball.Pos.Y = (negYBound + 1) - (state.Ball.Pos.Y - (negYBound + 1))
|
|
state.Ball.Vel.Y = state.Ball.Vel.Y * -1
|
|
}
|
|
|
|
// If the ball is within 1 pixel of x bounds and heading to the left (Player 1)
|
|
if state.Ball.Pos.X <= negXBound+1 && state.Ball.Vel.X < 0 {
|
|
// Paddle hit!
|
|
if state.Ball.Pos.Y <= state.Player1.Pos.Y+state.Player1.Size.Y && state.Ball.Pos.Y >= state.Player1.Pos.Y-state.Player1.Size.Y {
|
|
slog.Debug("Player1 paddle hit!")
|
|
state.Ball.Pos.X = (negXBound + 1) - (state.Ball.Pos.X - (negXBound + 1))
|
|
state.Ball.Vel.X = state.Ball.Vel.X * -1.001
|
|
angleTweak := (state.Ball.Pos.Y - state.Player1.Pos.Y) / (state.Player1.Size.Y / 2)
|
|
state.Ball.Vel.Y = angleTweak / 10
|
|
} else {
|
|
slog.Debug("Player1 paddle miss...")
|
|
state.Ball.Pos.X = 0
|
|
state.Ball.Pos.Y = 0
|
|
state.Ball.Vel.X = 1
|
|
state.Ball.Vel.Y = 0
|
|
if state.Score[player2.Username] >= 9 {
|
|
return StateUpdate{
|
|
FieldPath: "Winner",
|
|
Value: []byte(player2.Username),
|
|
}
|
|
}
|
|
state.Score[player2.Username] = state.Score[player2.Username] + 1
|
|
}
|
|
}
|
|
|
|
// If the ball is within 1 pixel of x bounds and heading towards player2 (to the right)
|
|
if state.Ball.Pos.X > posXBound-1 && state.Ball.Vel.X > 0 {
|
|
// Paddle hit!
|
|
if state.Ball.Pos.Y <= state.Player2.Pos.Y+state.Player2.Size.Y && state.Ball.Pos.Y >= state.Player2.Pos.Y-state.Player2.Size.Y {
|
|
slog.Debug("Player2 paddle hit!")
|
|
state.Ball.Pos.X = (posXBound - 1) - (state.Ball.Pos.X - (posXBound - 1))
|
|
state.Ball.Vel.X = state.Ball.Vel.X * -1.001
|
|
angleTweak := (state.Ball.Pos.Y - state.Player2.Pos.Y) / (state.Player2.Size.Y / 2)
|
|
state.Ball.Vel.Y = angleTweak / 10
|
|
} else {
|
|
slog.Debug("Player2 paddle miss...")
|
|
state.Ball.Pos.X = 0
|
|
state.Ball.Pos.Y = 0
|
|
state.Ball.Vel.X = -1
|
|
state.Ball.Vel.Y = 0
|
|
if state.Score[player1.Username] >= 9 {
|
|
return StateUpdate{
|
|
FieldPath: "Winner",
|
|
Value: []byte(player1.Username),
|
|
}
|
|
}
|
|
state.Score[player1.Username] = state.Score[player1.Username] + 1
|
|
}
|
|
}
|
|
|
|
ns, err := json.Marshal(state)
|
|
if err != nil {
|
|
slog.Debug("error marshalling entire state update", slog.Any("error", err))
|
|
}
|
|
|
|
return StateUpdate{
|
|
FieldPath: "All",
|
|
Value: ns,
|
|
}
|
|
}
|
|
|
|
func handlePlayerRequest(update StateUpdate, state *GameState) error {
|
|
|
|
fields := strings.Split(update.FieldPath, ".")
|
|
|
|
// type GameState struct {
|
|
// Message string
|
|
// Winner string
|
|
// Score map[string]int
|
|
// Player1 Player
|
|
// Player2 Player
|
|
// Ball Ball
|
|
// }
|
|
|
|
switch fields[0] {
|
|
case "Message":
|
|
state.Message = string(update.Value)
|
|
case "Winner":
|
|
state.Winner = string(update.Value)
|
|
case "Player1":
|
|
switch fields[1] {
|
|
case "Pos":
|
|
v1 := Vector{}
|
|
err := json.Unmarshal(update.Value, &v1)
|
|
if err != nil {
|
|
slog.Debug("error unmarshalling player1 update")
|
|
}
|
|
state.Player1.Pos = v1
|
|
}
|
|
case "Player2":
|
|
switch fields[1] {
|
|
case "Pos":
|
|
v2 := Vector{}
|
|
err := json.Unmarshal(update.Value, &v2)
|
|
if err != nil {
|
|
slog.Debug("error unmarshalling player2 update")
|
|
}
|
|
state.Player2.Pos = v2
|
|
}
|
|
case "Ball":
|
|
b := Ball{}
|
|
err := json.Unmarshal(update.Value, &b)
|
|
if err != nil {
|
|
slog.Debug("error unmarshalling ball update")
|
|
}
|
|
state.Ball = b
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func broadcastUpdate(update StateUpdate, player1, player2 GameClient) error {
|
|
msg, err := json.Marshal(update)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = player1.Conn.Write(msg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = player2.Conn.Write(msg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|