Scooby-Doo in The Ghosts of Pirate Beach

Scooby-Doo in The Ghosts of Pirate Beach
Developer: Funny Garbage Publisher: Cartoon Network Platform: Adobe Shockwave Released internationally: 2002 This game has uncompiled source code. This game has hidden developer credits. This game has hidden development-related text.

In The Ghosts of Pirate Beach, Scooby and the gang look for clues to solve the mystery of the ghost pirate Redbeard. If you played it as a kid, you probably just remember how satisfying it was to dig a bunch of holes on the beach.

Unused Text

Build Date

Cast member orbit-15 is called gt_version and contains the following timestamp:

10/4/01 7:02 PM

Version History

Cast member orbit-21 is called gt_version history contains the following:

-- version history

-- FINAL20 and earlier: steve warren 

-- FINAL21:
--   renamed all cast members to have "gt_" prefix for easier finding (and removing)
--   attached the movie script "gt_main" and the parent script "gt_timerObject" to a sprite to force all cast members to be copied when the score is copied
--   fixed bug in IE5 mac where ad graphic would not load
--   renamed dummy graphics with a "gt_x" prefix for ease of selecting
--   restored funtionality of pause for title page for at least 3 seconds regardless of load time

-- FINAL22: 
--   externalized the orbit enhanced graphic, using BMP extension on the GIF to fool AOL
--   added this version history cast member

-- FINAL24:
--   made gt_timerDone global handler to take care of checking for timer VIOD or done
--   made orbit banner (if any) start to load while ad up

Object List

Cast member Internal-45, called objData.txt contains this list of various objects:

Door01
Door02
Door03
Key01
Key02
Key03

Event01
Event02
Event03
Event04
Event05
Event06
	
score1	
scoreMultiplier1	
score2	
scoreMultiplier2	
score3	
scoreMultiplier3	
timeLimit		
timeBonusMultiplier		
debug		
doorsOpened

treasure piece	inventory
shovel	inventory
metalDetector	inventory
key	inventory
battery	inventory

Line Intersection

Cast member Internal-316 contains a description of an algorithm to find the intersection of two line segments.

Line Intersection

Given this representation, how do we find out if two line segments intersect, ie: 

\      /    vs    \  /
 \    /             \/
  \  /              /\
   \               /

One way is basically to use school maths (y=mx+c etc) to find the equations, and then intersection points of the lines, and then find out if these intersection points lie
'within' each line.. Another approach, given in Sedgewick, which is introduces ideas useful in other algorithms is as follows. 

First define a function that, given three points, tells you whether you have to turn clockwise or counter clockwise when travelling from the first to the second to the
third. Call this CCW: it will return TRUE if it is counter clockwise. Now, two lines l1 and l2 will intersect if (CCW(l1.p1, l1.p2, l2.p1) <> CCW(l1.p1, l1.p2,
l2.p2)) AND (CCW(l2.p1, l2.p2, l1.p1) <> CCW(l2.p1, l2.p2, l1.p2)). Basically, this just means that both endpoints of each line are on different 'sides' of the
other line. 

The CCW function can be defined fairly straightforwardly, by calculating the gradient between point 1 and point2, point 2 and point 3, and checking if one gradient
is larger than the other. (The implementation must cope with the fact that the slopes may be infinite, or that they are equal, but that's just a minor fiddle - see
Sedgewick). 

The following gives what might be an initial attempt at both ccw and intersect. I'll leave it as an exercise for the reader to work out how to make it deal with infinite
slopes (ie, dx=0), and the case where two lines are collinear. 

int ccw(point p1, point p2, point p3)

// Slightly deficient function to determine if the two lines p1, p2 and
// p2, p3 turn in counter clockwise direction}
{
  int dx1, dx2, dy1, dy2;
  dx1 = p2.x - p1.x; dy1 = p2.y - p1.y;
  dx2 = p3.x - p2.x; dy2 = p3.y - p2.y;
  if (dy1/dx1 < dy2/dx2) return 1;
  else return 0;
}

int intersect(line l1, line l2)
{
    return
       ((ccw(l1.p1, l1.p2, l2.p1) != ccw(l1.p1, l1.p2, l2.p2))
        && (ccw(l2.p1, l2.p2, l1.p1) != ccw(l2.p1, l2.p2, l1.p2)))
}

Cast member Internal-317 contains an implementation of the aforementioned algorithm.

void Intersect_Lines(float x0,float y0,float x1,float y1,
                                               float x2,float y2,float x3,float y3,
                                               float *xi,float *yi)
                          {
                          // this function computes the intersection of the sent lines
                          // and returns the intersection point, note that the function assumes
                          // the lines intersect. the function can handle vertical as well
                          // as horizontal lines. note the function isn't very clever, it simply
                          //applies the math, but we don't need speed since this is a
                          //pre-processing step

                          float a1,b1,c1, // constants of linear equations
                                a2,b2,c2,
                                det_inv,  // the inverse of the determinant of the coefficient
                          matrix
                                m1,m2;    // the slopes of each line

                          // compute slopes, note the cludge for infinity, however, this will
                          // be close enough

                          if ((x1-x0)!=0)
                             m1 = (y1-y0)/(x1-x0);
                          else
                             m1 = (float)1e+10;   // close enough to infinity

                          if ((x3-x2)!=0)
                             m2 = (y3-y2)/(x3-x2);
                          else
                             m2 = (float)1e+10;   // close enough to infinity

                          // compute constants

                          a1 = m1;
                          a2 = m2;

                          b1 = -1;
                          b2 = -1;

                          c1 = (y0-m1*x0);
                          c2 = (y2-m2*x2);

                          // compute the inverse of the determinate

                          det_inv = 1/(a1*b2 - a2*b1);

                          // use Kramers rule to compute xi and yi

                          *xi=((b1*c2 - b2*c1)*det_inv);
                          *yi=((a2*c1 - a1*c2)*det_inv);

                          } // end Intersect_Lines