engine_react_util¶

Quelle: base/tealdef/gui/main/engine_react_util.d.tl

Hinweise

React-Hooks, die Daten der Engine in einen React-State spiegeln. Die Schritt- und Timer-Hooks lesen die Engine über einen Callback getFromEngine neu. Die parallelen Hooks führen eine registrierte Funktion (useFnName) in einem Worker-Thread aus und geben ihr Ergebnis durch finalize. Die Hooks ändern den State nur, wenn sich der Wert geändert hat. Die meisten liefern außerdem eine Funktion commit, die den State setzt und Engine-Befehle schickt.

EngineReactUtil¶

record global base/tealdef/gui/main/engine_react_util.d.tl:3

global record EngineReactUtil

Laden: local engine_react_util = ug_require "::/gui/main/engine_react_util.tl" as EngineReactUtil

Hinweise

React-Hooks, die einen React-State mit Daten der Engine abgleichen und Befehle zum Ändern schicken.

Details

Wie alle React-Hooks müssen diese Hooks aus einer Recipe-Funktion aufgerufen werden, und zwar immer in derselben Reihenfolge.

Die Commit-Funktion, die die meisten Hooks liefern, hat die Form commit(newState, cmd?, callback?). Sie ruft onChange(newState, old, true) auf, setzt den State und schickt dann cmd mit api.cmd.sendCommand ab (oder, wenn cmd nil ist, die Befehle aus makeCommand/makeCommands). Solange Befehle ausstehen, liest der Hook die Engine nicht neu. So springt der State nicht zurück, bevor der Befehl angewendet wurde. Standardvergleich ist table_util.deepEquals.

Funktionen

useStepStateMulti<StateTypeT, CommandDataT is ICommandData>(getFromEngine : (function(old? : StateTypeT) : StateTypeT), makeCommands? : (function(StateTypeT) : {{Command<CommandDataT>, function(cmdData : CommandDataT, success : boolean, affectedEntities : {{Engine.Entity, Engine.Revision}})}}), stateEqualsFn? : (function(StateTypeT, StateTypeT) : boolean), onChange? : function(now : StateTypeT, old : StateTypeT, commit : boolean), once? : boolean) : ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})) base/tealdef/gui/main/engine_react_util.d.tl:4

Aufruf: engine_react_util.useStepStateMulti(…)

react state, commit fn

Hinweise

Wie useStepState, aber makeCommands liefert eine Liste von Paaren {command, callback}, die beim Commit alle abgeschickt werden.

Rückgabe ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}}))

Im Basisspiel verwendet: 3-mal in 2 Dateien

base/content/gui/gui/debug_panel/make_entity_debug_panel.tl:621

local state, commit = engine_react_util.useStepStateMulti(makeState, makeCommands)

base/content/gui/gui/line_vehicle_mgmt/manager_window.tl:2254

local deleteState, commitDelete : ReactStateT<integer>, function(integer) = engine_react_util.useStepStateMulti(makeDeleteState, makeDeleteCommands, nil, nil, t

useStepState<StateTypeT, CommandDataT is ICommandData>(getFromEngine : (function(old? : StateTypeT) : StateTypeT), makeCommand? : (function(StateTypeT) : Command<CommandDataT>, (function(CommandDataT, boolean, {{Engine.Entity, Engine.Revision}}))), stateEqualsFn? : (function(typeA : StateTypeT, typeB : StateTypeT) : boolean), onChange? : function(now : StateTypeT, old : StateTypeT, commit : boolean), once? : boolean) : ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})) base/tealdef/gui/main/engine_react_util.d.tl:12

Aufruf: engine_react_util.useStepState(…)

react state, commit fn

Hinweise

Erzeugt einen React-State, der in jedem Schritt neu aus der Engine gelesen wird und sich mit einem Befehl zurückschreiben lässt.

