It Doesn't Have to DO Anything...

Redirect!

2011-04-27T22:52:00.000-04:00

Hi everybody! While I've really enjoyed my time here on Blogger, I've been really thinking about moving on over to WordPress. Also, it's become very apparent that a 100% Flash site is NOT the way to go, and so www.coreyscallahan.com has been merged into what this blog was.

In short, the new It Doesn't Have to DO Anything will still be the place I post new, random Flash doodles, but you'll also find a highlight reel of sorts showcasing my favorite entries from this blog, as well as a few other projects I've done.

So enjoy the new and improved site! And so long, Blogger!

Zounds!

2011-04-20T22:48:00.002-04:00

Large version (recommended).

This here's my step into the wonderful world of sound visualizations! What you're seeing is basically the raw data of an .mp3 file. You've probably seen waveforms like this:

This is using the exact same type of data. Basically, each little "slice" of the waveform is a value between 1 and -1. That value is then amplified (if we didn't, the visualization would just look like a little cluster in the center of the screen) and then positioned based on the sin and cos of that value. Imagine a sound wave like the above, but curled around into a circle - that's what this is!

I'm also using the BitmapData object in Flash, which is a very nifty tool to check out. With it, many advanced effects can be created (such as the more detailed glow seen above). Anywho, hope you enjoy!

By the way, my song choice in this was something I dwelled on for a bit. Certain sounds show up much better in the visualization. Specifically, simple songs with long, constant tones, seem to show very cool geometric patterns. Louder, multi-layered songs tend to cause such complex waveforms that the visualization winds up looking like static. I'm particularly happy with the 6th song above ("Don't Let Us Get Sick" by Warren Zevon).

Twinkle

2011-03-30T22:57:00.001-04:00

Large version. (note that this is the same size but it will load in its own window)

Nope, I don't really know what this is either. I've just been sorta "doodling" out little things in Flash lately. This was going to be a checkerboard style grid of blocks that would grow and shrink randomly. I finished that up, but felt I'd push it in a slightly...blurrier direction. Not that the first thing didn't look cool, but I think this result is more indicative of what the program wanted to be in the first place.

Also note that the colorization is random every time (though one checkerboard grid will always be a shade of blue - I'm not sure why I chose to do that, but I think it has something to do with wanting SOME standardization to it).

Enjoy!

Scraps

2011-03-21T22:03:00.000-04:00

Large version.

Sometimes I randomly poke around on my external drives and find little scrap bits of projects I started and never finished. Or maybe they were just little bits that I didn't find interesting enough to post up on the blog. This was one of those measly little bits that caught my eye the other day. I spent a little time polishing it up - it's still nothing mind-shattering, but hey...it's something! It's GOOD to create!

Anywho, stick around and watch it - it will clear itself once the boxes reach the top. Oh, and if you're lucky, you may even be greeted by a special someone! OOH! Marvelous!

Ohhhhh...shiny and glowy!

2011-02-26T15:46:00.004-05:00

Large version.

Mmm...delicious delicious Flint Particle System!

Quivering Lines

2011-01-03T23:53:00.000-05:00

Large version.

Another end of break, random Flash doodle.

Enjoy!

Glowy!

2011-01-02T18:49:00.002-05:00

Large version.

The blog lives yet! I suppose. Well, this does a whole lotta nuffin', but I think it looks pretty nifty.

Click anywhere in the .swf to swap out a new random set of glowing bars.

It's Alive!

2010-11-09T22:27:00.005-05:00

Large version (opens in a new window)

It's alive! The blog, that is. After a long absence from the blogosphere (Ooh, how Web 2.0 of me!), the urge to program a wonderful little "do nothing" has overcome me. So here you have the very earliest skeleton of a virtual ecosystem. It's not much yet; mainly just little digital Roombas sucking up bits of "food" in order to survive.

At this point, we've got some slight randomization of body size (which determines how fast energy depletes), random move speed and turn times, and random lines of sight. I'm really hoping this turns into a fun little thriving ecosystem with births, species shifting, and a rudimentary idea of how natural selection works. That little countdown on each green harvester is how much energy it has left. The food replenishes itself every couple of seconds and it provides a random amount of energy to the harvesters based on size. You can click the blue "Add Harvester" button to throw another random harvester into the mix.

Inspiration came from a few things, but foremost in my mind is Larry Marder's "Beanworld", with its simple yet charming circle of life. Well, here's hoping this little nugget turns into something fun to watch!

More Doodling...

2010-06-17T21:23:00.003-04:00

Large version.

Hrm...

EDIT: How interesting! Originally the boxes were getting stuck halfway down the screen. They are meant to check if they're at the stage's height (though I did account for the height of the box). In this case, the stage is 600 px high. But the embedded .swf is resized to 400 x 300. The .swf seems to have gotten its bounds set as 400 x 300, but still saw half the .swf height as...300!? Bizarre! Easily fixed with hardcoding the y>600, though.

Sometimes...

2010-06-15T15:47:00.000-04:00

Large version.

Alternate Tribes

2010-06-13T15:53:00.000-04:00

Full version.

Here's an alternate version of the Tribes piece. Different music, the tribe members now smile as they play louder, and an issue was fixed where if you grabbed a tribe member when it was in the center, it was possible to have him get "stuck" on your cursor. This was due to the fact that a shrinking tribe member could potentially get away from your mouse cursor. No contact with the cursor means no mouse release!

On a side note, I'm more than happy to make more alternate versions if people have suggestions or want to submit 8-16 track compositions (in .wav format if you please).

“What should young people do with their lives today? Many things, obviously. But the most daring thing is to create stable communities in which the terrible disease of loneliness can be cured.” - Kurt Vonnegut

Tribes

2010-06-12T18:20:00.001-04:00

Full version.

Well, I've been tweaking and tweaking this thing. Here's my first acceptable version of it. This is essentially a little piece influenced by some recent conversations I've had about music and and culture differences. The original idea was to have 4 "tribes" each playing a very definite style of music. On their own, they sound wonderful - but even as each tribe intermingles with other tribes, the music STILL sounds good! Now unfortunately, I'm at the mercy of Apple's built-in GarageBand loops as my own musical skills are, while existant, not up-to-par for a project like this. However, I do plan on revisiting this and tweaking the music. For now, though, enjoy the festive sounds of Latin Music!

Faux-3D Wire Sculptures

2010-06-04T22:03:00.002-04:00

Large version.

CLICK FOR A NEW CONFIGURATION

Okay, I'm revisiting the curves again. Through a bit of an accident, I managed to create a faux-3D effect using some trig. What's going on is similar to the last curves expriment, only this time we're not randomizing the movement. Also, we're only moving points on the X-axis. Those points are moved by a sin of a steadily increasing number (.01 - interestingly, .1 created jittering line segments and .001 caused the figure to warp on the X-axis).

So WHY does it look 3D? I believe it has something to do with the sine wave having a pretty up close and personal relationship with the circle. Check this out for a graphic that illustrates this in 3D.

I also slapped on a minimal drop shadow to give the lines some depth.

Overall, I'm happy with this little mistake!

Saxomophoooooone....saxomophooooone...

2010-06-03T15:05:00.001-04:00

Large version.

I've been playing with the microphone. This is the "rough" version of what I want to do, and I expect the final to be quite different. So, enjoy! Make sure you have your microphone on - Otherwise, this would be rather boring...

What we're doing here is having Flash interface with a microphone connected to the computer - it listens at the framerate (in this case, 31 frames per second) for external sounds. If it detects anything, it reads back a value greater than 0. By the way, -1 seems to be an inactive microphone, 0 is detecting no sound, and 1-100 is the sound level detected.

Every frame, if we DO hear a sound, a circle is added to the stage which fades at a rapid rate, leaving a glowing impression on a BitmapData field. Adding a little more to it, louder sounds (which return larger activityLevel values) will generate larger circles. If the sound is over 1, we also swap out the color of the glows.

So enjoy! Remember - turn your mic on!

can't let that glow go

2010-05-31T18:59:00.000-04:00

I am absolutely falling in love with the BitmapData glow!

If the above is running a little slow, check out the large version in its own window here.

OR

Download the .swf itself here.

If interactivity is more your thing, check out the clickable version here. The standalone .swf is here.

The reason I'm offering so many options is that yes, these ARE a little intensive on your computer. But when they flow smoothly, boy are they fun to watch...at least, I think so! Enjoy!

I've been playing with curves...

2010-05-29T17:29:00.001-04:00

Specifically, I've been playing with how to animate curves and keep them random but smooth. This here's my second version. The original is below. A little less trippy...or at least a different trippy.

OH, by the way. Click the above to change the color of the glow. Some glows are more powerful than others, so if you don't see much of a glow...click!

The bulk of this is done by connecting an array of points with Flash's curveTo function and then then slightly changing the curve values every frame. The top was made with a BitmapData field over the top to give that glow effect (see 2 posts ago). As for the non-glowing version, I simply told the curves to fill in with a color. Since the points are intersecting all sorts of wobbly angles, you'll have some "negative" areas that won't be filled in, generating a nifty little checkerboard effect.

UPDATE: Looking at this little project the day after the fact reminds me why I love doing this so much. I put a VERY slight offset in the curve points that are randomized. The curves work wonderfully to show how a small change can have a large impact. If the initial offset was too large, you'd see the curves jitter as they scramble to their new random point. With no offset, the curves would essentially loop indefinitely in the same pattern (I'm using sin to loop). This tiny tiny offset adds upon itself, so once through the sin period, it has altered ever so slightly. Given that there are....I think 50? points on each glob of curves, that winds making a whole new pattern EVERY time it cycles through! The odds of getting the same exact curve are next to nothing! Add to that the fact that there are really 3 individual continuous curve globs and you really won't see the same thing twice...fun!

Perlin Noise

2010-05-28T13:04:00.000-04:00

Okay, so messing about with BitmapData inevitably led to learning about Perlin Noise. Named for Ken Perlin, a VFX fellow, it is used to procedurally generate textures in an organic way. I'm still trying to wrap my head around how exactly to use it, but the above is my first baby step into transforming a Perlin field...next step is to apply that field to something else!

Sparklies!

2010-05-27T15:12:00.000-04:00

No large version.

Okay, so thanks to this, I feel I've gained a little knowledge in the world of the BitmapData class in Flash. And good god...if you want some absolutely stunning effects, learn more about it! What we've got here is essentially a Bitmap (literally a...map of bits...) that is showing off its pixel data (naughty!). Since this data is now available to us, we can manipulate it however we'd like. In this case, we're putting a little glow and blur filters on it. HOWEVER...the Bitmap that we've drawn on the stage is a solid rectangle. So why does that glow appear inside this rectangle?

Enter the "draw" method of the BitmapData. See those little flickery particles? Those act as "holes" in the BitmapData. Every frame, Flash is redrawing that initial rectangle and taking a peek at what it looks like. If we have one of our particles over the rectangle, that rectangle isn't visible where the particle exists. So, as far as Flash is concerned there's nothing there. So we get a hole...a hole that can have a blur and glow filter applied to it! Nifty!

It's almost like a fortune cookie...

2010-05-25T22:09:00.002-04:00

Large version - highly recommended.

Whee! Twitter API AWAY! I've spent a little while now trying to get an understanding of the Twitter API and integrating it with Flash. Turns out there are some nice resources out there on how to get it running, but the thing that gave me the most difficulty was learning how to deal with the incoming data (which is in the form of an Atom feed with the Search API).

So...enjoy!

Remember Populous?

2010-05-21T15:28:00.000-04:00

Large.

Man, Populous was fun...

Anywho, what we have here is a fun little world-building tool in an isometric view. Simply grab your parcel of land, and drag up and down to bring it up or down. While that panel is highlighted, use keys 1-8 on your keyboard to swap out different types of land.

The wonderful thing about this, is how easy it is to change. I went with a Green Hill Zone from Sonic the Hedgehog for the design...because...well, it lent itself to it, I guess. Or maybe Sonic 3D Blast really got wedged deep into my brain.

Anyway, changing. If you want more land types, it's easy! I just need to draw it in an isometric view. No programming changes or anything. We could even adapt the programming to use multiple tilesets (say we allow the number keys to now change the FAMILY of tile, and repeated presses will cycle through different panels of that family).

So, have fun. Build things!

Glowy Things

2010-05-18T21:45:00.001-04:00

Large version.

Here's another "gotta make something" post. I'm actually pretty happy with the ethereal feel of it. Sort of ghostly, but not necessarily spooky. There are two elements at play here.

1). Glow Filter. I talked about filters in the last post. This is just adding a glow filter via actionscript. I'm adjusting the strength of the glow with the second important element of this .swf.

