char2.c

仙镜游戏源码,仅供学习!请勿用于非法应用!

#else
      // old version
      WFIFOW(fdc,2)=4+found_num*106;
      for( i = 0; i < found_num; i++ ) {

	j=sd->found_char[i];

	memset(WFIFOP(fdc,4+(i*106)),0x00,106);

	WFIFOL(fdc,4+(i*106)) = char_dat[j].char_id;
	WFIFOL(fdc,4+(i*106)+4) = char_dat[j].base_exp;
	WFIFOL(fdc,4+(i*106)+8) = char_dat[j].zeny;
	WFIFOL(fdc,4+(i*106)+12) = char_dat[j].job_exp;
	WFIFOL(fdc,4+(i*106)+16) = char_dat[j].job_level;

	WFIFOL(fdc,4+(i*106)+20) = 0;
	WFIFOL(fdc,4+(i*106)+24) = 0;
	WFIFOL(fdc,4+(i*106)+28) = char_dat[j].option;

	WFIFOL(fdc,4+(i*106)+32) = char_dat[j].karma;
	WFIFOL(fdc,4+(i*106)+36) = char_dat[j].manner;

	WFIFOW(fdc,4+(i*106)+40) = char_dat[j].status_point;
	WFIFOW(fdc,4+(i*106)+42) = char_dat[j].hp;
	WFIFOW(fdc,4+(i*106)+44) = char_dat[j].max_hp;
	WFIFOW(fdc,4+(i*106)+46) = char_dat[j].sp;
	WFIFOW(fdc,4+(i*106)+48) = char_dat[j].max_sp;
	WFIFOW(fdc,4+(i*106)+50) = DEFAULT_WALK_SPEED; // char_dat[j].speed;
	WFIFOW(fdc,4+(i*106)+52) = char_dat[j].class;
	WFIFOW(fdc,4+(i*106)+54) = char_dat[j].hair;
	WFIFOW(fdc,4+(i*106)+56) = 0;
	WFIFOW(fdc,4+(i*106)+58) = char_dat[j].base_level;
	WFIFOW(fdc,4+(i*106)+60) = char_dat[j].skill_point;
	WFIFOW(fdc,4+(i*106)+62) = 0;
	WFIFOW(fdc,4+(i*106)+64) = char_dat[j].sheild;
	WFIFOW(fdc,4+(i*106)+66) = char_dat[j].head_top;
	WFIFOW(fdc,4+(i*106)+68) = char_dat[j].head_mid;
	WFIFOW(fdc,4+(i*106)+70) = char_dat[j].hair_color;
	WFIFOW(fdc,4+(i*106)+72) = char_dat[j].clothes_color;

	memcpy( WFIFOP(fdc,4+(i*106)+74), char_dat[j].name, 24 );

	WFIFOB(fdc,4+(i*106)+98) = char_dat[j].str;
	WFIFOB(fdc,4+(i*106)+99) = char_dat[j].agi;
	WFIFOB(fdc,4+(i*106)+100) = char_dat[j].vit;
	WFIFOB(fdc,4+(i*106)+101) = char_dat[j].int_;
	WFIFOB(fdc,4+(i*106)+102) = char_dat[j].dex;
	WFIFOB(fdc,4+(i*106)+103) = char_dat[j].luk;
	WFIFOB(fdc,4+(i*106)+104) = char_dat[j].char_num;
      }
#endif
      WFIFOSET(fdc,WFIFOW(fdc,2));
      RFIFOSKIP(fd,7);
      break;
    default:
      close(fd);
      session[fd]->eof=1;
      return 0;
    }
  }
  RFIFOFLUSH(fd);
  return 0;
}

