Chomper9981
943 lines
38 KiB
C#
943 lines
38 KiB
C#
using BrewMonster.ELEMENT_DATA;
|
||
using BrewMonster.Network;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Threading.Tasks;
|
||
using UnityEngine;
|
||
using ModelRenderer.Scripts.GameData;
|
||
namespace BrewMonster
|
||
{
|
||
|
||
public struct LOCATION
|
||
{
|
||
public DATA_TYPE type;
|
||
public object pos;
|
||
};
|
||
|
||
namespace abase
|
||
{
|
||
public static class abase
|
||
{
|
||
const int RAND_MAX = 0x7fff;
|
||
public static int Rand(int lower, int upper)
|
||
{
|
||
if (upper == lower)
|
||
return lower;
|
||
else
|
||
return new System.Random().Next(lower, upper);
|
||
}
|
||
|
||
public static float Rand(float lower, float upper)
|
||
{
|
||
float rng = (float)new System.Random().NextDouble();
|
||
return lower + (upper - lower) * rng / (float)RAND_MAX;
|
||
}
|
||
|
||
public static int RandNormal(int lower, int upper) { return Rand(lower, upper); }
|
||
public static float RandUniform() { return Rand(0f, 1f); }
|
||
|
||
public static int RandSelect(List<float> option)
|
||
{
|
||
int num = option.Count;
|
||
float op = RandUniform();
|
||
for (int i = 0; i<num; i++)
|
||
{
|
||
float prob = (float)option[i];
|
||
if (op<prob)
|
||
return i;
|
||
op -= prob;
|
||
}
|
||
//assert(false);
|
||
return 0;
|
||
}
|
||
//static void* fastalloc(size_t size) { return malloc(size); }
|
||
//static void fastfree(void* buf, size_t size) { free(buf); }
|
||
}
|
||
};
|
||
|
||
namespace ELEMENT_DATA
|
||
{
|
||
public enum LOWER { LOWER_TREND };
|
||
public enum UPPER { UPPER_TREND };
|
||
public enum MIDDLE { MIDDLE_TREND };
|
||
public enum ANY { ANY_TREND };
|
||
|
||
public enum NORMAL { NORMAL_RAND };
|
||
public enum SPECIFIC { SPECIFIC_RAND };
|
||
|
||
//struct can not have a parameterless constructor
|
||
public class SpecRand
|
||
{
|
||
public List<int> IndexList;
|
||
public int IdxCap;
|
||
public int IdxIndex;
|
||
public List<float> RandList;
|
||
public int RandCap;
|
||
public int RandIndex;
|
||
//SpecRand() :IndexList(0),IdxCap(0),IdxIndex(0),RandList(0),RandCap(0),RandIndex(0) { }
|
||
|
||
public SpecRand() {
|
||
IndexList = new List<int>();
|
||
IdxCap = 0;
|
||
IdxIndex = 0;
|
||
RandList = new List<float>();
|
||
RandCap = 0;
|
||
RandIndex = 0;
|
||
|
||
}
|
||
public int RandSelect(int num)
|
||
{
|
||
if (IndexList == null || IndexList.Count == 0) return 0;
|
||
if (IdxIndex >= IdxCap) return 0;
|
||
if (num <= 0) return 0;
|
||
int idx = IndexList[IdxIndex++];
|
||
if (idx >= num) idx = num - 1;
|
||
return idx;
|
||
}
|
||
|
||
public int RandNormal(int lower, int upper)
|
||
{
|
||
if (RandList == null || RandList.Count == 0) return lower;
|
||
if (RandIndex >= RandCap) return lower;
|
||
float r = RandList[RandIndex++];
|
||
if (r < 0) r = 0f;
|
||
if (r >= 1.0f) r = 0.9999999f;
|
||
return (int)((upper - lower + 1) * r + lower);
|
||
}
|
||
|
||
public float Rand(float lower, float upper)
|
||
{
|
||
if (RandList == null || RandList.Count == 0) return lower;
|
||
if (RandIndex >= RandCap) return lower;
|
||
float r = RandList[RandIndex++];
|
||
if (r < 0) r = 0f;
|
||
if (r >= 1.0f) r = 0.9999999f;
|
||
return (float)((upper - lower) * r + lower);
|
||
}
|
||
}
|
||
public class SpecCls
|
||
{
|
||
SpecRand imp;
|
||
public SpecCls(SpecRand tmp) {
|
||
imp = tmp;
|
||
}
|
||
//Could be wrong, need to check
|
||
public int RandSelect(List<float> option)
|
||
{
|
||
int num = option.Count;
|
||
if(imp != null) return imp.RandSelect(num);
|
||
return 0;
|
||
}
|
||
|
||
public int RandNormal(int lower, int upper)
|
||
{
|
||
if (imp != null) return imp.RandNormal(lower, upper);
|
||
return lower;
|
||
}
|
||
|
||
public float Rand(float lower, float upper)
|
||
{
|
||
if (imp != null) return imp.Rand(lower, upper);
|
||
return lower;
|
||
}
|
||
}
|
||
public static class element_data
|
||
{
|
||
public static int RandNormal<TCls, TTrend>(int lower, int upper, TCls c) where TCls : SpecCls
|
||
{
|
||
return c.RandNormal(lower, upper);
|
||
}
|
||
public static int RandSelect<TCls, TTrend>(List<float> option, TCls c) where TCls : SpecCls
|
||
{
|
||
return c.RandSelect(option);
|
||
}
|
||
public static float Rand<TCls, TTrend>(float lower, float upper, TCls c) where TCls : SpecCls
|
||
{
|
||
return c.Rand(lower, upper);
|
||
}
|
||
public static int RandSelect_NORMAL_LOWER(List<float> option, NORMAL normalType, LOWER lowerTrend)
|
||
{
|
||
return abase.abase.RandSelect(option);
|
||
}
|
||
public static int RandSelect_NORMAL_MIDDLE(List<float> option, NORMAL normalType, MIDDLE middleTrend)
|
||
{
|
||
return abase.abase.RandSelect(option);
|
||
}
|
||
public static uint RandSelect_SPECIFIC_LOWER(List<float> option, SPECIFIC specificType, LOWER lowerTrend)
|
||
{
|
||
return 0;
|
||
}
|
||
public static int RandSelect_SPECIFIC_MIDDLE(List<float> option, SPECIFIC specificType, MIDDLE middleTrend)
|
||
{
|
||
return option.Count / 2;
|
||
}
|
||
public static int RandNormal_NORMAL_LOWER(int lower, int upper, NORMAL normalType, LOWER lowerTrend)
|
||
{
|
||
return abase.abase.RandNormal(lower, upper);
|
||
}
|
||
public static int RandNormal_NORMAL_UPPER(int lower, int upper, NORMAL normalType, UPPER upperTrend)
|
||
{
|
||
return abase.abase.RandNormal(lower, upper);
|
||
}
|
||
public static int RandNormal_NORMAL_MIDDLE(int lower, int upper, NORMAL normalType, MIDDLE middleTrend)
|
||
{
|
||
return abase.abase.RandNormal(lower, upper);
|
||
}
|
||
public static int RandNormal_NORMAL_ANY(int lower, int upper, NORMAL normalType, ANY anyTrend)
|
||
{
|
||
return abase.abase.RandNormal(lower, upper);
|
||
}
|
||
public static int RandNormal_SPECIFIC_LOWER(int lower, int upper, SPECIFIC specificType, LOWER lowerTrend)
|
||
{
|
||
return lower;
|
||
}
|
||
public static int RandNormal_SPECIFIC_UPPER(int lower, int upper, SPECIFIC specificType, UPPER upperTrend)
|
||
{
|
||
return upper;
|
||
}
|
||
public static int RandNormal_SPECIFIC_MIDDLE(int lower, int upper, SPECIFIC specificType, MIDDLE middleTrend)
|
||
{
|
||
return (upper + lower) / 2;
|
||
}
|
||
public static int RandNormal_SPECIFIC_ANY(int lower, int upper, SPECIFIC specificType, ANY anyTrend)
|
||
{
|
||
return abase.abase.RandNormal(lower, upper);
|
||
}
|
||
public static float Rand_NORMAL_LOWER(float lower, float upper, NORMAL normalType, LOWER lowerTrend)
|
||
{
|
||
return abase.abase.Rand(lower, upper);
|
||
}
|
||
public static float Rand_NORMAL_MIDDLE(float lower, float upper, NORMAL normalType, MIDDLE middleTrend)
|
||
{
|
||
return abase.abase.Rand(lower, upper);
|
||
}
|
||
public static float Rand_NORMAL_UPPER(float lower, float upper, NORMAL normalType, UPPER upperTrend)
|
||
{
|
||
return abase.abase.Rand(lower, upper);
|
||
}
|
||
public static float Rand_NORMAL_ANY(float lower, float upper, NORMAL normalType, ANY anyTrend)
|
||
{
|
||
return abase.abase.Rand(lower, upper);
|
||
}
|
||
public static float Rand_SPECIFIC_LOWER(float lower, float upper, SPECIFIC specificType, LOWER lowerTrend)
|
||
{
|
||
return lower;
|
||
}
|
||
public static float Rand_SPECIFIC_MIDDLE(float lower, float upper, SPECIFIC specificType, MIDDLE middleTrend)
|
||
{
|
||
return (upper + lower) / 2;
|
||
}
|
||
public static float Rand_SPECIFIC_UPPER(float lower, float upper, SPECIFIC specificType, UPPER upperTrend)
|
||
{
|
||
return upper;
|
||
}
|
||
public static float Rand_SPECIFIC_ANY(float lower, float upper, SPECIFIC specificType, ANY anyTrend)
|
||
{
|
||
return abase.abase.Rand(lower, upper);
|
||
}
|
||
}
|
||
public enum GEN_ADDON_MODE
|
||
{
|
||
ADDON_LIST_SHOP,
|
||
ADDON_LIST_DROP,
|
||
ADDON_LIST_PRODUCE,
|
||
ADDON_LIST_SPEC,
|
||
};
|
||
public enum ITEM_MAKE_TAG
|
||
{
|
||
IMT_NULL,
|
||
IMT_CREATE,
|
||
IMT_DROP,
|
||
IMT_SHOP,
|
||
IMT_PRODUCE,
|
||
IMT_SIGN, //װ����ǩ��
|
||
};
|
||
//#pragma pack(1)
|
||
public class item_tag_t
|
||
{
|
||
public char type;
|
||
public char size;
|
||
public item_tag_t(char type, char size)
|
||
{
|
||
this.type = type;
|
||
this.size = size;
|
||
}
|
||
};
|
||
//#pragma pack()
|
||
|
||
};// name space element_data
|
||
public struct guid_t
|
||
{
|
||
public int guid1;
|
||
public int guid2;
|
||
}
|
||
public struct item_data
|
||
{
|
||
public uint type; //��Ʒ��ģ��ID
|
||
public int count; //��Ʒ������
|
||
public int pile_limit; //��Ʒ�Ķѵ�����
|
||
public int equip_mask; //��Ʒ�Ŀ�װ����־��0x8000��ʾ����Ƕ��
|
||
public int proc_type; //��Ʒ�Ĵ�����ʽ
|
||
public int classid; //��Ʒ��Ӧ�����ID
|
||
public guid_t guid; //��Ʒ��GUID
|
||
public int price; //��Ʒ�ļ۸�
|
||
public int expire_date; //����ʱ��
|
||
public int content_length;
|
||
public byte item_content;
|
||
};
|
||
// #pragma pack(1)
|
||
public struct _item_content
|
||
{
|
||
public prerequisition preq;
|
||
public short sizeofessence; //װ�������С���ֽڣ�;
|
||
// essence //char ����[]; //ÿ�ֲ�ͬװ���ı���ṹ��ͬ
|
||
public int num_hole; //������Ŀ��������;
|
||
// int hole_type[MAX_NUM_HOLES]; //����Ƕ���������[������Ŀ]; //�������ĿΪ0,���������
|
||
public int num_addon; //���Ա���Ŀ����Ŀ��������;
|
||
// _addon ad[MAX_NUM_ADDONS]; //[���Ա���Ŀ����Ŀ];
|
||
};
|
||
//#pragma pack()
|
||
|
||
public struct addon_data
|
||
{
|
||
public int id;
|
||
public int[] arg;
|
||
public addon_data(int id) {
|
||
this.id = id;
|
||
arg = new int[3];
|
||
}
|
||
};
|
||
public struct prerequisition
|
||
{
|
||
public short level;
|
||
public short race;
|
||
public short strength;
|
||
public short vitality;
|
||
public short agility;
|
||
public short energy;
|
||
public int durability;
|
||
public int max_durability;
|
||
};
|
||
struct _weapon_essence
|
||
{
|
||
public enum WEAPON_TYPE
|
||
{
|
||
WEAPON_TYPE_MELEE = 0,
|
||
WEAPON_TYPE_RANGE = 1,
|
||
WEAPON_TYPE_MELEE_ASN = 2, //�̿�ʹ�õĽ���������������Ӱ���﹥�⣬�����������ͬ
|
||
};
|
||
|
||
public short weapon_type; //������� ��Ӧģ����Ľ���Զ�̱�־
|
||
public short weapon_delay; //�����Ĺ����ӳ�ʱ�䣬��50msΪ��λ
|
||
public int weapon_class; //�������� ��Ӧģ����Ĵ��� ���絶�� ������
|
||
public int weapon_level; //�������� ijЩ������Ҫ��������
|
||
public int require_projectile; //��Ҫ��ҩ������
|
||
public int damage_low; //����������С��ֵ
|
||
public int damage_high; //������������ֵ
|
||
public int magic_damage_low; //ħ������
|
||
public int magic_damage_high; //ħ������
|
||
public int attack_speed;
|
||
public float attack_range;
|
||
public float attack_short_range;
|
||
};
|
||
public static class itemdataman
|
||
{
|
||
#region const
|
||
public const uint ELEMENTDATAMAN_MAX_NUM_ADDON_PARAM = 3;
|
||
public struct _addon //������Ŀ
|
||
{
|
||
public int addon_type;
|
||
public int[] addon_arg; // 0 ~ 3 ��Ŀ�� ((type & 0x6000)>>13)
|
||
public _addon(int addon_type) {
|
||
this.addon_type = addon_type;
|
||
addon_arg = new int[ELEMENTDATAMAN_MAX_NUM_ADDON_PARAM];
|
||
}
|
||
};
|
||
#region Equip Mask
|
||
public const uint ELEMENTDATAMAN_MAX_NUM_HOLES = 5;
|
||
public const uint ELEMENTDATAMAN_MAX_NUM_ADDONS = 32;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_WEAPON = 0x0001;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_HEAD = 0x0002;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_NECK = 0x0004;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_SHOULDER = 0x0008;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_BODY = 0x0010;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_WAIST = 0x0020;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_LEG = 0x0040;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_FOOT = 0x0080;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_WRIST = 0x0100;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_FINGER1 = 0x0200;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_FINGER2 = 0x0400;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_PROJECTILE = 0x0800;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_FLYSWORD = 0x1000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_DAMAGERUNE = 0x20000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_BIBLE = 0x40000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_SPEAKER = 0x80000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_AUTO_HP = 0x100000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_AUTO_MP = 0x200000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_ELF = 0x800000; //lgc
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_STALLCARD = 0x1000000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_FORCE_TICKET = 0x4000000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_DYNSKILL_ALL = 0x18000000; public const uint ELEMENTDATAMAN_EQUIP_MASK_HAS_ADDON = 0x40000000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_EXTEND64 = 0x80000000;
|
||
public const uint ELEMENTDATAMAN_EQUIP_MASK_HIGH = 0xC0000000;
|
||
#endregion
|
||
#endregion
|
||
public static Dictionary<uint, LOCATION> sale_item_id_index_map;
|
||
public static elementdataman _edm;
|
||
public static int load_data(string pathname, bool disable_bind2)
|
||
{
|
||
_edm = ElementDataManProvider.GetElementDataMan();
|
||
generate_item_for_sell(disable_bind2);
|
||
return 0;
|
||
// if(await _edm.load_data(pathname) == 0)
|
||
// {
|
||
// generate_item_for_sell(disable_bind2);
|
||
// return 0;
|
||
// }
|
||
// else
|
||
// return -1;
|
||
}
|
||
|
||
public static int generate_item_for_sell(bool disable_bind2)
|
||
{
|
||
//#define CASE_CLEAR_PROC_TYPE(ESSENCE) case DT_##ESSENCE: \
|
||
// {\
|
||
// DATA_TYPE dt2;\
|
||
// ESSENCE* ess = (ESSENCE*)get_data_ptr(id, ID_SPACE_ESSENCE, dt2); \
|
||
// if (dt2 == datatype && ess && disable_bind2) ess->proc_type &= ~(0x0040);\
|
||
// }
|
||
|
||
byte[] item;
|
||
uint size;
|
||
int ret;
|
||
|
||
DATA_TYPE datatype = DATA_TYPE.DT_INVALID;
|
||
item_tag_t tag = new item_tag_t((char)ITEM_MAKE_TAG.IMT_SHOP, (char)'0');
|
||
//uint id = _edm.get_first_data_id(ID_SPACE.ID_SPACE_ESSENCE,ref datatype);
|
||
|
||
|
||
for (uint id = 0; id < _edm.essence_id_data_type_map.Count; id++)
|
||
{
|
||
_edm.essence_id_data_type_map.TryGetValue(id, out datatype);
|
||
switch (datatype)
|
||
{
|
||
case (DATA_TYPE.DT_WEAPON_ESSENCE):
|
||
generate_item_temp.generate_weapon(id,ID_SPACE.ID_SPACE_ESSENCE,
|
||
out item,out size,SPECIFIC.SPECIFIC_RAND,GEN_ADDON_MODE.ADDON_LIST_SHOP,tag);
|
||
BMLogger.Log("generate_item_for_sell: generate_weapon: " + id);
|
||
break;
|
||
default:
|
||
BMLogger.Log("generate_item_for_sell: default: " + id);
|
||
ret = -1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// CASE_CLEAR_PROC_TYPE(ARMOR_ESSENCE)
|
||
|
||
// ret = generate_armor(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0), element_data::ADDON_LIST_SHOP, &tag, sizeof(tag));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(PROJECTILE_ESSENCE)
|
||
|
||
// ret = generate_projectile(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
|
||
// case DT_QUIVER_ESSENCE:
|
||
// ret = generate_quiver_for_sell(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(STONE_ESSENCE)
|
||
|
||
// ret = generate_stone(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(DECORATION_ESSENCE)
|
||
|
||
// ret = generate_decoration(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0), element_data::ADDON_LIST_SHOP, &tag, sizeof(tag));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(MEDICINE_ESSENCE)
|
||
|
||
// ret = generate_medicine(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(WINGMANWING_ESSENCE)
|
||
|
||
// ret = generate_wingmanwing(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0), &tag, sizeof(tag));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(MATERIAL_ESSENCE)
|
||
|
||
// ret = generate_material(id, ID_SPACE_ESSENCE, (char**)&item, size, (MATERIAL_ESSENCE*)0, DT_MATERIAL_ESSENCE);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(DYE_TICKET_ESSENCE)
|
||
|
||
// ret = generate_material(id, ID_SPACE_ESSENCE, (char**)&item, size, (DYE_TICKET_ESSENCE*)0, DT_DYE_TICKET_ESSENCE);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FIREWORKS_ESSENCE)
|
||
|
||
// ret = generate_fireworks(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(WAR_TANKCALLIN_ESSENCE)
|
||
|
||
// ret = generate_tankcallin(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(SKILLMATTER_ESSENCE)
|
||
|
||
// ret = generate_skillmatter(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(DAMAGERUNE_ESSENCE)
|
||
|
||
// ret = generate_damagerune(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(ARMORRUNE_ESSENCE)
|
||
|
||
// ret = generate_armorrune(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(SKILLTOME_ESSENCE)
|
||
|
||
// ret = generate_skilltome(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FLYSWORD_ESSENCE)
|
||
|
||
// ret = generate_flysword(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0), &tag, sizeof(tag));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TOWNSCROLL_ESSENCE)
|
||
|
||
// ret = generate_townscroll(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(UNIONSCROLL_ESSENCE)
|
||
|
||
// ret = generate_unionscroll(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(REVIVESCROLL_ESSENCE)
|
||
|
||
// ret = generate_revivescroll(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(ELEMENT_ESSENCE)
|
||
|
||
// ret = generate_element(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TASKMATTER_ESSENCE)
|
||
|
||
// ret = generate_taskmatter(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TOSSMATTER_ESSENCE)
|
||
|
||
// ret = generate_tossmatter(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TASKDICE_ESSENCE)
|
||
|
||
// ret = generate_taskdice(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TASKNORMALMATTER_ESSENCE)
|
||
|
||
// ret = generate_tasknormalmatter(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FASHION_ESSENCE)
|
||
|
||
// ret = generate_fashion_item(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0), &tag, sizeof(tag));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FACEPILL_ESSENCE)
|
||
|
||
// ret = generate_facepill(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FACETICKET_ESSENCE)
|
||
|
||
// ret = generate_faceticket(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(GM_GENERATOR_ESSENCE)
|
||
|
||
// ret = generate_gm_generator(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(PET_EGG_ESSENCE)
|
||
|
||
// ret = generate_pet_egg(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(PET_FOOD_ESSENCE)
|
||
|
||
// ret = generate_pet_food(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(REFINE_TICKET_ESSENCE)
|
||
|
||
// ret = generate_refine_ticket(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(BIBLE_ESSENCE)
|
||
|
||
// ret = generate_bible(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(SPEAKER_ESSENCE)
|
||
|
||
// ret = generate_speaker(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(AUTOHP_ESSENCE)
|
||
|
||
// ret = generate_hp_amulet(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(AUTOMP_ESSENCE)
|
||
|
||
// ret = generate_mp_amulet(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(DOUBLE_EXP_ESSENCE)
|
||
|
||
// ret = generate_double_exp(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TRANSMITSCROLL_ESSENCE)
|
||
|
||
// ret = generate_transmitscroll(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(GOBLIN_ESSENCE)
|
||
|
||
// ret = generate_elf(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(GOBLIN_EQUIP_ESSENCE)
|
||
|
||
// ret = generate_elf_equip(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(GOBLIN_EXPPILL_ESSENCE)
|
||
|
||
// ret = generate_elf_exppill(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(SELL_CERTIFICATE_ESSENCE)
|
||
|
||
// ret = generate_stallcard(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(TARGET_ITEM_ESSENCE)
|
||
|
||
// ret = generate_skilltrigger2(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(LOOK_INFO_ESSENCE)
|
||
|
||
// ret = generate_queryotherproperty(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(INC_SKILL_ABILITY_ESSENCE)
|
||
|
||
// ret = generate_incskillability(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(WEDDING_BOOKCARD_ESSENCE)
|
||
|
||
// ret = generate_wedding_bookcard(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(WEDDING_INVITECARD_ESSENCE)
|
||
|
||
// ret = generate_wedding_invitecard(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(SHARPENER_ESSENCE)
|
||
|
||
// ret = generate_sharpener(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FACTION_MATERIAL_ESSENCE)
|
||
|
||
// ret = generate_factionmaterial(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(CONGREGATE_ESSENCE)
|
||
|
||
// ret = generate_congregate(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(FORCE_TOKEN_ESSENCE)
|
||
|
||
// ret = generate_force_ticket(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(DYNSKILLEQUIP_ESSENCE)
|
||
|
||
// ret = generate_dynskillequip(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(MONEY_CONVERTIBLE_ESSENCE)
|
||
|
||
// ret = generate_moneyconvertibleitem(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(MONSTER_SPIRIT_ESSENCE)
|
||
|
||
// ret = generate_soul(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(POKER_ESSENCE)
|
||
|
||
// ret = generate_generalcard(id, ID_SPACE_ESSENCE, (char**)&item, size, element_data::SPECIFIC(0));
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(POKER_DICE_ESSENCE)
|
||
|
||
// ret = generate_generalcard_dice(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(SHOP_TOKEN_ESSENCE)
|
||
|
||
// ret = generate_shoptoken(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// CASE_CLEAR_PROC_TYPE(UNIVERSAL_TOKEN_ESSENCE)
|
||
|
||
// ret = generate_universal_token(id, ID_SPACE_ESSENCE, (char**)&item, size);
|
||
// break;
|
||
|
||
// case DT_MONSTER_ESSENCE:
|
||
// case DT_NPC_ESSENCE:
|
||
// default:
|
||
// continue;
|
||
// }
|
||
|
||
// if (ret == 0 && size != 0)
|
||
// {
|
||
// sale_item_ptr_array.push_back(item);
|
||
// sale_item_size_array.push_back(size);
|
||
// LOCATION loc;
|
||
// loc.type = datatype;
|
||
// loc.pos = sale_item_ptr_array.size() - 1;
|
||
// sale_item_id_index_map[id] = loc;
|
||
// }
|
||
// }
|
||
return 0;
|
||
}
|
||
|
||
|
||
public static object get_item_for_sell(uint id)
|
||
{
|
||
uint pos;
|
||
if (sale_item_id_index_map.TryGetValue(id, out var itr))
|
||
{
|
||
return itr;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public static uint generate_equipment_addon_buffer_2
|
||
(DATA_TYPE essencetype,
|
||
List<int> candidate_addon,
|
||
byte[] addon_buffer, int start_offset,
|
||
ref uint addon_num)
|
||
{
|
||
//���ɶ��addon�����ܻ��в�������ʧ��
|
||
if(addon_num == 0) return 0;
|
||
byte[] addon_sld = addon_buffer;
|
||
int i,j;
|
||
int anum = 0;
|
||
int offset = start_offset;
|
||
for(i=0; i<candidate_addon.Count; i++)
|
||
{
|
||
uint id = (uint)candidate_addon[i];
|
||
if(id <= 0) continue;
|
||
|
||
//��ʼ���� addon
|
||
addon_data addondata = new addon_data((int)id);
|
||
int rparanum;
|
||
if((rparanum = generate_addon(essencetype,id, ref addondata)) < 0) continue;
|
||
|
||
//*(int*)addon_sld = (addondata.id &(~(0x3<<13))) | (rparanum<<13);
|
||
//addon_sld += sizeof(int);
|
||
int value = (addondata.id & (~(0x3 << 13))) | (rparanum << 13);
|
||
byte[] intBytes = BitConverter.GetBytes(value);
|
||
Array.Copy(intBytes, 0, addon_buffer, offset, 4);
|
||
offset += 4;
|
||
|
||
anum ++;
|
||
for(j=0; j<rparanum; j++)
|
||
{
|
||
//*(int*)addon_sld = addondata.arg[j];
|
||
//addon_sld += sizeof(int);
|
||
value = addondata.arg[j];
|
||
intBytes = BitConverter.GetBytes(value);
|
||
Array.Copy(intBytes, 0, addon_buffer, offset, 4);
|
||
offset += 4;
|
||
}
|
||
}
|
||
addon_num = (uint)anum;
|
||
return (uint)(addon_sld.Length - addon_buffer.Length);
|
||
}
|
||
|
||
|
||
public static int generate_addon(DATA_TYPE datatype,uint addon_id, ref addon_data data)
|
||
{
|
||
DATA_TYPE dt = DATA_TYPE.DT_INVALID;
|
||
int paramnum = 0;
|
||
object temp = _edm.get_data_ptr(addon_id, ID_SPACE.ID_SPACE_ADDON, ref dt);
|
||
if(temp == null)
|
||
{
|
||
return -1;
|
||
}
|
||
EQUIPMENT_ADDON addon = (EQUIPMENT_ADDON) temp;
|
||
if(dt != DATA_TYPE.DT_EQUIPMENT_ADDON) // error
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
data.id = (int)addon_id;
|
||
paramnum = addon.num_params;
|
||
data.arg[0] = addon.param1;
|
||
data.arg[1] = addon.param2;
|
||
data.arg[2] = addon.param3;
|
||
}
|
||
|
||
return EC_Game.addon_generate_arg(datatype, data, paramnum);
|
||
}
|
||
|
||
public static void generate_template_addon<RAN_CLASS>(
|
||
DATA_TYPE dt,float unique_prob,
|
||
List<int> unique, List<int> produce, List<int> drop, byte[] addon_buf,
|
||
ref uint addon_num,ref uint addon_size, RAN_CLASS cls,GEN_ADDON_MODE normal_addon,List<int> sa_list)
|
||
{
|
||
if(normal_addon == GEN_ADDON_MODE.ADDON_LIST_DROP)
|
||
{
|
||
uint un = 0;
|
||
//ASSERT(addon_size == 0);
|
||
if(element_data.Rand_NORMAL_LOWER(0f,1f,NORMAL.NORMAL_RAND,LOWER.LOWER_TREND) < unique_prob)
|
||
{
|
||
un = 1;
|
||
addon_size = generate_equipment_addon_buffer(dt, unique, 16, addon_buf,0, ref un);
|
||
addon_num -= un;
|
||
}
|
||
addon_size += generate_equipment_addon_buffer(dt, drop, 32, addon_buf, (int)addon_size, ref addon_num);
|
||
addon_num += un;
|
||
}
|
||
else if(normal_addon == GEN_ADDON_MODE.ADDON_LIST_PRODUCE)
|
||
{
|
||
uint un = 0;
|
||
//ASSERT(addon_size == 0);
|
||
if(element_data.Rand_NORMAL_LOWER(0f,1f,NORMAL.NORMAL_RAND,LOWER.LOWER_TREND) < unique_prob)
|
||
{
|
||
un = 1;
|
||
addon_size = generate_equipment_addon_buffer(dt, unique, 16, addon_buf,0, ref un);
|
||
addon_num -= un;
|
||
}
|
||
addon_size += generate_equipment_addon_buffer(dt, produce, 32, addon_buf, (int)addon_size, ref addon_num);
|
||
addon_num += un;
|
||
}
|
||
else if (normal_addon == GEN_ADDON_MODE.ADDON_LIST_SPEC)
|
||
{
|
||
addon_size = generate_spec_addon_buffer(dt,addon_buf, 0, itemdataman.ELEMENTDATAMAN_MAX_NUM_ADDONS, ref addon_num,sa_list);
|
||
}
|
||
else
|
||
{
|
||
addon_size = 0;
|
||
addon_num = 0;
|
||
}
|
||
}
|
||
|
||
public static uint generate_equipment_addon_buffer
|
||
(DATA_TYPE essencetype,
|
||
List<int> candidate_addon,
|
||
int candidate_num,
|
||
byte[] addon_buffer,
|
||
int start_offset,
|
||
ref uint addon_num)
|
||
{
|
||
if(addon_num == 0) return 0;
|
||
int[] addon_list = new int[32];
|
||
int i;
|
||
uint anum;
|
||
//����addon���������
|
||
for(anum = 0,i=0; i<addon_num; i++)
|
||
{
|
||
// float * prob_header =(float*) (candidate_header + sizeof(unsigned int));
|
||
// int addon_index = abase::RandSelect(prob_header, sizeof(unsigned int)+sizeof(float), candidate_num);
|
||
// int id = *(int*)(candidate_header + addon_index*(sizeof(unsigned int)+sizeof(float)));
|
||
uint id = (uint)candidate_addon[i];
|
||
if(id <= 0) continue;
|
||
/*
|
||
//�������ɶ��һ����addon
|
||
for(j =0; j < anum ; j ++)
|
||
{
|
||
if(addon_list[j] == id) break;
|
||
}
|
||
if(j != anum) continue;
|
||
*/
|
||
addon_list[anum++] = (int)id;
|
||
|
||
|
||
}
|
||
addon_num = anum;
|
||
|
||
List<int> addon_list_converted = new List<int>();
|
||
for (int j = 0; j < anum; j++)
|
||
{
|
||
addon_list_converted.Add(addon_list[j]);
|
||
}
|
||
return generate_equipment_addon_buffer_2(essencetype, addon_list_converted, addon_buffer, start_offset, ref addon_num);
|
||
}
|
||
|
||
public static uint generate_spec_addon_buffer
|
||
(DATA_TYPE essencetype,
|
||
byte[] addon_buffer,
|
||
int start_offset,
|
||
uint max_addon_size,
|
||
ref uint addon_num,
|
||
List<int> sa_list)
|
||
{
|
||
addon_num = 0;
|
||
if(sa_list.Count == 0) return 0;
|
||
int i;
|
||
for(i = 0; i < max_addon_size; i ++)
|
||
{
|
||
if(sa_list[i] <= 0) break;
|
||
}
|
||
if(i == 0 ) return 0;
|
||
addon_num = (uint)i;
|
||
return generate_equipment_addon_buffer_2(essencetype,sa_list,addon_buffer,start_offset, ref addon_num);
|
||
}
|
||
public static void get_item_guid( uint id, out int g1, out int g2)
|
||
{
|
||
EC_Game.get_item_guid(id,out g1,out g2);
|
||
}
|
||
public static int addon_update_ess_data(addon_data data, object essence,int ess_size, prerequisition require)
|
||
{
|
||
return EC_Game.addon_update_ess_data(data, essence, ess_size, require);
|
||
}
|
||
public static void update_require_data(prerequisition require)
|
||
{
|
||
EC_Game.update_require_data(require);
|
||
}
|
||
public static void set_to_classid(DATA_TYPE type, byte[] data, int major_type)
|
||
{
|
||
EC_Game.set_to_classid(type, data, major_type);
|
||
}
|
||
}
|
||
|
||
} |