FOCS Scripting Details

From FreeOrionWiki
Revision as of 11:16, 6 February 2015 by Geoff the Medio (Talk | contribs) (List)

Jump to: navigation, search

This page describes the scripting language used to describe much of the content of FreeOrion. This language is sometimes referred to as the FreeOrion Content Script, or "FOCS". Scripted content includes scripted descriptions of technology, buildings, and specials. These content files are text files, but some of them include special characters and therefor when editing them a somewhat more advanced editor is necessary. For example, on Windows, the Notepad and Wordpad editors can cause trouble, but the third party NotePad++ editor should be fine. An added benefit of using NotePad++ is that one of our contributors has made an add-on to help with the FOCS syntax.

Content Files

FreeOrion content is described in content files located in the /default subdirectory of the main FreeOrion game directory (typically 'C:\Freeorion').

File                | Contents
--------------------+--------------------------------------
techs.txt           | Tech Categories and Technologies
buildings.txt       | Buildings
specials.txt        | Specials (general)
planet_specials.txt | Specials (randomly placed on planets)
ship_hulls.txt      | Ship Hulls
ship_parts.txt      | Ship Parts
species.txt         | Species
space_monsters.txt  | ShipDesigns to use as space monsters

These files are structured as a list of descriptions of individual entries of their respective contents. buildings.txt is a list of "BuildingType" descriptions (see below). specials.txt is a list of "Special" descriptions. techs.txt contains tech category and tech descriptions. The ordering of entries in the files do not matter, except for techs.txt, which requires that a particular tech category entries appear before any techs are listed as part of that category.

The primary building blocks used to specify the above types of FreeOrion content are ValueRefs (value references), Conditions, and EffectsGroups (which contain Effects and Conditions). Effects change the game state and thereby give buildings, techs and specials their in-game purpose. Conditions act to filter a starting set of objects to a smaller set (which might sometimes wind up being one or none). In EffectsGroups Conditions determine if (the activation condition) and on what (the scope condition) effects act. Conditions also have a few other uses, such as determining where buildings or ship parts or hulls can be produced, and where species focus settings can be used; they are also used within some of the more advanced ValueRefs. ValueRefs provide values used by the other portions of the script. Sometimes that might be a simple constant, like three, which the scripter would simply write as "3". Other times that might be a dynamic value such as the current game turn number, scripted as "CurrentTurn". In other cases that might be something much more complex, such as the number of monsters within two starlane jumps of a given system; the syntax for such value references is described farther below.

Scripting Format

In FOCS, whitespace (spaces, tabs, and line endings) is only for the visual clarity of the script, and capitalization is ignored for everything outside of quotes.

Words in quotes, eg. "NAME" are case-sensitive names of scripted content items such as techs, buildings, or specials. The names of the items are defined in their description by their line:

name = "NAME"

These items may be referred to in other items' descriptions by "NAME". This might typically be done when unlocking a building with a tech, or adding or checking for the presence of a special to or on an object.

Comments may be added to files using c/c++-style comment blocks. Anything in such blocks will be ignored when parsing the content files. Anything after "/*" will be ignored until the next occurrence of "*/" (even if it occurs several lines later), and anything on a line after "//" will be ignored.

In the FOCS descriptions below, the fixed portion of the FOCS specifications are in lower case or MixedCase; things written in ALLCAPS are placeholders for scripted subcontent. That type of any such piece of scripted subcontent below is specified either as a Condition, an Effect, an EffectsGroup, a string, an int (integer), or a double (a "real" number such as 2.4). In many cases, any such string, int or double can be provided either as a simple constant or as a more complicated scripted ValueRef. In any situations where a plain constant is required (but not a ValueRef), we endeavor to specify those values as string_constant, int_constant and double_constant.

EffectsGroup

EffectsGroup

  scope = CONDITION
  activation = CONDITION [optional -- may be left out]
  stackinggroup = "STACKINGGROUP" [optional -- may be left out]
  effects = {EFFECT|[
      EFFECT
      EFFECT
      EFFECT
  ]}

Param Types:

SCOPE          Condition
ACTIVATION     Condition
STACKINGGROUP  string_constant
EFFECT         Effect

Describes the mechanism by which game content such as Techs, Buildings or Specials interacts with and alters the game state.

  • Consists primarily of:
    • One or more Effects
    • A "SCOPE" condition which indicates the objects in the scope of the Effect(s). The scope objects are those that are acted on by the effects in the effects group.
    • An "ACTIVATION" condition which indicates whether or not the Effect(s) will be executed on the objects in scope during the current turn.
  • Conditions start with a set of objects, and return subsets of this set according to whether the objects meet the criteria of the condition. For scope conditions, the entire game universe (or rather, all objects in it) are the initial set.
  • For activation conditions, the initial set is the source object of the effects group. This allows an EffectsGroup to be activated or suppressed based on the source object only (the object to which the EffectsGroup is attached). If the source object meets the activation condition, the EffectsGroup will be active in the current turn.
  • An EffectsGroup's stacking group determines when it should affect a specific target; if that target has already been affected by another EffectsGroup with the same stacking group, all EffectsGroups after the first have no effect on the target that turn. For instance, if an EffectsGroup is in a stacking group "WONDER_FARM_BONUS", and executes on a target object, no other EffectsGroup in the "WONDER_FARM_BONUS" stacking group will affect it on that turn.

Special

Special

  name = "NAME"
  description = "DESCRIPTION"
  effectsgroups = {EFFECTSGROUP|[     [optional -- may be left out]
       EFFECTSGROUP
       EFFECTSGROUP
       EFFECTSGROUP
  ]}

Param Types:

NAME           string_constant
DESCRIPTION    string_constant
EFFECTSGROUP   EffectsGroup

A specification for a Special, which is a definition of a predefined set of EffectsGroups with a unique name, which may be attached to an object in-game.

  • Specials used in the game are stored in specials.txt and planet_specials.txt.
    • specials.txt contains general specials that may be applied to objects using the AddSpecial effect.
    • planet_specials.txt contains specials that may be randomly applied to planets during universe generation.