int parse_frommap(int fd)
{
  int i,j;
  int id;

  for(id=0;id<MAX_SERVERS;id++)
    if(server_fd[id]==fd)
      break;
  if(id==MAX_SERVERS)
    session[fd]->eof=1;
  if(session[fd]->eof){
    for(i=0;i<MAX_SERVERS;i++)
      if(server_fd[i]==fd)
	server_fd[i]=-1;
    close(fd);
    delete_session(fd);
    return 0;
  }
  //printf("parse_frommap : %d %d %d\n",fd,RFIFOREST(fd),RFIFOW(fd,0));
  while(RFIFOREST(fd)>=2){
    switch(RFIFOW(fd,0)){
    case 0x2afa:
      for(i=4,j=0;i<RFIFOW(fd,2);i+=16,j++){
	memcpy(server[id].map[j],RFIFOP(fd,i),16);
	printf("set map %d.%d : %s\n",id,j,server[id].map[j]);
      }
      server[id].map[j][0]=0;
      RFIFOSKIP(fd,RFIFOW(fd,2));
      WFIFOW(fd,0)=0x2afb;
      WFIFOW(fd,2)=0;
      WFIFOSET(fd,3);
      break;
    case 0x2afc:
      if(RFIFOREST(fd)<14)
	return 0;
      printf("auth_fifo search %08x %08x %08x\n",RFIFOL(fd,2),RFIFOL(fd,6),RFIFOL(fd,10));
      for(i=0;i<AUTH_FIFO_SIZE;i++){
	if(auth_fifo[i].account_id==RFIFOL(fd,2) &&
	   auth_fifo[i].char_id==RFIFOL(fd,6) &&
	   auth_fifo[i].login_id1==RFIFOL(fd,10) &&
	   !auth_fifo[i].delflag){
	  auth_fifo[i].delflag=1;
	  break;
	}
      }
      printf("auth_fifo searched %d\n",i);
      if(i==AUTH_FIFO_SIZE){
	WFIFOW(fd,0)=0x2afe;
	WFIFOW(fd,2)=RFIFOL(fd,2);
	WFIFOB(fd,6)=0;
	WFIFOSET(fd,7);
      } else {
	WFIFOW(fd,0)=0x2afd;
	WFIFOW(fd,2)=12+sizeof(char_dat[0]);
	WFIFOL(fd,4)=RFIFOL(fd,2);
	WFIFOL(fd,8)=RFIFOL(fd,6);
	memcpy(WFIFOP(fd,12),&char_dat[auth_fifo[i].char_pos],sizeof(char_dat[0]));
	WFIFOSET(fd,WFIFOW(fd,2));
      }
      RFIFOSKIP(fd,14);
      break;
    case 0x2aff:
if(RFIFOREST(fd)<6) 
return 0; 
      server[id].users=RFIFOL(fd,2);
      RFIFOSKIP(fd,6);
      break;
    case 0x2b01:
 if(RFIFOREST(fd)<4 || RFIFOREST(fd)<RFIFOW(fd,2)) 
return 0; 


      for(i=0;i<char_num;i++){
	if(char_dat[i].account_id==RFIFOL(fd,4) &&
	   char_dat[i].char_id==RFIFOL(fd,8))
	  break;
      }
      if(i!=char_num){
	memcpy(&char_dat[i],RFIFOP(fd,12),sizeof(char_dat[0]));
      }
      RFIFOSKIP(fd,RFIFOW(fd,2));
      break;
    default:
      close(fd);
      session[fd]->eof=1;
      return 0;
    }
  }
  return 0;
}

int search_mapserver(char *map)
{
  int i,j,k;
  printf("search_mapserver %s\n",map);
  for(i=0;i<MAX_SERVERS;i++){
    if(server_fd[i]<0)
      continue;
    for(j=0;server[i].map[j][0];j++){
      //printf("%s : %s = %d\n",server[i].map[j],map,strcmp(server[i].map[j],map));
      if((k=strcmp(server[i].map[j],map))==0){
	printf("search_mapserver success %s -> %d\n",map,i);
	return i;
      }
      //printf("%s : %s = %d\n",server[i].map[j],map,k);
    }
  }
  printf("search_mapserver failed\n");
  return -1;
}

