private void OnEnable()
{
G.Engine.Computer(cd, new object[] { isFiring, currentDelay, G.Tick }, () =>
{
if (isFiring)
{
float tmp = currentDelay - G.Tick.Reduced;
while (tmp < 0)
{
tmp += delay;
fire.Fire(Empty.Instance);
}
currentDelay.Write(tmp);
}
else
{
currentDelay.Write(Mathf.Max(0, currentDelay - G.Tick.Reduced));
}
});
G.Engine.Computer(cd, new object[] { isManualFiring, ai.IsGunFiring }, () =>
{
isFiring.Write(isManualFiring || ai.IsGunFiring);
});
G.Engine.Reader(cd, new object[] { fire }, () =>
{
for (int i = 0, n = fire.Count; i < n; ++i)
{
var b = Instantiate(bullet, transform.position, transform.rotation);
W.Mark(b, "active");
b.SetActive(true);
}
});
}
public void Setup(CompositeDisposable cd, IEngine engine, State state)
{
Scene.Setup(cd, engine, state.SceneStack);
engine.Worker(cd, Dep.On(Scene.Open, state.Inventory.Items), () =>
{
Item openItem;
if (Scene.Open.TryRead(out openItem))
{
Item.Write(openItem);
}
else
{
var item = Item.Read();
var items = state.Inventory.Items.Read();
if (item != null && !items.Contains(item))
{
Item.Write(null);
}
}
});
engine.Worker(cd, Dep.On(Scene.State, Item), () =>
{
if (Scene.State == SceneState.Opened && Item.Read() == null)
{
Scene.Close.Fire(Empty.Instance);
}
});
}
public void Setup(CompositeDisposable cd, IEngine engine, SceneStack sceneStack)
{
Dialog.Setup(cd, engine, sceneStack);
engine.Worker(cd, Dep.On(Status, Trigger), () =>
{
if (Trigger && Status)
{
Dialog.Open.Fire(Empty.Instance);
}
});
engine.Worker(cd, Dep.On(Status, Trigger, Yes, No), () =>
{
T value;
if (!Status || Yes || No)
{
Current.Write(default(T));
}
else if (Trigger.TryRead(out value))
{
Current.Write(value);
}
});
engine.Worker(cd, Dep.On(Status, Trigger), () =>
{
T value;
if (Trigger.TryRead(out value) && !Status)
{
Rejected.Fire(value);
}
});
engine.Worker(cd, Dep.On(Status, Dialog.State, Yes, No), () =>
{
if (!Status && Dialog.State == SceneState.Opened)
{
Dialog.Close.Fire(Empty.Instance);
}
else if (Yes || No)
{
Dialog.Close.Fire(Empty.Instance);
}
});
engine.Worker(cd, Dep.On(Status, Yes), () =>
{
if (Yes && !Status)
{
throw new InvalidOperationException();
}
});
}
private void OnEnable()
{
G.Engine.Computer(cd, new object[] { G.Tick, G.Restart }, () =>
{
var r = rotation.Read();
if (G.Restart)
{
r = Quaternion.identity;
}
if (G.Tick)
{
r *= Quaternion.Euler(new Vector3(0, 0, 45) * G.Tick.Reduced);
}
// Can write directly to transform,
// just need to to use register listener.
// But use computer here to demonstrate how to delegate
// heavy computation to compute thread
rotation.Write(r);
});
G.Engine.Reader(cd, new object[] { rotation }, () =>
{
transform.rotation = rotation;
});
}
private void Update()
{
if (!G.IsGameRunning)
{
return;
}
bool f = Input.GetButton("Fire1");
isManualFiring.Write(f);
}
public void Setup(CompositeDisposable cd, IEngine engine)
{
var state = this;
Home.Setup(cd, engine, state);
Inventory.Setup(cd, engine, state);
SimpleLoading.Setup(cd, engine, state.SceneStack);
SceneStack.Setup(cd, engine);
engine.Worker(cd, Dep.On(Inventory.UpgradeItem.Yes, Inventory.SellItem.Yes), () =>
{
Gold.Write(Gold
- 10 * (Inventory.UpgradeItem.Yes ? 1 : 0)
+ 5 * (Inventory.SellItem.Yes ? 1 : 0)
);
});
engine.Worker(cd, Dep.On(SimpleLoading.State,
Home.Scene.State, Inventory.Scene.State,
Inventory.UpgradeItem.Dialog.State), () =>
{
bool needLoading = Home.Scene.State == SceneState.Opening ||
Inventory.Scene.State == SceneState.Opening ||
Inventory.UpgradeItem.Dialog.State == SceneState.Opening;
if (SimpleLoading.State == SceneState.Closed && needLoading)
{
SimpleLoading.Open.Fire(Empty.Instance);
}
else if (SimpleLoading.State == SceneState.Opened && !needLoading)
{
SimpleLoading.Close.Fire(Empty.Instance);
}
});
engine.Worker(cd, Dep.On(SceneStack.ActiveScenes), () =>
{
var active = SceneStack.ActiveScenes.Read();
ShouldShowBack.Write(active.Count > 1 && active[active.Count - 1].BackAutoClose);
});
}
public void Setup(CompositeDisposable cd, IEngine engine, State state)
{
Scene.Setup(cd, engine, state.SceneStack);
engine.Worker(cd, Dep.On(SelectedTab.Raw, state.Inventory.Scene.Open), () =>
{
if (state.Inventory.Scene.Open && CanOpenMore)
{
SelectedTab.Write("tab_more");
}
else
{
SelectedTab.Write(SelectedTab.Raw);
}
});
engine.Worker(cd, Dep.On(state.Inventory.Scene.Open), () =>
{
if (state.Inventory.Scene.Open)
{
CanOpenMore.Write(true);
}
});
}
private void OnEnable()
{
Engine.Computer(cd, new object[] { StartGame, Restart }, () =>
{
if (StartGame)
{
IsGameRunning.Write(true);
}
else if (Restart)
{
IsGameRunning.Write(false);
}
});
Engine.Computer(cd, new object[] { AddItem }, () =>
{
TotalItemCount.Write(TotalItemCount + AddItem.Count);
});
Engine.Firer(cd, new object[] { TouchEnemy }, () =>
{
if (TouchEnemy && !IsWinning)
{
Restart.Fire(Empty.Instance);
}
});
{
var requested = new List <GameObject>();
Engine.Guarder(cd,
new object[] { Tick, RequestDestroy },
() =>
{
if (Tick)
{
GameObject stillAlive = null;
for (int i = 0, n = requested.Count; i < n; ++i)
{
if (requested[i])
{
stillAlive = requested[i];
break;
}
}
if (stillAlive)
{
Debug.LogWarning("Requested to destroy but still alive", stillAlive);
}
requested.Clear();
}
requested.AddRange(RequestDestroy.Read());
}
);
}
Engine.Guarder(cd, new object[] { Restart, IsGameRunning }, () =>
{
if (Restart && !IsGameRunning)
{
throw new InvalidOperationException();
}
});
}
private void OnEnable()
{
G.Engine.Computer(cd, new object[] { G.PickUp, G.Restart }, () =>
{
if (G.Restart)
{
Score.Write(0);
}
else
{
Score.Write(Score + G.PickUp.Count);
}
});
G.Engine.Computer(cd, new object[] { Score, G.TotalItemCount }, () =>
{
G.IsWinning.Write(Score >= G.TotalItemCount);
});
G.Engine.Reader(cd, new object[] { Score, G.TotalItemCount }, () =>
{
countText.text = string.Format("Count: {0} / {1}",
Score, G.TotalItemCount);
});
G.Engine.Reader(cd, new object[] { Score, G.TotalItemCount }, () =>
{
if (Score >= G.TotalItemCount)
{
winText.text = "You win!";
}
else
{
winText.text = "";
}
});
{
bool canRestart = false;
Coroutine lastCoroutine = null;
cd.Add(new DisposableAction(() =>
{
if (lastCoroutine != null)
{
G.Instance.StopCoroutine(lastCoroutine);
}
}));
G.Engine.Reader(cd, new object[] { Score, G.TotalItemCount }, () =>
{
if (Score < G.TotalItemCount)
{
canRestart = true;
}
if (Score >= G.TotalItemCount && canRestart)
{
canRestart = false;
if (lastCoroutine != null)
{
G.Instance.StopCoroutine(lastCoroutine);
}
lastCoroutine = G.Instance.StartCoroutine(WaitThenRestart(G.Restart));
}
});
}
G.Engine.Writer(cd, new object[] { G.Tick, G.Restart }, () =>
{
if (G.Restart)
{
transform.position = orgPos;
}
Position.Write(transform.position);
});
G.Engine.Writer(cd, new object[] { G.Tick, G.IsGameRunning }, () =>
{
var v = Vector2.zero;
if (G.IsGameRunning)
{
v.x = Input.GetAxis("Horizontal");
v.y = Input.GetAxis("Vertical");
}
movement.Write(v);
});
}
public void Setup(CompositeDisposable cd, IEngine engine)
{
if (rawResponse != null)
{
engine.Worker(cd, Dep.On(rawResponse), () =>
{
string raw;
if (rawResponse.TryRead(out raw))
{
var res = default(TRes);
if (responseParser != null)
{
res = responseParser(raw);
}
Response.Fire(res);
}
});
}
engine.Worker(cd, Dep.On(Request, Response, Error), () =>
{
int result = Requesting - (Response ? 1 : 0) - (Error ? 1 : 0);
switch (pipe)
{
case HttpPipe.Multiple:
result += Request ? 1 : 0;
break;
case HttpPipe.SingleFirst:
case HttpPipe.SingleLast:
result += Requesting > 0 ? 0 : Math.Min(1, Request ? 1 : 0);
break;
}
if (result < 0)
{
throw new NotImplementedException();
}
else if (pipe.IsSingle() && result > 1)
{
throw new NotImplementedException();
}
Requesting.Write(result);
});
engine.Mainer(cd, Dep.On(Request), () =>
{
TReq req;
if (Request.TryRead(out req))
{
if (pipe == HttpPipe.SingleFirst && Requesting > 0)
{
UnityEngine.Debug.LogWarning("Skip a HTTP request, because of single on: " + url);
UnityEngine.Debug.LogWarning("Request: " + req);
}
else
{
if (pipe == HttpPipe.SingleLast && Requesting > 0)
{
UnityEngine.Debug.LogWarning("Stop previous HTTP request, because of single on: " + url);
UnityEngine.Debug.LogWarning("New request: " + req);
HttpMain.Instance.StopCoroutine(lastExec);
}
lastExec = HttpMain.Instance.StartCoroutine(Exec(req));
}
}
});
}
