Wow we have finally made it to the end of our journey. Helios has been such an amazing experience to develop thanks to the everyone's efforts and dedication to making an awesome game. It has been a rough couple of months but in the end we made it through. Thanks to everyone for supporting us through this project and please enjoy this video on the the development of Helios
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:
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!
After many weeks of hardships and almost a complete overhaul of our game, Team Helios is proud to announce that our beta version of Helios is out and ready for testing. Below is a link to a downloadable file for three things:
1. The beta version of Helios
2. A brief control guide and synopsis of the game
3. A survey for feedback on the game.
Our team would really appreciate anyone willing to test out our game and provide feedback on the content so that we can make it better for future gamers to enjoy. Please send your surveys back to email@example.com and thank you for your participation in making our game better.
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;
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;
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;
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:
(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!
Long time no see, or hear, or write, or whatever you call it but it’s been a while since any blog post was posted to here. Just to let everyone know our team is still kicking and alive but over the last two months our game has gone through a major overhaul. Not to get too much into the specifics of our dilemmas but the short and sweet answer for our team’s long hiatus was that our game wasn’t progressing as it should have so we had to reevaluate our core concepts and mechanics and reiterate our entire game. Now that might sound like a huge back step to our development and it was for about a week but fortunately for us our team is awesome so it wasn’t as much of a set back as we thought it would be.
Some of the biggest changes that we had to employ into our new game vision were:
1. Making our levels a lot smaller but elaborate.
2. Scrapping most of our light power mechanic and focusing the game on one specific mechanic, pushing objects.
3. Reiterating our world swapping mechanic to have a cause and effect mechanic.
Now the reason we decided to focus our attention towards just a few specific mechanic instead of many was because as mention before our game wasn’t progressing much and it was becoming too much of an action platformer instead of a puzzle platformer game.
The main concept behind Helios was to essentially have an intricate puzzle platform game focused on direct player controlled mechanics. Unfortunately our original idea of using three lights that gave the player different abilities was too out of scope for our project’s timeline so we couldn’t fully develop those mechanics. Instead we just said out with the old and in with the new which surprisingly worked out much better in the long run.
So here is a basic synopsis of want Helios gameplay will feature:
Since the game will revolve around the player pushing objects there will be a variety of pushable objects for the player to interact with throughout each level. The main three will be…
Similar to our light mechanics these boxes will have unique properties that are essential to so solving each level. For example the explosion box as the name suggest explodes ( and yes a lot of thought went into that) when it is drop from elevated levels destroy objects on impact. So levels that feature the explosion box will give a hint to the player that there is some object that will need to be destroyed for the them to progress
Another feature that will be integral to the player’s progression is the world/time swapping function. Very similar to our green light mechanic in our previous design, the player has to swap between time periods to traverse around levels. However instead of just switching between time periods to traverse, players will actually have to interact with objects in one time period to have an effect on the other time period.
As the end of this project nears us week by week expect more updates soon, such as some new tutorials on features applied to our game and a beta version of our game but thanks to everyone for following us and checking our website regular for updates. We are back and also Happy Holidays.
This is another swing at the low-poly visual style I tried for in my last test. This one's a lot better-looking and includes actual Helios gameplay (though slightly dated). Take a look:
This level was done using Level Streaming for the Nature and Mechanical worlds, meaning we streamed in all of the assets, sounds, volumes, and Kismet required for one world while streaming out those required for the other world.
The level-streaming system is remarkably convenient in terms of world-building, because anything we wanted to exist only in one world, including otherwise difficult things like Post Process Volumes and sound effects, we only needed to put in one world. However, when cooked into an executable there's a jarring lag when streaming levels, so we had to find another solution.
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
begin Object Name=YourSprite
Sprite= // Sprite's Full Name Goes here
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=".
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)
if(Pawn(Other)!=none && !Pawn(Other).bDeleteMe) //Is it a pawn?
Pawn(Other).TakeDamage(myDamage, None, Other.Location, Other.Velocity, myDamageType,, Self);
event RanInTo(Actor other)
if(Pawn(Other)!=none && !Pawn(Other).bDeleteMe) //Is it a pawn?
Pawn(Other).TakeDamage(myDamage, None, Other.Location, Velocity, myDamageType,, Self);
Begin Object Name=StaticMeshComponent0
(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."
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"
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.