2). We're using TRIGONOMETRY again! Now, there are several ways to get the pulsing glow effect, but I thought about it...and...the sine wave came to my aid! If you're familiar with the sine wave, you know that it oscillates from a crest to a trough and continues this (think of a REALLY sloppy sideways "S" - that's pretty much a sine wave). Each of these full runs is called a period. So we have a curve that goes from n to 0 to -n and back to 0. Handy for a repetitive movement! I'm essentially feeding sin an increasing number (representing the x axis - in other words, we're moving RIGHT along the wave) and it's spitting back a stream of numbers that go uuuuuuup and back doooooooown and back uuuuuuup until we all vomit, we're so dang full of numbers! Er. Or something. So our glow strength is going from 10 to -10 and back again. Since a negative strength on a glow makes the glow invisible...well...we don't see it.

OH, almost forgot two little things. The spat out number (the ups and downs) are amplified by 10 to get a strong glow effect. We're upping the amplitude of the sine wave! Joy of joys! The other little thing...when the glow is negative, I'm having some fun making the origin points of the glows jump around randomly in the dark. Creepy little buggers!

NOTE: One last thing, I swear. As each origin point is created, it also randomizes the QUALITY of the glow. That's why you sometimes see nice round glows, and other times you'll see more squared off glows. In this case, I wouldn't say there's a difference in quality. Just different effects.

Playing with Light

2010-05-17T15:43:00.000-04:00

Large.

You probably know how nifty Flash's built-in filters are. Dropshadows, glows, bevels, oh my! BUT, rather than activating these filters with the properties panel in Flash, why not take a peek under the hood and tweak them?

That's exactly what's going on up there. You see, each of those above green shapes is constantly redrawing its shadow relative to the yellow light source. It's actually a pretty easy technique to use, and it's a handy tool for faking light sources in your games and animations.

To actually use a filter in Flash, you'll first need to import it (import flash.filters.* where * is a wildcard OR the name of the specific filter you want). From there, you can just set up a var placeholder for the filter. Something like:

var myFilter;

Then we'll set that "myFilter" to a the filter we want. So...

myFilter = new DropShadowFilter(1,45,0,1,4,4,1,1,false,false,false);

What's up with all those numbers after the DropShadowFilter? Well, those are what we call arguments, and those are the specific parameters of the dropshadow. Flash has a nice built-in assistance tool that will fill you in on what each is. The ones I specifically messed with for the above .swf are the first two (1 and 45, the distance of the shadow and angle of the shadow, respectively).

Now at this point, it's important to note that the myFilter = new DropShadowFilter line is in the ENTER_FRAME of my movie clip - things will be changing, and I want to check for those changes every frame.

Let's take a look at MY version of the above line...
myFilter = new DropShadowFilter(distance*.05,newAngle,0,1,4,4,1,1,false,false,false);

The difference, of course, are the first two values. Those don't mean much without the backing code, so...
diffX = x - LightSource.main.newLight.x;
diffY = y - LightSource.main.newLight.y;
var distance = Math.sqrt(diffX * diffX + diffY * diffY);
newAngle = Math.atan2(diffY,diffX) * 180 / Math.PI;

What's going on? Well, we're first figuring the distance between the green object and the light source (subtract the light source's position from the green object's position for both axes). With our good buddy Pythagoras, we know the distance between two points is equal to the square root of the difference on each axis squared. Uh...C = the square root of A^2+B^2. Trust me.

So there's the distance of the dropshadow! Note that I multiplied it by .05. That's because I wanted to keep the shadow from getting too crazy long.

Now the meat - the ANGLE - of the dropshadow. The line starting with newAngle is where the magic happens. Using some trigonometric witchcraft known as the arctangent, Flash can calculate the angle between two objects. We just need the difference in positions (already got that, remember? diffX and diffY). And since Flash sees fit to deal with trig in radians, but rotation in DEGREES, we need to convert it. Easily done. Just multiply by 180/pi. Huzzah! Trig!

Rainbow Rain

2010-05-15T21:10:00.002-04:00

Large version.

I'm not really sure what's up with this one. I've been a little dry in the creative area lately, so I wanted to just make SOMETHING...so, enjoy Rainbow Rain!

On a side note, my homepage is now up and running! Let me know what you think.

Hooray!

2010-05-03T21:43:00.004-04:00

Large version here.

And if you're interested, here's the project in AIR form.

Why is this post entitled "Hooray!"? Well, because every little box that goes across your screen is a potential party! Click at the right time to smash through the colored boxes. Now, you may notice your confetti enlarges based on how many boxes you take out in one swipe - more smashes at once equals more party!

So...enjoy this! It's been sitting around my drive for a while in one form or another.

Menu 2 - A little more useful!

2010-04-26T22:13:00.000-04:00

Here's the second menu in large form.

This might have a little more purpose. Imagine a contractor wants to offer his or her services, but wants to give potential clients an estimate on the type of work he or she does. Bingo! Done! This would also be useful for just about any shop that sells a variety of items...or any site that wants to show options of any sort, for that matter. Heck, a character artist could show off their creations in a gallery format!

Oh, and it's fairly dynamic - if you want to add another item, it's about a 30-second process (not counting whatever content you add to the panel at right). Yay expandability!

Menus! Menus! God, how I love menus!

2010-04-26T22:08:00.002-04:00

Large version here.

Here is the first of two little menus I whipped up. I realized that this "does nothing" stuff is a lot of fun, but creating something that serves a purpose has its place, too! And so, here you go...

This one is a hypothetical color preview panel. It's not completely useful, but it would have its applications, I suppose. It needs just a few little extras to make it really useful. It wouldn't be a huge stretch to calculate the complementary color for the selected tile to show a little color palette. Anyway, enjoy!

If you didn't figure it out, you can roll over the colors to see them in the large panel. Click the "More" button to slide in a random assortment of new colors!

GloBounce

2010-04-10T10:44:00.000-04:00

Hi there! Since I am delighting in being retarded and not being able to figure out the issue with embedding my .swf into a blog post, you can find the second iteration of the GloBounce here.

If you'd rather have a direct .swf download, you can find that here. Make sure you open that in dedicated Flash player, not just a web browser.

This isn't quite complete, and I may decide to go in a completely different direction with it. For now, though, you can influence the white bouncer's movement based on your mouse position. The bouncer only changes direction when he bounces, so you'll need to plan your movements! The further the mouse is from the bouncer at the time of the bounce, the higher the movement influence. You also control his bounce height this way.

At any time in the air, you can click to initiate a mini-bounce. You can only do this 10 times in the air. Once you hit the floor, your jumps are replenished (man, I should put a meter in there...).

Finally, the point of it - see those white circles? See how many of those you can smack before touching the floor! Some day, I might even have proper scoring in there!

Hope you enjoy.

Bouncin' Along...

2010-04-08T22:40:00.001-04:00

If you're interested in seeing the next little experiment in progress, check it out here!

I'd recommend right-clicking and hitting "save as" to ensure that it displays in the proper bounds.

Bonus Post! Collatz Conjecture

2010-03-31T23:32:00.000-04:00

I definitely suggest you look at the large version.

Actionscript, of course, is a programming language. And one thing computers and programming languages do much more efficiently than humans is...well...compute! We can use this to our advantage and help display very complex math problems nearly instantly. Flash is a wonderful tool to use in eLearning in that the behind-the-scenes number crunching can easily be reflected graphically.

In this case, I stumbled upon something called the Collatz Conjecture. It's a conjecture that basically says that if you start with an integer, you check to see if it's even or odd. If it's even, divide by 2. If it's odd, multiply it by 3 and add 1. Repeat that over and over, and you will ALWAYS wind up with a value of 1.

With larger numbers, this process could take quite a while...so...enter Flash! Simply type in a number you want to check (I've limited it to 8 digits) and click "Go!" to quickly see the resulting path to 1.

Dynamically Shifting Menu UPDATED

2010-03-31T21:55:00.001-04:00

Large version.

Okay, as promised...I've updated this. I was considering making the image loading dynamic, but I kept running into little pitfalls. Nothing a little more time couldn't have solved, but there are already plenty of fantastic external image loaders out there!

Anywho, I've updated this into a photo gallery with a dynamically sized frame to house the images. To preserve the rounded corners' proportions, I enabled 9-slice scaling guides on the movie clip. If you're not aware of it, next time you create a movie clip, look for the little check box titled "Enable Guides for 9-Slice Scaling. When you go in to modify your movie clip, you'll see some dashed lines that are draggable. Whatever is inside of those guides will scale like you'd expect, but the four corners outside of the guides will NOT! Pretty fantastic when you're enlarging rounded curves, especially if the scaling is not proportionate.

Dynamically Shifting Menu

2010-03-29T23:31:00.001-04:00

Large version.

This is the first of a two-stage little doodle I put together. At this point, it is just a grid of menu items that reacts to whatever button you've rolled over. It was a nice little exercise in two-dimensional arrays. Nothing too crazy, but pretty useful for adding a little life to an otherwise ordinary field of buttons. Keep in mind that you can adjust anything about these buttons with the same basic code. You can shift the alpha, the color overlays, size...whatever your little heart desires!

The next step is to turn this into a dynamically loading photo gallery. Why? Why not?

Stay tuned for part 2 in the coming days!

EDIT: Fixed the little odd rollOver issue.

Coming Along...

2010-03-28T17:14:00.000-04:00

It's been a little while! Here we have some progress on the BubBomb game shown in the past couple of posts.

What's new?
Well, there's a new scoring mechanism in place that allows for chaining of pops. In other words, if you pop captured enemies in rapid succession without firing off another bubble, your score stacks!
You'll notice a few new visual features, such as a living background, start button, and score feedback messages.
Powerups are in! Well...sort of. Every so often, you'll see a gold enemy. Pop them to release a powerup into the field. Capture and pop the powerup and you'll get....NOTHING! I've not actually put in powerups yet, just a placeholder item. So as of now, powerups don't do squat. Some potential ideas are modifying your bubbles' behavior or offering a bonus multiplier on your chain pops. Any other suggestions?

Finally, and this is a minor fix, I had noticed an occasional bug that occurred when capturing an enemy too close to the edge of the stage. That seems to have been fixed, but be sure to let me know if it happens again!

That's it for now. Keep it funky!

I'm starting to think I have a thing for bubbles...

2010-03-15T22:36:00.000-04:00

Large version here.

Alright! As you saw from the last post, I've adapted the bubble catching turret game into another game style. Here you have a free-flying ship controlled with your mouse. Click and hold to drop off a bubble mine, and release to detonate it. Any enemy (represented by gray dots) caught in the expanding bubble will be considered "captured". Once you've got a nice run of them captured, ram them with your spiky body to pop them into oblivion!

Be careful, though...you can catch yourself in your own bubbles! Make sure you're a safe distance away before you detonate or else you'll wind up losing precious seconds...

Note that this is a work in progress, and due to that, we're in a sort of free play mode. You have unlimited ammo, no real goal, and no real way to lose. So have fun and get a feel for it! I plan to turn this into a full-fledged game with multiple enemy types (maybe some will require multiple hits before they're captured...), maybe some powerups, and who knows what else?

Comments are always appreciated.

Things are brewing...

2010-03-10T18:55:00.000-05:00

Nope, I've not forgotten about the blog!

For the longest time, I was having issues trying to decide what to work on. So, as I often do, I revisited my old experiments and projects. I've decided to update/reimagine something I created nearly a year ago. You can see a very very rough version of it here.

Gameplay-wise, it will be quite different from the bubble turret I've been showing, but it will share some elements with it.

Stay tuned! I hope to have a little more into it within the next couple of days.

Bubbles, pt.2

2010-03-02T22:38:00.001-05:00

Large version.

Well, the bubble catching game has been updated a bit. What's new in this version?
1) The enemy catching thing is pretty much completed. Now you can catch enemies in bubbles, and once they are caught, they can be successfully eliminated by hitting them with a regular bullet.
2) Powerups! I have the powerup generation in overdrive right now, but you'll notice these black and white logos sliding by. Hit them with a bullet (NOT an exploding bubble!) to activate a powerup. There are 3 - larger bullets, tri-shot, and rapid fire.