Parameter	Typ	Beschreibung
`getFromEngine`	`(function(old? : StateTypeT) : StateTypeT)`	Liest den aktuellen Wert aus der Engine und erhält den vorherigen Wert (beim ersten Mal `nil`).
`makeCommand?`	`(function(StateTypeT) : Command<CommandDataT>, (function(CommandDataT, boolean, {{Engine.Entity, Engine.Revision}})))`	Optional. Baut den Befehl (und als zweiten Rückgabewert optional einen Callback für das Ergebnis), den `commit` verwendet, wenn ihm kein Befehl übergeben wird.
`stateEqualsFn?`	`(function(typeA : StateTypeT, typeB : StateTypeT) : boolean)`	Optionaler Vergleich von altem und neuem Wert, Standard ist `table_util.deepEquals`.
`onChange?`	`function(now : StateTypeT, old : StateTypeT, commit : boolean)`	Optional. Wird vor der Änderung des States aufgerufen, mit `commit = true`, wenn die Änderung aus der Commit-Funktion kommt.
`once?`	`boolean`	Optional. Bei `true` wirkt die Commit-Funktion nur, solange noch kein Befehl geschickt wurde (gegen Doppelklicks).

Rückgabe ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})): Der React-State und die Commit-Funktion commit(newState, cmd?, callback?).

Im Basisspiel verwendet: 313-mal in 82 Dateien

base/content/game_mechanics/game_mechanics/company/company.tl:679

local companyState = engine_react_util.useStepState(makeCompanyState)

base/content/game_mechanics/game_mechanics/company/explorations/exploration_plane_entity_window.script.tl:18

local state = engine_react_util.useStepState(function() : State

base/content/game_mechanics/game_mechanics/emission/pollution_cleanup_facility_hud.script.tl:52

local state = engine_react_util.useStepState(function() : State

base/content/game_mechanics/game_mechanics/finance/account.tl:18

local loansEnabledState = engine_react_util.useStepState(makeLoansEnabledState)

base/content/game_mechanics/game_mechanics/finance/finances_assets.tl:216

local currentGameTimeState = engine_react_util.useStepState(function() : integer

base/content/game_mechanics/game_mechanics/finance/finances_cargo_lifetime.tl:59

local millisPerDayState = engine_react_util.useStepState(makeMillisPerDayState)

… und 76 weitere Dateien.

useStepStateTimer<StateTypeT>(getFromEngine : (function(old? : StateTypeT) : StateTypeT), interval? : number, stateEqualsFn? : (function(typeA : StateTypeT, typeB : StateTypeT) : boolean)) : ReactStateT<StateTypeT> base/tealdef/gui/main/engine_react_util.d.tl:20

Aufruf: engine_react_util.useStepStateTimer(…)

react state

Hinweise

Erzeugt einen nur lesbaren React-State, der in festen Abständen statt in jedem Schritt neu aus der Engine gelesen wird.

Parameter	Typ	Beschreibung
`getFromEngine`	`(function(old? : StateTypeT) : StateTypeT)`	Liest den aktuellen Wert aus der Engine und erhält den vorherigen Wert (beim ersten Mal `nil`).
`interval?`	`number`	Optionaler Abstand zwischen zwei Lesevorgängen in Sekunden, Standard 0,5.
`stateEqualsFn?`	`(function(typeA : StateTypeT, typeB : StateTypeT) : boolean)`	Optionaler Vergleich von altem und neuem Wert, Standard ist `table_util.deepEquals`.

Rückgabe ReactStateT<StateTypeT>: Der React-State.

Im Basisspiel verwendet: 124-mal in 58 Dateien

base/content/game_mechanics/game_mechanics/company/company_notification_greenify.script.tl:15

local state = engine_react_util.useStepStateTimer(makeState)

base/content/game_mechanics/game_mechanics/company/company_notification_marketing.script.tl:28

local progressState = engine_react_util.useStepStateTimer(makeProgressState)

base/content/game_mechanics/game_mechanics/company/company_notification_prospection.script.tl:14

local progressState = engine_react_util.useStepStateTimer(function() : number

base/content/game_mechanics/game_mechanics/finance/finances_table.tl:578

local tableState = engine_react_util.useStepStateTimer(makeTableState, nil, isTableEqual)

base/content/game_mechanics/game_mechanics/notifications/types/cargo_rtc_warning.script.tl:26

local state = engine_react_util.useStepStateTimer(makeState)

base/content/game_mechanics/game_mechanics/notifications/types/industry_close.script.tl:51

local state = engine_react_util.useStepStateTimer(makeState)

… und 52 weitere Dateien.

useStepStateTimerWithCommit<StateTypeT, CommandDataT is ICommandData>(getFromEngine : (function(old? : StateTypeT) : StateTypeT), interval? : number, makeCommand? : (function(StateTypeT) : Command<CommandDataT>, (function(CommandDataT, boolean, {{Engine.Entity, Engine.Revision}}))), stateEqualsFn? : (function(typeA : StateTypeT, typeB : StateTypeT) : boolean), onChange? : function(now : StateTypeT, old : StateTypeT, commit : boolean), once? : boolean) : ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})) base/tealdef/gui/main/engine_react_util.d.tl:26

Aufruf: engine_react_util.useStepStateTimerWithCommit(…)

react state, commit fn

Hinweise

Wie useStepStateTimer (Lesen in Abständen, Standard 0,5 Sekunden), liefert aber zusätzlich eine Commit-Funktion wie useStepState.

Rückgabe ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}}))

