367 lines
8.9 KiB
Go
367 lines
8.9 KiB
Go
package botserv
|
|
|
|
// delete me
|
|
|
|
import (
|
|
"log"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
|
|
"bitbucket.org/smcquay/bandwidth"
|
|
)
|
|
|
|
const maxPlayer = 128
|
|
|
|
// BotHealth is sent to all players so they know how other robots are
|
|
// doing.
|
|
type BotHealth struct {
|
|
RobotId string `json:"robot_id"`
|
|
Health int `json:"health"`
|
|
}
|
|
|
|
// Scanner contains a Robot/Projectile hash and is sent to the user to
|
|
// let them know which things they know about.
|
|
type Scanner struct {
|
|
Id string `json:"id"`
|
|
Type string `json:"type"`
|
|
}
|
|
|
|
// BotStats is stats for a single Player's Robot.
|
|
type BotStats struct {
|
|
Kills int
|
|
Deaths int
|
|
Suicides int
|
|
Shots int
|
|
DirectHits int
|
|
Hits int
|
|
Wins int
|
|
}
|
|
|
|
// PlayerStats is what you want many of. Contains a map of BotStats and total
|
|
// wins.
|
|
type PlayerStats struct {
|
|
BotStats map[string]*BotStats
|
|
Wins int
|
|
}
|
|
|
|
// GameStats is a collection of PlayerStats for all players involved.
|
|
type GameStats struct {
|
|
PlayerStats map[string]*PlayerStats
|
|
sync.RWMutex
|
|
}
|
|
|
|
// Game is the main point of interest in this application. Embodies all info
|
|
// required to keep track of players, robots, stats, projectils, etc.
|
|
// Currently Controllers have a map of these.
|
|
type Game struct {
|
|
id string
|
|
players map[*Player]bool
|
|
projectiles map[*Projectile]bool
|
|
splosions map[*Splosion]bool
|
|
obstacles []Obstacle
|
|
obstacle_count int
|
|
register chan *Player
|
|
unregister chan *Player
|
|
turn int
|
|
players_remaining int
|
|
width, height float32
|
|
maxPoints int
|
|
spectators map[*Spectator]bool
|
|
sregister chan *Spectator
|
|
sunregister chan *Spectator
|
|
kill chan bool
|
|
repair_hp int
|
|
repair_rate float32
|
|
tick_duration int
|
|
stats GameStats
|
|
mode GameMode
|
|
bw *bandwidth.Bandwidth
|
|
}
|
|
|
|
// This is the interface that different gametypes should implement.
|
|
type GameMode interface {
|
|
setup(g *Game)
|
|
tick(gg *Game, payload *Boardstate)
|
|
gameOver(gg *Game) (bool, *GameOver)
|
|
}
|
|
|
|
// NewGame Poplulates a Game struct and starts the bandwidth calculator.
|
|
func NewGame(id string, width, height float32, obstacles, tick, maxPoints int, mode string) (*Game, error) {
|
|
bw, err := bandwidth.NewBandwidth(
|
|
[]int{1, 10, 60},
|
|
1*time.Second,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
go bw.Run()
|
|
g := &Game{
|
|
id: id,
|
|
register: make(chan *Player, maxPlayer),
|
|
unregister: make(chan *Player, maxPlayer),
|
|
projectiles: make(map[*Projectile]bool),
|
|
splosions: make(map[*Splosion]bool),
|
|
obstacles: GenerateObstacles(obstacles, width, height),
|
|
obstacle_count: obstacles,
|
|
players: make(map[*Player]bool),
|
|
turn: 0,
|
|
width: width,
|
|
height: height,
|
|
maxPoints: maxPoints,
|
|
spectators: make(map[*Spectator]bool),
|
|
sregister: make(chan *Spectator),
|
|
sunregister: make(chan *Spectator),
|
|
kill: make(chan bool),
|
|
repair_hp: 5,
|
|
repair_rate: 3.0,
|
|
tick_duration: tick,
|
|
players_remaining: 2,
|
|
stats: GameStats{PlayerStats: make(map[string]*PlayerStats)},
|
|
bw: bw,
|
|
}
|
|
|
|
if mode == "melee" {
|
|
g.mode = &melee{respawn: make(map[*Robot]float64)}
|
|
} else {
|
|
g.mode = &deathmatch{}
|
|
}
|
|
|
|
g.mode.setup(g)
|
|
|
|
return g, nil
|
|
}
|
|
|
|
// tick is the method called every TICK ms.
|
|
func (g *Game) tick(payload *Boardstate) {
|
|
g.players_remaining = 0
|
|
payload.Objects = MinifyObstacles(g.obstacles)
|
|
|
|
// Update Players
|
|
for p := range g.players {
|
|
living_robots := 0
|
|
|
|
for _, r := range p.Robots {
|
|
if r.Health > 0 {
|
|
living_robots++
|
|
r.Tick(g)
|
|
}
|
|
|
|
if len(r.Message) > 0 {
|
|
if len(r.Message) > 100 {
|
|
r.Message = r.Message[0:99]
|
|
}
|
|
payload.Messages = append(payload.Messages, r.Message)
|
|
}
|
|
|
|
payload.OtherRobots = append(
|
|
payload.OtherRobots,
|
|
r.GetTruncatedDetails())
|
|
|
|
payload.AllBots = append(
|
|
payload.AllBots,
|
|
BotHealth{RobotId: r.Id, Health: r.Health})
|
|
}
|
|
|
|
if living_robots > 0 {
|
|
g.players_remaining++
|
|
}
|
|
}
|
|
|
|
// Update Projectiles
|
|
for pr := range g.projectiles {
|
|
pr.Tick(g)
|
|
}
|
|
|
|
// We do this here, because the tick calls can alter g.projectiles
|
|
for pr := range g.projectiles {
|
|
payload.Projectiles = append(payload.Projectiles, *pr)
|
|
}
|
|
|
|
// Update Splosions
|
|
for s := range g.splosions {
|
|
s.Tick()
|
|
if !s.Alive() {
|
|
delete(g.splosions, s)
|
|
}
|
|
payload.Splosions = append(payload.Splosions, *s)
|
|
}
|
|
}
|
|
|
|
// sendUpdate is what we use to determine what data goes out to each client;
|
|
// performs filtering and sorting of the data.
|
|
func (g *Game) sendUpdate(payload *Boardstate) {
|
|
// Ensure that the robots are always sent in a consistent order
|
|
sort.Sort(RobotSorter{Robots: payload.OtherRobots})
|
|
sort.Sort(AllRobotSorter{Robots: payload.AllBots})
|
|
|
|
for p := range g.players {
|
|
|
|
// Copy the payload but only add the robots in scanner range
|
|
player_payload := NewBoardstate()
|
|
player_payload.Messages = payload.Messages
|
|
player_payload.AllBots = payload.AllBots
|
|
player_payload.Turn = payload.Turn
|
|
|
|
for _, r := range p.Robots {
|
|
player_payload.MyRobots = append(player_payload.MyRobots, *r)
|
|
// player_payload.OtherRobots = append(
|
|
// player_payload.OtherRobots,
|
|
// r.GetTruncatedDetails())
|
|
}
|
|
|
|
player_payload.Objects = [][4]int{}
|
|
player_payload.Splosions = []Splosion{}
|
|
player_payload.Projectiles = []Projectile{}
|
|
living_robots := 0
|
|
|
|
for _, r := range p.Robots {
|
|
if r.Health > 0 {
|
|
living_robots++
|
|
|
|
// Filter robots by scanner
|
|
for player := range g.players {
|
|
for _, scan_entry := range r.Scanners {
|
|
for _, r := range player.Robots {
|
|
if r.Id == scan_entry.Id {
|
|
player_payload.OtherRobots = append(
|
|
player_payload.OtherRobots,
|
|
r.GetTruncatedDetails())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Filter projectiles
|
|
for proj := range g.projectiles {
|
|
|
|
if proj.Owner == r {
|
|
player_payload.Projectiles = append(
|
|
player_payload.Projectiles,
|
|
*proj)
|
|
}
|
|
|
|
for _, scan_entry := range r.Scanners {
|
|
if proj.Id == scan_entry.Id {
|
|
player_payload.Projectiles = append(
|
|
player_payload.Projectiles,
|
|
*proj)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Filter splosions
|
|
for splo := range g.splosions {
|
|
for _, scan_entry := range r.Scanners {
|
|
if splo.Id == scan_entry.Id {
|
|
player_payload.Splosions = append(
|
|
player_payload.Splosions,
|
|
*splo)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Filter objects
|
|
for _, ob := range g.obstacles {
|
|
if ob.distance_from_point(r.Position) < float32(r.Stats.ScannerRadius)+r.ScanCounter {
|
|
player_payload.Objects = append(
|
|
player_payload.Objects, ob.minify())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if living_robots == 0 {
|
|
// player_payload.OtherRobots = payload.OtherRobots
|
|
// player_payload.Projectiles = payload.Projectiles
|
|
// player_payload.Splosions = payload.Splosions
|
|
// player_payload.Objects = payload.Objects
|
|
// }
|
|
|
|
p.send <- player_payload
|
|
}
|
|
for s := range g.spectators {
|
|
s.send <- payload
|
|
}
|
|
|
|
}
|
|
|
|
// run is the method that contians the main game loop.
|
|
func (g *Game) run() {
|
|
ticker := time.NewTicker(time.Duration(g.tick_duration) * time.Millisecond)
|
|
for {
|
|
select {
|
|
case <-g.kill:
|
|
log.Printf("game %s: received kill signal, dying gracefully", g.id)
|
|
g.bw.Quit <- true
|
|
for player := range g.players {
|
|
close(player.send)
|
|
}
|
|
return
|
|
case p := <-g.register:
|
|
log.Println("registering player:", p.Id)
|
|
g.players[p] = true
|
|
g.stats.PlayerStats[p.Id] = &PlayerStats{
|
|
BotStats: make(map[string]*BotStats),
|
|
}
|
|
for _, r := range p.Robots {
|
|
g.stats.PlayerStats[p.Id].BotStats[r.Name] = &BotStats{}
|
|
r.gameStats = g.stats.PlayerStats[p.Id].BotStats[r.Name]
|
|
}
|
|
case p := <-g.unregister:
|
|
log.Println("unregistering player:", p.Id)
|
|
delete(g.players, p)
|
|
close(p.send)
|
|
case s := <-g.sregister:
|
|
log.Println("registering spectator:", s.Id)
|
|
g.spectators[s] = true
|
|
case s := <-g.sunregister:
|
|
log.Println("unregistering spectator:", s.Id)
|
|
delete(g.spectators, s)
|
|
close(s.send)
|
|
case <-ticker.C:
|
|
payload := NewBoardstate()
|
|
|
|
g.turn++
|
|
payload.Turn = g.turn
|
|
|
|
// UPDATE GAME STATE
|
|
if end, data := g.mode.gameOver(g); end {
|
|
g.sendGameOver(data)
|
|
}
|
|
|
|
g.tick(payload)
|
|
g.mode.tick(g, payload)
|
|
|
|
// SEND THE UPDATE TO EACH PLAYER
|
|
g.sendUpdate(payload)
|
|
}
|
|
}
|
|
log.Println("run done")
|
|
}
|
|
|
|
// sendGameOver is a special method that sends a GameOver object to the clients
|
|
// instead of a normal Boardstate message.
|
|
func (g *Game) sendGameOver(eg *GameOver) {
|
|
log.Printf("sending out game over message: %+v", eg)
|
|
for p := range g.players {
|
|
p.send <- eg
|
|
}
|
|
for s := range g.spectators {
|
|
s.send <- eg
|
|
}
|
|
}
|
|
|
|
// returns a GameParam object popuplated by info from the game. This is
|
|
// used during client/server initial negociation.
|
|
func (g *Game) gameParam() *GameParam {
|
|
return &GameParam{
|
|
BoardSize: BoardSize{
|
|
Width: g.width,
|
|
Height: g.height,
|
|
},
|
|
MaxPoints: g.maxPoints,
|
|
Type: "gameparam",
|
|
}
|
|
}
|