skill_lsw.cpp

国内著名网络游戏dragon的服务端完整源码 内附完整数据库结构

#include "..\stdafx.h"
#include "DefaultHeader.h"
#include "DR_NETWORK.h"
#include "CITEM.h"
#include "skill_lsw.h"
#include "MenuDefine.h"
#include "Auction.h"
#include "GmMgr.h"
#include "Menuserver.h"
#include "MailMgr.h"
#include "UserManager.h"
#include "LogManager.h"	// BBD 040308

extern void RecvCMD_COMFORM_RESET_ABILITY(t_packet &packet);//020820 lsw
extern void RecvCMD_TRADE_MODE_CHANGE(const int iCn, t_packet *p);//030127 lsw //Trade On/Off 悸泼

extern HDBC  hDBC;

t_raregroup			RareGroup[5][MAX_RARE_GROUP];
t_rareprobability	Rareprobability[MAX_RARE_PROBABILIY];
t_ItemFunction		ItemFunction[MAX_ITEM_FUNCTION];

int CanLearnSkill( CHARLIST *ch, int skill, int check_ability )
{
	if( !ch ) return 0;
	int inc = SkillTbl[skill].inclusive;	// 魄窜风凭 
	if( ch->Skill[skill] ) return 2;		// 捞固 硅奎澜
	if( check_ability && ch->skillexp[inc].skillexp < (DWORD)SkillTbl[skill].need_exp ) return 3;	// 瓷仿捞 葛磊恩
	
	return 1;		// 硅快扁俊 啊瓷窃.
}

void SendLearnSkillOk( int skill_no, t_connection c[], int cn )
{
	t_packet packet;
	packet.h.header.type = CMD_LEARN_SKILL_OK;
	{
		packet.u.kein.server_learn_skill_ok.skill_no = skill_no;
	}
	packet.h.header.size = sizeof( k_server_learn_skill_ok );
	QueuePacket( c, cn, &packet, 1 );		// 努扼捞攫飘 傈价	罐篮芭 绊措肺 焊郴霖促.
}

void SendStartSkillExp( int inc, t_skillexp exp, t_connection c[], int cn )
{
	t_packet packet;
	packet.h.header.type = CMD_SKILL_EXP;
	{
		packet.u.kein.server_skill_exp.type = inc;
		packet.u.kein.server_skill_exp.exp = exp;
	}
	packet.h.header.size = sizeof( k_server_skill_exp );
	QueuePacket( c, cn, &packet, 1 );		// 努扼捞攫飘 傈价	罐篮芭 绊措肺 焊郴霖促.
}

int GetSkillMother( int kind, int skill_mother[], int max )
{
	memset( skill_mother, 0, sizeof( int )*max );
	int count = 0;
	for( int i=0; i<MAX_SKILLMAIN; i++ )
	{
		if( SkillTbl[i].MotherSkillType == kind )
		{
			skill_mother[count++] = i;
		}
	}
	return count;
}

