ladder.c

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

	     if (teamfound!=NULL) search = teamfound;
          }

          if (search == NULL)
          {
            ladder->first->next = ladder_entry;
            ladder_entry->prev  = ladder->first;
            ladder->first       = ladder_entry;
          }
          else
          {
             ladder_entry->next = search;
             ladder_entry->prev = search->prev;
             if (search == ladder->last)
             // enter at end of list
             {
                search->prev = ladder_entry;
                ladder->last = ladder_entry;
             }
             else
             {
                search->prev->next = ladder_entry;
                search->prev       = ladder_entry;
             }
          }
        }
        else
        // start from first and the search towards last
        {
          t_ladder_internal *search;
          search = ladder->first;
	  while ((search != NULL) && (search->level > level))
	  {
	     search = search->prev;
	  }
          while ((search != NULL) && (search->level == level) && (search->xp > xp))
          {
             search = search->prev;
          }

	  if (teamcount!=0) // this only happens for atteams
	  {
	     t_ladder_internal *teamsearch;
	     t_ladder_internal *teamfound;

	     teamsearch = search;
	     teamfound = NULL;

	     while ((teamsearch != NULL) && (teamsearch->xp == xp))
	     {
	         if (in_same_team(account,teamsearch->account,teamcount,teamsearch->teamcount,clienttag))
		 {
		    teamfound = teamsearch;
		    break;
		 }
		 teamsearch = teamsearch->prev;
	     }
	     if (teamfound!=NULL) search = teamfound;

	  }


          if (search == NULL)
          {
             ladder->last->prev = ladder_entry;
             ladder_entry->next = ladder->last;
             ladder->last       = ladder_entry;
          }
          else
          {
             ladder_entry->prev = search;
             ladder_entry->next = search->next;
             if (search == ladder->first)
             // enter at beginning of list
             {
                search->next  = ladder_entry;
                ladder->first = ladder_entry;
             }
             else
             {
                search->next->prev = ladder_entry;
                search->next       = ladder_entry;
             }
           }
        }
      }
       ladder->dirty = 1;
       return 0;
}

extern int war3_ladder_update(t_ladder *ladder, int uid, int xp, int level, t_account *account, unsigned int teamcount)
{
   t_ladder_internal *search, *newpos;
   search = ladder->first;
   while (search && ((search->uid != uid) || (search->teamcount!=teamcount))) { search = search->prev; }
   if (search != NULL)
   {
     search->xp += xp;
     search->level = level;
     ladder->dirty = 1;

     // make sure, we don't get negative XP
     if (search->xp < 0) search->xp = 0;

     if (xp>0)
     // XP gained.... maybe getting better ranking
     {
        newpos = search->next;
	while ((newpos != NULL) && (newpos->level < level))
	{
	  newpos = newpos->next;
	}
        while ((newpos != NULL) && (newpos->level == level) && (newpos->xp < search->xp))
        {
          newpos = newpos->next;
        }
        if (newpos != search->next)
        // so we really have to change ranking now
        {
          // first close gap, where we've been...
          search->next->prev = search->prev;
          if (search->prev != NULL) 
            search->prev->next = search->next;
          else
            ladder->last = search->next;
          // and then move to new position
          search->next = newpos;
          if (newpos == NULL)
          {
             search->prev = ladder->first;
             ladder->first->next = search;
             ladder->first       = search;
          }
          else
          {
            search->prev = newpos->prev;
            newpos->prev->next = search;
            newpos->prev = search;
          }
        }
     }
     if (xp<0)
     // XP lost.... maybe ranking gets worse
     {
        newpos = search->prev;
	while ((newpos != NULL) && (newpos->level > level))
	{
	  newpos = newpos->prev;
	}
        while ((newpos != NULL) && (newpos->level == level) && (newpos->xp > search->xp))
        {
          newpos = newpos->prev;
        }
        if (newpos != search->prev)
        // so we really have to change ranking now
        {
          // first close gap, where we've been...
          search->prev->next = search->next;
          if (search->next != NULL) 
            search->next->prev = search->prev;
          else
            ladder->first = search->prev;
          // and then move to new position
          search->prev = newpos;
          if (newpos == NULL)
          {
             search->next = ladder->last;
             ladder->last->prev = search;
             ladder->last       = search;
          }
          else
          {
            search->next = newpos->next;
            newpos->next->prev = search;
            newpos->next = search;
          }
        }
     }
     return 0;
   }
   else
   return -1;
 }

 extern int ladder_get_rank(t_ladder *ladder, int uid, unsigned int teamcount, t_clienttag clienttag)
 {
   int ranking = 1;
   t_ladder_internal *search;
   search = ladder->first;
   while ((search!=NULL) && ((search->uid != uid) || (search->teamcount!=teamcount))) 
   { 
     search = search->prev; 
     ranking++;
     if (ladder==at_ladder(clienttag))
     {
       // if in the same team as previous account
       if ((search) && (search->next) 
           && in_same_team(search->account,search->next->account,teamcount,search->next->teamcount,clienttag))
	       ranking--;
     }
   }
   if (search != NULL)
   {
     return ranking;
   }
   else
   {
     return 0;
   }
 }

