ladder.c

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

    }
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return 0;
    }
    
	uid = account_get_uid(account);

    switch (lsort)
    {
    case ladder_sort_highestrated:
		if (ltime == ladder_time_current)
			return ladder_get_rank(ladder_cr(clienttag,id),uid,0,clienttag);
		else
			return ladder_get_rank(ladder_ar(clienttag,id),uid,0,clienttag);
    case ladder_sort_mostwins:
		if (ltime == ladder_time_current)
			return ladder_get_rank(ladder_cw(clienttag,id),uid,0,clienttag);
		else
			return ladder_get_rank(ladder_aw(clienttag,id),uid,0,clienttag);
    case ladder_sort_mostgames:
		if (ltime == ladder_time_current)
			return ladder_get_rank(ladder_cg(clienttag,id),uid,0,clienttag);
		else
			return ladder_get_rank(ladder_ag(clienttag,id),uid,0,clienttag);
    default:
	eventlog(eventlog_level_error,__FUNCTION__,"got bad ladder sort %u",(unsigned int)lsort);
    }
    
    return 0;
}

int in_same_team(t_account * acc1, t_account * acc2, unsigned int tc1, unsigned int tc2, t_clienttag clienttag)
{
   return 0;
}

extern t_ladder * solo_ladder(t_clienttag clienttag)
{
  if (clienttag==CLIENTTAG_WARCRAFT3_UINT) 
    return &WAR3_solo_ladder;
  if (clienttag==CLIENTTAG_WAR3XP_UINT) 
    return &W3XP_solo_ladder;
  else 
    return NULL;
}

extern t_ladder * team_ladder(t_clienttag clienttag)
{
  if (clienttag==CLIENTTAG_WARCRAFT3_UINT) 
    return &WAR3_team_ladder;
  if (clienttag==CLIENTTAG_WAR3XP_UINT) 
    return &W3XP_team_ladder;
  else 
    return NULL;
}

extern t_ladder * ffa_ladder(t_clienttag clienttag)
{
  if (clienttag==CLIENTTAG_WARCRAFT3_UINT)
    return &WAR3_ffa_ladder;
  else 
    return &W3XP_ffa_ladder;
}

extern t_ladder * at_ladder(t_clienttag clienttag)
{
  if (clienttag==CLIENTTAG_WARCRAFT3_UINT) 
    return &WAR3_at_ladder;
  else 
    return &W3XP_at_ladder;
}

 extern t_ladder * ladder_ar(t_clienttag clienttag, t_ladder_id ladder_id)
 {
   if (clienttag==CLIENTTAG_STARCRAFT_UINT)
	   return &STAR_active_rating;
   else if (clienttag==CLIENTTAG_BROODWARS_UINT)
	   return &SEXP_active_rating;
   else if (clienttag==CLIENTTAG_WARCIIBNE_UINT)
   {
           if (ladder_id == ladder_id_normal)
	           return &W2BN_active_rating;
	   else
	           return &W2BN_active_rating_ironman;
   }
   else return NULL;
 }

 extern t_ladder * ladder_aw(t_clienttag clienttag, t_ladder_id ladder_id)
 {
   if (clienttag==CLIENTTAG_STARCRAFT_UINT)
	   return &STAR_active_wins;
   else if (clienttag==CLIENTTAG_BROODWARS_UINT)
	   return &SEXP_active_wins;
   else if (clienttag==CLIENTTAG_WARCIIBNE_UINT)
   {
           if (ladder_id == ladder_id_normal)
	           return &W2BN_active_wins;
	   else
	           return &W2BN_active_wins_ironman;
   }
   else return NULL;
 }

 extern t_ladder * ladder_ag(t_clienttag clienttag, t_ladder_id ladder_id)
 {
   if (clienttag==CLIENTTAG_STARCRAFT_UINT)
	   return &STAR_active_games;
   else if (clienttag==CLIENTTAG_BROODWARS_UINT)
	   return &SEXP_active_games;
   else if (clienttag==CLIENTTAG_WARCIIBNE_UINT)
   {
           if (ladder_id == ladder_id_normal)
	           return &W2BN_active_games;
	   else
	           return &W2BN_active_games_ironman;
   }
   else return NULL;
 }

 extern t_ladder * ladder_cr(t_clienttag clienttag, t_ladder_id ladder_id)
{
   if (clienttag==CLIENTTAG_STARCRAFT_UINT)
	   return &STAR_current_rating;
   else if (clienttag==CLIENTTAG_BROODWARS_UINT)
	   return &SEXP_current_rating;
   else if (clienttag==CLIENTTAG_WARCIIBNE_UINT)
   {
	   if (ladder_id == ladder_id_normal)
		   return &W2BN_current_rating;
	   else
		   return &W2BN_current_rating_ironman;
   }
   else return NULL;
 }

 extern t_ladder * ladder_cw(t_clienttag clienttag, t_ladder_id ladder_id)
{
   if (clienttag==CLIENTTAG_STARCRAFT_UINT)
	   return &STAR_current_wins;
   else if (clienttag==CLIENTTAG_BROODWARS_UINT)
	   return &SEXP_current_wins;
   else if (clienttag==CLIENTTAG_WARCIIBNE_UINT)
   {
	   if (ladder_id == ladder_id_normal)
		   return &W2BN_current_wins;
	   else
		   return &W2BN_current_wins_ironman;
   }
   else return NULL;
 }

 extern t_ladder * ladder_cg(t_clienttag clienttag, t_ladder_id ladder_id)
{
   if (clienttag==CLIENTTAG_STARCRAFT_UINT)
	   return &STAR_current_games;
   else if (clienttag==CLIENTTAG_BROODWARS_UINT)
	   return &SEXP_current_games;
   else if (clienttag==CLIENTTAG_WARCIIBNE_UINT)
   {
	   if (ladder_id == ladder_id_normal)
		   return &W2BN_current_games;
	   else
		   return &W2BN_current_games_ironman;
   }
   else return NULL;
 }

