engineclasses.h

虚幻的再开发程序包源代码

    FLOAT LensFlareScale[12];
    BYTE MinLightCount;
    BYTE MaxLightCount;
    INT MinLightingPolyCount;
    INT MaxLightingPolyCount;
    DECLARE_FUNCTION(execZoneActors);
    void eventActorLeaving(class AActor* Other)
    {
        struct {class AActor* Other; } Parms;
        Parms.Other=Other;
        ProcessEvent(FindFunctionChecked(ENGINE_ActorLeaving),&Parms);
    }
    void eventActorEntered(class AActor* Other)
    {
        struct {class AActor* Other; } Parms;
        Parms.Other=Other;
        ProcessEvent(FindFunctionChecked(ENGINE_ActorEntered),&Parms);
    }
    DECLARE_CLASS(AZoneInfo,AInfo,0)
    #include "AZoneInfo.h"
};


class ENGINE_API AWarpZoneInfo : public AZoneInfo
{
public:
    FStringNoInit OtherSideURL;
    FName ThisTag;
    BITFIELD bNoTeleFrag:1;
    INT iWarpZone;
    FCoords WarpCoords;
    class AWarpZoneInfo* OtherSideActor;
    class UObject* OtherSideLevel;
    FStringNoInit Destinations[8];
    INT numDestinations;
    DECLARE_FUNCTION(execUnWarp);
    DECLARE_FUNCTION(execWarp);
    void eventForceGenerate()
    {
        ProcessEvent(FindFunctionChecked(ENGINE_ForceGenerate),NULL);
    }
    void eventGenerate()
    {
        ProcessEvent(FindFunctionChecked(ENGINE_Generate),NULL);
    }
    DECLARE_CLASS(AWarpZoneInfo,AZoneInfo,0)
    NO_DEFAULT_CONSTRUCTOR(AWarpZoneInfo)
};


class ENGINE_API ASkyZoneInfo : public AZoneInfo
{
public:
    DECLARE_CLASS(ASkyZoneInfo,AZoneInfo,0)
    NO_DEFAULT_CONSTRUCTOR(ASkyZoneInfo)
};

enum ENetMode
{
    NM_Standalone           =0,
    NM_DedicatedServer      =1,
    NM_ListenServer         =2,
    NM_Client               =3,
    NM_MAX                  =4,
};
enum ELevelAction
{
    LEVACT_None             =0,
    LEVACT_Loading          =1,
    LEVACT_Saving           =2,
    LEVACT_Connecting       =3,
    LEVACT_Precaching       =4,
    LEVACT_MAX              =5,
};

class ENGINE_API ALevelInfo : public AZoneInfo
{
public:
    FLOAT TimeDilation;
    FLOAT TimeSeconds;
    INT Year;
    INT Month;
    INT Day;
    INT DayOfWeek;
    INT Hour;
    INT Minute;
    INT Second;
    INT Millisecond;
    FStringNoInit Title;
    FStringNoInit Author;
    FStringNoInit IdealPlayerCount;
    INT RecommendedEnemies;
    INT RecommendedTeammates;
    FStringNoInit LevelEnterText;
    FStringNoInit LocalizedPkg;
    FStringNoInit Pauser;
    BITFIELD bLonePlayer:1;
    BITFIELD bBegunPlay:1;
    BITFIELD bPlayersOnly:1;
    BITFIELD bHighDetailMode:1;
    BITFIELD bStartup:1;
    BITFIELD bHumansOnly:1;
    BITFIELD bNoCheating:1;
    class UMusic* Song;
    BYTE SongSection;
    BYTE CdTrack;
    FLOAT PlayerDoppler;
    FLOAT Brightness;
    class UTexture* Screenshot;
    class UTexture* DefaultTexture;
    INT HubStackLevel;
    BYTE LevelAction;
    BYTE NetMode;
    FStringNoInit ComputerName;
    FStringNoInit EngineVersion;
    FStringNoInit MinNetVersion;
    class UClass* DefaultGameType;
    class AGameInfo* Game;
    class ANavigationPoint* NavigationPointList;
    class APawn* PawnList;
    FStringNoInit NextURL;
    BITFIELD bNextItems:1;
    FLOAT NextSwitchCountdown;
    INT AIProfile[8];
    FLOAT AvgAITime;
    BITFIELD bCheckWalkSurfaces:1;
    DECLARE_FUNCTION(execGetAddressURL);
    DECLARE_FUNCTION(execGetLocalURL);
    void eventServerTravel(const FString& URL, BITFIELD bItems)
    {
        struct {FString URL; BITFIELD bItems; } Parms;
        Parms.URL=URL;
        Parms.bItems=bItems;
        ProcessEvent(FindFunctionChecked(ENGINE_ServerTravel),&Parms);
    }
    DECLARE_CLASS(ALevelInfo,AZoneInfo,0)
    NO_DEFAULT_CONSTRUCTOR(ALevelInfo)
};


