Powered by

# Solidity API

# BareComponent

Components are a key-value store from entity id to component value. They are registered in the World and register updates to their state in the World. They have an owner, who can grant write access to more addresses. (Systems that want to write to a component need to be given write access first.) Everyone has read access.

# BareComponent__NotImplemented 

error BareComponent__NotImplemented()

# world 

address world

Reference to the World contract this component is registered in

# entityToValue 

mapping(uint256 => bytes) entityToValue

Mapping from entity id to value in this component

# id 

uint256 id

Public identifier of this component

# constructor 

constructor(address _world, uint256 _id) internal

# registerWorld 

function registerWorld(address _world) public

Register this component in the given world.

Name Type Description
_world address Address of the World contract.

# set 

function set(uint256 entity, bytes value) public

Set the given component value for the given entity. Registers the update in the World contract. Can only be called by addresses with write access to this component.

Name Type Description
entity uint256 Entity to set the value for.
value bytes Value to set for the given entity.

# remove 

function remove(uint256 entity) public

Remove the given entity from this component. Registers the update in the World contract. Can only be called by addresses with write access to this component.

Name Type Description
entity uint256 Entity to remove from this component.

# has 

function has(uint256 entity) public view virtual returns (bool)

Check whether the given entity has a value in this component.

Name Type Description
entity uint256 Entity to check whether it has a value in this component for.

# getRawValue 

function getRawValue(uint256 entity) public view virtual returns (bytes)

Get the raw (abi-encoded) value of the given entity in this component.

Name Type Description
entity uint256 Entity to get the raw value in this component for.

# getEntities 

function getEntities() public view virtual returns (uint256[])

Not implemented in BareComponent

# getEntitiesWithValue 

function getEntitiesWithValue(bytes) public view virtual returns (uint256[])

Not implemented in BareComponent

# registerIndexer 

function registerIndexer(address) external virtual

Not implemented in BareComponent

# _set 

function _set(uint256 entity, bytes value) internal virtual

Set the given component value for the given entity. Registers the update in the World contract. Can only be called internally (by the component or contracts deriving from it), without requiring explicit write access.

Name Type Description
entity uint256 Entity to set the value for.
value bytes Value to set for the given entity.

# _remove 

function _remove(uint256 entity) internal virtual

Remove the given entity from this component. Registers the update in the World contract. Can only be called internally (by the component or contracts deriving from it), without requiring explicit write access.

Name Type Description
entity uint256 Entity to remove from this component.

# Component

Components are a key-value store from entity id to component value. They are registered in the World and register updates to their state in the World. They have an owner, who can grant write access to more addresses. (Systems that want to write to a component need to be given write access first.) Everyone has read access.

# entities 

contract Set entities

Set of entities with values in this component

# valueToEntities 

contract MapSet valueToEntities

Reverse mapping from value to set of entities

# indexers 

contract IEntityIndexer[] indexers

List of indexers to be updated when a component value changes

# constructor 

constructor(address _world, uint256 _id) internal

# has 

function has(uint256 entity) public view virtual returns (bool)

Check whether the given entity has a value in this component.

Name Type Description
entity uint256 Entity to check whether it has a value in this component for.

# getEntities 

function getEntities() public view virtual returns (uint256[])

Get a list of all entities that have a value in this component.

# getEntitiesWithValue 

function getEntitiesWithValue(bytes value) public view virtual returns (uint256[])

Get a list of all entities that have the specified value in this component.

Name Type Description
value bytes Abi-encoded value to get the list of entities with this value for.

# registerIndexer 

function registerIndexer(address indexer) external virtual

Register a new indexer that gets notified when a component value is set.

Name Type Description
indexer address Address of the indexer to notify when a component value is set.

# _set 

function _set(uint256 entity, bytes value) internal virtual

Set the given component value for the given entity. Registers the update in the World contract. Can only be called internally (by the component or contracts deriving from it), without requiring explicit write access.

Name Type Description
entity uint256 Entity to set the value for.
value bytes Value to set for the given entity.