Im Basisspiel verwendet: 7-mal in 6 Dateien

base/content/game_mechanics/game_mechanics/company/company.tl:943

local playerNameState, commitName = engine_react_util.useStepStateTimerWithCommit(makePlayerNameState, 0, makeNameCommand)

base/content/game_mechanics/game_mechanics/notifications/gui/notification_popups.tl:277

local guiNotificationsState, commit = engine_react_util.useStepStateTimerWithCommit(makeGuiNotificationsState)

base/content/gui/gui/entity_window/view_manager.tl:201

local titleState, commitTitle = engine_react_util.useStepStateTimerWithCommit(function() : string

base/content/gui/gui/line_vehicle_mgmt/line_manager_panel.tl:768

local nameState, commitName = engine_react_util.useStepStateTimerWithCommit(makeNameState, 0, makeNameCommand)

base/content/gui/gui/line_vehicle_mgmt/manager_window.tl:2041

local nameState, commitName : ReactStateT<string>, function(string) = engine_react_util.useStepStateTimerWithCommit(makeNameState, 0, makeNameCommand)

base/content/gui/gui/line_vehicle_mgmt/vehicle_list_react_util.tl:222

local nameState, commitName = engine_react_util.useStepStateTimerWithCommit(makeNameState, 0, makeNameCommand)

useStepStateParallel<StateTypeT, ParamT, WorkItemResultT, CommandDataT is ICommandData>(useFnName : string, useFnParams : ParamT, finalize : (function(result : WorkItemResultT, useFnParams : ParamT, old? : StateTypeT) : StateTypeT), makeCommand? : (function(StateTypeT) : Command<CommandDataT>, (function(CommandDataT, boolean, {{Engine.Entity, Engine.Revision}}))), stateEqualsFn? : (function(StateTypeT, StateTypeT) : boolean), onChange? : (function(now : StateTypeT, old : StateTypeT, commit : boolean)), once? : boolean) : ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})) base/tealdef/gui/main/engine_react_util.d.tl:36

Aufruf: engine_react_util.useStepStateParallel(…)

make state that will update each step but in another thread. The result is finalize()d in the main thread and the resulting dirty state is applied next frame.

react state, commit fn

Hinweise

Erzeugt einen React-State, den eine benannte Funktion in jedem Schritt in einem Worker-Thread berechnet und der im Hauptthread fertiggestellt wird.

Parameter	Typ	Beschreibung
`useFnName`	`string`	Name der auszuführenden Funktion in der Form, die `util.useFn` annimmt (eine Skriptreferenz wie `"::/path/file.script@fnName"`).
`useFnParams`	`ParamT`	Parameter für diese Funktion (und für `finalize`).
`finalize`	`(function(result : WorkItemResultT, useFnParams : ParamT, old? : StateTypeT) : StateTypeT)`	Macht im Hauptthread aus dem Ergebnis des Workers den Wert des States. Erhält das Ergebnis, `useFnParams` und den vorherigen State.
`makeCommand?`	`(function(StateTypeT) : Command<CommandDataT>, (function(CommandDataT, boolean, {{Engine.Entity, Engine.Revision}})))`	Optional. Baut den Befehl, den die Commit-Funktion verwendet.
`stateEqualsFn?`	`(function(StateTypeT, StateTypeT) : boolean)`	Optionaler Vergleich, Standard ist `table_util.deepEquals`.
`onChange?`	`(function(now : StateTypeT, old : StateTypeT, commit : boolean))`	Optional. Wird vor einer committeten Änderung aufgerufen.
`once?`	`boolean`	Optional. Erlaubt nur einen Commit.

Rückgabe ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<CommandDataT>, callback? : function(cmdData : CommandDataT, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})): Der React-State und die Commit-Funktion.

Details

Den Anfangswert berechnet der Hook synchron im Hauptthread. Danach reiht er die Funktion in jedem Schritt mit react.enqueueParallel ein, solange kein Befehl aussteht.

Im Basisspiel verwendet: 3-mal in 2 Dateien

base/content/game_mechanics/game_mechanics/towns/town_react_util.tl:170

local reactState = engine_react_util.useStepStateParallel(

base/content/gui/gui/entity_window/town/town_eow.script.tl:1110

local dataState = engine_react_util.useStepStateParallel("::/game_mechanics/towns/town_util_parallel.script@town_util_parallel.getTownDistrictCountsState", para

make state that will update each step but in another thread. The resulting dirty state is applied next frame.

useStepStateParallelSimple<StateTypeT, ParamT>(useFnName : string, useFnParams : ParamT, stateEqualsFn? : (function(StateTypeT, StateTypeT))) : ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<ICommandData>, callback? : function(cmdData : ICommandData, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}})) base/tealdef/gui/main/engine_react_util.d.tl:47

Aufruf: engine_react_util.useStepStateParallelSimple(…)

react state, commit fn

Hinweise

useStepStateParallel ohne Schritt finalize und ohne Befehl: Das Ergebnis des Workers ist der State.

Rückgabe ReactStateT<StateTypeT>, function(type : StateTypeT, cmd? : Command<ICommandData>, callback? : function(cmdData : ICommandData, success : boolean, affectedEntites : {{Engine.Entity, Engine.Revision}}))

Im Basisspiel verwendet: 11-mal in 2 Dateien

base/content/game_mechanics/game_mechanics/towns/town_react_util.tl:264

local state = engine_react_util.useStepStateParallelSimple("::/game_mechanics/towns/town_util_parallel.script@town_util_parallel.getDeliveriesState", params.ent

base/content/gui/gui/entity_window/town/town_eow.script.tl:27

local stepState = engine_react_util.useStepStateParallelSimple("::/game_mechanics/towns/town_util_parallel.script@town_util_parallel.getTownLevelWidgetState", p

useDummyStepState() base/tealdef/gui/main/engine_react_util.d.tl:50

Aufruf: engine_react_util.useDummyStepState(…)

Hinweise

Ruft dieselben Hooks auf wie useStepStateMulti (eine Ref und einen State), tut aber sonst nichts.

Details

Verwende ihn in einem Zweig, in dem der echte Step-State-Hook ausgelassen wird. So bleibt die Reihenfolge der Hook-Aufrufe im Recipe zwischen zwei Renderdurchläufen gleich.