default.wfs

##########################################################################
#
#    Tabs aren't allowed in this schema file. This file serves as a
# reference and must format well for all people.
#
#    Parameters are organized within sections. You may quickly jump to
# sections by searching for the string SECTION.
#
#    The parser of this file is not very flexible in how it processes
# syntax. Follow the conventions you see in this file and you will be
# fine. For example, put an opening brace on its own line as done in our
# C++ code, and no soup for you!
#
#
# --- QUICK REFERENCE ---
#
#   min/max = inclusive min/max
#
#   exmin/exmax = exclusive min/max
#
#   assert = expression that results in error if evaluates to False.
#
#   default = value used if not specified and LegacyMode == False or
#             LegacyMode == True and legacy value is not provided.
#
#   legacy = value used if not specified and LegacyMode == True
#
#   $(...) = expression evaluated by Python. Symbols are properties
#            in the values file.
#
##########################################################################

#-------------------------------------------------------------------
# SECTION Simulation meta-information
#-------------------------------------------------------------------

LegacyMode {
  type    BOOL
  default False # This *has* to be False, because underlying proplib.cpp
                # assumes False if it doesn't find it in the values file.
}

PassiveLockstep {
  type    BOOL
  default False
}

InitSeed {
  type    INT
  default 42
}

SimulationSeed {
  type    INT
  default 0	# 0: not used
}

GenomeLayout {
  type    ENUM
  default N
  legacy  L
  values  [
    N           # NeurGroup
    L           # Legacy
  ]
}

#-------------------------------------------------------------------
# SECTION Simulation parameters -- Primary
#-------------------------------------------------------------------

MaxSteps {
  type    INT
  default 30000
  min   0
}

MinAgents {
  type    INT
  default 90
  min     0 # not sure about this... should it be no less than 2?
}

MaxAgents {
  type    INT
  default 300
  min     $( MinAgents )
}

InitAgents {
  type    INT
  default 180
  min     $( MinAgents )
  max     $( MaxAgents )
}

SeedAgents {
  type    INT
  default $( InitAgents ) # think this is a good idea?
  min     0
  max     $( InitAgents ) # is this right? I have to look at the code.
}

SeedMutationProbability {
  type    FLOAT
  default 0.0
  min     0.0
  max     1.0
}  

InitFood {
  type    INT
  default $( MinFood ) # good idea?
  min     $( MinFood )
  max     $( MaxFood )
}

MinFood {
  type    INT
  default 90
  min     0
}

MaxFood {
  type    INT
  default 120
  min     $( MinFood )
}

MaxFoodGrown {
  type    INT
  default $( MinFood ) # good idea?
  max     $( MaxFood )
}

FoodGrowthRate {
  type    FLOAT
  default 0.1
  min     0.0
  max     1.0 # is this right?
}

FoodRemoveEnergy {
  type    FLOAT
  default 0.0
}

FoodMaxLifeSpan {
  type    INT
  default 0 # 0 means infinity
  min 0
}

MinFoodEnergy {
  type    FLOAT
  default 200.0
  exmin   0.0 # does this have to be > 0, or >= 0?
}

MaxFoodEnergy {
  type    FLOAT
  default 1000.0
  min     $( MinFoodEnergy )
}

RatioBarrierPositions {
  type    BOOL
  default True
  legacy  False
}

NumEnergyTypes {
  type    INT
  default 1
  min     1
}

#------------------------------
#--- Food Types 
#------------------------------
FoodTypes {
  type    ARRAY
  default [
    Name Standard
    EnergyPolarity [
      1
    ]
    OverrideFoodColor False
  ]
  
  element {
    type    OBJECT
    properties {

      Name {
        type    STRING
      }
    
      EnergyPolarity {
        type    ARRAY
        min     $( NumEnergyTypes )
        max     $( NumEnergyTypes )
        element {
          type    INT
          min     -1
          max     1
        }
      }

      # Does this type have a color that overrides the global FoodColor?
      OverrideFoodColor {
        type    BOOL
        default True
      }

      FoodColor {
        type    OBJECT
        default {
          R    0.2
          G    0.6
          B    0.2
        }
      
        properties {
          R {
            type    FLOAT
            min     0.0
            max     1.0
          }
          G {
            type    FLOAT
            min     0.0
            max     1.0
          }
          B {
            type    FLOAT
            min     0.0
            max     1.0
          }
        }
      }

    }
  }
}

