Simply put the script somewhere in your scene, and mark any fields or properties in your code that should be tweakable with [TweakableMember] and the script will find them. Or you can restrict the searching to specific game objects by setting references to them in the inspector. It works for bool, int and float members at the moment, but is easy to extend.

The script is available on Github here.

It doesn't seem possible to customize all the colors, for example the gray borders and the scrollbars, but most colors can be changed.

The colors are based on this file by David Pierce https://github.com/dapierce/flashdevelop-colors. I altered the scheme a little bit to suit me better: darker background and other selection and highlight colors. I also changed the font to Consolas (since I didn't have Source Code Pro).

Syntax color scheme: DK_Solarized_Dark_Syntax.fdz
UI theme: DK_Solarized_Dark_UI.fdi

Run them with FlashDevelop, or import them with Tools > Select UI Theme...
You may need to restart FlashDevelop for all colors to take effect.

Enjoy!

I had been trying to optimize rendering of the canvas in Pyxel Edit without much luck, but then I tried Adobe Scout (awesome application btw!) that let me know that most of the time in the application was spent by the flash runtime rendering the display list. Apparently the whole canvas was re-drawn each time it changed just a bit. The odd thing was that the brush preview bitmap which is displayed on top was only rendered where it changed.

After some experimenting I found out that locking the bitmapdata of a bitmap object, which supposedly makes drawing faster, invalidates the whole bitmap and makes it get redrawn. Commenting out canvasBitmap.lock() immediately cut the displaylist rendering time by about 1/3 when drawing in the application.

To see what parts of the displaylist are redrawn one handy function is flash.profiler.showRedrawRegions(). It will draw rectangles around each redrawn region.

The "advanced telemetry" option in FlashDevelop doesn't seem to do anything (as of FD 4.4.2). So you need to run a Python script on the compiled SWF. This can be done automatically after each build with a command in "Post-Build Command Line" in the FD project options.

