void disp_char(int index, char *ch)
{
if (gcin_edit_display_ap_only())
return;
if (!top_bin)
return;
// dbg("disp_char %d %s\n", index, ch);
create_char(index);
GtkWidget *label = chars[index].label;
if (label) {
if (ch[0]==' ' && ch[1]==' ')
set_label_space(label);
else {
gtk_label_set_text(GTK_LABEL(label), ch);
}
}
#if GTK_CHECK_VERSION(3,0,0)
// bug in gtk3
set_label_font_size(label, gcin_font_size);
#endif
get_win0_geom();
if (win_x + win_xl >= dpy_xl)
move_win0(dpy_xl - win_xl, win_y);
gtk_widget_show_all(chars[index].vbox);
}
pointer parse_expr(parser* parse)
{
eat_whitespace(parse);
pointer ret_car;
pointer ret_cdr;
switch(*parse->curr)
{
case '(':
parse->curr++;
ret_car = parse_expr(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case '"':
ret_car = parse_string(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case '\'':
parse->curr++;
ret_car = parse_quote(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case ')':
parse->curr++;
return NIL;
case '+': case '-': case 'b':
ret_car = parse_number_or_symbol(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case '.':
return parse_number_or_pair(parse);
case '\\':
parse->curr++;
ret_car = create_char(*(parse->curr++));
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case ';':
while(!is_newline(*parse->curr) && *parse->curr != '\0')
parse->curr++;
return parse_expr(parse);
case 0:
return NIL;
default:
if(is_number_char(*parse->curr))
{
ret_car = parse_number(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
}
else if(is_symbol_char(*parse->curr))
{
ret_car = parse_symbol(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
}
else
return parser_error(parse, "Unexpected char in expression.");
}
parse->curr++;
}
void create_worker(int follow_cn, struct saltmine_ppd *ppd)
{
int cn;
struct saltmine_worker_data *workerdat;
// create
cn=create_char("monk_worker",0);
if (!cn) { xlog("create_char() failed in %s %d",__FILE__,__LINE__); return; }
snprintf(ch[cn].name,sizeof(ch[cn].name)-1,"%s's Monk",ch[follow_cn].name); ch[cn].name[sizeof(ch[cn].name)-1]=0;
ch[cn].dir=DX_DOWN;
update_char(cn);
ch[cn].hp=ch[cn].value[0][V_HP]*POWERSCALE;
ch[cn].endurance=ch[cn].value[0][V_ENDURANCE]*POWERSCALE;
ch[cn].mana=ch[cn].value[0][V_MANA]*POWERSCALE;
// set initital values
if ((workerdat=set_data(cn,DRD_SALTMINE_WORKER,sizeof(struct saltmine_worker_data)))) {
workerdat->follow_cn=follow_cn;
workerdat->follow_serial=ch[follow_cn].serial;
}
else {
destroy_char(cn);
xlog("set_data() failed in %s %d",__FILE__,__LINE__);
return;
}
// drop him to map
if (!drop_char(cn,179,19,0) && !drop_char(cn,182,19,0)) { destroy_char(cn); xlog("drop_char() failed (%s,%d)",__FILE__,__LINE__); return; }
// set first coords
ch[cn].tmpx=ch[follow_cn].x;
ch[cn].tmpy=ch[follow_cn].y;
}
void disp_char(int index, char *ch)
{
if (hime_edit_display_ap_only())
return;
if (!top_bin)
return;
// dbg("disp_char %d %s\n", index, ch);
create_char(index);
GtkWidget *label = chars[index].label;
if (label) {
if (ch[0]==' ' && ch[1]==' ')
set_label_space(label);
else {
gtk_label_set_text(GTK_LABEL(label), ch);
}
}
get_win0_geom();
if (win_x + win_xl >= dpy_xl)
move_win0(dpy_xl - win_xl, win_y);
gtk_widget_show_all(chars[index].vbox);
}
//--------------------------------
//print every codepoint (single, plain, header)
void print_spf()
{
int i=0;
for(i=0;i<TOTAL_CHARS;i++)
{
// printf("//%d %d\n",spf_mapping_table[i][0],i);
printf("//%d\n",spf_mapping_table[i][0]);
create_char(spf_mapping_table[i][0]);
print_char_cropped();
}
}
int open_window( GlobalFunc *global )
{
int i;
natorder = native_order();
msgf = global( LWMESSAGEFUNCS_GLOBAL, GFUSE_TRANSIENT );
filereq = global( LWFILEREQFUNC_GLOBAL, GFUSE_TRANSIENT );
rasf = global( LWRASTERFUNCS_GLOBAL, GFUSE_TRANSIENT );
panf = global( LWPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
if ( !msgf || !filereq || !rasf || !panf )
return AFUNC_BADGLOBAL;
panf->globalFun = global;
if( !( panel = PAN_CREATE( panf, PANEL_TITLE ))) {
msgf->error( PLUGIN_NAME " couldn't create its panel,", "not sure why." );
return AFUNC_OK;
}
panf->set( panel, PAN_USERKEYS, handle_key );
panf->set( panel, PAN_USEROPEN, handle_panopen );
cras[ 0 ] = create_char( COLOR_WHITE, SYSTEM_Ic( 30 ), rasf );
cras[ 1 ] = create_char( COLOR_BLACK, SYSTEM_Ic( 2 ), rasf );
cras[ 2 ] = create_char( COLOR_BLACK, SYSTEM_Ic( 15 ), rasf );
create_controls();
panf->open( panel, PANF_BLOCKING );
PAN_KILL( panf, panel );
for ( i = 0; i < 3; i++ )
free_char( cras[ i ], rasf );
free_icon( rasf );
return AFUNC_OK;
}
void keyholder_door(int in,int cn)
{
int x,y,n,in2,flag,co,nr;
char buf[80];
if (!cn) return;
nr=it[in].drdata[0];
for (n=0; n<9; n++) {
flag=0;
for (x=2+(n%3)*8; x<9+(n%3)*8; x++) {
for (y=231+(n/3)*8; y<238+(n/3)*8; y++) {
if ((in2=map[x+y*MAXMAP].it) && (it[in2].flags&IF_TAKE)) { flag=1; break; }
if (map[x+y*MAXMAP].ch) { flag=1; break; }
}
}
if (!flag) break;
}
if (flag) {
log_char(cn,LOG_SYSTEM,0,"You hear fighting noises from behind the door. It won't open while the fight lasts.");
return;
}
if (!(in2=ch[cn].citem) || it[in2].driver!=IDR_ENHANCE || it[in2].drdata[0]!=2 || *(unsigned int*)(it[in2].drdata+1)!=2000) {
log_char(cn,LOG_SYSTEM,0,"You'll need to use 2000 gold units as a key to open the door.");
return;
}
if (!teleport_char_driver(cn,2+(n%3)*8+1,231+(n/3)*8+3)) {
log_char(cn,LOG_SYSTEM,0,"You hear fighting noises from behind the door. It won't open while the fight lasts.");
return;
}
destroy_item(in2);
ch[cn].citem=0;
ch[cn].flags|=CF_ITEMS;
sprintf(buf,"keyholder_golem%d",nr);
co=create_char(buf,0);
if (co) {
update_char(co);
ch[co].hp=ch[co].value[0][V_HP]*POWERSCALE;
ch[co].endurance=ch[co].value[0][V_ENDURANCE]*POWERSCALE;
ch[co].mana=ch[co].value[0][V_MANA]*POWERSCALE;
ch[co].dir=DX_LEFTUP;
ch[co].tmpx=2+(n%3)*8+5;
ch[co].tmpy=231+(n/3)*8+3;
drop_char(co,2+(n%3)*8+5,231+(n/3)*8+3,1);
}
}
void a_class_generator::
populate(const unsigned int position, result_type& v) {
v.bool_property(create_bool(position + 0));
v.char_property(create_char(position + 1));
v.uchar_property(create_unsigned_char(position + 2));
v.int_property(create_int(position + 3));
v.uint_property(create_unsigned_int(position + 4));
v.long_property(create_long(position + 5));
v.ulong_property(create_unsigned_long(position + 6));
v.long_long_property(create_long_long(position + 7));
v.ulong_long_property(create_unsigned_long_long(position + 8));
v.short_property(create_short(position + 9));
v.ushort_property(create_unsigned_short(position + 10));
v.double_property(create_double(position + 11));
v.float_property(create_float(position + 12));
}
void ritual_create_char(char *name, int x, int y, int dir, int attackstart)
{
int cn;
struct lab5_daemon_data *dat;
// create
cn=create_char(name,0);
if (!cn) return;
ch[cn].dir=dir;
ch[cn].flags&=~CF_RESPAWN;
update_char(cn);
ch[cn].hp=ch[cn].value[0][V_HP]*POWERSCALE;
ch[cn].endurance=ch[cn].value[0][V_ENDURANCE]*POWERSCALE;
ch[cn].mana=ch[cn].value[0][V_MANA]*POWERSCALE;
// drop him to map
if (!drop_char(cn,x,y,0)) {
destroy_char(cn);
/*destroy_items(cn);
free_char(cn);*/
xlog("drop_char failed (%s,%d)",__FILE__,__LINE__);
return;
}
// set values of the secure move driver
ch[cn].tmpx=ch[cn].x;
ch[cn].tmpy=ch[cn].y;
// set direction of deamon driver
dat=set_data(cn,DRD_LAB5_DAEMON,sizeof(struct lab5_daemon_data));
if (dat) {
dat->dir=dir;
dat->attackstart=attackstart*TICKS;
}
}
void edemongate_driver(int in,int cn)
{
int n,co,ser,nr;
char name[80];
if (cn) return;
nr=it[in].drdata[0];
if (nr==0) {
static int pos[14]={
62,157,
62,164,
62,174,
62,184,
62,191,
56,174,
67,174};
for (n=0; n<7; n++) {
co=*(unsigned short*)(it[in].drdata+4+n*4);
ser=*(unsigned short*)(it[in].drdata+6+n*4);
if (!co || !ch[co].flags || (unsigned short)ch[co].serial!=(unsigned short)ser) {
sprintf(name,"edemon2s");
co=create_char(name,0);
if (!co) break;
if (item_drop_char(in,co)) {
ch[co].tmpx=pos[n*2];
ch[co].tmpy=pos[n*2+1];
update_char(co);
ch[co].hp=ch[co].value[0][V_HP]*POWERSCALE;
ch[co].endurance=ch[co].value[0][V_ENDURANCE]*POWERSCALE;
ch[co].mana=ch[co].value[0][V_MANA]*POWERSCALE;
ch[co].dir=DX_RIGHTDOWN;
*(unsigned short*)(it[in].drdata+4+n*4)=co;
*(unsigned short*)(it[in].drdata+6+n*4)=ch[co].serial;
break; // only one spawn per call
} else {
destroy_char(co);
break;
}
}
}
call_item(it[in].driver,in,0,ticker+TICKS*10);
} else if (nr==1) {
static int pos[100]={0},co_nr[100],serial[100],maxpos=0;
if (!maxpos) {
for (n=1; n<MAXITEM; n++) {
if (!it[n].flags) continue;
if (it[n].driver!=IDR_EDEMONLIGHT) continue;
if (it[n].drdata[0]!=4) continue;
pos[maxpos++]=it[n].x+it[n].y*MAXMAP;
}
}
for (n=0; n<maxpos; n++) {
if (!(co=co_nr[n]) || !ch[co].flags || ch[co].serial!=serial[n]) {
co=create_char("edemon6s",0);
if (!co) break;
if (item_drop_char(in,co)) {
ch[co].tmpx=pos[n]%MAXMAP;
ch[co].tmpy=pos[n]/MAXMAP;
update_char(co);
ch[co].hp=ch[co].value[0][V_HP]*POWERSCALE;
ch[co].endurance=ch[co].value[0][V_ENDURANCE]*POWERSCALE;
ch[co].mana=ch[co].value[0][V_MANA]*POWERSCALE;
ch[co].dir=DX_RIGHTDOWN;
co_nr[n]=co;
serial[n]=ch[co].serial;
break; // only one spawn per call
} else {
destroy_char(co);
break;
}
}
}
call_item(it[in].driver,in,0,ticker+TICKS*20);
}
}
void minewall(int in,int cn)
{
int in2,amount,co;
char buf[80];
if (!cn) {
if (!it[in].drdata[4]) {
it[in].drdata[4]=1;
switch((it[in].x+it[in].y)%3) {
case 0: it[in].sprite=15070; break;
case 1: it[in].sprite=15078; break;
case 2: it[in].sprite=15086; break;
}
}
if (it[in].drdata[3]==8) {
if ((map[it[in].x+it[in].y*MAXMAP].flags&MF_TMOVEBLOCK) || map[it[in].x+it[in].y*MAXMAP].it) {
call_item(it[in].driver,in,0,ticker+TICKS);
return;
}
it[in].sprite-=8;
it[in].drdata[3]=0;
it[in].flags|=IF_USE;
it[in].flags&=~IF_VOID;
remove_lights(it[in].x,it[in].y);
map[it[in].x+it[in].y*MAXMAP].it=in;
map[it[in].x+it[in].y*MAXMAP].flags|=MF_TSIGHTBLOCK|MF_TMOVEBLOCK;
it[in].flags|=IF_SIGHTBLOCK;
reset_los(it[in].x,it[in].y);
add_lights(it[in].x,it[in].y);
set_sector(it[in].x,it[in].y);
}
return;
}
if (ch[cn].citem) {
log_char(cn,LOG_SYSTEM,0,"Please empty your hand (mouse cursor) first.");
player_driver_dig_off(cn);
return;
}
if (it[in].drdata[3]<9) {
if (ch[cn].endurance<POWERSCALE) {
log_char(cn,LOG_SYSTEM,0,"You're too exhausted to continue digging.");
player_driver_dig_off(cn);
return;
}
ch[cn].endurance-=POWERSCALE/4-(ch[cn].prof[P_MINER]*POWERSCALE/(4*25));
it[in].drdata[3]++;
it[in].drdata[5]=0;
it[in].sprite++;
if (it[in].drdata[3]==8) {
map[it[in].x+it[in].y*MAXMAP].it=0;
map[it[in].x+it[in].y*MAXMAP].flags&=~MF_TMOVEBLOCK;
it[in].flags&=~IF_USE;
it[in].flags|=IF_VOID;
call_item(it[in].driver,in,0,ticker+TICKS*60*5+RANDOM(TICKS*60*25));
if (!RANDOM(15)) {
in2=create_item("silver");
if (!in2) elog("silver not found");
amount=RANDOM(it[in].drdata[0]*2+1)+it[in].drdata[0];
//xlog("amount=%d",amount);
if (ch[cn].prof[P_MINER]) amount+=amount*ch[cn].prof[P_MINER]/10;
//xlog("amount=%d",amount);
if (!amount && in2) {
destroy_item(in2);
}
} else if (!RANDOM(50)) {
in2=create_item("gold");
if (!in2) elog("gold not found");
amount=RANDOM(it[in].drdata[1]*2+1)+it[in].drdata[1];
if (ch[cn].prof[P_MINER]) amount+=amount*ch[cn].prof[P_MINER]/10;
if (!amount && in2) {
destroy_item(in2);
}
} else amount=in2=0;
if (amount && in2) {
it[in2].value*=amount;
*(unsigned int*)(it[in2].drdata+1)=amount;
sprintf(it[in2].description,"%d units of %s.",*(unsigned int*)(it[in2].drdata+1),it[in2].name);
if (ch[cn].flags&CF_PLAYER) dlog(cn,in2,"took from minewall");
ch[cn].citem=in2;
it[in2].carried=cn;
ch[cn].flags|=CF_ITEMS;
log_char(cn,LOG_SYSTEM,0,"You found %d units of %s.",amount,it[in2].name);
if (it[in2].drdata[0]==1) check_military_silver(cn,amount);
}
if (!RANDOM(10)) {
sprintf(buf,"miner%d",it[in].drdata[2]);
co=create_char(buf,0);
if (!co) elog("%s not found",buf);
if (co) {
if (drop_char(co,it[in].x,it[in].y,0)) {
ch[co].tmpx=ch[co].x;
ch[co].tmpy=ch[co].y;
update_char(co);
ch[co].hp=ch[co].value[0][V_HP]*POWERSCALE;
ch[co].endurance=ch[co].value[0][V_ENDURANCE]*POWERSCALE;
ch[co].mana=ch[co].value[0][V_MANA]*POWERSCALE;
ch[co].dir=DX_RIGHTDOWN;
} else {
destroy_char(co);
}
}
}
}
set_sector(it[in].x,it[in].y);
if (it[in].drdata[3]==3) {
remove_lights(it[in].x,it[in].y);
map[it[in].x+it[in].y*MAXMAP].flags&=~MF_TSIGHTBLOCK;
it[in].flags&=~IF_SIGHTBLOCK;
reset_los(it[in].x,it[in].y);
add_lights(it[in].x,it[in].y);
}
}
if (it[in].drdata[3]<8) player_driver_dig_on(cn);
else player_driver_dig_off(cn);
}
/*!
* \brief Parse from Client
*
* \author Fimbulwinter Development Team
* \author GreenBox
* \date 08/12/11
*
**/
int CharServer::parse_from_client(tcp_connection::pointer cl)
{
CharSessionData *csd = ((CharSessionData *)cl->get_data());
if (cl->flags.eof)
{
if (csd && csd->auth && auth_conn_ok)
{
WFIFOHEAD(auth_conn,6);
WFIFOW(auth_conn,0) = INTER_CA_SET_ACC_OFF;
WFIFOL(auth_conn,2) = csd->account_id;
auth_conn->send_buffer(6);
}
set_char_offline(csd->account_id, -1);
if (csd)
delete csd;
ShowInfo("Closed connection from '"CL_WHITE"%s"CL_RESET"'.\n", cl->socket().remote_endpoint().address().to_string().c_str());
cl->do_close();
return 0;
}
while(RFIFOREST(cl) >= 2)
{
unsigned short cmd = RFIFOW(cl, 0);
#define FIFOSD_CHECK(rest) { if(RFIFOREST(cl) < rest) return 0; if (csd==NULL || !csd->auth) { cl->skip(rest); return 0; } }
switch (cmd)
{
case HEADER_CH_SELECT_CHAR:
FIFOSD_CHECK(3);
{
int slot = RFIFOB(cl,2);
int char_id;
CharData cd;
cl->skip(3);
{
statement s = (database->prepare << "SELECT `char_id` FROM `char` WHERE `account_id`=:a AND `char_num`=:s",
use(csd->account_id), use(slot), into(char_id));
s.execute(true);
if (s.get_affected_rows() <= 0)
{
WFIFOPACKET(cl, spacket, HC_REFUSE_ENTER);
spacket->error_code = 0;
cl->send_buffer(sizeof(struct PACKET_HC_REFUSE_ENTER));
}
}
chars->load_char(char_id, cd, true);
int server = -1;
if (map_to_zone.count(cd.last_point.map))
server = map_to_zone[cd.last_point.map];
if (server < 0)
{
// TODO: Find for major city
WFIFOPACKET(cl, spacket, SC_NOTIFY_BAN);
spacket->error_code = 1;
cl->send_buffer(sizeof(struct PACKET_SC_NOTIFY_BAN));
break;
}
auth_nodes[csd->account_id].sex = csd->sex;
auth_nodes[csd->account_id].char_id = char_id;
auth_nodes[csd->account_id].gmlevel = csd->gmlevel;
auth_nodes[csd->account_id].login_id1 = csd->login_id1;
auth_nodes[csd->account_id].login_id2 = csd->login_id2;
auth_nodes[csd->account_id].expiration_time = csd->expiration_time;
WFIFOPACKET(cl, spacket, HC_NOTIFY_ZONESVR);
spacket->char_id = char_id;
maps.copy_map_name_ext((char*)spacket->map_name, cd.last_point.map);
spacket->addr.ip = htonl(servers[server].addr.to_ulong());
spacket->addr.port = servers[server].port;
cl->send_buffer(sizeof(struct PACKET_HC_NOTIFY_ZONESVR));
}
break;
case HEADER_CH_REQUEST_DEL_TIMER:
FIFOSD_CHECK(6);
delete2_req(cl, csd);
cl->skip(6);
break;
case HEADER_CH_ACCEPT_DEL_REQ:
FIFOSD_CHECK(12);
delete2_accept(cl, csd);
cl->skip(6);
break;
case HEADER_CH_CANCEL_DEL_REQ:
FIFOSD_CHECK(6);
delete2_cancel(cl, csd);
cl->skip(6);
break;
case HEADER_CH_DELETE_CHAR:
case HEADER_CH_DELETE_CHAR2:
if (cmd == HEADER_CH_DELETE_CHAR) FIFOSD_CHECK(sizeof(struct PACKET_CH_DELETE_CHAR));
if (cmd == HEADER_CH_DELETE_CHAR2) FIFOSD_CHECK(sizeof(struct PACKET_CH_DELETE_CHAR2));
{
int cid = RFIFOL(cl,2);
char email[40];
memcpy(email, RFIFOP(cl,6), 40);
cl->skip((cmd == HEADER_CH_DELETE_CHAR) ? sizeof(struct PACKET_CH_DELETE_CHAR) : sizeof(struct PACKET_CH_DELETE_CHAR2));
if (_strcmpi(email, csd->email) != 0 && (strcmp("*****@*****.**", csd->email) || (strcmp("*****@*****.**", email) && strcmp("", email))))
{
WFIFOPACKET(cl, spacket, HC_REFUSE_DELETECHAR);
spacket->error_code = 0;
cl->send_buffer(sizeof(struct PACKET_HC_REFUSE_DELETECHAR));
break;
}
bool found = false;
int i, ch;
for (i = 0; i < MAX_CHARS; i++)
{
if (csd->found_char[i] == cid)
{
found = true;
break;
}
}
if (!found)
{
WFIFOPACKET(cl, spacket, HC_REFUSE_DELETECHAR);
spacket->error_code = 0;
cl->send_buffer(sizeof(struct PACKET_HC_REFUSE_DELETECHAR));
break;
}
else
{
for(ch = i; ch < MAX_CHARS - 1; ch++)
csd->found_char[ch] = csd->found_char[ch+1];
csd->found_char[MAX_CHARS - 1] = -1;
if (!chars->delete_char(cid))
{
WFIFOPACKET(cl, spacket, HC_REFUSE_DELETECHAR);
spacket->error_code = 0;
cl->send_buffer(sizeof(struct PACKET_HC_REFUSE_DELETECHAR));
break;
}
WFIFOPACKET(cl, spacket, HC_ACCEPT_DELETECHAR);
cl->send_buffer(sizeof(struct PACKET_HC_ACCEPT_DELETECHAR));
}
}
break;
case HEADER_CH_MAKE_CHAR:
FIFOSD_CHECK(sizeof(struct PACKET_CH_MAKE_CHAR));
{
TYPECAST_PACKET(RFIFOP(cl,0),rpacket,CH_MAKE_CHAR);
// TODO: Check create char disabled
int i = create_char(csd, (char*)rpacket->name,rpacket->str,rpacket->agi,rpacket->vit,rpacket->int_,rpacket->dex,rpacket->luk,rpacket->char_slot,rpacket->head_color,rpacket->head_style);
//'Charname already exists' (-1), 'Char creation denied' (-2) and 'You are underaged' (-3)
if (i < 0)
{
WFIFOPACKET(cl, spacket, HC_REFUSE_MAKECHAR);
switch (i) {
case -1: spacket->error_code = 0x00; break;
case -2: spacket->error_code = 0xFF; break;
case -3: spacket->error_code = 0x01; break;
}
cl->send_buffer(sizeof(struct PACKET_HC_REFUSE_MAKECHAR));
}
else
{
// retrieve data
CharData char_dat;
memset(&char_dat, 0, sizeof(CharData));
chars->load_char(i, char_dat, false); //Only the short data is needed.
// send to player
WFIFOPACKET(cl, spacket, HC_ACCEPT_MAKECHAR);
char_to_buf(&spacket->charinfo, &char_dat);
cl->send_buffer(sizeof(struct PACKET_HC_ACCEPT_MAKECHAR));
// add new entry to the chars list
for (int n = 0; n < MAX_CHARS; n++)
{
if(csd->found_char[n] == -1)
csd->found_char[n] = i; // the char_id of the new char
}
}
cl->skip(sizeof(struct PACKET_CH_MAKE_CHAR));
}
break;
case HEADER_CH_ENTER_CHECKBOT:
FIFOSD_CHECK(sizeof(struct PACKET_CH_ENTER_CHECKBOT));
{
WFIFOPACKET(cl, spacket, HC_CHECKBOT_RESULT);
spacket->packet_len = sizeof(struct PACKET_HC_CHECKBOT_RESULT);
spacket->result = 1;
cl->send_buffer(spacket->packet_len);
cl->skip(TYPECAST_PACKET_ONCE(RFIFOP(cl,0), CH_ENTER_CHECKBOT)->packet_len);
}
break;
case HEADER_CH_CHECKBOT:
FIFOSD_CHECK(sizeof(struct PACKET_CH_CHECKBOT));
{
WFIFOPACKET(cl, spacket, HC_CHECKBOT_RESULT);
spacket->packet_len = sizeof(struct PACKET_HC_CHECKBOT_RESULT);
spacket->result = 1;
cl->send_buffer(spacket->packet_len);
cl->skip(TYPECAST_PACKET_ONCE(RFIFOP(cl,0), CH_CHECKBOT)->packet_len);
}
break;
case HEADER_CH_ENTER:
if(RFIFOREST(cl) < sizeof(struct PACKET_CH_ENTER))
return 0;
{
int account_id = RFIFOL(cl,2);
unsigned int login_id1 = RFIFOL(cl,6);
unsigned int login_id2 = RFIFOL(cl,10);
char sex = RFIFOB(cl,16);
cl->skip(sizeof(struct PACKET_CH_ENTER));
if (csd)
{
break;
}
csd = new CharSessionData();
csd->account_id = account_id;
csd->login_id1 = login_id1;
csd->login_id2 = login_id2;
csd->sex = sex;
csd->auth = false;
csd->cl = cl;
cl->set_data((char*)csd);
WFIFOHEAD(cl, 4);
WFIFOL(cl,0) = account_id;
cl->send_buffer(4);
if (auth_nodes.count(account_id) &&
auth_nodes[account_id].login_id1 == login_id1 &&
auth_nodes[account_id].login_id2 == login_id2)
{
auth_nodes.erase(account_id);
auth_ok(cl, csd);
}
else
{
if (auth_conn_ok)
{
WFIFOHEAD(auth_conn,19);
WFIFOW(auth_conn,0) = INTER_CA_AUTH;
WFIFOL(auth_conn,2) = csd->account_id;
WFIFOL(auth_conn,6) = csd->login_id1;
WFIFOL(auth_conn,10) = csd->login_id2;
WFIFOB(auth_conn,14) = csd->sex;
WFIFOL(auth_conn,15) = cl->tag();
auth_conn->send_buffer(19);
}
else
{
WFIFOPACKET(cl, spacket, HC_REFUSE_ENTER);
spacket->error_code = 0;
cl->send_buffer(sizeof(struct PACKET_HC_REFUSE_ENTER));
}
}
}
break;
case HEADER_PING:
if (RFIFOREST(cl) < sizeof(PACKET_PING))
return 0;
cl->skip(sizeof(PACKET_PING));
break;
case INTER_ZC_LOGIN:
if (RFIFOREST(cl) < 60)
return 0;
{
char *user = (char*)RFIFOP(cl, 2);
char *pass = (char*)RFIFOP(cl, 26);
if (strcmp(user, config.inter_login_user.c_str()) || strcmp(pass, config.inter_login_pass.c_str()))
{
WFIFOHEAD(cl, 3);
WFIFOW(cl, 0) = INTER_CZ_LOGIN_REPLY;
WFIFOB(cl, 2) = 1;
cl->send_buffer(3);
}
else
{
int id = cl->tag();
servers[id].cl = cl;
servers[id].addr = address_v4(ntohl(RFIFOL(cl, 54)));
servers[id].port = ntohs(RFIFOW(cl, 58));
servers[id].users = 0;
cl->set_parser(&CharServer::parse_from_zone);
cl->flags.server = 1;
cl->realloc_fifo(FIFOSIZE_SERVERLINK, FIFOSIZE_SERVERLINK);
WFIFOHEAD(cl, 3);
WFIFOW(cl, 0) = INTER_CZ_LOGIN_REPLY;
WFIFOB(cl, 2) = 0;
cl->send_buffer(3);
}
cl->skip(60);
}
break;
default:
ShowWarning("Unknown packet 0x%04x sent from %s, closing connection.\n", cmd, cl->socket().remote_endpoint().address().to_string().c_str());
cl->set_eof();
return 0;
}
}
return 0;
}
int warptrialdoor_driver(int in,int cn)
{
int xs,ys,xe,ye,x,y,m,in2,dx,dy,dir,co;
struct warpfighter_data *dat;
struct warped_ppd *ppd;
ppd=set_data(cn,DRD_WARP_PPD,sizeof(struct warped_ppd));
if (!ppd) return 2; // oops...
if (!ppd->base) ppd->base=40;
if (!it[in].drdata[2]) {
xs=xe=ys=ye=in2=0;
for (x=it[in].x+1,y=it[in].y; x<it[in].x+15; x++) {
if (map[x+y*MAXMAP].it && it[map[x+y*MAXMAP].it].driver==IDR_WARPTRIALDOOR) {
in2=map[x+y*MAXMAP].it;
xs=it[in].x;
xe=it[in2].x;
for (x=it[in].x+1,y=it[in].y; y<it[in].y+15; y++) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
ye=y;
break;
}
}
for (x=it[in].x+1,y=it[in].y; y>it[in].y-15; y--) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
ys=y;
break;
}
}
break;
}
if (map[x+y*MAXMAP].flags&(MF_MOVEBLOCK|MF_TMOVEBLOCK)) break;
}
if (!in2) {
for (x=it[in].x-1,y=it[in].y; x>it[in].x-15; x--) {
if (map[x+y*MAXMAP].it && it[map[x+y*MAXMAP].it].driver==IDR_WARPTRIALDOOR) {
in2=map[x+y*MAXMAP].it;
xe=it[in].x;
xs=it[in2].x;
for (x=it[in].x-1,y=it[in].y; y<it[in].y+15; y++) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
ye=y;
break;
}
}
for (x=it[in].x-1,y=it[in].y; y>it[in].y-15; y--) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
ys=y;
break;
}
}
break;
}
if (map[x+y*MAXMAP].flags&(MF_MOVEBLOCK|MF_TMOVEBLOCK)) break;
}
}
if (!in2) {
for (x=it[in].x,y=it[in].y+1; y<it[in].y+15; y++) {
if (map[x+y*MAXMAP].it && it[map[x+y*MAXMAP].it].driver==IDR_WARPTRIALDOOR) {
in2=map[x+y*MAXMAP].it;
ys=it[in].y;
ye=it[in2].y;
for (x=it[in].x,y=it[in].y+1; x<it[in].x+15; x++) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
xe=x;
break;
}
}
for (x=it[in].x,y=it[in].y+1; x>it[in].x-15; x--) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
xs=x;
break;
}
}
break;
}
if (map[x+y*MAXMAP].flags&(MF_MOVEBLOCK|MF_TMOVEBLOCK)) break;
}
}
if (!in2) {
for (x=it[in].x,y=it[in].y-1; y>it[in].y-15; y--) {
if (map[x+y*MAXMAP].it && it[map[x+y*MAXMAP].it].driver==IDR_WARPTRIALDOOR) {
in2=map[x+y*MAXMAP].it;
ye=it[in].y;
ys=it[in2].y;
for (x=it[in].x,y=it[in].y-1; x<it[in].x+15; x++) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
xe=x;
break;
}
}
for (x=it[in].x,y=it[in].y-1; x>it[in].x-15; x--) {
if (map[x+y*MAXMAP].flags&MF_MOVEBLOCK) {
xs=x;
break;
}
}
break;
}
if (map[x+y*MAXMAP].flags&(MF_MOVEBLOCK|MF_TMOVEBLOCK)) break;
}
}
//xlog("xs=%d, ys=%d, xe=%d, ye=%d, in=%d, in2=%d",xs,ys,xe,ye,in,in2);
it[in].drdata[2]=xs;
it[in].drdata[3]=ys;
it[in].drdata[4]=xe;
it[in].drdata[5]=ye;
*(unsigned short*)(it[in].drdata+6)=in2;
}
if (!cn) return 2;
xs=it[in].drdata[2];
ys=it[in].drdata[3];
xe=it[in].drdata[4];
ye=it[in].drdata[5];
in2=*(unsigned short*)(it[in].drdata+6);
if (ch[cn].x>=xs && ch[cn].x<=xe && ch[cn].y>=ys && ch[cn].y<=ye) {
log_char(cn,LOG_SYSTEM,0,"You cannot open the door from this side.");
return 2;
}
for (y=ys+1; y<ye; y++) {
for (x=xs+1,m=x+y*MAXMAP; x<xe; x++,m++) {
if ((co=map[m].ch) && ch[co].driver!=CDR_SIMPLEBADDY) {
log_char(cn,LOG_SYSTEM,0,"You hear fighting noises and the door won't open.");
return 2;
}
}
}
co=create_char("warped_fighter",0);
if (!co) {
log_char(cn,LOG_SYSTEM,0,"Bug #319i, sorry.");
return 2;
}
if (!drop_char(co,(xs+xe)/2,(ys+ye)/2,0)) {
log_char(cn,LOG_SYSTEM,0,"Bug #319j, sorry.");
destroy_char(co);
return 2;
}
ch[co].tmpx=ch[co].x;
ch[co].tmpy=ch[co].y;
warped_raise(co,ppd->base);
update_char(co);
ch[co].hp=ch[co].value[0][V_HP]*POWERSCALE;
ch[co].endurance=ch[co].value[0][V_ENDURANCE]*POWERSCALE;
ch[co].mana=ch[co].value[0][V_MANA]*POWERSCALE;
ch[co].lifeshield=ch[co].value[0][V_MAGICSHIELD]*POWERSCALE;
ch[co].dir=DX_RIGHTDOWN;
dat=set_data(co,DRD_WARPFIGHTER,sizeof(struct warpfighter_data));
if (!dat) {
log_char(cn,LOG_SYSTEM,0,"Bug #319k, sorry.");
remove_char(co);
destroy_char(co);
return 2;
}
dir=offset2dx(it[in].x,it[in].y,it[in2].x,it[in2].y);
if (!dir) {
log_char(cn,LOG_SYSTEM,0,"Bug #319l, sorry.");
remove_char(co);
destroy_char(co);
return 2;
}
dx2offset(dir,&dx,&dy,NULL);
dat->co=cn;
dat->cser=ch[cn].serial;
dat->tx=it[in2].x+dx;
dat->ty=it[in2].y+dy;
dat->xs=xs;
dat->xe=xe;
dat->ys=ys;
dat->ye=ye;
teleport_char_driver(cn,it[in].x+dx,it[in].y+dy);
return 1;
}
