If you cannot view this newsletter correctly, click here to view it online

Editorial - August 2014

It's holiday season once again for many people around the globe. The Brits go in search of scorching sun, the Nordic dwellers head to the mountains and lakes for a month or more, and the Antipodeans tend to make the most of their own beautiful countries. Whatever your plans, taking a short break from your development activities is a good idea, and recharging your creative cells will be advantageous in the long run. There's just two things to remember, apart from your passport and toothbrush of course. Firstly, make sure you are backed up and have made note of where you left off; you don't want to spend the first week back trying to unravel the mess you left behind. Secondly, take your notebook and camera phone with you. You never know when you'll get your next piece of inspiration, or indeed what you will see along the way to trigger the inspiration.

We'll leave you with some light reading for the holiday period. Take a casual browse through the updates to FPS Creator Reloaded and AGK Version 2. There's a leisurely tutorial on ensuring your players don't get bored waiting for your games to load. We have the highlights of an epic AGK adventure, and a library of videos to keep you entertained.

Until next time,

contents

(1) FPSCR 1.008 (2) The Escape (3) FPSC News (4) FPSCR Competition (5) FPSCR Videos (6) AGK Development (7) Animations & Assets (8) Rush to Adventure (9) Medusa FPSCR (10) TGC Channel (11) Social Feeds

FPS Creator Reloaded hits Beta 1.008

Rendering Engine

Characters

A.I.

Weapons

Music

Editor

Test Level Settings

LUA

Miscellaneous fixes

The Escape - FPSCR Demo Game

Demo System Requirements

Minimum

Windows XP

1GB Video Card (Minimum Shader Model 2.0)

2GB System Memory

1GB of Hard Drive Space Available

 

Recommended

Windows 7/8

2GB Video Card (Shader Model 3.0 or above)

2GB System Memory

1GB of Hard Drive Space Available

 

 

What's next for The Escape?

Alongside our community getting a test of the progress to date, we've learned plenty from the feedback. This is an opportunity to fine tune FPS Creator Reloaded from real-world experience, which is more valuable than lab-testing small sectors. 

 

The first tweak to go in the demo is the brightness and contrast adjustment, and when you put the old and new renders side by side you can see how much nicer the new one is. There is unlikely to be any debate here, and we have also added slider controls so you can adjust these settings to suit your own project levels.

 

 

FPSC Reloaded Blog

By Lee Bamber

Each month we'll update you on the progress of FPS Creator Reloaded. You will find a running commentary on the development through the FPSC-R Blog, but right here you will find some of the selected highlights that deserve your utmost attention. You can also follow the development on the official Facebook page. Within the R&D offices here at TGC, Reloaded is our main focus and we aim to constantly develop it to make it into a world class game creation tool. With great support from people who have made pledges to the project we are able to evolve and build our best game maker ever!

Lee Bamber, FPS Creator Reloaded Developer summarises the July achievements for himself and the FPSCR development team. 

July was the month when we released The Escape, a demo level to allow everyone to get a taste of FPS Creator Relaoded. As the community played and fed back on their experiences, the team continued to move forward and onwards.

New Characters

Take a look at this image for a preview of the next band of characters to join the FPSC Reloaded brigade of bandits and baddies. It's safe to say you wouldn't want to meet them in full daylight, never mind down a dark alley.

Here's another close up shot for you to take in the detail to be found in these character skins.

From the ammo pockets to the gloves, nothing has been left without the most minute of textures and shaders to bring them to life.

This chap is Rocket Man, not someone you want to stand infront of for too long! With Reloaded you can easily place an army of these guys down and make life the player of your games pure hell!

FPSCR - The Outtakes

Sometimes things happen that you couldn't orchestrate even if you tried. Most bugs are incredibly dull, but every now and then one or two will manifest themselves onscreen much to the amusement of the team. Here is a small selection of those moments.

Firstly, take a look at this guy, he's obviously had a hard day defending the fortress, and just needs a couple of minutes rest for his feet.

He'd better hope nobody takes the opportunity to blow up the barrel he's chosen as his resting place.

Next, we have death by porcupine. Easily mistaken for Bowser in the Mario Brothers, this is actually a very unfortunate and untimely death for another of the FPS Creator Reloaded Bad Guys.

Can you work out what has actually happened here? 

This final shot is one you don't want to take yourself. Essentially, this is the result of feeling rather smug and pausing to take a Selfie, only to be hit by a stray RPG just as you hit print screen. It's not a moment you'll be sharing on Facebook.

