allegiance/test/Inc/PigsIDL.idl

import "ScrRun.idl";
import "AGCIDL.idl";


/////////////////////////////////////////////////////////////////////////////
// Forward Declarations

enum dispid_PigsIDL;
enum PigState;
enum PigMapType;
enum PigLobbyMode;
enum PigThrust;

interface IPigBehaviorType;
interface IPigBehaviorTypes;
interface IPigBehaviorScriptType;
interface IPigBehaviorHost;
interface IPigBehavior;
interface IPigBehaviors;
interface IPigBehaviorStack;
interface IPig;
interface IPigs;
interface IPigTeam;
interface IPigTeams;
interface IPigMissionParams;
interface IPigMissionParamsPrivate;
interface IPigMission;
interface IPigMissions;
interface IPigLobby;
interface IPigLobbies;
interface IPigSession;
interface IPigSessionEvents;
dispinterface _IPigSessionEvents;
interface IPigEvent;
interface IPigTimer;
interface IPigShip;
interface IPigShipEvent;
interface IPigVector;
interface IPigAccount;
interface IPigAccountDispenser;
interface IPigHullTypes;


/////////////////////////////////////////////////////////////////////////////
// {secret}
// DISPID Enumeration
//
// Notes:
//   Never remove one of these enumeration values without replacing it
//   with a dispid_Reservedx value to take its place, where x is the next
//   reserved index not in use.
//
//   Always add new values to the end of the enumeration so that these values
//   will never change.
//
enum dispid_PigsIDL
{
  dispid_PigsIDL_Begin = dispid_AGCIDL_End,

  dispid_SessionInfo,
  dispid_Sessions,
  dispid_ScriptDir,
  dispid_BehaviorTypes,
  dispid_Lobbies,
  dispid_Pigs,
  dispid_Name,
  dispid_Behaviors,
  dispid_IsScript,
  dispid_InvokeCommands,
  dispid_FilePathName,
  dispid_FileName,
  dispid_FileAttributes,
  dispid_FileModifiedTime,
  dispid_FileText,
  dispid_ScriptText,
  dispid_BehaviorType,
  dispid_Pig,
  dispid_IsActive,
  dispid_ProgID,
  dispid_CLSID,
  dispid_BaseBehaviorType,
  dispid_BaseBehavior,
  dispid_AppearsValid,
  dispid_EventHandler,
  dispid_RepetitionCount,
  dispid_Interval,
  dispid_PigState,
  dispid_PigStateName,
  dispid_Stack,
  dispid_Host,
  dispid_TeamCount,
  dispid_MaxTeamPlayers,
  dispid_MinTeamPlayers,
  dispid_MapType,
  dispid_ID,
  dispid_LobbyServer,
  dispid_AllStop,
  dispid_Face,
  dispid_IsThrusting,
  dispid_Throttle,
  dispid_Pitch,
  dispid_Yaw,
  dispid_Roll,
  dispid_Names,
  dispid_NamesAvailable,
  dispid_NamesInUse,
  dispid_NextAvailable,
  dispid_MissionServer,
  dispid_MaxPigs,
  dispid_AccountDispenser,
  dispid_Password,
  dispid_X,
  dispid_Y,
  dispid_Z,
  dispid_SetXYZ,
  dispid_ExpirationExpression,
  dispid_UpdatesPerSecond,
  dispid_Timer,
  dispid_IsExpired,
  dispid_Action,
  dispid_AutoAction,
  dispid_HullTypes,
  dispid_FireWeapon,
  dispid_FireMissile,
  dispid_DropMine,
  dispid_ActiveWeapon,
  dispid_IsFiringWeapon,
  dispid_IsFiringMissile,
  dispid_IsDroppingMine,
  dispid_SellAllParts,
  dispid_BuyHull,
  dispid_BuyDefaultLoadout,
  dispid_RipCord,
  dispid_PitchUp,
  dispid_PitchDown,
  dispid_YawLeft,
  dispid_YawRight,
  dispid_RollLeft,
  dispid_RollRight,
  dispid_Cloak,
  dispid_AcceptCommand,
  dispid_ClearCommand,
  dispid_Defend,
  dispid_IsRipCording,
  dispid_IsCloaked,
  dispid_LockVector,
  dispid_IsVectorLocked,
  dispid_QueuedCommand,
  dispid_AcceptedCommand,
  dispid_AutoAcceptCommands,
  dispid_AutoPilot,
  dispid_Money,
  dispid_ArtPath,
  dispid_CommitSuicide,
  dispid_CommandLine,
  dispid_Version,
  dispid_ProcessID,
  dispid_OnEvent,
  dispid_ActivateAllEvents,
  dispid_DeactivateAllEvents,
  dispid_InterruptionExpression,
  dispid_EventLog,
  dispid_AccountServer,
  dispid_ShipAngleThreshold1,
  dispid_ShipAngleThreshold2,
  dispid_ShipAngleThreshold3,
  dispid_ShipDistanceThreshold1,
  dispid_ShipDistanceThreshold2,
  dispid_ShipDistanceThreshold3,
  dispid_ShipsUpdateLatencyThreshold1,
  dispid_ShipsUpdateLatencyThreshold2,
  dispid_ShipsUpdateLatencyThreshold3,
  dispid_ZoneAuthServer,
  dispid_ZoneAuthTimeout,
  dispid_LobbyMode,

  dispid_PigsIDL_End = dispid_PigsIDL_Begin + 0x1000
};


/////////////////////////////////////////////////////////////////////////////
// PigState
[
  uuid(15219781-D562-11d2-9646-00C04F68DEB0),
  helpstring("Constants for pig player states.")
]
typedef [v1_enum] enum PigState
{
  PigState_NonExistant,
  PigState_LoggingOn,
  PigState_LoggingOff,
  PigState_MissionList,
  PigState_CreatingMission,
  PigState_JoiningMission,
  PigState_QuittingMission,
  PigState_TeamList,
  PigState_JoiningTeam,
  PigState_WaitingForMission,
  PigState_Docked,
  PigState_Launching,
  PigState_Flying,
  PigState_Terminated,
} PigState;


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(2942EC81-D0DC-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a pig behavior type object.")
]
interface IPigBehaviorType : IDispatch
{
  [propget, id(dispid_InvokeCommands), helpstring("Gets the collection of command strings that will invoke this behavior.")]
  HRESULT InvokeCommands([out, retval] ITCStrings** ppStrings);

  [propget, id(DISPID_VALUE), helpstring("Gets the name of this behavior type.")]
  HRESULT Name([out, retval] BSTR* pbstrName);

  [propget, id(dispid_Description), helpstring("Gets the description of this behavior type.")]
  HRESULT Description([out, retval] BSTR* pbstrDescription);

  [propget, id(dispid_Behaviors), helpstring("Gets the collection of pig behavior objects currently referencing this behavior type.")]
  HRESULT Behaviors([out, retval] IPigBehaviors** ppBehaviors);