# _remove 

function _remove(uint256 entity) internal virtual

Remove the given entity from this component. Registers the update in the World contract. Can only be called internally (by the component or contracts deriving from it), without requiring explicit write access.

Name Type Description
entity uint256 Entity to remove from this component.

# Indexer

# entities 

contract Set entities

# valueToEntities 

mapping(bytes => address) valueToEntities

# entityToValue 

mapping(uint256 => bytes) entityToValue

# components 

contract Component[] components

# trackValueForComponent 

bool[] trackValueForComponent

# constructor 

constructor(contract Component[] _components, bool[] _trackValueForComponent) public

# update 

function update(uint256 entity, bytes value) external

# remove 

function remove(uint256 entity) external

# supportsInterface 

function supportsInterface(bytes4 interfaceId) external view returns (bool)

query whether contract has registered support for given interface

Name Type Description
interfaceId bytes4 interface id
Name Type Description
[0] bool bool whether interface is supported

# getEntities 

function getEntities() external view returns (uint256[])

# getEntitiesWithValue 

function getEntitiesWithValue(bytes value) external view returns (uint256[])

# has 

function has(uint256 entity) public view returns (bool)

# _set 

function _set(uint256 entity, bytes[] newValues) internal

# Uint256Node 

struct Uint256Node {
  uint256 value;
  uint256 next;
}

# freeFunction 

freeFunction pointer(struct Uint256Node a) internal pure returns (bytes32 ptr)

# freeFunction 

freeFunction fromPointer(bytes32 ptr) internal pure returns (struct Uint256Node a)

# freeFunction 

freeFunction isPositiveFragment(struct QueryFragment fragment) internal pure returns (bool)

# freeFunction 

freeFunction isNegativeFragment(struct QueryFragment fragment) internal pure returns (bool)

# freeFunction 

freeFunction isSettingFragment(struct QueryFragment fragment) internal pure returns (bool)

# freeFunction 

freeFunction isEntityFragment(struct QueryFragment fragment) internal pure returns (bool)

# freeFunction 

freeFunction passesQueryFragment(uint256 entity, struct QueryFragment fragment) internal view returns (bool)

# freeFunction 

freeFunction passesQueryFragmentProxy(uint256 entity, struct QueryFragment fragment, struct QueryFragment proxyRead) internal view returns (bool passes, bool proxyFound)

# freeFunction 

freeFunction isBreakingPassState(bool passes, struct QueryFragment fragment) internal pure returns (bool)

For positive fragments (Has/HasValue) we need to find any passing entity up the proxy chain so as soon as passes is true, we can early return. For negative fragments (Not/NotValue) every entity up the proxy chain must pass, so we can early return if we find one that doesn't pass.

# QueryVars 

struct QueryVars {
  LinkedList entities;
  uint256 numEntities;
  struct QueryFragment proxyRead;
  struct QueryFragment proxyExpand;
  bool initialFragment;
}

# LibQuery

# query 

function query(struct QueryFragment[] fragments) internal view returns (uint256[])

Execute the given query and return a list of entity ids

Name Type Description
fragments struct QueryFragment[] List of query fragments to execute
Name Type Description
[0] uint256[] entities List of entities matching the query

# _processProxyRead 

function _processProxyRead(struct QueryVars v, struct QueryFragment fragment, uint256 entity, bool passes) internal view returns (bool)

# _processProxyExpand 

function _processProxyExpand(struct QueryVars v, struct QueryFragment fragment, uint256 entity, LinkedList nextEntities, uint256 nextNumEntities) internal view returns (LinkedList, uint256)

# getChildEntities 

function getChildEntities(uint256 entity, contract IComponent component, uint256 depth) internal view returns (uint256[])

Recursively computes all direct and indirect child entities up to the specified depth

Name Type Description
entity uint256 Entity to get all child entities up to the specified depth
component contract IComponent Entity reference component
depth uint256 Depth up to which the recursion should be applied
Name Type Description
[0] uint256[] Set of entities that are child entities of the given entity via the given component