1. Install Python (if you don't already have it).
http://python.org

2. Download the script.
https://github.com/adamcath/telemetry-utils

3. Specify the post-build command.
Go to Project > Properties > Build and enter:

[path to python.exe] [path to script] [path to output swf]

In my case I have

"D:\Program Files (x86)\Python33\python.exe" $(ProjectDir)\add-opt-in.py $(OutputDir)\$(OutputName)

4. Done!
The script is now run on the file after each build.

More info: http://www.adobe.com/devnet/scout/articles/adobe-scout-getting-started.html

Unity3D example and source code

Unity project

The interesting bit of C#:

private Vector3 FindInterceptVector(Vector3 shotOrigin, float shotSpeed,
    Vector3 targetOrigin, Vector3 targetVel) {
    
    Vector3 dirToTarget = Vector3.Normalize(targetOrigin - shotOrigin);
    
    // Decompose the target's velocity into the part parallel to the
    // direction to the cannon and the part tangential to it.
    // The part towards the cannon is found by projecting the target's
    // velocity on dirToTarget using a dot product.
    Vector3 targetVelOrth =
    Vector3.Dot(targetVel, dirToTarget) * dirToTarget;
    
    // The tangential part is then found by subtracting the
    // result from the target velocity.
    Vector3 targetVelTang = targetVel - targetVelOrth;
    
    /*
    * targetVelOrth
    * |
    * |
    *
    * ^...7  <-targetVel
    * |  /.
    * | / .
    * |/ .
    * t--->  <-targetVelTang
    *
    *
    * s--->  <-shotVelTang
    *
    */
    
    // The tangential component of the velocities should be the same
    // (or there is no chance to hit)
    // THIS IS THE MAIN INSIGHT!
    Vector3 shotVelTang = targetVelTang;
    
    // Now all we have to find is the orthogonal velocity of the shot
    
    float shotVelSpeed = shotVelTang.magnitude;
    if (shotVelSpeed > shotSpeed) {
        // Shot is too slow to intercept target, it will never catch up.
        // Do our best by aiming in the direction of the targets velocity.
        return targetVel.normalized * shotSpeed;
    } else {
        // We know the shot speed, and the tangential velocity.
        // Using pythagoras we can find the orthogonal velocity.
        float shotSpeedOrth =
        Mathf.Sqrt(shotSpeed * shotSpeed - shotVelSpeed * shotVelSpeed);
        Vector3 shotVelOrth = dirToTarget * shotSpeedOrth;
        
        // Finally, add the tangential and orthogonal velocities.
        return shotVelOrth + shotVelTang;
    }
}

Update:

If you want to find the point where they meet, you can calculate the time it will take, and then multiply the shot velocity by that. In practice they will collide sooner since they have a certain radius, but we can take that into account when we calculate the time.

// Find the time of collision (distance / relative velocity)
float timeToCollision = ((shotOrigin - targetOrigin).magnitude - shotRadius - targetRadius)
        / (shotVelOrth.magnitude-targetVelOrth.magnitude);

// Calculate where the shot will be at the time of collision
Vector3 shotVel = shotVelOrth + shotVelTang;
Vector3 shotCollisionPoint = shotOrigin + shotVel * timeToCollision;

The script required remapping the Caps Lock key to another key in the Windows registry though, so I started improving it a bit. I added some new functionality and customized it to my preferences. I also added another very handy function that lets you drag anywhere on a window to move it while holding Caps Lock, the way you can do while holding the Alt key on Linux. I got that feature from an article at How-to-geek, changed the key from Alt to CapsLock and added it to the script. Very handy indeed!

Below you can see the default mappings for the script, although it's easy to change it if you like:

You have access to all the common keys on the right side of the keyboard (Cursors, Home, End, PgUp, PgDn, Ins, Del) from your home row, which is very handy when typing! Common commands like cut-copy-paste, undo-redo, backspace-delete are also very easy to access giving less hand movement. You can still toggle caps lock if you need to by pressing the Windows Key + Caps Lock.

To use the script:

1. Download and install Autohotkey.


2. Download the script.


3. Put the script (or a shortcut to it) in the Startup folder so that it runs each time you start you computer.

Update: If you like the regular cursor layout I made another version of the script:

The cursor key layout should be more familiar than the Vim-style layout to most people, and much easier to learn.

Gist for the version I currently use: https://gist.github.com/Danik/5808330

Original keyboard layout graphic by Simon Kaupinmäki

IMPORTANT 1: The file makes changes in the registry, use it at your own risk!
IMPORTANT 2: You need to open the file in a text editor and change the path to sublime_text.exe if it's not located at C:\Program Files\Sublime Text 2\sublime_text.exe.

Download, (edit if needed) and run this file. Now you should be able to open files and folders by right clicking!

pyxeledit.com

Pyxel Edit is now in public beta and you can get it at http://pyxeledit.com/

Pyxel Edit is a drawing application aimed at making pixel art. It has features to make it faster and easier to make low resolution art like tile sets for games. It's made using Adobe Air, runs on Windows and Mac, and is currently in beta.

What's special about it?
You can draw freeform like in any other program, you can also draw and place tiles. If you have multiple instances of a tile and edit one, they all update. This still works if some of the instances are flipped or rotated. This is really nice when making tile sets, as you can instantly see how all the tiles work together as you draw them. This feature is inspired by the awesome Pixothello and Cosmigo Pro Motion, but taken one step further.

Tileset importing
Pyxel Edit can import images of tilesets or mockups and identify all the unique tiles automatically, which is great for editing and rearranging old tile sets or doing edits of mockups.

Tilemap exporting
The tilemap can be exported to XML or plain text, making Pyxel Edit also useable as a level editor. Just export the tileset image and the tilemap, and you are ready to load it into your game!

How much does it cost?
The beta is free. In the future there might be a free and a paid "pro" version.

Future features
In addition to adding lots of small features, new tools, better menus and polishing the UI, animation support is planned.

Follow @PyxelEdit for updates.

Video

You can play it here: Play Aether. Have fun!

Edit: Results:

#31 Fun 3.79
#37 Overall 3.90
#47 Mood 3.66
#51 Innovation 3.90
#82 Audio 3.47
#108 Graphics 3.80
#312 Humor 2.47
#354 Theme 3.18
Total number of compo entries: 1072

As you might know, I released an early version of the pixel editor, now called PyxelEdit, for the Ludum Dare community. Even though it is far from complete, I wanted to share what I had because I think it's cool and could be useful for making quick graphics for LD.

I have not yet decided exactly what to do with the editor. Right now I'm refactoring the code because there is a lot of prototype code in there, the data and representation is not fully separated etc. This will make the code much easier and faster to work with in the long run, but it also means there won't be any updates for a while (more than small fixes to the LD version if needed).

In the mean time, you can get the LD version of the editor here: /stuff/pyxeledit/

Here is a demo video (sligtly outdated):

If you have any name suggestions I'd appreciate it. Pretty much anything with "pixel" seems to be taken. :)

If you have a Playbook, you can get it for free in App World. Let me know if you have any feedback.

You need a list of lowercase words to filter for. The one I used is far too big to paste here, but you can find one by searching for "bad word list".

private static const badWords:Array = ["lots","of","bad","words"];

// Returns a profane word if found, else ""
static public function checkName(text:String):String {
	text = text.toLowerCase();
	
	for (var i:int = 0; i < charReplacements.length; i++ ) {
		var ra:Array = charReplacements[i] as Array;
		text = strReplace(text, ra[0], ra[1]);
	}
	
	for each (var w:Object in badWords) {
		if (text.indexOf(String(w)) != -1) {
			return String(w);
		}
	}
	return "";
}

The function will detect character sequences that look like some other character, to make it harder to bypass the filter. For example, 1 becomes i, û becomes u, |\| becomes n etc.
In this way "Fuc|<" would be detected for instance. The sequence replacements can even be used to identify inappropriate symbols like "(.)", by converting them to (in)appropriate words if you like. :)

private static const charReplacements:Array = [["@", "a"], ["0", "o"], ["1", "i"], 
	["2", "r"], ["3", "e"], ["4", "a"], ["5", "s"], ["7", "t"], ["8", "b"], 
	["9", "g"], ["|<", "k"], ["|\/|", "m"], ["|\|", "n"], ["ä", "a"], ["ã", "a"], 
	["â", "a"], ["ä", "a"], ["á", "a"], ["à", "a"], ["å", "a"], ["é", "e"], 
	["è", "e"], ["ë", "e"], ["ê", "e"], ["§", "s"], ["$", "s"], ["£", "l"], 
	["€", "e"], ["ü", "u"], ["û", "u"], ["ú", "u"], ["ù", "u"], ["î", "i"], 
	["ï", "i"], ["í", "i"], ["ì", "i"], ["ÿ", "y"], ["ý", "y"], ["ö", "o"], 
	["ô", "o"], ["õ", "o"], ["ó", "o"], ["ò", "o"], ["(.)","boob"]];

You will also need this helper function for string replacement:

// Helper that replaces all "find" with "replace" in the given input string
public static function strReplace(input:String, find:String, replace:String):String {
	while (input.indexOf("find") != -1)
		input = input.split(find).join(replace);
	return input.split(find).join(replace);
}

It works quite well, let me know if you found it useful or have any suggesstions.

48 min RTS

The game is about a robot, endlessly walking on the surface of a small planet. To survive you have to plant seeds, which turn into plants that you can harvest for more seeds, and so on. To make the task more complicated, you keep going faster and faster, and there is a hungry Capybara eating any of the plants he comes across. Colliding with the Capybara or a plant that has been left too long and turned into a thorny dead bush will make you drop all your seeds!

Each time you complete a circle, you need to eat one seed for energy, and if you pass the flag without any seeds you loose.

I made the graphics and music and a little bit of the programming. Andreas Bjerkeholt (Harteex), Disa Faith (Disaia) and Robert Edström (Legogris) did the programming, and we all made the game design together.

You can find out more, and try the game here: http://globalgamejam.org/2012/planet-yrwys. To run it you need Windows and the XNA runtime, but that should download automatically in the installer I believe. You can also use an Xbox controller if you have one.

PLAY

The tools I used:

• Flashdevelop (IDE)


• Flashpunk (Game library)


• Photoshop


