Aller au contenu
Top-Metin2.org - Vous êtes à la recherche d'un serveur Metin 2 ? ×
×
×
  • Créer...

Correctifs Divers


Messages recommandés

  • Robot

[FIX] Deux personnes achètent le même article en même temps (le client plante)

  Pokaż ukrytą zawartość
Cherechez dans : /game/src/shop.cpp
 	if (IsPCShop())
	{
		if (!pkSelectedItem)
		{
			sys_log(0, "Shop::Buy : Critical: This user seems to be a hacker : invalid pcshop item : BuyerPID:%d SellerPID:%d",
					ch->GetPlayerID(),
					m_pkPC->GetPlayerID());

			return false;
		}

		if ((pkSelectedItem->GetOwner() != m_pkPC))
		{
			sys_log(0, "Shop::Buy : Critical: This user seems to be a hacker : invalid pcshop item : BuyerPID:%d SellerPID:%d",
					ch->GetPlayerID(),
					m_pkPC->GetPlayerID());

			return false;
		}
	}


Changez pour :


	if (IsPCShop())
	{
		if (!pkSelectedItem)
		{
			sys_log(0, "Shop::Buy : Critical: This user seems to be a hacker : invalid pcshop item : BuyerPID:%d SellerPID:%d",
					ch->GetPlayerID(),
					m_pkPC->GetPlayerID());

			return SHOP_SUBHEADER_GC_SOLD_OUT;
		}

		if (pkSelectedItem->GetOwner() != m_pkPC)
		{
			sys_log(0, "Shop::Buy : Critical: This user seems to be a hacker : invalid pcshop item : BuyerPID:%d SellerPID:%d",
					ch->GetPlayerID(),
					m_pkPC->GetPlayerID());

			return SHOP_SUBHEADER_GC_SOLD_OUT;
		}
	}
 

 

[FIX] Détruire le serveur avec des objets (ajouté à la guilde)

  Ukryj zawartość

 

Cherchez dans : /game/src/input_main.cpp
		case GUILD_SUBHEADER_CG_ADD_MEMBER:
			{
				const DWORD vid = *reinterpret_cast<const DWORD*>(c_pData);
				LPCHARACTER newmember = CHARACTER_MANAGER::instance().Find(vid);

				if (!newmember)
				{
					ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<±ćµĺ> ±×·ŻÇŃ »ç¶÷Ŕ» ĂŁŔ» Ľö ľř˝Ŕ´Ď´Ů."));
					return SubPacketLen;
				}

				if (!ch->IsPC())
					return SubPacketLen;

				if (LC_IsCanada() == true)
				{
					if (newmember->GetQuestFlag("change_guild_master.be_other_member") > get_global_time())
					{
						ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<±ćµĺ> ľĆÁ÷ °ˇŔÔÇŇ Ľö ľř´Â Äł¸ŻĹÍŔÔ´Ď´Ů"));
						return SubPacketLen;
					}
				}

				pGuild->Invite(ch, newmember);
			}
			return SubPacketLen;
Changer comme ceci :

		case GUILD_SUBHEADER_CG_ADD_MEMBER:
			{
				const DWORD vid = *reinterpret_cast<const DWORD*>(c_pData);
				LPCHARACTER newmember = CHARACTER_MANAGER::instance().Find(vid);

				if (!newmember)
				{
					ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<±ćµĺ> ±×·ŻÇŃ »ç¶÷Ŕ» ĂŁŔ» Ľö ľř˝Ŕ´Ď´Ů."));
					return SubPacketLen;
				}

				if (!ch->IsPC() || !newmember->IsPC())
					return SubPacketLen;

				pGuild->Invite(ch, newmember);
			}
			return SubPacketLen;

 

 

[FIX] Lancer des yangs (chargement au point où le canal plante)

  Ukryj zawartość

 


Cherchez dans : /game/src/char_item.cpp

		

bool CHARACTER::DropGold(int gold)
		{
		    if (gold <= 0 || gold > GetGold())
		        return false;		

    if (!CanHandleItem())
		        return false;		

    if (0 != g_GoldDropTimeLimitValue)
		    {
		        if (get_dword_time() < m_dwLastGoldDropTime+g_GoldDropTimeLimitValue)
		        {
		            ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ °ńµĺ¸¦ ąö¸± Ľö ľř˝Ŕ´Ď´Ů."));
		            return false;
		        }
		    }		

    m_dwLastGoldDropTime = get_dword_time();		

    LPITEM item = ITEM_MANAGER::instance().CreateItem(1, gold);		

    if (item)
		    {
		        PIXEL_POSITION pos = GetXYZ();		

        if (item->AddToGround(GetMapIndex(), pos))
		        {
		            //Motion(MOTION_PICKUP);
		            PointChange(POINT_GOLD, -gold, true);		

            // şę¶óÁúżˇ µ·ŔĚ ľřľîÁř´Ů´Â ąö±×°ˇ ŔִµĄ,
		            // °ˇ´ÉÇŃ ˝ĂłŞ¸®żŔ Áßżˇ ÇĎłŞ´Â,
		            // ¸ŢĹ©·ÎłŞ, ÇŮŔ» ˝áĽ­ 1000żř ŔĚÇĎŔÇ µ·Ŕ» °čĽÓ ąö·Á °ńµĺ¸¦ 0Ŕ¸·Î ¸¸µé°í, 
		            // µ·ŔĚ ľřľîÁł´Ů°í şą±¸ ˝ĹĂ»ÇĎ´Â °ÍŔĎ Ľöµµ ŔÖ´Ů.
		            // µű¶óĽ­ ±×·± °ćżě¸¦ Ŕâ±â Ŕ§ÇŘ ł·Ŕş ĽöġŔÇ °ńµĺżˇ ´ëÇŘĽ­µµ ·Î±×¸¦ ł˛±č.
		            if (LC_IsBrazil() == true)
		            {
		                if (gold >= 213)
		                    LogManager::instance().CharLog(this, gold, "DROP_GOLD", "");
		            }
		            else
		            {
		                if (gold > 1000) // õżř ŔĚ»ó¸¸ ±â·ĎÇŃ´Ů.
		                    LogManager::instance().CharLog(this, gold, "DROP_GOLD", "");
		            }		

            if (false == LC_IsBrazil())
		            {
		                item->StartDestroyEvent(150);
		                ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¶łľîÁř ľĆŔĚĹŰŔş %dşĐ ČÄ »ç¶óÁý´Ď´Ů."), 150/60);
		            }
		            else
		            {
		                item->StartDestroyEvent(60);
		                ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¶łľîÁř ľĆŔĚĹŰŔş %dşĐ ČÄ »ç¶óÁý´Ď´Ů."), 1);
		            }
		        }		

        Save();
		        return true;
		    }		

    return false;
		}		

 

Changez pour :
 

		

		bool CHARACTER::DropGold(int gold) 
		{ 
		    return false;
		}		

 

 