int parse_char(int fd)
{
  int i,ch;
  struct char_session_data *sd;

  if(login_fd<0)
    session[fd]->eof=1;
  if(session[fd]->eof){
    if(fd==login_fd)
      login_fd=-1;
    close(fd);
    delete_session(fd);
    return 0;
  }
  printf("parse_char : %d %d %d\n",fd,RFIFOREST(fd),RFIFOW(fd,0));
  sd=session[fd]->session_data;
  while(RFIFOREST(fd)>=2){
    switch(RFIFOW(fd,0)){
    case 0x65:
      if(RFIFOREST(fd)<17)
	return 0;
      if(sd==NULL){
	sd=session[fd]->session_data=malloc(sizeof(*sd));
	memset(sd,0,sizeof(*sd));
      }
      WFIFOW(login_fd,0)=0x2712;
      sd->account_id=WFIFOL(login_fd,2)=RFIFOL(fd,2);
      sd->login_id1=WFIFOL(login_fd,6)=RFIFOL(fd,6);
      sd->login_id2=WFIFOL(login_fd,10)=RFIFOL(fd,10);
      WFIFOSET(login_fd,14);
      sd->sex=RFIFOB(fd,16);
      sd->state=CHAR_STATE_WAITAUTH;
      WFIFOL(fd,0)=RFIFOL(fd,2);
      WFIFOSET(fd,4);
      RFIFOSKIP(fd,17);
      break;
    case 0x66:
      if(RFIFOREST(fd)<3)
	return 0;
      for(ch=0;ch<3;ch++)
	if(sd->found_char[ch]>=0 && char_dat[sd->found_char[ch]].char_num==RFIFOB(fd,2))
	  break;
      if(ch!=3){
	FILE *logfp;

	logfp=fopen("char.log","a");
	if(logfp){
	  fprintf(logfp,"char select %d-%d %s\n",sd->account_id,RFIFOB(fd,2),char_dat[sd->found_char[ch]].name);
	  fclose(logfp);
	}

	WFIFOW(fd,0)=0x71;
	WFIFOL(fd,2)=char_dat[sd->found_char[ch]].char_id;
	memcpy(WFIFOP(fd,6),char_dat[sd->found_char[ch]].last_point.map,16);
	i=search_mapserver(char_dat[sd->found_char[ch]].last_point.map);
	if(i<0){
	  WFIFOL(fd,22)=char_ip;
	  WFIFOW(fd,26)=5001;
	} else {
	  WFIFOL(fd,22)=server[i].ip;
	  WFIFOW(fd,26)=server[i].port;
	}
	WFIFOSET(fd,28);

	if(auth_fifo_pos>=AUTH_FIFO_SIZE){
	  auth_fifo_pos=0;
	}
	printf("auth_fifo set %d - %08x %08x %08x\n",auth_fifo_pos,sd->account_id,char_dat[sd->found_char[ch]].char_id,sd->login_id1);
	auth_fifo[auth_fifo_pos].account_id=sd->account_id;
	auth_fifo[auth_fifo_pos].char_id=char_dat[sd->found_char[ch]].char_id;
	auth_fifo[auth_fifo_pos].login_id1=sd->login_id1;
	auth_fifo[auth_fifo_pos].delflag=0;
	auth_fifo[auth_fifo_pos].char_pos=sd->found_char[ch];
	auth_fifo_pos++;
      }
      RFIFOSKIP(fd,3);
      break;
    case 0x67:
      i=make_new_char(fd,RFIFOP(fd,2));
      if(i<0){
	WFIFOW(fd,0)=0x6e;
	WFIFOB(fd,2)=0x00;
	WFIFOSET(fd,3);
	RFIFOSKIP(fd,37);
	break;
      }

      WFIFOW(fd,0)=0x6d;
      memset(WFIFOP(fd,2),0x00,106);

      WFIFOL(fd,2) = char_dat[i].char_id;
      WFIFOL(fd,2+4) = char_dat[i].base_exp;
      WFIFOL(fd,2+8) = char_dat[i].zeny;
      WFIFOL(fd,2+12) = char_dat[i].job_exp;
      WFIFOL(fd,2+16) = char_dat[i].job_level;

      WFIFOL(fd,2+28) = char_dat[i].karma;
      WFIFOL(fd,2+32) = char_dat[i].manner;

      WFIFOW(fd,2+40) = 0x30;	
      WFIFOW(fd,2+42) = char_dat[i].hp;
      WFIFOW(fd,2+44) = char_dat[i].max_hp;
      WFIFOW(fd,2+46) = char_dat[i].sp;
      WFIFOW(fd,2+48) = char_dat[i].max_sp;
      WFIFOW(fd,2+50) = 150; // char_dat[i].speed;
      WFIFOW(fd,2+52) = char_dat[i].class;
      WFIFOW(fd,2+54) = char_dat[i].hair;

      WFIFOW(fd,2+58) = char_dat[i].base_level;
      WFIFOW(fd,2+60) = char_dat[i].skill_point;

      WFIFOW(fd,2+64) = char_dat[i].sheild;
      WFIFOW(fd,2+66) = char_dat[i].head_top;
      WFIFOW(fd,2+68) = char_dat[i].head_mid;
      WFIFOW(fd,2+70) = char_dat[i].hair_color;

      memcpy( WFIFOP(fd,2+74), char_dat[i].name, 24 );

      WFIFOB(fd,2+98) = char_dat[i].str;
      WFIFOB(fd,2+99) = char_dat[i].agi;
      WFIFOB(fd,2+100) = char_dat[i].vit;
      WFIFOB(fd,2+101) = char_dat[i].int_;
      WFIFOB(fd,2+102) = char_dat[i].dex;
      WFIFOB(fd,2+103) = char_dat[i].luk;
      WFIFOB(fd,2+104) = char_dat[i].char_num;

      WFIFOSET(fd,108);
      RFIFOSKIP(fd,37);
      if(sd->found_char[0]==-1)
	sd->found_char[0]=i;
      else if(sd->found_char[1]==-1)
	sd->found_char[1]=i;
      else
	sd->found_char[2]=i;
      break;
    case 0x68:
      for(i=0;i<3;i++){
	if(char_dat[sd->found_char[i]].char_id==RFIFOL(fd,2)){
	  if(sd->found_char[i]!=char_num-1){
	    memcpy(&char_dat[sd->found_char[i]],&char_dat[char_num-1],sizeof(char_dat[0]));
	  }
	  char_num--;
	  if(i==0){
	    sd->found_char[0]=sd->found_char[1];
	    sd->found_char[1]=sd->found_char[2];
	  } else if(i==1){
	    sd->found_char[1]=sd->found_char[2];
	  }
	  sd->found_char[2]=-1;
	  break;
	}
      }
      if(i==3){
	WFIFOW(fd,0)=0x70;
	WFIFOB(fd,2)=0;
	WFIFOSET(fd,3);
      } else {
	WFIFOW(fd,0)=0x6f;
	WFIFOSET(fd,2);
      }
      RFIFOSKIP(fd,46);
      break;
    case 0x2af8:
      if(RFIFOREST(fd)<60)
	return 0;
      WFIFOW(fd,0)=0x2af9;
      for(i=0;i<MAX_SERVERS;i++){
	if(server_fd[i]<0)
	  break;
      }
      if(i==MAX_SERVERS || strcmp(RFIFOP(fd,2),userid) || strcmp(RFIFOP(fd,26),passwd)){
	WFIFOB(fd,2)=3;
	WFIFOSET(fd,3);
	RFIFOSKIP(fd,60);
      } else {
	WFIFOB(fd,2)=0;
	session[fd]->func_parse=parse_frommap;
	server_fd[i]=fd;
	server[i].ip=RFIFOL(fd,54);
	server[i].port=RFIFOW(fd,58);
	server[i].users=0;
	memset(server[i].map,0,sizeof(server[i].map));
	WFIFOSET(fd,3);
	RFIFOSKIP(fd,60);
	return 0;
      }
      break;
    default:
      close(fd);
      session[fd]->eof=1;
      return 0;
    }
  }
  RFIFOFLUSH(fd);
  return 0;
}

