public IReadOnlyList <Entity> GetEntities()
{
List <Entity> list = _EntityDic.Values.ToList();
list.Sort((x, y) =>
{
EntityPrefab entity_x = Prefabs.GetEntity(x.Type);
EntityPrefab entity_y = Prefabs.GetEntity(y.Type);
if (entity_x.priority > entity_y.priority)
{
return(-1);
}
else if (entity_x.priority == entity_y.priority)
{
return(0);
}
else
{
return(1);
}
});
return(list);
}
private async Task CallbackEntity(Nuid id, EntityEvent entity_event, NList args)
{
string entity_type = Global.NULL_STRING;
Entity entity = EntityManager.Get(id);
if (entity != null)
{
entity_type = entity.Type;
}
else
{
entity_type = await GetCacheType(id);
}
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
return;
}
if (entity_prefab.ancestors != null && entity_prefab.ancestors.Count > 0)
{
for (int i = entity_prefab.ancestors.Count - 1; i >= 0; i--)
{
string parent_type = entity_prefab.ancestors[i];
await NModule.CallbackEntity(this, id, parent_type, entity_event, args);
}
}
await NModule.CallbackEntity(this, id, entity_type, entity_event, args);
}
EntityPrefabRoot CreatePrefab(EntityRef entityRef, EntityPrefab prefab, Transform2D *transform)
{
var asset = UnityDB.FindAsset <EntityPrefabAsset>(prefab.Id);
if (asset)
{
EntityPrefabRoot instance;
instance = transform == null?Instantiate(asset.Prefab) : Instantiate(asset.Prefab, transform->Position.ToUnityVector2(), transform->Rotation.ToUnityQuaternion());
instance.AssetGuid = prefab.Guid;
instance.EntityRef = entityRef;
if (transform != null)
{
instance.transform.position = transform->Position.ToUnityVector3();
instance.transform.rotation = transform->Rotation.ToUnityQuaternion();
}
// add to lookup
_activePrefabs.Add(entityRef, instance);
// return instance
return(instance);
}
return(null);
}
private static string GenEntityNamespace(EntityPrefab entity_prefab)
{
StringBuilder sb = new StringBuilder();
string parent_name = entity_prefab.GetEntityParentFormat();
string self_name = entity_prefab.GetEntitySelfFormat();
if (string.IsNullOrEmpty(parent_name))
{
sb.Append("public class ").Append(self_name);
}
else
{
sb.Append("public class ").Append(self_name).Append(" : ").Append(parent_name);
}
sb.AppendLine();
sb.Append(GenUtils.str_tab + "{");
sb.AppendLine();
sb.Append(GenUtils.str_tab2);
if (string.IsNullOrEmpty(parent_name))
{
sb.Append("public const string TYPE = \"").Append(entity_prefab.type).Append("\";");
}
else
{
sb.Append("public new const string TYPE = \"").Append(entity_prefab.type).Append("\";");
}
sb.AppendLine();
sb.Append(GenUtils.str_tab2);
return(sb.ToString());
}
private Entity GenObject(string type)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(type);
if (entity_prefab == null)
{
return(null);
}
Entity gen_entity = new Entity();
gen_entity.Type = entity_prefab.type;
foreach (FieldPrefab field_prefab in entity_prefab.fields.Values)
{
switch (field_prefab.type)
{
case VarType.Bool:
gen_entity.CreateField(field_prefab.name, Global.NULL_BOOL);
break;
case VarType.Int:
gen_entity.CreateField(field_prefab.name, Global.NULL_INT);
break;
case VarType.Float:
gen_entity.CreateField(field_prefab.name, Global.NULL_FLOAT);
break;
case VarType.Long:
gen_entity.CreateField(field_prefab.name, Global.NULL_LONG);
break;
case VarType.String:
gen_entity.CreateField(field_prefab.name, Global.NULL_STRING);
break;
case VarType.Nuid:
gen_entity.CreateField(field_prefab.name, Nuid.Empty);
break;
case VarType.List:
gen_entity.CreateField(field_prefab.name, NList.Empty);
break;
default:
break;
}
}
foreach (TablePrefab table_prefab in entity_prefab.tables.Values)
{
gen_entity.CreateTable(table_prefab.name, table_prefab.primary_key.type);
}
return(gen_entity);
}
protected override void OnEventFired(object source, EntityCreationStartingEventArgs args)
{
EntityPrefab prefabType = ComputePrefabType(args.EntityGuid);
IMovementData movementData = MovementDataMappable.RetrieveEntity(args.EntityGuid);
//load the entity's prefab from the factory
GameObject prefab = PrefabFactory.Create(prefabType);
GameObject entityGameObject = GameObject.Instantiate(prefab, movementData.InitialPosition, Quaternion.Euler(0, movementData.Rotation, 0));
OnEntityWorldRepresentationCreated?.Invoke(this, new EntityWorldRepresentationCreatedEventArgs(args.EntityGuid, entityGameObject));
}
/// <inheritdoc />
public DefaultEntityCreationContext(NetworkEntityGuid entityGuid, IMovementData movementData, EntityPrefab prefabType, [NotNull] IEntityDataFieldContainer entityData)
{
if (!Enum.IsDefined(typeof(EntityPrefab), prefabType))
{
throw new InvalidEnumArgumentException(nameof(prefabType), (int)prefabType, typeof(EntityPrefab));
}
EntityGuid = entityGuid ?? throw new ArgumentNullException(nameof(entityGuid));
MovementData = movementData ?? throw new ArgumentNullException(nameof(movementData));
PrefabType = prefabType;
EntityData = entityData ?? throw new ArgumentNullException(nameof(entityData));
}
private static string GetEntityParentFormat(this EntityPrefab entity_prefab)
{
string parent_name = entity_prefab.ancestors.Count > 0 ? entity_prefab.ancestors[0] : "";
if (string.IsNullOrEmpty(parent_name))
{
return("");
}
return(GenUtils.FormatName(parent_name));
}
/// <inheritdoc />
public DefaultEntityCreationContext([NotNull] NetworkEntityGuid entityGuid, Vector3 initialPosition, float orientation, EntityPrefab prefabType)
{
if (!Enum.IsDefined(typeof(EntityPrefab), prefabType))
{
throw new InvalidEnumArgumentException(nameof(prefabType), (int)prefabType, typeof(EntityPrefab));
}
EntityGuid = entityGuid ?? throw new ArgumentNullException(nameof(entityGuid));
InitialPosition = initialPosition;
Orientation = orientation;
PrefabType = prefabType;
}
private static string GenEntityNamespace(EntityPrefab entity_prefab)
{
StringBuilder sb = new StringBuilder();
string self_name = entity_prefab.GetEntitySelfFormat();
sb.Append($"export namespace {self_name}").AppendLine();
sb.Append("{").AppendLine();
sb.Append(GenUtils.str_tab).Append($"export const TYPE: string = \"{entity_prefab.type}\";").AppendLine();
return(sb.ToString());
}
public static void entityDestroyed(string name)
{
EntityPrefab ePrefab = null;
if (spawnEntities.TryGetValue(name, out ePrefab))
{
ePrefab.entityDestroyed();
}
else
{
Debug.LogError("entityDestroyed: error: EntityPrefab " + name + " does not exist");
}
}
public void setPrafabPer()
{
U3D_Render.EntityView ev = EntityFactory.getEntityViewByID(this.m_ID);
if (ev == null)
{
return;
}
EntityPrefab ep = ev.gameObject.GetComponent <EntityPrefab>();
if (ep != null)
{
this.fPer = ep.per;
}
}
private async Task <Entity> GetCacheEntity(Nuid entity_id)
{
try
{
IRedisDatabase db = GetCache(entity_id);
ITransaction query_trans = db.Database.CreateTransaction();
string type = await GetCacheType(entity_id);
EntityTransaction trans = new EntityTransaction(entity_id, type);
EntityPrefab entity_prefab = Prefabs.GetEntity(trans.Type);
if (entity_prefab == null)
{
throw new Exception($"Prefabs.GetEntity cant found {trans.Type}");
}
string field_key = CacheUtils.BuildFields(trans.Id);
trans.Fields = query_trans.HashGetAllAsync(field_key);
foreach (Table table in trans.Entity.GetTables())
{
TablePrefab table_prefab = entity_prefab.tables[table.GetName()];
string table_key = CacheUtils.BuildTable(trans.Id, table.GetName());
Task <HashEntry[]> key_values = query_trans.HashGetAllAsync(table_key);
trans.AddTableTrans(table.GetName(), key_values);
}
bool redis_execute = await query_trans.ExecuteAsync();
if (!redis_execute)
{
throw new Exception("query_trans ExecuteAsync ERROR!!");
}
return(await BuildCacheEntity(trans));
}
catch (Exception ex)
{
_Logger.LogError(ex, "GetCacheEntities Failed");
}
return(null);
}
private async Task CallbackTable(Nuid id, string table_name, TableEvent table_event, NList args)
{
string entity_type = Global.NULL_STRING;
Entity entity = EntityManager.Get(id);
if (entity != null)
{
entity_type = entity.Type;
}
else
{
entity_type = await GetCacheType(id);
}
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
return;
}
if (entity_prefab.ancestors != null && entity_prefab.ancestors.Count > 0)
{
for (int i = entity_prefab.ancestors.Count - 1; i >= 0; i--)
{
string parent_type = entity_prefab.ancestors[i];
await NModule.CallbackTable(this, id, parent_type, table_name, table_event, args);
}
}
await NModule.CallbackTable(this, id, entity_type, table_name, table_event, args);
TablePrefab table_prefab = entity_prefab.tables[table_name];
if (table_prefab != null && table_prefab.sync)
{
NList msg = NList.New().Add(id).Add(table_name).Add((int)table_event).Append(args);
await SyncTable(id, msg);
}
}
private async Task CallbackField(Nuid id, string field_name, FieldEvent field_event, NList args)
{
string entity_type = Global.NULL_STRING;
Entity entity = EntityManager.Get(id);
if (entity != null)
{
entity_type = entity.Type;
}
else
{
entity_type = await GetCacheType(id);
}
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
return;
}
if (entity_prefab.ancestors != null && entity_prefab.ancestors.Count > 0)
{
for (int i = entity_prefab.ancestors.Count - 1; i >= 0; i--)
{
string parent_type = entity_prefab.ancestors[i];
await NModule.CallbackField(this, id, parent_type, field_name, field_event, args);
}
}
await NModule.CallbackField(this, id, entity_type, field_name, field_event, args);
FieldPrefab field_prefab = entity_prefab.fields[field_name];
if (field_prefab != null && field_prefab.sync)
{
NList msg = NList.New().Add(id).Add(field_name).Add((int)field_event).Append(args);
await SyncManager.Callback(SyncType.Field, this, id, msg);
}
}
private static string GetEntitySelfFormat(this EntityPrefab entity_prefab)
{
return(GenUtils.FormatName(entity_prefab.type));
}
private async Task <IReadOnlyList <Entity> > LoadPersistEntities()
{
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
try
{
var collection = database.GetCollection <EntityList>(PersistUtils.ENTITIES);
var filter = Builders <EntityList> .Filter.Eq(n => n.origin, Identity);
IAsyncCursor <EntityList> res = await collection.FindAsync(filter);
EntityList entity_list = await res.FirstOrDefaultAsync();
if (entity_list == null)
{
return(null);
}
List <Entity> entities = new List <Entity>();
foreach (EntityChild entity_child in entity_list.entities)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_child.type);
if (entity_prefab == null)
{
continue;
}
BsonDocument doc = entity_child.entity;
long unique = doc.GetValue(Global.MARK_UNIQUE).AsInt64;
Entity entity = Entity.Gen(entity_child.type);
entity.Id = Nuid.New(unique, Identity);
foreach (FieldPrefab field_prefab in entity_prefab.fields.Values)
{
if (!field_prefab.save)
{
continue;
}
Field field = entity.GetField(field_prefab.name);
if (field == null)
{
continue;
}
BsonValue bsonValue = doc.GetValue(field_prefab.name);
switch (field_prefab.type)
{
case VarType.Bool:
{
bool value = bsonValue.AsBoolean;
field.TrySet(value, out _);
}
break;
case VarType.Int:
{
int value = bsonValue.AsInt32;
field.TrySet(value, out _);
}
break;
case VarType.Long:
{
long value = bsonValue.AsInt64;
field.TrySet(value, out _);
}
break;
case VarType.Float:
{
float value = (float)bsonValue.AsDouble;
field.TrySet(value, out _);
}
break;
case VarType.String:
{
string value = bsonValue.AsString;
field.TrySet(value, out _);
}
break;
case VarType.Nuid:
{
string value = bsonValue.AsBsonDocument.ToJson();
Nuid nuid = JsonUtils.ToObject <Nuid>(value);
field.TrySet(value, out _);
}
break;
case VarType.List:
{
string value = bsonValue.AsBsonDocument.ToJson();
NList lst = JsonUtils.ToObject <NList>(value);
field.TrySet(value, out _);
}
break;
default:
break;
}
}
foreach (TablePrefab table_prefab in entity_prefab.tables.Values)
{
if (!table_prefab.save)
{
continue;
}
BsonArray bsonarr = doc.GetValue(table_prefab.name) as BsonArray;
foreach (BsonDocument key_value_bson in bsonarr.Values)
{
BsonValue pk_bson = key_value_bson.GetValue(nameof(TablePrefab.primary_key));
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
bool value = pk_bson.AsBoolean;
LoadTableKeyValue(value);
}
break;
case VarType.Int:
{
int value = pk_bson.AsInt32;
LoadTableKeyValue(value);
}
break;
case VarType.Long:
{
long value = pk_bson.AsInt64;
LoadTableKeyValue(value);
}
break;
case VarType.String:
{
string value = pk_bson.AsString;
LoadTableKeyValue(value);
}
break;
case VarType.Nuid:
{
string value = pk_bson.AsBsonDocument.ToJson();
Nuid nuid = JsonUtils.ToObject <Nuid>(value);
LoadTableKeyValue(nuid);
}
break;
default:
break;
}
void LoadTableKeyValue <TPrimaryKey>(TPrimaryKey primary_key)
{
Table <TPrimaryKey> table = entity.GetTable(table_prefab.name) as Table <TPrimaryKey>;
NList key_value = NList.New();
for (int col = 0; col < table_prefab.cols; col++)
{
TablePrefab.ColumnPrefab column = table_prefab.columns[col];
BsonValue col_bson = key_value_bson.GetValue(column.name);
switch (column.type)
{
case VarType.Bool:
{
bool value = col_bson.AsBoolean;
key_value.Add(value);
}
break;
case VarType.Int:
{
int value = col_bson.AsInt32;
key_value.Add(value);
}
break;
case VarType.Long:
{
long value = col_bson.AsInt64;
key_value.Add(value);
}
break;
case VarType.Float:
{
float value = (float)col_bson.AsDouble;
key_value.Add(value);
}
break;
case VarType.String:
{
string value = col_bson.AsString;
key_value.Add(value);
}
break;
case VarType.Nuid:
{
string value = col_bson.AsBsonDocument.ToJson();
Nuid nuid = JsonUtils.ToObject <Nuid>(value);
key_value.Add(value);
}
break;
case VarType.List:
{
string value = col_bson.AsBsonDocument.ToJson();
NList lst = JsonUtils.ToObject <NList>(value);
key_value.Add(value);
}
break;
default:
break;
}
}
table.TrySetKeyValue(primary_key, key_value, out _);
}
}
}
entities.Add(entity);
}
return(entities);
}
catch (Exception ex)
{
_Logger.LogError(ex, "LoadPersisitEntities Failed!");
}
return(null);
}
private async Task PushPersistFields(Entity entity)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
return;
}
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
var collection = database.GetCollection <BsonDocument>(entity.Type);
Dictionary <string, object> models = new Dictionary <string, object>();
models.Add(Global.MARK_ORIGIN, entity.Id.Origin);
models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
Field[] fields = entity.GetFields();
foreach (Field field in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[field.Name];
if (field_prefab == null)
{
continue;
}
if (!field_prefab.save)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
models.Add(field_prefab.name, field.Get <bool>());
}
break;
case VarType.Int:
{
models.Add(field_prefab.name, field.Get <int>());
}
break;
case VarType.Float:
{
models.Add(field_prefab.name, field.Get <float>());
}
break;
case VarType.Long:
{
models.Add(field_prefab.name, field.Get <long>());
}
break;
case VarType.Nuid:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <Nuid>()));
models.Add(field_prefab.name, document);
}
break;
case VarType.Time:
{
models.Add(field_prefab.name, field.Get <DateTime>());
}
break;
case VarType.String:
{
models.Add(field_prefab.name, field.Get <string>());
}
break;
case VarType.List:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <NList>()));
models.Add(field_prefab.name, document);
}
break;
}
}
FilterDefinitionBuilder <BsonDocument> builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filter = builder.And(builder.Eq("unique", entity.Id.Unique), builder.Eq("origin", entity.Id.Origin));
var found = await collection.FindOneAndUpdateAsync(filter, new BsonDocument(models));
if (found == null)
{
await collection.InsertOneAsync(new BsonDocument(models));
}
}
private async Task <IReadOnlyList <Entity> > GetCacheEntities()
{
Nuid id = Nuid.New(Identity, Identity);
IRedisDatabase db = GetCache(id);
string entites_key = CacheUtils.BuildEntities(id);
List <Entity> sorts = new List <Entity>();
List <EntityTransaction> entity_trans = new List <EntityTransaction>();
try
{
HashEntry[] entities = await db.Database.HashGetAllAsync(entites_key);
foreach (HashEntry member in entities)
{
long child_id = long.Parse(member.Name);
string type = member.Value;
Nuid entity_id = Nuid.New(child_id, Identity);
EntityTransaction trans = new EntityTransaction(entity_id, type);
if (trans.Entity == null)
{
continue;
}
entity_trans.Add(trans);
}
ITransaction query_trans = db.Database.CreateTransaction();
foreach (EntityTransaction trans in entity_trans)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(trans.Type);
if (entity_prefab == null)
{
throw new Exception($"Prefabs.GetEntity cant found {trans.Type}");
}
string field_key = CacheUtils.BuildFields(trans.Id);
trans.Fields = query_trans.HashGetAllAsync(field_key);
foreach (Table table in trans.Entity.GetTables())
{
TablePrefab table_prefab = entity_prefab.tables[table.GetName()];
string table_key = CacheUtils.BuildTable(trans.Id, table.GetName());
Task <HashEntry[]> key_values = query_trans.HashGetAllAsync(table_key);
trans.AddTableTrans(table.GetName(), key_values);
}
}
bool redis_execute = await query_trans.ExecuteAsync();
if (!redis_execute)
{
throw new Exception("query_trans ExecuteAsync ERROR!!");
}
foreach (EntityTransaction trans in entity_trans)
{
Entity entity = await BuildCacheEntity(trans);
sorts.Add(entity);
}
}
catch (Exception ex)
{
_Logger.LogError(ex, "GetCacheEntities Failed");
}
entity_trans.Clear();
sorts.Sort((x, y) =>
{
EntityPrefab entity_x = Prefabs.GetEntity(x.Type);
EntityPrefab entity_y = Prefabs.GetEntity(y.Type);
return(entity_y.priority - entity_x.priority);
});
return(sorts);
}
private async Task PushPersistTables(Entity entity)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
return;
}
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
Table[] tables = entity.GetTables();
foreach (Table table in tables)
{
var collection = database.GetCollection <BsonDocument>(table.Name);
TablePrefab table_prefab = entity_prefab.tables[table.Name];
if (table_prefab == null)
{
continue;
}
if (!table_prefab.save)
{
continue;
}
NList rows = table.GetRows();
for (int i = 0; i < rows.Count; i++)
{
long row = rows.Get <long>(i);
NList row_value = table.GetRow(row);
Dictionary <string, object> models = new Dictionary <string, object>();
models.Add(Global.MARK_ORIGIN, entity.Id.Origin);
models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
models.Add(Global.MARK_ROW, row);
for (int col = 0; col < table_prefab.cols; col++)
{
TablePrefab.ColumnPrefab column = table_prefab.columns[col];
switch (column.type)
{
case VarType.Bool:
models.Add(column.name, row_value.Get <bool>(col));
break;
case VarType.Int:
models.Add(column.name, row_value.Get <int>(col));
break;
case VarType.Float:
models.Add(column.name, row_value.Get <float>(col));
break;
case VarType.Long:
models.Add(column.name, row_value.Get <long>(col));
break;
case VarType.Time:
models.Add(column.name, row_value.Get <DateTime>(col));
break;
case VarType.Nuid:
models.Add(column.name, BsonDocument.Parse(JsonUtils.ToJson(row_value.Get <Nuid>(col))));
break;
case VarType.String:
models.Add(column.name, row_value.Get <string>(col));
break;
case VarType.List:
models.Add(column.name, BsonDocument.Parse(JsonUtils.ToJson(row_value.Get <NList>(col))));
break;
}
}
await collection.InsertOneAsync(new BsonDocument(models));
}
}
}
private async Task PullPersistFields(string entity_type)
{
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
var collection = database.GetCollection <BsonDocument>(entity_type);
FilterDefinitionBuilder <BsonDocument> builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filter = builder.And(builder.Eq("unique", Identity), builder.Eq("origin", Identity));
//获取数据
var result = (await collection.FindAsync <BsonDocument>(filter)).ToList();
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
foreach (BsonDocument doc in result)
{
long unique = doc.GetValue("unique").AsInt64;
long origin = doc.GetValue("origin").AsInt64;
Entity entity = EntityManager.Create(Nuid.New(unique, origin), entity_type);
foreach (FieldPrefab field_prefab in entity_prefab.fields.Values)
{
if (!field_prefab.save)
{
continue;
}
Field field = entity.GetField(field_prefab.name);
if (field == null)
{
continue;
}
BsonValue bsonValue = doc.GetValue(field_prefab.name);
switch (field_prefab.type)
{
case VarType.Bool:
{
bool value = bsonValue.AsBoolean;
field.TrySet(value, out NList res);
}
break;
case VarType.Int:
{
int value = bsonValue.AsInt32;
field.TrySet(value, out NList res);
}
break;
case VarType.Long:
{
long value = bsonValue.AsInt64;
field.TrySet(value, out NList res);
}
break;
case VarType.Float:
{
float value = (float)bsonValue.AsDouble;
field.TrySet(value, out NList res);
}
break;
case VarType.String:
{
string value = bsonValue.AsString;
field.TrySet(value, out NList res);
}
break;
case VarType.Time:
{
DateTime value = bsonValue.AsBsonDateTime.ToUniversalTime();
field.TrySet(value, out NList res);
}
break;
case VarType.Nuid:
{
string value = bsonValue.AsBsonDocument.ToJson();
Nuid nuid = JsonUtils.ToObject <Nuid>(value);
field.TrySet(nuid, out NList res);
}
break;
case VarType.List:
{
string value = bsonValue.AsBsonDocument.ToJson();
NList lst = JsonUtils.ToObject <NList>(value);
field.TrySet(lst, out NList res);
}
break;
}
}
}
//int count = await collection.CountAsync();
//BsonDocument b = collection.AsQueryable();
//var list = (await collection.FindAsync(x => x.GetValue(Global.MARK_UNIQUE) == Identity)).ToList();
}
private Entity Gen(string entity_type)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
return(null);
}
Entity new_entity = new Entity();
new_entity.Type = entity_prefab.type;
foreach (FieldPrefab field in entity_prefab.fields.Values)
{
switch (field.type)
{
case VarType.Bool:
new_entity.CreateField(field.name, Global.NULL_BOOL);
break;
case VarType.Int:
new_entity.CreateField(field.name, Global.NULL_INT);
break;
case VarType.Float:
new_entity.CreateField(field.name, Global.NULL_FLOAT);
break;
case VarType.Long:
new_entity.CreateField(field.name, Global.NULL_LONG);
break;
case VarType.String:
new_entity.CreateField(field.name, Global.NULL_STRING);
break;
case VarType.Nuid:
new_entity.CreateField(field.name, Nuid.Empty);
break;
case VarType.Time:
new_entity.CreateField(field.name, DateTime.MinValue);
break;
case VarType.List:
new_entity.CreateField(field.name, NList.Empty);
break;
default:
break;
}
}
foreach (TablePrefab table in entity_prefab.tables.Values)
{
new_entity.CreateTable(table.name);
}
return(new_entity);
}
private async Task BatchCache(object arg)
{
if (BatchCahceList.Count <= 0)
{
return;
}
try
{
int db = (int)(Identity % CacheUtils.EntityDBs);
IRedisDatabase redis = _CacheClient.GetDb(db);
ITransaction trans = redis.Database.CreateTransaction();
foreach (NList batch in BatchCahceList)
{
CacheOption option = (CacheOption)batch.Get <int>(0);
Nuid entity_id = batch.Get <Nuid>(1);
switch (option)
{
case CacheOption.SetEntity:
{
string entity_type = batch.Get <string>(2);
string key = CacheUtils.BuildEntities(entity_id);
Task task = trans.HashSetAsync(key, entity_id.Unique.ToString(), entity_type);
}
break;
case CacheOption.DelEntity:
{
string entity_type = batch.Get <string>(2);
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
continue;
}
foreach (TablePrefab table_prefab in entity_prefab.tables.Values)
{
string table_key = CacheUtils.BuildTable(entity_id, table_prefab.name);
Task table_task = trans.KeyDeleteAsync(table_key);
}
string field_key = CacheUtils.BuildFields(entity_id);
Task field_task = trans.KeyDeleteAsync(field_key);
string entity_key = CacheUtils.BuildEntities(entity_id);
Task entity_task = trans.HashDeleteAsync(entity_key, entity_id.Unique.ToString());
}
break;
case CacheOption.SetField:
{
string field_name = batch.Get <string>(2);
byte[] field_value = batch.Get <byte[]>(3);
string key = CacheUtils.BuildFields(entity_id);
Task task = trans.HashSetAsync(key, field_name, field_value);
}
break;
case CacheOption.SetRow:
{
string table_name = batch.Get <string>(2);
long row = batch.Get <long>(3);
NList row_value = batch.Get <NList>(4);
string key = CacheUtils.BuildTable(entity_id, table_name);
Task task = trans.HashSetAsync(key, row, ProtoUtils.Serialize(row_value));
}
break;
case CacheOption.DelRow:
{
string table_name = batch.Get <string>(2);
long row = batch.Get <long>(3);
string key = CacheUtils.BuildTable(entity_id, table_name);
Task task = trans.HashDeleteAsync(key, row);
}
break;
case CacheOption.ClearTable:
{
string table_name = batch.Get <string>(2);
string key = CacheUtils.BuildTable(entity_id, table_name);
Task task = trans.KeyDeleteAsync(key);
}
break;
default:
break;
}
}
bool result = await trans.ExecuteAsync();
if (result)
{
BatchCahceList.Clear();
}
else
{
throw new Exception();
}
}
catch (Exception ex)
{
_Logger.LogError(ex, string.Format("{0} BatchCache ExecuteAsync Failed", Identity));
}
}
private async Task SetCacheEntities(IReadOnlyList <Entity> entities)
{
IRedisDatabase db = GetCache();
ITransaction trans = db.Database.CreateTransaction();
{
string key = CacheUtils.BuildEntities(Nuid.New(Identity, Identity));
HashEntry[] hashFields = new HashEntry[entities.Count];
for (int i = 0; i < entities.Count; i++)
{
hashFields[i] = new HashEntry(entities[i].Id.Unique, entities[i].Type);
}
Task _ = trans.HashSetAsync(key, hashFields);
}
{
foreach (Entity entity in entities)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
continue;
}
string fields_key = CacheUtils.BuildFields(entity.Id);
Field[] fields = entity.GetFields();
List <HashEntry> cache_fields = new List <HashEntry>();
for (int i = 0; i < fields.Length; i++)
{
FieldPrefab field_prefab = entity_prefab.fields[fields[i].Name];
if (field_prefab == null)
{
continue;
}
string field_value = "";
switch (field_prefab.type)
{
case VarType.Bool:
field_value = JsonUtils.ToJson(fields[i].Get <bool>());
break;
case VarType.Int:
field_value = JsonUtils.ToJson(fields[i].Get <int>());
break;
case VarType.Long:
field_value = JsonUtils.ToJson(fields[i].Get <long>());
break;
case VarType.Float:
field_value = JsonUtils.ToJson(fields[i].Get <float>());
break;
case VarType.String:
field_value = JsonUtils.ToJson(fields[i].Get <string>());
break;
case VarType.Nuid:
field_value = JsonUtils.ToJson(fields[i].Get <Nuid>());
break;
case VarType.List:
field_value = JsonUtils.ToJson(fields[i].Get <NList>());
break;
default:
break;
}
cache_fields.Add(new HashEntry(fields[i].Name, field_value));
}
Task _ = trans.HashSetAsync(fields_key, cache_fields.ToArray());
Table[] tables = entity.GetTables();
foreach (Table table in tables)
{
string table_key = CacheUtils.BuildTable(entity.Id, table.GetName());
TablePrefab table_prefab = entity_prefab.tables[table.GetName()];
if (table_prefab == null)
{
continue;
}
List <HashEntry> cache_key_values = new List <HashEntry>();
void SetCacheKeyValue <TPrimaryKey>()
{
Table <TPrimaryKey> t = table as Table <TPrimaryKey>;
IReadOnlyList <TPrimaryKey> keys = t.GetPrimaryKeys();
foreach (TPrimaryKey key in keys)
{
string json = JsonUtils.ToJson(t.GetKeyValue(key));
cache_key_values.Add(new HashEntry(key.ToString(), json));
}
}
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
SetCacheKeyValue <bool>();
break;
case VarType.Int:
SetCacheKeyValue <int>();
break;
case VarType.Long:
SetCacheKeyValue <long>();
break;
case VarType.Float:
SetCacheKeyValue <float>();
break;
case VarType.String:
SetCacheKeyValue <string>();
break;
case VarType.Nuid:
SetCacheKeyValue <Nuid>();
break;
default:
break;
}
Task __ = trans.HashSetAsync(table_key, cache_key_values.ToArray());
}
}
bool redis_execute = await trans.ExecuteAsync();
if (!redis_execute)
{
throw new Exception("trans ExecuteAsync ERROR!!");
}
}
}
async Task <Entity> BuildCacheEntity(EntityTransaction trans)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(trans.Type);
if (entity_prefab == null)
{
throw new Exception($"Prefabs.GetEntity cant found {trans.Type}");
}
HashEntry[] fields = await trans.Fields;
foreach (HashEntry entry in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[entry.Name];
if (field_prefab == null)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
SetFieldValue <bool>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Int:
{
SetFieldValue <int>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Float:
{
SetFieldValue <float>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Long:
{
SetFieldValue <long>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.String:
{
SetFieldValue <string>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Nuid:
{
SetFieldValue <Nuid>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.List:
{
SetFieldValue <NList>(entry.Name, entry.Value, ref trans.Entity);
}
break;
default:
break;
}
void SetFieldValue <T>(string field_name, RedisValue field_value, ref Entity entity)
{
T value = JsonUtils.ToObject <T>(field_value);
Field field = entity.GetField(field_name);
if (field == null)
{
return;
}
NList res = NList.Empty;
field.TrySet(value, out res);
}
}
foreach (KeyValuePair <string, Task <HashEntry[]> > table_task in trans.Tables)
{
TablePrefab table_prefab = entity_prefab.tables[table_task.Key];
if (table_prefab == null)
{
continue;
}
Table table_trans = trans.Entity.GetTable(table_task.Key);
if (table_trans == null)
{
continue;
}
HashEntry[] table_key_values = await table_task.Value;
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
Table <bool> table = table_trans as Table <bool>;
foreach (HashEntry entry in table_key_values)
{
bool key = bool.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.Int:
{
Table <int> table = table_trans as Table <int>;
foreach (HashEntry entry in table_key_values)
{
int key = int.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.Long:
{
Table <long> table = table_trans as Table <long>;
foreach (HashEntry entry in table_key_values)
{
long key = long.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.String:
{
Table <string> table = table_trans as Table <string>;
foreach (HashEntry entry in table_key_values)
{
string key = entry.Name;
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.Nuid:
{
Table <Nuid> table = table_trans as Table <Nuid>;
foreach (HashEntry entry in table_key_values)
{
Nuid key = Nuid.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
default:
break;
}
}
return(trans.Entity);
}
private async Task <NList> GetCacheKeys(Nuid id, string table_name)
{
if (!await CacheExist(id))
{
return(NList.Empty);
}
IRedisDatabase db = GetCache(id);
string key = CacheUtils.BuildTable(id, table_name);
string type = await GetCacheType(id);
EntityPrefab entity_prefab = Prefabs.GetEntity(type);
if (entity_prefab == null)
{
return(NList.Empty);
}
TablePrefab table_prefab = entity_prefab.tables[table_name];
if (table_prefab == null)
{
return(NList.Empty);
}
NList rows = NList.New();
foreach (string hash_key in await db.HashKeysAsync(key))
{
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
bool row = bool.Parse(hash_key);
rows.Add(row);
}
break;
case VarType.Int:
{
int row = int.Parse(hash_key);
rows.Add(row);
}
break;
case VarType.Long:
{
long row = long.Parse(hash_key);
rows.Add(row);
}
break;
case VarType.Nuid:
{
Nuid row = Nuid.Parse(hash_key);
rows.Add(row);
}
break;
case VarType.String:
{
string row = hash_key;
rows.Add(row);
}
break;
default:
break;
}
}
return(rows.Count > 0 ? rows : NList.Empty);
}
public async Task Destroy(Nuid id)
{
if (id.Origin != Identity)
{
INode node = GrainFactory.GetGrain <INode>(id.Origin);
if (await node.IsActive())
{
await node.Destroy(id);
return;
}
}
if (NodeType == NodeType.Grain)
{
Entity entity = EntityManager.Get(id);
if (entity == null)
{
_Logger.LogError($"{id} Destroy Entity Failed When not found!");
return;
}
if (EntityManager.Remove(id))
{
_Logger.LogError($"{id} Destroy Entity Failed When EntityManager Remove!");
return;
}
}
else if (NodeType == NodeType.Cache)
{
if (!await CacheExist(id))
{
_Logger.LogError($"{id} Destroy Entity Failed when not CacheExist!");
return;
}
string entity_type = await GetCacheType(id);
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
_Logger.LogError($"{id} Destroy Entity Failed when not EntityPrefab {entity_type}!");
return;
}
int db = (int)(Identity % CacheUtils.EntityDBs);
IRedisDatabase redis = _CacheClient.GetDb(db);
ITransaction trans = redis.Database.CreateTransaction();
foreach (TablePrefab table_prefab in entity_prefab.tables.Values)
{
string table_key = CacheUtils.BuildTable(id, table_prefab.name);
Task table_task = trans.KeyDeleteAsync(table_key);
}
string field_key = CacheUtils.BuildFields(id);
Task field_task = trans.KeyDeleteAsync(field_key);
string entity_key = CacheUtils.BuildEntities(id);
Task entity_task = trans.HashDeleteAsync(entity_key, id.Unique);
bool result = await trans.ExecuteAsync();
if (!result)
{
_Logger.LogError($"{id} Destroy Entity Failed when ITransaction Execute");
return;
}
}
await CallbackEntity(id, EntityEvent.OnDestroy, NList.Empty);
await SyncEntity(id, NList.New().Add(id).Add((int)EntityEvent.OnDestroy));
}
// Create new spawn data
public static ProceduralGenerationSpawnData CreateSpawnData(EntityManager entityManager, EntityPrefab entityPrefab, float minGenerationHeight, int amount, int maxSteepness, bool ignoreCollisions)
{
return(new ProceduralGenerationSpawnData
{
Amount = amount,
IgnoreCollisions = ignoreCollisions,
MaxSteepness = maxSteepness,
MinGenerationHeight = minGenerationHeight,
EntityPrefab = entityPrefab,
Id = GenerateId(entityManager)
});
}
private async Task SavePersistEntities()
{
IReadOnlyList <Entity> entities = null;
if (NodeType == Abstractions.NodeType.Grain)
{
entities = EntityManager.GetEntities();
}
else if (NodeType == Abstractions.NodeType.Cache)
{
entities = await GetCacheEntities();
}
if (entities == null || entities.Count == 0)
{
return;
}
EntityList entity_list = new EntityList();
entity_list.entities = new List <EntityChild>();
entity_list.origin = Identity;
entity_list.node = NodeType;
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
foreach (Entity entity in entities)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
continue;
}
Dictionary <string, object> entity_models = new Dictionary <string, object>();
entity_models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
Field[] fields = entity.GetFields();
foreach (Field field in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[field.Name];
if (field_prefab == null)
{
continue;
}
if (!field_prefab.save)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
entity_models.Add(field_prefab.name, field.Get <bool>());
}
break;
case VarType.Int:
{
entity_models.Add(field_prefab.name, field.Get <int>());
}
break;
case VarType.Float:
{
entity_models.Add(field_prefab.name, field.Get <float>());
}
break;
case VarType.Long:
{
entity_models.Add(field_prefab.name, field.Get <long>());
}
break;
case VarType.Nuid:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <Nuid>()));
entity_models.Add(field_prefab.name, document);
}
break;
case VarType.String:
{
entity_models.Add(field_prefab.name, field.Get <string>());
}
break;
case VarType.List:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <NList>()));
entity_models.Add(field_prefab.name, document);
}
break;
default:
break;
}
}
Table[] tables = entity.GetTables();
foreach (Table base_table in tables)
{
BsonArray table_model = new BsonArray();
TablePrefab table_prefab = entity_prefab.tables[base_table.GetName()];
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
UpdateTableKeyValue <bool>();
}
break;
case VarType.Int:
{
UpdateTableKeyValue <int>();
}
break;
case VarType.Long:
{
UpdateTableKeyValue <long>();
}
break;
case VarType.Float:
{
UpdateTableKeyValue <float>();
}
break;
case VarType.String:
{
UpdateTableKeyValue <string>();
}
break;
case VarType.Nuid:
{
UpdateTableKeyValue <Nuid>();
}
break;
default:
break;
}
void UpdateTableKeyValue <TPrimaryKey>()
{
Table <TPrimaryKey> table = base_table as Table <TPrimaryKey>;
foreach (TPrimaryKey key in table.GetPrimaryKeys())
{
Dictionary <string, object> key_value_models = new Dictionary <string, object>();
key_value_models.Add(nameof(TablePrefab.primary_key), key);
NList key_value = table.GetKeyValue(key);
for (int col = 0; col < table_prefab.cols; col++)
{
TablePrefab.ColumnPrefab col_prefab = table_prefab.columns[col];
switch (col_prefab.type)
{
case VarType.Bool:
{
bool col_value = key_value.Get <bool>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Int:
{
int col_value = key_value.Get <int>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Long:
{
long col_value = key_value.Get <long>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Float:
{
float col_value = key_value.Get <float>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.String:
{
string col_value = key_value.Get <string>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Nuid:
{
Nuid col_value = key_value.Get <Nuid>(col);
key_value_models.Add(col_prefab.name, BsonDocument.Parse(JsonUtils.ToJson(col_value)));
}
break;
case VarType.List:
{
NList col_value = key_value.Get <NList>(col);
key_value_models.Add(col_prefab.name, BsonDocument.Parse(JsonUtils.ToJson(col_value)));
}
break;
default:
break;
}
}
table_model.Add(new BsonDocument(key_value_models));
}
}
entity_models.Add(base_table.GetName(), table_model);
}
entity_list.entities.Add(new EntityChild()
{
unique = entity.Id.Unique, type = entity.Type, entity = new BsonDocument(entity_models)
});
}
var collection = database.GetCollection <EntityList>(PersistUtils.ENTITIES);
var filter = Builders <EntityList> .Filter.And(Builders <EntityList> .Filter.Eq(n => n.origin, Identity));
EntityList found = await collection.FindOneAndReplaceAsync(filter, entity_list);
if (found == null)
{
await collection.InsertOneAsync(entity_list);
}
}
protected override void OnCreate()
{
EntityPrefab.SetupPrefabs(EntityManager);
}