[FIX] Extension du deuxième personnage à distance (réception d'expérience malgré deux emplacements différents) 

  Pokaż ukrytą zawartość

 


Cherchez dans : /game/src/char_battle.cpp

		

		if (!pAttacker || pAttacker->IsNPC() || DISTANCE_APPROX(GetX()-pAttacker->GetX(), GetY()-pAttacker->GetY())>5000)
		    continue;		

Modifiez :

		

		if (!pAttacker || pAttacker->IsNPC() || DISTANCE_APPROX(GetX()-pAttacker->GetX(), GetY()-pAttacker->GetY()) > 10000 || (DISTANCE_APPROX(GetX()-pAttacker->GetX(), GetY()-pAttacker->GetY()) > 5000 && !pAttacker->GetParty())) 
		    continue;

 

 

[FIX] Lame enchantée

  Pokaż ukrytą zawartość

 


Cherchez dans : /game/src/char_battle.cpp

		

		if (pAttacker->GetPoint(POINT_HIT_HP_RECOVERY) && number(0, 4) > 0) // 80% Č®·ü 
		{ 
		    int i = MIN(dam, iCurHP) * pAttacker->GetPoint(POINT_HIT_HP_RECOVERY) / 100; 		

		    if (i) 
		    { 
		        CreateFly(FLY_HP_SMALL, pAttacker); 
		        pAttacker->PointChange(POINT_HP, i); 
		    }
		}		

 

 

 

Changer comme ceci :

		

if (pAttacker->GetPoint(POINT_HIT_HP_RECOVERY) && number(0, 4) > 0) // 80% Č®·ü 
		{ 
		    int i = MIN(dam, iCurHP) * pAttacker->GetPoint(POINT_HIT_HP_RECOVERY) / 100;		

    if (i && i > 0) 
		    { 
		        CreateFly(FLY_HP_SMALL, pAttacker);
		        pAttacker->PointChange(POINT_HP, i);
		    }
		}		

 

 

[FIX] Probable hp / sp jump fix (par exemple lors de l'utilisation de sarah ou de la couverture) Gné ?

  Pokaż ukrytą zawartość

 


Cherchez dans  /game/src/char.cpp

		void CHARACTER::ComputePoints()
		{
		    long lStat = GetPoint(POINT_STAT);
		    long lStatResetCount = GetPoint(POINT_STAT_RESET_COUNT);
		    long lSkillActive = GetPoint(POINT_SKILL);
		    long lSkillSub = GetPoint(POINT_SUB_SKILL);
		    long lSkillHorse = GetPoint(POINT_HORSE_SKILL);
		    long lLevelStep = GetPoint(POINT_LEVEL_STEP);		

		    long lAttackerBonus = GetPoint(POINT_PARTY_ATTACKER_BONUS);
		    long lTankerBonus = GetPoint(POINT_PARTY_TANKER_BONUS);
		    long lBufferBonus = GetPoint(POINT_PARTY_BUFFER_BONUS);
		    long lSkillMasterBonus = GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);
		    long lHasteBonus = GetPoint(POINT_PARTY_HASTE_BONUS);
		    long lDefenderBonus = GetPoint(POINT_PARTY_DEFENDER_BONUS);		

		    long lHPRecovery = GetPoint(POINT_HP_RECOVERY);
		    long lSPRecovery = GetPoint(POINT_SP_RECOVERY);		

		    memset(m_pointsInstant.points, 0, sizeof(m_pointsInstant.points));
		    BuffOnAttr_ClearAll();
		    m_SkillDamageBonus.clear();		

		    SetPoint(POINT_STAT, lStat);
		    SetPoint(POINT_SKILL, lSkillActive);
		    SetPoint(POINT_SUB_SKILL, lSkillSub);
		    SetPoint(POINT_HORSE_SKILL, lSkillHorse);
		    SetPoint(POINT_LEVEL_STEP, lLevelStep);
		    SetPoint(POINT_STAT_RESET_COUNT, lStatResetCount);		

		    SetPoint(POINT_ST, GetRealPoint(POINT_ST));
		    SetPoint(POINT_HT, GetRealPoint(POINT_HT));
		    SetPoint(POINT_DX, GetRealPoint(POINT_DX));
		    SetPoint(POINT_IQ, GetRealPoint(POINT_IQ));		

		    SetPart(PART_MAIN, GetOriginalPart(PART_MAIN));
		    SetPart(PART_WEAPON, GetOriginalPart(PART_WEAPON));
		    SetPart(PART_HEAD, GetOriginalPart(PART_HEAD));
		    SetPart(PART_HAIR, GetOriginalPart(PART_HAIR));		

		    SetPoint(POINT_PARTY_ATTACKER_BONUS, lAttackerBonus);
		    SetPoint(POINT_PARTY_TANKER_BONUS, lTankerBonus);
		    SetPoint(POINT_PARTY_BUFFER_BONUS, lBufferBonus);
		    SetPoint(POINT_PARTY_SKILL_MASTER_BONUS, lSkillMasterBonus);
		    SetPoint(POINT_PARTY_HASTE_BONUS, lHasteBonus);
		    SetPoint(POINT_PARTY_DEFENDER_BONUS, lDefenderBonus);		

		    SetPoint(POINT_HP_RECOVERY, lHPRecovery);
		    SetPoint(POINT_SP_RECOVERY, lSPRecovery);		

		    // PC_BANG_ITEM_ADD
		    SetPoint(POINT_PC_BANG_EXP_BONUS, 0);
		    SetPoint(POINT_PC_BANG_DROP_BONUS, 0);
		    // END_PC_BANG_ITEM_ADD		

		    int iMaxHP, iMaxSP;
		    int iMaxStamina;		

		    if (IsPC())
		    {
		        // ĂÖ´ë »ý¸í·Â/Á¤˝Ĺ·Â
		        iMaxHP = JobInitialPoints[GetJob()].max_hp + m_points.iRandomHP + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].hp_per_ht;
		        iMaxSP = JobInitialPoints[GetJob()].max_sp + m_points.iRandomSP + GetPoint(POINT_IQ) * JobInitialPoints[GetJob()].sp_per_iq;
		        iMaxStamina = JobInitialPoints[GetJob()].max_stamina + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].stamina_per_con;		

		        {
		            CSkillProto* pkSk = CSkillManager::instance().Get(SKILL_ADD_HP);		

		            if (NULL != pkSk)
		            {
		                pkSk->SetPointVar("k", 1.0f * GetSkillPower(SKILL_ADD_HP) / 100.0f);		

		                iMaxHP += static_cast<int>(pkSk->kPointPoly.Eval());
		            }
		        }		

		        // ±âş» °Şµé
		        SetPoint(POINT_MOV_SPEED,    100);
		        SetPoint(POINT_ATT_SPEED,    100);
		        PointChange(POINT_ATT_SPEED, GetPoint(POINT_PARTY_HASTE_BONUS));
		        SetPoint(POINT_CASTING_SPEED,    100);
		    }
		    else
		    {
		        iMaxHP = m_pkMobData->m_table.dwMaxHP;
		        iMaxSP = 0;
		        iMaxStamina = 0;		

		        SetPoint(POINT_ATT_SPEED, m_pkMobData->m_table.sAttackSpeed);
		        SetPoint(POINT_MOV_SPEED, m_pkMobData->m_table.sMovingSpeed);
		        SetPoint(POINT_CASTING_SPEED, m_pkMobData->m_table.sAttackSpeed);
		    }		

		    if (IsPC())
		    {
		        // ¸» Ÿ°í ŔÖŔ» ¶§´Â ±âş» ˝şĹČŔĚ ¸»ŔÇ ±âÁŘ ˝şĹČş¸´Ů ł·Ŕ¸¸é łô°Ô ¸¸µç´Ů.
		        // µű¶óĽ­ ¸»ŔÇ ±âÁŘ ˝şĹČŔĚ ą«»ç ±âÁŘŔ̹ǷÎ, Ľö¶ó/ą«´çŔş ŔüĂĽ ˝şĹČ ÇŐŔĚ
		        // ´ëäŔűŔ¸·Î ´ő żĂ¶ó°ˇ°Ô µÉ °ÍŔĚ´Ů.
		        if (GetMountVnum()) 
		        {
		            if (GetHorseST() > GetPoint(POINT_ST))
		                PointChange(POINT_ST, GetHorseST() - GetPoint(POINT_ST));		

		            if (GetHorseDX() > GetPoint(POINT_DX))
		                PointChange(POINT_DX, GetHorseDX() - GetPoint(POINT_DX));		

		            if (GetHorseHT() > GetPoint(POINT_HT))
		                PointChange(POINT_HT, GetHorseHT() - GetPoint(POINT_HT));		

		            if (GetHorseIQ() > GetPoint(POINT_IQ))
		                PointChange(POINT_IQ, GetHorseIQ() - GetPoint(POINT_IQ));
		        }		

		    }		

		    ComputeBattlePoints();		

		    // ±âş» HP/SP ĽłÁ¤
		    if (iMaxHP != GetMaxHP())
		    {
		        SetRealPoint(POINT_MAX_HP, iMaxHP); // ±âş»HP¸¦ RealPointżˇ ŔúŔĺÇŘ łő´Â´Ů.
		    }		

		    PointChange(POINT_MAX_HP, 0);		

		    if (iMaxSP != GetMaxSP())
		    {
		        SetRealPoint(POINT_MAX_SP, iMaxSP); // ±âş»SP¸¦ RealPointżˇ ŔúŔĺÇŘ łő´Â´Ů.
		    }		

		    PointChange(POINT_MAX_SP, 0);		

		    SetMaxStamina(iMaxStamina);		

		    m_pointsInstant.dwImmuneFlag = 0;		

		    for (int i = 0 ; i < WEAR_MAX_NUM; i++) 
		    {
		        LPITEM pItem = GetWear(i);
		        if (pItem)
		        {
		            pItem->ModifyPoints(true);
		            SET_BIT(m_pointsInstant.dwImmuneFlag, GetWear(i)->GetImmuneFlag());
		        }
		    }		

		    // żëČĄĽ® ˝Ă˝şĹŰ
		    // ComputePointsżˇĽ­´Â ÄɸŻĹÍŔÇ ¸đµç ĽÓĽş°ŞŔ» ĂʱâČ­Çϰí,
		    // ľĆŔĚĹŰ, ąöÇÁ µîżˇ °ü·ĂµČ ¸đµç ĽÓĽş°ŞŔ» Ŕç°č»ęÇϱ⠶§ą®żˇ,
		    // żëČĄĽ® ˝Ă˝şĹ۵µ ActiveDeckżˇ ŔÖ´Â ¸đµç żëČĄĽ®ŔÇ ĽÓĽş°ŞŔ» ´Ů˝Ă Ŕűżë˝ĂÄŃľß ÇŃ´Ů.
		    if (DragonSoul_IsDeckActivated())
		    {
		        for (int i = WEAR_MAX_NUM + DS_SLOT_MAX * DragonSoul_GetActiveDeck(); 
		            i < WEAR_MAX_NUM + DS_SLOT_MAX * (DragonSoul_GetActiveDeck() + 1); i++)    
		        {
		            LPITEM pItem = GetWear(i);
		            if (pItem)
		            {
		                if (DSManager::instance().IsTimeLeftDragonSoul(pItem))
		                    pItem->ModifyPoints(true);
		            }
		        }
		    }		

		    if (GetHP() > GetMaxHP())
		        PointChange(POINT_HP, GetMaxHP() - GetHP());		

		    if (GetSP() > GetMaxSP())
		        PointChange(POINT_SP, GetMaxSP() - GetSP());		

		    ComputeSkillPoints();		

		    RefreshAffect();
		    CPetSystem* pPetSystem = GetPetSystem();
		    if (NULL != pPetSystem)
		    {
		        pPetSystem->RefreshBuff();
		    }		

		    for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
		    {
		        it->second->GiveAllAttributes();
		    }		

		    UpdatePacket();
		}		

Modificez :

		

		void CHARACTER::ComputePoints()
		{
		    long lStat = GetPoint(POINT_STAT);
		    long lStatResetCount = GetPoint(POINT_STAT_RESET_COUNT);
		    long lSkillActive = GetPoint(POINT_SKILL);
		    long lSkillSub = GetPoint(POINT_SUB_SKILL);
		    long lSkillHorse = GetPoint(POINT_HORSE_SKILL);
		    long lLevelStep = GetPoint(POINT_LEVEL_STEP);		

		    long lAttackerBonus = GetPoint(POINT_PARTY_ATTACKER_BONUS);
		    long lTankerBonus = GetPoint(POINT_PARTY_TANKER_BONUS);
		    long lBufferBonus = GetPoint(POINT_PARTY_BUFFER_BONUS);
		    long lSkillMasterBonus = GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);
		    long lHasteBonus = GetPoint(POINT_PARTY_HASTE_BONUS);
		    long lDefenderBonus = GetPoint(POINT_PARTY_DEFENDER_BONUS);		

		    long lHPRecovery = GetPoint(POINT_HP_RECOVERY);
		    long lSPRecovery = GetPoint(POINT_SP_RECOVERY);		

		    memset(m_pointsInstant.points, 0, sizeof(m_pointsInstant.points));
		    BuffOnAttr_ClearAll();
		    m_SkillDamageBonus.clear();		

		    SetPoint(POINT_STAT, lStat);
		    SetPoint(POINT_SKILL, lSkillActive);
		    SetPoint(POINT_SUB_SKILL, lSkillSub);
		    SetPoint(POINT_HORSE_SKILL, lSkillHorse);
		    SetPoint(POINT_LEVEL_STEP, lLevelStep);
		    SetPoint(POINT_STAT_RESET_COUNT, lStatResetCount);		

		    SetPoint(POINT_ST, GetRealPoint(POINT_ST));
		    SetPoint(POINT_HT, GetRealPoint(POINT_HT));
		    SetPoint(POINT_DX, GetRealPoint(POINT_DX));
		    SetPoint(POINT_IQ, GetRealPoint(POINT_IQ));		

		    SetPart(PART_MAIN, GetOriginalPart(PART_MAIN));
		    SetPart(PART_WEAPON, GetOriginalPart(PART_WEAPON));
		    SetPart(PART_HEAD, GetOriginalPart(PART_HEAD));
		    SetPart(PART_HAIR, GetOriginalPart(PART_HAIR));		

		    SetPoint(POINT_PARTY_ATTACKER_BONUS, lAttackerBonus);
		    SetPoint(POINT_PARTY_TANKER_BONUS, lTankerBonus);
		    SetPoint(POINT_PARTY_BUFFER_BONUS, lBufferBonus);
		    SetPoint(POINT_PARTY_SKILL_MASTER_BONUS, lSkillMasterBonus);
		    SetPoint(POINT_PARTY_HASTE_BONUS, lHasteBonus);
		    SetPoint(POINT_PARTY_DEFENDER_BONUS, lDefenderBonus);		

		    SetPoint(POINT_HP_RECOVERY, lHPRecovery);
		    SetPoint(POINT_SP_RECOVERY, lSPRecovery);		

		    SetPoint(POINT_PC_BANG_EXP_BONUS, 0);
		    SetPoint(POINT_PC_BANG_DROP_BONUS, 0);		

		    int iMaxHP, iMaxSP;
		    int iMaxStamina;		

		    if(IsPC())
		    {
		        iMaxHP = JobInitialPoints[GetJob()].max_hp + m_points.iRandomHP + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].hp_per_ht;
		        iMaxSP = JobInitialPoints[GetJob()].max_sp + m_points.iRandomSP + GetPoint(POINT_IQ) * JobInitialPoints[GetJob()].sp_per_iq;
		        iMaxStamina = JobInitialPoints[GetJob()].max_stamina + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].stamina_per_con;		

		        {
		            CSkillProto* pkSk = CSkillManager::instance().Get(SKILL_ADD_HP);		

		            if(NULL != pkSk)
		            {
		                pkSk->SetPointVar("k", 1.0f * GetSkillPower(SKILL_ADD_HP) / 100.0f);		

		                iMaxHP += static_cast<int>(pkSk->kPointPoly.Eval());
		            }
		        }		

		        SetPoint(POINT_MOV_SPEED, 100);
		        SetPoint(POINT_ATT_SPEED, 100);
		        PointChange(POINT_ATT_SPEED, GetPoint(POINT_PARTY_HASTE_BONUS));
		        SetPoint(POINT_CASTING_SPEED, 100);
		    }
		    else
		    {
		        iMaxHP = m_pkMobData->m_table.dwMaxHP;
		        iMaxSP = 0;
		        iMaxStamina = 0;		

		        SetPoint(POINT_ATT_SPEED, m_pkMobData->m_table.sAttackSpeed);
		        SetPoint(POINT_MOV_SPEED, m_pkMobData->m_table.sMovingSpeed);
		        SetPoint(POINT_CASTING_SPEED, m_pkMobData->m_table.sAttackSpeed);
		    }		

		    if(IsPC())
		    {
		        // Podwyższanie statów podczas jazdy konnej (jeśli standardowa wartość jest niższa niż statystyki podczas jazdy)
		        if(GetMountVnum())
		        {
		            if(GetHorseST() > GetPoint(POINT_ST))
		                PointChange(POINT_ST, GetHorseST() - GetPoint(POINT_ST));		

		            if(GetHorseDX() > GetPoint(POINT_DX))
		                PointChange(POINT_DX, GetHorseDX() - GetPoint(POINT_DX));		

		            if(GetHorseHT() > GetPoint(POINT_HT))
		                PointChange(POINT_HT, GetHorseHT() - GetPoint(POINT_HT));		

		            if(GetHorseIQ() > GetPoint(POINT_IQ))
		                PointChange(POINT_IQ, GetHorseIQ() - GetPoint(POINT_IQ));
		        }		

		    }		

		    ComputeBattlePoints();		

		    // Ustawienie HP/SP
		    if(iMaxHP != GetMaxHP())
		    {
		        SetRealPoint(POINT_MAX_HP, iMaxHP); // HP ustawia domyślnie na RealPoint.
		    }		

		    PointChange(POINT_MAX_HP, 0);		

		    if(iMaxSP != GetMaxSP())
		    {
		        SetRealPoint(POINT_MAX_SP, iMaxSP); // SP ustawia domyślnie na RealPoint.
		    }		

		    PointChange(POINT_MAX_SP, 0);
		    // Koniec		

		    SetMaxStamina(iMaxStamina);		

		    m_pointsInstant.dwImmuneFlag = 0;		

		    for(int i = 0; i < WEAR_MAX_NUM; i++)
		    {
		        LPITEM pItem = GetWear(i);
		        if(pItem)
		        {
		            pItem->ModifyPoints(true);
		            SET_BIT(m_pointsInstant.dwImmuneFlag, GetWear(i)->GetImmuneFlag());
		        }
		    }		

		    if(DragonSoul_IsDeckActivated())
		    {
		        for(int i = WEAR_MAX_NUM + DS_SLOT_MAX * DragonSoul_GetActiveDeck();
		            i < WEAR_MAX_NUM + DS_SLOT_MAX * (DragonSoul_GetActiveDeck() + 1); i++)
		        {
		            LPITEM pItem = GetWear(i);
		            if(pItem)
		            {
		                if(DSManager::instance().IsTimeLeftDragonSoul(pItem))
		                    pItem->ModifyPoints(true);
		            }
		        }
		    }		

		    UpdatePacket(); // Update		

		    ComputeSkillPoints();		

		    RefreshAffect();		

		    CPetSystem* pPetSystem = GetPetSystem();
		    if(NULL != pPetSystem)
		    {
		        pPetSystem->RefreshBuff();
		    }
		   
		    for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
		    {
		        it->second->GiveAllAttributes();
		    }   
		   
		    if(GetHP() > GetMaxHP())
		        PointChange(POINT_HP, GetMaxHP() - GetHP());
		   
		    if(GetSP() > GetMaxSP())
		        PointChange(POINT_SP, GetMaxSP() - GetSP());		

		    UpdatePacket(); // Update
		}

 

 