BuildingType

BuildingType

   name = "NAME"
   description = "DESCRIPTION"
   buildcost = BUILDCOST
   buildtime = BUILDTIME
   location = CONDITION
   [captureresult = CAPTURERESULT]
   effectsgroups = {EFFECTSGROUP|[    [optional -- may be left out]
       EFFECTSGROUP
       EFFECTSGROUP
       EFFECTSGROUP
   ]}
   graphic = "GRAPHICFILENAME"

Param Types:

NAME             string_constant
DESCRIPTION      string_constant
BUILDCOST        double
BUILDTIME        int
LOCATION         Condition
CAPTURERESULT    CaptureResult
EFFECTSGROUP     EffectsGroup
GRAPHICFILENAME  string_constant

A specification for a building of a certain type.

  • BuildingTypes must each have a unique name.
  • BuildingTypes used in the game are stored in buildings.txt.
  • The note about Special name and description text also applies to BuildingTypes.
  • GRAPHICFILENAME should be relative to the art directory. So it should appear in the form "foo/bar.png" instead of "default/data/art/foo/bar.png".

Item

Item type = TYPE name = "NAME"

Param Types:

TYPE             UnlockableItemType
NAME             string_constant

A specification for an unlockable item.

  • Item definitions appear within Tech definitions.
  • type defines the kind of thing to be unlocked, e.g. a Building, ShipHull, ShipPart, or Tech.
  • name is the name of the specific item of that kind to be unlocked, e.g. a "WonderFarm" building or a "MegaLaser" ship part.
  • The note about Special and BuildingType name and description text also applies to Items.

Tech Category

TechCategory name = "NAME" graphic = "GRAPHIC" colour = COLOUR

Param Type:

NAME string
GRAPHIC string_constant
COLOUR colour

Specifies a technology category.

  • Techs are displayed by category in the UI
  • A category must be defined in techs.txt before a tech in that category may be defined (later in the same file)

Colour

(RED, GREEN, BLUE, ALPHA)

Param Type:

RED    int_constant
GREEN  int_constant
BLUE   int_constant
ALPHA  int_constant

Specifies a colour.

  • Brackets must surround the colour component numbers, which must also be separated by commas.
  • Colour components are specified in the range [0, 255]
  • Example: in a TechCategory definition, one might write:
colour = (116, 225, 107, 255)

FocusType

FocusType
    name = NAME
    description = DESCRIPTION
    location = CONDITION
    graphic = GRAPHICFILENAME

Specifies a focus setting for a planet.

  • Within each species, each FocusType must have a unique name. Two different species may have (the same or different) FocusTypes with the same name, however.
  • The location condition determines which planets on which the FocusType can be used.
  • The graphic determines the icon used to represent the FocusType in the UI.

Tech

Tech
   name = "NAME"
   description = "DESCRIPTION"
   short_description = "SHORT_DESCRIPTION"
   techtype = TYPE
   category = "CATEGORY"
   researchcost = RESEARCHCOST
   researchturns = RESEARCHTURNS
   prerequisites = {"NAME"|[
       "NAME"
       "NAME"
       "NAME"
   ]}
   unlock = {ITEM|[
       ITEM
       ITEM
       ITEM
   ]}
   effectsgroups = {EFFECTSGROUP|[ [optional -- may be left out]
        EFFECTSGROUP
        EFFECTSGROUP
        EFFECTSGROUP
   ]}
   graphic = "GRAPHICFILENAME"

Param Types:

NAME               string_constant
DESCRIPTION        string_constant
SHORT_DESCRIPTION  string_constant
TYPE               TechType
CATEGORY           string_constant
RESEARCHCOST       double
RESEARCHTURNS      double
NAME               string_constant
ITEM               Item
EFFECTSGROUP       EffectsGroup

A specification for a technology.

  • Techs must each have a unique name.
  • Each tech may optionally have one or more EffectsGroups associated with it.
    • Tech EffectsGroups are use as their source object the capitol planet of the empire that researches the tech.
  • All of a tech's prerequisites must be known before a Tech can be researched.
    • Theory techs can only depend on other Theory techs
    • Refinements cannot be prerequisites except for other refinements.
  • The note about Special and BuildingType name and description text also applies to Tech names, descriptions, and category names.
  • GRAPHICFILENAME should be relative to the art directory. So it should appear in the form "foo/bar.png" instead of "default/data/art/foo/bar.png".
  • Techs used in the game are stored in techs.txt. That file includes examples of theory techs with no effects or unlocked items, as well as applications that unlock buildings or which have effects of their own.

Ship Hull

Hull
   name = "NAME"
   description = "DESCRIPTION"
   speed = BATTLESPEED
   starlaneSpeed = STARLANESPEED
   fuel = FUEL
   stealth = STEALTH
   health = HEALTH
   buildCost = BUILDCOST
   buildTime = BUILDTIME
   location = CONDITION
   effectsgroups = {EFFECTSGROUP|[ [optional -- may be left out]
        EFFECTSGROUP
        EFFECTSGROUP
        EFFECTSGROUP
   ]}
   graphic = "GRAPHICFILENAME"

Param Types:

NAME               string_constant
DESCRIPTION        string_constant
BATTLESPEED        double_constant
STARLANESPEED      double_constant
FUEL               double_constant
STEALTH            double_constant
HEALTH             double_constant
BUILDCOST          double
BUILDTIME          int
CONDITION          Condition
EFFECTSGROUP       EffectsGroup
GRAPHICFILENAME    string_constant

A specification for a ship hull.

  • Hulls must each have a unique name.
  • Each hull may optionally have one or more EffectsGroups associated with it.
    • Hull EffectsGroups are use as their source object the ship in which the hull is located.
  • The note about Special and BuildingType name and description text also applies to Hull names and descriptions.
  • GRAPHICFILENAME should be relative to the art directory. So it should appear in the form "foo/bar.png" instead of "default/data/art/foo/bar.png".
  • Hulls used in the game are stored in ship_hulls.txt.