• Audition (sound editing)


• Cubase (music)


• Chronolapse (timelapse recording)

Continue reading for more info and a post-mortem.

What went wrong:

I waited far too long to implement basic things like getting hurt, dieing and winning, which meant I had to rush that in in the last couple of hours. The basic gameplay challenge when fighting the ravens is not that hard or fun, I should have worked more on that, as well as added more kinds of enemies, and perhaps a boss. It would also make the game more fun if I added some sort of progression, like new abilities.

The story is intentionally vauge, but only because I didn't have time to flesh it out. It might add to the mystery and mood, I'm not sure. I would really have liked to have time to add a proper ending.

If you miss one of the spheres, you have to go back and find it. I wanted to have some sort of checkpoint, where to pass you would need to complete the part of the game behind you, but I didn't get around to it. This also means you can win the game in different places, which is maybe cool, but...

What went right:

The player physics feel pretty good, although the attacking part can use some more work. I'm proud of the healing mechanic although it isn't used to such a big extent.

The camera doesn't follow the player all the time, instead it snaps to 32x24 tile screens. This was an experiment, and I think it turned out ok. Because the screens are predetermined, you have more control over the scenes the player will see, and can tailor each scene to look as best it can. Of course, it's also a limitation, and can be irritating for the player when navigating small passages for example.

I made the level as one big png-image in photoshop, where each pixel corresponds to one 10x10 pix tile. This made it really easy to edit, and because it was one single big image, I could quickly see how the whole world looked together. In order to see where each screen in the game was positioned, I just filled the image with helper rectangles. It worked suprisingly well.
Here is the final world image scaled up a bit (Warning: SPOILERS!): world.png

The auto-tiling was a thing I threw together in a hackish manner, but it worked really well too, and supports additional tilesets easily given an offset to the base tile (solid tile).

Summary:

Here is the entry page on the Ludum Dare site.

http://www.ludumdare.com/compo/ludum-dare-22/?action=rate&uid=2311

It plays a lot better than the compo version!

There's also lot's of new items and skills you can buy. More info coming soon!

Cross posted at the LD site:

Waking up at 1:30 PM in the day today with aching fingers, I felt happy.

The game is actually pretty fun to play, and not too badly balanced. There are three zones of different colors, and each zone get's a bit harder. The enemies get a little too fast and jumpy after a while though.

I don't regret using Flashpunk this time, it really makes everything so much easier than using just as3 like last time. I spent many hours on a stupid bug though, and realised Flashpunk tilemaps do not actually clear tiles when you call clearTile() on them if the clear tile (index 0) is transparent. That was annoying and made me loose a lot of time.

I think the leaderboard can add a lot to the game. Sadly Playtomic has disabled it's leaderboards due to some problems, but it should be working soon again.

I didn't really make any graphics at all, but focused on gameplay instead. I think that was a good idea, but the game could really use some better graphics. The music and sound effects could be better too, but they do the job.

A breakdown of the time spent in different applications (tracked with ProcrastiTracker):

• Flashdevelop 13h


• Chrome 6h


• Flashplayer 4h


• XChat 2h


• Photoshop 2h


• Cubase 1h

Timelapse:

https://www.youtube.com/watch?v=

The original game had a lot of flaws. There was only one level, you couldn't move for a few seconds when you collided which was very frustrating, the resolution was way too high making it unplayable on smaller screens, if you ran out of fuel it was a chore to continue playing as you fell and crashed over and over, and it just suffered from a general lack of playtesting.

Even though there was many problems, I feel like there is a good game in there. I'm especially happy with the controls and movement of the submarine, and I want to get it closer to it's potential. Due to work over the summer, progress is slow, but I have fixed most of the problems in the LD version, added some new features such as time powerups and mines and replaced many of the rushed sprites with shiny new ones. There are now multiple levels instead of the huge single level, and the tiles in the level are now about half of the original size. (can't remember why I made 'em so huge!)

Continue reading for more info and screenshots.

The walls were very boxy before, I made it better by implementing auto tiling so that the tiles fit together better. At the moment I'm using the original rock graphic. It has been extended into 16 versions which are selected by examining which neighbouring tiles are rock. It could look better and still needs some work, I might redo the wall graphics completely to make it less square.

