Changing the game icon in UDK is a surprisingly simple but cool thing you can do to give your game a little more personality.

First of all, you're going to need an image in either .png or .jpg format.  Make it perfectly square, and make sure it'll look good at various sizes, as Windows will make it bigger and smaller depending on whether it's in your taskbar, start menu, or file hierarchy.

Next, take that image to ConvertIcon.com.  Upload it and then export it as a .ico file.

Note: .ico files have pages which store various sizes of the install icon for various uses.  Download your .ico from ConvertIcon in all of the sizes offered and you'll be sure that your game will stand out no matter where it's installed.

Now go into your UDK hierarchy.  You're looking for:

C:\UDK\UDK-2012-07\Binaries\InstallData

In here you'll find a .ico file called GameIcon.  Reserve it someplace else in case you want it back later, and replace it with the one you just made with ConvertIcon, making sure to rename it "GameIcon"

When you cook your game, the UDKInstall will still have the same icon it has always had, but when the game is installed on the hard drive, it will have whatever logo you dropped in there.

Download and install Helios to check out our cool custom icon!
 
Here is a brief tutorial on how to add custom footsteps into UDK. Before I get started please be aware that this tutorial is designed for people who have an intermediate understanding of Unreal Script and UDK. Certain aspects such as importing sound waves into UDK will not be covered in this tutorial since it should be prior knowledge on the readers end. Also note that the scripts used in this tutorial are all custom scripts but the information can applied to the default scripts UDK provides.(Note:  if you do edit the default scripts make copies of the original code prior to any alterations)

To start off in your Custom Pawn script’s default properties you will add a Sound Group Class that the pawn will reference instead of the default Sound Group Class that the UTPawn uses.( Assuming you are extending off of UTPawn). It should look something like this:

class CustomPawn extends UTPawn;

defaultproperties
{

SoundGroup'CustomGameSoundGroup'

}


Next you will need to create a new script that will act as your custom sound group that extends off the UTPawn sound group like this:

Class CustomGameSoundGroup extends UTPawnSoundGroup;

defaultproperties

{

}


In the default properties of this script is the location where you will place your custom footstep sounds that your pawn will use in the game. By default UDK comes with an array of footstep sounds that can be overridden, so for good measure I usually copy and paste the default footstep sounds present in the original sound group used by the UTPawn:

Class CustomGameSoundGroup extends UTPawnSoundGroup;

defaultproperties

{
FootstepSounds[0]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_StoneCue')


FootstepSounds[1]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_DirtCue')


FootstepSounds[2]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_EnergyCue' )


FootstepSounds[3]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_Flesh Cue')


FootstepSounds[4]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_FoliageCue')


FootstepSounds[5]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_GlassPlateCue')


FootstepSounds[6]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_WaterDeepCue')


FootstepSounds[7]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_WaterShallowCue')


FootstepSounds[8]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_MetalCue')


FootstepSounds[9]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_SnowCue')


FootstepSounds[10]=(Material,Sound=SoundCue'A_Character_Footsteps.FootSteps.A_Character_Footstep_WoodCue')

}


In UDK footsteps are produced and recognize by the material texture applied to the static mesh or bsp the pawn is walking on. Sound effects like footsteps are applied to material textures by a physical material as shown below:
The physical material that is applied to the material texture actually houses the location of where the custom sound group script looks at to apply the footstep sounds. Looking back at the default footstep sounds you will see that before the sound cue is referenced in the line of code, a material type is called with a unique name. This material type is what connects the sound cues present in the script to the physical material.

First create a custom physical material and in its properties, go to the very bottom and click the blue arrow on the right of "Physical Material Property" and click "UTPhysicalMaterialProperty". A section called "Material Type" should appear. This is where you put in the type of material you want to have a specific footstep sound.  For example in my game I made footstep sounds for walking in a junkyard.
I put "HeliosJunkYard" as the material type then close it. Navigate to the material texture that I’m going to use it on, open it, and in the Physical Material properties plug in the physical material I just created. Next I have to go back to the CustomGameSoundGroup script that I created and add the sound pathway to the physical material like so:


FootstepSounds[11]=(Material, SoundCue'Helios_SFX.GroundSFX.DirtFS')

(Note: keep in mind that if you have multiple footstep sound effects you will need to number them properly in an array)

Lastly with a quick recompile of my scripts my custom footstep sound is all set to be used in the game.

 
World Switching Transition


In this tutorial  you will see how we were able to create materials that we used to simulate a transition effect between our two worlds similar to what is shown in the video above and picture below. In our game, the player swaps between two different points in time, so we aimed to create an effect that would give the player some great aesthetic feedback for that mechanic.

