CnC_Remastered_Collection

MPMGRD.CPP (7185B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code 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, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 #include "mpmgrd.h"
 
 extern "C" {
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include "types.h"
 #include "rtq.h"
 #include "services.h"
 }
 #include "mplib.h"
 #include "mplpc.h"
 
 
 #define     STATUS_OK    1
 #define     STATUS_BAD   0
 
 #define     BROADCAST_ADDR    0
 
 typedef struct {
    DWORD      address;
    char       Data[1];
 } packet;
 
 #define min(a,b) (((a) < (b)) ? (a) : (b))
 
 #define     FREEQUEUE            0
 #define     DOSWORKQUEUE         1
 #define     WINWORKQUEUE         2
 #define     WINSENDQUEUE         3
 #define     DOSPENDINGQUEUE      4
 #define     WINWORKQUEUE2        5
 
 // 6, 7, 8, taken up by LPC services
 
 #define     GDOSWORKQUEUE        14
 #define     GWINWORKQUEUE        15
 #define     GWINSENDQUEUE        16
 #define     GDOSPENDINGQUEUE     17
 #define     GWINWORKQUEUE2       18
 
 MPlayerManClass::MPlayerManClass(void) : ConnManClass()
 {
    unsigned  size;
 
    MGenGetMasterNode(&size);
    if (size != sizeof(RTQ_NODE)) {
       exit(-234);
    }
    _myAddr = LPCGetMPAddr();
    _nConnections = 0;
 
    for (int i = 0; i < CONNECT_MAX; i++) {
       _Connections[i] = 0;
       strcpy(_Names[i], "");
    }
 }
 
 // here's what we do to get private & broadcasts over the same chunnel
 // we package up an extra dword at the beginning to indicate the address
 
 int
 MPlayerManClass::Send_Private_Message(void *buf,
                                       int buflen,
                                       int /* ack_req */,
                                       int conn_id)
 {
    RTQ_NODE *n;
 	int idx = Connection_Index(conn_id);
 
 	if (_nConnections == 0) {
 		return (STATUS_OK);
 	}
 
    while ((n = MGenMoveTo(FREEQUEUE, DOSWORKQUEUE)) == 0);
 
    packet *p = (packet *) n->rtqDatum;
 
    if (conn_id == CONNECTION_NONE) {
       p->address = BROADCAST_ADDR;
    } else {
       p->address = _Connections[idx];
    }
 
    memcpy(p->Data, buf, buflen);
    n->rtqUpCtr = (WORD)(buflen + sizeof(DWORD));
 
    MGenMoveTo(DOSWORKQUEUE, WINSENDQUEUE);
    PostWindowsMessage();
    Yield();
 
    return STATUS_OK;
 }
 
 int
 MPlayerManClass::Get_Private_Message(void *buf, int *buflen,
                                      int *conn_id)
 {
    RTQ_NODE *n;
 	int i;
 
    if ((n = MGenMoveTo(DOSPENDINGQUEUE, DOSWORKQUEUE)) == 0) {
       *buflen = 0;
       return 0;
    }
 
    packet *p = (packet *) n->rtqDatum;
 
    int lentocpy = n->rtqUpCtr - sizeof(DWORD);
 
    *conn_id = CONNECTION_NONE;
 	for (i = 0; i < _nConnections; i++) {
 		if (p->address == _Connections[i]) {
 			(*conn_id) = _ID[i];
 			break;
 		}
 	}
 
    memcpy(buf, p->Data, lentocpy);
 
    *buflen = lentocpy;
 
    MGenMoveTo(DOSWORKQUEUE, FREEQUEUE);
 
    return STATUS_OK;
 }
 
 int
 MPlayerManClass::Send_Global_Message(void *buf, int buflen, int /*ack_req*/,
    int address)
 {
    RTQ_NODE *n;
 
    while ((n = MGenMoveTo(FREEQUEUE, DOSWORKQUEUE)) == 0);
 
    packet *p = (packet *) n->rtqDatum;
 
    if (address == 0) {
       p->address = BROADCAST_ADDR;
    } else {
       p->address = address;
    }
 
    memcpy(p->Data, buf, buflen);
    n->rtqUpCtr = (WORD)(buflen + sizeof(DWORD));
 
    MGenMoveTo(DOSWORKQUEUE, GWINSENDQUEUE);
    PostWindowsMessage();
    Yield();
 
    return STATUS_OK;
 }
 
 int
 MPlayerManClass::Get_Global_Message(void *buf, int *buflen, int *address)
 {
    RTQ_NODE *n;
 
    if ((n = MGenMoveTo(GDOSPENDINGQUEUE, DOSWORKQUEUE)) == 0) {
       *buflen = 0;
       return 0;
    }
 
    packet *p = (packet *) n->rtqDatum;
 
    int lentocpy = n->rtqUpCtr - sizeof(DWORD);
 
    if (address) {
       if (p->address == BROADCAST_ADDR) {
          *address = 0;
       } else {
          *address = p->address;
       }
    }
 
    memcpy(buf, p->Data, lentocpy);
 
    *buflen = lentocpy;
 
    MGenMoveTo(DOSWORKQUEUE, FREEQUEUE);
 
    return STATUS_OK;
 }
 
 int
 MPlayerManClass::Service(void)
 {
    return STATUS_OK;
 }
 
 int
 MPlayerManClass::Create_Connection(int id, char *name, int address)
 {
    _Connections[_nConnections] = address;
 	_ID[_nConnections] = id;
    strcpy(_Names[_nConnections], name);
    _nConnections++;
    return STATUS_OK;
 }
 
 int
 MPlayerManClass::Delete_Connection(int id)
 {
 	int i;
 	int idx = Connection_Index(id);
 	if (idx == -1)
 		return 0;
 
 	for (i = idx; i < _nConnections - 1; i++) {
 		_Connections[i] = _Connections[i+1];
 		_ID[i] = _ID[i+1];
 		strcpy (_Names[i], _Names[i+1]);
 	}
    _nConnections--;
    return STATUS_OK;
 }
 
 char *
 MPlayerManClass::Connection_Name(int id)
 {
 	int idx = Connection_Index(id);
 	if (idx==-1) {
 		return (NULL);
 	}
 
    return _Names[idx];
 }
 
 int
 MPlayerManClass::Connection_Address(int id)
 {
 	int idx = Connection_Index(id);
 	if (idx==-1) {
 		return (0);
 	}
 
    return _Connections[idx];
 }
 
 int
 MPlayerManClass::Num_Connections(void)
 {
    return _nConnections;
 }
 
 int
 MPlayerManClass::Connection_ID(int index)
 {
    return _ID[index];
 }
 
 int
 MPlayerManClass::Connection_Index(int id)
 {
 	int i;
 
 	for (i = 0; i < _nConnections; i++) {
 		if (_ID[i] == id) {
 			return i;
 		}
 	}
 
    return -1;
 }
 
 int
 MPlayerManClass::Global_Num_Send(void)
 {
    return 0;
 }
 
 int
 MPlayerManClass::Global_Num_Receive(void)
 {
    return MGenGetQueueCtr(GDOSPENDINGQUEUE);
 }
 
 int
 MPlayerManClass::Private_Num_Send(int /*id*/)
 {
    return 0;
 }
 
 int
 MPlayerManClass::Private_Num_Receive(int /*id*/)
 {
    return MGenGetQueueCtr(DOSPENDINGQUEUE);
 }
 
 void
 MPlayerManClass::Reset_Response_Time(void)
 {
    // unsupported
 }
 
 unsigned long
 MPlayerManClass::Response_Time(void)
 {
    return (160 * 60) / 1000;   // 160 microseconds one way (9 ticks)
 }
 
 void
 MPlayerManClass::Set_Timing(unsigned long /*retrydelta*/,
                             unsigned long /*maxretries*/,
                             unsigned long /*timeout*/)
 {
    // unsupported
 }
 
 void
 MPlayerManClass::Configure_Debug(int /*index*/, int /*type_offset*/,
                                  int /*type_size*/, char ** /*names*/,
                                  int /*namestart*/, int /*namecount*/)
 {
    // unsupported
 }
 
 void
 MPlayerManClass::Mono_Debug_Print(int /*index*/, int /*refresh*/)
 {
    // unsupported
 }
 
 int
 MPlayerManClass::Init(void)
 {
    return STATUS_OK;
 }
 
 int MPlayerManClass::Find_Num_Connections(void)
 {
 	TGAMEDEF game_def;
 	int sz = sizeof(game_def);
 
 	GetGameDef(&game_def, &sz);
 
 	return (game_def.numPlayers - 1);
 
 }
 
 
 void MPlayerManClass::Flush_All(void)
 {
 	MGenFlushNodes(DOSPENDINGQUEUE, FREEQUEUE);
 	MGenFlushNodes(GDOSPENDINGQUEUE, FREEQUEUE);
 }