void RecvLearnSkill( t_client_learn_skill *p, t_connection c[], int cn  )		//###1213 荐沥
{
	CHARLIST *ch = CheckServerId( cn );
	if( !ch ) return;

//	ch->Money = GetMoneyByItem( ch );

	int inc = SkillTbl[p->skillno].inclusive;
	int money = SkillTbl[p->skillno].money;

	int skill_mother[20];
	int count_max = GetSkillMother( inc, skill_mother, 20 );

	if( ch->Money < (DWORD)money )
	{
		SendServerResult( CM_LEARNSKILL, 4, cn );
		return; // 捣捞 何练秦...
	}

	int befor_enough = 1;		// 傈窜拌 胶懦阑 肪 50捞惑 劳躯绰啊?
	int check_ability=1;		// 瓷仿 眉农甫 秦具 窍绰啊?

	switch (inc)
	{
		case COOKING:
			{
				if( ch->skillexp[FARMING].skillexp/10000 < 50 && ch->skillexp[FISHING].skillexp/10000 < 50 ) befor_enough=0;
				break;
			}
		case BLACKSMITHY:
			{
				if( ch->skillexp[MINING].skillexp/10000 < 50 )	befor_enough=0;
				break;
			}
		case CANDLEMAKING:
			{
				if( ch->skillexp[FISHING].skillexp/10000 < 50 )	befor_enough=0;
				break;
			}
		case CARPENTRY:	
		case BOWCRAFTING:
			{
				if( ch->skillexp[CUTDOWN].skillexp/10000 < 50 ) befor_enough=0;
				break;
			}
		case TAILORING:
			{
				if( ch->skillexp[BUTCHERING].skillexp/10000 < 50 ) befor_enough=0;
				break;
			}
		case ALCHEMING:
			{
				if( ch->skillexp[HERBDIGGING].skillexp/10000 < 50 ) befor_enough=0;
				break;
			}
		case TAIMING : 
			{	//< CSD-030806
				if (ch->GetLevel() < 35 ) befor_enough = 0;
				check_ability = 0; // 歹捞惑 瓷仿 眉农绰 绝促.
				break;
			}	//> CSD-030806
		case ANIMAL_LORE:
			{
				if( ch->skillexp[TAIMING].skillexp/10000 < 40 ) befor_enough = 0;
				break;
			}
	}

	if( !befor_enough )
	{
		SendServerResult( CM_LEARNSKILL, 3, cn );
		return;
	}

	int ret_learn = 0;
	int error_learn=0;
	for( int i=0 ; i<count_max ; i++ ) 
	{
		int ret = CanLearnSkill( ch, skill_mother[i], check_ability );
		if( ret == 1 ) 
		{
			ch->Skill[skill_mother[i]] = true;
			SendLearnSkillOk(skill_mother[i], c, cn );
			ret_learn = 1;
		}
//		else ret = error_learn;			// Commented by chan78 at 2000/11/28
		else error_learn = ret;			// 001212 YGI
	}

	if( !ret_learn )
	{
		SendServerResult( CM_LEARNSKILL, error_learn, cn );	// 2:捞固 硅奎澜   3:瓷仿捞 何练窃.
		return;
	}
	SubtractMoney( money, ch );
	//SendSubtractMoney( money, cn );

	if( ch->skillexp[inc].skillexp < 50000 ) {ch->skillexp[inc].skillexp = 50000;}
	//011022 lsw >
	SkillMgr.SendSkillExp( inc, ch->skillexp[inc], cn);
	//011022 lsw <

	SendServerResult( CM_LEARNSKILL, 1, cn );
}

