network_command.cpp

Go to the documentation of this file.
00001 /* $Id: network_command.cpp 25770 2013-09-14 11:34:09Z rubidium $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
00008  */
00009 
00012 #ifdef ENABLE_NETWORK
00013 
00014 #include "../stdafx.h"
00015 #include "network_admin.h"
00016 #include "network_client.h"
00017 #include "network_server.h"
00018 #include "../command_func.h"
00019 #include "../company_func.h"
00020 #include "../settings_type.h"
00021 
00023 static CommandCallback * const _callback_table[] = {
00024   /* 0x00 */ NULL,
00025   /* 0x01 */ CcBuildPrimaryVehicle,
00026   /* 0x02 */ CcBuildAirport,
00027   /* 0x03 */ CcBuildBridge,
00028   /* 0x04 */ CcBuildCanal,
00029   /* 0x05 */ CcBuildDocks,
00030   /* 0x06 */ CcFoundTown,
00031   /* 0x07 */ CcBuildRoadTunnel,
00032   /* 0x08 */ CcBuildRailTunnel,
00033   /* 0x09 */ CcBuildWagon,
00034   /* 0x0A */ CcRoadDepot,
00035   /* 0x0B */ CcRailDepot,
00036   /* 0x0C */ CcPlaceSign,
00037   /* 0x0D */ CcPlaySound10,
00038   /* 0x0E */ CcPlaySound1D,
00039   /* 0x0F */ CcPlaySound1E,
00040   /* 0x10 */ CcStation,
00041   /* 0x11 */ CcTerraform,
00042   /* 0x12 */ CcAI,
00043   /* 0x13 */ CcCloneVehicle,
00044   /* 0x14 */ CcGiveMoney,
00045   /* 0x15 */ CcCreateGroup,
00046   /* 0x16 */ CcFoundRandomTown,
00047   /* 0x17 */ CcRoadStop,
00048   /* 0x18 */ CcBuildIndustry,
00049   /* 0x19 */ CcStartStopVehicle,
00050   /* 0x1A */ CcGame,
00051   /* 0x1B */ CcAddVehicleNewGroup,
00052 };
00053 
00059 void CommandQueue::Append(CommandPacket *p)
00060 {
00061   CommandPacket *add = MallocT<CommandPacket>(1);
00062   *add = *p;
00063   add->next = NULL;
00064   if (this->first == NULL) {
00065     this->first = add;
00066   } else {
00067     this->last->next = add;
00068   }
00069   this->last = add;
00070   this->count++;
00071 }
00072 
00078 CommandPacket *CommandQueue::Pop(bool ignore_paused)
00079 {
00080   CommandPacket **prev = &this->first;
00081   CommandPacket *ret = this->first;
00082   CommandPacket *prev_item = NULL;
00083   if (ignore_paused && _pause_mode != PM_UNPAUSED) {
00084     while (ret != NULL && !IsCommandAllowedWhilePaused(ret->cmd)) {
00085       prev_item = ret;
00086       prev = &ret->next;
00087       ret = ret->next;
00088     }
00089   }
00090   if (ret != NULL) {
00091     if (ret == this->last) this->last = prev_item;
00092     *prev = ret->next;
00093     this->count--;
00094   }
00095   return ret;
00096 }
00097 
00103 CommandPacket *CommandQueue::Peek(bool ignore_paused)
00104 {
00105   if (!ignore_paused || _pause_mode == PM_UNPAUSED) return this->first;
00106 
00107   for (CommandPacket *p = this->first; p != NULL; p = p->next) {
00108     if (IsCommandAllowedWhilePaused(p->cmd)) return p;
00109   }
00110   return NULL;
00111 }
00112 
00114 void CommandQueue::Free()
00115 {
00116   CommandPacket *cp;
00117   while ((cp = this->Pop()) != NULL) {
00118     free(cp);
00119   }
00120   assert(this->count == 0);
00121 }
00122 
00124 static CommandQueue _local_wait_queue;
00126 static CommandQueue _local_execution_queue;
00127 
00138 void NetworkSendCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, CompanyID company)
00139 {
00140   assert((cmd & CMD_FLAGS_MASK) == 0);
00141 
00142   CommandPacket c;
00143   c.company  = company;
00144   c.tile     = tile;
00145   c.p1       = p1;
00146   c.p2       = p2;
00147   c.cmd      = cmd;
00148   c.callback = callback;
00149 
00150   strecpy(c.text, (text != NULL) ? text : "", lastof(c.text));
00151 
00152   if (_network_server) {
00153     /* If we are the server, we queue the command in our 'special' queue.
00154      *   In theory, we could execute the command right away, but then the
00155      *   client on the server can do everything 1 tick faster than others.
00156      *   So to keep the game fair, we delay the command with 1 tick
00157      *   which gives about the same speed as most clients.
00158      */
00159     c.frame = _frame_counter_max + 1;
00160     c.my_cmd = true;
00161 
00162     _local_wait_queue.Append(&c);
00163     return;
00164   }
00165 
00166   c.frame = 0; // The client can't tell which frame, so just make it 0
00167 
00168   /* Clients send their command to the server and forget all about the packet */
00169   MyClient::SendCommand(&c);
00170 }
00171 
00181 void NetworkSyncCommandQueue(NetworkClientSocket *cs)
00182 {
00183   for (CommandPacket *p = _local_execution_queue.Peek(); p != NULL; p = p->next) {
00184     CommandPacket c = *p;
00185     c.callback = 0;
00186     cs->outgoing_queue.Append(&c);
00187   }
00188 }
00189 
00193 void NetworkExecuteLocalCommandQueue()
00194 {
00195   assert(IsLocalCompany());
00196 
00197   CommandQueue &queue = (_network_server ? _local_execution_queue : ClientNetworkGameSocketHandler::my_client->incoming_queue);
00198 
00199   CommandPacket *cp;
00200   while ((cp = queue.Peek()) != NULL) {
00201     /* The queue is always in order, which means
00202      * that the first element will be executed first. */
00203     if (_frame_counter < cp->frame) break;
00204 
00205     if (_frame_counter > cp->frame) {
00206       /* If we reach here, it means for whatever reason, we've already executed
00207        * past the command we need to execute. */
00208       error("[net] Trying to execute a packet in the past!");
00209     }
00210 
00211     /* We can execute this command */
00212     _current_company = cp->company;
00213     cp->cmd |= CMD_NETWORK_COMMAND;
00214     DoCommandP(cp, cp->my_cmd);
00215 
00216     queue.Pop();
00217     free(cp);
00218   }
00219 
00220   /* Local company may have changed, so we should not restore the old value */
00221   _current_company = _local_company;
00222 }
00223 
00227 void NetworkFreeLocalCommandQueue()
00228 {
00229   _local_wait_queue.Free();
00230   _local_execution_queue.Free();
00231 }
00232 
00238 static void DistributeCommandPacket(CommandPacket &cp, const NetworkClientSocket *owner)
00239 {
00240   CommandCallback *callback = cp.callback;
00241   cp.frame = _frame_counter_max + 1;
00242 
00243   NetworkClientSocket *cs;
00244   FOR_ALL_CLIENT_SOCKETS(cs) {
00245     if (cs->status >= NetworkClientSocket::STATUS_MAP) {
00246       /* Callbacks are only send back to the client who sent them in the
00247        *  first place. This filters that out. */
00248       cp.callback = (cs != owner) ? NULL : callback;
00249       cp.my_cmd = (cs == owner);
00250       cs->outgoing_queue.Append(&cp);
00251     }
00252   }
00253 
00254   cp.callback = (cs != owner) ? NULL : callback;
00255   cp.my_cmd = (cs == owner);
00256   _local_execution_queue.Append(&cp);
00257 }
00258 
00264 static void DistributeQueue(CommandQueue *queue, const NetworkClientSocket *owner)
00265 {
00266 #ifdef DEBUG_DUMP_COMMANDS
00267   /* When replaying we do not want this limitation. */
00268   int to_go = UINT16_MAX;
00269 #else
00270   int to_go = _settings_client.network.commands_per_frame;
00271 #endif
00272 
00273   CommandPacket *cp;
00274   while (--to_go >= 0 && (cp = queue->Pop(true)) != NULL) {
00275     DistributeCommandPacket(*cp, owner);
00276     NetworkAdminCmdLogging(owner, cp);
00277     free(cp);
00278   }
00279 }
00280 
00282 void NetworkDistributeCommands()
00283 {
00284   /* First send the server's commands. */
00285   DistributeQueue(&_local_wait_queue, NULL);
00286 
00287   /* Then send the queues of the others. */
00288   NetworkClientSocket *cs;
00289   FOR_ALL_CLIENT_SOCKETS(cs) {
00290     DistributeQueue(&cs->incoming_queue, cs);
00291   }
00292 }
00293 
00300 const char *NetworkGameSocketHandler::ReceiveCommand(Packet *p, CommandPacket *cp)
00301 {
00302   cp->company = (CompanyID)p->Recv_uint8();
00303   cp->cmd     = p->Recv_uint32();
00304   if (!IsValidCommand(cp->cmd))               return "invalid command";
00305   if (GetCommandFlags(cp->cmd) & CMD_OFFLINE) return "offline only command";
00306   if ((cp->cmd & CMD_FLAGS_MASK) != 0)        return "invalid command flag";
00307 
00308   cp->p1      = p->Recv_uint32();
00309   cp->p2      = p->Recv_uint32();
00310   cp->tile    = p->Recv_uint32();
00311   p->Recv_string(cp->text, lengthof(cp->text), (!_network_server && GetCommandFlags(cp->cmd) & CMD_STR_CTRL) != 0 ? SVS_ALLOW_CONTROL_CODE | SVS_REPLACE_WITH_QUESTION_MARK : SVS_REPLACE_WITH_QUESTION_MARK);
00312 
00313   byte callback = p->Recv_uint8();
00314   if (callback >= lengthof(_callback_table))  return "invalid callback";
00315 
00316   cp->callback = _callback_table[callback];
00317   return NULL;
00318 }
00319 
00325 void NetworkGameSocketHandler::SendCommand(Packet *p, const CommandPacket *cp)
00326 {
00327   p->Send_uint8 (cp->company);
00328   p->Send_uint32(cp->cmd);
00329   p->Send_uint32(cp->p1);
00330   p->Send_uint32(cp->p2);
00331   p->Send_uint32(cp->tile);
00332   p->Send_string(cp->text);
00333 
00334   byte callback = 0;
00335   while (callback < lengthof(_callback_table) && _callback_table[callback] != cp->callback) {
00336     callback++;
00337   }
00338 
00339   if (callback == lengthof(_callback_table)) {
00340     DEBUG(net, 0, "Unknown callback. (Pointer: %p) No callback sent", cp->callback);
00341     callback = 0; // _callback_table[0] == NULL
00342   }
00343   p->Send_uint8 (callback);
00344 }
00345 
00346 #endif /* ENABLE_NETWORK */