unrealwiki:Sandbox: Difference between revisions

From Unreal Wiki, The Unreal Engine Documentation Site
No edit summary
mNo edit summary
 
(8 intermediate revisions by 4 users not shown)
Line 1: Line 1:
Do not edit the area above the separator line, please.
Do not edit the area above the separator line, please.
----
----
[[Legacy:Actor]]
UIComp_DrawImage custom subclasses:
[[Actor]]
{{#dpl:
[[UE3:Actor (UT3)]]
|category=Subclasses of UIComp_DrawImage{{!}}Subclasses of UIComp_DrawImage (UE3)}{{!}}Subclasses of UIComp_DrawImage (UT3)
[[Project:Sandbox]]
|category=Custom classes{{!}}Custom UE3-specific classes{{!}}Custom UT3-specific classes
 
|namespace={{#if:UE3|{{!}}UE3}}{{!}}User
<uscript>
|format=,[[%PAGE%|%TITLE%]],,
// Extended to add support for weapon idle animations
|inlinetext=,&#32;
//////////////////////////////////////////////////////
|shownamespace=false
simulated state Active
|replaceintitle=/ (?!\()/,_
{
|resultsheader=\n;Known custom subclasses&#58;:
simulated function BeginState(name PreviousStateName)
|oneresultheader=\n;Known custom subclass&#58;:
{
|noresultsheader=<nowiki></nowiki>
local int i;
|allowcachedresults=true
 
}}
// Cache a reference to the AI controller
if (Role == ROLE_Authority)
{
CacheAIController();
}
 
if  ( SendToIdleState() )
{
if ( GetZoomedState() == ZST_Zoomed )
{
PushState('Zoomed');
}
}
 
OnAnimEnd(none, 0.f, 0.f);
if ( UTBot(Instigator.Controller) != None )
{
if ( PendingFire(0) )
{
StillFiring(0);
}
else if ( PendingFire(1) )
{
StillFiring(1);
}
}
 
// Check to see if we need to go down
  if( bWeaponPutDown )
{
`LogInv("Weapon put down requested during transition, put it down now");
PutDownWeapon();
}
else if ( !HasAnyAmmo() )
{
WeaponEmpty();
}
else if ( bAutoFire )
{
        // if either of the fire modes are pending, perform them
for( i=0; i<GetPendingFireLength(); i++ )
{
if ( PendingFire(i) )
{
BeginFire(i);
break;
}
}
}
 
if (InvManager != none && InvManager.LastAttemptedSwitchToWeapon != none)
{
if (InvManager.LastAttemptedSwitchToWeapon != self)
{
InvManager.LastAttemptedSwitchToWeapon.ClientWeaponSet(true);
}
InvManager.LastAttemptedSwitchToWeapon = none;
}
}
 
/**
* Override BeginFire to verify that the pawn isn't busy (performing other blocking animations, etc.) as well
* as handle starting the prefire sequence if this weapon has a prefire animation.
*/
simulated function BeginFire(byte FireModeNum)
{
// verify that our owning pawn isn't busy before calling Super.BeginFire(), which is where PendingFire is set
if ( !IsFiringAllowed(FireModeNum) )
{
return;
}
 
// `log(`location @ `showvar(IsTimerActive(nameof(DelayedFire)),DelayedFire Active));
 
// if this weapon uses a prefire animation
if ( FireModeNum < PrefireDelay.Length && PreFireDelay[FireModeNum] > 0 )
{
PrefireCachedStartTrace = InstantFireStartTrace();
if ( FireModeNum == 0 )
{
// if there is already a timer for this, it means that the user is spamming the fire button
// and we are still performing the prefire sequence from the first time the user pressed the
// fire button
if ( IsTimerActive(nameof(DelayedFire)) )
{
return;
}
 
// do the actual firing of the weapon after the prefire sequence has been completed.
SetTimer(PreFireDelay[FireModeNum], false, nameof(DelayedFire));
}
else if ( FireModeNum == 1 )
{
// if there is already a timer for this, it means that the user is spamming the fire button
// and we are still performing the prefire sequence from the first time the user pressed the
// fire button
if ( IsTimerActive(nameof(DelayedAltFire)) )
{
return;
}
 
// do the actual firing of the weapon after the prefire sequence has been completed.
SetTimer(PreFireDelay[FireModeNum], false, nameof(DelayedAltFire));
}
else
{
`log("Unhandled fire mode in" @ Name $ "." $ GetFuncName() @ "-" @ FireModeNum);
ScriptTrace();
}
 
// ensure our weapon mode is custom so that CustomFire() is called right now.  CustomFire() will do the prefire stuff
WeaponFireTypes[FireModeNum] = EWFT_Custom;
}
 
Super.BeginFire(FireModeNum);
}
 
/**
* Called when an animation ends.
*
* Always return to the weapon idle animation after our last played custom animation is finished, if it has one.
*/
simulated event OnAnimEnd( optional AnimNodeSequence SeqNode, optional float PlayedTime, optional float ExcessTime )
{
// we do NOTHING, very much on purpose, so that UT will stop triggering our idle animation while we're in the middle
// of doing something else.
}
 
/**
* Starts a random idle animation.
*/
simulated function PlayWeaponIdleAnim( optional bool bLocalOnly )
{
Global.PlayWeaponIdleAnim(bLocalOnly);
}
 
 
/**
* Called when zooming starts.
*
* @param WeaponOwner value of Instigator.Controller, the player that is holding this weapon.w
*/
simulated function StartZoom(UTPlayerController WeaponOwner)
{
`wtrace_enter(Self,`showvar(WeaponOwner));
 
// calling Global.StartZoom() will result in the PlayWeaponIdleAnimation() function being called.  Since we are transitioning into
// a zoomed state, we want the idle animation that is played to be the one setup for the zoom mode.  Therefore, PushState() prior
// to calling Global.StartZoom() so that Zoomed.PlayWeaponIdleAnim() is called rather than our version.
PushState('Zoomed');
Global.StartZoom(WeaponOwner);
 
// and just to be on the safe side.
PlayWeaponIdleAnim();
 
`wtrace_exit(Self);
}
}
 
simulated state WeaponEquipping
{
/**
* Overridden to trigger our weapon equip animation and hide the carry attachment.
*/
simulated event BeginState(Name PreviousStateName)
{
Super.BeginState(PreviousStateName);
 
if ( !bDisplayAmmoAttachment )
{
ToggleCarryAttachment(false);
}
}
}
 
simulated state WeaponFiring
{
ignores SwitchAmmoTypes;
/**
* Timer event, call is set up in Weapon::TimeWeaponFiring().
* The weapon is given a chance to evaluate if another shot should be fired.
* This event defines the weapon's rate of fire.
*/
simulated function RefireCheckTimer()
{
if ( IsTimerActive(nameof(DelayedFire)) || IsTimerActive(nameof(DelayedAltFire)) )
{
return;
}
Super.RefireCheckTimer();
}
 
simulated event BeginState(name PreviousStateName)
{
// this call will result in WeaponFired() being called, which spawns our effects.
// After returning from this function, the CheckRefire timer function will be active.
Super.BeginState(PreviousStateName);
}
 
simulated event EndState(name NextStateName)
{
local int Idx;
 
if ( NextStateName == 'Active' )
{
for ( Idx = 0; Idx < GetPendingFireLength(); Idx++ )
{
ClearPendingFire(Idx);
}
}
 
Super.EndState(NextStateName);
}
 
simulated function StartZoom(UTPlayerController WeaponOwner)
{
// don't allow the player to switch zooming modes while reloading
}
 
simulated function EndZoom(UTPlayerController WeaponOwner)
{
// don't allow the player to switch zooming modes while reloading
}
}
 
/** Override BeginFire so that it will enter the firing state right away. */
simulated function BeginFire(byte FireModeNum)
{
 
// verify that our owning pawn isn't busy before calling Super.BeginFire(), which is where PendingFire is set
if ( !IsFiringAllowed(FireModeNum) )
{
return;
}
//`log(`location @ `showvar(IsTimerActive(nameof(DelayedFire)),DelayedFire Active));
 
Super.BeginFire(FireModeNum);
 
}
 
 
/**
* For tracehit weapons with no prefire delay, handles firing the weapon.
*/
simulated function InstantFire()
{
//`log(`location);
CustomFire();
PerformInstantFire();
}
 
/**
* For weapons using projectiles, which have no prefire delay - fires the weapon.
*/
simulated function Projectile ProjectileFire()
{
//`log(`location);
CustomFire();
return Super.ProjectileFire();
 
}
 
simulated function Delayed_CustomFire( byte FireModeNum );
 
/**
* Called on a timer (set in BeginFire()), this is called only for weapons which have a prefire delay.
*/
simulated function DelayedFire()
{
DelayedWeaponFire(0);
}
 
/**
* Called on a timer (set in BeginFire()), this is called only for weapons which have a prefire delay.
*/
simulated function DelayedAltFire()
{
DelayedWeaponFire(1);
}
 
simulated function DelayedWeaponFire( byte FireModeNum )
{
//`log(`location);
// restore our WeaponFireType, since we switched it to EWFT_Custom in BeginFire()
WeaponFireTypes[FireModeNum] = default.WeaponFireTypes[FireModeNum];
if ( WeaponFireTypes[FireModeNum] == EWFT_InstantHit )
{
// our own version of InstantFire() is only called for weapons that do not have a prefire
// delay, so go directly to our parent class/state version
PerformInstantFire();
}
else if ( WeaponFireTypes[FireModeNum] == EWFT_Projectile )
{
// our own version of ProjectileFire() is only called for weapons that do not have a prefire
// delay, so go directly to our parent class/state version
Super.ProjectileFire();
}
else if ( WeaponFireTypes[FireModeNum] == EWFT_Custom )
{
Delayed_CustomFire(FireModeNum);
}
 
PrefireCachedStartTrace = vect(0,0,0);
}
 
/**
* Utility function to allow me to inject some debugging code prior to passing control to our parent classes.
*/
protected simulated function PerformInstantFire()
{
Super.InstantFire();
}
 
</uscript>
 
Testing UScript highlighter...
<uscript>
class X extends Y within Z
    implements(I)
    nottransient;
 
`include(SomeFile.uci)
 
 
var(Group) interp struct Type {
  var() bool bCorrect;
  var array<class<Actor> > ActorClasses;
} VarName;
 
reliable client function CheckType(optional class<Actor> ActorClass)
{
  local int i;
 
  for (i = 0; i < VarName.ActorClasses.Length; ++i) {
    if (ActorClass == None || ClassIsChildOf(VarName.ActorClasses[i], ActorClass)) {
      VarName.ActorClasses[i].static.StaticSaveConfig();
      continue;
    }
    VarName.ActorClasses.Remove(i--, 1);
  }
  VarName.bCorrect = True;
}
 
static function byte GetHash(int Value)
{
  switch (Value) {
    case -1:
      return 0;
    case 0xCAFE:
      return 1
    default:
      return (Value >= 0 && Value < 10) ? class'Hasher'.default.Hash[Value] : (Value & 0xff);
  }
}
 
defaultproperties
{
  VarName.Empty
  VarName[0] = {(
    bCorrect = True,
    ActorClasses.Add(class'ReplicationInfo')
  )}
}
</uscript>

Latest revision as of 01:55, 9 August 2015

Do not edit the area above the separator line, please.


UIComp_DrawImage custom subclasses: