342 lines
8.2 KiB
Go
342 lines
8.2 KiB
Go
package game
|
|
|
|
import (
|
|
"client/client"
|
|
"client/elements"
|
|
"client/fonts"
|
|
"client/gamedata"
|
|
"client/pb"
|
|
"fmt"
|
|
"image/color"
|
|
"maps"
|
|
"math"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2"
|
|
"github.com/hajimehoshi/ebiten/v2/inpututil"
|
|
"github.com/hajimehoshi/ebiten/v2/text/v2"
|
|
"github.com/hajimehoshi/ebiten/v2/vector"
|
|
"golang.org/x/exp/rand"
|
|
)
|
|
|
|
const (
|
|
screenWidth = 640
|
|
screenHeight = 480
|
|
movementLimit = 5
|
|
stageRadius = 200
|
|
)
|
|
|
|
var (
|
|
namelist = []string{"slappy", "mick", "rodney", "george", "ringo",
|
|
"robin", "temitry", "evangeline", "ron", "abigail", "lester",
|
|
"maynard", "agnes", "stacey", "wendell", "susanne", "myrtle",
|
|
"teresa", "kristi", "genos", "felton", "lawrence", "rosie",
|
|
"nigel", "constance", "maryellen", "dollie", "markus",
|
|
"dorthy", "lazaro", "willa", "dino", "gustavo", "conrad",
|
|
"georgia", "lucinda", "saitama"}
|
|
)
|
|
|
|
func init() {
|
|
rand.Seed(uint64(time.Now().UnixNano()))
|
|
}
|
|
|
|
type ClientData struct {
|
|
Id int
|
|
Address string
|
|
Name string
|
|
Position gamedata.Coordinates
|
|
Hit bool
|
|
Eliminated bool
|
|
}
|
|
|
|
type Game struct {
|
|
name string
|
|
blocky *elements.Block
|
|
hitblocky *elements.Block
|
|
elimblocky *elements.Block
|
|
gameId int
|
|
realclients map[int]ClientData
|
|
gameclient *client.Client
|
|
cycle int
|
|
mu sync.Mutex
|
|
|
|
//similar fields that we see in the client list, but for us
|
|
eliminated bool
|
|
hit bool
|
|
|
|
dino *elements.Dino
|
|
}
|
|
|
|
func NewGame() *Game {
|
|
g := &Game{
|
|
gameclient: client.NewClient(),
|
|
blocky: elements.NewBlock(),
|
|
hitblocky: elements.NewBlock(),
|
|
elimblocky: elements.NewBlock(),
|
|
cycle: 0,
|
|
name: namelist[rand.Intn(len(namelist))],
|
|
dino: elements.NewDino(gamedata.DinoTypeGreen),
|
|
}
|
|
|
|
g.blocky.SetColor(color.RGBA{R: 0xff, G: 0x00, B: 0x00, A: 0xff})
|
|
g.hitblocky.SetColor(color.RGBA{R: 0x00, G: 0xff, B: 0xff, A: 0xff})
|
|
g.elimblocky.SetColor(color.RGBA{R: 0x00, G: 0x00, B: 0xff, A: 0xff})
|
|
|
|
g.blocky.SetPosition(gamedata.Coordinates{X: float64(screenWidth) / 2, Y: float64(screenHeight) / 2})
|
|
g.blocky.SetTargetPosition(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.blocky.Update()
|
|
g.dino.Update()
|
|
//g.hitblocky.Update()
|
|
|
|
g.HandleInput()
|
|
g.SendPosition()
|
|
|
|
g.cycle++
|
|
return nil
|
|
}
|
|
|
|
func (g *Game) Draw(screen *ebiten.Image) {
|
|
screen.Clear()
|
|
|
|
g.blocky.Draw()
|
|
g.hitblocky.Draw()
|
|
g.elimblocky.Draw()
|
|
|
|
vector.StrokeCircle(screen, float32(screenWidth)/2, float32(screenHeight)/2, stageRadius, 3, color.White, true)
|
|
|
|
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)
|
|
if !g.eliminated {
|
|
if !g.hit {
|
|
screen.DrawImage(g.blocky.Sprite, op)
|
|
} else {
|
|
screen.DrawImage(g.hitblocky.Sprite, op)
|
|
}
|
|
} else {
|
|
screen.DrawImage(g.elimblocky.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.Eliminated {
|
|
screen.DrawImage(g.elimblocky.Sprite, op)
|
|
} else {
|
|
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)
|
|
}
|
|
|
|
g.dino.Draw()
|
|
dop := &ebiten.DrawImageOptions{}
|
|
dop.GeoM.Translate(-float64(g.dino.Sprite.Bounds().Dx())/2, -float64(g.dino.Sprite.Bounds().Dy())/2)
|
|
dop.GeoM.Translate(g.blocky.GetPosition().X, g.blocky.GetPosition().Y)
|
|
screen.DrawImage(g.dino.Sprite, dop)
|
|
|
|
}
|
|
|
|
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,
|
|
Eliminated: client.Eliminated,
|
|
}
|
|
|
|
g.mu.Lock()
|
|
g.realclients[int(client.Id)] = update
|
|
g.mu.Unlock()
|
|
} else {
|
|
g.eliminated = client.Eliminated
|
|
g.hit = client.Hit
|
|
//this is us
|
|
|
|
//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: ", payload.Identity.Id)
|
|
g.gameId = int(payload.Identity.Id)
|
|
case *pb.ServerEnvelope_Gameevent:
|
|
//fmt.Printf("someone slapping! target:%d, instigator:%d isSlap:%d", payload.Gameevent.Target, payload.Gameevent.Instigator, payload.Gameevent.Slap)
|
|
|
|
switch payload.Gameevent.Event.(type) {
|
|
case *pb.GameEvent_Slap:
|
|
if payload.Gameevent.Target == int32(g.gameId) {
|
|
g.mu.Lock()
|
|
dx := g.blocky.GetPosition().X - g.realclients[int(payload.Gameevent.Instigator)].Position.X
|
|
dy := g.blocky.GetPosition().Y - g.realclients[int(payload.Gameevent.Instigator)].Position.Y
|
|
g.mu.Unlock()
|
|
|
|
if dx != 0 {
|
|
dx = (dx / math.Abs(dx)) * 100
|
|
}
|
|
if dy != 0 {
|
|
dy = (dy / math.Abs(dy)) * 100
|
|
}
|
|
if dx == 0 && dy == 0 {
|
|
b := rand.Intn(2)
|
|
if b == 0 {
|
|
dx = 100
|
|
dy = 100
|
|
} else {
|
|
dx = -100
|
|
dy = -100
|
|
}
|
|
}
|
|
|
|
cpos := gamedata.Coordinates{}
|
|
cpos.X = g.blocky.GetPosition().X + dx
|
|
cpos.Y = g.blocky.GetPosition().Y + dy
|
|
g.blocky.SetTargetPosition(cpos)
|
|
}
|
|
case *pb.GameEvent_Eliminated:
|
|
fmt.Println("someone eliminated...", payload.Gameevent.Target)
|
|
|
|
/*
|
|
g.mu.Lock()
|
|
client := g.realclients[int(payload.Gameevent.Target)]
|
|
client.Eliminated = true
|
|
g.realclients[int(payload.Gameevent.Target)] = client
|
|
g.mu.Unlock()
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
g.dino.SetLeft(true)
|
|
}
|
|
if ebiten.IsKeyPressed(ebiten.KeyD) {
|
|
dx = +movementLimit
|
|
g.dino.SetLeft(false)
|
|
}
|
|
|
|
if math.Abs(float64(dx)) > 0 || math.Abs(float64(dy)) > 0 {
|
|
g.dino.SetAction(gamedata.DinoActionWalk)
|
|
} else {
|
|
g.dino.SetAction(gamedata.DinoActionIdle)
|
|
}
|
|
|
|
cpos := g.blocky.GetPosition()
|
|
cpos.X += float64(dx)
|
|
cpos.Y += float64(dy)
|
|
g.blocky.SetTargetPosition(cpos)
|
|
|
|
if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
|
|
g.SendSlap()
|
|
g.dino.SetAction(gamedata.DinoActionSlap)
|
|
}
|
|
|
|
}
|
|
|
|
func (g *Game) SendPosition() {
|
|
//broadcast our position
|
|
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)
|
|
}
|
|
}
|
|
|
|
func (g *Game) SendSlap() {
|
|
if g.gameclient.IsConnected() {
|
|
slap := &pb.SlapEvent{
|
|
Slap: true,
|
|
}
|
|
envelope := &pb.ClientEnvelope{
|
|
Payload: &pb.ClientEnvelope_Slap{
|
|
Slap: slap,
|
|
},
|
|
}
|
|
|
|
g.gameclient.SendMessage(envelope)
|
|
}
|
|
}
|