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)); }