I think that's about it for now! Upcoming will be multiple enemy types, maybe alternate types of bullets, and...well...an objective!

Enjoy!

Not much to say...

2010-02-28T23:04:00.000-05:00

Large version here.

Not really much to say here. Slider controls bpm, etc. etc.

I don't know if the bpm is completely accurate.

The plan is to use the growing bars in a better experiment. Soon.

Sorry for the Delay!

2010-02-23T23:17:00.000-05:00

Hello, I've been taking it just a bit easy on the blog posts in preparation for setting up my personal homepage.

It's nothing much now, but consider that domain PARKED!

Bubble Trappings (WIP)

2010-02-21T23:30:00.000-05:00

Large Version.

Keep in mind, this is a WIP! I'm giving you guys a sneak-peek at a little game I've been whipping up. Here you can see the initial bubble cannon aiming, firing, and detonating. Hit tests are all in, and the next step is to make the trapped enemies catchable. There are some other things to do, but this should be wrapped up in the next few days!

Let me know if you have any immediate observations or suggestions. Thanks for reading!

Wind Redux...Redux...

2010-02-20T18:53:00.000-05:00

Large version.

Source.

I have decided to go back to an old project and rewrite it in AS3. I've probably not 100% optimized this to the point that it COULD be, but I just wanted to see how difficult it would be to convert something from AS2 to AS3. Turns out, not too hard! Though I do have to say that dealing with dynamic text is a bit more involved than in AS2. Gone are the days of just dropping in a dynamic text field and saying "go!". Ah well...