Ship Part

Part
   name = "NAME"
   description = "DESCRIPTION"
   class = CLASS
   {STATS  --  format depends on CLASS}
   buildCost = BUILDCOST
   buildTime = BUILDTIME
   mountableSlotTypes = {SLOTTYPE|[
        SLOTTYPE
        SLOTTYPE
        SLOTTYPE
   ]}
   location = CONDITION
   effectsgroups = {EFFECTSGROUP|[ [optional -- may be left out]
        EFFECTSGROUP
        EFFECTSGROUP
        EFFECTSGROUP
   ]}
   graphic = "GRAPHICFILENAME"

Param Types:

NAME               string_constant
DESCRIPTION        string_constant
CLASS              PartClass
SLOTTYPE           SlotType
CONDITION          Condition
EFFECTSGROUP       EffectsGroup
GRAPHICFILENAME    string_constant

STATS is a series of parameters that depends on the CLASS of the part.


A specification for a ship part.

  • Parts must each have a unique name.
  • Each part may optionally have one or more EffectsGroups associated with it.
    • Part EffectsGroups are use as their source object the ship in which the part is located.
  • The note about Special and BuildingType name and description text also applies to Part names and descriptions.
  • GRAPHICFILENAME should be relative to the art directory. So it should appear in the form "foo/bar.png" instead of "default/data/art/foo/bar.png".
  • Hulls used in the game are stored in ship_parts.txt.

Species

Species
   name = "NAME"
   description = "DESCRIPTION"
   foci = {FOCUSTYPE|[             [optional -- may be left out]
       FOCUSTYPE
       FOCUSTYPE
       FOCUSTYPE
   ]}
   effectsgroups = {EFFECTSGROUP|[ [optional -- may be left out]
        EFFECTSGROUP
        EFFECTSGROUP
        EFFECTSGROUP
   ]}
   environments = {PLANETTYPEENVIRONMENT [optional -- may be left out]
       PLANETTYPEENVIRONMENT
       PLANETTYPEENVIRONMENT
       PLANETTYPEENVIRONMENT
   ]}
   graphic = "GRAPHICFILENAME"

Param Types:

NAME                   string_constant
DESCRIPTION            string_constant
FOCUSTYPE              FocusType
EFFECTSGROUP           EffectsGroup
PLANETTYPEENVIRONMENT  (see below)
GRAPHICFILENAME        string_constant
  • Species must have a unique name.
  • PLANETTYPEENVIRONMENT has format:
type = PLANETTYPE environment = ENVIRONMENT

with param types:

PLANETTYPE         PlanetType
ENVIRONMENT        PlanetEnvironment


ShipDesign

ShipDesign
   name = "NAME"
   description = "DESCRIPTION"
   lookup_strings = true
   hull = "HULLTYPE"
   parts = [
       "PARTTYPE"
       "PARTTYPE"
       "PARTTYPE"
   ]
   graphic = "GRAPHICFILENAME"
   model = "MODELNAME"

Types and Expressions (ValueRefs)

In the Conditions and Effects below, there are parameters that specify details about how the condition or effect functions. These parameters can be specified as a constant number (eg. 5) or value (Blue), or can be variables that depend on the gamestate. Variables may refer to the Source, Target, RootCandidate or LocalCandidate objects (see below), a few independent values such as the number of the current game turn, or may refer to statistics about the gamestate that are calculated from multiple objects.

Source, Target, RootCandidate, LocalCandidate

ValueRefs, Conditions and Effects are evaluated in light of an automatically generated Scripting Context, which specifies one or more of a Source, Target, RootCandidate, and LocalCandidate. The way these get automatically generated depends on what content type is being evaluated.

For an Effect, the Source object is the object to which the Effect is attached. For example, a building might have an effect that increases a planet's industry meter. When defining that building's effects, the building itself would be the Source object.

The Target object of an Effect is the object that the Effect is modifying. In an effect that modifies a planet's industry meter, the planet would be the Target object.

The objects being tested by Conditions are candidates, and for reference within the scripts these are broadly divided into two types relating to the potentially multi-tiered nature of Conditions. Consider the following EffectsGroup scope condition:

 scope = WithinDistance distance = 5 condition = And [
   Planet
   OwnedBy TheEmpire RootCandidate.Owner
   Construction low = 0 high = LocalCandidate.TargetConstruction / 2
 ]

Here there are two sets of objects being matched: 1) The objects actually being matched for the scope. These are objects within distance 5 of an object matched by the subcondition. 2) The objects matched by the subcondition, which are used to evaluate the outer condition. These are planets that are owned by the same empire that owns the object matched in the outer condition, and that have less than half their own target construction.

RootCandidate refers to the object being matched in the outer-most condition - WithinDistance in this case. This gives a way to refer to the object actually being matched by a big multi-part condition from one of the inner condition definitions, where the object being matched by a subcondition is likely not the same object being matched by the outer condition.

LocalCandidate refers to the object being matched in whatever condition it is directly in - the Construction meter condition in this case. This gives a way to refer to the object being matched by the current condition, regardless of what other conditions are matching outside or inside the current condition.

The RootCandidate and LocalCandidate may be used with the same types of variable references as for Source and Target.

For the Location condition, BuildTime value and BuildCost value for content such as a BuildingType, ShipHull or ShipPart, the context Source is the EmpireSource for the empire currently under consideration; this is its Capital planet if it has one, otherwise some other object owned by the empire. The Target in this context is the potential production location (planet) for which the Location, BuildTime or BuildCost is being evaluated.

For EmpireStatistic ValueRefs, the scripting context only has a Source, which is the EmpireSource mentioned above.

Free/Independent Variables

There are some variables that may be used without referring directly to the Source, Target or candidate objects. The current free variables that may be referenced are those specifying the galaxy setup conditions, and one which provides the current game turn. These currently all provide an integer result. For galaxy setup variables, their underlying type is generally a specialized enumeration which for this purpose gets mapped to an integer corresponding to the order they get listed in the GalaxySetup screen. For example, most galaxy setup variables work with range [None, Low, Medium, High], which gets mapped to [0, 1, 2, 3]. (Many of those variables drop the None value, and so have a range of 1-3.) Current Max AI Aggressions range from 0 to 5. The current list of free variables is:

