networkzero/client/game/game.go

package game

import (
	"client/client"
	"client/elements"
	"client/fonts"
	"client/gamedata"
	"client/pb"
	"fmt"
	"maps"
	"sync"
	"time"

	"github.com/hajimehoshi/ebiten/v2"
	"github.com/hajimehoshi/ebiten/v2/text/v2"
	"golang.org/x/exp/rand"
)

var (
	screenWidth   = 640
	screenHeight  = 480
	movementLimit = 5

	namelist = []string{"slappy", "mick", "rodney", "george", "ringo", "robin", "temitry "}
)

func init() {
	rand.Seed(uint64(time.Now().UnixNano()))
}

type ClientData struct {
	Id       int
	Address  string
	Name     string
	Position gamedata.Coordinates
	Hit      bool
}

type Game struct {
	name        string
	blocky      *elements.Block
	hitblocky   *elements.Block
	gameId      int
	realclients map[int]ClientData
	gameclient  *client.Client
	cycle       int
	mu          sync.Mutex
}

func NewGame() *Game {
	g := &Game{
		gameclient: client.NewClient(),
		blocky:     elements.NewBlock(),
		hitblocky:  elements.NewBlock(),
		cycle:      0,
		name:       namelist[rand.Intn(len(namelist))],
	}

	g.hitblocky.SetHit(true)

	g.blocky.SetPosition(gamedata.Coordinates{X: float64(screenWidth) / 2, Y: float64(screenHeight) / 2})

	g.realclients = make(map[int]ClientData)

	//g.gameId = g.gameclient.GetIdentity()
	go g.gameclient.ReadData(g.HandleServerData)
	return g
}

func (g *Game) Update() error {

	g.HandleInput()

	//broadcast our position
	//if g.cycle%2 == 0 {
	if g.gameclient.IsConnected() {
		cd := &pb.ClientCoordinates{
			Name: g.name,
			Coordinates: &pb.Coordinates{
				X: g.blocky.GetPosition().X, //g.position.X,
				Y: g.blocky.GetPosition().Y, //g.position.Y,
			},
		}

		envelope := &pb.ClientEnvelope{
			Payload: &pb.ClientEnvelope_Coordinates{
				Coordinates: cd,
			},
		}

		g.gameclient.SendMessage(envelope)

	}
	//}

	g.cycle++
	return nil
}

func (g *Game) Draw(screen *ebiten.Image) {
	screen.Clear()

	g.blocky.Draw()
	g.hitblocky.Draw()

	op := &ebiten.DrawImageOptions{}
	op.GeoM.Translate(-float64(g.blocky.Sprite.Bounds().Dx())/2, -float64(g.blocky.Sprite.Bounds().Dy())/2)
	op.GeoM.Translate(g.blocky.GetPosition().X, g.blocky.GetPosition().Y)
	screen.DrawImage(g.blocky.Sprite, op)
	f2 := &text.GoTextFace{
		Source: fonts.LaunchyFont.New,
		Size:   12,
	}
	top := &text.DrawOptions{}
	top.GeoM.Translate(g.blocky.GetPosition().X-50, g.blocky.GetPosition().Y+15)
	text.Draw(screen, "you ("+g.name+")", f2, top)

	g.mu.Lock()
	clientcopy := maps.Clone(g.realclients)
	g.mu.Unlock()
	for _, client := range clientcopy {
		op := &ebiten.DrawImageOptions{}
		op.GeoM.Translate(-float64(g.blocky.Sprite.Bounds().Dx())/2, -float64(g.blocky.Sprite.Bounds().Dy())/2)
		op.GeoM.Translate(client.Position.X, client.Position.Y)
		if !client.Hit {
			screen.DrawImage(g.blocky.Sprite, op)
		} else {
			screen.DrawImage(g.hitblocky.Sprite, op)
		}

		f2 := &text.GoTextFace{
			Source: fonts.LaunchyFont.New,
			Size:   12,
		}
		top := &text.DrawOptions{}
		top.GeoM.Translate(client.Position.X, client.Position.Y)
		text.Draw(screen, client.Name, f2, top)
	}

}

func (g *Game) Layout(outsideWidth, outsideHeight int) (screenwidth, screenheight int) {
	return screenWidth, screenHeight
}

func (g *Game) HandleServerData(envelope *pb.ServerEnvelope) {

	switch payload := envelope.Payload.(type) {
	case *pb.ServerEnvelope_Broadcast:
		//fmt.Println("Here comes the broadcast!")

		for _, client := range payload.Broadcast.Clients {
			if client.Id != int32(g.gameId) {
				update := ClientData{
					Id:      int(client.Id),
					Address: client.Address,
					Name:    client.Name,
					Position: gamedata.Coordinates{
						X: client.Coordinates.X,
						Y: client.Coordinates.Y,
					},
					Hit: client.Hit,
				}

				g.mu.Lock()
				g.realclients[int(client.Id)] = update
				g.mu.Unlock()
			} else {
				g.blocky.SetHit(client.Hit)
			}
		}
	case *pb.ServerEnvelope_Event:
		//add or remove client from client list
		if payload.Event.Connected && payload.Event.Id != int32(g.gameId) {
			realclient := ClientData{
				Id: int(payload.Event.Id),
			}
			g.realclients[int(payload.Event.Id)] = realclient
		} else {
			delete(g.realclients, int(payload.Event.Id))
		}
	case *pb.ServerEnvelope_Identity:
		fmt.Println("Server is trying to give us our id.")
		g.gameId = int(payload.Identity.Id)
	}
}

func (g *Game) HandleInput() {

	dx := 0
	dy := 0
	if ebiten.IsKeyPressed(ebiten.KeyW) {
		dy = -movementLimit
	}
	if ebiten.IsKeyPressed(ebiten.KeyS) {
		dy = +movementLimit
	}
	if ebiten.IsKeyPressed(ebiten.KeyA) {
		dx = -movementLimit
	}
	if ebiten.IsKeyPressed(ebiten.KeyD) {
		dx = +movementLimit
	}
	cpos := g.blocky.GetPosition()
	cpos.X += float64(dx)
	cpos.Y += float64(dy)
	g.blocky.SetPosition(cpos)
}