private static ToolResult CopyUsedTexturesObj(string objFile, string outputDirectory, string textureDirectory)
{
bool success = false;
string message = "";
ObjData objData = ObjParser.TryParseObj(objFile);
if (objData != null)
{
objData.UpdateMtlData();
MtlData mtlData = objData.Mtl;
if (mtlData != null)
{
success = ObjModifier.CopyUsedTextures(mtlData, outputDirectory, textureDirectory);
message = MessageBoxConstants.GetMessageExecutionGeneric(success);
}
else
{
message = MessageBoxConstants.MessageErrorCopyTextures + MessageBoxConstants.MessageMtlNotFound;
}
}
else
{
message = MessageBoxConstants.GetMessageExecutionErrorParse(objFile);
}
return(new ToolResult(message, success));
}
public void Load(ObjData obj)
{
if (CheckIsActive(obj.sUid) != null)
{
return;
}
if (!MoveToActive(obj))
{
SceneObj sceneObj = new SceneObj(obj);
sceneObj.status = SceneObjStatus.New;
GameObject resObj = null;
ResourcesObj resourceObj;
if (ResourcesObjDic.TryGetValue(obj.resPath, out resourceObj))
{
resObj = resourceObj.obj;
resourceObj.CreateIns();
}
else
{
resObj = Resources.Load <GameObject>(obj.resPath);
}
CreateObj(resObj, sceneObj);
ActiveObjDic.Add(obj.sUid, sceneObj);
}
}
/// <summary>
/// Rename every material from the obj and mtl to make them unique after the merge
/// </summary>
/// <param name="objData"></param>
/// <param name="mtlData"></param>
/// <param name="indexMaterial"></param>
private static void SetUniqueMaterialsNames(ObjData objData, MtlData mtlData, IntWrapper indexMaterial)
{
// Dictionary that associate every material to a list of groups
Dictionary <string, List <int> > dictMaterialGroups = ObjUtils.GetDictMaterialGroups(objData);
if (mtlData == null) // Need to rename the Materials in obj only
{
foreach (KeyValuePair <string, List <int> > keyValue in dictMaterialGroups)
{
SetUniqueMaterialsName(objData, keyValue.Value, indexMaterial);
indexMaterial.Value++;
}
}
else // Need to rename the Materials in both obj and mtl
{
// Dictionary that associate every material of the mtl file to their index
Dictionary <string, int> dictMaterialIndex = MtlUtils.GetDictMaterialIndex(mtlData);
foreach (KeyValuePair <string, List <int> > keyValue in dictMaterialGroups)
{
SetUniqueMaterialsName(objData, keyValue.Value, indexMaterial);
if (dictMaterialIndex.TryGetValue(keyValue.Key, out int index)) // We get the index of the material
{
MaterialMtl materialMtl = mtlData.MaterialsList[index];
if (materialMtl.NewMtl != null)
{
materialMtl.NewMtl = GenericUtils.MergeIndexStr(indexMaterial.Value, materialMtl.NewMtl);
}
}
indexMaterial.Value++;
}
}
}
private void CreateHeroPreview(uint heroId, int i)
{
CUIFormScript form = Singleton <CUIManager> .GetInstance().GetForm(HeroChooseLogic.s_heroInitChooseFormPath);
if (form == null)
{
return;
}
string name = string.Format("RawImage{0}", i);
GameObject gameObject = form.transform.Find(name).gameObject;
CUIRawImageScript component = gameObject.GetComponent <CUIRawImageScript>();
ObjData hero3DObj = CUICommonSystem.GetHero3DObj(heroId, true);
if (hero3DObj.Object == null)
{
return;
}
component.AddGameObject(name, hero3DObj.Object, Vector3.zero, Quaternion.identity, hero3DObj.Object.transform.localScale);
this.cacheObjList.Add(hero3DObj.Object);
CUIEventScript cUIEventScript = gameObject.GetComponent <CUIEventScript>();
if (cUIEventScript == null)
{
cUIEventScript = gameObject.AddComponent <CUIEventScript>();
cUIEventScript.Initialize(form);
}
cUIEventScript.SetUIEvent(enUIEventType.Click, enUIEventID.Hero_Init_Select, new stUIEventParams
{
heroId = heroId
});
}
/// <summary>
/// Try to parse the obj file to make the data useable. Return null if error during the parsing
/// </summary>
/// <param name="file">File to parse</param>
/// <param name="parseMtl">Parse the mtl file directly</param>
/// <returns>WrlData if successful, null otherwise</returns>
public static ObjData TryParseObj(string file, bool parseMtl = true)
{
ObjData objData = null;
try { objData = ParseObj(file, parseMtl); } catch { }
return(objData);
}
//this methode shades the objects in uv space
//it's called by the Render(...) every frame for every object
//Input: obj: ObjData, obj, for which the tilemask should be created
// renderContext: ScriptableRenderContext
// camera: Camera in scene
void RunObjectSpaceComputeShader(ObjData obj)
{
//vertex location buffer
Vector3[] locPos = GetVertices(obj.obj);
ComputeBuffer locationBuffer = new ComputeBuffer(locPos.Length, sizeof(float) * 3);
locationBuffer.SetData(locPos);
//vertex normal buffer
Vector3[] normals = GetNormals(obj.obj);
ComputeBuffer normalBuffer = new ComputeBuffer(normals.Length, sizeof(float) * 3);
normalBuffer.SetData(normals);
//setup cs parameters
worldPosShader.SetMatrix("localToWorldMatrix", obj.obj.GetComponent <Renderer>().localToWorldMatrix);
worldPosShader.SetTexture(worldPosKernel, "tileMask", obj.tileMask);
worldPosShader.SetTexture(worldPosKernel, "vertexIds", obj.obj.GetComponent <Renderer>().material.GetTexture("_VertexIDs"));
worldPosShader.SetTexture(worldPosKernel, "objectTexture", obj.obj.GetComponent <Renderer>().material.GetTexture("_Texture"));
worldPosShader.SetTexture(worldPosKernel, "baycentCoords", obj.obj.GetComponent <Renderer>().material.GetTexture("_BaycentCoords"));
worldPosShader.SetBuffer(worldPosKernel, "vertexPositions", locationBuffer);
worldPosShader.SetBuffer(worldPosKernel, "vertexNormals", normalBuffer);
worldPosShader.SetTexture(worldPosKernel, "textureTiles", obj.obj.GetComponent <Renderer>().material.GetTexture("_TextureAtlas"));
//Call compute shader
worldPosShader.Dispatch(worldPosKernel, MAX_TEXTURE_SIZE * 2 / 8, MAX_TEXTURE_SIZE / 8, 1);
//release buffer
locationBuffer.Release();
normalBuffer.Release();
}
public bool CheckAndUpdateInfo()
{
VertsCount = 0;
PolygonsCount = 0;
SubMeshesCount = 0;
bool fileExist = System.IO.File.Exists(Path);
if (!fileExist)
{
Info = "missing file";
VertsCount = -1;
return(false);
}
else if (ObjData.GetObjInfo(Path, ref MeshName, ref VertsCount, ref PolygonsCount, ref SubMeshesCount))
{
Info = string.Format("{0}.obj {1} verts, {2} polygons, {3} submeshes", MeshName, VertsCount, PolygonsCount, SubMeshesCount);
return(true);
}
else
{
Info = "not valid obj file";
VertsCount = -1;
return(false);
}
}
void GatherRenderObject()
{
if (LRayMarchObjects == null)
{
return;
}
if (LRayMarchObjects.Length == 0)
{
Debug.Log("Zero Object");
return;
}
MarchData.Clear();
for (int i = 0; i < LRayMarchObjects.Length; i++)
{
ObjData OD = new ObjData();
OD.ShType = (int)LRayMarchobjProperties[i].ShType;
OD.OpType = (int)LRayMarchobjProperties[i].OpType;
OD.material = LRayMarchobjProperties[i].baseColor;
OD.origin = LRayMarchObjects[i].transform.position;
OD.upvector = LRayMarchObjects[i].transform.up;
OD.size = LRayMarchObjects[i].transform.localScale;
OD.size = LRayMarchObjects[i].transform.localScale;
MarchData.Add(OD);
}
}
public void ReedResultServer()
{
string data;
string url = @"https://covid-api.com/api/reports?date=" + DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd") + "&q=egypt";
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
using (Stream stream = response.GetResponseStream())
using (StreamReader reader = new StreamReader(stream))
{
data = reader.ReadToEnd();
}
ObjData dataObj = JsonConvert.DeserializeObject <ObjData>(data);
if (dataObj.data[0] != null && !context.Corons.Any(c => c.Date.Equals(DateTime.Now)))
{
context.Add(new Coron {
Active = dataObj.data[0].active,
Confirmed = dataObj.data[0].confirmed.ToString(),
Date = dataObj.data[0].date,
Deaths = dataObj.data[0].deaths,
Recovered = dataObj.data[0].recovered
});
context.SaveChanges();
}
}
void Awake()
{
if (instance == null)
{
instance = this;
}
Block = new GameObject[]
{
NONE,
USER,
DUPL,
FINI
};
float fix = 1080f / Screen.width; // 0.5f
float h = (Screen.height * fix - Screen.width * fix) * 0.5f;
if (h < 360f)
{
h = 360;
}
ButtonPanel.GetComponent <RectTransform>().sizeDelta = new Vector2(0, h);
StagePanel.GetComponent <RectTransform>().sizeDelta = new Vector2(0, h);
}
public ObjData ConvertFileAsync(string objFilePath, bool useMtl, Material standardMaterial, Material transparentMaterial)
{
var objData = new ObjData();
ConvertFile(objFilePath, useMtl, standardMaterial, transparentMaterial, objData);
return(objData);
}
/// <summary>
/// Return a dictionary with each Material associated to the indexes of their Group
/// </summary>
/// <param name="objData"></param>
/// <returns></returns>
public static Dictionary <string, List <int> > GetDictMaterialGroups(ObjData objData)
{
var dict = new Dictionary <string, List <int> >();
int i = 0;
foreach (ObjectObj objectObj in objData.ObjectsList)
{
if (objectObj.MaterialName != null)
{
if (dict.TryGetValue(objectObj.MaterialName, out List <int> groups))
{
groups.Add(i); // If the keyvalue already exists, we add the new index
}
else
{
dict.Add(objectObj.MaterialName, new List <int>()
{
i
}); // Otherwise, we create the new keyvalue
}
}
i++;
}
return(dict);
}
/// <summary>
/// Merge the list of given ObjData into a single one and returns it
/// </summary>
/// <param name="objFiles"></param>
/// <returns></returns>
public static ObjData MergeObjFiles(List <ObjData> objFiles)
{
if (objFiles != null)
{
int length = objFiles.Count;
if (length >= 1) // Should always be the case
{
ObjData objData = objFiles[0];
if (length == 1) // Only one objData
{
return(objData);
}
else // More objData to merge with the first one
{
IntWrapper indexMaterial = new IntWrapper(0);
// Rename every materials to be unique
SetUniqueMaterialsNames(objData, objData.Mtl, indexMaterial);
for (int i = 1; i < length; i++)
{
ObjData nextObjData = objFiles[i];
SetUniqueMaterialsNames(nextObjData, nextObjData.Mtl, indexMaterial);
objData.MergeObjData(nextObjData);
}
return(objData);
}
}
}
return(null);
}
/// <summary>
/// Extract each .bmp texture from the material or group and store it into the TextureName attributes
/// </summary>
/// <param name="objData">Data parsed from the obj file</param>
public static void ParseTextures(ObjData objData)
{
foreach (ObjectObj objectObj in objData.ObjectsList)
{
if (objectObj.GroupName == null)
{
if (objectObj.ObjectName != null)
{
objectObj.GroupName = objectObj.ObjectName;
}
else // Impossible to set a group name (unlikely to happen)
{
continue;
}
}
if (objectObj.MaterialName == null) // If no material
{
objectObj.MaterialName = objectObj.GroupName;
}
if (objectObj.TextureName == null) // No texture assigned currently
{
string textureName = GenericUtils.ExtractTextureNameFromMaterial(objectObj.MaterialName);
if (textureName == null) // No bmp found in the material
{
textureName = GenericUtils.ExtractTextureNameFromMaterial(objectObj.GroupName);
}
objectObj.TextureName = textureName;
}
}
}
private IEnumerator IELoad(ObjData obj)
{
SceneObj sceneObj = new SceneObj(obj);
sceneObj.status = SceneObjStatus.Loading;
ActiveObjDic.Add(obj.sUid, sceneObj);
GameObject resObj = null;
ResourcesObj resourceObj;
if (ResourcesObjDic.TryGetValue(obj.resPath, out resourceObj))
{
resObj = resourceObj.obj;
resourceObj.CreateIns();
}
else
{
ResourceRequest request = Resources.LoadAsync <GameObject>(obj.resPath);
yield return(request);
resObj = request.asset as GameObject;
}
CreateObj(resObj, sceneObj);
sceneObj.status = SceneObjStatus.New;
}
private static ToolResult ConvertObjToSmd(string objFile, string smdOutput, bool useTextureName)
{
bool success = false;
string message = "";
ObjData objData = ObjParser.TryParseObj(objFile);
if (objData != null)
{
objData.UpdateMtlData();
MtlData mtlData = objData.Mtl;
if (mtlData == null)
{
// No MTL means the SMD will use a default material name for all objects
useTextureName = false;
}
success = SmdExporter.WriteSmd(objData, mtlData, smdOutput, useTextureName);
message = MessageBoxConstants.GetMessageExecutionCreation(success, smdOutput);
}
else
{
message = MessageBoxConstants.GetMessageExecutionErrorParse(objFile);
}
return(new ToolResult(message, success));
}
private static ToolResult MergeObjFiles(List <string> fileList, string objOutput)
{
bool success = false;
StringBuilder sb = new StringBuilder();
if (fileList != null)
{
List <ObjData> objDatas = ObjParser.ParseObjs(fileList);
ObjData objData = ObjModifier.MergeObjFiles(objDatas);
if (objData != null)
{
success = ObjExporter.WriteObj(objData, objData.Mtl, objOutput, makeMtl: true, useExistingMtl: true);
sb.AppendLine($"Merged {objDatas.Count} obj files into one");
sb.Append(MessageBoxConstants.GetMessageExecutionCreation(success, objOutput));
}
else
{
sb.Append(MessageBoxConstants.MessageErrorMergeObj + MessageBoxConstants.MessageErrorExecution);
}
}
else
{
sb.Append(MessageBoxConstants.MessageErrorMergeObj + MessageBoxConstants.MessageNoFilesMerge);
}
return(new ToolResult(sb.ToString(), success));
}
public static void AddView(ushort id, netvrkView view, GameObject go)
{
MonoBehaviour[] scripts = go.GetComponents <MonoBehaviour>();
ObjData data = objList[id];
data.netObj = view;
foreach (MonoBehaviour script in scripts)
{
Type type = script.GetType();
MethodInfo[] objectFields = type.GetMethods(BindingFlags.Instance | BindingFlags.Public);
for (int i = 0; i < objectFields.Length; i++)
{
netvrkRpc attribute = Attribute.GetCustomAttribute(objectFields[i], typeof(netvrkRpc)) as netvrkRpc;
if (attribute != null)
{
data.methods.Add(objectFields[i].Name);
data.scripts.Add(script);
data.rpcMethods.Add(objectFields[i]);
}
}
MethodInfo info = type.GetMethod("OnNetvrkReadSyncStream", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (info != null)
{
data.syncMethod = info;
data.syncScript = script;
}
}
}
private static ToolResult DeleteUnusedMaterialsObj(string objFile, string objOutput)
{
bool success = false;
string message = "";
ObjData objData = ObjParser.TryParseObj(objFile);
if (objData != null)
{
objData.UpdateMtlData();
MtlData mtlData = objData.Mtl;
if (mtlData != null)
{
ObjModifier.DeleteUnusedMaterials(objData, mtlData);
success = ObjExporter.WriteObj(objData, mtlData, objOutput, makeMtl: true, useExistingMtl: true);
message = MessageBoxConstants.GetMessageExecutionCreation(success, objOutput);
}
else
{
message = MessageBoxConstants.MessageErrorDeleteUnusedMaterials +
MessageBoxConstants.MessageMtlNotFound;
}
}
else
{
message = MessageBoxConstants.GetMessageExecutionErrorParse(objFile);
}
return(new ToolResult(message, success));
}
private void CreateHeroPreview(uint heroId, int i)
{
CUIFormScript form = Singleton <CUIManager> .GetInstance().GetForm(s_heroInitChooseFormPath);
if (form != null)
{
string name = string.Format("RawImage{0}", i);
GameObject gameObject = form.transform.Find(name).gameObject;
CUIRawImageScript component = gameObject.GetComponent <CUIRawImageScript>();
ObjData data = CUICommonSystem.GetHero3DObj(heroId, true);
if (data.Object != null)
{
component.AddGameObject(name, data.Object, Vector3.zero, Quaternion.identity, data.Object.transform.localScale);
this.cacheObjList.Add(data.Object);
CUIEventScript script3 = gameObject.GetComponent <CUIEventScript>();
if (script3 == null)
{
script3 = gameObject.AddComponent <CUIEventScript>();
script3.Initialize(form);
}
stUIEventParams eventParams = new stUIEventParams {
heroId = heroId
};
script3.SetUIEvent(enUIEventType.Click, enUIEventID.Hero_Init_Select, eventParams);
}
}
}
public static void SendRpc(ushort objId, string method, object[] data, netvrkTargets targets, int channel = 0)
{
if (!isConnected)
{
Debug.LogWarning("netVRk: Can not send RPCs when not connected!");
return;
}
int methodId = GetObjMethodId(objId, method);
if (methodId < 0)
{
Debug.LogError("netVRk: Rpc method: " + method + " not found!");
return;
}
byte[] bytes = netvrkSerialization.SerializeRpc(objId, (byte)methodId, data);
for (int i = 0; i < playerList.Count; i++)
{
SteamNetworking.SendP2PPacket(playerList[i].SteamId, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable, channel);
}
if (targets == netvrkTargets.All)
{
ObjData objData = objList[objId];
objData.rpcMethods[methodId].Invoke(objData.scripts[methodId], data);
}
}
int _sortNameReverse(ObjData a, ObjData b)
{
string aname = a.obj == null ? "" : a.obj.name;
string bname = b.obj == null ? "" : b.obj.name;
return(string.Compare(bname, aname));
}
int _sortNameForward(ObjData a, ObjData b)
{
string aname = a.obj == null ? "" : a.obj.name;
string bname = b.obj == null ? "" : b.obj.name;
return(string.Compare(aname, bname));
}
public static byte[] AlchemyResponse(bool isSuccess, ObjData.slotItem sItem, byte type, byte totalblue)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_ALCHEMY);
Writer.Byte(1);
Writer.Byte(2);
Writer.Bool(isSuccess);
Writer.Byte(sItem.Slot);
if (!isSuccess) { Writer.Byte(0); }
Writer.DWord(0);
Writer.DWord(sItem.ID);
Writer.Byte(sItem.PlusValue);
Writer.LWord(0);
Writer.DWord(sItem.Durability);
Writer.Byte(ObjData.Manager.ItemBlue[sItem.dbID].totalblue);
for (int i = 0; i <= ObjData.Manager.ItemBlue[sItem.dbID].totalblue - 1; i++)
{
Writer.DWord(ObjData.Manager.MagicOptions.Find(mg => (mg.Name == Convert.ToString(ObjData.Manager.ItemBlue[sItem.dbID].blue[i]))).ID);
Writer.DWord(ObjData.Manager.ItemBlue[sItem.dbID].blueamount[i]);
}
Writer.Word(1);
Writer.Word(2);
Writer.Word(3);
return Writer.GetBytes();
}
/// <summary>
/// Delete every unused material the obj file
/// </summary>
/// <param name="objData">Data parsed from the obj file</param>
/// <param name="mtlData">Data parsed from the mtl file</param>
public static bool DeleteUnusedMaterials(ObjData objData, MtlData mtlData)
{
if (mtlData == null)
{
return(false);
}
// Dictionary that associate every material to a list of groups
Dictionary <string, List <int> > dictMaterialGroups = ObjUtils.GetDictMaterialGroups(objData);
// Dictionary that associate every material of the mtl file to their index
Dictionary <string, int> dictMaterialIndex = MtlUtils.GetDictMaterialIndex(mtlData);
List <MaterialMtl> newMaterialsList = new List <MaterialMtl>();
foreach (KeyValuePair <string, List <int> > keyValue in dictMaterialGroups)
{
if (dictMaterialIndex.TryGetValue(keyValue.Key, out int index)) // We get the index of the material
{
MaterialMtl materialMtl = mtlData.MaterialsList[index];
newMaterialsList.Add(materialMtl);
}
}
// Every material that wasnt used in a group was not added to the list
mtlData.MaterialsList = newMaterialsList;
return(true);
}
private void UnpackRpc(byte[] buffer)
{
netvrkSerialization.unpackOutput output = netvrkSerialization.UnserializeRpc(buffer);
ObjData data = objList[output.objectId];
int id = output.methodId;
data.rpcMethods[id].Invoke(data.scripts[id], output.data);
}
/// <summary>
/// Delete every material from each object
/// </summary>
/// <param name="objData">Data parsed from the obj file</param>
public static void DeleteMaterials(ObjData objData)
{
foreach (ObjectObj objectObj in objData.ObjectsList)
{
objectObj.MaterialName = null;
objectObj.TextureName = null;
}
}
public void Action(GameObject scanObj)
{
scanObject = scanObj;
ObjData objData = scanObject.GetComponent <ObjData>();
Talk(objData.id, objData.isNpc);
talkPanel.SetBool("isShow", isAction);
}
private void AddInternals()
{
ObjData data = new ObjData();
data.methods = new List <string>();
string[] enumNames = Enum.GetNames(typeof(InternalMethod));
data.methods.AddRange(enumNames);
objList.Add(0, data);
}
public void Action(GameObject scanObj)
{
scanObject = scanObj;
ObjData objData = scanObject.GetComponent <ObjData>();
Talk(objData.id, objData.isNPC);
talkPanel.SetActive(isAction);
}
private void InitializePage()
{
DataSet ds = ObjData.GetlistTop10();
int recordCount = 10;// ObjData.GetOrdersCount();
gvLogList.DataSource = ds;
logListPager.RecordCount = recordCount;
gvLogList.DataBind();
}
public static double gamedistance(ObjData.vektor p1, ObjData.vektor p2)
{
// Nukei: for test with range checking on objects, maybe faster than only calculating distance
if ((p1.xSec >= p2.xSec - 1) && (p1.xSec <= p2.xSec + 1) && (p1.ySec >= p2.ySec - 1) && (p1.ySec <= p2.ySec + 1))
{
return gamedistance(p1.x, p1.y, p2.x, p2.y);
}
else
{
return 99999999999999;
}
}
public static byte[] StopMovement(ObjData.vektor p)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_PICKUPITEM_MOVE);
Writer.DWord(p.ID);
Writer.Byte(p.xSec);
Writer.Byte(p.ySec);
Writer.Float(p.x);
Writer.Float(p.z);
Writer.Float(p.y);
Writer.Word(0/*p.Angle*/); // Angle
return Writer.GetBytes();
}
public static byte[] Movement(ObjData.vektor p)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_MOVEMENT); //Select opcode
Writer.DWord(p.ID); //Player ID
Writer.Bool(true); //Bool 1
Writer.Byte(p.xSec); //Player X Sector
Writer.Byte(p.ySec); //Player Y Sector
if (!FileDB.CheckCave(p.xSec, p.ySec))
{
Writer.Word(p.x); //Player X Location
Writer.Word(p.z); //Player Z Location
Writer.Word(p.y); //Player Y Location
}
else
{
if (p.x < 0)
{
Writer.Word(p.x);
Writer.Word(0xFFFF);
}
else
{
Writer.DWord(p.x);
}
Writer.DWord(p.z);
if (p.y < 0)
{
Writer.Word(p.y);
Writer.Word(0xFFFF);
}
else
{
Writer.DWord(p.y);
}
}
Writer.Bool(false);
/* ReSearch this is ext packets
Writer.Byte(p.xSec); //Player X Sector
Writer.Byte(p.ySec); //Player Y Sector
Writer.Word(p.x); //Player X Location
Writer.DWord(p.z); //Player Z Location
Writer.Word(p.y); */ //Player Y Location
return Writer.GetBytes();
}
public void Add(ObjData.slotItem objects)
{
if (item.Count < 5)
{
item.Add(objects);
}
else
{
if (item.Count >= 5)
{
item[0] = item[1];
item[1] = item[2];
item[2] = item[3];
item[3] = item[4];
item[4] = objects;
}
}
}
private IEnumerator GetTexturesAsync(string mtlFile, LinesRef linesRef, string filePath, Dictionary<string, Texture2D> textures, ObjData objData, BoolRef loadError)
{
Texture2D diffuseTexture = null;
string[] lines = mtlFile.Split ('\n');
int numberOfTextures = 0;
// See how many textures there are (to use for progress)
for (int i = 0; i < lines.Length; i++) {
var line = lines[i];
CleanLine (ref line);
lines[i] = line;
if (line.Length < 7 || line[0] == '#') {
continue;
}
if (IsTextureLine (line) && filePath != "") {
numberOfTextures++;
}
}
float progress = .5f;
for (int i = 0; i < lines.Length; i++) {
if (lines[i].Length < 7 || lines[i][0] == '#') {
continue;
}
// Get diffuse/bump texture
if (IsTextureLine (lines[i]) && filePath != "") {
var textureFilePath = GetFileName (lines[i], GetToken (lines[i]));
if (textureFilePath != "") {
var completeFilePath = filePath + textureFilePath;
var www = new WWW(completeFilePath);
while (!www.isDone) {
objData.SetProgress (progress + (www.progress / numberOfTextures) * .5f);
if (objData.cancel) {
loadError.b = true;
yield break;
}
yield return null;
}
if (www.error != null) {
Debug.LogError ("Error loading " + completeFilePath + ": " + www.error);
loadError.b = true;
objData.SetDone();
yield break;
}
progress += (1.0f / numberOfTextures) * .5f;
diffuseTexture = new Texture2D (4, 4);
www.LoadImageIntoTexture (diffuseTexture);
if (lines[i].StartsWith ("map_bump") || lines[i].StartsWith ("bump")) {
ConvertToNormalmap (diffuseTexture);
}
textures[textureFilePath] = diffuseTexture;
}
}
}
linesRef.lines = lines;
}
private GameObject[] CreateObjects(ref string objFile, bool useMtl, Dictionary<string, Material> materials, Material standardMaterial, ObjData objData, string fileName)
{
// Set up obj file
string[] fileLines = objFile.Split ('\n');
int totalVertices = 0;
int totalUVs = 0;
int totalNormals = 0;
var foundF = false;
var foundGroupStart = false;
int firstFCount = 0;
int groupCount = 0;
var originalGroupIndices = new List<int>();
int faceCount = 0;
maxPoints = Mathf.Clamp (maxPoints, 0, 65534);
// Find number of groups in file; also find total number of vertices, normals, and uvs
for (int i = 0; i < fileLines.Length; i++) {
if (fileLines[i].Length < 2) continue;
char char1 = System.Char.ToLower(fileLines[i][0]);
char char2 = System.Char.ToLower(fileLines[i][1]);
if (char1 == 'f' && char2 == ' ') {
if (!foundF) {
firstFCount = faceCount;
}
faceCount++;
if (foundGroupStart && !foundF) {
groupCount++;
originalGroupIndices.Add (firstFCount);
foundGroupStart = false;
}
foundF = true;
}
else if ((char1 == 'o' && char2 == ' ') || (char1 == 'g' && char2 == ' ') || (char1 == 'u' && char2 == 's')) { // "us" == "usemtl"
foundGroupStart = true;
foundF = false;
}
else if (char1 == 'v' && char2 == ' ') {
totalVertices++;
}
else if (char1 == 'v' && char2 == 't') {
totalUVs++;
}
else if (useSuppliedNormals && char1 == 'v' && char2 == 'n') {
totalNormals++;
}
}
if (groupCount == 0) {
originalGroupIndices.Add (firstFCount);
groupCount = 1;
}
if (totalVertices == 0) {
Debug.LogError ("No vertices found in file");
return null;
}
if (faceCount == 0) {
Debug.LogError ("No face data found in file");
return null;
}
originalGroupIndices.Add (-1);
int verticesCount = 0;
int uvsCount = 0;
int normalsCount = 0;
var objVertices = new Vector3[totalVertices];
var objUVs = new Vector2[totalUVs];
var objNormals = new Vector3[totalNormals];
var triData = new List<string>();
var quadWarning = false;
var polyWarning = false;
var objectNames = new string[groupCount];
var materialNames = new string[groupCount];
int index = 0;
var lineInfo = new string[0];
var groupIndices = new int[groupCount+1];
int numberOfGroupsUsed = 0;
faceCount = 0;
groupCount = 0;
int mtlCount = 0;
int objectNamesCount = 0;
try {
while (index < fileLines.Length) {
var line = fileLines[index++];
// Skip over comments and short lines
if (line.Length < 3 || line[0] == '#') continue;
// Remove excess whitespace
CleanLine (ref line);
// Skip over short lines (again, in the off chance the above line made this line too short)
if (line.Length < 3) continue;
// If line ends with "\" then combine with the next line, assuming there is one (should be, but just in case)
while (line[line.Length-1] == '\\' && index < fileLines.Length) {
line = line.Substring (0, line.Length-1) + " " + fileLines[index++].TrimEnd();
CleanLine (ref line);
}
char char1 = System.Char.ToLower(line[0]);
char char2 = System.Char.ToLower(line[1]);
// Get material name from usemtl line, plus object name if it doesn't have one from g or o lines
if (char1 == 'u' && char2 == 's') {
if (useMtl && line.StartsWith ("usemtl") && mtlCount++ == 0) {
lineInfo = line.Split (' ');
if (lineInfo.Length > 1) {
materialNames[groupCount] = lineInfo[1];
if (objectNamesCount++ == 0) {
if (useFileNameAsObjectName && fileName != "") {
objectNames[groupCount] = fileName;
}
else {
objectNames[groupCount] = lineInfo[1];
}
}
}
}
}
// Get object name
else if (((char1 == 'o' && char2 == ' ') || (char1 == 'g' && char2 == ' ')) && objectNamesCount++ == 0) {
if (useFileNameAsObjectName && fileName != "") {
objectNames[groupCount] = fileName;
}
else {
objectNames[groupCount] = line.Substring (2, line.Length-2);
}
}
// Read vertices
else if (char1 == 'v' && char2 == ' ') {
lineInfo = line.Split (' ');
if (lineInfo.Length != 4) {
throw new System.Exception ("Incorrect number of points while trying to read vertices:\n" + line + "\n");
}
else {
// Invert x value so it works properly in Unity (left-handed)
objVertices[verticesCount++] = new Vector3(-float.Parse (lineInfo[1], CultureInfo.InvariantCulture), float.Parse (lineInfo[2], CultureInfo.InvariantCulture), float.Parse (lineInfo[3], CultureInfo.InvariantCulture));
}
}
// Read UVs
else if (char1 == 'v' && char2 == 't') {
lineInfo = line.Split (' ');
if (lineInfo.Length > 4 || lineInfo.Length < 3) {
throw new System.Exception ("Incorrect number of points while trying to read UV data:\n" + line + "\n");
}
else {
objUVs[uvsCount++] = new Vector2(float.Parse (lineInfo[1], CultureInfo.InvariantCulture), float.Parse (lineInfo[2], CultureInfo.InvariantCulture));
}
}
// Read normals
else if (useSuppliedNormals && char1 == 'v' && char2 == 'n') {
lineInfo = line.Split (' ');
if (lineInfo.Length != 4) {
throw new System.Exception ("Incorrect number of points while trying to read normals:\n" + line + "\n");
}
else {
// Invert x value so it works properly in Unity
objNormals[normalsCount++] = new Vector3(-float.Parse (lineInfo[1], CultureInfo.InvariantCulture), float.Parse (lineInfo[2], CultureInfo.InvariantCulture), float.Parse (lineInfo[3], CultureInfo.InvariantCulture));
}
}
// Read triangle face info
else if (char1 == 'f' && char2 == ' ') {
lineInfo = line.Split (' ');
if (lineInfo.Length >= 4 && lineInfo.Length <= 5) {
// If data is relative offset, dissect it and replace it with calculated absolute data
if (lineInfo[1].Substring (0, 1) == "-") {
for (int i = 1; i < lineInfo.Length; i++) {
var lineInfoParts = lineInfo[i].Split ('/');
lineInfoParts[0] = (verticesCount - -int.Parse (lineInfoParts[0])+1).ToString();
if (lineInfoParts.Length > 1) {
if (lineInfoParts[1] != "") {
lineInfoParts[1] = (uvsCount - -int.Parse (lineInfoParts[1])+1).ToString();
}
if (lineInfoParts.Length == 3) {
lineInfoParts[2] = (normalsCount - -int.Parse (lineInfoParts[2])+1).ToString();
}
}
lineInfo[i] = System.String.Join ("/", lineInfoParts);
}
}
// Triangle
for (int i = 1; i < 4; i++) {
triData.Add (lineInfo[i]);
}
// Quad -- split by adding another triangle
if (lineInfo.Length == 5) {
quadWarning = true;
triData.Add (lineInfo[1]);
triData.Add (lineInfo[3]);
triData.Add (lineInfo[4]);
}
}
// Line describes polygon containing more than 4 or fewer than 3 points, which are not supported
else {
polyWarning = true;
}
// Store index for face group start locations
if (++faceCount == originalGroupIndices[groupCount+1]) {
groupIndices[++groupCount] = triData.Count;
mtlCount = 0;
objectNamesCount = 0;
}
}
}
}
catch (System.Exception err) {
GameObject.Find("Canvas").transform.FindChild("PanelPopupLoad").gameObject.SetActive(false);
Debug.LogError (err.Message);
return null;
}
if (combineMultipleGroups && !useSubmeshesWhenCombining) {
numberOfGroupsUsed = 1;
groupIndices[1] = triData.Count;
}
else {
groupIndices[groupCount+1] = triData.Count;
numberOfGroupsUsed = groupIndices.Length-1;
}
// Parse vert/uv/normal index data from triangle face lines
var triVerts = new int[triData.Count];
var triUVs = new int[triData.Count];
var triNorms = new int[triData.Count];
var lengthCount = 3;
for (int i = 0; i < triData.Count; i++) {
string triString = triData[i];
lineInfo = triString.Split ('/');
triVerts[i] = int.Parse (lineInfo[0])-1;
if (lineInfo.Length > 1) {
if (lineInfo[1] != "") {
triUVs[i] = int.Parse (lineInfo[1])-1;
}
if (lineInfo.Length == lengthCount && useSuppliedNormals) {
triNorms[i] = int.Parse (lineInfo[2])-1;
}
}
}
var objVertList = new List<Vector3>(objVertices);
if (totalUVs > 0) {
SplitOnUVs (triData, triVerts, triUVs, objVertList, objUVs, objVertices, ref verticesCount);
}
// Warnings
if (quadWarning && !suppressWarnings) {
Debug.LogWarning ("At least one object uses quads...automatic triangle conversion is being used, which may not produce best results");
}
if (polyWarning && !suppressWarnings) {
Debug.LogWarning ("Polygons which are not quads or triangles have been skipped");
}
if (totalUVs == 0 && !suppressWarnings) {
Debug.LogWarning ("At least one object does not seem to be UV mapped...any textures used will appear as a solid color");
}
if (totalNormals == 0 && !suppressWarnings) {
Debug.LogWarning ("No normal data found for at least one object...automatically computing normals instead");
}
// Errors
if (totalVertices == 0 && triData.Count == 0) {
Debug.LogError ("No objects seem to be present...possibly the .obj file is damaged or could not be read");
return null;
}
else if (totalVertices == 0) {
Debug.LogError ("The .obj file does not contain any vertices");
return null;
}
else if (triData.Count == 0) {
Debug.LogError ("The .obj file does not contain any polygons");
return null;
}
// Set up GameObject array...only 1 object if combining groups
var gameObjects = new GameObject[combineMultipleGroups? 1 : numberOfGroupsUsed];
for (int i = 0; i < gameObjects.Length; i++) {
gameObjects[i] = new GameObject(objectNames[i], typeof(MeshFilter), typeof(MeshRenderer));
}
// --------------------------------
// Create meshes from the .obj data
GameObject go = null;
Mesh mesh = null;
Vector3[] newVertices = null;
Vector2[] newUVs = null;
Vector3[] newNormals = null;
int[] newTriangles = null;
var useSubmesh = (combineMultipleGroups && useSubmeshesWhenCombining && numberOfGroupsUsed > 1)? true : false;
Material[] newMaterials = null;
if (useSubmesh) {
newMaterials = new Material[numberOfGroupsUsed];
}
int lastUsedMaterialIndex = 0;
bool hasUsedMaterial = false;
for (int i = 0; i < numberOfGroupsUsed; i++) {
if (!useSubmesh || (useSubmesh && i == 0)) {
go = gameObjects[i];
mesh = new Mesh();
// Find the number of unique vertices used by this group, also used to map original vertices into 0..thisVertices.Count range
var vertHash = new Dictionary<int, int>();
var thisVertices = new List<Vector3>();
int counter = 0;
int vertHashValue = 0;
int triStart = groupIndices[i];
int triEnd = groupIndices[i + 1];
if (useSubmesh) {
triStart = groupIndices[0];
triEnd = groupIndices[numberOfGroupsUsed];
}
for (int j = triStart; j < triEnd; j++) {
if (!vertHash.TryGetValue (triVerts[j], out vertHashValue)) {
vertHash[triVerts[j]] = counter++;
thisVertices.Add (objVertList[triVerts[j]]);
}
}
if (thisVertices.Count > maxPoints) {
Debug.LogError ("The number of vertices in the object " + objectNames[i] + " exceeds the maximum allowable limit of " + maxPoints);
return null;
}
newVertices = new Vector3[thisVertices.Count];
newUVs = new Vector2[thisVertices.Count];
newNormals = new Vector3[thisVertices.Count];
newTriangles = new int[triEnd - triStart];
// Copy .obj mesh data for vertices and triangles to arrays of the correct size
if (scaleFactor == Vector3.one && objRotation == Vector3.zero && objPosition == Vector3.zero) {
for (int j = 0; j < thisVertices.Count; j++) {
newVertices[j] = thisVertices[j];
}
}
else {
transform.eulerAngles = objRotation;
transform.position = objPosition;
transform.localScale = scaleFactor;
var thisMatrix = transform.localToWorldMatrix;
for (int j = 0; j < thisVertices.Count; j++) {
newVertices[j] = thisMatrix.MultiplyPoint3x4 (thisVertices[j]);
}
transform.position = Vector3.zero;
transform.rotation = Quaternion.identity;
transform.localScale = Vector3.one;
}
// Arrange UVs and normals so they match up with vertices
if (uvsCount > 0 && normalsCount > 0 && useSuppliedNormals) {
for (int j = triStart; j < triEnd; j++) {
newUVs[vertHash[triVerts[j]]] = objUVs[triUVs[j]];
// Needs to be normalized or lighting is whacked (especially with specular), and some apps don't output normalized normals
newNormals[vertHash[triVerts[j]]] = objNormals[triNorms[j]].normalized;
}
}
else {
// Arrange UVs so they match up with vertices
if (uvsCount > 0) {
for (int j = triStart; j < triEnd; j++) {
newUVs[vertHash[triVerts[j]]] = objUVs[triUVs[j]];
}
}
// Arrange normals so they match up with vertices
if (normalsCount > 0 && useSuppliedNormals) {
for (int j = triStart; j < triEnd; j++) {
newNormals[vertHash[triVerts[j]]] = objNormals[triNorms[j]];
}
}
}
// Since we flipped the normals, swap triangle points 2 & 3
counter = 0;
for (int j = triStart; j < triEnd; j += 3) {
newTriangles[counter ] = vertHash[triVerts[j ]];
newTriangles[counter+1] = vertHash[triVerts[j+2]];
newTriangles[counter+2] = vertHash[triVerts[j+1]];
counter += 3;
}
mesh.vertices = newVertices;
mesh.uv = newUVs;
if (autoCenterOnOrigin) {
var offset = mesh.bounds.center;
int end = newVertices.Length;
for (int j = 0; j < end; j++) {
newVertices[j] -= offset;
}
mesh.vertices = newVertices;
}
if (useSuppliedNormals) {
mesh.normals = newNormals;
}
if (useSubmesh) {
mesh.subMeshCount = numberOfGroupsUsed;
}
}
if (useSubmesh) {
int thisLength = groupIndices[i + 1] - groupIndices[i];
var thisTriangles = new int[thisLength];
System.Array.Copy (newTriangles, groupIndices[i], thisTriangles, 0, thisLength);
mesh.SetTriangles (thisTriangles, i);
if (materialNames[i] != null) {
if (useMtl && materials.ContainsKey (materialNames[i])) {
newMaterials[i] = materials[materialNames[i]];
if (materials[materialNames[i]]) {
}
hasUsedMaterial = true;
lastUsedMaterialIndex = i;
}
}
else {
if (hasUsedMaterial) {
newMaterials[i] = materials[materialNames[lastUsedMaterialIndex]];
}
else {
newMaterials[i] = standardMaterial;
}
}
}
else {
mesh.triangles = newTriangles;
}
// Stuff that's done for each object, or at the end if using submeshes
if (!useSubmesh || (useSubmesh && i == numberOfGroupsUsed-1) ) {
if (normalsCount == 0 || !useSuppliedNormals) {
mesh.RecalculateNormals();
if (computeTangents) {
newNormals = mesh.normals;
}
}
if (computeTangents) {
var newTangents = new Vector4[newVertices.Length];
CalculateTangents (newVertices, newNormals, newUVs, newTriangles, newTangents);
mesh.tangents = newTangents;
}
mesh.RecalculateBounds();
go.GetComponent<MeshFilter>().mesh = mesh;
if (!useSubmesh) {
if (materialNames[i] != null) {
if (useMtl && materials.ContainsKey (materialNames[i])) {
go.GetComponent<Renderer>().material = materials[materialNames[i]];
hasUsedMaterial = true;
lastUsedMaterialIndex = i;
}
}
else {
if (hasUsedMaterial) {
go.GetComponent<Renderer>().material = materials[materialNames[lastUsedMaterialIndex]];
}
else {
go.GetComponent<Renderer>().material = standardMaterial;
}
}
}
else {
go.GetComponent<Renderer>().materials = newMaterials;
}
}
}
if (objData != null) {
objData.SetDone();
objData.gameObjects = gameObjects;
return null;
}
return gameObjects;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Update Player Slot / Do not remove item
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HandleUpdateSlotn(byte slot, ObjData.slotItem item, int packet)
{
try
{
client.Send(Packet.Player_HandleUpdateSlot(slot, (ushort)item.Amount, packet));
Send(Packet.Player_HandleEffect(Character.Information.UniqueID, item.ID));
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Update Item Count
/////////////////////////////////////////////////////////////////////////////////
void ItemUpdateAmount(ObjData.slotItem sItem, int owner)
{
#region Item Update Amount
if (sItem.Amount <= 0)
DB.query("delete from char_items where slot='" + sItem.Slot + "' AND owner='" + owner + "'");
else
DB.query("UPDATE char_items SET quantity='" + Math.Abs(sItem.Amount) + "' WHERE slot='" + sItem.Slot + "' AND owner='" + owner + "'");
client.Send(Packet.ItemUpdate_Quantity(sItem.Slot, sItem.Amount));
#endregion
}
//-----------------------------------------------------
public void setLibToShow(ObjData od)
{
//Determination de la lib a afficher
//int type=0,brand=0;
//ObjData _objectData = interacteur.getSelected().GetComponent<ObjData>();
bkupSelTyp = od.selTyp;
bkupSelFab = od.selFab;
bkupSelObj = od.selObj;
//Sauvergarde Type et marque de l'objet
/*if(oslo.getCategory().GetParentCategory() == null) // que un type
{
brand = -1;
int typeID = oslo.getCategory().GetId();
foreach(OSLibCategory cat in _library.GetCategoryList())
{
if(cat.GetId() == typeID)
break;
else
type ++;
}
//bkupSelM = 0;
bkupSelTyp = type;
bkupSelFab = -1;
}
else // type plus marque
{
int brandID = oslo.getCategory().GetId();
int typeID = oslo.getCategory().GetParentCategory().GetId();
bkupSelTyp = _secondCategory[oslo.getCategory().GetBrandId()];
bkupSelFab = _firstCategory[oslo.getCategory().GetParentCategory().GetBrandId()];
//bkupSelM = 0;
// bkupSelTyp = type;
// bkupSelFab = brand;
}*/
setMenuState();
showMenu = true;
//ulActive = true;
}
/// <summary>
/// Does the conversion
/// </summary>
/// <param name="data">The obj data to convert</param>
/// <returns>The constructed Scene</returns>
public static Scene Convert(ObjData data)
{
Scene s = new Scene();
Dictionary<string, Material> materials = new Dictionary<string, Material>();
Dictionary<string, Bitmap> bitmaps = new Dictionary<string, Bitmap>();
foreach (var mat in data.materials)
{
LoadBitmap(mat.AlphaTextureMap, bitmaps);
LoadBitmap(mat.AmbientTextureMap, bitmaps);
LoadBitmap(mat.BumpMap, bitmaps);
LoadBitmap(mat.DiffuseTextureMap, bitmaps);
LoadBitmap(mat.DisplacementMap, bitmaps);
LoadBitmap(mat.SpecularCoefficientMap, bitmaps);
LoadBitmap(mat.SpecularTextureMap, bitmaps);
Material m = new Material();
m.AlphaMap = bitmaps[mat.AlphaTextureMap];
m.AmbientMap = bitmaps[mat.AmbientTextureMap];
m.BumpMap = bitmaps[mat.AmbientTextureMap];
m.DiffuseMap = bitmaps[mat.AmbientTextureMap];
m.DisplacementMap = bitmaps[mat.AmbientTextureMap];
m.SpecularCoefficientMap = bitmaps[mat.AmbientTextureMap];
m.SpecularMap = bitmaps[mat.AmbientTextureMap];
m.Texture = bitmaps[mat.DiffuseTextureMap];
m.AmbientColor = mat.Ambient;
m.DiffuseColor = mat.Diffuse;
m.SpecularCoefficient = mat.SpecularCoefficient;
m.SpecularColor = mat.Specular;
m.Transparency = mat.Transparency;
m.Name = mat.Name;
materials[m.Name] = m;
}
foreach (var f in data.faces)
{
Vertex v1 = new Vertex();
Vertex v2 = new Vertex();
Vertex v3 = new Vertex();
v1.Position = data.vertices[f.Vert1.vertex - 1];
v2.Position = data.vertices[f.Vert2.vertex - 1];
v3.Position = data.vertices[f.Vert3.vertex - 1];
v1.Normal = data.normals[f.Vert1.normal - 1];
v2.Normal = data.normals[f.Vert2.normal - 1];
v3.Normal = data.normals[f.Vert3.normal - 1];
// Only set the texture coordinates if they were set
if (f.Vert1.texCoord > 0 && f.Vert2.texCoord > 0 && f.Vert3.texCoord > 0)
{
v1.TexCoord = data.texCoords[f.Vert1.texCoord - 1];
v2.TexCoord = data.texCoords[f.Vert2.texCoord - 1];
v3.TexCoord = data.texCoords[f.Vert3.texCoord - 1];
}
Triangle t = new Triangle(v1, v2, v3);
if (!string.IsNullOrEmpty(f.Material))
{
t.Material = materials[f.Material];
}
s.Triangles.Add(t);
}
return s;
}
public static bool lineSegmentIntersection(ObjData.vektor Line1_A, ObjData.vektor Line1_B, ObjData.vektor Line2_A, ObjData.vektor Line2_B, ref List<ObjData.vektor> CollisionPoints)
{
// Fail if either line segment is zero-length.
if (Line1_A.x == Line1_B.x && Line1_A.y == Line1_B.y || Line2_A.x == Line2_B.x && Line2_A.y == Line2_B.y) return false;
// Translate the system so that point A is on the origin.
Line1_B.x -= Line1_A.x; Line1_B.y -= Line1_A.y;
Line2_A.x -= Line1_A.x; Line2_A.y -= Line1_A.y;
Line2_B.x -= Line1_A.x; Line2_B.y -= Line1_A.y;
// Discover the length of segment A-B.
float distAB = (float)Math.Sqrt(Line1_B.x * Line1_B.x + Line1_B.y * Line1_B.y);
// Rotate the system so that point B is on the positive X axis.
float theCos = Line1_B.x / distAB;
float theSin = Line1_B.y / distAB;
float newX = Line2_A.x * theCos + Line2_A.y * theSin;
Line2_A.y = Line2_A.y * theCos - Line2_A.x * theSin; Line2_A.x = newX;
newX = Line2_B.x * theCos + Line2_B.y * theSin;
Line2_B.y = Line2_B.y * theCos - Line2_B.x * theSin; Line2_B.x = newX;
// Fail if segment C-D doesn't cross line A-B.
if (Line2_A.y < 0.0f && Line2_B.y < 0.0f || Line2_A.y >= 0.0f && Line2_B.y >= 0.0f) return false;
// Discover the position of the intersection point along line A-B.
float ABpos = Line2_B.x + (Line2_A.x - Line2_B.x) * Line2_B.y / (Line2_B.y - Line2_A.y);
// Fail if segment C-D crosses line A-B outside of segment A-B.
if (ABpos < 0.0f || ABpos > distAB) return false;
// Apply the discovered position to line A-B in the original coordinate system.
ObjData.vektor cp = new ObjData.vektor();
cp.x = Line1_A.x + ABpos * theCos;
cp.y = Line1_A.y + ABpos * theSin;
CollisionPoints.Add(cp);
return true;
}
/////////////////////////////////////////////////////////////////////////////////
// Equiped items
/////////////////////////////////////////////////////////////////////////////////
public void ItemEquiped(ObjData.slotItem item, byte slot)
{
#region Equiped items
try
{
if (Character.Information.Level >= ObjData.Manager.ItemBase[item.ID].Level)
{
if (slot <= 5)
{
Character.Stat.MagDef += ObjData.Manager.ItemBase[item.ID].Defans.MinMagDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.MagDefINC);
Character.Stat.PhyDef += ObjData.Manager.ItemBase[item.ID].Defans.MinPhyDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.PhyDefINC);
Character.Stat.Parry += ObjData.Manager.ItemBase[item.ID].Defans.Parry;
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, true);
client.Send(Packet.PlayerStat(Character));
}
if (slot == 6)
{
Character.Stat.MinPhyAttack += ObjData.Manager.ItemBase[item.ID].Attack.Min_LPhyAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.PhyAttackInc);
Character.Stat.MaxPhyAttack += ObjData.Manager.ItemBase[item.ID].Attack.Min_HPhyAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.PhyAttackInc);
Character.Stat.MinMagAttack += ObjData.Manager.ItemBase[item.ID].Attack.Min_LMagAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.MagAttackINC);
Character.Stat.MaxMagAttack += ObjData.Manager.ItemBase[item.ID].Attack.Min_HMagAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.MagAttackINC);
Character.Stat.Hit += ObjData.Manager.ItemBase[item.ID].Attack.MinAttackRating;
Character.Information.Item.wID = item.ID;
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, true);
client.Send(Packet.PlayerStat(Character));
}
if (slot == 7)
{
if (ObjData.Manager.ItemBase[item.ID].Itemtype == ObjData.item_database.ItemType.CH_SHIELD || ObjData.Manager.ItemBase[item.ID].Itemtype == ObjData.item_database.ItemType.EU_SHIELD)
{
Character.Stat.MagDef += ObjData.Manager.ItemBase[item.ID].Defans.MinMagDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.MagDefINC);
Character.Stat.PhyDef += ObjData.Manager.ItemBase[item.ID].Defans.MinPhyDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.PhyDefINC);
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, true);
}
Character.Information.Item.sAmount = item.Amount;
Character.Information.Item.sID = item.ID;
client.Send(Packet.PlayerStat(Character));
}
if (slot == 8)
{
//Teleport user back to binded location
Send(Packet.StatePack(Character.Information.UniqueID, 0x0B, 0x01, false));
Character.Information.Scroll = true;
StartScrollTimer(0);//Set to job time info
DB.query("UPDATE character_jobs SET job_state='1' WHERE character_name='" + Character.Information.Name + "'");
Character.Job.state = 1;
SavePlayerReturn();
}
if (slot >= 9 && slot <= 12)
{
Character.Stat.MagDef += (short)(ObjData.Manager.ItemBase[item.ID].Defans.MagAbsorb + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.AbsorbINC) * 10);
Character.Stat.PhyDef += (short)(ObjData.Manager.ItemBase[item.ID].Defans.PhyAbsorb + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.AbsorbINC) * 10);
client.Send(Packet.PlayerStat(Character));
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, true);
}
Send(Packet.MoveItemEnquipEffect(Character.Information.UniqueID, item.Slot, item.ID, item.PlusValue));
SavePlayerInfo();
}
else
return;
}
catch (Exception ex)
{
Log.Exception("Item equip error: ", ex);
}
#endregion
}
public ObjData ConvertFileAsync(string objFilePath, bool useMtl, Material standardMaterial, Material transparentMaterial)
{
var objData = new ObjData();
ConvertFile (objFilePath, useMtl, standardMaterial, transparentMaterial, objData);
return objData;
}
// collision detection 2D - /With Linear Algebra/
public static bool isCollided_onMovement(ObjData.vektor fromPos, ObjData.vektor toPos, ref ObjData.vektor CollisionPoint)
{
try
{
fromPos.x = packetx(fromPos.x, fromPos.xSec) / 20.0f;
fromPos.y = packety(fromPos.y, fromPos.ySec) / 20.0f;
toPos.x = packetx(toPos.x, toPos.xSec) / 20.0f;
toPos.y = packety(toPos.y, toPos.ySec) / 20.0f;
// iterated line
ObjData.vektor Line_A = new ObjData.vektor();
ObjData.vektor Line_B = new ObjData.vektor();
List<ObjData.vektor> CollisionPoints = new List<ObjData.vektor>();
// get current region to filter out the objects
short region = makeRegion(fromPos.xSec, fromPos.ySec);
int say = 0;
foreach (var item in ObjData.Manager.MapObject)
{
if (item.Key == region)
{
say++;
}
}
if (say == 0)
{
Console.WriteLine("Pozisyon bulunamadı");
}
// get all entitys in this region and try to cut them with our movement line
foreach (ObjData.SectorObject.n7nEntity obj in ObjData.Manager.MapObject[region].entitys)
{
foreach (ObjData.SectorObject.n7nEntity.sLine line in obj.OutLines)
{
// if not passable
if (line.flag != 0)
{
Line_A.x = obj.Points[line.PointA].x + obj.Position.x;
Line_A.y = obj.Points[line.PointA].y + obj.Position.y;
Line_B.x = obj.Points[line.PointB].x + obj.Position.x;
Line_B.y = obj.Points[line.PointB].y + obj.Position.y;
if (lineSegmentIntersection(fromPos, toPos, Line_A, Line_B, ref CollisionPoints))
{
Console.WriteLine("x:{0} y:{1}", gamex(CollisionPoints[0].x, fromPos.xSec), gamey(CollisionPoints[0].y, fromPos.ySec));
}
}
}
}
if (CollisionPoints.Count == 0) return false;
// set the nearest collision point for return point
double minDistance = gamedistance(fromPos.x, fromPos.y, CollisionPoints[0].x, CollisionPoints[0].y);
foreach (ObjData.vektor cp in CollisionPoints)
{
//double currentDistance = gamedistance(fromPos.x, fromPos.y, cp.x, cp.y);
double currentDistance = gamedistance(fromPos, cp);
if (currentDistance <= minDistance)
{
CollisionPoint.x = cp.x;
CollisionPoint.y = cp.y;
}
}
// translate the collision point on the movement line to get real coordinates (not the exact point of collision)
double sin_alpha = Math.Abs(CollisionPoints[0].y - fromPos.y) / minDistance;
double cos_alpha = Math.Abs(CollisionPoints[0].x - fromPos.x) / minDistance;
CollisionPoints[0].y = (float)(sin_alpha * (minDistance - 3));
CollisionPoints[0].x = (float)(cos_alpha * (minDistance - 3));
}
catch (Exception ex)
{
CLFramework.Log.Exception("Collision detection failed: ", ex);
}
return true;
}
private IEnumerator GetWWWFiles(string objFilePath, bool useMtl, Material standardMaterial, Material transparentMaterial, ObjData objData)
{
var www = new WWW(objFilePath);
while (!www.isDone) {
objData.SetProgress (www.progress * (useMtl? .5f : 1.0f));
if (objData.cancel) {
yield break;
}
yield return null;
}
if (www.error != null) {
Debug.LogError ("Error loading " + objFilePath + ": " + www.error);
objData.SetDone();
yield break;
}
string objFile = www.text;
string filePath = "";
Dictionary<string, Material> materials = null;
if (useMtl) {
string mtlFileName = GetMTLFileName (ref objFilePath, ref objFile, ref filePath);
if (mtlFileName != "") {
// Read in mtl file
www = new WWW(filePath + mtlFileName);
while (!www.isDone) {
if (objData.cancel) {
yield break;
}
yield return null;
}
if (www.error != null) {
if (!useMTLFallback) {
Debug.LogError ("Error loading " + (filePath + mtlFileName) + ": " + www.error);
objData.SetDone();
yield break;
}
else {
useMtl = false;
}
}
if (useMtl && www.text != "") {
// Get textures and parse MTL file
var linesRef = new LinesRef();
var textures = new Dictionary<string, Texture2D>();
var loadError = new BoolRef(false);
yield return StartCoroutine (GetTexturesAsync (www.text, linesRef, filePath, textures, objData, loadError));
if (loadError.b == true) {
yield break;
}
materials = ParseMTL (linesRef.lines, standardMaterial, transparentMaterial, filePath, textures);
if (materials == null) {
useMtl = false;
}
}
}
else {
useMtl = false;
}
}
CreateObjects (ref objFile, useMtl, materials, standardMaterial, objData, Path.GetFileNameWithoutExtension (objFilePath));
}
private IEnumerator GetTexturesAsync(string mtlFile, LinesRef linesRef, string filePath, Dictionary<string, Texture2D> textures, ObjData objData)
{
Texture2D diffuseTexture = null;
string[] lines = SplitLines (ref mtlFile);
int numberOfTextures = 0;
// See how many textures there are (to use for progress)
for (int i = 0; i < lines.Length; i++) {
var line = lines[i];
CleanLine (ref line);
lines[i] = line;
if (line.Length < 7 || line[0] == '#') {
continue;
}
if (line.StartsWith ("map_Kd") && filePath != "") {
numberOfTextures++;
}
}
float progress = .5f;
for (int i = 0; i < lines.Length; i++) {
if (lines[i].Length < 7 || lines[i][0] == '#') {
continue;
}
// Get diffuse texture
if (lines[i].StartsWith ("map_Kd") && filePath != "") {
var lineInfo = lines[i].Split (' ');
if (lineInfo.Length > 1) {
var textureFilePath = filePath + lineInfo[1];
var www = new WWW(textureFilePath);
while (!www.isDone) {
objData.SetProgress (progress + (www.progress / numberOfTextures) * .5f);
yield return null;
}
if (www.error != null) {
Debug.Log (www.error);
objData.SetDone();
yield break;
}
progress += (1.0f / numberOfTextures) * .5f;
diffuseTexture = new Texture2D (4, 4);
www.LoadImageIntoTexture (diffuseTexture);
textures[lineInfo[1]] = diffuseTexture;
}
continue;
}
}
linesRef.lines = lines;
}
void Update(ObjData obj)
{
if (_table == null)
this.Initialize();
for (int i = 0; i < _table.Controls.Count; i++)
{
if (!(_table.Controls[i] is TextBox))
continue;
TextBox textBox = (TextBox)_table.Controls[i];
Binding b = textBox.DataBindings[0];
b.ReadValue();
//label.Text = property.Name;
//label.Text = LanguagePack.GetNm(obj.GetType(), row);
//if(label.Text=="")
// label.Text = LanguagePack.GetNm(obj.GetType(), row);
//textBox.Location = new System.Drawing.Point(0, 0);
//textBox.Name = "textBox_" + property.Name;
//textBox.Size = new System.Drawing.Size(50, 30);
//Binding b = new Binding("Text", obj, property.Name);
//textBox.DataBindings.Add(b);
//_table.Controls.Add(label, 0, row);
//_table.Controls.Add(textBox, 1, row);
}
// PropertyInfo[] properties = obj.GetType().GetProperties();
//List<PropertyInfo> showList= new List<PropertyInfo>();
//foreach (PropertyInfo property in properties)
//{
// System.Attribute[] attrs =
// System.Attribute.GetCustomAttributes(property);
// bool isShowable = false;
// foreach (Attribute attr in attrs)
// isShowable |= (attr is MyShowProperty) ?
// true : false;
// if (!isShowable)
// continue;
// if
// (showList.Exists(
// delegate(PropertyInfo matcher)
// {
// return matcher.Name == property.Name ? true : false;
// })
// )
// continue;
// showList.Add(property);
//}
}
private IEnumerator GetWWWFiles(string objFilePath, bool useMtl, Material standardMaterial, Material transparentMaterial, ObjData objData)
{
var www = new WWW(objFilePath);
while (!www.isDone) {
objData.SetProgress (www.progress * (useMtl? .5f : 1.0f));
yield return null;
}
if (www.error != null) {
Debug.Log (www.error);
objData.SetDone();
yield break;
}
string objFile = www.text;
string filePath = "";
Dictionary<string, Material> materials = null;
if (useMtl) {
string mtlFileName = GetMTLFileName (ref objFilePath, ref objFile, ref filePath);
if (mtlFileName != "") {
// Read in mtl file
www = new WWW(filePath + mtlFileName);
yield return www;
if (www.error != null) {
Debug.Log (www.error);
objData.SetDone();
yield break;
}
if (www.text != "") {
// Get textures and parse MTL file
var linesRef = new LinesRef();
var textures = new Dictionary<string, Texture2D>();
yield return StartCoroutine (GetTexturesAsync (www.text, linesRef, filePath, textures, objData));
materials = ParseMTL (linesRef.lines, standardMaterial, transparentMaterial, filePath, textures);
if (materials == null) {
useMtl = false;
}
}
}
else {
useMtl = false;
}
}
CreateObjects (ref objFile, useMtl, materials, standardMaterial, objData);
}
/////////////////////////////////////////////////////////////////////////////////
// Unequip Items
/////////////////////////////////////////////////////////////////////////////////
public void ItemUnEquiped(ObjData.slotItem item)
{
#region Unequip items
LoadBluesid(item.dbID);
try
{
if (item.Slot <= 5)
{
Character.Stat.MagDef -= ObjData.Manager.ItemBase[item.ID].Defans.MinMagDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.MagDefINC);
Character.Stat.PhyDef -= ObjData.Manager.ItemBase[item.ID].Defans.MinPhyDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.PhyDefINC);
Character.Stat.Parry -= ObjData.Manager.ItemBase[item.ID].Defans.Parry;
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, false);
client.Send(Packet.PlayerStat(Character));
}
if (item.Slot == 6)
{
Character.Stat.MinPhyAttack -= ObjData.Manager.ItemBase[item.ID].Attack.Min_LPhyAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.PhyAttackInc);
Character.Stat.MaxPhyAttack -= ObjData.Manager.ItemBase[item.ID].Attack.Min_HPhyAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.PhyAttackInc);
Character.Stat.MinMagAttack -= ObjData.Manager.ItemBase[item.ID].Attack.Min_LMagAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.MagAttackINC);
Character.Stat.MaxMagAttack -= ObjData.Manager.ItemBase[item.ID].Attack.Min_HMagAttack + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Attack.MagAttackINC);
Character.Stat.Hit -= ObjData.Manager.ItemBase[item.ID].Attack.MinAttackRating;
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, false);
client.Send(Packet.PlayerStat(Character));
Character.Information.Item.wID = 0;
}
if (item.Slot == 7)
{
if (ObjData.Manager.ItemBase[item.ID].Itemtype == ObjData.item_database.ItemType.CH_SHIELD || ObjData.Manager.ItemBase[item.ID].Itemtype == ObjData.item_database.ItemType.EU_SHIELD)
{
Character.Stat.MagDef -= ObjData.Manager.ItemBase[item.ID].Defans.MinMagDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.MagDefINC);
Character.Stat.PhyDef -= ObjData.Manager.ItemBase[item.ID].Defans.MinPhyDef + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.PhyDefINC);
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, false);
}
client.Send(Packet.PlayerStat(Character));
Character.Information.Item.sAmount = 0;
Character.Information.Item.sID = 0;
}
if (item.Slot == 8)
{
if (Character.Job.Jobname != "0" && Character.Job.state == 1)
{
//Teleport user back to binded location
Send(Packet.StatePack(Character.Information.UniqueID, 0x0B, 0x01, false));
Character.Information.Scroll = true;
StartScrollTimer(0);
DB.query("UPDATE character_jobs SET job_state='0' WHERE character_name='" + Character.Information.Name + "'");
Character.Job.state = 0;
SavePlayerReturn();
}
}
if (item.Slot >= 9 && item.Slot <= 12)
{
Character.Stat.MagDef -= (short)(ObjData.Manager.ItemBase[item.ID].Defans.MagAbsorb + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.AbsorbINC) * 10);
Character.Stat.PhyDef -= (short)(ObjData.Manager.ItemBase[item.ID].Defans.PhyAbsorb + (item.PlusValue * (double)ObjData.Manager.ItemBase[item.ID].Defans.AbsorbINC) * 10);
client.Send(Packet.PlayerStat(Character));
if (ObjData.Manager.ItemBlue[item.dbID].totalblue != 0) AddRemoveBlues(this, item, false);
}
Send(Packet.MoveItemUnequipEffect(Character.Information.UniqueID, item.Slot, item.ID));
SavePlayerInfo();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
#endregion
}
public static bool GetSurroundRange(ObjData.vektor obj, ObjData.vektor origo, int range)
{
if (obj.x >= (origo.x - range) && obj.x <= ((origo.x - range) + range * 2) && obj.y >= (origo.y - range) && obj.y <= ((origo.y - range) + range * 2))
{
return true;
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////
// Slot update packet
/////////////////////////////////////////////////////////////////////////////////
void GetUpdateSlot(ObjData.slotItem item, byte toSlot, int toItemID, short quantity)
{
#region Send item move packet
client.Send(Packet.MoveItem(0, item.Slot, toSlot, quantity, 0, "MOVE_INSIDE_INVENTORY"));
#endregion
}
GameObject[] ConvertFile(string objFilePath, bool useMtl, Material standardMaterial, Material transparentMaterial, ObjData objData)
{
objFilePath = objFilePath.Replace ('\\', '/');
string objFile = "";
if (objData == null) {
#if !UNITY_WEBPLAYER && !UNITY_WEBGL
if (!File.Exists (objFilePath)) {
Debug.LogError ("File not found: " + objFilePath);
return null;
}
objFile = File.ReadAllText (objFilePath);
if (objFile == null) {
Debug.LogError ("File not usable: " + objFilePath);
return null;
}
#else
Debug.LogWarning ("ConvertFile is not supported in the web player. Use ConvertFileAsync, or switch to a different platform.");
return null;
#endif
}
else {
if (objFilePath.StartsWith("http://") || objFilePath.StartsWith("https://") || objFilePath.StartsWith("file://") || objFilePath.StartsWith("ftp://")) {
StartCoroutine (GetWWWFiles (objFilePath, useMtl, standardMaterial, transparentMaterial, objData));
}
else {
Debug.LogError ("File path must start with http://, https://, ftp://, or file://");
}
return null;
}
string mtlFile = "";
string filePath = "";
if (useMtl) {
#if !UNITY_WEBPLAYER && !UNITY_WEBGL
string mtlFileName = GetMTLFileName (ref objFilePath, ref objFile, ref filePath);
// Read in mtl file
if (File.Exists (filePath + mtlFileName)) {
mtlFile = File.ReadAllText (filePath + mtlFileName);
}
else {
Debug.LogWarning ("MTL file not found: " + (filePath + mtlFileName));
}
#endif
}
return Convert (ref objFile, ref mtlFile, standardMaterial, transparentMaterial, filePath, useMtl, Path.GetFileNameWithoutExtension (objFilePath));
}
public void AddRemoveBlues(PlayerMgr ch, ObjData.slotItem item, bool add)
{
try
{
LoadBluesid(item.dbID);
string name;
if (ObjData.Manager.ItemBlue.ContainsKey(item.dbID))
{
for (int k = 0; k < ObjData.Manager.ItemBlue[item.dbID].totalblue; k++)
{
name = Convert.ToString(ObjData.Manager.ItemBlue[item.dbID].blue[k]);
switch (name)
{
case "MATTR_INT":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_INT"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_STR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_STR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_LUCK":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_LUCK"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_HP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_HP"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_MP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_MP"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_REGENHPMP": // hp/mp regen inc(%)
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_REGENHPMP"))
{
if (add)
{
ch.Character.Blues.mpregen += Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.hpregen += Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.mpregen -= Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.hpregen -= Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_RESIST_FROSTBITE":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_FROSTBITE"))
{
if (add)
ch.Character.Blues.Resist_Frostbite += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Frostbite -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_ESHOCK":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_ESHOCK"))
{
if (add)
ch.Character.Blues.Resist_Eshock += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Eshock -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_BURN":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_BURN"))
{
if (add)
ch.Character.Blues.Resist_Burn += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Burn -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_POISON":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_POISON"))
{
if (add)
ch.Character.Blues.Resist_Poison += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Poison -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_ZOMBIE":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_ZOMBIE"))
{
if (add)
ch.Character.Blues.Resist_Zombie += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Zombie -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_STR_3JOB":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_STR_3JOB"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_INT_3JOB":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_INT_3JOB"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_STR_AVATAR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_STR_AVATAR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_INT_AVATAR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_INT_AVATAR"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_STR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_HR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_HR"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Hit = (ch.Character.Stat.Hit / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Hit += ch.Character.Blues.UpdatedStats[item.dbID].Hit;
}
else
{
ch.Character.Stat.Hit -= ch.Character.Blues.UpdatedStats[item.dbID].Hit;
ch.Character.Blues.UpdatedStats[item.dbID].Hit = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_ER":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_ER"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Parry = (ch.Character.Stat.Parry / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Parry += ch.Character.Blues.UpdatedStats[item.dbID].Parry;
}
else
{
ch.Character.Stat.Parry -= ch.Character.Blues.UpdatedStats[item.dbID].Parry;
ch.Character.Blues.UpdatedStats[item.dbID].Parry = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_ER": //parry rate inc
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_ER"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Parry = (ch.Character.Stat.Parry / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Parry += ch.Character.Blues.UpdatedStats[item.dbID].Parry;
}
else
{
ch.Character.Stat.Parry -= ch.Character.Blues.UpdatedStats[item.dbID].Parry;
ch.Character.Blues.UpdatedStats[item.dbID].Parry = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_HR": //attack rate inc (%)
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_HR"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Hit = (ch.Character.Stat.Hit / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Hit += ch.Character.Blues.UpdatedStats[item.dbID].Hit;
}
else
{
ch.Character.Stat.Hit -= ch.Character.Blues.UpdatedStats[item.dbID].Hit;
ch.Character.Blues.UpdatedStats[item.dbID].Hit = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_HP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_HP"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_MP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MP"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_DRUA": // damage increase
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_DRUA"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack = (ch.Character.Stat.MinPhyAttack / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack = (ch.Character.Stat.MaxPhyAttack / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack = (ch.Character.Stat.MinMagAttack / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack = (ch.Character.Stat.MaxMagAttack / 100) * Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.MinPhyAttack += ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack;
ch.Character.Stat.MaxPhyAttack += ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack;
ch.Character.Stat.MinMagAttack += ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack;
ch.Character.Stat.MaxMagAttack += ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack;
}
else
{
ch.Character.Stat.MinPhyAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack;
ch.Character.Stat.MaxPhyAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack;
ch.Character.Stat.MinMagAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack;
ch.Character.Stat.MaxMagAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack;
ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack = 0;
ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack = 0;
ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack = 0;
ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_DARA": // damage absorption
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_DARA"))
{
if (add)
{
//ch.Character.Stat.phy_Absorb += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
//ch.Character.Stat.mag_Absorb += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
//ch.Character.Stat.phy_Absorb -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
//ch.Character.Stat.mag_Absorb -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MDIA": // ignore monster defense
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_HPRG": //hp recovery increase
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_HPRG"))
{
if (add)
{
ch.Character.Blues.hpregen += Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.hpregen -= Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MPRG": //mp recovery increase
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MPRG"))
{
if (add)
{
ch.Character.Blues.mpregen += Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.mpregen -= Convert.ToDouble(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_RESIST_STUN":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_STUN"))
{
if (add)
ch.Character.Blues.Resist_Stun += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Stun -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_CSMP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_CSMP"))
{
if (add)
ch.Character.Blues.Resist_CSMP += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_CSMP -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_DISEASE":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_DISEASE"))
{
if (add)
ch.Character.Blues.Resist_Disease += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Disease -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_SLEEP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_SLEEP"))
{
if (add)
ch.Character.Blues.Resist_Sleep += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Sleep -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_FEAR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_FEAR"))
{
if (add)
ch.Character.Blues.Resist_Fear += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Fear -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_NASRUN_UMDU": //damage increase(only @ uniques)
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_UMDU"))
{
if (add)
{
ch.Character.Blues.UniqueDMGInc += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.UniqueDMGInc += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_NASRUN_HPNA": //maximum hp increase
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_HPNA"))
{
if (add)
{
ch.Character.Stat.Hp += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondHp += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Stat.Hp -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondHp -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_NASRUN_MPNA": //maximum mp increase
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_MPNA"))
{
if (add)
{
ch.Character.Stat.Mp += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondMP += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Stat.Mp -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondMP -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_NASRUN_BLOCKRATE": //blocking rate increase
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_BLOCKRATE"))
{
if (add)
{
ch.Character.Stat.BlockRatio += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Stat.BlockRatio -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_STR_SET":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_STR_SET"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_INT_SET":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_INT_SET"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_ER_SET":
break;
case "MATTR_HP_SET":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_HP_SET"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_MP_SET":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_MP_SET"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_LUCK_SET":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_LUCK_SET"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_STR_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR_2"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_STR_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR_3"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_STR_4":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR_4"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT_2"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT_3"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT_4":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT_4"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_MDIA_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA_2"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MDIA_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA_3"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MDIA_4":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA_4"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_LUCK":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_LUCK_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK_2"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_LUCK_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK_4"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_LUCK_4":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK_4"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_ALL_SET":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_ALL_SET"))
{
if (add)
ch.Character.Blues.Resist_All += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_All -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_TRADE_STR":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_STR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_STR_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_STR_2"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_STR_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_STR_3"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_INT":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_INT"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_INT_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_INT_2"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_INT_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_INT_3"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_HP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_HP"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_HP_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_HP_2"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_HP_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_HP_3"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_MP":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_MP"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_MP_2":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_MP_2"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_MP_3":
if (ObjData.Manager.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_MP_3"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(ObjData.Manager.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Client.Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
}
}
}
else
{
Console.WriteLine("[BlueSystem] ItemBlue for ID {0} not found", item.dbID);
}
}
catch (Exception ex)
{
Console.WriteLine("Blue add/remove error {0}", ex);
Log.Exception(ex);
}
}
void HandleUpdateSlotChange(byte slot, ObjData.slotItem item, int packet)
{
DB.query("UPDATE char_items SET itemid='" + packet + "' WHERE owner='" + Character.Information.CharacterID + "' AND itemnumber='item" + item.Slot + "' AND id='" + item.dbID + "'");
//Need to be defined per item type (potion or private item)
Send(Packet.Player_HandleEffect(Character.Information.UniqueID, item.ID));
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Update Player Slot / Remove item
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HandleUpdateSlot(byte slot, ObjData.slotItem item, int packet)
{
try
{
item.Amount--;
client.Send(Packet.Player_HandleUpdateSlot(slot, (ushort)item.Amount, packet));
if (item.Amount > 0)
{
DB.query("UPDATE char_items SET quantity='" + Math.Abs(item.Amount) + "' WHERE owner='" + Character.Information.CharacterID + "' AND itemnumber='item" + item.Slot + "' AND id='" + item.dbID + "'");
}
else
{
DB.query("delete from char_items where id='" + item.dbID + "'");
}
//Need to be defined per item type (potion or private item)
Send(Packet.Player_HandleEffect(Character.Information.UniqueID, item.ID));
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Get degree information
/////////////////////////////////////////////////////////////////////////////////
public int GetItemDegree(ObjData.slotItem item)
{
try
{
if (1 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 8)
return 1;
else if (8 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 16)
return 2;
else if (16 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 24)
return 3;
else if (24 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 32)
return 4;
else if (32 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 42)
return 5;
else if (42 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 52)
return 6;
else if (52 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 64)
return 7;
else if (64 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 76)
return 8;
else if (76 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 90)
return 9;
else if (90 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 101)
return 10;
else if (101 <= ObjData.Manager.ItemBase[item.ID].Level && ObjData.Manager.ItemBase[item.ID].Level < 110)
return 11;
else
{
return 1;
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
return 1;
}