# getValueWithProxy 

function getValueWithProxy(contract IComponent component, uint256 entity, contract IComponent proxyComponent, uint256 depth) internal view returns (bytes value, bool found)

# listToArray 

function listToArray(LinkedList list, uint256 length) public pure returns (uint256[] array)

Helper function to turn a linked list into an array

# arrayToList 

function arrayToList(uint256[] array) public pure returns (LinkedList list)

Helper function to turn an array into a linked list

# LibTypes

Enum of supported schema types

# SchemaValue 

enum SchemaValue {
  BOOL,
  INT8,
  INT16,
  INT32,
  INT64,
  INT128,
  INT256,
  INT,
  UINT8,
  UINT16,
  UINT32,
  UINT64,
  UINT128,
  UINT256,
  BYTES,
  STRING,
  ADDRESS,
  BYTES4,
  BOOL_ARRAY,
  INT8_ARRAY,
  INT16_ARRAY,
  INT32_ARRAY,
  INT64_ARRAY,
  INT128_ARRAY,
  INT256_ARRAY,
  INT_ARRAY,
  UINT8_ARRAY,
  UINT16_ARRAY,
  UINT32_ARRAY,
  UINT64_ARRAY,
  UINT128_ARRAY,
  UINT256_ARRAY,
  BYTES_ARRAY,
  STRING_ARRAY
}

# MapSet

Key value store with uint256 key and uint256 Set value

# items 

mapping(uint256 => uint256[]) items

# itemToIndex 

mapping(uint256 => mapping(uint256 => uint256)) itemToIndex

# add 

function add(uint256 setKey, uint256 item) public

# remove 

function remove(uint256 setKey, uint256 item) public

# has 

function has(uint256 setKey, uint256 item) public view returns (bool)

# getItems 

function getItems(uint256 setKey) public view returns (uint256[])

# size 

function size(uint256 setKey) public view returns (uint256)

# Ownable

IERC173 implementation

# constructor 

constructor() public

# OwnableWritable

Ownable with authorized writers

# OwnableWritable__NotWriter 

error OwnableWritable__NotWriter()

# writeAccess 

function writeAccess(address operator) public view virtual returns (bool)

Whether given operator has write access

# onlyWriter 

modifier onlyWriter()

Revert if caller does not have write access to this component

# authorizeWriter 

function authorizeWriter(address writer) public virtual

Grant write access to the given address. Can only be called by the owner.

Name Type Description
writer address Address to grant write access to.

# unauthorizeWriter 

function unauthorizeWriter(address writer) public virtual

Revoke write access from the given address. Can only be called by the owner.

Name Type Description
writer address Address to revoke write access.

# OwnableWritableStorage

# Layout 

struct Layout {
  mapping(address => bool) writeAccess;
}

# STORAGE_SLOT 

bytes32 STORAGE_SLOT

# layout 

function layout() internal pure returns (struct OwnableWritableStorage.Layout l)

# PayableSystem

System base contract

# components 

contract IUint256Component components

# world 

contract IWorld world

# constructor 

constructor(contract IWorld _world, address _components) internal

# Set

Set of unique uint256

# items 

uint256[] items

# itemToIndex 

mapping(uint256 => uint256) itemToIndex

# add 

function add(uint256 item) public

# remove 

function remove(uint256 item) public

# getIndex 

function getIndex(uint256 item) public view returns (bool, uint256)

# has 

function has(uint256 item) public view returns (bool)

# getItems 

function getItems() public view returns (uint256[])

# size 

function size() public view returns (uint256)

# System

System base contract

# components 

contract IUint256Component components

# world 

contract IWorld world

# constructor 

constructor(contract IWorld _world, address _components) internal

# SystemStorage

Systems contain the address of the components registry and world contract as state variables. SystemStorage ensures that these addresses are stored at deterministic locations in a System contract's storage. Developers can read/write components and access world utilities from any library called by a System. Warning: Library must be initialized (init) by a contract that can access components + world contracts before use. The intialization is done automatically for any contract inheriting System or MudTest.