CurrentTurn             int
GalaxyAge               int
GalaxyMaxAIAggression   int
GalaxyMonsterFrequency  int
GalaxyNativeFrequency   int
GalaxyPlanetDensity     int
GalaxyShape             int
GalaxySize              int
GalaxySpecialFrequency  int
GalaxyStarlaneFrequency int
UniverseCentreX         double
UniverseCentreY         double

Object Attributes

Object attributes are variables that are properties of the Source, Target, LocalCandidate, or RootCandidate objects.

List

Here is a comprehensive list of the attributes available (but not necessarily currently used in-game), and their types (more on types later):

Industry                  double
TargetIndustry            double
Research                  double
TargetResearch            double
Trade                     double
TargetTrade               double
Construction              double
TargetConstruction        double
Population                double
TargetPopulation          double
TargetHappiness           double
Happiness                 double
MaxFuel                   double
Fuel                      double
MaxShield                 double
Shield                    double
MaxDefense                double
Defense                   double
MaxTroops                 double
Troops                    double
RebelTroops               double
MaxStructure              double
Structure                 double
Supply                    double
Stealth                   double
Detection                 double
BattleSpeed               double
StarlaneSpeed             double
TradeStockpile            double
X                         double
Y                         double
SizeAsDouble              double
NextTurnPopGrowth         double
Size                      double
DistanceFromOriginalType  double
PlanetSize                PlanetSize +
PlanetType                PlanetType +
PlanetEnvironment         PlanetEnvironment +
ObjectType                UniverseObjectType +!
StarType                  StarType +
Focus                     string
Species                   string
BuildingType              string
Owner                     int ++
ID                        int +++
CreationTurn              int
Age                       int
ProducedByEmpireID        int
DesignID                  int ++++
FleetID                   int
PlanetID                  int
SystemID                  int
FinalDestinationID        int
NextSystemID              int
PreviousSystemID          int
NumShips                  int
LastTurnBattleHere        int
LastTurnActiveInBattle    int
Orbit                     int
Species                   int
TurnsSinceFocusChange     int


+ The valid values for these types are listed after the corresponding conditions below. These values may change however, so for the most up-to-date list, it may be necessary to consult the FreeOrion source code.
++ Owner will return -1 if there are no owners (such as for a roaming space monster or unexplored system)
+++ This is the unique integer ID used to identify an object internally within FreeOrion.
++++ This is the unique integer ID used to identify a ship design.
! The types returned by ObjectType have some overlap. For instance, a Planet is also a PopCenter and a ProdCenter. In this case, Planet is returned before PopCenter or ProdCenter, since if you see a Planet, you know it is a ProdCenter, but seeing a ProdCenter, you have no idea if it is a Planet or something else that produces goods or resources, for instance a mining outpost. This principle guides the order in which type is determined when ObjectType is used.

Value

As a special case, there is a utility variable available that is used like a free variable, but actually refers to the target object:

Value                 double, int, string, PlanetSize, PlanetType, StarType

The type returned by "Value" depend on the type of effect in which it is used. For meter-setting effects, or when setting an empire stockpile, Value will be a double. For SetPlanetSize, it will be a PlanetSize, and similarly for lanetType, PlanetEnvironment, StarType. For setting a planet's species, Value will be a string.

The value of "Value" is the initial value of whatever is being set. For example, in a SetStealth effect, "Value" would return the same as "Target.Stealth". For SetPlanetType, "Value" would return the same as "Target.PlanetType".

Statistics

Statistics are values calculated from a sampling of objects in the game universe, which may or may not include the Source and Target objects.

List

The available statistical calculations that can be performed on the property values of objects matching the sampling condition are:

Number
Sum
Mean
RMS
Mode
Max
Min
Spread
STDEV
Product

Mode may be used for any type of parameter, including enumerated types like PlanetSize and double or int or string. The other statistic types may be used only for parameters that are int or double.

Use

Constants

In item descriptions, parameter values such as LOW, HIGH, or NUMBER may be simple numbers, like 5 or 10, in which case all objects with the appropriate meter are treated the same by Turn.

Variables

Parameter values may also be defined in terms of attributes (or "properties") of the Source or Target object. In these cases, different objects may be differently matched or not, if the property used differs between them.

Object attributes can be referenced on the source or target object, but not alone. So "Source.ID" and "Target.PlanetSize" are legal variables, but "PlanetEnvironment" in isolation is not.

Parameter values may also be defined in terms of the free variables mentioned above that are not associated with a particular object. In this case, the variable name is used without any object reference; for example, "CurrentTurn" returns the current game turn.

Parameter values for meter-altering effects may also refer to "Value" which is equivalent to referring to the meter of the target object that is being altered, depending which meter-setting effect is being used.

In addition, an object's containing object, if one exists, may be used in a variable. For instance, if the source is a planet, "Source.System.StarType" represents the star type of the source's system. Planet may also be used in a similar fashion, as in "Target.Planet.PlanetEnvironment".

Nonsensical combinations of Target, Source, Planet, System, and the above attributes are allowed, but will always return 0 for numeric values, and a special value representing an invalid value for enumerated type values. The special invalid value is guaranteed not to match the value of any actual object.

For example, if the source object is a System, Source.System.StarType will always return an invalid Star Type.

Similarly, Target.System.Farming makes no sense (since farming meters meters exist for Planets but not Systems), and so will return the double value 0.0.

Statistics

Parameter values may also be defined in terms of statistics calculated from the gamestate. A statistic returns a value based on the specified property, calculation and a condition to select objects in the game Universe.

In any place where a constant or variable could be specified, a statistic may be used instead. The format for a statistic calculation is:

StatisticType property = PropertyName condition = SamplingCondition

The "property =" and "condition =" may be omitted:

StatisticType PropertyName SamplingCondition

For example, to calculate the sum of all planets' populations,

Sum Population Planet

The result would return a double value, which will be used just as if a constant like 42.4 had been specified, or a variable like Target.Population had been specified.

Types

The "double" type listed above, is a double-precision floating point number, which is more or less any real number in the range [-10^300, 10^300]. The "int" type is an integer number, which is basically any whole number in the range [-2*10^9, 2*10^9]. The other types are enumerated types, with specific values. Each such value has a string associated with it, for instance the first valid StarType is Blue.

In the Conditions and Effects below, certain parameters have types. It is illegal to provide a parameter of the wrong type, and it will result in a thrown exception (a purposeful crash of FreeOrion). There is one major exceptions to this. It is legal to provide a int value for any parameter of any type. This is mainly to support easy expression syntax, which is the next thing that needs to be addressed.

Instead of providing a singe variable or constant value (such as 3.14, 5, or STAR_BLUE), you can instead provide an arithmetic expression. Legal expressions may contain parentheses, +, -, *, / and ^ (for exponentiation). The - operator can be binary as in "3 - 4", or unary as in "-Source.MaxHealth". Whitespace (spaces, tabs, and newlines) is ignored. Expressions may be arbitrarily complex. The type of the entire expression must match the type of the parameter for which it is intended. For instance, it is illegal to supply "1 + 3.14" as a value for an int-type parameter, since 3.14 is not an int. As mentioned before, though, it is legal to supply "STAR_BLUE + 1" as a value for a StarType parameter, since integers are always ok.

Note that since arbitrarily complex expressions are allowed in Effects, and multiple Effects may affect a single target in a single turn, the order in which the Effects are applied to the target may matter. For instance, if Effect A sets the current industry meter to "Target.Industry + 20", and Effect B sets the current industry meter to "Target.Industry * 3", the answer could be X * 3 + 20 or (X + 20) * 3, depending on the order of execution. To minimize this, and in keeping with the guidelines for Effects in general, such Effects should have small magnitude, which will make the problem largely disappear. For instance, if "Target.Industry + 3" and "Target.Industry * 1.05" are used instead, the difference between X * 1.05 + 3 and (X + 3) * 1.05 is a negligible 0.15.

Note that some of the parameters in the Conditions and Effects below ask for a certain type, sometimes a type-expression. Those parameters that do not explicitly allow type-expressions cannot handle them.

Conditions

The syntax {a|b|c} below indicates a choice of values, exactly one of which must be selected. The brackets and vertical lines are not legal to use themselves.

{a|[a b c ...]} indicates that a single item may be specified ( a ), or multiple items in a list ( [a b c ...] ).

"low = ", "high = ", etc., indicates an *optional* parameter name. All parameters must appear in the order indicated, so the names are not necessary to indicate which value is meant for which parameter. The name may be included, however (except for with the And, Not and Or conditions, which do not have or allow such parameter names).

General

All

Matches all objects.


Source

Matches the Source object.


Target

Matches the target object of an effect. This can be used within effect definitions, but not within scope or activation condition definitions, as when those conditions are evaluated, the target object hasn't yet been determined.


Turn low = LOW high = HIGH

Matches objects if the current game turn is greater than or equal to LOW and less than HIGH.


NumberOf number = NUMBER condition = CONDITION

Matches at most NUMBER objects that match CONDITION. If fewer than NUMBER objects match CONDITION, all such objects are matched. If more than NUMBER objects match CONDITION, NUMBER such objects are randomly selected and matched.


Number low = LOW high = HIGH condition = CONDITION

Matches all objects if the number of objects that match CONDITION is greater than or equal to LOW and less than HIGH. Objects matched may or may not themselves match CONDITION.


Random probability = PROB

Matches objects with a probability of PROB. That is, objects have a probability of PROB of being matched.

Type

Building
Ship
Fleet
Planet
PopulationCenter
ProductionCenter
System 

Matches objects with the indicated type.

Building / Special

Building name = {"NAME" | ["NAME0" "NAME1" "NAME2" ...]}

Matches buildings with the indicated name(s). NAME is as indicated in a particular building description, by: name = "NAME" or name = ["NAME0" "NAME1" "NAME2"] (etc.)


HasSpecial name = "NAME"

Matches objects that have the indicated special.

Containing Associations

Contains condition = CONDITION

Matches objects that contain one or more objects that match the indicated CONDITION


ContainedBy condition = CONDITION

Matches objects that are contained by one or more objects that match the indicated CONDITION


Enqueued type = {Building | Ship} name = "NAME" empire = EMPIRE low = LOW high = HIGH
Enqueued type = Ship design = DESIGNID low = LOW
Enqueued type = {Building | Ship} empire = EMPIRE high = HIGH
Enqueued low = LOW

Matches objects where the empire with the indicated id EMPIRE (or any empires if none is specified) have within the indicated range (LOW to HIGH inclusive) of the indicated type of production item with the indicated name or design ID (NAME or DESIGN ID) and TYPE (Building or Ship). The count used to assess LOW and HIGH takes into account the element blocksize.

Planet / Star

Planet type = {TYPE|[TYPE0 TYPE1 TYPE2 ...]}

Matches objects that are or are contained by planets that have the indicated type.

Types are:

Swamp
Toxic
Inferno
Radiated
Barren
Tundra
Desert
Terran
Ocean
Gaia
Asteroids
GasGiant


Planet size = {SIZE|[SIZE0 SIZE1 SIZE2 ...]}

Matches objects that are or are contained by planets that are the indicated size.

Sizes are:

Tiny
Small
Medium
Large
Huge
Asteroids
GasGiant


Planet environment = {ENV|[ENV0 ENV1 ENV2 ...]}

Matches objects that are or are contained by planets that have the indicated environment.

Environments are:

Uninhabitable
Hostile
Poor
Adequate
Good


HomeWorld
    name = {SPECIES|[SPECIES0 SPECIES1 ...]}     [optional -- may be left out]