We are writing this technical guide to aim at a difficulty level that should be considered intermediate, so not every set will be fully in the process, but we will show you how to create the transition materials and how we decided to use them in our game.

Thanks to the entire Epic community for their support, because without such a talented and helpful community, learning how to master UDK would be much more difficult! Special thanks to Sarah Taylor and Danpaz3D in particular for sharing their knowledge on transition effects. Let’s get started!


Creating the Materials

In our game we have two very different worlds to showcase two different points in time, so we wanted to set up a cool transition effect that looked like our game world was changing in real time. Creating this material transition effect was just one of the ways were we able to accomplish this goal.

First, let’s start with making the material. You’ll need to make sure you have two textures that you want to switch between. You will also need a texture that you will want to use as your transition effect. We simply used a texture that is often used to make masks for materials, which is simply a clouds render effect that was made in Photoshop.

Make a new material and make sure that your blend mode is set to opaque and your lighting is set to phong, which should be by default. You will want to create three Texture Sample nodes and plug your textures into them. As a side note, you will want to make sure to properly comment your material nodes as it makes it much easier for others working with you to follow your work and understand it properly. I noticed that I actually labeled my starting and ending textures wrong in the picture below where they actually need to be reversed. After you have your textures applied, you will want to create a Constant node and then convert that into a Scalar Parameter by right clicking and choosing that option. This node works the magic with this material and is the most important node in the material; I will explain why later. Make sure to name the Scalar Parameter down in the properties section under Parameter Name. We named ours “Transition”, which we will be using later on to set up the material in game. All four nodes are now ready to plugged into an If node.

Plug your Scalar Parameter track, which should be set to “0” by default, to the slot labeled “A” on the If node. You will then plug the red channel of the texture you want to use as the transition effect into the slot labeled “B”. Finish the material by plugging RBG channel of the texture that you want to show first into the slot labeled “A<B” and your ending texture into the two slots labeled “A>B” and “A=B”. You will then plug your If node into the diffuse channel and save your material in both the material editor and in the content browser.

You are probably wondering what you just did, so I’ll explain. Our Scalar Parameter node is essentially controlling what texture is showing based on the value, so if the value is 0 then the starting texture will show and if the value is 1 then the ending texture will show. The values in between 0 and 1 decide how much of the transition texture will show in conjunction with our starting and ending textures. The If node simply does the math for us, so we can sit back and enjoy a lovely goblet of Mountain Dew.

That is all that goes into making the material. That was easy, right? Now how do we get the material to work in the game? That is rather easy as well. You have a few choices with one of the choices being much easier to implement than the others.

The way that we did it was by setting up a material track in Matinee. The track will simply change the value of the Scalar Parameter over time from 0 to 1. You can hook the Matinee track up to any kind of input such as Level Loaded or Key/Button Pressed, so that when the Matinee is triggered by something it will play the track and transition the material for you in real time.

First, you will want to create the Matinee track in Kismet by right clicking and choosing “New Matinee”. Then you will want to double click to open the Matinee editor and create a new empty group. We labeled our empty group “Transition” because of a naming convention we set up, which I will explain later. You will want to create a “New Float Material Param Track” in the empty group.

You will notice that down at the bottom are properties for the track, which are shown in the picture above. These properties must be set correctly or your material transition will not work. First, you will want to click the green plus icon to create a new Target Material. Make sure your material you made is highlighted in the content browser and click the green arrow icon to plug that into the Target Material field. Remember when I said that the Scalar Parameter node was the most important node in the material? The Param Name is the key to getting this material to work properly. You will enter the name of the Scalar Parameter we created earlier in this field, so make sure that they match one another or else your material transition will not work. The gigantic orange arrow in the picture below shows where you will enter the name of your Scalar Parameter node into the Matinee track.

Now that you have the track and the properties set up correctly, you will simply create two key frames that can stretch across however much time you want. We set ours to play throughout a duration of 1 second, so our materials will basically transition into one another across the time span of 1 second. Set the first value of the key frame to 0 and the second key frame value to 1 then close Matinee. You can now apply your material to a static mesh in the world and test it out in game. It’s beautiful isn’t it? There are so many things that you can do with this sort of effect, but I wanted to show you how we did it and give you the foundation to start building from to make something bigger and better! I hope this tutorial helped you in some way, shape, or form, and if you have questions then feel free to post them on our team website where you can contact us directly!

 
To create a custom sprite actor for use in UDK, you'll first need to import a texture to UDK, so we'll do this in two parts, one for setting up a texture, and one for attaching that texture to a custom actor script.

1.) Importing a Texture to UDK

To import a texture to UDK, you'll first need an image.  This image will have two very specific requirements:

1.) It must be in the windows .bmp file format.
2.) It must be a perfectly square image, with dimensions in powers of 2, like 1024 x 1024 or 512 x 512.

