data/qcsrc/server/scores.qc

   1 .float scores[MAX_SCORE];
   2 .float teamscores[MAX_TEAMSCORE];
   3
   4 .entity scorekeeper;
   5 entity teamscorekeepers[16];
   6 string scores_label[MAX_SCORE];
   7 float scores_flags[MAX_SCORE];
   8 string teamscores_label[MAX_TEAMSCORE];
   9 float teamscores_flags[MAX_TEAMSCORE];
  10 float teamscores_entities_count;
  11 var .float scores_primary;
  12 var .float teamscores_primary;
  13 float scores_initialized;
  14
  15 .float Version;
  16 .float(entity to) SendEntity;
  17
  18 vector ScoreField_Compare(entity t1, entity t2, .float field, float fieldflags, vector previous) // returns: cmp value, best prio
  19 {
  20         if(fieldflags & SFL_SORT_PRIO_MASK < previous_y)
  21                 return previous;
  22         if(t1.field == t2.field)
  23                 return previous;
  24
  25         previous_y = fieldflags & SFL_SORT_PRIO_MASK;
  26
  27         if(fieldflags & SFL_DECREASING)
  28                 previous_x = (t1.field - t2.field);
  29         else
  30                 previous_x = (t2.field - t1.field);
  31
  32         return previous;
  33 }
  34
  35 /*
  36  * teamscore entities
  37  */
  38
  39 void TeamScore_SendEntity(entity to)
  40 {
  41         float i;
  42
  43         WriteByte(MSG_ENTITY, ENT_CLIENT_TEAMSCORES);
  44         WriteByte(MSG_ENTITY, self.team);
  45         for(i = 0; i < MAX_TEAMSCORE; ++i)
  46                 WriteShort(MSG_ENTITY, self.teamscores[i]);
  47 }
  48
  49 void TeamScore_Spawn(float t, string name)
  50 {
  51         entity ts;
  52         ts = spawn();
  53         ts.classname = "csqc_score_team";
  54         ts.SendEntity = TeamScore_SendEntity;
  55         ts.netname = name; // not used yet, FIXME
  56         ts.Version = 1; // immediately send, so csqc knows about the team
  57         ts.team = t;
  58         teamscorekeepers[t] = ts;
  59         ++teamscores_entities_count;
  60 }
  61
  62 void TeamScore_Add(entity player, float scorefield, float score)
  63 {
  64         entity s;
  65         if(!scores_initialized) return; // FIXME remove this when everything uses this system
  66         s = teamscorekeepers[player.team];
  67         if(!s)
  68                 error("Adding score to unknown team!");
  69         s.(teamscores[scorefield]) += score;
  70         s.Version += 1;
  71 }
  72
  73 float TeamScore_Compare(entity t1, entity t2)
  74 {
  75         if(!t1 || !t2) return (!t2) - !t1;
  76
  77         vector result;
  78         float i;
  79         for(i = 0; i < MAX_TEAMSCORE; ++i)
  80                 result = ScoreField_Compare(t1, t2, teamscores[i], teamscores_flags[i], result);
  81         return result_x;
  82 }
  83
  84 /*
  85  * the scoreinfo entity
  86  */
  87
  88 void ScoreInfo_SetLabel_PlayerScore(float i, string label, float scoreflags)
  89 {
  90         scores_label[i] = label;
  91         scores_flags[i] = scoreflags;
  92         if(scoreflags & SFL_SORT_PRIO_MASK == SFL_SORT_PRIO_PRIMARY)
  93                 scores_primary = scores[i];
  94 }
  95
  96 void ScoreInfo_SetLabel_TeamScore(float i, string label, float scoreflags)
  97 {
  98         teamscores_label[i] = label;
  99         teamscores_flags[i] = scoreflags;
 100         if(scoreflags & SFL_SORT_PRIO_MASK == SFL_SORT_PRIO_PRIMARY)
 101                 teamscores_primary = teamscores[i];
 102 }
 103
 104 void ScoreInfo_SendEntity(entity to)
 105 {
 106         WriteByte(MSG_ENTITY, ENT_CLIENT_SCORES_INFO);
 107         float i;
 108         for(i = 0; i < MAX_SCORE; ++i)
 109         {
 110                 WriteString(MSG_ENTITY, scores_label[i]);
 111                 WriteByte(MSG_ENTITY, scores_flags[i]);
 112         }
 113         for(i = 0; i < MAX_TEAMSCORE; ++i)
 114         {
 115                 WriteString(MSG_ENTITY, teamscores_label[i]);
 116                 WriteByte(MSG_ENTITY, teamscores_flags[i]);
 117         }
 118 }
 119
 120 void ScoreInfo_Init(float teams)
 121 {
 122         scores_initialized = 1;
 123         if(teams >= 1)
 124                 TeamScore_Spawn(COLOR_TEAM1, "Red");
 125         if(teams >= 2)
 126                 TeamScore_Spawn(COLOR_TEAM2, "Blue");
 127         if(teams >= 3)
 128                 TeamScore_Spawn(COLOR_TEAM3, "Yellow");
 129         if(teams >= 4)
 130                 TeamScore_Spawn(COLOR_TEAM4, "Pink");
 131         entity si;
 132         si = spawn();
 133         si.classname = "csqc_score_info";
 134         si.SendEntity = ScoreInfo_SendEntity;
 135         si.Version = 1;
 136 }
 137
 138 /*
 139  * per-player score entities
 140  */
 141
 142 void PlayerScore_SendEntity()
 143 {
 144         float i;
 145
 146         WriteByte(MSG_ENTITY, ENT_CLIENT_SCORES);
 147         WriteByte(MSG_ENTITY, num_for_edict(self.owner));
 148         for(i = 0; i < MAX_SCORE; ++i)
 149                 WriteShort(MSG_ENTITY, self.scores[i]);
 150 }
 151
 152 void PlayerScore_Clear(entity player)
 153 {
 154         entity sk;
 155         float i;
 156
 157         if(!teamscores_entities_count)
 158         {
 159                 sk = player.scorekeeper;
 160                 for(i = 0; i < MAX_SCORE; ++i)
 161                         sk.(scores[i]) = 0;
 162                 sk.Version += 1;
 163         }
 164 }
 165
 166 void Score_ClearAll()
 167 {
 168         entity p, sk;
 169         float i;
 170         FOR_EACH_CLIENTSLOT(p)
 171         {
 172                 sk = p.scorekeeper;
 173                 if(!sk)
 174                         continue;
 175                 for(i = 0; i < MAX_SCORE; ++i)
 176                         sk.(scores[i]) = 0;
 177                 sk.Version += 1;
 178         }
 179         for(i = 0; i < 16; ++i)
 180         {
 181                 sk = teamscorekeepers[i];
 182                 if(!sk)
 183                         continue;
 184                 for(i = 0; i < MAX_SCORE; ++i)
 185                         sk.(teamscores[i]) = 0;
 186                 sk.Version += 1;
 187         }
 188 }
 189
 190 void PlayerScore_Attach(entity player)
 191 {
 192         entity sk;
 193         if(player.scorekeeper)
 194                 error("player already has a scorekeeper");
 195         sk = spawn();
 196         sk.owner = player;
 197         sk.SendEntity = PlayerScore_SendEntity;
 198         player.scorekeeper = sk;
 199 }
 200
 201 void PlayerScore_Detach(entity player)
 202 {
 203         if(!player.scorekeeper)
 204                 error("player has no scorekeeper");
 205         remove(player.scorekeeper);
 206         player.scorekeeper = world;
 207 }
 208
 209 void PlayerScore_Add(entity player, float scorefield, float score)
 210 {
 211         entity s;
 212         if(!scores_initialized) return; // FIXME remove this when everything uses this system
 213         s = player.scorekeeper;
 214         if(!s)
 215                 error("Adding score to unknown player!");
 216         s.(scores[scorefield]) += score;
 217         s.Version += 1;
 218 }
 219
 220 void PlayerTeamScore_Add(entity player, float pscorefield, float tscorefield, float score)
 221 {
 222         PlayerScore_Add(player, pscorefield, score);
 223         if(teamscores_entities_count) // only for teamplay
 224                 TeamScore_Add(player, tscorefield, score);
 225 }
 226
 227 float PlayerScore_Compare(entity t1, entity t2)
 228 {
 229         if(!t1 || !t2) return (!t2) - !t1;
 230
 231         vector result;
 232         float i;
 233         for(i = 0; i < MAX_TEAMSCORE; ++i)
 234                 result = ScoreField_Compare(t1, t2, scores[i], scores_flags[i], result);
 235         return result_x;
 236 }
 237
 238 void WinningConditionHelper()
 239 {
 240         float c;
 241         if(teamscores_entities_count)
 242         {
 243                 float t;
 244                 WinningConditionHelper_equality = 1;
 245                 WinningConditionHelper_winnerteam = 0;
 246                 for(t = 1; t < 16; ++t)
 247                 {
 248                         c = TeamScore_Compare(teamscorekeepers[WinningConditionHelper_winnerteam], teamscorekeepers[t]);
 249                         if(c == 0)
 250                                 WinningConditionHelper_equality = 1;
 251                         else if(c < 0)
 252                         {
 253                                 WinningConditionHelper_equality = 0;
 254                                 WinningConditionHelper_winnerteam = t;
 255                         }
 256                 }
 257
 258                 WinningConditionHelper_topscore = teamscorekeepers[WinningConditionHelper_winnerteam].teamscores_primary;
 259
 260                 WinningConditionHelper_winner = world;
 261                 if(WinningConditionHelper_equality)
 262                         WinningConditionHelper_winnerteam = -1;
 263         }
 264         else
 265         {
 266                 entity p;
 267                 WinningConditionHelper_equality = 1;
 268                 WinningConditionHelper_winner = world;
 269                 FOR_EACH_PLAYER(p)
 270                 {
 271                         c = PlayerScore_Compare(WinningConditionHelper_winner.scorekeeper, p.scorekeeper);
 272                         if(c == 0)
 273                                 WinningConditionHelper_equality = 1;
 274                         else if(c < 0)
 275                         {
 276                                 WinningConditionHelper_equality = 0;
 277                                 WinningConditionHelper_winner = p;
 278                         }
 279                 }
 280
 281                 WinningConditionHelper_topscore = WinningConditionHelper_winner.scorekeeper.scores_primary;
 282
 283                 if(WinningConditionHelper_equality)
 284                         WinningConditionHelper_winner = world;
 285                 WinningConditionHelper_winnerteam = -1;
 286         }
 287 }
 288
 289 void Score_DebugPrint()
 290 {
 291         entity p, sk;
 292         float i, t;
 293
 294         print("netname");
 295         for(i = 0; i < MAX_SCORE; ++i)
 296                 print(":", scores_label[i]);
 297         print("\n");
 298         FOR_EACH_PLAYER(p)
 299         {
 300                 sk = p.scorekeeper;
 301                 print(p.netname);
 302                 for(i = 0; i < MAX_SCORE; ++i)
 303                         print(":", ftos(sk.(scores[i])));
 304                 print("\n");
 305         }
 306
 307         print("teamname");
 308         for(i = 0; i < MAX_TEAMSCORE; ++i)
 309                 print(":", teamscores_label[i]);
 310         print("\n");
 311         for(t = 0; t < 16; ++t)
 312         {
 313                 sk = teamscorekeepers[t];
 314                 if(sk)
 315                 {
 316                         print(ftos(t));
 317                         for(i = 0; i < MAX_TEAMSCORE; ++i)
 318                                 print(":", ftos(sk.(teamscores[i])));
 319                         print("\n");
 320                 }
 321         }
 322 }