play
Check out some of our latest releases here.

Learn more about intuition
Aug
13
Posted By
aeiowu

One of the essential parts in a vehicle is leaf springs. The car’s force is being blocked by it. The leaf springs history can be traced back to the medieval period; its latest version is the parabolic spring. This device, attached to a wheel and axle, provide balance and to remove resistant force. Today, leaf springs are very common in autos. The following heavy commercial vehicles like: trucks, vans, SUVs, and railway carriages are having leaf springs on their chassis.

What are Leaf Springs for?

Leaf springs are deemed crucial as it functions as linkage to hold the axle in place. In that sense, buying a separate linkage will no longer required when your car has already leaf springs placed in it. It makes the suspension simple, yet strong. The force because of a sudden acceleration and braking can be dispelled by leaf springs. The vibrations made by these forces will be dispelled. This helps the car stay intact even if it experiences intensive use.

Plenty of entrepreneurs often believed that folks today are living in the industry of iron. With the advent of technology, info can be access with just a single click. The net gives you info on where to buy leaf springs. It has a wide range for you to pick from. However, before you purchase leaf springs it is essential to think about some factors first. If you want more information, you may head over to buy leaf springs online where you can find much more information.

Primarily, you need to consider first the kind of vehicle that you have. This is considered important knowing the fact that parabolic springs differ from one vehicle to another. Just take this for instance, if you own an SUV, then normally, a larger leaf spring will be needed. That’s why a product provider that you would acquire these materials from should also have parabolic leaf spring with various models or brands of cars. You can do that by asking them in advance.

Lots of people buy leaf springs online. Nevertheless, there are also issues about this since you cannot actually see the material personally. The minute you will see the product is when it is delivered to you. With that said, knowing the reputation of the company plays a crucial role for you to know if the they give a top quality leaf springs or parabolic springs. Talking them directly or reading reviews is the ideal way to do this. Among the things that a trustworthy product company supplies is a hotline number and a round-the-clock customer support that will entertain your questions in line with the product. A cash back guarantee is also provided by reliable firms. In that sense, if you opt to purchase leaf springs online, better check these things out first.

Tags
#

Categories
Greg   game development
COMMENTS
000
Jul
29
Posted By
aeiowu

Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!

Tags
#

Categories
Greg   game development
COMMENTS
000
Mar
02
Posted By
godatplay

In Part 1 I said I would talk about our game Undefined Behavior more specifically. Maybe that wording was a little too liberal. By the end of the game jam, we didn’t really have a game per se. With that said, what we did end up with had a distinct feel to it.

Undefined Behavior Screenshot

The game was supposed to be a sort of first-person puzzle game where you’re a programmer in a highly augmented reality world who accidentally introduced a viral bug which starts to glitch that world more and more. You have to explore the environment and using your “debugging tools” to study specific glitches and figure out what’s wrong. Over time you realize what the symptoms are, which leads to an “ah-ha” moment where you realize what you did followed by a climax last-minute bug fixing. I’d love to come back to the idea at some point, especially since we didn’t get very far with the glitches. Evan did have an idea to use the raw memory data from the program itself to glitch things out, which I thought was great.

As I mentioned earlier, Plaidgadget is a 2D vector-based engine. Despite that, we decided we were going to try out a pseudo-3D, old school FPS style like Doom or Wolfenstein. He was able to take his figure animation system to load in an object drawn from multiple angles, so we could have the object rotate as you walked around it, along with an edit mode for placing objects in a level. For the 3D look, he places figures on the screen and scales them manually, which in some ways is more interesting to me than a fully 3D space.

Undefined Behavior, Editor Mode

Undefined Behavior Screenshot 2

2D vs. 3D

Quick side note: I’m not sure what it is about polygonal 3D (although I certainly have theories!), but many times polygonal 3D graphics just doesn’t seem to have as much character as 2D graphics (it appears I’m not alone in my opinion). An irritation has been rattling around inside my head for the last couple years…concept art looks better than the final end product of a videogame. Concept art is usually just so much more inspiring and full of wonder, and that bothers me. One of my goals in life is to be successful enough that I can lead a “videogame art direction think tank” that has the sole job of learning how to translate the awesomeness of concept art into videogames. I already have a big long list of things for this hypothetical team to do. Maybe someday…

Pushing Against Self-Imposed Boundaries

So anyway, I think a big part of the distinct feel we had comes from trying to hack pseudo-3D into a 2D engine. Despite the fact that I’ve read about this before, actually doing it made me realize first-hand that you can come up with some interesting things when you intentionally give yourself stricter boundaries and then push against them. By taking Plaidgadget, an engine intentionally limited in scope, and trying to see what creative things we can do within those limitations, we ended up with something interesting.

