RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure repository to include all source folders

Browse Source 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
tindevil
2025-11-29 20:17:20 +09:00
parent 5d3cd64a25
commit dd97ddec92
11602 changed files with 1446576 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1859
Server/ToolProject/ItemRebalanceConverter/ItemRebalanceConverter.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

181
Server/ToolProject/ItemRebalanceConverter/ItemRebalanceConverter.vcproj Normal file
View File

@@ -0,0 +1,181 @@
<?xml version="1.0" encoding="ks_c_5601-1987"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="ItemRebalanceConverter"
ProjectGUID="{F7B477FE-287F-4AA2-A26B-F7B7FF8AAF5D}"
Keyword="Win32Proj">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="../DBToolExecutable/$(ConfigurationName)"
IntermediateDirectory="../Intermediate/$(ProjectName)/$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../;./;../../RylServerProject/;../../RylServerProject/BaseLibrary;../../RylServerProject/RylGameLibrary;../../RylServerProject/RylServerLibrary"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="TRUE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ws2_32.lib"
OutputFile="$(OutDir)/ItemRebalanceConverter.exe"
LinkIncremental="2"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile="$(OutDir)/ItemRebalanceConverter.pdb"
SubSystem="1"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="../DBToolExecutable/$(ConfigurationName)"
IntermediateDirectory="../Intermediate/$(ProjectName)/$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="../;./;../../RylServerProject/;../../RylServerProject/BaseLibrary;../../RylServerProject/RylGameLibrary;../../RylServerProject/RylServerLibrary"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="0"
UsePrecompiledHeader="2"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="ws2_32.lib"
OutputFile="$(OutDir)/ItemRebalanceConverter.exe"
LinkIncremental="1"
GenerateDebugInformation="TRUE"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="<22>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
<File
RelativePath=".\ItemRebalanceConverter.cpp">
</File>
<File
RelativePath=".\OldItemConstants.cpp">
</File>
<File
RelativePath=".\OldItemDataParser.cpp">
</File>
<File
RelativePath=".\OldItemMgr.cpp">
</File>
<File
RelativePath=".\OldItemStructure.cpp">
</File>
<File
RelativePath=".\stdafx.cpp">
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="<22><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath=".\OldItemConstants.h">
</File>
<File
RelativePath=".\OldItemDataParser.h">
</File>
<File
RelativePath=".\OldItemMgr.h">
</File>
<File
RelativePath=".\OldItemStructure.h">
</File>
<File
RelativePath=".\stdafx.h">
</File>
</Filter>
<Filter
Name="<22><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
<File
RelativePath=".\ReadMe.txt">
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

497
Server/ToolProject/ItemRebalanceConverter/OldItemConstants.cpp Normal file
View File