We finish off this collection with a moment that team member Simon finds rather amusing. Watch the target in the distance as he is obliterated by the RPG. One thing is for certain, physics are well and truly enabled in FPS Creator Relaoded!

 

  

If you want a summary of the blog details, don't forget you can get the FPS Creator Reloaded newsletter too, simply by registering on the site.

 

 

 

 

 

The Escaped Review

SegmentNext have published a review of The Escaped. In summary, they are looking forward to using the full version, given the ease in which the demo was produced. Highlighted is the ability to build the foundation quickly, allowing time to dedicate to the more complex elements.

Read the review here. 

  

Reloaded Discount Deal 

Pledge Now to support FPSC Reloaded development 

Crowd funding provides a way for Indie Developers like The Games Creators to pre-fund their projects. It's also a thumbs up from customers to show the developers the market wants and needs their new idea.

By pledging you are helping The Games Creators to build the most exciting and revolutionary game creator. With your pledging support you can strengthen our team as we build this amazing technology. You are essentially becoming part of our family as you share in it's development and ultimate production.

All pledge levels grant the backer access to all betas, with other bonuses, including free model packs valued at between $18 and $39 for Gold and Silver pledge levels.

So, if you'd like to help fund Reloaded development and join us on our journey, please support us with a pledge. The most popular and best value deal is the Gold level pledge, but you can find details of all pledge levels here.

FPSC Reloaded - Competition Update

 

Rescue the Princess - tomjscott

The Rules

1st Prize

2nd Prize

3rd Prize

4th to 10th placed winners each receive

FPSCR Videos

The last few weeks has seen a catalogue of FPS Creator Reloaded educational material making its way onto YouTube. You can of course subscribe to our channel and get immediate updates; the details are towards the end of the newsletter. For those of you that haven't taken the opportunity yet to work through these bite-sized lessons, here are the videos currently available.

AGK V2 Developments

IDE in Focus

As reported last month, we are updating the IDE for AGK Version 2. We can now confirm that Geany is the base we have opted for. First and foremost this will enable development on Mac OS X as well as Windows, which is welcome news for developers focused on Apple products. It also provdes a framework for many other desirable features.

The work has proved to be challenging, but we know it will be a worthwhile step for developers everywhere. Some of the features already implemented are:

• Highlighting code syntax
• Folding code (functions, loops and comments)
• Symbol parsing - so you can easily see all the functions in your code and access them from a side panel
• IntelliSense as you type so you can quickly enter commands

The new AGK2 IDE

As you type the IDE will present a list of commands

Easy Project Navigation

We've successfully tamed the complex projects system of Geany and now have the IDE supporting the opening of multiple projects, including the importing of older AGKV1 projects in the *.cbp format. When more than one project is open it also allows you to easily switch between active projects. The IDE still allows you to open files that aren't part of any project so you can quickly refer to snippets or individual files, these automatically disappear from the project list when they are closed.

The current job is stripping down the Geany build menu which is currently document based and caters for every conceivable build method (compiling, linking, make files, etc), whilst we want it to be project based and only need compiling. It would also be nice if we could get the AGK compiler to output errors to the IDE message console, hopefully we'll have something to report on in the next few days.

What is Geany?

Geany is a small and lightweight Integrated Development Environment. It was developed to provide a small and fast IDE, which has only a few dependencies from other packages. Another goal was to be as independent as possible from a special Desktop Environment like KDE or GNOME - Geany only requires the GTK2 runtime libraries.

Some basic features of Geany:

• Syntax highlighting
• Code folding
• Symbol name auto-completion
• Construct completion/snippets
• Call tips
• Many supported filetypes including C, Java, PHP, HTML, Python, Perl, Pascal
• Symbol lists
• Code navigation
• Build system to compile and execute your code
• Simple project management
• Plugin interface
• Geany is known to run under Linux, FreeBSD, NetBSD, OpenBSD, MacOS X, AIX v5.3, Solaris Express and Windows. More generally, it should run on every platform, which is supported by the GTK libraries.

Loading Animations and Staggering Asset Creation

by Sean Mann, Napland Games

In our last game, Shape Time, I ended up deciding to load quite a few assets at launch time. I implemented a loading animation, but it seemed to actually slow down the loading process a bit. In our next game I wanted to optimize this as much as possible to improve loading time. The reason the loading animation was affecting the speed of loading assets was that I was calling Sync() as frequently as possible so that the animation would update. Here's an example how it was done (the loading animation in this case is a sprite with frames):

