Merge branch 'master' into Mario/stats_eloranking
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / round_handler.qc
1 #include "round_handler.qh"
2
3 #include <server/defs.qh>
4 #include <server/miscfunctions.qh>
5 #include "campaign.qh"
6 #include "command/vote.qh"
7 #include "../common/util.qh"
8
9 void round_handler_Think(entity this)
10 {
11         if (intermission_running)
12         {
13                 round_handler_Reset(0);
14                 round_handler_Remove();
15                 return;
16         }
17
18         if (time < game_starttime)
19         {
20                 round_handler_Reset(game_starttime);
21                 return;
22         }
23
24         game_stopped = false;
25
26         if (this.wait)
27         {
28                 this.wait = false;
29                 this.cnt = this.count + 1;  // init countdown
30                 round_starttime = time + this.count;
31                 reset_map(true);
32         }
33
34         if (this.cnt > 0)  // countdown running
35         {
36                 if (this.canRoundStart() && !(autocvar_g_campaign && !campaign_bots_may_start))
37                 {
38                         if (this.cnt == this.count + 1) round_starttime = time + this.count;
39                         int f = this.cnt - 1;
40                         if (f == 0)
41                         {
42                                 this.cnt = 0;
43                                 this.round_endtime = (this.round_timelimit) ? time + this.round_timelimit : 0;
44                                 this.nextthink = time;
45                                 if (this.roundStart) this.roundStart();
46                                 return;
47                         }
48                         this.cnt = this.cnt - 1;
49                 }
50                 else
51                 {
52                         round_handler_Reset(0);
53                 }
54                 this.nextthink = time + 1;  // canRoundStart every second
55         }
56         else
57         {
58                 if (this.canRoundEnd())
59                 {
60                         // schedule a new round
61                         this.wait = true;
62                         this.nextthink = time + this.delay;
63                 }
64                 else
65                 {
66                         this.nextthink = time;  // canRoundEnd every frame
67                 }
68         }
69 }
70
71 void round_handler_Init(float the_delay, float the_count, float the_round_timelimit)
72 {
73         entity this = round_handler;
74         this.delay = (the_delay > 0) ? the_delay : 0;
75         this.count = fabs(floor(the_count));
76         this.cnt = this.count + 1;
77         this.round_timelimit = (the_round_timelimit > 0) ? the_round_timelimit : 0;
78 }
79
80 // NOTE: this is only needed because if round_handler spawns at time 1
81 // game_starttime isn't initialized yet
82 void round_handler_FirstThink(entity this)
83 {
84         round_starttime = max(time, game_starttime) + this.count;
85         setthink(this, round_handler_Think);
86         this.nextthink = max(time, game_starttime);
87 }
88
89 void round_handler_Spawn(bool() canRoundStart_func, bool() canRoundEnd_func, void() roundStart_func)
90 {
91         if (round_handler)
92         {
93                 backtrace("Can't spawn round_handler again!");
94                 return;
95         }
96         entity this = round_handler = new(round_handler);
97
98         setthink(this, round_handler_FirstThink);
99         this.canRoundStart = canRoundStart_func;
100         this.canRoundEnd = canRoundEnd_func;
101         this.roundStart = roundStart_func;
102         this.wait = false;
103         round_handler_Init(5, 5, 180);
104         this.nextthink = time;
105 }
106
107 void round_handler_Reset(float next_think)
108 {
109         entity this = round_handler;
110         this.wait = false;
111         if (this.count)
112                 if (this.cnt < this.count + 1) this.cnt = this.count + 1;
113         this.nextthink = next_think;
114         round_starttime = (next_think) ? (next_think + this.count) : -1;
115 }
116
117 void round_handler_Remove()
118 {
119         delete(round_handler);
120         round_handler = NULL;
121 }