@@ -0,0 +1,497 @@
#include "stdafx.h"
#include "OldItemConstants.h"
#include "OldItemStructure.h"
#include <algorithm>
using namespace OldItem;
OldItem::CItemType& OldItem::CItemType::GetInstance()
{
static CItemType itemType;
return itemType;
}
const CTypeName OldItem::Attribute::Attributes[OldItem::Attribute::MAX_ATTRIBUTE_NUM] =
{
CTypeName(Attribute::NONE, "NONE"),
CTypeName(Attribute::CRITICAL_TYPE, "CRITICAL_TYPE"),
CTypeName(Attribute::CRITICAL_PERCENTAGE, "CRITICAL_PERCENTAGE"),
CTypeName(Attribute::MIN_DAMAGE, "MIN_DAMAGE"),
CTypeName(Attribute::MAX_DAMAGE, "MAX_DAMAGE"),
CTypeName(Attribute::DRC, "DRC"),
CTypeName(Attribute::OFFENCE_REVISION, "OFFENCE_REVISION"),
CTypeName(Attribute::DEFENCE, "DEFENCE"),
CTypeName(Attribute::DEFENCE_REVISION, "DEFENCE_REVISION"),
CTypeName(Attribute::MAGIC_RESISTANCE, "MAGIC_RESISTANCE"),
CTypeName(Attribute::BLOCKING_PERCENTAGE, "BLOCKING_PERCENTAGE"),
CTypeName(Attribute::ATTACK_SPEED, "ATTACK_SPEED"),
CTypeName(Attribute::MOVE_SPEED, "MOVE_SPEED"),
CTypeName(Attribute::ATTACK_RANGE, "ATTACK_RANGE"),
CTypeName(Attribute::RANGE_ATTACK_DISTANCE, "RANGE_ATTACK_DISTANCE"),
CTypeName(Attribute::MAX_HP, "MAX_HP"),
CTypeName(Attribute::MAX_MP, "MAX_MP"),
CTypeName(Attribute::HP_REGEN_AMOUNT, "HP_REGEN_AMOUNT"),
CTypeName(Attribute::MP_REGEN_AMOUNT, "MP_REGEN_AMOUNT"),
CTypeName(Attribute::FIRE_ATTACK, "FIRE_ATTACK"),
CTypeName(Attribute::LIGHTNING_ATTACK, "LIGHTNING_ATTACK"),
CTypeName(Attribute::COLD_ATTACK, "COLD_ATTACK"),
CTypeName(Attribute::DRAIN_ATTACK, "DRAIN_ATTACK"),
CTypeName(Attribute::POISON_ATTACK, "POISON_ATTACK"),
CTypeName(Attribute::FIRE_RESISTANCE, "FIRE_RESISTANCE"),
CTypeName(Attribute::LIGHTNING_RESISTANCE, "LIGHTNING_RESISTANCE"),
CTypeName(Attribute::COLD_RESISTANCE, "COLD_RESISTANCE"),
CTypeName(Attribute::DRAIN_RESISTANCE, "DRAIN_RESISTANCE"),
CTypeName(Attribute::POISON_RESISTANCE, "POISON_RESISTANCE"),
CTypeName(Attribute::ADD_STR, "ADD_STR"),
CTypeName(Attribute::ADD_DEX, "ADD_DEX"),
CTypeName(Attribute::ADD_CON, "ADD_CON"),
CTypeName(Attribute::ADD_INT, "ADD_INT"),
CTypeName(Attribute::ADD_WIS, "ADD_WIS")
};
const CTypeName OldItem::Grade::Grades[Grade::MAX_ITEM_GRADE] =
{
CTypeName(Grade::ETC, "ETC"),
CTypeName(Grade::NORMAL, "NORMAL"),
CTypeName(Grade::ENHANCED, "ENHANCED"),
CTypeName(Grade::RARE, "RARE")
};
OldItem::CItemType::CItemType()
{
using namespace OldItem::ItemType;
int nCount = 0;
for(nCount = 0; nCount < MAX_ARRAY_TYPE; ++nCount)
{
m_ItemTypes[nCount].reserve(MAX_ITEM_TYPE);
}
m_ItemTypeNames[HELM] = CTypeName(HELM, "HELM");
m_ItemTypeNames[SHIRT] = CTypeName(SHIRT, "SHIRT");
m_ItemTypeNames[TUNIC] = CTypeName(TUNIC, "TUNIC");
m_ItemTypeNames[ARMOUR] = CTypeName(ARMOUR, "ARMOUR");
m_ItemTypeNames[GLOVE] = CTypeName(GLOVE, "GLOVE");
m_ItemTypeNames[BOOTS] = CTypeName(BOOTS, "BOOTS");
m_ItemTypeNames[SWORD] = CTypeName(SWORD, "ONEHANDED_SWORD");
m_ItemTypeNames[BLUNT] = CTypeName(BLUNT, "ONEHANDED_BLUNT");
m_ItemTypeNames[AXE] = CTypeName(AXE, "ONEHANDED_AXE");
m_ItemTypeNames[TWOHANDED_BLUNT] = CTypeName(TWOHANDED_BLUNT, "TWOHANDED_BLUNT");
m_ItemTypeNames[TWOHANDED_AXE] = CTypeName(TWOHANDED_AXE, "TWOHANDED_AXE");
m_ItemTypeNames[TWOHANDED_SWORD] = CTypeName(TWOHANDED_SWORD, "TWOHANDED_SWORD");
m_ItemTypeNames[BOW] = CTypeName(BOW, "BOW");
m_ItemTypeNames[CROSSBOW] = CTypeName(CROSSBOW, "CROSSBOW");
m_ItemTypeNames[STAFF] = CTypeName(STAFF, "STAFF");
m_ItemTypeNames[DAGGER] = CTypeName(DAGGER, "DAGGER");
m_ItemTypeNames[SHIELD] = CTypeName(SHIELD, "SHIELD");
m_ItemTypeNames[CLOAK] = CTypeName(CLOAK, "CLOAK");
m_ItemTypeNames[RING] = CTypeName(RING, "RING");
m_ItemTypeNames[NECKLACE] = CTypeName(NECKLACE, "NECKLACE");
m_ItemTypeNames[POTION] = CTypeName(POTION, "POTION");
m_ItemTypeNames[POISON] = CTypeName(POISON, "POISON");
m_ItemTypeNames[TRAP] = CTypeName(TRAP, "TRAP");
m_ItemTypeNames[SKILLBOOK] = CTypeName(SKILLBOOK, "SKILLBOOK");
m_ItemTypeNames[GEM] = CTypeName(GEM, "GEM");
m_ItemTypeNames[RUNE] = CTypeName(RUNE, "RUNE");
m_ItemTypeNames[MATERIAL] = CTypeName(MATERIAL, "ORE");
m_ItemTypeNames[AMMO] = CTypeName(AMMO, "AMMO");
m_ItemTypeNames[ETC] = CTypeName(ETC, "ETC");
m_ItemTypeNames[HEAD] = CTypeName(HEAD, "HEAD");
m_ItemTypeNames[BODY] = CTypeName(BODY, "BODY");
m_ItemTypeNames[PROTECT_A] = CTypeName(PROTECT_A, "PROTECT_A");
m_ItemTypeNames[PELVIS] = CTypeName(PELVIS, "PELVIS");
m_ItemTypeNames[COM_BLUNT] = CTypeName(COM_BLUNT, "COM_BLUNT");
m_ItemTypeNames[COM_SWORD] = CTypeName(COM_SWORD, "COM_SWORD");
m_ItemTypeNames[OPP_HAMMER] = CTypeName(OPP_HAMMER, "OPP_HAMMER");
m_ItemTypeNames[OPP_AXE] = CTypeName(OPP_AXE, "OPP_AXE");
m_ItemTypeNames[OPP_SLUSHER] = CTypeName(OPP_SLUSHER, "OPP_SLUSHER");
m_ItemTypeNames[OPP_TALON] = CTypeName(OPP_TALON, "OPP_TALON");
m_ItemTypeNames[OPP_SYTHE] = CTypeName(OPP_SYTHE, "OPP_SYTHE");
m_ItemTypeNames[SKILL_A_GUARD] = CTypeName(SKILL_A_GUARD, "SKILL_A_GUARD");
m_ItemTypeNames[SKILL_A_ATTACK] = CTypeName(SKILL_A_ATTACK, "SKILL_A_ATTACK");
m_ItemTypeNames[SKILL_A_GUN] = CTypeName(SKILL_A_GUN, "SKILL_A_GUN");
m_ItemTypeNames[SKILL_A_KNIFE] = CTypeName(SKILL_A_KNIFE, "SKILL_A_KNIFE");
m_ItemTypeNames[ACCESSORY] = CTypeName(ACCESSORY, "ACCESSORY");
m_ItemTypeNames[ARROW] = CTypeName(ARROW, "ARROW");
m_ItemTypeNames[BOLT] = CTypeName(BOLT, "BOLT");
m_ItemTypeNames[PORTAL] = CTypeName(PORTAL, "PORTAL");
m_ItemTypeNames[EVENT_DROP] = CTypeName(EVENT_DROP, "EVENT_DROP");
m_ItemTypeNames[EVENT_LOTTERY] = CTypeName(EVENT_LOTTERY, "EVENT_LOTTERY");
m_ItemTypeNames[EXPBOOK] = CTypeName(EXPBOOK, "EXPBOOK");
m_ItemTypeNames[CASHBOOK] = CTypeName(CASHBOOK, "CASHBOOK");
m_ItemTypeNames[FIRE_CRACKER] = CTypeName(FIRE_CRACKER, "FIRE_CRACKER");
m_ItemTypeNames[CAMP_KIT] = CTypeName(CAMP_KIT, "CAMP_KIT");
m_ItemTypeNames[SHORT_RANGE_ARMS_KIT] = CTypeName(SHORT_RANGE_ARMS_KIT, "SHORT_RANGE_ARMS_KIT");
m_ItemTypeNames[LONG_RANGE_ARMS_KIT] = CTypeName(LONG_RANGE_ARMS_KIT, "LONG_RANGE_ARMS_KIT");
m_ItemTypeNames[AIRSHIP_KIT] = CTypeName(AIRSHIP_KIT, "AIRSHIP_KIT");
// <20><><EFBFBD><EFBFBD>
m_ItemTypes[EQUIP_TYPE].push_back(ARROW); m_ItemTypes[EQUIP_TYPE].push_back(BOLT);
m_ItemTypes[EQUIP_TYPE].push_back(HELM); m_ItemTypes[EQUIP_TYPE].push_back(SHIRT);
m_ItemTypes[EQUIP_TYPE].push_back(TUNIC); m_ItemTypes[EQUIP_TYPE].push_back(ARMOUR);
m_ItemTypes[EQUIP_TYPE].push_back(SHIELD); m_ItemTypes[EQUIP_TYPE].push_back(CLOAK);
m_ItemTypes[EQUIP_TYPE].push_back(GLOVE); m_ItemTypes[EQUIP_TYPE].push_back(BOOTS);
m_ItemTypes[EQUIP_TYPE].push_back(SWORD); m_ItemTypes[EQUIP_TYPE].push_back(BLUNT);
m_ItemTypes[EQUIP_TYPE].push_back(AXE); m_ItemTypes[EQUIP_TYPE].push_back(DAGGER);
m_ItemTypes[EQUIP_TYPE].push_back(STAFF); m_ItemTypes[EQUIP_TYPE].push_back(TWOHANDED_BLUNT);
m_ItemTypes[EQUIP_TYPE].push_back(TWOHANDED_AXE); m_ItemTypes[EQUIP_TYPE].push_back(TWOHANDED_SWORD);
m_ItemTypes[EQUIP_TYPE].push_back(BOW); m_ItemTypes[EQUIP_TYPE].push_back(CROSSBOW);
m_ItemTypes[EQUIP_TYPE].push_back(RING); m_ItemTypes[EQUIP_TYPE].push_back(NECKLACE);
m_ItemTypes[EQUIP_TYPE].push_back(HEAD); m_ItemTypes[EQUIP_TYPE].push_back(BODY);
m_ItemTypes[EQUIP_TYPE].push_back(PELVIS); m_ItemTypes[EQUIP_TYPE].push_back(PROTECT_A);
m_ItemTypes[EQUIP_TYPE].push_back(COM_BLUNT); m_ItemTypes[EQUIP_TYPE].push_back(COM_SWORD);
m_ItemTypes[EQUIP_TYPE].push_back(OPP_HAMMER); m_ItemTypes[EQUIP_TYPE].push_back(OPP_AXE);
m_ItemTypes[EQUIP_TYPE].push_back(OPP_SLUSHER); m_ItemTypes[EQUIP_TYPE].push_back(OPP_TALON);
m_ItemTypes[EQUIP_TYPE].push_back(OPP_SYTHE); m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_GUARD);
m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_ATTACK); m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_GUN);
m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_KNIFE); m_ItemTypes[EQUIP_TYPE].push_back(ACCESSORY);
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
m_ItemTypes[USE_ITEM_TYPE].push_back(POTION); m_ItemTypes[USE_ITEM_TYPE].push_back(POISON);
m_ItemTypes[USE_ITEM_TYPE].push_back(TRAP); m_ItemTypes[USE_ITEM_TYPE].push_back(SKILLBOOK);
m_ItemTypes[USE_ITEM_TYPE].push_back(AMMO); m_ItemTypes[USE_ITEM_TYPE].push_back(PORTAL);
m_ItemTypes[USE_ITEM_TYPE].push_back(EVENT_LOTTERY); m_ItemTypes[USE_ITEM_TYPE].push_back(EXPBOOK);
m_ItemTypes[USE_ITEM_TYPE].push_back(CASHBOOK); m_ItemTypes[USE_ITEM_TYPE].push_back(FIRE_CRACKER);
m_ItemTypes[USE_ITEM_TYPE].push_back(CAMP_KIT);
m_ItemTypes[USE_ITEM_TYPE].push_back(SHORT_RANGE_ARMS_KIT);
m_ItemTypes[USE_ITEM_TYPE].push_back(LONG_RANGE_ARMS_KIT);
m_ItemTypes[USE_ITEM_TYPE].push_back(AIRSHIP_KIT);
// <20><><EFBFBD><EFBFBD>
m_ItemTypes[WEAPON_TYPE].push_back(SWORD); m_ItemTypes[WEAPON_TYPE].push_back(BLUNT);
m_ItemTypes[WEAPON_TYPE].push_back(AXE); m_ItemTypes[WEAPON_TYPE].push_back(DAGGER);
m_ItemTypes[WEAPON_TYPE].push_back(STAFF); m_ItemTypes[WEAPON_TYPE].push_back(TWOHANDED_BLUNT);
m_ItemTypes[WEAPON_TYPE].push_back(TWOHANDED_AXE); m_ItemTypes[WEAPON_TYPE].push_back(TWOHANDED_SWORD);
m_ItemTypes[WEAPON_TYPE].push_back(BOW); m_ItemTypes[WEAPON_TYPE].push_back(CROSSBOW);
m_ItemTypes[WEAPON_TYPE].push_back(COM_BLUNT); m_ItemTypes[WEAPON_TYPE].push_back(COM_SWORD);
m_ItemTypes[WEAPON_TYPE].push_back(OPP_HAMMER); m_ItemTypes[WEAPON_TYPE].push_back(OPP_AXE);
m_ItemTypes[WEAPON_TYPE].push_back(OPP_SLUSHER); m_ItemTypes[WEAPON_TYPE].push_back(OPP_TALON);
m_ItemTypes[WEAPON_TYPE].push_back(OPP_SYTHE);
// <20><><EFBFBD>
m_ItemTypes[ARMOUR_TYPE].push_back(HELM); m_ItemTypes[ARMOUR_TYPE].push_back(SHIRT);
m_ItemTypes[ARMOUR_TYPE].push_back(TUNIC); m_ItemTypes[ARMOUR_TYPE].push_back(ARMOUR);
m_ItemTypes[ARMOUR_TYPE].push_back(SHIELD); m_ItemTypes[ARMOUR_TYPE].push_back(CLOAK);
m_ItemTypes[ARMOUR_TYPE].push_back(GLOVE); m_ItemTypes[ARMOUR_TYPE].push_back(BOOTS);
m_ItemTypes[ARMOUR_TYPE].push_back(HEAD); m_ItemTypes[ARMOUR_TYPE].push_back(BODY);
m_ItemTypes[ARMOUR_TYPE].push_back(PELVIS); m_ItemTypes[ARMOUR_TYPE].push_back(PROTECT_A);
// <20><>ų<EFBFBD><C5B3>
m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_GUARD); m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_ATTACK);
m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_GUN); m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_KNIFE);
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
m_ItemTypes[TWOHANDED_TYPE].push_back(STAFF); m_ItemTypes[TWOHANDED_TYPE].push_back(TWOHANDED_BLUNT);
m_ItemTypes[TWOHANDED_TYPE].push_back(TWOHANDED_AXE); m_ItemTypes[TWOHANDED_TYPE].push_back(TWOHANDED_SWORD);
m_ItemTypes[TWOHANDED_TYPE].push_back(BOW); m_ItemTypes[TWOHANDED_TYPE].push_back(CROSSBOW);
// <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD><CCB5>ϴ<EFBFBD><CFB4><EFBFBD> <20><><EFBFBD><EFBFBD>
m_ItemTypes[UPGRADE_SOCKET_ONLY].push_back(HELM);
m_ItemTypes[UPGRADE_SOCKET_ONLY].push_back(RING);
m_ItemTypes[UPGRADE_SOCKET_ONLY].push_back(NECKLACE);
m_ItemTypes[UPGRADE_SOCKET_ONLY].push_back(HEAD);
m_ItemTypes[UPGRADE_SOCKET_ONLY].push_back(ACCESSORY);
for(nCount = 0; nCount < MAX_ARRAY_TYPE; ++nCount)
{
std::sort(m_ItemTypes[nCount].begin(), m_ItemTypes[nCount].end());
}
}
bool OldItem::CItemType::IsCorrectItemType(ArrayType itemType, unsigned char cEquipType)
{
return std::binary_search(m_ItemTypes[itemType].begin(),
m_ItemTypes[itemType].end(), cEquipType);
}
unsigned char OldItem::CItemType::ConvertRandomOptionType(unsigned char cEquipType)
{
using namespace OldItem::ItemType;
if (true == IsCorrectItemType(CItemType::WEAPON_TYPE, cEquipType))
{
return RandomOption::WEAPON;
}
else
{
switch (cEquipType)
{
case ARMOUR: case BODY: return RandomOption::ARMOUR_BODY;
case HELM: case HEAD: return RandomOption::HELM_HEAD;
case RING: case ACCESSORY: return RandomOption::RING_ACCESSORY;
case NECKLACE: return RandomOption::NECKLACE;
case SHIELD: case SKILL_A_GUARD: return RandomOption::SKILL_A_GUARD;
case SKILL_A_ATTACK:
case SKILL_A_GUN:
case SKILL_A_KNIFE:
return RandomOption::SKILL_A_WEAPON;
}
}
return RandomOption::MAX_RANDOM_OPTION_TYPE;
}
void OldItem::CItemType::SetEquipTypeFlags(OldItem::ItemInfo& itemInfo)
{
using namespace OldItem::ItemType;
switch (itemInfo.m_DetailData.m_cItemType)
{
case ARROW:
case BOLT:
itemInfo.m_DetailData.m_dwFlags |= OldItem::DetailData::STACKABLE;
break;
}
if (IsCorrectItemType(WEAPON_TYPE, itemInfo.m_DetailData.m_cItemType))
{
itemInfo.m_DetailData.m_dwFlags |= DetailData::WEAPON;
if (IsCorrectItemType(TWOHANDED_TYPE, itemInfo.m_DetailData.m_cItemType))
{
itemInfo.m_DetailData.m_dwFlags |= DetailData::TWOHANDED;
}
}
else if (IsCorrectItemType(SKILL_ARM_TYPE, itemInfo.m_DetailData.m_cItemType))
{
itemInfo.m_DetailData.m_dwFlags |= DetailData::SKILL_ARM;
}
else if (IsCorrectItemType(ARMOUR_TYPE, itemInfo.m_DetailData.m_cItemType))
{
itemInfo.m_DetailData.m_dwFlags |= DetailData::ARMOUR;
}
itemInfo.m_DetailData.m_dwFlags |= OldItem::DetailData::EQUIP;
}
void OldItem::CItemType::SetUseItemTypeFlags(OldItem::ItemInfo& itemInfo)
{
using namespace OldItem::ItemType;
switch (itemInfo.m_DetailData.m_cItemType)
{
case POTION:
case POISON:
case TRAP:
case PORTAL:
case FIRE_CRACKER:
itemInfo.m_DetailData.m_dwFlags |= OldItem::DetailData::QUICKSLOT_IN;
break;
}
if (itemInfo.m_DetailData.m_cMaxDurabilityOrStack > 1)
{
itemInfo.m_DetailData.m_dwFlags |= OldItem::DetailData::STACKABLE;
}
itemInfo.m_DetailData.m_dwFlags |= OldItem::DetailData::USE_ITEM;
}
void OldItem::CItemType::SetEtcItemTypeFlags(OldItem::ItemInfo& itemInfo)
{
if (itemInfo.m_DetailData.m_cMaxDurabilityOrStack > 1)
{
itemInfo.m_DetailData.m_dwFlags |= OldItem::DetailData::STACKABLE;
}
}
using namespace OldItem::Attribute;
typedef OldItem::ItemAttribute Gem;
typedef OldItem::ItemAttribute Upg;
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 1<><31> <20>ɷ<EFBFBD>ġ <20><><EFBFBD>̺<EFBFBD>
const Gem GemAttribute1[5][4] =
{
// <09><><EFBFBD><EFBFBD> / <20><>ų<EFBFBD><C5B3> <09>Ƹ<EFBFBD> <09><><EFBFBD><EFBFBD> / <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD>
Gem(FIRE_ATTACK, 1), Gem(FIRE_RESISTANCE, 1), Gem(FIRE_RESISTANCE, 1), Gem(ADD_STR, 3), // <20><><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD>
Gem(POISON_ATTACK, 1), Gem(POISON_RESISTANCE, 1), Gem(POISON_RESISTANCE, 1), Gem(ADD_CON, 3), // <20><><EFBFBD>޶<EFBFBD><DEB6><EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(COLD_ATTACK, 1), Gem(COLD_RESISTANCE, 1), Gem(COLD_RESISTANCE, 1), Gem(ADD_INT, 3), // <20><><EFBFBD><EFBFBD><EFBFBD>̾<EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(LIGHTNING_ATTACK, 1), Gem(LIGHTNING_RESISTANCE, 1), Gem(LIGHTNING_RESISTANCE, 1), Gem(ADD_WIS, 3), // <20><><EFBFBD>̾Ƹ<CCBE><C6B8><EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(DRAIN_ATTACK, 1), Gem(DRAIN_RESISTANCE, 1), Gem(DRAIN_RESISTANCE, 1), Gem(ADD_DEX, 3) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 2<><32> <20>̻<EFBFBD> <20>ɷ<EFBFBD>ġ <20><><EFBFBD>̺<EFBFBD>
const Gem GemAttribute2[5][4] =
{
// <09><><EFBFBD><EFBFBD> / <20><>ų<EFBFBD><C5B3> <09>Ƹ<EFBFBD> <09><><EFBFBD><EFBFBD> / <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD>
Gem(MAX_DAMAGE, 1), Gem(DEFENCE_REVISION, 1), Gem(DEFENCE_REVISION, 1), Gem(ADD_STR, 3), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(HP_REGEN_AMOUNT, 2), Gem(MAX_HP, 1), Gem(MAX_HP, 1), Gem(ADD_CON, 3), // <20><><EFBFBD>޶<EFBFBD><DEB6><EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(MP_REGEN_AMOUNT, 2), Gem(MAX_MP, 1), Gem(MAGIC_RESISTANCE, 2), Gem(ADD_INT, 3), // <20><><EFBFBD><EFBFBD><EFBFBD>̾<EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(CRITICAL_PERCENTAGE, 1), Gem(MAGIC_RESISTANCE, 2), Gem(BLOCKING_PERCENTAGE, 1), Gem(ADD_DEX, 3), // <20><><EFBFBD>̾Ƹ<CCBE><C6B8><EFBFBD> <20><><EFBFBD><EFBFBD>
Gem(OFFENCE_REVISION, 1), Gem(DEFENCE, 1), Gem(DEFENCE, 1), Gem(ADD_DEX, 3) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 2<><32> <20>̻<EFBFBD> <20>ɷ<EFBFBD>ġ <20><><EFBFBD>̺<EFBFBD>
const Upg UpgradeAttribute[15][4] =
{
// <09><><EFBFBD><EFBFBD> / <20><>ų<EFBFBD><C5B3> <09>Ƹ<EFBFBD> <09><><EFBFBD><EFBFBD> / <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD>
Upg(MAX_DAMAGE, 3), Upg(DEFENCE, 3), Upg(BLOCKING_PERCENTAGE, 2), Upg(0, 0), // 1<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 3), Upg(DEFENCE, 3), Upg(BLOCKING_PERCENTAGE, 2), Upg(0, 0), // 2<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 6), Upg(DEFENCE, 6), Upg(BLOCKING_PERCENTAGE, 4), Upg(0, 0), // 3<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 6), Upg(DEFENCE, 6), Upg(BLOCKING_PERCENTAGE, 4), Upg(0, 0), // 4<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 9), Upg(DEFENCE, 9), Upg(BLOCKING_PERCENTAGE, 6), Upg(0, 0), // 5<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 9), Upg(DEFENCE, 9), Upg(BLOCKING_PERCENTAGE, 6), Upg(0, 0), // 6<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 12), Upg(DEFENCE, 12), Upg(BLOCKING_PERCENTAGE, 8), Upg(0, 0), // 7<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 12), Upg(DEFENCE, 12), Upg(BLOCKING_PERCENTAGE, 8), Upg(0, 0), // 8<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 15), Upg(DEFENCE, 15), Upg(BLOCKING_PERCENTAGE, 10), Upg(0, 0), // 9<>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 15), Upg(DEFENCE, 15), Upg(BLOCKING_PERCENTAGE, 10), Upg(0, 0), // 10<31>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 19), Upg(DEFENCE, 19), Upg(BLOCKING_PERCENTAGE, 13), Upg(0, 0), // 11<31>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 19), Upg(DEFENCE, 19), Upg(BLOCKING_PERCENTAGE, 13), Upg(0, 0), // 12<31>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 23), Upg(DEFENCE, 23), Upg(BLOCKING_PERCENTAGE, 16), Upg(0, 0), // 13<31>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 23), Upg(DEFENCE, 23), Upg(BLOCKING_PERCENTAGE, 16), Upg(0, 0), // 14<31>ܰ<EFBFBD>
Upg(MAX_DAMAGE, 27), Upg(DEFENCE, 27), Upg(BLOCKING_PERCENTAGE, 19), Upg(0, 0), // 15<31>ܰ<EFBFBD>
};
enum EquipType { None = 0, Weapon = 1, Armour = 2, Shield = 3, Helm = 4 };
short GetEquipType(OldItem::ItemType::Type eItemType)
{
using namespace OldItem::ItemType;
// <20><><EFBFBD><EFBFBD> Ÿ<><C5B8> <20><><EFBFBD><EFBFBD>
switch (eItemType)
{
case SWORD: case BLUNT: case AXE: case TWOHANDED_BLUNT: // <20>ΰ<EFBFBD>
case TWOHANDED_AXE: case TWOHANDED_SWORD: case BOW: case CROSSBOW:
case STAFF: case DAGGER:
case COM_BLUNT: case COM_SWORD: case OPP_HAMMER: case OPP_AXE: // <20><>ĭ
case OPP_SLUSHER: case OPP_TALON: case OPP_SYTHE: case SKILL_A_ATTACK:
case SKILL_A_GUN: case SKILL_A_KNIFE:
return Weapon;
case ARMOUR: // <20>ΰ<EFBFBD>
case BODY: // <20><>ĭ
return Armour;
case SHIELD: // <20>ΰ<EFBFBD>
case SKILL_A_GUARD: // <20><>ĭ
return Shield;
case HELM: // <20>ΰ<EFBFBD>
case HEAD: // <20><>ĭ
return Helm;
}
return None;
}
void OldItem::CItemType::GetInstallGemAttribute(const unsigned char* cSockets_In,
OldItem::ItemAttribute* cAttributes_Out,
OldItem::ItemType::Type eItemType,
unsigned char cSocketNum,
unsigned char cMaxAttributeNum)
{
enum GemType
{
Ruby = 0,
Emerald = 1,
Sapphire = 2,
Diamond = 3,
BlackMoon = 4,
MaxType = 5
};
short EquipType = GetEquipType(eItemType); // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
short GemType = 0; // <20><> Ÿ<><C5B8>
short GemLevel = 0; // <20><> <20><><EFBFBD><EFBFBD>
if (0 >= EquipType)
return;
Gem GemAttr;
unsigned short AttributeIndex = 0;
for(unsigned char SocketIndex = 0;
SocketIndex < cSocketNum && AttributeIndex < cMaxAttributeNum;
++SocketIndex)
{
GemType = (cSockets_In[SocketIndex] - 1) % MaxType;
GemLevel = ((cSockets_In[SocketIndex] - 1) / MaxType) + 1;
if (0 == SocketIndex)
{
GemAttr = GemAttribute1[GemType][EquipType - 1]; // <20><><EFBFBD><EFBFBD> ù<><C3B9>°
}
else
{
GemAttr = GemAttribute2[GemType][EquipType - 1]; // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
}
GemAttr.m_usValue *= GemLevel;
cAttributes_Out[AttributeIndex] = GemAttr;
++AttributeIndex;
if (MAX_DAMAGE == GemAttr.m_cType)
{
// <20>ְ<EFBFBD>, <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD>.
GemAttr.m_cType = MIN_DAMAGE;
cAttributes_Out[AttributeIndex] = GemAttr;
++AttributeIndex;
}
}
}
void OldItem::CItemType::GetUpgradeItemAttribute(OldItem::ItemType::Type eItemType, OldItem::ItemAttribute* cAttributes_Out,
unsigned char cUpgradeLevel, unsigned char cMaxUpgradeAttributeNum)
{
using namespace OldItem::ItemType;
short EquipType = GetEquipType(eItemType); // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
if (0 == cUpgradeLevel || 0 >= EquipType)
return;
Upg UpgAttr = UpgradeAttribute[cUpgradeLevel - 1][EquipType - 1];
if (0 == UpgAttr.m_usValue)
return;
short AttributeIndex = 0;
cAttributes_Out[AttributeIndex] = UpgAttr;
++AttributeIndex;
if (MAX_DAMAGE == UpgAttr.m_cType)
{
// <20>ְ<EFBFBD>, <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD>.
UpgAttr.m_cType = MIN_DAMAGE;
cAttributes_Out[AttributeIndex] = UpgAttr;
++AttributeIndex;
}
/* FIXME :
if (IsWeapon(EquipType))
{
Attribute[0].m_nAttributeType = Attribute::MIN_DAMAGE; // <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ
Attribute[0].m_nValue = 3;
Attribute[1].m_nAttributeType = Attribute::MAX_DAMAGE; // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ
Attribute[1].m_nValue = 3;
return 2;
}
else if (IsArmour(EquipType))
{
Attribute[0].m_nAttributeType = Attribute::DEFENCE; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ
Attribute[0].m_nValue = 3;
return 1;
}
*/
}

348
Server/ToolProject/ItemRebalanceConverter/OldItemConstants.h Normal file
View File

@@ -0,0 +1,348 @@
#ifndef _OLD_ITEM_CONSTANTS_H_
#define _OLD_ITEM_CONSTANTS_H_
#include <vector>
#include <Pattern/Singleton.h>
#include <Utility/TypeArray.h>
namespace OldItem
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
struct ItemInfo;
struct ItemAttribute;
namespace ItemType
{
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8> ( 8bit )
enum Type
{
// <20>ΰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
HELM = 0, SHIRT = 1,
TUNIC = 2, ARMOUR = 3,
GLOVE = 4, BOOTS = 5,
SWORD = 6, BLUNT = 7,
AXE = 8, TWOHANDED_BLUNT = 9,
TWOHANDED_AXE = 10, TWOHANDED_SWORD = 11,
BOW = 12, CROSSBOW = 13,
STAFF = 14, DAGGER = 15,
SHIELD = 16, CLOAK = 17,
RING = 18, NECKLACE = 19,
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
POTION = 20, POISON = 21,
TRAP = 22, SKILLBOOK = 23,
GEM = 24, RUNE = 25,
MATERIAL = 26, AMMO = 27,
ETC = 28,
// <20><>ĭ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
HEAD = 29, BODY = 30,
PROTECT_A = 31, PELVIS = 32,
COM_BLUNT = 33, COM_SWORD = 34,
OPP_HAMMER = 35, OPP_AXE = 36,
OPP_SLUSHER = 37, OPP_TALON = 38,
OPP_SYTHE = 39, SKILL_A_GUARD = 40,
SKILL_A_ATTACK = 41, SKILL_A_GUN = 42,
SKILL_A_KNIFE = 43, ACCESSORY = 44,
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28>Ŀ<EFBFBD> <20>߰<EFBFBD><DFB0><EFBFBD>)
ARROW = 45, BOLT = 46,
PORTAL = 47, EVENT_DROP = 48,
EVENT_LOTTERY = 49, EXPBOOK = 50,
CASHBOOK = 51, FIRE_CRACKER = 52,
CAMP_KIT = 53, SHORT_RANGE_ARMS_KIT = 54, // <20><><EFBFBD><EFBFBD>, <20>ٰŸ<D9B0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ŸƮŶ
LONG_RANGE_ARMS_KIT = 55, AIRSHIP_KIT = 56, // <20><><EFBFBD>Ÿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ŸƮŶ
MAX_ITEM_TYPE = 57
};
enum DropType
{
MAX_DROP_TYPE = 35
};
};
class CItemType
{
public:
static CItemType& GetInstance();
enum ArrayType
{
EQUIP_TYPE = 0, USE_ITEM_TYPE = 1,
WEAPON_TYPE = 2, ARMOUR_TYPE = 3,
SKILL_ARM_TYPE = 4, TWOHANDED_TYPE = 5,
UPGRADE_SOCKET_ONLY = 6, MAX_ARRAY_TYPE = 7
};
typedef std::vector<OldItem::ItemAttribute> ItemAttributeArray;
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
static void GetInstallGemAttribute(const unsigned char* cSockets_In,
ItemAttribute* cAttributes_Out, ItemType::Type eItemType,
unsigned char cSocketNum, unsigned char cMaxAttributeNum);
static bool IsUpgradeSocketOnly(ItemType::Type eItemType);
static void GetUpgradeItemAttribute(ItemType::Type eItemType, ItemAttribute* cAttributes_Out,
unsigned char cUpgradeLevel, unsigned char cMaxUpgradeAttributeNum);
// <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
bool IsCorrectItemType(ArrayType itemType, unsigned char cEquipType);
unsigned char ConvertRandomOptionType(unsigned char cEquipType);
void SetEquipTypeFlags(ItemInfo& itemInfo);
void SetUseItemTypeFlags(ItemInfo& itemInfo);
void SetEtcItemTypeFlags(ItemInfo& itemInfo);
CTypeName* GetItemTypeName() { return m_ItemTypeNames; }
private:
CItemType();
typedef std::vector<ItemType::Type> ItemTypeArray;
ItemTypeArray m_ItemTypes[MAX_ARRAY_TYPE];
CTypeName m_ItemTypeNames[ItemType::MAX_ITEM_TYPE];
};
namespace Attribute
{
enum Type
{
// Creature<72><65> <20><><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD>. <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD><DBBF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
NONE = 0, CRITICAL_TYPE = 1,
CRITICAL_PERCENTAGE = 2, MIN_DAMAGE = 3,
MAX_DAMAGE = 4, DRC = 5,
OFFENCE_REVISION = 6, DEFENCE = 7,
DEFENCE_REVISION = 8, MAGIC_RESISTANCE = 9,
BLOCKING_PERCENTAGE = 10, ATTACK_SPEED = 11,
MOVE_SPEED = 12, ATTACK_RANGE = 13,
RANGE_ATTACK_DISTANCE = 14, MAX_HP = 15,
MAX_MP = 16, HP_REGEN_AMOUNT = 17,
MP_REGEN_AMOUNT = 18, FIRE_ATTACK = 19,
LIGHTNING_ATTACK = 20, COLD_ATTACK = 21,
DRAIN_ATTACK = 22, POISON_ATTACK = 23,
FIRE_RESISTANCE = 24, LIGHTNING_RESISTANCE = 25,
COLD_RESISTANCE = 26, DRAIN_RESISTANCE = 27,
POISON_RESISTANCE = 28, ADD_STR = 29,
ADD_DEX = 30, ADD_CON = 31,
ADD_INT = 32, ADD_WIS = 33,
MAGIC_POWER = 34,
MAX_ATTRIBUTE_NUM = 35
};
enum Trend
{
Aggressive = (1 << 0),
Defensive = (1 << 1)
};
enum CriticalType
{
NONE_TYPE = 0,
SWORD_TYPE = 1,
AXE_TYPE = 2,
BLUNT_TYPE = 3
};
extern const CTypeName Attributes[MAX_ATTRIBUTE_NUM];
};
namespace EquipType
{
enum Type
{
Attach = 0,
Detach = 1,
GuardArm = 2
};
enum DoubleSwordType
{
ErrorDoubleSword = 0,
SoloSword = 1,
WarriorDoubleSword = 2,
AssasinDoubleDagger = 3
};
};
namespace RandomOption
{
enum Type
{
WEAPON = 0, ARMOUR_BODY = 1,
HELM_HEAD = 2, RING_ACCESSORY = 3,
NECKLACE = 4, SKILL_A_GUARD = 5,
SKILL_A_WEAPON = 6,
MAX_RANDOM_OPTION_TYPE = 7
};
enum Attribute
{
MAX_DURABILITY = 0, NOW_DURABILITY = 1,
MIN_DAMAGE = 2, MAX_DAMAGE = 3,
OFFENCE_REVISION = 4, DEFENCE = 5,
DEFENCE_REVISION = 6, MAGIC_RESISTANCE = 7,
CRITICAL_PERCENTAGE = 8, BLOCKING_PERCENTAGE = 9,
MAX_HP = 10, MAX_MP = 11,
HP_REGEN_AMOUNT = 12, MP_REGEN_AMOUNT = 13,
MAX_RANDOM_OPTION_ATTRIBUTE = 14
};
enum ValueRange
{
MIN_MINUS_FACTOR = 0, MIN_MULTIPLY_FACTOR = 1,
MIN_DIVIDE_FACTOR = 2, MAX_MULTIPLY_FACTOR = 3,
MAX_DIVIDE_FACTOR = 4, MAX_PLUS_FACTOR = 5,
MAX_RANDOM_OPTION_VALUE_RANGE = 6
};
};
namespace EquipmentPos
{
// <20><><EFBFBD><EFBFBD> <20><>ġ ( 8bit )
enum Type
{
// <20>ΰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ
HELM = 0, SHIRT = 1,
TUNIC = 2, ARMOUR = 3,
GLOVE = 4, BOOTS = 5,
NECKLACE = 6, RINGR = 7,
RINGL = 8, SHIELD_HAND1 = 9,
SHIELD_HAND2 = 10, WEAPON_HAND1 = 11,
WEAPON_HAND2 = 12, CLOAK = 13,
RIDE = 14,
// <20><>ĭ <20><><EFBFBD><EFBFBD> <20><>ġ
HEAD = 0, BODY = 3,
PROTECT_ARM = 4, PELVIS = 5,
ACCESSORY1 = 6, ACCESSORY2 = 7,
ACCESSORY3 = 8, SKILL_ARM = 9,
WEAPON = 11,
MAX_EQUPMENT_POS = 16,
TEMP_ITEM_INDEX = 128
};
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
namespace StatusLimit
{
enum Type
{
NONE = 0, LEVEL = 1,
STR = 2, DEX = 3,
CON = 4, INT = 5,
WIS = 6,
MAX_STATUS_LIMIT = 7
};
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
namespace Grade
{
enum Type
{
ETC = 0,
NORMAL = 1,
ENHANCED = 2,
RARE = 3,
MAX_ITEM_GRADE = 4
};
extern const CTypeName Grades[MAX_ITEM_GRADE];
};
namespace ExtraSpacePos
{
enum Type
{
UPGRADE_EQUIPMENT_POS = 0,
UPGRADE_MATERIAL_POS = 1,
HOLDITEM_POS = 2,
KIT_MATERIAL_POS = 3,
CAMP_MATERIAL_POS = 4,
EMBLEM_JEWEL_POS1 = 5,
EMBLEM_JEWEL_POS2 = 6,
EMBLEM_JEWEL_POS3 = 7,
EMBLEM_JEWEL_POS4 = 8,
EMBLEM_JEWEL_POS5 = 9,
EMBLEM_JEWEL_POS6 = 10,
EMBLEM_JEWEL_POS7 = 11,
EMBLEM_JEWEL_POS8 = 12,
EMBLEM_JEWEL_POS9 = 13,
MAX_EXTRA_SPACE_NUM = 14,
EMBLEM_JEWEL_POS_NUM = 9
};
};
namespace EtcItemID
{
enum Type
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID
GEM_START_ID = 1901,
GEM_END_ID = 1915,
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID
MINERAL_START_ID = 2001,
MINERAL_END_ID = 2003,
SYLVINE = 2001,
MYTHRIL = 2002,
ETERNIUM = 2003,
// ȸ<><C8B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID
POTION_START_ID = 3020,
POTION_END_ID = 3124,
// <20><><EFBFBD><EFBFBD><EFBFBD>ǵ<EFBFBD> ID
OBLIVION_STONE = 9914,
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ŸƮŶ ID
CAMP_KIT_ID = 7100,
SHORT_RANGE_ARMS_KIT_ID = 7101,
LONG_RANGE_ARMS_KIT_ID = 7102,
AIRSHIP_KIT_ID = 7103,
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
SIEGE_MATERIAL_ID = 9914,
// <20><>ö ID
SCRAPS = 2101
};
};
namespace Chemical
{
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ռ<EFBFBD> <20><><EFBFBD><EFBFBD>
enum Result
{
S_SUCCESS = 0, // <20><><EFBFBD><EFBFBD>
F_WRONG_RECIPE = 2, // <20>ùٸ<C3B9> <20>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD> <20>ƴմϴ<D5B4>.
F_NOT_ENOUGH_ITEM = 3, // <20>ռ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ּҷ<D6BC><D2B7><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD>մϴ<D5B4>.
F_WRONG_RATE = 4 // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD><DFBB>մϴ<D5B4>. <20>ռ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ֽñ<D6BD> <20>ٶ<EFBFBD><D9B6>ϴ<EFBFBD>.
};
};
};
#endif

291
Server/ToolProject/ItemRebalanceConverter/OldItemDataParser.cpp Normal file
View File

@@ -0,0 +1,291 @@
#include "stdafx.h"
#include <Utility/Math/Math.h>
// Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̹Ƿ<CCB9> include<64><65> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
#include <Log/ServerLog.h>
#include "OldItemStructure.h"
#include "OldItemDataParser.h"
using namespace OldItem;
namespace OldItemDataParser
{
bool ReadString(char* szBuffer_Out, int nBufferLen, const char* szValue_In)
{
int nLength = _snprintf(szBuffer_Out, nBufferLen - 1, "%s", szValue_In);
if (0 <= nLength)
{
szBuffer_Out[nLength] = '\0';
return true;
}
szBuffer_Out[nBufferLen - 1] = '\0';
ERRLOG1(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̰<EFBFBD> <20><><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. Data:%s", szValue_In);
return false;
}
inline bool ReadValue(unsigned char& cValue_Out, const char* szValue_In)
{
cValue_Out = static_cast<unsigned char>(atoi(szValue_In));
return true;
}
inline bool ReadValue(unsigned short& usValue_Out, const char* szValue_In)
{
usValue_Out = static_cast<unsigned short>(atoi(szValue_In));
return true;
}
inline bool ReadValue(unsigned long& dwValue_Out, const char* szValue_In)
{
dwValue_Out = static_cast<unsigned long>(atol(szValue_In));
return true;
}
inline bool ReadValue(float& fValue_Out, const char* szValue_In)
{
fValue_Out = static_cast<float>(atof(szValue_In));
return true;
}
bool ReadStringToTypeValue(unsigned char& cVaule_Out, const CTypeName* lpTypeArray,
const unsigned char nMaxType, const char* szValue_In)
{
for (unsigned char nCount = 0; nCount < nMaxType; ++nCount)
{
if (0 == strcmp(szValue_In, lpTypeArray[nCount].GetTypeName()))
{
cVaule_Out = lpTypeArray[nCount].GetTypeValue();
return true;
}
}
return false;
}
// <20>⺻ <20><><EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD>
bool ReadID(OldItem::ItemInfo& itemInfo, const char* szValue)
{
itemInfo.m_usProtoTypeID = static_cast<unsigned short>(atoi(szValue));
if (0 == itemInfo.m_usProtoTypeID || 0xFFFF == itemInfo.m_usProtoTypeID)
{
ERRLOG1(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID<49><44> <20>̻<EFBFBD><CCBB>մϴ<D5B4>. 0<>̳<EFBFBD> 0xFFFF<46><46> <20><><EFBFBD><EFBFBD><EFBFBD>Ͻ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. ID:0x%08x",
itemInfo.m_usProtoTypeID);
return false;
}
return true;
}
bool ReadItemName(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_SpriteData.m_szName, SpriteData::MAX_NAME, szValue); }
bool ReadFieldModelName(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szFieldModelName, StringData::MAX_FIELD_MODEL_NAME, szValue); }
bool ReadAttachedModelName(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szEquipModelName, StringData::MAX_EQUIP_MODEL_NAME, szValue); }
bool ReadSpriteDDS(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_SpriteData.m_szSpriteName, SpriteData::MAX_SPRITE_NAME, szValue); }
bool ReadMinX(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMinX, szValue); }
bool ReadMinY(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMinY, szValue); }
bool ReadMaxX(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMaxX, szValue); }
bool ReadMaxY(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMaxY, szValue); }
bool ReadSizeX(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cXSize, szValue); }
bool ReadSizeY(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cYSize, szValue); }
bool ReadEffectSound(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szEffectSoundName, StringData::MAX_EFFECT_SOUND_NAME, szValue); }
bool ReadItemLevel(OldItem::ItemInfo& itemInfo, const char* szValue)
{
unsigned char cGrade = 0;
if (ReadStringToTypeValue(cGrade, OldItem::Grade::Grades, OldItem::Grade::MAX_ITEM_GRADE, szValue))
{
itemInfo.m_DetailData.m_ItemGrade = static_cast<OldItem::Grade::Type>(cGrade);
return true;
}
return false;
}
bool ReadItemType(OldItem::ItemInfo& itemInfo, const char* szValue)
{
return ReadStringToTypeValue(itemInfo.m_DetailData.m_cItemType,
OldItem::CItemType::GetInstance().GetItemTypeName(), OldItem::ItemType::MAX_ITEM_TYPE, szValue);
}
bool ReadTypeName(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szTypeName, StringData::MAX_TYPE_NAME, szValue); }
bool ReadPrice(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_dwPrice, szValue); }
bool ReadBlackPrice(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_dwBlackPrice, szValue); }
bool ReadMedalPrice(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_dwMedalPrice, szValue); }
bool ReadOptionLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cOptionLimit, szValue); }
bool ReadDurability(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cDefaultDurabilityOrStack, szValue); }
bool ReadMaxDurability(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cMaxDurabilityOrStack, szValue); }
bool ReadClassLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_dwClassLimit, szValue); }
bool ReadSkillLimitType(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nSkillType, szValue); }
bool ReadSkillLimitLevel(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_cSkillLevel, szValue); }
bool ReadLevelLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_cLevelLimit, szValue); }
bool ReadSTRLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::STR], szValue); }
bool ReadDEXLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::DEX], szValue); }
bool ReadCONLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::CON], szValue); }
bool ReadINTLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::INT], szValue); }
bool ReadWISLimit(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::WIS], szValue); }
bool ReadCraftExp(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_dwCraftExp, szValue); }
}
bool OldItemDataParser::SetDefaultData(ParseDataArray& parseDataArray)
{
parseDataArray.reserve(40);
parseDataArray.push_back(ParseData("ID", ReadID));
parseDataArray.push_back(ParseData("ItemName", ReadItemName));
parseDataArray.push_back(ParseData("FieldModelName", ReadFieldModelName));
parseDataArray.push_back(ParseData("AttachedModelName", ReadAttachedModelName));
parseDataArray.push_back(ParseData("SpriteDDS", ReadSpriteDDS));
parseDataArray.push_back(ParseData("MinX", ReadMinX));
parseDataArray.push_back(ParseData("MinY", ReadMinY));
parseDataArray.push_back(ParseData("MaxX", ReadMaxX));
parseDataArray.push_back(ParseData("MaxY", ReadMaxY));
parseDataArray.push_back(ParseData("SizeX", ReadSizeX));
parseDataArray.push_back(ParseData("SizeY", ReadSizeY));
parseDataArray.push_back(ParseData("EffectSound", ReadEffectSound));
parseDataArray.push_back(ParseData("ItemLevel", ReadItemLevel));
parseDataArray.push_back(ParseData("ItemType", ReadItemType));
parseDataArray.push_back(ParseData("TypeName", ReadTypeName));
parseDataArray.push_back(ParseData("Price", ReadPrice));
parseDataArray.push_back(ParseData("BlackPrice", ReadBlackPrice));
parseDataArray.push_back(ParseData("MedalPrice", ReadMedalPrice));
parseDataArray.push_back(ParseData("OptionLimit", ReadOptionLimit));
parseDataArray.push_back(ParseData("Durability", ReadDurability));
parseDataArray.push_back(ParseData("MaxDurability", ReadMaxDurability));
parseDataArray.push_back(ParseData("ClassLimit", ReadClassLimit));
parseDataArray.push_back(ParseData("SkillLimitType", ReadSkillLimitType));
parseDataArray.push_back(ParseData("SkillLimitLevel", ReadSkillLimitLevel));
parseDataArray.push_back(ParseData("LevelLimit", ReadLevelLimit));
parseDataArray.push_back(ParseData("STRLimit", ReadSTRLimit));
parseDataArray.push_back(ParseData("DEXLimit", ReadDEXLimit));
parseDataArray.push_back(ParseData("CONLimit", ReadCONLimit));
parseDataArray.push_back(ParseData("INTLimit", ReadINTLimit));
parseDataArray.push_back(ParseData("WISLimit", ReadWISLimit));
parseDataArray.push_back(ParseData("CraftExp", ReadCraftExp));
return true;
}
namespace OldItemDataParser
{
bool ReadCriticalType(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::CRITICAL_TYPE], szValue); }
bool ReadCriticalPercentage(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::CRITICAL_PERCENTAGE], szValue); }
bool ReadMinDamage(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MIN_DAMAGE], szValue); }
bool ReadMaxDamage(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MAX_DAMAGE], szValue); }
bool ReadDRC(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::DRC], szValue); }
bool ReadOffenceRevision(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::OFFENCE_REVISION], szValue); }
bool ReadDefence(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::DEFENCE], szValue); }
bool ReadDefenceRevision(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::DEFENCE_REVISION], szValue); }
bool ReadResistance(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MAGIC_RESISTANCE], szValue); }
bool ReadBlockingPercentage(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::BLOCKING_PERCENTAGE], szValue); }
bool ReadAttackSpeed(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ATTACK_SPEED], szValue); }
bool ReadMoveSpeed(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MOVE_SPEED], szValue); }
bool ReadAttackRange(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ATTACK_RANGE], szValue); }
bool ReadRangedAttack(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::RANGE_ATTACK_DISTANCE], szValue); }
bool ReadHpMaxPlus(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MAX_HP], szValue); }
bool ReadMpMaxPlus(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MAX_MP], szValue); }
bool ReadHPRegen(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::HP_REGEN_AMOUNT], szValue); }
bool ReadMPRegen(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::MP_REGEN_AMOUNT], szValue); }
bool ReadFireAttribute(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::FIRE_ATTACK], szValue); }
bool ReadLightingAttribute(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::LIGHTNING_ATTACK], szValue); }
bool ReadColdAttribute(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::COLD_ATTACK], szValue); }
bool ReadDrainAttribute(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::DRAIN_ATTACK], szValue); }
bool ReadPoisonAttribute(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::POISON_ATTACK], szValue); }
bool ReadFireResistance(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::FIRE_RESISTANCE], szValue); }
bool ReadLightningResistance(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::LIGHTNING_RESISTANCE], szValue); }
bool ReadColdResistance(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::COLD_RESISTANCE], szValue); }
bool ReadDrainResistance(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::DRAIN_RESISTANCE], szValue); }
bool ReadPoisonResistance(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::POISON_RESISTANCE], szValue); }
bool ReadSTRAdd(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ADD_STR], szValue); }
bool ReadDEXAdd(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ADD_DEX], szValue); }
bool ReadCONAdd(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ADD_CON], szValue); }
bool ReadINTAdd(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ADD_INT], szValue); }
bool ReadWISAdd(OldItem::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[OldItem::Attribute::ADD_WIS], szValue); }
bool ReadMaterialValue(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cMaterialType, szValue); }
bool ReadMaxSocketNum(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cMaxSocketNum, szValue); }
}
bool OldItemDataParser::SetEquipData(ParseDataArray& parseDataArray)
{
parseDataArray.push_back(ParseData("CriticalType", ReadCriticalType));
parseDataArray.push_back(ParseData("CriticalPercentage", ReadCriticalPercentage));
parseDataArray.push_back(ParseData("MinDamage", ReadMinDamage));
parseDataArray.push_back(ParseData("MaxDamage", ReadMaxDamage));
parseDataArray.push_back(ParseData("DRC", ReadDRC));
parseDataArray.push_back(ParseData("OffenceRevision", ReadOffenceRevision));
parseDataArray.push_back(ParseData("Defence", ReadDefence));
parseDataArray.push_back(ParseData("DefenceRevision", ReadDefenceRevision));
parseDataArray.push_back(ParseData("Resistance", ReadResistance));
parseDataArray.push_back(ParseData("BlockingPercentage", ReadBlockingPercentage));
parseDataArray.push_back(ParseData("AttackSpeed", ReadAttackSpeed));
parseDataArray.push_back(ParseData("MoveSpeed", ReadMoveSpeed));
parseDataArray.push_back(ParseData("AttackRange", ReadAttackRange));
parseDataArray.push_back(ParseData("LongRangeAttack", ReadRangedAttack));
parseDataArray.push_back(ParseData("HpMaxPlus", ReadHpMaxPlus));
parseDataArray.push_back(ParseData("MpMaxPlus", ReadMpMaxPlus));
parseDataArray.push_back(ParseData("HPRegen", ReadHPRegen));
parseDataArray.push_back(ParseData("MPRegen", ReadMPRegen));
parseDataArray.push_back(ParseData("FireAttribute", ReadFireAttribute));
parseDataArray.push_back(ParseData("LightingAttribute", ReadLightingAttribute));
parseDataArray.push_back(ParseData("ColdAttribute", ReadColdAttribute));
parseDataArray.push_back(ParseData("DrainAttribute", ReadDrainAttribute));
parseDataArray.push_back(ParseData("PoisonAttribute", ReadPoisonAttribute));
parseDataArray.push_back(ParseData("FireResistance", ReadFireResistance));
parseDataArray.push_back(ParseData("LightningResistance", ReadLightningResistance));
parseDataArray.push_back(ParseData("ColdResistance", ReadColdResistance));
parseDataArray.push_back(ParseData("DrainResistance", ReadDrainResistance));
parseDataArray.push_back(ParseData("PoisonResistance", ReadPoisonResistance));
parseDataArray.push_back(ParseData("STRAdd", ReadSTRAdd));
parseDataArray.push_back(ParseData("DEXAdd", ReadDEXAdd));
parseDataArray.push_back(ParseData("CONAdd", ReadCONAdd));
parseDataArray.push_back(ParseData("INTAdd", ReadINTAdd));
parseDataArray.push_back(ParseData("WISAdd", ReadWISAdd));
parseDataArray.push_back(ParseData("MaterialValue", ReadMaterialValue));
parseDataArray.push_back(ParseData("MaxSocketNum", ReadMaxSocketNum));
return true;
}
namespace OldItemDataParser
{
bool ReadSkill_ID(OldItem::ItemInfo& itemInfo, const char* szValue) { itemInfo.m_UseItemInfo.m_usSkill_ID = Math::Convert::Atos(szValue); return true; }
bool ReadSkill_Level(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_usSkill_LockCount, szValue); }
bool ReadZone(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_cZone, szValue); }
bool ReadPositionX(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_Pos.m_fPointX, szValue); }
bool ReadPositionY(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_Pos.m_fPointY, szValue); }
bool ReadPositionZ(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_Pos.m_fPointZ, szValue); }
bool ReadAmount(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_dwAmount, szValue); }
bool ReadItemDescribe(OldItem::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szItemDescribe, OldItem::StringData::MAX_ITEM_DESCRIBE, szValue); }
}
bool OldItemDataParser::SetUseItemData(ParseDataArray& parseDataArray)
{
parseDataArray.push_back(ParseData("CriticalType", ReadSkill_ID));
parseDataArray.push_back(ParseData("CriticalPercentage", ReadSkill_Level));
parseDataArray.push_back(ParseData("MinDamage", ReadZone));
parseDataArray.push_back(ParseData("MaxDamage", ReadPositionX));
parseDataArray.push_back(ParseData("DRC", ReadPositionY));
parseDataArray.push_back(ParseData("OffenceRevision", ReadPositionZ));
parseDataArray.push_back(ParseData("Defence", ReadAmount));
parseDataArray.push_back(ParseData("DefenceRevision", ReadItemDescribe));
return true;
}
bool OldItemDataParser::SetEtcItemData(ParseDataArray& parseDataArray)
{
parseDataArray.push_back(ParseData("CriticalType", ReadItemDescribe));
return true;
}