class ENGINE_API AGameInfo : public AInfo
{
public:
    INT ItemGoals;
    INT KillGoals;
    INT SecretGoals;
    BYTE Difficulty;
    BITFIELD bNoMonsters:1;
    BITFIELD bMuteSpectators:1;
    BITFIELD bHumansOnly:1;
    BITFIELD bRestartLevel:1;
    BITFIELD bPauseable:1;
    BITFIELD bCoopWeaponMode:1;
    BITFIELD bClassicDeathmessages:1;
    BITFIELD bLowGore:1;
    BITFIELD bCanChangeSkin:1;
    BITFIELD bTeamGame:1;
    BITFIELD bVeryLowGore:1;
    BITFIELD bNoCheating:1;
    BITFIELD bDeathMatch:1;
    BITFIELD bGameEnded:1;
    BITFIELD bOverTime:1;
    FLOAT AutoAim;
    FLOAT GameSpeed;
    FLOAT StartTime;
    class UClass* DefaultPlayerClass;
    class UClass* DefaultWeapon;
    INT MaxSpectators;
    INT NumSpectators;
    FStringNoInit AdminPassword;
    FStringNoInit GamePassword;
    class UClass* ScoreBoardType;
    class UClass* GameMenuType;
    FStringNoInit BotMenuType;
    FStringNoInit RulesMenuType;
    FStringNoInit SettingsMenuType;
    FStringNoInit GameUMenuType;
    FStringNoInit MultiplayerUMenuType;
    FStringNoInit GameOptionsMenuType;
    class UClass* HUDType;
    class UClass* MapListType;
    FStringNoInit MapPrefix;
    FStringNoInit BeaconName;
    FStringNoInit SpecialDamageString;
    FStringNoInit SwitchLevelMessage;
    INT SentText;
    FStringNoInit DefaultPlayerName;
    FStringNoInit LeftMessage;
    FStringNoInit FailedSpawnMessage;
    FStringNoInit FailedPlaceMessage;
    FStringNoInit FailedTeamMessage;
    FStringNoInit NameChangedMessage;
    FStringNoInit EnteredMessage;
    FStringNoInit GameName;
    FStringNoInit MaxedOutMessage;
    FStringNoInit WrongPassword;
    FStringNoInit NeedPassword;
    INT MaxPlayers;
    INT NumPlayers;
    INT CurrentID;
    class UClass* MutatorClass;
    class AMutator* BaseMutator;
    class UClass* WaterZoneType;
    FName DefaultPlayerState;
    class UClass* GameReplicationInfoClass;
    class AGameReplicationInfo* GameReplicationInfo;
    FStringNoInit ServerLogName;
    class AStatLog* LocalLog;
    class AStatLog* WorldLog;
    BITFIELD bLocalLog:1;
    BITFIELD bLocalLogQuery:1;
    BITFIELD bWorldLog:1;
    BITFIELD bLoggingGame:1;
    FStringNoInit LocalLogFileName;
    FStringNoInit WorldLogFileName;
    FStringNoInit LocalBatcherURL;
    FStringNoInit LocalBatcherParams;
    FStringNoInit LocalStatsURL;
    FStringNoInit WorldBatcherURL;
    FStringNoInit WorldBatcherParams;
    FStringNoInit WorldStatsURL;
    DECLARE_FUNCTION(execParseKillMessage);
    DECLARE_FUNCTION(execBrowseRelativeLocalURL);
    DECLARE_FUNCTION(execExecuteWorldLogBatcher);
    DECLARE_FUNCTION(execExecuteLocalLogBatcher);
    DECLARE_FUNCTION(execGetNetworkNumber);
    void eventAcceptInventory(class APawn* PlayerPawn)
    {
        struct {class APawn* PlayerPawn; } Parms;
        Parms.PlayerPawn=PlayerPawn;
        ProcessEvent(FindFunctionChecked(ENGINE_AcceptInventory),&Parms);
    }
    void eventPostLogin(class APlayerPawn* NewPlayer)
    {
        struct {class APlayerPawn* NewPlayer; } Parms;
        Parms.NewPlayer=NewPlayer;
        ProcessEvent(FindFunctionChecked(ENGINE_PostLogin),&Parms);
    }
    class APlayerPawn* eventLogin(const FString& Portal, const FString& Options, FString& Error, class UClass* SpawnClass)
    {
        struct {FString Portal; FString Options; FString Error; class UClass* SpawnClass; class APlayerPawn* ReturnValue; } Parms;
        Parms.Portal=Portal;
        Parms.Options=Options;
        Parms.Error=Error;
        Parms.SpawnClass=SpawnClass;
        Parms.ReturnValue=0;
        ProcessEvent(FindFunctionChecked(ENGINE_Login),&Parms);
        Error=Parms.Error;
        return Parms.ReturnValue;
    }
    void eventPreLogin(const FString& Options, FString& Error)
    {
        struct {FString Options; FString Error; } Parms;
        Parms.Options=Options;
        Parms.Error=Error;
        ProcessEvent(FindFunctionChecked(ENGINE_PreLogin),&Parms);
        Error=Parms.Error;
    }
    FString eventGetBeaconText()
    {
        struct {FString ReturnValue; } Parms;
        ProcessEvent(FindFunctionChecked(ENGINE_GetBeaconText),&Parms);
        return Parms.ReturnValue;
    }
    void eventInitGame(const FString& Options, FString& Error)
    {
        struct {FString Options; FString Error; } Parms;
        Parms.Options=Options;
        Parms.Error=Error;
        ProcessEvent(FindFunctionChecked(ENGINE_InitGame),&Parms);
        Error=Parms.Error;
    }
    void eventDetailChange()
    {
        ProcessEvent(FindFunctionChecked(ENGINE_DetailChange),NULL);
    }
    void eventGameEnding()
    {
        ProcessEvent(FindFunctionChecked(ENGINE_GameEnding),NULL);
    }
    DECLARE_CLASS(AGameInfo,AInfo,0|CLASS_Config)
    NO_DEFAULT_CONSTRUCTOR(AGameInfo)
};


