ladder.c

打魔兽战网的都知道他是什么

		  if ((rating = account_get_ladder_active_rating(account,CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman))>0)
		  {
		    wins = account_get_ladder_active_wins(account,CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);
		    
		    if (w2bn_ari_res!=load_success)
	     	    {
		      war3_ladder_add(&W2BN_active_rating_ironman, uid,wins,rating,account,0,CLIENTTAG_WARCIIBNE_UINT);
	 	    }
		    
		    if (w2bn_awi_res!=load_success)
	     	    {
	 	      war3_ladder_add(&W2BN_active_wins_ironman, uid,rating,wins,account,0,CLIENTTAG_WARCIIBNE_UINT);
	 	    }
		    
		    if (w2bn_agi_res!=load_success)
	     	    {
	 	      int games = account_get_ladder_active_wins(account,CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman)+
		 		  account_get_ladder_active_losses(account,CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman)+
	         	          account_get_ladder_active_disconnects(account,CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);

	 	      war3_ladder_add(&W2BN_active_games_ironman, uid,rating, games,account,0,CLIENTTAG_WARCIIBNE_UINT);
	     	    }
		  }

	   }
    }
}


int standard_writer(FILE * fp, t_ladder * ladder, t_clienttag clienttag)
{
    t_ladder_internal * pointer;
    unsigned int rank=0;

    pointer = ladder->first;
    while (pointer != NULL)
    {
	rank++;
	if (clienttag==CLIENTTAG_WARCRAFT3_UINT || clienttag==CLIENTTAG_WAR3XP_UINT)
	{
	    if (ladder==at_ladder(clienttag))
	    {
		// if in the same team as previous account
		if ((pointer) && (pointer->next) 
		    && in_same_team(pointer->account,pointer->next->account,pointer->teamcount,pointer->next->teamcount,clienttag))
		{
		    rank--;
		}
		// other team... so write all team members names, xp and rank to file
		else
		{
		    //fprintf(fp,"%s,%u,%u\n",account_get_atteammembers(pointer->account,pointer->teamcount,clienttag),pointer->xp,rank);
		}
	    }
	    else
	    // write username, xp and rank to file
		fprintf(fp,"%s,%u,%u\n",account_get_name(pointer->account),pointer->xp,rank);
	}
	else if (clienttag==CLIENTTAG_STARCRAFT_UINT || clienttag==CLIENTTAG_BROODWARS_UINT || clienttag==CLIENTTAG_WARCIIBNE_UINT)
	{
	    fprintf(fp,"%u %s %u (%u / %u / %u)\n",rank, account_get_name(pointer->account),pointer->level,
		account_get_ladder_wins(pointer->account,ladder->clienttag,ladder->ladder_id), 
		account_get_ladder_losses(pointer->account,ladder->clienttag,ladder->ladder_id),
		account_get_ladder_disconnects(pointer->account,ladder->clienttag,ladder->ladder_id));
	}
	pointer=pointer->prev;
  }
  return 0;
}