[FIX] Réparer les emplacements dans l'alchimi du dragon

  Pokaż ukrytą zawartość

 

Cherchez dans : /common/length.h
 

		

		typedef struct SItemPos
		{
		    BYTE window_type;
		    WORD cell;
		    SItemPos ()
		    {
		        window_type = INVENTORY;
		        cell = WORD_MAX;
		    }		

		    SItemPos (BYTE _window_type, WORD _cell)
		    {
		        window_type = _window_type;
		        cell = _cell;
		    }		

		    bool IsValidItemPosition() const
		    {
		        switch (window_type)
		        {
		        case RESERVED_WINDOW:
		            return false;
		        case INVENTORY:
		        case EQUIPMENT:
		        case BELT_INVENTORY:
		            return cell < INVENTORY_AND_EQUIP_SLOT_MAX;
		        case DRAGON_SOUL_INVENTORY:
		            return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
		        // µżŔűŔ¸·Î Ĺ©±â°ˇ Á¤ÇŘÁö´Â window´Â valid ĂĽĹ©¸¦ ÇŇ Ľö°ˇ ľř´Ů.
		        case SAFEBOX:
		        case MALL:
		            return false;
		        default:
		            return false;
		        }
		        return false;
		    }
		    
		    bool IsEquipPosition() const
		    {
		        return ((INVENTORY == window_type || EQUIPMENT == window_type) && cell >= INVENTORY_MAX_NUM && cell < INVENTORY_MAX_NUM + WEAR_MAX_NUM)
		            || IsDragonSoulEquipPosition();
		    }		

		    bool IsDragonSoulEquipPosition() const
		    {
		        return (DRAGON_SOUL_EQUIP_SLOT_START <= cell) && (DRAGON_SOUL_EQUIP_SLOT_END > cell);
		    }		

		    bool IsBeltInventoryPosition() const
		    {
		        return (BELT_INVENTORY_SLOT_START <= cell) && (BELT_INVENTORY_SLOT_END > cell);
		    }		

		    bool IsDefaultInventoryPosition() const
		    {
		        return INVENTORY == window_type && cell < INVENTORY_MAX_NUM;
		    }		

		    bool operator==(const struct SItemPos& rhs) const
		    {
		        return (window_type == rhs.window_type) && (cell == rhs.cell);
		    }
		    bool operator<(const struct SItemPos& rhs) const
		    {
		        return (window_type < rhs.window_type) || ((window_type == rhs.window_type) && (cell < rhs.cell));
		    }
		} TItemPos;		

 

 

 

Remplacez par :
 

		

		typedef struct SItemPos
		{
		    BYTE window_type;
		    WORD cell;
		    SItemPos ()
		    {
		        window_type = INVENTORY;
		        cell = WORD_MAX;
		    }
		    SItemPos (BYTE _window_type, WORD _cell)
		    {
		        window_type = _window_type;
		        cell = _cell;
		    }
		    bool IsValidItemPosition() const
		    {
		        switch (window_type)
		        {
		        case RESERVED_WINDOW:
		            return false;
		        case INVENTORY:
		        case EQUIPMENT:
		        case BELT_INVENTORY:
		            return cell < INVENTORY_AND_EQUIP_SLOT_MAX;
		        case DRAGON_SOUL_INVENTORY:
		            return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
		        // µżŔűŔ¸·Î Ĺ©±â°ˇ Á¤ÇŘÁö´Â window´Â valid ĂĽĹ©¸¦ ÇŇ Ľö°ˇ ľř´Ů.
		        case SAFEBOX:
		        case MALL:
		            return false;
		        default:
		            return false;
		        }
		        return false;
		    }
		    bool IsEquipPosition() const
		    {
		        return (IsDefaultInventoryEquipPosition() || IsDragonSoulEquipPosition());
		    }
		    bool IsDefaultInventoryEquipPosition() const
		    {
		        return ((INVENTORY == window_type || EQUIPMENT == window_type) && cell >= INVENTORY_MAX_NUM && cell < INVENTORY_MAX_NUM + WEAR_MAX_NUM);
		    }
		    bool IsDragonSoulEquipPosition() const
		    {
		        return ((INVENTORY == window_type || EQUIPMENT == window_type) && cell >= DRAGON_SOUL_EQUIP_SLOT_START && cell < DRAGON_SOUL_EQUIP_SLOT_END);
		    }
		    bool IsBeltInventoryPosition() const
		    {
		        return ((INVENTORY == window_type) && cell >= BELT_INVENTORY_SLOT_START && cell < BELT_INVENTORY_SLOT_END);
		    }
		    bool IsDefaultInventoryPosition() const
		    {
		        return ((INVENTORY == window_type) && cell < INVENTORY_MAX_NUM);
		    }
		    bool operator==(const struct SItemPos& rhs) const
		    {
		        return (window_type == rhs.window_type) && (cell == rhs.cell);
		    }
		    bool operator<(const struct SItemPos& rhs) const
		    {
		        return (window_type < rhs.window_type) || ((window_type == rhs.window_type) && (cell < rhs.cell));
		    }
		} TItemPos;		

 

 

