381 lines
13 KiB
Go
381 lines
13 KiB
Go
package main
|
|
|
|
/*
|
|
#cgo CFLAGS: -I ${SRCDIR}/lib
|
|
#cgo LDFLAGS: -L ${SRCDIR}/lib -l ffi_wrapper
|
|
#include "ffi-wrapper.h"
|
|
#include <stdlib.h>
|
|
*/
|
|
import "C"
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"math"
|
|
"slices"
|
|
|
|
"github.com/heroiclabs/nakama-common/runtime"
|
|
)
|
|
|
|
const (
|
|
MATCH_LOADING = iota
|
|
MATCH_START
|
|
STATE_UPDATE
|
|
FINAL_PHASE
|
|
MATCH_END
|
|
)
|
|
|
|
const (
|
|
BULLET_LINEAR = 0
|
|
)
|
|
|
|
const (
|
|
STAGE_WIDTH float64 = 90.0
|
|
STAGE_HEIGHT float64 = 160.0
|
|
BULLET_KILL_BUFFER_WIDTH float64 = 16.0
|
|
PLAYER_HIT_COL_RADIUS_MULTIPLIER float64 = 0.01
|
|
PLAYER_GRAZE_COL_RADIUS_MULTIPLIER float64 = 0.04
|
|
PLAYER_DEATH_TIMER_MAX int = 180
|
|
GRAZE_ADDITION_MULTIPLIER int = 1000
|
|
)
|
|
|
|
// Interface for registering match handlers
|
|
type BattleRoyaleMatch struct{}
|
|
|
|
type PlayerStageState struct {
|
|
hitCol *C.Circle
|
|
grazeCol *C.Circle
|
|
bullets []*C.Bullet
|
|
updatePlayerPos bool
|
|
health int
|
|
graze int
|
|
score int
|
|
deathTimer int
|
|
}
|
|
|
|
type PlayerUpdate struct {
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
}
|
|
|
|
type GameTickUpdate struct {
|
|
Tick int64 `json:"tick"`
|
|
PlayerHitPos map[string]interface{} `json:"playerHitPos"`
|
|
PlayerGrazePos map[string]interface{} `json:"playerGrazePos"`
|
|
NewBullets []map[string]interface{} `json:"newBullets"`
|
|
ForcePlayerPos bool `json:"forcePlayerPos"`
|
|
DeathTimer int `json:"deathTimer"`
|
|
Graze int `json:"graze"`
|
|
}
|
|
|
|
type PresenceState struct { // present time! hahahahahahahah!
|
|
presence runtime.Presence
|
|
stageState PlayerStageState
|
|
}
|
|
|
|
type BattleRoyaleMatchState struct {
|
|
tickRate int
|
|
currentMatchPhase int
|
|
presences map[string]*PresenceState
|
|
emptyTicks int
|
|
}
|
|
|
|
// Run on match start, initializes game state and sets tick rate
|
|
func (m *BattleRoyaleMatch) MatchInit(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, params map[string]interface{}) (interface{}, int, string) {
|
|
tickRate := 60 // MatchLoop invocations per second
|
|
state := &BattleRoyaleMatchState{
|
|
tickRate: tickRate,
|
|
presences: map[string]*PresenceState{},
|
|
emptyTicks: 0,
|
|
currentMatchPhase: MATCH_LOADING,
|
|
}
|
|
label := ""
|
|
|
|
return state, tickRate, label
|
|
}
|
|
|
|
// Run when a user attempts to join or rejoin a match. Responsible for deciding whether or not to let them in.
|
|
func (m *BattleRoyaleMatch) MatchJoinAttempt(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presence runtime.Presence, metadata map[string]string) (interface{}, bool, string) {
|
|
lobbyState, ok := state.(*BattleRoyaleMatchState)
|
|
if !ok {
|
|
logger.Error("State is not a valid lobby state object for MatchJoin.")
|
|
return nil, false, "Failed to join match: match does not exist."
|
|
}
|
|
accepted := true
|
|
rejectedMessage := ""
|
|
|
|
return lobbyState, accepted, rejectedMessage
|
|
}
|
|
|
|
// Run when a user successfully joins a match, registers their presence in the game state
|
|
func (m *BattleRoyaleMatch) MatchJoin(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presences []runtime.Presence) interface{} {
|
|
lobbyState, ok := state.(*BattleRoyaleMatchState)
|
|
if !ok {
|
|
logger.Error("State is not a valid lobby state object for MatchJoin.")
|
|
return nil
|
|
}
|
|
|
|
for i := 0; i < len(presences); i++ {
|
|
lobbyState.presences[presences[i].GetSessionId()] = &PresenceState{
|
|
presence: presences[i],
|
|
stageState: PlayerStageState{
|
|
hitCol: C.new_circle(C.double(STAGE_WIDTH*0.5), C.double(STAGE_HEIGHT-STAGE_HEIGHT*0.1), C.double(STAGE_WIDTH*PLAYER_HIT_COL_RADIUS_MULTIPLIER)),
|
|
grazeCol: C.new_circle(C.double(STAGE_WIDTH*0.5), C.double(STAGE_HEIGHT-STAGE_HEIGHT*0.1), C.double(STAGE_WIDTH*PLAYER_GRAZE_COL_RADIUS_MULTIPLIER)),
|
|
bullets: []*C.Bullet{},
|
|
updatePlayerPos: true,
|
|
health: 3,
|
|
deathTimer: -1,
|
|
},
|
|
}
|
|
}
|
|
|
|
return lobbyState
|
|
}
|
|
|
|
// Run when a user successfully leaves a match, de-registers their presence in the game state
|
|
func (m *BattleRoyaleMatch) MatchLeave(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presences []runtime.Presence) interface{} {
|
|
lobbyState, ok := state.(*BattleRoyaleMatchState)
|
|
if !ok {
|
|
logger.Error("State is not a valid lobby state object for MatchLeave.")
|
|
return nil
|
|
}
|
|
|
|
for i := 0; i < len(presences); i++ {
|
|
sessionID := presences[i].GetSessionId()
|
|
|
|
playerState, exists := lobbyState.presences[sessionID]
|
|
if exists {
|
|
for _, bullet := range playerState.stageState.bullets {
|
|
C.destroy_bullet(bullet)
|
|
}
|
|
C.destroy_circle(playerState.stageState.hitCol)
|
|
C.destroy_circle(playerState.stageState.grazeCol)
|
|
delete(lobbyState.presences, sessionID)
|
|
}
|
|
}
|
|
|
|
return lobbyState
|
|
}
|
|
|
|
// Run when a match gets an arbitrary signal from the Nakama runtime (probably from the matchmaker/match lister APIs)
|
|
func (m *BattleRoyaleMatch) MatchSignal(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, data string) (interface{}, string) {
|
|
lobbyState, ok := state.(*BattleRoyaleMatchState)
|
|
if !ok {
|
|
logger.Error("State is not a valid lobby state object for MatchSignal.")
|
|
return nil, "Failed to get valid state for return signal"
|
|
}
|
|
|
|
returnMessage := ""
|
|
return lobbyState, returnMessage
|
|
}
|
|
|
|
// Run when the server enters the graceful shutdown flow. Gives the match a chance to shutdown cleanly within graceSeconds.
|
|
func (m *BattleRoyaleMatch) MatchTerminate(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, graceSeconds int) interface{} {
|
|
lobbyState, ok := state.(*BattleRoyaleMatchState)
|
|
if !ok {
|
|
logger.Error("State is not a valid lobby state object for MatchTerminate.")
|
|
return nil
|
|
}
|
|
|
|
return lobbyState
|
|
}
|
|
|
|
// Main game loop, executed at tickRate per second specified in MatchInit
|
|
func (m *BattleRoyaleMatch) MatchLoop(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, messages []runtime.MatchData) interface{} {
|
|
lobbyState, ok := state.(*BattleRoyaleMatchState)
|
|
if !ok {
|
|
logger.Error("State is not a valid lobby state object for MatchLoop.")
|
|
return nil
|
|
}
|
|
|
|
// If we have no presences in the match according to the match state, increment the empty ticks count
|
|
if len(lobbyState.presences) == 0 {
|
|
lobbyState.emptyTicks++
|
|
}
|
|
|
|
// If the match has been empty for more than 100 ticks, end the match by returning nil
|
|
if lobbyState.emptyTicks > 100 {
|
|
return nil
|
|
}
|
|
|
|
// Respond to player input
|
|
for _, msg := range messages {
|
|
// Validate player existence
|
|
_, exists := lobbyState.presences[msg.GetSessionId()]
|
|
if !exists {
|
|
logger.Warn("Received input for non-existent player session ID: %v", msg.GetSessionId())
|
|
continue
|
|
}
|
|
|
|
// Parse player message
|
|
var update PlayerUpdate
|
|
if err := json.Unmarshal(msg.GetData(), &update); err != nil {
|
|
logger.Warn("Failed to parse input: %v", err)
|
|
continue
|
|
}
|
|
|
|
// Player movement bounds detection
|
|
clampedX := update.X < 0 || update.X > STAGE_WIDTH
|
|
clampedY := update.Y < 0 || update.Y > STAGE_HEIGHT
|
|
|
|
update.X = math.Max(0, math.Min(update.X, STAGE_WIDTH))
|
|
update.Y = math.Max(0, math.Min(update.Y, STAGE_HEIGHT))
|
|
|
|
lobbyState.presences[msg.GetSessionId()].stageState.hitCol.x = C.double(update.X)
|
|
lobbyState.presences[msg.GetSessionId()].stageState.hitCol.y = C.double(update.Y)
|
|
|
|
lobbyState.presences[msg.GetSessionId()].stageState.grazeCol.x = C.double(update.X)
|
|
lobbyState.presences[msg.GetSessionId()].stageState.grazeCol.y = C.double(update.Y)
|
|
|
|
if clampedX || clampedY {
|
|
lobbyState.presences[msg.GetSessionId()].stageState.updatePlayerPos = true
|
|
}
|
|
}
|
|
|
|
// Compute and broadcast per-presence state
|
|
for _, v := range lobbyState.presences {
|
|
// Clean up bullets when they pass off the board
|
|
v.stageState.bullets = slices.DeleteFunc(v.stageState.bullets, func(b *C.Bullet) bool {
|
|
if C.bullet_beyond_kill_boundary(b, C.int64_t(tick)) {
|
|
C.destroy_bullet(b)
|
|
return true
|
|
}
|
|
return false
|
|
})
|
|
|
|
// If the player is dead. Decrement the death timer
|
|
if v.stageState.deathTimer >= 0 {
|
|
v.stageState.deathTimer -= 1
|
|
}
|
|
|
|
if v.stageState.deathTimer == 0 { // If the player's death timer has run out, reset them. 0 is a special deathTimer tick that indicates reset to the clients.
|
|
v.stageState.hitCol.x = C.double(STAGE_WIDTH * 0.5)
|
|
v.stageState.hitCol.y = C.double(STAGE_HEIGHT - STAGE_HEIGHT*0.1)
|
|
|
|
v.stageState.grazeCol.x = C.double(STAGE_WIDTH * 0.5)
|
|
v.stageState.grazeCol.y = C.double(STAGE_HEIGHT - STAGE_HEIGHT*0.1)
|
|
|
|
v.stageState.updatePlayerPos = true
|
|
} else if v.stageState.deathTimer == -1 { // If the player is alive, check if the player collided with a bullet and kill them if so
|
|
if slices.ContainsFunc(v.stageState.bullets, func(b *C.Bullet) bool {
|
|
return bool(C.bullet_collides_with(b, C.int64_t(tick), v.stageState.hitCol))
|
|
}) {
|
|
v.stageState.deathTimer = PLAYER_DEATH_TIMER_MAX
|
|
} else if slices.ContainsFunc(v.stageState.bullets, func(b *C.Bullet) bool { // Otherwise, check the graze col and increment the graze and score
|
|
return bool(C.bullet_collides_with(b, C.int64_t(tick), v.stageState.grazeCol))
|
|
}) {
|
|
v.stageState.graze += GRAZE_ADDITION_MULTIPLIER
|
|
}
|
|
}
|
|
|
|
var newBulletsToBroadcast = []map[string]interface{}{}
|
|
|
|
if tick%30 == 0 && v.stageState.deathTimer == -1 {
|
|
numBullets := 20
|
|
spreadAngle := 60.0 // Spread in degrees
|
|
startAngle := 90 - (spreadAngle / 2)
|
|
bulletSpeed := STAGE_WIDTH / float64(lobbyState.tickRate) / 3
|
|
bulletRadiusMult := 0.03
|
|
|
|
// Define a single spawn point near the top of the screen
|
|
spawnX := STAGE_WIDTH / 2 // Centered horizontally
|
|
spawnY := STAGE_HEIGHT * 0.1 // 10% from the top
|
|
|
|
for i := 0; i < numBullets; i++ {
|
|
angle := startAngle + (spreadAngle/float64(numBullets-1))*float64(i)
|
|
angleRad := angle * (math.Pi / 180.0)
|
|
|
|
velx := bulletSpeed * math.Cos(angleRad)
|
|
vely := bulletSpeed * math.Sin(angleRad)
|
|
|
|
bullet := C.new_bullet(
|
|
C.uint8_t(BULLET_LINEAR),
|
|
C.int64_t(tick),
|
|
C.double(spawnX), // Fixed X start position
|
|
C.double(spawnY), // Fixed Y start position
|
|
C.double(bulletRadiusMult*STAGE_WIDTH), // Fixed radius
|
|
C.double(velx),
|
|
C.double(vely),
|
|
)
|
|
|
|
v.stageState.bullets = append(v.stageState.bullets, bullet)
|
|
|
|
var x, y C.double
|
|
C.bullet_get_current_pos(bullet, C.int64_t(tick), &x, &y)
|
|
|
|
bulletData := map[string]interface{}{
|
|
"class": BULLET_LINEAR,
|
|
"tick": tick,
|
|
"x": float64(x),
|
|
"y": float64(y),
|
|
"radius_multiplier": bulletRadiusMult,
|
|
"vel_x": velx,
|
|
"vel_y": vely,
|
|
}
|
|
|
|
newBulletsToBroadcast = append(newBulletsToBroadcast, bulletData)
|
|
}
|
|
}
|
|
|
|
var tickData = GameTickUpdate{
|
|
Tick: tick,
|
|
PlayerHitPos: map[string]interface{}{
|
|
"x": v.stageState.hitCol.x,
|
|
"y": v.stageState.hitCol.y,
|
|
"radius_multiplier": PLAYER_HIT_COL_RADIUS_MULTIPLIER,
|
|
},
|
|
PlayerGrazePos: map[string]interface{}{
|
|
"x": v.stageState.grazeCol.x,
|
|
"y": v.stageState.grazeCol.y,
|
|
"radius_multiplier": PLAYER_GRAZE_COL_RADIUS_MULTIPLIER,
|
|
},
|
|
NewBullets: newBulletsToBroadcast,
|
|
ForcePlayerPos: v.stageState.updatePlayerPos,
|
|
DeathTimer: v.stageState.deathTimer,
|
|
Graze: v.stageState.graze,
|
|
}
|
|
|
|
v.stageState.updatePlayerPos = false
|
|
|
|
data, err := json.Marshal(tickData)
|
|
if err != nil {
|
|
logger.Error("Error marshalling bullet data", err)
|
|
} else {
|
|
reliable := true
|
|
dispatcher.BroadcastMessage(STATE_UPDATE, data, nil, nil, reliable)
|
|
}
|
|
}
|
|
|
|
return lobbyState
|
|
}
|
|
|
|
// RPC for force-creating a match for debugging/development, separate from the matchmaking process
|
|
func ManualForceCreateBRMatchRPC(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, payload string) (string, error) {
|
|
modulename := "battle-royale"
|
|
|
|
if matchId, err := nk.MatchCreate(ctx, modulename, make(map[string]interface{})); err != nil {
|
|
return "", err
|
|
} else {
|
|
return matchId, nil
|
|
}
|
|
}
|
|
|
|
// main function for hooking into the nakama runtime, responsible for setting up all handlers
|
|
func InitModule(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, initializer runtime.Initializer) error {
|
|
// Register handlers for match lifecycle
|
|
if err := initializer.RegisterMatch("battle-royale", func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule) (runtime.Match, error) {
|
|
return &BattleRoyaleMatch{}, nil
|
|
}); err != nil {
|
|
logger.Error("Unable to register match handler: %v", nil)
|
|
return err
|
|
}
|
|
|
|
// Register RPCs
|
|
if err := initializer.RegisterRpc("manual_force_create_br_match_rpc", ManualForceCreateBRMatchRPC); err != nil {
|
|
logger.Error("Unable to register: %v", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|