I've not yet added the little tag that pops up the beads, but that probably wouldn't be too crazy to do. Just add a text field to the Bead class that ties in to the ID.

I tried to add a blur filter to faster moving beads, and it was working well. HOWEVER, I ran into some really odd behavior when it came to blurred objects and rollOvers. If a blurred object was rolled over just on the edge, it would spaz out and jump between being considered rolled over, and being rolled out of. I'm not sure what the deal with that is! So...no blur! Of course, if we threw out the idea of rolling over, then we could dump the blur in. VERY easy and very nifty!

I've provided the source at the request of mikeland.us.

I Feel I Have Arrived...

2010-02-17T22:19:00.001-05:00

Large version here.

Phew. I'm feeling pretty good. Why is that? Because the above is my first thing ActionScript 3 that I can say I'm pretty happy with! That's right! I have made great strides in AS3 tonight!

I'm all giddy with the possibilities...

As for the coding itself, there's nothing too awfully insane here. We've got a ship that follows the mouse cursor loosely; it does this by moving the distance between itself and the mouse times a fraction of the distance every frame. In other words, if it's 50 pixels from the mouse and we've moving with .5 drag, it will move 25 pixels, then 12.5 pixels, then 6.25 pixels, etc. etc. until it reaches 0.

The bomb is simply a class that initializes with a movement speed on the y axis of -10. Instantly and in every frame, that movement speed increases by .5, giving the illusion of acceleration.

Once the bomb hits, it is removed from the stage and replaced by a shape tweened circle. I manually animated the growth via timeline, but it would be very possible to do so with straight code. That little rainbow flourish you see as the explosion fades is just me playing with code tweens and the ColorTransform object. I simply tween the ColorTransform from a random color to another random color.

There you have it! AS3...I'm warming up to you!

PS:I found this tutorial to be incredibly helpful in learning to get classes to speak to one another. Be sure to download the AS3 source code. Interestingly enough, I had my "a-ha moment" with the AS2 version of this tutorial...hmm...they must be doing something right!

8 Points

2010-02-15T18:44:00.001-05:00

Large version.

This is an offshoot of something I was trying to which was, actually, radically different. Originally, I meant to create grid of dots that would react to your mouse position. In a way of testing when a dot was near enough to the mouse cursor, I had a line tracing between the mouse and dot. Quickly moving around, I noticed you got some nifty little patterns going.

And so, this was born. I had to drastically cut down the number of dots, as the original number (about 80, I think) caused a lot of slowdown.

I could see a simpler version (say just 4 dots/lines) being a nifty little way to add a bit of interest to a simple menu.

UPDATE: I noticed that eventually, this would get draggier and draggier...this was because I wasn't actually able to clear out an array that contained all of the lines. As a quick fix, I set the array to reset every 10 seconds, SO if you see all the lines suddenly blink out of existence, that's what you're seeing.

The Colors!

2010-02-14T23:14:00.000-05:00

Large version.

This is a result of me learning a bit about adjusting the color of a movie clip via actionscript. It was surprisingly very easy! Here's a quick trimmed down version of it. Keep in mind, this is contained within the onLoad function of a the colored panel's Class file.

var colorful = new Color(this);
var colorTransform = new Object();
colorful.setRGB(0x003366);
colorTransform = {ra:Math.random() * 100, rb:'0', ga:Math.random() * 100, gb:'0', ba:Math.random() * 100, bb:'0', aa:'100', ab:'100'};
colorful.setTransform(colorTransform);

The first line sets up a Color object and assigns it "this", or whatever movie clip you want it to adhere to. After that, we create an Object called "colorTransform" which will contain all the information for the actual color transformation. That information includes, as you can see, a long list of parameters such as "ra" and "ba". It seems like a long list, but there are essentially two types of parameters that relate to the red channel, green channel, blue channel, and alpha channel. The three I'm dealing with here are the ra, ga, and ba parameters which is a number from -100 to 100 and controls the percentage of that parameter's color. So, something like ra:100, ga:50, and ba:50 would yield a pinkish color.

Once we've set up what the colorTransform IS, we simply set it to our original Color object. Simple, eh? You can experiment a ton with it and even set up color tweens with this.

Bonus! You can use this on photos, too! Just be sure to set the imported picture to be cached as a Bitmap and the above code will work on it.

Enjoy!

Silver - the Musical

2010-02-10T09:30:00.000-05:00

Hey everybody, I just finished up helping a buddy put together a site for his upcoming project.

It's called Silver, a musical based on Robert Louis Stevenson's Treasure Island. Check it out!

Bing!

2010-02-07T12:36:00.001-05:00

Large version here.

This little guy started out life as a simple sorting experiment. Originally, the falling discs would pass through the flashing white "sensor" and be sent to a different column based on their color and type. Once that was out of the way, I decided to add a few more things. For one thing, why not give the user some feedback when a disc leaves the stage? The version just prior to this one had no user interactivity; you just watched the discs falling and they'd "bing" as they left the stage. Due to the random nature of their spawning, it produced some nifty little melodies. Never anything TOO intricate (we are just dealing with 4 notes here...), but enough to be amusing.

Though I was rather pleased with the non-interactive version, I wanted to let the user feel like they were having an effect on the little Bing World. So, I slapped in an Breakout-style paddle that let the user keep a disc from being instantly removed. Next came some wrestling in my mind. Do I want the user to just influence what happens? OR do I want the user to CREATE what happens? In other words, should sounds come only if a user does something, or should the sound ALWAYS happen - the user just redirects it? In the end, I decided to let the user create the sounds, so a disc won't bing unless it has been first been hit by the user's paddle.

