public async Task HandleAtomMessage(NetsyChannel channel, AtomMessage atomMessage)
{
//channel can be null
Guard.NotNull(atomMessage, nameof(atomMessage));
var netsyMessage = NetsyMessage.FromAtomMessage(atomMessage.Data);
var package = this._packageSerializer.Deserialize(netsyMessage.Data);
switch (netsyMessage.Kind)
{
case NetsyMessageKind.SendPackage:
this._handlerRegistry.HandlePackage(channel, package);
break;
case NetsyMessageKind.Request:
var(success, response) = await this._handlerRegistry.HandleIncomingRequest(channel, package);
if (success)
{
var responseData = this._packageSerializer.Serialize(response);
var responseMessage = NetsyMessage.ResponseFor(responseData, netsyMessage.RequestId);
await this.SendMessageAsync(responseMessage);
}
break;
case NetsyMessageKind.Response:
this._handlerRegistry.HandleResponse(netsyMessage.RequestId, package);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task OnMessageReceivedAsync(AtomMessage message)
{
foreach (var plugin in this._plugins)
{
await plugin.OnMessageReceivedAsync(message);
}
}
public async Task OnChannelMessageReceivedAsync(AtomChannel channel, AtomMessage message)
{
foreach (var plugin in this._plugins)
{
await plugin.OnChannelMessageReceivedAsync(channel, message);
}
}
public async Task OnSendingMessageAsync(AtomMessage message)
{
foreach (var plugin in this._plugins)
{
await plugin.OnSendingMessageAsync(message);
}
}
public void UpdateModel(AtomModel model)
{
_model = model;
_atomMessage = new AtomMessage(_model.AtomicNumber, 1);
_model.rMaxStockNextLevel.Subscribe(newValue => UIStockLabel.text = "+" + newValue.ToString()).AddTo(this);
_model.rMaxStockUpgradePrice.Subscribe(newValue => UISCLabel.text = newValue.ToString()).AddTo(this);
gameModel.User.rSC.Subscribe(SC => UIButton.interactable = SC >= _model.MaxStockUpgradePrice).AddTo(this);
}
internal void UpdateModel(AtomModel model)
{
_model = model;
_startTime = Time.time;
_originalMaxStock = _model.MaxStock;
_atomMessage = new AtomMessage(_model.AtomicNumber, 1);
AddReactor(timePercent);
AddReactor
(
_model.rHarvestRate
.Subscribe(rate =>
{
_model.Stock = (int)(((float)_model.Stock / _model.MaxStock) * (_originalMaxStock * _model.HarvestRate));
_model.MaxStock = (int)(_originalMaxStock * _model.HarvestRate);
_harvestTime = _model.AtomicWeight / _model.HarvestRate;
_startTime = -(timePercent.Value * _harvestTime) + Time.time;
})
);
AddReactor
(
Observable.EveryUpdate()
.Subscribe(_ => timePercent.Value = (Time.time - _startTime) / _harvestTime)
);
AddReactor
(
timePercent.Subscribe(percent => UISlider.value = UISlider.maxValue * percent)
);
AddReactor
(
_model.rStock.Where(_ => _model.Stock <= 0).Subscribe(_ => DestroyReactors())
);
AddReactor
(
timePercent
.Where(value => value >= 1f)
.Subscribe(_ =>
{
_startTime = Time.time;
_model.Stock -= 1;
Messenger.Dispatch(AtomMessage.ATOM_HARVEST, _atomMessage);
})
);
}
public virtual Task OnChannelMessageReceivedAsync(AtomChannel channel, AtomMessage message)
{
return(Task.CompletedTask);
}
public virtual Task OnChannelSendingMessageAsync(AtomChannel channel, AtomMessage message)
{
return(Task.CompletedTask);
}
public virtual Task OnMessageReceivedAsync(AtomMessage message)
{
return Task.CompletedTask;
}
public virtual Task OnSendingMessageAsync(AtomMessage message)
{
return Task.CompletedTask;
}
private void SpendAtoms(AbstractMessage msg)
{
AtomMessage message = msg as AtomMessage;
gameModel.AMM.SpendAtoms(message.SC);
}
private void AtomStockUpgrade(AbstractMessage msg)
{
AtomMessage message = msg as AtomMessage;
gameModel.AMM.UpgradeAtomStock(message.AtomicNumber);
}
private void AtomHarvested(AbstractMessage message)
{
AtomMessage data = message as AtomMessage;
gameModel.AMM.HarvestAtom(data.AtomicNumber);
}
public AtomMessage ToAtomMessage()
{
return(AtomMessage.FromData(this.GetData()));
}