UDK will not allow you to even try to import a texture if it does not conform to these two criteria.

You can create your own image in image software like GIMP, or find something using Google (try the "Exactly..." filter in the size section on the left of Google Image search to refine your results to images that fit your size requirements).

Make sure your image has transparency.  If not, you'll have an awkward-looking square picture with a background.

Make sure the image is saved as a .bmp.  I did this for my custom sprites by opening the .jpgs in GIMP and clicking Export and saving them as .bmps.

In UDK, open your content browser and click "Import", then select your image and give it the appropriate package, grouping, and title.  Once you've completed this step, you should have a brand-new, usable texture in UDK.

Keep UDK open for a minute, and we'll get into the script.

2.) Creating a Sprite Actor in Script

In whatever script-editing software you use (I use Microsoft VisualStudio with NFringe; it plays nice with UDK), create a new script in your custom scripts package.

Here's what you'll need in the body of your script:

class MyCustomSprite extends Actor
   placeable;

defaultproperties
{
  begin Object Name=YourSprite
    Sprite= // Sprite's Full Name Goes here
    HiddenGame=false
    AlwaysLoadOnClient=False
    AlwaysLoadOnServer=False
  end Object
  Components.Add(YourSprite)
}


Go to UDK and find your texture in the content browser, right click on it and find the option "Copy Full Name to Clipboard" and insert it into the relevant space in the script, after "Sprite=".

That's it.

Save your scripts, close UDK and reopen it to rebuild your scripts, and you can find your sprite in the "Uncategorized" section of the Actor Classes tab in your Content Browser.
 
 Hello there this is Darren and I’m Team Helios awesome kismet scripters, even through the other members are too bashful to tell me face to face. As my first post to this blog I thought I should provide everyone with an Unreal Script developed for our game if anyone else in game design was looking for the same result.

In our game we have sections where objects fall and hurt the player when they make contact with them. So we need the actor to spawn in, destroy itself when it hurts the player, and have a life span long enough to reach the player from whatever height the object was spawning from. Aside from the static meshes uses many of the falling objects in our game extended off this one script and I hope it will help other game designers in their endeavors:

class FallingActor extends KActorSpawnable placeable;

var() int myDamage;
var() class<DamageType> myDamageType;

 event Bump(Actor Other, PrimitiveComponent OtherComp, Vector HitNormal)
{
       Super.Bump(Other,OtherComp,HitNormal);

       if(Pawn(Other)!=none && !Pawn(Other).bDeleteMe) //Is it a pawn?
      
{
            self.Destroy();
       }

       Pawn(Other).TakeDamage(myDamage, None, Other.Location, Other.Velocity, myDamageType,, Self);
}

event RanInTo(Actor other)
{
       Super.RanInto(Other);

       if(Pawn(Other)!=none && !Pawn(Other).bDeleteMe) //Is it a pawn?
       {
            self.Destroy();
       }

       Pawn(Other).TakeDamage(myDamage, None, Other.Location, Velocity, myDamageType,, Self);
}

defaultproperties
{
       Begin Object Name=StaticMeshComponent0
             StaticMesh=StaticMesh'PhysTest_Resources.RemadePhysBarrel'
              BlockNonZeroExtent=True
              BlockZeroExtent=True
              BlockActors=True
              CollideActors=True
              AlwaysCheckCollision=true
       End Object

       bWakeOnLevel
       bNoEncroachCheck=False
       LifeSpan= 5.0
      
       myDamage=10
       myDamage'DmgType_Crushed'
}

 
(This is a simple guide I made for the team for importing new fonts to use in the UDK.  Unless you're making a game based on Star Trek or the Aliens franchise, UDK doesn't have a lot to offer you in terms of fonts.  Here's a quick and easy guide to getting new fonts into your projects.)

To import a new font into UDK, it must first be accessible through your system's control panel.

In order to do this, download a font (Dafont.com is a great resource for amazing, free fonts).  Double click the font to open a preview, and click "install font."
Picture
The font preview screen in Windows7
Now head to UDK's Content Browser.  Find the package you want to import to, right click in some blank space, and click "New Font."  Fill out the dialogue with all of the necessary information (Package, Grouping, Name) and then, at the bottom, click "Choose Font"
Picture
Make sure to fill in your package and grouping, name your font, and then select "Choose Font"
In this pretty familiar-looking font window, you'll want to adjust the size of the font.  Whatever size you import it in will be its default rendering size, so pick a size that's comfortable but that you can still fiddle with.  I chose 22 or 24 for all of the fonts I've imported so far, but smaller or larger is fine.

When you're done, the font should be imported properly to the UDK, and can be used in any rendering scripts you use for putting information on the HUD.