# Layout 

struct Layout {
  contract IUint256Component components;
  contract IWorld world;
}

# STORAGE_SLOT 

bytes32 STORAGE_SLOT

Location in memory where the Layout struct will be stored

# layout 

function layout() internal pure returns (struct SystemStorage.Layout l)

Utility for accessing the STORAGE_SLOT location in the contract's storage

Name Type Description
l struct SystemStorage.Layout Layout struct at storage position l

# init 

function init(contract IWorld _world, contract IUint256Component _components) internal

Register this component in the given world.

This function must be called at the start of any contract that expects libraries to access SystemStorage!

Name Type Description
_world contract IWorld Address of the World contract.
_components contract IUint256Component Address of the Components registry contract.

# components 

function components() public view returns (contract IUint256Component)
Name Type Description
[0] contract IUint256Component Component registry contract

# world 

function world() public view returns (contract IWorld)
Name Type Description
[0] contract IWorld World contract

# system 

function system(uint256 systemID) internal view returns (address)
Name Type Description
systemID uint256 ID for a system
Name Type Description
[0] address address of the System contract from the components registry

# component 

function component(uint256 componentID) internal view returns (address)
Name Type Description
componentID uint256 ID for a component
Name Type Description
[0] address address of the Component contract from the components registry

# World

The World contract is at the core of every on-chain world. Entities, components and systems are registered in the World. Components register updates to their state via the registerComponentValueSet and registerComponentValueRemoved methods, which emit the ComponentValueSet and ComponentValueRemoved events respectively.

Clients can reconstruct the entire state (of all components) by listening to these two events, instead of having to add a separate getter or event listener for every type of data. (Have a look at the MUD network package for a TypeScript implementation of contract/client state sync.)

The World is an ownerless and permissionless contract. Anyone can register new components and systems in the world (via the registerComponent and registerSystem methods). Clients decide which components and systems they care about.

# entities 

contract Set entities

# _components 

contract Uint256Component _components

# _systems 

contract Uint256Component _systems

# register 

contract RegisterSystem register

# ComponentValueSet 

event ComponentValueSet(uint256 componentId, address component, uint256 entity, bytes data)

# ComponentValueRemoved 

event ComponentValueRemoved(uint256 componentId, address component, uint256 entity)

# constructor 

constructor() public

# init 

function init() public

Initialize the World. Separated from the constructor to prevent circular dependencies.

# components 

function components() public view returns (contract IUint256Component)

Get the component registry Uint256Component (mapping from component address to component id)

# systems 

function systems() public view returns (contract IUint256Component)

Get the system registry Uint256Component (mapping from system address to system id)

# registerComponent 

function registerComponent(address componentAddr, uint256 id) public

Register a new component in this World. ID must be unique.

# registerSystem 

function registerSystem(address systemAddr, uint256 id) public

Register a new system in this World. ID must be unique.

# requireComponentRegistered 

modifier requireComponentRegistered(address component)

Reverts if the component is not registered in this World.

# registerComponentValueSet 

function registerComponentValueSet(address component, uint256 entity, bytes data) public

Deprecated - use registerComponentValueSet(entity, data) instead Register a component value update. Emits the ComponentValueSet event for clients to reconstruct the state.

# registerComponentValueSet 

function registerComponentValueSet(uint256 entity, bytes data) public

Register a component value update. Emits the ComponentValueSet event for clients to reconstruct the state.

# registerComponentValueRemoved 

function registerComponentValueRemoved(address component, uint256 entity) public

Deprecated - use registerComponentValueRemoved(entity) instead Register a component value removal. Emits the ComponentValueRemoved event for clients to reconstruct the state.

# registerComponentValueRemoved 

function registerComponentValueRemoved(uint256 entity) public

Register a component value removal. Emits the ComponentValueRemoved event for clients to reconstruct the state.

# getComponent 

