mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-29 01:42:27 +12:00
fd05be35c1
DLL version incremented Beacon functionality added Support for loading screen match preview display Placeholder handling of new key-bindable mod commands
799 lines
36 KiB
C++
799 lines
36 KiB
C++
//
|
|
// 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
|
|
|
|
/* $Header: F:\projects\c&c\vcs\code\event.cpv 2.17 16 Oct 1995 16:50:28 JOE_BOSTIC $ */
|
|
/***********************************************************************************************
|
|
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
|
***********************************************************************************************
|
|
* *
|
|
* Project Name : Command & Conquer *
|
|
* *
|
|
* File Name : EVENT.CPP *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : 12/09/94 *
|
|
* *
|
|
* Last Update : June 25, 1995 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* EventClass::EventClass -- Construct an id and cell based event. *
|
|
* EventClass::EventClass -- Construct simple target type event. *
|
|
* EventClass::EventClass -- Constructor for mission change events. *
|
|
* EventClass::EventClass -- Constructor for navigation computer events. *
|
|
* EventClass::EventClass -- Constructor for object types affecting cells event. *
|
|
* EventClass::EventClass -- Constructor for sidebar build events. *
|
|
* EventClass::EventClass -- Constructs event to transfer special flags. *
|
|
* EventClass::EventClass -- Default constructor for event objects. *
|
|
* EventClass::EventClass -- Event for sequencing animations. *
|
|
* EventClass::EventClass -- Megamission assigned to unit. *
|
|
* EventClass::Execute -- Execute a queued command. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "function.h"
|
|
#include "ccdde.h"
|
|
|
|
/***************************************************************************
|
|
** Table of what data is really used in the EventClass struct for different
|
|
** events. This table must be kept current with the EventType enum.
|
|
*/
|
|
unsigned char EventClass::EventLength[EventClass::LAST_EVENT] = {
|
|
0, // EMPTY
|
|
size_of(EventClass, Data.General ), // ALLY
|
|
size_of(EventClass, Data.MegaMission ), // MEGAMISSION
|
|
size_of(EventClass, Data.Target ), // IDLE
|
|
size_of(EventClass, Data.Target ), // SCATTER
|
|
0, // DESTRUCT
|
|
0, // DEPLOY
|
|
size_of(EventClass, Data.Place ), // PLACE
|
|
0, // OPTIONS
|
|
size_of(EventClass, Data.General ), // GAMESPEED
|
|
size_of(EventClass, Data.Specific ), // PRODUCE
|
|
size_of(EventClass, Data.Specific.Type ), // SUSPEND
|
|
size_of(EventClass, Data.Specific.Type ), // ABANDON
|
|
size_of(EventClass, Data.Target ), // PRIMARY
|
|
size_of(EventClass, Data.Special ), // SPECIAL_PLACE
|
|
0, // EXIT
|
|
size_of(EventClass, Data.Anim ), // ANIMATION
|
|
size_of(EventClass, Data.Target ), // REPAIR
|
|
size_of(EventClass, Data.Target ), // SELL
|
|
size_of(EventClass, Data.Options ), // SPECIAL
|
|
0, // FRAMESYNC
|
|
0, // MESSAGE
|
|
size_of(EventClass, Data.FrameInfo.Delay ), // RESPONSE_TIME
|
|
size_of(EventClass, Data.FrameInfo ), // FRAMEINFO
|
|
size_of(EventClass, Data.NavCom ), // ARCHIVE
|
|
size_of(EventClass, Data.Timing ), // TIMING
|
|
size_of(EventClass, Data.ProcessTime ), // PROCESS_TIME
|
|
};
|
|
|
|
char * EventClass::EventNames[EventClass::LAST_EVENT] = {
|
|
"EMPTY",
|
|
"ALLY",
|
|
"MEGAMISSION",
|
|
"IDLE",
|
|
"SCATTER",
|
|
"DESTRUCT",
|
|
"DEPLOY",
|
|
"PLACE",
|
|
"OPTIONS",
|
|
"GAMESPEED",
|
|
"PRODUCE",
|
|
"SUSPEND",
|
|
"ABANDON",
|
|
"PRIMARY",
|
|
"SPECIAL_PLACE",
|
|
"EXIT",
|
|
"ANIMATION",
|
|
"REPAIR",
|
|
"SELL",
|
|
"SPECIAL",
|
|
"FRAMESYNC",
|
|
"MESSAGE",
|
|
"RESPONSE_TIME",
|
|
"FRAMEINFO",
|
|
"ARCHIVE",
|
|
"TIMING",
|
|
"PROCESS_TIME",
|
|
};
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructs event to transfer special flags. *
|
|
* *
|
|
* This constructs an event that will transfer the special flags. *
|
|
* *
|
|
* INPUT: data -- The special flags to be transported to all linked computers. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 06/25/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(SpecialClass data)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = SPECIAL;
|
|
Frame = ::Frame;
|
|
Data.Options.Data = data;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Construct simple target type event. *
|
|
* *
|
|
* This will construct a generic event that needs only a target parameter. The actual *
|
|
* event and target values are specified as parameters. *
|
|
* *
|
|
* INPUT: type -- The event type to construct. *
|
|
* *
|
|
* target-- The target value that this event is to apply to. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 06/25/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, TARGET target)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Target.Whom = target;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Default constructor for event objects. *
|
|
* *
|
|
* This constructs a simple event object that requires no parameters other than the *
|
|
* type of event it is. *
|
|
* *
|
|
* INPUT: type -- The type of event to construct. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for general-purpose-data events. *
|
|
* *
|
|
* INPUT: type -- The type of event to construct. *
|
|
* val -- data value *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, int val)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Data.General.Value = val;
|
|
Frame = ::Frame;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for navigation computer events. *
|
|
* *
|
|
* Constructor for events that are used to assign the navigation computer. *
|
|
* *
|
|
* INPUT: type -- The type of event (this constructor can be used by other navigation *
|
|
* type events). *
|
|
* *
|
|
* src -- The object that the event should apply to. *
|
|
* *
|
|
* dest -- The destination (or target) that the event needs to complete. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, TARGET src, TARGET dest)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.NavCom.Whom = src;
|
|
Data.NavCom.Where = dest;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Event for sequencing animations. *
|
|
* *
|
|
* This constructor is used for animations that must be created through the event system. *
|
|
* *
|
|
* INPUT: anim -- The animation that will be created. *
|
|
* *
|
|
* coord -- The location where the animation is to be created. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/19/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(AnimType anim, HousesType owner, COORDINATE coord, int visible)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = ANIMATION;
|
|
Frame = ::Frame;
|
|
Data.Anim.What = anim;
|
|
Data.Anim.Owner = owner;
|
|
Data.Anim.Where = coord;
|
|
Data.Anim.Visible = visible;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Megamission assigned to unit. *
|
|
* *
|
|
* This is the event that is used to assign most missions to units. It combines both the *
|
|
* mission and the target (navcom and tarcom). *
|
|
* *
|
|
* INPUT: src -- The object that this mission is to apply to. *
|
|
* *
|
|
* mission -- The mission to assign to this object. *
|
|
* *
|
|
* target -- The target to assign to this object's TarCom. *
|
|
* *
|
|
* destination -- The destination to assign to this object's NavCom. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(TARGET src, MissionType mission, TARGET target, TARGET destination)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = MEGAMISSION;
|
|
Frame = ::Frame;
|
|
Data.MegaMission.Whom = src;
|
|
Data.MegaMission.Mission = mission;
|
|
Data.MegaMission.Target = target;
|
|
Data.MegaMission.Destination = destination;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for sidebar build events. *
|
|
* *
|
|
* This constructor is used for events that deal with an object type and an object ID. *
|
|
* Typically, this is used exclusively by the sidebar. *
|
|
* *
|
|
* INPUT: type -- The event type of this object. *
|
|
* *
|
|
* object -- The object type number. *
|
|
* *
|
|
* id -- The object sub-type number. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, RTTIType object, int id)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Specific.Type = object;
|
|
Data.Specific.ID = id;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for object types affecting cells event. *
|
|
* *
|
|
* This constructor is used for those events that have an object type and associated cell. *
|
|
* Typically, this is for building placement after construction has completed. *
|
|
* *
|
|
* INPUT: type -- The event type for this object. *
|
|
* *
|
|
* object -- The object type number (actual object is probably inferred from the *
|
|
* sidebar data). *
|
|
* *
|
|
* cell -- The cell location where this event is to occur. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, RTTIType object, CELL cell)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Place.Type = object;
|
|
Data.Place.Cell = cell;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Construct an id and cell based event. *
|
|
* *
|
|
* This constructor is used for those events that require an ID number and a cell location. *
|
|
* *
|
|
* INPUT: type -- The event type this will be. *
|
|
* *
|
|
* id -- The arbitrary id number to assign. *
|
|
* *
|
|
* cell -- The location for this event. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, int id, CELL cell)
|
|
{
|
|
ID = Houses.ID(PlayerPtr);
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Special.ID = id;
|
|
Data.Special.Cell = cell;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::Execute -- Execute a queued command. *
|
|
* *
|
|
* This routine executes an event. The even must already have been confirmed by any *
|
|
* remote machine before calling this routine. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void EventClass::Execute(void)
|
|
{
|
|
TechnoClass * techno;
|
|
AnimClass * anim = 0;
|
|
HouseClass * house = 0;
|
|
char txt[80];
|
|
int i;
|
|
//#if (0)
|
|
if (Type < 0 || Type > PROCESS_TIME){
|
|
char tempbuf[128];
|
|
sprintf (tempbuf, "Packet type %d received\n", Type);
|
|
CCDebugString (tempbuf);
|
|
|
|
sprintf (tempbuf, " ID = %d\n", ID);
|
|
CCDebugString (tempbuf);
|
|
|
|
sprintf (tempbuf, " Frame = %d\n", Frame);
|
|
CCDebugString (tempbuf);
|
|
|
|
sprintf (tempbuf, " MPlayer ID = %d\n", MPlayerID);
|
|
CCDebugString (tempbuf);
|
|
|
|
}
|
|
//#endif //(0)
|
|
|
|
|
|
switch (Type) {
|
|
/*
|
|
** Update the archive target for this building.
|
|
*/
|
|
case ARCHIVE:
|
|
techno = As_Techno(Data.NavCom.Whom);
|
|
if (techno && techno->IsActive) {
|
|
techno->ArchiveTarget = Data.NavCom.Where;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Make or break alliance.
|
|
*/
|
|
case ALLY:
|
|
house = Houses.Raw_Ptr(Data.General.Value);
|
|
if (Houses.Raw_Ptr(ID)->Is_Ally(house)) {
|
|
Houses.Raw_Ptr(ID)->Make_Enemy((HousesType)Data.General.Value);
|
|
} else {
|
|
Houses.Raw_Ptr(ID)->Make_Ally((HousesType)Data.General.Value);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Special self destruct action requested. This is active in the multiplayer mode.
|
|
*/
|
|
case DESTRUCT:
|
|
CCDebugString ("C&C95 - Resignation packet received\n");
|
|
Houses.Raw_Ptr(ID)->Flag_To_Die();
|
|
Houses.Raw_Ptr(ID)->Resigned = true;
|
|
break;
|
|
|
|
/*
|
|
** Update the special control flags. This is necessary so that in a multiplay
|
|
** game, all machines will agree on the rules. If these options change during
|
|
** game play, then all players are informed that options have changed.
|
|
*/
|
|
case SPECIAL:
|
|
{
|
|
Special = Data.Options.Data;
|
|
HouseClass * house = Houses.Raw_Ptr(ID);
|
|
|
|
sprintf(txt, Text_String(TXT_SPECIAL_WARNING), house->Name);
|
|
Messages.Add_Message(txt, MPlayerTColors[house->RemapColor],
|
|
TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, 1200, 0, 0);
|
|
Map.Flag_To_Redraw(false);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Starts or stops repair on the specified object. This event is triggered by the
|
|
** player clicking the repair wrench on a building.
|
|
*/
|
|
case REPAIR:
|
|
CCDebugString ("C&C95 - Repair packet received\n");
|
|
techno = As_Techno(Data.Target.Whom);
|
|
if (techno && techno->IsActive) {
|
|
techno->Repair(-1);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Tells a building/unit to sell. This event is triggered by the player clicking the
|
|
** sell animating cursor over the building or unit.
|
|
*/
|
|
case SELL:
|
|
CCDebugString ("C&C95 - Sell packet received\n");
|
|
techno = As_Techno(Data.Target.Whom);
|
|
if (techno && techno->IsActive && techno->House == Houses.Raw_Ptr(ID)) {
|
|
techno->Sell_Back(-1);
|
|
} else {
|
|
if (Is_Target_Cell(Data.Target.Whom)) {
|
|
Houses.Raw_Ptr(ID)->Sell_Wall(As_Cell(Data.Target.Whom));
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** This even is used to trigger an animation that is generated as a direct
|
|
** result of player intervention.
|
|
*/
|
|
case ANIMATION:
|
|
anim = new AnimClass(Data.Anim.What, Data.Anim.Where);
|
|
if (anim) {
|
|
anim->Set_Owner(Data.Anim.Owner);
|
|
|
|
if (Special.IsVisibleTarget)
|
|
{
|
|
anim->Set_Visible_Flags(static_cast<unsigned int>(-1));
|
|
}
|
|
else
|
|
{
|
|
anim->Set_Visible_Flags(static_cast<unsigned int>(Data.Anim.Visible));
|
|
}
|
|
|
|
/*
|
|
** Beacons have a 30-second kill time.
|
|
*/
|
|
if (Data.Anim.What == ANIM_BEACON) {
|
|
FILETIME ft;
|
|
GetSystemTimeAsFileTime(&ft);
|
|
|
|
unsigned long long kill_time = ((unsigned long long)ft.dwLowDateTime + ((unsigned long long)ft.dwHighDateTime << 32ULL)) + 300000000ULL;
|
|
anim->Kill_At(kill_time);
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** This event will place the specified object at the specified location.
|
|
** The event is used to place newly constructed buildings down on the map. The
|
|
** object type is specified. From this object type, the house can determine the
|
|
** exact factory and real object pointer to use.
|
|
*/
|
|
case PLACE:
|
|
CCDebugString ("C&C95 - Place packet received\n");
|
|
Houses.Raw_Ptr(ID)->Place_Object(Data.Place.Type, Data.Place.Cell);
|
|
break;
|
|
|
|
/*
|
|
** This event starts production of the speicified object type. The house can
|
|
** determine from the type and ID value, what object to begin production on and
|
|
** what factory to use.
|
|
*/
|
|
case PRODUCE:
|
|
CCDebugString ("C&C95 - Produce packet received\n");
|
|
Houses.Raw_Ptr(ID)->Begin_Production(Data.Specific.Type, Data.Specific.ID);
|
|
break;
|
|
|
|
/*
|
|
** This event is generated when the player puts production on hold. From the
|
|
** object type, the factory can be inferred.
|
|
*/
|
|
case SUSPEND:
|
|
CCDebugString ("C&C95 - Suspend packet received\n");
|
|
Houses.Raw_Ptr(ID)->Suspend_Production(Data.Specific.Type);
|
|
break;
|
|
|
|
/*
|
|
** This event is generated when the player cancels production of the specified
|
|
** object type. From the object type, the exact factory can be inferred.
|
|
*/
|
|
case ABANDON:
|
|
CCDebugString ("C&C95 - Abandon packet received\n");
|
|
Houses.Raw_Ptr(ID)->Abandon_Production(Data.Specific.Type);
|
|
break;
|
|
|
|
/*
|
|
** Toggles the primary factory state of the specified building.
|
|
*/
|
|
case PRIMARY:{
|
|
CCDebugString ("C&C95 - Primary building packet received\n");
|
|
BuildingClass * building = As_Building(Data.Target.Whom);
|
|
if (building && building->IsActive) {
|
|
building->Toggle_Primary();
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** This is the general purpose mission control event. Most player
|
|
** action routes through this event. It sets a unit's mission, TarCom,
|
|
** and NavCom to the values specified.
|
|
*/
|
|
case MEGAMISSION:
|
|
techno = As_Techno(Data.MegaMission.Whom);
|
|
if (techno && techno->IsActive) {
|
|
|
|
/*
|
|
** Fetch a pointer to the object of the mission.
|
|
*/
|
|
ObjectClass * object;
|
|
if (Target_Legal(Data.MegaMission.Target)) {
|
|
object = As_Object(Data.MegaMission.Target);
|
|
} else {
|
|
object = As_Object(Data.MegaMission.Destination);
|
|
}
|
|
|
|
/*
|
|
** Break any existing team contact, since it is now invalid.
|
|
*/
|
|
if (!techno->IsTethered) {
|
|
techno->Transmit_Message(RADIO_OVER_OUT);
|
|
}
|
|
switch (techno->What_Am_I()) {
|
|
case RTTI_INFANTRY:
|
|
case RTTI_UNIT:
|
|
if (((FootClass *)techno)->Team) {
|
|
((FootClass *)techno)->Team->Remove((FootClass *)techno);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (object) {
|
|
|
|
// 2019/09/20 JAS - Added record of who clicked on the object
|
|
HouseClass* house = Houses.Raw_Ptr(ID);
|
|
bool is_allied = house != nullptr && house->Is_Ally(techno);
|
|
if (is_allied || Special.IsVisibleTarget) {
|
|
object->Clicked_As_Target((HousesType)ID);
|
|
}
|
|
}
|
|
techno->Assign_Mission(Data.MegaMission.Mission);
|
|
|
|
/*
|
|
** Guard area mode is handled with care. The specified target is actually
|
|
** assigned as the location that should be guarded. In addition, the
|
|
** movement destination is immediately set to this new location.
|
|
*/
|
|
if (Data.MegaMission.Mission == MISSION_GUARD_AREA &&
|
|
// Target_Legal(Data.MegaMission.Target) &&
|
|
(techno->What_Am_I() == RTTI_INFANTRY || techno->What_Am_I() == RTTI_UNIT || techno->What_Am_I() == RTTI_AIRCRAFT)) {
|
|
|
|
techno->ArchiveTarget = Data.MegaMission.Target;
|
|
techno->Assign_Target(TARGET_NONE);
|
|
techno->Assign_Destination(Data.MegaMission.Target);
|
|
} else if (Data.MegaMission.Mission == MISSION_ENTER &&
|
|
object != NULL &&
|
|
object->What_Am_I() == RTTI_BUILDING &&
|
|
*((BuildingClass*)object) == STRUCT_REFINERY) {
|
|
techno->Transmit_Message(RADIO_HELLO, (BuildingClass*)object);
|
|
techno->Assign_Destination(TARGET_NONE);
|
|
} else {
|
|
techno->Assign_Target(Data.MegaMission.Target);
|
|
techno->Assign_Destination(Data.MegaMission.Destination);
|
|
}
|
|
|
|
#ifdef NEVER
|
|
if ((techno->What_Am_I() == RTTI_UNIT || techno->What_Am_I() == RTTI_INFANTRY) &&
|
|
Data.MegaMission.Mission == MISSION_GUARD_AREA) {
|
|
|
|
techno->ArchiveTarget = Data.MegaMission.Destination;
|
|
}
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Request that the unit/infantry/aircraft go into idle mode.
|
|
*/
|
|
case IDLE:
|
|
techno = As_Techno(Data.Target.Whom);
|
|
if (techno && techno->IsActive && !techno->IsInLimbo && !techno->IsTethered) {
|
|
techno->Assign_Destination(TARGET_NONE);
|
|
techno->Assign_Target(TARGET_NONE);
|
|
techno->Enter_Idle_Mode();
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Request that the unit/infantry/aircraft scatter from its current location.
|
|
*/
|
|
case SCATTER:
|
|
techno = As_Techno(Data.Target.Whom);
|
|
if (techno && techno->IsActive && !techno->IsInLimbo && !techno->IsTethered) {
|
|
techno->Scatter(0, true);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** If we are placing down the ion cannon blast then lets take
|
|
** care of it.
|
|
*/
|
|
case SPECIAL_PLACE:
|
|
CCDebugString ("C&C95 - Special blast packet received\n");
|
|
Houses.Raw_Ptr(ID)->Place_Special_Blast((SpecialWeaponType)Data.Special.ID, Data.Special.Cell);
|
|
break;
|
|
|
|
/*
|
|
** Exit the game.
|
|
** Give parting message while palette is fading to black.
|
|
*/
|
|
case EXIT:
|
|
CCDebugString ("C&C95 - Exit game packet received\n");
|
|
Theme.Queue_Song(THEME_NONE);
|
|
Stop_Speaking();
|
|
Speak(VOX_CONTROL_EXIT);
|
|
while (Is_Speaking()) {
|
|
Call_Back();
|
|
}
|
|
GameActive = false;
|
|
break;
|
|
|
|
/*
|
|
** Process the options menu.
|
|
*/
|
|
case OPTIONS:
|
|
SpecialDialog = SDLG_OPTIONS;
|
|
break;
|
|
|
|
/*
|
|
** Process the options Game Speed
|
|
*/
|
|
case GAMESPEED:
|
|
CCDebugString ("C&C95 - Game speed packet received\n");
|
|
Options.GameSpeed = Data.General.Value;
|
|
break;
|
|
|
|
/*
|
|
** Adjust connection timing for multiplayer games
|
|
*/
|
|
case RESPONSE_TIME:
|
|
char flip[128];
|
|
sprintf (flip, "C&C95 - Changing MaxAhead to %d frames\n", Data.FrameInfo.Delay);
|
|
CCDebugString (flip);
|
|
MPlayerMaxAhead = Data.FrameInfo.Delay;
|
|
break;
|
|
|
|
//
|
|
// This event tells all systems to use new timing values. It's like
|
|
// RESPONSE_TIME, only it works. It's only used with the
|
|
// COMM_MULTI_E_COMP protocol.
|
|
//
|
|
case TIMING:
|
|
CCDebugString ("C&C95 - Timing packet received\n");
|
|
//#if(TIMING_FIX)
|
|
//
|
|
// If MaxAhead is about to increase, we're vulnerable to a Packet-
|
|
// Received-Too-Late error, if any system generates an event after
|
|
// this TIMING event, but before it executes. So, record the
|
|
// period of vulnerability's frame start & end values, so we
|
|
// can reschedule these events to execute after it's over.
|
|
//
|
|
if (Data.Timing.MaxAhead > MPlayerMaxAhead) {
|
|
NewMaxAheadFrame1 = Frame;
|
|
NewMaxAheadFrame2 = Frame + Data.Timing.MaxAhead;
|
|
}
|
|
//#endif
|
|
|
|
DesiredFrameRate = Data.Timing.DesiredFrameRate;
|
|
MPlayerMaxAhead = Data.Timing.MaxAhead;
|
|
|
|
sprintf (flip, "C&C95 - Timing packet: DesiredFrameRate = %d\n", Data.Timing.DesiredFrameRate);
|
|
CCDebugString (flip);
|
|
sprintf (flip, "C&C95 - Timing packet: MaxAhead = %d\n", Data.Timing.MaxAhead);
|
|
CCDebugString (flip);
|
|
|
|
/*
|
|
** If spawned from WChat then we should be getting poked every minute. If not then
|
|
** deliberately break the max ahead value
|
|
*/
|
|
if (Special.IsFromWChat){
|
|
MPlayerMaxAhead += DDEServer.Time_Since_Heartbeat()/(70*60);
|
|
//if (DDEServer.Time_Since_Heartbeat() >= 70*60) CCDebugString ("C&C95 - Missed a heartbeat\n");
|
|
}
|
|
break;
|
|
|
|
//
|
|
// This event tells all systems what the other systems' process
|
|
// timing requirements are; it's used to compute a desired frame rate
|
|
// for the game.
|
|
//
|
|
case PROCESS_TIME:
|
|
for (i = 0; i < MPlayerCount; i++) {
|
|
if (MPlayerID == ::MPlayerID[i]) {
|
|
TheirProcessTime[i] = Data.ProcessTime.AverageTicks;
|
|
|
|
char flip[128];
|
|
sprintf (flip, "C&C95 - Received PROCESS_TIME packet of %04x ticks\n", Data.ProcessTime.AverageTicks);
|
|
CCDebugString (flip);
|
|
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Default: do nothing.
|
|
*/
|
|
default:
|
|
break;
|
|
}
|
|
}
|