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