public static void ComputeRemain(IEl <int> target,
IOp <Ops.Tick> tick)
{
int remain = target.Read();
if (remain == 0)
{
return;
}
Ops.Tick t;
if (tick.TryRead(out t))
{
remain -= t.Dt;
}
if (remain < 0)
{
remain = 0;
}
if (remain != target.Read())
{
target.Write(remain);
}
}
public static void ComputeList(ILi <IModifierItem> target,
IEntity entity, IOp <Ops.Tick> tick, IList <Ops.Hit> hit,
IModifierItemFactory itemFactory)
{
Ops.Tick t;
if (!tick.TryRead(out t) && hit.Count <= 0)
{
return;
}
var items = target.AsWrite();
for (int i = 0, n = hit.Count; i < n; ++i)
{
var h = hit[i];
if (h.To != entity)
{
continue;
}
var a = h.From.Hitters.AddModifier;
if (a == null)
{
continue;
}
for (int j = 0, m = a.Modifiers.Count; j < m; ++j)
{
items.Add(itemFactory.Create(a.Modifiers[j]));
}
}
if (tick.TryRead(out t))
{
items.RemoveAll(it =>
{
if (it.Remain.Read() == 0)
{
itemFactory.Dispose(it);
return(true);
}
return(false);
});
}
}
public static void Items(
ILi <ITodoItem> target,
IEl <int> nextId,
IMultiOp <string> newItem_,
IOp <Empty> deleteCompletedItems_,
IMultiOp <string> deleteItem_,
ITodoItemFactory factory)
{
var newItem = newItem_.Read();
Empty tmp;
bool deleteCompletedItems = deleteCompletedItems_.TryRead(out tmp);
var deleteItem = deleteItem_.Read();
if (newItem.Count <= 0 &&
!deleteCompletedItems &&
deleteItem.Count <= 0)
{
return;
}
var items = target.AsWrite();
if (newItem.Count > 0)
{
for (int i = 0, n = newItem.Count; i < n; ++i)
{
items.Add(factory.Create((nextId.Read() + i).ToString(), newItem[i]));
}
nextId.Write(nextId.Read() + newItem.Count);
}
if (deleteCompletedItems)
{
items.RemoveAll(it =>
{
if (it.IsCompleted.Read())
{
factory.Dispose(it);
return(true);
}
return(false);
});
}
if (deleteItem.Count > 0)
{
items.RemoveAll(it =>
{
if (deleteItem.Contains(it.Id))
{
factory.Dispose(it);
return(true);
}
return(false);
});
}
}
public static void Content(IEl <string> target, IEl <string> editingItemId, IOp <string> finishEdit_, string myId)
{
string finishEdit;
if (editingItemId.Read() == myId && finishEdit_.TryRead(out finishEdit))
{
string newContent = finishEdit;
if (!string.IsNullOrEmpty(newContent))
{
target.Write(newContent);
}
}
}
public static void ComputeElapsed(IEl <int> target,
IOp <Ops.Tick> tick)
{
int elapsed = target.Read();
Ops.Tick t;
if (tick.TryRead(out t))
{
elapsed += t.Dt;
}
if (elapsed != target.Read())
{
target.Write(elapsed);
}
}
public static void EditingItemId(IEl <string> target, IOp <string> edit_, IOp <string> finish)
{
string edit;
string tmp;
var editingItemId = target.Read();
if (finish.TryRead(out tmp))
{
editingItemId = null;
}
else if (edit_.TryRead(out edit))
{
editingItemId = edit;
}
if (editingItemId != target.Read())
{
target.Write(editingItemId);
}
}
public static void ComputeCurrent(IEl <int> target,
int max, int regenSpeed, IEntity entity, int armorValue,
IOp <Ops.Tick> tick, IList <Ops.Hit> hit, IList <IStickHitItem> stickHits,
int randomSeed)
{
if (target.Read() <= 0)
{
return;
}
int add = 0;
int sub = 0;
int ticks = 0;
Ops.Tick t;
if (tick.TryRead(out t))
{
ticks = t.Dt;
}
add += ticks * regenSpeed;
for (int i = 0, n = hit.Count; i < n; ++i)
{
var h = hit[i];
if (h.From.HasOwner.Owner != entity)
{
continue;
}
var hitters = h.From.Hitters;
if (hitters.Damage == null)
{
continue;
}
int lifeStealPercent = hitters.Damage.LifeStealPercent.Read();
if (lifeStealPercent <= 0)
{
continue;
}
// TODO Still need hit random seed, beside world random seed
// to make sure 2 hits in same update
// are different when calc critical
int dealtDamage = CalcDealtDamage(hitters.Damage,
h.To.Armor.Value.Read(), randomSeed, h.RandomSeed);
int canStealAmount = Math.Min(dealtDamage, h.To.Health.Current.Read());
add += (int)Math.Ceiling(canStealAmount * (lifeStealPercent / 100f));
}
for (int i = 0, n = stickHits.Count; i < n; ++i)
{
var s = stickHits[i];
var h = s.Hit;
if (h.From.HasOwner.Owner != entity)
{
continue;
}
var hitters = h.From.Hitters;
if (hitters.Damage == null)
{
continue;
}
int lifeStealPercent = hitters.Damage.LifeStealPercent.Read();
if (lifeStealPercent <= 0)
{
continue;
}
int dealtDamage = CalcDealtDot(ticks, s, hitters.Damage,
h.To.Armor.Value.Read(), randomSeed, h.RandomSeed);
int canStealAmount = Math.Min(dealtDamage, h.To.Health.Current.Read());
add += (int)Math.Ceiling(canStealAmount * (lifeStealPercent / 100f));
}
for (int i = 0, n = hit.Count; i < n; ++i)
{
var h = hit[i];
if (h.To != entity)
{
continue;
}
var hitters = h.From.Hitters;
if (hitters.Damage == null)
{
continue;
}
sub += CalcDealtDamage(hitters.Damage, armorValue,
randomSeed, h.RandomSeed);
}
for (int i = 0, n = hit.Count; i < n; ++i)
{
var h = hit[i];
if (h.From.HasOwner.Owner != entity)
{
continue;
}
var reflectDamagePercent = h.To.DamageReflector.Percent.Read();
if (reflectDamagePercent <= 0)
{
continue;
}
var hitters = h.From.Hitters;
if (hitters.Damage == null)
{
continue;
}
int dealtDamage = CalcDealtDamage(hitters.Damage,
h.To.Armor.Value.Read(), randomSeed, h.RandomSeed);
sub += (int)Math.Ceiling(dealtDamage * (reflectDamagePercent / 100f));
}
for (int i = 0, n = stickHits.Count; i < n; ++i)
{
var s = stickHits[i];
var h = s.Hit;
if (h.To != entity)
{
continue;
}
var hitters = h.From.Hitters;
if (hitters.Damage == null)
{
continue;
}
sub += CalcDealtDot(ticks, s, hitters.Damage,
armorValue, randomSeed, h.RandomSeed);
}
// Can be very flexible here, prefer add over sub, sub over add or fair
int current = target.Read();
current = Math.Min(max, current + add);
current = Math.Max(0, current - sub);
if (current != target.Read())
{
target.Write(current);
}
}