34
Server/ToolProject/ItemRebalanceConverter/OldItemDataParser.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef _OLD_ITEM_DATA_PARSER_H_
#define _OLD_ITEM_DATA_PARSER_H_
#include <vector>
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
namespace OldItem
{
struct ItemInfo;
};
namespace OldItemDataParser
{
struct ParseData
{
typedef bool(*ParseFunc) (OldItem::ItemInfo& itemInfo, const char* szValue);
const char* m_szColumnName;
ParseFunc m_fnParseFunc;
ParseData(const char* szColumnName, ParseFunc fnParseFunc)
: m_szColumnName(szColumnName), m_fnParseFunc(fnParseFunc) { }
};
typedef std::vector<ParseData> ParseDataArray;
bool SetDefaultData(ParseDataArray& parseDataArray);
bool SetEquipData(ParseDataArray& parseDataArray);
bool SetUseItemData(ParseDataArray& parseDataArray);
bool SetEtcItemData(ParseDataArray& parseDataArray);
};
#endif

679
Server/ToolProject/ItemRebalanceConverter/OldItemMgr.cpp Normal file
View File

@@ -0,0 +1,679 @@
#include "stdafx.h"
#include <memory>
#include <algorithm>
#include <functional>
// Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̹Ƿ<CCB9> include<64><65> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
#include <Log/ServerLog.h>
#include <Network/XORCrypt/XORCrypt.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Utility/DelimitedFile.h>
#include <Utility/TokenlizedFile.h>
#include <Utility/Resource/EnsureCleanup.h>
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>
#include <Utility/Setup/ServerSetup.h>
#include "OldItemDataParser.h"
#include "OldItemMgr.h"
#define DECODE_HEADER(Start_In, Length_In, PageVer_In, PageNum_In) CXORCrypt::GetInstance().DecodeHeader((Start_In),(Length_In),(PageVer_In),(PageNum_In))
#define ENCODE_HEADER(Start_In, Length_In, PageVer_In, PageNum_In) CXORCrypt::GetInstance().EncodeHeader((Start_In),(Length_In),(PageVer_In),(PageNum_In))
#define COMPRESS(In, In_len, Out, Out_len) CMiniLZO::Compress((In), (In_len), (Out), (Out_len))
#define DECOMPRESS(In, In_len, Out, Out_len) CMiniLZO::Decompress((In), (In_len), (Out), (Out_len))
using namespace OldItem;
const char* CItemMgr::ms_szItemScriptFileName = "./Script/Game/ItemScript.txt";
const char* CItemMgr::ms_szBGItemScriptFileName = "./Script/Game/BGItemScript.txt";
const char* CItemMgr::ms_szChemicalScriptFileName = "./Script/Game/Chemical.txt";
class CParseDelimitedData
{
public:
CParseDelimitedData(CTokenlizedFile& TokenlizedFile) : m_TokenlizedFile(TokenlizedFile) { }
bool operator() (OldItemDataParser::ParseDataArray& ParserArray, OldItem::ItemInfo& itemInfo)
{
for (OldItemDataParser::ParseDataArray::iterator itr = ParserArray.begin();
itr != ParserArray.end(); ++itr)
{
const char* szValue = m_TokenlizedFile.GetStringValue(itr->m_szColumnName);
if (NULL == szValue)
{
ERRLOG2(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. Line:%d, ColumnName:%d",
m_TokenlizedFile.GetCurrentLine(), itr->m_szColumnName);
return false;
}
if (false == itr->m_fnParseFunc(itemInfo, szValue))
{
ERRLOG2(g_Log, "<EFBFBD>˸<EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20>ƴմϴ<D5B4>. Line:%d, ColumnName:%d",
m_TokenlizedFile.GetCurrentLine(), itr->m_szColumnName);
return false;
}
}
return true;
}
private:
CTokenlizedFile& m_TokenlizedFile;
};
OldItem::CItemMgr& OldItem::CItemMgr::GetInstance()
{
static CItemMgr itemMgr;
return itemMgr;
}
CItemMgr::CItemMgr()
: m_ItemInfoArray(NULL), m_nItemNum(0), m_ChemicalArray(NULL), m_nChemicalNum(0)
{
}
CItemMgr::~CItemMgr()
{
DestoryItemInfo();
DestoryChemical();
}
void CItemMgr::DestoryItemInfo(void)
{
if (NULL != m_ItemInfoArray)
{
delete [] m_ItemInfoArray;
m_ItemInfoArray = NULL;
}
m_nItemNum = 0;
}
void CItemMgr::DestoryChemical(void)
{
if (NULL != m_ChemicalArray)
{
delete [] m_ChemicalArray;
m_ChemicalArray = NULL;
}
m_nChemicalNum = 0;
}
bool CItemMgr::LoadItemProtoType(const char* szFileName)
{
DestoryItemInfo();
ItemInfo itemInfo;
CTokenlizedFile TokenlizedFile; // <20><>ü <20>Ҹ<EFBFBD><D2B8><EFBFBD>, <20>ڵ<EFBFBD> Close.
char szItemScriptName[MAX_PATH];
if (SERVER_ID::GROUP_BATTLE_SERVER == CServerSetup::GetInstance().GetServerGroup())
{
strncpy(szItemScriptName, ms_szBGItemScriptFileName, MAX_PATH);
}
else
{
strncpy(szItemScriptName, ms_szItemScriptFileName, MAX_PATH);
}
if (false == TokenlizedFile.Open((NULL != szFileName) ? szFileName : szItemScriptName))
{
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.");
return false;
}
if (false == TokenlizedFile.ReadColumn())
{
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20>÷<EFBFBD><C3B7><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.");
return false;
}
OldItemDataParser::ParseDataArray DefaultItemData;
OldItemDataParser::ParseDataArray EquipItemData;
OldItemDataParser::ParseDataArray UseItemData;
OldItemDataParser::ParseDataArray EtcItemData;
OldItemDataParser::SetDefaultData(DefaultItemData);
OldItemDataParser::SetEquipData(EquipItemData);
OldItemDataParser::SetUseItemData(UseItemData);
OldItemDataParser::SetEtcItemData(EtcItemData);
CItemType& ItemType = CItemType::GetInstance();
std::vector<ItemInfo> ItemInfoVector;
CParseDelimitedData ParseData(TokenlizedFile);
while (TokenlizedFile.ReadLine())
{
itemInfo.Initialize();
if (false == ParseData(DefaultItemData, itemInfo))
{
return false;
}
if (ItemType.IsCorrectItemType(CItemType::EQUIP_TYPE,
itemInfo.m_DetailData.m_cItemType))
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if (false == ParseData(EquipItemData, itemInfo))
{
return false;
}
ItemType.SetEquipTypeFlags(itemInfo);
}
else if (ItemType.IsCorrectItemType(CItemType::USE_ITEM_TYPE,
itemInfo.m_DetailData.m_cItemType))
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if (false == ParseData(UseItemData, itemInfo))
{
return false;
}
ItemType.SetUseItemTypeFlags(itemInfo);
}
else
{
// <20><>Ÿ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if (false == ParseData(EtcItemData, itemInfo))
{
return false;
}
ItemType.SetEtcItemTypeFlags(itemInfo);
}
ItemInfoVector.push_back(itemInfo);
}
if (false == TokenlizedFile.IsEOF())
{
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
return false;
}
std::sort(ItemInfoVector.begin(), ItemInfoVector.end());
for (std::vector<ItemInfo>::iterator itr = ItemInfoVector.begin();
itr != ItemInfoVector.end() - 1; ++itr)
{
if (itr->m_usProtoTypeID == (itr+1)->m_usProtoTypeID)
{
ERRLOG1(g_Log, "<EFBFBD><EFBFBD>ġ<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID<49><44> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>. <20><><EFBFBD><EFBFBD>ID:%d", itr->m_usProtoTypeID);
return false;
}
};
m_nItemNum = ItemInfoVector.size();
m_ItemInfoArray = new ItemInfo[m_nItemNum];
if (NULL == m_ItemInfoArray)
{
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. <20>޸𸮰<DEB8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
return false;
}
std::copy(ItemInfoVector.begin(), ItemInfoVector.end(), m_ItemInfoArray);
return true;
}
const ItemInfo* CItemMgr::GetItemInfo(unsigned short usProtoTypeID)
{
ItemInfo* lpFirst = m_ItemInfoArray;
ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
ItemInfo* lpMid = NULL;
size_t nCount = m_nItemNum;
size_t nCount2 = 0;
for (; 0 < nCount; )
{
nCount2 = nCount / 2;
lpMid = lpFirst + nCount2;
if (lpMid->m_usProtoTypeID < usProtoTypeID)
{
lpFirst = ++lpMid, nCount -= nCount2 + 1;
}
else
{
nCount = nCount2;
}
}
return (lpFirst != lpLast && !(usProtoTypeID < lpFirst->m_usProtoTypeID)) ? lpFirst : NULL;
}
const ItemInfo* CItemMgr::GetItemInfoFromItemName(const char* szItemName)
{
ItemInfo* lpFirst = m_ItemInfoArray;
ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
for (; lpFirst != lpLast; ++lpFirst)
{
if (0 == strcmp(lpFirst->m_SpriteData.m_szName, szItemName))
{
return lpFirst;
}
}
return NULL;
}
const ItemInfo* CItemMgr::GetItemInfoFromEquipName(const char* szEquipName)
{
ItemInfo* lpFirst = m_ItemInfoArray;
ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
for (; lpFirst != lpLast; ++lpFirst)
{
if (0 == strcmp(lpFirst->m_StringData.m_szEquipModelName, szEquipName))
{
return lpFirst;
}
}
return NULL;
}
const char* CItemMgr::GetEquipName(const unsigned short usItemProtoTypeID)
{
const ItemInfo* pItemInfo = GetItemInfo(usItemProtoTypeID);
if(pItemInfo)
{
return pItemInfo->m_StringData.m_szEquipModelName;
}
return NULL;
}
const unsigned short CItemMgr::GetItemIDFromSkillID(const unsigned short usSkill_ID, const unsigned short unSkill_LockCount)
{
ItemInfo* lpFirst = m_ItemInfoArray;
ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
for (; lpFirst != lpLast; ++lpFirst)
{
if (lpFirst->m_UseItemInfo.m_usSkill_ID == usSkill_ID &&
lpFirst->m_UseItemInfo.m_usSkill_LockCount == unSkill_LockCount)
{
return lpFirst->m_usProtoTypeID;
}
}
return 0;
}
bool CItemMgr::LoadItemProtoTypeBinary(const char* szFileNameBinary)
{
if (NULL == szFileNameBinary) { return false; }
HANDLE hFile = CreateFile(szFileNameBinary, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) { return false; }
CEnsureCloseHandle EnsureCloseHandle(hFile);
unsigned long dwRead = 0;
unsigned long dwFileHighSize = 0;
unsigned long dwFileSize = GetFileSize(hFile, &dwFileHighSize);
char* lpAllocated = new char[dwFileSize];
CEnsureDeleteArray<char> EnsureFileInfo(lpAllocated);
if (false == ReadFile(hFile, lpAllocated, dwFileSize, &dwRead, NULL))
{
return false;
}
unsigned long dwHeaderSize = sizeof(unsigned long) + *reinterpret_cast<unsigned long *>(lpAllocated) + sizeof(unsigned long);
unsigned long dwDecompressedSize = *reinterpret_cast<unsigned long *>(lpAllocated + dwHeaderSize - sizeof(unsigned long));
DestoryItemInfo();
m_nItemNum = dwDecompressedSize / sizeof(ItemInfo);
m_ItemInfoArray = new ItemInfo[m_nItemNum];
if (NULL == m_ItemInfoArray)
{
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ҷ<EFBFBD><D2B7><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. <20>޸𸮰<DEB8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
return false;
}
DECOMPRESS(lpAllocated + dwHeaderSize, dwFileSize - dwHeaderSize,
reinterpret_cast<char *>(m_ItemInfoArray), &dwDecompressedSize);
DECODE_HEADER(reinterpret_cast<char *>(m_ItemInfoArray), dwDecompressedSize, 0, 2);
return true;
}
bool CItemMgr::SaveItemProtoTypeBinary(const char* szFileNameBinary, const char* szTrashFile)
{
if (NULL == szFileNameBinary || NULL == szTrashFile) { return false; }
HANDLE hFile = CreateFile(szFileNameBinary, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) { return false; }
CEnsureCloseHandle EnsureCloseSaveHandle(hFile);
unsigned long nItemInfoSize = static_cast<unsigned long>(sizeof(ItemInfo) * m_nItemNum);
unsigned long nCompressedInfoSize = nItemInfoSize;
char* lpItemInfo = new char[nItemInfoSize];
char* lpCompressedInfo = new char[nItemInfoSize];
CEnsureDeleteArray<char> EnsureDeleteItemInfo(lpItemInfo);
CEnsureDeleteArray<char> EnsureDeleteCompressedInfo(lpCompressedInfo);
if (NULL == lpItemInfo || NULL == lpCompressedInfo)
{
return false;
}
memcpy(lpItemInfo, m_ItemInfoArray, nItemInfoSize);
ENCODE_HEADER(lpItemInfo, nItemInfoSize, 0, 2);
COMPRESS(lpItemInfo, nItemInfoSize, lpCompressedInfo, &nCompressedInfoSize);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD>) <20>ڷ<EFBFBD>
HANDLE hTrashFile = CreateFile(szTrashFile, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hTrashFile == INVALID_HANDLE_VALUE) { return false; }
CEnsureCloseHandle EnsureCloseTrashHandle(hTrashFile);
unsigned long dwRead = 0;
unsigned long dwWritten = 0;
unsigned long dwFileHighSize = 0;
unsigned long dwTrashFileSize = GetFileSize(hTrashFile, &dwFileHighSize);
char* lpTrashFileData = new char[dwTrashFileSize];
CEnsureDeleteArray<char> EnsureDeleteTrashFile(lpTrashFileData);
if (false == ReadFile(hTrashFile, lpTrashFileData, dwTrashFileSize, &dwRead, NULL))
{
return false;
}
// Trash File<6C><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
WriteFile(hFile, &dwTrashFileSize, sizeof(unsigned long), &dwWritten, 0); // Trash <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
WriteFile(hFile, lpTrashFileData, dwTrashFileSize, &dwWritten, 0); // Trash <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// <20>ùٸ<C3B9> <20>ڷ<EFBFBD>
WriteFile(hFile, &nItemInfoSize, sizeof(unsigned long), &dwWritten, 0); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
WriteFile(hFile, lpCompressedInfo, nCompressedInfoSize, &dwWritten, 0); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
return true;
}
bool CItemMgr::LoadItemChemical(const char* szFileName)
{
const int ITEM_NAME_LEN = 32;
char szBuffer[ITEM_NAME_LEN];
int nLineCount = 0;
CDelimitedFile DelimitedFile; // <20><>ü <20>Ҹ<EFBFBD><D2B8><EFBFBD>, <20>ڵ<EFBFBD> Close.
// <20><>ũ<EFBFBD>ο<EFBFBD> <20>α<EFBFBD> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><>.
// <20><>ũ<EFBFBD>ο<EFBFBD><CEBF><EFBFBD> \<5C>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>̳<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>Ե<EFBFBD><D4B5><EFBFBD> <20>ʵ<EFBFBD><CAB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>.
// ( '<27>̽<EFBFBD><CCBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߸<EFBFBD><DFB8>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD>ϴ<EFBFBD>' <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD> )
#define READ_DATA(ColumnName, Argument) \
if (false == DelimitedFile.ReadData(Argument)) \
{ \
ERRLOG2(g_Log, "<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ռ<EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20>б<EFBFBD> <20><><EFBFBD><EFBFBD> : %d<><64> %s<>÷<EFBFBD><C3B7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD>!", nLineCount, #ColumnName); \
return false; \
}
#define READ_STRING(ColumnName, Buffer, BufferSize) \
if (false == DelimitedFile.ReadString(Buffer, BufferSize)) \
{\
ERRLOG2(g_Log, "<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ռ<EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20>б<EFBFBD> <20><><EFBFBD><EFBFBD> : %d<><64> %s<>÷<EFBFBD><C3B7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD>!", nLineCount, #ColumnName);\
return false;\
}
if (false == DelimitedFile.Open(szFileName ? szFileName : ms_szChemicalScriptFileName, 2))
{
ERRLOG1(g_Log, "%s <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.", szFileName ? szFileName : ms_szChemicalScriptFileName);
return false;
}
std::vector<ChemicalInfo> ChemicalVector;
ChemicalInfo tempChemical;
while (DelimitedFile.ReadLine())
{
++nLineCount;
READ_STRING("PickkingItem Name", szBuffer, ITEM_NAME_LEN);
READ_DATA("PickkingItem ID", tempChemical.m_wPickkingItemID);
READ_DATA("PickkingItem Num", tempChemical.m_cPickkingItemNum);
READ_STRING("TargetItem Name", szBuffer, ITEM_NAME_LEN);
READ_DATA("TargetItem ID", tempChemical.m_wTargetItemID);
READ_DATA("TargetItem Num", tempChemical.m_cTargetItemNum);
READ_STRING("ResultItem Name", szBuffer, ITEM_NAME_LEN);
READ_DATA("ResultItem ID", tempChemical.m_wResultItemID);
READ_DATA("ResultItem Num", tempChemical.m_cResultItemNum);
const ItemInfo* lpPickkingItem = GetItemInfo(tempChemical.m_wPickkingItemID);
const ItemInfo* lpTargetItem = GetItemInfo(tempChemical.m_wTargetItemID);
const ItemInfo* lpResultItem = GetItemInfo(tempChemical.m_wResultItemID);
if (NULL == lpPickkingItem || NULL == lpTargetItem || NULL == lpResultItem)
{
ERRLOG3(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>. "
"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : %d, <20>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : %d, <20>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : %d",
tempChemical.m_wPickkingItemID, tempChemical.m_wTargetItemID, tempChemical.m_wResultItemID);
return false;
}
if (lpTargetItem->m_DetailData.m_cXSize < lpResultItem->m_DetailData.m_cXSize ||
lpTargetItem->m_DetailData.m_cYSize < lpResultItem->m_DetailData.m_cYSize)
{
ERRLOG6(g_Log, "<EFBFBD>ռ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>۽<EFBFBD><DBBD>ϴ<EFBFBD>. "
"<EFBFBD>ռ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : %d(%dx%d), <20>ռ<EFBFBD><D5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : %d(%dx%d)",
tempChemical.m_wTargetItemID, lpTargetItem->m_DetailData.m_cXSize, lpTargetItem->m_DetailData.m_cYSize,
tempChemical.m_wResultItemID, lpResultItem->m_DetailData.m_cXSize, lpResultItem->m_DetailData.m_cYSize);
return false;
}
ChemicalVector.push_back(tempChemical);
}
std::sort(ChemicalVector.begin(), ChemicalVector.end());
m_nChemicalNum = ChemicalVector.size();
m_ChemicalArray = new ChemicalInfo[m_nChemicalNum];
if (NULL == m_ChemicalArray)
{
ERRLOG0(g_Log, "<EFBFBD>޸<EFBFBD><EFBFBD><EFBFBD> <20>Ҵ翡 <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.");
return false;
}
std::copy(ChemicalVector.begin(), ChemicalVector.end(), m_ChemicalArray);
return true;
}
bool CItemMgr::LoadItemChemicalBinary(const char* szFileNameBinary)
{
HANDLE hFile = CreateFile((0 == szFileNameBinary) ? ms_szChemicalScriptFileName : szFileNameBinary,
GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) { return false; }
CEnsureCloseHandle EnsureCloseHandle(hFile);
unsigned long dwRead = 0;
unsigned long dwFileHighSize = 0;
unsigned long dwFileSize = GetFileSize(hFile, &dwFileHighSize);
char* lpAllocated = new char[dwFileSize];
CEnsureDeleteArray<char> EnsureFileInfo(lpAllocated);
if (false == ReadFile(hFile, lpAllocated, dwFileSize, &dwRead, NULL))
{
return false;
}
unsigned long dwHeaderSize = sizeof(unsigned long) + *reinterpret_cast<unsigned long *>(lpAllocated) + sizeof(unsigned long);
unsigned long dwDecompressedSize = *reinterpret_cast<unsigned long *>(lpAllocated + dwHeaderSize - sizeof(unsigned long));
DestoryChemical();
m_nChemicalNum = dwDecompressedSize / sizeof(ChemicalInfo);
m_ChemicalArray = new ChemicalInfo[m_nChemicalNum];
if (NULL == m_ChemicalArray)
{
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ҷ<EFBFBD><D2B7><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. <20>޸𸮰<DEB8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
return false;
}
DECOMPRESS(lpAllocated + dwHeaderSize, dwFileSize - dwHeaderSize,
reinterpret_cast<char *>(m_ChemicalArray), &dwDecompressedSize);
DECODE_HEADER(reinterpret_cast<char *>(m_ChemicalArray), dwDecompressedSize, 0, 2);
return true;
}
bool CItemMgr::SaveItemChemicalBinary(const char* szFileNameBinary, const char* szTrashFile)
{
HANDLE hFile = CreateFile((0 == szFileNameBinary) ? ms_szChemicalScriptFileName : szFileNameBinary,
GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) { return false; }
CEnsureCloseHandle EnsureCloseSaveHandle(hFile);
unsigned long nChemicalInfoSize = static_cast<unsigned long>(sizeof(ChemicalInfo) * m_nChemicalNum);
unsigned long nCompressedInfoSize = nChemicalInfoSize;
char* lpChemicalInfo = new char[nChemicalInfoSize];
char* lpCompressedInfo = new char[nChemicalInfoSize];
CEnsureDeleteArray<char> EnsureDeleteItemInfo(lpChemicalInfo);
CEnsureDeleteArray<char> EnsureDeleteCompressedInfo(lpCompressedInfo);
if (NULL == lpChemicalInfo || NULL == lpCompressedInfo)
{
return false;
}
memcpy(lpChemicalInfo, m_ChemicalArray, nChemicalInfoSize);
ENCODE_HEADER(lpChemicalInfo, nChemicalInfoSize, 0, 2);
COMPRESS(lpChemicalInfo, nChemicalInfoSize, lpCompressedInfo, &nCompressedInfoSize);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD>) <20>ڷ<EFBFBD>
HANDLE hTrashFile = CreateFile(szTrashFile, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hTrashFile == INVALID_HANDLE_VALUE) { return false; }
CEnsureCloseHandle EnsureCloseTrashHandle(hTrashFile);
unsigned long dwRead = 0;
unsigned long dwWritten = 0;
unsigned long dwFileHighSize = 0;
unsigned long dwTrashFileSize = GetFileSize(hTrashFile, &dwFileHighSize);
char* lpTrashFileData = new char[dwTrashFileSize];
CEnsureDeleteArray<char> EnsureDeleteTrashFile(lpTrashFileData);
if (false == ReadFile(hTrashFile, lpTrashFileData, dwTrashFileSize, &dwRead, NULL))
{
return false;
}
// Trash File<6C><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
WriteFile(hFile, &dwTrashFileSize, sizeof(unsigned long), &dwWritten, 0); // Trash <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
WriteFile(hFile, lpTrashFileData, dwTrashFileSize, &dwWritten, 0); // Trash <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// <20>ùٸ<C3B9> <20>ڷ<EFBFBD>
WriteFile(hFile, &nChemicalInfoSize, sizeof(unsigned long), &dwWritten, 0); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
WriteFile(hFile, lpCompressedInfo, nCompressedInfoSize, &dwWritten, 0); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
return true;
}
class CFindChemical : public std::unary_function<ChemicalInfo, bool>
{
public:
explicit CFindChemical(unsigned short wPickkingItemID, unsigned short wTargetItemID)
: m_wPickkingItemID(wPickkingItemID), m_wTargetItemID(wTargetItemID)
{ }
bool operator() (ChemicalInfo& chemical)
{
return (m_wPickkingItemID == chemical.m_wPickkingItemID &&
m_wTargetItemID == chemical.m_wTargetItemID);
}
private:
const unsigned short m_wPickkingItemID;
const unsigned short m_wTargetItemID;
};
unsigned char CItemMgr::GetChemicalResult(ChemicalInfo& chemical)
{
CFindChemical findChemical(chemical.m_wPickkingItemID, chemical.m_wTargetItemID);
const ChemicalInfo* lpChemicalRecipe =
std::find_if(&m_ChemicalArray[0], &m_ChemicalArray[m_nChemicalNum], findChemical);
if (&m_ChemicalArray[m_nChemicalNum] == lpChemicalRecipe)
{
return Chemical::F_WRONG_RECIPE;
}
if (lpChemicalRecipe->m_cPickkingItemNum > chemical.m_cPickkingItemNum ||
lpChemicalRecipe->m_cTargetItemNum > chemical.m_cTargetItemNum)
{
return Chemical::F_NOT_ENOUGH_ITEM;
}
if (0 != chemical.m_cTargetItemNum % lpChemicalRecipe->m_cTargetItemNum ||
0 != chemical.m_cPickkingItemNum % lpChemicalRecipe->m_cPickkingItemNum)
{
return Chemical::F_WRONG_RATE;
}
chemical.m_wResultItemID = lpChemicalRecipe->m_wResultItemID;
unsigned char cPickkingItemUse = chemical.m_cPickkingItemNum / lpChemicalRecipe->m_cPickkingItemNum;
unsigned char cTargetItemUse = chemical.m_cTargetItemNum / lpChemicalRecipe->m_cTargetItemNum;
if (cPickkingItemUse >= cTargetItemUse)
{
chemical.m_cPickkingItemNum = chemical.m_cPickkingItemNum - cTargetItemUse * lpChemicalRecipe->m_cPickkingItemNum;
chemical.m_cTargetItemNum = 0;
chemical.m_cResultItemNum = cTargetItemUse * lpChemicalRecipe->m_cResultItemNum;
}
else
{
chemical.m_cPickkingItemNum = 0;
chemical.m_cTargetItemNum = chemical.m_cTargetItemNum - cPickkingItemUse * lpChemicalRecipe->m_cTargetItemNum;
chemical.m_cResultItemNum = cPickkingItemUse * lpChemicalRecipe->m_cResultItemNum;
}
return Chemical::S_SUCCESS;
}

66
Server/ToolProject/ItemRebalanceConverter/OldItemMgr.h Normal file
View File

@@ -0,0 +1,66 @@
#ifndef _OLD_CITEM_MGR_H_
#define _OLD_CITEM_MGR_H_
#include "OldItemStructure.h"
// ----------------------------------------------------------------------------
// class : CItemMgr ( must use in single thread )
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD><C6AE> <20>ε<EFBFBD><CEB5>ϰ<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD>, <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
namespace OldItem
{
class CItemMgr
{
public:
static CItemMgr& GetInstance();
~CItemMgr();
// ----------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ (ItemScript.txt)
bool LoadItemProtoType(const char* szFileName = NULL);
bool LoadItemProtoTypeBinary(const char* szFileNameBinary = NULL);
bool SaveItemProtoTypeBinary(const char* szFileNameBinary = NULL, const char* szTrashFile = NULL);
const OldItem::ItemInfo* GetItemInfo(unsigned short usProtoTypeID);
const OldItem::ItemInfo* GetItemInfoFromItemName(const char* szItemName);
const OldItem::ItemInfo* GetItemInfoFromEquipName(const char* szEquipName);
const char* GetEquipName(const unsigned short usItemProtoTypeID);
const unsigned short GetItemIDFromSkillID(const unsigned short usSkill_ID, const unsigned short unSkill_LockCount);
// ----------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ռ<EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ (ChemicalInfo.txt)
bool LoadItemChemical(const char* szFileName = NULL);
bool LoadItemChemicalBinary(const char* szFileNameBinary = NULL);
bool SaveItemChemicalBinary(const char* szFileNameBinary = NULL, const char* szTrashFile = NULL);
unsigned char GetChemicalResult(ChemicalInfo& chemical);
private:
CItemMgr();
void DestoryItemInfo(void);
void DestoryChemical(void);
static const char* ms_szItemScriptFileName;
static const char* ms_szBGItemScriptFileName;
static const char* ms_szChemicalScriptFileName;
size_t m_nItemNum;
ItemInfo* m_ItemInfoArray;
size_t m_nChemicalNum;
ChemicalInfo* m_ChemicalArray;
};
}
#endif

109
Server/ToolProject/ItemRebalanceConverter/OldItemStruct.h Normal file
View File

@@ -0,0 +1,109 @@
#ifndef _OLD_ITEM_STRUCTS_H_
#define _OLD_ITEM_STRUCTS_H_
namespace OldItem
{
#pragma pack(1)
struct ItemPos
{
unsigned short m_cPos : 4; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (Equip, Inven...) (0~15)
unsigned short m_cIndex : 12; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> (0~4095)
ItemPos() : m_cPos(0), m_cIndex(0) { }
ItemPos(unsigned char cPos, unsigned short usIndex) : m_cPos(cPos), m_cIndex(usIndex) { }
inline void SetPos(unsigned short wIndex) { m_cIndex = wIndex; }
inline void SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex);
inline void GetPos(unsigned char& cXIndex, unsigned char& cYIndex, unsigned char& cZIndex) const;
inline unsigned char GetXIndex(void) const { return (m_cIndex & 0x00F); }
inline unsigned char GetYIndex(void) const { return (m_cIndex & 0x0F0) >> 4; }
inline unsigned char GetZIndex(void) const { return (m_cIndex & 0xF00) >> 8; }
inline void SetXIndex(unsigned char cXIndex) { m_cIndex = (m_cIndex & 0xFF0) + cXIndex; }
inline void SetYIndex(unsigned char cYIndex) { m_cIndex = (m_cIndex & 0xF0F) + (cYIndex << 4); }
inline void SetZIndex(unsigned char cZIndex) { m_cIndex = (m_cIndex & 0x0FF) + (cZIndex << 8); }
inline bool operator == (const ItemPos& rhs) const { return (m_cPos == rhs.m_cPos && m_cIndex == rhs.m_cIndex); }
};
inline void ItemPos::SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex)
{
m_cIndex = (cZIndex << 8) + (cYIndex << 4) + cXIndex;
}
inline void ItemPos::GetPos(unsigned char& cXIndex, unsigned char& cYIndex, unsigned char& cZIndex) const
{
cXIndex = (m_cIndex & 0x00F);
cYIndex = (m_cIndex & 0x0F0) >> 4;
cZIndex = (m_cIndex & 0xF00) >> 8;
}
struct ItemData
{
unsigned __int64 m_dwUID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> UID
unsigned short m_usProtoTypeID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
ItemPos m_ItemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
unsigned char m_cItemSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü ũ<><C5A9>.
unsigned char m_cNumOrDurability; // <20><><EFBFBD><EFBFBD> Ȥ<><C8A4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
ItemData() { m_dwUID = m_usProtoTypeID = m_cNumOrDurability = 0; m_cItemSize = sizeof(ItemData); }
void DumpInfo(unsigned long dwCID, const char* szExtraString) const;
};
struct ItemAttribute
{
unsigned short m_cType : 6; // <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD> 6bit (64<36><34><EFBFBD><EFBFBD>)
short m_usValue : 10; // <20>Ӽ<EFBFBD> <20><> 10bit (-512~511<31><31><EFBFBD><EFBFBD>)
ItemAttribute() : m_cType(0), m_usValue(0) { }
ItemAttribute(unsigned char cType, unsigned short usValue) : m_cType(cType), m_usValue(usValue) { }
};
// <20>ڿ<EFBFBD> Socket<65><74><EFBFBD>빰<EFBFBD><EBB9B0> m_cSocketNum<75><6D>ŭ, Attribute<74><65> m_cDiffAttributeNum<75><6D>ŭ <20>ٴ´<D9B4>.
struct EquipmentInfo
{
enum
{
MAX_UPGRADE_LEVEL = 15, // <20>ִ<EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD> <20><><EFBFBD><EFBFBD> - 15
MAX_UPGRADE_SOCKET_ONLY = 5, // <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD><CCB5>Ҷ<EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>
MAX_UPGRADE_ATTRIBUTE = 2, // <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD><CCB5><EFBFBD> <20><><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
MAX_MINSIZE_SOCKET_NUM = 6, // ũ<>Ⱑ 1by1<79><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
MAX_MINSIZE_ATTRIBUTE_NUM = 6, // ũ<>Ⱑ 1by1<79><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
MAX_SOCKET_NUM = 8, // <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
MAX_SOCKET_ATTRIBUTE_NUM = 16, // <20><><EFBFBD><EFBFBD> <20>ϳ<EFBFBD><CFB3><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> <20>ΰ<EFBFBD><CEB0><EFBFBD><EFBFBD><EFBFBD> <20>޸<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>.
MAX_ATTRIBUTE_NUM = 12, // <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
MAX_SOCKET_AND_ATTRIBUTE_MINISIZE = (MAX_MINSIZE_SOCKET_NUM * sizeof(char) + MAX_MINSIZE_ATTRIBUTE_NUM * sizeof(ItemAttribute)),
MAX_SOCKET_AND_ATTRIBUTE_SIZE = (MAX_SOCKET_NUM * sizeof(char) + MAX_ATTRIBUTE_NUM * sizeof(ItemAttribute))
};
unsigned short m_cRuneSocket : 11; // <20><> <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
short m_cDiffMaterialType : 5; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + m_cDiffMaterialType = <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>(-16~15)
char m_cDiffMaxSocket : 5; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> + m_cDiffMaxSocket = <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> (-16~15)
unsigned char m_cReserved : 3; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
unsigned char m_cSocketNum : 4; // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> (0~15)
unsigned char m_cAttributeNum : 4; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD> <20><><EFBFBD>ų<EFBFBD>, <20><>ġ<EFBFBD><C4A1> <20>ٸ<EFBFBD> <20>Ӽ<EFBFBD> <20><>(0~15<31><35>)
char m_cDiffMaxDurability; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>۰<EFBFBD><DBB0><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
unsigned char m_cReserved2; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
EquipmentInfo()
{
m_cRuneSocket = m_cDiffMaterialType = m_cDiffMaxSocket = m_cDiffMaxDurability =
m_cSocketNum = m_cAttributeNum = m_cReserved = m_cReserved2 = 0;
}
};
#pragma pack()
};
#endif