int XML_writer(FILE * fp, t_ladder * ladder, t_clienttag clienttag)
  /* XML Ladder files
   * added by jfro 
   * 1/2/2003
   */
{
  t_ladder_internal * pointer;
  unsigned int rank=0;
  unsigned int level;
  unsigned int wins;
  unsigned int losses;
  unsigned int discs;
  unsigned int orc_wins,human_wins,undead_wins,nightelf_wins,random_wins;
  unsigned int orc_losses,human_losses,undead_losses,nightelf_losses,random_losses;

  fprintf(fp,"<?xml version=\"1.0\"?>\n<ladder>\n");
  pointer = ladder->first;
  while (pointer != NULL)
  {
     rank++;

     if (clienttag==CLIENTTAG_WARCRAFT3_UINT || clienttag==CLIENTTAG_WAR3XP_UINT)
     {
     
     if (ladder==at_ladder(clienttag))
     {
       // if in the same team as previous account
       if ((pointer) && (pointer->next) 
           && in_same_team(pointer->account,pointer->next->account,pointer->teamcount,pointer->next->teamcount,clienttag))
	       rank--;
       else
	 {
	   /* other team... so write all team members names, xp and rank to file
	   fprintf(fp,"\t<team>\n");
	   if (account_get_atteammembers(pointer->account,pointer->teamcount,clienttag)==NULL)
	     {
	       eventlog(eventlog_level_error,__FUNCTION__,"got invalid team, skipping");
	       pointer=pointer->prev;
	       continue;
	     }
	   
	   members = xstrdup(account_get_atteammembers(pointer->account,pointer->teamcount,clienttag));
	   for ( member = strtok(members," ");
		 member;
		 member = strtok(NULL," "))
	       fprintf(fp,"\t\t<member>%s</member>\n",member);
	   xfree(members);
	   fprintf(fp,"\t\t<xp>%u</xp>\n\t\t<rank>%u</rank>\n\t</team>\n",pointer->xp,rank);
	   */
	 }
     }
     else {
         if (ladder==solo_ladder(clienttag)) {
           level = account_get_ladder_level(pointer->account,clienttag,ladder_id_solo);
           wins = account_get_ladder_wins(pointer->account,clienttag,ladder_id_solo);
           losses = account_get_ladder_losses(pointer->account,clienttag,ladder_id_solo);
         }
         else if (ladder==team_ladder(clienttag)) {
           level = account_get_ladder_level(pointer->account,clienttag,ladder_id_team);
           wins = account_get_ladder_wins(pointer->account,clienttag,ladder_id_team);
           losses = account_get_ladder_losses(pointer->account,clienttag,ladder_id_team);
         }
         else if (ladder==ffa_ladder(clienttag)) {
           level = account_get_ladder_level(pointer->account,clienttag,ladder_id_ffa);
           wins = account_get_ladder_wins(pointer->account,clienttag,ladder_id_ffa);
           losses = account_get_ladder_losses(pointer->account,clienttag,ladder_id_ffa);
         }
         else {
           level = 0;
           wins = 0;
           losses = 0;
         }
         orc_wins = account_get_racewins(pointer->account,W3_RACE_ORCS,clienttag);
         orc_losses = account_get_racelosses(pointer->account,W3_RACE_ORCS,clienttag);
         undead_wins = account_get_racewins(pointer->account,W3_RACE_UNDEAD,clienttag);
         undead_losses = account_get_racelosses(pointer->account,W3_RACE_UNDEAD,clienttag);
         human_wins = account_get_racewins(pointer->account,W3_RACE_HUMANS,clienttag);
         human_losses = account_get_racelosses(pointer->account,W3_RACE_HUMANS,clienttag);
         nightelf_wins = account_get_racewins(pointer->account,W3_RACE_NIGHTELVES,clienttag);
         nightelf_losses = account_get_racelosses(pointer->account,W3_RACE_NIGHTELVES,clienttag);
         random_wins = account_get_racewins(pointer->account,W3_RACE_RANDOM,clienttag);
         random_losses = account_get_racelosses(pointer->account,W3_RACE_RANDOM,clienttag);
     // write username, xp and rank to file and everyhing else needed for nice ladder pages
	 fprintf(fp,"\t<player>\n\t\t<name>%s</name>\n\t\t<level>%u</level>\n\t\t<xp>%u</xp>\n",
                    account_get_name(pointer->account),level,pointer->xp);
	 fprintf(fp,"\t\t<wins>%u</wins>\n\t\t<losses>%u</losses>\n\t\t<rank>%u</rank>\n",
                    wins,losses,rank);
	 fprintf(fp,"\t\t<races>\n\t\t\t<orc>\n\t\t\t\t<wins>%u</wins>\n\t\t\t\t<losses>%u</losses>\n\t\t\t</orc>\n",
                    orc_wins,orc_losses);
	 fprintf(fp,"\t\t\t<human>\n\t\t\t\t<wins>%u</wins>\n\t\t\t\t<losses>%u</losses>\n\t\t\t</human>\n",
                    human_wins,human_losses);
	 fprintf(fp,"\t\t\t<nightelf>\n\t\t\t\t<wins>%u</wins>\n\t\t\t\t<losses>%u</losses>\n\t\t\t</nightelf>\n",
		    nightelf_wins,nightelf_losses);
	 fprintf(fp,"\t\t\t<undead>\n\t\t\t\t<wins>%u</wins>\n\t\t\t\t<losses>%u</losses>\n\t\t\t</undead>\n",
		    undead_wins,undead_losses);
	 fprintf(fp,"\t\t\t<random>\n\t\t\t\t<wins>%u</wins>\n\t\t\t\t<losses>%u</losses>\n\t\t\t</random>\n\t\t</races>\n\t</player>\n",
                    random_wins,random_losses);
     }
     
     } // end: if clienttag WAR3 or WAR3XP
    else if (clienttag==CLIENTTAG_STARCRAFT_UINT || clienttag==CLIENTTAG_BROODWARS_UINT || clienttag==CLIENTTAG_WARCIIBNE_UINT)
    {
	wins = account_get_ladder_wins(pointer->account,ladder->clienttag,ladder->ladder_id);
	losses = account_get_ladder_losses(pointer->account,ladder->clienttag,ladder->ladder_id);
	discs = account_get_ladder_disconnects(pointer->account,ladder->clienttag,ladder->ladder_id);
	
	fprintf(fp,"\t<player>\n\t\t<rank>%u</rank>\n\t\t<name>%s</name>\n\t\t<rating>%u</rating>\n",
	    rank, account_get_name(pointer->account),pointer->level);
	fprintf(fp,"\t\t<wins>%u</wins>\n\t\t<losses>%u</losses>\n\t\t<discs>%u</discs>\n\t</player>\n",
                    wins,losses,discs);
    }

     pointer=pointer->prev;
  }
  fprintf(fp,"</ladder>\n");
  return 0;
}