int send_users_tologin(int tid,unsigned int tick,int id,int data)
{
  if(login_fd>0 && session[login_fd]){
    int i,users;
    for(i=0,users=0;i<MAX_SERVERS;i++){
      if(server_fd[i]>0){
	users+=server[i].users;
      }
    }
    WFIFOW(login_fd,0)=0x2714;
    WFIFOL(login_fd,2)=users;
    WFIFOSET(login_fd,6);
    for(i=0;i<MAX_SERVERS;i++){
      int fd;
      if((fd=server_fd[i])>0){
	WFIFOW(fd,0)=0x2b00;
	WFIFOL(fd,2)=users;
	WFIFOSET(fd,6);
      }
    }
  }
  return 0;
}

int check_connect_login_server(int tid,unsigned int tick,int id,int data)
{
  if(login_fd<=0 || session[login_fd]==NULL){
    login_fd=make_connection(inet_addr(login_ip_str),login_port);
    session[login_fd]->func_parse=parse_tologin;
    WFIFOW(login_fd,0)=0x2710;
    memcpy(WFIFOP(login_fd,2),userid,24);
    memcpy(WFIFOP(login_fd,26),passwd,24);
    WFIFOL(login_fd,50)=0;
    WFIFOL(login_fd,54)=char_ip;
    WFIFOL(login_fd,58)=char_port;
    memcpy(WFIFOP(login_fd,60),server_name,16);
    WFIFOSET(login_fd,76);
  }
  return 0;
}

