Game Maker

This is the story about a computer manufacturing company that is struggling to return to its glory days back in the late 90's. With the commoditization of computers, every computer manufacturer is now producing the same thing. Even the packaging has become a copy of our struggling manufacturer's.

Everyone was using the cow spotted boxes!

As it turns out, some aliens have hijacked a shipment of fake cow spotted boxes, added anti-gravity devices and armed them with exploding 3.5" floppy disks.

Maybelle, the retired cow, has been given the task to destroy the fake cow spotted boxes and eliminate the aliens possessing these card board containers before it's too late (whatever that means).

There is one condition- no laughing. I am not a graphic artist and will never be one (as you can probably tell).

None-the-less, I'm sucking it up and ignoring all comedic comments regarding Maybelle the Cow.

Why? You ask, is the cow upside down?

Because our cow is equipped with nuclear cow milk that she uses to destroy those alien controlled fake cow spotted boxes which fly above her head. So, she needs to be upside down.

Remember, they've taken control of the competitors fake cow spotted boxes and have armed them with exploding 3.5" floppy disk.

First, I set up some globals that define our visual dimensions.

Script Name: initGame

// Create and set global variables

// SCREEN DATA

// Screen width
global.gScreenWidth = 1024;
// Screen height
global.gScreenHeight = 768;

// The view is the rough area within which
// we'd like our path to remain.

// Left position of view
global.gViewLeft = 112;
// Right position of view
global.gViewRight = 936;
// Top position of view
global.gViewTop = 72;
// Bottom position of view
global.gViewBottom = 500;

I created some globals for configuring our path generator.

Script Name: dataPath

// PATH DATA

// Number of random paths to create
global.PathCountCreate = 25
// Number of times to loop the path
global.PathLoop = 4;
// Speed of objects on path
global.PathSpeed = 30;
// Create path queue
global.PathQueue = ds_queue_create();
// Set this to true when a new path is desired
global.PathGetNew = false;

Now, I created a random pathPoint generator. Depending on what quadrant we want the point in, a random point is added to our path.

Script Name: createPathPoint

// This is the path we're working on
// argument0 --> path
// The quadrant from which we want our random point
// argument1 --> quadrant
// The speed along the path
// argument2 --> speed

var nPath;
var nQuad;
var nSpeed;

var nLeft;
var nRight;
var nTop;
var nBottom;

nLeft = global.gViewLeft;
nRight = global.gViewRight;
nTop = global.gViewTop;
nBottom = global.gViewBottom;

nPath = argument0;
nQuad = argument1;
nSpeed = argument2;

{
switch(nQuad )
{
case 1:
path_add_point(nPath , random((nRight-nLeft)/2)+nLeft, random((nBottom-nTop)/2)+nTop, nSpeed );
break;
case 2:
path_add_point(nPath , random((nRight-nLeft)/2)+((nRight-nLeft)/2)+nLeft, random((nBottom-nTop)/2)+nTop, nSpeed );
break;
case 3:
path_add_point(nPath , random((nRight-nLeft)/2)+nLeft, random((nBottom-nTop)/2)+((nBottom-nTop)/2)+nTop, nSpeed );
break;
case 4:
path_add_point(nPath , random((nRight-nLeft)/2)+((nRight-nLeft)/2)+nLeft, random((nBottom-nTop)/2)+((nBottom-nTop)/2)+nTop, nSpeed );
break;
}
}

The is where we create a random path. The number of passes is the number of times we want to create 4 random points in our path. The beginning and end of paths are located in the upper left corner of the screen. Imagine the object waiting in mother ship located in the upper left, coming out of the ship, traveling around and returning back to the mother ship.

Script Name: createPath

// argument0 --> number of passes
// argument1 --> speed

var quadrant_pattern;
var loop;
var maxloop;
var pathspeed;

maxloop = argument0;
pathspeed = argument1;
path = argument2;
// Select a path pattern to use;

// Clear path object
path_clear_points(path);

// Create beginning of path
path_add_point(path, 0, global.gViewTop/2, pathspeed );
path_add_point(path, 80, global.gViewTop/2, pathspeed );
path_add_point(path, 128, global.gViewTop/2, pathspeed );
path_add_point(path, 176, global.gViewTop, pathspeed );

for (loop=0; loop < maxloop; loop+=1)
{

quadrant_pattern = round(random(6));

switch (quadrant_pattern)
{
case 0:
// Quadrant order is 1-2-3-4 (SAME AS 6)
createPathPoint(path,1,pathspeed );
createPathPoint(path,4,pathspeed );
createPathPoint(path,3,pathspeed );
createPathPoint(path,2,pathspeed );
break;
case 1:
// Quadrant order is 1-2-3-4
createPathPoint(path,1,pathspeed );
createPathPoint(path,2,pathspeed );
createPathPoint(path,3,pathspeed );
createPathPoint(path,4,pathspeed );
break;
case 2:
// Quadrant order is 1-2-3-4
createPathPoint(path,1,pathspeed );
createPathPoint(path,2,pathspeed );
createPathPoint(path,4,pathspeed );
createPathPoint(path,3,pathspeed );
break;
case 3:
// Quadrant order is 1-2-3-4
createPathPoint(path,1,pathspeed );
createPathPoint(path,3,pathspeed );
createPathPoint(path,2,pathspeed );
createPathPoint(path,4,pathspeed );
break;
case 4:
// Quadrant order is 1-2-3-4
createPathPoint(path,1,pathspeed );
createPathPoint(path,3,pathspeed );
createPathPoint(path,4,pathspeed );
createPathPoint(path,2,pathspeed );
break;
case 5:

// Quadrant order is 1-2-3-4
createPathPoint(path,1,pathspeed );
createPathPoint(path,4,pathspeed );
createPathPoint(path,2,pathspeed );
createPathPoint(path,3,pathspeed );
break;
case 6:
// Quadrant order is 1-2-3-4 (SAME AS 0)
createPathPoint(path,1,pathspeed );
createPathPoint(path,4,pathspeed );
createPathPoint(path,3,pathspeed );
createPathPoint(path,2,pathspeed );
break;

}

}
// Create end of path
path_add_point(path, 176, global.gViewTop, pathspeed );
path_add_point(path, 128, global.gViewTop/2, pathspeed );
path_add_point(path, 80, global.gViewTop/2, pathspeed );
path_add_point(path, 0, global.gViewTop/2, pathspeed );

This is where we'll add a bunch of paths to our queue waiting to be used.

Script Name: setPaths

while (ds_queue_size(global.PathQueue) < global.PathCountCreate)
{
myPath = path_add();
path_set_kind(myPath,1);
createPath(global.PathLoop, global.PathSpeed, myPath);
ds_queue_enqueue(global.PathQueue, path_duplicate(myPath));
}

In the end, the way this should be done is by calling this function every time a path is used. "global.PathCountCreate" should be a global indicating the number at which to create more paths.

If you find this at all useful, and are having troubles getting it to work for you, drop me a line. This works perfectly for me, but I created it about 2 years ago, so I may have missed something.

Oh, I forgot to say that this should be called just before your level starts. Otherwise you won't have any paths in the queue until the function is called the first time.