607 lines
20 KiB
C++
607 lines
20 KiB
C++
/*
|
|
Rose Online Server Emulator
|
|
Copyright (C) 2006,2007 OSRose Team http://www.osrose.net
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
developed with Main erose/hrose source server + some change from the original eich source
|
|
*/
|
|
#include "character.h"
|
|
#include "worldserver.h"
|
|
|
|
// return true if this character is monster
|
|
bool CCharacter::IsMonster( )
|
|
{
|
|
if(CharType == 2 || CharType == 3)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// return true if this character is player
|
|
bool CCharacter::IsPlayer( )
|
|
{
|
|
if(CharType == 1)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
//return true if this character is an NPC
|
|
bool CCharacter::IsNPC( )
|
|
{
|
|
if(CharType == 4)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// return true if HP is lower to 1
|
|
bool CCharacter::IsDead( )
|
|
{
|
|
if(Stats->HP <= 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// return true if this character is summon
|
|
bool CCharacter::IsSummon( )
|
|
{
|
|
if(this == NULL) return false;
|
|
if(CharType == 3)// this line is erroring. No idea why
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// Virtual function [return item drop]
|
|
CDrop* CCharacter::GetDrop( )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// start action [attack]
|
|
void CCharacter::StartAction( CCharacter* Target, BYTE action, UINT skillid)
|
|
{
|
|
|
|
BEGINPACKET( pak, 0 );
|
|
switch(action)
|
|
{
|
|
case NORMAL_ATTACK:
|
|
{
|
|
//Log( MSG_INFO, "case NORMAL_ATTACK");
|
|
if(Target == NULL)return;
|
|
RESETPACKET( pak, 0x798 );
|
|
ADDWORD ( pak, clientid );
|
|
ADDWORD ( pak, Target->clientid );
|
|
ADDWORD ( pak, Stats->Move_Speed );
|
|
ADDFLOAT ( pak, Target->Position->current.x * 100 );
|
|
ADDFLOAT ( pak, Target->Position->current.y * 100 );
|
|
Battle->target = Target->clientid;
|
|
Battle->atktarget = Target->clientid;
|
|
Battle->atktype = action;
|
|
Battle->skilltarget = 0;
|
|
Battle->bufftarget = 0;
|
|
Battle->skillid = 0;
|
|
Position->destiny = Target->Position->current; //move to intercept target
|
|
Position->lastMoveTime = clock();
|
|
//Log(MSG_DEBUG,"Normal Attack set destiny X: %f Y: %f.",Position->current.x,Position->current.y);
|
|
}
|
|
break;
|
|
case SKILL_ATTACK: //Log( MSG_INFO, "case SKILL_ATTACK");
|
|
case SKILL_BUFF:
|
|
{
|
|
if(Target == NULL)return;
|
|
RESETPACKET( pak, 0x7b3 );
|
|
ADDWORD ( pak, clientid );
|
|
ADDWORD ( pak, Target->clientid );
|
|
ADDWORD ( pak, skillid );
|
|
ADDWORD ( pak, 0x0000 );
|
|
ADDFLOAT ( pak, Target->Position->current.x * 100 );
|
|
ADDFLOAT ( pak, Target->Position->current.y * 100 );
|
|
Battle->target = Target->clientid;
|
|
|
|
if(action == SKILL_ATTACK)
|
|
{
|
|
//Log( MSG_INFO, "case SKILL_ATTACK");
|
|
Battle->skilltarget = Target->clientid;
|
|
Battle->bufftarget = 0;
|
|
}
|
|
else
|
|
{
|
|
//Log( MSG_INFO, "case SKILL_BUFF");
|
|
Battle->bufftarget = Target->clientid;
|
|
Battle->skilltarget = 0;
|
|
}
|
|
|
|
Battle->atktype = action;
|
|
Position->destiny = Target->Position->current; //move toward target
|
|
Battle->skillid = skillid;
|
|
Position->lastMoveTime = clock();
|
|
//Log(MSG_DEBUG,"Skill Attack set destiny X: %f Y: %f.",Position->current.x,Position->current.y);
|
|
}
|
|
break;
|
|
case SKILL_AOE://Log( MSG_INFO, "case SKILL_AOE");
|
|
case BUFF_SELF://Log( MSG_INFO, "case BUFF_SELF");
|
|
case BUFF_AOE:
|
|
{
|
|
|
|
//Log( MSG_INFO, "Battle set for skill %i Action = %i", skillid, action);
|
|
//Log( MSG_INFO, "case BUFF_AOE");
|
|
RESETPACKET( pak, 0x7b2);
|
|
ADDWORD ( pak, clientid );
|
|
ADDWORD ( pak, skillid );
|
|
Battle->atktype = action;
|
|
Battle->skillid = skillid;
|
|
Position->skilltargetpos.x = Position->current.x;
|
|
Position->skilltargetpos.y = Position->current.y;
|
|
//Log( MSG_INFO, "BUFF_AOE packet sent");
|
|
}
|
|
break;
|
|
case AOE_TARGET:
|
|
{
|
|
//Log( MSG_INFO, "case AOE_TARGET");
|
|
//Target is NULL for this function when cast by a player
|
|
//Target is NOT NULL when it comes from a monster
|
|
if(Target != NULL) //monster attack
|
|
{
|
|
Position->skilltargetpos.x = Target->Position->current.x;
|
|
Position->skilltargetpos.y = Target->Position->current.y;
|
|
}
|
|
RESETPACKET( pak, 0x7b4 );
|
|
ADDWORD ( pak, clientid );
|
|
ADDWORD ( pak, skillid );
|
|
ADDFLOAT ( pak, Position->skilltargetpos.x * 100 );
|
|
ADDFLOAT ( pak, Position->skilltargetpos.y * 100 );
|
|
Battle->atktype = action;
|
|
Battle->skillid = skillid;
|
|
Battle->skilltarget = 0;
|
|
Battle->bufftarget = 0;
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
break;
|
|
}
|
|
GServer->SendToVisible( &pak, this );
|
|
Battle->contatk = true;
|
|
|
|
//Log(MSG_INFO,"Battle Attacktype = %i",Battle->atktype);
|
|
return;
|
|
}
|
|
|
|
bool CCharacter:: IsOnBattle( )
|
|
{
|
|
if(Battle->atktype == 0)
|
|
{
|
|
if(Battle->iscasting == 1)
|
|
{
|
|
clock_t etime = clock() - Battle->lastAtkTime;
|
|
if( etime < CLOCKS_PER_SEC * 100 / Stats->Attack_Speed )
|
|
{
|
|
//Log(MSG_DEBUG,"Iscasting is true while NOT in battle. Reset to false.");
|
|
Battle->iscasting = 0;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
switch(Battle->atktype)
|
|
{
|
|
case 1: //NORMAL_ATTACK:
|
|
{
|
|
if(Battle->atktarget != 0) return true;
|
|
}
|
|
break;
|
|
case 2: //SKILL_ATTACK:
|
|
case 8: //AOE_TARGET:
|
|
{
|
|
if(Battle->skilltarget != 0 && Battle->skillid != 0) return true;
|
|
}
|
|
break;
|
|
case 3: //SKILL_BUFF:
|
|
{
|
|
if(Battle->bufftarget != 0 && Battle->skillid != 0) return true;
|
|
}
|
|
break;
|
|
case 4: //SKILL_AOE:
|
|
//case SKILL_SELF: //no such skill type
|
|
case 6: //BUFF_SELF:
|
|
case 7: //BUFF_AOE:
|
|
{
|
|
if(Battle->skillid != 0) return true;
|
|
}
|
|
break;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
bool CCharacter::CanAttack( )
|
|
{
|
|
|
|
clock_t etime = clock() - Battle->lastAtkTime;
|
|
if(CharType == 4) //it's an npc
|
|
{
|
|
|
|
//Log(MSG_DEBUG, "It's an NPC so set speed to 1");
|
|
//always return true for an NPC
|
|
Stats->Attack_Speed = 1;
|
|
}
|
|
if (Stats->Attack_Speed < 1)
|
|
{
|
|
|
|
Log( MSG_INFO, "weapon with no attackspeed.");
|
|
return false;
|
|
}
|
|
if(Battle->iscasting == 1)
|
|
{
|
|
if( etime < CLOCKS_PER_SEC * GServer->Config.SkillMult / Stats->Attack_Speed ) //should make the delay 4 times longer
|
|
{
|
|
//Log(MSG_INFO,"Cannot attack yet. Last attack time = %i",Battle->lastAtkTime);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
Log(MSG_INFO,"iscasting reset to 0 after time delay");
|
|
Battle->iscasting = 0;
|
|
Battle->NextAtkTime = Battle->lastAtkTime + (CLOCKS_PER_SEC * GServer->Config.SkillMult / Stats->Attack_Speed);
|
|
return true;
|
|
}
|
|
}
|
|
else //normal attack
|
|
{
|
|
if( etime < CLOCKS_PER_SEC * GServer->Config.AttkMult / Stats->Attack_Speed )
|
|
{
|
|
//Log(MSG_INFO,"Cannot attack yet. Last attack time = %i",Battle->lastAtkTime);
|
|
return false;
|
|
}
|
|
}
|
|
Battle->NextAtkTime = Battle->lastAtkTime + (CLOCKS_PER_SEC * GServer->Config.SkillMult / Stats->Attack_Speed);
|
|
return true;
|
|
}
|
|
|
|
// return true if target is reached
|
|
bool CCharacter::IsTargetReached( CCharacter* Enemy, CSkills* skill )
|
|
{
|
|
CMap* map = GServer->MapList.Index[Position->Map];
|
|
if(map == NULL)
|
|
return true;
|
|
float distance = GServer->distance( Position->current, Enemy->Position->current );
|
|
|
|
if(skill == NULL) //it's a normal attack
|
|
{
|
|
if(distance <= Stats->Attack_Distance)
|
|
{
|
|
Position->destiny = Position->current;
|
|
//Log(MSG_DEBUG,"(istargetreached) Destiny set to current position X: %f Y: %f.",Position->current.x,Position->current.y);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Position->destiny = Enemy->Position->current;
|
|
//Log(MSG_DEBUG,"(istargetreached) Destiny set to Enemy position X: %f Y: %f.",Position->current.x,Position->current.y);
|
|
}
|
|
}
|
|
else // skill attack
|
|
{
|
|
float SkillRange = (float)skill->range;
|
|
if(SkillRange == 0)
|
|
{
|
|
SkillRange = Stats->Attack_Distance;
|
|
}
|
|
if(distance <= SkillRange)
|
|
{
|
|
Position->destiny = Position->current;
|
|
//Log(MSG_DEBUG,"(istargetreached skill) Destiny set to current position X: %f Y: %f.",Position->current.x,Position->current.y);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Position->destiny = Enemy->Position->current;
|
|
//Log(MSG_DEBUG,"(istargetreached skill) Destiny set to Enemy position X: %f Y: %f.",Position->current.x,Position->current.y);
|
|
//Log(MSG_DEBUG,"(istargetreached skill) Distance: %f range: %i.", distance, SkillRange);
|
|
}
|
|
}
|
|
//Log(MSG_INFO,"(istargetreached) Cannot attack. Too far away");
|
|
return false;
|
|
}
|
|
|
|
// return true if the character is moving
|
|
bool CCharacter::IsMoving( )
|
|
{
|
|
if(Position->current.x == Position->destiny.x && Position->current.y == Position->destiny.y )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// VIRTUAL [add player damage]
|
|
void CCharacter::AddDamage( CCharacter* enemy, long int hitpower)
|
|
{
|
|
|
|
}
|
|
|
|
// return character target
|
|
CCharacter* CCharacter::GetCharTarget( )
|
|
{
|
|
CCharacter* thistarget = GServer->MapList.Index[Position->Map]->GetCharInMap( Battle->target );
|
|
if (thistarget != NULL)
|
|
{
|
|
//Log(MSG_DEBUG, "getchartarget found target OK");
|
|
return thistarget;
|
|
}
|
|
//Log(MSG_DEBUG, "getchartarget failed to find target");
|
|
//if I don't currently have a target then return the character who just hit me
|
|
return GServer->MapList.Index[Position->Map]->GetCharInMap( Battle->hitby );
|
|
}
|
|
|
|
// VIRTUAL [reduce ammon/bullets/cannons]
|
|
void CCharacter::ReduceABC( )
|
|
{
|
|
|
|
}
|
|
|
|
// VIRTUAL [get extra buff value]
|
|
int CCharacter::GetEVBuff( )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// VIRTUAL [return intelligence]
|
|
unsigned int CCharacter::GetInt( )
|
|
{
|
|
return 15;
|
|
}
|
|
|
|
|
|
// Check For Debuffs
|
|
void CCharacter::RefreshBuff( )
|
|
{
|
|
bool bflag = false;
|
|
for( UINT i=0;i<30;i++)
|
|
{
|
|
if(MagicStatus[i].Buff == 0) continue;
|
|
clock_t etime = clock() - MagicStatus[i].BuffTime;
|
|
if( etime >= MagicStatus[i].Duration * CLOCKS_PER_SEC )
|
|
{
|
|
switch(MagicStatus[i].Status)
|
|
{
|
|
case 18: // attack power up
|
|
case 19: // attack power down
|
|
case 48: // attack power up
|
|
if(i<15)
|
|
Status->Attack_up = 0xff;
|
|
else
|
|
Status->Attack_down = 0xff;
|
|
Stats->Attack_Power = GetAttackPower( );
|
|
break;
|
|
case 20: // def up
|
|
case 21: // def down
|
|
case 49: // def up
|
|
if(i<15)
|
|
Status->Defense_up= 0xff;
|
|
else
|
|
Status->Defense_down = 0xff;
|
|
Stats->Defense = GetDefense( );
|
|
break;
|
|
case 24: //accuracy up
|
|
case 25: //accuracy down
|
|
case 51: //attack accuracy up.
|
|
if(i<15)
|
|
Status->Accury_up= 0xff;
|
|
else
|
|
Status->Accury_down = 0xff;
|
|
Stats->Accury = GetAccury( );
|
|
break;
|
|
case 22: // macic resistance up
|
|
case 23: // magic resistance down
|
|
case 50: // magic resistance up
|
|
if(i<15)
|
|
Status->Magic_Defense_up = 0xff;
|
|
else
|
|
Status->Magic_Defense_down = 0xff;
|
|
Stats->Magic_Defense = GetMagicDefense( );
|
|
break;
|
|
case 28: //dodge up
|
|
case 29: //dodge down
|
|
case 53: //dodge rate up
|
|
if(i<15)
|
|
Status->Dodge_up = 0xff;
|
|
else
|
|
Status->Dodge_down = 0xff;
|
|
Stats->Dodge = GetDodge( );
|
|
break;
|
|
case 14: //dash
|
|
case 15: //slow
|
|
case 46: //movement speed increased
|
|
if(i<15)
|
|
Status->Dash_up = 0xff;
|
|
else
|
|
Status->Dash_down = 0xff;
|
|
Stats->Move_Speed = GetMoveSpeed( );
|
|
break;
|
|
case 16: // haste attack
|
|
case 17: // slow attack
|
|
case 47: // attack speed up
|
|
if(i<15)
|
|
Status->Haste_up = 0xff;
|
|
else
|
|
Status->Haste_down = 0xff;
|
|
Stats->Attack_Speed = GetAttackSpeed( );
|
|
break;
|
|
case 26: // crit up
|
|
case 27: // crit down
|
|
case 52: // crit up
|
|
if(i<15)
|
|
Status->Critical_up = 0xff;
|
|
else
|
|
Status->Critical_down = 0xff;
|
|
Stats->Critical = GetCritical( );
|
|
break;
|
|
case 12: // max HP up
|
|
case 44: // max HP up
|
|
if(i<15)
|
|
Status->HP_up = 0xff;
|
|
else
|
|
Status->HP_down = 0xff;
|
|
Stats->MaxHP = GetMaxHP( );
|
|
break;
|
|
case 13: // max MP up
|
|
case 45: // max MP up
|
|
if(i<15)
|
|
Status->MP_up = 0xff;
|
|
else
|
|
Status->MP_down = 0xff;
|
|
Stats->MaxMP = GetMaxMP( );
|
|
break;
|
|
case 32: // faint
|
|
Status->Stuned = 0xff;
|
|
Status->CanAttack = true;
|
|
//printf("removing stun\n");
|
|
break;
|
|
case 7: case 8: case 9: case 10: case 11: //poisoned
|
|
Status->Poisoned = 0xff;
|
|
//printf("removing poison\n");
|
|
break;
|
|
case 30: // muted
|
|
Status->Muted = 0xff;
|
|
Status->CanCastSkill = true;
|
|
break;
|
|
case 31: // sleep May need to be fixed later to accomodate multiple status effects.
|
|
Status->Sleep = 0xff;
|
|
Status->CanMove = true;
|
|
Status->CanCastSkill = true;
|
|
Status->CanAttack = true;
|
|
break;
|
|
case 54: //A_GMExtra_Damage:
|
|
case 36: //A_Extra_Damage:
|
|
if(i<15)
|
|
{
|
|
Status->ExtraDamage_up = 0xff;
|
|
Stats->ExtraDamage = 0xff;
|
|
}
|
|
else
|
|
{
|
|
Status->ExtraDamage_down = 0xff;
|
|
Stats->ExtraDamage = 0xff;
|
|
}
|
|
|
|
break;
|
|
case 56: // Taunt
|
|
Status->Taunt = 0xff;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
MagicStatus[i].Status = 0;
|
|
MagicStatus[i].Buff = 0;
|
|
MagicStatus[i].BuffTime = 0;
|
|
MagicStatus[i].Duration = 0;
|
|
MagicStatus[i].Value = 0;
|
|
bflag = true;
|
|
}
|
|
else if (MagicStatus[i].Status >= 7 && MagicStatus[i].Status <= 11 && etime > 1*CLOCKS_PER_SEC) //Do poison dmg every 1.5 seconds
|
|
{
|
|
Stats->HP -= MagicStatus[i].Status; //Actually take 7, 8, 9, 10 or 11 from the health. Based on the Status itself
|
|
MagicStatus[i].BuffTime += 1*CLOCKS_PER_SEC;
|
|
MagicStatus[i].Duration -= 1;
|
|
//printf("did %i poison dmg to the player, still %i seconds and %i HP remain \n", MagicStatus[i].Status, MagicStatus[i].Duration, Stats->HP);
|
|
|
|
//A bunch of messy code to send dmg packet
|
|
BEGINPACKET( pak, 0x7b6 );
|
|
ADDWORD ( pak, clientid ); // client taking damage
|
|
ADDWORD ( pak, 0 ); // client doing damage
|
|
ADDDWORD ( pak, 0x000007f8 );
|
|
ADDBYTE ( pak, 0x00 );
|
|
if (Stats->HP < 1)
|
|
{
|
|
ADDWORD ( pak, MagicStatus[i].Status + 0x8000 );
|
|
}
|
|
else
|
|
{
|
|
ADDWORD ( pak, MagicStatus[i].Status + 0x2000 );
|
|
}
|
|
//ADDDWORD ( pak, MagicStatus[i].Status ); //damage amount
|
|
|
|
//If poisoned entity (player or monster) is killed
|
|
if( IsDead())
|
|
{
|
|
//printf("char died\n");
|
|
Log( MSG_INFO, "found dead monster");
|
|
CDrop* thisdrop = NULL;
|
|
CMap* map = GServer->MapList.Index[thisdrop->posMap];
|
|
ADDDWORD ( pak, 16 );
|
|
if( !IsSummon( ) && !IsPlayer( ))
|
|
{
|
|
thisdrop = GetDrop( );
|
|
if( thisdrop != NULL)
|
|
{
|
|
map->AddDrop( thisdrop );
|
|
}
|
|
}
|
|
GServer->SendToVisible( &pak, this ); // removed thisdrop from the packet
|
|
//kill the monster if its HP is less than 0
|
|
BEGINPACKET( pak1, 0x799 );
|
|
ADDWORD ( pak1, clientid );
|
|
ADDWORD ( pak1, clientid );
|
|
ADDDWORD ( pak1, 0x8005 );
|
|
GServer->SendToVisible( &pak1, this );
|
|
}
|
|
|
|
//If enemy is still alive
|
|
else
|
|
{
|
|
ADDDWORD ( pak, 4 );
|
|
GServer->SendToVisible( &pak, this );
|
|
}
|
|
}
|
|
}
|
|
if(bflag)
|
|
{
|
|
BEGINPACKET( pak,0x7b7 );
|
|
ADDWORD ( pak, clientid );
|
|
ADDDWORD ( pak, GServer->BuildBuffs( this ) );
|
|
GServer->SendToVisible( &pak, this );
|
|
}
|
|
}
|
|
|
|
// VIRTUAL [return party pointer]
|
|
CParty* CCharacter::GetParty( )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// VIRTUAL [return clan pointer]
|
|
CLAN* CCharacter::GetClan( )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
bool CCharacter::IsAttacking( )
|
|
{
|
|
if(IsOnBattle( ))
|
|
{
|
|
switch(Battle->atktype)
|
|
{
|
|
case SKILL_BUFF:
|
|
case BUFF_SELF:
|
|
case BUFF_AOE:
|
|
return false;
|
|
default:
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
else return false;
|
|
}
|