extern int ladder_write_to_file(char const * filename, t_ladder * ladder, t_clienttag clienttag)
{
  FILE * fp;
  
  if (!filename)
  {
    eventlog(eventlog_level_error,__FUNCTION__,"got NULL filename");
    return -1;
  }
  
  if (!(fp = fopen(filename,"w")))
  { 
     eventlog(eventlog_level_error,__FUNCTION__,"could not open file \"%s\" for writing (fopen: %s)",filename,pstrerror(errno)); 
     return -1;
  }

  if (prefs_get_XML_output_ladder())
    XML_writer(fp,ladder,clienttag);
  else
    standard_writer(fp,ladder,clienttag);

  fclose(fp);
  return 0;
}

extern int ladders_write_to_file()
{
  
  ladder_write_to_file(WAR3_solo_filename, &WAR3_solo_ladder,CLIENTTAG_WARCRAFT3_UINT);
  ladder_write_to_file(WAR3_team_filename, &WAR3_team_ladder,CLIENTTAG_WARCRAFT3_UINT);
  ladder_write_to_file(WAR3_ffa_filename,  &WAR3_ffa_ladder, CLIENTTAG_WARCRAFT3_UINT);
  ladder_write_to_file(WAR3_at_filename,   &WAR3_at_ladder,  CLIENTTAG_WARCRAFT3_UINT);
  ladder_write_to_file(W3XP_solo_filename, &W3XP_solo_ladder,   CLIENTTAG_WAR3XP_UINT);
  ladder_write_to_file(W3XP_team_filename, &W3XP_team_ladder,   CLIENTTAG_WAR3XP_UINT);
  ladder_write_to_file(W3XP_ffa_filename,  &W3XP_ffa_ladder,    CLIENTTAG_WAR3XP_UINT);
  ladder_write_to_file(W3XP_at_filename,   &W3XP_at_ladder,     CLIENTTAG_WAR3XP_UINT);
  ladder_write_to_file(STAR_ar_filename,   &STAR_active_rating, CLIENTTAG_STARCRAFT_UINT);
  ladder_write_to_file(STAR_cr_filename,   &STAR_current_rating,CLIENTTAG_STARCRAFT_UINT);
  ladder_write_to_file(SEXP_ar_filename,   &SEXP_active_rating, CLIENTTAG_BROODWARS_UINT);
  ladder_write_to_file(SEXP_cr_filename,   &SEXP_current_rating,CLIENTTAG_BROODWARS_UINT);
  ladder_write_to_file(W2BN_ar_filename,   &W2BN_active_rating, CLIENTTAG_WARCIIBNE_UINT);
  ladder_write_to_file(W2BN_cr_filename,   &W2BN_current_rating,CLIENTTAG_WARCIIBNE_UINT);
  ladder_write_to_file(W2BN_ari_filename,  &W2BN_active_rating_ironman, CLIENTTAG_WARCIIBNE_UINT);
  ladder_write_to_file(W2BN_cri_filename,  &W2BN_current_rating_ironman,CLIENTTAG_WARCIIBNE_UINT);

  return 0;
}

extern char * create_filename(const char * path, const char * filename, const char * ending)
{
  char * result;

  result = xmalloc(strlen(path)+1+strlen(filename)+strlen(ending)+1);
  sprintf(result,"%s/%s%s",path,filename,ending);

  return result;
}

static void dispose_filename(char * filename)
{
  if (filename) xfree(filename);
}