function getComponent(uint256 id) external view returns (address)

Deprecated, but left here for backward compatibility. TODO: refactor all consumers.

# getComponentIdFromAddress 

function getComponentIdFromAddress(address componentAddr) external view returns (uint256)

Deprecated, but left here for backward compatibility. TODO: refactor all consumers.

# getSystemAddress 

function getSystemAddress(uint256 systemId) external view returns (address)

Deprecated, but left here for backward compatibility. TODO: refactor all consumers.

# getNumEntities 

function getNumEntities() public view returns (uint256)

# query 

function query(struct WorldQueryFragment[] worldQueryFragments) public view returns (uint256[])

Helper function to execute a query with query fragments referring to a component ID instead of a component address.

# hasEntity 

function hasEntity(uint256 entity) public view returns (bool)

Check whether an entity exists in this world.

# getUniqueEntityId 

function getUniqueEntityId() public view returns (uint256)

Get a new unique entity ID.

# Uint256Component

Reference implementation of a component storing a uint256 value for each entity.

# constructor 

constructor(address world, uint256 id) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, uint256 value) public virtual

# getValue 

function getValue(uint256 entity) public view virtual returns (uint256)

# getEntitiesWithValue 

function getEntitiesWithValue(uint256 value) public view virtual returns (uint256[])

# componentsComponentId 

uint256 componentsComponentId

# systemsComponentId 

uint256 systemsComponentId

# IComponent

# getSchema 

function getSchema() external pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, bytes value) external

# remove 

function remove(uint256 entity) external

# has 

function has(uint256 entity) external view returns (bool)

# getRawValue 

function getRawValue(uint256 entity) external view returns (bytes)

# getEntities 

function getEntities() external view returns (uint256[])

# getEntitiesWithValue 

function getEntitiesWithValue(bytes value) external view returns (uint256[])

# registerIndexer 

function registerIndexer(address indexer) external

# world 

function world() external view returns (address)

# IEntityContainer

# has 

function has(uint256 entity) external view returns (bool)

# getEntities 

function getEntities() external view returns (uint256[])

# getEntitiesWithValue 

function getEntitiesWithValue(bytes value) external view returns (uint256[])

# IEntityIndexer

# update 

function update(uint256 entity, bytes value) external

# remove 

function remove(uint256 entity) external

# IOwnableWritable

# authorizeWriter 

function authorizeWriter(address writer) external

# unauthorizeWriter 

function unauthorizeWriter(address writer) external

# IPayableSystem

# execute 

function execute(bytes args) external payable returns (bytes)

# ISystem

# execute 

function execute(bytes args) external returns (bytes)

# IUint256Component

# set 

function set(uint256 entity, uint256 value) external

# getValue 

function getValue(uint256 entity) external view returns (uint256)

# getEntitiesWithValue 

function getEntitiesWithValue(uint256 value) external view returns (uint256[])

# WorldQueryFragment 

struct WorldQueryFragment {
  enum QueryType queryType;
  uint256 componentId;
  bytes value;
}

# IWorld

# components 

function components() external view returns (contract IUint256Component)

# systems 

function systems() external view returns (contract IUint256Component)

# registerComponent 

function registerComponent(address componentAddr, uint256 id) external

# getComponent 

function getComponent(uint256 id) external view returns (address)

# getComponentIdFromAddress 

function getComponentIdFromAddress(address componentAddr) external view returns (uint256)

# registerSystem 

function registerSystem(address systemAddr, uint256 id) external

# registerComponentValueSet 

function registerComponentValueSet(address component, uint256 entity, bytes data) external

# registerComponentValueSet 

function registerComponentValueSet(uint256 entity, bytes data) external

# registerComponentValueRemoved 

function registerComponentValueRemoved(address component, uint256 entity) external

# registerComponentValueRemoved 

function registerComponentValueRemoved(uint256 entity) external

# getNumEntities 

function getNumEntities() external view returns (uint256)

# hasEntity 

function hasEntity(uint256 entity) external view returns (bool)

