UT99.org | Unreal Tournament Community

Code: Select all

//=============================================================================
// RPG_LotteryTrigger.
//=============================================================================
class RPG_LotteryTrigger expands Triggers;

var RPG_LotteryTrigger LotteryTrigger;
var playerpawn PP; // The playerpawn that walks into the trigger.

#exec OBJ LOAD FILE="../Sounds/RPG_Test.uax" PACKAGE=RPG_Test
/*
//  exec import: Texture
    #exec TEXTURE IMPORT NAME=NameForTextureToImportAs FILE=PATH\TO\SomeTexture.pcx GROUP=SomeGroup MIPS=OFF FLAGS=2 PALETTE=SomeTexPalette LODSET=2
//  note no terminating ";". Presumably must be all on one line, too

//  exec import: Sound
    #exec AUDIO IMPORT NAME=NameForSoundToImportAs FILE=PATH\TO\Soundfile.wav GROUP=SomeGroup
*/
var int FailCount;
var int WinCount;
var() int FailLimit;
var() int WinLimit;
var() bool bPersistantFails;
var int CurTimer;
//=============================================================================
//var(Events) name Event; // Left here for informative purposes, works like a normal trigger
//=============================================================================
var() bool bTriggerOnceOnly;

event Touch( Actor Other)
// When an Actor intersects with this actor, this event begins
{
    if ( Other.IsA('PlayerPawn') && !IsInState('Lottery') ) 
//   Typecasts from Actor into PlayerPawn
    {
        if ( WinCount >= WinLimit )
        {
            GotoState('');
        }
        else
        {
        PP = PlayerPawn(Other); 
//       Defines PlayerPawn as PP
        GotoState('Lottery');
//       Changes the State from '', or default (none), to 'Lottery'
        SetCollision( false );
        }
    }
    else
    {
        GotoState('');
    }
    if ( bTriggerOnceOnly )
    {
        SetCollision( false );
    }
}
//=============================================================================
// > Code flow is executed after activated by GoToState('Lottery'),
// > If PP (PlayerPawn) = none, then the state ends.
// > A variable integer (var int) is assigned to CurTimer:
//  - The value will later be read by LotteryPanel, then displayed through
//     a single multi-skin for font.
// > The state begins by assigning 3 to CurTimer, playing a sound, then
//    the state sleeps for one second.  This occurs twice more, CurTimer is
//    assigned 0, function DoLottery() executes, the state sleeps for 1.5
//    seconds to maintain the countdown drawn by RPG_LotteryPanel.
// > The state then ends, though DoLottery() has executed before the end of the
//    state and NOT at the end of the state.
//=============================================================================
state Lottery
// A special code flow exectued during the Actor's native Tick.
{
        event EndState()
        // State-only script function, immediately called after this script's
        //  GoToState() call changes the actor into a different (or none) 
        //  state, executed before the next line of code; consider the current 
        //  state's EndState() as an extension of GoToState().
        // In this case, PP = none because he's either died, disconnected or 
        //  the lottery has finished.
        {
                PP = none; 
                // If PP = none, the state ends.
        }
Begin:
        CurTimer = 3;
        // This value is passed on to RPG_LotteryPanel.  
        //  Ex: ( LotteryTrigger.CurTimer > 1 )
        //  CurTimer is later changed into a String.
        PP.PlaySound ( Sound'RPG_Test.RPG_HaloCount');
        // This sound is played from the player themselves.
        Sleep( 1 );
        // Latent function: can only be called within state code, not from
        //  within functions.
        //=====================================================================
        // > Sleep( float Seconds ): Pauses the state execution for a certain 
        //    amount of time, and then continues.
        // > FinishAnim(): Waits until the current animation sequence you're
        //    playing completes, and then continues.
        // > FinishInterpolation(): Waits for the current InterpolationPoint
        //    movement to complete, and then continues.
        // > Stop;
        // > WaitForLanding(); (pawn only)
        // > MoveToward, MoveTo, StrafeFacing, etc (pawn only)
        // > Goto: Operator, paired with a label name (ex: Goto Begin;).  100%
        //    safer than GotoState from within State.
        // You can customize flow control using While() loops paired with
        //  Sleep(0.0); calls.
        //=====================================================================
        CurTimer = 2;
        PP.PlaySound ( Sound'RPG_Test.RPG_HaloCount');
        Sleep( 1 );
        CurTimer = 1;
        PP.PlaySound ( Sound'RPG_Test.RPG_HaloCount');
        Sleep( 1 );
        CurTimer = 0;
        DoLottery();
//       Executes function DoLottery().
      Sleep( 1.5 ); 
//     Added to preserve number 0 CurTimer for RPG_LotteryPanel.
      GotoState('');
//     Default is none.
}

