private void CreateUniformSpread(IEntityFactory factory, int count)
{
for (int i = 0; i < count; i++)
{
int x = Random.Range(0, MapProvider.MapCellularWidth);
int y = Random.Range(0, MapProvider.MapCellularHeight);
Vector2 position = MapProvider.TranslateToReal(new Vector2Int(x, y));
IEntity food = factory.CreateEntity(GameManager, position);
}
}
public void Handle(IList <IObjectFuture> objectFutures)
{
IEntityFactory entityFactory = EntityFactory;
IList <IObjRef> oris = new List <IObjRef>(objectFutures.Count);
// ObjectFutures have to be handled in order
for (int i = 0, size = objectFutures.Count; i < size; i++)
{
IObjectFuture objectFuture = objectFutures[i];
if (!(objectFuture is ObjRefFuture))
{
throw new ArgumentException("'" + GetType().Name + "' cannot handle " + typeof(IObjectFuture).Name
+ " implementations of type '" + objectFuture.GetType().Name + "'");
}
if (objectFuture.Value != null)
{
continue;
}
ObjRefFuture objRefFuture = (ObjRefFuture)objectFuture;
IObjRef ori = objRefFuture.Ori;
if (ori.Id != null && !Object.Equals(ori.Id, 0))
{
oris.Add(ori);
}
else if (ori is IDirectObjRef && ((IDirectObjRef)ori).Direct != null)
{
Object entity = ((IDirectObjRef)ori).Direct;
objRefFuture.Value = entity;
oris.Add(null);
}
else
{
Object newEntity = entityFactory.CreateEntity(ori.RealType);
objRefFuture.Value = newEntity;
oris.Add(null);
}
}
IList <Object> objects = Cache.GetObjects(oris, CacheDirective.ReturnMisses);
for (int i = 0, size = objectFutures.Count; i < size; i++)
{
if (oris[i] == null)
{
continue;
}
ObjRefFuture objRefFuture = (ObjRefFuture)objectFutures[i];
Object obj = objects[i];
objRefFuture.Value = obj;
}
}
public static Entity LocateOrCreate <Entity>(string key, string typeString, Type entityFactoryType, bool isLocatorEnabled) where Entity : class, IEntity, new()
{
if (string.IsNullOrEmpty(typeString))
{
throw new ArgumentException("typeString");
}
if (entityFactoryType == null)
{
throw new ArgumentException("entityFactoryType");
}
Entity entity = default(Entity);
Type defaultType = typeof(Entity);
if (defaultType.GetInterface("IEntityCacheItem") != null)
{
entity = EntityCache.GetItem <Entity>(key.ToString());
}
if (entity == null)
{
IEntityFactory factory = null;
if (EntityFactories.ContainsKey(entityFactoryType.FullName))
{
factory = EntityFactories[entityFactoryType.FullName];
}
else
{
factory = TryAddEntityFactory(entityFactoryType);
}
if (((key != null) && isLocatorEnabled) && EntityLocator.Contains(key))
{
entity = EntityLocator.Get(key) as Entity;
}
if (entity == null)
{
entity = factory.CreateEntity(typeString, defaultType) as Entity;
}
if (!entity.IsEntityTracked)
{
StartTracking(key, entity, isLocatorEnabled);
}
if (entity.GetType().GetInterface("IEntityCacheItem") != null)
{
EntityCache.AddCache(key, entity);
}
}
return(entity);
}
/// <summary>
/// Locates an entity for retrieval from the <see cref="Locator"/>, or instatiates a new instance
/// of the entity if not currently being tracked.
/// </summary>
/// <typeparam name="Entity">Must implement <see cref="IEntity"/> and is the default type to create, and will be the return type.</typeparam>
/// <param name="key">primary key representation</param>
/// <param name="typeString">type string to create</param>
/// <param name="entityFactoryType">factory used to try to create this entity.</param>
/// <param name="isLocatorEnabled">bool determining whether to use Entity Locating.</param>
/// <returns>Created entity of T</returns>
public static Entity LocateOrCreate <Entity>(string key, string typeString, Type entityFactoryType, bool isLocatorEnabled) where Entity : class, IEntity, new()
{
#region Validation
if (string.IsNullOrEmpty(typeString))
{
throw new ArgumentException("typeString");
}
if (entityFactoryType == null)
{
throw new ArgumentException("entityFactoryType");
}
#endregion
Entity entity = default(Entity);
lock (syncObject) //This is here because most of the classes in ObjectBuilder are NOT thread-safe
{
//Generated Table Entities Type
Type defaultType = typeof(Entity);
bool isCacheable = defaultType.GetInterface("IEntityCacheItem") != null;
//see if entity is cachable, if IEntityCacheItem
//retrieve from cache.
if (isCacheable)
{
entity = EntityCache.GetItem <Entity>(key.ToString());
}
if (entity != null)
{
return(entity);
}
IEntityFactory factory = null;
lock (syncObject)
{
if (EntityFactories.ContainsKey(entityFactoryType.FullName))
{
factory = EntityFactories[entityFactoryType.FullName];
}
else
{
factory = TryAddEntityFactory(entityFactoryType);
}
}
//attempt to locate
if (key != null && isLocatorEnabled)
{
lock (syncObject)
{
if (EntityLocator.Contains(key))
{
entity = EntityLocator.Get(key) as Entity;
}
}
}
//if not found try create from factory
if (entity == null)
{
entity = factory.CreateEntity(typeString, defaultType) as Entity;
}
//add to locator and start tracking.
if (!entity.IsEntityTracked)
{
StartTracking(key, entity, isLocatorEnabled);
}
//add entity to Cache if IEntityCacheItem
if (entity.GetType().GetInterface("IEntityCacheItem") != null)
{
EntityCache.AddCache(key, entity);
}
}
return(entity);
}
private void Transfer(MudAction action)
{
/* entity to entity
* entity to room
* room to entity
*/
//types of entities involved
var e2e = _entities.ContainsKey(action.SenderId) && _entities.ContainsKey(action.ReceiverId);
var e2r = _entities.ContainsKey(action.SenderId) && _rooms.ContainsKey(action.ReceiverId);
var r2e = _rooms.ContainsKey(action.SenderId) && _entities.ContainsKey(action.ReceiverId);
var requestor = r2e ? _rooms[action.SenderId] : _entities[action.SenderId];
var receiver = e2r ? _rooms[action.ReceiverId] : _entities[action.ReceiverId];
var subject = _entities[action.OtherEntity1];
var zone = _zones[GetRoomWithEntity(subject.Id).Zone];
var isItem = subject.Components.Has("item");
var requestedQty = 1;
int.TryParse(action.Args[0], out requestedQty);
if (isItem && requestedQty > 1 && (e2e || e2r))
{
if (requestedQty > int.Parse(subject.Traits.Get("quantity").Value))
{
DoAction(new MudAction("infotoplayer", 0, requestor.Id, "There aren't that many to pick up."));
return;
}
}
//permission
var canTake = new MudAction("cantake", requestor.Id, receiver.Id, subject.Id, action.Args);
if (!subject.DoAction(canTake) || !receiver.DoAction(canTake) || !zone.DoAction(canTake) || !requestor.DoAction(canTake))
{
return;
}
//physical movement
var newEntityId = 0;
MudEntity newEntity;
if (isItem && requestedQty > 1 && requestedQty != int.Parse(subject.Traits.Get("quantity").Value))
{
newEntity = _entityFactory.CreateEntity(subject.Name, (subject.Traits.GetAll().ToDictionary(x => x.Name, x => x.Value)));
_entities.Add(newEntity.Id, newEntity);
newEntityId = newEntity.Id;
newEntity.Traits.Set("quantity", requestedQty.ToString());
var comps = subject.Components.GetAll();
foreach (var c in comps)
{
ComponentManager.Instance.AssignComponent(newEntity, c.Name);
}
}
else
{
if (r2e)
{
_rooms[requestor.Id].Entities.Remove(subject.Id);
}
else if (e2r)
{
var inventory = GetEntitiesFromTrait(requestor, "items").ToList();
inventory.Remove(subject);
requestor.Traits.Set("items", string.Join(",", inventory.Select(x => x.Id.ToString())));
_rooms[receiver.Id].Entities.Add(subject.Id);
}
newEntityId = subject.Id;
newEntity = subject;
}
if (r2e)
{
//is subject an item?
if (newEntity.Components.Has("item"))
{
if (receiver.Traits.Has("items"))
{
var itemsString = receiver.Traits.Get("items").Value;
var itemIds = itemsString.Split(',').Select(x => int.Parse(x)).ToList();
itemIds.Add(subject.Id);
receiver.Traits.Set("items", string.Join(",", itemIds.Select(x => x.ToString())));
}
else
{
receiver.Traits.Add("items", newEntityId.ToString());
}
}
}
else if (e2r)
{
}
//notifications
var transType = "";
if (e2e)
{
transType = "e2e";
}
else if (e2r)
{
transType = "e2r";
}
else
{
transType = "r2e";
}
var receivedEntity = new MudAction("receivedentity", requestor.Id, receiver.Id, newEntity.Id, transType,
newEntity.Traits.Has("quantity") ? newEntity.Traits.Get("quantity").Value : null);
var room = r2e ? _rooms[requestor.Id] : GetRoomWithEntity(requestor.Id);
ActionRoomMobs(receivedEntity, room.Id);
ActionRoomItems(receivedEntity, room.Id);
//TODO: CLEANUP ITEMS
if (!isItem || !newEntity.Traits.Has("isStackable"))
{
return;
}
var entityItems = GetEntitiesFromTrait(receiver, "items").ToList();
var existingItems = entityItems.Where(x => x.Name == newEntity.Name).ToList();
if (existingItems.Count <= 1)
{
return;
}
var totalQty = existingItems.Sum(x => int.Parse(x.Traits.Get("quantity").Value));
newEntity.Traits.Set("quantity", totalQty.ToString());
var oldItem = existingItems.Single(x => x.Id != newEntity.Id);
entityItems.Remove(oldItem);
_entities.Remove(oldItem.Id);
receiver.Traits.Set("items", string.Join(",", entityItems.Select(x => x.Id.ToString())));
}
protected ICUDResult ApplyIntern(ICUDResult cudResult, bool checkBaseState, IncrementalMergeState incrementalState)
{
ICache stateCache = incrementalState.GetStateCache();
IList <IChangeContainer> allChanges = cudResult.AllChanges;
IList <Object> originalRefs = cudResult.GetOriginalRefs();
IList <Object> allObjects = GetAllExistingObjectsFromCache(stateCache, allChanges);
List <Object> hardRefs = new List <Object>();
hardRefs.Add(allObjects); // add list as item intended. adding each item of the source is NOT needed
List <IObjRef> toFetchFromCache = new List <IObjRef>();
List <DirectValueHolderRef> toPrefetch = new List <DirectValueHolderRef>();
List <IBackgroundWorkerDelegate> runnables = new List <IBackgroundWorkerDelegate>();
IEntityFactory entityFactory = this.EntityFactory;
IdentityHashMap <IObjRef, StateEntry> newObjRefToStateEntryMap = new IdentityHashMap <IObjRef, StateEntry>();
IdentityHashMap <IChangeContainer, IChangeContainer> alreadyClonedMap = new IdentityHashMap <IChangeContainer, IChangeContainer>();
List <IChangeContainer> newAllChanges = new List <IChangeContainer>(allChanges.Count);
for (int a = 0, size = allChanges.Count; a < size; a++)
{
IChangeContainer changeContainer = allChanges[a];
Object originalEntity = originalRefs[a];
StateEntry stateEntry = incrementalState.entityToStateMap.Get(originalEntity);
IChangeContainer newChangeContainer;
if (changeContainer is CreateContainer)
{
newChangeContainer = new CreateContainer();
}
else if (changeContainer is UpdateContainer)
{
newChangeContainer = new UpdateContainer();
}
else
{
newChangeContainer = new DeleteContainer();
}
newAllChanges.Add(newChangeContainer);
alreadyClonedMap.Put(changeContainer, newChangeContainer);
if (!(changeContainer is CreateContainer))
{
Object stateCacheEntity2 = allObjects[a];
stateEntry = incrementalState.entityToStateMap.Get(stateCacheEntity2);
if (stateEntry == null)
{
stateEntry = new StateEntry(stateCacheEntity2, changeContainer.Reference, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity2, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
}
// delete & update do not need further handling
continue;
}
Type realType = changeContainer.Reference.RealType;
Object stateCacheEntity;
if (stateEntry == null)
{
stateCacheEntity = entityFactory.CreateEntity(realType);
DirectObjRef directObjRef = new DirectObjRef(realType, stateCacheEntity);
directObjRef.CreateContainerIndex = a;
stateEntry = new StateEntry(stateCacheEntity, directObjRef, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
newObjRefToStateEntryMap.Put(changeContainer.Reference, stateEntry);
}
else
{
stateCacheEntity = stateEntry.entity;
}
allObjects[a] = stateCacheEntity;
}
cloneStateTL.Value = new CloneState(newObjRefToStateEntryMap, incrementalState);
try
{
for (int a = allChanges.Count; a-- > 0;)
{
IChangeContainer changeContainer = allChanges[a];
IObjRefContainer entity = (IObjRefContainer)allObjects[a];
changeContainer = FillClonedChangeContainer(changeContainer, alreadyClonedMap);
IPrimitiveUpdateItem[] puis;
IRelationUpdateItem[] ruis;
if (changeContainer is CreateContainer)
{
CreateContainer createContainer = (CreateContainer)changeContainer;
puis = createContainer.Primitives;
ruis = createContainer.Relations;
}
else if (changeContainer is UpdateContainer)
{
UpdateContainer updateContainer = (UpdateContainer)changeContainer;
puis = updateContainer.Primitives;
ruis = updateContainer.Relations;
}
else
{
((IDataObject)entity).ToBeDeleted = true;
continue;
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)entity).Get__EntityMetaData();
ApplyPrimitiveUpdateItems(entity, puis, metaData);
if (ruis != null)
{
bool isUpdate = changeContainer is UpdateContainer;
foreach (IRelationUpdateItem rui in ruis)
{
ApplyRelationUpdateItem(entity, rui, isUpdate, metaData, toPrefetch, toFetchFromCache, checkBaseState, runnables);
}
}
}
while (toPrefetch.Count > 0 || toFetchFromCache.Count > 0 || runnables.Count > 0)
{
if (toPrefetch.Count > 0)
{
PrefetchHelper.Prefetch(toPrefetch);
toPrefetch.Clear();
}
if (toFetchFromCache.Count > 0)
{
IList <Object> fetchedObjects = stateCache.GetObjects(toFetchFromCache, CacheDirective.None);
hardRefs.Add(fetchedObjects); // add list as item intended. adding each item of the source is NOT needed
toFetchFromCache.Clear();
}
IBackgroundWorkerDelegate[] runnableArray = runnables.ToArray();
runnables.Clear();
foreach (IBackgroundWorkerDelegate runnable in runnableArray)
{
runnable();
}
}
List <Object> newObjects = new List <Object>(allObjects.Count);
List <DirectValueHolderRef> changedRelationRefs = new List <DirectValueHolderRef>();
for (int a = allObjects.Count; a-- > 0;)
{
IChangeContainer newChange = newAllChanges[a];
IRelationUpdateItem[] ruis = null;
Object entity = allObjects[a];
if (newChange is CreateContainer)
{
newObjects.Add(entity);
ruis = ((CreateContainer)newChange).Relations;
}
else if (newChange is UpdateContainer)
{
ruis = ((UpdateContainer)newChange).Relations;
}
if (ruis == null)
{
continue;
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entity.GetType());
foreach (IRelationUpdateItem rui in ruis)
{
Member member = metaData.GetMemberByName(rui.MemberName);
changedRelationRefs.Add(new DirectValueHolderRef((IObjRefContainer)entity, (RelationMember)member));
}
}
if (newObjects.Count > 0)
{
((IWritableCache)stateCache).Put(newObjects);
}
if (changedRelationRefs.Count > 0)
{
PrefetchHelper.Prefetch(changedRelationRefs);
}
return(new CUDResult(newAllChanges, allObjects));
}
finally
{
cloneStateTL.Value = null;
}
}
public Object NewInstance()
{
return(entityFactory.CreateEntity(this));
}