t_ladder_internal * ladder_get_rank_internal(t_ladder * ladder,int rank, t_clienttag clienttag)
{
  int ranking;
  t_ladder_internal *search;

  // this should be a huge speedup when getting many subsequent entries from ladder
  // like used in saving of binary ladders
  if ((last_ladder == ladder) && (last_rank < rank) && (last_internal != NULL))
    {
      ranking = last_rank;
      search = last_internal;
    }
  else
    {
      ranking = 1;
      search = ladder->first;
    }

  while ((search!=NULL) && (ranking<rank)) 
  { 
     search = search->prev; 
     ranking++;
     if (ladder == at_ladder(clienttag))
     {
       if ((search) && (search->next)
	  && in_same_team(search->account,search->next->account,search->teamcount,search->next->teamcount,clienttag))
	      ranking--;
     }
  }
  last_ladder   = ladder;
  last_internal = search;
  last_rank     = rank;
  return search;
}

extern t_account * ladder_get_account(t_ladder *ladder, int rank, unsigned int * teamcount,t_clienttag clienttag)
{
  t_ladder_internal *search;

  if (!(ladder))
  {
    // eventlog(eventlog_level_error,__FUNCTION__,"got request for non-existant ladder");
    return NULL;
  }

  search = ladder_get_rank_internal(ladder,rank,clienttag);

  if (search) 
  {
    *teamcount = search->teamcount;
    return search->account;
  }
  else
  {
    *teamcount = 0;
    return NULL;
  }
}

typedef int (* t_set_fct)(t_account *account,t_clienttag cltag, t_ladder_id ldr_id,unsigned int rank);
typedef int (* t_get_fct)(t_account *account,t_clienttag cltag, t_ladder_id ldr_id);

extern int ladder_update_accounts(t_ladder *ladder, t_set_fct set_fct, t_get_fct get_fct1)
{
    t_ladder_internal *pointer, *tmp_pointer;
    t_account *account;
    t_clienttag clienttag;
    int rank = 1;
    int update = 0;
    char clienttag_str[5];

    if (ladder->dirty == 1)
    {
      if ((set_fct!=NULL) && (get_fct1!=NULL))
      {
      clienttag = ladder_get_clienttag(ladder);
      pointer = ladder->first;
      while (pointer!=NULL)
      {
         account = pointer->account;
         if (rank <= MaxRankKeptInLadder) 
         {
           if (ladder->ladder_id == ladder_id_none) //war3/w3xp AT ladder
	   {
		   // do nothing now
	   }
	   else //other ladders...
	   {
	     if ((*get_fct1)(account,clienttag,ladder->ladder_id)!=rank)
             {	
	       (*set_fct)(account,clienttag,ladder->ladder_id,rank);
	       update++;	
	     }
	   }

	   pointer=pointer->prev;
	   rank++;
	  
         }
         else
	 {
	   // leave while loop
           break;
	 }
      }
      while (pointer!=NULL)
      {
        // all accounts following now are out of the ladder range we keep track of....
	    // so set rank to 0 and remove account from ladder
        if (ladder->ladder_id == ladder_id_none) //war3/w3xp AT ladder
		{
	          if ((*get_fct1)(account,pointer->teamcount,clienttag)!=0) 
		    (*set_fct)(account,pointer->teamcount,clienttag,0);
		}
		else
		{ 
		  if ((*get_fct1)(account,clienttag,ladder->ladder_id)!=0) 
		    (*set_fct)(account,clienttag,ladder->ladder_id,0);
		}

	// remove account from ladder
	if (pointer->next!=NULL) pointer->next->prev = pointer->prev;
	if (pointer->prev!=NULL) pointer->prev->next = pointer->next;
	if (ladder->last == pointer)  ladder->last  = pointer->next;
	if (ladder->first == pointer) ladder->first = pointer->prev;
	tmp_pointer = pointer->prev;
	xfree((void *)pointer);
	pointer = tmp_pointer;
      }
      }
      binary_ladder_save(w3_ladder_to_binary_ladder_types(ladder),4,&ladder_get_from_ladder);
      if (update != 0)
        eventlog(eventlog_level_info,__FUNCTION__,"updated %u accounts for clienttag %s",update,tag_uint_to_str(clienttag_str,ladder->clienttag));
    }
    ladder->dirty = 0;
    return 0;
}

extern int ladder_update_all_accounts(void)
{
  eventlog(eventlog_level_info,__FUNCTION__,"updating ranking for all accounts");
  ladder_update_accounts(&WAR3_solo_ladder, &account_set_ladder_rank,   &account_get_ladder_rank);
  ladder_update_accounts(&WAR3_team_ladder, &account_set_ladder_rank,   &account_get_ladder_rank);
  ladder_update_accounts(&WAR3_ffa_ladder,  &account_set_ladder_rank,   &account_get_ladder_rank);
  //ladder_update_accounts(&WAR3_at_ladder,  &account_set_atteamrank, &account_get_atteamrank);
  ladder_update_accounts(&W3XP_solo_ladder, &account_set_ladder_rank,   &account_get_ladder_rank);
  ladder_update_accounts(&W3XP_team_ladder, &account_set_ladder_rank,   &account_get_ladder_rank);
  ladder_update_accounts(&W3XP_ffa_ladder,  &account_set_ladder_rank,   &account_get_ladder_rank);
  //ladder_update_accounts(&W3XP_at_ladder,  &account_set_atteamrank, &account_get_atteamrank);
  ladder_update_accounts(&STAR_current_rating,&account_set_ladder_rank, &account_get_ladder_rank);
  ladder_update_accounts(&STAR_current_wins,  NULL,                      NULL);
  ladder_update_accounts(&STAR_current_games, NULL,                      NULL);
  ladder_update_accounts(&SEXP_current_rating,&account_set_ladder_rank, &account_get_ladder_rank);
  ladder_update_accounts(&SEXP_current_wins,  NULL,                      NULL);
  ladder_update_accounts(&SEXP_current_games, NULL,                      NULL);