t_clienttag ladder_get_clienttag(t_ladder * ladder)
{
  return ladder->clienttag;
}

t_binary_ladder_types w3_ladder_to_binary_ladder_types(t_ladder * ladder)
{
  return ladder->type;
}

t_ladder * binary_ladder_types_to_w3_ladder(t_binary_ladder_types type)
{
  t_ladder * ladder;

  switch (type)
  {
    case WAR3_SOLO:
	ladder = &WAR3_solo_ladder;
	break;
    case WAR3_TEAM:
	ladder = &WAR3_team_ladder;
	break;
    case WAR3_FFA:
	ladder = &WAR3_ffa_ladder;
	break;
    case WAR3_AT:
	ladder = &WAR3_at_ladder;
	break;
    case W3XP_SOLO:
	ladder = &W3XP_solo_ladder;
	break;
    case W3XP_TEAM:
	ladder = &W3XP_team_ladder;
	break;
    case W3XP_FFA:
	ladder = &W3XP_ffa_ladder;
	break;
    case W3XP_AT:
	ladder = &W3XP_at_ladder;
	break;
	case STAR_AR  : 
	ladder = &STAR_active_rating;
	break;
	case STAR_AW  : 
	ladder = &STAR_active_wins;
	break;
	case STAR_AG  : 
	ladder = &STAR_active_games;
	break;
	case STAR_CR  : 
	ladder = &STAR_current_rating;
	break;
	case STAR_CW  : 
	ladder = &STAR_current_wins;
	break;
	case STAR_CG  : 
	ladder = &STAR_current_games;
	break;
	case SEXP_AR  : 
	ladder = &SEXP_active_rating;
	break;
	case SEXP_AW  : 
	ladder = &SEXP_active_wins;
	break;
	case SEXP_AG  : 
	ladder = &SEXP_active_games;
	break;
	case SEXP_CR  : 
	ladder = &SEXP_current_rating;
	break;
	case SEXP_CW  : 
	ladder = &SEXP_current_wins;
	break;
	case SEXP_CG  : 
	ladder = &SEXP_current_games;
	break;
	case W2BN_AR  : 
	ladder = &W2BN_active_rating;
	break;
	case W2BN_AW  : 
	ladder = &W2BN_active_wins;
	break;
	case W2BN_AG  : 
	ladder = &W2BN_active_games;
	break;
	case W2BN_CR  : 
	ladder = &W2BN_current_rating;
	break;
	case W2BN_CW  : 
	ladder = &W2BN_current_wins;
	break;
	case W2BN_CG  : 
	ladder = &W2BN_current_games;
	break;
	case W2BN_ARI : 
	ladder = &W2BN_active_rating_ironman;
	break;
	case W2BN_AWI : 
	ladder = &W2BN_active_wins_ironman;
	break;
	case W2BN_AGI : 
	ladder = &W2BN_active_games_ironman;
	break;
	case W2BN_CRI : 
	ladder = &W2BN_current_rating_ironman;
	break;
	case W2BN_CWI : 
	ladder = &W2BN_current_wins_ironman;
	break;
	case W2BN_CGI : 
	ladder = &W2BN_current_games_ironman;
	break;

    default:
	eventlog(eventlog_level_error,__FUNCTION__,"got invalid ladder type %d",type);
	return NULL;
  }
  return ladder;
}

void ladder_init(t_ladder *ladder,t_binary_ladder_types type, t_clienttag clienttag, t_ladder_id ladder_id)
{
    ladder->first = NULL;
    ladder->last  = NULL;
    ladder->dirty = 1;
    ladder->type = type;
    ladder->clienttag = clienttag;
    ladder->ladder_id = ladder_id;
}

void ladder_destroy(t_ladder *ladder)
{
  t_ladder_internal *pointer;

  while (ladder->first!=NULL)
  {
    pointer = ladder->first;
    ladder->first = pointer->prev;
    xfree((void *)pointer);
  }
}

extern int war3_ladder_add(t_ladder *ladder, int uid, int xp, int level, t_account *account, unsigned int teamcount,t_clienttag clienttag)
{
   t_ladder_internal *ladder_entry;
   ladder_entry = xmalloc(sizeof(t_ladder_internal));

   ladder_entry->uid       = uid;
   ladder_entry->xp        = xp;
   ladder_entry->level     = level;
   ladder_entry->account   = account;
   ladder_entry->teamcount = teamcount;
   ladder_entry->prev      = NULL;
   ladder_entry->next      = NULL;

   if (ladder->first == NULL)
   { // ladder empty, so just insert element
      ladder->first = ladder_entry;
      ladder->last  = ladder_entry;
   }
   else
   { // already elements in list
     // determine if first or last user in ladder has XP
     // closest to current, cause should be the shorter way to insert
     // new user
        if ((ladder->first->xp - xp) >= (xp - ladder->last->xp))
        // we should enter from last to first
        {
          t_ladder_internal *search;
          search = ladder->last;
          while ((search != NULL) && (search->level < level))
          {
            search = search->next;
          }
          while ((search != NULL) && (search->level == level) && (search->xp < xp))
	  {
            search = search->next;
	  }

          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) && (teamsearch->level == level))
	     {
	         if (in_same_team(account,teamsearch->account,teamcount,teamsearch->teamcount,clienttag))
	    	 {
		    teamfound = teamsearch;
		    break;
		 }
		 teamsearch = teamsearch->next;
	     }