  [propget, id(dispid_IsScript), helpstring("Gets the indicator of whether or not this object is based on a script or not.")]
  HRESULT IsScript([out, retval] VARIANT_BOOL* pbIsScript);

  [propget, id(dispid_BaseBehaviorType), helpstring("Gets the behavior type that serves as this one's base class.")]
  HRESULT BaseBehaviorType([out, retval] IPigBehaviorType** ppBaseType);

  [propput, helpstring("Gets/sets the flag indicating whether or not the script has encountered an error yet.")]
  HRESULT AppearsValid([in] VARIANT_BOOL bAppearsValid);
  [propget, id(dispid_AppearsValid)]
  HRESULT AppearsValid([out, retval] VARIANT_BOOL* pbAppearsValid);

}; // End: interface IPigBehaviorType : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(29E0A261-CC16-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a collection of pig behavior script objects.")
]
interface IPigBehaviorTypes : ITCCollection
{
  [propget, id(DISPID_VALUE), helpstring("Gets an item from the collection. Takes an argument, index, that is either the 0-relative index into the collection, the name of the behavior, or one of the invoke commands of the behavior.")]
  HRESULT Item([in] VARIANT* pvIndex, [out, retval] IPigBehaviorType** ppBehaviorType);

}; // End: interface IPigBehaviorTypes : ITCCollection


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(29E0A260-CC16-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a pig behavior script object.")
]
interface IPigBehaviorScriptType : IPigBehaviorType
{
  [propget, id(dispid_FilePathName), helpstring("Gets the path and name of the script file that defines this behavior.")]
  HRESULT FilePathName([out, retval] BSTR* pbstrFilePathName);

  [propget, id(dispid_FileName), helpstring("Gets the name of the script file that defines this behavior.")]
  HRESULT FileName([out, retval] BSTR* pbstrFileName);

  [propget, id(dispid_FileModifiedTime), helpstring("Gets the time (UTC) that the script file was last modified.")]
  HRESULT FileModifiedTime([out, retval] DATE* pdate);

  [propget, id(dispid_FileAttributes), helpstring("Gets the attributes of the script file.")]
  HRESULT FileAttributes([out, retval] FileAttributes* peFileAttributes);

  [propget, id(dispid_FileText), helpstring("Gets the text of the entire script file.")]
  HRESULT FileText([out, retval] BSTR* pbstrFileText);

  [propget, id(dispid_ScriptText), helpstring("Gets the text of the script sections within the file.")]
  HRESULT ScriptText([out, retval] ITCStrings** ppScriptStrings);

  [propget, id(dispid_ProgID), helpstring("Gets the Prog ID of the Active Scripting engine used to parse/execute this script.")]
  HRESULT ScriptEngineProgID([out, retval] BSTR* pbstrProgID);

  [propget, id(dispid_CLSID), helpstring("Gets the CLSID of the Active Scripting engine used to parse/execute this script.")]
  HRESULT ScriptEngineCLSID([out, retval] BSTR* pbstrCLSID);

}; // End: interface IPigBehaviorScriptType : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(15219786-D562-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a pig behavior host object.")
]
interface IPigBehaviorHost : IDispatch
{
  [helpstring("Useful test method that beeps as specified.")]
  HRESULT Beep([in] long nFrequency, [in] long nDuration);

  [helpstring("Creates a new pig object with the specified behavior type.")]
  HRESULT CreatePig([in, defaultvalue("Default")] BSTR bstrType,
    [in, defaultvalue("")] BSTR bstrCommandLine, [out, retval] IPig** ppPig);

  [helpstring("Useful test method that echoes the specified text to the debugger output.")]
  HRESULT Trace([in] BSTR bstrText);

  [propget, helpstring("Gets the textual name of the specified pig state.")]
  HRESULT StateName([in] PigState ePigState, [out, retval] BSTR* pbstrPigState);

  [helpstring("Generates a random integer between 0 and 32,767.")]
  HRESULT Random([out, retval] short* pnRandom);

}; // End: interface IPigBehaviorHost : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(10AB179C-C6FA-11d2-85C9-00C04F68DEB0),
  helpstring("Interface to a pig behavior object.")
]
interface IPigBehavior : IDispatch
{
  ///////////////////////////////////////////////////////////////////////////
  // Infrastructure Properties
  [propget, id(dispid_BehaviorType), helpstring("Gets the object that describes this class of behavior.")]
  HRESULT BehaviorType([out, retval] IPigBehaviorType** ppType);

  [propget, id(dispid_BaseBehavior), helpstring("Get the behavior, if any, that serve's as the this one's base class.")]
  HRESULT BaseBehavior([out, retval] IDispatch** ppBaseBehavior);

  [propget, id(dispid_Pig), helpstring("Gets the pig player object using this behavior instance.")]
  HRESULT Pig([out, retval] IPig** ppPig);

  [propget, id(dispid_Host), helpstring("Gets the object used to access the rest of the Pigs object model.")]
  HRESULT Host([out, retval] IPigBehaviorHost** ppHost);

  [propget, id(dispid_IsActive), helpstring("Gets the indicator of whether or not this behaior is the one currently active for the pig player object.")]
  HRESULT IsActive([out, retval] VARIANT_BOOL* pbIsActive);

  [propget, id(DISPID_VALUE), helpstring("Gets the dictionary containing the behavior-defined properties.")]
  HRESULT Properties([out, retval] IDictionary** ppProperties);

  [propget, id(dispid_Timer), helpstring("Gets the timer for which the event expression is currently executing, if any")]
  HRESULT Timer([out, retval] IPigTimer** ppTimer);

  [propget, id(dispid_CommandLine), helpstring("Gets the command line text used to activate the behvaior, if any.")]
  HRESULT CommandLine([out, retval] BSTR* pbstrCommandLine);

  ///////////////////////////////////////////////////////////////////////////
  // Infrastructure Methods
  [helpstring("Creates a new timer object.")]
  HRESULT CreateTimer([in] float fInterval, [in] BSTR bstrEventExpression,
    [in, defaultvalue(-1)] long nRepetitions,
    [in, defaultvalue("")] BSTR bstrName,
    [out, retval] IPigTimer** ppTimer);


  ///////////////////////////////////////////////////////////////////////////
  // Activation / Deactivation Response Methods
  [helpstring("Called when this behavior becomes a pig's active behavior.")]
  HRESULT OnActivate([in] IPigBehavior* pPigDeactived);

  [helpstring("Called when this behavior is deactivated as a pig's active behavior.")]
  HRESULT OnDeactivate([in] IPigBehavior* pPigActivated);