void create_filenames(void)
{
    // In the ladderdir are binary ladder files, the human readable ladderlist output 
    // is better in other place, in the outputdir [KWS]

  if (prefs_get_XML_output_ladder())
  {
    WAR3_solo_filename = create_filename(prefs_get_outputdir(),WAR3_solo_file,xml_end);
    WAR3_team_filename = create_filename(prefs_get_outputdir(),WAR3_team_file,xml_end);
    WAR3_ffa_filename  = create_filename(prefs_get_outputdir(),WAR3_ffa_file,xml_end);
    WAR3_at_filename   = create_filename(prefs_get_outputdir(),WAR3_at_file,xml_end);
    W3XP_solo_filename = create_filename(prefs_get_outputdir(),W3XP_solo_file,xml_end);
    W3XP_team_filename = create_filename(prefs_get_outputdir(),W3XP_team_file,xml_end);
    W3XP_ffa_filename  = create_filename(prefs_get_outputdir(),W3XP_ffa_file,xml_end);
    W3XP_at_filename   = create_filename(prefs_get_outputdir(),W3XP_at_file,xml_end);
    STAR_ar_filename   = create_filename(prefs_get_outputdir(),STAR_ar_file,xml_end);
    STAR_cr_filename   = create_filename(prefs_get_outputdir(),STAR_cr_file,xml_end);
    SEXP_ar_filename   = create_filename(prefs_get_outputdir(),SEXP_ar_file,xml_end);
    SEXP_cr_filename   = create_filename(prefs_get_outputdir(),SEXP_cr_file,xml_end);
    W2BN_ar_filename   = create_filename(prefs_get_outputdir(),W2BN_ar_file,xml_end);
    W2BN_cr_filename   = create_filename(prefs_get_outputdir(),W2BN_cr_file,xml_end);
    W2BN_ari_filename  = create_filename(prefs_get_outputdir(),W2BN_ari_file,xml_end);
    W2BN_cri_filename  = create_filename(prefs_get_outputdir(),W2BN_cri_file,xml_end);
  }
  else
  {
    WAR3_solo_filename = create_filename(prefs_get_outputdir(),WAR3_solo_file,std_end);
    WAR3_team_filename = create_filename(prefs_get_outputdir(),WAR3_team_file,std_end);
    WAR3_ffa_filename  = create_filename(prefs_get_outputdir(),WAR3_ffa_file,std_end);
    WAR3_at_filename   = create_filename(prefs_get_outputdir(),WAR3_at_file,std_end);
    W3XP_solo_filename = create_filename(prefs_get_outputdir(),W3XP_solo_file,std_end);
    W3XP_team_filename = create_filename(prefs_get_outputdir(),W3XP_team_file,std_end);
    W3XP_ffa_filename  = create_filename(prefs_get_outputdir(),W3XP_ffa_file,std_end);
    W3XP_at_filename   = create_filename(prefs_get_outputdir(),W3XP_at_file,std_end);
    STAR_ar_filename   = create_filename(prefs_get_outputdir(),STAR_ar_file,std_end);
    STAR_cr_filename   = create_filename(prefs_get_outputdir(),STAR_cr_file,std_end);
    SEXP_ar_filename   = create_filename(prefs_get_outputdir(),SEXP_ar_file,std_end);
    SEXP_cr_filename   = create_filename(prefs_get_outputdir(),SEXP_cr_file,std_end);
    W2BN_ar_filename   = create_filename(prefs_get_outputdir(),W2BN_ar_file,std_end);
    W2BN_cr_filename   = create_filename(prefs_get_outputdir(),W2BN_cr_file,std_end);
    W2BN_ari_filename  = create_filename(prefs_get_outputdir(),W2BN_ari_file,std_end);
    W2BN_cri_filename  = create_filename(prefs_get_outputdir(),W2BN_cri_file,std_end);
  }
}