class ENGINE_API ANavigationPoint : public AActor
{
public:
    FName ownerTeam;
    BITFIELD taken:1;
    INT upstreamPaths[16];
    INT Paths[16];
    INT PrunedPaths[16];
    class ANavigationPoint* VisNoReachPaths[16];
    INT visitedWeight;
    class AActor* RouteCache;
    INT bestPathWeight;
    class ANavigationPoint* nextNavigationPoint;
    class ANavigationPoint* nextOrdered;
    class ANavigationPoint* prevOrdered;
    class ANavigationPoint* startPath;
    class ANavigationPoint* previousPath;
    INT cost;
    INT ExtraCost;
    BITFIELD bPlayerOnly:1;
    BITFIELD bEndPoint:1;
    BITFIELD bEndPointOnly:1;
    BITFIELD bSpecialCost:1;
    BITFIELD bOneWayPath:1;
    BYTE PathDescription;
    DECLARE_FUNCTION(execdescribeSpec);
    BITFIELD eventAccept(class AActor* Incoming)
    {
        struct {class AActor* Incoming; BITFIELD ReturnValue; } Parms;
        Parms.Incoming=Incoming;
        Parms.ReturnValue=0;
        ProcessEvent(FindFunctionChecked(ENGINE_Accept),&Parms);
        return Parms.ReturnValue;
    }
    INT eventSpecialCost(class APawn* Seeker)
    {
        struct {class APawn* Seeker; INT ReturnValue; } Parms;
        Parms.Seeker=Seeker;
        Parms.ReturnValue=0;
        ProcessEvent(FindFunctionChecked(ENGINE_SpecialCost),&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(ANavigationPoint,AActor,0)
    NO_DEFAULT_CONSTRUCTOR(ANavigationPoint)
};


class ENGINE_API ALiftExit : public ANavigationPoint
{
public:
    FName LiftTag;
    class AMover* MyLift;
    FName LiftTrigger;
    class ATrigger* RecommendedTrigger;
    FLOAT LastTriggerTime;
    DECLARE_CLASS(ALiftExit,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(ALiftExit)
};


class ENGINE_API ALiftCenter : public ANavigationPoint
{
public:
    FName LiftTag;
    class AMover* MyLift;
    FName LiftTrigger;
    class ATrigger* RecommendedTrigger;
    FLOAT LastTriggerTime;
    FLOAT MaxZDiffAdd;
    DECLARE_CLASS(ALiftCenter,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(ALiftCenter)
};


class ENGINE_API AWarpZoneMarker : public ANavigationPoint
{
public:
    class AWarpZoneInfo* markedWarpZone;
    class AActor* TriggerActor;
    class AActor* TriggerActor2;
    DECLARE_CLASS(AWarpZoneMarker,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(AWarpZoneMarker)
};


class ENGINE_API AButtonMarker : public ANavigationPoint
{
public:
    DECLARE_CLASS(AButtonMarker,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(AButtonMarker)
};


class ENGINE_API ATriggerMarker : public ANavigationPoint
{
public:
    DECLARE_CLASS(ATriggerMarker,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(ATriggerMarker)
};


class ENGINE_API AInventorySpot : public ANavigationPoint
{
public:
    class AInventory* markedItem;
    DECLARE_CLASS(AInventorySpot,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(AInventorySpot)
};


class ENGINE_API APlayerStart : public ANavigationPoint
{
public:
    BYTE TeamNumber;
    BITFIELD bSinglePlayerStart:1;
    BITFIELD bCoopStart:1;
    BITFIELD bEnabled:1;
    DECLARE_CLASS(APlayerStart,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(APlayerStart)
};


class ENGINE_API ATeleporter : public ANavigationPoint
{
public:
    FStringNoInit URL;
    FName ProductRequired;
    BITFIELD bChangesVelocity:1;
    BITFIELD bChangesYaw:1;
    BITFIELD bReversesX:1;
    BITFIELD bReversesY:1;
    BITFIELD bReversesZ:1;
    BITFIELD bEnabled:1;
    FVector TargetVelocity;
    class AActor* TriggerActor;
    class AActor* TriggerActor2;
    DECLARE_CLASS(ATeleporter,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(ATeleporter)
};


class ENGINE_API APathNode : public ANavigationPoint
{
public:
    DECLARE_CLASS(APathNode,ANavigationPoint,0)
    NO_DEFAULT_CONSTRUCTOR(APathNode)
};


class ENGINE_API ADecora