package pxd.proto
Get desktop application:
View/edit binary Protocol Buffers messages
message
account.proto:27* General data associated to an account.
optional uint32 kills = 1
* The number of characters killed by the account in total.
optional uint32 fame = 2
* The fame of this account.
optional uint64 balance = 3
* Balance of vCHI for this account.
optional uint64 burnsale_balance = 4
* Balance of vCHI minted through the burnsale, which corresponds to the balance that will be carried over to the full game.
message
ongoing.proto:44* Data representing an "armour repair" operation in progress.
Used in:
(message has no fields)
message
combat.proto:93* An attack that a character or building has. This data is either hardcoded (for buildings) or derived from other stuff (like equipped weapons). But it is stored in the current form in the game state as a sort of "cache" while processing combat in each round. (It only needs to be updated when an explicit action is done by the owner of a character.)
Used in: ,
optional uint32 range = 1
* The range of the attack (as L1 distance on our hex grid). This may be zero in which case it affects only enemies on the same tile. If the value is missing entirely instead, it implies that there will not be a concrete "target", which is the case e.g. for AoE effects around the attacker itself.
optional uint32 area = 2
* The size of the AoE for this attack, around the selected target (if range is present) or the attacker (if range is not present). If this is not present, then it means that only the target itself is affected.
optional damage = 3
* If this attack does damage, the stats for it.
optional effects = 4
* If this attack has non-damage effects, the stats for it.
optional bool gain_hp = 5
* If true, then HP drained through this attack's damage will be given back to the attacker (if any). This works per HP type, i.e. shield HP drained are added to the shield (if not full) and armour HP are added to the armour (if not full).
optional bool friendlies = 6
* If true, then this attack affects friendlies instead of enemies. This is used for positive effects, like improved shield regeneration.
message
combat.proto:116* Data about the damage a particular attack does.
Used in: ,
optional uint32 min = 1
Maximum and minimum damage of the attack. The actual damage will be chosen uniformly from the both-inclusive range.
optional uint32 max = 2
optional uint32 armour_percent = 3
* If this is set, it specifies the factor (as percent) that the attack does damage to armour specifically. If not, 100% (no modification) is assumed.
optional uint32 shield_percent = 4
* The factor (as percent) that this attack does damage to shields.
optional uint32 weapon_size = 5
* "Size" of the attack's weapon for hit/miss chance computation. See target_size on CombatData.
message
ongoing.proto:57* Data about an ongoing blueprint copy operation. While a blueprint is being copied, it is "removed" from the main inventory, and only given back together with the copy when the operation is done.
Used in:
optional string account = 1
* The account doing the copying. Also the owner of the blueprints.
optional string original_type = 2
* The blueprint item type being copied (the original).
optional string copy_type = 3
* The item type of the copy that will be produced.
optional uint32 num_copies = 4
* The number of copies being made.
message
config.proto:69* Specific data for blueprint items defining the modalities for constructing stuff from it.
Used in:
optional string for_item = 1
* The item type constructed from the blueprint.
optional bool original = 2
* Whether or not this is an original. Originals can be copied and can be used an unlimited amount of time, whereas copies (if not originals) cannot be copied themselves and can only be used once to build an item.
message
building.proto:48* The state of one building on the map. (There is additional data stored for it directly in the database, as well as extra data stored in other database tables like inventories or trade orders.)
optional shape_trafo = 1
* The transformation applied to the building's base shape.
optional bool foundation = 2
* True if this is just a foundation for now (and not the full building).
optional construction_inventory = 3
* The inventory with materials for construction of the full building, while this is just a foundation.
optional uint64 ongoing_construction = 4
* If this is a foundation being upgraded to full building right now, then this is the ID of the ongoing operation corresponding to it.
optional combat_data = 5
* Static combat data for this building (besides regeneration). This is mostly based on the building type, but may change if the building is upgraded or the account gains skills.
optional config = 6
* The current configuration for the building.
optional age_data = 7
* Age data for this building.
message
building.proto:106* Data about the building age, i.e. the block heights when it was founded and finished.
Used in:
optional uint32 founded_height = 1
* Block height when it was founded.
optional uint32 finished_height = 2
* Block height when it was finished.
message
building.proto:80* Configuration data for a building, which can be changed by the building's owner at will.
Used in: ,
optional uint32 service_fee_percent = 1
* The service fee that users need to pay to the building owner for using services in the building. This is a percentage of the service's base fee (the burnt amount).
optional int32 dex_fee_bps = 2
* The fee charged by the building owner for trades on the building's DEX. This is in basis points (1/100 of a percent) and paid by the seller from the received Cubits.
message
ongoing.proto:131* An operation for changing the owner-configurable building data. This is delayed to prevent frontrunning. At the end of the ongoing operation, the data will be updated in the building itself.
Used in:
optional new_config = 1
* The new configuration data.
message
ongoing.proto:117* An operation to finish building construction (i.e. upgrade it from a foundation to the full building).
Used in:
(message has no fields)
message
config.proto:284* Hardcoded data defining a type of building.
Used in:
optional uint32 enter_radius = 1
* The enter/exit L1 radius of this building. Characters can enter the building if they are within this L1 radius of the centre coordinate, and when exiting, they will appear on a random spot within that radius.
repeated shape_tiles = 2
* All tiles that make up the building's shape, in the basic, untransformed way. The coordinates are relative to the building's centre.
optional foundation = 3
* Combat data for the foundation of the building alone.
optional full_building = 4
* Combat data for the full building (after construction is done).
optional construction = 5
* The data for constructing this building.
optional offered_services = 6
* Services this building type offers.
message
config.proto:304* Combination of combat and regen data for a building or the foundation.
Used in:
optional combat_data = 1
optional regen_data = 2
message
config.proto:323* Required resources and other data for constructing the building.
Used in:
map<string, uint32> foundation = 1
* Resources (keyed by item type, value is the quantity) required to lay the foundation.
map<string, uint32> full_building = 2
* Resources for upgrading the foundation to the full building.
optional uint32 blocks = 3
* Number of blocks the construction (from foundation to full building) takes for this type.
optional string faction = 4
* The faction of this building type. If this is set, then only players with a matching faction can build it. This is inferred from the building name in roconfig data and only set at runtime.
message
config.proto:358* The set of services offered by a building. Since "false" is the default value for a boolean field, only those services that are offered need to be listed in the actual config data.
Used in:
optional bool refining = 1
optional bool armour_repair = 2
optional bool reverse_engineering = 3
optional bool blueprint_copy = 4
optional bool item_construction = 5
optional bool vehicle_construction = 6
message
config.proto:517* A stage in the burnsale schedule.
Used in:
optional uint64 amount_sold = 1
* Amount of vCHI to be sold in the stage.
optional uint64 price_sat = 2
* Price of one coin in CHI satoshi.
message
character.proto:78* The state of one character in the game. Note that this does not include data fields that are stored directly in database columns, namely those on which the database keeps indices.
optional string vehicle = 1
* The vehicle (as item type) this character is using.
repeated string fitments = 2
* Fitments placed on the vehicle.
optional movement = 3
* Active movement of the character, if any.
optional combat_data = 4
* Static combat data for thie character. That data is derived from other information (e.g. equipped weapons, current vehicle), but it is cached here for easy computation of combat. The data here changes only through explicit actions done by the owner.
optional uint64 ongoing = 5
* If the character is currently busy, then this is the ID of the corresponding ongoing operation.
optional mining = 6
* The character's mining data, if it can mine.
optional uint32 prospecting_blocks = 7
* The character's prospecting rate, if it can prospect. This is the number of blocks it takes them to finish prospection.
optional uint32 speed = 8
* Movement speed of the character.
optional uint64 cargo_space = 9
* Total cargo space the character has.
optional refining = 10
* If this is set, the character can do mobile refining (and the stats for it are given here).
message
combat.proto:241* All data related to combat that a fighter entity (character or building) has. This only includes basic properties of the fighter and not more dynamic data like the current target or the current HP, nor specific data that is frequently accessed like HP regeneration.
Used in: , , ,
repeated attacks = 1
* The offensive attacks the figher has.
repeated low_hp_boosts = 2
* Any low-HP boosts for the fighter.
repeated self_destructs = 3
* Any self-destruct attacks this fighter has.
optional received_damage_modifier = 4
* Reduction applied to any damage received (e.g. from the "armour hardener" upgrade fitment).
optional hit_chance_modifier = 5
* Modification (e.g. boost) to the hit chance of any attacks made by this fighter.
optional uint32 target_size = 6
* "Size" of the fighter as a target, i.e. for hit/miss chance computation. If this is missing or at least as large as the corresponding size of the attack, then the base chance (without any modifiers) is 100%. If the target size is lower, the chance is proportionally lowered.
message
combat.proto:61* Modifications done to a combat entity's stats due to attacks (e.g. slowing or range reduction).
Used in:
optional speed = 1
* Modification to the speed.
optional range = 2
* Modification to the range.
optional hit_chance = 3
* Modification to the hit chance of attacks from this fighter.
optional shield_regen = 4
* Modification to the shield regeneration rate.
optional bool mentecon = 5
* If set, then the affected fighter ignores the friendly/enemy classification and just considers everyone a valid target for both normal and friendly attacks (and similarly affects everyone with AoE attacks of either type).
message
config.proto:625* The hardcoded "configuration data" for Taurion. This includes all data that describes read-only aspects of the game, like known item or vehicle types and stats for them. An instance of this proto is populated from text format encoded in roconfig/<files>.pb.text and made available to all parts of the code.
map<string, > fungible_items = 1
* Known types of fungible items.
map<string, > building_types = 2
* Known types of buildings.
optional resource_dist = 3
* Distribution of resources for prospecting.
repeated initial_buildings = 4
* Initial buildings (ancient buildings and starter zones).
repeated safe_zones = 5
* Safe and starter zones.
optional params = 6
* Basic parameters.
optional testnet_merge = 100
* The testnet-specific configuration data. This is merged into the main configuration when running on testnet or regtest.
optional regtest_merge = 101
* The regtest-specific configuration data. This is merged into the testnet data by the RoConfig-helper class when running on regtest. Safe zones and prizes in there will completely replace the values in the mainnet config, instead of being added to them.
message
config.proto:151* Data specific about items that are fitments.
Used in:
optional string slot = 1
* The type of slot this requires.
optional VehicleSize vehicle_size = 2
* If set, then this fitment can only be placed on a vehicle of the (exact) given size.
optional attack = 3
* An attack this does.
optional cargo_space = 4
* Modification to the cargo space.
optional speed = 5
* Modification to the movement speed.
optional max_armour = 6
* Modification to max armour HP.
optional max_shield = 7
* Modification to max shield HP.
optional shield_regen = 8
* Modification to shield regeneration rate.
optional armour_regen = 9
* Modification to armour regeneration rate.
optional range = 10
* Modification of all attack ranges (and AoE area sizes).
optional damage = 11
* Modification of all attack damages (min and max).
optional received_damage = 12
* Modification to the received damage (e.g. armour hardening).
optional hit_chance = 13
* Modification to the self hit chance.
optional complexity = 14
* Modification to the vehicle's allowed fitment complexity.
optional prospecting_blocks = 15
* Modification to the vehicle's prospecting blocks. Since a larger number of blocks is worse, a fitment will likely have a negative modifier here.
optional mining_rate = 16
* MOdification to the vehicle's mining rate (min and max).
optional low_hp_boost = 17
* Low-HP-boost this fitment provides (if any).
optional self_destruct = 18
* Self-destruct ability of this fitment (if any).
optional refining = 19
* If this is a mobile refinery, the stats for it.
message
combat.proto:199* Small utility message to hold stats about HP (both the permanent armour-based ones and the regenerating shield).
Used in:
optional uint32 armour = 1
* The "permanent" armour-based HP.
optional uint32 shield = 2
* The regenerating, shield-based HP.
optional mhp = 3
* Partially regenerated HP in 1/1000 HP units. When it reaches 1000 for shield or armour, the "actual" HP are incremented accordingly. This field is only present for the current HP of a fighter, not the maximum HP in its RegenData.
message
geometry.proto:28* A coordinate on the hexagonal map. The coordinates are encoded in the "axial" format, as used everywhere in the backend as well.
Used in: , , , ,
optional sint32 x = 1
optional sint32 y = 2
message
config.proto:446* Data for a building that is initially on the map. All of them are ancient and indestructible.
Used in:
optional string type = 1
* Type of the building.
optional centre = 2
* Centre of the building.
optional shape_trafo = 3
* Shape transformation of the building.
message
inventory.proto:29* Data about loot "somewhere". This can be the inventory of a character, it can be the assets of an account in a building, and it can be the loot on the ground at a certain coordinate.
Used in:
map<string, uint64> fungible = 1
* Data about fungible assets held. This is simply a map from item types (which are hardcoded strings) to the amount of each type. The amount is an integer number, representing some smallest fraction of the item.
message
ongoing.proto:87* Data about an ongoing item or vehicle construction. If it is based on an original blueprint, then the blueprint will be taken away temporarily and given back together with the constructed items. Blueprint copies and resources required for the construction are always just removed when the operation starts (and thus not related to the operation state). Construction from an original produces the items "in series", which means that we schedule an update for each single item finished and give them out one after the other while the operation is still going on. If constructing from blueprint copies, all of them are done in parallel, and just one update is done after the construction time and all items are given out at once.
Used in:
optional string account = 1
* The account doing the operation, which will receive items when done.
optional string output_type = 2
* The constructed item.
optional uint32 num_items = 3
* The number of items still to be constructed. If this is done based on an original blueprint, we will update the operation after each produced item, give that item out, decrement the number here, and re-schedule an update.
optional string original_type = 4
* If this construction is based on an original blueprint, then this is the blueprint type used. After it is done (or if the building is destroyed), one item of this type is also given back.
message
config.proto:222* Hardcoded data defining a type of fungible item.
Used in:
optional uint32 space = 1
* The cargo space it uses per unit.
optional uint32 complexity = 2
* For items that have one, the complexity level.
optional bool with_blueprint = 3
* Whether or not this item has an associated blueprint.
map<string, uint32> construction_resources = 4
* The resources required to construct one of this item type, assuming there exists a blueprint for it.
optional string faction = 5
* If this item is a fitment or vehicle and specific to a particular faction, then this field indicates that faction. May be null for faction-neutral items, e.g. most fitments. For fitments, this has to be explicitly set in the roconfig data. For vehicles, it is deduced from the name prefix (e.g. "rv ") via the RoConfig logic.
oneof type
refines = 101
* If this type of item can be refined, then the stats for doing so.
is_blueprint = 102
* If this is a blueprint, the associated data.
prize = 103
* If this is a prize, the associated data.
reveng = 104
* If this can be reverse engineered (i.e. is an artefact), the configuration data specifying the corresponding stats.
vehicle = 105
* If this is a vehicle item, the specific stats for that.
fitment = 106
* If this is a fitment, the specific stats for that.
message
combat.proto:181* Stats for a boost to combat stats that is in effect when a character has low armour HP (i.e. "final breath" attack).
Used in: ,
optional uint32 max_hp_percent = 1
* The percentage of armour HP at which it activates.
optional damage = 2
* Boost to damage.
optional range = 3
* Boost to range.
message
character.proto:31* Data about the mining state of a character.
Used in:
optional rate = 1
* The mining speed parameters.
optional bool active = 2
* Set to true if the character is currently mining.
message
character.proto:38* Stats about the speed for mining (which is random based on a distribution from these parameters).
Used in: ,
optional uint64 min = 1
* The minimum units per block.
optional uint64 max = 2
* The maximum units per block.
message
character.proto:60* Data about mobile refining capabilities of a character.
Used in: ,
optional input = 1
* The "inefficiency factor" of mobile refining. Refining in a mobile refinery costs the same vCHI fee and produces the same outputs as a normal refining step, but uses up more input ore per step. This is specified by the modifier here.
message
movement.proto:31* An "active" movement of a character. Movement is specified by a list of waypoints, which will be visited in order and have to be apart only by principal directions.
Used in:
repeated waypoints = 1
* The waypoints that will still be visited. While they are traversed, already visited points are removed from this list. In other words, the first element will always be the current target of the character. When this list becomes empty, then it stops moving.
optional uint32 chosen_speed = 2
* If set, then the character chooses to travel at the minimum of this value and its actual speed. This can be used to reduce travel speed for faster vehicles to stay around slower ones in a convoy.
message
ongoing.proto:142* Data about an ongoing operation.
optional uint32 start_height = 1
* The block height when the operation started. This is useful for the frontend to show (e.g. calculate progress).
oneof op
* The ongoing operation itself, which can be one of several types.
prospection = 101
armour_repair = 102
blueprint_copy = 103
item_construction = 104
building_construction = 105
building_update = 106
message
ongoing.proto:29* Data representing an on-going prospection by a character.
Used in:
(message has no fields)
message
config.proto:531* Basic parameters of the game.
Used in:
optional int64 character_cost = 1
* The amount of CHI to be paid for a character.
optional uint32 character_limit = 2
* The maximum number of characters per account.
optional uint32 blocked_step_retries = 3
* Number of retries of a blocked movement step before the movement is cancelled completely. Note that this is really the number of *retries*, meaning that movement is only cancelled after N+1 blocked turns if N is the value here.
optional uint32 damage_list_blocks = 4
* The number of blocks for which a character stays on a damage list.
optional uint32 prospection_expiry_blocks = 5
* The number of blocks after which a region can be reprospected (if there are no other factors preventing it).
optional uint32 armour_repair_hp_per_block = 6
* The number of HP that can be repaired per block.
optional uint32 armour_repair_cost_millis = 7
* Cost (in 1/1000 vCHI) for repairing one HP of armour.
optional int64 bp_copy_cost = 8
* Cost (in vCHI) for copying a blueprint, per complexity.
optional uint32 bp_copy_blocks = 9
* Number of blocks for copying a blueprint, per complexity.
optional int64 construction_cost = 10
* Cost (in vCHI) for constructing an item, per complexity.
optional uint32 construction_blocks = 11
* Nubmer of blocks for constructing an item, per complexity.
optional uint32 building_update_delay = 12
* Delay (in blocks) until an owner-initiated update to the building configuration takes effect.
optional uint32 dex_fee_bps = 13
* Base fee (which is burnt) paid by sellers on the DEX in basis points.
optional int64 min_region_ore = 14
* Minimum units of ore found in a prospected region.
optional int64 max_region_ore = 15
* Maximum units of ore found in a prospected region.
optional string dev_addr = 16
* The address to which developer payments should be sent.
optional string burn_addr = 17
* The address to which burn payments should be sent.
optional bool god_mode = 18
* Whether or not god mode is enabled.
map<string, > spawn_areas = 19
* Spawn areas for the factions (with the "r", "g", "b" string as key).
repeated burnsale_stages = 20
* Data about the burnsale schedule.
repeated prizes = 21
* Prospecting prizes. They are just a list and not a map, because the order matters (it is the order in which winning is checked). This field has a special rule when merging in the regtest configuration: It is replaced rather than concatenated (which would be the default behaviour for proto merge).
message
config.proto:88* Specific data for prize items.
There is no specific data we need to define for prize items, this is just a placeholder to mark them as prizes.
Used in:
(message has no fields)
message
config.proto:497* Definition of the configuration for one prospecting prize.
Used in:
optional string name = 1
* Name for the prize (used in the game state and also for constructing the item name by appending " prize").
optional uint32 number = 2
* Number of prizes of this type available.
optional uint32 probability = 3
* Probability to win this prize as 1 / N.
message
region.proto:27* Data about the prospecting outcome of a region.
Used in:
optional string name = 1
* The Xaya name of the user who prospected the region. This has no impact on the game play, but can be useful for display purposes.
optional uint32 height = 2
* The block height at which the region was prospected.
optional string resource = 3
* The type of resources that can be mined on the current region. The amount left is stored directly in a DB column (because it may be updated frequently while the region is being mined). Every prospected region has some type of resource assigned, although there may be very little of it minable (or all might already have been taken).
message
config.proto:48* Data about the ability to refine items of this type to other item types (i.e. raw materials into refined resources).
Used in:
optional uint32 input_units = 1
* Number of instances going into one "refining unit".
optional uint32 cost = 2
* Base cost (burnt) in vCHI for one refinement step.
map<string, uint32> outputs = 3
* The outputs (as item type, amount) for one refining step (i.e. "input_units" input units).
message
combat.proto:224* Data relevant for HP regeneration. This is split out from the main combat data, because it needs to be accessed for every fighter all the time to figure out if they need regeneration.
Used in: ,
optional max_hp = 1
* Maximum HP of the fighter.
optional regeneration_mhp = 2
* Regeneration rate of HPs in "milli HP per block".
message
region.proto:55* All data stored about a particular region on the map.
optional uint64 prospecting_character = 1
* The character ID who is currently prospecting here (if any).
optional prospection = 2
* If already prospected, the outcome.
message
config.proto:388* Data for the resource distribution on the map (when prospecting). This is based on multiple "areas" where one or two resources occur. Each area has a central x/y coordinate. Then within a core L1 radius around this area, those resources appear with "full chance". Towards an outer radius, the chance falls off to zero linearly. If multiple areas overlap (or there are two resources in one), then we pick between them based on their chances as weights. The radii themselves are just constants in the source code. The proto data in this message holds the more complex things, like the list of areas and also how the ores correspond to artefacts.
Used in:
repeated areas = 1
* Resource areas.
map<string, > possible_artefacts = 2
* The artefacts that can be found with each ore type.
message
config.proto:394* One area where resources can be found.
Used in:
optional centre = 1
* The centre coordinate of the area.
repeated string resources = 2
* The type(s) of resources to be found here.
message
config.proto:412* Data specifying the artefacts found together with a particular ore in a region.
Used in:
repeated entries = 1
* Entries for all the artefacts that can be found with a given ore in a region. They are checked in order until the end or the first artefact is discovered.
message
config.proto:418* Entry for one artefact with its chance of finding it.
Used in:
optional string artefact = 1
* The artefact's item name.
optional uint32 probability = 2
* The chance as 1 / N.
message
config.proto:97* Data about the ability to reverse-engineer an item to obtain blueprints.
Used in:
optional uint32 cost = 1
* Cost (in vCHI) for a reveng attempt.
repeated string possible_outputs = 2
* Types of items (most likely blueprint originals) that can be obtained from this through reverse engineering.
message
config.proto:464* Data for a safe zone. They represent both the general no-combat zones as well as the faction-specific starter areas.
Used in:
optional centre = 1
* Centre of the zone.
optional uint32 radius = 2
* L1 radius of the zone.
optional string faction = 3
* If this is a faction starter zone, the faction as string ("r", "g" or "b"). If this is a general no-combat zone, then the field is unset.
message
combat.proto:166* Stats for the self-destruct ability of an entity (when the entity is destroyed, AoE damage is dealt to enemies in range).
Used in: ,
optional uint32 area = 1
* The AoE range of the attack.
optional damage = 2
* The damage done.
message
building.proto:32* A geometrical transformation applied to the building's shape (e.g. for rotating it on the map). This does not include the shift of all tiles to the building's centre.
Used in: ,
optional uint32 rotation_steps = 1
* Number of clock-wise rotation steps about 60 degrees the base shape is rotated around the building centre. This can go from 0 to 5.
message
config.proto:486* Definition of a spawn location.
Used in:
optional uint64 building_id = 1
* The building ID into which new characters are spawned.
message
modifier.proto:28* General modification something can give to an existing numerical value, e.g. an increase to a vehicle speed or combat damage.
Used in: , , , ,
optional sint32 percent = 1
* Relative change to the base value, in percent. This is added (or subtracted if negative), so not a multiplicative factor.
optional sint32 absolute = 2
* Absolute change to the base value.
message
combat.proto:30* Identifier for a target of attacks. This can be either a character (in a vehicle on the map) or a building.
optional TargetId.Type type = 1
* The type of this target.
optional uint64 id = 2
* The database ID of this target entity (based on its type). Absence of this field means that the target is "empty" / null / there is no target.
* Different types of target. The type determines where the data is stored in the database and how it is accessed.
Used in:
INVALID_TYPE = 0
TYPE_BUILDING = 1
The numeric values below are used to sort TargetKey instances, which are expected to match the sorting order used in some DB queries.
TYPE_CHARACTER = 2
message
config.proto:114* Data specific about items that are vehicles.
Used in:
optional uint32 cargo_space = 1
* Base cargo space of this vehicle.
optional uint32 speed = 2
* Base movement speed (in milli-tiles per block).
optional regen_data = 3
* Basic regeneration data and max HP.
optional combat_data = 4
* Basic combat data (including attacks mostly).
optional mining_rate = 5
* Base mining speed for the vehicle.
optional uint32 prospecting_blocks = 6
* Base prospecting rate (if prospecting is possible).
optional VehicleSize size = 7
* Size of the vehicle for fitment purposes.
map<string, uint32> equipment_slots = 8
* Number of equipment slots of each type. The slot types are just strings which have to be matched between here and the fitment configs. The valid values are "high", "mid" and "low". Unfortunately we cannot use enum values as they can't be keys in protocol buffer maps.
* Size of a vehicle.
Used in: ,
STARTER = 1
LIGHT = 2
MEDIUM = 3
HEAVY = 4
VERY_HEAVY = 5
message
movement.proto:57* Additional data for movement, which is stored separately in the database and not as part of the broader "character proto". This is the data that is expected to change frequently, e.g. potentially on every turn without explicit moves being sent by the player.
optional uint32 partial_step = 1
* Partial progress towards the next tile.
optional uint32 blocked_turns = 2
* Number of turns for which the character has been blocked by an obstacle in its (already computed) path. This is used to stop movement after a certain number of tries, rather than trying forever.