Assets are an essential part of most games, how you manage them determines whether you spend more time working on them than dealing with them.

For small to medium games, loading an entire directory and having it referenced to a Map is the ideal solution. It’s both flexible and simple.

The following code allows you to do just this:

Prototype.i LOAD_DIRECTORY_CALLBACK( Map Assets.i(), directory.s, extension.s, name.s, userDefined.i = #Null )
 
Procedure.i LoadDirectory( Map assets.i(), directory.s, extension.s, *callback.LOAD_DIRECTORY_CALLBACK, userDefined.i = #Null )
 
	Define.i dir = ExamineDirectory( #PB_Any, directory, "*" + extension )
	If IsDirectory( dir )
 
		Define.i count = 0
		Define.s name = ""
 
		While NextDirectoryEntry( dir )
			If DirectoryEntryType( dir ) = #PB_DirectoryEntry_File
				name = DirectoryEntryName( dir );
				assets( ReplaceString( name, extension, "" ) ) = *callback( assets(), directory, extension, name, userDefined );LoadSound( #PB_Any, directory + "\" + name )
				count + 1
			EndIf
		Wend
 
		FinishDirectory( dir )
	EndIf
	ProcedureReturn count
 
EndProcedure

To use this code you must define a procedure of your own, this procedure is going to be called on each file to be loaded; you’ll have to load and process the file in this function.

Example use:

Global NewMap sprite.i()
Procedure.i callback_loadsprites( Map Assets.i(), directory.s, extension.s, name.s, userDefined.i = #Null )
	ProcedureReturn LoadSprite( #PB_Any, directory + "\" + name, userDefined )
EndProcedure
 
LoadDirectory( sprite(), "sprites", ".png", @callback_loadsprites() )

The example will attempt to scan through the directory “sprites”, it will execute your callback on each png file it finds inside the aforementioned directory, furthermore it’ll reference the filename (without extension) to the sprite() Map, so when you need a handle for the sprite called “fire.png” you’d just use sprite(“fire”) to obtain it.

Since the files are referenced to a Map by their actual name, you could easily implement a scripting system or any other dynamic management solution for your assets without much hassle.

An interesting part of the code is the return value, it’s actually the number of assets found (not the ones loaded, since your callback could choose not to load a certain file, for instance).

There are several limitations to this simple implementation, which is why I mentioned “small games” – There is no directory recursion, no advanced filtering options, no way to parallel the process on a separate thread and there’s no error handling at the moment.

However, it’s still very useful and I highly recommend you try it out, while it’s not a novel aproach, it’s always been the method I used to load my assets and it just works.

Have fun!

Light fire sprite sheet, ideal for filler or part of a composition. Complete with all frames.

Specs:

• 128×128
• 38 frames
• Alpha channel, PNG

The goodies:

Neat little fire

Notes:

Take a look at the legal notes here. Commercial use is prohibited.

More to come…

The following is a volumetric explosion sprite sheet, one of many left over from past work. You may use them for private or freeware (open source only) projects. Commercial use is prohibited, please contact me regarding licensing or custom work.

Specs:

There are 38 frames. Each frame is 128×128 and the complete sheet contains an alpha channel, the grid is centered but it hasn’t been packed; as you can see there’s a lot of wasted space. This is however a “sane” way of sharing the sprites, otherwise I would have to provide my own format specifications for the metadata, packer, etc.

This way you can split them and pack them however you want into whatever format you wish. These are however quite usable in their current form.

The goodies:

A simple volumetric explosion

A simple volumetric explosion, corrected levels, saturation, etc.

Misc:

The corrected version was not exactly proofed, there are a few artifacts due to the processing, however if you’re going to use any sort of scaling filter these shouldn’t be a problem.

As you probably noticed the particles were rendered using a black background, mostly because of the high amounts of smoke involved; white or neutral would’ve been problematic.

Footer:

It’s no secret that these are leftovers, but they’re perfectly good sprites — they just didn’t make it due to time constraints.

I cannot discuss which title they were meant for though, but I can tell you there’s more of them.

The actual image data contains a disclaimer, it’s hidden by the alpha channel. I mention this because I take it seriously, you may not profit from my work unless “I” profit from your work (It’s only fair right?).

Other than that feel free to use them, even as place-holders. And of course, if you’d like to share some of your handy work, feel free to contact me.

I’ll probably post more freebies throughout the week.

Cheers.

One Iteration based on a base pattern gives us many ships to choose from.

The next logical step is to start separating the various parts of the code and begin to implement various means of generating content, adding noise based on a map/pattern as well as being able to mix different patterns to change the outcome. Another step in the process is to allow the use of arbitrarily sized patterns.

With just a few modifications to the base pattern we can generate all kinds of content, we then choose the one we like the most and select it’s pattern as the new base design for future mutations. The possibilities are endless!

Generating procedural content is nothing new, but it sure is exciting! — And it’s always a challenge to optimize and evolve this type of code.

Hopefully I’ll come up with something usable in the near future.

If you add a sprite atlas library (I’ll share later) you’ll be able to manipulate sprites with animation in quite a flexible way without too much hassle.

The idea is to encapsulate the animation functionality in such a way that it makes it easy to work with. You have the ability to start, stop, pause, change speed, etc. You can create animations that range from any frame to any frame and that can animate in many ways such as sequential (loop), play-once and ping-pong (back and forth, or rather the inverse). By making use of the time-lapse library we can easily create time-based animation.

The base code:

;##############################################################################
;$$$	file: Animation.pb - date: 05:05 p.m. 06/08/2009			$$$
;$$$	author: Gustavo Julio Fiorenza (info@gushh.net || info@gushh.com.ar)	$$$
;$$$					aka: gushh, dagcrack.			$$$
;$$$ 	description: provides several count modes for animation purposes	$$$
;##############################################################################
 
EnableExplicit
XIncludeFile "TimeLapse.pb" ; Used for timing.
 
Structure ANIMATION
	*timer.TIMELAPSE	; The timer's speed is "per frame", use the Get/SetLength functions to overcome this.
	frame_max.i		; Maximum global frame
	frame_min.i		; Minimum global frame
	frame_now.i		; Current local frame
	mode.i			; The animation mode (loop, play once, ping-pong, etc).
	status.i		; Internal var used for keeping track of the animation "status". It's used as a bool.
	is_playing.i		; Used to determine whether the animation is playing or not.
EndStructure
 
Enumeration 1
	#ANIMATION_LOOP
	#ANIMATION_PLAYONCE
	#ANIMATION_PINGPONG
EndEnumeration
 
 
Procedure.i AnimationCreate( Speed.i, MinFrame.i, MaxFrame.i, CurrentFrame.i = 0, Mode.i = #ANIMATION_LOOP, *callback.i = #Null )
 
	Define.ANIMATION *this = AllocateMemory( SizeOf(ANIMATION) )
 
	If *this
 
		With *this
			\timer		= TimeLapseCreate( Speed, *callback, *this ) ; We're passing this instance as the timer's user-data, useful in callbacks.
			\frame_max 	= MaxFrame
			\frame_min	= MinFrame
			\frame_now	= MinFrame + CurrentFrame
			\mode 		= Mode
			\status		= 0
			\is_playing	= #True
		EndWith
 
		ProcedureReturn *this
 
	EndIf
 
EndProcedure
 
Procedure.i AnimationDestroy( *this.ANIMATION )
 
	If *this
 
		If *this\timer
			TimeLapseDestroy(*this\timer)
		EndIf
 
		FreeMemory(*this)
		*this = #Null
		ProcedureReturn *this
 
	EndIf
 
EndProcedure
 
Procedure.i AnimationUpdate( *this.ANIMATION )
 
	If *this
		If *this\is_playing
			If TimeLapseUpdate( *this\timer )
 
				Select *this\mode
 
					Case #ANIMATION_LOOP
 
						*this\frame_now + 1
 
						If *this\frame_now > *this\frame_max
							*this\frame_now = *this\frame_min
						EndIf
 
					Case #ANIMATION_PINGPONG
 
						If *this\status
 
							*this\frame_now - 1
 
							If *this\frame_now < = *this\frame_min
								*this\status = #True - *this\status
							EndIf
 
						Else
 
							*this\frame_now + 1
 
							If *this\frame_now => *this\frame_max
								*this\status = #True - *this\status
							EndIf
 
						EndIf
 
					Case #ANIMATION_PLAYONCE
 
						If *this\status
							; status is set to one, this means we already played the animation.
						Else
 
							*this\frame_now + 1
 
							If *this\frame_now => *this\frame_max
								*this\status = #True - *this\status
							EndIf
 
						EndIf
 
				EndSelect	
 
				ProcedureReturn #True ; always return true unless you want to invalidate the update call!
 
			EndIf
		EndIf
	EndIf
 
EndProcedure

The helper functions:

Procedure.i AnimationGetCurrentFrame( *this.ANIMATION )
	ProcedureReturn *this\frame_now - *this\frame_min
EndProcedure
 
Procedure.i AnimationSetCurrentFrame( *this.ANIMATION, Frame.i )
	*this\frame_now = (Frame - *this\frame_min)
EndProcedure
 
Procedure.i AnimationGetTotalFrames( *this.ANIMATION )
	ProcedureReturn (*this\frame_max - *this\frame_min)
EndProcedure
 
Procedure.i AnimationGetMode( *this.ANIMATION )
	ProcedureReturn *this\mode
EndProcedure
 
Procedure.i AnimationSetMode( *this.ANIMATION, NewMode.i )
	*this\mode = NewMode
EndProcedure
 
Procedure.i AnimationGetSpeed( *this.ANIMATION )
	ProcedureReturn TimeLapseGet( *this\timer )
EndProcedure
 
Procedure.i AnimationSetSpeed( *this.ANIMATION, Speed.i )
	TimeLapseSet( *this\timer, Speed )
EndProcedure
 
Procedure.i AnimationPlay( *this.ANIMATION )
	*this\is_playing	= #True
EndProcedure
 
Procedure.i AnimationPause( *this.ANIMATION )
	*this\is_playing	= #False
EndProcedure
 
Procedure.i AnimationStop( *this.ANIMATION )
	*this\is_playing	= #False
	*this\frame_now		= *this\frame_min
EndProcedure
 
Procedure.i AnimationReset( *this.ANIMATION )
	AnimationStop(*this)
	AnimationPlay(*this)
EndProcedure
 
Procedure.i AnimationGetLength( *this.ANIMATION )
	ProcedureReturn AnimationGetTotalFrames( *this ) * AnimationGetSpeed( *this )
EndProcedure
 
Procedure.i AnimationSetLength( *this.ANIMATION, NewLength.i )
	AnimationSetSpeed( *this, NewLength / AnimationGetTotalFrames( *this ) )
EndProcedure

Thanks to the base lib, you can also use callbacks, this are useful for executing events on known frames (say you’re writing a game and you want a sound to be played at frame 12 from the jumping cycle… easy!)

A minimal example:

Define.ANIMATION *anim
 
If OpenConsole()
	*anim = AnimationCreate( 250, 0, 9, 0, #ANIMATION_PINGPONG )
	If *anim
		Repeat
			If AnimationUpdate( *anim ) ; the reason frame 0 is not seen in the first print is because we update before we display.
				PrintN( Str( AnimationGetCurrentFrame( *anim ) ) )
			EndIf
			Delay(10)
		Until Inkey() = Chr(27)
 
		AnimationDestroy(*anim)
	EndIf
	CloseConsole()
EndIf

A somewhat bloated example with callbacks can be found in here.

The playback functionality could be extended, however I found little need for other methods — That’s basically my excuse for “I ran out of ideas” — One thing I’d do is decouple the “play once” functionality from the playing mode, so essentially you’d be able to play a loop or ping-pong animation just once.

That’s pretty much it. Once again, this is trivial code but it’s a must and I’m sure someone will benefit from it.

The only reason I didn’t post a graphical example is because you need a way of dealing with sprite sheets and that’s the job for yet another library. Should you use the sprite library, you’d still need to feed the ClipSprite() function with meaningful data, there is no point in doing it by hand. That said, I’ll post the “sprite atlas” library tomorrow, hopefully.

Cheers