  ///////////////////////////////////////////////////////////////////////////
  // State Transition Response Methods
  [helpstring("Called when the state of the pig has changed to PigState_NonExistant.")]
  HRESULT OnStateNonExistant([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_LoggingOn.")]
  HRESULT OnStateLoggingOn([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_LoggingOff.")]
  HRESULT OnStateLoggingOff([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_MissionList.")]
  HRESULT OnStateMissionList([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_CreatingMission.")]
  HRESULT OnStateCreatingMission([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_JoiningMission.")]
  HRESULT OnStateJoiningMission([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_QuittingMission.")]
  HRESULT OnStateQuittingMission([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_TeamList.")]
  HRESULT OnStateTeamList([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_JoiningTeam.")]
  HRESULT OnStateJoiningTeam([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_WaitingForMission.")]
  HRESULT OnStateWaitingForMission([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_Docked.")]
  HRESULT OnStateDocked([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_Launching.")]
  HRESULT OnStateLaunching([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_Flying.")]
  HRESULT OnStateFlying([in] PigState eStatePrevious);

  [helpstring("Called when the state of the pig has changed to PigState_Terminated.")]
  HRESULT OnStateTerminated([in] PigState eStatePrevious);


  ///////////////////////////////////////////////////////////////////////////
  // TODO: Game Response Methods
  [helpstring("Called when the Pig's current mission begins.")]
  HRESULT OnMissionStarted();

  [helpstring("Called when the Pig receives chat text.")]
  HRESULT OnReceiveChat([in] BSTR bstrText, [in] IAGCShip* pShipSender,
    [out, retval] VARIANT_BOOL* pbHandled);

  [helpstring("Called when any ship takes damage.")]
  HRESULT OnShipDamaged([in] IAGCShip* pShip, [in] IAGCModel* pModelLauncher,
    [in] float fAmount, [in] float fLeakage,
    [in] IAGCVector* pVector1, [in] IAGCVector* pVector2);

  [helpstring("Called when the Pig ship is killed.")]
  HRESULT OnShipKilled([in] IAGCModel* pModelLauncher, [in] float fAmount,
    [in] IAGCVector* pVector1, [in] IAGCVector* pVector2);

  [helpstring("Called when the Pig ship is transported to a new Sector.")]
  HRESULT OnSectorChange([in] IAGCSector* pSectorOld,
    [in] IAGCSector* pSectorNew);

  [helpstring("Called when the Pig ship hits an Aleph.")]
  HRESULT OnAlephHit([in] IAGCAleph* pAleph);

}; // End: interface IPigBehavior : IDispatch



/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(16AA8204-C6FA-11d2-85C9-00C04F68DEB0),
  helpstring("Interface to a collection of pig behavior objects.")
]
interface IPigBehaviors : ITCCollection
{

}; // End: interface IPigBehaviors : ITCCollection


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(15219782-D562-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a stack of pig behavior objects.")
]
interface IPigBehaviorStack : ITCCollection
{
  [helpstring("Creates a new behavior of the specified type and pushes it onto the top of the behavior stack.")]
  HRESULT Push([in] BSTR bstrType, [in, defaultvalue("")] BSTR bstrCommandLine,
    [out, retval] IPigBehavior** ppBehavior);

  [helpstring("Pops the top-most behavior off the stack, unless there is only one behavior remaining on the stack.")]
  HRESULT Pop();

  [propget, id(DISPID_VALUE), helpstring("Gets a reference to a behavior on the stack without removing it from the stack.")]
  HRESULT Top([in, defaultvalue(0)] long nFromTop,
    [out, retval] IPigBehavior** ppBehavior);

  [propget, helpstring("Gets the pig object which owns this behavior stack.")]
  HRESULT Pig([out, retval] IPig** ppPig);

}; // End: interface IPigBehaviorStack : ITCCollection


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(01B61700-C6FA-11d2-85C9-00C04F68DEB0),
  helpstring("Interface to a pig player object.")
]
interface IPig : IDispatch
{
  [propget, id(dispid_PigState), helpstring("Gets the current state of the pig.")]
  HRESULT PigState([out, retval] PigState* pePigState);

  [propget, id(dispid_PigStateName), helpstring("Gets the textual name of the state of the pig.")]
  HRESULT PigStateName([out, retval] BSTR* pbstrPigState);

  [propget, id(dispid_Stack), helpstring("Gets the stack of behaviors associated with this pig.")]
  HRESULT Stack([out, retval] IPigBehaviorStack** ppStack);

  [propget, id(DISPID_VALUE), helpstring("Gets the character name of the pig.")]
  HRESULT Name([out, retval] BSTR* pbstrName);

  [propget, helpstring("Gets the ship object of the pig.")]
  HRESULT Ship([out, retval] IPigShip** ppShip);

  [propput, helpstring("Gets/sets the number of times per second that the IGC layer is updated.")]
  HRESULT UpdatesPerSecond([in] long nPerSecond);
  [propget, id(dispid_UpdatesPerSecond)]
  HRESULT UpdatesPerSecond([out, retval] long* pnPerSecond);

  // TODO: Move to IAGCStation interface, when developed
  [propget, id(dispid_HullTypes), helpstring("Gets the collection of hull types available to this pig.")]
  HRESULT HullTypes([out, retval] IPigHullTypes** ppHullTypes);

  [propget, id(dispid_Money), helpstring("Gets this pig's liquid worth.")]
  HRESULT Money([out, retval] AGCMoney* pnMoney);

  [helpstring("Logs on to the mission server.")]
  HRESULT Logon();

  [helpstring("Logs off from the lobby server.")]
  HRESULT Logoff();

  [helpstring("Creates (and joins) a new mission with the specified parameters.")]
  HRESULT CreateMission([in] IPigMissionParams* pMissionParams);

  [helpstring("Joins a mission, which may be specified by name, by a buddy player, or not at all.")]
  HRESULT JoinMission([in, defaultvalue("")] BSTR bstrMissionOrPlayer);

  [helpstring("Requests a position on a team, which may be specified by name, by a buddy player, or not at all.")]
  HRESULT JoinTeam([in, defaultvalue("")] BSTR bstrTeamOrPlayer);

  [helpstring("Quits the current game.")]
  HRESULT QuitGame();

  [helpstring("Undocks from the station and enters space.")]
  HRESULT Launch();

  [helpstring("Forces the pig to exit the game.")]
  HRESULT Shutdown();

  [propget, helpstring("Gets the AGCGame object that the Pig is a member of, if any.")]
  HRESULT Game([out, retval] IAGCGame** ppGame);

  [propget, helpstring("Gets the AGCShip object that sent the current chat. NULL if chat was from HQ or Pig is not currently processing chat text.")]
  HRESULT Me([out, retval] IAGCShip** ppShip);

  [propget, helpstring("Gets the target of the current chat. AGCChat_NoSelection if Pig is not currently processing chat text.")]
  HRESULT ChatTarget([out, retval] AGCChatTarget* peChatTarget);

  [propget, id(dispid_Host), helpstring("Gets the object used to access the rest of the Pigs object model.")]
  HRESULT Host([out, retval] IPigBehaviorHost** ppHost);

  [helpstring("Starts the game.")]
  HRESULT StartGame();

  [propput, helpstring("Contains a threshold value, representing an angle in radians, to which each ship's movement is compared.")]
  HRESULT ShipAngleThreshold1([in] float rRadians);
  [propget, id(dispid_ShipAngleThreshold1)]
  HRESULT ShipAngleThreshold1([out, retval] float* prRadians);

  [propput, helpstring("Contains a threshold value, representing an angle in radians, to which each ship's movement is compared.")]
  HRESULT ShipAngleThreshold2([in] float rRadians);
  [propget, id(dispid_ShipAngleThreshold2)]
  HRESULT ShipAngleThreshold2([out, retval] float* prRadians);

  [propput, helpstring("Contains a threshold value, representing an angle in radians, to which each ship's movement is compared.")]
  HRESULT ShipAngleThreshold3([in] float rRadians);
  [propget, id(dispid_ShipAngleThreshold3)]
  HRESULT ShipAngleThreshold3([out, retval] float* prRadians);

  [propput, helpstring("Contains a threshold value, representing a distance, to which each ship's movement is compared.")]
  HRESULT ShipDistanceThreshold1([in] float rDistance);
  [propget, id(dispid_ShipDistanceThreshold1)]
  HRESULT ShipDistanceThreshold1([out, retval] float* prDistance);

  [propput, helpstring("Contains a threshold value, representing a distance, to which each ship's movement is compared.")]
  HRESULT ShipDistanceThreshold2([in] float rDistance);
  [propget, id(dispid_ShipDistanceThreshold2)]
  HRESULT ShipDistanceThreshold2([out, retval] float* prDistance);

  [propput, helpstring("Contains a threshold value, representing a distance, to which each ship's movement is compared.")]
  HRESULT ShipDistanceThreshold3([in] float rDistance);
  [propget, id(dispid_ShipDistanceThreshold3)]
  HRESULT ShipDistanceThreshold3([out, retval] float* prDistance);

  [propput, helpstring("Contains a threshold value, representing ZTime, to which the (heavy_update_time - client_time) is compared.")]
  HRESULT ShipsUpdateLatencyThreshold1([in] long nMilliseconds);
  [propget, id(dispid_ShipsUpdateLatencyThreshold1)]
  HRESULT ShipsUpdateLatencyThreshold1([out, retval] long* pnMilliseconds);

  [propput, helpstring("Contains a threshold value, representing ZTime, to which the (heavy_update_time - client_time) is compared.")]
  HRESULT ShipsUpdateLatencyThreshold2([in] long nMilliseconds);
  [propget, id(dispid_ShipsUpdateLatencyThreshold2)]
  HRESULT ShipsUpdateLatencyThreshold2([out, retval] long* pnMilliseconds);

  [propput, helpstring("Contains a threshold value, representing ZTime, to which the (heavy_update_time - client_time) is compared.")]
  HRESULT ShipsUpdateLatencyThreshold3([in] long nMilliseconds);
  [propget, id(dispid_ShipsUpdateLatencyThreshold3)]
  HRESULT ShipsUpdateLatencyThreshold3([out, retval] long* pnMilliseconds);

  [helpstring("Sends the bytes specified to the connected lobby server, if any. pvBytes is either the name of a file, or a SAFEARRAY of bytes.")]
  HRESULT SendBytesToLobby([in] VARIANT* pvBytes, [in, defaultvalue(0)] VARIANT_BOOL bGuaranteed);

  [helpstring("Sends the bytes specified to the connected game server, if any. pvBytes is either the name of a file, or a SAFEARRAY of bytes.")]
  HRESULT SendBytesToGame([in] VARIANT* pvBytes, [in, defaultvalue(0)] VARIANT_BOOL bGuaranteed);

}; // End: interface IPig : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(0A773978-C6FA-11d2-85C9-00C04F68DEB0),
  helpstring("Interface to a collection of pig player objects.")
]
interface IPigs : ITCCollection
{
  ///////////////////////////////////////////////////////////////////////////
  // Parameters:
  //   index - A *VARIANT* of type *VT_BSTR* that specifies the name of an
  // item in the collection.
  //   ppPig - Address of a variable to receive the specified item from the
  // collection.
  //
  // Return Value: One of the following results:
  //
  //   S_OK - The method completed successfully.
  //   E_POINTER - The specified pointer is invalid.
  //   E_INVALIDARG - The specified index is out of range.
  [propget, id(DISPID_VALUE), helpstring("Returns an IPig* from the collection or NULL if the specified named pig does not exist in the collection. Takes an argument, index, which must be the name of a pig in the collection.")]
  HRESULT Item([in] VARIANT* pvIndex, [out, retval] IPig** ppPig);

}; // End: interface IPigs : ITCCollection


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(B1935982-D27B-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a Team object.")
]
interface IPigTeam : IDispatch
{
  [propget, id(DISPID_VALUE), helpstring("Gets the name of the team.")]
  HRESULT Name([out, retval] BSTR* bstrName);

//  [propget, helpstring("Gets/sets the civilization of the team.")]

//  [propget, helpstring("Gets the station the team starts at.")]

//  [propget, helpstring("Gets/sets the ship of the team's leader.")]

  [propget, helpstring("Gets the maximum allowed players on this team.")]
  HRESULT PlayersMaximum([out, retval] short* pnPlayersMaximum);

  [propget, helpstring("Gets the current number of players on this team.")]
  HRESULT PlayerCount([out, retval] short* pnPlayers);

//  [propget, helpstring("Gets the collection of players on this team.")]
//  HRESULT Players([out, retval] IPigPlayers** ppPlayers);

  [propput, helpstring("Gets/sets the 'auto-accept' flag of this team.")]
  HRESULT IsAutoAccept([in] VARIANT_BOOL bAutoAccept);
  [propget]
  HRESULT IsAutoAccept([out, retval] VARIANT_BOOL* pbAutoAccept);

  [propput, helpstring("Gets/sets the 'ready' flag of this team.")]
  HRESULT IsReady([in] VARIANT_BOOL bReady);
  [propget]
  HRESULT IsReady([out, retval] VARIANT_BOOL* pbReady);

  [propput, helpstring("Gets/sets the 'force-ready' flag of this team.")]
  HRESULT IsForceReady([in] VARIANT_BOOL bForceReady);
  [propget]
  HRESULT IsForceReady([out, retval] VARIANT_BOOL* pbForceReady);

  [propput, helpstring("Gets/sets the 'active' flag of this team.")]
  HRESULT IsActive([in] VARIANT_BOOL bActive);
  [propget]
  HRESULT IsActive([out, retval] VARIANT_BOOL* pbActive);

}; // End: interface IPigTeam : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(B1935983-D27B-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a collection of Team objects.")
]
interface IPigTeams : ITCCollection
{

}; // End: interface IPigTeams : ITCCollection


/////////////////////////////////////////////////////////////////////////////
// PigMapType
[
  uuid(15219784-D562-11d2-9646-00C04F68DEB0),
  helpstring("Constants for mission map types.")
]
typedef [v1_enum] enum PigMapType
{
  PigMapType_SingleRing,
  PigMapType_DoubleRing,
  PigMapType_PinWheel,
  PigMapType_DiamondRing,
  PigMapType_Snowflake,
  PigMapType_SplitBases,
  PigMapType_Count,
  PigMapType_Default = PigMapType_DoubleRing,
} PigMapType;


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(15219783-D562-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a MissionParams object.")
]
interface IPigMissionParams : IDispatch
{
  [helpstring("Validates the properties of the object.")]
  HRESULT Validate();

  [propput, helpstring("Gets/sets the number of teams for the mission.")]
  HRESULT TeamCount([in] short nTeamCount);
  [propget, id(dispid_TeamCount)]
  HRESULT TeamCount([out, retval] short* pnTeamCount);

  [propput, helpstring("Gets/sets the maximum number of players allowed on a team.")]
  HRESULT MaxTeamPlayers([in] short nMaxTeamPlayers);
  [propget, id(dispid_MaxTeamPlayers)]
  HRESULT MaxTeamPlayers([out, retval] short* pnMaxTeamPlayers);

  [propput, helpstring("Gets/sets the minimum number of players allowed on a team.")]
  HRESULT MinTeamPlayers([in] short nMinTeamPlayers);
  [propget, id(dispid_MinTeamPlayers)]
  HRESULT MinTeamPlayers([out, retval] short* pnMinTeamPlayers);

  [propput, helpstring("Gets/sets the map type for the mission.")]
  HRESULT MapType([in] PigMapType eMapType);
  [propget, id(dispid_MapType)]
  HRESULT MapType([out, retval] PigMapType* peMapType);

}; // End: interface IPigMissionParams : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, pointer_default(unique), nonextensible,
  uuid(91C86108-DCF4-11d2-A507-00C04F68DEB0),
  helpstring("Private interface to a MissionParams object.")
]
interface IPigMissionParamsPrivate : IUnknown
{
  [helpstring("Gets a stream containing the length-prefixed data structure.")]
  HRESULT GetData([out, retval] IStream** ppstm);

}; // End: interface IPigMissionParamsPrivate : IUnknown


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(29E0A262-CC16-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a Mission object.")
]
interface IPigMission : IDispatch
{
  // TODO: Does this go into teams?
  [propget, id(dispid_Pigs), helpstring("Gets the collection of (pig) players.")]
  HRESULT Pigs([out, retval] IPigs** ppPigs);

}; // End: interface IPigMission : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(29E0A263-CC16-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a collection of Mission objects.")
]
interface IPigMissions : ITCCollection
{

}; // End: interface IPigMissions : ITCCollection


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(34E485E0-C7B7-11d2-85C9-00C04F68DEB0),
  helpstring("Interface to a Lobby object.")
]
interface IPigLobby : IDispatch
{
}; // End: interface IPigLobby : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(34E485E1-C7B7-11d2-85C9-00C04F68DEB0),
  helpstring("Interface to a collection of Lobby objects.")
]
interface IPigLobbies : ITCCollection
{

}; // End: interface IPigLobbies : ITCCollection


/////////////////////////////////////////////////////////////////////////////
// PigLobbyMode
[
  uuid(454A9C85-1353-422c-8557-E2FADE69A0EC),
  helpstring("Constants for pig lobby server mode.")
]
typedef [v1_enum] enum PigLobbyMode
{
  PigLobbyMode_Club,
  PigLobbyMode_Free,
  PigLobbyMode_LAN,
} PigLobbyMode;


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(4D13B28C-C6F2-11D2-85C9-00C04F68DEB0),
  helpstring("IPigSession Interface")
]
interface IPigSession : IDispatch
{
  [propput, helpstring("Gets/sets the session information object.")]
  HRESULT SessionInfo([in] ITCSessionInfo* pSessionInfo);
  [propget, id(dispid_SessionInfo)]
  HRESULT SessionInfo([out, retval] ITCSessionInfo** ppSessionInfo);

  [propget, id(dispid_Sessions), helpstring("Gets the collection of connected sessions.")]
  HRESULT SessionInfos([out, retval] ITCSessionInfos** ppSessionInfos);

  [propput, helpstring("Gets/sets the directory for script files.")]
  HRESULT ScriptDir([in] BSTR bstrScriptDir);
  [propget, id(dispid_ScriptDir)]
  HRESULT ScriptDir([out, retval] BSTR* pbstrScriptDir);

  [propput, helpstring("Gets/sets the directory for artwork files.")]
  HRESULT ArtPath([in] BSTR bstrArtPath);
  [propget, id(dispid_ArtPath)]
  HRESULT ArtPath([out, retval] BSTR* pbstrArtPath);

  [propget, id(dispid_BehaviorTypes), helpstring("Gets the collection of behavior scripts.")]
  HRESULT BehaviorTypes([out, retval] IPigBehaviorTypes** ppBehaviorTypes);

  [propget, id(dispid_Lobbies), helpstring("Gets the collection of game lobby servers.")]
  HRESULT Lobbies([out, retval] IPigLobbies** ppLobbies);

  [propget, id(dispid_Pigs), helpstring("Gets the collection of all (pig) players.")]
  HRESULT Pigs([out, retval] IPigs** ppPigs);

  [helpstring("Creates a new pig object with the specified behavior type.")]
  HRESULT CreatePig([in, defaultvalue("Default")] BSTR bstrType,
    [in, defaultvalue("")] BSTR bstrCommandLine, [out, retval] IPig** ppPig);

  [propput, helpstring("Gets/sets the server on which all pigs will be created.")]
  HRESULT MissionServer([in] BSTR bstrServer);
  [propget, id(dispid_MissionServer)]
  HRESULT MissionServer([out, retval] BSTR* pbstrServer);

  [propput, helpstring("Gets/sets maximum number of pigs that can be created on this server.")]
  HRESULT MaxPigs([in] long nMaxPigs);
  [propget, id(dispid_MaxPigs)]
  HRESULT MaxPigs([out, retval] long* pnMaxPigs);

  [propget, id(dispid_AccountDispenser), helpstring("Gets the object that dispenses pig accounts.")]
  HRESULT AccountDispenser([out, retval] IPigAccountDispenser** ppDispenser);

  [propget, id(dispid_Version), helpstring("Gets the version information of the Pig server.")]
  HRESULT Version([out, retval] IAGCVersionInfo** ppVersion);

  [propget, id(dispid_ProcessID), helpstring("Gets the process ID of the server, meaningful only on the local machine.")]
  HRESULT ProcessID([out, retval] DWORD* pdwProcessID);

  [id(dispid_ActivateAllEvents), helpstring("Enables the firing of all available events from this session.")]
  HRESULT ActivateAllEvents();

  [id(dispid_DeactivateAllEvents), helpstring("Disables the firing of all available events from this session.")]
  HRESULT DeactivateAllEvents();

  [propget, id(dispid_EventLog), helpstring("Gets the event log object.")]
  HRESULT EventLog([out, retval] IAGCEventLogger** ppEventLogger);

  [propput, helpstring("Contains the server from which pig accounts will be dispensed. When empty, the MissionServer is used. When this property is a period character, the local machine is used.")]
  HRESULT AccountServer([in] BSTR bstrServer);
  [propget, id(dispid_AccountServer)]
  HRESULT AccountServer([out, retval] BSTR* pbstrServer);

  [propput, helpstring("Contains the server on which the pig accounts will be authenticated. When empty, no authentication is performed.")]
  HRESULT ZoneAuthServer([in] BSTR bstrServer);
  [propget, id(dispid_ZoneAuthServer)]
  HRESULT ZoneAuthServer([out, retval] BSTR* pbstrServer);

  [propput, helpstring("Contains the maximum amount of time allowed for authentication of pig accounts. Ignored when ZoneAuthServer is an empty string.")]
  HRESULT ZoneAuthTimeout([in] long nMilliseconds);
  [propget, id(dispid_ZoneAuthTimeout)]
  HRESULT ZoneAuthTimeout([out, retval] long* pnMilliseconds);

  [propput, helpstring("Specifies the mode of lobby connection that is used for server connections. Affects the usage of the MissionServer property.")]
  HRESULT LobbyMode([in] PigLobbyMode eMode);
  [propget, id(dispid_LobbyMode)]
  HRESULT LobbyMode([out, retval] PigLobbyMode* peMode);

}; // End: interface IPigSession : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, oleautomation, pointer_default(unique), nonextensible,
  uuid(1B41CCF2-C6F5-11d2-85C9-00C04F68DEB0),
  helpstring("IPigSessionEvents Interface")
]
interface IPigSessionEvents : IUnknown
{
  [id(dispid_OnEvent), helpstring("Called when an event is fired for this session.")]
  HRESULT OnEvent([in] IAGCEvent* pEvent);

}; // End: interface IPigSessionEvents : IUnknown


/////////////////////////////////////////////////////////////////////////////
[
  uuid(9BCD384F-C6F2-11D2-85C9-00C04F68DEB0),
  helpstring("_IPigSessionEvents Interface")
]
dispinterface _IPigSessionEvents
{
  interface IPigSessionEvents;

}; // End: dispinterface _IPigSessionEvents


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(3FF9E450-EE33-11d2-A50B-00C04F68DEB0),
  helpstring("Interface to a Pig Event object.")
]
interface IPigEvent : IDispatch
{
  [propput, helpstring("Gets/sets the name of the object.")]
  HRESULT Name([in] BSTR bstrName);
  [propget, id(DISPID_VALUE)]
  HRESULT Name([out, retval] BSTR* pbstrName);

  [propput, helpstring("Gets/sets the expression to be evaluated on the normal expiration of this action.")]
  HRESULT ExpirationExpression([in] BSTR bstrExpr);
  [propget, id(dispid_ExpirationExpression)]
  HRESULT ExpirationExpression([out, retval] BSTR* pbstrExpr);

  [propget, id(dispid_IsExpired), helpstring("Gets whether or not the event has expired.")]
  HRESULT IsExpired([out, retval] VARIANT_BOOL* pbExpired);

  [helpstring("Kills the event.")]
  HRESULT Kill();

  [propput, helpstring("Gets/sets the expression to be evaluated on the interrupted expiration of this action.")]
  HRESULT InterruptionExpression([in] BSTR bstrExpr);
  [propget, id(dispid_InterruptionExpression)]
  HRESULT InterruptionExpression([out, retval] BSTR* pbstrExpr);

}; // End: interface IPigEvent : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(B1935984-D27B-11d2-9646-00C04F68DEB0),
  helpstring("Interface to a Timer object.")
]
interface IPigTimer : IPigEvent
{
  [propput, helpstring("Gets/sets the number of interval occurences remaining for this timer.")]
  HRESULT RepetitionCount([in] long nRepetitionCount);
  [propget, id(dispid_RepetitionCount)]
  HRESULT RepetitionCount([out, retval] long* pnRepetitionCount);

  [propput, helpstring("Gets/sets the time, in seconds, of each timer interval.")]
  HRESULT Interval([in] float fInterval);
  [propget, id(dispid_Interval)]
  HRESULT Interval([out, retval] float* pfInterval);

}; // End: interface IPigTimer : IPigEvent


/////////////////////////////////////////////////////////////////////////////
// PigThrust
[
  uuid(B1B86020-E3B2-11d2-A507-00C04F68DEB0),
  helpstring("Constants for pig thrust actions.")
]
typedef [v1_enum] enum PigThrust
{
  ThrustNone,
  ThrustLeft,
  ThrustRight,
  ThrustUp,
  ThrustDown,
  ThrustForward,
  ThrustBackward,
  ThrustBooster,
} PigThrust;


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(D3A182FA-DB30-11d2-A505-00C04F68DEB0),
  helpstring("Interface to a Pig Ship object.")
]
interface IPigShip : IAGCShip
{
  [id(dispid_SellAllParts), helpstring("Sells all parts loaded onto the ship.")]
  HRESULT SellAllParts();

  [id(dispid_BuyHull), helpstring("Buys the specified hull type.")]
  HRESULT BuyHull([in] IAGCHullType* pHullType);

  [id(dispid_BuyDefaultLoadout), helpstring("Buys the default loadout for the current hull type.")]
  HRESULT BuyDefaultLoadout();

  [id(dispid_CommitSuicide), helpstring("Kills the ship.")]
  HRESULT CommitSuicide([out, retval] BSTR* pbstrResponse);

  [id(dispid_AllStop), helpstring("Stops all thrusting, throttling, axis turning, and action events.")]
  HRESULT AllStop([out, retval] BSTR* pbstrResponse);

  [id(dispid_Thrust), helpstring("Thrusts the ship in the specified direction(s).")]
  HRESULT Thrust(
    [in, defaultvalue(ThrustNone)] PigThrust e1,
    [in, defaultvalue(ThrustNone)] PigThrust e2,
    [in, defaultvalue(ThrustNone)] PigThrust e3,
    [in, defaultvalue(ThrustNone)] PigThrust e4,
    [in, defaultvalue(ThrustNone)] PigThrust e5,
    [in, defaultvalue(ThrustNone)] PigThrust e6,
    [in, defaultvalue(ThrustNone)] PigThrust e7,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_FireWeapon), helpstring("Begins/ends the firing of the active weapon.")]
  HRESULT FireWeapon([in, defaultvalue(-1)] VARIANT_BOOL bBegin,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_FireMissile), helpstring("Begins/ends the firing of the missile launcher.")]
  HRESULT FireMissile([in, defaultvalue(-1)] VARIANT_BOOL bBegin,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_DropMine), helpstring("Begins/ends the dropping of mines (or probes).")]
  HRESULT DropMine([in, defaultvalue(-1)] VARIANT_BOOL bBegin,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_LockVector), helpstring("Activates/deactivates the vector lock.")]
  HRESULT LockVector([in, defaultvalue(-1)] VARIANT_BOOL bLockVector,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_RipCord), helpstring("Activates/deactivates the rip cording action.")]
  HRESULT RipCord([in] VARIANT* pvParam, [out, retval] BSTR* pbstrResponse);

  [id(dispid_Cloak), helpstring("Cloaks/decloaks the ship.")]
  HRESULT Cloak([in, defaultvalue(-1)] VARIANT_BOOL bCloak,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_AcceptCommand), helpstring("Accepts the queued command.")]
  HRESULT AcceptCommand([out, retval] BSTR* pbstrResponse);

  [id(dispid_ClearCommand), helpstring("Clears the accepted command.")]
  HRESULT ClearCommand([out, retval] BSTR* pbstrResponse);

/* // When I have time to implement these
  [id(dispid_PitchUp), helpstring("Turns the ship the specified number of positive degrees upward.")]
  HRESULT PitchUp([in] float fDegrees, [out, retval] BSTR* pbstrResponse);

  [id(dispid_PitchDown), helpstring("Turns the ship the specified number of positive degrees downward.")]
  HRESULT PitchDown([in] float fDegrees, [out, retval] BSTR* pbstrResponse);

  [id(dispid_YawLeft), helpstring("Turns the ship the specified number of positive degrees to the left.")]
  HRESULT YawLeft([in] float fDegrees, [out, retval] BSTR* pbstrResponse);

  [id(dispid_YawRight), helpstring("Turns the ship the specified number of positive degrees to the right.")]
  HRESULT YawRight([in] float fDegrees, [out, retval] BSTR* pbstrResponse);

  [id(dispid_RollLeft), helpstring("Rolls the ship the specified number of positive degrees to the left")]
  HRESULT RollLeft([in] float fDegrees, [out, retval] BSTR* pbstrResponse);

  [id(dispid_RollRight), helpstring("Rolls the ship the specified number of positive degrees to the right.")]
  HRESULT RollRight([in] float fDegrees, [out, retval] BSTR* pbstrResponse);
*/

  [id(dispid_Face), helpstring("Turns the ship to face the vector, specified by either an object name (VT_BSTR) or an IAGCVector* or IAGCModel* (VT_DISPATCH).")]
  HRESULT Face([in] VARIANT* pvarObject,
    [in, defaultvalue("")] BSTR bstrCompletionExpr,
    [in, defaultvalue("")] BSTR bstrInterruptionExpr,
    [in, defaultvalue(-1)] VARIANT_BOOL bMatchUpVector,
    [out, retval] BSTR* pbstrResponse);

  [id(dispid_Defend), helpstring("Defends the specified target.")]
  HRESULT Defend([in] BSTR bstrObject,
    [out, retval] BSTR* pbstrResponse);

  [propput, helpstring("Gets/sets the AutoPilot state.")]
  HRESULT AutoPilot([in] VARIANT_BOOL bEngage);
  [propget, id(dispid_AutoPilot)]
  HRESULT AutoPilot([out, retval] VARIANT_BOOL* pbEngaged);

  [propget, id(dispid_AutoAction), helpstring("Gets the Pig Ship action event object for this ship.")]
  HRESULT AutoAction([out, retval] IPigShipEvent** ppAutoAction);

  [propget, id(dispid_IsThrusting), helpstring("Indicates whether the ship is thrusting in the specified direction.")]
  HRESULT IsThrusting([in] PigThrust eThrust, [out, retval] VARIANT_BOOL* pbThrusting);

  [propput, helpstring("Gets/sets the weapon that is active. This must be 0 thru 3, or -1 for the default of 'all weapons'.")]
  HRESULT ActiveWeapon([in] long iWeapon);
  [propget, id(dispid_ActiveWeapon)]
  HRESULT ActiveWeapon([out, retval] long* piWeapon);

  [propget, id(dispid_IsFiringWeapon), helpstring("Indicates whether the ship is firing the active weapon.")]
  HRESULT IsFiringWeapon([out, retval] VARIANT_BOOL* pbFiring);

  [propget, id(dispid_IsFiringMissile), helpstring("Indicates whether the ship is firing the missile launcher.")]
  HRESULT IsFiringMissile([out, retval] VARIANT_BOOL* pbFiring);

  [propget, id(dispid_IsDroppingMine), helpstring("Indicates whether the ship is dropping a mine (or probe).")]
  HRESULT IsDroppingMine([out, retval] VARIANT_BOOL* pbDropping);

  [propget, id(dispid_IsVectorLocked), helpstring("Indicates whether the ship's vector lock is active.")]
  HRESULT IsVectorLocked([out, retval] VARIANT_BOOL* pbVectorLocked);

  [propget, id(dispid_IsRipCording), helpstring("Indicates whether the ship is rip-cording.")]
  HRESULT IsRipCording([out, retval] VARIANT_BOOL* pbRipCording);

  [propget, id(dispid_IsCloaked), helpstring("Indicates whether the ship is cloaked.")]
  HRESULT IsCloaked([out, retval] VARIANT_BOOL* pbCloaked);

  [propput, helpstring("Gets/sets the ship's throttle. The valid range is 0 to 100.")]
  HRESULT Throttle([in] float fThrottle);
  [propget, id(dispid_Throttle)]
  HRESULT Throttle([out, retval] float* pfThrottle);

  [propput, helpstring("Gets/sets the ship's pitch speed. The valid range is -100 to 100.")]
  HRESULT Pitch([in] float fPitch);
  [propget, id(dispid_Pitch)]
  HRESULT Pitch([out, retval] float* pfPitch);

  [propput, helpstring("Gets/sets the ship's yaw speed. The valid range is -100 to 100.")]
  HRESULT Yaw([in] float fYaw);
  [propget, id(dispid_Yaw)]
  HRESULT Yaw([out, retval] float* pfYaw);

  [propput, helpstring("Gets/sets the ship's roll speed. The valid range is -100 to 100.")]
  HRESULT Roll([in] float fRoll);
  [propget, id(dispid_Roll)]
  HRESULT Roll([out, retval] float* pfRoll);

  [propget, id(dispid_QueuedCommand), helpstring("Gets the queued command.")]
  HRESULT QueuedCommand([out, retval] IAGCCommand** ppCommand);

  [propget, id(dispid_AcceptedCommand), helpstring("Gets the accepted command.")]
  HRESULT AcceptedCommand([out, retval] IAGCCommand** ppCommand);

  [propput, helpstring("Gets/sets whether the ship automatically accepts queued commands.")]
  HRESULT AutoAcceptCommands([in] VARIANT_BOOL bAutoAccept);
  [propget, id(dispid_AutoAcceptCommands)]
  HRESULT AutoAcceptCommands([out, retval] VARIANT_BOOL* pbAutoAccept);

  [propget, helpstring("Gets the amount of time left until the ripcordind action completes.")]
  HRESULT RipCordTimeLeft([out, retval] float* pfRipCordTimeLeft);

}; // End: interface IPigShip : IAGCShip


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(768293B0-EF2E-11d2-A50D-00C04F68DEB0),
  helpstring("Interface to a Pig Ship Event object.")
]
interface IPigShipEvent : IPigEvent
{
  [propget, id(dispid_Action), helpstring("Gets name of the action in progress.")]
  HRESULT Action([out, retval] BSTR* pbstrAction);

  [propget, id(dispid_Target), helpstring("Gets the name of the target object for the action in progress.")]
  HRESULT Target([out, retval] BSTR* pbstrTarget);

}; // End: interface IPigShipEvent : IPigEvent


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(892FA168-E797-11d2-A508-00C04F68DEB0),
  helpstring("Interface to a Pig Vector object.")
]
interface IPigVector : IDispatch
{
  [propput, helpstring("Gets/sets the x coordinate of the vector.")]
  HRESULT X([in] float xArg);
  [propget, id(dispid_X)]
  HRESULT X([out, retval] float* pxArg);

  [propput, helpstring("Gets/sets the y coordinate of the vector.")]
  HRESULT Y([in] float yArg);
  [propget, id(dispid_Y)]
  HRESULT Y([out, retval] float* pyArg);

  [propput, helpstring("Gets/sets the z coordinate of the vector.")]
  HRESULT Z([in] float zArg);
  [propget, id(dispid_Z)]
  HRESULT Z([out, retval] float* pzArg);

  [id(dispid_SetXYZ), helpstring("Sets the x, y, and z coordinates of the vector.")]
  HRESULT SetXYZ([in] float xArg, [in] float yArg, [in] float zArg);

  [propget, id(DISPID_VALUE), helpstring("Gets the displayable string representation of the vector.")]
  HRESULT DisplayString([out, retval] BSTR* pbstrDisplayString);

}; // End: interface IPigVector : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(64323312-E7DB-11d2-A508-00C04F68DEB0),
  helpstring("Interface to a Pig Account object.")
]
interface IPigAccount : IDispatch
{
  [propget, id(DISPID_VALUE), helpstring("Gets the account name.")]
  HRESULT Name([out, retval] BSTR* pbstrName);

  [propget, id(dispid_Password), helpstring("Gets the account password.")]
  HRESULT Password([out, retval] BSTR* pbstrPassword);

}; // End: interface IPigAccount : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(9FFC3A84-E7C7-11d2-A508-00C04F68DEB0),
  helpstring("Interface to a Pig Account Dispenser object.")
]
interface IPigAccountDispenser : IDispatch
{
  [propget, id(dispid_NextAvailable), helpstring("Gets an available account and marks it 'in-use'.")]
  HRESULT NextAvailable([out, retval] IPigAccount** ppAccount);