There are now more than one level in the game. The level format is really simple, using bitmaps. This works pretty well, but there are some limitations. For example there cannot be a rock background where there is an item, which means there will be holes in the background wall where mines or other items are placed. This could be sort of fixed by putting a rock background tile behind the item if more than half of the surrounding tiles are rock, fixing the hole issue.

The way I found was to make a 1x1 bitmap, and then drawing the stage to the bitmap using a translation matrix for the offset. The result is then in the single pixel of the bitmap.

public function pickColorFromStage(x:int, y:int):uint {
   var bmd:BitmapData = new BitmapData(1, 1, false, 0x000000);
   var matrix:Matrix = new Matrix();
   matrix.translate(-x, -y);
   bmd.draw(stage, matrix);
   return bmd.getPixel(0, 0);
}

You can save the base64 string in a text document at the moment as it's not possible to save them in the application, but I have added some hard coded presets you can try using the numbered buttons. (they can be accessed with keys 0-9 aswell)

To open the preset window, click Presets in the panel or press P. To make a base64 string for your brush, click "Generate base64", and copy the text. To use a base64 brush that someone sent you, just paste it in the text area and click "Load from base64".

Open FloralParticles 0.45

You can share presets in the comments below if you want. I might even add good ones as standard presets in the application. :)

• Improved line rendering


• Color mixing


• Multi-step undo/redo


• Fade-To-Color setting


• Save to PNG (lossless and faster)


• Background vignette (toggleable)


• Fullscreen mode


• Mouse smoothing


• New spawner behaviours


• Opacity setting, global and fading per particle

Any suggestions or feedback are welcome, just post a comment below.

Also added is an opacity slider, speed multiplier, a bunch of new controls for the brush behaviour, a color mixing slider which makes the particles pick up the colors from the canvas and a bunch of other stuff. It's a lot of fun!

A runnable is coming soon.

Interface

Open FloralParticles 0.3

-Change color
-Change size
-Shifting color
-Blur
-Freeze Blur (makes a depth-of-field kind of effect)
-Lots of tweaks

All of it is controlled by keyboard presses at the moment, I should make some kind of GUI to make it more accessible perhaps.

You can make some pretty interesting vine graphics with it. It also has an undo function and you can save the image as a JPEG.

However, I settled with the idea of a game where you control a little sub going for the surface, even if it didn't fit the theme. Better a game that doesn't than no game at all, and I kind of made it fit...

Click here to play the compo version (it's in flash): The World Above.

I also made a timelapse of my screen during the making, you can watch it on youtube here: Timelapse.

Near the end the game was pretty good, so I tried to make it worse by adding random control glitches where the player shoots automatically and the controls are reversed. :)

I made the player image in photoshop in literally about a minute, then inverted the image in order to make the enemy. :P Then I just added as many effects as possible, random scaling, rotations depending on position, a psychadelic background that shifts color etc.

The only thing that can hurt you is your own bullets, they bounce back at you from the edge of the screen. The enemies come from the other side, so you have to go back around them or bounce your bullets on the edge. To make the game extra annoying your bullets predict where you are going (basically they get your y-speed) so that they hit you unless you change your speed.

Shooting an enemy earns you 1 point and getting hit loses you 1 point. You win if you get 1000 points.

Programming, graphics and music by me, sound effects made using as3sfxr. Programmed in Monkey. Enjoy! (or don't :P )
Entry page on the Ludum Dare site: http://www.ludumdare.com/compo/minild-25/?action=preview&uid=2311

PLAY (HTML5)

Here's what I've got so far. Enemies just keep on spawning at the moment, so it's kind of repetitive. :P
Chrome recommended for performance. IE doesn't even work yet (until IE9 which is coming out in a couple of days.)

There are currently two control schemes:

Mouse - aim and shoot
Arrows - move

or

Z - strafe
X - shoot
Arrows - move.

Space drops a bomb in both cases. And you shoot backwards. :)

I haven't decided on which to use yet, if you have any feedback make a comment!