130
Server/ToolProject/ItemRebalanceConverter/OldItemStructure.cpp Normal file
View File

@@ -0,0 +1,130 @@
#include "stdafx.h"
#include <Utility/Math/Math.h>
#include <Log/ServerLog.h>
#include <algorithm>
#include "OldItemStructure.h"
using namespace OldItem;
void OldItem::ItemData::DumpInfo(unsigned long dwCID, const char* szExtraString) const
{
const int MIN_BUFFER = 32;
char szItemUID[MIN_BUFFER];
Math::Convert::Hex64ToStr(szItemUID, m_dwUID);
ERRLOG8(g_Log, "CID:0x%08x / ItemUID:%s / ProtoTypeID:%d / ItemPos(%d, 0x%04x) / ItemSize:%d / NumOrDurability:%d %s",
dwCID, szItemUID, m_usProtoTypeID, m_ItemPos.m_cPos, m_ItemPos.m_cIndex,
m_cItemSize, m_cNumOrDurability, szExtraString);
}
OldItem::SpriteData::SpriteData() { Initialize(); }
void OldItem::SpriteData::Initialize()
{
memset(m_szName, 0, MAX_NAME);
memset(m_szSpriteName, 0, MAX_SPRITE_NAME);
m_nSpriteMinX = m_nSpriteMinY = m_nSpriteMaxX = m_nSpriteMaxY = 0;
}
OldItem::StringData::StringData() { Initialize(); }
void OldItem::StringData::Initialize()
{
memset(m_szFieldModelName, 0, MAX_FIELD_MODEL_NAME);
memset(m_szEquipModelName, 0, MAX_EQUIP_MODEL_NAME);
memset(m_szEffectSoundName, 0, MAX_EFFECT_SOUND_NAME);
memset(m_szTypeName, 0, MAX_TYPE_NAME);
memset(m_szItemDescribe, 0, MAX_ITEM_DESCRIBE);
}
OldItem::DetailData::DetailData() { Initialize(); }
void OldItem::DetailData::Initialize()
{
m_ItemGrade = OldItem::Grade::ETC;
m_dwFlags = m_dwPrice = m_dwBlackPrice = m_dwMedalPrice = m_dwCraftExp = 0;
m_cOptionLimit = m_cItemType = m_cXSize = m_cYSize =
m_cDefaultDurabilityOrStack = m_cMaxDurabilityOrStack = m_cMaterialType = m_cMaxSocketNum = 0;
}
OldItem::EquipAttribute::EquipAttribute() { Initialize(); }
void OldItem::EquipAttribute::Initialize()
{
m_nAttibuteNum = 0;
std::fill_n(m_usAttributeValue, unsigned short(OldItem::Attribute::MAX_ATTRIBUTE_NUM), 0);
}
OldItem::UseItemInfo::UseItemInfo() { Initialize(); }
void OldItem::UseItemInfo::Initialize()
{
m_usSkill_ID = 0;
m_usSkill_LockCount = 0;
m_cZone = 0;
m_dwAmount = 0;
}
OldItem::UseLimit::UseLimit() { Initialize(); }
void OldItem::UseLimit::Initialize()
{
std::fill_n(m_nStatusLimit, unsigned short(StatusLimit::MAX_STATUS_LIMIT), 0);
m_dwClassLimit = m_nSkillType = m_cSkillLevel = m_cLevelLimit = 0;
}
OldItem::ItemInfo::ItemInfo() { Initialize(); }
OldItem::ItemInfo::ItemInfo(unsigned short usProtoTypeID) { Initialize(); m_usProtoTypeID = usProtoTypeID; }
void OldItem::ItemInfo::Initialize()
{
m_usProtoTypeID = 0;
m_DetailData.Initialize();
m_UseLimit.Initialize();
m_SpriteData.Initialize();
m_StringData.Initialize();
m_EquipAttribute.Initialize();
m_UseItemInfo.Initialize();
}
/*
const char* OldItem::ItemInfo::GetItemDescribe(void) const
{
if (OldItem::ItemType::SKILLBOOK == m_DetailData.m_cItemType)
{
const Skill::ProtoType* pSkillProtoType = CSkillMgr::GetInstance().GetSkillProtoType(m_UseItemInfo.m_usSkill_ID);
if (NULL != pSkillProtoType)
{
return pSkillProtoType[m_UseItemInfo.m_usSkill_LockCount].m_szSkillDescribe;
}
}
return m_StringData.m_szItemDescribe;
}
*/
OldItem::ItemGarbage::ItemGarbage(CItem* lpItem, unsigned long dwRemainNum)
: m_lpItem(lpItem), m_dwRemainNum(dwRemainNum)
{
}
OldItem::ChemicalInfo::ChemicalInfo()
: m_wPickkingItemID(0), m_wTargetItemID(0), m_wResultItemID(0),
m_cPickkingItemNum(0), m_cTargetItemNum(0), m_cResultItemNum(0)
{
}
OldItem::ChemicalInfo::ChemicalInfo(unsigned short wPickkingItemID, unsigned char cPickkingItemNum,
unsigned short wTargetItemID, unsigned char cTargetItemNum)
: m_wPickkingItemID(wPickkingItemID), m_wTargetItemID(wTargetItemID), m_wResultItemID(0),
m_cPickkingItemNum(cPickkingItemNum),m_cTargetItemNum(cTargetItemNum), m_cResultItemNum(0)
{
}

