func (self *Game) start(c common.SkinnyContext) (err error) {
if self.State != common.GameStateCreated {
err = fmt.Errorf("%+v is already started", self)
return
}
self.State = common.GameStateStarted
self.Closed = true
if err = c.DB().Set(self); err != nil {
return
}
var startState *state.State
if self.Variant == common.ClassicalString {
if startState, err = classical.Start(); err != nil {
return
}
} else {
err = fmt.Errorf("Unknown variant %v", self.Variant)
return
}
startPhase := startState.Phase()
epoch, err := epoch.Get(c.DB())
if err != nil {
return
}
phase := &Phase{
GameId: self.Id,
Ordinal: 0,
Orders: map[dip.Nation]map[dip.Province][]string{},
Resolutions: map[dip.Province]string{},
Season: startPhase.Season(),
Year: startPhase.Year(),
Type: startPhase.Type(),
Deadline: epoch + (time.Minute * time.Duration(self.Deadlines[startPhase.Type()])),
}
phase.Units, phase.SupplyCenters, phase.Dislodgeds, phase.Dislodgers, phase.Bounces, _ = startState.Dump()
if err = c.DB().Set(phase); err != nil {
return
}
if err = self.allocate(c.DB(), phase); err != nil {
return
}
if err = phase.Schedule(c); err != nil {
return
}
phase.SendStartedEmails(c, self)
return
}
func assertMove(t *testing.T, j *state.State, src, dst dip.Province, success bool) {
if success {
unit, _, ok := j.Unit(src)
if !ok {
t.Errorf("Should be a unit at %v", src)
}
j.SetOrder(src, orders.Move(src, dst))
j.Next()
if err, ok := j.Resolutions()[src]; ok && err != nil {
t.Errorf("Move from %v to %v should have worked, got %v", src, dst, err)
}
if now, _, ok := j.Unit(src); ok && reflect.DeepEqual(now, unit) {
t.Errorf("%v should have moved from %v", now, src)
}
if now, _, _ := j.Unit(dst); !reflect.DeepEqual(now, unit) {
t.Errorf("%v should be at %v now", unit, dst)
}
} else {
unit, _, _ := j.Unit(src)
j.SetOrder(src, orders.Move(src, dst))
j.Next()
if err, ok := j.Resolutions()[src]; !ok || err == nil {
t.Errorf("Move from %v to %v should not have worked", src, dst)
}
if now, _, _ := j.Unit(src); !reflect.DeepEqual(now, unit) {
t.Errorf("%v should not have moved from %v", now, src)
}
}
}
func testDATC(t *testing.T, statePair *datc.StatePair) {
var s *state.State
if statePair.Before.Phase == nil {
s = Blank(&phase{
year: 1901,
season: cla.Spring,
typ: cla.Movement,
})
} else {
s = Blank(statePair.Before.Phase)
}
s.SetUnits(statePair.Before.Units)
s.SetDislodgeds(statePair.Before.Dislodgeds)
s.SetSupplyCenters(statePair.Before.SCs)
for prov, order := range statePair.Before.Orders {
if s.Phase().Type() == cla.Movement {
if u, _, ok := s.Unit(prov); ok && u.Nation == order.Nation {
s.SetOrder(prov, order.Order)
}
} else if s.Phase().Type() == cla.Retreat {
if u, _, ok := s.Dislodged(prov); ok && u.Nation == order.Nation {
s.SetOrder(prov, order.Order)
}
} else if s.Phase().Type() == cla.Adjustment {
if order.Order.Type() == cla.Build {
if n, _, ok := s.SupplyCenter(prov); ok && n == order.Nation {
s.SetOrder(prov, order.Order)
}
} else if order.Order.Type() == cla.Disband {
if u, _, ok := s.Unit(prov); ok && u.Nation == order.Nation {
s.SetOrder(prov, order.Order)
}
}
} else {
t.Fatalf("Unsupported phase type %v", s.Phase().Type())
}
}
for _, order := range statePair.Before.FailedOrders {
if order.Order.Type() == cla.Move && !order.Order.Flags()[cla.ViaConvoy] {
s.AddBounce(order.Order.Targets()[0], order.Order.Targets()[1])
}
}
for _, order := range statePair.Before.SuccessfulOrders {
if order.Order.Type() == cla.Move && !order.Order.Flags()[cla.ViaConvoy] {
s.SetDislodger(order.Order.Targets()[0], order.Order.Targets()[1])
}
}
s.Next()
err := false
for prov, unit := range statePair.After.Units {
if found, ok := s.Units()[prov]; ok {
if !found.Equal(unit) {
err = true
t.Errorf("%v: Expected %v in %v, but found %v", statePair.Case, unit, prov, found)
}
} else {
err = true
t.Errorf("%v: Expected %v in %v, but found nothing", statePair.Case, unit, prov)
}
}
for prov, unit := range statePair.After.Dislodgeds {
if found, ok := s.Dislodgeds()[prov]; ok {
if !found.Equal(unit) {
err = true
t.Errorf("%v: Expected %v dislodged in %v, but found %v", statePair.Case, unit, prov, found)
}
} else {
err = true
t.Errorf("%v: Expected %v dislodged in %v, but found nothing", statePair.Case, unit, prov)
}
}
for prov, unit := range s.Units() {
if _, ok := statePair.After.Units[prov]; !ok {
err = true
t.Errorf("%v: Expected %v to be empty, but found %v", statePair.Case, prov, unit)
}
}
for prov, unit := range s.Dislodgeds() {
if _, ok := statePair.After.Dislodgeds[prov]; !ok {
err = true
t.Errorf("%v: Expected %v to be empty of dislodged units, but found %v", statePair.Case, prov, unit)
}
}
if err {
dip.DumpLog()
t.Errorf("%v: ### Units:", statePair.Case)
for prov, unit := range statePair.Before.Units {
t.Errorf("%v: %v %v", statePair.Case, prov, unit)
}
t.Errorf("%v: ### Dislodged before:", statePair.Case)
for prov, disl := range statePair.Before.Dislodgeds {
t.Errorf("%v: %v %v", statePair.Case, prov, disl)
}
t.Errorf("%v: ### Orders:", statePair.Case)
for _, order := range statePair.Before.Orders {
t.Errorf("%v: %v", statePair.Case, order.Order)
}
t.Errorf("%v: ### Units after:", statePair.Case)
for prov, unit := range s.Units() {
t.Errorf("%v: %v %v", statePair.Case, prov, unit)
}
t.Errorf("%v: ### Dislodged after:", statePair.Case)
for prov, unit := range s.Dislodgeds() {
t.Errorf("%v: %v %v", statePair.Case, prov, unit)
}
t.Errorf("%v: ### Errors:", statePair.Case)
for prov, err := range s.Resolutions() {
t.Errorf("%v: %v %v", statePair.Case, prov, err)
}
t.Fatalf("%v failed", statePair.Case)
}
}
func verifyPosition(t *testing.T, s *state.State, match []string, scCollector map[dip.Province]dip.Nation, unitCollector, dislodgedCollector map[dip.Province]dip.Unit, fails *int) {
if match[2] == "supply" {
if nation, _, ok := s.SupplyCenter(dip.Province(match[3])); ok && nation == dip.Nation(match[1]) {
scCollector[dip.Province(match[3])] = nation
} else {
t.Errorf("%v: Expected %v to own SC in %v, but found %v, %v", s.Phase(), match[1], match[3], nation, ok)
*fails += 1
}
} else if match[2] == "army" {
if unit, _, ok := s.Unit(dip.Province(match[3])); ok && unit.Nation == dip.Nation(match[1]) && unit.Type == cla.Army {
unitCollector[dip.Province(match[3])] = unit
} else {
t.Errorf("%v: Expected to find %v %v in %v, but found %v, %v", s.Phase(), match[1], cla.Army, match[3], unit, ok)
*fails += 1
}
} else if match[2] == "fleet" {
if unit, _, ok := s.Unit(dip.Province(match[3])); ok && unit.Nation == dip.Nation(match[1]) && unit.Type == cla.Fleet {
unitCollector[dip.Province(match[3])] = unit
} else {
t.Errorf("%v: Expected to find %v %v in %v, but found %v, %v", s.Phase(), match[1], cla.Fleet, match[3], unit, ok)
*fails += 1
}
} else if match[2] == "fleet/dislodged" {
if unit, _, ok := s.Dislodged(dip.Province(match[3])); ok && unit.Nation == dip.Nation(match[1]) && unit.Type == cla.Fleet {
dislodgedCollector[dip.Province(match[3])] = unit
} else {
t.Errorf("%v: Expected to find %v %v dislodged in %v, but found %v, %v", s.Phase(), match[1], cla.Army, match[3], unit, ok)
*fails += 1
}
} else if match[2] == "army/dislodged" {
if unit, _, ok := s.Dislodged(dip.Province(match[3])); ok && unit.Nation == dip.Nation(match[1]) && unit.Type == cla.Army {
dislodgedCollector[dip.Province(match[3])] = unit
} else {
t.Errorf("%v: Expected to find %v %v dislodged in %v, but found %v, %v", s.Phase(), match[1], cla.Army, match[3], unit, ok)
*fails += 1
}
} else {
t.Fatalf("Unknown position description %v", match)
}
}
func verifyReversePositions(t *testing.T, s *state.State, scCollector map[dip.Province]dip.Nation, unitCollector, dislodgedCollector map[dip.Province]dip.Unit, fails *int) {
for prov, nation1 := range s.SupplyCenters() {
if nation2, ok := scCollector[prov]; !ok || nation1 != nation2 {
t.Errorf("%v: Found %v in %v, expected %v, %v", s.Phase(), nation1, prov, nation2, ok)
*fails += 1
}
}
for prov, unit1 := range s.Units() {
if unit2, ok := unitCollector[prov]; !ok || unit2.Nation != unit1.Nation || unit1.Type != unit2.Type {
t.Errorf("%v: Found %v in %v, expected %v, %v", s.Phase(), unit1, prov, unit2, ok)
*fails += 1
}
}
for prov, unit1 := range s.Dislodgeds() {
if unit2, ok := dislodgedCollector[prov]; !ok || unit2.Nation != unit1.Nation || unit1.Type != unit2.Type {
t.Errorf("%v: Found %v dislodged in %v, expected %v, %v", s.Phase(), unit1, prov, unit2, ok)
*fails += 1
}
}
}