Matches planets that are homeworlds to playable species. If no species are specified, the homeworld of any species will be matched.

SPECIES the name of a species in the game, as defined in species.txt


Capital

Matches planets that are capitols of an (any) empire. Use in combination with OwnedBy for a specific empire's homeworld.


Star type = {TYPE|[TYPE0 TYPE1 TYPE2 ...]}

Matches objects that are or are contained by systems that have the indicated star type.

Types are:

Blue
White
Yellow
Orange
Red
Neutron
BlackHole

Infrastructure / Focus

Focus focus = {FOCUS|[FOCUS0 FOCUS1 FOCUS2 ...]}

Matches planets that have the indicated focus or any of the indicated foci.

FOCUS or FOCUS# are strings. Each species may have a different set of foci available, but typical focus options include "FOCUS_FARMING", "FOCUS_MINING", "FOCUS_INDUSTRY", "FOCUS_RESEARCH" and "FOCUS_TRADE"

MeterValue

TargetPopulation low = LOW high = HIGH
TargetHealth low = LOW high = HIGH
TargetFarming low = LOW high = HIGH
TargetIndustry low = LOW high = HIGH
TargetResearch low = LOW high = HIGH
TargetTrade low = LOW high = HIGH
TargetMining low = LOW high = HIGH
TargetConstruction low = LOW high = HIGH
MaxFuel low = LOW high = HIGH
MaxShield low = LOW high = HIGH
MaxStructure low = LOW high = HIGH
MaxDefense low = LOW high = HIGH
Population low = LOW high = HIGH
Health low = LOW high = HIGH
Farming low = LOW high = HIGH
Industry low = LOW high = HIGH
Research low = LOW high = HIGH
Trade low = LOW high = HIGH
Mining low = LOW high = HIGH
Construction low = LOW high = HIGH
Fuel low = LOW high = HIGH
Shield low = LOW high = HIGH
Structure low = LOW high = HIGH
Defense low = LOW high = HIGH
FoodConsumption low = LOW high = HIGH
Supply low = LOW high = HIGH
Stealth low = LOW high = HIGH
Detection low = LOW high = HIGH
Battlespeed low = LOW high = HIGH
Starlanespeed low = LOW high = HIGH

Matches objects with the appropriate meter values that are greater than or equal to LOW and less than or equal to HIGH. That is, LOW specifies the lowest allowed value of the meter, and HIGH specifies the highest allowed value. Either of the LOW and HIGH parameters may be omitted, in which case there is no limit on the meter value in that direction. For example, if only LOW is specified, there is no upper limit on the allowed meter value.

Object Owner / Producer

OwnedBy affiliation = {EnemyOf|AllyOf|TheEmpire|AnyEmpire} [empire = EMPIRE]

Matches objects owned by (OwnedBy) an empire with the indicated affiliation to the indicated id EMPIRE. EMPIRE may be omitted with using AnyEmpire, which will match objects owned by any empire, regardless of what EMPIRE is specified (or not). Typically EMPIRE is specified as a function of an object, such as Source.Owner, however a constant integer such as 2 may also be specified.


OwnerFoodStockpile low = LOW high = HIGH
OwnerMineralStockpile low = LOW high = HIGH
OwnerTradeStockpile low = LOW high = HIGH

Matches objects with exactly one owner, whose owner's stockpile of the appropriate resource is greater than or equal to LOW and less than or equal to HIGH.


OwnerHasTech name = "NAME"

Matches objects with exactly one owner, whose owner has the tech NAME.

Note: This is useful for refinements of technologies, where a refinement tech is indicated by NAME in an effects group of the item being refined.


VisibleToEmpire empire = {EMPIRE|[EMPIRE0 EMPIRE1 EMPIRE2 ...]}

Matches objects that are visible to the indicated empire(s).


ProducedByEmpire empire = EMPIRE

Matches buildings or ships produced by the empire with id indicated by EMPIRE. Typically EMPIRE is specified as a function of an object, such as Source.Owner, however a constant integer such as 2 may also be specified. Note that ownership and who produced an object aren't necessary the same, particularly for buildings, which may be captured with planets from other empires.

Ship Design

Design name = "NAME"

Matches ships that have a design generated from the predefined designs in predefined_ship_designs.txt or space_monsters.txt

Design design = DESIGNID

Matches ships that have the specified ship design ID. Most likely this would be Source.DesignID

DesignHasHull name = "NAME"

Matches ships that have the indicated hull in their design.

DesignHasPart low = LOW high = HIGH name = "NAME"

Matches ships that have >= LOW and < HIGH of the part NAME in their design.

DesignHasPartClass low = LOW high = HIGH class = CLASS

Matches ships that have >= LOW and < HIGH of parts of the indicated PartClass in their design.

Armed

Matches ships that have weapons.

Monster

Matches space monsters.

Galaxy Map Position

WithinDistance distance = DISTANCE condition = CONDITION

Matches objects that are within the indicated Euclidean direct-line DISTANCE of any objects that matches CONDITION. The matched objects may or may not themselves match CONDITION.


WithinStarlaneJumps jumps = JUMPS condition = CONDITION

Matches objects that are within the indicated number of starlane jumps (crossings from one star to the next) of any objects that matches CONDITION. The matched objects may or may not themselves match CONDITION.


Stationary

Matches objects that are not moving. The only objects that move are fleets and ships. Objects are not stationary if they are going to move, so fleets ordered to move are not stationary, but fleets that arrive in a system are stationary on the turn after they arrive.

ResupplyableBy empire = EMPIRE

Matched objects should be in systems where the empire with id EMPIRE can provide fleet supply.

ResourceSupplyConnected empire = EMPIRE condition = CONDITION

Matched objects should be in systems connected by resource sharing lines for the empire with id EMPIRE to at least one object that matches the sub-condition CONDITION. Objects outside systems shouldn't be matched, regardless of whether they're on a starlane that is connected to an object that matched the sub-condition.

Logical

Note: There are no optional "param =" indicators for And, Or, & Not.