It was a rewarding enough experience that I’ll be thinking about how I can do it again in the future.

Tags
#

Categories
intuition collective
COMMENTS
000
Feb
01
Posted By
godatplay

Our local game developer club, Iowa Game-Dev Friendship, held what I think was our 8th game jam in Ames this weekend. As expected, it was an awesome time. This time my team had a big setback, and because of it I came to a profound realization about game engine authorship and its importance for a meaningful creative experience.  Developers and designers talk about the importance of videogame authorship, but this weekend I realized in a new way how that can translate into game development tools as well.

Background

Before I explain in more detail, you should know I’m increasingly becoming a “get things done” kind of guy, which is manifested by my avid support of the Unity game development tool due to its ability to get something up and running quickly.  Naturally I want to use it for every game jam, and this one was no different.

While brainstorming ideas over pizza, my friend Evan Balster of Plaid Notion (Infinite Blank, Sense of Wonder Night finalist and Kickstarter fundee) and I came up with an interesting game idea based on a mutual affection for glitch art and decided to team up for the game jam. I convinced him to use Unity, but due to some apparent bug in Windows 64 bit, it simply would not install on his machine after at least an hour of effort. In the end, we decided to use his own engine Plaidgadget, and I had to face one of my biggest game jam fears: spending the first 8+ hours setting up the dev environment. I thought we were doomed, but I guess God had other plans…

Evan as game engine

If you’ve ever met Evan, it won’t take you long to realize that he’s a character. He’s very eccentric, which would likely turn off some, but he seemed to me to have a certain innocence and lovable genuine-ness. This feeling was recently confirmed when he offered to help me in a way that only a true friend would.

It didn’t take me long to realize how much of his own character was present in Plaidgadget. If anyone could ever call a game engine “charming in its quirkiness,” I think you would say that about this.

Plaidgadget interface

Plaidgadget is a strictly 2D vector-based game engine – designed with a specific goal to not be a generic do-everything engine. It even has some of its own art tools, including a “figure editor” where you can draw vector shapes and even skin them to bones with simple IK. The workflow is pretty unique, designed with the help of Plaid Notion partner Beau Blyth (Action Fist, Fish Face, Uberleben) and includes a transform tool based on concentric circular areas for pivot, move, rotate/scale, and rotate. It even lets you animate with forward and backward keys and primitive previous-frame onion skinning through showing the outlines, but has no real visual interface for keyframes.

Animated character in Plaidgadget

At first glance, the figure editor seems ghetto and very limited, but eventually I came to realize that those limitations really helped me to focus. It actually changed the way I thought about creating, which is what all of my favorite tools do. By using this tool, I understood more and more how providing a large number of options to perform some task can sometimes slow you down by making you value specific techniques more highly than you should, causing you to spend too much time trying to determine the best course of action. I thought it was funny how much I valued Unity’s “get things done” ability yet missed how it can also sometimes work against that by offering so many choices and by trying to do everything. I was beginning to form a dogma.

Because Evan had a vision for a specific engine that could do one thing well and really put himself (and Beau) into it, Plaidgadget is essentially following the same mentality as many indie games. As a result, it’s both interesting and inspiring to use. Here was this tool that, despite some flaws, still allowed me to focus precisely because it was limited.

Game development philosophy repentance

This realization was liberating in a sense because it freed me from a sort of judgmental mindset about game dev tools. It lifted what was becoming an evil burden off my shoulders. And by the grace of God, that led to a sort of creative breakthrough toward the end of the weekend. This freedom inspired me to design a character and animate a simple walk cycle “traditionally,” i.e. with no skeleton, in about the course of an hour. It was a pretty big accomplishment for me considering I did no planning or sketching at all beforehand and since I don’t consider myself very good at drawing. I essentially sketched a character animation the way one sketches a thumbnail, and it gave me a whole new level of confidence.

I often read about people who say “I can’t believe what I was able to accomplish,” but don’t really experience it myself very much. This was one of those experiences, and I’m not sure if it would have happened had things gone the way I wanted them to. I still love Unity, but I feel like a changed man with an appreciation for what I now consider “indie tools” that have a singular vision and try to take one interesting idea and run with it the way indie games do.

In Part 2, I talk about our game more specifically and how it was impacted by different tools.

The Importance of Game Engine Authorship, Part 2

Tags
#

Categories
intuition collective
COMMENTS
000
Oct
25
Posted By
aeiowu

