qcsrc/menu/xonotic/serverlist.qc

   1 #ifndef SERVERLIST_H
   2 #define SERVERLIST_H
   3 #include "listbox.qc"
   4 CLASS(XonoticServerList, XonoticListBox)
   5         METHOD(XonoticServerList, configureXonoticServerList, void(entity))
   6         ATTRIB(XonoticServerList, rowsPerItem, float, 1)
   7         METHOD(XonoticServerList, draw, void(entity))
   8         METHOD(XonoticServerList, drawListBoxItem, void(entity, int, vector, bool, bool))
   9         METHOD(XonoticServerList, doubleClickListBoxItem, void(entity, float, vector))
  10         METHOD(XonoticServerList, resizeNotify, void(entity, vector, vector, vector, vector))
  11         METHOD(XonoticServerList, keyDown, float(entity, float, float, float))
  12         METHOD(XonoticServerList, toggleFavorite, void(entity, string))
  13
  14         ATTRIB(XonoticServerList, iconsSizeFactor, float, 0.85)
  15
  16         ATTRIB(XonoticServerList, realFontSize, vector, '0 0 0')
  17         ATTRIB(XonoticServerList, realUpperMargin, float, 0)
  18         ATTRIB(XonoticServerList, columnIconsOrigin, float, 0)
  19         ATTRIB(XonoticServerList, columnIconsSize, float, 0)
  20         ATTRIB(XonoticServerList, columnPingOrigin, float, 0)
  21         ATTRIB(XonoticServerList, columnPingSize, float, 0)
  22         ATTRIB(XonoticServerList, columnNameOrigin, float, 0)
  23         ATTRIB(XonoticServerList, columnNameSize, float, 0)
  24         ATTRIB(XonoticServerList, columnMapOrigin, float, 0)
  25         ATTRIB(XonoticServerList, columnMapSize, float, 0)
  26         ATTRIB(XonoticServerList, columnTypeOrigin, float, 0)
  27         ATTRIB(XonoticServerList, columnTypeSize, float, 0)
  28         ATTRIB(XonoticServerList, columnPlayersOrigin, float, 0)
  29         ATTRIB(XonoticServerList, columnPlayersSize, float, 0)
  30
  31         ATTRIB(XonoticServerList, selectedServer, string, string_null) // to restore selected server when needed
  32         METHOD(XonoticServerList, setSelected, void(entity, float))
  33         METHOD(XonoticServerList, setSortOrder, void(entity, float, float))
  34         ATTRIB(XonoticServerList, filterShowEmpty, float, 1)
  35         ATTRIB(XonoticServerList, filterShowFull, float, 1)
  36         ATTRIB(XonoticServerList, filterString, string, string_null)
  37         ATTRIB(XonoticServerList, controlledTextbox, entity, NULL)
  38         ATTRIB(XonoticServerList, ipAddressBox, entity, NULL)
  39         ATTRIB(XonoticServerList, favoriteButton, entity, NULL)
  40         ATTRIB(XonoticServerList, nextRefreshTime, float, 0)
  41         METHOD(XonoticServerList, refreshServerList, void(entity, float)) // refresh mode: REFRESHSERVERLIST_*
  42         ATTRIB(XonoticServerList, needsRefresh, float, 1)
  43         METHOD(XonoticServerList, focusEnter, void(entity))
  44         METHOD(XonoticServerList, positionSortButton, void(entity, entity, float, float, string, void(entity, entity)))
  45         ATTRIB(XonoticServerList, sortButton1, entity, NULL)
  46         ATTRIB(XonoticServerList, sortButton2, entity, NULL)
  47         ATTRIB(XonoticServerList, sortButton3, entity, NULL)
  48         ATTRIB(XonoticServerList, sortButton4, entity, NULL)
  49         ATTRIB(XonoticServerList, sortButton5, entity, NULL)
  50         ATTRIB(XonoticServerList, connectButton, entity, NULL)
  51         ATTRIB(XonoticServerList, infoButton, entity, NULL)
  52         ATTRIB(XonoticServerList, currentSortOrder, float, 0)
  53         ATTRIB(XonoticServerList, currentSortField, float, -1)
  54
  55         ATTRIB(XonoticServerList, ipAddressBoxFocused, float, -1)
  56
  57         ATTRIB(XonoticServerList, seenIPv4, float, 0)
  58         ATTRIB(XonoticServerList, seenIPv6, float, 0)
  59         ATTRIB(XonoticServerList, categoriesHeight, float, 1.25)
  60
  61         METHOD(XonoticServerList, getTotalHeight, float(entity))
  62         METHOD(XonoticServerList, getItemAtPos, float(entity, float))
  63         METHOD(XonoticServerList, getItemStart, float(entity, float))
  64         METHOD(XonoticServerList, getItemHeight, float(entity, float))
  65 ENDCLASS(XonoticServerList)
  66 entity makeXonoticServerList();
  67
  68 #ifndef IMPLEMENTATION
  69 float autocvar_menu_slist_categories;
  70 float autocvar_menu_slist_categories_onlyifmultiple;
  71 float autocvar_menu_slist_purethreshold;
  72 float autocvar_menu_slist_modimpurity;
  73 float autocvar_menu_slist_recommendations;
  74 float autocvar_menu_slist_recommendations_maxping;
  75 float autocvar_menu_slist_recommendations_minfreeslots;
  76 float autocvar_menu_slist_recommendations_minhumans;
  77 float autocvar_menu_slist_recommendations_purethreshold;
  78
  79 // server cache fields
  80 #define SLIST_FIELDS \
  81         SLIST_FIELD(CNAME,       "cname") \
  82         SLIST_FIELD(PING,        "ping") \
  83         SLIST_FIELD(GAME,        "game") \
  84         SLIST_FIELD(MOD,         "mod") \
  85         SLIST_FIELD(MAP,         "map") \
  86         SLIST_FIELD(NAME,        "name") \
  87         SLIST_FIELD(MAXPLAYERS,  "maxplayers") \
  88         SLIST_FIELD(NUMPLAYERS,  "numplayers") \
  89         SLIST_FIELD(NUMHUMANS,   "numhumans") \
  90         SLIST_FIELD(NUMBOTS,     "numbots") \
  91         SLIST_FIELD(PROTOCOL,    "protocol") \
  92         SLIST_FIELD(FREESLOTS,   "freeslots") \
  93         SLIST_FIELD(PLAYERS,     "players") \
  94         SLIST_FIELD(QCSTATUS,    "qcstatus") \
  95         SLIST_FIELD(CATEGORY,    "category") \
  96         SLIST_FIELD(ISFAVORITE,  "isfavorite")
  97
  98 #define SLIST_FIELD(suffix,name) float SLIST_FIELD_##suffix;
  99 SLIST_FIELDS
 100 #undef SLIST_FIELD
 101
 102 const float REFRESHSERVERLIST_RESORT = 0;    // sort the server list again to update for changes to e.g. favorite status, categories
 103 const float REFRESHSERVERLIST_REFILTER = 1;  // ..., also update filter and sort criteria
 104 const float REFRESHSERVERLIST_ASK = 2;       // ..., also suggest querying servers now
 105 const float REFRESHSERVERLIST_RESET = 3;     // ..., also clear the list first
 106
 107 // function declarations
 108 float IsServerInList(string list, string srv);
 109 #define IsFavorite(srv) IsServerInList(cvar_string("net_slist_favorites"), srv)
 110 #define IsPromoted(srv) IsServerInList(_Nex_ExtResponseSystem_PromotedServers, srv)
 111 #define IsRecommended(srv) IsServerInList(_Nex_ExtResponseSystem_RecommendedServers, srv)
 112
 113 entity RetrieveCategoryEnt(float catnum);
 114
 115 float CheckCategoryOverride(float cat);
 116 float CheckCategoryForEntry(float entry);
 117 float m_gethostcachecategory(float entry) { return CheckCategoryOverride(CheckCategoryForEntry(entry)); }
 118
 119 void RegisterSLCategories();
 120
 121 void ServerList_Connect_Click(entity btn, entity me);
 122 void ServerList_Categories_Click(entity box, entity me);
 123 void ServerList_ShowEmpty_Click(entity box, entity me);
 124 void ServerList_ShowFull_Click(entity box, entity me);
 125 void ServerList_Filter_Change(entity box, entity me);
 126 void ServerList_Favorite_Click(entity btn, entity me);
 127 void ServerList_Info_Click(entity btn, entity me);
 128 void ServerList_Update_favoriteButton(entity btn, entity me);
 129
 130 // fields for category entities
 131 const int MAX_CATEGORIES = 9;
 132 const int CATEGORY_FIRST = 1;
 133 entity categories[MAX_CATEGORIES];
 134 int category_ent_count;
 135 .string cat_name;
 136 .string cat_string;
 137 .string cat_enoverride_string;
 138 .string cat_dioverride_string;
 139 .float cat_enoverride;
 140 .float cat_dioverride;
 141
 142 // fields for drawing categories
 143 int category_name[MAX_CATEGORIES];
 144 int category_item[MAX_CATEGORIES];
 145 int category_draw_count;
 146
 147 #define SLIST_CATEGORIES \
 148         SLIST_CATEGORY(CAT_FAVORITED,    "",            "",             ZCTX(_("SLCAT^Favorites"))) \
 149         SLIST_CATEGORY(CAT_RECOMMENDED,  "",            "",             ZCTX(_("SLCAT^Recommended"))) \
 150         SLIST_CATEGORY(CAT_NORMAL,       "",            "CAT_SERVERS",  ZCTX(_("SLCAT^Normal Servers"))) \
 151         SLIST_CATEGORY(CAT_SERVERS,      "CAT_NORMAL",  "CAT_SERVERS",  ZCTX(_("SLCAT^Servers"))) \
 152         SLIST_CATEGORY(CAT_XPM,          "CAT_NORMAL",  "CAT_SERVERS",  ZCTX(_("SLCAT^Competitive Mode"))) \
 153         SLIST_CATEGORY(CAT_MODIFIED,     "",            "CAT_SERVERS",  ZCTX(_("SLCAT^Modified Servers"))) \
 154         SLIST_CATEGORY(CAT_OVERKILL,     "",            "CAT_SERVERS",  ZCTX(_("SLCAT^Overkill Mode"))) \
 155         SLIST_CATEGORY(CAT_INSTAGIB,     "",            "CAT_SERVERS",  ZCTX(_("SLCAT^InstaGib Mode"))) \
 156         SLIST_CATEGORY(CAT_DEFRAG,       "",            "CAT_SERVERS",  ZCTX(_("SLCAT^Defrag Mode")))
 157
 158 #define SLIST_CATEGORY_AUTOCVAR(name) autocvar_menu_slist_categories_##name##_override
 159 #define SLIST_CATEGORY(name,enoverride,dioverride,str) \
 160         int name; \
 161         string SLIST_CATEGORY_AUTOCVAR(name) = enoverride;
 162 SLIST_CATEGORIES
 163 #undef SLIST_CATEGORY
 164
 165 #endif
 166 #endif
 167 #ifdef IMPLEMENTATION
 168
 169 void RegisterSLCategories()
 170 {
 171         entity cat;
 172         #define SLIST_CATEGORY(name,enoverride,dioverride,str) \
 173                 SET_FIELD_COUNT(name, CATEGORY_FIRST, category_ent_count) \
 174                 CHECK_MAX_COUNT(name, MAX_CATEGORIES, category_ent_count, "SLIST_CATEGORY") \
 175                 cat = spawn(); \
 176                 categories[name - 1] = cat; \
 177                 cat.classname = "slist_category"; \
 178                 cat.cat_name = strzone(#name); \
 179                 cat.cat_enoverride_string = strzone(SLIST_CATEGORY_AUTOCVAR(name)); \
 180                 cat.cat_dioverride_string = strzone(dioverride); \
 181                 cat.cat_string = strzone(str);
 182         SLIST_CATEGORIES
 183         #undef SLIST_CATEGORY
 184
 185         int i, x, catnum;
 186         string s;
 187
 188         #define PROCESS_OVERRIDE(override_string,override_field) \
 189                 for(i = 0; i < category_ent_count; ++i) \
 190                 { \
 191                         s = categories[i].override_string; \
 192                         if((s != "") && (s != categories[i].cat_name)) \
 193                         { \
 194                                 catnum = 0; \
 195                                 for(x = 0; x < category_ent_count; ++x) \
 196                                 { if(categories[x].cat_name == s) { \
 197                                         catnum = (x+1); \
 198                                         break; \
 199                                 } } \
 200                                 if(catnum) \
 201                                 { \
 202                                         strunzone(categories[i].override_string); \
 203                                         categories[i].override_field = catnum; \
 204                                         continue; \
 205                                 } \
 206                                 else \
 207                                 { \
 208                                         printf( \
 209                                                 "RegisterSLCategories(): Improper override '%s' for category '%s'!\n", \
 210                                                 s, \
 211                                                 categories[i].cat_name \
 212                                         ); \
 213                                 } \
 214                         } \
 215                         strunzone(categories[i].override_string); \
 216                         categories[i].override_field = 0; \
 217                 }
 218         PROCESS_OVERRIDE(cat_enoverride_string, cat_enoverride)
 219         PROCESS_OVERRIDE(cat_dioverride_string, cat_dioverride)
 220         #undef PROCESS_OVERRIDE
 221 }
 222
 223 // Supporting Functions
 224 entity RetrieveCategoryEnt(int catnum)
 225 {
 226         if((catnum > 0) && (catnum <= category_ent_count))
 227         {
 228                 return categories[catnum - 1];
 229         }
 230         else
 231         {
 232                 error(sprintf("RetrieveCategoryEnt(%d): Improper category number!\n", catnum));
 233                 return world;
 234         }
 235 }
 236
 237 bool IsServerInList(string list, string srv)
 238 {
 239         string p;
 240         int i, n;
 241         if(srv == "")
 242                 return false;
 243         srv = netaddress_resolve(srv, 26000);
 244         if(srv == "")
 245                 return false;
 246         p = crypto_getidfp(srv);
 247         n = tokenize_console(list);
 248         for(i = 0; i < n; ++i)
 249         {
 250                 if(substring(argv(i), 0, 1) != "[" && strlen(argv(i)) == 44 && strstrofs(argv(i), ".", 0) < 0)
 251                 {
 252                         if(p)
 253                                 if(argv(i) == p)
 254                                         return true;
 255                 }
 256                 else
 257                 {
 258                         if(srv == netaddress_resolve(argv(i), 26000))
 259                                 return true;
 260                 }
 261         }
 262         return false;
 263 }
 264
 265 int CheckCategoryOverride(int cat)
 266 {
 267         entity catent = RetrieveCategoryEnt(cat);
 268         if(catent)
 269         {
 270                 int override = (autocvar_menu_slist_categories ? catent.cat_enoverride : catent.cat_dioverride);
 271                 if(override) { return override; }
 272                 else { return cat; }
 273         }
 274         else
 275         {
 276                 error(sprintf("CheckCategoryOverride(%d): Improper category number!\n", cat));
 277                 return cat;
 278         }
 279 }
 280
 281 int CheckCategoryForEntry(int entry)
 282 {
 283         string s, k, v, modtype = "";
 284         int j, m, impure = 0, freeslots = 0, sflags = 0;
 285         s = gethostcachestring(SLIST_FIELD_QCSTATUS, entry);
 286         m = tokenizebyseparator(s, ":");
 287
 288         for(j = 2; j < m; ++j)
 289         {
 290                 if(argv(j) == "") { break; }
 291                 k = substring(argv(j), 0, 1);
 292                 v = substring(argv(j), 1, -1);
 293                 switch(k)
 294                 {
 295                         case "P": { impure = stof(v); break; }
 296                         case "S": { freeslots = stof(v); break; }
 297                         case "F": { sflags = stof(v); break; }
 298                         case "M": { modtype = strtolower(v); break; }
 299                 }
 300         }
 301
 302         if(modtype != "xonotic") { impure += autocvar_menu_slist_modimpurity; }
 303
 304         // check if this server is favorited
 305         if(gethostcachenumber(SLIST_FIELD_ISFAVORITE, entry)) { return CAT_FAVORITED; }
 306
 307         // now check if it's recommended
 308         if(autocvar_menu_slist_recommendations)
 309         {
 310                 string cname = gethostcachestring(SLIST_FIELD_CNAME, entry);
 311
 312                 if(IsPromoted(cname)) { return CAT_RECOMMENDED; }
 313                 else
 314                 {
 315                         float recommended = 0;
 316                         if(autocvar_menu_slist_recommendations & 1)
 317                         {
 318                                 if(IsRecommended(cname)) { ++recommended; }
 319                                 else { --recommended; }
 320                         }
 321                         if(autocvar_menu_slist_recommendations & 2)
 322                         {
 323                                 if(
 324                                         ///// check for minimum free slots
 325                                         (freeslots >= autocvar_menu_slist_recommendations_minfreeslots)
 326
 327                                         && // check for purity requirement
 328                                         (
 329                                                 (autocvar_menu_slist_recommendations_purethreshold < 0)
 330                                                 ||
 331                                                 (impure <= autocvar_menu_slist_recommendations_purethreshold)
 332                                         )
 333
 334                                         && // check for minimum amount of humans
 335                                         (
 336                                                 gethostcachenumber(SLIST_FIELD_NUMHUMANS, entry)
 337                                                 >=
 338                                                 autocvar_menu_slist_recommendations_minhumans
 339                                         )
 340
 341                                         && // check for maximum latency
 342                                         (
 343                                                 gethostcachenumber(SLIST_FIELD_PING, entry)
 344                                                 <=
 345                                                 autocvar_menu_slist_recommendations_maxping
 346                                         )
 347                                 )
 348                                         { ++recommended; }
 349                                 else
 350                                         { --recommended; }
 351                         }
 352                         if(recommended > 0) { return CAT_RECOMMENDED; }
 353                 }
 354         }
 355
 356         // if not favorited or recommended, check modname
 357         if(modtype != "xonotic")
 358         {
 359                 switch(modtype)
 360                 {
 361                         // old servers which don't report their mod name are considered modified now
 362                         case "": { return CAT_MODIFIED; }
 363
 364                         case "xpm": { return CAT_XPM; }
 365                         case "minstagib":
 366                         case "instagib": { return CAT_INSTAGIB; }
 367                         case "overkill": { return CAT_OVERKILL; }
 368                         //case "nix": { return CAT_NIX; }
 369                         //case "newtoys": { return CAT_NEWTOYS; }
 370
 371                         // "cts" is allowed as compat, xdf is replacement
 372                         case "cts":
 373                         case "xdf": { return CAT_DEFRAG; }
 374
 375                         default: { dprintf("Found strange mod type: %s\n", modtype); return CAT_MODIFIED; }
 376                 }
 377         }
 378
 379         // must be normal or impure server
 380         return ((impure > autocvar_menu_slist_purethreshold) ? CAT_MODIFIED : CAT_NORMAL);
 381 }
 382
 383 void XonoticServerList_toggleFavorite(entity me, string srv)
 384 {
 385         string s, s0, s1, s2, srv_resolved, p;
 386         int i, n;
 387         bool f = false;
 388         srv_resolved = netaddress_resolve(srv, 26000);
 389         p = crypto_getidfp(srv_resolved);
 390         s = cvar_string("net_slist_favorites");
 391         n = tokenize_console(s);
 392         for(i = 0; i < n; ++i)
 393         {
 394                 if(substring(argv(i), 0, 1) != "[" && strlen(argv(i)) == 44 && strstrofs(argv(i), ".", 0) < 0)
 395                 {
 396                         if(p)
 397                                 if(argv(i) != p)
 398                                         continue;
 399                 }
 400                 else
 401                 {
 402                         if(srv_resolved != netaddress_resolve(argv(i), 26000))
 403                                 continue;
 404                 }
 405                 s0 = s1 = s2 = "";
 406                 if(i > 0)
 407                         s0 = substring(s, 0, argv_end_index(i - 1));
 408                 if(i < n-1)
 409                         s2 = substring(s, argv_start_index(i + 1), -1);
 410                 if(s0 != "" && s2 != "")
 411                         s1 = " ";
 412                 cvar_set("net_slist_favorites", strcat(s0, s1, s2));
 413                 s = cvar_string("net_slist_favorites");
 414                 n = tokenize_console(s);
 415                 f = true;
 416                 --i;
 417         }
 418
 419         if(!f)
 420         {
 421                 s1 = "";
 422                 if(s != "")
 423                         s1 = " ";
 424                 if(p)
 425                         cvar_set("net_slist_favorites", strcat(s, s1, p));
 426                 else
 427                         cvar_set("net_slist_favorites", strcat(s, s1, srv));
 428         }
 429
 430         me.refreshServerList(me, REFRESHSERVERLIST_RESORT);
 431 }
 432
 433 void ServerList_Update_favoriteButton(entity btn, entity me)
 434 {
 435         me.favoriteButton.setText(me.favoriteButton,
 436                 (IsFavorite(me.ipAddressBox.text) ?
 437                         _("Remove") : _("Favorite")
 438                 )
 439         );
 440 }
 441
 442 entity makeXonoticServerList()
 443 {
 444         entity me;
 445         me = NEW(XonoticServerList);
 446         me.configureXonoticServerList(me);
 447         return me;
 448 }
 449 void XonoticServerList_configureXonoticServerList(entity me)
 450 {
 451         me.configureXonoticListBox(me);
 452
 453         // update field ID's
 454         #define SLIST_FIELD(suffix,name) SLIST_FIELD_##suffix = gethostcacheindexforkey(name);
 455         SLIST_FIELDS
 456         #undef SLIST_FIELD
 457
 458         // clear list
 459         me.nItems = 0;
 460 }
 461 void XonoticServerList_setSelected(entity me, int i)
 462 {
 463         //int save = me.selectedItem;
 464         SUPER(XonoticServerList).setSelected(me, i);
 465         /*
 466         if(me.selectedItem == save)
 467                 return;
 468         */
 469         if(me.nItems == 0)
 470                 return;
 471         if(gethostcachevalue(SLIST_HOSTCACHEVIEWCOUNT) != me.nItems)
 472                 return; // sorry, it would be wrong
 473
 474         if(me.selectedServer)
 475                 strunzone(me.selectedServer);
 476         me.selectedServer = strzone(gethostcachestring(SLIST_FIELD_CNAME, me.selectedItem));
 477
 478         me.ipAddressBox.setText(me.ipAddressBox, me.selectedServer);
 479         me.ipAddressBox.cursorPos = strlen(me.selectedServer);
 480         me.ipAddressBoxFocused = -1;
 481 }
 482 void XonoticServerList_refreshServerList(entity me, int mode)
 483 {
 484         //print("refresh of type ", ftos(mode), "\n");
 485
 486         if(mode >= REFRESHSERVERLIST_REFILTER)
 487         {
 488                 float m;
 489                 int i, n;
 490                 int listflags = 0;
 491                 string s, typestr, modstr;
 492
 493                 s = me.filterString;
 494
 495                 m = strstrofs(s, ":", 0);
 496                 if(m >= 0)
 497                 {
 498                         typestr = substring(s, 0, m);
 499                         s = substring(s, m + 1, strlen(s) - m - 1);
 500                         while(substring(s, 0, 1) == " ")
 501                                 s = substring(s, 1, strlen(s) - 1);
 502                 }
 503                 else
 504                         typestr = "";
 505
 506                 modstr = cvar_string("menu_slist_modfilter");
 507
 508                 m = SLIST_MASK_AND - 1;
 509                 resethostcachemasks();
 510
 511                 // ping: reject negative ping (no idea why this happens in the first place, engine bug)
 512                 sethostcachemasknumber(++m, SLIST_FIELD_PING, 0, SLIST_TEST_GREATEREQUAL);
 513
 514                 // show full button
 515                 if(!me.filterShowFull)
 516                 {
 517                         sethostcachemasknumber(++m, SLIST_FIELD_FREESLOTS, 1, SLIST_TEST_GREATEREQUAL); // legacy
 518                         sethostcachemaskstring(++m, SLIST_FIELD_QCSTATUS, ":S0:", SLIST_TEST_NOTCONTAIN); // g_maxplayers support
 519                 }
 520
 521                 // show empty button
 522                 if(!me.filterShowEmpty)
 523                         sethostcachemasknumber(++m, SLIST_FIELD_NUMHUMANS, 1, SLIST_TEST_GREATEREQUAL);
 524
 525                 // gametype filtering
 526                 if(typestr != "")
 527                         sethostcachemaskstring(++m, SLIST_FIELD_QCSTATUS, strcat(typestr, ":"), SLIST_TEST_STARTSWITH);
 528
 529                 // mod filtering
 530                 if(modstr != "")
 531                 {
 532                         if(substring(modstr, 0, 1) == "!")
 533                                 sethostcachemaskstring(++m, SLIST_FIELD_MOD, resolvemod(substring(modstr, 1, strlen(modstr) - 1)), SLIST_TEST_NOTEQUAL);
 534                         else
 535                                 sethostcachemaskstring(++m, SLIST_FIELD_MOD, resolvemod(modstr), SLIST_TEST_EQUAL);
 536                 }
 537
 538                 // server banning
 539                 n = tokenizebyseparator(_Nex_ExtResponseSystem_BannedServers, " ");
 540                 for(i = 0; i < n; ++i)
 541                         if(argv(i) != "")
 542                                 sethostcachemaskstring(++m, SLIST_FIELD_CNAME, argv(i), SLIST_TEST_NOTSTARTSWITH);
 543
 544                 m = SLIST_MASK_OR - 1;
 545                 if(s != "")
 546                 {
 547                         sethostcachemaskstring(++m, SLIST_FIELD_NAME, s, SLIST_TEST_CONTAINS);
 548                         sethostcachemaskstring(++m, SLIST_FIELD_MAP, s, SLIST_TEST_CONTAINS);
 549                         sethostcachemaskstring(++m, SLIST_FIELD_PLAYERS, s, SLIST_TEST_CONTAINS);
 550                         sethostcachemaskstring(++m, SLIST_FIELD_QCSTATUS, strcat(s, ":"), SLIST_TEST_STARTSWITH);
 551                 }
 552
 553                 // sorting flags
 554                 //listflags |= SLSF_FAVORITES;
 555                 listflags |= SLSF_CATEGORIES;
 556                 if(me.currentSortOrder < 0) { listflags |= SLSF_DESCENDING; }
 557                 sethostcachesort(me.currentSortField, listflags);
 558         }
 559
 560         resorthostcache();
 561         if(mode >= REFRESHSERVERLIST_ASK)
 562                 refreshhostcache(mode >= REFRESHSERVERLIST_RESET);
 563 }
 564 void XonoticServerList_focusEnter(entity me)
 565 {
 566         SUPER(XonoticServerList).focusEnter(me);
 567         if(time < me.nextRefreshTime)
 568         {
 569                 //print("sorry, no refresh yet\n");
 570                 return;
 571         }
 572         me.nextRefreshTime = time + 10;
 573         me.refreshServerList(me, REFRESHSERVERLIST_ASK);
 574 }
 575
 576 void XonoticServerList_draw(entity me)
 577 {
 578         int i;
 579         bool found = false, owned;
 580
 581         if(_Nex_ExtResponseSystem_BannedServersNeedsRefresh)
 582         {
 583                 if(!me.needsRefresh)
 584                         me.needsRefresh = 2;
 585                 _Nex_ExtResponseSystem_BannedServersNeedsRefresh = 0;
 586         }
 587
 588         if(_Nex_ExtResponseSystem_PromotedServersNeedsRefresh)
 589         {
 590                 if(!me.needsRefresh)
 591                         me.needsRefresh = 3;
 592                 _Nex_ExtResponseSystem_PromotedServersNeedsRefresh = 0;
 593         }
 594
 595         if(_Nex_ExtResponseSystem_RecommendedServersNeedsRefresh)
 596         {
 597                 if(!me.needsRefresh)
 598                         me.needsRefresh = 3;
 599                 _Nex_ExtResponseSystem_RecommendedServersNeedsRefresh = 0;
 600         }
 601
 602         if(me.currentSortField == -1)
 603         {
 604                 me.setSortOrder(me, SLIST_FIELD_PING, +1);
 605                 me.refreshServerList(me, REFRESHSERVERLIST_RESET);
 606         }
 607         else if(me.needsRefresh == 1)
 608         {
 609                 me.needsRefresh = 2; // delay by one frame to make sure "slist" has been executed
 610         }
 611         else if(me.needsRefresh == 2)
 612         {
 613                 me.needsRefresh = 0;
 614                 me.refreshServerList(me, REFRESHSERVERLIST_REFILTER);
 615         }
 616         else if(me.needsRefresh == 3)
 617         {
 618                 me.needsRefresh = 0;
 619                 me.refreshServerList(me, REFRESHSERVERLIST_RESORT);
 620         }
 621
 622         owned = ((me.selectedServer == me.ipAddressBox.text) && (me.ipAddressBox.text != ""));
 623
 624         for(i = 0; i < category_draw_count; ++i) { category_name[i] = -1; category_item[i] = -1; }
 625         category_draw_count = 0;
 626
 627         if(autocvar_menu_slist_categories >= 0) // if less than 0, don't even draw a category heading for favorites
 628         {
 629                 float itemcount = gethostcachevalue(SLIST_HOSTCACHEVIEWCOUNT);
 630                 me.nItems = itemcount;
 631
 632                 //float visible = floor(me.scrollPos / me.itemHeight);
 633                 // ^ unfortunately no such optimization can be made-- we must process through the
 634                 // entire list, otherwise there is no way to know which item is first in its category.
 635
 636                 // binary search method suggested by div
 637                 float x;
 638                 float begin = 0;
 639                 for(x = 1; x <= category_ent_count; ++x) {
 640                         float first = begin;
 641                         float last = (itemcount - 1);
 642                         if (first > last) {
 643                                 // List is empty.
 644                                 break;
 645                         }
 646                         float catf = gethostcachenumber(SLIST_FIELD_CATEGORY, first);
 647                         float catl = gethostcachenumber(SLIST_FIELD_CATEGORY, last);
 648                         if (catf > x) {
 649                                 // The first one is already > x.
 650                                 // Therefore, category x does not exist.
 651                                 // Higher numbered categories do exist though.
 652                         } else if (catl < x) {
 653                                 // The last one is < x.
 654                                 // Thus this category - and any following -
 655                                 // don't exist.
 656                                 break;
 657                         } else if (catf == x) {
 658                                 // Starts at first. This breaks the loop
 659                                 // invariant in the binary search and thus has
 660                                 // to be handled separately.
 661                                 if(gethostcachenumber(SLIST_FIELD_CATEGORY, first) != x)
 662                                         error("Category mismatch I");
 663                                 if(first > 0)
 664                                         if(gethostcachenumber(SLIST_FIELD_CATEGORY, first - 1) == x)
 665                                                 error("Category mismatch II");
 666                                 category_name[category_draw_count] = x;
 667                                 category_item[category_draw_count] = first;
 668                                 ++category_draw_count;
 669                                 begin = first + 1;
 670                         } else {
 671                                 // At this point, catf <= x < catl, thus
 672                                 // catf < catl, thus first < last.
 673                                 // INVARIANTS:
 674                                 // last - first >= 1
 675                                 // catf == gethostcachenumber(SLIST_FIELD_CATEGORY(first)
 676                                 // catl == gethostcachenumber(SLIST_FIELD_CATEGORY(last)
 677                                 // catf < x
 678                                 // catl >= x
 679                                 while (last - first > 1) {
 680                                         float middle = floor((first + last) / 2);
 681                                         // By loop condition, middle != first && middle != last.
 682                                         float cat = gethostcachenumber(SLIST_FIELD_CATEGORY, middle);
 683                                         if (cat >= x) {
 684                                                 last = middle;
 685                                                 catl = cat;
 686                                         } else {
 687                                                 first = middle;
 688                                                 catf = cat;
 689                                         }
 690                                 }
 691                                 if (catl == x) {
 692                                         if(gethostcachenumber(SLIST_FIELD_CATEGORY, last) != x)
 693                                                 error("Category mismatch III");
 694                                         if(last > 0)
 695                                                 if(gethostcachenumber(SLIST_FIELD_CATEGORY, last - 1) == x)
 696                                                         error("Category mismatch IV");
 697                                         category_name[category_draw_count] = x;
 698                                         category_item[category_draw_count] = last;
 699                                         ++category_draw_count;
 700                                         begin = last + 1; // already scanned through these, skip 'em
 701                                 }
 702                                 else
 703                                         begin = last; // already scanned through these, skip 'em
 704                         }
 705                 }
 706                 if(autocvar_menu_slist_categories_onlyifmultiple && (category_draw_count == 1))
 707                 {
 708                         category_name[0] = -1;
 709                         category_item[0] = -1;
 710                         category_draw_count = 0;
 711                         me.nItems = itemcount;
 712                 }
 713         }
 714         else { me.nItems = gethostcachevalue(SLIST_HOSTCACHEVIEWCOUNT); }
 715
 716         me.connectButton.disabled = ((me.nItems == 0) && (me.ipAddressBox.text == ""));
 717         me.infoButton.disabled = ((me.nItems == 0) || !owned);
 718         me.favoriteButton.disabled = ((me.nItems == 0) && (me.ipAddressBox.text == ""));
 719
 720         if(me.selectedServer)
 721         {
 722                 for(i = 0; i < me.nItems; ++i)
 723                 {
 724                         if(gethostcachestring(SLIST_FIELD_CNAME, i) == me.selectedServer)
 725                         {
 726                                 // don't follow the selected item with SUPER(XonoticServerList).setSelected(me, i);
 727                                 me.selectedItem = i;
 728                                 found = true;
 729                                 break;
 730                         }
 731                 }
 732         }
 733         if(!found)
 734         {
 735                 if(me.nItems > 0)
 736                 {
 737                         // selected server disappeared, select the last server (scrolling to it)
 738                         if(me.selectedItem >= me.nItems)
 739                                 SUPER(XonoticServerList).setSelected(me, me.nItems - 1);
 740                         if(me.selectedServer)
 741                                 strunzone(me.selectedServer);
 742                         me.selectedServer = strzone(gethostcachestring(SLIST_FIELD_CNAME, me.selectedItem));
 743                 }
 744         }
 745
 746         if(owned)
 747         {
 748                 if(me.selectedServer != me.ipAddressBox.text)
 749                 {
 750                         me.ipAddressBox.setText(me.ipAddressBox, me.selectedServer);
 751                         me.ipAddressBox.cursorPos = strlen(me.selectedServer);
 752                         me.ipAddressBoxFocused = -1;
 753                 }
 754         }
 755
 756         if(me.ipAddressBoxFocused != me.ipAddressBox.focused)
 757         {
 758                 if(me.ipAddressBox.focused || me.ipAddressBoxFocused < 0)
 759                         ServerList_Update_favoriteButton(NULL, me);
 760                 me.ipAddressBoxFocused = me.ipAddressBox.focused;
 761         }
 762
 763         SUPER(XonoticServerList).draw(me);
 764 }
 765 void ServerList_PingSort_Click(entity btn, entity me)
 766 {
 767         me.setSortOrder(me, SLIST_FIELD_PING, +1);
 768 }
 769 void ServerList_NameSort_Click(entity btn, entity me)
 770 {
 771         me.setSortOrder(me, SLIST_FIELD_NAME, -1); // why?
 772 }
 773 void ServerList_MapSort_Click(entity btn, entity me)
 774 {
 775         me.setSortOrder(me, SLIST_FIELD_MAP, -1); // why?
 776 }
 777 void ServerList_PlayerSort_Click(entity btn, entity me)
 778 {
 779         me.setSortOrder(me, SLIST_FIELD_NUMHUMANS, -1);
 780 }
 781 void ServerList_TypeSort_Click(entity btn, entity me)
 782 {
 783         string s, t;
 784         float i, m;
 785         s = me.filterString;
 786         m = strstrofs(s, ":", 0);
 787         if(m >= 0)
 788         {
 789                 s = substring(s, 0, m);
 790                 while(substring(s, m+1, 1) == " ") // skip spaces
 791                         ++m;
 792         }
 793         else
 794                 s = "";
 795
 796         for(i = 1; ; i *= 2) // 20 modes ought to be enough for anyone
 797         {
 798                 t = MapInfo_Type_ToString(i);
 799                 if(i > 1)
 800                         if(t == "") // it repeats (default case)
 801                         {
 802                                 // no type was found
 803                                 // choose the first one
 804                                 s = MapInfo_Type_ToString(1);
 805                                 break;
 806                         }
 807                 if(s == t)
 808                 {
 809                         // the type was found
 810                         // choose the next one
 811                         s = MapInfo_Type_ToString(i * 2);
 812                         if(s == "")
 813                                 s = MapInfo_Type_ToString(1);
 814                         break;
 815                 }
 816         }
 817
 818         if(s != "")
 819                 s = strcat(s, ":");
 820         s = strcat(s, substring(me.filterString, m+1, strlen(me.filterString) - m - 1));
 821
 822         me.controlledTextbox.setText(me.controlledTextbox, s);
 823         me.controlledTextbox.keyDown(me.controlledTextbox, K_END, 0, 0);
 824         me.controlledTextbox.keyUp(me.controlledTextbox, K_END, 0, 0);
 825         //ServerList_Filter_Change(me.controlledTextbox, me);
 826 }
 827 void ServerList_Filter_Change(entity box, entity me)
 828 {
 829         if(me.filterString)
 830                 strunzone(me.filterString);
 831         if(box.text != "")
 832                 me.filterString = strzone(box.text);
 833         else
 834                 me.filterString = string_null;
 835         me.refreshServerList(me, REFRESHSERVERLIST_REFILTER);
 836
 837         me.ipAddressBox.setText(me.ipAddressBox, "");
 838         me.ipAddressBox.cursorPos = 0;
 839         me.ipAddressBoxFocused = -1;
 840 }
 841 void ServerList_Categories_Click(entity box, entity me)
 842 {
 843         box.setChecked(box, autocvar_menu_slist_categories = !autocvar_menu_slist_categories);
 844         me.refreshServerList(me, REFRESHSERVERLIST_RESORT);
 845
 846         me.ipAddressBox.setText(me.ipAddressBox, "");
 847         me.ipAddressBox.cursorPos = 0;
 848         me.ipAddressBoxFocused = -1;
 849 }
 850 void ServerList_ShowEmpty_Click(entity box, entity me)
 851 {
 852         box.setChecked(box, me.filterShowEmpty = !me.filterShowEmpty);
 853         me.refreshServerList(me, REFRESHSERVERLIST_REFILTER);
 854
 855         me.ipAddressBox.setText(me.ipAddressBox, "");
 856         me.ipAddressBox.cursorPos = 0;
 857         me.ipAddressBoxFocused = -1;
 858 }
 859 void ServerList_ShowFull_Click(entity box, entity me)
 860 {
 861         box.setChecked(box, me.filterShowFull = !me.filterShowFull);
 862         me.refreshServerList(me, REFRESHSERVERLIST_REFILTER);
 863
 864         me.ipAddressBox.setText(me.ipAddressBox, "");
 865         me.ipAddressBox.cursorPos = 0;
 866         me.ipAddressBoxFocused = -1;
 867 }
 868 void XonoticServerList_setSortOrder(entity me, int fld, int direction)
 869 {
 870         if(me.currentSortField == fld)
 871                 direction = -me.currentSortOrder;
 872         me.currentSortOrder = direction;
 873         me.currentSortField = fld;
 874         me.sortButton1.forcePressed = (fld == SLIST_FIELD_PING);
 875         me.sortButton2.forcePressed = (fld == SLIST_FIELD_NAME);
 876         me.sortButton3.forcePressed = (fld == SLIST_FIELD_MAP);
 877         me.sortButton4.forcePressed = 0;
 878         me.sortButton5.forcePressed = (fld == SLIST_FIELD_NUMHUMANS);
 879         me.selectedItem = 0;
 880         if(me.selectedServer)
 881                 strunzone(me.selectedServer);
 882         me.selectedServer = string_null;
 883         me.refreshServerList(me, REFRESHSERVERLIST_REFILTER);
 884 }
 885 void XonoticServerList_positionSortButton(entity me, entity btn, float theOrigin, float theSize, string theTitle, void(entity, entity) theFunc)
 886 {
 887         vector originInLBSpace, sizeInLBSpace;
 888         originInLBSpace = eY * (-me.itemHeight);
 889         sizeInLBSpace = eY * me.itemHeight + eX * (1 - me.controlWidth);
 890
 891         vector originInDialogSpace, sizeInDialogSpace;
 892         originInDialogSpace = boxToGlobal(originInLBSpace, me.Container_origin, me.Container_size);
 893         sizeInDialogSpace = boxToGlobalSize(sizeInLBSpace, me.Container_size);
 894
 895         btn.Container_origin_x = originInDialogSpace.x + sizeInDialogSpace.x * theOrigin;
 896         btn.Container_size_x   =                         sizeInDialogSpace.x * theSize;
 897         btn.setText(btn, theTitle);
 898         btn.onClick = theFunc;
 899         btn.onClickEntity = me;
 900         btn.resized = 1;
 901 }
 902 void XonoticServerList_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
 903 {
 904         SUPER(XonoticServerList).resizeNotify(me, relOrigin, relSize, absOrigin, absSize);
 905
 906         me.realFontSize_y = me.fontSize / (absSize.y * me.itemHeight);
 907         me.realFontSize_x = me.fontSize / (absSize.x * (1 - me.controlWidth));
 908         me.realUpperMargin = 0.5 * (1 - me.realFontSize.y);
 909
 910         me.columnIconsOrigin = 0;
 911         me.columnIconsSize = me.realFontSize.x * 4 * me.iconsSizeFactor;
 912         me.columnPingSize = me.realFontSize.x * 3;
 913         me.columnMapSize = me.realFontSize.x * 10;
 914         me.columnTypeSize = me.realFontSize.x * 4;
 915         me.columnPlayersSize = me.realFontSize.x * 5;
 916         me.columnNameSize = 1 - me.columnPlayersSize - me.columnMapSize - me.columnPingSize - me.columnIconsSize - me.columnTypeSize - 5 * me.realFontSize.x;
 917         me.columnPingOrigin = me.columnIconsOrigin + me.columnIconsSize + me.realFontSize.x;
 918         me.columnNameOrigin = me.columnPingOrigin + me.columnPingSize + me.realFontSize.x;
 919         me.columnMapOrigin = me.columnNameOrigin + me.columnNameSize + me.realFontSize.x;
 920         me.columnTypeOrigin = me.columnMapOrigin + me.columnMapSize + me.realFontSize.x;
 921         me.columnPlayersOrigin = me.columnTypeOrigin + me.columnTypeSize + me.realFontSize.x;
 922
 923         me.positionSortButton(me, me.sortButton1, me.columnPingOrigin, me.columnPingSize, _("Ping"), ServerList_PingSort_Click);
 924         me.positionSortButton(me, me.sortButton2, me.columnNameOrigin, me.columnNameSize, _("Host name"), ServerList_NameSort_Click);
 925         me.positionSortButton(me, me.sortButton3, me.columnMapOrigin, me.columnMapSize, _("Map"), ServerList_MapSort_Click);
 926         me.positionSortButton(me, me.sortButton4, me.columnTypeOrigin, me.columnTypeSize, _("Type"), ServerList_TypeSort_Click);
 927         me.positionSortButton(me, me.sortButton5, me.columnPlayersOrigin, me.columnPlayersSize, _("Players"), ServerList_PlayerSort_Click);
 928
 929         int f = me.currentSortField;
 930         if(f >= 0)
 931         {
 932                 me.currentSortField = -1;
 933                 me.setSortOrder(me, f, me.currentSortOrder); // force resetting the sort order
 934         }
 935 }
 936 void ServerList_Connect_Click(entity btn, entity me)
 937 {
 938         localcmd(sprintf("connect %s\n",
 939                 ((me.ipAddressBox.text != "") ?
 940                         me.ipAddressBox.text : me.selectedServer
 941                 )
 942         ));
 943 }
 944 void ServerList_Favorite_Click(entity btn, entity me)
 945 {
 946         string ipstr;
 947         ipstr = netaddress_resolve(me.ipAddressBox.text, 26000);
 948         if(ipstr != "")
 949         {
 950                 m_play_click_sound(MENU_SOUND_SELECT);
 951                 me.toggleFavorite(me, me.ipAddressBox.text);
 952                 me.ipAddressBoxFocused = -1;
 953         }
 954 }
 955 void ServerList_Info_Click(entity btn, entity me)
 956 {
 957         if (me.nItems != 0)
 958                 main.serverInfoDialog.loadServerInfo(main.serverInfoDialog, me.selectedItem);
 959
 960         vector org = boxToGlobal(eY * (me.selectedItem * me.itemHeight - me.scrollPos), me.origin, me.size);
 961         vector sz = boxToGlobalSize(eY * me.itemHeight + eX * (1 - me.controlWidth), me.size);
 962         DialogOpenButton_Click_withCoords(me, main.serverInfoDialog, org, sz);
 963 }
 964 void XonoticServerList_doubleClickListBoxItem(entity me, int i, vector where)
 965 {
 966         ServerList_Connect_Click(NULL, me);
 967 }
 968 void XonoticServerList_drawListBoxItem(entity me, int i, vector absSize, bool isSelected, bool isFocused)
 969 {
 970         // layout: Ping, Server name, Map name, NP, TP, MP
 971         float p;
 972         int q;
 973         bool isv4, isv6;
 974         vector theColor;
 975         float theAlpha;
 976         bool pure = false;
 977         int freeslots = -1, sflags = -1, j, m;
 978         string s, typestr, versionstr, k, v, modname;
 979
 980         //printf("time: %f, i: %d, item: %d, nitems: %d\n", time, i, item, me.nItems);
 981
 982         vector oldscale = draw_scale;
 983         vector oldshift = draw_shift;
 984 #define SET_YRANGE(start,end) \
 985         draw_scale = boxToGlobalSize(eX * 1 + eY * (end - start), oldscale); \
 986         draw_shift = boxToGlobal(eY * start, oldshift, oldscale);
 987
 988         for (j = 0; j < category_draw_count; ++j) {
 989                 // Matches exactly the headings with increased height.
 990                 if (i == category_item[j])
 991                         break;
 992         }
 993
 994         if (j < category_draw_count)
 995         {
 996                 entity catent = RetrieveCategoryEnt(category_name[j]);
 997                 if(catent)
 998                 {
 999                         SET_YRANGE(
1000                                 (me.categoriesHeight - 1) / (me.categoriesHeight + 1),
1001                                 me.categoriesHeight / (me.categoriesHeight + 1)
1002                         );
1003                         draw_Text(
1004                                 eY * me.realUpperMargin
1005                                 +
1006 #if 0
1007                                 eX * (me.columnNameOrigin + (me.columnNameSize - draw_TextWidth(catent.cat_string, 0, me.realFontSize)) * 0.5),
1008                                 catent.cat_string,
1009 #else
1010                                 eX * (me.columnNameOrigin),
1011                                 strcat(catent.cat_string, ":"),
1012 #endif
1013                                 me.realFontSize,
1014                                 SKINCOLOR_SERVERLIST_CATEGORY,
1015                                 SKINALPHA_SERVERLIST_CATEGORY,
1016                                 0
1017                         );
1018                         SET_YRANGE(me.categoriesHeight / (me.categoriesHeight + 1), 1);
1019                 }
1020         }
1021
1022         if(isSelected)
1023                 draw_Fill('0 0 0', '1 1 0', SKINCOLOR_LISTBOX_SELECTED, SKINALPHA_LISTBOX_SELECTED);
1024         else if(isFocused)
1025         {
1026                 me.focusedItemAlpha = getFadedAlpha(me.focusedItemAlpha, SKINALPHA_LISTBOX_FOCUSED, SKINFADEALPHA_LISTBOX_FOCUSED);
1027                 draw_Fill('0 0 0', '1 1 0', SKINCOLOR_LISTBOX_FOCUSED, me.focusedItemAlpha);
1028         }
1029
1030         s = gethostcachestring(SLIST_FIELD_QCSTATUS, i);
1031         m = tokenizebyseparator(s, ":");
1032         typestr = "";
1033         if(m >= 2)
1034         {
1035                 typestr = argv(0);
1036                 versionstr = argv(1);
1037         }
1038         freeslots = -1;
1039         modname = "";
1040         for(j = 2; j < m; ++j)
1041         {
1042                 if(argv(j) == "")
1043                         break;
1044                 k = substring(argv(j), 0, 1);
1045                 v = substring(argv(j), 1, -1);
1046                 if(k == "P")
1047                         pure = stob(v);
1048                 else if(k == "S")
1049                         freeslots = stof(v);
1050                 else if(k == "F")
1051                         sflags = stoi(v);
1052                 else if(k == "M")
1053                         modname = v;
1054         }
1055
1056 #ifdef COMPAT_NO_MOD_IS_XONOTIC
1057         if(modname == "")
1058                 modname = "Xonotic";
1059 #endif
1060
1061         /*
1062         SLIST_FIELD_MOD = gethostcacheindexforkey("mod");
1063         s = gethostcachestring(SLIST_FIELD_MOD, i);
1064         if(s != "data")
1065                 if(modname == "Xonotic")
1066                         modname = s;
1067         */
1068
1069         // list the mods here on which the pure server check actually works
1070         if(modname != "Xonotic")
1071         if(modname != "InstaGib" || modname != "MinstaGib")
1072         if(modname != "CTS")
1073         if(modname != "NIX")
1074         if(modname != "NewToys")
1075                 pure = false;
1076
1077         if(gethostcachenumber(SLIST_FIELD_FREESLOTS, i) <= 0)
1078                 theAlpha = SKINALPHA_SERVERLIST_FULL;
1079         else if(freeslots == 0)
1080                 theAlpha = SKINALPHA_SERVERLIST_FULL; // g_maxplayers support
1081         else if (!gethostcachenumber(SLIST_FIELD_NUMHUMANS, i))
1082                 theAlpha = SKINALPHA_SERVERLIST_EMPTY;
1083         else
1084                 theAlpha = 1;
1085
1086         p = gethostcachenumber(SLIST_FIELD_PING, i);
1087         const int PING_LOW = 75;
1088         const int PING_MED = 200;
1089         const int PING_HIGH = 500;
1090         if(p < PING_LOW)
1091                 theColor = SKINCOLOR_SERVERLIST_LOWPING + (SKINCOLOR_SERVERLIST_MEDPING - SKINCOLOR_SERVERLIST_LOWPING) * (p / PING_LOW);
1092         else if(p < PING_MED)
1093                 theColor = SKINCOLOR_SERVERLIST_MEDPING + (SKINCOLOR_SERVERLIST_HIGHPING - SKINCOLOR_SERVERLIST_MEDPING) * ((p - PING_LOW) / (PING_MED - PING_LOW));
1094         else if(p < PING_HIGH)
1095         {
1096                 theColor = SKINCOLOR_SERVERLIST_HIGHPING;
1097                 theAlpha *= 1 + (SKINALPHA_SERVERLIST_HIGHPING - 1) * ((p - PING_MED) / (PING_HIGH - PING_MED));
1098         }
1099         else
1100         {
1101                 theColor = eX;
1102                 theAlpha *= SKINALPHA_SERVERLIST_HIGHPING;
1103         }
1104
1105         if(gethostcachenumber(SLIST_FIELD_ISFAVORITE, i))
1106         {
1107                 theColor = theColor * (1 - SKINALPHA_SERVERLIST_FAVORITE) + SKINCOLOR_SERVERLIST_FAVORITE * SKINALPHA_SERVERLIST_FAVORITE;
1108                 theAlpha = theAlpha * (1 - SKINALPHA_SERVERLIST_FAVORITE) + SKINALPHA_SERVERLIST_FAVORITE;
1109         }
1110
1111         s = gethostcachestring(SLIST_FIELD_CNAME, i);
1112
1113         isv4 = isv6 = false;
1114         if(substring(s, 0, 1) == "[")
1115         {
1116                 isv6 = true;
1117                 me.seenIPv6 += 1;
1118         }
1119         else if(strstrofs("0123456789", substring(s, 0, 1), 0) >= 0)
1120         {
1121                 isv4 = true;
1122                 me.seenIPv4 += 1;
1123         }
1124
1125         q = stof(substring(crypto_getencryptlevel(s), 0, 1));
1126         if((q <= 0 && cvar("crypto_aeslevel") >= 3) || (q >= 3 && cvar("crypto_aeslevel") <= 0))
1127         {
1128                 theColor = SKINCOLOR_SERVERLIST_IMPOSSIBLE;
1129                 theAlpha = SKINALPHA_SERVERLIST_IMPOSSIBLE;
1130         }
1131
1132         if(q == 1)
1133         {
1134                 if(cvar("crypto_aeslevel") >= 2)
1135                         q |= 4;
1136         }
1137         if(q == 2)
1138         {
1139                 if(cvar("crypto_aeslevel") >= 1)
1140                         q |= 4;
1141         }
1142         if(q == 3)
1143                 q = 5;
1144         else if(q >= 3)
1145                 q -= 2;
1146         // possible status:
1147         // 0: crypto off
1148         // 1: AES possible
1149         // 2: AES recommended but not available
1150         // 3: AES possible and will be used
1151         // 4: AES recommended and will be used
1152         // 5: AES required
1153
1154         // --------------
1155         //  RENDER ICONS
1156         // --------------
1157         vector iconSize = '0 0 0';
1158         iconSize_y = me.realFontSize.y * me.iconsSizeFactor;
1159         iconSize_x = me.realFontSize.x * me.iconsSizeFactor;
1160
1161         vector iconPos = '0 0 0';
1162         iconPos_x = (me.columnIconsSize - 3 * iconSize.x) * 0.5;
1163         iconPos_y = (1 - iconSize.y) * 0.5;
1164
1165         string n;
1166
1167         if (!(me.seenIPv4 && me.seenIPv6))
1168         {
1169                 iconPos.x += iconSize.x * 0.5;
1170         }
1171         else if(me.seenIPv4 && me.seenIPv6)
1172         {
1173                 n = string_null;
1174                 if(isv6)
1175                         draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_ipv6"), 0); // PRECACHE_PIC_MIPMAP
1176                 else if(isv4)
1177                         draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_ipv4"), 0); // PRECACHE_PIC_MIPMAP
1178                 if(n)
1179                         draw_Picture(iconPos, n, iconSize, '1 1 1', 1);
1180                 iconPos.x += iconSize.x;
1181         }
1182
1183         if(q > 0)
1184         {
1185                 draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_aeslevel", ftos(q)), 0); // PRECACHE_PIC_MIPMAP
1186                 draw_Picture(iconPos, n, iconSize, '1 1 1', 1);
1187         }
1188         iconPos.x += iconSize.x;
1189
1190         if(modname == "Xonotic")
1191         {
1192                 if(pure == 0)
1193                 {
1194                         draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_pure1"), PRECACHE_PIC_MIPMAP);
1195                         draw_Picture(iconPos, n, iconSize, '1 1 1', 1);
1196                 }
1197         }
1198         else
1199         {
1200                 draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_mod_", modname), PRECACHE_PIC_MIPMAP);
1201                 if(draw_PictureSize(n) == '0 0 0')
1202                         draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_mod_"), PRECACHE_PIC_MIPMAP);
1203                 if(pure == 0)
1204                         draw_Picture(iconPos, n, iconSize, '1 1 1', 1);
1205                 else
1206                         draw_Picture(iconPos, n, iconSize, '1 1 1', SKINALPHA_SERVERLIST_ICON_NONPURE);
1207         }
1208         iconPos.x += iconSize.x;
1209
1210         if(sflags >= 0 && (sflags & SERVERFLAG_PLAYERSTATS))
1211         {
1212                 draw_PreloadPictureWithFlags(n = strcat(SKINGFX_SERVERLIST_ICON, "_stats1"), 0); // PRECACHE_PIC_MIPMAP
1213                 draw_Picture(iconPos, n, iconSize, '1 1 1', 1);
1214         }
1215         iconPos.x += iconSize.x;
1216
1217         // --------------
1218         //  RENDER TEXT
1219         // --------------
1220
1221         // ping
1222         s = ftos(p);
1223         draw_Text(me.realUpperMargin * eY + (me.columnPingOrigin + me.columnPingSize - draw_TextWidth(s, 0, me.realFontSize)) * eX, s, me.realFontSize, theColor, theAlpha, 0);
1224
1225         // server name
1226         s = draw_TextShortenToWidth(gethostcachestring(SLIST_FIELD_NAME, i), me.columnNameSize, 0, me.realFontSize);
1227         draw_Text(me.realUpperMargin * eY + me.columnNameOrigin * eX, s, me.realFontSize, theColor, theAlpha, 0);
1228
1229         // server map
1230         s = draw_TextShortenToWidth(gethostcachestring(SLIST_FIELD_MAP, i), me.columnMapSize, 0, me.realFontSize);
1231         draw_Text(me.realUpperMargin * eY + (me.columnMapOrigin + (me.columnMapSize - draw_TextWidth(s, 0, me.realFontSize)) * 0.5) * eX, s, me.realFontSize, theColor, theAlpha, 0);
1232
1233         // server gametype
1234         s = draw_TextShortenToWidth(typestr, me.columnTypeSize, 0, me.realFontSize);
1235         draw_Text(me.realUpperMargin * eY + (me.columnTypeOrigin + (me.columnTypeSize - draw_TextWidth(s, 0, me.realFontSize)) * 0.5) * eX, s, me.realFontSize, theColor, theAlpha, 0);
1236
1237         // server playercount
1238         s = strcat(ftos(gethostcachenumber(SLIST_FIELD_NUMHUMANS, i)), "/", ftos(gethostcachenumber(SLIST_FIELD_MAXPLAYERS, i)));
1239         draw_Text(me.realUpperMargin * eY + (me.columnPlayersOrigin + (me.columnPlayersSize - draw_TextWidth(s, 0, me.realFontSize)) * 0.5) * eX, s, me.realFontSize, theColor, theAlpha, 0);
1240 }
1241
1242 bool XonoticServerList_keyDown(entity me, int scan, bool ascii, bool shift)
1243 {
1244         vector org, sz;
1245
1246         org = boxToGlobal(eY * (me.selectedItem * me.itemHeight - me.scrollPos), me.origin, me.size);
1247         sz = boxToGlobalSize(eY * me.itemHeight + eX * (1 - me.controlWidth), me.size);
1248
1249         if(scan == K_ENTER || scan == K_KP_ENTER)
1250         {
1251                 ServerList_Connect_Click(NULL, me);
1252                 return true;
1253         }
1254         else if(scan == K_MOUSE2 || scan == K_SPACE)
1255         {
1256                 if(me.nItems != 0)
1257                 {
1258                         m_play_click_sound(MENU_SOUND_OPEN);
1259                         main.serverInfoDialog.loadServerInfo(main.serverInfoDialog, me.selectedItem);
1260                         DialogOpenButton_Click_withCoords(me, main.serverInfoDialog, org, sz);
1261                         return true;
1262                 }
1263                 return false;
1264         }
1265         else if(scan == K_INS || scan == K_MOUSE3 || scan == K_KP_INS)
1266         {
1267                 if(me.nItems != 0)
1268                 {
1269                         me.toggleFavorite(me, me.selectedServer);
1270                         me.ipAddressBoxFocused = -1;
1271                         return true;
1272                 }
1273                 return false;
1274         }
1275         else if(SUPER(XonoticServerList).keyDown(me, scan, ascii, shift))
1276                 return true;
1277         else if(!me.controlledTextbox)
1278                 return false;
1279         else
1280                 return me.controlledTextbox.keyDown(me.controlledTextbox, scan, ascii, shift);
1281 }
1282
1283 float XonoticServerList_getTotalHeight(entity me)
1284 {
1285         float num_normal_rows = me.nItems;
1286         int num_headers = category_draw_count;
1287         return me.itemHeight * (num_normal_rows + me.categoriesHeight * num_headers);
1288 }
1289 int XonoticServerList_getItemAtPos(entity me, float pos)
1290 {
1291         pos = pos / me.itemHeight;
1292         int i;
1293         for (i = category_draw_count - 1; i >= 0; --i) {
1294                 int itemidx = category_item[i];
1295                 float itempos = i * me.categoriesHeight + category_item[i];
1296                 if (pos >= itempos + me.categoriesHeight + 1)
1297                         return itemidx + 1 + floor(pos - (itempos + me.categoriesHeight + 1));
1298                 if (pos >= itempos)
1299                         return itemidx;
1300         }
1301         // No category matches? Note that category 0 is... 0. Therefore no headings exist at all.
1302         return floor(pos);
1303 }
1304 float XonoticServerList_getItemStart(entity me, int item)
1305 {
1306         int i;
1307         for (i = category_draw_count - 1; i >= 0; --i) {
1308                 int itemidx = category_item[i];
1309                 float itempos = i * me.categoriesHeight + category_item[i];
1310                 if (item >= itemidx + 1)
1311                         return (itempos + me.categoriesHeight + 1 + item - (itemidx + 1)) * me.itemHeight;
1312                 if (item >= itemidx)
1313                         return itempos * me.itemHeight;
1314         }
1315         // No category matches? Note that category 0 is... 0. Therefore no headings exist at all.
1316         return item * me.itemHeight;
1317 }
1318 float XonoticServerList_getItemHeight(entity me, int item)
1319 {
1320         int i;
1321         for (i = 0; i < category_draw_count; ++i) {
1322                 // Matches exactly the headings with increased height.
1323                 if (item == category_item[i])
1324                         return me.itemHeight * (me.categoriesHeight + 1);
1325         }
1326         return me.itemHeight;
1327 }
1328
1329 #endif