What do you think? Would you like to see sound happen even without user input? Or is it a better feeling knowing that, in a way, you created a quasi-composition?

And another thing...are the sounds too annoying? If anybody has any ideas on different sounds, let me know (or better yet, send them to me in .mp3 format - if it's nifty enough, I'll put it up here!).

Anywho, take care everybody. And enjoy.

Updated Embers

2010-02-04T14:06:00.000-05:00

Hello, just letting you all know that the source code for an updated version of the previous Embers.swf is now available on My Media House.

Enjoy! By the way, exporting as an .html and setting it as your desktop wallpaper gives a little life to your desktop. Just...be careful not to overdo it.

Since the last one did too much...

2010-02-01T22:53:00.000-05:00

Large Version Recommended.

In a departure from the previous project, I whipped up something that's just fun to look at. When the .swf loads, you'll get 4 little orbs of light that fly around randomly, leaving a trail of glowing embers. You can hit one with your mouse to cause it to pause and grow a bit. Clicking will produce a brand new one.

So nothing TOO crazy here, but each ember's flight path is based off its previous position. Every frame, the ember looks at its current move speed and then varies its vector by a small degree (between -.5 and .5, which when added 31 times per second really adds up!) In other words, you get generally smooth arcs instead of rapid sudden changes in movement. If you wanted to produce a slower, lazier arc, you'd just put a bit of a delay in the change in position. Maybe have it adjust its flight path every 15 frames instead of every single frame.

So, enjoy and gaze a bit!

Links

2010-01-30T10:37:00.001-05:00

No real blog update at this moment, but I wanted to bring your attention to a new section to the right of the blog. I've added a spot reserved for links to other sites that are of interest to me. The first is a link to My Media House, a site that's just getting revved up. Right now there's a nice batch of FREE stock files including a few photos and Flash files. Expect this site to grow in content in the near future! I plan to be contributing to this site often.

Also added is a link to Oxygen Education, my current place of employment. For those interested in how Flash is applicable to an educational setting, take a look! Or take a look if you just like really nifty-looking interactive programs based in Flash.

Well that's it for the moment!

Wahoolazuma!

2010-01-27T23:06:00.002-05:00

Big version here.

I'd heavily recommend downloading the .swf and running it from your local machine, but through a web browser is fine, too.

First off, let me say this game was inspired by Larry Marder's Beanworld. If you've not checked it out, it's definitely a fun read! Equal parts quirk, wonderment, and charm, it makes a great gift for just about anybody!

In Beanworld, the behaviors and lifestyle of the native beans are explored. Though it seems to be a pretty contained system that makes some sense, the nature of the beans is a simple one, often left to the imagination. In other words, a wonderful source of inspiration for fun little mini-games!

In case you're wondering the story behind the above game...well...go read Beanworld yourself!

By the way, this is a simple, rough version. If I were to create a game for anything other than my own personal learning experience, there are a few things I'd change. Any suggestions? I just might touch something up if you demand it!

EDIT: So it seems you can't score any points UNTIL you get a multiplier. I'll fix that up...soonish.

And I'm back...flowers in hand. Er...screen.

2010-01-23T15:29:00.000-05:00

Big 'un here.

Yikes...it has been nearly a week since my last update! I can't let this happen again...

Anyway, the above is the result of a quick little experiment. The instructions, should you want to know what you're doing before you're doing it, are as follows:
The white flower is considered the "active" flower.
Click any segment of the active flower to spawn a new flower in that segment's direction.
You can also use your arrow keys to spawn a new flower.
Click the purple diamond to send out a tracer that traces the history of the buds.
Click the purple circle to clear the field of flowers.
The green slider lets you move the field around, so you can construct flowers even outside of the window!

That's it for now! I've been touching up the slingshot, and I've also been putting together a couple of mini-games for work. If I can, I'll post those games so you can see what it is that I do.

Speaking of work, we've just rolled out our new website!

Take a look!

Gotcha!

2010-01-16T16:37:00.000-05:00

Large version.

I lied! Here's an update to the slingshot. I've got a decent idea of where I want this headed now, so I plan to get it polished up in the next few days!

The biggest addition here is the addition of the capturing bubble that seeks out berries that have fallen. Once it "sees" one, it rushes to it and grabs it. With berry in tow, it returns it to the center of the screen, drops it off, and a new berry spawns. This will be a huge element in the final product.

Slingshot pt. 2

2010-01-13T22:23:00.000-05:00

Well, today has been quite the day. Little annoyances have plagued me throughout the day. I'm sure we've all been assaulted by the terrible images coming in from Haiti. All of my little issues seem so small compared to what they are going through down there. I encourage you to send good thoughts (or better yet, a little spare cash) down south. Our local Fox affiliate has a nice collection of links you can find here.

Right-o, then.

Large version.

As you can see, I've made some progress in this slingshot app. I have an idea of what I plan to do with this, but it might not be fully realized for a short while yet.

Slingshot (WIP)

2010-01-11T22:15:00.000-05:00

Large version.

I'm not completely done with this one yet, but I did want to upload my progress so far. To fire off a shot, click and hold one of the two yellow dots. Drag back, and release it to fire! You can pack a lot of energy into a shot, so if you pull back too far, you'll likely send it flying insanely fast off the screen.

I'll be touching this up and doing a little more with it in the next few days.

Wind Redux!

2010-01-09T16:01:00.002-05:00

Large version.

I decided to go back to the .swf from a couple of posts ago and add a few features. I think that this really shows how this could be formed into a useful application.

Controls are the same, but now rolling over any of the particles with your mouse allows you to see a few scraps of data from it, including:

the ID (based on when it is added to the stage)
the type (in this case, based on the color)
the weight (which determines size and speed)
the speed on each axis at which the particle is moving

Letter Scramble (WIP)

2010-01-07T23:21:00.001-05:00

Large version.

Okay, this project is not quite 100% finished, but I'm not sure what else I'm going to do with it.

Not much to say about it. Type something in the white field and then click the grey INPUT button. Once the button is clicked, whatever is in the text field is split up using Flash's .split() ability. Each letter is sent into an array in order. From there, a movie clip is added for each letter. This movie clip has a target letter which is what we want the movie clip to ultimately display.

The randomization is achieved by having an array of possible letters (a-z, and A-Z). Every 2 frames, the text field is filled with a random letter from the array until this swap has happened a set number of times (25*letter position+10). When the set number has been reached, BAM! The field is then filled in with that target letter from earlier.

