anchor.diff:          Map.exists (fun _ v -> FieldSpace.containsSpecifiedCharacter index v) chessboard.FieldSpaces
       
       static member enemyAtCoordinates coordinates chessboard =
  -        chessboard.FieldSpaces.[coordinates].ContainsEnemy
  +        FieldSpace.containsEnemy chessboard.FieldSpaces.[coordinates]
       
       static member pickupAtCoordinates coordinates chessboard =
           chessboard.FieldSpaces.[coordinates].ContainsPickup
  
positive.code: type [<ReferenceEquality; NoComparison>] Chessboard =
      { FieldSpaces : Map<Vector2i, FieldSpace> }
  
      // NOTE: the following subset data can be optimized on demand by converting them from filters to storage caches, without interfering with the interface.
      
      member this.CharacterSpaces =
          Map.filter (fun _ (v : FieldSpace) -> v.ContainsCharacter) this.FieldSpaces
      
      member this.EnemySpaces =
          Map.filter (fun _ (v : FieldSpace) -> v.ContainsEnemy) this.FieldSpaces
  
      member this.PropSpaces =
          Map.filter (fun _ (v : FieldSpace) -> v.ContainsProp) this.FieldSpaces
      
      member this.PickupSpaces =
          Map.filter (fun _ (v : FieldSpace) -> v.ContainsPickup) this.FieldSpaces
  
      member this.OccupiedSpaces =
          Map.filter (fun _ (v : FieldSpace) -> v.IsOccupied) this.FieldSpaces |> Map.toKeyList
      
      member this.UnoccupiedSpaces =
          Map.filter (fun _ (v : FieldSpace) -> not v.IsOccupied) this.FieldSpaces |> Map.toKeyList
  
      member this.OpenDirections coordinates =
          List.filter (fun d -> List.exists (fun x -> x = (coordinates + (dtovc d))) this.UnoccupiedSpaces) [Upward; Rightward; Downward; Leftward]
  
      member this.Characters =
          Map.map (fun _ (v : FieldSpace) -> v.GetCharacter) this.CharacterSpaces
  
      member this.EnemyIndices =
          Map.toListBy (fun _ (v : FieldSpace) -> v.GetCharacterIndex) this.EnemySpaces
      
      member this.Pickups =
          Map.map (fun _ (v : FieldSpace) -> v.GetPickup) this.PickupSpaces
      
      member this.EnemyCount =
          this.EnemySpaces.Count
  
negative.code:     member this.GetCharacter =
          match this.CharacterOpt with Some character -> character | None -> failwithumf ()
      
      static member getCharacter (fieldSpace : FieldSpace) =
          fieldSpace.GetCharacter
      
      member this.GetCharacterIndex =
          this.GetCharacter.CharacterIndex
  
      static member getCharacterIndex (fieldSpace : FieldSpace) =
          fieldSpace.GetCharacterIndex
      
      static member tryGetOccupant fieldSpace =
          match fieldSpace.CharacterOpt with
          | Some character -> Some (OccupyingCharacter character)
          | None ->
              match fieldSpace.PropOpt with
              | Some prop -> Some (OccupyingProp prop)
              | None -> None
      
      member this.GetPickup =
          match this.PickupOpt with Some pickup -> pickup | None -> failwithumf ()
      
      static member getPickup (fieldSpace : FieldSpace) =
          fieldSpace.GetPickup
  
      member this.ContainsCharacter =
          match this.CharacterOpt with Some _ -> true | None -> false
  
      static member containsCharacter (fieldSpace : FieldSpace) =
          fieldSpace.ContainsCharacter
      
      static member containsEnemy fieldSpace =
          match fieldSpace.CharacterOpt with
          | None -> false // more efficient order
          | Some character -> character.IsEnemy
  
      static member containsSpecifiedCharacter index fieldSpace =
          match fieldSpace.CharacterOpt with
          | None -> false // more efficient order
  