Merge lp:~armagetronad-ct/armagetronad/0.4-delaycmd into lp:~armagetronad-dev/armagetronad/0.4-armagetronad-work

[Voodoo]

Hey,

I don't know if it worth including it in mainstream but it happens to be a useful feature for servers like ed's onslaught fortress, mayhem or flower power, and it was just a matter of a few minutes to extract it.
This is the delay_command from sty+ct rewritten a while ago for my experiments on scripting (armagetronad-ct branch). It works the exact same way as in sty+ct:
delay_command [r<repeat_delay>] [+-]<start_delay> <command>

The optional + indicates whether start_delay is relative instead of absolute.
The optional - indicates it should be send before game start (absolute time during countdown)
The repeat option was added by kyle later (may be for some wild fortress maps) and is rather self explanatory.

I allows to avoid external scripting in simple cases like timing messages and scoring (onslaught) or sending stages settings (mayhem).

Some typical example:
delay_command 60 center_message 2 minutes left!

delay_command 37 center_message - 3 -
delay_command 38 center_message - 2 -
delay_command 39 center_message - 1 -
delay_command 40 center_message Stage 2 is starting now!
delay_command 40 cycle_speed 50
...

Unmerged revisions

1454. By Voodoo on 2012-10-20

add delay_command to 0.4

=== modified file 'src/tron/gGame.cpp'
--- src/tron/gGame.cpp	2012-08-26 15:53:43 +0000
+++ src/tron/gGame.cpp	2012-10-21 07:50:24 +0000
@@ -759,6 +759,93 @@
 static tSettingItem<bool> sg_ttm("TALK_TO_MASTER",
                                  sg_TalkToMaster);
 
+// *************************
+// ***   delayed commands
+// *************************
+
+class delayedCommands {
+private:
+        static std::map<int, std::set<std::string> > cmd_map;
+        // compute key for std::multimap
+        static int Key(REAL time) {return int(ceil(time*10));};
+public:
+        // clear all delayed commands
+        static void Clear() {
+                cmd_map.clear();
+                con << "Clearing delayed commands ...\n";
+        };
+        // add new delayed commands
+        static void Add(REAL time, std::string cmd, int interval) {
+                std::stringstream store;
+                store << interval << " " << cmd;
+                cmd_map[Key(time)].insert(store.str());
+        };
+        // check, run and remove delayed commands
+        static void Run(REAL currentTime);
+};
+
+std::map<int, std::set<std::string> > delayedCommands::cmd_map;
+
+static void sg_AddDelayedCmd(std::istream &s)
+{
+        // first parse the line to get the param : delay or interval
+        // if the param start by an r then it means we have the interval
+        // if the param start by a +, assume that it's a delay relative to current game time ...
+        int interval=0;
+        tString delay_str;
+        s >> delay_str;
+        if (delay_str.SubStr(0,1)=="r") {
+                interval = atoi(delay_str.SubStr(1));
+                s >> delay_str;
+        }
+        REAL delay = atof(delay_str);
+        if (delay_str.SubStr(0,1)=="+") {
+                REAL gt = se_GameTime();
+                delay += gt;
+        }
+        // this will make sure it using the command if  start time has passed
+        if ((interval > 0) && (se_GameTime() > delay)){
+                REAL ogt = se_GameTime() - delay;
+                int disposition = (ogt/interval)+1;
+                delay = disposition*interval+delay;
+        }
+        tString cmd_str;
+        cmd_str.ReadLine( s, true );
+        if (cmd_str.length()==0) return;
+
+        // add extracted command
+        delayedCommands::Add(delay,cmd_str,interval);
+        //con << "DELAY_COMMAND " << delay << " "<< interval<<" &" << cmd_str.str() << "&\n";
+}
+
+static tConfItemFunc sg_AddDelayedCmd_conf("DELAY_COMMAND",&sg_AddDelayedCmd);
+static tAccessLevelSetter sg_AddDelayedCmdConfLevel( sg_AddDelayedCmd_conf, tAccessLevel_Owner );
+
+void delayedCommands::Run(REAL currentTime) {
+        if (cmd_map.empty()) return;
+        std::map<int, std::set<std::string> >::iterator it = cmd_map.begin();
+        while ((it != cmd_map.end())&&(it->first<=Key(currentTime))) {
+                if (it->first>Key(currentTime-1.0)) {
+                        std::set<std::string>::iterator sit (it->second.begin()), send(it->second.end());
+                        for(;sit!=send;++sit) {
+                                std::istringstream stream(*sit);
+                                int interval;
+                                stream >> interval;
+                                tCurrentAccessLevel elevator( sg_AddDelayedCmd_conf.GetRequiredLevel(), true );
+                                tConfItemBase::LoadAll(stream); // run command if it's not too old, otherwise, just skip it ...
+                                if (interval>0) {
+                                        cmd_map[Key(currentTime+interval)].insert(stream.str());
+                                }
+                        }
+                }
+                cmd_map.erase(it++); // erase current and get next iterator
+        }
+}
+
+// *****************************
+// ***   end delayed commands
+// *****************************
+
 #define PREPARE_TIME 4
 
 static bool just_connected=true;
@@ -3300,6 +3387,8 @@
 
                 Analysis(0);
 
+                delayedCommands::Clear();
+
                 // wait for external script to end its work if needed
                 REAL timeout = tSysTimeFloat() + sg_waitForExternalScriptTimeout;
                 if ( sg_waitForExternalScript )
@@ -4604,6 +4693,8 @@
         }
     }
 
+    delayedCommands::Run(gtime);
+
     static float lastTime = 1e42;
 
     if(sg_gameTimeInterval >= 0 && (gtime >= lastTime + sg_gameTimeInterval || gtime < lastTime)) {