Skill Caps and Start Skills

[mollymillions]

I am not a C++ coder and had to do a fair amount of homework before I could start coding this.

For the db records where level = 0, the CAP value will be the start skill value for the skill and the FORMULA value will be used as the offset for the skill cap calculations (skillcap = offset + level * formula).

I need to finalise the start skills and formula offsets in these tables. I will get them inline with what was used previously and re-post in the near future.

MaxSkills.h is no longer needed, although I put the call to the new MaxSkill calc here as it required changing less lines of code. The existing Class_Skill table is no longer used.

All the new code will handle skill values > 255 but there is a check in GetMaxSkill to ensure none are returned greater then 252 as values > 252 may cause the skill succsess calcs to fail? I am pretty sure that all of the skill value = 254 or 255 checks have been removed, to allow for implementation of skill values greater than 255 in the future.

I added the following references to databse.h:

#include "../common/classes.h"
#include "../common/races.h"
#include "../common/skills.h"

to allow the use of the following global(?) constants:

PLAYER_CLASS_COUNT
HIGHEST_SKILL
LEVEL_CAP
Count_Array_Race


ToDo:
-The lists should be moved into SharedMem.
-The misc language skills are not getting handled correctly ATM.
-Free the array memeory in the Zone and World destructors?

http://members.dodo.net.au/~mollymil...lassSkills.sql
http://members.dodo.net.au/~mollymil...RaceSkills.sql

[mollymillions]

---------------------------------
insert \zone\net.cpp -line 200 ish
---------------------------------
	LogFile->write(EQEMuLog::Status, "Loading skill caps");
	database.LoadClassSkill(false);
	database.LoadClassSkill(true);
--------------------------------
replace \zone\mob.h -line 275 ish
--------------------------------
	int8			MaxSkill(int16 skillid, int16 class_, int16 race, int16 level);
	inline int8	MaxSkill(int16 skillid) { return MaxSkill(skillid, GetClass(), GetRace(), GetLevel()); }
 
--------------------------------------
replace \zone\maxskill.h -line 2050 ish
--------------------------------------
	int8 Mob::MaxSkill(int16 skillid, int16 class_, int16 Race, int16 level) {
		return database.GetMaxSkill(skillid, class_, race, level);
	}
 
-------------------------
insert \common\Database.h
-------------------------
#include "../common/classes.h"
#include "../common/races.h"
#include "../common/skills.h"
-----------------------------------------------
insert/replace \common\Database.h -line 500 ish
-----------------------------------------------
	int16 CalcSkill(int16 classraceid, int8 skillid, int8 startlevel, int8 endlevel, int16 skillcap, int16 increment, int16 skillvalue, bool RaceMode);
	void	LoadClassSkill(bool RaceMode);
	void	DumpSkills();
	int16 GetClassSkill(int8 skillid, int8 classid, int16 level);
	int16 GetRaceSkill(int8 skillid, int16 raceid, int16 level);
	int16 GetMaxSkill(int8 skillid, int8 class_, int16 race, int16 level);
	uint16 class_skill[PLAYER_CLASS_COUNT * (HIGHEST_SKILL+1) * (LEVEL_CAP+1)];
	uint16 race_skill[Count_Array_Race * (HIGHEST_SKILL+1) * (LEVEL_CAP+1)]; 
	int16 GetTrainlevel(int16 eqrace, int16 eqclass, int8 skill_id); 
 