void RecvGmRegist( t_packet *p, short int cn, int makemode )
{
	CHARLIST *ch = CheckServerId( cn );
	if( !ch ) {return;}

	const int gm_list_index = p->u.kein.gm_regist.gm_list_index;
	if(0 > gm_list_index || MAX_GM_MAIN <= gm_list_index){return;}

	GM_QUEST *pGmMain = &g_GmMain[gm_list_index];

	const int iSkillNo = pGmMain->skill;

	const int ret = GMMgr.CanGmRegist( gm_list_index, ch );//pGmMain捞 1 何磐聪鳖
	if(0 > ret){return;}//021212 lsw //殿废 阂啊扼搁
	// 酒捞袍 昏力, 捣 昏力 棺 咯矾 贸府
	if(-1 == ::SubtractMoney( pGmMain->need_money, ch ))
	{
		return;//捣档 绝绰霸 你
	}
	for( int i=0; i<MAX_GM_NEED_ITEM_COUNT; i++ )
	{
		const int iItemNo = pGmMain->need_item[i];
		if( iItemNo )
		{
			::SendDeleteItemQuantity( ch, iItemNo, pGmMain->need_quantity[i] );		// 漂沥 酒捞袍阑 漂沥 肮荐父怒 昏力 茄促.
		}
	}

	switch(ret)
	{
	case 1:
	case 2:
	case 3:
		{
			ch->skillexp[iSkillNo].skillexp = 1000000;//011012 lsw
			ch->view_job = gm_list_index;// 焊咯临 流诀阑 GM栏肺 官槽促.
			{// 叼厚 历厘
			t_packet packet;
			packet.h.header.type = CMD_GM_REGIST;
			packet.u.kein.gm_regist_db.gm_list = gm_list_index;
			::strcpy( packet.u.kein.gm_regist_db.name , ch->Name );
			packet.h.header.size = sizeof( k_gm_regist_db );
			QueuePacket(connections, DB_DEMON, &packet, 1);
			}
		}break;
	case 4://扁己狼 版快绰 粱 促福促
		{//扁己篮 叼厚俊 历厘档 救茄促
			t_SkillExp3 *pExp = (t_SkillExp3*)(&ch->skillexp[iSkillNo]);
			pExp->skillType = gm_list_index;
			pExp->year = g_year;
			pExp->day = g_mon*30 +g_day+10;//10老阑 霖促
		}break;
	default:
		{
			return;
		}break;
	}//switch(ret)

	
	SkillMgr.SendSkillExp(iSkillNo,ch->skillexp[iSkillNo],ch->GetServerID());

	//010708 lsw 瘤骏 殿废苞 窃膊 胶懦捞 埃促.
	if(ret==2)
	{
		int iCheckJob = iSkillNo;
		
		int iMy2ndSkillNo = g_GmMain[gm_list_index].skill;
		int iResultGMSkillNumber =-1;
		
		if( ch->skillexp[iCheckJob].skillexp == 1000000)//011012 lsw
		{
			int ok =0;
			switch(iCheckJob)
			{
			case CARPENTRY		:	iResultGMSkillNumber = 106;	ok = 1;
				break;
			case BLACKSMITHY	:	iResultGMSkillNumber = 107;	ok = 1;
				break;
			case COOKING		:	iResultGMSkillNumber = 108;	ok = 1;
				break;
			case TAILORING		:	iResultGMSkillNumber = 109;	ok = 1;															
				break;
			case BOWCRAFTING	:	iResultGMSkillNumber = 110;	ok = 1;
				break;
			case ALCHEMING		:	iResultGMSkillNumber = 111;	ok = 1;
				break;
			case CANDLEMAKING	:	iResultGMSkillNumber = 112;	ok = 1;
				break;
			default:
				ok = 0;
				break;
			}
			if(	ok ==1)
			{
				ch->Skill[iResultGMSkillNumber] = true;
				::SendLearnSkillOk(iResultGMSkillNumber,connections,cn);
			}
		}
	}
	return;
}

const int Convert[2][5]={//020823 lsw
		{RARE_POWER,		RARE_POWER,		RARE_POWER,		RARE_VIGOR,			RARE_POWER},
		{RARE_VIGOR,		RARE_VIGOR,		RARE_VIGOR,		RARE_PIERCING,		RARE_PIERCING}};

bool CorrectRareKind(const int iResultAttr,const int iCompareAttr)
{
	RareMain *result = ((LPRareMain)(&iResultAttr));
	RareMain *compare = ((LPRareMain)(&iCompareAttr));

	const int iResultSok = result->soksung1;
	const int iTargetSok = compare->soksung1;
	
	if( result->grade != compare->grade){return false;}
	if( result->iHighLevel != compare->iHighLevel){return false;}
	if( result->soksung2 != compare->soksung2){return false;}
	if( result->soksung3 != compare->soksung3){return false;}
	if( result->IsDynamicRare != compare->IsDynamicRare){return false;}

	for(int i = 0; i < 5; i++)
	{
		if(	Convert [0][i] == iResultSok)
		{
			if(	Convert [1][i] == iTargetSok)
			{
				return true;
			}
		}
		else if(	Convert [1][i] == iResultSok)
		{
			if(	Convert [0][i] == iTargetSok)
			{
				return true;
			}
		}
	}
	return false;
}
void ConvertRare(RareMain &rare)
{
	for(int i = 0; i < 5; i++)
	{
		if(	Convert [1][i] == rare.soksung1)
		{
			rare.soksung1 = Convert [0][i];
		}
	}
}

