?? pet.c
字號:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "db.h"
#include "timer.h"
#include "pc.h"
#include "map.h"
#include "intif.h"
#include "clif.h"
#include "chrif.h"
#include "socket.h"
#include "pet.h"
#include "itemdb.h"
#include "battle.h"
#include "mob.h"
#include "npc.h"
#include "script.h"
#ifdef MEMWATCH
#include "memwatch.h"
#endif
#define MIN_PETTHINKTIME 100
struct pet_db pet_db[MAX_PET_DB];
static int dirx[8]={0,-1,-1,-1,0,1,1,1};
static int diry[8]={1,1,0,-1,-1,-1,0,1};
static int pet_timer(int tid,unsigned int tick,int id,int data);
static int pet_walktoxy_sub(struct pet_data *pd);
static int distance(int x0,int y0,int x1,int y1)
{
int dx,dy;
dx=abs(x0-x1);
dy=abs(y0-y1);
return dx>dy ? dx : dy;
}
static int calc_next_walk_step(struct pet_data *pd)
{
if(pd->walkpath.path_pos>=pd->walkpath.path_len)
return -1;
if(pd->walkpath.path[pd->walkpath.path_pos]&1)
return pd->speed*14/10;
return pd->speed;
}
static int pet_performance_val(struct map_session_data *sd)
{
if(sd->pet.intimate > 900)
return (sd->petDB->s_perfor > 0)? 4:3;
else if(sd->pet.intimate > 750)
return 2;
else
return 1;
}
int pet_hungry_val(struct map_session_data *sd)
{
if(sd->pet.hungry > 90)
return 4;
else if(sd->pet.hungry > 75)
return 3;
else if(sd->pet.hungry > 25)
return 2;
else if(sd->pet.hungry > 10)
return 1;
else
return 0;
}
static int pet_can_reach(struct pet_data *pd,int x,int y)
{
struct walkpath_data wpd;
if( pd->bl.x==x && pd->bl.y==y ) // 摨偠儅僗
return 1;
// 忈奞暔敾掕
wpd.path_len=0;
wpd.path_pos=0;
wpd.path_half=0;
return (path_search(&wpd,pd->bl.m,pd->bl.x,pd->bl.y,x,y,0)!=-1)?1:0;
}
static int pet_calc_pos(struct pet_data *pd,int tx,int ty,int dir)
{
int x,y,dx,dy;
int i,j=0,k;
pd->to_x = tx;
pd->to_y = ty;
if(dir >= 0 && dir < 8) {
dx = -dirx[dir]*2;
dy = -diry[dir]*2;
x = tx + dx;
y = ty + dy;
if(!(j=pet_can_reach(pd,x,y))) {
if(dx > 0) x--;
else if(dx < 0) x++;
if(dy > 0) y--;
else if(dy < 0) y++;
if(!(j=pet_can_reach(pd,x,y))) {
for(i=0;i<12;i++) {
k = rand()%8;
dx = -dirx[k]*2;
dy = -diry[k]*2;
x = tx + dx;
y = ty + dy;
if((j=pet_can_reach(pd,x,y)))
break;
else {
if(dx > 0) x--;
else if(dx < 0) x++;
if(dy > 0) y--;
else if(dy < 0) y++;
if((j=pet_can_reach(pd,x,y)))
break;
}
}
if(!j) {
x = tx;
y = ty;
if(!pet_can_reach(pd,x,y))
return 1;
}
}
}
}
else
return 1;
pd->to_x = x;
pd->to_y = y;
return 0;
}
static int pet_attack(struct pet_data *pd,unsigned int tick,int data)
{
struct mob_data *md;
int mode,race,range;
pd->state.state=MS_IDLE;
md=(struct mob_data *)map_id2bl(pd->target_id);
if(md == NULL || md->bl.type != BL_MOB || pd->bl.m != md->bl.m || md->bl.prev == NULL ||
distance(pd->bl.x,pd->bl.y,md->bl.x,md->bl.y) > 13) {
pd->target_id=0;
return 0;
}
mode=mob_db[pd->class].mode;
race=mob_db[pd->class].race;
if(mob_db[pd->class].mexp <= 0 && !(mode&0x20) && (md->option & 0x06 && race != 4 && race != 6) ) {
pd->target_id=0;
return 0;
}
range = mob_db[pd->class].range + 1;
if(distance(pd->bl.x,pd->bl.y,md->bl.x,md->bl.y) > range)
return 0;
if(battle_config.monster_attack_direction_change)
pd->dir=map_calc_dir(&pd->bl, md->bl.x,md->bl.y );
clif_fixpetpos(pd);
battle_weapon_attack(&pd->bl,&md->bl,tick,0);
pd->attackabletime = tick + battle_get_adelay(&pd->bl);
pd->timer=add_timer(pd->attackabletime,pet_timer,pd->bl.id,0);
pd->state.state=MS_ATTACK;
return 0;
}
/*==========================================
*
*------------------------------------------
*/
static int pet_walk(struct pet_data *pd,unsigned int tick,int data)
{
int moveblock;
int i,ctype;
int x,y,dx,dy;
pd->state.state=MS_IDLE;
if(pd->walkpath.path_pos >= pd->walkpath.path_len || pd->walkpath.path_pos != data)
return 0;
pd->walkpath.path_half ^= 1;
if(pd->walkpath.path_half==0){
pd->walkpath.path_pos++;
if(pd->state.change_walk_target){
pet_walktoxy_sub(pd);
return 0;
}
}
else {
if(pd->walkpath.path[pd->walkpath.path_pos] >= 8)
return 1;
x = pd->bl.x;
y = pd->bl.y;
/* ctype = map_getcell(pd->bl.m,x,y);
if(ctype == 1 || ctype == 5) {
pet_stop_walking(pd,1);
return 0;
}*/
pd->dir=pd->walkpath.path[pd->walkpath.path_pos];
dx = dirx[pd->dir];
dy = diry[pd->dir];
ctype = map_getcell(pd->bl.m,x+dx,y+dy);
if(ctype == 1 || ctype == 5) {
pet_walktoxy_sub(pd);
return 0;
}
moveblock = ( x/BLOCK_SIZE != (x+dx)/BLOCK_SIZE || y/BLOCK_SIZE != (y+dy)/BLOCK_SIZE);
pd->state.state=MS_WALK;
map_foreachinmovearea(clif_petoutsight,pd->bl.m,x-AREA_SIZE,y-AREA_SIZE,x+AREA_SIZE,y+AREA_SIZE,dx,dy,BL_PC,pd);
x += dx;
y += dy;
if(moveblock) map_delblock(&pd->bl);
pd->bl.x = x;
pd->bl.y = y;
if(moveblock) map_addblock(&pd->bl);
map_foreachinmovearea(clif_petinsight,pd->bl.m,x-AREA_SIZE,y-AREA_SIZE,x+AREA_SIZE,y+AREA_SIZE,-dx,-dy,BL_PC,pd);
pd->state.state=MS_IDLE;
}
if((i=calc_next_walk_step(pd))>0){
i = i>>1;
if(i < 1 && pd->walkpath.path_half == 0)
i = 1;
pd->timer=add_timer(tick+i,pet_timer,pd->bl.id,pd->walkpath.path_pos);
pd->state.state=MS_WALK;
if(pd->walkpath.path_pos >= pd->walkpath.path_len)
clif_fixpetpos(pd);
}
return 0;
}
int pet_stopattack(struct pet_data *pd)
{
pd->target_id=0;
if(pd->state.state == MS_ATTACK)
pet_changestate(pd,MS_IDLE,0);
return 0;
}
int pet_target_check(struct map_session_data *sd,struct block_list *bl,int type)
{
struct pet_data *pd = sd->pd;
struct mob_data *md;
int rate,mode,race;
if(bl && pd && bl->type == BL_MOB && sd->pet.intimate > 900 && sd->pet.hungry > 0 && pd->class != battle_get_class(bl)
&& pd->state.state != MS_DELAY) {
mode=mob_db[pd->class].mode;
race=mob_db[pd->class].race;
md=(struct mob_data *)bl;
if(md->bl.type != BL_MOB || pd->bl.m != md->bl.m || md->bl.prev == NULL ||
distance(pd->bl.x,pd->bl.y,md->bl.x,md->bl.y) > 13)
return 0;
if(mob_db[pd->class].mexp <= 0 && !(mode&0x20) && (md->option & 0x06 && race!=4 && race!=6) )
return 0;
if(!type) {
rate = sd->petDB->attack_rate;
rate = rate * (150 - (sd->pet.intimate - 1000))/100;
if(battle_config.pet_support_rate != 100)
rate = rate*battle_config.pet_support_rate/100;
if(sd->petDB->attack_rate > 0 && rate <= 0)
rate = 1;
}
else {
rate = sd->petDB->defence_attack_rate;
rate = rate * (150 - (sd->pet.intimate - 1000))/100;
if(battle_config.pet_support_rate != 100)
rate = rate*battle_config.pet_support_rate/100;
if(sd->petDB->defence_attack_rate > 0 && rate <= 0)
rate = 1;
}
if(rand()%10000 < rate) {
if(pd->target_id == 0 || rand()%10000 < sd->petDB->change_target_rate)
pd->target_id = bl->id;
}
}
return 0;
}
int pet_changestate(struct pet_data *pd,int state,int type)
{
unsigned int tick;
int i;
if(pd->timer != -1)
delete_timer(pd->timer,pet_timer);
pd->timer=-1;
pd->state.state=state;
switch(state) {
case MS_WALK:
if((i=calc_next_walk_step(pd)) > 0){
i = i>>2;
pd->timer=add_timer(gettick()+i,pet_timer,pd->bl.id,0);
} else
pd->state.state=MS_IDLE;
break;
case MS_ATTACK:
tick = gettick();
i=DIFF_TICK(pd->attackabletime,tick);
if(i>0 && i<2000)
pd->timer=add_timer(pd->attackabletime,pet_timer,pd->bl.id,0);
else
pd->timer=add_timer(tick+1,pet_timer,pd->bl.id,0);
break;
case MS_DELAY:
pd->timer=add_timer(gettick()+type,pet_timer,pd->bl.id,0);
break;
}
return 0;
}
static int pet_timer(int tid,unsigned int tick,int id,int data)
{
struct pet_data *pd;
pd=(struct pet_data*)map_id2bl(id);
if(pd == NULL || pd->bl.type != BL_PET)
return 1;
if(pd->timer != tid){
if(battle_config.error_log)
printf("pet_timer %d != %d\n",pd->timer,tid);
return 0;
}
pd->timer=-1;
if(pd->bl.prev == NULL)
return 1;
switch(pd->state.state){
case MS_WALK:
pet_walk(pd,tick,data);
break;
case MS_ATTACK:
pet_attack(pd,tick,data);
break;
case MS_DELAY:
pet_changestate(pd,MS_IDLE,0);
break;
default:
if(battle_config.error_log)
printf("pet_timer : %d ?\n",pd->state.state);
break;
}
return 0;
}
static int pet_walktoxy_sub(struct pet_data *pd)
{
struct walkpath_data wpd;
if(path_search(&wpd,pd->bl.m,pd->bl.x,pd->bl.y,pd->to_x,pd->to_y,0))
return 1;
memcpy(&pd->walkpath,&wpd,sizeof(wpd));
pd->state.change_walk_target=0;
pet_changestate(pd,MS_WALK,0);
clif_movepet(pd);
// if(battle_config.etc_log)
// printf("walkstart\n");
return 0;
}
int pet_walktoxy(struct pet_data *pd,int x,int y)
{
struct walkpath_data wpd;
if(pd->state.state == MS_WALK && path_search(&wpd,pd->bl.m,pd->bl.x,pd->bl.y,x,y,0))
return 1;
pd->to_x=x;
pd->to_y=y;
if(pd->state.state == MS_WALK) {
pd->state.change_walk_target=1;
} else {
return pet_walktoxy_sub(pd);
}
return 0;
}
int pet_stop_walking(struct pet_data *pd,int type)
{
if(pd->state.state == MS_WALK || pd->state.state == MS_IDLE) {
pd->walkpath.path_len=0;
pd->to_x=pd->bl.x;
pd->to_y=pd->bl.y;
}
if(type&0x01)
clif_fixpetpos(pd);
if(type&~0xff)
pet_changestate(pd,MS_DELAY,type>>8);
else
pet_changestate(pd,MS_IDLE,0);
return 0;
}
static int pet_hungry(int tid,unsigned int tick,int id,int data)
{
struct map_session_data *sd;
int interval,t;
sd=map_id2sd(id);
if(sd==NULL)
return 1;
if(sd->pet_hungry_timer != tid){
if(battle_config.error_log)
printf("pet_hungry_timer %d != %d\n",sd->pet_hungry_timer,tid);
return 0;
}
sd->pet_hungry_timer = -1;
if(!sd->status.pet_id || !sd->pd || !sd->petDB)
return 1;
sd->pet.hungry--;
t = sd->pet.intimate;
if(sd->pet.hungry < 0) {
if(sd->pd->target_id > 0)
pet_stopattack(sd->pd);
sd->pet.hungry = 0;
sd->pet.intimate -= battle_config.pet_hungry_friendly_decrease;
if(sd->pet.intimate <= 0) {
sd->pet.intimate = 0;
if(battle_config.pet_status_support && t > 0) {
if(sd->bl.prev != NULL)
pc_calcstatus(sd,0);
else
pc_calcstatus(sd,2);
}
}
clif_send_petdata(sd,1,sd->pet.intimate);
}
clif_send_petdata(sd,2,sd->pet.hungry);
if(battle_config.pet_hungry_delay_rate != 100)
interval = (sd->petDB->hungry_delay*battle_config.pet_hungry_delay_rate)/100;
else
interval = sd->petDB->hungry_delay;
if(interval <= 0)
interval = 1;
sd->pet_hungry_timer = add_timer(tick+interval,pet_hungry,sd->bl.id,0);
return 0;
}
int search_petDB_index(int key,int type)
{
int i;
for(i=0;i<MAX_PET_DB;i++) {
if(pet_db[i].class <= 0)
continue;
switch(type) {
case PET_CLASS:
if(pet_db[i].class == key)
return i;
break;
case PET_CATCH:
if(pet_db[i].itemID == key)
return i;
break;
case PET_EGG:
if(pet_db[i].EggID == key)
return i;
break;
case PET_EQUIP:
if(pet_db[i].AcceID == key)
return i;
break;
case PET_FOOD:
if(pet_db[i].FoodID == key)
return i;
break;
default:
return -1;
}
}
return -1;
}
int pet_hungry_timer_delete(struct map_session_data *sd)
{
if(sd->pet_hungry_timer != -1) {
delete_timer(sd->pet_hungry_timer,pet_hungry);
sd->pet_hungry_timer = -1;
}
return 0;
}
int pet_remove_map(struct map_session_data *sd)
{
if(sd->status.pet_id && sd->pd) {
pet_changestate(sd->pd,MS_IDLE,0);
if(sd->pet_hungry_timer != -1)
pet_hungry_timer_delete(sd);
clif_clearchar_area(&sd->pd->bl,0);
map_delblock(&sd->pd->bl);
map_deliddb(&sd->pd->bl);
map_freeblock(sd->pd);
}
return 0;
}
int pet_performance(struct map_session_data *sd)
{
pet_stop_walking(sd->pd,2000<<8);
clif_pet_performance(&sd->pd->bl,rand()%pet_performance_val(sd) + 1);
return 0;
}
int pet_return_egg(struct map_session_data *sd)
{
struct item tmp_item;
int flag;
if(sd->status.pet_id && sd->pd) {
pet_remove_map(sd);
sd->status.pet_id = 0;
sd->pd = NULL;
if(sd->petDB == NULL)
return 1;
sd->pet.incuvate = 1;
memset(&tmp_item,0,sizeof(tmp_item));
tmp_item.nameid = sd->petDB->EggID;
tmp_item.identify = 1;
tmp_item.card[0] = 0xff00;
*((long *)(&tmp_item.card[1])) = sd->pet.pet_id;
tmp_item.card[3] = sd->pet.rename_flag;
if((flag = pc_additem(sd,&tmp_item,1))) {
clif_additem(sd,0,0,flag);
map_addflooritem(&tmp_item,1,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
}
if(battle_config.pet_status_support && sd->pet.intimate > 0) {
if(sd->bl.prev != NULL)
pc_calcstatus(sd,0);
else
pc_calcstatus(sd,2);
}
intif_save_petdata(sd->status.account_id,&sd->pet);
pc_makesavestatus(sd);
chrif_save(sd);
storage_storage_save(sd);
sd->petDB = NULL;
}
return 0;
}
int pet_data_init(struct map_session_data *sd)
{
struct pet_data *pd;
int i,interval;
if(sd->status.account_id != sd->pet.account_id || sd->status.char_id != sd->pet.char_id ||
sd->status.pet_id != sd->pet.pet_id) {
sd->status.pet_id = 0;
return 1;
}
i = search_petDB_index(sd->pet.class,PET_CLASS);
if(i < 0) {
sd->status.pet_id = 0;
return 1;
}
sd->petDB = &pet_db[i];
sd->pd = pd = calloc(sizeof(struct pet_data), 1);
if(pd==NULL){
printf("out of memory : pet_data_init\n");
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -