public GfxSkillSenderInfo(TableConfig.Skill configData, int seq, int actorId, GameObject gfxObj)
{
m_Seq = seq;
m_ConfigData = configData;
m_ActorId = actorId;
m_GfxObj = gfxObj;
}
public void CopyFrom(TableConfig.Actor actor)
{
id = actor.id;
name = actor.name;
icon = actor.icon;
bigIcon = actor.bigIcon;
type = actor.type;
avatar = actor.avatar;
skill0 = actor.skill0;
skill1 = actor.skill1;
skill2 = actor.skill2;
skill3 = actor.skill3;
skill4 = actor.skill4;
skill5 = actor.skill5;
skill6 = actor.skill6;
skill7 = actor.skill7;
skill8 = actor.skill8;
bornskill = actor.bornskill;
deadskill = actor.deadskill;
size = actor.size;
logicsize = actor.logicsize;
speed = actor.speed;
viewrange = actor.viewrange;
gohomerange = actor.gohomerange;
hp = actor.hp;
mp = actor.mp;
attack = actor.attack;
defence = actor.defence;
addhp = actor.addhp;
addmp = actor.addmp;
addattack = actor.addattack;
adddefence = actor.adddefence;
}
public ImpactInfo(TableConfig.Skill cfg)
{
if (null != cfg) {
ImpactId = cfg.id;
}
ConfigData = cfg;
}
public void CopyTo(TableConfig.Actor actor)
{
actor.id = id;
actor.name = name;
actor.icon = icon;
actor.bigIcon = bigIcon;
actor.type = type;
actor.avatar = avatar;
actor.skill0 = skill0;
actor.skill1 = skill1;
actor.skill2 = skill2;
actor.skill3 = skill3;
actor.skill4 = skill4;
actor.skill5 = skill5;
actor.skill6 = skill6;
actor.skill7 = skill7;
actor.skill8 = skill8;
actor.bornskill = bornskill;
actor.deadskill = deadskill;
actor.size = size;
actor.logicsize = logicsize;
actor.speed = speed;
actor.viewrange = viewrange;
actor.gohomerange = gohomerange;
actor.hp = hp;
actor.mp = mp;
actor.attack = attack;
actor.defence = defence;
actor.addhp = addhp;
actor.addmp = addmp;
actor.addattack = addattack;
actor.adddefence = adddefence;
}
public SkillInfo(TableConfig.Skill cfg)
{
if (null != cfg) {
SkillId = cfg.id;
}
ConfigData = cfg;
}
private void AddActor(int actorID, bool isGreen, TableConfig.Actor cfg)
{
GameObject obj = ClientModule.Instance.GetGameObject(actorID);
GameObject headObj = Utility.FindChildObject(obj, "bloodbar");
if (obj != null && headObj != null) {
GameObject overheadBar = Utility.FindChildObject(obj, "OverHeadBar(Clone)");
if (overheadBar == null) {
overheadBar = (GameObject)ResourceSystem.Instance.NewObject("UI/OverHeadBar");
}
overheadBar.SetActive(true);
overheadBar.transform.SetParent(obj.transform);
//overheadBar.transform.localPosition = headObj.transform.position - obj.transform.position;
overheadBar.transform.position = headObj.transform.position;
OverHeadBar view = overheadBar.GetComponent<OverHeadBar>();
view.Reset();
Color green = new Color(35f / 255f, 192f / 255f, 25f / 255f);
Color red = new Color(172f / 255f, 45f / 255f, 26f / 255f);
view.SetHealthColor(isGreen);
views[actorID] = view;
view.SetHealth(1);
float mp = ClientModule.Instance.GetNpcMp(actorID);
view.SetMp(mp);
}
}
internal GfxSkillSenderInfo(TableConfig.Skill configData, int seq, int actorId, EntityInfo gfxObj, Scene scene)
{
m_Seq = seq;
m_ConfigData = configData;
m_ActorId = actorId;
m_GfxObj = gfxObj;
m_Scene = scene;
}
/// <inheritdoc/>
public void UpdateRows(
IEnumerable <IDictionary <string, object> > rows,
int rowCount,
TableConfig config,
Action <int> updatedCallback)
{
foreach (IDictionary <string, object> dictionary in rows)
{
UpdateRow(dictionary, config);
}
}
/// <summary>
/// 拼接查询语句
/// </summary>
/// <param name="tableConfig"></param>
/// <returns></returns>
private string GetSelectSql(TableConfig tableConfig)
{
string S_DBField = "";
string selectSql = "SELECT {0} FROM {1} alias ";
string Fields = "";
foreach (ColumnConfig item in tableConfig.ColumnConfigList)
{
S_DBField = item.S_DBField;
//类型转换
if (item.S_ColumnDataType == ColumnDataType.STRING)
{
if (item.T_ColumnDataType == ColumnDataType.DATE)
{
if (tableConfig.s_DBType == DataBaseType.Oracle || tableConfig.s_DBType == DataBaseType.Oracle9i)
{
S_DBField = UtilsConvert.GetOracleStrToData(S_DBField);
}
else if (tableConfig.s_DBType == DataBaseType.MySql)
{
S_DBField = UtilsConvert.GetMySqlStrToData(S_DBField);
}
else if (tableConfig.s_DBType == DataBaseType.SqlServer)
{
S_DBField = UtilsConvert.GetSqlStrToData(S_DBField);
}
}
}
if (item.S_ColumnDataType == ColumnDataType.DATE)
{
if (item.T_ColumnDataType == ColumnDataType.STRING)
{
if (tableConfig.s_DBType == DataBaseType.Oracle || tableConfig.s_DBType == DataBaseType.Oracle9i)
{
S_DBField = UtilsConvert.GetOracleDataToStr(S_DBField);
}
else if (tableConfig.s_DBType == DataBaseType.MySql)
{
S_DBField = UtilsConvert.GetMySqlDataToStr(S_DBField);
}
else if (tableConfig.s_DBType == DataBaseType.SqlServer)
{
S_DBField = UtilsConvert.GetSqlDataToStr(S_DBField);
}
}
}
Fields += S_DBField + " as " + item.T_DBField + " ,";
}
if (Fields.Length > 0)
{
Fields = Fields.Remove(Fields.Length - 1, 1);
}
return(string.Format(selectSql, Fields, tableConfig.S_TableName));
}
private IDictionary <string, object> MaskSql(
IDictionary <string, object> obj,
TableConfig tableConfig, IEnumerable <ColumnConfig> columnConfigs)
{
foreach (var columnConfig in columnConfigs)
{
IDataProvider dataProvider = this.GetDataProvider(DataType.Sql);
obj[columnConfig.Name] = dataProvider.GetValue(columnConfig, obj, null);
}
return(obj);
}
public TableInfoBuilder(DatabaseConfig dbConfig, TableConfig tableConfig, IConfigValidator configValidator, IWhereConditionValidator whereConditionValidator,
ILinkedServerValidator linkedServerValidator, IColumnTypeManager columnTypeManager, IPrimaryKeyManager primaryKeyManager)
{
TableConfig = tableConfig;
DatabaseConfig = dbConfig;
_configValidator = configValidator;
_whereConditionValidator = whereConditionValidator;
_columnTypeManager = columnTypeManager;
_linkedServerValidator = linkedServerValidator;
_primaryKeyManager = primaryKeyManager;
}
/// <summary>
/// Updates the status of table for booking
/// </summary>
/// <param name="tableNo"></param>
/// <param name="status"></param>
/// <returns></returns>
public bool TableStatus(int tableNo, bool status)
{ //Parcel Facility Table 999 is reserved for Parcel
if (tableNo != parcelTable)
{
TableConfig tableConfig = db.TableConfigs.Where(x => x.TableID == tableNo).FirstOrDefault();
tableConfig.TableStatus = status;
db.Entry(tableConfig).State = EntityState.Modified;
db.SaveChanges();
}
return(true);
}
private void TypeListAddCallback(ReorderableList list)
{
_tempTableConfig = new TableConfig();
_tempTableConfig.HasPrimaryKey = true;
_typeInfoList = new ReorderableList(_tempTableConfig.FieldList, typeof(FieldConfig), true, true, true, false);
_typeInfoList.elementHeight = 80;
_typeInfoList.drawHeaderCallback = TypeInfoListDrawHeaderCallback;
_typeInfoList.drawElementCallback = TypeInfoListDrawElementCallback;
_typeInfoList.onAddCallback = TypeInfoListAddCallback;
TSDatabaseUtils.TableConfigSerializeData.TableConfigList.Add(_tempTableConfig);
}
public SqlBuilder(TableConfig <T> tableConfig, T entity)
{
_tableConfig = tableConfig;
_entity = entity;
_parameters = new Dictionary <string, QueryPart>();
_parametersMulti = new Dictionary <string, MultiQueryPart>();
_parameterLists = new Dictionary <string, List <string> >();
_orderBy = new List <string>();
_groupBy = new List <string>();
_query = new StringBuilder();
}
public void Show <T>(object aimObj, TableConfig cfg)
{
this._aimObj = aimObj;
this._cfg = cfg;
Type t = aimObj.GetType();
PropertyInfo pi = t.GetProperty(cfg.Name);
selectList = (List <double>)pi.GetValue(aimObj);
skillList = Editor_TableTool.GetData <T>();
base.Show();
}
/// <summary>
/// Masks the specified object with new data
/// </summary>
/// <param name="obj">The object to mask</param>
/// <param name="tableConfig">The table configuration.</param>
/// <returns></returns>
public IDictionary <string, object> Mask(
IDictionary <string, object> obj,
TableConfig tableConfig)
{
foreach (ColumnConfig columnConfig in tableConfig.Columns.Where(x => !x.Ignore && x.Type != DataType.Computed))
{
object existingValue = obj[columnConfig.Name];
Name.Gender?gender = null;
if (!string.IsNullOrEmpty(columnConfig.UseGenderColumn))
{
object g = obj[columnConfig.UseGenderColumn];
gender = Utils.Utils.TryParseGender(g?.ToString());
}
if (columnConfig.Unique)
{
existingValue = GetUniqueValue(tableConfig.Name, columnConfig, existingValue, gender);
}
else
{
existingValue = _dataGenerator.GetValue(columnConfig, existingValue, gender);
}
//replace the original value
obj[columnConfig.Name] = existingValue;
}
foreach (ColumnConfig columnConfig in tableConfig.Columns.Where(x => !x.Ignore && x.Type == DataType.Computed))
{
var separator = columnConfig.Separator ?? " ";
StringBuilder colValue = new StringBuilder();
bool first = true;
foreach (var sourceColumn in columnConfig.SourceColumns)
{
if (!obj.ContainsKey(sourceColumn))
{
throw new Exception($"Source column {sourceColumn} could not be found.");
}
if (first)
{
first = false;
}
else
{
colValue.Append(separator);
}
colValue.Append(obj[sourceColumn] ?? String.Empty);
}
obj[columnConfig.Name] = colValue.ToString();
}
return(obj);
}
public EntityInfo DelayAddEntity(int unitId, int camp, TableConfig.Actor cfg, int ai, params string[] aiParams)
{
EntityInfo entity = NewEntityInfo();
entity.SceneContext = m_SceneContext;
entity.LoadData(unitId, camp, cfg, ai, aiParams);
entity.IsBorning = true;
entity.BornTime = 0;
entity.SetAIEnable(false);
entity.SetStateFlag(Operate_Type.OT_AddBit, CharacterState_Type.CST_Invincible);
m_DelayAdd.Add(entity);
return entity;
}
/// <summary>
/// 删除配置
/// </summary>
public void DeleteTableConfig()
{
try
{
TableConfig config = GetEditedTableConfig();
TableAndFieldConfig.DeleteTableConfig(config);
}
catch (Exception err)
{
throw err;
}
}
public void CopyFrom(TableConfig.Skill skill)
{
id = skill.id;
desc = skill.desc;
type = skill.type;
icon = skill.icon;
distance = skill.distance;
duration = skill.duration;
interval = skill.interval;
canmove = skill.canmove;
impacttoself = skill.impacttoself;
impact = skill.impact;
interruptPriority = skill.interruptPriority;
isInterrupt = skill.isInterrupt;
targetType = skill.targetType;
aoeType = skill.aoeType;
aoeSize = skill.aoeSize;
aoeAngleOrLength = skill.aoeAngleOrLength;
maxAoeTargetCount = skill.maxAoeTargetCount;
dslSkillId = skill.dslSkillId;
dslFile = skill.dslFile;
startupSkillId = skill.startupSkillId;
flybackSkillId = skill.flybackSkillId;
startupPositionType = skill.startupPositionType;
autoCast = skill.autoCast;
needTarget = skill.needTarget;
cooldown = skill.cooldown;
damage = skill.damage;
addhp = skill.addhp;
addmp = skill.addmp;
addattack = skill.addattack;
adddefence = skill.adddefence;
addshield = skill.addshield;
addspeed = skill.addspeed;
addcritical = skill.addcritical;
addcriticalpow = skill.addcriticalpow;
addrps = skill.addrps;
subsequentSkills.Clear();
subsequentSkills.AddRange(skill.subsequentSkills);
resources.Clear();
foreach (var pair in skill.resources) {
SkillResource res = new SkillResource();
res.Key = pair.Key;
res.Resource = pair.Value;
resources.Add(res);
}
}
public void Draw_CustomTableConfig_Success()
{
// Arrange
List<TestEntity> testData = new List<TestEntity>
{
new TestEntity { Id = 1, Value = "Short" },
new TestEntity { Id = 2, Value = "Loooooooooooong" },
};
Table<TestEntity> table = new Table<TestEntity>
{
Columns =
{
new Column<TestEntity>("Id", c => c.Id.ToString()),
new Column<TestEntity>("Value", c => c.Value),
},
};
TestWriter<TestEntity> testWriter = new TestWriter<TestEntity>(this.Writer);
TableConfig customTableConfig = new TableConfig
{
BottomLeftCharacter = '#',
HorizontalBottomJointCharacter = '#',
BottomRightCharacter = '#',
HorizontalCharacter = '#',
HorizontalTopJointCharacter = '#',
IntersectionJointCharacter = '#',
TopLeftCharacter = '#',
TopRightCharacter = '#',
VerticalCharacter = '#',
VerticalLeftJointCharacter = '#',
VerticalRightJointCharacter = '#',
};
// Act
testWriter.Draw(table, testData, customTableConfig);
// Assert
var result = this.Writer.ToString();
result.Should().NotBeNullOrWhiteSpace("Draw should render the table.");
var lines = result.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
lines.Length.Should().Be(6, "Draw should generate the correct number of lines.");
lines[0].Should().Be("########################");
lines[1].Should().Be("# Id # Value #");
lines[2].Should().Be("########################");
lines[3].Should().Be("# 1 # Short #");
lines[4].Should().Be("# 2 # Loooooooooooong #");
lines[5].Should().Be("########################");
}
private void TypeListDrawHeaderCallback(Rect rect)
{
rect.width -= 30;
EditorGUI.LabelField(rect, LanguageUtils.CreateListHead);
rect.x = rect.xMax + 5;
rect.width = 30;
if (GUI.Button(rect, "", "OL Plus"))
{
_tempTableConfig = new TableConfig();
_tempTableConfig.HasPrimaryKey = true;
TSDatabaseUtils.TableConfigSerializeData.TableConfigList.Add(_tempTableConfig);
}
}
/// <summary>
/// Add Table Method adds new table to the Table
/// It checks the Table if the inputed table is already present if present it returns false
/// if not then updates the database.
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public bool AddTable(TableViewModel table)
{
TableConfig tableConfig = db.TableConfigs.Where(x => x.TableID == table.TableID).FirstOrDefault();
if (tableConfig != null)
{
return(false);
}
tableConfig = Mapper.Map <TableViewModel, TableConfig>(table);
db.TableConfigs.Add(tableConfig);
db.SaveChanges();
return(true);
}
/// <inheritdoc/>
public void UpdateRows(
IEnumerable <IDictionary <string, object> > rows,
int rowCount,
TableConfig config,
Action <int> updatedCallback)
{
int?batchSize = _sourceConfig.UpdateBatchSize;
if (batchSize == null ||
batchSize <= 0)
{
batchSize = rowCount;
}
IEnumerable <Batch <IDictionary <string, object> > > batches = Batch <IDictionary <string, object> > .BatchItems(
rows,
(
objects,
enumerable) => enumerable.Count() < batchSize);
int totalUpdated = 0;
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
foreach (Batch <IDictionary <string, object> > batch in batches)
{
SqlTransaction sqlTransaction = connection.BeginTransaction();
string sql = BuildUpdateSql(config);
connection.Execute(sql, batch.Items, sqlTransaction, null, CommandType.Text);
if (_sourceConfig.DryRun)
{
sqlTransaction.Rollback();
}
else
{
sqlTransaction.Commit();
}
if (updatedCallback != null)
{
totalUpdated += batch.Items.Count;
updatedCallback.Invoke(totalUpdated);
}
}
}
}
public override bool AreTheParamsValid(string connectionString, TableConfig tableConfig)
{
bool doConstantScrambledDuplicatesExist;
bool doAllColumnsExist;
bool doAllPairedColumnsInsideExist;
bool doAllPairedColumnsOutsideExist;
bool isThereAPrimaryKeyConflict;
bool isThereAUniqueConstraintConflict;
DataTable schemaTable;
try
{
schemaTable = GetTableSchema(connectionString, tableConfig.FullTableName);
}
catch (SqlException ex)
{
Log.Error($"Error while checking the parameters of table: {tableConfig.FullTableName}. " +
$"Connection string: {connectionString}. " +
$"The mapped database {connectionString} or table {tableConfig.FullTableName} doesn't exist or it is unreachable. " +
$"Error message: {ex.Message}");
return(false);
}
var loggingInfo = new LoggingInfo {
ConnectionString = connectionString, TableNameWithSchema = tableConfig.FullTableName
};
var constantColumns = tableConfig.ConstantColumns?.Select(c => c.Name)
.Select(c => ParameterNameHelper.RemoveParenthesises(c)) ?? new List <string>();
var scrambledColumns = tableConfig.ScrambledColumns?.Select(c => c.Name)
.Select(c => ParameterNameHelper.RemoveParenthesises(c)) ?? new List <string>();
var pairedColumns = tableConfig.PairedColumnsInsideTable?
.Select(cl =>
cl.Select(c => ParameterNameHelper.RemoveParenthesises(c)).ToList()).ToList() ?? new List <List <string> >();
var allColumns = constantColumns.Concat(scrambledColumns);
doConstantScrambledDuplicatesExist = DoConstantScrambledDuplicatesExist(loggingInfo, scrambledColumns, constantColumns);
doAllColumnsExist = DoAllColumnsExist(schemaTable, loggingInfo, allColumns);
doAllPairedColumnsInsideExist = DoAllPairedColumnsInsideExist(loggingInfo, schemaTable, pairedColumns);
doAllPairedColumnsOutsideExist = DoAllPairedColumnsOutsideExist(connectionString, tableConfig);
isThereAPrimaryKeyConflict = IsThereAPrimaryKeyConflict(schemaTable, loggingInfo, allColumns);
isThereAUniqueConstraintConflict = IsThereAUniqueConstraintConflict(schemaTable, loggingInfo, allColumns);
return(!doConstantScrambledDuplicatesExist && doAllColumnsExist && doAllPairedColumnsInsideExist &&
doAllPairedColumnsOutsideExist && !isThereAPrimaryKeyConflict && !isThereAUniqueConstraintConflict);
}
/// <summary>
/// Loads the <see cref="ForeignKeyAttribute"/>.
/// </summary>
/// <param name="tableConfig">The table configuration.</param>
protected virtual void LoadForeignKeyAttribute(TableConfig tableConfig)
{
foreach (PropertyData property in tableConfig.Properties.Where(x => !x.IsIgnored && !x.IsNested))
{
if (property.IsColumn)
{
ForeignKeyAttribute[] keys = property.Info.GetCustomAttributes <ForeignKeyAttribute>().ToArray();
if (keys.Length > 0)
{
tableConfig.ForeignKeys.Add(property.FullName);
if (!tableConfig.ColumnNames.ContainsKey(property.FullName) &&
keys.Any(x => !string.IsNullOrEmpty(x.Name)))
{
if (keys.Length > 1)
{
throw new InvalidConfigurationException($"Invalid multiple foreign key for property "
+ $"\"{property.FullName}\" of the type \"{tableConfig.Type}\".");
}
else
{
tableConfig.ColumnNames.Add(property.FullName, keys[0].Name);
}
}
}
}
// If there are not other properties
else if (!tableConfig.ForeignKeys.Where(x => x.StartsWith($"{property.FullName}.")).Any())
{
ForeignKeyAttribute[] keys = property.Info.GetCustomAttributes <ForeignKeyAttribute>().ToArray();
if (keys.Length > 1 && keys.Any(x => string.IsNullOrEmpty(x.PropertyName)))
{
throw new InvalidConfigurationException($"Empty property name in multiple foreign key "
+ $"for property \"{property.FullName}\" of the type \"{tableConfig.Type}\".");
}
foreach (ForeignKeyAttribute foreignKeyAttr in keys)
{
string column = !string.IsNullOrEmpty(foreignKeyAttr.PropertyName)
? $"{property.FullName}.{foreignKeyAttr.PropertyName}" : property.FullName;
tableConfig.ForeignKeys.Add(column);
if (!string.IsNullOrEmpty(foreignKeyAttr.Name) && !tableConfig.ColumnNames.ContainsKey(column))
{
tableConfig.ColumnNames.Add(column, foreignKeyAttr.Name);
}
}
}
}
}
/// <summary>
/// Adds a table to the card.
/// </summary>
/// <param name="configAction">Action to perform table configuration.</param>
/// <returns>The card builder instance.</returns>
public MvcCoreBootstrapCardBuilder Table <T>(TableModel <T> model, Action <MvcCoreBootstrapTableBuilder <T> > configAction) where T : new()
{
TableState tableState = new TableStateParser().Parse(_httpContext);
_tableEntities = model.ProcessedEntities as IEnumerable <object>;
_tableConfig = new TableConfig();
_tableRenderer = new TableRenderer <T>(model, _tableConfig, tableState, new TableNodeParser());
configAction(new MvcCoreBootstrapTableBuilder <T>(model, new BuilderFactory(), _tableConfig));
_tableConfigHandler.Check(_tableConfig, _tableEntities);
_tableConfig.ContainerId = _config.Id;
return(this);
}
private void ValuesConfig_Load(object sender, EventArgs e)
{
//GlobalVariables.dtConfig.DefaultView.RowFilter = "ConfigValue=1";
m_dt_config = TableConfig.getDataTableByRowFilter("IsShow=1");
m_configValue = m_dt_config.DefaultView;
// GlobalVariables.dtTagsSetFive.DefaultView.RowFilter = "";
m_configValue.Table.AcceptChanges();
m_configValue.RowFilter = "IsShow=1";
dataGridView1.AutoGenerateColumns = false;
dataGridView1.DataSource = m_configValue;
}
private void RemoveData(int removeIndex)
{
EditorUtility.DisplayProgressBar(LanguageUtils.CreateListDelete, LanguageUtils.CreateListDeleteing, 0f);
EditorApplication.LockReloadAssemblies();
TableConfig config = TSDatabaseUtils.TableConfigSerializeData.TableConfigList[removeIndex];
TSDatabaseUtils.TableConfigSerializeData.TableConfigList.RemoveAt(removeIndex);
if (!string.IsNullOrEmpty(config.DataPath))
{
File.Delete(Path.GetFullPath(config.DataPath));
if (TSDatabaseUtils.PrimaryKeySerializeData.PrimaryKeyDic.ContainsKey(config.TableName))
{
TSDatabaseUtils.PrimaryKeySerializeData.PrimaryKeyDic.Remove(config.TableName);
}
}
EditorUtility.DisplayProgressBar(LanguageUtils.CreateListDelete, LanguageUtils.CreateListDeleteing, 0.5f);
if (!string.IsNullOrEmpty(config.CodePath))
{
File.Delete(Path.GetFullPath(config.CodePath));
string editorPath = TSDatabaseUtils.EditorFullPath + "/TableEditor/" + config.TableName + "EditorData.cs";
if (File.Exists(editorPath))
{
File.Delete(editorPath);
}
string configPath = TSDatabaseUtils.EditorFullPath + "/Data/Table/" + config.TableName + "Config.cs";
if (File.Exists(configPath))
{
File.Delete(configPath);
}
string configDataPath = TSDatabaseUtils.EditorFullPath + "/Config/Table/" + config.TableName + "Config.asset";
if (File.Exists(configDataPath))
{
File.Delete(configDataPath);
}
}
EditorUtility.DisplayProgressBar(LanguageUtils.CreateListDelete, LanguageUtils.CreateListDeleteing, 1f);
EditorApplication.UnlockReloadAssemblies();
WriteConfig();
AssetDatabase.Refresh();
if (_tempTableConfig == config)
{
_typeList.index = -1;
_typeList.onSelectCallback(_typeList);
//_tempTableConfig = null;
}
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog(LanguageUtils.CreateListDelete, LanguageUtils.CreateListDeleted, "OK");
}
internal void AddShield(int objId, TableConfig.Skill cfg, int seq)
{
EntityInfo entity = m_Scene.EntityManager.GetEntityInfo(objId);
if (null != entity) {
if (cfg.type == (int)SkillOrImpactType.Skill) {
entity.SetShield(Operate_Type.OT_Relative, cfg.addshield);
} else {
ImpactInfo impactInfo = entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
if (null != impactInfo) {
entity.SetShield(Operate_Type.OT_Relative, impactInfo.DamageData.AddShield);
}
}
}
}
public static void DrawGroupList(TableConfig config, PropertyInfo f, object o, Dictionary <string, TableConfig> dict)
{
DrawGroupListTitle(config, o, dict);
var value = f.GetValue(o);
Type type = f.PropertyType;
Type genericType = type.GetGenericArguments()[0];
int count = Convert.ToInt32(type.GetProperty("Count").GetValue(value, null));
if (count == 0)
{
if (GUILayout.Button("创建一行属性"))
{
MethodInfo methodInfo = f.PropertyType.GetMethod("Add");
var parentValue = f.GetValue(o);
if (genericType.Equals(typeof(string)))
{
methodInfo.Invoke(parentValue, new object[] { default(string) });
}
else if (genericType.Equals(typeof(double)))
{
methodInfo.Invoke(parentValue, new object[] { default(double) });
}
foreach (string child in config.ParameterList)
{
PropertyInfo fi = o.GetType().GetProperty(child);
var childValue = fi.GetValue(o);
Type childType = fi.PropertyType.GetGenericArguments()[0];
MethodInfo childMethod = fi.PropertyType.GetMethod("Add");
if (childType.Equals(typeof(string)))
{
childMethod.Invoke(childValue, new object[] { default(string) });
}
else if (childType.Equals(typeof(double)))
{
childMethod.Invoke(childValue, new object[] { default(double) });
}
}
}
}
else
{
for (int i = 0; i < count; i++)
{
DrawGroupListItem(f, o, i, config);
count = Convert.ToInt32(type.GetProperty("Count").GetValue(value, null));
}
}
}
/// <summary>
/// Loads the member metadata.
/// </summary>
/// <param name="tableConfig">The table configuration.</param>
/// <param name="tableInfo">The table information.</param>
/// <param name="parentInfo">The parent class table information.</param>
protected virtual void LoadMemberMetadata(TableConfig tableConfig, TableInfo tableInfo, TableInfo parentInfo)
{
foreach (var memberItem in tableConfig.MemberMetadata)
{
bool addMetadata = !tableInfo.MemberMetadata.TryGetValue(memberItem.Key, out var memberMetadata);
if (addMetadata)
{
memberMetadata = new Dictionary <string, object>();
}
foreach (var item in memberItem.Value.Where(x => !IsIgnore(x.Key)))
{
if (!memberMetadata.ContainsKey(item.Key))
{
memberMetadata.Add(item.Key, item.Value);
}
}
if (addMetadata && memberMetadata.Any())
{
tableInfo.MemberMetadata.Add(memberItem.Key, memberMetadata);
}
}
if (parentInfo != null)
{
foreach (var memberItem in parentInfo.MemberMetadata)
{
IDictionary <string, object> memberMetadata = null;
foreach (var item in memberItem.Value.Where(x => !IsIgnore(x.Key)))
{
if (IsInheritMember(tableConfig, item.Key))
{
if (memberMetadata == null &&
!tableInfo.MemberMetadata.TryGetValue(memberItem.Key, out memberMetadata))
{
memberMetadata = new Dictionary <string, object>();
tableInfo.MemberMetadata.Add(memberItem.Key, memberMetadata);
}
if (!memberMetadata.ContainsKey(item.Key))
{
memberMetadata.Add(item.Key, item.Value);
}
}
}
}
}
}
private static void Execute(
Config config)
{
WriteLine("Masking Data");
UpdateProgress(ProgressType.Overall, 0, config.Tables.Count, "Overall Progress");
var dataProviders = new List <IDataProvider>();
dataProviders.Add(new BogusDataProvider(config.DataGeneration));
dataProviders.Add(new SqlDataProvider(new System.Data.SqlClient.SqlConnection(config.DataSource.Config.connectionString.ToString())));
//create a data masker
IDataMasker dataMasker = new DataMasker(dataProviders);
//grab our dataSource from the config, note: you could just ignore the config.DataSource.Type
//and initialize your own instance
IDataSource dataSource = DataSourceProvider.Provide(config.DataSource.Type, config.DataSource);
for (int i = 0; i < config.Tables.Count; i++)
{
TableConfig tableConfig = config.Tables[i];
var rowCount = dataSource.GetCount(tableConfig);
UpdateProgress(ProgressType.Masking, 0, (int)rowCount, "Masking Progress");
UpdateProgress(ProgressType.Updating, 0, (int)rowCount, "Update Progress");
IEnumerable <IDictionary <string, object> > rows = dataSource.GetData(tableConfig);
int rowIndex = 0;
var maskedRows = rows.Select(row =>
{
rowIndex++;
//update per row, or see below,
//dataSource.UpdateRow(row, tableConfig);
UpdateProgress(ProgressType.Masking, rowIndex);
return(dataMasker.Mask(row, tableConfig));
});
//update all rows
dataSource.UpdateRows(maskedRows, rowCount, tableConfig, totalUpdated => UpdateProgress(ProgressType.Updating, totalUpdated));
UpdateProgress(ProgressType.Overall, i + 1);
}
WriteLine("Done");
}
public ActionResult Index()
{
var config = new TableConfig()
{
ColumnDef = new List <ColumnData>()
{
new ColumnData()
{
Caption = "First Name", Field = "firstName"
},
new ColumnData()
{
Caption = "Last Name", Field = "lastName"
},
new ColumnData()
{
Caption = "Age", Field = "age"
},
new ColumnData()
{
Caption = "Address", Field = "address"
},
new ColumnData()
{
Caption = "Country", Field = "country"
},
},
ChildColumnDef = new List <ColumnData>()
{
new ColumnData()
{
Caption = "Title", Field = "title"
},
new ColumnData()
{
Caption = "Description", Field = "description"
},
new ColumnData()
{
Caption = "Date", Field = "date"
},
},
DeleteUrl = Url.Action("DeleteEmployee"),
SubmitUrl = Url.Action("SaveEmployees"),
LoadDataUrl = Url.Action("LoadEmployees"),
};
return(View(config));
}
public static string ConstructorParams(this TableConfig table, bool pascal = true)
{
StringBuilder str = new StringBuilder();
if (table == null)
{
throw new AggregateException("table为空");
}
foreach (var item in table.ColumnConfig)
{
string fieldName = item.PropName.ProcessingFieldName(pascal);
str.Append($"{item.CsType} {fieldName.Substring(0, 1).ToLower()}{fieldName.Substring(1)},");
}
return(str.ToString().TrimEnd(','));
}
public static int GetFieldSortOrder(String strTableName, String strColName)
{
TableConfig tableConfig = null;
if (TableConfigList.TryGetValue(strTableName, out tableConfig))
{
FieldConfig colConfig = null;
if (tableConfig.FieldConfigList.TryGetValue(strColName, out colConfig))
{
return(colConfig.SortOrder);
}
}
return(-1);
}
/// <summary>
/// Loads the table name.
/// </summary>
/// <param name="tableConfig">The table configuration.</param>
/// <param name="tableInfo">The table information.</param>
/// <param name="parentInfo">The parent class table information.</param>
protected virtual void LoadTableName(TableConfig tableConfig, TableInfo tableInfo, TableInfo parentInfo)
{
if (tableConfig.InheritTable == true)
{
tableInfo.TableName = parentInfo.TableName;
}
else if (!string.IsNullOrEmpty(tableConfig.TableName))
{
tableInfo.TableName = tableConfig.TableName;
}
else
{
tableInfo.TableName = ConfigData.TableNameDefault(tableConfig.Type);
}
}
public void OnLevelWasLoaded(TableConfig.Level level)
{
camera = Camera.main;
cameraSetting = camera.gameObject.GetComponent<SkillViewerCameraSetting>();
if (cameraSetting == null) {
cameraSetting = camera.gameObject.AddComponent<SkillViewerCameraSetting>();
}
//camera.transform.rotation = cameraSetting.GetRotation();// 注释掉，临时让摄像机设置不起作用 peterdou
SetState(State.Lookat);
followPose.pos = camera.transform.position;
followPose.rot = camera.transform.rotation;
fixPose.pos = camera.transform.position;
fixPose.rot = camera.transform.rotation;
}
/// <summary>
/// Loads the <see cref="ColumnAttribute"/>.
/// </summary>
/// <param name="tableConfig">The table configuration.</param>
protected virtual void LoadColumnAttribute(TableConfig tableConfig)
{
foreach (PropertyData property in tableConfig.Properties.Where(x => !x.IsIgnored))
{
if (!tableConfig.ColumnNames.ContainsKey(property.FullName))
{
ColumnAttribute columnAttr = property.Info.GetCustomAttribute <ColumnAttribute>();
if (columnAttr != null)
{
tableConfig.ColumnNames.Add(property.FullName, columnAttr.Name);
}
}
}
}
void OnEnable()
{
if (_selectConfigIndex >= 0)
{
if (_selectConfigIndex >= TSDatabaseUtils.TableConfigSerializeData.TableConfigList.Count)
{
_selectConfigIndex = 0;
}
else
{
_tempTableConfig = TSDatabaseUtils.TableConfigSerializeData.TableConfigList[_selectConfigIndex];
}
}
_enumArray = TSDatabaseUtils.GetEnums();
}
public static string[] GetForeignKey(TableConfig config, string typeName)
{
List <string> keys = new List <string>();
keys.Add("");
for (int i = 0; i < TableConfigSerializeData.TableConfigList.Count; i++)
{
string name = TableConfigSerializeData.TableConfigList[i].TableName;
if (name != config.TableName && TableConfigSerializeData.TableConfigList[i].HasPrimaryKey && TableConfigSerializeData.TableConfigList[i].PrimaryType == typeName)
{
keys.Add(name);
}
}
return(keys.ToArray());
}
public static void DrawGroupListTitle(TableConfig config, object o, Dictionary <string, TableConfig> dict)
{
GUILayout.BeginHorizontal();
GUILayout.Label(config.Des);
foreach (string child in config.ParameterList)
{
FieldInfo fi = o.GetType().GetField(child, flag);
TableConfig t;
if (dict.TryGetValue(child, out t))
{
GUILayout.Label(t.Des);
}
}
GUILayout.EndHorizontal();
}
internal int GetTargetType(int actorId, TableConfig.Skill cfg, int seq)
{
if (cfg.type == (int)SkillOrImpactType.Skill) {
return cfg.targetType;
} else {
EntityViewModel view = GetEntityViewById(actorId);
if (null != view && null != view.Entity) {
EntityInfo entity = view.Entity;
ImpactInfo impactInfo = entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
if (null != impactInfo) {
return impactInfo.TargetType;
}
}
}
return 0;
}
private SkillInstanceInfo NewSkillInstance(int skillId, TableConfig.Skill skillData)
{
SkillInstanceInfo instInfo = GetUnusedSkillInstanceInfoFromPool(skillId);
if (null == instInfo) {
if (null != skillData) {
return NewSkillInstanceImpl(skillId, skillData);
} else {
GameFramework.LogSystem.Error("Can't find skill config, skill:{0} TableConfig.Skill is null!", skillId);
return null;
}
} else {
instInfo.m_IsUsed = true;
return instInfo;
}
}
private SkillInstanceInfo NewSkillInstanceImpl(int skillId, TableConfig.Skill skillData)
{
string filePath = GameFramework.HomePath.GetAbsolutePath(FilePathDefine_Server.C_DslPath + skillData.dslFile);
SkillConfigManager.Instance.LoadSkillIfNotExist(skillData.dslSkillId, filePath);
SkillInstance inst = SkillConfigManager.Instance.NewSkillInstance(skillData.dslSkillId);
if (inst == null) {
GameFramework.LogSystem.Error("Can't load skill config, skill:{0} dsl skill:{1}!", skillId, skillData.dslSkillId);
return null;
}
SkillInstanceInfo res = new SkillInstanceInfo();
res.m_SkillId = skillId;
res.m_SkillInstance = inst;
res.m_IsUsed = true;
AddSkillInstanceInfoToPool(skillId, res);
return res;
}
private bool TryInitImpactInfo(ImpactInfo impactInfo, TableConfig.Skill cfg, int seq, int curObjId, int srcObjId, Dictionary<string, object> args)
{
bool ret = false;
EntityInfo srcNpc = null;
EntityViewModel srcView = GetEntityViewById(srcObjId);
if (null != srcView && null != srcView.Entity) {
srcNpc = srcView.Entity;
}
impactInfo.StartTime = TimeUtility.GetLocalMilliseconds();
impactInfo.ImpactSenderId = srcObjId;
if (cfg.type == (int)SkillOrImpactType.Skill) {
impactInfo.SenderPosition = null != srcNpc ? srcNpc.GetMovementStateInfo().GetPosition3D() : ScriptRuntime.Vector3.Zero;
impactInfo.SkillId = cfg.id;
impactInfo.DurationTime = cfg.duration > 0 ? cfg.duration : impactInfo.ConfigData.duration;
impactInfo.TargetType = cfg.targetType;
impactInfo.DamageData.CopyFrom(cfg.damageData);
impactInfo.DamageData.Merge(impactInfo.ConfigData.damageData);
impactInfo.ImpactToTarget = cfg.impact;
ret = true;
} else {
ImpactInfo srcImpactInfo = null;
EntityViewModel myView = GetEntityViewById(curObjId);
if (null != myView && null != myView.Entity) {
srcImpactInfo = myView.Entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
}
if (null != srcImpactInfo) {
//如果当前技能配置有数据则继承当前配置数据，否则继承源impact记录的数据。
impactInfo.SenderPosition = srcImpactInfo.SenderPosition;
impactInfo.SkillId = srcImpactInfo.SkillId;
impactInfo.DurationTime = srcImpactInfo.DurationTime > 0 ? srcImpactInfo.DurationTime : impactInfo.ConfigData.duration;
impactInfo.TargetType = srcImpactInfo.TargetType;
impactInfo.DamageData.CopyFrom(srcImpactInfo.DamageData);
impactInfo.DamageData.Merge(impactInfo.ConfigData.damageData);
impactInfo.ImpactToTarget = cfg.impact != 0 ? cfg.impact : srcImpactInfo.ImpactToTarget;
ret = true;
}
}
return ret;
}
internal ImpactInfo TrackImpact(TableConfig.Skill cfg, int seq, int curObjId, int srcObjId, int targetId, string emitBone, int emitImpact, UnityEngine.Vector3 offset, bool isFinal, Dictionary<string, object> args)
{
EntityViewModel view = GetEntityViewById(targetId);
EntityViewModel srcView = GetEntityViewById(srcObjId);
if (null != view && null != view.Entity && null != view.Actor && !view.Entity.IsDeadSkillCasting()) {
EntityInfo npc = view.Entity;
if (null != cfg) {
ImpactInfo impactInfo = null;
if (emitImpact <= 0 || emitImpact >= SkillInstance.c_FirstInnerEmitSkillId) {
impactInfo = new ImpactInfo(PredefinedSkill.Instance.EmitSkillCfg);
} else {
impactInfo = new ImpactInfo(emitImpact);
}
if (TryInitImpactInfo(impactInfo, cfg, seq, curObjId, srcObjId, args)) {
UnityEngine.GameObject srcObj = GetGameObject(srcObjId);
if (null != srcObj) {
UnityEngine.Transform t = Utility.FindChildRecursive(srcObj.transform, emitBone);
if (null != t) {
UnityEngine.Vector3 pos = t.TransformPoint(offset);
impactInfo.SenderPosition = new ScriptRuntime.Vector3(pos.x, pos.y, pos.z);
} else {
UnityEngine.Vector3 pos = srcObj.transform.TransformPoint(offset);
pos.y += npc.GetRadius();
impactInfo.SenderPosition = new ScriptRuntime.Vector3(pos.x, pos.y, pos.z);
}
}
impactInfo.DamageData.IsFinal = isFinal;
npc.GetSkillStateInfo().AddImpact(impactInfo);
GfxSkillSystem.Instance.StartSkill(targetId, impactInfo.ConfigData, impactInfo.Seq, args);
return impactInfo;
}
}
}
return null;
}
private static void AddPredefinedSkill(TableConfig.Skill cfg, int id)
{
cfg.id = cfg.dslSkillId = id;
cfg.dslFile = "Skill/predefined.dsl";
//添加到技能表数据中
var skills = TableConfig.SkillProvider.Instance.SkillMgr.GetData();
skills[cfg.id] = cfg;
}
internal GfxSkillSenderInfo(TableConfig.Skill configData, int seq, int actorId, EntityInfo gfxObj, int targetActorId, EntityInfo targetGfxObj, Scene scene)
: this(configData, seq, actorId, gfxObj, scene)
{
m_TargetActorId = targetActorId;
m_TargetGfxObj = targetGfxObj;
}
internal bool StartSkill(int actorId, TableConfig.Skill configData, int seq, params Dictionary<string, object>[] locals)
{
bool ret = false;
if (null == configData) {
LogSystem.Error("{0} can't cast skill, config is null !", actorId, seq);
Helper.LogCallStack();
return false;
}
if (!m_Scene.EntityController.CanCastSkill(actorId, configData, seq)) {
m_Scene.EntityController.CancelCastSkill(actorId);
LogSystem.Warn("{0} can't cast skill {1} {2}, cancel.", actorId, configData.id, seq);
m_Scene.EntityController.CancelIfImpact(actorId, configData, seq);
return false;
}
GfxSkillSenderInfo senderInfo = m_Scene.EntityController.BuildSkillInfo(actorId, configData, seq, m_Scene);
if (null != senderInfo && null != senderInfo.GfxObj) {
int skillId = senderInfo.SkillId;
EntityInfo obj = senderInfo.GfxObj;
SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
if (logicInfo != null) {
LogSystem.Warn("{0} is casting skill {1} {2}, cancel.", actorId, skillId, seq);
m_Scene.EntityController.CancelIfImpact(actorId, configData, seq);
return false;
}
SkillInstanceInfo inst = null;
SkillInstance innerInstance = null;
if (skillId == PredefinedSkill.c_EmitSkillId) {
for (int i = 0; i < locals.Length; ++i) {
object instObj;
if (locals[i].TryGetValue("emitskill", out instObj)) {
innerInstance = instObj as SkillInstance;
}
}
if (null == innerInstance) {
LogSystem.Warn("{0} use predefined skill {1} {2} but not found emitskill, cancel.", actorId, skillId, seq);
//m_Scene.EntityController.CancelIfImpact(actorId, configData, seq);
//return false;
}
} else if (skillId == PredefinedSkill.c_HitSkillId) {
for (int i = 0; i < locals.Length; ++i) {
object instObj;
if (locals[i].TryGetValue("hitskill", out instObj)) {
innerInstance = instObj as SkillInstance;
}
}
if (null == innerInstance) {
LogSystem.Warn("{0} use predefined skill {1} {2} but not found hitskill, cancel.", actorId, skillId, seq);
//m_Scene.EntityController.CancelIfImpact(actorId, configData, seq);
//return false;
}
}
if (null == innerInstance) {
inst = NewSkillInstance(skillId, senderInfo.ConfigData);
} else {
inst = NewInnerSkillInstance(skillId, innerInstance);
}
if (null != inst) {
m_SkillLogicInfos.Add(new SkillLogicInfo(senderInfo, inst));
} else {
LogSystem.Warn("{0} cast skill {1} {2}, alloc failed.", actorId, skillId, seq);
m_Scene.EntityController.CancelIfImpact(actorId, configData, seq);
return false;
}
logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
if (null != logicInfo) {
if (null != locals) {
int localCount = locals.Length;
for (int i = 0; i < localCount; ++i) {
foreach (KeyValuePair<string, object> pair in locals[i]) {
logicInfo.SkillInst.SetVariable(pair.Key, pair.Value);
}
}
}
EntityInfo target = senderInfo.TargetGfxObj;
if (null != target && target != obj && configData.type == (int)SkillOrImpactType.Skill) {
TriggerUtil.Lookat(m_Scene, obj, target.GetMovementStateInfo().GetPosition3D());
}
m_Scene.EntityController.ActivateSkill(actorId, skillId, seq);
logicInfo.SkillInst.Context = m_Scene;
logicInfo.SkillInst.Start(logicInfo.Sender);
ret = true;
}
}
return ret;
}
internal void CancelIfImpact(int actorId, TableConfig.Skill cfg, int seq)
{
EntityViewModel view = GetEntityViewById(actorId);
if (null != view && null != view.Entity) {
if (cfg.type != (int)SkillOrImpactType.Skill) {
view.Entity.GetSkillStateInfo().RemoveImpact(seq);
}
}
}
internal bool CanCastSkill(int objId, TableConfig.Skill configData, int seq)
{
bool ret=true;
if (configData.type == (int)SkillOrImpactType.Skill) {
EntityViewModel view = GetEntityViewById(objId);
if (null != view && null != view.Entity) {
EntityInfo entity = view.Entity;
if (entity.GetSkillStateInfo().IsSkillActivated()) {
SkillInfo skillInfo = entity.GetSkillStateInfo().GetCurSkillInfo();
if (null != skillInfo && skillInfo.ConfigData.interruptPriority >= configData.interruptPriority) {
ret = false;
}
}
}
}
return ret;
}
internal GfxSkillSenderInfo BuildSkillInfo(int objId, TableConfig.Skill configData, int seq)
{
GfxSkillSenderInfo ret = null;
EntityViewModel view = GetEntityViewById(objId);
if (null != view && null != view.Actor && null != view.Entity && null != configData) {
EntityInfo entity = view.Entity;
int targetId = 0;
if (configData.type == (int)SkillOrImpactType.Skill) {
targetId = entity.GetAiStateInfo().Target;
} else {
ImpactInfo impactInfo = entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
if (null != impactInfo) {
targetId = impactInfo.ImpactSenderId;
}
}
UnityEngine.GameObject targetObj = GetGameObject(targetId);
if (null != targetObj) {
ret = new GfxSkillSenderInfo(configData, seq, objId, view.Actor, targetId, targetObj);
} else {
ret = new GfxSkillSenderInfo(configData, seq, objId, view.Actor);
}
}
return ret;
}
//-----------------------------------------------------------------------------------------------------------
public static void CalcImpactConfig(int emitImpact, int hitImpact, SkillInstance instance, TableConfig.Skill cfg, out Dictionary<string, object> result)
{
var variables = instance.Variables;
result = new Dictionary<string, object>(variables);
if (null != instance.EmitSkillInstances) {
if (emitImpact <= 0)
emitImpact = SkillInstance.c_FirstInnerEmitSkillId;
TableConfig.Skill impactCfg = TableConfig.SkillProvider.Instance.GetSkill(emitImpact);
if (null != impactCfg) {
if (impactCfg.type == (int)SkillOrImpactType.Buff) {
emitImpact = SkillInstance.c_FirstInnerEmitSkillId;
}
}
SkillInstance val;
if (instance.EmitSkillInstances.TryGetValue(emitImpact, out val)) {
result["emitskill"] = val;
}
}
if (null != instance.HitSkillInstances) {
if (hitImpact <= 0)
hitImpact = SkillInstance.c_FirstInnerHitSkillId;
TableConfig.Skill impactCfg = TableConfig.SkillProvider.Instance.GetSkill(hitImpact); ;
if (null != impactCfg) {
if (impactCfg.type == (int)SkillOrImpactType.Buff) {
hitImpact = SkillInstance.c_FirstInnerHitSkillId;
}
}
SkillInstance val;
if (instance.HitSkillInstances.TryGetValue(hitImpact, out val)) {
result["hitskill"] = val;
}
}
string hitEffect = SkillParamUtility.RefixResourceVariable("hitEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect)) {
result["hitEffect"] = hitEffect;
}
string hitEffect1 = SkillParamUtility.RefixResourceVariable("hitEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect1)) {
result["hitEffect1"] = hitEffect1;
}
string hitEffect2 = SkillParamUtility.RefixResourceVariable("hitEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect2)) {
result["hitEffect2"] = hitEffect2;
}
string hitEffect3 = SkillParamUtility.RefixResourceVariable("hitEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect3)) {
result["hitEffect3"] = hitEffect3;
}
string emitEffect = SkillParamUtility.RefixResourceVariable("emitEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect)) {
result["emitEffect"] = emitEffect;
}
string emitEffect1 = SkillParamUtility.RefixResourceVariable("emitEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect1)) {
result["emitEffect1"] = emitEffect1;
}
string emitEffect2 = SkillParamUtility.RefixResourceVariable("emitEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect2)) {
result["emitEffect2"] = emitEffect2;
}
string emitEffect3 = SkillParamUtility.RefixResourceVariable("emitEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect3)) {
result["emitEffect3"] = emitEffect3;
}
string targetEffect = SkillParamUtility.RefixResourceVariable("targetEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect)) {
result["targetEffect"] = targetEffect;
}
string targetEffect1 = SkillParamUtility.RefixResourceVariable("targetEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect1)) {
result["targetEffect1"] = targetEffect1;
}
string targetEffect2 = SkillParamUtility.RefixResourceVariable("targetEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect2)) {
result["targetEffect2"] = targetEffect2;
}
string targetEffect3 = SkillParamUtility.RefixResourceVariable("targetEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect3)) {
result["targetEffect3"] = targetEffect3;
}
string selfEffect = SkillParamUtility.RefixResourceVariable("selfEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect)) {
result["selfEffect"] = selfEffect;
}
string selfEffect1 = SkillParamUtility.RefixResourceVariable("selfEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect1)) {
result["selfEffect1"] = selfEffect1;
}
string selfEffect2 = SkillParamUtility.RefixResourceVariable("selfEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect2)) {
result["selfEffect2"] = selfEffect2;
}
string selfEffect3 = SkillParamUtility.RefixResourceVariable("selfEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect3)) {
result["selfEffect3"] = selfEffect3;
}
}
public static int GetSkillImpactId(Dictionary<string, object> variables, TableConfig.Skill cfg)
{
int impactId = 0;
object idObj;
if (variables.TryGetValue("impact", out idObj)) {
impactId = (int)idObj;
}
return impactId;
}
internal void PreloadSkillInstance(TableConfig.Skill skillData)
{
if (null != skillData) {
SkillInstanceInfo info = NewSkillInstanceImpl(skillData.id, skillData);
RecycleSkillInstance(info);
if (null != info.m_SkillInstance.EmitSkillInstances) {
foreach (var pair in info.m_SkillInstance.EmitSkillInstances) {
SkillInstanceInfo iinfo = NewInnerSkillInstanceImpl(PredefinedSkill.c_EmitSkillId, pair.Value);
RecycleSkillInstance(iinfo);
}
}
if (null != info.m_SkillInstance.HitSkillInstances) {
foreach (var pair in info.m_SkillInstance.HitSkillInstances) {
SkillInstanceInfo iinfo = NewInnerSkillInstanceImpl(PredefinedSkill.c_HitSkillId, pair.Value);
RecycleSkillInstance(iinfo);
}
}
}
}
internal void RemoveShield(int objId, TableConfig.Skill cfg, int seq)
{
EntityViewModel view = GetEntityViewById(objId);
if (null != view && null != view.Entity) {
EntityInfo entity = view.Entity;
if (cfg.type == (int)SkillOrImpactType.Skill) {
entity.SetShield(Operate_Type.OT_Absolute, 0);
} else {
ImpactInfo impactInfo = entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
if (null != impactInfo) {
entity.SetShield(Operate_Type.OT_Absolute, 0);
}
}
}
}
internal int SelectTargetForSkill(string type, int actorId, TableConfig.Skill cfg, int seq, HashSet<int> history)
{
if (string.IsNullOrEmpty(type))
return 0;
EntityViewModel view = GetEntityViewById(actorId);
if(null!=view && null!=view.Entity){
EntityInfo entity = view.Entity;
int campId = entity.GetCampId();
if (type.CompareTo("minhp") == 0) {
int targetId = 0;
float minhp = float.MaxValue;
ScriptRuntime.Vector3 pos = entity.GetMovementStateInfo().GetPosition3D();
ClientModule.Instance.KdTree.Query(pos, cfg.distance, (float distSqr, KdTreeObject kdObj) => {
if (minhp > kdObj.Object.Hp && EntityInfo.GetRelation(campId, kdObj.Object.GetCampId()) == CharacterRelation.RELATION_ENEMY) {
int objId = kdObj.Object.GetId();
if (!history.Contains(objId)) {
minhp = kdObj.Object.Hp;
targetId = objId;
}
}
});
return targetId;
} else if (type.CompareTo("maxdist") == 0) {
int targetId = 0;
float maxDistSqr = 0;
ScriptRuntime.Vector3 pos = entity.GetMovementStateInfo().GetPosition3D();
ClientModule.Instance.KdTree.Query(pos, cfg.distance, (float distSqr, KdTreeObject kdObj) => {
if (maxDistSqr < distSqr && EntityInfo.GetRelation(campId, kdObj.Object.GetCampId()) == CharacterRelation.RELATION_ENEMY) {
int objId = kdObj.Object.GetId();
if (!history.Contains(objId)) {
maxDistSqr = distSqr;
targetId = objId;
}
}
});
return targetId;
} else if (type.CompareTo("randenemy") == 0) {
return GetRandEnemyId(campId, history);
} else if (type.CompareTo("randfriend") == 0) {
return GetRandFriendId(campId, history);
}
}
return 0;
}
internal ImpactInfo SendImpact(TableConfig.Skill cfg, int seq, int curObjId, int srcObjId, int targetId, int impactId, bool isFinal, Dictionary<string, object> args)
{
EntityViewModel view = GetEntityViewById(targetId);
if (null != view && null != view.Entity && null != view.Actor && !view.Entity.IsDeadSkillCasting()) {
EntityInfo npc = view.Entity;
if (null != cfg) {
UnityEngine.Quaternion hitEffectRotation = UnityEngine.Quaternion.identity;
UnityEngine.GameObject srcObj = GetGameObject(srcObjId);
UnityEngine.GameObject targetObj = view.Actor;
if (null != srcObj && null != targetObj) {
hitEffectRotation = srcObj.transform.localRotation;
}
var addArgs = new Dictionary<string, object> { { "hitEffectRotation", hitEffectRotation } };
ImpactInfo impactInfo = null;
if (impactId <= 0 || impactId >= SkillInstance.c_FirstInnerHitSkillId) {
impactInfo = new ImpactInfo(PredefinedSkill.Instance.HitSkillCfg);
impactId = PredefinedSkill.c_HitSkillId;
} else {
impactInfo = new ImpactInfo(impactId);
}
if (null != impactInfo.ConfigData) {
if (TryInitImpactInfo(impactInfo, cfg, seq, curObjId, srcObjId, args)) {
if (impactInfo.ConfigData.type == (int)SkillOrImpactType.Buff) {
ImpactInfo oldImpactInfo = npc.GetSkillStateInfo().FindImpactInfoById(impactInfo.ImpactId);
if (null != oldImpactInfo) {
oldImpactInfo.DurationTime += impactInfo.DurationTime;
return oldImpactInfo;
}
}
impactInfo.DamageData.IsFinal = isFinal;
npc.GetSkillStateInfo().AddImpact(impactInfo);
SkillInfo skillInfo = npc.GetSkillStateInfo().GetCurSkillInfo();
if (null != skillInfo && (cfg.isInterrupt || impactInfo.ConfigData.isInterrupt)) {
GfxSkillSystem.Instance.StopSkill(targetId, skillInfo.SkillId, 0, true);
}
GfxSkillSystem.Instance.StartSkill(targetId, impactInfo.ConfigData, impactInfo.Seq, args, addArgs);
return impactInfo;
}
} else {
LogSystem.Error("impact {0} config can't found !", impactInfo.ImpactId);
}
}
}
return null;
}
private IEnumerator LoadLevel(TableConfig.Level lvl)
{
HighlightPromptManager.Instance.Release();
BattleTopMenuManager.Instance.Release();
SkillBarManager.Instance.Release();
OverHeadBarManager.Instance.Release();
m_CameraController = null;
yield return null;
yield return UnityEngine.SceneManagement.SceneManager.LoadSceneAsync("Loading");
yield return Resources.UnloadUnusedAssets();
yield return UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(lvl.prefab);
ClientModule.Instance.OnSceneLoaded(lvl);
Utility.EventSystem.Publish("loading_complete","ui",null);
}
public static bool GetSkillStartPosition(Vector3 srcPos, TableConfig.Skill cfg, SkillInstance instance, int srcId, int targetId, ref Vector3 targetPos)
{
ScriptRuntime.Vector3 pos;
object posVal;
if (instance.Variables.TryGetValue("skill_targetpos", out posVal)) {
pos = (ScriptRuntime.Vector3)posVal;
targetPos = new Vector3(pos.X, pos.Y, pos.Z);
return true;
}
if (instance.Variables.TryGetValue("skill_homepos", out posVal)) {
pos = (ScriptRuntime.Vector3)posVal;
targetPos = new Vector3(pos.X, pos.Y, pos.Z);
return true;
}
float dist = cfg.distance;
if (dist <= Geometry.c_FloatPrecision) {
object val;
if (instance.Variables.TryGetValue("skill_distance", out val)) {
dist = (float)Convert.ChangeType(val, typeof(float));
} else {
dist = EntityController.Instance.CalcSkillDistance(dist, srcId, targetId);
}
} else {
dist = EntityController.Instance.CalcSkillDistance(dist, srcId, targetId);
}
if (dist <= Geometry.c_FloatPrecision) {
dist = 0.1f;
}
float dir;
if (EntityController.Instance.CalcPosAndDir(targetId, out pos, out dir)) {
pos += Geometry.GetRotate(new ScriptRuntime.Vector3(0, 0, dist), dir);
targetPos = new Vector3(pos.X, pos.Y, pos.Z);
return true;
}
return false;
}