[FIX] Invisibilité des personnages après connexion / téléportation (package)

  Pokaż ukrytą zawartość

 


Cherchez dans : /game/src/char_affect.cpp

		

		if (AFFECT_REVIVE_INVISIBLE != pkAff->dwType) 
		{ 
		    ComputePoints();
		}		

Modifiez comme ceci :

		

		if (AFFECT_REVIVE_INVISIBLE != pkAff->dwType)
		    ComputePoints(); 
		else 
		    UpdatePacket();		

 

 

[FIX] Débogage des guerres de guilde 

  Pokaż ukrytą zawartość

 


Cherchez dans :  /game/src/cmd_general.cpp

int type = GUILD_WAR_TYPE_FIELD;		

Modifiez comme :

unsigned int type = GUILD_WAR_TYPE_FIELD;		

 

 

[FIX] Impossible de créer un magasin sur une monture

  Pokaż ukrytą zawartość

 


Cherchez dans : /game/src/char.cpp

void CHARACTER::OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount)		

En dessous de :

if (GetMyShop()) // ŔĚąĚ ĽĄŔĚ ż­·Á ŔÖŔ¸¸é ´Ý´Â´Ů. 
		{
		    CloseMyShop();
		    return;
		}		

Ajoutez :

		

		if (IsRiding())
		{ 
		    ChatPacket(CHAT_TYPE_INFO, "Jesli chcesz otworzyc sklep zejdz z wierzchowca");
		    return;
		}		

 

 

[FIX] -32k HP du personnage après la téléportation ou la connexion

  Pokaż ukrytą zawartość

 


Cherchez dans : /game/src/char.cpp

		

SetHP(t->hp);
		SetSP(t->sp);		

Changez en :

		

SetHP(GetMaxHP()); // -32k hp fix 
		SetSP(GetMaxSP()); // -32k sp fix		

 

 

Maintenant dans :  /common/tables.h

Recherchez dans  :  typedef struct SPlayerTable

		

		short hp;
		short sp;		

 

Et changez en :

		

		// -32k hp/sp fix 
		int hp;
		int sp;		

 

 

[FIX] Drop des objets (de monstres / metins, une fois que chaque million tue un objet qui n'est pas affecté au drop drop) Gné²

Révélation

Cherchez le fichier : /game/src/item_manager_read_tables.cpp

Remplacez le tout par :

#include "stdafx.h"
#include "utils.h"
#include "config.h"
#include "char.h"
#include "char_manager.h"
#include "desc_client.h"
#include "db.h"
#include "log.h"
#include "skill.h"
#include "text_file_loader.h"
#include "priv_manager.h"
#include "questmanager.h"
#include "unique_item.h"
#include "safebox.h"
#include "blend_item.h"
#include "dev_log.h"
#include "locale_service.h"
#include "item.h"
#include "item_manager.h"
#include "item_manager_private_types.h"
#include "group_text_parse_tree.h"
 
std::vector<CItemDropInfo> g_vec_pkCommonDropItem[MOB_RANK_MAX_NUM];
 
bool ITEM_MANAGER::ReadCommonDropItemFile(const char * c_pszFileName)
{
	FILE * fp = fopen(c_pszFileName, "r");
 
	if (!fp)
	{
		sys_err("Cannot open %s", c_pszFileName);
		return false;
	}
 
	char buf[1024];
 
	int lines = 0;
 
	while (fgets(buf, 1024, fp))
	{
		++lines;
 
		if (!*buf || *buf == '\n')
			continue;
 
		TDropItem d[MOB_RANK_MAX_NUM];
		char szTemp[64];
 
		memset(&d, 0, sizeof(d));
 
		char * p = buf;
		char * p2;
 
		for (int i = 0; i <= MOB_RANK_S_KNIGHT; ++i)
		{
			for (int j = 0; j < 6; ++j)
			{
				p2 = strchr(p, '\t');
 
				if (!p2)
					break;
 
				strlcpy(szTemp, p, MIN(sizeof(szTemp), (p2 - p) + 1));
				p = p2 + 1;
 
				switch (j)
				{
				case 0: break;
				case 1: str_to_number(d[i].iLvStart, szTemp);	break;
				case 2: str_to_number(d[i].iLvEnd, szTemp);	break;
				case 3: d[i].fPercent = atof(szTemp);	break;
				case 4: strlcpy(d[i].szItemName, szTemp, sizeof(d[i].szItemName));	break;
				case 5: str_to_number(d[i].iCount, szTemp);	break;
				}
			}
 
			DWORD dwPct = (DWORD) (d[i].fPercent * 10000.0f);
			DWORD dwItemVnum = 0;
 
			if (!ITEM_MANAGER::instance().GetVnumByOriginalName(d[i].szItemName, dwItemVnum))
			{
				// Ŕ̸§Ŕ¸·Î ¸řĂŁŔ¸¸é ąřČŁ·Î °Ë»ö
				str_to_number(dwItemVnum, d[i].szItemName);
				if (!ITEM_MANAGER::instance().GetTable(dwItemVnum))
				{
					sys_err("No such an item (name: %s)", d[i].szItemName);
					fclose(fp);
					return false;
				}
			}
 
			if (d[i].iLvStart == 0)
				continue;
 
			g_vec_pkCommonDropItem[i].push_back(CItemDropInfo(d[i].iLvStart, d[i].iLvEnd, dwPct, dwItemVnum));
		}
	}
 
	fclose(fp);
 
	for (int i = 0; i < MOB_RANK_MAX_NUM; ++i)
	{
		std::vector<CItemDropInfo> & v = g_vec_pkCommonDropItem[i];
		std::sort(v.begin(), v.end());
 
		std::vector<CItemDropInfo>::iterator it = v.begin();
 
		sys_log(1, "CommonItemDrop rank %d", i);
 
		while (it != v.end())
		{
			const CItemDropInfo & c = *(it++);
			sys_log(1, "CommonItemDrop %d %d %d %u", c.m_iLevelStart, c.m_iLevelEnd, c.m_iPercent, c.m_dwVnum);
		}
	}
 
 
 
	return true;
}
 
bool ITEM_MANAGER::ReadSpecialDropItemFile(const char * c_pszFileName)
{
	CTextFileLoader loader;
 
	if (!loader.Load(c_pszFileName))
		return false;
 
	std::string stName;
 
	for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
	{
		loader.SetChildNode(i);
 
		loader.GetCurrentNodeName(&stName);
 
		int iVnum;
 
		if (!loader.GetTokenInteger("vnum", &iVnum))
		{
			sys_err("ReadSpecialDropItemFile : Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
			loader.SetParentNode();
			return false;
		}
 
		sys_log(0,"DROP_ITEM_GROUP %s %d", stName.c_str(), iVnum);
 
		TTokenVector * pTok;
 
		//
		std::string stType;
		int type = CSpecialItemGroup::NORMAL;
		if (loader.GetTokenString("type", &stType))
		{
			stl_lowers(stType);
			if (stType == "pct")
			{
				type = CSpecialItemGroup::PCT;
			}
			else if (stType == "quest")
			{
				type = CSpecialItemGroup::QUEST;
				quest::CQuestManager::instance().RegisterNPCVnum(iVnum);
			}
			else if (stType == "special")
			{
				type = CSpecialItemGroup::SPECIAL;
			}
		}
 
		if ("attr" == stType)
		{
			CSpecialAttrGroup * pkGroup = M2_NEW CSpecialAttrGroup(iVnum);
			for (int k = 1; k < 256; ++k)
			{
				char buf[4];
				snprintf(buf, sizeof(buf), "%d", k);
 
				if (loader.GetTokenVector(buf, &pTok))
				{
					DWORD apply_type = 0;
					int	apply_value = 0;
					str_to_number(apply_type, pTok->at(0).c_str());
					if (0 == apply_type)
					{
						apply_type = FN_get_apply_type(pTok->at(0).c_str());
						if (0 == apply_type)
						{
							sys_err ("Invalid APPLY_TYPE %s in Special Item Group Vnum %d", pTok->at(0).c_str(), iVnum);
							return false;
						}
					}
					str_to_number(apply_value, pTok->at(1).c_str());
					if (apply_type > MAX_APPLY_NUM)
					{
						sys_err ("Invalid APPLY_TYPE %u in Special Item Group Vnum %d", apply_type, iVnum);
						M2_DELETE(pkGroup);
						return false;
					}
					pkGroup->m_vecAttrs.push_back(CSpecialAttrGroup::CSpecialAttrInfo(apply_type, apply_value));
				}
				else
				{
					break;
				}
			}
			if (loader.GetTokenVector("effect", &pTok))
			{
				pkGroup->m_stEffectFileName = pTok->at(0);
			}
			loader.SetParentNode();
			m_map_pkSpecialAttrGroup.insert(std::make_pair(iVnum, pkGroup));
		}
		else
		{
			CSpecialItemGroup * pkGroup = M2_NEW CSpecialItemGroup(iVnum, type);
			for (int k = 1; k < 256; ++k)
			{
				char buf[4];
				snprintf(buf, sizeof(buf), "%d", k);
 
				if (loader.GetTokenVector(buf, &pTok))
				{
					const std::string& name = pTok->at(0);
					DWORD dwVnum = 0;
 
					if (!GetVnumByOriginalName(name.c_str(), dwVnum))
					{
						if (name == "°ćÇčġ" || name == "exp")
						{
							dwVnum = CSpecialItemGroup::EXP;
						}
						else if (name == "mob")
						{
							dwVnum = CSpecialItemGroup::MOB;
						}
						else if (name == "slow")
						{
							dwVnum = CSpecialItemGroup::SLOW;
						}
						else if (name == "drain_hp")
						{
							dwVnum = CSpecialItemGroup::DRAIN_HP;
						}
						else if (name == "poison")
						{
							dwVnum = CSpecialItemGroup::POISON;
						}
						else if (name == "group")
						{
							dwVnum = CSpecialItemGroup::MOB_GROUP;
						}
						else
						{
							str_to_number(dwVnum, name.c_str());
							if (!ITEM_MANAGER::instance().GetTable(dwVnum))
							{
								sys_err("ReadSpecialDropItemFile : there is no item %s : node %s", name.c_str(), stName.c_str());
								M2_DELETE(pkGroup);
 
								return false;
							}
						}
					}
 
					int iCount = 0;
					str_to_number(iCount, pTok->at(1).c_str());
					int iProb = 0;
					str_to_number(iProb, pTok->at(2).c_str());
 
					int iRarePct = 0;
					if (pTok->size() > 3)
					{
						str_to_number(iRarePct, pTok->at(3).c_str());
					}
 
					sys_log(0,"        name %s count %d prob %d rare %d", name.c_str(), iCount, iProb, iRarePct);
					pkGroup->AddItem(dwVnum, iCount, iProb, iRarePct);
 
					// CHECK_UNIQUE_GROUP
					if (iVnum < 30000)
					{
						m_ItemToSpecialGroup[dwVnum] = iVnum;
					}
					// END_OF_CHECK_UNIQUE_GROUP
 
					continue;
				}
 
				break;
			}
			loader.SetParentNode();
			if (CSpecialItemGroup::QUEST == type)
			{
				m_map_pkQuestItemGroup.insert(std::make_pair(iVnum, pkGroup));
			}
			else
			{
				m_map_pkSpecialItemGroup.insert(std::make_pair(iVnum, pkGroup));
			}
		}
	}
 
	return true;
}
 
 
bool ITEM_MANAGER::ConvSpecialDropItemFile()
{
	char szSpecialItemGroupFileName[256];
	snprintf(szSpecialItemGroupFileName, sizeof(szSpecialItemGroupFileName),
		"%s/special_item_group.txt", LocaleService_GetBasePath().c_str());
 
	FILE *fp = fopen("special_item_group_vnum.txt", "w");
	if (!fp)
	{
		sys_err("could not open file (%s)", "special_item_group_vnum.txt");
		return false;
	}
 
	CTextFileLoader loader;
 
	if (!loader.Load(szSpecialItemGroupFileName))
	{
		fclose(fp);
		return false;
	}
 
	std::string stName;
 
	for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
	{
		loader.SetChildNode(i);
 
		loader.GetCurrentNodeName(&stName);
 
		int iVnum;
 
		if (!loader.GetTokenInteger("vnum", &iVnum))
		{
			sys_err("ConvSpecialDropItemFile : Syntax error %s : no vnum, node %s", szSpecialItemGroupFileName, stName.c_str());
			loader.SetParentNode();
			fclose(fp);
			return false;
		}
 
		std::string str;
		int type = 0;
		if (loader.GetTokenString("type", &str))
		{
			stl_lowers(str);
			if (str == "pct")
			{
				type = 1;
			}
		}
 
		TTokenVector * pTok;
 
		fprintf(fp, "Group	%s\n", stName.c_str());
		fprintf(fp, "{\n");
		fprintf(fp, "	Vnum	%i\n", iVnum);
		if (type)
			fprintf(fp, "	Type	Pct");
 
		for (int k = 1; k < 256; ++k)
		{
			char buf[4];
			snprintf(buf, sizeof(buf), "%d", k);
 
			if (loader.GetTokenVector(buf, &pTok))
			{
				const std::string& name = pTok->at(0);
				DWORD dwVnum = 0;
 
				if (!GetVnumByOriginalName(name.c_str(), dwVnum))
				{
					if (	name == "°ćÇčġ" ||
						name == "mob" ||
						name == "slow" ||
						name == "drain_hp" ||
						name == "poison" ||
						name == "group")
					{
						dwVnum = 0;
					}
					else
					{
						str_to_number(dwVnum, name.c_str());
						if (!ITEM_MANAGER::instance().GetTable(dwVnum))
						{
							sys_err("ReadSpecialDropItemFile : there is no item %s : node %s", name.c_str(), stName.c_str());
							fclose(fp);
 
							return false;
						}
					}
				}
 
				int iCount = 0;
				str_to_number(iCount, pTok->at(1).c_str());
				int iProb = 0;
				str_to_number(iProb, pTok->at(2).c_str());
 
				int iRarePct = 0;
				if (pTok->size() > 3)
				{
					str_to_number(iRarePct, pTok->at(3).c_str());
				}
 
				//    1   "±âĽú Ľö·ĂĽ­"   1   100
				if (0 == dwVnum)
					fprintf(fp, "	%d	%s	%d	%d\n", k, name.c_str(), iCount, iProb);
				else
					fprintf(fp, "	%d	%u	%d	%d\n", k, dwVnum, iCount, iProb);
 
				continue;
			}
 
			break;
		}
		fprintf(fp, "}\n");
		fprintf(fp, "\n");
 
		loader.SetParentNode();
	}
 
	fclose(fp);
	return true;
}
 
bool ITEM_MANAGER::ReadEtcDropItemFile(const char * c_pszFileName)
{
	FILE * fp = fopen(c_pszFileName, "r");
 
	if (!fp)
	{
		sys_err("Cannot open %s", c_pszFileName);
		return false;
	}
 
	char buf[512];
 
	int lines = 0;
 
	while (fgets(buf, 512, fp))
	{
		++lines;
 
		if (!*buf || *buf == '\n')
			continue;
 
		char szItemName[256];
		float fProb = 0.0f;
 
		strlcpy(szItemName, buf, sizeof(szItemName));
		char * cpTab = strrchr(szItemName, '\t');
 
		if (!cpTab)
			continue;
 
		*cpTab = '\0';
		fProb = atof(cpTab + 1);
 
		if (!*szItemName || fProb == 0.0f)
			continue;
 
		DWORD dwItemVnum;
 
		if (!ITEM_MANAGER::instance().GetVnumByOriginalName(szItemName, dwItemVnum))
		{
			sys_err("No such an item (name: %s)", szItemName);
			fclose(fp);
			return false;
		}
 
		m_map_dwEtcItemDropProb[dwItemVnum] = (DWORD) (fProb * 10000.0f);
		sys_log(0, "ETC_DROP_ITEM: %s prob %f", szItemName, fProb);
	}
 
	fclose(fp);
	return true;
}
 
bool ITEM_MANAGER::ReadMonsterDropItemGroup(const char * c_pszFileName)
{
	CTextFileLoader loader;
 
	if (!loader.Load(c_pszFileName))
		return false;
 
	for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
	{
		std::string stName("");
 
		loader.GetCurrentNodeName(&stName);
 
		if (strncmp (stName.c_str(), "kr_", 3) == 0)
		{
			if (LC_IsYMIR())
			{
				stName.assign(stName, 3, stName.size() - 3);
			}
			else
			{
				continue;
			}
		}
 
		loader.SetChildNode(i);
 
		int iMobVnum = 0;
		int iKillDrop = 0;
		int iLevelLimit = 0;
 
		std::string strType("");
 
		if (!loader.GetTokenString("type", &strType))
		{
			sys_err("ReadMonsterDropItemGroup : Syntax error %s : no type (kill|drop), node %s", c_pszFileName, stName.c_str());
			loader.SetParentNode();
			return false;
		}
 
		if (!loader.GetTokenInteger("mob", &iMobVnum))
		{
			sys_err("ReadMonsterDropItemGroup : Syntax error %s : no mob vnum, node %s", c_pszFileName, stName.c_str());
			loader.SetParentNode();
			return false;
		}
 
		if (strType == "kill")
		{
			if (!loader.GetTokenInteger("kill_drop", &iKillDrop))
			{
				sys_err("ReadMonsterDropItemGroup : Syntax error %s : no kill drop count, node %s", c_pszFileName, stName.c_str());
				loader.SetParentNode();
				return false;
			}
		}
		else
		{
			iKillDrop = 1;
		}
 
		if ( strType == "limit" )
		{
			if ( !loader.GetTokenInteger("level_limit", &iLevelLimit) )
			{
				sys_err("ReadmonsterDropItemGroup : Syntax error %s : no level_limit, node %s", c_pszFileName, stName.c_str());
				loader.SetParentNode();
				return false;
			}
		}
		else
		{
			iLevelLimit = 0;
		}
 
		sys_log(0,"MOB_ITEM_GROUP %s [%s] %d %d", stName.c_str(), strType.c_str(), iMobVnum, iKillDrop);
 
		if (iKillDrop == 0)
		{
			loader.SetParentNode();
			continue;
		}
 
		TTokenVector* pTok = NULL;
 
		if (strType == "kill")
		{
			CMobItemGroup * pkGroup = M2_NEW CMobItemGroup(iMobVnum, iKillDrop, stName);
 
			for (int k = 1; k < 256; ++k)
			{
				char buf[4];
				snprintf(buf, sizeof(buf), "%d", k);
 
				if (loader.GetTokenVector(buf, &pTok))
				{
					//sys_log(1, "               %s %s", pTok->at(0).c_str(), pTok->at(1).c_str());
					std::string& name = pTok->at(0);
					DWORD dwVnum = 0;
 
					if (!GetVnumByOriginalName(name.c_str(), dwVnum))
					{
						str_to_number(dwVnum, name.c_str());
						if (!ITEM_MANAGER::instance().GetTable(dwVnum))
						{
							sys_err("ReadMonsterDropItemGroup : there is no item %s : node %s : vnum %d", name.c_str(), stName.c_str(), dwVnum);
							return false;
						}
					}
					else
					{
						dwVnum = 0;
					}
 
					int iCount = 0;
					str_to_number(iCount, pTok->at(1).c_str());
 
					if (iCount<1)
					{
						sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s : vnum %d, count %d", name.c_str(), stName.c_str(), dwVnum, iCount);
						return false;
					}
 
					int iPartPct = 0;
					str_to_number(iPartPct, pTok->at(2).c_str());
 
					if (iPartPct == 0)
					{
						sys_err("ReadMonsterDropItemGroup : there is no drop percent for item %s : node %s : vnum %d, count %d, pct %d", name.c_str(), stName.c_str(), iPartPct);
						return false;
					}
 
					int iRarePct = 0;
					str_to_number(iRarePct, pTok->at(3).c_str());
					iRarePct = MINMAX(0, iRarePct, 100);
 
					sys_log(0,"        %s count %d rare %d", name.c_str(), iCount, iRarePct);
					pkGroup->AddItem(dwVnum, iCount, iPartPct, iRarePct);
					continue;
				}
 
				break;
			}
			m_map_pkMobItemGroup.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));
 
		}
		else if (strType == "drop")
		{
			CDropItemGroup* pkGroup;
			bool bNew = true;
			itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find (iMobVnum);
			if (it == m_map_pkDropItemGroup.end())
			{
				pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
			}
			else
			{
				bNew = false;
				pkGroup = it->second;
			}
 
			for (int k = 1; k < 256; ++k)
			{
				char buf[4];
				snprintf(buf, sizeof(buf), "%d", k);
 
				if (loader.GetTokenVector(buf, &pTok))
				{
					std::string& name = pTok->at(0);
					DWORD dwVnum = 0;
 
 
					if (!GetVnumByOriginalName(name.c_str(), dwVnum))
					{
						str_to_number(dwVnum, name.c_str());
						if (!ITEM_MANAGER::instance().GetTable(dwVnum))
						{
							sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
							M2_DELETE(pkGroup);
							return false;
						}
					}
					else
					{
						dwVnum = 0;
						str_to_number(dwVnum, name.c_str());
						if (!ITEM_MANAGER::instance().GetTable(dwVnum))
						{
							sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
							M2_DELETE(pkGroup);
							return false;
						}
					}
 
					int iCount = 0;
					str_to_number(iCount, pTok->at(1).c_str());
 
					if (iCount < 1)
					{
						sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
						M2_DELETE(pkGroup);
 
						return false;
					}
 
					float fPercent = atof(pTok->at(2).c_str());
 
					DWORD dwPct = (DWORD)(10000.0f * fPercent);
 
					sys_log(0,"        name %s pct %d count %d", name.c_str(), dwPct, iCount);
					pkGroup->AddItem(dwVnum, dwPct, iCount);
 
					continue;
				}
 
				break;
			}
			if (bNew)
				m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
 
		}
		else if ( strType == "limit" )
		{
			CLevelItemGroup* pkLevelItemGroup = M2_NEW CLevelItemGroup(iLevelLimit);
 
			for ( int k=1; k < 256; k++ )
			{
				char buf[4];
				snprintf(buf, sizeof(buf), "%d", k);
 
				if ( loader.GetTokenVector(buf, &pTok) )
				{
					std::string& name = pTok->at(0);
					DWORD dwItemVnum = 0;
 
					if (!GetVnumByOriginalName(name.c_str(), dwItemVnum))
					{
						str_to_number(dwItemVnum, name.c_str());
						if ( !ITEM_MANAGER::instance().GetTable(dwItemVnum) )
						{
							M2_DELETE(pkLevelItemGroup);
							return false;
						}
					}
					else
					{
						dwItemVnum = 0;
					}					
 
					int iCount = 0;
					str_to_number(iCount, pTok->at(1).c_str());
 
					if (iCount < 1)
					{
 
						M2_DELETE(pkLevelItemGroup);
						return false;
					}
 
					float fPct = atof(pTok->at(2).c_str());
					DWORD dwPct = (DWORD)(10000.0f * fPct);
 
					pkLevelItemGroup->AddItem(dwItemVnum, dwPct, iCount);
 
					continue;
				}
 
				break;
			}
 
			m_map_pkLevelItemGroup.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));
		}
		else if (strType == "thiefgloves")
		{
			CBuyerThiefGlovesItemGroup* pkGroup = M2_NEW CBuyerThiefGlovesItemGroup(0, iMobVnum, stName);
 
			for (int k = 1; k < 256; ++k)
			{
				char buf[4];
				snprintf(buf, sizeof(buf), "%d", k);
 
				if (loader.GetTokenVector(buf, &pTok))
				{
					std::string& name = pTok->at(0);
					DWORD dwVnum = 0;
 
					if (!GetVnumByOriginalName(name.c_str(), dwVnum))
					{
						str_to_number(dwVnum, name.c_str());
						if (!ITEM_MANAGER::instance().GetTable(dwVnum))
						{
							sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
							M2_DELETE(pkGroup);
 
							return false;
						}
					}
					else
					{
						dwVnum = 0;
					}					
 
					int iCount = 0;
					str_to_number(iCount, pTok->at(1).c_str());
 
					if (iCount < 1)
					{
						sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
						M2_DELETE(pkGroup);
 
						return false;
					}
 
					float fPercent = atof(pTok->at(2).c_str());
 
					DWORD dwPct = (DWORD)(10000.0f * fPercent);
 
					sys_log(0,"        name %s pct %d count %d", name.c_str(), dwPct, iCount);
					pkGroup->AddItem(dwVnum, dwPct, iCount);
 
					continue;
				}
 
				break;
			}
 
			m_map_pkGloveItemGroup.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));
		}
		else
		{
			sys_err("ReadMonsterDropItemGroup : Syntax error %s : invalid type %s (kill|drop), node %s", c_pszFileName, strType.c_str(), stName.c_str());
			loader.SetParentNode();
			return false;
		}
 
		loader.SetParentNode();
	}
 
	return true;
}
 
bool ITEM_MANAGER::ReadDropItemGroup(const char * c_pszFileName)
{
	CTextFileLoader loader;
 
	if (!loader.Load(c_pszFileName))
		return false;
 
	std::string stName;
 
	for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
	{
		loader.SetChildNode(i);
 
		loader.GetCurrentNodeName(&stName);
 
		int iVnum;
		int iMobVnum;
 
		if (!loader.GetTokenInteger("vnum", &iVnum))
		{
			sys_err("ReadDropItemGroup : Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
			loader.SetParentNode();
			return false;
		}
 
		if (!loader.GetTokenInteger("mob", &iMobVnum))
		{
			sys_err("ReadDropItemGroup : Syntax error %s : no mob vnum, node %s", c_pszFileName, stName.c_str());
			loader.SetParentNode();
			return false;
		}
 
		sys_log(0,"DROP_ITEM_GROUP %s %d", stName.c_str(), iMobVnum);
 
		TTokenVector * pTok;
 
		itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find(iMobVnum);
 
		CDropItemGroup* pkGroup;
 
		if (it == m_map_pkDropItemGroup.end())
			pkGroup = M2_NEW CDropItemGroup(iVnum, iMobVnum, stName);
		else
			pkGroup = it->second;
 
		for (int k = 1; k < 256; ++k)
		{
			char buf[4];
			snprintf(buf, sizeof(buf), "%d", k);
 
			if (loader.GetTokenVector(buf, &pTok))
			{
				std::string& name = pTok->at(0);
				DWORD dwVnum = 0;
 
				if (!GetVnumByOriginalName(name.c_str(), dwVnum))
				{
					str_to_number(dwVnum, name.c_str());
					if (!ITEM_MANAGER::instance().GetTable(dwVnum))
					{
						sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
 
						if (it == m_map_pkDropItemGroup.end())
							M2_DELETE(pkGroup);
 
 
 
 
						return false;
					}
				}
				else
				{
					dwVnum = 0;
				}				
 
				float fPercent = atof(pTok->at(1).c_str());
 
				DWORD dwPct = (DWORD)(10000.0f * fPercent);
 
				int iCount = 1;
				if (pTok->size() > 2)
					str_to_number(iCount, pTok->at(2).c_str());
 
				if (iCount < 1)
				{
					sys_err("ReadDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
 
					if (it == m_map_pkDropItemGroup.end())
						M2_DELETE(pkGroup);
 
 
 
 
					return false;
				}
 
				sys_log(0,"        %s %d %d", name.c_str(), dwPct, iCount);
				pkGroup->AddItem(dwVnum, dwPct, iCount);
				continue;
			}
 
			break;
		}
 
		if (it == m_map_pkDropItemGroup.end())
			m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
 
		loader.SetParentNode();
	}
 
 
 
 
	return true;
}
 
bool ITEM_MANAGER::ReadItemVnumMaskTable(const char * c_pszFileName)
{
	FILE *fp = fopen(c_pszFileName, "r");
	if (!fp)
	{
		return false;
	}
 
	int ori_vnum, new_vnum;
	while (fscanf(fp, "%u %u", &ori_vnum, &new_vnum) != EOF)
	{
		m_map_new_to_ori.insert (TMapDW2DW::value_type (new_vnum, ori_vnum));
	}
	fclose(fp);
	return true;
}

 

[FIX] Téléportation d'un membre du groupe vers le leader (par exemple, nous sommes en m1, et à travers les caméras du mod, nous appelons le joueur à nous-mêmes)

  Pokaż ukrytą zawartość

Cherchez dans : /game/src/party.cpp

 

La fonction :

void CParty::SummonToLeader(DWORD pid)

 

En dessous de :

    if (!ch)
    {
        l->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<ĆÄĆĽ> ĽŇČŻÇĎ·Á´Â ´ë»óŔ» ĂŁŔ» Ľö ľř˝Ŕ´Ď´Ů."));
        return;
    }

 

Ajoutez :

    if(ch->GetMapIndex() != l->GetMapIndex())
    {
        l->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Czlonek grupy nie jest na tej mapie."));
        return;
    }

 

 

[FIX] Injection SQL (Amis et Guilde)

  Pokaż ukrytą zawartość

 


Complètement après ça.

Ah bah la je colle ....

 

 

[FIX] Débogage du parchemin du dieu dragon (+ 10 % de chance pour une mise à niveau)

  Pokaż ukrytą zawartość

 


Cherchez dans :  /game/src/char_item.cpp
 

		

		        if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
		        {
		            if (LC_IsYMIR() == true || LC_IsKorea() == true)
		                success_prob = hyuniron_prob_euckr[MINMAX(0, item->GetRefineLevel(), 8)];
		            else
		                success_prob = hyuniron_prob[MINMAX(0, item->GetRefineLevel(), 8)];
		        }		

 

Modifiez comme ceci :

		

		        if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
		        {
		            success_prob = MINMAX(1, prt->prob+10, 100);
		        }		

Cherchez aussi :

		

		bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell)		

En dessous de :

		p.prob = prt->prob;		

Ajoutez :

		

		    LPITEM itemScroll = GetInventoryItem(iAdditionalCell);
		    if(!itemScroll)
		    {
		    }
		    else
		    {
		            if (itemScroll->GetValue(0) == YONGSIN_SCROLL)
		            {
		                p.prob = MIN(100, prt->prob+10);
		        }
		    }		

 

  • Metin2 Dev 1

french_banner.gif

Lien vers le commentaire
Partager sur d’autres sites

  • Réponses 0
  • Créé
  • Dernière réponse

Meilleurs contributeurs dans ce sujet

Jours populaires



  • brilliantdiscord_widget
  • Flux d'Activité

    1. 0

      OldEraMT2 | Classique 2009 Oldschool | Niveau 99 | 7 langues | Sans pay2win | Bêta fermée

    2. 6

      problème de connexion à mon serveur local (je suis débutant dans ce genre d'entreprise )

    3. 2

      problème de lancement serveur

    4. 9
    5. 0

      [PVM/PVP] ATLAX2 - EASY PLAY

    6. 2

      problème de lancement serveur

Information importante

Conditions d’utilisation / Politique de confidentialité / Règles / Nous avons placé des cookies sur votre appareil pour aider à améliorer ce site. Vous pouvez choisir d’ajuster vos paramètres de cookie, sinon nous supposerons que vous êtes d’accord pour continuer.