extern void ladders_init(void)
{
  eventlog(eventlog_level_info,__FUNCTION__,"initializing war3 ladders");
  ladder_init(&WAR3_solo_ladder,    WAR3_SOLO, CLIENTTAG_WARCRAFT3_UINT,ladder_id_solo);
  ladder_init(&WAR3_team_ladder,    WAR3_TEAM, CLIENTTAG_WARCRAFT3_UINT,ladder_id_team);
  ladder_init(&WAR3_ffa_ladder,     WAR3_FFA,  CLIENTTAG_WARCRAFT3_UINT,ladder_id_ffa);
  ladder_init(&WAR3_at_ladder,      WAR3_AT,   CLIENTTAG_WARCRAFT3_UINT,ladder_id_none);
  ladder_init(&W3XP_solo_ladder,    W3XP_SOLO, CLIENTTAG_WAR3XP_UINT,ladder_id_solo);
  ladder_init(&W3XP_team_ladder,    W3XP_TEAM, CLIENTTAG_WAR3XP_UINT,ladder_id_team);
  ladder_init(&W3XP_ffa_ladder,     W3XP_FFA,  CLIENTTAG_WAR3XP_UINT,ladder_id_ffa);
  ladder_init(&W3XP_at_ladder,      W3XP_AT,   CLIENTTAG_WAR3XP_UINT,ladder_id_none);
  ladder_init(&STAR_active_rating,  STAR_AR,   CLIENTTAG_STARCRAFT_UINT,ladder_id_normal);
  ladder_init(&STAR_active_wins,    STAR_AW,   CLIENTTAG_STARCRAFT_UINT,ladder_id_normal);
  ladder_init(&STAR_active_games,   STAR_AG,   CLIENTTAG_STARCRAFT_UINT,ladder_id_normal);
  ladder_init(&STAR_current_rating, STAR_CR,   CLIENTTAG_STARCRAFT_UINT,ladder_id_normal);
  ladder_init(&STAR_current_wins,   STAR_CW,   CLIENTTAG_STARCRAFT_UINT,ladder_id_normal);
  ladder_init(&STAR_current_games,  STAR_CG,   CLIENTTAG_STARCRAFT_UINT,ladder_id_normal);
  ladder_init(&SEXP_active_rating,  SEXP_AR,   CLIENTTAG_BROODWARS_UINT,ladder_id_normal);
  ladder_init(&SEXP_active_wins,    SEXP_AW,   CLIENTTAG_BROODWARS_UINT,ladder_id_normal);
  ladder_init(&SEXP_active_games,   SEXP_AG,   CLIENTTAG_BROODWARS_UINT,ladder_id_normal);
  ladder_init(&SEXP_current_rating, SEXP_CR,   CLIENTTAG_BROODWARS_UINT,ladder_id_normal);
  ladder_init(&SEXP_current_wins,   SEXP_CW,   CLIENTTAG_BROODWARS_UINT,ladder_id_normal);
  ladder_init(&SEXP_current_games,  SEXP_CG,   CLIENTTAG_BROODWARS_UINT,ladder_id_normal);
  ladder_init(&W2BN_current_rating,         W2BN_CR,   CLIENTTAG_WARCIIBNE_UINT,ladder_id_normal);
  ladder_init(&W2BN_current_wins,           W2BN_CW,   CLIENTTAG_WARCIIBNE_UINT,ladder_id_normal);
  ladder_init(&W2BN_current_games,          W2BN_CG,   CLIENTTAG_WARCIIBNE_UINT,ladder_id_normal);
  ladder_init(&W2BN_current_rating_ironman, W2BN_CRI,  CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);
  ladder_init(&W2BN_current_wins_ironman,   W2BN_CWI,  CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);
  ladder_init(&W2BN_current_games_ironman,  W2BN_CGI,  CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);
  ladder_init(&W2BN_active_rating,          W2BN_AR,   CLIENTTAG_WARCIIBNE_UINT,ladder_id_normal);
  ladder_init(&W2BN_active_wins,            W2BN_AW,   CLIENTTAG_WARCIIBNE_UINT,ladder_id_normal);
  ladder_init(&W2BN_active_games,           W2BN_AG,   CLIENTTAG_WARCIIBNE_UINT,ladder_id_normal);
  ladder_init(&W2BN_active_rating_ironman,  W2BN_ARI,  CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);
  ladder_init(&W2BN_active_wins_ironman,    W2BN_AWI,  CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);
  ladder_init(&W2BN_active_games_ironman,   W2BN_AGI,  CLIENTTAG_WARCIIBNE_UINT,ladder_id_ironman);

  create_filenames();
}

void dispose_filenames(void)
{
  dispose_filename(WAR3_solo_filename);
  dispose_filename(WAR3_team_filename);
  dispose_filename(WAR3_ffa_filename);
  dispose_filename(WAR3_at_filename);
  dispose_filename(W3XP_solo_filename);
  dispose_filename(W3XP_team_filename);
  dispose_filename(W3XP_ffa_filename);
  dispose_filename(W3XP_at_filename);
  dispose_filename(STAR_ar_filename);
  dispose_filename(STAR_cr_filename);
  dispose_filename(SEXP_ar_filename);
  dispose_filename(SEXP_cr_filename);
  dispose_filename(W2BN_ar_filename);
  dispose_filename(W2BN_cr_filename);
  dispose_filename(W2BN_ari_filename);
  dispose_filename(W2BN_cri_filename);
}

extern void ladders_destroy(void)
{
  eventlog(eventlog_level_info,__FUNCTION__,"destroying war3 ladders");
  ladder_destroy(&WAR3_solo_ladder);
  ladder_destroy(&WAR3_team_ladder);
  ladder_destroy(&WAR3_ffa_ladder);
  ladder_destroy(&WAR3_at_ladder