public override void LoadExcelSheet(DataRow rowData)
{
fmDataItem data = m_fmData as fmDataItem;
data.m_nCode = GetInt(rowData, "nCode");
data.m_strNameCode = GetString(rowData, "strNameCode");
data.m_strImage = GetString(rowData, "strImage");
{
string str = GetString(rowData, "eBeyond");
data.m_eBeyond = (eBeyond)Enum.Parse(typeof(eBeyond), str);
}
{
string str = GetString(rowData, "eParts");
data.m_eParts = (eParts)Enum.Parse(typeof(eParts), str);
}
data.m_nPrice = GetInt(rowData, "nPrice");
{
string str = GetString(rowData, "eWeapon");
data.m_eWeapon = (eWeapon)Enum.Parse(typeof(eWeapon), str);
}
string[] strOpts = GetStrArray(rowData, "eOptions");
List <int> list = new List <int>();
foreach (var node in strOpts)
{
eOption eOpt = (eOption)Enum.Parse(typeof(eOption), node);
list.Add((int)eOpt);
}
data.m_nArrOptions = list.ToArray();
}
static public void Invoke(string[] args)
{
eOption option = GetOption(args);
if (eOption.none != option)
{
string[] targetPaths = new string[args.Length - 1];
Array.Copy(args, 1, targetPaths, 0, targetPaths.Length);
Converter.GenerateCodeInfo info = null;
switch (option)
{
case eOption.files:
info = Converter.Files(targetPaths, (percent, file) => { Debug.Log("{0}% ({1}%) {2}", percent._convert * 100.0f, percent._insert * 100.0f, file); });
break;
case eOption.directorys:
info = Converter.Directorys(targetPaths, (percent, file) => { Debug.Log("{0}% ({1}%) {2}", percent._convert * 100.0f, percent._insert * 100.0f, file); });
break;
default:
break;
}
IOAssist.CreateFile(info.Path + Converter.GenerateCodeInfo._DEFAULT_CODE_FILE_FULLNAME, info.Code);
}
}
private bool ChangePartsImageCode(eBeyond beyond, eParts parts, eOption opt, out int code)
{
code = 0;
if (beyond == eBeyond.Ancient)
{
if (true == m_ancientItems.ContainsKey(parts))
{
if (true == m_ancientItems[parts].ContainsKey(opt))
{
code = m_ancientItems[parts][opt].Code;
return(true);
}
}
}
else if (beyond == eBeyond.Mythic)
{
if (true == m_mythicItems.ContainsKey(parts))
{
if (true == m_mythicItems[parts].ContainsKey(opt))
{
code = m_mythicItems[parts][opt].Code;
return(true);
}
}
}
return(false);
}
public eErrorCode ChangeLegendSetOpt(ref rdItem changeItem)
{
// 기존 옵션 제거
rdOption option = changeItem.AddOpts.Find(x => x.Grade == eOptGrade.Legend || x.Grade == eOptGrade.Set);
if (null == option)
{
return(eErrorCode.Error);
}
int hit = m_random.Next(0, 2);
if (hit == 0)
{
changeItem.Grade = eGrade.Legend;
}
else
{
changeItem.Grade = eGrade.Set;
}
eOption kind = GetLegendSetOption(changeItem.Grade, changeItem.Parts, changeItem.Lv);
option.Kind = kind;
option.Grade = GetOptGrade(kind);
option.Value = GetValue(changeItem.Lv, kind);
return(eErrorCode.Success);
}
public void SetInDunPlace(int indunCode, int place, int boss, int goblin, eOption opt)
{
m_nInDunCode = indunCode;
m_nPlace = place;
m_nBoss = boss;
m_nGoblin = goblin;
m_nOpt = opt;
}
public void InitInDunPlace()
{
m_nInDunCode = 0;
m_nPlace = 0;
m_nBoss = 0;
m_nGoblin = 0;
m_nOpt = eOption.None;
}
public rdOption(int index, bool remelt, eOptGrade grade, eOption option, float value)
{
Index = index;
Remelt = remelt;
Grade = grade;
Kind = option;
Value = value;
}
public void GetItemWithBoss(fmDropItem fdi, eOption selecedOpt, out rdItem item)
{
int lv = fdi.Lv;
eGrade grade = fdi.Grade;
eParts parts = fdi.Parts;
item = new rdItem();
item.Lv = lv;
item.Grade = grade;
item.Parts = parts;
item.BaseOpt = new List <rdOption>();
item.AddOpts = new List <rdOption>();
GetBaseOpt(item);
List <eOption> temp = GetList(eGrade.Normal, parts, lv);
int cnt = GetOptionCount(grade);
//Console.WriteLine(cnt);
for (int i = 0; i < cnt; ++i)
{
int hit = m_random.Next(0, temp.Count);
eOption kind = temp.ElementAt(hit);
eOptGrade cc = (eOptGrade)((int)kind >> 8);
rdOption option = new rdOption(i + 1, false, GetOptGrade(kind), kind, GetValue(lv, kind));
item.AddOpts.Add(option);
temp.RemoveAt(hit);
if (cc == eOptGrade.Normal)
{
eOption remove = (eOption)((int)kind + ((int)eOptGrade.Normal << 8));
temp.Remove(remove);
}
else if (cc == eOptGrade.Epic)
{
eOption remove = (eOption)((int)kind - ((int)eOptGrade.Normal << 8));
temp.Remove(remove);
}
// eOptCategory
}
if (eGrade.Legend <= grade)
{
eOptGrade optGrade = GetLegendSetOptGrade(grade);
//Console.WriteLine(optGrade);
eOption kind = selecedOpt;
rdOption option = new rdOption(cnt + 1, false, optGrade, kind, GetValue(lv, kind));
item.AddOpts.Add(option);
}
}
private void GetBaseValue(int lv, eParts parts, out eOption option, out float value, out int code)
{
//Logger.Debug("GetBaseValue: {0}" , parts);
int cnt = m_items[parts].Count;
int hit = m_random.Next(0, cnt);
var data = m_items[parts].ElementAt(hit).Value;
code = data.m_nCode;
option = m_items[parts].ElementAt(hit).Key;
GetBaseValue(lv, option, out value);
}
public static void Read(this List <eOption> list, ref Packet p)
{
int count = p.ReadInt();
list.Capacity = count;
for (int i = 0; i < count; ++i)
{
eOption value = (eOption)p.ReadInt();
list.Add(value);
}
}
private eOptGrade GetOptGrade(eOption opt)
{
// eOptCategory
eOptGrade cc = (eOptGrade)((int)opt >> 8);
return(cc);
//if (cc == eOptGrade.Normal) return eGrade.Normal;
//else if (cc == eOptGrade.Epic) return eGrade.Epic;
//else if (cc == eOptGrade.Legend) return eGrade.Legend;
//else if (cc == eOptGrade.Set) return eGrade.Set;
//else return eGrade.Normal;
}
public static float GetBaseValue(int lv, eOption option, eMinMax range, bool ancient)
{
if (false == bLoad)
{
Load();
}
float value = 0f;
if (option == eOption.BWDMin)
{
value = GetBaseBWDMin(lv, range, ancient);
}
else if (option == eOption.BWDMax)
{
value = GetBaseBWDMax(lv, range, ancient);
}
else if (option == eOption.AS)
{
value = GetBaseAs(range, ancient);
}
else if (option == eOption.HP)
{
value = GetValue(lv, option, range, ancient);
value = (float)Math.Round(value * 3);
}
else if (option == eOption.DEF)
{
value = GetValue(lv, option, range, ancient);
value = (float)Math.Round(value * 3);
}
else if (option == eOption.Element)
{
value = GetValue(lv, option, range, ancient);
}
else if (option == eOption.CriRate)
{
value = GetValue(lv, option, range, ancient);
value = (float)Math.Round(value * 2);
}
else
{
value = GetValue(lv, option, range, ancient);
value = (float)Math.Round(value * 4);
}
return(value);
}
public static float GetValue(int lv, eOption opt, eMinMax range, bool ancient)
{
if (false == bLoad)
{
Load();
}
if (ancient)
{
return(m_valuesAncient[opt](lv, range));
}
else
{
return(m_values[opt](lv, range));
}
}
public bool Load(fmDataTable table)
{
Dictionary <int, fmDataOption> dic = table.Find <fmDataOption>(eFmDataType.Option);
if (null == dic)
{
return(false);
}
//m_optList.Add(eParts.Weapon, new List<eOption>());
//m_optList.Add(eParts.Necklace, new List<eOption>());
//m_optList.Add(eParts.Ring, new List<eOption>());
//m_optList.Add(eParts.Belt, new List<eOption>());
//m_optList.Add(eParts.Gloves, new List<eOption>());
//m_optList.Add(eParts.Pants, new List<eOption>());
//m_optList.Add(eParts.Armor, new List<eOption>());
//m_optList.Add(eParts.Head, new List<eOption>());
//m_optList.Add(eParts.Jewel, new List<eOption>());
foreach (var node in dic)
{
int lv = node.Value.m_nAppearLv;
eOption opt = node.Value.m_eOption;
eOptGrade optGrade = (eOptGrade)((int)opt >> 8);
foreach (var beyond in node.Value.m_nArrBeyond)
{
if ((eBeyond)beyond == eBeyond.Mythic)
{
int cnt = node.Value.m_nArrParts.Length;
for (int i = 0; i < cnt; ++i)
{
eParts parts = (eParts)node.Value.m_nArrParts[i];
if (false == m_optList.ContainsKey(parts))
{
m_optList.Add(parts, new List <eOption>());
}
m_optList[parts].Add(opt);
}
}
}
}
return(true);
}
public float GetBaseValue(int lv, eOption option)
{
float value = 0f;
//if (option == eOption.BWDMin)
//{
// value = GetBaseBWDMin(lv);
//}
//else if (option == eOption.BWDMax)
//{
// value = GetBaseBWDMax(lv);
//}
//else if (option == eOption.AS)
//{
// value = GetBaseAs();
//}
//else
if (option == eOption.HP)
{
value = GetValue(lv, option);
value = (float)Math.Round(value * 3);
}
else if (option == eOption.DEF)
{
value = GetValue(lv, option);
value = (float)Math.Round(value * 3);
}
else if (option == eOption.Element)
{
value = GetValue(lv, option);
}
else if (option == eOption.CriRate)
{
value = GetValue(lv, option);
value = (float)Math.Round(value * 2);
}
else
{
value = GetValue(lv, option);
value = (float)Math.Round(value * 4);
}
return(value);
}
public eErrorCode Remelt(ref rdItem remeltItem, int optIndex, eOption selectedOpt)
{
if (null == remeltItem)
{
return(eErrorCode.Auth_PleaseLogin);
}
eOption kind = selectedOpt;
eOptGrade cc = (eOptGrade)((int)kind >> 8);
eOption normKind = eOption.None;
eOption epicKind = eOption.None;
if (cc == eOptGrade.Normal)
{
normKind = kind;
epicKind = (eOption)((int)kind + ((int)eOptGrade.Normal << 8));
}
else if (cc == eOptGrade.Epic)
{
normKind = (eOption)((int)kind - ((int)eOptGrade.Normal << 8));
epicKind = kind;
}
rdOption remeltOpt = null;
foreach (var node in remeltItem.AddOpts)
{
if (node.Index == optIndex)
{
remeltOpt = node;
}
else
{
if (true == node.Remelt)
{
return(eErrorCode.Item_Remelt_AlreadyOther);
}
else
{
if (node.Kind == normKind)
{
return(eErrorCode.Item_AlreadySameOpt);
}
if (node.Kind == epicKind)
{
return(eErrorCode.Item_AlreadySameOpt);
}
}
}
}
if (null == remeltOpt)
{
return(eErrorCode.Params_InvalidParam);
}
remeltOpt.Remelt = true;
Logger.Debug("optIndex {0}", optIndex);
Logger.Debug("remeltOpt.Grade {0}", remeltOpt.Grade);
if (eOptGrade.Legend == remeltOpt.Grade || eOptGrade.Set == remeltOpt.Grade)
{
return(eErrorCode.Item_OutOfType);
}
remeltOpt.Kind = selectedOpt;
remeltOpt.Grade = GetOptGrade(selectedOpt);
if (eBeyond.None == remeltItem.Beyond)
{
remeltOpt.Value = GetValue(remeltItem.Lv, remeltOpt.Kind);
}
else
{
remeltOpt.Value = GetAncientValue(remeltItem.Lv, remeltOpt.Kind);
}
return(eErrorCode.Success);
}
private void GetBaseOpt(rdItem item)
{
eOptGrade grade = eOptGrade.Normal;
// 무기
if (item.Parts == eParts.Weapon)
{
//item.Code = GetWeaponCode();
float min = 0;
float max = 0;
float speed = 0;
item.Code = GetWeapon(item.Lv, out min, out max, out speed);
// 1. 무기 최소 공격력
{
eOption select = eOption.BWDMin;
//float value = 0;
//GetBaseValue(item.Lv, select, out value);
rdOption option = new rdOption(1, false, grade, select, min);
item.BaseOpt.Add(option);
}
// 2. 무기 최대 공격력
{
eOption select = eOption.BWDMax;
//float value = 0;
//GetBaseValue(item.Lv, select, out value);
rdOption option = new rdOption(2, false, grade, select, max);
item.BaseOpt.Add(option);
}
// 4. 공속
{
eOption select = eOption.AS;
//float value = 0;
//GetBaseValue(item.Lv, select, out value);
rdOption option = new rdOption(3, false, grade, select, speed);
item.BaseOpt.Add(option);
}
// 3. 속성
{
eOption select = eOption.Element;
float value = 0f;
{
int b = (int)eElement.None;
int e = 1 + (int)eElement.Nature;
value = m_random.Next(b, e);
}
rdOption option = new rdOption(4, false, grade, select, value);
item.BaseOpt.Add(option);
}
}
else
{
// 기타
{
eOption select = eOption.None;
float value = 0;
int code = 0;
GetBaseValue(item.Lv, item.Parts, out select, out value, out code);
rdOption option = new rdOption(1, false, grade, select, value);
item.Code = code;
item.BaseOpt.Add(option);
}
}
}
private void GetDiscovery(List <fmDiscovery> discoverys, out List <rdItem> items, out fmDiscoveryRs fdrs, int rewardRuby = 0, eOption selectedOpt = eOption.None)
{
fdrs = new fmDiscoveryRs();
items = new List <rdItem>();
items.Clear();
if (0 < rewardRuby)
{
AddGameRuby(rewardRuby);
fdrs.Ruby += rewardRuby;
}
foreach (var nodes in discoverys)
{
foreach (var node in nodes.DropList)
{
if (node.Kind == eReward.Gold)
{
int gold = int.Parse(node.Contents);
AddGold(gold);
fdrs.Gold += gold;
}
else if (node.Kind == eReward.Stone)
{
int stone = int.Parse(node.Contents);
AddStone(stone);
fdrs.Stone += stone;
}
else if (node.Kind == eReward.SCKey)
{
int scKey = int.Parse(node.Contents);
AddSCKey(scKey);
fdrs.SCKey += scKey;
}
else if (node.Kind == eReward.Ruby)
{
int ruby = int.Parse(node.Contents);
AddGameRuby(ruby);
fdrs.Ruby += ruby;
}
//else if (node.Kind == eReward.DHeart)
//{
// int dHeart = int.Parse(node.Contents);
// AddDHeartFnc(dHeart);
// fdrs.DHeart += dHeart;
//}
//else if (node.Kind == eReward.Seal)
//{
// int seal = int.Parse(node.Contents);
// AddSeal(seal);
// fdrs.Seal += seal;
//}
else if (node.Kind == eReward.Item)
{
rdItem item = null;
if (eOption.None == selectedOpt)
{
theOptionPicker.Instance.GetItem(new JavaScriptSerializer().Deserialize <fmDropItem>(node.Contents), out item);
}
else
{
theOptionPicker.Instance.GetItemWithBoss(new JavaScriptSerializer().Deserialize <fmDropItem>(node.Contents), selectedOpt, out item);
}
if (null == item)
{
continue;
}
if (item.Parts == eParts.Jewel)
{
//Console.WriteLine(item.Parts);
if (eGrade.Epic < item.Grade)
{
//Console.WriteLine(item.Grade);
// 방송
//ArchiveExecuter.Instance.Push(new Msg_Broadcast_Public_NT(GetName(), item));
}
}
if ((GetLv() + 10) < item.Lv)
{
Logger.Error("Cheater Name:{0} , AccId:{1}, Lv:{2}, ItemLv:{3}", GetName(), AccId, GetLv(), item.Lv);
}
TryTakeItem(item);
items.Add(item);
}
}
fdrs.Exp += nodes.Exp;
}
fdrs.IsLevelUp = LevelUpAddExp(fdrs.Exp);
}
public eErrorCode UpToAncient(ref rdItem remeltItem)
{
rdOption keepOpt = null;
foreach (var node in remeltItem.AddOpts)
{
if (eOptGrade.Legend == node.Grade || eOptGrade.Set == node.Grade)
{
keepOpt = node;
}
}
if (null == keepOpt)
{
return(eErrorCode.Error);
}
int lv = remeltItem.Lv;
eGrade grade = remeltItem.Grade;
eParts parts = remeltItem.Parts;
bool bChanged = false;
int changeCode = 0;
//if (parts == eParts.Jewel)
//{
// bChanged = true;
// changeCode = remeltItem.Code;
//}
//else
if (parts == eParts.Weapon)
{
bChanged = ChangeWeaponImageCode(eBeyond.Ancient, remeltItem.Code, out changeCode);
}
else
{
bChanged = ChangePartsImageCode(eBeyond.Ancient, parts, remeltItem.BaseOpt.ElementAt(0).Kind, out changeCode);
}
if (false == bChanged)
{
Logger.Error("Failed. UpToAncient {0} / {1} / {2}", parts, remeltItem.Code, remeltItem.BaseOpt.ElementAt(0).Kind);
return(eErrorCode.Server_TableError);
}
remeltItem.Code = changeCode;
remeltItem.AddOpts.Clear();
List <eOption> temp = GetAncientOptList(parts);
int cnt = GetOptionCount(grade);
for (int i = 0; i < cnt; ++i)
{
int hit = m_random.Next(0, temp.Count);
eOption kind = temp.ElementAt(hit);
rdOption option = new rdOption(i + 1, false, GetOptGrade(kind), kind, GetAncientValue(lv, kind));
remeltItem.AddOpts.Add(option);
temp.RemoveAt(hit);
}
{
remeltItem.AddOpts.Add(keepOpt);
}
remeltItem.Beyond = eBeyond.Ancient;
return(eErrorCode.Success);
}
private void GetBaseValue(int lv, eOption option, out float value)
{
// 기본 베이스 옵션 값 선택
value = m_option.GetBaseValue(lv, option);
}
private void controlGarageOptions(eOption i_Option)
{
try
{
AutoRepairShop.VehicleInShop.eVehicleStatus?status;
string licenseNumber;
Console.Clear();
switch (i_Option)
{
case eOption.AddVehicle:
addVehicle();
break;
case eOption.ShowVehiclesByLicense:
PrintingUtils.PrintLicensesList(r_AutoRepairShop.ShowAllVehiclesInGarage());
break;
case eOption.ShowVehiclesByStatus:
status = getStatus();
PrintingUtils.PrintLicensesList(r_AutoRepairShop.ShowAllVehiclesInGarage(status), status);
break;
case eOption.ModifyStatus:
licenseNumber = getLicenseNumber();
if (r_AutoRepairShop.IsVehicleExist(licenseNumber))
{
status = getStatus();
r_AutoRepairShop.SetNewStatusToVehicle(licenseNumber, status, out bool isSucceeded);
PrintingUtils.StatusModified(licenseNumber, status, isSucceeded);
}
else
{
throw new ArgumentException("Vehicle is not exist in the garage");
}
break;
case eOption.InflateWheels:
licenseNumber = getLicenseNumber();
r_AutoRepairShop.SetWheelsPressureToMaximum(licenseNumber, out bool isInflated);
PrintingUtils.InflateWheels(licenseNumber, isInflated);
break;
case eOption.RefuelVehicle:
licenseNumber = getLicenseNumber();
if (r_AutoRepairShop.IsVehicleExist(licenseNumber))
{
getFuelToAdd(out FuelVehicle.eFuelType fuelType, out float fuelToAdd);
r_AutoRepairShop.FillInEnergyToVehicle(
licenseNumber,
fuelToAdd,
out bool isRefueled,
fuelType);
PrintingUtils.EnergyAdded(licenseNumber, isRefueled, fuelType);
}
else
{
throw new ArgumentException("Vehicle is not exist in the garage");
}
break;
case eOption.LoadVehicle:
licenseNumber = getLicenseNumber();
if (r_AutoRepairShop.IsVehicleExist(licenseNumber))
{
float minutesToAdd = getMinutesToLoad();
r_AutoRepairShop.FillInEnergyToVehicle(licenseNumber, minutesToAdd, out bool isLoaded);
PrintingUtils.EnergyAdded(licenseNumber, isLoaded);
}
else
{
throw new ArgumentException("Vehicle is not exist in the garage");
}
break;
case eOption.ShowVehicleDetails:
licenseNumber = getLicenseNumber();
PrintingUtils.PrintVehicleDetails(
r_AutoRepairShop.ShowDetailsOfVehicle(licenseNumber, out bool isExist),
isExist);
break;
case eOption.Exit:
m_LeaveStore = true;
break;
default:
throw new ValueOutOfRangeException(1, 9);
}
if (i_Option != eOption.Exit)
{
PrintingUtils.Delay();
}
}
catch (Exception ex)
{
PrintingUtils.PrintExceptionErrors(ex);
throw;
}
}
public float GetValue(int lv, eOption option)
{
return(m_values[option](lv));
}
public eErrorCode CreateMythic(eOption selectOpt, eElement element, ref rdItem mythicItem)
{
rdOption keepOpt = null;
foreach (var node in mythicItem.AddOpts)
{
if (eOptGrade.Legend == node.Grade || eOptGrade.Set == node.Grade)
{
keepOpt = node;
}
}
if (null == keepOpt)
{
return(eErrorCode.Error);
}
int lv = mythicItem.Lv;
eGrade grade = mythicItem.Grade;
eParts parts = mythicItem.Parts;
if (parts != eParts.Weapon)
{
if (selectOpt == eOption.None)
{
return(eErrorCode.Params_InvalidParam);
}
}
int changeCode = 0;
if (parts == eParts.Weapon)
{
if (false == ChangeWeaponImageCode(eBeyond.Mythic, mythicItem.Code, out changeCode))
{
Logger.Error("Failed. CreateMythic {0} / {1} / {2}", parts, mythicItem.Code, selectOpt);
return(eErrorCode.Server_TableError);
}
}
else
{
if (false == ChangePartsImageCode(eBeyond.Mythic, mythicItem.Parts, selectOpt, out changeCode))
{
Logger.Error("Failed. CreateMythic {0} / {1} / {2}", parts, mythicItem.Code, selectOpt);
return(eErrorCode.Params_InvalidParam);
}
}
mythicItem.Code = changeCode;
mythicItem.Beyond = eBeyond.Mythic;
mythicItem.AddOpts.Clear();
mythicItem.BaseOpt.Clear();
if (parts == eParts.Weapon)
{
float min = 0;
float max = 0;
float speed = 0;
GetWeapon(lv, out min, out max, out speed);
{
eOption select = eOption.BWDMin;
rdOption option = new rdOption(1, false, eOptGrade.Normal, select, min);
mythicItem.BaseOpt.Add(option);
}
{
eOption select = eOption.BWDMax;
rdOption option = new rdOption(2, false, eOptGrade.Normal, select, max);
mythicItem.BaseOpt.Add(option);
}
{
eOption select = eOption.AS;
rdOption option = new rdOption(3, false, eOptGrade.Normal, select, speed);
mythicItem.BaseOpt.Add(option);
}
{
eOption select = eOption.Element;
float value = (float)element;
rdOption option = new rdOption(4, false, eOptGrade.Normal, select, value);
mythicItem.BaseOpt.Add(option);
}
}
else
{
float value = 0f;
GetBaseValue(mythicItem.Lv, selectOpt, out value);
rdOption option = new rdOption(1, false, eOptGrade.Normal, selectOpt, value);
mythicItem.BaseOpt.Add(option);
}
List <eOption> temp = GetAncientOptList(parts);
int cnt = GetOptionCount(grade, eBeyond.Mythic);
for (int i = 0; i < cnt; ++i)
{
int hit = m_random.Next(0, temp.Count);
eOption kind = temp.ElementAt(hit);
rdOption option = new rdOption(i + 1, false, GetOptGrade(kind), kind, GetAncientValue(lv, kind));
mythicItem.AddOpts.Add(option);
temp.RemoveAt(hit);
}
{
keepOpt.Index = mythicItem.AddOpts.Count + 1;
mythicItem.AddOpts.Add(keepOpt);
}
return(eErrorCode.Success);
}
//-----------------------------------------------------------------
// Ancient
//-----------------------------------------------------------------
public float GetAncientValue(int lv, eOption option)
{
return(m_valuesAncient[option](lv));
}
private float GetAncientValue(int lv, eOption option)
{
return(m_option.GetAncientValue(lv, option));
}
public bool Load(fmDataTable table)
{
Dictionary <int, fmDataOption> dic = table.Find <fmDataOption>(eFmDataType.Option);
if (null == dic)
{
return(false);
}
m_optList.Add(eGrade.Normal, new Dictionary <int, Dictionary <eParts, List <eOption> > >());
m_optList.Add(eGrade.Legend, new Dictionary <int, Dictionary <eParts, List <eOption> > >());
m_optList.Add(eGrade.Set, new Dictionary <int, Dictionary <eParts, List <eOption> > >());
foreach (var node in dic)
{
int lv = node.Value.m_nAppearLv;
if (false == m_nLvRange.Contains(lv))
{
m_nLvRange.Add(lv);
}
foreach (var item in m_optList)
{
if (false == item.Value.ContainsKey(lv))
{
item.Value.Add(lv, new Dictionary <eParts, List <eOption> >());
item.Value[lv].Add(eParts.Weapon, new List <eOption>());
item.Value[lv].Add(eParts.Necklace, new List <eOption>());
item.Value[lv].Add(eParts.Ring, new List <eOption>());
item.Value[lv].Add(eParts.Belt, new List <eOption>());
item.Value[lv].Add(eParts.Gloves, new List <eOption>());
item.Value[lv].Add(eParts.Pants, new List <eOption>());
item.Value[lv].Add(eParts.Armor, new List <eOption>());
item.Value[lv].Add(eParts.Head, new List <eOption>());
item.Value[lv].Add(eParts.Jewel, new List <eOption>());
}
}
}
foreach (var node in dic)
{
int lv = node.Value.m_nAppearLv;
eOption opt = node.Value.m_eOption;
eOptGrade optGrade = (eOptGrade)((int)opt >> 8);
foreach (var beyond in node.Value.m_nArrBeyond)
{
if ((eBeyond)beyond == eBeyond.None)
{
int cnt = node.Value.m_nArrParts.Length;
for (int i = 0; i < cnt; ++i)
{
eParts parts = (eParts)node.Value.m_nArrParts[i];
if (optGrade < eOptGrade.Legend)
{
foreach (var list in m_optList[eGrade.Normal])
{
if (lv <= list.Key)
{
list.Value[parts].Add(opt);
}
}
}
else if (eOptGrade.Legend == optGrade)
{
foreach (var list in m_optList[eGrade.Legend])
{
if (lv <= list.Key)
{
list.Value[parts].Add(opt);
}
}
}
else if (eOptGrade.Set == optGrade)
{
foreach (var list in m_optList[eGrade.Set])
{
if (lv <= list.Key)
{
list.Value[parts].Add(opt);
}
}
}
}
}
}
}
m_nLvRange = m_nLvRange.OrderBy(x => x).ToList();
return(true);
}
public static eOptGrade GetOptHiword(eOption opt)
{
return((eOptGrade)((int)opt >> 8));
}