//=============================================================================
// > Function is called from Lottery after timer has ended.
// > If "PP" (PlayerPawn) is deleted while in RPG_LotteryTrigger, state
//    returns to default.
// > If the PlayerPawn remains, a roll is executed with there being three
//    possible roll results.
//  - For each failure, a count is added toward FailCount.
//  - If the random roll result increments FailCount to be greater than or
//     equal to the number defined in the editor, an explosion sprite appears
//     and the player is killed.
//  - If the player succeeds or fails a roll, FailCount is reset to zero.
//
// > This is an example of playing sound through a local pawn after 
//    type the instigator playerpawn to a string (PP). 
/*
    PP.PlaySound (sound'RPG_Test.RPG_NoDamageHit');
*/
//  - Left for informative purposes.
//=============================================================================
function DoLottery()
{
        local float Selection;

        if ( PP == none || PP.bDeleteMe )
//       Player disconnected while in 'Lottery'.
        {
                GotoState('');
                SetCollision( true );
                return;
//              Note that the optional "return" keyword cannot be used in
//               state code.  "return" ends the function or operator, unless
//               the function is designated a value to return, where it
//               will immediately return a value.
        }
        selection = FRand();
        SetCollision( true );
//       Returns a random number from 0.0 to 1.0
        if (Selection >= 0.8)
        {
                GiveWeapon(PP, "UnrealI.FlakCannon", true);
                GiveWeapon(PP, "UnrealShare.Eightball", true);
//               QUESTION: How can this be changed so that rewards can be
//                          edited within the editor's Actor Advanced 
//                          Properties window?
                if ( bPersistantFails )
                {
                    ++WinCount;
                    return;
                }
                else
                {
                    ++WinCount;
                    FailCount = 0;
                    return;
                }
        }
        else if (Selection >= 0.7)
        {
                GiveWeapon(PP, "UnrealI.FlakCannon", true);
                if ( bPersistantFails )
                {
                    ++WinCount;
                    return;
                }
                else
                {
                    ++WinCount;
                    FailCount = 0;
                    return;
                }

        }
        else
        {
                PP.PlaySound (sound'RPG_Test.RPG_NoDamageHit');
                if ( ++FailCount >= FailLimit )
//              "++" increments the modified value of "FailCount" by 1.
                {
//                       Make player explode or something:
                        Spawn(class'SpriteBallExplosion',,,Location);
//                       local Projectile P;
//                       P = Spawn(ProjectileClass, Instigator,,, Instigator.ViewRotation);
                        PP.TakeDamage( 255,none,Location,vect(0,0,50), 'Exploded');
//                       function TakeDamage (int Damage, Pawn InstigatedBy, vector HitLocation, vector Momentum, name DamageType)
                        PP.Died( none, 'Exploded', Location);
//                       function Died (Pawn Killer, name DamageType, vector HitLocation)
                        FailCount = 0;
                        return;
                }
        }
}

function Weapon GiveWeapon(Pawn PlayerPawn, string aClassName, optional bool bBringUp)
{
    local class<Weapon> WeaponClass; // Defines any WeaponClass defined by 
                                     //  "function Weapon GiveWeapon()".
    local Weapon NewWeapon; // Is used to define initial settings for weapon 
                            //  that is created as a result of 
                            //  "function DoLottery()".
 
    WeaponClass = class<Weapon>(DynamicLoadObject(aClassName, class'Class'));
    // Defines the local class<Weapon>, next dynamically loading the
    //  string in line 157 (and others). DynamicLoadObject is a native 
    //  function declared in Object. It loads an object of a specified class.
    //  Which object of that class is specified as a string. The string is the
    //  name of the thing that you want to load. If that thing does not exist
    //  in memory, it will be loaded from the appropriate package file.

    if ( PlayerPawn.FindInventoryType(WeaponClass) != None )
        return None;
    // Checks the PlayerPawn's Inventory for the weapon defined as WeaponClass,
    //  and if found returns 
    newWeapon = Spawn(WeaponClass);
    if ( newWeapon != None ) {
        newWeapon.RespawnTime = 0.0;
        newWeapon.GiveTo(PlayerPawn);
        newWeapon.bHeldItem = true;
        newWeapon.GiveAmmo(PlayerPawn);
        newWeapon.SetSwitchPriority(PlayerPawn);
        newWeapon.WeaponSet(PlayerPawn);
        newWeapon.AmbientGlow = 0;
        if ( PlayerPawn.IsA('PlayerPawn') )
            newWeapon.SetHand(PlayerPawn(PlayerPawn).Handedness);
        else
            newWeapon.GotoState('Idle');
        if ( bBringUp ) {
            PlayerPawn.Weapon.GotoState('DownWeapon');
            PlayerPawn.PendingWeapon = None;
            PlayerPawn.Weapon = newWeapon;
            PlayerPawn.Weapon.BringUp();
        }
    }
    return newWeapon;
}