void RecvCMD_SKILL_RARE_UPGRADE(const int cn, t_packet *p)
{
	const int iSkillNo	= p->u.SkillRareUpgrade.iSkillNo;
	LPCHARLIST ch		= ::CheckServerId(cn);
	if(!ch)
	{
		return;
	}

	if (!ch->IsPayedUser())
	{
		return;
	}


	float iSuccessRate = 0.000;
	ItemAttr SourceItem = GenerateItem(p->u.SkillRareUpgrade.SourceItem.item_no);

	if( !SourceItem.item_no ) return;

	int iSourceItemMuch = 0;//item_result 波啊 窍唱聪鳖

	unsigned int iResultSok	= 0;
	RareMain TempSokSung;

	CItem *	t = ItemUnit( SourceItem.item_no);
	SourceItem.attr[IATTR_RARE_MAIN] = p->u.SkillRareUpgrade.SourceItem.attr[IATTR_RARE_MAIN];
	memcpy(&TempSokSung,&p->u.SkillRareUpgrade.SourceItem.attr[IATTR_RARE_MAIN],sizeof(int));
	const bool bIsDynamicRare = TempSokSung.IsDynamicRare;
	if( !bIsDynamicRare)
	{
		ConvertRare(TempSokSung);
	}

	if( !t ){return;}

	WORD now =0, max =0, nowtemp=0, maxtemp=0;
	DWORD resultdur =0;
	

	int why = 0;
	int resourcelimit[MAX_UPGRADE_RARE] = {0,};
	
	int a[4] = {0,};//additem 1~4
	int al[4] = {0,};//additem Limit 1~4
	int HaveResource[4] = {0,};//鞘夸 酒捞袍捞 乐唱

	const int iKind = t->GetItemKind();
	const int AddItem[4] ={	ItemMutantKind[iKind].AddItem[0]/100,
							ItemMutantKind[iKind].AddItem[1]/100,
							ItemMutantKind[iKind].AddItem[2]/100,
							ItemMutantKind[iKind].AddItem[3]/100};

	POS pos;
	ItemAttr *i;
	int iIsCracked =0;
	for (int ti = 0; ti < MAX_UPGRADE_RARE ; ti++)//胶懦阑 矫档茄 酒捞袍阑 葛炼府 瘤款促
	{
		pos = p->u.SkillRareUpgrade.pos[ti];
		switch( pos.type )
		{
		case INV :		i = &ch->inv[pos.p1][pos.p2][pos.p3];	break;
		case EQUIP :	i = &ch->equip[pos.p3];					break;
		case QUICK :	i = &ch->quick[pos.p3];					break;
		default: continue; break;
		}
		
		LPRareMain pRare = ((LPRareMain)(&SourceItem.attr[IATTR_RARE_MAIN]));

		if( i->item_no )
		{
			if( SourceItem.item_no == i->item_no )//011224 lsw
			{
				if( 0 != pRare->iHighLevel )//饭绢 酒捞袍捞 酒聪搁(敲矾胶 酒捞袍捞芭唱 
				{
					iIsCracked = 1;//窍捞 酒捞袍 诀臂 窍妨搁
				}
				if( pRare->soksung2
				||	pRare->soksung3)
				{
					iIsCracked = 1;//钢萍饭绢 诀臂 窍妨搁 //0211120 lsw
				}

				if( SourceItem.attr[IATTR_RARE_MAIN] != i->attr[IATTR_RARE_MAIN] )
				{
					if(!CorrectRareKind(SourceItem.attr[IATTR_RARE_MAIN],i->attr[IATTR_RARE_MAIN]))
					{