So Hundreds was the first game that I programmed and because of that I was pretty skittish about showing anyone my horrible code, because… How would anyone get anything from it? Programmers usually pat me on the head and tell me:
Programmer

Oh that’s cute! You put it all in one file.

Yea real cute. Anyway, I guess my hope is that amateur coders or designers/artists will use it as some sort of stepping stone on the way to demystifying how this whole learning process works. The physics in Hundreds are apparently incredibly simple [as far as physics are concerned] but for me they were a huge challenge to understand. Even now looking at them, I don’t understand what’s going on anymore.

Sometimes it’s tough out here in the wild west but I’ll continue to share as much as I can in hopes that it will help others on their journey through the untamed lands of programming. So, here’s the ugly ass source from Baby Greg’s First Game!

If you put this into a Flash compiler you might be able to run it, but there are a few assets [menu items, intros and etc.] that it’ll probably want.

Here’s a link to a plain text file containing all the code if you don’t want to suffer through copy and pasting: HundredsSourceCode.txt. It’s a little under 1000 lines.

Also, I will say that I’m most proud of the way I figured out how to do the stopwatch [levelTime()]. It was a problem I wasn’t really looking forward to, but when I started trying to find a solution I found it more interesting that I thought I would of. It was really rewarding when I finally thought through it completely and solved it once and for all. :)

