server/robot.go

package server

import (
	"log"
	"math"
	"math/rand"

	v "bitbucket.org/hackerbots/vector"
)

// 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:"-"`
	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            *IdGenerator
}

// 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 := 200.0
	s.Speed = float64(request.Speed)/100.0*(speed_max-speed_min) + speed_min

	accel_min := 20.0
	accel_max := 200.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 < -1.0*r.Stats.Speed {
		r.TargetSpeed = -1.0 * r.Stats.Speed
	}

	// Are we speeding up or slowing down?
	increase := true
	if float32(math.Abs(float64(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 * r.Delta)

		// Dont go too far
		if r.Speed < r.TargetSpeed {
			r.Speed = r.TargetSpeed
		}

		// Cap reverse at 1/4 top speed
		if r.Speed < (-0.25 * r.Stats.Speed) {
			r.Speed = (-0.25 * r.Stats.Speed)
		}
	}

	// 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
		}
	}
}