graphvent/vex.go

276 lines
7.4 KiB
Go

package main
import (
"fmt"
"time"
"errors"
)
type Member struct {
BaseResource
}
func NewMember(name string) * Member {
member := &Member{
BaseResource: NewBaseResource(name, "A Team Member", []Resource{}),
}
return member
}
type Team struct {
BaseResource
Org string
Team string
}
func (team * Team) Members() []*Member {
ret := make([]*Member, len(team.children))
for idx, member := range(team.children) {
ret[idx] = member.(*Member)
}
return ret
}
func NewTeam(org string, team string, members []*Member) * Team {
name := fmt.Sprintf("%s%s", org, team)
description := fmt.Sprintf("Team %s", name)
resource := &Team{
BaseResource: NewBaseResource(name, description, make([]Resource, len(members))),
Org: org,
Team: team,
}
for idx, member := range(members) {
resource.children[idx] = member
}
return resource
}
type Alliance struct {
BaseResource
teams []*Team
}
func NewAlliance(team0 * Team, team1 * Team) * Alliance {
name := fmt.Sprintf("Alliance %s/%s", team0.Name(), team1.Name())
description := ""
resource := &Alliance{
BaseResource: NewBaseResource(name, description, []Resource{team0, team1}),
teams: []*Team{team0, team1},
}
return resource
}
type Arena interface {
Resource
}
type VirtualArena struct {
BaseResource
connected bool
}
func NewVirtualArena(name string) * VirtualArena {
arena := &VirtualArena{
BaseResource: NewBaseResource(name, "A virtual vex arena", []Resource{}),
connected: false,
}
return arena
}
func (arena * VirtualArena) lock(node GraphNode) error {
if arena.connected == false {
log.Logf("vex", "ARENA NOT CONNECTED: %s", arena.Name())
error_str := fmt.Sprintf("%s is not connected, cannot lock", arena.Name())
return errors.New(error_str)
}
return nil
}
func (arena * VirtualArena) update(signal GraphSignal) {
arena.signal <- signal
arena.BaseResource.update(signal)
}
func (arena * VirtualArena) Init(abort chan error) bool {
log.Logf("vex", "Initializing %s", arena.Name())
go func(arena * VirtualArena, abort chan error) {
signal := NewSignal(arena, "resource_connected")
arena.connected = true
SendUpdate(arena, signal)
log.Logf("vex", "VIRTUAL_ARENA goroutine starting: %s", arena.Name())
for true {
select {
case <- abort:
log.Logf("vex", "Virtual arena %s aborting", arena.Name())
break
case update := <- arena.signal:
log.Logf("vex", "VIRTUAL_ARENA_ACTION: %s : %+v", arena.Name(), update)
}
}
}(arena, abort)
return true
}
type VexEvent struct {
BaseEvent
}
func NewVexEvent(name string, description string) * VexEvent {
event := &VexEvent{
BaseEvent: NewBaseEvent(name, description, []Resource{}),
}
event.actions["wait"] = EventWait(event)
event.handlers["abort"] = EventAbort(event)
event.actions["start"] = func() (string, error) {
log.Logf("vex", "STARTING_VEX_TOURNAMENT %s", event.Name())
return "wait", nil
}
return event
}
const start_slack = 250 * time.Millisecond
const TEMP_AUTON_TIME = 5 * time.Second
const TEMP_DRIVE_TIME = 5 * time.Second
type Match struct {
BaseEvent
arena Arena
state string
control string
control_start time.Time
control_duration time.Duration
alliances []*Alliance
}
func NewMatch(alliance0 * Alliance, alliance1 * Alliance, arena Arena) * Match {
name := fmt.Sprintf("Match: %s vs. %s on %s", alliance0.Name(), alliance1.Name(), arena.Name())
description := "A vex match"
match := &Match{
BaseEvent: NewBaseEvent(name, description, []Resource{alliance0, alliance1, arena}),
state: "init",
control: "init",
control_start: time.UnixMilli(0),
control_duration: 0,
arena: arena,
alliances: []*Alliance{alliance0, alliance1},
}
match.actions["wait"] = EventWait(match)
match.handlers["abort"] = EventAbort(match)
match.actions["start"] = func() (string, error) {
log.Logf("vex", "STARTING_MATCH %s", match.Name())
match.control = "none"
match.state = "scheduled"
match.control_start = time.Now()
return "wait", nil
}
match.handlers["queue_autonomous"] = func(signal GraphSignal) (string, error) {
if match.state != "scheduled" {
log.Logf("vex", "BAD_STATE: %s: %s - %s", signal.Type(), match.state, match.Name())
return "wait", nil
}
log.Logf("vex", "AUTONOMOUS_QUEUED: %s", match.Name())
match.control = "none"
match.state = "autonomous_queued"
match.control_start = time.Now().Add(start_slack)
new_signal := NewSignal(match, "autonomous_queued")
go SendUpdate(match, new_signal)
return "wait", nil
}
match.handlers["start_autonomous"] = func(signal GraphSignal) (string, error) {
if match.state != "autonomous_queued" {
log.Logf("vex", "BAD_STATE: %s: %s - %s", signal.Type(), match.state, match.Name())
return "wait", nil
}
log.Logf("vex", "AUTONOMOUS_RUNNING: %s", match.Name())
match.control = "program"
match.state = "autonomous_running"
match.control_start = time.Now() // TODO
match.control_duration = TEMP_AUTON_TIME
go SendUpdate(match, NewSignal(match, "autonomous_running"))
end_time := match.control_start.Add(TEMP_AUTON_TIME)
match.SetTimeout(end_time, "autonomous_done")
log.Logf("vex", "AUTONOMOUS@%s: %s UNTIL %s", time.Now(), match.control_start, end_time)
return "wait", nil
}
match.handlers["autonomous_done"] = func(signal GraphSignal) (string, error) {
if match.state != "autonomous_running" {
log.Logf("vex", "BAD_STATE: %s: %s - %s", signal.Type(), match.state, match.Name())
return "wait", nil
}
log.Logf("vex", "AUTONOMOUS_DONE: %s", match.Name())
match.control = "none"
match.state = "autonomous_done"
return "wait", nil
}
match.handlers["queue_driver"] = func(signal GraphSignal) (string, error) {
if match.state != "autonomous_done"{
log.Logf("vex", "BAD_STATE: %s: %s - %s", signal.Type(), match.state, match.Name())
return "wait", nil
}
match.control = "none"
match.state = "driver_queued"
match.control_start = time.Now().Add(start_slack)
new_signal := NewSignal(match, "driver_queued")
go SendUpdate(match, new_signal)
return "wait", nil
}
match.handlers["start_driver"] = func(signal GraphSignal) (string, error) {
if match.state != "driver_queued" {
log.Logf("vex", "BAD_STATE: %s: %s - %s", signal.Type(), match.state, match.Name())
return "wait", nil
}
match.control = "driver"
match.state = "driver_running"
match.control_start = time.Now() // TODO
match.control_duration = TEMP_DRIVE_TIME
go SendUpdate(match, NewSignal(match, "driver_running"))
end_time := match.control_start.Add(TEMP_DRIVE_TIME)
match.SetTimeout(end_time, "driver_done")
return "wait", nil
}
match.handlers["driver_done"] = func(signal GraphSignal) (string, error) {
if match.state != "driver_running" {
log.Logf("vex", "BAD_STATE: %s: %s - %s", signal.Type(), match.state, match.Name())
return "wait", nil
}
match.control = "none"
match.state = "driver_done"
return "", nil
}
match.actions["driver_done"] = func() (string, error) {
SendUpdate(match, NewSignal(match, "driver_done"))
return "wait", nil
}
match.actions["autonomous_done"] = func() (string, error) {
SendUpdate(match, NewSignal(match, "autonomous_done"))
return "wait", nil
}
return match
}