  [propget, id(dispid_Names), helpstring("Gets a collection of all the managed user names.")]
  HRESULT Names([out, retval] ITCStrings** ppNames);

  [propget, id(dispid_NamesAvailable), helpstring("Gets a collection of the available user names.")]
  HRESULT NamesAvailable([out, retval] ITCStrings** ppNames);

  [propget, id(dispid_NamesInUse), helpstring("Gets a collection of the user names in use.")]
  HRESULT NamesInUse([out, retval] ITCStrings** ppNames);

}; // End: interface IPigAccountDispenser : IDispatch


/////////////////////////////////////////////////////////////////////////////
[
  object, dual, pointer_default(unique), nonextensible,
  uuid(5B9E660C-F8FD-11d2-A50F-00C04F68DEB0),
  helpstring("Interface to a collection of hull type objects.")
]
interface IPigHullTypes : ITCCollection
{
  ///////////////////////////////////////////////////////////////////////////
  // Parameters:
  //   index - A *VARIANT* of type *VT_BSTR* that specifies the name of an
  // item in the collection.
  //   ppHullType - Address of a variable to receive the specified item from
  // the collection.
  //
  // Return Value: One of the following results:
  //
  //   S_OK - The method completed successfully.
  //   E_POINTER - The specified pointer is invalid.
  //   E_INVALIDARG - The specified index is out of range.
  [propget, id(DISPID_VALUE), helpstring("Returns an IAGCHullType* from the collection or NULL if the specified named hull type does not exist in the collection. Takes an argument, index, which must be either the name of a hull type in the collection or a 0-based index into the collection.")]
  HRESULT Item([in] VARIANT* pvIndex, [out, retval] IAGCHullType** ppHullType);

}; // End: interface IPigHullTypes : ITCCollection



/////////////////////////////////////////////////////////////////////////////

cpp_quote("#if defined(__cplusplus) && _MSC_VER >= 1100")
cpp_quote("  extern \"C++\"")
cpp_quote("  {")
cpp_quote("    /////////////////////////////////////////////////////////////////////////")
cpp_quote("    // Smart Pointer Declarations")
cpp_quote("")
cpp_quote("    #include <comdef.h>")
cpp_quote("")
cpp_quote("    #ifndef TC_COM_SMARTPTR_TYPEDEF")
cpp_quote("      #define TC_COM_SMARTPTR_TYPEDEF(Interface) \\")
cpp_quote("        _COM_SMARTPTR_TYPEDEF(Interface, __uuidof(Interface))")
cpp_quote("    #endif // TC_COM_SMARTPTR_TYPEDEF")
cpp_quote("")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehaviorType);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehaviorTypes);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehaviorScriptType);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehaviorHost);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehavior);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehaviors);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigBehaviorStack);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPig);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigs);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigTeam);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigTeams);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigMission);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigMissionParams);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigMissionParamsPrivate);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigMissions);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigLobby);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigLobbies);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigSession);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigSessionEvents);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigEvent);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigTimer);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigShip);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigShipEvent);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigVector);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigAccount);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigAccountDispenser);")
cpp_quote("    TC_COM_SMARTPTR_TYPEDEF(IPigHullTypes);")
cpp_quote("")
cpp_quote("  } // extern \"C++\"")
cpp_quote("#endif // defined(__cplusplus) && _MSC_VER >= 1100")
cpp_quote("")