DataCenter(
IEntityManager someEntityManager,
IDataProcessorManager someDataProcessorManager,
IDataCore someDataCore)
{
// someEntityManager
if (someEntityManager == null)
{
throw new ArgumentNullException("someEntityManager");
}
this.entityManager = someEntityManager;
this.entityManager.OnAttach(this);
// someDataProcessorManager
if (someDataProcessorManager == null)
{
throw new ArgumentNullException("someDataProcessorManager");
}
this.dataProcessorManager = someDataProcessorManager;
this.dataProcessorManager.OnAttach(this);
// someDataCore
if (someDataCore == null)
{
throw new ArgumentNullException("someDataCore");
}
dataCore = someDataCore;
deltaTime = 0.0;
}
void FreeID(ulong someId)
{
IDataCore core = this.dataCenter.DataCore;
core.StatusEntityIDListTable[true].Remove(someId);
core.StatusEntityIDListTable[false].Add(someId);
}
void RemoveDataFromEntity <TData>(ulong someEntityId)
where TData : IData
{
IDataCore core = this.dataCenter.DataCore;
Type dataType = typeof(TData);
if (!core.DataTypeEntityIDListTable.ContainsKey(dataType))
{
throw new ArgumentException(
"Entity is not holding data of given type"
);
}
core.DataTypeEntityIDListTable[dataType].Remove(someEntityId);
// fetch data then remove it
IData removedData = core.EntityIDDataTable[someEntityId][dataType];
core.EntityIDDataTable[someEntityId].Remove(dataType);
// Fire data removed event
if (this.DataRemoved != null)
{
this.DataRemoved(
this,
new EntityDataEventArgs(someEntityId, removedData));
}
}
void SetTagForEntity(ulong someEntityId, string someTag)
{
if (!this.ContainsEntity(someEntityId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
if (someTag == null)
{
throw new ArgumentNullException("someTag");
}
IDataCore core = this.dataCenter.DataCore;
string previousTag = core.EntityIDTagTable[someEntityId];
core.EntityTagEntityIDListTable[previousTag].Remove(someEntityId);
//create tag -> entity relation
if (!core.EntityTagEntityIDListTable.ContainsKey(someTag))
{
core.EntityTagEntityIDListTable.Add(
someTag,
new List <ulong>()
);
}
core.EntityTagEntityIDListTable[someTag].Add(someEntityId);
core.EntityIDTagTable[someEntityId] = someTag;
}
void RemoveEntity(ulong someId)
{
if (!this.ContainsEntity(someId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
IDataCore core = this.dataCenter.DataCore;
string tag = core.EntityIDTagTable[someId];
List <IData> entityData = this.GetAllDataFromEntity(someId);
core.EntityTagEntityIDListTable[tag].Remove(someId);
core.EntityIDTagTable.Remove(someId);
foreach (IData data in entityData)
{
Type t = data.GetType();
core.DataTypeEntityIDListTable[t].Remove(someId);
}
core.EntityIDDataTable.Remove(someId);
this.FreeID(someId);
// Fire entity created event
if (this.EntityRemoved != null)
{
this.EntityRemoved(this, new EntityEventArgs(someId));
}
}
List <ulong> GetEntitiesWithTag(string someTag)
{
IDataCore core = this.dataCenter.DataCore;
if (!core.EntityTagEntityIDListTable.ContainsKey(someTag))
{
return(new List <ulong>());
}
return(core.EntityTagEntityIDListTable[someTag]);
}
void CreateNewID()
{
IDataCore core = this.dataCenter.DataCore;
if (core.EntityIDCounter == ulong.MaxValue)
{
throw new ArithmeticException(
"Can not create new entity. ulong limit reached!"
);
}
core.StatusEntityIDListTable[false].Add(++core.EntityIDCounter);
}
string GetTagForEntity(ulong someEntityId)
{
if (!this.ContainsEntity(someEntityId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
IDataCore core = this.dataCenter.DataCore;
return(core.EntityIDTagTable[someEntityId]);
}
ulong PopNextID()
{
ulong id = 0;
int lastIndex = 0;
IDataCore core = this.dataCenter.DataCore;
lastIndex = core.StatusEntityIDListTable[false].Count - 1;
id = core.StatusEntityIDListTable[false][lastIndex];
core.StatusEntityIDListTable[false].RemoveAt(lastIndex);
core.StatusEntityIDListTable[true].Add(id);
return(id);
}
bool HasEntityData <TData>(ulong someEntityId)
where TData : IData
{
if (!this.ContainsEntity(someEntityId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
IDataCore core = this.dataCenter.DataCore;
Type dataType = typeof(TData);
return(core.EntityIDDataTable[someEntityId].ContainsKey(dataType));
}
List <ulong> GetEntitiesWithData(List <Type> someDataTypeList)
{
if (someDataTypeList == null)
{
throw new ArgumentNullException("someDataTypeList");
}
IDataCore core =
this.dataCenter.DataCore;
Dictionary <Type, List <ulong> > canditates =
new Dictionary <Type, List <ulong> >();
List <ulong> entities =
new List <ulong>();
if (someDataTypeList.Count == 0)
{
return(entities);
}
IEnumerable <ulong> intersectionList = null;
foreach (Type dataType in someDataTypeList)
{
if (!core.DataTypeEntityIDListTable.ContainsKey(dataType))
{
entities.Clear();
break;
}
if (intersectionList == null)
{
intersectionList = core.DataTypeEntityIDListTable[dataType];
}
intersectionList =
intersectionList.Intersect(
core.DataTypeEntityIDListTable[dataType]);
}
if (intersectionList != null)
{
entities.AddRange(intersectionList);
}
return(entities);
}
public DtoInterceptor(Type dtoType, IDataCore dataCore, NotifyPropertyChanged npc)
{
if (dataCore == null)
{
throw new ArgumentNullException(nameof(dataCore), $"{nameof( dataCore )} must not be null");
}
if (dtoType == null)
{
throw new ArgumentNullException(nameof(dtoType), $"{nameof( dtoType )} must not be null");
}
_dataCore = dataCore;
DtoType = dtoType;
_npc = npc;
Init( );
}
void AddDataToEntity(ulong someEntityId, IData someData)
{
if (!this.ContainsEntity(someEntityId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
if (someData == null)
{
throw new ArgumentNullException("someData");
}
IDataCore core = this.dataCenter.DataCore;
Type dataType = someData.GetType();
if (core.EntityIDDataTable[someEntityId].ContainsKey(dataType))
{
throw new EntityAlreadyHoldsDataException(someEntityId, dataType);
}
core.EntityIDDataTable[someEntityId].Add(
dataType,
someData
);
if (!core.DataTypeEntityIDListTable.ContainsKey(dataType))
{
core.DataTypeEntityIDListTable.Add(
dataType,
new List <ulong>()
);
}
core.DataTypeEntityIDListTable[dataType].Add(someEntityId);
// Fire data added event
if (this.DataAdded != null)
{
this.DataAdded(
this,
new EntityDataEventArgs(someEntityId, someData));
}
}
List <ulong> GetEntitiesWithData <TData>()
where TData : IData
{
IDataCore core = this.dataCenter.DataCore;
Type dataType = typeof(TData);
List <ulong> entities;
if (!core.DataTypeEntityIDListTable.ContainsKey(dataType))
{
entities = new List <ulong>();
}
else
{
entities = core.DataTypeEntityIDListTable[dataType];
}
return(entities);
}
TData GetDataFromEntity <TData>(ulong someEntityId)
where TData : IData
{
if (!this.ContainsEntity(someEntityId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
IDataCore core = this.dataCenter.DataCore;
Type dataType = typeof(TData);
if (!core.EntityIDDataTable[someEntityId].ContainsKey(dataType))
{
throw new EntityDoesNotHoldDataException(someEntityId, dataType);
}
return((TData)core.EntityIDDataTable[someEntityId][dataType]);
}
List <IData> GetAllDataFromEntity(ulong someEntityId)
{
if (!this.ContainsEntity(someEntityId))
{
throw new ArgumentException(
"No entity with given id registered!"
);
}
IDataCore core = this.dataCenter.DataCore;
List <IData> entityDataList = new List <IData>();
foreach (Dictionary <Type, IData> dict in core.EntityIDDataTable.Values)
{
foreach (IData data in dict.Values)
{
entityDataList.Add(data);
}
}
return(entityDataList);
}
