s/constrain/constraint/

1 files changed, 61 insertions, 61 deletions

diff --git a/go/game/targets.go b/go/game/targets.go
index 11918fdf..e9f227e0 100644
--- a/go/game/targets.go
+++ b/go/game/targets.go
@@ -11,17 +11,17 @@ import (
 )
 
 type (
-	TargetConstrainFunc func(interface{}) error
-	TargetConstrain     struct {
+	TargetConstraintFunc func(interface{}) error
+	TargetConstraint     struct {
 		desc      string
-		constrain TargetConstrainFunc
+		constraint TargetConstraintFunc
 	}
 )
 
 type Targets struct {
 	s          *State
 	action     Action
-	constrains []*TargetConstrain
+	constraints []*TargetConstraint
 	sel        []interface{}
 }
 
@@ -56,7 +56,7 @@ func newTargetsWithSel(s *State, targets []string, action Action, sel []interfac
 		sel: sel,
 	}
 
-	t.buildConstrains(targets, action)
+	t.buildConstraints(targets, action)
 	return t
 }
 
@@ -64,32 +64,32 @@ func newTargets(s *State, targets []string, action Action) *Targets {
 	return newTargetsWithSel(s, targets, action, make([]interface{}, 0, len(targets)))
 }
 
-func (t *Targets) buildConstrains(targets []string, action Action) {
+func (t *Targets) buildConstraints(targets []string, action Action) {
 	for _, desc := range targets {
-		c := &TargetConstrain{desc, targetConstrain(desc, t.s, action)}
-		t.constrains = append(t.constrains, c)
+		c := &TargetConstraint{desc, targetConstraint(desc, t.s, action)}
+		t.constraints = append(t.constraints, c)
 	}
 }
 
 func (t *Targets) RequireTargets() bool {
-	return len(t.constrains) != len(t.sel)
+	return len(t.constraints) != len(t.sel)
 }
 
 func (t *Targets) Options() [][]interface{} {
-	options := make([][]interface{}, 0, len(t.constrains))
-	for _, c := range t.constrains {
+	options := make([][]interface{}, 0, len(t.constraints))
+	for _, c := range t.constraints {
 		options = append(options, c.options(t.s))
 	}
 	return options
 }
 
 func (t *Targets) NextOptions() []interface{} {
-	if len(t.constrains) == 0 {
+	if len(t.constraints) == 0 {
 		return nil
 	}
 
 	next := len(t.sel)
-	return t.constrains[next].options(t.s)
+	return t.constraints[next].options(t.s)
 }
 
 func (t *Targets) AddTarget(target interface{}) {
@@ -101,9 +101,9 @@ func (t *Targets) CheckTargets(s *State) error {
 		return fmt.Errorf("Number of selected targets and required ones does not match")
 	}
 
-	for i, c := range t.constrains {
+	for i, c := range t.constraints {
 		sel := t.sel[i]
-		if err := c.constrain(sel); err != nil {
+		if err := c.constraint(sel); err != nil {
 			return fmt.Errorf("selected target %s does not fit its desciption %s: %s",
 				sel, c.desc, err)
 		}
@@ -112,25 +112,25 @@ func (t *Targets) CheckTargets(s *State) error {
 	return nil
 }
 
-func targetConstrain(desc string, s *State, action Action) TargetConstrainFunc {
-	constrains := []TargetConstrainFunc{}
+func targetConstraint(desc string, s *State, action Action) TargetConstraintFunc {
+	constraints := []TargetConstraintFunc{}
 	if strings.Contains(desc, "permanent") {
-		constrains = append(constrains, parsePermanentTargetConstrain(desc, s, action)...)
+		constraints = append(constraints, parsePermanentTargetConstraint(desc, s, action)...)
 	} else if strings.Contains(desc, "unit") {
-		constrains = append(constrains, parseUnitTargetConstrain(desc, s, action)...)
+		constraints = append(constraints, parseUnitTargetConstraint(desc, s, action)...)
 	} else if strings.Contains(desc, "artifact") {
-		constrains = append(constrains, parseArtifactTargetConstrain(desc, s, action)...)
+		constraints = append(constraints, parseArtifactTargetConstraint(desc, s, action)...)
 	} else if strings.Contains(desc, "tile") {
-		constrains = append(constrains, parseTileTargetConstrain(desc, s, action)...)
+		constraints = append(constraints, parseTileTargetConstraint(desc, s, action)...)
 		// } else if strings.Contains("action") {
-		// contrains = append(contrains, parseActionTargetConstrain(desc, s, action)...)
+		// constraints = append(constraints, parseActionTargetConstraint(desc, s, action)...)
 		// } else if strings.Contains("spell") {
-		// contrains = append(contrains, parseSpellTargetConstrain(desc, s, action)...)
+		// constraints = append(constraints, parseSpellTargetConstraint(desc, s, action)...)
 	}
 
 	return func(t interface{}) error {
-		for _, constrain := range constrains {
-			if err := constrain(t); err != nil {
+		for _, constraint := range constraints {
+			if err := constraint(t); err != nil {
 				return err
 			}
 		}
@@ -139,7 +139,7 @@ func targetConstrain(desc string, s *State, action Action) TargetConstrainFunc {
 	}
 }
 
-func enemyPermanentTargetConstrain(action Action) TargetConstrainFunc {
+func enemyPermanentTargetConstraint(action Action) TargetConstraintFunc {
 	var sourceController *Player
 	switch source := action.Source().(type) {
 	case *Player:
@@ -147,7 +147,7 @@ func enemyPermanentTargetConstrain(action Action) TargetConstrainFunc {
 	case Permanent:
 		sourceController = source.Controller()
 	default:
-		log.Fatalf("Unhandled source type %T in enemyPermanentTargetConstrain", source)
+		log.Fatalf("Unhandled source type %T in enemyPermanentTargetConstraint", source)
 	}
 
 	return func(t interface{}) (err error) {
@@ -160,7 +160,7 @@ func enemyPermanentTargetConstrain(action Action) TargetConstrainFunc {
 	}
 }
 
-func attackableTargetConstrain(action Action) TargetConstrainFunc {
+func attackableTargetConstraint(action Action) TargetConstraintFunc {
 	return func(t interface{}) (err error) {
 		p, _ := t.(Permanent)
 		if !p.Attackable() {
@@ -178,7 +178,7 @@ func attackableTargetConstrain(action Action) TargetConstrainFunc {
 	}
 }
 
-func rangeTargetConstrain(source interface{}, r int) TargetConstrainFunc {
+func rangeTargetConstraint(source interface{}, r int) TargetConstraintFunc {
 	var sourcePos Position
 	switch source := source.(type) {
 	case *Tile:
@@ -186,7 +186,7 @@ func rangeTargetConstrain(source interface{}, r int) TargetConstrainFunc {
 	case Permanent:
 		sourcePos = source.Tile().Position
 	default:
-		log.Fatalf("Unhandled source type %T in rangeTargetConstrain", source)
+		log.Fatalf("Unhandled source type %T in rangeTargetConstraint", source)
 	}
 
 	return func(t interface{}) (err error) {
@@ -199,7 +199,7 @@ func rangeTargetConstrain(source interface{}, r int) TargetConstrainFunc {
 	}
 }
 
-var permanentTargetConstrain TargetConstrainFunc = func(t interface{}) (err error) {
+var permanentTargetConstraint TargetConstraintFunc = func(t interface{}) (err error) {
 	_, ok := t.(Permanent)
 	if !ok {
 		err = fmt.Errorf("target is %T not Permanent", t)
@@ -207,31 +207,31 @@ var permanentTargetConstrain TargetConstrainFunc = func(t interface{}) (err erro
 	return
 }
 
-func parsePermanentTargetConstrain(desc string, s *State, action Action) []TargetConstrainFunc {
-	constrains := []TargetConstrainFunc{permanentTargetConstrain}
+func parsePermanentTargetConstraint(desc string, s *State, action Action) []TargetConstraintFunc {
+	constraints := []TargetConstraintFunc{permanentTargetConstraint}
 
 	if strings.Contains(desc, "enemy permanent") {
-		constrains = append(constrains, enemyPermanentTargetConstrain(action))
+		constraints = append(constraints, enemyPermanentTargetConstraint(action))
 	}
 
 	if strings.Contains(desc, "attackable ") {
-		log.Println("adding attackable contrained")
-		constrains = append(constrains, attackableTargetConstrain(action))
+		log.Println("adding attackable constrained")
+		constraints = append(constraints, attackableTargetConstraint(action))
 	}
 
 	if strings.Contains(desc, " in range ") {
 		tokens := strings.SplitN(desc, " in range ", 2)
 		r, err := strconv.Atoi(tokens[1])
 		if err != nil {
-			log.Fatalf("Invalid range %s in target constrain %s", tokens[1], desc)
+			log.Fatalf("Invalid range %s in target constraint %s", tokens[1], desc)
 		}
-		constrains = append(constrains, rangeTargetConstrain(action, r))
+		constraints = append(constraints, rangeTargetConstraint(action, r))
 	}
 
-	return constrains
+	return constraints
 }
 
-var unitTargetConstrain TargetConstrainFunc = func(t interface{}) (err error) {
+var unitTargetConstraint TargetConstraintFunc = func(t interface{}) (err error) {
 	_, ok := t.(*Unit)
 	if !ok {
 		err = fmt.Errorf("target is %T not *Unit", t)
@@ -239,26 +239,26 @@ var unitTargetConstrain TargetConstrainFunc = func(t interface{}) (err error) {
 	return
 }
 
-func parseUnitTargetConstrain(desc string, s *State, action Action) []TargetConstrainFunc {
-	constrains := []TargetConstrainFunc{unitTargetConstrain}
+func parseUnitTargetConstraint(desc string, s *State, action Action) []TargetConstraintFunc {
+	constraints := []TargetConstraintFunc{unitTargetConstraint}
 
 	if strings.Contains(desc, "enemy unit") {
-		constrains = append(constrains, enemyPermanentTargetConstrain(action))
+		constraints = append(constraints, enemyPermanentTargetConstraint(action))
 	}
 
 	if strings.Contains(desc, " in range ") {
 		tokens := strings.SplitN(desc, " in range ", 2)
 		r, err := strconv.Atoi(tokens[1])
 		if err != nil {
-			log.Fatalf("Invalid range %s in target constrain %s", tokens[1], desc)
+			log.Fatalf("Invalid range %s in target constraint %s", tokens[1], desc)
 		}
-		constrains = append(constrains, rangeTargetConstrain(action, r))
+		constraints = append(constraints, rangeTargetConstraint(action, r))
 	}
 
-	return constrains
+	return constraints
 }
 
-var artifactTargetConstrain TargetConstrainFunc = func(t interface{}) (err error) {
+var artifactTargetConstraint TargetConstraintFunc = func(t interface{}) (err error) {
 	_, ok := t.(*Artifact)
 	if !ok {
 		err = fmt.Errorf("target is %T not *Artifact", t)
@@ -266,12 +266,12 @@ var artifactTargetConstrain TargetConstrainFunc = func(t interface{}) (err error
 	return
 }
 
-func parseArtifactTargetConstrain(constrain string, s *State, action Action) []TargetConstrainFunc {
-	constrains := []TargetConstrainFunc{artifactTargetConstrain}
-	return constrains
+func parseArtifactTargetConstraint(constraint string, s *State, action Action) []TargetConstraintFunc {
+	constraints := []TargetConstraintFunc{artifactTargetConstraint}
+	return constraints
 }
 
-var tileTargetConstrain TargetConstrainFunc = func(t interface{}) (err error) {
+var tileTargetConstraint TargetConstraintFunc = func(t interface{}) (err error) {
 	_, ok := t.(*Tile)
 	if !ok {
 		err = fmt.Errorf("target is %T not *Tile", t)
@@ -279,13 +279,13 @@ var tileTargetConstrain TargetConstrainFunc = func(t interface{}) (err error) {
 	return
 }
 
-func parseTileTargetConstrain(desc string, s *State, action Action) []TargetConstrainFunc {
+func parseTileTargetConstraint(desc string, s *State, action Action) []TargetConstraintFunc {
 	log.Println("parsing", desc)
-	constrains := []TargetConstrainFunc{tileTargetConstrain}
+	constraints := []TargetConstraintFunc{tileTargetConstraint}
 
 	if moveAction, ok := action.(*MoveAction); ok {
 		u := moveAction.Source().(*Unit)
-		constrains = append(constrains, func(t interface{}) (err error) {
+		constraints = append(constraints, func(t interface{}) (err error) {
 			tile := t.(*Tile)
 			if slices.Contains(u.MoveRangeTiles(s.Map), tile) {
 				return nil
@@ -310,10 +310,10 @@ func parseTileTargetConstrain(desc string, s *State, action Action) []TargetCons
 
 	if strings.Contains(desc, "spawn") {
 		if player == nil {
-			log.Fatalf("Not implemented spawn tile constrain for %T", action)
+			log.Fatalf("Not implemented spawn tile constraint for %T", action)
 		}
 
-		constrains = append(constrains, func(t interface{}) (err error) {
+		constraints = append(constraints, func(t interface{}) (err error) {
 			tile := t.(*Tile)
 			if slices.Contains(s.AvailableSpawnTiles(player, card), tile) {
 				return nil
@@ -323,11 +323,11 @@ func parseTileTargetConstrain(desc string, s *State, action Action) []TargetCons
 	}
 
 	if strings.Contains(desc, "available") {
-		constrains = append(constrains, func(t interface{}) (err error) {
+		constraints = append(constraints, func(t interface{}) (err error) {
 			tile := t.(*Tile)
 
 			if card == nil {
-				log.Fatalf("Not implemented availability tile constrain for %T", action)
+				log.Fatalf("Not implemented availability tile constraint for %T", action)
 			}
 
 			if tile.IsAvailableForCard(card) {
@@ -337,14 +337,14 @@ func parseTileTargetConstrain(desc string, s *State, action Action) []TargetCons
 		})
 	}
 
-	return constrains
+	return constraints
 }
 
-func (c *TargetConstrain) options(s *State) (options []interface{}) {
+func (c *TargetConstraint) options(s *State) (options []interface{}) {
 	candidates := targetCandidates(c.desc, s)
 
 	for _, candidate := range candidates {
-		if err := c.constrain(candidate); err == nil {
+		if err := c.constraint(candidate); err == nil {
 			options = append(options, candidate)
 		}
 	}