#------------------------------
#--- Agent Metabolisms
#------------------------------
AgentMetabolisms {
  type    ARRAY
  min     1
  default [
    EnergyPolarity [
      1
    ]
  ]

  element {
    type    OBJECT
    properties {

      # If named "Null", will be assigned name "MetabolismN"
      Name {
        type    STRING
        default Null
      }

      EnergyPolarity {
        type    ARRAY
        min     $( NumEnergyTypes )
        max     $( NumEnergyTypes )
        default [
          1
        ]
        element {
          type    INT
          min     -1
          max     1
        }
      }

      CarcassFoodTypeMode {
        type    ENUM
        default FindEnergyPolarity
        values  [
          None
          FoodTypeName
          FindEnergyPolarity
        ]
      }

      CarcassFoodTypeName {
        type    STRING
        default Standard
      }

      MinEatAge {
        type OBJECT
        default {
          Conditions [
            Value 0
            Mode Time
          ]
        }
        properties {

          Record {
            type    BOOL
            default True
          }

          Conditions {
            type    ARRAY
            element {
              type    OBJECT
              properties {

                CouplingRange {
                  type    ENUM
                  default None
                  values [
                    None
                    Begin
                    End
                  ]
                }
          
                Value {
                  type    FLOAT
                  min     0
                }

                Mode {
                  type    ENUM
                  values [
                    Time
                    Count
                  ]
                }

                Time {
                  type    INT
                  default 0
                  min     0
                }
      
                Count {
                  type    OBJECT
                  default {
                  }
                  properties {
      
                    Value {
                      type    ENUM
                      default MetabolismAgents
                      values [
                        MetabolismAgents
                      ]
                    }
      
                    Op {
                      type    ENUM
                      default UNDEFINED
                      values [
                        UNDEFINED
                        EQ
                        GT
                        LT
                      ]
                      if $( Mode == \"Count\" ) {
                        assert $( Op != \"UNDEFINED\" )
                      }
                    }
                      
                    Threshold {
                      type    INT
                      default 0
                    }
      
                    Duration {
                      type    INT
                      default 0
                      min     0
                    }
      
                  }
                }

              }
            }
          }
        }
      }

      EatMultiplier {
        type OBJECT
        default {
          Conditions [
            Value [
              1
            ]
            Mode Time
          ]
        }
        properties {

          Record {
            type    BOOL
            default True
          }

          Conditions {
            type    ARRAY
            element {
              type    OBJECT
              properties {

                CouplingRange {
                  type    ENUM
                  default None
                  values [
                    None
                    Begin
                    End
                  ]
                }
          
                Value {
                  type    ARRAY
                  min     $( NumEnergyTypes )
                  max     $( NumEnergyTypes )
                  element {
                    type    FLOAT
                  }
                }

                Mode {
                  type    ENUM
                  values [
                    Time
                    Count
                  ]
                }

                Time {
                  type    INT
                  default 0
                  min     0
                }
      
                Count {
                  type    OBJECT
                  default {
                  }
                  properties {
      
                    Value {
                      type    ENUM
                      default MetabolismAgents
                      values [
                        MetabolismAgents
                      ]
                    }
      
                    Op {
                      type    ENUM
                      default UNDEFINED
                      values [
                        UNDEFINED
                        EQ
                        GT
                        LT
                      ]
                      if $( Mode == \"Count\" ) {
                        assert $( Op != \"UNDEFINED\" )
                      }
                    }
                      
                    Threshold {
                      type    INT
                      default 0
                    }
      
                    Duration {
                      type    INT
                      default 0
                      min     0
                    }
      
                  }
                }

              }
            }
          }
        }
      }
      
    }
  }
}

#------------------------------
# Barriers 
#------------------------------
Barriers {
  type    ARRAY
  default [
    # I don't think we actually want these as default values. These are values I was playing
    # with for shields. Note gaps on both ends of Z.
    KeyFrames [
      X1    0.33
      Z1    -0.9
      X2    0.33
      Z2    -0.1
    ]
  ,
    KeyFrames [
      X1    0.67
      Z1    -0.9
      X2    0.67
      Z2    -0.1
    ]
  ]

  element {               # element of Barriers[]
    type    OBJECT
    
    properties {          # properties of Barrier

      KeyFrames {
        type    ARRAY

        element {         # element of KeyFrames[]
          type    OBJECT
          properties {    # properties of KeyFrame
            
            CouplingRange {
              type    ENUM
              default None
              values [
                None
                Begin
                End
              ]
            }

	    Mode {
              type    ENUM
              default Time
              values [
                Time
                Count
              ]
            }

            Time {
              type    INT
              default 0
              min     0
            }

            Count {
              type    OBJECT
              default {
              }
              properties {

                Value {
                  type    ENUM
                  default Agents
                  values [
                    Agents
                  ]
                }

                Op {
                  type    ENUM
                  default UNDEFINED
                  values [
                    UNDEFINED
                    EQ
                    GT
                    LT
                  ]
                  if $( Mode == \"Count\" ) {
                    assert $( Op != \"UNDEFINED\" )
                  }
                }
                
                Threshold {
                  type    INT
                  default 0
                }

                Duration {
                  type    INT
                  default 0
                  min     0
                }
              }
            }

            X1 {
              type    FLOAT
              min     0.0
              max     $( 1.0 if RatioBarrierPositions else WorldSize )
            }
            Z1 {
              type    FLOAT
              max     0.0
              min     $( -1.0 if RatioBarrierPositions else -WorldSize )
            }

            X2 {
              type    FLOAT
              min     0.0
              max     $( 1.0 if RatioBarrierPositions else WorldSize )
            }
            Z2 {
              type    FLOAT
              max     0.0
              min     $( -1.0 if RatioBarrierPositions else -WorldSize )
            }
          }
        }
      }
    }
  }
}

#------------------------------
#--- Domains 
#------------------------------
Domains {
  type    ARRAY

  default [
    CenterX                   0.5
    CenterZ                   0.5
    SizeX                     1.0
    SizeZ                     1.0
    MinAgentsFraction         -1.0
    MaxAgentsFraction         -1.0
    InitAgentsFraction        -1.0
    InitSeedsFraction         -1.0
    ProbabilityOfMutatingSeeds -1.0
    InitFoodFraction          -1.0
    MinFoodFraction           -1.0
    MaxFoodFraction           -1.0
    MaxFoodGrownFraction      -1.0
    FoodRate                  -1.0
    FoodPatches [             
        FoodFraction              0.2
        InitFoodFraction          -1.0
        MinFoodFraction           -1.0
        MaxFoodFraction           1.0
        MaxFoodGrownFraction      1.0
        FoodRate                  -1.0
        CenterX                   0.5
        CenterZ                   0.05
        SizeX                     1.0
        SizeZ                     0.1
        Shape                     R
        Distribution              U
      ,                         
        FoodFraction              0.8
        InitFoodFraction          -1.0
        MinFoodFraction           -1.0
        MaxFoodFraction           1.0
        MaxFoodGrownFraction      1.0
        FoodRate                  -1.0
        CenterX                   0.5
        CenterZ                   0.8
        SizeX                     1.0
        SizeZ                     0.4
        Shape                     R
        Distribution              U
    ]
    BrickPatches [
    ]
  ]

  exmin   0
  max     10 # This number comes from the MAXDOMAINS symbol in Simulation.h. It is critical they match.

  element {
    type    OBJECT
    properties {

      CenterX {
        type    FLOAT
        exmin   0.0
        exmax   1.0
      }

      CenterZ {
        type    FLOAT
        exmin   0.0
        exmax   1.0
      }

      SizeX {
        type    FLOAT
        exmin   0.0
        max     1.0
      }

      SizeZ {
        type    FLOAT
        exmin   0.0
        max     1.0
      }

      MinAgentsFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (MinAgentsFraction == -1.0) or (MinAgentsFraction >= 0.0) )
      }

      MaxAgentsFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (MaxAgentsFraction == -1.0) or (MaxAgentsFraction >= 0.0) )
      }

      InitAgentsFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (InitAgentsFraction == -1.0) or (InitAgentsFraction >= 0.0) )
      }

      InitSeedsFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (InitSeedsFraction == -1.0) or (InitSeedsFraction >= 0.0) )
      }

      ProbabilityOfMutatingSeeds {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (ProbabilityOfMutatingSeeds == -1.0) or (ProbabilityOfMutatingSeeds >= 0.0) )
      }

      InitFoodFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (InitFoodFraction == -1.0) or (InitFoodFraction >= 0.0) )
      }

      MinFoodFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (MinFoodFraction == -1.0) or (MinFoodFraction >= 0.0) )
      }

      MaxFoodFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (MaxFoodFraction == -1.0) or (MaxFoodFraction >= 0.0) )
      }

      MaxFoodGrownFraction {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (MaxFoodGrownFraction == -1.0) or (MaxFoodGrownFraction >= 0.0) )
      }

      FoodRate {
        type    FLOAT
	default -1.0
        max     1.0
        assert  $( (FoodRate == -1.0) or (FoodRate >= 0.0) )
      }

      #------------------------------
      # FoodPatches
      #------------------------------
      FoodPatches {
        type    ARRAY

        element {
          type    OBJECT

          properties { # Please pay attention to min/max/assert logic. I didn't put enough thought into it.

            FoodTypeName {
              type    STRING
              default Standard
            }

            FoodFraction {
              type    FLOAT
              exmin   0.0
              max     1.0
            }

            InitFoodFraction {
              type    FLOAT
	      default -1.0
              max     1.0
              assert  $( (InitFoodFraction == -1.0) or (InitFoodFraction >= 0.0) )
            }
                                    
            MinFoodFraction {
              type    FLOAT
	      default -1.0
              max     1.0
              assert  $( (MinFoodFraction == -1.0) or (MinFoodFraction >= 0.0) )
            }
                                    
            MaxFoodFraction {
              type    FLOAT
	      default -1.0
              max     1.0
              assert  $( (MaxFoodFraction == -1.0) or (MaxFoodFraction >= 0.0) )
            }
                                    
            MaxFoodGrownFraction {
              type    FLOAT
	      default -1.0
              max     1.0
              assert  $( (MaxFoodGrownFraction == -1.0) or (MaxFoodGrownFraction >= 0.0) )
            }
                                    
            FoodRate {
              type    FLOAT
	      default -1.0
              max     1.0
              assert  $( (FoodRate == -1.0) or (FoodRate >= 0.0) )
            }

            CenterX {
              type    FLOAT
              exmin   0.0
              exmax   1.0
            }
      
            CenterZ {
              type    FLOAT
              exmin   0.0
              exmax   1.0
            }
      
            SizeX {
              type    FLOAT
              exmin   0.0
              max     1.0
            }
      
            SizeZ {
              type    FLOAT
              exmin   0.0
              max     1.0
            }

            Shape {
              type    ENUM
              default R
              values [
                R           # Rectangular
                E           # Elliptical
              ]
            }

            Distribution {
              type    ENUM
              default U
              values [
                U           # Uniform
                L           # Linear
                G           # Gaussian
              ]
            }

            NeighborhoodSize {
              type    FLOAT
              default 10.0
              min     0.0
              max     $( WorldSize ) # what should the max be? this is kind of a fudge factor, isn't it?
            }

            RemoveFood {
              type    BOOL
              default False
            }

            OnCondition {
              type    OBJECT
              default {
              }

              properties {
                Mode {
                  type    ENUM
                  default Time
                  values [
                    Time
                    MaxPopGroup
                  ]
                }

                Time {
                  type    OBJECT
                  default {
                  }

                  properties {
                
                    Period {
                      type    INT
                      default 0
                      min     0
                    }

                    OnFraction {
                      type    FLOAT
                      default 1.0
                      min     0.0
                      max     1.0
                    }

                    Phase {
                      type    FLOAT
                      default 0.0
                      min     0.0
                      max     1.0
                    }

                  } # Time properties
                } # Time

                MaxPopGroup {
                  type    OBJECT
                  default {
                  }

                  properties {

                    MaxAgents {
                      type    INT
                      default 200
                      min     0
                    }

                    Timeout {
                      type    INT
                      default 2000
                      assert  $( Timeout == -1 or Timeout > 0 )
                    }

                    Delay {
                      type    INT
                      default 0
                      min     0
                    }

                    Group {
                      type    ENUM
                      default Domain
                      values [
                        Domain
                        World
                      ]
                    }

                  } # MaxPopGroup properties
                } # MaxPopGroup

              } # OnCondition properties
            } # OnCondition
                                    
          } # FoodPatch properties
        } # FoodPatches[] element
      }  # FoodPatches[]


      #------------------------------
      # BrickPatches
      #------------------------------
      BrickPatches {
        type    ARRAY

        default [
        ]

        element {
          type    OBJECT

          properties {

            CenterX {
              type    FLOAT
              exmin   0.0
              exmax   1.0
            }
      
            CenterZ {
              type    FLOAT
              #exmin   0.0
              #exmax   1.0
            }
      
            SizeX {
              type    FLOAT
              exmin   0.0
              max     1.0
            }
      
            SizeZ {
              type    FLOAT
              exmin   0.0
              max     1.0
            }

            BrickCount {
              type    INT
              exmin   0
            }

            Shape {
              type    ENUM
              default R
              values [
                R           # Rectangular
                E           # Elliptical
              ]
            }

            Distribution {
              type    ENUM
              default U
              values [
                U           # Uniform
                L           # Linear
                G           # Gaussian
              ]
            }

            NeighborhoodSize {
              type    FLOAT
              default 0.0
              min     0.0
              max     $( WorldSize ) # what should the max be? this is kind of a fudge factor, isn't it?
            }

            OverrideBrickColor {
              type    BOOL
              default False
            }

            #
            # Optional color override for this patch.
            #
            BrickColor {
              type    OBJECT
              default {
                R    0.6
                G    0.2
                B    0.2
              }
            
              properties {
                R {
                  type    FLOAT
                  min     0.0
                  max     1.0
                }
                G {
                  type    FLOAT
                  min     0.0
                  max     1.0
                }
                B {
                  type    FLOAT
                  min     0.0
                  max     1.0
                }
              }
            }

            #
            # Index of food patch to which this brick patch's On state is linked.
            # -1 == No sync
            #
            OnSyncFoodPatchIndex {
              type    INT
              min     -1
              default -1
            }

          } # BrickPatch properties
        } # BrickPatches[] element
      }  # BrickPatches[]

    } # Domain properties
  } # Domains[] element
} # Domains[]


