You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

218 lines
4.6 KiB
Go

package main
import (
"database/sql"
"fmt"
"math"
"math/rand"
"time"
)
var (
index map[int]*System
nameIndex map[string]*System
)
type System struct {
*Shield
id int
x, y, z float64
planets int
name string
players map[*Connection]bool
colonizedBy *Connection
distances []Ray
money int64
}
func (s *System) Tick(game *Game) {
if s.colonizedBy != nil && s.money > 0 {
s.colonizedBy.Deposit(1)
s.money -= 1
}
if s.Shield != nil {
s.Shield.Tick()
}
}
func (s *System) Dead() bool {
return false
}
func (s *System) Reset() {
s.players = make(map[*Connection]bool, 32)
s.colonizedBy = nil
}
func (s *System) Arrive(conn *Connection) {
if s.players[conn] {
return
}
log_info("player %s has arrived at system %v", conn.Name(), s)
if s.players == nil {
s.players = make(map[*Connection]bool, 8)
}
s.players[conn] = true
if s.planets == 1 {
conn.Printf("you are in the system %v. There is %d planet here.\n", s, s.planets)
} else {
conn.Printf("you are in the system %v. There are %d planets here.\n", s, s.planets)
}
}
func (s *System) Leave(p *Connection) {
delete(s.players, p)
// p.location = nil
}
func (s *System) NotifyInhabitants(template string, args ...interface{}) {
s.EachConn(func(conn *Connection) {
conn.Printf(template, args...)
})
}
func (s *System) EachConn(fn func(*Connection)) {
if s.players == nil {
return
}
for conn, _ := range s.players {
fn(conn)
}
}
func (s *System) NumInhabitants() int {
if s.players == nil {
return 0
}
return len(s.players)
}
func (e System) Store(db *sql.DB) {
_, err := db.Exec(`
insert into planets
(name, x, y, z, planets)
values
(?, ?, ?, ?, ?)
;`, e.name, e.x, e.y, e.z, e.planets)
if err != nil {
log_error("unable to store system: %v", err)
}
}
func (s *System) DistanceTo(other *System) float64 {
return dist3d(s.x, s.y, s.z, other.x, other.y, other.z)
}
func (s *System) LightTimeTo(other *System) time.Duration {
return time.Duration(int64(s.DistanceTo(other) * 100000000))
}
func (s *System) BombTimeTo(other *System) time.Duration {
return time.Duration(int64(s.DistanceTo(other) * 110000000))
}
func (s *System) TravelTimeTo(other *System) time.Duration {
return time.Duration(int64(s.DistanceTo(other) * 125000000))
}
type Ray struct {
s *System
dist float64 // distance in parsecs
}
func (s *System) Bombed(bomber *Connection, frame int64) {
if s.Shield != nil {
if s.Shield.Hit() {
s.EachConn(func(conn *Connection) {
conn.Printf("A bomb has hit %v but it was stopped by the system's shield.\n", s)
conn.Printf("Shield remaining: %v.\n", s.energy)
conn.Printf("Shield is recharing....\n")
})
return
}
}
s.EachConn(func(conn *Connection) {
conn.Die(frame)
s.Leave(conn)
bomber.MadeKill(conn)
})
if s.colonizedBy != nil {
s.colonizedBy.Printf("your mining colony on %s has been destroyed!\n", s.name)
s.colonizedBy = nil
}
for id, _ := range index {
if id == s.id {
continue
}
delay := s.LightTimeTo(index[id])
id2 := id
time.AfterFunc(delay, func() {
bombNotice(id2, s.id)
})
}
}
func bombNotice(to_id, from_id int) {
to := index[to_id]
from := index[from_id]
to.EachConn(func(conn *Connection) {
conn.Printf("a bombing has been observed on %s\n", from.name)
})
}
func (s System) String() string {
return fmt.Sprintf("%s (id: %v)", s.name, s.id)
}
type Neighborhood []Neighbor
func (n Neighborhood) Len() int { return len(n) }
func (n Neighborhood) Less(i, j int) bool { return n[i].distance < n[j].distance }
func (n Neighborhood) Swap(i, j int) { n[i], n[j] = n[j], n[i] }
type Neighbor struct {
id int
distance float64
}
func countSystems() (int, error) {
row := db.QueryRow(`select count(*) from planets`)
var n int
err := row.Scan(&n)
return n, err
}
func sq(x float64) float64 {
return x * x
}
func dist3d(x1, y1, z1, x2, y2, z2 float64) float64 {
return math.Sqrt(sq(x1-x2) + sq(y1-y2) + sq(z1-z2))
}
func indexSystems() map[int]*System {
rows, err := db.Query(`select * from planets`)
if err != nil {
log_error("unable to select all planets: %v", err)
return nil
}
defer rows.Close()
index = make(map[int]*System, 551)
nameIndex = make(map[string]*System, 551)
for rows.Next() {
p := System{}
if err := rows.Scan(&p.id, &p.name, &p.x, &p.y, &p.z, &p.planets); err != nil {
log_info("unable to scan planet row: %v", err)
continue
}
index[p.id] = &p
nameIndex[p.name] = &p
p.money = int64(rand.NormFloat64()*options.moneySigma + options.moneyMean)
// log_info("seeded system %v with %v monies", p, p.money)
}
return index
}