PLAY GAME! (Note: Lots of flashing going on. If you have epilepsy be aware!)

Updated! Cleaned it up and added more controls. You can now change the number of steps the ray traces and a bunch of other things.

My team consisted of myself, Andreas Bjerkeholt and Alejandro Valenzuela (check out his detailed report of the event on his blog here!)

The first day we spent prototyping a number of other ideas, (including dinosaur metroite bowling and a planet-light bending simulator where the goal was to make a ray of light reach earth :)) before choosing this platformer.

The major feature in the game is the recording and playback, and we spent a big portion of the time getting that to work good. At first earlier replays were interferring with later ones causing them to go out of sync.

We were planning to have a deadly wall of lava or crocodiles moving towards you from the left, hence the name Parallel Stampede (there's a stampede, and you play many instances of yourself in parallel), but we didn't have time to make that.

We got in a real hurry at the and, and made the levels in about 10 minutes each, and unfortunately the last level is not possible very hard to finish. :D So here is the end screen so that someone sees it and my work is not in vain. :P
(ignore the spelling error)

Some sprites, I'm happy with these considering they were made in a rush:

It was a good experience!

Play it and the other jam games at the Global Game Jam site:
http://www.globalgamejam.org/2011/parallel-stampede

Here is a flash example and sourcecode:

Flash example

Download sourcecode

Assumptions
Here we have a cannon on the ground, trying to hit a flying target. Let us assume the target is travelling with constant velocity, unaffected by gravity, and so is the projectile shot by the cannon.

The target will have a known velocity u. We will also know the speed of the projectile |v| in advance, and we want to find the vector v that will make it hit the target.

Method
The idea is to transform the shooter and target to a new coordinate system where the line between them is one of the axes, match up the parallell speed, and then calculate the appropriate tangential speed for the projectile.

In order for the projectile to hit the target, the I composants of the velocities, vi and ui must be equal. If they are not, the projectile will be too fast or slow in that direction and cannot hit the target.

To calculate vi, first find the vector between A and B, and normalize it. Then project u onto AB using a dot product, giving uj. Subtracting uj from u, we get ui which is equal to vi.

Once vi has been determined, |vj| can be found by using Pythagoras theorem, since we know the magnitude |v|.

Then we can multiply the unit vector AB by |vj| to get vj, and lastly, add together vj and vi to get v

Pseudocode

// Given: ux, uy, vmag (projectile speed), Ax, Ay, Bx, By

// Find the vector AB
ABx = Bx - Ax
ABy = By - Ay

// Normalize it
ABmag = sqrt(ABx * ABx + ABy * ABy)
ABx /= ABmag
ABy /= ABmag

// Project u onto AB
uDotAB = ABx * ux + ABy * uy
ujx = uDotAB * ABx
ujy = uDotAB * ABy

// Subtract uj from u to get ui
uix = ux - ujx
uiy = uy - ujy

// Set vi to ui (for clarity)
vix = uix
viy = uiy

// Calculate the magnitude of vj
viMag = sqrt(vix * vix + viy * viy)
vjMag = sqrt(vMag * vMag - viMag * viMag)

// Get vj by multiplying it's magnitude with the unit vector AB
vjx = ABx * vjMag
vjy = ABy * vjMag

// Add vj and vi to get v
vx = vjx + vix
vy = vjy + viy

It can be interesting to note that any vector v with vi=ui, and vj in the direction of the target, will make the projectile hit the target. For example the two purple lines in the diagram. But the only one with the correct magnitude is the v we have found.

This example is in 2D, but the same method can be used in 3D by considering the plane in which the target, cannon and target velocity lies.

Corner Cases
It is not always certain that the cannon can hit the target. This can be the case if the target is faster than the projectile, and moving away from it. For the hit to be possible u must be greater than vi at the time of fire. If u<vi the expression in the square root will be negative, and thus the root will be undefined, so you should have a check for that.

Example
Flash example

Source code
Flashdevelop project

Update:

Update 2, the same thing in 3D:

Much improved from my first submission I think.

You can play The Secret Documents here.

I will post about experiments and various other things like artwork or music that I make.