public static int GetStatDefault(StatsRow statsRow) { if (statsRow.valTable != -1) return -1; // if it's a table stat, then return -1 for no row set // if a normal stat, then let's assuming 0 is default - we'll work in raw values, so apply offset(s) int retValue = statsRow.valOffs; if (statsRow.valOffs != 0 && statsRow.valShift != 0) { Debug.Assert(statsRow.valShift == 0); // not sure what to do if a stat has an offset and a shift... (shift then offset, or offset then shift?) } return retValue; }
private Stat _AddStat(StatsRow statsRow, int value, params int[] paramValues) { Stat stat; lock (Stats) { if (Stats.TryGetValue(statsRow.code, out stat) && stat != null) return stat; stat = new Stat { StatRow = statsRow }; //Object valueRow = null; //if (statsRow.ValueExcelTable != null && value >= 0 && value < statsRow.ValueExcelTable.Rows.Count) //{ // valueRow = statsRow.ValueExcelTable.Rows[value]; //} //Stat.StatValue statValue = new Stat.StatValue { Value = value, ValueRow = valueRow }; //stat.Values.Add(statValue); Stat.StatValue statValue = _CreateStatValue(statsRow, value, paramValues); stat.Values.Add(statValue); } return stat; }
private static Stat.StatValue _CreateStatValue(StatsRow statsRow, int value, int[] paramValues) { Object valueRow = null; if (statsRow.ValueExcelTable != null && value >= 0 && value < statsRow.ValueExcelTable.Rows.Count) { valueRow = statsRow.ValueExcelTable.Rows[value]; } Stat.StatValue statValue = new Stat.StatValue { Value = value, ValueRow = valueRow }; if (paramValues == null || paramValues.Length == 0) return statValue; if (paramValues.Length >= 1) { statValue.Param1 = paramValues[0]; if ((statsRow.Param1ExcelTable != null && paramValues[0] >= 0 && paramValues[0] < statsRow.Param1ExcelTable.Rows.Count)) { statValue.Param1Row = statsRow.Param1ExcelTable.Rows[paramValues[0]]; } } if (paramValues.Length >= 2) { statValue.Param2 = paramValues[1]; if ((statsRow.Param2ExcelTable != null && paramValues[1] >= 0 && paramValues[1] < statsRow.Param2ExcelTable.Rows.Count)) { statValue.Param2Row = statsRow.Param2ExcelTable.Rows[paramValues[1]]; } } if (paramValues.Length >= 3) { statValue.Param3 = paramValues[2]; if ((statsRow.Param3ExcelTable != null && paramValues[2] >= 0 && paramValues[2] < statsRow.Param3ExcelTable.Rows.Count)) { statValue.Param3Row = statsRow.Param3ExcelTable.Rows[paramValues[2]]; } } if (paramValues.Length >= 4) { statValue.Param4 = paramValues[3]; if ((statsRow.Param4ExcelTable != null && paramValues[3] >= 0 && paramValues[3] < statsRow.Param4ExcelTable.Rows.Count)) { statValue.Param4Row = statsRow.Param4ExcelTable.Rows[paramValues[3]]; } } return statValue; }
public Stat SetStatAt(StatsRow statData, int index, int value, int? param1 = null, int? param2 = null, int? param3 = null, int? param4 = null) { return Stats.AddOrUpdate(statData.code, (code) => { int totalParams = 0; totalParams += (param1.HasValue ? 1 : 0); totalParams += (param2.HasValue ? 1 : 0); totalParams += (param3.HasValue ? 1 : 0); totalParams += (param4.HasValue ? 1 : 0); int[] paramValues = new int[totalParams]; if (param1.HasValue) paramValues.SetValue(param1, 0); if (param2.HasValue) paramValues.SetValue(param2, 1); if (param3.HasValue) paramValues.SetValue(param3, 2); if (param4.HasValue) paramValues.SetValue(param4, 3); return _AddStat(statData, value, paramValues); }, (code, stat) => { if (stat.Values.Count > index) return null; lock (stat.Values) { Stat.StatValue statValue; if (stat.Values.Count == index) { statValue = new Stat.StatValue(); stat.Values.Add(statValue); } else { statValue = stat.Values[index]; } statValue.Value = value; if (param1.HasValue) { statValue.Param1 = param1.Value; if ((statData.Param1ExcelTable != null && param1.Value >= 0 && param1.Value < statData.Param1ExcelTable.Rows.Count)) { statValue.Param1Row = statData.Param1ExcelTable.Rows[param1.Value]; } } if (param2.HasValue) { statValue.Param2 = param2.Value; if ((statData.Param2ExcelTable != null && param2.Value >= 0 && param2.Value < statData.Param2ExcelTable.Rows.Count)) { statValue.Param2Row = statData.Param2ExcelTable.Rows[param2.Value]; } } if (param3.HasValue) { statValue.Param3 = param3.Value; if ((statData.Param3ExcelTable != null && param3.Value >= 0 && param3.Value < statData.Param3ExcelTable.Rows.Count)) { statValue.Param3Row = statData.Param3ExcelTable.Rows[param3.Value]; } } if (param4.HasValue) { statValue.Param4 = param4.Value; if ((statData.Param4ExcelTable != null && param4.Value >= 0 && param4.Value < statData.Param4ExcelTable.Rows.Count)) { statValue.Param4Row = statData.Param4ExcelTable.Rows[param4.Value]; } } } return stat; } ); }
public int GetStatValue(StatsRow statsRow, int param1) { Stat stat; if (!Stats.TryGetValue(statsRow.code, out stat) || stat == null) { return (statsRow.ValueExcelTable == null) ? 0 : -1; } lock (stat.Values) { foreach (Stat.StatValue statValue in stat.Values) { if (statValue.Param1 != param1) continue; return statValue.Value; } } return (statsRow.ValueExcelTable == null) ? 0 : -1; }
public Stat GetOrAddStat(StatsRow statsRow, int defaultValue, params int[] defaultParams) { return Stats.GetOrAdd(statsRow.code, code => _AddStat(statsRow, defaultValue, defaultParams)); }
/// <summary> /// Adds or Updates a stat /// </summary> /// <param name="statsRow"></param> /// <param name="value"></param> /// <param name="paramValues"></param> /// <returns></returns> public Stat AddOrUpdate(StatsRow statsRow, int value, params int[] paramValues) { // debug check - ensure we're supplying the current/needed number of params... not sure if this is required or not yet Debug.Assert(statsRow.ParamCount == ((paramValues == null) ? 0 : paramValues.Length)); //Stat.StatValue statValue; return Stats.AddOrUpdate(statsRow.code, (code) => { //int defaultValue; //int[] defaultParamValues = new int[index]; // We're assuming a default of 0 for values and -1 for tables - as of this writing, no param has a shift. // The paramXOffs is applicable only to table references i.e. it's akin to "offset" for stat value; not "valOffs" //if (index == 0) //{ // defaultValue = value; //} //else //{ // defaultValue = GetStatDefault(statsRow); //} //if (index == 1) //{ // defaultParamValues[0] = value; //} //else if (index > 1) //{ // defaultParamValues[0] = (statsRow.param1Table == -1) ? 0 : -1; //} //if (index == 2) //{ // defaultParamValues[1] = value; //} //else if (index > 2) //{ // defaultParamValues[1] = (statsRow.param2Table == -1) ? 0 : -1; //} //if (index == 3) //{ // defaultParamValues[2] = value; //} //else if (index > 3) //{ // defaultParamValues[2] = (statsRow.param3Table == -1) ? 0 : -1; //} //if (index == 4) //{ // defaultParamValues[3] = value; //} return _AddStat(statsRow, value, paramValues); }, (code, stat) => { lock (stat.Values) { // do we already have a value? Stat.StatValue currStatValue = null; if (statsRow.ParamCount == 0 || paramValues == null) { Debug.Assert(stat.Values.Count <= 1); // if no params, then we can't have multiple values if (stat.Values.Count == 1) currStatValue = stat.Values[0]; } else { currStatValue = stat.Values.FirstOrDefault(statValue => (paramValues.Length == 1 && statValue.Param1 == paramValues[0]) || (paramValues.Length == 2 && statValue.Param1 == paramValues[0] && statValue.Param2 == paramValues[1]) || (paramValues.Length == 3 && statValue.Param1 == paramValues[0] && statValue.Param2 == paramValues[1] && statValue.Param3 == paramValues[2]) || (paramValues.Length == 3 && statValue.Param1 == paramValues[0] && statValue.Param2 == paramValues[1] && statValue.Param3 == paramValues[2] && statValue.Param4 == paramValues[3])); } if (currStatValue == null) // we need to add it { Stat.StatValue statValue = _CreateStatValue(statsRow, value, paramValues); stat.Values.Add(statValue); } else if (currStatValue.Value != value) { currStatValue.Value = value; Object valueRow = null; if (statsRow.ValueExcelTable != null && value >= 0 && value < statsRow.ValueExcelTable.Rows.Count) { valueRow = statsRow.ValueExcelTable.Rows[value]; } currStatValue.ValueRow = valueRow; } } return stat; } ); }