func BackupRule(state dip.State, deps []dip.Province) (err error) {
only_moves := true
convoys := false
for _, prov := range deps {
if order, _, ok := state.Order(prov); ok {
if order.Type() != cla.Move {
only_moves = false
}
if order.Type() == cla.Convoy {
convoys = true
}
}
}
if only_moves {
for _, prov := range deps {
state.SetResolution(prov, nil)
}
return
}
if convoys {
for _, prov := range deps {
if order, _, ok := state.Order(prov); ok && order.Type() == cla.Convoy {
state.SetResolution(prov, cla.ErrConvoyParadox)
}
}
return
}
err = fmt.Errorf("Unknown circular dependency between %v", deps)
return
}
func (self *phase) PostProcess(s dip.State) (err error) {
if self.typ == cla.Retreat {
for prov, _ := range s.Dislodgeds() {
s.RemoveDislodged(prov)
s.SetResolution(prov, cla.ErrForcedDisband)
}
s.ClearDislodgers()
s.ClearBounces()
if self.season == cla.Fall {
s.Find(func(p dip.Province, o dip.Order, u *dip.Unit) bool {
if u != nil {
if s.Graph().SC(p) != nil {
s.SetSC(p.Super(), u.Nation)
}
}
return false
})
}
} else if self.typ == cla.Adjustment {
for _, nationality := range cla.Nations {
_, _, balance := cla.AdjustmentStatus(s, nationality)
if balance < 0 {
var su []dip.Province
if su, err = self.sortedUnits(s, nationality); err != nil {
return
}
su = su[:-balance]
for _, prov := range su {
dip.Logf("Removing %v due to forced disband", prov)
s.RemoveUnit(prov)
s.SetResolution(prov, cla.ErrForcedDisband)
}
}
}
} else if self.typ == cla.Movement {
for prov, unit := range s.Dislodgeds() {
hasRetreat := false
for edge, _ := range s.Graph().Edges(prov) {
if _, _, ok := s.Unit(edge); !ok && !s.Bounce(prov, edge) {
if cla.HasEdge(s, unit.Type, prov, edge) {
dip.Logf("%v can retreat to %v", prov, edge)
hasRetreat = true
break
}
}
}
if !hasRetreat {
s.RemoveDislodged(prov)
dip.Logf("Removing %v since it has no retreat", prov)
}
}
}
return
}