--------------------------------------------
replace \common\Database.cpp -line 5670 ish
--------------------------------------------
int16 Database::GetTrainlevel(int16 eqrace, int16 eqclass, int8 skill_id) {
 
	//is the skill trainable? 
	if(GetMaxSkill(skill_id, eqclass, eqrace, LEVEL_CAP)==0)		
		return LEVEL_CAP+1; // Untrainable
 
	//skill is trainable so get the level? 
	for (int level = 1;level<LEVEL_CAP;level++) {
		if (GetMaxSkill(skill_id, eqclass, eqrace, level)>0) 
			return level;		 
	}
 
	//catch
	return LEVEL_CAP+1; // Untrainable 
}
-----------------
Insert \common\Database.cpp -line 6020 ish
-----------------
void Database::LoadClassSkill(bool RaceMode) {	 
	char errbuf[MYSQL_ERRMSG_SIZE];
	char *query = 0;
	MYSQL_RES *result;
	MYSQL_ROW row;
	char* sql;
 
	int8 KEY_COUNT;
	int8 skill_level = 0, skill_formula = 0;		
	int8 skillid=255, newskillid=255; 
	int8 level=1, newlevel=0;
	int16 increment = 0, newincrement = 0, offset = 5;
	int16 skillvalue=0, skillcap = 0, newskillcap = 0;
	int16 classraceid=255, newclassraceid=255;
	if (RaceMode) {
		KEY_COUNT = Count_Array_Race-1;
		sql = "SELECT race, skill, level, formula, cap FROM raceskills ORDER BY race, skill, level";
	} else {
		KEY_COUNT = PLAYER_CLASS_COUNT;
		sql = "SELECT class, skill, level, formula, cap FROM classskills ORDER BY class, skill, level"; 
	}
 
	//Default all caps to 0 (todo: use calloc() to initialize the array with zeros)
	int16 ubound = (KEY_COUNT * (HIGHEST_SKILL+1) * (LEVEL_CAP+1));
	for (int16 i=0; i<ubound;i++) {
		if (RaceMode)
			race_skill[i]=0;	
		else
			class_skill[i]=0; 
	}
 
	if (database.RunQuery(query, MakeAnyLenString(&query, sql), errbuf, &result)) {	 
		safe_delete_array(query);
 
		while((row = mysql_fetch_row(result))) {							
 
			newclassraceid = atoi(row[0]);
			newskillid = atoi(row[1]);
			newlevel = atoi(row[2]);
			newincrement = atoi(row[3]);
			newskillcap = atoi(row[4]);
 
			if (RaceMode) 
				newclassraceid = (int16)GetArrayRace(newclassraceid);
			if (newlevel > LEVEL_CAP+1)
				newlevel = LEVEL_CAP+1;
 
			if ((newclassraceid != classraceid) || (newskillid != skillid)){
 
				//finalise the previous classskill							 
				if ((classraceid <= KEY_COUNT) && (skillid <= HIGHEST_SKILL) && (level >0) && (skillcap > 0)){									 
					skillvalue = CalcSkill(classraceid, skillid, level,(int8)(LEVEL_CAP+1), skillcap, increment, skillvalue, RaceMode);
				}
 
				offset = 5; //default formula offset
				increment = 0;
				skillcap = 0;
				skillvalue = 0;
				level = 1;			 
			}
			if ((newclassraceid < KEY_COUNT+1) && (newskillid < HIGHEST_SKILL+1)) {			 
 
				if (newlevel == 0){				 
 
					//write the start skill and get the formula offset				 
					CalcSkill(newclassraceid, newskillid, newlevel,(int8)(1), newskillcap, 0, newskillcap, RaceMode);
					offset = newincrement; 
					level = 0;
				}
				else if(level > 0){ 
					if (skillvalue == 0)						
						skillvalue = offset;
 
					skillvalue = CalcSkill(newclassraceid, newskillid, level, newlevel, skillcap, newincrement, skillvalue, RaceMode);				 
				} 
				skillcap = newskillcap;
				increment = newincrement;
				level = newlevel;
				classraceid = newclassraceid;
				skillid = newskillid;
			}					 
		}
		mysql_free_result(result);
 
		//finalise the previous class/race skill								
		if ((classraceid <= KEY_COUNT) && (skillid <= HIGHEST_SKILL) && (level >0) && (skillcap > 0))							 
			skillvalue = CalcSkill(classraceid, skillid, level,(int8)(LEVEL_CAP+1), skillcap, increment, skillvalue, RaceMode);
	}
	else
		LogFile->write(EQEMuLog::Error, "Error in LoadClassSkillCaps query %s: %s", query, errbuf);
 
	safe_delete_array(query);
}
int16 Database::CalcSkill(int16 classraceid, int8 skillid, int8 level, int8 endlevel, int16 skillcap, int16 increment, int16 skillvalue, bool RaceMode) {
 
	//All paramaters must be validated before the call 
	while(level < endlevel) { 
		skillvalue = skillvalue + increment;
		if (skillvalue > skillcap)
			skillvalue=skillcap;						
 
		if (RaceMode) 
			race_skill[(classraceid-1) * ((HIGHEST_SKILL+1) * (LEVEL_CAP+1)) + skillid * (LEVEL_CAP+1) + level] = skillvalue;			 
		else
			class_skill[(classraceid-1) * ((HIGHEST_SKILL+1) * (LEVEL_CAP+1)) + skillid * (LEVEL_CAP+1) + level] = skillvalue;					 
		level++;
	}
	return skillvalue;
}
int16 Database::GetClassSkill(int8 skillid, int8 classid, int16 level)
{
	if (classid > 0 && classid <= PLAYER_CLASS_COUNT && skillid >= 0 && skillid <= HIGHEST_SKILL && level >= 0 && level <= LEVEL_CAP) 
		return class_skill[(classid-1) * ((HIGHEST_SKILL+1) * (LEVEL_CAP+1)) + skillid * (LEVEL_CAP+1) + level];		
	else
		return 0;
}
int16 Database::GetRaceSkill(int8 skillid, int16 raceid, int16 level)
{
	(int16)raceid = GetArrayRace(raceid);
	if (raceid > 0 && raceid < Count_Array_Race && skillid >= 0 && skillid <= HIGHEST_SKILL && level >= 0 && level <= LEVEL_CAP) 
		return race_skill[(raceid-1) * ((HIGHEST_SKILL+1) * (LEVEL_CAP+1)) + skillid * (LEVEL_CAP+1) + level];
	else
		return 0;
}
int16 Database::GetMaxSkill(int8 skillid, int8 class_, int16 race, int16 level) {
 
	//Handle GM classes 
	if (class_>19)
		class_ = class_-19;
 
	int16 ClassSkill = database.GetClassSkill(skillid,class_,level);
	int16 RaceSkill = database.GetRaceSkill(skillid,race,level);	
 
	//Get the greater of the race or class cap 
	if (RaceSkill > ClassSkill) {
		if (RaceSkill > 252)
			RaceSkill = 252;
		return RaceSkill; 
	} else {
		if (ClassSkill > 252)
			ClassSkill = 252;
		return ClassSkill;
	}
} 
----------------------------
replace \zone\doors.cpp -line 180 ish
----------------------------
			else
			{ // door is locked, either no key works for it or player doesn't have the key - try to pick it
				if(sender->MaxSkill(35, sender->GetClass(), sender->GetRace(), sender->GetLevel())>0 && GetLockpick()!=0)
				{ // client has the lock pick skill and this lock can be picked

[mollymillions]

-----------------------------
Replace \zone\client_process.cpp -line 1275 ish
-----------------------------
else if (gmskill->skillbank == 0x00)
	{
		// normal skills go here
		if (gmskill->skill_id > HIGHEST_SKILL)
		{
			cout << "Wrong Training Skill (abilities)" << endl;
			DumpPacket(app);
			return;
		}
		int8 skilllevel = GetRawSkill(gmskill->skill_id);
		//if ( skilllevel == 255)
		//{
		//  // Client never gets this skill; check for gm status or fail
		//  return;
		//}
		//else if (skilllevel == 254)
		//{
		//  // Client training new skill for the first time set the skill to level-1
		//  int16 t_level = database.GetTrainlevel(GetClass(), gmskill->skill_id);
		//  //cout<<"t_level:"<<t_level<<endl;
		//  if (t_level == 66 || t_level == 0)
		//  {
		//	  return;
		//  }
		//  //m_pp.skills[gmskill->skill_id + 1] = t_level;
		//  SetSkill(gmskill->skill_id, t_level);
		//}
		if (skilllevel == 0) {
			int16 t_level = database.GetTrainlevel(GetRace(), GetClass(), gmskill->skill_id);		   
			if (t_level == 66 || t_level == 0)
			{
				return;
			}
			SetSkill(gmskill->skill_id, t_level);
		}
		else if (skilllevel <= 251)
		{
			// Client train a valid skill
			// FIXME If the client doesn't do the "You are more skilled than I" check we should do it here
			SetSkill(gmskill->skill_id, skilllevel + 1);
		}
		else
		{
			// Log a warning someones been hacking
			LogFile->write(EQEMuLog::Error, "OP_GMTrainSkill: failed client: %s", GetName());
			return;
		}
		
-----------------
replace \zone\client_packet.cpp -line 5800 ish (redundant code)
-----------------
	////validate skills
	//for (int sk = 1; sk < MAX_PP_SKILL; sk++) {
	//  //int cap = GetSkillCap(sk-1);
	//  //int cap = MaxSkill(sk-1, GetClass(), GetLevel());
	//  int cap = MaxSkill( sk-1, GetClass(), GetRace(), GetLevel());
	//  if (cap >= 254)
	//	  m_pp.skills[sk] = cap;
	//}	 
----------------------------
insert \world\net.cpp -line 205 ish
----------------------------
	LogFile->write(EQEMuLog::Status, "Loading start skills..");
	database.LoadClassSkill(false);
	database.LoadClassSkill(true);  
	
--------------
insert \world\client.h -line 70 ish
--------------
	void SetClassStartingSkills( PlayerProfile_Struct *pp ); //nolonger used
	void SetRaceStartingSkills( PlayerProfile_Struct *pp ); //nolonger used
	void SetStartingSkills( PlayerProfile_Struct *pp );
			
-------------------------------
insert \world\client.cpp -line 1300 ish
--------------------------------
void Client::SetStartingSkills( PlayerProfile_Struct *pp )
{ 
	for (int8 skill=0;skill<=HIGHEST_SKILL;skill++) {	   
		StartSkill = database.GetMaxSkill(skill,(int8)(pp->class_),(int16)(pp->race),0);	
		if (StartSkill > 0) 
				pp->skills[skill+1] = StartSkill;	   
	}
}