303
Server/ToolProject/ItemRebalanceConverter/OldItemStructure.h Normal file
View File

@@ -0,0 +1,303 @@
#ifndef _OLD_ITEM_STRUCTURE_H_
#define _OLD_ITEM_STRUCTURE_H_
#include <Creature/CreatureStructure.h>
#include "OldItemConstants.h"
namespace OldItem
{
class CItem;
#pragma pack(1)
// ------------------------------------------------------------------------------------------
// UseLimit, ItemInfo <20><> <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20>ִ´<D6B4>.
struct ItemPos
{
unsigned short m_cPos : 4; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (Equip, Inven...) (0~15)
unsigned short m_cIndex : 12; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> (0~4095)
ItemPos() : m_cPos(0), m_cIndex(0) { }
ItemPos(unsigned char cPos, unsigned short usIndex) : m_cPos(cPos), m_cIndex(usIndex) { }
inline void SetPos(unsigned short wIndex) { m_cIndex = wIndex; }
inline void SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex);
inline void GetPos(unsigned char& cXIndex, unsigned char& cYIndex, unsigned char& cZIndex) const;
inline unsigned char GetXIndex(void) const { return (m_cIndex & 0x00F); }
inline unsigned char GetYIndex(void) const { return (m_cIndex & 0x0F0) >> 4; }
inline unsigned char GetZIndex(void) const { return (m_cIndex & 0xF00) >> 8; }
inline void SetXIndex(unsigned char cXIndex) { m_cIndex = (m_cIndex & 0xFF0) + cXIndex; }
inline void SetYIndex(unsigned char cYIndex) { m_cIndex = (m_cIndex & 0xF0F) + (cYIndex << 4); }
inline void SetZIndex(unsigned char cZIndex) { m_cIndex = (m_cIndex & 0x0FF) + (cZIndex << 8); }
inline bool operator == (const ItemPos& rhs) const { return (m_cPos == rhs.m_cPos && m_cIndex == rhs.m_cIndex); }
};
inline void ItemPos::SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex)
{
m_cIndex = (cZIndex << 8) + (cYIndex << 4) + cXIndex;
}
inline void ItemPos::GetPos(unsigned char& cXIndex, unsigned char& cYIndex, unsigned char& cZIndex) const
{
cXIndex = (m_cIndex & 0x00F);
cYIndex = (m_cIndex & 0x0F0) >> 4;
cZIndex = (m_cIndex & 0xF00) >> 8;
}
struct ItemData
{
unsigned __int64 m_dwUID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> UID
unsigned short m_usProtoTypeID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
ItemPos m_ItemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
unsigned char m_cItemSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü ũ<><C5A9>.
unsigned char m_cNumOrDurability; // <20><><EFBFBD><EFBFBD> Ȥ<><C8A4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
ItemData() { m_dwUID = m_usProtoTypeID = m_cNumOrDurability = 0; m_cItemSize = sizeof(ItemData); }
void DumpInfo(unsigned long dwCID, const char* szExtraString) const;
};
struct ItemAttribute
{
unsigned short m_cType : 6; // <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD> 6bit (64<36><34><EFBFBD><EFBFBD>)
short m_usValue : 10; // <20>Ӽ<EFBFBD> <20><> 10bit (-512~511<31><31><EFBFBD><EFBFBD>)
ItemAttribute() : m_cType(0), m_usValue(0) { }
ItemAttribute(unsigned char cType, unsigned short usValue) : m_cType(cType), m_usValue(usValue) { }
};
// <20>ڿ<EFBFBD> Socket<65><74><EFBFBD>빰<EFBFBD><EBB9B0> m_cSocketNum<75><6D>ŭ, Attribute<74><65> m_cDiffAttributeNum<75><6D>ŭ <20>ٴ´<D9B4>.
struct EquipmentInfo
{
enum
{
MAX_UPGRADE_LEVEL = 15, // <20>ִ<EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD> <20><><EFBFBD><EFBFBD> - 15
MAX_UPGRADE_SOCKET_ONLY = 5, // <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD><CCB5>Ҷ<EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>
MAX_UPGRADE_ATTRIBUTE = 2, // <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD><CCB5><EFBFBD> <20><><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
MAX_MINSIZE_SOCKET_NUM = 6, // ũ<>Ⱑ 1by1<79><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
MAX_MINSIZE_ATTRIBUTE_NUM = 6, // ũ<>Ⱑ 1by1<79><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
MAX_SOCKET_NUM = 8, // <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
MAX_SOCKET_ATTRIBUTE_NUM = 16, // <20><><EFBFBD><EFBFBD> <20>ϳ<EFBFBD><CFB3><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> <20>ΰ<EFBFBD><CEB0><EFBFBD><EFBFBD><EFBFBD> <20>޸<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>.
MAX_ATTRIBUTE_NUM = 12, // <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
MAX_SOCKET_AND_ATTRIBUTE_MINISIZE = (MAX_MINSIZE_SOCKET_NUM * sizeof(char) + MAX_MINSIZE_ATTRIBUTE_NUM * sizeof(ItemAttribute)),
MAX_SOCKET_AND_ATTRIBUTE_SIZE = (MAX_SOCKET_NUM * sizeof(char) + MAX_ATTRIBUTE_NUM * sizeof(ItemAttribute))
};
unsigned short m_cRuneSocket : 11; // <20><> <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
short m_cDiffMaterialType : 5; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + m_cDiffMaterialType = <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>(-16~15)
char m_cDiffMaxSocket : 5; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> + m_cDiffMaxSocket = <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> (-16~15)
unsigned char m_cReserved : 3; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
unsigned char m_cSocketNum : 4; // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> (0~15)
unsigned char m_cAttributeNum : 4; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD> <20><><EFBFBD>ų<EFBFBD>, <20><>ġ<EFBFBD><C4A1> <20>ٸ<EFBFBD> <20>Ӽ<EFBFBD> <20><>(0~15<31><35>)
char m_cDiffMaxDurability; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>۰<EFBFBD><DBB0><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
unsigned char m_cReserved2; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
EquipmentInfo()
{
m_cRuneSocket = m_cDiffMaterialType = m_cDiffMaxSocket = m_cDiffMaxDurability =
m_cSocketNum = m_cAttributeNum = m_cReserved = m_cReserved2 = 0;
}
};
#pragma pack()
const unsigned char MAX_ITEM_SIZE = sizeof(ItemData) +
sizeof(EquipmentInfo) + EquipmentInfo::MAX_SOCKET_AND_ATTRIBUTE_SIZE;
struct SpriteData
{
enum { MAX_NAME = 64, MAX_SPRITE_NAME = 32 };
char m_szName[MAX_NAME];
char m_szSpriteName[MAX_SPRITE_NAME];
unsigned short m_nSpriteMinX;
unsigned short m_nSpriteMinY;
unsigned short m_nSpriteMaxX;
unsigned short m_nSpriteMaxY;
SpriteData();
void Initialize();
};
struct StringData
{
enum
{
MAX_FIELD_MODEL_NAME = 32, MAX_EQUIP_MODEL_NAME = 32,
MAX_EFFECT_SOUND_NAME = 32, MAX_TYPE_NAME = 32,
MAX_ITEM_DESCRIBE = 256
};
char m_szFieldModelName[MAX_FIELD_MODEL_NAME];
char m_szEquipModelName[MAX_EQUIP_MODEL_NAME];
char m_szEffectSoundName[MAX_EFFECT_SOUND_NAME];
char m_szTypeName[MAX_TYPE_NAME];
char m_szItemDescribe[MAX_ITEM_DESCRIBE];
StringData();
void Initialize();
};
struct DetailData
{
enum Flags
{
EQUIP = ( 1 << 0), // <20><><EFBFBD><EFBFBD><EFBFBD>Ҽ<EFBFBD> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
USE_ITEM = ( 1 << 1), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
QUICKSLOT_IN = ( 1 << 2), // <20><><EFBFBD><EFBFBD><EFBFBD>Կ<EFBFBD> <20><><EFBFBD><20><> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
STACKABLE = ( 1 << 3), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
TWOHANDED = ( 1 << 4), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
WEAPON = ( 1 << 5), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
ARMOUR = ( 1 << 6), // <20><><EFBFBD>ʷ<EFBFBD><CAB7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SKILL_ARM = ( 1 << 7), // <20><>ų<EFBFBD><C5B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
unsigned char m_cItemType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>( namespace Type <20><><EFBFBD><EFBFBD> )
unsigned char m_cXSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Xũ<58><C5A9>
unsigned char m_cYSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Yũ<59><C5A9>
unsigned char m_cOptionLimit;
unsigned char m_cDefaultDurabilityOrStack;
unsigned char m_cMaxDurabilityOrStack;
unsigned char m_cMaterialType;
unsigned char m_cMaxSocketNum;
unsigned long m_dwCraftExp;
Grade::Type m_ItemGrade;
unsigned long m_dwPrice;
unsigned long m_dwBlackPrice;
unsigned long m_dwMedalPrice;
unsigned long m_dwFlags;
DetailData();
void Initialize();
};
struct EquipAttribute
{
unsigned short m_usAttributeValue[OldItem::Attribute::MAX_ATTRIBUTE_NUM];
unsigned short m_nAttibuteNum;
EquipAttribute();
void Initialize();
};
struct UseItemInfo
{
unsigned short m_usSkill_ID;
unsigned short m_usSkill_LockCount;
unsigned char m_cZone;
Position m_Pos;
unsigned long m_dwAmount;
UseItemInfo();
void Initialize();
};
struct UseLimit
{
enum DeactivatedType
{
STATUS_LIMIT = ( 1 << 0),
CLASS_LIMIT = ( 1 << 1),
BROKEN_ITEM = ( 1 << 2)
};
unsigned short m_nStatusLimit[StatusLimit::MAX_STATUS_LIMIT];
unsigned short m_nSkillType; // <20><>ų <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
unsigned char m_cSkillLevel; // <20><>ų <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned char m_cLevelLimit;
unsigned long m_dwClassLimit;
UseLimit();
void Initialize();
};
#pragma pack(8)
struct ItemInfo
{
unsigned short m_usProtoTypeID;
DetailData m_DetailData;
UseLimit m_UseLimit;
SpriteData m_SpriteData;
StringData m_StringData;
EquipAttribute m_EquipAttribute;
UseItemInfo m_UseItemInfo;
ItemInfo();
ItemInfo(unsigned short usPrototypeID);
void Initialize();
inline bool operator < (ItemInfo& rhs)
{
return (m_usProtoTypeID < rhs.m_usProtoTypeID);
}
// const char* GetItemDescribe(void) const;
};
#pragma pack()
struct ItemGarbage
{
CItem* m_lpItem;
unsigned long m_dwRemainNum;
ItemGarbage(CItem* lpItem, unsigned long dwRemainNum);
};
struct ChemicalInfo
{
unsigned short m_wPickkingItemID;
unsigned short m_wTargetItemID;
unsigned short m_wResultItemID;
unsigned char m_cPickkingItemNum;
unsigned char m_cTargetItemNum;
unsigned char m_cResultItemNum;
ChemicalInfo();
ChemicalInfo(unsigned short wPickkingItemID, unsigned char cPickkingItemNum,
unsigned short wTargetItemID, unsigned char cTargetItemNum);
bool operator < (const ChemicalInfo& rhs)
{
if (m_wPickkingItemID == rhs.m_wPickkingItemID)
{
return m_wTargetItemID < rhs.m_wTargetItemID;
}
return m_wPickkingItemID < rhs.m_wPickkingItemID;
}
bool operator == (const ChemicalInfo& rhs)
{
return (m_wPickkingItemID == rhs.m_wPickkingItemID && m_wTargetItemID == rhs.m_wTargetItemID &&
m_cPickkingItemNum == rhs.m_cPickkingItemNum && m_cTargetItemNum == rhs.m_cTargetItemNum);
}
};
}
#endif

