func (self *move) validateRetreatPhase(v dip.Validator) error {
if !v.Graph().Has(self.targets[0]) {
return cla.ErrInvalidSource
}
if !v.Graph().Has(self.targets[1]) {
return cla.ErrInvalidDestination
}
if self.targets[0] == self.targets[1] {
return cla.ErrIllegalMove
}
var unit dip.Unit
var ok bool
if unit, self.targets[0], ok = v.Dislodged(self.targets[0]); !ok {
return cla.ErrMissingUnit
}
var err error
if self.targets[1], err = cla.AnyMovePossible(v, unit.Type, self.targets[0], self.targets[1], unit.Type == cla.Army, false, false); err != nil {
return cla.ErrIllegalMove
}
if _, _, ok := v.Unit(self.targets[1]); ok {
return cla.ErrIllegalRetreat
}
if v.Bounce(self.targets[0], self.targets[1]) {
return cla.ErrIllegalRetreat
}
return nil
}
func (self *disband) Validate(v dip.Validator) error {
if v.Phase().Type() == cla.Adjustment {
return self.validateBuildPhase(v)
} else if v.Phase().Type() == cla.Retreat {
return self.validateRetreatPhase(v)
}
return cla.ErrInvalidPhase
}
func (self *move) Validate(v dip.Validator) error {
if v.Phase().Type() == cla.Movement {
return self.validateMovementPhase(v)
} else if v.Phase().Type() == cla.Retreat {
return self.validateRetreatPhase(v)
}
return cla.ErrInvalidPhase
}
func (self *disband) validateRetreatPhase(v dip.Validator) error {
if !v.Graph().Has(self.targets[0]) {
return cla.ErrInvalidTarget
}
var ok bool
if _, self.targets[0], ok = v.Dislodged(self.targets[0]); !ok {
return cla.ErrMissingUnit
}
return nil
}
func (self *disband) validateBuildPhase(v dip.Validator) error {
if !v.Graph().Has(self.targets[0]) {
return cla.ErrInvalidTarget
}
var unit dip.Unit
var ok bool
if unit, self.targets[0], ok = v.Unit(self.targets[0]); !ok {
return cla.ErrMissingUnit
}
if _, _, balance := cla.AdjustmentStatus(v, unit.Nation); balance > -1 {
return cla.ErrMissingDeficit
}
return nil
}
func (self *phase) Winner(s dip.Validator) *dip.Nation {
sizes := map[dip.Nation]int{}
for _, nat := range s.SupplyCenters() {
sizes[nat]++
}
var biggest *dip.Nation
var bigSize int
for nat, size := range sizes {
if biggest == nil || size > bigSize {
natCpy := nat
biggest = &natCpy
bigSize = size
}
}
if bigSize > 17 {
return biggest
}
return nil
}
func (self *hold) Validate(v dip.Validator) error {
if v.Phase().Type() != cla.Movement {
return cla.ErrInvalidPhase
}
if !v.Graph().Has(self.targets[0]) {
return cla.ErrInvalidTarget
}
var ok bool
if _, self.targets[0], ok = v.Unit(self.targets[0]); !ok {
return cla.ErrMissingUnit
}
return nil
}
func (self *hold) Options(v dip.Validator, nation dip.Nation, src dip.Province) (result dip.Options) {
if v.Phase().Type() == cla.Movement {
if v.Graph().Has(src) {
if unit, actualSrc, ok := v.Unit(src); ok {
if unit.Nation == nation {
result = dip.Options{
dip.SrcProvince(actualSrc): nil,
}
}
}
}
}
return
}
func (self *move) Options(v dip.Validator, nation dip.Nation, src dip.Province) (result dip.Options) {
if v.Phase().Type() == cla.Retreat {
if !self.flags[cla.ViaConvoy] {
if v.Graph().Has(src) {
if unit, actualSrc, ok := v.Dislodged(src); ok {
if unit.Nation == nation {
for _, dst := range cla.PossibleMoves(v, src, false, true) {
if _, _, foundUnit := v.Unit(dst); !foundUnit {
if !v.Bounce(src, dst) {
if result == nil {
result = dip.Options{}
}
if result[dip.SrcProvince(actualSrc)] == nil {
result[dip.SrcProvince(actualSrc)] = dip.Options{}
}
result[dip.SrcProvince(actualSrc)][dst] = nil
}
}
}
}
}
}
}
} else if v.Phase().Type() == cla.Movement {
if v.Graph().Has(src) {
if unit, actualSrc, ok := v.Unit(src); ok {
if unit.Nation == nation {
if !self.flags[cla.ViaConvoy] || unit.Type == cla.Army {
for _, dst := range cla.PossibleMoves(v, src, true, false) {
if !self.flags[cla.ViaConvoy] {
if result == nil {
result = dip.Options{}
}
if result[dip.SrcProvince(actualSrc)] == nil {
result[dip.SrcProvince(actualSrc)] = dip.Options{}
}
result[dip.SrcProvince(actualSrc)][dst] = nil
} else {
if cp := cla.AnyConvoyPath(v, src, dst, false, nil); len(cp) > 1 {
if result == nil {
result = dip.Options{}
}
if result[dip.SrcProvince(actualSrc)] == nil {
result[dip.SrcProvince(actualSrc)] = dip.Options{}
}
result[dip.SrcProvince(actualSrc)][dst] = nil
}
}
}
}
}
}
}
}
return
}
func (self *disband) Options(v dip.Validator, nation dip.Nation, src dip.Province) (result dip.Options) {
if v.Phase().Type() == cla.Adjustment {
if v.Graph().Has(src) {
if unit, actualSrc, ok := v.Unit(src); ok {
if unit.Nation == nation {
if _, _, balance := cla.AdjustmentStatus(v, unit.Nation); balance < 0 {
result = dip.Options{
dip.SrcProvince(actualSrc): nil,
}
}
}
}
}
} else if v.Phase().Type() == cla.Retreat {
if v.Graph().Has(src) {
if unit, actualSrc, ok := v.Dislodged(src); ok {
if unit.Nation == nation {
result = dip.Options{
dip.SrcProvince(actualSrc): nil,
}
}
}
}
}
return
}
func (self *phase) Options(s dip.Validator, nation dip.Nation) (result dip.Options) {
return s.Options(orders.Orders(), nation)
}