protected void SubscribeAllEvent <T>(
EntityEventHandler <T> handler,
Type[]?before = null, Type[]?after = null)
where T : notnull
{
SubEvent(EventSource.All, handler, before, after);
}
public virtual bool Delete(T obj, EntityEventHandler <T> deletingHandler = null, EntityEventHandler <T> deletedHandler = null)
{
obj = this.HandleEvents(events, es => es.DeletingHandler, DataOperation.Delete, obj, null);
obj = this.HandleEvent(deletingHandler, DataOperation.Delete, obj, null);
U entity = new U();
entity = mapper.Map <T, U>(obj, () => entity);
var tbl = db.Set <U>();
if (!tbl.Local.Contains(entity))
{
db.Entry(entity).State = EntityState.Deleted;
}
else
{
db.Set <U>().Remove(entity);
}
int ret = db.SaveChanges();
if (ret > 0)
{
this.HandleEvent(deletedHandler, DataOperation.Delete, obj, null);
this.HandleEvents(events, es => es.DeletedHandler, DataOperation.Delete, obj, null);
}
return(ret > 0);
}
public virtual bool Update(T obj, EntityEventHandler <T> updatingHandler = null, EntityEventHandler <T> updatedHandler = null)
{
obj = this.HandleEvents(events, es => es.UpdatingHandler, DataOperation.Update, obj, obj);
obj = this.HandleEvent(updatingHandler, DataOperation.Update, obj, obj);
U entity = new U();
entity = mapper.Map <T, U>(obj, () => entity);
var tbl = db.Set <U>();
if (!tbl.Local.Contains(entity))
{
db.Entry <U>(entity).State = EntityState.Modified;
}
else
{
db.Entry <U>(entity).CurrentValues.SetValues(entity);
}
int ret = db.SaveChanges();
if (ret > 0)
{
this.HandleEvent(updatedHandler, DataOperation.Update, obj, obj);
this.HandleEvents(events, es => es.UpdatedHandler, DataOperation.Update, obj, obj);
}
return(ret > 0);
}
private void On_SocketDeath()
{
if (gameObject != null)
{
EntityEventHandler entityHandler = GetComponent <EntityEventHandler>();
entityHandler.ChangeHealth.Try(new HealthEventData(-Mathf.Infinity));
}
}
protected void SubscribeNetworkEvent <T>(EntityEventHandler <T> handler)
where T : notnull
{
EntityManager.EventBus.SubscribeEvent(EventSource.Network, this, handler);
_subscriptions ??= new();
_subscriptions.Add(new SubBroadcast <T>(EventSource.Network));
}
// Intended for helper methods, so minimal API.
public void SubEvent <T>(
EventSource src,
EntityEventHandler <T> handler,
Type[]?before = null, Type[]?after = null)
where T : notnull
{
System.SubEvent(src, handler, before, after);
}
public void RegisterEvent(int eventID, EntityEventHandler handler)
{
if (!eventHandlerDic.TryGetValue(eventID, out var handlers))
{
handlers = new List <EntityEventHandler>();
eventHandlerDic.Add(eventID, handlers);
}
handlers.Add(handler);
}
/// <summary>
/// Wraps the EntityEvent invocation inside a protected virtual method to let derived classes override it.
/// This method guards against the possibility of a race condition if the last subscriber unsubscribes immediately
/// after the null check and before the event is raised. So please don't simplify the invocation even if Visual Studio
/// tells you to.
/// </summary>
/// <param name="e">Event arguments</param>
protected virtual void OnEntityEvent(EntityEventArgs e)
{
EntityEventHandler handler = EntityEvent;
// Event will be null if there are no subscribers
if (handler != null)
{
// Use the () operator to raise the event.
handler(this, e);
}
}
private void SubEvent <T>(
EventSource src,
EntityEventHandler <T> handler,
Type[]?before, Type[]?after)
where T : notnull
{
EntityManager.EventBus.SubscribeEvent(src, this, handler, GetType(), before, after);
_subscriptions ??= new();
_subscriptions.Add(new SubBroadcast <T>(src));
}
public virtual bool Insert(T obj, EntityEventHandler <T> insertingHandler = null, EntityEventHandler <T> insertedHandler = null)
{
obj = this.HandleEvents(events, es => es.InsertingHandler, DataOperation.Insert, null, obj);
obj = this.HandleEvent(insertingHandler, DataOperation.Insert, null, obj);
int ret = db.Insert <T>(obj);
if (ret > 0)
{
this.HandleEvent(insertedHandler, DataOperation.Insert, null, obj);
this.HandleEvents(events, es => es.InsertedHandler, DataOperation.Insert, null, obj);
}
return(ret > 0);
}
public virtual bool Delete(T obj, EntityEventHandler <T> deletingHandler = null, EntityEventHandler <T> deletedHandler = null)
{
obj = this.HandleEvents(events, es => es.DeletingHandler, DataOperation.Delete, obj, null);
obj = this.HandleEvent(deletingHandler, DataOperation.Delete, obj, null);
var ret = repository.Remove(GetKeyQuery(obj));
if (ret.DocumentsAffected > 0)
{
this.HandleEvent(deletedHandler, DataOperation.Delete, obj, null);
this.HandleEvents(events, es => es.DeletedHandler, DataOperation.Delete, obj, null);
}
return(ret.DocumentsAffected > 0);
}
public virtual bool Delete(T obj, EntityEventHandler <T> deletingHandler = null, EntityEventHandler <T> deletedHandler = null)
{
obj = this.HandleEvents(events, es => es.DeletingHandler, DataOperation.Delete, obj, null);
obj = this.HandleEvent(deletingHandler, DataOperation.Delete, obj, null);
int ret = db.Delete <T>(obj);
if (ret > 0)
{
this.HandleEvent(deletedHandler, DataOperation.Delete, obj, null);
this.HandleEvents(events, es => es.DeletedHandler, DataOperation.Delete, obj, null);
}
return(ret > 0);
}
public virtual bool Insert(T obj, EntityEventHandler <T> insertingHandler = null, EntityEventHandler <T> insertedHandler = null)
{
obj = this.HandleEvents(events, es => es.InsertingHandler, DataOperation.Insert, null, obj);
obj = this.HandleEvent(insertingHandler, DataOperation.Insert, null, obj);
var ret = repository.Insert <T>(obj);
if (ret.DocumentsAffected > 0)
{
this.HandleEvent(insertedHandler, DataOperation.Insert, null, obj);
this.HandleEvents(events, es => es.InsertedHandler, DataOperation.Insert, null, obj);
}
return(ret.DocumentsAffected > 0);
}
public static T HandleEvent <T>(this IRepository <T> repository, EntityEventHandler <T> handler, DataOperation action, T original, T obj)
where T : class
{
if (handler == null)
{
return(obj == null ? original : obj);
}
var args = new EntityEventArgs <T>()
{
Action = action, OriginalEntity = original, Entity = obj, Repository = repository
};
handler(args);
return(args.Entity);
}
public virtual bool Update(T obj, EntityEventHandler <T> updatingHandler = null, EntityEventHandler <T> updatedHandler = null)
{
obj = this.HandleEvents(events, es => es.UpdatingHandler, DataOperation.Update, obj, obj);
obj = this.HandleEvent(updatingHandler, DataOperation.Update, obj, obj);
var ret = repository.Save(obj);
if (ret.DocumentsAffected > 0)
{
this.HandleEvent(updatedHandler, DataOperation.Update, obj, obj);
this.HandleEvents(events, es => es.UpdatedHandler, DataOperation.Update, obj, obj);
}
return(ret.DocumentsAffected > 0);
}
public virtual bool Insert(T obj, EntityEventHandler <T> insertingHandler = null, EntityEventHandler <T> insertedHandler = null)
{
U entity = new U();
entity = mapper.Map <T, U>(obj, () => entity);
obj = this.HandleEvents(events, es => es.InsertingHandler, DataOperation.Insert, null, obj);
obj = this.HandleEvent(insertingHandler, DataOperation.Insert, null, obj);
int ret = db.Insert <U>(entity);
if (ret > 0)
{
this.HandleEvent(insertedHandler, DataOperation.Insert, null, obj);
this.HandleEvents(events, es => es.InsertedHandler, DataOperation.Insert, null, obj);
}
return(ret > 0);
}
public virtual bool Update(T obj, EntityEventHandler <T> updatingHandler = null, EntityEventHandler <T> updatedHandler = null)
{
U entity = new U();
entity = mapper.Map <T, U>(obj, () => entity);
obj = this.HandleEvents(events, es => es.UpdatingHandler, DataOperation.Update, obj, obj);
obj = this.HandleEvent(updatingHandler, DataOperation.Update, obj, obj);
int ret = db.Update <U>(entity);
if (ret > 0)
{
this.HandleEvent(updatedHandler, DataOperation.Update, obj, obj);
this.HandleEvents(events, es => es.UpdatedHandler, DataOperation.Update, obj, obj);
}
return(ret > 0);
}
private bool _longHitReady; // tells whether LongHitStart has ended and animation should proceed
private void Awake()
{
_chars = this.gameObject.GetComponent <EntityCharacteristics>();
_eventHandler = this.gameObject.GetComponent <EntityEventHandler>();
_movementController = this.gameObject.GetComponent <PlayerMovement>();
_animationController = this.gameObject.GetComponent <PlayerAnimation>();
_combatController = this.gameObject.GetComponent <EntityCombat>();
_UI = this.gameObject.GetComponent <PlayerUI>();
_isAllowedToMove = true;
_longHitLastFrame = false;
_longHitReady = false;
FindAllWeaponManagers();
_activeWeaponIndex = 0;
DisableActiveHitManager("Awake");
}
public static bool SaveAll <T>(this IRepository <T> repository, ITransactionManager trans, IEnumerable <T> original, IEnumerable <T> current, Func <T, T, bool> exists
, bool deleteIfNoFound = true, bool notUpdateIfFound = false
, EntityEventHandler <T> insertingHandler = null, EntityEventHandler <T> insertedHandler = null
, EntityEventHandler <T> updatingHandler = null, EntityEventHandler <T> updatedHandler = null
, EntityEventHandler <T> deletingHandler = null, EntityEventHandler <T> deletedHandler = null)
where T : class
{
if (deleteIfNoFound)
{
if (notUpdateIfFound)
{
return(SaveAll(repository, trans, original, current, exists,
(repo, o) => { repo.Insert(o, insertingHandler, insertedHandler); },
null,
(repo, o) => { repo.Delete(o, deletingHandler, deletedHandler); }));
}
else
{
return(SaveAll(repository, trans, original, current, exists,
(repo, o) => { repo.Insert(o, insertingHandler, insertedHandler); },
(repo, o, c) => { repo.Update(c, updatingHandler, updatedHandler); },
(repo, o) => { repo.Delete(o, deletingHandler, deletedHandler); }));
}
}
else
{
if (notUpdateIfFound)
{
return(SaveAll(repository, trans, original, current, exists,
(repo, o) => { repo.Insert(o, insertingHandler, insertedHandler); },
null,
null));
}
else
{
return(SaveAll(repository, trans, original, current, exists,
(repo, o) => { repo.Insert(o, insertingHandler, insertedHandler); },
(repo, o, c) => { repo.Update(c, updatingHandler, updatedHandler); },
null));
}
}
}
public static bool SaveAll <T>(this IRepository <T> repository, ITransactionManager trans, IEnumerable <T> newItems, IEnumerable <T> modifiedItems, IEnumerable <T> deletedItems
, EntityEventHandler <T> insertingHandler = null, EntityEventHandler <T> insertedHandler = null
, EntityEventHandler <T> updatingHandler = null, EntityEventHandler <T> updatedHandler = null
, EntityEventHandler <T> deletingHandler = null, EntityEventHandler <T> deletedHandler = null)
where T : class
{
try
{
trans.BeginTransaction();
newItems.ForEach(o => repository.Insert(o, insertingHandler, insertedHandler));
modifiedItems.ForEach(o => repository.Update(o, updatingHandler, updatedHandler));
deletedItems.ForEach(o => repository.Delete(o, deletingHandler, deletedHandler));
trans.Commit();
return(true);
}
catch (Exception ex)
{
trans.Rollback();
throw ex;
}
}
public void UnregisterEvent(int eventID, EntityEventHandler handler)
{
if (eventHandlerDic.TryGetValue(eventID, out var handlers))
{
for (int i = 0; i < handlers.Count;)
{
if (handlers[i] == null || handlers[i] == handler)
{
handlers.RemoveAt(i);
}
else
{
++i;
}
}
if (handlers.Count == 0)
{
eventHandlerDic.Remove(eventID);
}
}
}
public Entity()
{
OnInit();
if (EntityConfig.Difference)
{
if (null != Difference.Handler)
{
var follow = EntityCache.__Collected
? __Table.Follow
: this.GetType().GetAttribute <DiffFollow>();
if (null != follow)
{
BeforeModify += new EntityEventHandler(DiffBeforeModify);
BeforeRemove += new EntityEventHandler(DiffBeforeRemove);
AfterAdd += new EntityEventHandler(DiffAfterAdd);
AfterModify += new EntityEventHandler(DiffAfterModify);
AfterRemove += new EntityEventHandler(DiffAfterRemove);
}
}
}
}
public virtual void Initialise()
{
OnCreate = new EntityEventHandler(Event_OnCreate);
OnDestroy = new EntityEventHandler(Event_OnDestroy);
}
protected void SubscribeLocalEvent <T>(EntityEventHandler <T> handler)
where T : EntitySystemMessage
{
EntityManager.EventBus.SubscribeEvent(EventSource.Local, this, handler);
}
public RegisteredEvents(MyStringHash eventType, MyComponentBase component, EntityEventHandler handler)
{
this[eventType] = new List <RegisteredComponent>();
this[eventType].Add(new RegisteredComponent(component, handler));
}
//Convenience thing.
public void SubscribeEvent <T>(EntityEventHandler <EntityEventArgs> evh, IEntityEventSubscriber s) where T : EntityEventArgs
{
EntityManager.SubscribeEvent <T>(evh, s);
}
/// <summary>
/// This will register the component to listen to some events on entity that is other than entity containing this component
/// </summary>
/// <param name="entity">Entity on which we listen to events</param>
/// <param name="component">Component that is being registered</param>
/// <param name="eventType">type of event</param>
/// <param name="handler">handler to be called</param>
public static void RegisterForEntityEvent(this MyEntityComponentBase component, MyEntity entity, MyStringHash eventType, EntityEventHandler handler)
{
if (ProcessingEvents)
{
AddPostponedRegistration(component, entity, eventType, handler);
return;
}
if (component.Entity == entity)
{
RegisterForEntityEvent(component, eventType, handler);
return;
}
if (entity == null)
{
System.Diagnostics.Debug.Fail("You can't register this component for events, when you don't know on which entity it should be listening to..");
return;
}
component.BeforeRemovedFromContainer += RegisteredComponentBeforeRemovedFromContainer;
entity.OnClose += RegisteredEntityOnClose;
if (RegisteredListeners.ContainsKey(entity.EntityId))
{
var registeredForEntity = RegisteredListeners[entity.EntityId];
if (registeredForEntity.ContainsKey(eventType))
{
var entry = registeredForEntity[eventType].Find(x => x.Handler == handler);
if (entry == null)
{
registeredForEntity[eventType].Add(new RegisteredComponent(component, handler));
}
}
else
{
registeredForEntity[eventType] = new List <RegisteredComponent>();
registeredForEntity[eventType].Add(new RegisteredComponent(component, handler));
}
}
else
{
RegisteredListeners[entity.EntityId] = new RegisteredEvents(eventType, component, handler);
}
if (ExternalListeners.ContainsKey(component) && !ExternalListeners[component].Contains(entity.EntityId))
{
ExternalListeners[component].Add(entity.EntityId);
}
else
{
ExternalListeners[component] = new List <long>()
{
entity.EntityId
};
}
ExternalyListenedEntities.Add(entity.EntityId);
}
private static void AddPostponedRegistration(MyEntityComponentBase component, MyEntity entity, MyStringHash eventType, EntityEventHandler handler)
{
PostponedRegistration.Add(new Tuple <MyEntityComponentBase, MyEntity, MyStringHash, EntityEventHandler>(component, entity, eventType, handler));
HasPostponedOperations = true;
}
// Constructors
protected EntityComponent()
{
EntityChangedHandler = new EntityEventHandler(EntityChangedListener);
}
protected void SubscribeEvent <T>(EntityEventHandler <T> evh)
where T : EntitySystemMessage
{
EntityManager.SubscribeEvent <T>(evh, this);
}
void Awake()
{
eventHandler = GetComponent <EntityEventHandler>();
}