for num = 1 to 10
	fileName$ = “atlas” + str(num) + “.png”
	LoadImage(i , fileName$)
	Sync()
next num

This would certainly animate the loading sprite just fine, but I knew there had to be a better, more universal way. The problem is that Sync() is limited by the frame rate of the device. So if you've got a device that is capable of only 30FPS (fairly common in with mobile devices) then you are limiting your loading sequence to one file every 30th of a second. This is not that bad for files, but if you want to display the animation while other, possibly faster processes take place, then you're likely slowing them down. 

Let's look at an example of a script that might be slowed by a Sync() call:

for num = 1 to 100
	if num = 1
		img = LoadImage(“yourImage.png”)
		CreateSprite(num , img)
		SetSpriteSize(num , 10 , -1)
		SetSpriteDepth(num , 100)
	else
		CloneSprite(num , 1)
	endif
	SetSpritePosition(random(0,90) , random(0,90))
next num

This script is pretty fast, but it might take up to a second or more on mobile devices. If we add a Sync() call to this routine so we can show a loading animation then the routine will be much slower because the Sync() call will render the screen and limit the engine to whatever the available FPS is. At 30FPS this script would require 3.33 seconds to run. Without Sync() it may take considerably less time, however, that would be dependent the device.

So how do we speed this up? The answer is to only call Sync() only when it is time that you expect to have a frame drawn to the screen. The example below uses a literal 1/60 of a second between Sync() calls. There are more advance ways to determine the expected time to call Sync(), but this is sufficient for showing a loading animation. The example simply rotates a loading image for simplicity.

global gLoading = 0
global gLoading_LastSync# = 0.0 
function ToggleLoadingAnim(iOnOff)
    if GetSpriteExists(gLoading) = 0
        gLoading = LoadSprite(“loading.png”)
        SetSpriteSize(gLoading , 10  , -1)
	SetSpriteDepth(gLoading , 1)
    endif
    if iOnOff = 1
        SetSpritePositionByOffset(gLoading , 50 , 50)
        gLoading_LastSync# = 0.0
    else
        SetSpritePositionByOffset(gLoading , -500 , -500)
    endif