int do_init(int argc,char **argv)
{
  int i;
  if(argv[1]){
    char line[1024],w1[1024],w2[1024];
    FILE *fp=fopen(argv[1],"r");
    if(fp==NULL){
      printf("file not found: %s\n",argv[1]);
      exit(1);
    }
    while(fgets(line,1020,fp)){
      i=sscanf(line,"%[^:]:%s",w1,w2);
      if(i!=2)
	continue;
      if(strcmp(w1,"userid")==0){
	memcpy(userid,w2,24);
      } else if(strcmp(w1,"passwd")==0){
	memcpy(passwd,w2,24);
      } else if(strcmp(w1,"server_name")==0){
	memcpy(server_name,w2,16);
      } else if(strcmp(w1,"login_ip")==0){
	memcpy(login_ip_str,w2,16);
      } else if(strcmp(w1,"login_port")==0){
	login_port=atoi(w2);
      } else if(strcmp(w1,"char_ip")==0){
	memcpy(char_ip_str,w2,16);
      } else if(strcmp(w1,"char_port")==0){
	char_port=atoi(w2);
      } else if(strcmp(w1,"char_txt")==0){
	strcpy(char_txt,w2);
      }
    }
    fclose(fp);
  }
  char_ip=inet_addr(char_ip_str);

  for(i=0;i<MAX_SERVERS;i++)
    server_fd[i]=-1;

  mmo_char_init();
  term_func=mmo_char_sync;

  default_func_parse=parse_char;
  make_listen_port(char_port);

  i=add_timer(gettick()+10,check_connect_login_server,0,0);
  timer_data[i]->type=TIMER_INTERVAL;
  timer_data[i]->interval=10*1000;

  i=add_timer(gettick()+10,send_users_tologin,0,0);
  timer_data[i]->type=TIMER_INTERVAL;
  timer_data[i]->interval=5*1000;
  return 0;
}