package src
{
	package src
{
	import flash.display.*;
	import flash.events.*;
	import flash.geom.*;
	import flash.text.*;
	import flash.media.*;
	import flash.net.*;
	import flash.utils.getTimer;
	import flash.net.SharedObject;

	import SWFStats.*;

	public class BPop extends Sprite
	{

		//GAME OBJECTS
		private var color:uint = 0xCCCCCC;
		private var circle:MovieClip;
		private var circleBlur:Shape;
		private var circlePack:Array = [];
		private var colorPack:Array = [];
		private var velocityPack:Array = [];
		private var blurPack:Array = [];

		private var velocity:Point;
		private var mouseDist:Point;
		private var crossDist:Point;
		private var killDist:Point;
		private var bounceDist:Point;
		private var circleDist:Point;

		private var mouseOffStage:Boolean = false;

		private var GROW_RATE:Number = 5;
		private var START_SIZE:Number = 10;
		private var START_RADIUS:Number = 42;
		private var SPEED:Number = 7;
		private var STEP:Number = 3;
		private var colored:Boolean = false;
		private var touched:Boolean = false;
		private var circleShrunk:Boolean = false;
		private var blurCount:Number = 0;

		//HUD ELEMENTS
		private var circleSize:TextField;
		private var circleFormat:TextFormat;
		private var thePause:Boolean = false;
		private var uiPause:Boolean = false;
		private var counter:Number = 0;
		private var circleDeath:MovieClip;
		private var crossDistKill:Point;
		private var bounceKill:Boolean = false;

		private var minCounter:Number = 30;

		//SOUND
		private var circleHit:Sound;
		private var circleKill:Sound;

		//MENU
		private var bg:Shape;
		private var bgHack:Shape;
		private var level:Number = 3;
		private var levelAdjust:Number = 2;
		private var levelStop:Boolean = false;
		private var gameOver:Boolean = false;
		private var gameWin:Boolean = false;
		private var uiGameOver:MovieClip;
		private var uiGameWin:MovieClip;
		private var uiGameLock:MovieClip;
		private var uiTitleScreen:MovieClip;
		private var uiScore:MovieClip;
		private var score:Number = 0;

		private var gameStarted:Boolean = false;
		private var siteLocked:Boolean = true;

		private var timeFormat:TextFormat;
		private var scoreFormat:TextFormat;
		private var levelFormat:TextFormat;

		private var days:Number = 0;
		private var daysString:String = "";
		private var hours:Number = 0;
		private var hoursString:String = "";
		private var minutes:Number = 0;
		private var minutesString:String = "";
		private var seconds:Number = 0;
		private var secondsString:String = "";
		private var mSeconds:Number = 0;
		private var mSecondsString:String = "";

		private var levelStartTime:Number = 0;
		private var levelEndTime:Number = 0;

		private var virginHack:Boolean = true;

		private var iconCircle:SimpleButton;
		private var iconPack:Array = [];

		//SAVING
		private var sharedObj:SharedObject;
		private var saveData:Object;
		private var maxLevels:Number = 1;

		public function BPop():void
		{
			//LOAD SWF STATS
			SWFStats.Log.View(513, "6feb47a0-aa7c-4b86-b7b0-72c0261a7fd6", root.loaderInfo.loaderURL);

			blurPack = new Array();

			//LOAD SOUNDS
			circleHit = new sfx_circleHit();
			circleKill = new sfx_circleKill();

			addEventListener(Event.ENTER_FRAME, tick);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, shiftPress);
			stage.addEventListener(Event.MOUSE_LEAVE, offStage);
			stage.addEventListener(MouseEvent.MOUSE_MOVE, onStage);

			loadLocalData();
			titleScreen();
			stage.focus = stage;

			function tick(e:Event):void
			{
				physics();
				collisionCheck();
				uiLogic();
			}
		}

		private function offStage(e:Event):void
		{
			mouseOffStage = true;
		}

		private function onStage(e:Event):void
		{
			mouseOffStage = false;
		}

		private function shiftPress(e:KeyboardEvent):void
		{
			if (bg != null && e.keyCode == 32) //SPACEBAR RESTART
			{
				runRestart();
			}
		}

		private function runRestart():void
		{
			if(iconCircle != null)
			{
				stage.addEventListener(MouseEvent.CLICK, iconClick);
			}

			if(gameOver == true)
			{
				removeChild(bg);
				removeChild(uiScore);
				removeChild(uiGameOver);

				if(iconCircle != null)
				{
					for(var i = 0; i < iconPack.length; i++)
					{
						removeChild(iconPack[i]);
					}
				}

				iconPack = new Array();
			}

			if(gameWin == true)
			{

				removeChild(bg);
				removeChild(uiScore);
				removeChild(uiGameWin);

				if(iconCircle != null)
				{
					for(var p = 0; p  999)
			{
				seconds++;
				mSeconds -= 1000
			}
			if(mSeconds  59)
			{
				minutes++;
				seconds -= 60;
			}
			if(seconds  59)
			{
				hours++;
				minutes -= 60;
			}
			if(minutes  23)
			{
				days++;
				hours -= 24;
			}
			if(hours <= 9)
			{
				hoursString = hoursString.concat("0");
			}
			hoursString = hoursString.concat(hours); //HOURS

			if(days < 9)
			{
				daysString = daysString.concat("0");
			}
				else
				{
					daysString = daysString.concat(days);
				}

			return daysString + ":" + hoursString + ":" + minutesString + ":" + secondsString + ":" + mSecondsString;
		}

		private function levelSelect():void
		{
			for(var i = 0; i = 0 && i = 10 && i = 20 && i = 30 && i = 40 && i = 50 && i = 60 && i = 70 && i = 80 && i = 90 && i < 100)
				{
					iconCircle.x = 456 + ((i - 90) * 32);
					iconCircle.y = 325;
				}
			}
		}

		private function populate():void
		{
			uiScore = new ui_score();
			addChild(uiScore);

			levelFormat = new TextFormat();
			levelFormat.letterSpacing = -16;

			uiScore.txt_level.defaultTextFormat = levelFormat;
			uiScore.txt_level.setTextFormat(levelFormat);

			trace("score added");
			trace("level =" + (level - 2));

			uiScore.txt_level.text = level - 2;			

			if(levelStop == false)
			{
				for(var i = 1; i < level + levelAdjust; i++)
				{
					circles(Math.random()*(stage.stageWidth - (START_RADIUS * 2)) + START_RADIUS, Math.random()*(stage.stageHeight - (START_RADIUS * 2)) + START_RADIUS, START_RADIUS);

					velocity = new Point(Math.random() * SPEED, Math.random() * SPEED);
					velocityPack.push(velocity);

					if(i == ((level + levelAdjust) - 1))
					{
						levelStop = true;
						trace("done");
					}
				}
			}

			for(var p = 0; p  circlePack[p].x + circlePack[p].width/2 && mouseX  circlePack[p].y + circlePack[p].height/2 && mouseY < circlePack[p].y - circlePack[p].height/2)
				   {
						circlePack[p].y += circlePack[p].height;
				   }
				}
			}

			//START A FRESH STOPWATCH
			levelStartTime = getTimer();

			days = 0;
			daysString = "";
			hours = 0;
			hoursString = "";
			minutes = 0;
			minutesString = "";
			seconds = 0;
			secondsString = "";
			mSeconds = 0;
			mSecondsString = "";
		}

		private function physics():void
		{
			if(thePause == false)
			{
				for(var t = 0; t < STEP; t++)
				{
					for(var i = 0; i < circlePack.length; i++)
					{
						circlePack[i].x += velocityPack[i].x / STEP; //SPEED VECTORS DIVIDED BY STEP ITERATIONS (t)
						circlePack[i].y += velocityPack[i].y / STEP;

						for(var p = i + 1; p < circlePack.length; p++) //CIRCLE TO CIRCLE BOUNCE
						{
							crossDist = new Point(circlePack[p].x - circlePack[i].x, circlePack[p].y - circlePack[i].y);

							if(crossDist.length - (circlePack[i].width/2 + circlePack[p].width/2) <= 0)
							{
								if(circlePack[i].circleColored == false || circlePack[p].circleColored == false)
								{
									bounceKill = true;

									crossDist.normalize((circlePack[i].width/2) + (circlePack[p].width/2));

									var centerPoint = new Point(circlePack[i].x + (crossDist.x / 2), circlePack[i].y + (crossDist.y / 2));

									var circlePoint_p:Point = new Point(centerPoint.x + (crossDist.x / 2), centerPoint.y + (crossDist.y / 2));
									var circlePoint_i:Point = new Point(centerPoint.x - (crossDist.x / 2), centerPoint.y - (crossDist.y / 2));

									circlePack[p].x = circlePoint_p.x;
									circlePack[p].y = circlePoint_p.y;
									circlePack[i].x = circlePoint_i.x;
									circlePack[i].y = circlePoint_i.y;

									//BOUNCE
									crossDist.normalize(1);

									var dotProdVelocity_p:Number = (crossDist.x * velocityPack[p].x) + (crossDist.y * velocityPack[p].y);
									var wallNormalProduct_p:Point = new Point((dotProdVelocity_p * crossDist.x) * 2, (dotProdVelocity_p * crossDist.y) * 2);
									var newVelocity_p:Point = new Point(velocityPack[p].x - wallNormalProduct_p.x, velocityPack[p].y - wallNormalProduct_p.y);

									var dotProdVelocity_i:Number = (crossDist.x * velocityPack[i].x) + (crossDist.y * velocityPack[i].y);
									var wallNormalProduct_i:Point = new Point((dotProdVelocity_i * crossDist.x) * 2, (dotProdVelocity_i * crossDist.y) * 2);
									var newVelocity_i:Point = new Point(velocityPack[i].x - wallNormalProduct_i.x, velocityPack[i].y - wallNormalProduct_i.y);

									var dotProd:Number = (velocityPack[i].x * velocityPack[p].x) + (velocityPack[i].y * velocityPack[p].y);

									if(dotProd = stage.stageWidth)
					{
						velocityPack[i].x = -velocityPack[i].x;

						if(circlePack[i].x + circlePack[i].width/2 > stage.stageWidth) //JITTER CHECK
						{
							circlePack[i].x = (stage.stageWidth - 1) - (circlePack[i].width/2);
						}
					}
					//LEFT BOUND BOUNCE
					if(circlePack[i].x - circlePack[i].width/2 <= 0)
					{
						velocityPack[i].x = -velocityPack[i].x;

						if(circlePack[i].x - circlePack[i].width/2 < 0) //JITTER CHECK
						{
							circlePack[i].x = ((circlePack[i].width/2) + 1);
						}
					}
					//BOTTOM BOUND BOUNCE
					if(circlePack[i].y = stage.stageHeight) //JITTER CHECK
						{
							velocityPack[i].y = -velocityPack[i].y;

							if(circlePack[i].y + circlePack[i].height/2 > stage.stageHeight) //CAN'T GROW PAST SCREEN HEIGHT
							{
								circlePack[i].y = (stage.stageHeight - 1) - (circlePack[i].height/2);
							}
						}
					}
						else
						{
							velocityPack[i].y = 0;
						}
					//TOP BOUND BOUNCE
					if(circlePack[i].y < stage.stageHeight)
					{
						if(circlePack[i].y - circlePack[i].height/2 <= 0)
						{
							velocityPack[i].y = -velocityPack[i].y;

							if(circlePack[i].y - circlePack[i].height/2 < 0) //JITTER CHECK
							{
								circlePack[i].y = ((circlePack[i].height/2) + 1);
							}
						}
					}
						else
						{
							velocityPack[i].y = 0;
						}
					}
				}
			}
				else
				{
					if (bg == null && uiPause == false)
					{
						levelKill();
					}
				}
		}

		private function collisionCheck():void
		{
			if(thePause == false)
			{
				for(var i = 0; i < circlePack.length; i++)
				{
					mouseDist = new Point(circlePack[i].x - mouseX, circlePack[i].y - mouseY);

					if (mouseDist.length <= circlePack[i].width/2 && mouseOffStage == false)
					{
						circlePack[i].circleColored = true;

						circleHit.play();

						if(circlePack[i].height <= stage.stageHeight)
						{
							circlePack[i].width += GROW_RATE;
							circlePack[i].height += GROW_RATE;

							//CIRCLE SPECIFIC SIZE TEXT
							circlePack[i].circleSize.text = (parseInt(circlePack[i].circleSize.text) + 1).toString();

							//COLOR SWITCH
							circlePack[i].graphics.clear();
							circlePack[i].graphics.beginFill(0xff0000, 1);
							circlePack[i].graphics.drawCircle(0, 0, START_SIZE);
							circlePack[i].graphics.endFill();

							score++;
						}
					}
						else
						{
							circlePack[i].circleColored = false;
						}

					if(circlePack[i].circleColored == false)
					{
						circlePack[i].graphics.clear();
						circlePack[i].graphics.beginFill(colorPack[i], 1);
						circlePack[i].graphics.drawCircle(0, 0, START_SIZE);
						circlePack[i].graphics.endFill();
					}
				}
			}
				else
				{
					return;
				}
		}

		private function levelWin():void
		{
			if(gameWin == false)
			{
				trace("win counter: " + counter);
				if(counter <= 30)
				{
					for(var i = 0; i < circlePack.length; i++)
					{
						circlePack[i].graphics.clear();
						circlePack[i].graphics.beginFill(0xDEDEDE, minCounter/30);
						circlePack[i].graphics.drawCircle(0, 0, START_SIZE);
						circlePack[i].graphics.endFill();

						uiScore.alpha = minCounter/30;
					}
				}
					else
					{
						trace("draw me the sky!");
						gameWin = true;
						uiPause = false;
						thePause = false;
						minCounter = 30;
						counter = 0;
					}

				minCounter--;
				counter++;
			}
		}

		private function levelKill():void
		{
			if(gameOver == false)
			{
				trace("lose counter: " + counter);

				if(counter == 1)
				{
					for(var i = 0; i  1 && counter  99 && bg == null)
					{
						trace("win game")
						levelEndTime = getTimer();
						uiPause = true;
						thePause = true;

						if(level - 2 < saveData.maxLevels)
						{
							trace("not added to levels");
						}
							else
							{
								saveData.maxLevels++;
								Log.LevelCounterMetric("Max Level", maxLevels);
							}

						updateSave();
					}

					if(gameOver == true && bg == null)
					{
						//Log.LevelCounterMetric("Max Level", maxLevels);

						bg = new Shape();
						bg.graphics.clear();
						bg.graphics.beginFill(0xFF0000, 1);
						bg.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
						bg.graphics.endFill();
						addChild(bg);

						stage.focus = stage;

						uiGameOver = new ui_gameOver();

						levelFormat = new TextFormat();
						levelFormat.letterSpacing = -9;
						scoreFormat = new TextFormat();
						scoreFormat.letterSpacing = -4;
						timeFormat = new TextFormat();
						timeFormat.letterSpacing = -4;

						uiGameOver.txt_level.defaultTextFormat = levelFormat;
						uiGameOver.txt_level.setTextFormat(levelFormat);
						uiGameOver.txt_score.defaultTextFormat = scoreFormat;
						uiGameOver.txt_score.setTextFormat(scoreFormat);
						uiGameOver.txt_time.defaultTextFormat = timeFormat;
						uiGameOver.txt_time.setTextFormat(timeFormat);

						addChild(uiGameOver);

						uiGameOver.txt_level.text = level - 2; //LEVEL
						uiGameOver.txt_score.text = score; //SCORE
						uiGameOver.txt_time.text = levelTime(); //TIME

						levelSelect();

						for(var i = 0; i < circlePack.length; i++)
						{
							removeChild(circlePack[i]);
						}

						circlePack = new Array();
					}

					if(gameWin == true && bg == null)
					{
						//Log.LevelCounterMetric("Max Level", maxLevels);

						bg = new Shape();
						bg.graphics.clear();
						bg.graphics.beginFill(0xFFFFFF, 1);
						bg.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
						bg.graphics.endFill();
						addChild(bg);

						stage.focus = stage;

						uiGameWin = new ui_gameWin();

						levelFormat = new TextFormat();
						levelFormat.letterSpacing = -9;
						timeFormat = new TextFormat();
						timeFormat.letterSpacing = -4;

						uiGameWin.txt_level.defaultTextFormat = levelFormat;
						uiGameWin.txt_level.setTextFormat(levelFormat);
						uiGameWin.txt_time.defaultTextFormat = timeFormat;
						uiGameWin.txt_time.setTextFormat(timeFormat);

						addChild(uiGameWin);

						//NEXT BUTTON
						uiGameWin.btn_next.addEventListener(MouseEvent.CLICK, nextClick);
						uiGameWin.btn_next.useHandCursor = true;

						uiGameWin.txt_level.text = level - 2; //LEVEL
						uiGameWin.txt_time.text = levelTime(); //TIME

						for(var p = 0; p < circlePack.length; p++)
						{
							removeChild(circlePack[p]);
						}

						level++;

						circlePack = new Array();
					}
				}
			}
				else
				{
					levelWin();
				}
		}

		private function titleScreen():void
		{
			bg = new Shape();
			bg.graphics.clear();
			bg.graphics.beginFill(0xFF0000, 1);
			bg.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
			bg.graphics.endFill();
			addChild(bg);

			stage.focus = stage;

			uiTitleScreen = new ui_titleScreen();
			uiTitleScreen.btn_intro.addEventListener(MouseEvent.CLICK, introClick);
			uiTitleScreen.btn_start.addEventListener(MouseEvent.CLICK, startClick);
			uiTitleScreen.btn_start.useHandCursor = true;

			addChild(uiTitleScreen);

			circlePack = new Array();
			trace("ADDDDDDDD");
		}
	}
}

In case you missed the link to the plain text file, here it is: HundredsSourceCode.txt

Tags
#

Categories
Greg   game development
COMMENTS
000
Aug
07
Posted By
aeiowu

Around 6 years ago or so, 2004 or something, I started looking around for advice directed at budding game developers. At the time I was mostly looking around to see where and how I should start in on my big game idea that I had rolling around in my head for enough time that I decided to try my hand at making it.

It wasn’t long until I found the famous Sloperama post on ideas. But I didn’t believe it, and I don’t think a lot of new developers do either. But it is true. Sort of…

While Tom has good reason to write something like this intended for game dev tenderfoots, I think this nugget of advice can have a decent negative effect on what more experienced developers decide to work on, or even prototype.

So my post is directed towards developers with a few polished games under their belt. To stay with the Boy Scout ranking system, these developers would be First Class or Star. Not necessarily Eagle Scouts [Miyamoto?], but know how to tie a square-knot no problem. They’re comfortable with the execution of the game idea, working on usability, play-testing and have a general understanding of good and bad design. I’m not saying there’s some sort of ceiling on any of these, but I think there’s a point you reach where you feel like you’re “in your cockpit” [Stolen from Mike] when you’re making whatever it is that you’re making.

I think the reason Tom Sloper wrote that article, and so many other veterans follow with the same advice for designers starting out, is due to the fact that many a first timer looking to promote their game solely based on the idea of it is often touting an idea that doesn’t excite people experienced in game development. That’s not all that surprising, though if you’ve made a few games. Or even one.

I’m not excited by my Big Ideas that started me off on this path in the first place. In fact, a friend asked about “my first love” just last night and he seemed disappointed that I wasn’t excited anymore by the idea, like I had lost something along the way. But I’d argue the opposite, I’ve actually gained something and that’s the ability to understand my limits [temporary] as a developer at this point in time and what that means for the games I want to make.

In the beginning I would let ideas run wild with features, story and content. They were sprawling epics of games that would take decades to create with even a medium sized team, but I didn’t care. I was a teenager in love. Now though, an idea of that scope can’t even get me off the couch because it’s too big to understand really quickly. Not that a large idea can’t be great, but it certainly is much harder to test against and I have less experience with that. That’s just me, though.

As I grow as a developer I temper my taste for the game ideas that we come up with and I think more developers should take notice and give ourselves a little more credit as designers. Our latest game, due out in a week or so, is a product of really hashing out ideas based on an abstract concept and trusting our gut for that Eureka moment. I’m not saying it will be typical but the first time we tried doing the brainstorm-room thing, as more experienced developers, it worked. Though it seemed that throughout the process, the important thing was not to settle on good-enough. We had plenty of decent ideas that could have been decent games, but we weren’t excited about those.

For this session we settled on a word or phrase [parallax scrolling] and used it as a starting point to drive the brainstorm. Just about all of our games are centered around one mechanic that seeds teh rest of the game. If we hold true to that mechanic we feel like the mechanic itself will form into something cool and interesting. Anyway, “parallax” went to “speed”, into a discussion about speed and the feeling of going fast and how awesome that is, into talking about propulsion types and eventually into the final solution which was the Eureka moment. It was incredibly obvious to us both simultaneously that we realized it had to be prototyped immediately. I went into my room and created a mockup while Mike made a control-scheme prototype. And we had it.

A lot of my views on ideas now are driven by the experience, and while it may never happen again and I could be totally wrong, I feel like we need to trust ourselves as developers more often and put a little more faith into our ideas, even if they have burned us in the past with those terribly overblown growing-pain game projects that we all embarked on when wide eyed and green. Find a project that excites you in all areas that need exciting! Scope. Style. Gameplay. Innovation? You can have ‘em all, just hold out for the right one and bounce ideas off each other. It’s not like we have a checklist of things that make for a good or bad game project, it’s just what our tastes have become so we don’t need to check them against some sort of rote list or anything, we just kind of know.

I feel like that’s also one really important facet of settling in on an idea [as opposed to rapid prototyping multiple ideas]. Most often, those early game projects that I spent years translating into worthless design documents were solely from my brain, and that’s a problem! Our brains like to give themselves credit when they come up with something “new” so that colors the idea in a favorable light. If you have another brain around that can’t help but give you “big ups” for an idea it didn’t completely have, then you probably know you’re onto something.

Anyway, just wanted to ramble on that for a bit, something I’ve been thinking about while on some downtime. Also, you should know that there are many ways to generate ideas and prototypes. This is just what worked for us last time and we’ll probably try it again for the next game. I’m all for people coming up with personal ideas as a means of expression [I do that also] or shotgun prototypes or picking random ideas off a dartboard. Whatever works!

Tags
#

Categories
Greg   game development
COMMENTS
002
Jun
29
Posted By
aeiowu

Play it right now for free!

I felt a great sense of accomplishment making this game on my own, though I know there is an oceans worth of improvement to be had still, it’s a big milestone for me so I thought I’d share the journey with you all in this post.

My whole career as a game developer has been spent on the visual side of things, which can sometimes be frustrating for me. In my formative years as a developer I often struggled with programmers on any number of levels. Getting something as basic as prototyping the first draft of player movement in the game was an extremely laborious task [we were using a game-maker like tool as well!].

Though, I’m not totally oblivious to coding. I code all my own websites [intuition, Mikengreg, this site...] but that’s more script than anything and when it comes to games I rarely touched more than a config file in plain text or XML scripts.

So a few years ago, during the days of Dinowaurs, I ventured out to try and learn a bit about coding games. At first I started using ActionScript 2.0 with the help of a book or two and I made some solid progress, but I never felt like I “got it”. I think I made some particle systems and a few other toys, but no games.

After awhile I bought a few books on ActionScript 3.0 and dove into the terrifying world of Object Oriented Programming [OOP]. It was a completely new way to set things up compared to 2.0 though it felt more organized. Like there was a more strict set of rules that I’d need to follow that might allow me to uncover the underlying structure of this “magical coding stuff” better.

For the next couple years, and up until just recently, I would find a free night or weekend and try certain things out. Most of the time it was a simple project to learn how input works with the keyboard. Other times it was a grandiose plan to overhaul my portfolio or create a “platforming garden” where I would be able to test and tweak platforming characters. These would always fail miserably because I was in way over my head, but they were wholly necessary to the learning process. After I failed or came up against a brick wall I would often stop studying/coding for months at a time. The frustration was immense and I didn’t really have a community to advise me during. That was fine though. I certainly had plenty to do with my other projects and the break was nice since I would get a little obsessive about figuring out a certain problem.

So this sort of on/off parabola continued until about a month or two ago. I was in a programming phase and I took to going back to the early chapters of the Moock book. I realized I didn’t truly understand the core concepts of many different devices in OOP and I needed to get back to basics. It was here that I learned how powerful functions actually can be and what arrays actually do. I continued to read and re-read these same chapters until I completely understood the building blocks of AS3.0 and it was then that I decided I could pull of an actual game.

Using only circles and frictionless physics I was able to make a full game that I’m pretty happy with. It’s not a game that is supposed to say anything in particular nor is it a game that I think is incredibly gripping or fun for me, but I feel like the concept is sound and the execution decent for my first game. There are many things I would like to alter if I had the powers of an expert coder [motion blur] but those simply won’t be happening for this game.

I hope some of you get a kick out of it and I’m considering posting the awful source here since it might be a good opportunity for some more experienced developers to give me some tips on how to better code something and so on. Though that could get overwhelming as the whole thing is a 100% mess; I’m sure. It’s all in one file! o_O

Oh! And post your highest level in the comments if you want. I don’t have high-scores or anything so this’ll have to do.

Tags
#

Categories
Greg   game development
COMMENTS
008