#-------------------------------------------------------------------
# SECTION Simulation parameters -- Secondary
#-------------------------------------------------------------------

WorldSize {
  type    FLOAT
  default 100.0
  exmin   0.0
}

Edges { # TODO: I don't know what this is in the code.
  type    ENUM
  default B
  values [
    B         # Blocked
    W         # Wraparound
    T         # Tabletop    
  ]
}

#
# Can the agents slide along the world edge?
#
StickyEdges {
  type    BOOL
  default False
}

#
# Can the agents slide along barriers?
#
StickyBarriers {
  type    BOOL
  default False
}

AgentsAreFood {
  type    ENUM
  default True
  values [
    Fight        # If died by fight.
  ]
  scalar {
    type    BOOL
  }
}

MaxMateVelocity {
  type    OBJECT
  default {
  } 
  properties {

    Record {
      type    BOOL
      default True
    }

    Conditions {
      type    ARRAY
      default [
        Mode Time
        Value 1.0
        Time 0
      ]
      element {
        type    OBJECT
    
        properties {

          CouplingRange {
            type    ENUM
            default None
            values [
              None
              Begin
              End
            ]
          }
    
          Value {
            type    FLOAT
            exmin   0.0
            max     1.0
          }
              
          Mode {
            type    ENUM
            default IntThreshold
            values [
              Time
              IntThreshold
            ]
          }
              
          Time {
            type    INT
            default 0
            min     0
          }
    
          IntThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default Agents
                values [
                  Agents
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"IntThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    INT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

        }
      }
    }
  }
}

MinEatVelocity {
  type    OBJECT
  default {
  } 
  properties {

    Record {
      type    BOOL
      default True
    }

    Conditions {
      type    ARRAY
      default [
        Mode Time
        Value 0.0
        Time 0
      ]
      element {
        type    OBJECT
    
        properties {

          CouplingRange {
            type    ENUM
            default None
            values [
              None
              Begin
              End
            ]
          }
    
          Value {
            type    FLOAT
            min     0.0
            exmax   1.0
          }
              
          Mode {
            type    ENUM
            default IntThreshold
            values [
              Time
              IntThreshold
	      FloatThreshold
            ]
          }
              
          Time {
            type    INT
            default 0
            min     0
          }
    
          IntThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default Agents
                values [
                  Agents
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"IntThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    INT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

          FloatThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default EatFailed
                values [
                  EatFailed
                  EatFailedYaw
                  EatFailedVel
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"FloatThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    FLOAT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

        }
      }
    }
  }
}

MaxEatVelocity {
  type    OBJECT
  default {
  } 
  properties {

    Record {
      type    BOOL
      default True
    }

    Conditions {
      type    ARRAY
      default [
        Mode Time
        Value 1.0
        Time 0
      ]
      element {
        type    OBJECT
    
        properties {

          CouplingRange {
            type    ENUM
            default None
            values [
              None
              Begin
              End
            ]
          }
    
          Value {
            type    FLOAT
            exmin   0.0
            max     1.0
          }
              
          Mode {
            type    ENUM
            default IntThreshold
            values [
              Time
              IntThreshold
	      FloatThreshold
            ]
          }
              
          Time {
            type    INT
            default 0
            min     0
          }
    
          IntThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default Agents
                values [
                  Agents
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"IntThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    INT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

          FloatThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default EatFailed
                values [
                  EatFailed
                  EatFailedYaw
                  EatFailedVel
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"FloatThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    FLOAT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

        }
      }
    }
  }
}

MaxEatYaw {
  type    OBJECT
  default {
  } 
  properties {

    Record {
      type    BOOL
      default True
    }

    Conditions {
      type    ARRAY
      default [
        Mode Time
        Value 1.0
        Time 0
      ]
      element {
        type    OBJECT
    
        properties {

          CouplingRange {
            type    ENUM
            default None
            values [
              None
              Begin
              End
            ]
          }
    
          Value {
            type    FLOAT
            exmin   0.0
            max     1.0
          }
              
          Mode {
            type    ENUM
            default IntThreshold
            values [
              Time
              IntThreshold
	      FloatThreshold
            ]
          }
              
          Time {
            type    INT
            default 0
            min     0
          }
    
          IntThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default Agents
                values [
                  Agents
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"IntThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    INT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

          FloatThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default EatFailed
                values [
                  EatFailed
                  EatFailedYaw
                  EatFailedVel
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"FloatThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    FLOAT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

        }
      }
    }
  }
}

MateWait {
  type    INT
  default 25
  min     0
  exmax   $( MaxLifeSpan )
}

InitMateWait {
  type    INT
  default 0
  min     0
  exmax   $( MaxLifeSpan )
}

EatMateWait {
  type    INT
  default 0
  min     0
  exmax   $( MaxLifeSpan )
}

# Minimum distance agent must be from last eat position before can mate.
EatMateMinDistance {
  type    OBJECT
  default {
  } 
  properties {

    Record {
      type    BOOL
      default True
    }

    Conditions {
      type    ARRAY
      default [
        Mode Time
        Value 0.0
        Time 0
      ]
      element {
        type    OBJECT
    
        properties {

          CouplingRange {
            type    ENUM
            default None
            values [
              None
              Begin
              End
            ]
          }
    
          Value {
            type    FLOAT
            min   0.0
            max     $(WorldSize)
          }
              
          Mode {
            type    ENUM
            default IntThreshold
            values [
              Time
              IntThreshold
            ]
          }
              
          Time {
            type    INT
            default 0
            min     0
          }
    
          IntThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default Agents
                values [
                  Agents
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"IntThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    INT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

        }
      }
    }
  }
}

EnableMateWaitFeedback {
  type    BOOL
  default True
  legacy  False
}

EnableSpeedFeedback {
  type    BOOL
  default True
  legacy  False
}

EnableGive {
  type    BOOL
  default True
  legacy  False
}

EnableCarry {
  type    BOOL
  default True
  legacy  False

  # TODO: 1) Enhance tokenizer to support quotes.
  #       2) Enhance eval() to automatically escape quotes in expressions.
  #       3) Support new "statement" node so we can have multiple warn or assert statements in the
  #          same scope. Currently, they're properties, so there is a name clash.
  if $( EnableCarry ) {
    if $( MaxCarries == 0 ) {
      warn $( \"EnableCarry = True, but MaxCarries = 0\" )
    } elif $( not (CarryAgents or CarryFood or CarryBricks) ) {
      warn $( \"EnableCarry = True, but CarryAgents, CarryFood, and CarryBricks all False.\" )
    }
  }
}

MaxCarries {
  type    INT
  default 3
}

CarryAgents {
  type    BOOL
  default True
}

CarryFood {
  type    BOOL
  default True
}

CarryBricks {
  type    BOOL
  default True
}

ShieldAgents {
  type    BOOL
  default False
}

ShieldFood {
  type    BOOL
  default False
}

ShieldBricks {
  type    BOOL
  default True
  legacy  False
}

CarryPreventsEat {
  type    FLOAT
  default 0.0
  min     0.0
  max     1.0
}

CarryPreventsFight {
  type    FLOAT
  default 0.0
  min     0.0
  max     1.0
}

CarryPreventsGive {
  type    FLOAT
  default 0.0
  min     0.0
  max     1.0
}

CarryPreventsMate {
  type    FLOAT
  default 0.0
  min     0.0
  max     1.0
}

EnableVisionPitch {
  type    BOOL
  default True
  legacy  False
}

MinVisionPitch {
  type    FLOAT
  default -7.5
  min     -90.0
  max     0.0
}

MaxVisionPitch {
  type    FLOAT
  default 7.5
  min     0
  max     90.0
}

EnableVisionYaw {
  type    BOOL
  default True
  legacy  False
}

MinVisionYaw {
  type    FLOAT
  default -90.0
  min     -180.0
  max     0.0
}

MaxVisionYaw {
  type    FLOAT
  default 90
  min     0
  max     180.0
}

EyeHeight {
  type    FLOAT
  default 1.0
  legacy  0.5
  min     0.0
  max     1.0
}

BodyRedChannel {
  type    ENUM
  default Fight
  values [
    Fight
    Give
  ]
  scalar {
    type    FLOAT
    min     0.0
    max     1.0
  }
}

BodyGreenChannel {
  type    ENUM
  default I
  values [
    I             # ID gene
    L             # Light neuron
  ]
  scalar {
    type    FLOAT
    min     0.0
    max     1.0
  }
}

BodyBlueChannel {
  type    ENUM
  default Mate
  values [
    Mate
    Energy
  ]
  scalar {
    type    FLOAT
    min     0.0
    max     1.0
  }
}

NoseColor {
  type    ENUM
  default L
  values [
    L            # Light neuron
  ]
  scalar {
    type    FLOAT
    min     0.0
    max     1.0
  }
}

AgentHealingRate {
  type    FLOAT
  default 0.0
  min     0.0
  max     $( MaxAgentMaxEnergy )
}

SolidAgents {
  type    BOOL
  default False
}

SolidFood {
  type    BOOL
  default False
}

SolidBricks {
  type    BOOL
  default False
  legacy  True
}

PreBirthCycles {
  type    INT
  default 25
  min     0
}

NumDepletionSteps {
  type    INT
  default 125
  legacy  0
  min     0
}

ApplyLowPopulationAdvantage {
  type    BOOL
  default True
  legacy  False
}

#-------------------------------------------------------------------
# SECTION Simulation parameters -- Tertiary
#-------------------------------------------------------------------
	
MaxVelocity {
  type    FLOAT
  default 1.0
  exmin   0.0
}

MotionRate {
  type    FLOAT
  default 1.0
  exmin   0.0
}

YawRate {
  type    FLOAT
  default 20.0
  exmin   0.0
}

YawEncoding {
  type    ENUM
  values [
    Oppose
    Squash
  ]
  default Oppose
  legacy  Squash
}

MinAgentMaxEnergy {
  type    FLOAT
  default 500.0
  exmin   0.0
}

MaxAgentMaxEnergy {
  type    FLOAT
  default 1000.0
  min     $( MinAgentMaxEnergy )
}

MinFoodEnergyAtDeath {
  type    FLOAT
  default 0.0
  min     0.0
}

MiscegenationDelay {
  type    INT
  default -1       # -1: off
  min     -1
}

MiscegenationFunctionBias {
  type    FLOAT
  default 1.0
}

MiscegenationFunctionInverseSlope {
  type    FLOAT
  default 2.0
}

FoodEnergySizeScale {
  type    FLOAT
  default 400.0
  exmin   0.0
}

FoodConsumptionRate {
  type    FLOAT
  default 100.0
  exmin   0.0
}

MinMateEnergyFraction {
  type    FLOAT
  default 0.0		# (eliminate someday?)
  min     0.0
  max     1.0
}

MinHorizontalFieldOfView {
  type    FLOAT
  default 20.0
  exmin   0.0
}

MaxHorizontalFieldOfView {
  type    FLOAT
  default 140.0
  min     $( MinHorizontalFieldOfView )
}

VerticalFieldOfView {
  type    FLOAT
  default 10.0
  exmin   0.0
}

MaxSizeFightAdvantage {
  type    FLOAT
  default 2.5
}

MinSizeEnergyPenalty {
  type    FLOAT
  default 0.0
  min     0.0
}

MaxSizeEnergyPenalty {
  type    FLOAT
  default 10.0
  min     $( MinSizeEnergyPenalty )
}

DamageRate {
  type    FLOAT
  default 2.5
}

ProbabilisticFoodPatches {
  type    BOOL
  default True
  legacy  False
}

RandomBirthLocation {
  type    BOOL
  default False
}

RandomBirthLocationRadius {
  type    FLOAT
  default 1.0
  min     0.0
  max     1.0
}

SmiteMode {
  type    ENUM
  default O
  values [
    O         # Off
    R         # Random
    L         # Least Fit
  ]
}

SmiteFrac {
  type    FLOAT
  default 0.1
}

SmiteAgeFrac {
  type    FLOAT
  default 0.25
}

FogFunction {
  type    ENUM
  default O
  values [
    O        # Off
    L        # Linear
    E        # Exponential
  ]
}

ExpFogDensity {
  type    FLOAT
  default 0.1		# only applies to exponential fog
}

LinearFogEnd {
  type    INT
  default 33		# only applies to linear fog
}

#-------------------------------------------------------------------
# SECTION Simulation parameters -- Gene Expression (in legacy gene order)
#-------------------------------------------------------------------

MinAgentSize {
  type    FLOAT
  default 0.5
}

MaxAgentSize {
  type    FLOAT
  default 2.0
}

MinAgentStrength {
  type    FLOAT
  default 0.5
}

MaxAgentStrength {
  type    FLOAT
  default 2.0
}

MinAgentMaxSpeed {
  type    FLOAT
  default 0.5
}

MaxAgentMaxSpeed {
  type    FLOAT
  default 1.5
}

MinMutationRate {
  type    FLOAT
  default 0.001
}

MaxMutationRate {
  type    FLOAT
  default 0.005
}

MinCrossoverPoints {
  type    INT
  default 2
}

MaxCrossoverPoints {
  type    INT
  default 8
}

MinLifeSpan {
  type    INT
  default 500
}

MaxLifeSpan {
  type    INT
  default 1000
}

MinEnergyFractionToOffspring {
  type    FLOAT
  default 0.2
}

MaxEnergyFractionToOffspring {
  type    FLOAT
  default 0.8
}

MinVisionNeuronsPerGroup {
  type    INT
  default 1
}

MaxVisionNeuronsPerGroup {
  type    INT
  default 16
}

MinInternalNeuralGroups {
  type    INT
  default 20
}

MaxInternalNeuralGroups {
  type    INT
  default 20
}

MinExcitatoryNeuronsPerGroup {
  type    INT
  default 0
}

MaxExcitatoryNeuronsPerGroup {
  type    INT
  default 16
}

MinInhibitoryNeuronsPerGroup {
  type    INT
  default 0
}

MaxInhibitoryNeuronsPerGroup {
  type    INT
  default 16
}

MinConnectionDensity {
  type    FLOAT
  default 0.0
}

MaxConnectionDensity {
  type    FLOAT
  default 1.0
}

MinTopologicalDistortion {
  type    FLOAT
  default 0.0
}

MaxTopologicalDistortion {
  type    FLOAT
  default 1.0
}

MinLearningRate {
  type    FLOAT
  default 0.0
}

MaxLearningRate {
  type    FLOAT
  default 0.1
}

#-------------------------------------------------------------------
# SECTION Simulation parameters -- Gene Options
#-------------------------------------------------------------------

MinInitialBitProb {
  type    FLOAT
  default 0.1		# default to 0.5?
}

MaxInitialBitProb {
  type    FLOAT
  default 0.6		# default to 0.5?
}



EnableTopologicalDistortionRngSeed {
  type    BOOL
  default True
  legacy  False
}

MinTopologicalDistortionRngSeed {
  type    INT
  default 0
}

MaxTopologicalDistortionRngSeed {
  type    INT
  default 255
}



EnableInitWeightRngSeed {
  type    BOOL
  default True
  legacy  False
}

MinInitWeightRngSeed {
  type    INT
  default 0
}

MaxInitWeightRngSeed {
  type    INT
  default 255
}



SeedFightBias {
  type    FLOAT
  default 0.0
  legacy  0.5
}

SeedFightExcitation {
  type    FLOAT
  default 0.0
  legacy  1.0
}

SeedGiveBias {
  type    FLOAT
  default 0.0
}

SeedPickupBias {
  type    FLOAT
  default 0.0
}

SeedDropBias {
  type    FLOAT
  default 0.0
}

SeedPickupExcitation {
  type    FLOAT
  default 0.0
}

SeedDropExcitation {
  type    FLOAT
  default 0.0
}

#-------------------------------------------------------------------
# SECTION Simulation parameters -- Neural Function
#-------------------------------------------------------------------

LogisticSlope {
  type    FLOAT
  default 0.5
}

MaxSynapseWeight {
  type    FLOAT
  default 8.0
}

MaxSynapseWeightInitial {
  type    FLOAT
  default 2.0
}

SynapseWeightDecayRate {
  type    FLOAT
  default 0.99
}

MaxBiasWeight {
  type    FLOAT
  default 8.0
}

NeuronModel {
  type    ENUM
  default F
  values [
    F             # Firing Rate
    T             # Tau
    S             # Spiking
  ]
}

EnableSpikingGenes {
  type BOOL
  default True
}

SpikingAMin {
  type    FLOAT
  default 0.001
}

SpikingAMax {
  type    FLOAT
  default 0.2
}

SpikingBMin {
  type    FLOAT
  default 0.01
}

SpikingBMax {
  type    FLOAT
  default 0.3
}

SpikingCMin {
  type    FLOAT
  default -80
}

SpikingCMax {
  type    FLOAT
  default -30
}

SpikingDMin {
  type    FLOAT
  default 0.1
}

SpikingDMax {
  type    FLOAT
  default 10
}


TauMin {
  type    FLOAT
  default 0.01
}

TauMax {
  type    FLOAT
  default 1.0
}

TauSeed {
  type    FLOAT
  default 1.0
}


#-------------------------------------------------------------------
# SECTION Simulation parameters -- Behavior Control
#-------------------------------------------------------------------

EatThreshold {
  type    FLOAT
  default 0.2
}

MateThreshold {
  type    FLOAT
  default 0.5
}

FightThreshold {
  type    FLOAT
  default 0.2
}

GiveThreshold {
  type    FLOAT
  default 0.3
  legacy  0.2
}

PickupThreshold {
  type    FLOAT
  default 0.5
}

DropThreshold {
  type    FLOAT
  default 0.5
}

FightMode {
  type    ENUM
  default Normal
  values [
    Normal
    Null
  ]
}

FightMultiplier {
  type    FLOAT
  default 1.0
}

GiveFraction {
  type    FLOAT
  default 0.2
  legacy  1.0
}


#-------------------------------------------------------------------
# SECTION Simulation parameters -- Energy Use
#-------------------------------------------------------------------
	
EnergyUseEat {
  type    FLOAT
  default 0.01
}

EnergyUseMateMode {
  type    ENUM
  default Constant
  values  [
    Constant
    Conditional
  ]
}

EnergyUseMate {
  type    FLOAT
  default 0.1
}

EnergyUseMateConditional {
  type    OBJECT
  default {
  } 
  properties {

    Record {
      type    BOOL
      default True
    }

    Conditions {
      type    ARRAY
      default [
        Mode Time
        Value 0.1
        Time 0
      ]
      element {
        type    OBJECT
    
        properties {

          CouplingRange {
            type    ENUM
            default None
            values [
              None
              Begin
              End
            ]
          }
    
          Value {
            type    FLOAT
            min   0.0
          }
              
          Mode {
            type    ENUM
            default IntThreshold
            values [
              Time
              IntThreshold
            ]
          }
              
          Time {
            type    INT
            default 0
            min     0
          }
    
          IntThreshold {
            type    OBJECT
            default {
            }
            properties {
    
              Value {
                type    ENUM
                default Agents
                values [
                  Agents
                ]
              }
    
              Op {
                type    ENUM
                default UNDEFINED
                values [
                  UNDEFINED
                  EQ
                  GT
                  LT
                ]
                if $( Mode == \"IntThreshold\" ) {
                  assert $( Op != \"UNDEFINED\" )
                }
              }
                    
              Threshold {
                type    INT
                default 0
              }
    
              Duration {
                type    INT
                default 0
                min     0
              }
            }
          }

        }
      }
    }
  }
}

EnergyUseFight {
  type    FLOAT
  default 1.0
}

EnergyUseGive {
  type    FLOAT
  default 1.0
}

EnergyUseMove {
  type    FLOAT
  default 0.1
}

EnergyUseTurn {
  type    FLOAT
  default 0.1
}

EnergyUseLight {
  type    FLOAT
  default 0.01
}

EnergyUseFocus {
  type    FLOAT
  default 0.001
}

EnergyUsePickup {
  type    FLOAT
  default 0.5
}

EnergyUseDrop {
  type    FLOAT
  default 0.001
}

EnergyUseCarryAgent {
  type    FLOAT
  default 0.05
}

EnergyUseCarryAgentSize {
  type    FLOAT
  default 0.05
}

EnergyUseCarryFood {
  type    FLOAT
  default 0.01
}

EnergyUseCarryBrick {
  type    FLOAT
  default 0.01
}

EnergyUseNeurons {
  type    FLOAT
  default 1.84
}

EnergyUseSynapses {
  type    FLOAT
  default 0.34
}

EnergyUseFixed {
  type    FLOAT
  default 0.05
}

#-------------------------------------------------------------------
# SECTION Simulator control
#-------------------------------------------------------------------

ComplexityType {
  type    ENUM
  default P
  values [
    O        # Off
    P        # Processing
    A        # All
    I        # Input
    B        # Behavior
    D        # Processing-Input
    Z        # ZeroMaxVelocityHack
  ]
}

RecordGeneSeparation {
  type    BOOL
  default False
}

EndOnPopulationCrash {
  type    BOOL
  default False
}

StaticTimestepGeometry {
  type    BOOL
  default True
  legacy  False
}

ParallelInitAgents {
  type    BOOL
  default True
  legacy  False
}

ParallelInteract {
  type    BOOL
  default True
  legacy  False
}

ParallelCreateAgents {
  type    BOOL
  default True
  legacy  False
}

# This only takes effect if StaticTimestepGeometry is True.
# Its primary purpose is for easing debugging with False value.
ParallelBrains {
  type    BOOL
  default True
  legacy  True
}

CheckPointFrequency {
  type    INT
  default 1000
}

StatusFrequency {
  type    INT
  default 100
}

RetinaWidth {
  type    INT
  default 22
}

RetinaHeight {
  type    INT
  default $( RetinaWidth )
  assert $( RetinaWidth == RetinaHeight ) # change this when we support more than one row
}

AgentHeight {
  type    FLOAT
  default 0.2
}

FoodHeight {
  type    FLOAT
  default 0.6
}

FoodColor {
  type    OBJECT
  default {
    R    0.2
    G    0.6
    B    0.2
  }

  properties {
    R {
      type    FLOAT
      min     0.0
      max     1.0
    }
    G {
      type    FLOAT
      min     0.0
      max     1.0
    }
    B {
      type    FLOAT
      min     0.0
      max     1.0
    }
  }
}

BrickHeight {
  type    FLOAT
  default 0.5
}

BrickColor {
  type    OBJECT
  default {
    R    0.6
    G    0.2
    B    0.2
  }

  properties {
    R {
      type    FLOAT
      min     0.0
      max     1.0
    }
    G {
      type    FLOAT
      min     0.0
      max     1.0
    }
    B {
      type    FLOAT
      min     0.0
      max     1.0
    }
  }
}

BarrierHeight {
  type    FLOAT
  default 5.0
}

BarrierColor {
  type    OBJECT
  default {
    R    0.35
    G    0.25
    B    0.15
  }

  properties {
    R {
      type    FLOAT
      min     0.0
      max     1.0
    }
    G {
      type    FLOAT
      min     0.0
      max     1.0
    }
    B {
      type    FLOAT
      min     0.0
      max     1.0
    }
  }
}

GroundColor {
  type    OBJECT
  default {
    R    0.1
    G    0.15
    B    0.05
  }

  properties {
    R {
      type    FLOAT
      min     0.0
      max     1.0
    }
    G {
      type    FLOAT
      min     0.0
      max     1.0
    }
    B {
      type    FLOAT
      min     0.0
      max     1.0
    }
  }
}

GroundClearance {
  type    FLOAT
  default 0.0
}

CameraColor {
  type    OBJECT
  default {
    R    0.3
    G    0.3
    B    0.3
  }

  properties {
    R {
      type    FLOAT
      min     0.0
      max     1.0
    }
    G {
      type    FLOAT
      min     0.0
      max     1.0
    }
    B {
      type    FLOAT
      min     0.0
      max     1.0
    }
  }
}

CameraRadius {
  type    FLOAT
  default 0.6
}

CameraHeight {
  type    FLOAT
  default 0.35
}

CameraRotationRate {
  type    FLOAT
  default 0.09
}

CameraAngleStart {
  type    FLOAT
  default 0.0
}

CameraFieldOfView {
  type    FLOAT
  default 90.0
}

BrainMonitorFrequency {
  type    INT
  default 1
}

GrayCoding {
  type    BOOL
  default False
}

RecordMovie {
  type    BOOL
  default False
}

RecordBirthsDeaths {
  type    BOOL
  default True
  legacy  False
}

RecordPosition {
  type    BOOL
  default True
  legacy  False
}

RecordBarrierPosition {
  type    BOOL
  default True
  legacy  False
}

RecordContacts {
  type    BOOL
  default True
  legacy  False
}

RecordCollisions {
  type    BOOL
  default True
  legacy  False
}

RecordCarry {
  type    BOOL
  default True
  legacy  False
}

RecordEnergy {
  type    BOOL
  default True
  legacy  False
}

BrainAnatomyRecordAll {
  type    BOOL
  default True
  legacy  False
}

BrainFunctionRecordAll {
  type    BOOL
  default True
  legacy  False
}

BrainAnatomyRecordSeeds {
  type    BOOL
  default True
  legacy  False
}

BrainFunctionRecordSeeds {
  type    BOOL
  default True
  legacy  False
}

BestSoFarBrainAnatomyRecordFrequency {
  type    INT
  default 1000
}

BestSoFarBrainFunctionRecordFrequency {
  type    INT
  default 1000
}

BestRecentBrainAnatomyRecordFrequency {
  type    INT
  default 1000
}

BestRecentBrainFunctionRecordFrequency {
  type    INT
  default 1000
}

RecordGeneStats {
  type    BOOL
  default True
  legacy  False
}

RecordPerformanceStats {
  type    BOOL
  default True
}

RecordFoodPatchStats {
  type    BOOL
  default True
  legacy  False
}

RecordComplexity {
  type    BOOL
  default False
}

RecordAdamiComplexity {
  type    BOOL
  default True
  legacy  False
}

AdamiComplexityRecordFrequency {
  type    INT
  default 200
}

RecordGenomes {
  type    BOOL
  default True
  legacy  False
}

RecordSeparations {
  type    BOOL
  default True
  legacy  False
}

CompressFiles {
  type    BOOL
  default True
  legacy  False
}

#-------------------------------------------------------------------
# SECTION Simulator resume control
#-------------------------------------------------------------------

SeedGenomeFromRun {
  type    BOOL
  default False
}

SeedPositionFromRun {
  type    BOOL
  default False
}

#-------------------------------------------------------------------
# SECTION Genetic algorithm parameters
#-------------------------------------------------------------------

EliteFrequency {
  type    INT
  default 100
}

PairFrequency {
  type    INT
  default 2
}

NumberFittest {
  type    INT
  default 30
}

NumberRecentFittest {
  type    INT
  default 10
}

ComplexityFitnessWeight {
  type    FLOAT
  default 0.0
  legacy  $( 0.0 if ComplexityType == \"O\" else 1.0 )
}

HeuristicFitnessWeight {
  type    FLOAT
  default 0.0
}

#-------------------------------------------------------------------
# SECTION Heuristic fitness function parameters
#-------------------------------------------------------------------

FitnessWeightEating {
  type    FLOAT
  default 10.0
}

FitnessWeightMating {
  type    FLOAT
  default 100.0
}

FitnessWeightMoving {
  type    FLOAT
  default 0.1
}

FitnessWeightEnergyAtDeath {
  type    FLOAT
  default 5.0
}

FitnessWeightLongevity {
  type    FLOAT
  default 25.0
}

#-------------------------------------------------------------------
# SECTION Eliminate
#-------------------------------------------------------------------

WrapAround {
  type    BOOL
  default False	# now use "Borders", requires code change
}

Vision {
  type    BOOL
  default True	# make always true
}

ShowVision {
  type    BOOL
  default True
  assert $( ShowVision ) # make always true (until drawn offscreen, and then base on window visibility)
}

PositionSeed {
  type    INT
  default 42		# not used
}

MonitorAgentRank {
  type    INT
  default 1		# always initialize to 1
}

MonitorGeneSeparation {
  type    BOOL
  default False	# use visibility of the gene separation window and fRecordGeneSeparation in their respective places
}

ChartBorn {
  type    BOOL
  default True	# base it on window visibility; be careful as this metric is displayed and printed in stats
}

ChartFitness {
  type    BOOL
  default True	# base on window visibility
}

ChartFoodEnergy {
  type    BOOL
  default True	# base on window visibility
}

ChartPopulation {
  type    BOOL
  default True	# base on window visibility
}

ChartGeneSeparation {
  type    BOOL
  default False	# base on window visibility
}

MinBiasLrate {
  type    FLOAT
  default 0.0		# set to zero or disable entirely
}

MaxBiasLrate {
  type    FLOAT
  default 0.0		# set to zero or disable entirely
}

OverHeadRank {
  type    INT
  default 1		# just always initialize fOverHeadRank to 1
}

AgentTracking {
  type    BOOL
  default True	# base on tracking/overhead-view window visibility
}

#********************************************************************************
#-------------------------------------------------------------------
# Rename (as above)
#-------------------------------------------------------------------

DumpFrequency				--->		CheckPointFrequency
MinWin						--->		RetinaWidth, RetinaHeight
MinNumAgents				--->		MinAgents
MaxNumAgents				--->		MaxAgents
InitNumAgents				--->		InitAgents
NumberToSeed				--->		SeedAgents
ProbabilityOfMutatingSeeds	--->		SeedMutationProbability
SeedFromFile				--->		SeedGenomeFromRun
PositionSeedsFromFile		--->		SeedPositionFromRun
MiscAgents					--->		MiscegenationDelay
MiscBias					--->		MiscegenationFunctionBias
MiscInvisSlope				--->		MiscegenationFunctionInverseSlope
InitFoodCount				--->		InitFood
MinFoodCount				--->		MinFood
MaxFoodCount				--->		MaxFood
FoodRate					--->		FoodGrowthRate
GenomeSeed					--->		InitSeed
AgentsRfood					--->		AgentsAreFood
Fitness1Frequency			--->		EliteFrequency
Fitness2Frequency			--->		PairFrequency
NumberFit					--->		NumberFittest
NumberRecentFit				--->		NumberRecentFittest
EatMateSpan					--->		EatMateWait
EatFitnessParameter			--->		FitnessWeightEating
MateFitnessParameter		--->		FitnessWeightMating
MoveFitnessParameter		--->		FitnessWeightMoving
EnergyFitnessParameter		--->		FitnessWeightEnergyAtDeath
AgeFitnessParameter			--->		FitnessWeightLongevity
Size2Energy					--->		FoodEnergySizeScale
Eat2Consome					--->		FoodConsumptionRate
MinVisPixels				--->		MinVisionNeuronsPerGroup
MaxVisPixels				--->		MaxVisionNeuronsPerGroup
MinNumCpts					--->		MinCrossoverPoints
MaxNumCpts					--->		MaxCrossoverPoints
MinStrength					--->		MinAgentStrength
MaxStrength					--->		MaxAgentStrength
MinMaxEnergy				--->		MinAgentMaxEnergy
MaxMaxEnergy				--->		MaxAgentMaxEnergy
MinMateEnergy				--->		MinEnergyFractionToOffspring
MaxMateEnergy				--->		MaxEnergyFractionToOffspring
MinMateFrac					--->		MinMateEnergyFraction
MinMaxSpeed					--->		MinAgentMaxSpeed
MaxMaxSpeed					--->		MaxAgentMaxSpeed
Speed2DPosition				--->		MotionRate
Yaw2DYaw					--->		YawRate
MinLRate					--->		MinLearningRate
MaxLRate					--->		MaxLearningRate
MinFocus					--->		MinHorizontalFieldOfView
MaxFocus					--->		MaxHorizontalFieldOfView
AgentFOV					--->		VerticalFieldOfView
MaxSizeAdvantage			--->		MaxSizeFightAdvantage
Power2Energy				--->		DamageRate
Eat2Energy					--->		EnergyUseEat
Mate2Energy					--->		EnergyUseMate
Fight2Energy				--->		EnergyUseFight
Speed2Energy				--->		EnergyUseMove
Yaw2Energy					--->		EnergyUseTurn
Light2Energy				--->		EnergyUseLight
Focus2Energy				--->		EnergyUseFocus
Pickup2Energy				--->		EnergyUsePickup
Drop2Energy					--->		EnergyUseDrop
CarryAgent2Energy			--->		EnergyUseCarryAgent
CarryAgentSize2Energy		--->		EnergyUseCarryAgentSize
CarryFood2Energy			--->		EnergyUseCarryFood
CarryBrick2Energy			--->		EnergyUseCarryBrick
MaxNeuron2Energy			--->		EnergyUseNeurons
MaxSynapse2Energy			--->		EnergyUseSynapses
FixedEnergyDrain			--->		EnergyUseFixed
MinSizePenalty				--->		MinSizeEnergyPenalty
MaxSizePenalty				--->		MaxSizeEnergyPenalty
LogisticsSlope				--->		LogisticSlope
MaxWeight					--->		MaxSynapseWeight
InitMaxWeight				--->		MaxSynapseWeightInitial
DecayRate					--->		SynapseWeightDecayRate
FightFraction				--->		FightMultiplier
MinBitProb					--->		MinInitialBitProb
MaxBitProb					--->		MaxInitialBitProb
CameraFOV					--->		CameraFieldOfView
BrainMonitorStride			--->		BrainMonitorFrequency
UseProbabilisticFoodPatches --->		ProbabilisticFoodPatches
MinInternalNeurGroups		--->		MinInternalNeuralGroups
MaxInternalNeurGroups		--->		MaxInternalNeuralGroups
MinENeurPerGroup			--->		MinExcitatoryNeuronsPerGroup
MaxENeurPerGroup			--->		MaxExcitatoryNeuronsPerGroup
MinINeurPerGroup			--->		MinInhibitoryNeuronsPerGroup
MaxINeurPerGroup			--->		MaxInhibitoryNeuronsPerGroup
MaxBias						--->		MaxBiasWeight
NumPreBirthCycles			--->		PreBirthCycles
********************************************************************************#