# getUniqueEntityId 

function getUniqueEntityId() external view returns (uint256)

# query 

function query(struct WorldQueryFragment[] worldQueryFragments) external view returns (uint256[])

# init 

function init() external

# QueryType 

enum QueryType {
  Has,
  Not,
  HasValue,
  NotValue,
  ProxyRead,
  ProxyExpand
}

# QueryFragment 

struct QueryFragment {
  enum QueryType queryType;
  contract IComponent component;
  bytes value;
}

# RegisterType 

enum RegisterType {
  Component,
  System
}

# ID 

uint256 ID

# RegisterSystem

# constructor 

constructor(contract IWorld _world, address _components) public

# requirement 

function requirement(bytes args) public view returns (bytes)

# execute 

function execute(address msgSender, enum RegisterType registerType, address addr, uint256 id) public returns (bytes)

# execute 

function execute(bytes args) public returns (bytes)

# ComponentTest

# vm 

contract Vm vm

# users 

address payable[] users

# component 

contract TestComponent component

# setUp 

function setUp() public

# testSetAndGetValue 

function testSetAndGetValue() public

# testRemove 

function testRemove() public

# testGetEntities 

function testGetEntities() public

# testGetEntitiesWithValue 

function testGetEntitiesWithValue() public

# IndexerTest

# vm 

contract Vm vm

# position 

contract PositionComponent position

# damage 

contract DamageComponent damage

# regionCreatures 

contract Indexer regionCreatures

# setUp 

function setUp() public

# testSetAndGetEntitiesWithValue 

function testSetAndGetEntitiesWithValue() public

# testUpdate 

function testUpdate() public

# testRemove 

function testRemove() public

# testGetEntities 

function testGetEntities() public

# LibQueryTest

# vm 

contract Vm vm

# users 

address payable[] users

# component1 

contract TestComponent1 component1

# component2 

contract TestComponent2 component2

# component3 

contract TestComponent3 component3

# prototypeTag 

contract PrototypeTagComponent prototypeTag

# fromPrototype 

contract FromPrototypeComponent fromPrototype

# ownedByEntity 

contract OwnedByEntityComponent ownedByEntity

# setUp 

function setUp() public

# testHasQuery 

function testHasQuery() public

# testHasValueQuery 

function testHasValueQuery() public

# testCombinedHasQuery 

function testCombinedHasQuery() public

# testCombinedHasValueQuery 

function testCombinedHasValueQuery() public

# testCombinedHasHasValueQuery 

function testCombinedHasHasValueQuery() public

# testCombinedHasNotQuery 

function testCombinedHasNotQuery() public

# testCombinedHasValueNotQuery 

function testCombinedHasValueNotQuery() public

# testCombinedHasHasValueNotQuery 

function testCombinedHasHasValueNotQuery() public

# testNotValueQuery 

function testNotValueQuery() public

# testInitialProxyExpand 

function testInitialProxyExpand() public

# testDeepProxyExpand 

function testDeepProxyExpand() public

# testProxyRead 

function testProxyRead() public

# testDeepProxyRead 

function testDeepProxyRead() public

# testGetValueWithProxy 

function testGetValueWithProxy() public

# SetTest

# vm 

contract Vm vm

# users 

address payable[] users

# set 

contract Set set

# setUp 

function setUp() public

# testAdd 

function testAdd() public

# testAddDuplicate 

function testAddDuplicate() public

# testRemove 

function testRemove() public

# testGetItems 

function testGetItems() public

# testSize 

function testSize() public

# testHas 

function testHas() public

# SampleSystem

# constructor 

constructor(contract IWorld _world, address _components) public

# execute 

function execute(bytes arguments) public returns (bytes)

# executeTyped 

function executeTyped() external returns (bytes)

# getWorld 

function getWorld() public view returns (contract IWorld)

# getComponents 

function getComponents() public view returns (contract IUint256Component)

# SystemTest

# systems 

contract IUint256Component systems

# world 

contract World world