I plan to flesh this out and maybe even use it in a useful way in the future, so if you have any suggestions, let me know!

EDIT: Linda asked about having all of the letters stop at the same time. Here's a .fla file that contains the code that does that.

Any way the wind blows...

2010-01-06T22:42:00.000-05:00

Click and drag the green gem on the above .swf.

Large version here.

I was going to post something about randomizing text with input fields, but this little guy popped into my head on the drive home from work. At my place of work, Oxygen Education, I recently helped a co-worker develop a wind turbine simulator. It was fairly simple, where the _rotation property of a movie clip changed based on where a specific draggable movie clip was.

Well, I decided to take this concept a step further and control an entire ARRAY of movie clips with it. And I thought to myself, I thought "Well, why not allow movement in all directions?"

And so I did. A simple for loop adds the bead movie clips to the stage at random positions. As they are added, an empty variable called "weight" is filled in (which I've set as a number from 1-10). The weight adjusts how large the object is, and also has an effect on the movement speed. You'll notice the larger, and therefore "heavier", beads move a bit slowly. This is accomplished by setting the movement rate to a number multiplied by a decimal (determined by the weight).

So there you have it! Another useless, yet fun to watch, Flash experiment!

Placeholder

2010-01-04T21:43:00.001-05:00

Okay, I really don't have anything for you guys today. I have SOME things I could post, but not really the time tonight to fully explain them. So...enjoy this hastily-scrawled vector turtle thingum I found sitting in my "Doodles" folder.

Tilepalooza

2010-01-03T14:45:00.000-05:00

Large version here.

I'm really not sure what to DO with this yet, but I felt I'd share it anyhow. Seems like it's not a bad idea to try and keep posting a Flash working every day or two. Any ideas anybody? It almost seems like a nice start to a puzzle game or a fun little password system.

Mockery

2010-01-02T11:27:00.000-05:00

A week or so ago, I was helping out a buddy Jake Mansfield with setting up the coding basics of his personal website. He essentially wanted the site to act like a desktop, with draggable icons and such. So, taking the little bits of code I used from that, I decided to whip this up last night.

Large version here.

No real content of worth on it, but you could definitely use this as a starting point for an actual website! In fact, I just may do that...

Capstone 2009

2010-01-01T16:50:00.000-05:00

Well, a new year is upon us. And just about a month ago, I presented my final Capstone project at the 2009 MAS Capstone event at IUPUI.

This requires a larger space than I have available on this blog, so here's a link to the large version. And here's a link to the local version all zipped up nice and tidy for you to see on your local computer (running the .swf in a standalone Flash player is MUCH faster than through a web browser). You can run each .swf individually in the local version, but the main interface is titled "container_cursor.swf".

For now, just play around with it and let me know what you think! In the next few posts, I'll focus on each individual aspect of the project. I'd be happy to answer any questions and share with readers some of the source code.

Christmas Hurl

2009-12-24T17:22:00.000-05:00

I recommend going to the large version here and saving the .swf to your desktop.

The holidays are here! In celebration, I've whipped up the above. It's a simple little tree decoration thing that showcases a few concepts. First off, we have gravity and physics. As each ornament falls, it picks up speed, giving the illusion of gravity pulling. Surprisingly, faking gravity is INCREDIBLY easy! You see, each movie clip is moving a set amount every frame (shown as _y+=dy where dy is a number). The trick here is that the "dy" constantly increases by a set amount. So let's say dy starts at 0 but increases by 1 every time.

Frame1:
dy = 1
old _y = 0
new _y = 1

Frame 2:
dy = 2
old_y = 1
new _y = 3

Frame 3:
dy = 3
old_y = 3
new _y = 6

and so on...but remember, you're likely running around 24 -31 fps, so your change in dy should probably be tiny (experiment with this to simulate different gravities! I tend to use .1 as a baseline, but it changes depending on how I want something to move).

Speaking of dy, the bouncing effect is a neat little trick, too. When the movie clip hits the bottom, it is first moved to the bottom edge of the screen (if something is moving fast enough it goes PAST the bottom of the screen, so this rights it) and then it's dy is multiplied by -.7. Why not -1? In the real world, some energy is lost to the ground when a ball bounces (ever have a really heavy box fall beside you? Even if you didn't get hit, you definitely felt the box thud! That's the dissipated energy...some of it, anyway).

The last little bit I'll share with you is how to calculate the speed of the thrown object. To be honest, this was an experiment that I really didn't expect to work. But surprise! Work it did. Essentially, we're keeping track of two values. Where the mouse is NOW and where the mouse was a frame ago. These values are updated every time the mouse moves, and the difference between the two is stored as a number. When you release the ornament, that difference is used to determine the speed of the the thrown object. Nifty, eh?

Well, that's it for now. Merry Christmas!

Feelin' Lucky?

2009-12-20T15:31:00.000-05:00

Larger version here.

In a departure from the stuff I normally do, I decided to make an actual game. Here you have a 4-reeled slot machine. You place your bet (top 3 red buttons) and your risk of the spin (bottom 3 red buttons). Then click the purple "roll" button and you're off!

Your winnings are determined by how many of the rings line up once the spin is completed.
No Matches: 0
One Match: (your bet) x (risk/2)
Two Matches or 3 of-a-kind: (your bet) x (risk)
All Four: (your bet) x (risk) x 5

This isn't an absolutely crazy to program game. I use modulus (%) to determine when or if one of the rings should stop. Each ring is simple a tweened animation, and every 1, 2, or 5 frames (based on risk 1, risk 5, or risk 10 respectively) it rolls a counter to see if it should stop or not.

Once all four rings are stopped, the frame number of each is pushed into an array. Each value in the array is compared to the rest of the values to see if they match. Different numbers of matches indicate what the winnings should be. I wasn't quite able to compare a single value against everything else and then exclude it from the array (probably could, but not worth the headache), so a non-match actually shows up as 4 matches (the checked value in the array checks against itself as well).

Oh, and the little "$" button in the corner refills your credits to 100 if you are below 100 credits.

Rising Bubble

2009-12-18T00:16:00.000-05:00

Alright, first post après capstone. This is just a little experiment toying with trigonometric functions as a method of movement. Once you click somewhere in the stage, a bubble is added. A few starting values are randomly selected and then plugged into the function of a sine (sin) wave. The x coordinate of the bubble is the result of the sine wave function. A constantly increasing value is plugged into the sine function and the result is the x coordinate. Since a sine wave is a repeating, oscillating curve, we get the left to right motion. The change in the y coordinate is simply a constant increase (though that constant is randomized at the beginning of the bubble's life cycle).

Enjoy! Expect another post (maybe something a little more complex) in the next few days. If you have any suggestions or just want to see something specific, let me know. I'll see what I can do!

Sketchy

2009-12-07T20:49:00.000-05:00

Time is tight what with the end of semester fast approaching, so here's another little experiment I whipped up back in the day. The gist of this program is that whenever the mouse button is down, Flash generates an empty movie clip which is then filled with a line created through Flash's built-in drawing API.

The main unique thing about this is that Flash grabs the endpoints of the line from the mouse and a tiny movie clip on the stage. Though this may not be too awfully different from your standard drawing program, this process could be animated easily. In fact, I have another version of this where the origin points move around randomly drawing lines between them. The effect is much like an old familiar Windows screensaver.

I probably will hold off on posts until after this Friday. This Friday is IUPUI's capstone night where I will be presenting my final senior project. If you're in the Indianapolis area, feel free to stop by and check out all the nifty New Media projects!

Eno?

2009-12-04T02:44:00.000-05:00

This is a super basic little thingum...but then, I'm also feeling a little fried at the end of this week. This requires headphones or speakers, and though it may take it a second, I swear it IS doing something after you click start.

This is pretty much an incremental counter that, when it hits a certain point, cues in an .mp3 and calls a function that adds the little sound notification text. Nothing huge, but I did use some similar code to create the soundtrack for my upcoming capstone project.

Stay on target...

2009-12-01T10:44:00.000-05:00

Just a little quick one. Here we have a "seeker" movie clip that is constantly on the hunt for those delicious little green orbs. It will turn to face the nearest one (or the one it's currently chasing) via some trigonometry. The chasing is nothing too incredibly complex. There's an invisible hit box surrounding the seeker and when it hits a green orb, the seeker's change in coordinates is based off of where the orb is relative to the seeker.

You may notice the seeker has a preference for one of the orbs. I believe that if both orbs are within sight, the seeker goes after the one it is currently chasing. I have seen it do an about-face to chase the other orb, but I think that's because I've put in a cool down period for the chase. In other words, if the hit zone ISN'T hitting the green orb, the seeker will still give chase for a half second. During this cool down period (invisible to the viewer), the seeker can freely change targets if one is available.

Dynamic Text Loading

2009-11-29T14:55:00.000-05:00

EDIT: Okay, for some reason the embedded .swf couldn't locate the .txt file in the same directory. So, here's a link to a version that works.
Remember, use the arrow keys to move the letter origin point.

Alright, here we have another old random experiment from a few months back. Basically what we have here is a .swf pulling in text information from an external .txt file. Every half a second or so, we pull the next character from the text file and shove it into a new dynamic text field. This text field is inside a movie clip that simply fades over the course of a few seconds.

Simple stuff here, but it amuses me! But then, so do sparkly objects and keys, so...

Anyway, you'll find the .as file below (that houses the origin point's controls) and the .fla containing the code. The "testTxt.txt" is the text the .swf pulls from, so if you want to save these files to your local machine, be sure to grab that little guy, too.

ALSO, you may wonder why I have my loadVars line in the onEnterFrame function...sure, it costs a little more computation, BUT this allows for instant updating. You could have this .swf open, modify and save the .txt file, and BAM! The .swf instantly reflects the changes made without have to recompile. Slick, eh?

text file
.fla source
.as source

Shuffle Board

2009-11-27T20:26:00.000-05:00

Ah, simplicity...

I sat down today and wanted to whip this up. After a couple hours, I realized I was getting nowhere. I was approaching this completely backwards. See, originally I intended to keep an array of the x and y coordinates of each dot. THEN, I wanted to shuffle each of those arrays around and assign them to the dots. This turned into a huge hassle, as I realized by completely shuffling them, you always had some overlap (it was possible to have several dots in the same location). SO, I tried to store each x and y coordinate as a pair into an array. That sort of worked, but based on how I originally added the movie clips to the stage, I could only truly randomize either the rows or the columns. Everything moved in this case, but if all columns were randomized, then all rows would move together as a group.

So then it hit me. Don't shuffle the coordinates. Shuffle the DOTS! Duh! If I would have approached this from that perspective at the beginning, this would have taken minutes rather than hours.

Source files:
scrambleDots.fla
Scrambler.as

CatScope Gradient Mask

2009-11-24T23:42:00.000-05:00

Ooh, masking! For those of you who have never messed around in Flash or any other graphics package, the idea of a "mask" may not be completely clear. The way I think about it is that a mask acts as a window over another image. Look out your window. Think of the outside as a single large image. Your window (NOT the wall!) is the mask. It's a bit misleading in that a mask actually SHOWS something instead of hiding it.

That being said, the above is an example of a mask. Not only is it a mask, but it's a GRADIENT mask (notice how it fades to black around the edges). Gradient masks can be tricky in Flash, as you have to use a dynamic mask via actionscript instead of simply plopping a mask onto the stage.

Painterly

2009-11-23T20:37:00.000-05:00

This is one of many similar things I've put together. I sort of lumped them all together into a "Painters" series. Essentially you have various leaders that will chase your mouse cursor. As they do, they drop off little dabs of "paint" which fade and drift away after a few moments.

At some point in the future, I might combine many of the Painters into one single object that I can upload here. There were so many types...some that twinkled, some that DIDN'T fade, some that snaked off into tiny little extra tendrils...

Once again, a simple but fun one! Enjoy!

EDIT: Almost forgot! The large version is here.

Tiles

2009-11-22T22:43:00.000-05:00

This isn't anything TOO amazing, but it's been laying around my drive for a little while. Just a fun little repeating sequence of tiles. And don't think this is the pinnacle of my programming! It's just a tiny little thing I whipped up quickly. Very quickly.

If you'd like to see it in a larger (1024x768) version, head here.

Welcome!

2009-11-22T22:09:00.001-05:00

Welcome to this brand-spanking new blog! I have decided to set up an area where I can easily showcase my random workings in Flash. Why the title? Well, I've seen a million Flash workings that DO something. Either they're a set animation with a beginning and end, or a game that also only exists for a set time period. My creations tend to be a little more abstract and really don't have a set timeline. You see, they don't really have to do anything...

For the record, most everything I will be posting in the near future is still in ActionScript 2.0, but I plan to begin educating myself (finally) in AS3 after graduation this December.