server/robot.go

529 lines
14 KiB
Go

package server
import (
"log"
"math"
"math/rand"
v "hackerbots.us/vector"
"mcquay.me/idg"
)
// Robot contains everything the game needs to know to simulate robot behavior.
// Players have a []Robot
type Robot struct {
Id string `json:"id"`
Name string `json:"name"`
Message string `json:"-"`
Stats Stats `json:"-"`
TargetSpeed float64 `json:"target_speed"`
Speed float64 `json:"speed"`
Health int `json:"health"`
RepairCounter float64 `json:"repair"`
ScanCounter float64 `json:"scan_bonus"`
ActiveScan bool `json:"-"`
Position v.Point2d `json:"position"`
Heading v.Vector2d `json:"heading"`
DesiredHeading *v.Vector2d `json:"-"`
MoveTo *v.Point2d `json:"-"`
FireAt *v.Point2d `json:"-"`
Scanners []Scanner `json:"scanners"`
LastFired int `json:"-"`
Collision *Collision `json:"collision"`
Hit bool `json:"hit"`
Probe *v.Point2d `json:"probe"`
ProbeResult *Collision `json:"probe_result"`
gameStats *BotStats `json:"-"`
Delta float64 `json:"-"`
idg *idg.Generator
}
// Collision is basically a Point2d.
type Collision struct {
v.Point2d
Type string `json:"type"`
}
// This is the subset of data we send to players about robots
// that are not theirs.
type OtherRobot struct {
Id string `json:"id"`
Name string `json:"name"`
Position v.Point2d `json:"position"`
Heading v.Vector2d `json:"heading"`
Health int `json:"health"`
}
// GetTruncatedDetails pares down our info into an OtherRobot.
func (r Robot) GetTruncatedDetails() OtherRobot {
return OtherRobot{
Id: r.Id,
Name: r.Name,
Position: r.Position,
Heading: r.Heading,
Health: r.Health,
}
}
// RobotSorter implements sort.Interface for OtherRobot
type RobotSorter struct {
Robots []OtherRobot
}
func (s RobotSorter) Len() int {
return len(s.Robots)
}
func (s RobotSorter) Swap(i, j int) {
s.Robots[i], s.Robots[j] = s.Robots[j], s.Robots[i]
}
func (s RobotSorter) Less(i, j int) bool {
return s.Robots[i].Id < s.Robots[j].Id
}
// AllRobotSorter implements sort.Inteface for BotHealth
type AllRobotSorter struct {
Robots []BotHealth
}
func (s AllRobotSorter) Len() int {
return len(s.Robots)
}
func (s AllRobotSorter) Swap(i, j int) {
s.Robots[i], s.Robots[j] = s.Robots[j], s.Robots[i]
}
func (s AllRobotSorter) Less(i, j int) bool {
return s.Robots[i].RobotId < s.Robots[j].RobotId
}
// Stats is the point allocation for a Robot.
type Stats struct {
Hp int `json:"hp"`
Speed float64 `json:"speed"`
Acceleration float64 `json:"acceleration"`
WeaponRadius int `json:"weapon_radius"`
ScannerRadius int `json:"scanner_radius"`
TurnSpeed int `json:"turn_speed"`
FireRate int `json:"fire_rate"`
WeaponDamage int `json:"weapon_damage"`
WeaponSpeed float64 `json:"weapon_speed"`
}
// StatsRequest is the struct used in comunication with the player. We request
// stats using an integer between 1 and 100, the integer values map to sensible
// min-max ranges
type StatsRequest struct {
Hp int `json:"hp"`
Speed int `json:"speed"`
Acceleration int `json:"acceleration"`
WeaponRadius int `json:"weapon_radius"`
ScannerRadius int `json:"scanner_radius"`
TurnSpeed int `json:"turn_speed"`
FireRate int `json:"fire_rate"`
WeaponDamage int `json:"weapon_damage"`
WeaponSpeed int `json:"weapon_speed"`
}
// DeriveStats maps the 0-100 values to sensible in-game min-max values.
func DeriveStats(request StatsRequest) Stats {
s := Stats{}
// Conversion Tables
hp_min := 20.0
hp_max := 200.0
s.Hp = int((float64(request.Hp) / 100.0 * (hp_max - hp_min)) + hp_min)
speed_min := 40.0
speed_max := 250.0
s.Speed = float64(request.Speed)/100.0*(speed_max-speed_min) + speed_min
accel_min := 20.0
accel_max := 100.0
s.Acceleration = ((float64(request.Acceleration) / 100.0) * (accel_max - accel_min)) + accel_min
wep_rad_min := 5.0
wep_rad_max := 60.0
s.WeaponRadius = int(((float64(request.WeaponRadius) / 100.0) * (wep_rad_max - wep_rad_min)) + wep_rad_min)
scan_rad_min := 100.0
scan_rad_max := 400.0
s.ScannerRadius = int(((float64(request.ScannerRadius) / 100.0) * (scan_rad_max - scan_rad_min)) + scan_rad_min)
turn_spd_min := 30.0
turn_spd_max := 300.0
s.TurnSpeed = int(((float64(request.TurnSpeed) / 100.0) * (turn_spd_max - turn_spd_min)) + turn_spd_min)
fire_rate_min := 10.0
fire_rate_max := 2000.0
s.FireRate = int(fire_rate_max+300.0) - int(((float64(request.FireRate)/100.0)*(fire_rate_max-fire_rate_min))+fire_rate_min)
weapon_damage_min := 0.0
weapon_damage_max := 20.0
s.WeaponDamage = int(((float64(request.WeaponDamage) / 100.0) * (weapon_damage_max - weapon_damage_min)) + weapon_damage_min)
weapon_speed_min := 80.0
weapon_speed_max := 600.0
s.WeaponSpeed = float64(((float64(request.WeaponSpeed) / 100.0) * (weapon_speed_max - weapon_speed_min)) + weapon_speed_min)
return s
}
// Instruction is the struct a player sends each turn.
type Instruction struct {
Message *string `json:"message,omitempty"`
MoveTo *v.Point2d `json:"move_to,omitempty"`
Heading *v.Vector2d `json:"heading,omitempty"`
FireAt *v.Point2d `json:"fire_at,omitempty"`
Probe *v.Point2d `json:"probe,omitempty"`
TargetSpeed *float64 `json:"target_speed,omitempty"`
Repair *bool `json:"repair,omitempty"`
Scan *bool `json:"scan,omitempty"`
}
// returns collision, the intersection point, and the robot with whom r has
// collided, if this happened.
func (r *Robot) checkCollisions(g *Game, probe v.Vector2d) (bool, *v.Point2d, *Robot) {
finalCollision := false
closest := math.Inf(1)
var intersection *v.Point2d
var finalRobot *Robot
// TODO: this needs moved to the conf?
botSize := 5.0
botPolygon := v.OrientedSquare(r.Position, r.Heading, botSize)
bounds := []Obstacle{
Obstacle{
Bounds: v.AABB2d{A: v.Point2d{0, 0}, B: v.Point2d{0, g.width}},
Hp: 0,
},
Obstacle{
Bounds: v.AABB2d{A: v.Point2d{0, 0}, B: v.Point2d{0, g.height}},
Hp: 0,
},
Obstacle{
Bounds: v.AABB2d{A: v.Point2d{g.width, g.height}, B: v.Point2d{0, g.height}},
Hp: 0,
},
Obstacle{
Bounds: v.AABB2d{A: v.Point2d{g.width, g.height}, B: v.Point2d{g.width, 0}},
Hp: 0,
},
}
obstacles := append(g.obstacles, bounds...)
// Check Obstacles
for _, obj := range obstacles {
// collision due to motion:
collision, move_collision, translation := v.PolyPolyIntersection(
botPolygon, probe, obj.Bounds.ToPolygon())
if collision || move_collision {
finalCollision = true
p := r.Position.Add(probe).Add(translation)
if dist := r.Position.Sub(p).Mag(); dist < closest {
intersection = &p
closest = dist
}
}
// collision due to probe
collision, _, wallIntersect := v.RectIntersection(obj.Bounds, r.Position, probe)
if collision && wallIntersect != nil {
finalCollision = collision
if dist := r.Position.Sub(*wallIntersect).Mag(); dist < closest {
intersection = wallIntersect
closest = dist
}
}
}
// Check Other Bots
for player := range g.players {
for _, bot := range player.Robots {
if bot.Id == r.Id {
continue
}
player_rect := v.OrientedSquare(bot.Position, bot.Heading, botSize)
collision, move_collision, translation := v.PolyPolyIntersection(
botPolygon, probe, player_rect)
if collision || move_collision {
finalCollision = collision
p := r.Position.Add(probe).Add(translation.Scale(1.2))
if dist := r.Position.Sub(p).Mag(); dist < closest {
intersection = &p
closest = dist
finalRobot = bot
}
}
}
}
return finalCollision, intersection, finalRobot
}
// Tick is the Robot's chance to udpate itself.
func (r *Robot) Tick(g *Game) {
r.Collision = nil
r.Hit = false
r.scan(g)
// Cap Target Speed
if r.TargetSpeed > r.Stats.Speed {
r.TargetSpeed = r.Stats.Speed
}
if r.TargetSpeed < -0.25*r.Stats.Speed {
r.TargetSpeed = -0.25 * r.Stats.Speed
}
// Are we speeding up or slowing down?
increase := true
if r.Speed-r.TargetSpeed > v.Epsilon {
increase = false
}
if increase {
r.Speed += (r.Stats.Acceleration * r.Delta)
// Stop us from going too far
if r.Speed > r.TargetSpeed {
r.Speed = r.TargetSpeed
}
} else {
r.Speed -= (r.Stats.Acceleration * 8 * r.Delta)
// Dont go too far
if r.Speed < r.TargetSpeed {
r.Speed = r.TargetSpeed
}
}
// Adjust Heading
current_heading := r.Heading
if current_heading.Mag() == 0 && r.MoveTo != nil {
// We may have been stopped before this and had no heading
current_heading = r.MoveTo.Sub(r.Position).Normalize()
}
new_heading := current_heading
if r.MoveTo != nil {
// Where do we WANT to be heading?
new_heading = r.MoveTo.Sub(r.Position).Normalize()
}
if r.DesiredHeading != nil {
// Where do we WANT to be heading?
new_heading = r.DesiredHeading.Normalize()
}
if new_heading.Mag() > 0 {
// Is our direction change too much? Hard coding to 5 degrees/s for now
angle := v.Angle(current_heading, new_heading) * v.Rad2deg
dir := 1.0
if angle < 0 {
dir = -1.0
}
// Max turn radius in this case is in degrees per second
if math.Abs(angle) > float64(r.Stats.TurnSpeed)*r.Delta {
// New heading should be a little less, take current heading and
// rotate by the max turn radius per frame.
rot := (float64(r.Stats.TurnSpeed) * r.Delta) * v.Deg2rad
new_heading = current_heading.Rotate(rot * dir)
}
move_vector := new_heading.Scale(r.Speed * r.Delta)
collision, intersection_point, hit_robot := r.checkCollisions(g, move_vector)
if collision {
dmg := int(math.Abs(float64(r.Speed)) / 10.0)
if dmg <= 0 {
// All collisions need to do at least a little damage,
// otherwise robots could get stuck and never die
dmg = 1
}
r.Collision = &Collision{
Point2d: *intersection_point,
Type: "obstacle",
}
if hit_robot != nil {
r.Collision.Type = "robot"
}
if hit_robot != nil {
hit_robot.Health -= dmg
hit_robot.Speed = (hit_robot.Speed * 0.5)
// hit_robot.Heading = r.Heading
if hit_robot.Health <= 0 {
hit_robot.gameStats.Deaths++
r.gameStats.Kills++
}
}
if r.Position != *intersection_point {
r.Position = *intersection_point
}
r.Health -= dmg
r.MoveTo = &r.Position
r.Speed = (r.Speed * -0.5)
// r.Heading = r.Heading.Scale(-1.0)
if r.Health <= 0 {
r.gameStats.Deaths++
r.gameStats.Suicides++
}
} else {
r.Position = r.Position.Add(move_vector)
if new_heading.Mag() > 0 {
r.Heading = new_heading
} else {
log.Printf("Zero Heading %v", new_heading)
}
}
}
// We only self repair when we're stopped
if math.Abs(float64(r.Speed)) < v.Epsilon && r.RepairCounter > 0 {
r.RepairCounter -= r.Delta
if r.RepairCounter < 0 {
r.Health += g.repair_hp
if r.Health > r.Stats.Hp {
r.Health = r.Stats.Hp
}
r.RepairCounter = g.repair_rate
}
}
// We are only allowed to scan when we're stopped
if math.Abs(float64(r.Speed)) < v.Epsilon && r.ActiveScan {
r.ScanCounter += r.Delta * float64(r.Stats.ScannerRadius) * 0.1
} else if r.ScanCounter > 0 {
r.ScanCounter -= r.Delta * float64(r.Stats.ScannerRadius) * 0.05
if r.ScanCounter <= 0 {
r.ScanCounter = 0
}
}
if r.FireAt != nil {
proj := r.fire(g)
if proj != nil {
g.projectiles[proj] = true
}
}
if r.Probe != nil && r.ProbeResult == nil {
probe_vector := r.Probe.Sub(r.Position)
coll, pos, robo := r.checkCollisions(g, probe_vector)
if coll {
r.ProbeResult = &Collision{
Point2d: *pos,
Type: "obstacle",
}
if robo != nil {
r.ProbeResult.Type = "robot"
}
}
}
}
// scan updates the robots field of view if it's in teh appropriate mode
func (r *Robot) scan(g *Game) {
r.Scanners = r.Scanners[:0]
for player := range g.players {
for _, bot := range player.Robots {
if bot.Id == r.Id || bot.Health <= 0 {
continue
}
dist := v.Distance(bot.Position, r.Position)
if dist < float64(r.Stats.ScannerRadius+int(r.ScanCounter)) {
s := Scanner{
Id: bot.Id,
Type: "robot",
}
r.Scanners = append(r.Scanners, s)
}
}
}
for proj := range g.projectiles {
if proj.Owner == r {
continue
}
dist := v.Distance(proj.Position, r.Position)
if dist < float64(r.Stats.ScannerRadius+int(r.ScanCounter)) {
s := Scanner{
Id: proj.Id,
Type: "projectile",
}
r.Scanners = append(r.Scanners, s)
}
}
for splo := range g.splosions {
dist := v.Distance(splo.Position, r.Position)
if dist < float64(r.Stats.ScannerRadius+int(r.ScanCounter)) {
s := Scanner{
Id: splo.Id,
Type: "explosion",
}
r.Scanners = append(r.Scanners, s)
}
}
}
// fire is called according to player instruction. XXX: There is a race here...
func (r *Robot) fire(g *Game) *Projectile {
// Throttle the fire rate
time_since_fired := (float64(g.turn) * (r.Delta * 1000)) - (float64(r.LastFired) * (r.Delta * 1000))
if time_since_fired < float64(r.Stats.FireRate) {
return nil
}
r.LastFired = g.turn
r.gameStats.Shots++
return &Projectile{
Id: r.idg.Hash(),
Position: r.Position,
MoveTo: *r.FireAt,
Damage: r.Stats.WeaponDamage,
Radius: r.Stats.WeaponRadius,
Speed: r.Stats.WeaponSpeed,
Owner: r,
Delta: r.Delta,
}
}
// reset is called to move a robot to a reasonable location at game start time.
func (r *Robot) reset(g *Game) {
for {
start_pos := v.Point2d{
X: rand.Float64() * float64(g.width),
Y: rand.Float64() * float64(g.height),
}
r.MoveTo = &start_pos
r.Position = start_pos
r.Health = r.Stats.Hp
// Check Obstacles
retry := false
for _, obj := range g.obstacles {
_, inside, _ := v.RectIntersection(obj.Bounds, r.Position, v.Vector2d{X: 0, Y: 0})
if inside {
retry = true
}
}
if !retry {
break
}
}
}