endfunction 
function LoadingAnim_Sync()
    time_now# = timer()
    dT# = time_now# - gLoading_LastSync#
    if dT# > 0.017
        ft# = GetFrameTime()
        gLoading_LastSync# = time_now#
        t# = 3.0
        angle# = GetSpriteAngle(gLoading) + 360.0 * ft# / t#
        angle_int = round(angle#)
        angle_int = mod(angle_int , 360)
        SetSpriteAngle(gLoading , angle_int)
        Sync()
    endif
endfunction

The code consists of 2 globals and 2 simple functions. ToggleLoadingAnim() is used to set up the sprite and globals, position the sprite, and make it visible. This should be called before any loop that you want to overlay the loading animation on. You also call this to hide the animation. Inside of the loop you will use LoadingAnim_Sync() in place of a standard Sync() call. So our original code that loaded 100 sprites becomes this:

ToggleLoadingAnim(1)
for num = 1 to 100
	if num = 1
		img = LoadImage(“yourImage.png”)
		CreateSprite(num , img)
		SetSpriteSize(num , 10 , -1)
		SetSpriteDepth(num , 100)
	else
		CloneSprite(num , 1)
	endif
	SetSpritePosition(random(0,90) , random(0,90))
	LoadingAnim_Sync()
next num
ToggleLoadingAnim(0)

That's it! Now you can load up lots of assets and have a nice loading animation so that the user doesn't wonder what's going on. Remember, folks don't like to wait even a second for something to happen these days, so make sure to use a method like this to let them know your game is still running. Now if we could only thread the loading animation so that we can draw to the screen while loading large files. Another thing you might want to consider is that you might get large values out of GetFrameTime() while loading files. So you might want to limit the ft# variable when you're translating a sprite (moving or rotating). Either way you'll get a bit of jitter in your sprite's translation because Sync() just can't be called fast enough due to the time it took to load a file. 

Users don't want to wait long for your game to load, so it's important to only load at launch time the assets you need to display the title screen / main menu of your game. After that you can stagger the creation of assets by creating only a handful every frame and then if they aren't all loaded when they're actually needed, you can finish up loading them and show a loading animation. In our next game I did this for our level selection menu. 

The level selection menu needed 200 buttons, 3 star sprites for each button, and 2 text objects for each button – that's a total of 800 sprites and 400 text objects! This was just way too slow to load on demand. So what I did is create a handful of these objects every frame during the Sync() calls. This way the buttons could be loaded while the player is looking at the main menu which incorporates a short animation of about 2 seconds. Let's examine how we can do something like this.

Make an array that will hold the object IDs for the level buttons and a global to hold an image ID:

#constant LVL_BTN_COUNT 200
dim _lvl_btns[LVL_BTN_COUNT]
_lvl_btns[0] = 0
global gLvlBtnImg as integer

Create a new function that includes the Sync() command and will create a handful of objects each frame:

function LvlBtn_Sync()
	//we'll store the count of created objects here
	count = _lvl_btns[0]
	if count < LVL_BTN_COUNT
		skip_objects = 0
		if GetImageExists(gLvlBtnImg) = 0
			gLvlBtnImg = LoadImage(“mybutton.png”)
			//since we're loading an image this frame
			//let's not make any sprites or text
			skip_objects = 1
		endif
		
		if skip_objects = 0
			baseSprite = _lvl_btns[1]
			needBaseSprite = 0
			if GetSpriteExists(baseSprite) = 0
				needBaseSprite = 1
				endif
			for i = 1 to 10
			
			if needBaseSprite = 1
				needBaseSprite = 0
				thisSprite = CreateSprite(gLvlBtnImg)
				SetSpriteSize(thisSprite , 10 , 5)
				SetSpritePosition(thisSprite , -1000 , -1000)
				SetSpriteDepth(thisSprite , 10)
			else
				thisSprite = CloneSprite(baseSprite)
			endif
			_lvl_btns[count] = thisSprite
			inc _lvl_btns[0]
		next i 
		endif
	endif
	Sync()
endfunction

Now we're creating those 200 sprites in 20 frames. At 30FPS we'll have created them in less than 1 second! They should all be prepared by the time we need to show the level selection menu, but just in case, you should also have a catch that ensures they're all created when the user goes to access the level selection screen. If they aren't all made then you can show the loading animation to tell the user the app is working on something.

This method can be used in a variety of ways. For example, while the user is playing one level you can slowly start loading the assets for the next level in each frame. This should be done with care so that it doesn't drag down performance when the action of the game is happening. As long as the sprites are off-screen they won't be rendered and won't cause a drag on the engine.

Next time I'll discuss methods on how to “thread” animations in a loop so that you can easily contain different animations in separate functions. Oftentimes we need to have a lot of things going on simultaneously and they cannot interrupt each other or user input. Thanks for reading!

Rush to Download an AGK Epic Adventure

 

Medusa FPSCR

Bonus for TGC Customers!

Anyone buying Medusa Pro in August 2014 will be given access to an additional Rock Pack containing 2 additional templates, capable of generating a huge range of rock formations. You also have the option to sell your creations in the TGC Store under the generous license, simply by providing your own textures. So if you have been procrastinating over this purchase, now is the time to come out from under your rock and buy it!

Full details, purchasing options and the free Medusa Lite can be found here. 

The TGC YouTube Channel

Have you visited the TGC YouTube Channel yet? You may be surprised:

• Over 140 videos!
• Almost 800,000 views!
• Over 2,300 subscribers!

Take a look at our channel now, and make sure you hit the subscribe button to stay up to date with new video uploads. Very often you'll get advanced previews of upcoming news.

Keep up to date with TGC on Facebook & Google+

Join over 6,300 fans on TGC's Facebook page to keep bang up to date on news, user projects from the forums and discussions.

We're keen to hear from all our avid users and we always love to hear what you've been up to with the tools we sell. So if you have something you want to share with the wider TGC audience why not post it into the TGC Facebook page?

FPSC Reloaded

There are now over 2,600 fans discussing Reloaded on our Facebook page right now. Whether you simply want to see the update and progress news as it is released, or get involved in technical discussions about LOD, Light and lots of other topics, sign up to this page today to be part of it.

App Game Kit 

You can join in the Facebook discussions in our AGK group page with almost 600 members and we have a new AGK Facebook page.

Google+

You can also follow our products on Google+ 

TGC on Google+

FPSC Reloaded on Google+

App Game Kit on Google+ 

The Game Creators in no way endorse or support products mentioned in this newsletter that are not specifically published by them. Always check first before parting with your money. © The Game Creators Limited 2014.