And [CONDITION0 CONDITION1 CONDITION2 ...]
And [
 CONDITION0
 CONDITION1
 CONDITION2
]

Matches objects that match all of the indicated subconditions.


Or [CONDITION0 CONDITION1 CONDITION2 ...]
Or [
 CONDITION0
 CONDITION1
 CONDITION2
]

Matches objects that match at least one, or more, of the indicated subconditions.


Not CONDITION

Matches objects that do not match CONDITION.

Notes

Implicit ContainedBy

Some Conditions that match an object's containing object will be returned, even though they at first seem to be nonsensical. For instance, if the target object is a Planet, StarType will match the type of the System in which the target is located. This means that StarType will match all objects in all Systems with the given star type, and the Systems themselves. Similarly, all objects on all Planets (and the Planets themselves) that match a PlanetType, PlanetSize, or PlanetEnvironment will be matched. This has an important implication; if you want all Systems with blue stars, you should use

And [
  Star type = Blue
  System
]

If you want all Ships in Systems with blue stars, you should use:

And [ Ship Star type = Blue ]

And & Or Efficiency

The And and Or Conditions are designed to work as efficiently as possible, by only searching the objects that have not already been matched. So it is always best to put the most restrictive Condition first in an And Condition's list of subconditions.

For instance, if "Star type = Blue" matches about 1000 objects,

And [ Source Star type = Blue ]

will be about 1000 times faster than

And [ Star type = Blue Source ]

This is because the former only has to look at the match from Source to see if it also is (or is inside of) a blue-starred System, whereas that latter has to look through the 1000 matches of objects that are or are in blue-starred systems, to see if any of them also matches Source.

Effects

SetMeter

Acting on ships:

SetTargetPopulation value = VALUE
SetTargetHealth value = VALUE
SetTargetFarming value = VALUE
SetTargetIndustry value = VALUE
SetTargetResearch value = VALUE
SetTargetTrade value = VALUE
SetTargetMining value = VALUE
SetTargetConstruction value = VALUE
SetMaxFuel value = VALUE
SetMaxShield value = VALUE
SetMaxStructure value = VALUE
SetMaxDefense value = VALUE
SetPopulation value = VALUE
SetHealth value = VALUE
SetFarming value = VALUE
SetIndustry value = VALUE
SetResearch value = VALUE
SetTrade value = VALUE
SetMining value = VALUE
SetConstruction value = VALUE
SetFuel value = VALUE
SetShield value = VALUE
SetStructure value = VALUE
SetDefense value = VALUE
SetFoodConsumption value = VALUE
SetSupply value = VALUE
SetStealth value = VALUE
SetDetection value = VALUE
SetBattleSpeed value = VALUE
SetStarlaneSpeed value = VALUE

Param Type:

VALUE double

Sets the appropriate meter to VALUE.

  • If the target of the Effect does not have the requested meter, nothing is done.
  • Typically, meter-setting effects do so by adding or subtracting form the same meter value of the Target. For example,
SetTargetResearch Target.TargetResearch + 5

or

SetHealth Value - 10

