Esempio n. 1
0
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
}
Esempio n. 2
0
func (self *disband) adjudicateBuildPhase(r dip.Resolver) error {
	unit, _, _ := r.Unit(self.targets[0])
	_, disbands, _ := cla.AdjustmentStatus(r, unit.Nation)
	if len(disbands) == 0 || self.at.After(disbands[len(disbands)-1].At()) {
		return cla.ErrIllegalDisband
	}
	return nil
}
Esempio n. 3
0
File: phase.go Progetto: arlm/godip
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
}
Esempio n. 4
0
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
}