32
Server/ToolProject/ItemRebalanceConverter/ReadMe.txt Normal file
View File

@@ -0,0 +1,32 @@
========================================================================
<20>ܼ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> : ItemRebalanceConverter <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
========================================================================
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><> ItemRebalanceConverter <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.
<EFBFBD><EFBFBD> <20><><EFBFBD>Ͽ<EFBFBD><CFBF><EFBFBD> ItemRebalanceConverter <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>Ͽ<EFBFBD>
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ԵǾ<D4B5> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
ItemRebalanceConverter.vcproj
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>縦 <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VC++ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>⺻ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
<20>ش<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Visual C++<2B><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD>
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><>
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ɿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
ItemRebalanceConverter.cpp
<20>⺻ <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
/////////////////////////////////////////////////////////////////////////////
<EFBFBD><EFBFBD>Ÿ ǥ<><C7A5> <20><><EFBFBD><EFBFBD>:
StdAfx.h <20><> StdAfx.cpp<70><70>
ItemRebalanceConverter.pch<63><68><EFBFBD><EFBFBD> <20≯<EFBFBD><CCB8><EFBFBD> PCH(<28≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD>) <20><><EFBFBD>ϰ<EFBFBD>
StdAfx.obj<62><6A><EFBFBD><EFBFBD> <20≯<EFBFBD><CCB8><EFBFBD> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>˴ϴ<CBB4>.
/////////////////////////////////////////////////////////////////////////////
<EFBFBD><EFBFBD>Ÿ <20><><EFBFBD><EFBFBD>:
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> "TODO:" <20>ּ<EFBFBD><D6BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ڰ<EFBFBD> <20>߰<EFBFBD><DFB0>ϰų<CFB0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD> <20>ϴ<EFBFBD>
<EFBFBD>ҽ<EFBFBD> <20>ڵ<EFBFBD> <20>κ<EFBFBD><CEBA><EFBFBD> <20><>Ÿ<EFBFBD><C5B8><EFBFBD>ϴ<EFBFBD>.
/////////////////////////////////////////////////////////////////////////////

8
Server/ToolProject/ItemRebalanceConverter/stdafx.cpp Normal file
View File

@@ -0,0 +1,8 @@
// stdafx.cpp : ǥ<><C7A5> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
// ItemRebalanceConverter.pch<63><68> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˴ϴ<CBB4>.
// stdafx.obj<62><6A><EFBFBD><EFBFBD> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>Ե˴ϴ<CBB4>.
#include "stdafx.h"
// TODO: <20>ʿ<EFBFBD><CABF><EFBFBD> <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> STDAFX.H<><48><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.

12
Server/ToolProject/ItemRebalanceConverter/stdafx.h Normal file
View File

@@ -0,0 +1,12 @@
// stdafx.h : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD>
// ǥ<><C7A5> <20>ý<EFBFBD><C3BD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
//
#pragma once
#include <iostream>
#include <tchar.h>
// TODO: <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD> <20>ʿ<EFBFBD><CABF><EFBFBD> <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>⿡<EFBFBD><E2BFA1> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.