private IEvent _Undo(bool countNonActionable = true) // TODO
{
IEvent e = allEvents.Pop(); // Make method for this
if (e is IActionableEvent)
{
IBaseCommand undoCommand = (e as IActionableEvent).NewUndoCommand();
if (undoCommand is IEntityModifier)
{
IEntityModifier m = (undoCommand as IEntityModifier);
Assert.IsTrue(m is IEventProducing);
(m as IEventProducing).DontRecordEvent = true;
EM.ApplyMod(m);
}
else if (undoCommand is IIndependentModifier)
{
IIndependentModifier m = (undoCommand as IIndependentModifier);
Assert.IsTrue(m is IEventProducing);
(m as IEventProducing).DontRecordEvent = true;
EM.ApplyMod(m);
}
else if (undoCommand is Command)
{
throw new NotImplementedException();
}
else
{
throw new Exception("Cannot apply undo command: " + undoCommand.GetType().Name);
}
}
return(e);
}
private void _Do(IEvent e)
{
if (e is IActionableEvent)
{
IBaseCommand doCommand = (e as IActionableEvent).NewDoCommand();
if (doCommand is IEntityModifier)
{
IEntityModifier m = (doCommand as IEntityModifier);
Assert.IsTrue(m is IEventProducing);
EM.ApplyMod(m);
}
else if (doCommand is IIndependentModifier)
{
IIndependentModifier m = (doCommand as IIndependentModifier);
Assert.IsTrue(m is IEventProducing);
EM.ApplyMod(m);
}
else if (doCommand is Command)
{
throw new NotImplementedException();
}
else
{
throw new Exception();
}
}
}
public bool unregisterEntityModifier(IEntityModifier pEntityModifier)
{
if (this.mEntityModifiers == null)
{
return(false);
}
return(this.mEntityModifiers.Remove(pEntityModifier));
}
public void SendEntityMod(IEntityModifier m)
{
object[] args = new object[] {
Serialisation.ToBinary(m.e), // Assume that the entity is not serialised with the modifier
Serialisation.ToBinary(m)
};
View.RPC("DoEntityDependentMod", PhotonTargets.All, args);
}
public void registerEntityModifier(IEntityModifier pEntityModifier)
{
if (this.mEntityModifiers == null)
{
this.allocateEntityModifiers();
}
this.mEntityModifiers.Add(pEntityModifier);
}
public void Remove(TIdentifier identifier)
{
if (_entities.TryGetValue(identifier, out var entity))
{
IEntityModifier changer = entity;
changer.MarkAsRemoved();
_entities.Remove(identifier);
}
}
public void RefreshEntityOnModifierUsingUID(IModifier m)
{
if (m is IEntityModifier)
{
IEntityModifier em = m as IEntityModifier;
IEntityRegistry r = GetRegistryByEntityType(em.IntendedEntityType);
em.e = r.GetUncastEntityByUID(em.e.UID);
}
}
public void Assign(IEntityModifier mod, CharacterNode target)
{
_target = target;
_watchedMod = mod;
if (_watchedMod != null)
{
_iconImage.sprite = mod.Icon != null ? mod.Icon : _defaultIcon;
UpdateCoolDown();
}
}
private bool ContainsMod(IEntityModifier mod)
{
for (int i = 0; i < _active.Count; i++)
{
if (_active[i].Mod == mod)
{
return(true);
}
}
return(false);
}
public void UnregisterModifier(IEntityModifier modifier)
{
if (modifier == null || modifiers == null)
{
return;
}
if (modifiers.Contains(modifier))
{
modifiers.Remove(modifier);
}
}
public void RegisterModifier(IEntityModifier modifier)
{
if (modifiers == null)
{
modifiers = new EntityModifierList(this);
}
if (modifiers.Contains(modifier))
{
return;
}
modifiers.AddModifier(modifier);
}
public void SendEntityModAndConfirm(IEntityModifier m, Action finished)
{
int requestID = NetworkInteractionTracker.RecordMassPingRequestStarted();
PhotonHelper.RequestFromPlayers(
DependentRequest,
r => ReturnModSentByRequestID.Add(requestID, r),
_ => {
Debug.Log("Mod sent to all players, should be done locally too");
ReturnModSentByRequestID.Remove(requestID);
if (finished != null)
{
finished.Invoke();
}
},
PhotonNetwork.player.ID, m, requestID
);
}
public override int SaveChanges()
{
foreach (EntityEntry entry in ChangeTracker.Entries())
{
if (entry.Entity is IEntityCreator || entry.Entity is IEntityModifier)
{
if (entry.State == EntityState.Added)
{
IEntityCreator entity = (IEntityCreator)entry.Entity;
entity.UserCreated = UserName;
entity.DateCreated = DateTime.Now;
}
if (entry.State == EntityState.Modified)
{
IEntityModifier entity = (IEntityModifier)entry.Entity;
entity.UserModified = UserName;
entity.DateModified = DateTime.Now;
}
}
}
return(base.SaveChanges());
}
public OrderLineCollection(IEntityModifier root) : base(root)
{
}
public static int TurnsLeft(this IEntityModifier mod)
{
return((mod.TurnStart + mod.TurnLength) - TurnBased.TurnNumber);
}
public static int TurnEnd(this IEntityModifier mod)
{
return(mod.TurnStart + mod.TurnLength);
}
public EntityCollection(IEntityModifier root)
{
_root = root;
}
public void AddBuildUI(IEntityModifier mod)
{
buildUIs.Add(mod);
}
public void OnPoolDespawned()
{
_watchedMod = null;
}
public void RemoveBuildUI(IEntityModifier mod)
{
buildUIs.Remove(mod);
}
public void AddBuildUI(IEntityModifier mod)
{
buildUIs.Add(mod);
}
public LoopEntityModifier(IEntityModifier entityModifier)
: base(entityModifier)
{
}
public LoopEntityModifier(IEntityModifier entityModifier, int loopCount)
: base(entityModifier, loopCount)
{
}
protected Entity(IEntityModifier root)
{
_root = root;
}
public void RemoveBuildUI(IEntityModifier mod)
{
buildUIs.Remove(mod);
}
