//=================================================
// RainGen.
// author: c0mpi1e(Carlos Cuello)
// Total Time So Far: 20 hrs.
//
// legal: Everything in this class is 100% original and is the
// property of me. It was originally
// produced for the USCM:Infestation TC, and any revisions
// to this mod will be used in that. This is the final
// version that I will release to the public. You may use
// this in any map and release it as part of any map you
// create as long as you give me full credit. If you need
// anything added in particular you can email me and I'll see
// what I can do.
//
// This is basically what controls the Rain and is the only thing you
// will have to work with. I wanted to keep this something that anyone
// can use, tried to keep it very configurable and tried to make
// everything be handled from UnrealEd. So for all you map makers,
// simply add as many raingen's to the ceiling of the sky where you want
// it to fall from. The RainGen delivers a limited range of raindrops, so
// do not expect one raingen to create a monsoon. To change the various
// settings for the rain, select all the RainGens in your map and click
// on the properties dialog box, then click on the several Rain propety
// menu's that appear(Rain_Behaviour, Rain_Looks, Rain_Sounds). The
// intensity variable should be kept between 0 and 5 or so to keep
// rendering speed good. DropSpeed should be negative for faster rain,
// and positive for slower rain, however beware that a positive integer
// greater than 100 or so will cause the raindrops to go up and hit the
// ceiling.
//
// Note: For this release, lightning is not working, if you absolutley
// need it, then email me and I'll see what I can do.
//=================================================
class RainGen expands Effects;
// Variables you can manipulate from UnrealED
// This enum lets a mapper or whatnot choose between 3 different sprites
// for the rain drop. The parenthesis after var tells unreal that this
// variable can be changed from Unrealed, if you put something in the
// parenthesis then that will be the parent menu of the variable.
var(Rain_Looks) enum ERainType
{
Rain_Drop,
Rain_Line,
Rain_LongLine
} RainDrawType;
var(Rain_Looks) float DropSize; // The size of each drop
var(Rain_Behaviour) int intensity; // The intensity of the rain
var(Rain_Behaviour) int DropSpeed; // determines the drop speed. Neg numbers
// make it drop faster, positive slows it
// down, should be modified for the
// default properties dialog
var(Rain_Behaviour) int RainRadius; // The radius of the rain, which is
// random from 0 to RainRadius
var(Rain_Behaviour) bool bThunder;
var(Rain_Behaviour) bool bLightning; // not implemented yet
var(Rain_Sounds) Sound ThunderSound1;
var(Rain_Sounds) Sound ThunderSound2;
var(Rain_Sounds) int SoundRadius;
var(Rain_Sounds) int RainVolume;
// Private Variables we want to keep to ourselves
var int ct; // misc counter variable, used for
// for loops, rather have it as a global
// variable because we might use it more
// than once.
var Effects D; // the actual raindrop
var Effects L; // used for lightining
var vector NewLoc; // the location of the random rain drop
// Set all our variables.
simulated function PreBeginPlay()
{
Super.PreBeginPlay();
// We want to enable the timer
Enable('Timer');
// Set the timer for every ten clicks we want the thunder to be
// handled here, randomly. If you put this into the tick function
// it slows things down considerably.
SetTimer(10, true);
// Play the rain sound, using the Ambient slot
PlaySound(EffectSound1, Slot_Ambient, RainVolume,, SoundRadius);
}
// Find a random number from -Max to Max
function int RandomNeg(int Max)
{
local int k;
k = Rand(Max + 1);
if (Rand(2) == 1)
k = -k;
return k;
}
// This is where thunder and lightning are handled
function Timer()
{
Super.Timer();
if (bThunder == true && Rand(5) < 3)
{
// Randomly choose which thunder sound to use
if (Frand() < 0.5)
PlaySound(ThunderSound1, Slot_Misc, 25, true);
else
PlaySound(ThunderSound2, Slot_Misc, 25, true);
}
// If we go into the timer, but have bThunder set to false
// then we no longer want to call the timer, we can put this before
// in PreBeginPlay, but because we use default properties
// to handle everything, we will not know then.
if (bThunder == false)
Disable('Timer');
}
// This is where everything takes place
function Tick(float deltatime)
{
// For the number of intensity that is set from UnrealEd, then
// spawn a new raindrop
for (ct = 0; ct < intensity; ct ++)
// Find a new location for the spawned RainDrop, using my
// function RandomNeg() and base it off of the current Location
// we only want to produce one on the horizontal plane of
// sky or ceiling, so we leave the Z axes alone.
NewLoc.X = Location.X + RandomNeg(RainRadius);
NewLoc.Y = Location.Y + RandomNeg(RainRadius);
NewLoc.Z = Location.Z;
// Spawn a raindrop at NewLoc
d = Spawn(class'RainDrops',,,NewLoc);
// Set the size to what the user specified
d.DrawScale = DropSize;
// Same with the speeed
d.Velocity.Z = DropSpeed;
// Depending on what you choose for RainDrawType then set
// the appropriate Texture.
switch RainDrawType
{
case Rain_Drop:
d.Texture = Texture'RainDrop4';
break;
case Rain_Line:
d.Texture = Texture'RainLong';
break;
case Rain_LongLine:
d.Texture = Texture'RainLonger';
break;
default:
d.Texture = Texture'RainDrop4';
}
}
}
//============================================
// RainDrops
//============================================
class RainDrops expands Effects;
var effects d;
function PreBeginPlay()
{
Super.PostBeginPlay();
// Make the rain actually fall :)
SetPhysics(PHYS_Falling);
}
// When a drop hits a wall or lands on the ground then create
// a small rain puddle effect
function HitWall( vector HitNormal, actor HitWall )
{
Super.HitWall(HitNormal, HitWall);
// 60% chance that there will be a puddle left on the ground
// do this to keep performance up
if (Frand() < 0.8)
Spawn(class'RainPuddle',,,Location);
Destroy();
}
// Same for Landed
function Landed(vector HitNormal)
{
Super.Landed(HitNormal);
if (Frand() < 0.8)
Spawn(class'RainPuddle',,,Location);
Destroy();
}
//===========================================
// RainPuddle.
// Most of the code here is copied from the RingExplosion
// code, basically I just changed the DrawScale to a smaller
// value, I do not take any credit for this outside of that,
// its makes a very nice effect.
//===========================================
class RainPuddle expands Effects;
var bool bSpawnOnce;
simulated function Timer()
{
local WaterRing r;
if ( Level.NetMode != NM_DedicatedServer )
{
r = Spawn(class'WaterRing',,,,rot(16384,0,0));
r.DrawScale = 0.02;
r.RemoteRole = ROLE_None;
}
else
Destroy();
if (bSpawnOnce) Destroy();
bSpawnOnce=True;
}
simulated function PostBeginPlay()
{
SetTimer(0.3,True);
}
|