The value "Value" always refers to the present value of the meter being set, allowing incremental changes to meter values without the cumbersome use of references to the Target such as "Target.FoodConsumption" (for the Target's food consumption meter) which would instead be just "Value" when using the SetFoodConsumption effect.

When a "max" (eg. MaxStructure) or "target" (eg. TargetPopulation) meter value, or another meter for which there is no associated "max" or "target" meter (eg. Stealth), the change is non-presistant. This means that every turn, the meter is reset to 0, and all effects must re-act on the meter for it to retain a consistent value. If on a subsequent turn, the effect does not at on that target, the meter value will return to its previous value (or whatever value all other effects acting on it produce).

When a meter (eg. Structure) has an associated "max" or "target" meter (eg. MaxStructure), the meter value IS persistant. Repeatedly applying the same effect every turn will accumulate. If an effect reduced an object's Health meter by -2 every turn, the 2nd turn would have a net -4 reduction, the 3rd turn would have a net -6 reduction, etc. If an effect alters such a meter once, then does not act again, the meter stays reduced, until other effects increase or decrease it, or it increases or decreases itself over time towards its associated target or max value.


SetEmpireStockpile

SetEmpireFoodStockpile value = VALUE
SetEmpireFoodStockpile empire = EMPIRE value = VALUE
SetEmpireMineralStockpile value = VALUE
SetEmpireMineralStockpile empire = EMPIRE value = VALUE
SetEmpireTradeStockpile value = VALUE
SetEmpireTradeStockpile empire = EMPIRE value = VALUE

Param Type:

VALUE double
EMPIRE int

Sets the empire stockpile of STOCKPILE of the empire with ID EMPIRE, or the target object's owner if no EMPIRE is specified, to VALUE. If the indicated EMPIRE id is invalid, nothing is done.

SetOwnerCapitol

SetOwnerCapitol

Sets the target object to be the capitol of its owner's empire. If the target is not a planet, or is not owned by a single empire, nothing is done.

SetPlanetType

SetPlanetType type = TYPE

Param Type:

TYPE PlanetType

Sets the planet type of the target to TYPE.

  • Has no effect on non-Planet targets.
  • Changing type from Asteroids or GasGiant to something else will also change its size to Tiny or Huge, respectively.
  • Changing type to Asteroids or GasGiant will also cause the size to change to Asteroids or GasGiant, respectively.

SetPlanetSize

SetPlanetSize size = SIZE

Param Type:

SIZE PlanetSize

Sets the planet size of the target to SIZE.

  • Has no effect on non-Planet targets.
  • Changing the size of a Asteroids or GasGiant planet will also change its type to Barren.
  • Changing size to Asteroids or GasGiant will also cause the type to change to Asteroids or GasGiant, respectively.

SetOwner

SetOwner empire = EMPIRE

Param Type:

EMPIRE int

Sets empire EMPIRE_ID as the owner of the target.

  • Has no effect if EMPIRE_ID was already the owner of the target object.

CreatePlanet

CreatePlanet type = TYPE size = SIZE

Param Types:

TYPE PlanetType
SIZE PlanetSize

Creates a new planet at the location of the target object. If the target object is not located in a system, nothing is done. If there are no free orbit slots at the target object's system, nothing is done.

CreateBuilding

CreateBuilding name = NAME

Param Types:

NAME string

Creates a new building at the location indicated by the target object. If the target object is not a planet, nothing is done.

CreateShip

CreateShip
    designname = "NAME"
    empire = EMPIREID
    species = "SPECIES"

ParamTypes

NAME string_constant
EMPIREID int_constant
SPECIES string_constant

Creates a new shipat the location of the target object. The design of the new ship is indicated by the NAME parameter, which looks up the design in premade_ship_designs.txt in the default folder. EMPIREID is the id of the empire who should own the newly created ship, which is probably the id of something related to the source or target objects. SPECIES is the name of the species which should crew the newly created ship, which can be something related to target or source objects, or an explicit species name.

Destroy

Destroy

Destroys the target object.

  • The Destroy effect will not destroy a System object, although any other objects in or outside a system can be destroyed.
  • Destroy effects are executed after all other effects.
  • Destroying a fleet will destroy its ships.
  • Destroying all the ships in a fleet will destroy the fleet.
  • Destroying a planet will destroy its buildings.

AddSpecial

AddSpecial name = "NAME"

Param Type:

NAME string_constant

Adds the Special with the name NAME to the target object.

RemoveSpecial

RemoveSpecial name = "NAME"

Param Type:

NAME string_constant

Removes the Special with the name NAME to the target object.

  • Has no effect if no such Special was already attached to the target object.

SetStarType

SetStarType type = TYPE

Param Type:

TYPE StarType

Sets the star type of the target to TYPE.

  • Has no effect on non-System targets.

MoveTo

MoveTo location = CONDITION

Param Type:

LOCATION Condition

Moves the target object to the location of one of the objects matched by LOCATION

  • If no objects match the location condition, nothing is done.
  • If more than one object matches the location condition, one object is chosen by the condition
  • If the target object is a ship and the location object is a fleet or a ship (in a fleet) owned by the same empire, the ship is inserted into the fleet.
  • If the target object is a ship and the location is not a fleet into which the ship can be inserted, a new fleet is created for the ship a the new location.
  • If the target object is a ship and its location is the same system but not a different fleet, nothing is done and the ship is left in its original fleet.
  • If the target object is a fleet and its location is a fleet or ship outside a system, and a fleet is moved to or created at the target location, the fleet will be moving to the same system as the taget object fleet.
  • If the target object is a building and the location object is a planet or a building on a planet, the building is added to the planet.
  • If the target object is a building and the location is not a planet or on a planet, nothing is done.
  • If the target object is a planet and the location object is not a system or in a system, nothing is done.
  • If the target object is a planet and the location system has no empty orbit slots, nothing is done.
  • If the target object is a system, nothing is done.
  • Any target object moved to the location of a system will be inserted into that system.

Techs

GiveEmpireTech name = "NAME"
GiveEmpireTech name = "NAME" empire = EMPIRE

Param Type:

NAME string_constant
EMPIRE integer ID of empire (such as Target.Owner which is the default if this parameter is omitted).

GiveEmpireTech gives the indicated empire the indicated tech. After this, the result should be the same as if the empire had researched that tech.


SetEmpireTechProgress name = "NAME" progress = PROGRESS
SetEmpireTechProgress name = "NAME" progress = PROGRESS empire = EMPIRE

Param Type:

NAME string_constant
PROGRESS double
EMPIRE integer ID of empire

SetEmpireTechProgress sets the amount of research points (RP) the indicated empire has accumulated towards researching the indicated tech (limited to between 0 and the total RP cost of the tech).

Victory

Victory reason = "REASON"

Param Type

REASON string_constant

Victory causes the owner of the target object to win the game. Losing human players (which is any player who has not won on the turn a player wins) are ejected from the game. The string REASON is d_constantisplayed in a popup to all players, with the name of the winning empire inserted as the %1% parameter to the string.

AddStarlanes and RemoveStarlanes

AddStarlanes endpoint = CONDITION
RemoveStarlanes endpoint = CONDITION

Param Type

CONDITION condition

AddStarlanes adds starlanes between the target system and any system containing an object that matches CONDITION. RemoveStarlanes removes starlanes between the target system and any system containing an object that matches CONDITIONS. Adding a starlanes where one already exists, or removing a starlane wher none exists does nothing.

MoveTo

MoveTo destination = CONDITION

Param Type

CONDITION condition

MoveTo moves the target object to the location of the / one of the objects matched by the CONDITION parameter.

SetDestination

SetDestination destination = CONDITION

Param Type

CONDITION condition

SetDestination sets the travel route of the target fleet to be the shortest path for the target to move to an object that matches the CONDITION parameter. If multiple objects match CONDITION, one is chosen. If the target fleet can't move to the chosen object, nothing is done. The shortest path for the object may depend on the empire that owns it (if any).

SetAggression

SetAggressive
SetPassive

SetAggressive marks a fleet as aggressive, meaning it will block enemy supply, and engage any enemy fleets or planets in its system. SetPassive marks a fleet as passive, meaning it will not block supply or initiate combat. Remaining passive may be useful for staying hidden in a system (if stealthy) or to make non-aggressive monster types not attack player fleets.

SetSpecies

SetSpecies name = "NAME"

Param Type

NAME string_constant

SetSpecies sets the species of the target ship or planet to the indicated species NAME.

Effect Evaluation & Application Ordering

Effects are evaluated and then applied while processing a FreeOrion turn. When this happens, all EffectsGroups' activation and scope conditions are evaluated before any effects are applied. The order of effects application is as follows: effects from Species, then effects from Specials, then effects from Techs, then effects from Buildings, then effects from Ship Hulls, then effects from Ship Parts. The order of execution of Effects within these groups is deterministic, though not controllable. Multiple effects scripted into the same item will be evaluated in the order in which they appear.