# components 

contract IUint256Component components

# system 

contract SampleSystem system

# setUp 

function setUp() public

# testSystemStorage 

function testSystemStorage() public

# testSystemStorageTest 

function testSystemStorageTest() public

# WorldTest

# vm 

contract Vm vm

# users 

address payable[] users

# world 

contract World world

# component1 

contract TestComponent1 component1

# component2 

contract TestComponent2 component2

# component3 

contract TestComponent3 component3

# prototypeTag 

contract PrototypeTagComponent prototypeTag

# fromPrototype 

contract FromPrototypeComponent fromPrototype

# ownedByEntity 

contract OwnedByEntityComponent ownedByEntity

# setUp 

function setUp() public

# testQuery 

function testQuery() public

# ID 

uint256 ID

# DamageComponent

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, uint256 value) public

# getValue 

function getValue(uint256 entity) public view returns (uint256)

# getEntitiesWithValue 

function getEntitiesWithValue(uint256 value) public view returns (uint256[])

# FromPrototypeComponent

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, uint256 prototypeEntity) public

# getValue 

function getValue(uint256 entity) public view returns (uint256)

# getEntitiesWithValue 

function getEntitiesWithValue(uint256 prototypeEntity) public view returns (uint256[])

# OwnedByEntityComponent

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, uint256 ownedByEntity) public

# getValue 

function getValue(uint256 entity) public view returns (uint256)

# getEntitiesWithValue 

function getEntitiesWithValue(uint256 ownedByEntity) public view returns (uint256[])

# Position 

struct Position {
  int64 x;
  int64 y;
}

# ID 

uint256 ID

# PositionComponent

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, struct Position value) public

# getValue 

function getValue(uint256 entity) public view returns (struct Position)

# getEntitiesWithValue 

function getEntitiesWithValue(struct Position value) public view returns (uint256[])

# PrototypeTagComponent

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# set 

function set(uint256 entity, bool value) public

# getValue 

function getValue(uint256 entity) public view returns (bool)

# getEntitiesWithValue 

function getEntitiesWithValue(bool value) public view returns (uint256[])

# TestComponent

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# TestComponent1

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# TestComponent2

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# TestComponent3

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# TestComponent4

# ID 

uint256 ID

# constructor 

constructor(address world) public

# getSchema 

function getSchema() public pure returns (string[] keys, enum LibTypes.SchemaValue[] values)

Return the keys and value types of the schema of this component.

# UtilsTest

# testSplit 

function testSplit() public

# freeFunction 

freeFunction entityToAddress(uint256 entity) internal pure returns (address)

Turn an entity ID into its corresponding Ethereum address.

# freeFunction 

freeFunction addressToEntity(address addr) internal pure returns (uint256)

Turn an Ethereum address into its corresponding entity ID.

# freeFunction 

freeFunction getAddressById(contract IUint256Component registry, uint256 id) internal view returns (address)

Get an Ethereum address from an address/id registry component (like _components/_systems in World.sol)

# freeFunction 

freeFunction getIdByAddress(contract IUint256Component registry, address addr) internal view returns (uint256)

Get an entity id from an address/id registry component (like _components/_systems in World.sol)

# freeFunction 

freeFunction getComponentById(contract IUint256Component components, uint256 id) internal view returns (contract IComponent)

Get a Component from an address/id registry component (like _components in World.sol)

# freeFunction 

freeFunction getSystemAddressById(contract IUint256Component components, uint256 id) internal view returns (address)

Get the Ethereum address of a System from an address/id component registry component in which the System registry component is registered (like _components in World.sol)

# freeFunction 

freeFunction getSystemById(contract IUint256Component components, uint256 id) internal view returns (contract ISystem)

Get a System from an address/id component registry component in which the System registry component is registered (like _components in World.sol)

# freeFunction 

freeFunction split(bytes data, uint8[] lengths) internal pure returns (bytes[])

Split a single bytes blob into an array of bytes of the given length

© Copyright 2023. All rights reserved.