If you appreciate the work done within the wiki, please consider supporting The Cutting Room Floor on Patreon. Thanks for all your support!

Scooby-Doo in The Ghosts of Pirate Beach

From The Cutting Room Floor
Jump to navigation Jump to search

Title Screen

Scooby-Doo in The Ghosts of Pirate Beach

Developer: Funny Garbage
Publisher: Cartoon Network[1]
Platform: Adobe Shockwave
Released internationally: 2002[1]

SourceIcon.png This game has uncompiled source code.
CopyrightIcon.png This game has hidden developer credits.
DevTextIcon.png 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:



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

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)
       ((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
                                det_inv,  // the inverse of the determinant of the coefficient
                                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);
                             m1 = (float)1e+10;   // close enough to infinity

                          if ((x3-x2)!=0)
                             m2 = (y3-y2)/(x3-x2);
                             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