#include <stdio.h>
#include <stdlib.h>
#include <bios.h>
#include <dos.h>
#include "library.h"
#include "planeai.h"

#include "world.h"
#include "behave.h"

#include "sdata.h"
#include "Cockpit.h"
#include "f15defs.h"
#include "speech.h"
#include "armt.h"
#include "proto.h"
#include "setup.h"
#include "carr.h"

#define CHECKBASES 75

int whichourcarr; // holds value for which boat our carrier
int boatnum; // index of this boat in "ps" array
int junktime = -999;

extern int friendfire;
extern int enemyfire;
extern int firstbehaveshow;
extern UBYTE lastadded;
extern long oldFPX;
extern long oldFPZ;
extern UWORD oldAltval;
extern int olddog;
extern char Txt[];
extern COORD xydist ();
extern long LMul ();

extern COORD Px,Py;
extern long PxLng, PyLng;
extern int OurHead,OurRoll, OurPitch;
extern UWORD AirSpeed;
extern SWORD Knots;
extern UWORD Alt;
extern int Demo;
extern int FIRST_ENEMY_TRACE,DMAX9;
extern int TSpeed;

extern int Rtime;
extern int PovMisl;
extern int detected, atarg;
extern COORD xlast[],ylast[];
extern int zlast[];
extern int Rcolor;
extern int CloseBase[],CloseDist[];
extern int CloseGuy;
extern int Iflew;
extern int LastRate;
extern int REALFLIGHT;
extern int RunwayLeftX;
extern RPS *Rp3D;


extern struct PlaneData far *GetPlanePtr(int PlaneNo);
extern struct PlaneData far *ptype;


extern int planecnt; // used since somebody desided to make i static
// and after the planes file grew to more than
// 5000 lines I got sick of it and desided to
// kludge something so I could split the file.
// I kept I static in this file so wouldn't
// infect something else

extern int pdest; // pitch angle to plane's destination

extern int droll; // delta roll this frame

extern int AIWingMan;

extern int tempvar;
extern int tempbehavevar;
extern struct _path_ aipaths[];
extern struct _wayPoint_ aiwaypoints[];
extern struct _action_ aiactions[];
extern int PlanesLaunched;
extern int Fticks;
extern int Speedy;

extern struct FPARAM{
long X;
long Y;
long Z;
long VEL[3];
int MAT[9];
} FPARAMS;

extern carriers far carrier;
extern int ONTHECAT;
extern int ONTHEHOOK;

//***************************************************************************
void doboats()
{
int i;
int maxrollval;
struct Planes *psi; // pointer into "ps" structure array for this boat
long cdx, cdy;
int orgbasespeed;

int z, n;

// return;

for (i=LASTPLANE, psi=(ps + LASTPLANE); i<MAXPLANE; i++, psi++) {
boatnum = i;
planecnt = i;

if (ps[boatnum].status & ALIVE) {
UpdateI(planecnt);

// ptype = p + ps[boatnum].type;

ptype = GetPlanePtr(ps[boatnum].type);


if (ps[boatnum].status&ACTIVE) { /* Planes in the air */

orgbasespeed = bv[i].basespeed;

#ifdef SHOWBEHAVIORS
if((tempvar) && (i >= firstbehaveshow) && (i < (firstbehaveshow + 4)))
ShowWhichBehave(i);
#endif

if((Rtime & 7) == (i & 7))
bv[i].Behavior();
else
droll = 0;

if(bv[i].Behavior == AIGoHome)
droll = 0;

if(bv[i].behaveflag & DAMAGECONTROLSURFACE) /* Control Surfaces Damaged */
droll /= 2;

droll = rng2(droll, -ptype->maneuver<<9, ptype->maneuver<<9);

// if (ps[boatnum].status & CRASH) droll = 4<<8;

ps[boatnum].status &= ~PANIC;

if(ps[i].status & PITCHUP)
bv[i].basespeed = orgbasespeed;

AvoidLand();

UpdateBoatHeadPitchRoll (i);

UpdateBoatSpeedAndPosition (i);

if ((Rtime%(FrameRate*4) == (i&3)*FrameRate)) {
if (!(ps[boatnum].status&CRASH)) {
// boatsearching ();
search();
}
}

if((!(bv[i].behaveflag & ENEMYNOFIRE)) && (ptype->gun != 0)) {
CheckBoatGunFiring();
}

if(i == whichourcarr) {
#if 0
if(tempvar)
bv[whichourcarr].verticlesep ++;
#endif
cdx = carrier.x;
cdy = carrier.z;
UpdateOurCarrier(i);
cdx = carrier.x - cdx;
cdy = carrier.z - cdy;
UpdateAIsOnCarrier(i, cdx, cdy);
}

} else {
ps[i].speed = 0;
}
}
else {
ps[i].speed = 0;
}
}
if(tempvar)
firstbehaveshow += 4;
if(firstbehaveshow >= MAXPLANE)
firstbehaveshow = 0;
}

/*----------*/
void UpdateBoatHeadPitchRoll (int bnum)

#include "library.h"

#include "world.h"
#include "sdata.h"
#include "Cockpit.h"
#include "sounds.h"
#include "f15defs.h"
#include "awg9.h"
#include "speech.h"
#include "planeai.h"
#include "setup.h"

#define NM10 475

extern int timetargetplayer;
extern long PxLng;
extern long PyLng;
extern COORD Px,Py;
extern UWORD Alt;
extern int CloseDist[];
extern int detected;
extern COORD xlast[],ylast[];
extern int zlast[];
extern int pulse,pulsee;
extern int Rtime;
extern int JAMMER[];
extern int FTicks;

int CloseGuy;
int DMAX9;

int LastSpike;
int LastMud;

extern struct PlaneData far *GetPlanePtr(int PlaneNo);
extern struct MissileData far *GetMissilePtr(int MissileNo);
extern struct RadarData far *GetRadarPtr(int RadarNo);


//***************************************************************************
// Process enemy ground radar sites
doradar()
{
int i;
struct Radars *r;

if (LastSpike) LastSpike -= FTicks;
if (LastMud) LastMud -= FTicks;

// determine active radar

// Make sure that the Rdrs array is set up properly before this
// is working

// for (i=0; i<NERADAR; i++) {
for (i=0; i<NRADAR; i++) {
r = Rdrs + i;
r->status &= ~RACTIVE;
if (r->rclass != RL_NONE && !(r->status&DESTROYED)) {
--r->pause;
if (r->pause < 0) {
// r->pause = 256*FrameRate/(32+(r->alert>>2))+i;
r->pause = 512*FrameRate/(32+(r->alert>>4))+i;
}
else if (r->pause == 0) {
r->status |= RACTIVE;
detect (i);
}
}
}
}

//***************************************************************************
// Radar detection check
detect(int i)
{
COORD dist,xydist();
int signal,j,k,angl,a,m;
long x,y;
int targetnum;
struct RadarData far *tempradar;
struct MissileData far *tempmissile;
long ldist;
int gtnum;


// check if returning a signal

// SCOTT - The radar list needs to be read in like the new data list stuff
// A radar list is built and the various types are stored

j = Rdrs[i].rclass;
tempradar = GetRadarPtr(j);
signal = Rsignal (Rdrs[i].x,Rdrs[i].y,0, j,&angl,&dist, Rdrs[i].status & (FRIENDLY|NEUTRAL), &targetnum);

if(targetnum < -1)
return(0);

if (!Night && dist <= 2) { // visual
signal = dist+1;
Rdrs[i].alert = 255;
}

// check if detected

if (signal>dist) {
if (Rdrs[i].alert + (5<<Diff) <256) {
Rdrs[i].alert += (5<<Diff);
} else {
Rdrs[i].alert = 255;
}

if (Rdrs[i].alert>127) {
tempgotcha = 1;
gotcha(targetnum);
tempgotcha = -999;
if (!(Rdrs[i].status&RTRACK) && (tempradar->detectiontype==RADAR)) {
if (!(Damaged&D_ECM)) {
if(targetnum == MAXPLANE)
Sound(N_RadarSearch, 1,0);
if (CloseGuy==0 && !LastMud) {
Message("Singer!",RIO_MSG);
Speech(SINGER);
LastMud = 8*60;
}
}
}
Rdrs[i].status |= RTRACK;
}

if (!(Rdrs[i].status&RTRACK) && (tempradar->detectiontype==RADAR)) {
if (!(Damaged&D_ECM)) {
if(targetnum == MAXPLANE)
Sound(N_RadarSearch, 1,0);
if (CloseGuy==0) {
TEWS_SPOTTED (i); // set TEWS display
if (!(Rdrs[i].status&RSEEN) && !LastSpike) {
Message("Spike!",RIO_MSG);
Speech(SPIKE);
LastSpike=8*60;
}
}
}
}

Rdrs[i].status |= RSEEN;

// SAM WILL BE FIRED IF:
// 1) MISSILE IS ASSOCIATED WITH RADAR INSTALLATION
// 2) NOT OUT OF MISSILES
// 3) RADAR ALERT LEVEL IS HIGH ENOUGH
// 4) PLAYER IS NOT CLOSE TO FRIENDLY BASE
// 5) PLAYER IS WITHIN MISSILE ENVELOPE

// m = r[j].mtype;
tempmissile = GetMissilePtr(tempradar->missiletype);
a = (CloseGuy ? ps[targetnum].alt : Alt);

if (tempradar->missiletype == ML_NONE) return 0; // 1)
if (Rdrs[i].status & NOAMMO) return 0; // 2)
if (Rdrs[i].alert <= 250) return 0; // 3)
/* if (CloseDist[CloseGuy]<NM10) return 0; */ // 4)
if (dist > tempmissile->range) return 0; // 5)
if (dist < tempmissile->minrange) return 0; // 5)
if (a > tempmissile->maxalt*3281L/4) return 0; // 5)

if (JAMMER[CloseGuy]) {
if (tempradar->jam>(Rtime+i)%10) return 0;
}

x = (long)(Rdrs[i].x + 8)<<HTOV;
y = (long) Rdrs[i].y<<HTOV;

if (tempmissile->homing==IR_1 && !CheckTailAspect (x, y)) return 0;


// k= (Diff ? i%Diff : 0) + 15; // planes use the first fifteen slots
k = FindEmptyMissileSlot2 (NPSAM, NESAM, i);


if(k == -1)
return(0);

if (ss[k].dist != 0) return 0; // NO OPEN SLOTS

Rdrs[i].alert -= 50<<(3-Diff);

ss[k].x = x;
ss[k].y = y;
ss[k].alt = 25;
ss[k].speed = 1;
ss[k].head = angl;
ss[k].pitch = 0x4000;
ldist = (long)tempmissile->range*(825/8);
ss[k].dist = (int)ldist;
ss[k].type = tempmissile->MissileEnumId;
ss[k].source = i;
ss[k].srctype = 0;
// ss[k].target = CloseGuy?0:MAXPLANE;
ss[k].target = targetnum;
ss[k].tgttype = 1;
ss[k].losing = 0;

gtnum = GetRadarGTNum(i);

LogIt (SLG_GROUND_MISSILE_LAUNCH, gtnum, x, y, 1, -999, tempmissile->MissileEnumId, 0L, LOG_GRND);

if (CloseGuy==0) {
Sound(N_RadarLock, 1,0);
Message("Singer Launch!",RIO_MSG);
Speech(SINGERLAUNCH);
}

if(CloseEnoughFor(SLOWSTUFF, (int)(x>>HTOV), (int)(y>>HTOV)))
NoAccel();

if (rnd (tempradar->missilecount) == 0) { // OUT OF MISSILES?
Rdrs[i].status |= NOAMMO;
return 0;
}
} else {
Rdrs[i].status &= ~RTRACK;
Rdrs[i].status &= ~RSEEN;

if (Rdrs[i].alert >= (2<<(3-Diff))) {
Rdrs[i].alert -= (2<<(3-Diff));
} else {
Rdrs[i].alert = 0;
}

}
}

//***************************************************************************
// General radar detection algorithm for ground radars and planes
Rsignal(COORD x,COORD y,int z, int type,int *ang,int *dst,int isfriend,int *targetnum)
{
COORD dist,dist1,xydist();
int dx,dy,dx1,dy1;
int signal, alt, DeadZone, cap;
int founddist, cnt;
int friendflag;
struct RadarData far *tempradar;

*targetnum = -999;
founddist = 0;

/* Calculate signal strength */
if(isfriend != FRIENDLY) {
founddist = 1;
dx = Px-x;
dy = Py-y;
dist = xydist(dx,dy);
CloseGuy=0;
*targetnum = MAXPLANE;
}

for (cnt=0; cnt<NPLANES; cnt++) {
if ((ps[cnt].status & ALIVE) && (ps[cnt].status&ACTIVE) && (!(ps[cnt].status&(CRASH|CIVILIAN))) && (ps[cnt].speed)) { /* Planes in the air */
if(!FriendMatchType(cnt, isfriend)) {
dist1 = xydist(dx1=ps[cnt].x-x, dy1=ps[cnt].y-y);
if ((dist1<dist) || (!founddist)) {
founddist = 1;
dist=dist1;
dx = dx1;
dy = dy1;
CloseGuy=1;
*targetnum = cnt;
}
}
}
}

*dst = (int)((long)dist*32/825); // convert to Km
*ang = angle (dx,-dy);

tempradar = GetRadarPtr(type);

signal = tempradar->range;

if(!founddist)
*targetnum = -999;

// dead zone for ground-based radar only

if (z==0 && tempradar->detectiontype == RADAR) {
alt = (CloseGuy?ps[*targetnum].alt:Alt);

// Dead Zone is approx: Capped at:
// Level 3 - 1013 ft per 10NM 10000 ft
// Level 2 - 1216 ft per 10NM 12000 ft
// Level 1 - 1500 ft per 10NM 14000 ft
// Level 0 - 2026 ft per 10NM 16000 ft

if (dist<475) dist = 475; // min dist 10 NM
DeadZone = ((long)dist<<HTOV)/(30+(Diff*10));
cap = 4000 - (Diff*500);
if (DeadZone > cap) DeadZone = cap;
if (DeadZone > alt) signal = *dst;
}

if ((AWG9_REALITY_LEVEL==AWG9_AUTHENTIC) && AWG9_SNIFF && Diff>=2) {
signal -=signal*2/8; // reduce range by Diff factor
} else {
signal -=signal*(3-Diff)/8; // reduce range by Diff factor
}

return signal;
}

//***************************************************************************
// We've been detected !! (Arghhhh)
gotcha (int targetnum)
{
int i;

detected = FrameRate<<8;
DMAX9 = FrameRate<<6;

if (targetnum != MAXPLANE) {
if((ps[targetnum].status & CRASH) || (!((ps[targetnum].status & ALIVE) && (ps[targetnum].status & ACTIVE))))
return(0);
xlast[1]=ps[targetnum].x;
ylast[1]=ps[targetnum].y;
zlast[1]=ps[targetnum].alt;
InterceptControl(targetnum);
ps[targetnum].time = Gtime; /* Us this to tell us last time plane detected */

} else {
xlast[0]=Px;
ylast[0]=Py;
zlast[0]=Alt;
InterceptControl(-1);
// bv[0].behaveflag &= ~ENEMYNOFIRE;
timetargetplayer = Gtime;
}

// Make sure the Rdrs array is setup properly before turning this on
// for (i=0; i<NTARGET; i++) {
for (i=0; i<0; i++) {
if (Rdrs[i].rclass!=RL_NONE) {
Rdrs[i].alert = rng (Rdrs[i].alert, 10<<Diff,255);
}
}
}

//***************************************************************************
// General radar detection algorithm for ground radars and planes
// When looking at only one specific plane
int RsignalOne (COORD x,COORD y,int z, int type,int *ang,int *dst,int isfriend,int targetnum)
{
COORD dist,dist1,xydist();
int dx,dy,dx1,dy1;
int signal, alt, DeadZone, cap;
int friendflag;
struct RadarData far *tempradar;

if(targetnum < -1){
tempradar = GetRadarPtr(type);
signal = tempradar->range;

*dst = signal + 100;
*ang = 0;

return(signal);
}

/* Calculate signal strength */
if((!isfriend) && (targetnum == -1)) {
dx = Px-x;
dy = Py-y;
dist = xydist(dx,dy);
CloseGuy=0;
}

if(targetnum >= 0) {
if ((ps[targetnum].status & ALIVE) && (ps[targetnum].status&ACTIVE)
&& (!(ps[targetnum].status&(CRASH|CIVILIAN))) && (ps[targetnum].speed)) { /* Planes in the air */
if(!FriendMatchType(targetnum, isfriend)) {
dist1 = xydist(dx1=ps[targetnum].x-x, dy1=ps[targetnum].y-y);
dist=dist1;
dx = dx1;
dy = dy1;
CloseGuy=1;
}
}
}

*dst = (int)((long)dist*32/825); // convert to Km
*ang = angle (dx,-dy);

signal = tempradar->range;

// dead zone for ground-based radar only

if (z==0 && tempradar->detectiontype == RADAR) {
alt = (CloseGuy?ps[targetnum].alt:Alt);

// Dead Zone is approx: Capped at:
// Level 3 - 1013 ft per 10NM 10000 ft
// Level 2 - 1216 ft per 10NM 12000 ft
// Level 1 - 1500 ft per 10NM 14000 ft
// Level 0 - 2026 ft per 10NM 16000 ft

if (dist<475) dist = 475; // min dist 10 NM
DeadZone = ((long)dist<<HTOV)/(30+(Diff*10));
cap = 4000 - (Diff*500);
if (DeadZone > cap) DeadZone = cap;
if (DeadZone > alt) signal = *dst;
}

if ((AWG9_REALITY_LEVEL==AWG9_AUTHENTIC) && AWG9_SNIFF && Diff>=2) {
signal -=signal*2/8; // reduce range by Diff factor
} else {
signal -=signal*(3-Diff)/8; // reduce range by Diff factor
}

return signal;
}

FLEET DEFENDER
THE OFFICIAL STRATEGY GUIDE

by Bruce C. Shelly

CONTENTS
***********

CHAPTER 1 INTRODUCTION
DESIGNING FLEET DEFENDER
Simulating the F-14
Wingman and Squadron
The Artificial Intelligence
Missions
THE OFFICIAL STRATEGY GUIDE
Description
Using the Guide

CHAPTER 2 RADAR
RADAR OPTIONS
Standard Mode
Standard Search Mode
Standard Track Mode
Moderate and Authentic Modes
Pulse Doppler Search (PDSRCH)
Pulse Doppler Single Target Track (PDSTT)
Range While Search (RWS)
Track-While-Scan-Automatic (TWS-A)
Track-While-Scan-Manual (TWS-M)
Boresight (BRST)
Vertical Scan Lockdown (VSL)
RADAR SCANNING
AWG-9 Scan Patterns
Scan Pattern Parameters
Moderate Mode Scan Patterns
Authentic Mode Scan Patterns
ACHIEVING TARGET LOCKON
Standard Mode Lockdown
PDSRCH and RWS Lockon
Losing Radar Lock
RADAR TIPS AND TROUBLESHOOTING
In General
Radar Screen Explanations
Radar Cross Section
RIO Assistance Levels
Using TWSA and TWSM Modes
Activation and Setting Scan Patterns
Target Identification
Target Designation
Reading Target Information
Launching Missiles
Data Link Targets
Using Combat Maneuver (ACM) Radar Modes

CHAPTER 3 AVIATOR NOTES
STARTING A MISSION
Preflight Checklist
Postlaunch Checklist
AIR-TO-AIR WEAPONS
AIM-54 Phoenix
Sparrow
Sidewinder
Guns
AIR COMBAT
General Tips
Corner Velocity
Enemy Pilots
Fighting the Weirdos
T-28
Dragon
TBF Avengers
Flying Saucer
GENERAL PILOT TIPS
Target Identification
Tracking Information
Television Camera System (TCS)
Reverse Tactical View
The Big Picture
Fuel Management
Drop Tanks
Efficient Fuel Line
Landings
SQUADRON MANAGEMENT
Sharing the Experience
Using Your Wingman
Fighting Position
Sanitize
Attack My Target
Go Tactical
Loose Goose
SOVIET SCRAMBLES

CHAPTER 4 OCEANA MISSIONS
FLEET READINGS TRAINING
RADAR TRAINING
Formation Identification Sorties
Target Identification Sorties
ADVANTAGED DACT SORTIES
One-On-One Advantaged DACT Sorties
One-On-Two Advantaged DACT Sorties
NEUTRAL DACT SORTIES
One-On-One Neutral DACT Sorties
One-On-Two Neutral DACT Sorties
DISADVANTAGED DACT SORTIES
One-On-One Disadvantaged DACT Sorties
One-On-Two Disadvantaged DACT Sorties
MISCELLANEOUS DACT SORTIES
WINGMAN TRAINING SORTIES

CHAPTER 5 POWDER KEG
SITUATION AND MISSIONS

CHAPTER 6 EL DORADO CANYON
SITUATION AND MISSIONS

CHAPTER 7 CARRIER DUEL
SITUATION AND MISSIONS

CHAPTER 8 FIGHTING WITHDRAWAL
SITUATION AND MISSIONS

CHAPTER 9 RETURN TO NORWAY
SITUATION AND MISSIONS

CHAPTER 10 ASSAULT ON THE KOLA PENINSULA
SITUATION AND MISSIONS

CHAPTER 11 KHYBER RIFLES
SITUATION AND MISSIONS

CHAPTER 12 INDIAN OCEAN CRUISE
SITUATION AND MISSIONS

CHAPTER 13 INDIAN ROPE TRICK
SITUATION AND MISSIONS

CHAPTER 14 RETURN TO ROK
SITUATION AND MISSIONS

CHAPTER 15 PUSH ‘EM BACK
SITUATION AND MISSIONS

CHAPTER 16 PICK A CARD
SITUATION AND MISSIONS



ACKNOWLEDGMENTS
**********************

Late in 1993, Larry Russell of MPS Labs, MicroProse Entertainment Software, first proposed that I write this strategy guide. At the time, MicroProse was considering preparing such guides for all their software releases and publishing these books themselves. Because so many old friends from my own MicroProse days had been involved with the project, I welcomed the opportunity before even seeing the game.

I counted on two factors: first, I was certain the talented staff assembled to develop the game would create a fine product; second, I was certain that my longtime friendship with much of the team would assure that I received all the help I would need. I was right on both counts.

I want to thank everyone involved in creating Fleet Defender, and especially those who helped me directly while preparing this guide. Larry Russell not only served for much of 1994 as the editor for all of the strategy guide projects, but he also was my main contact and source of materials. Larry wrote the game documentation and designed most of the missions.

Scott Elson programmed the missions and provided me with the files from which the mission information was obtained. For several weeks I was on the phone with Scott almost daily deciphering the code. Mike McDonald programmed the radars and provided me with several pages of valuable notes that were the basis for Chapter 2. Chris Clark also worked on missions and was considered one of the hottest Fleet Defenders. I relied on him and the quality assurance crew for much of the information in Chapter 3. When I needed an answer about game play quickly, Chris always had the answer. I need also mention George Wargo, a former F15 pilot, who graciously led me by the hand through some of the intricacies of flight and air combat.

I visited my old haunts in April of 1994 and had the chance to talk to several members of the Fleet Defender team about their work. Scott Elson and Mike McDonald each shared part of their day with me. Vaughn Thomas was the lead tester on the quality assurance team, and he arranged for me a meeting with most of his top Fleet Defenders: David Ginsburg, Walter Carter, Russell Clark, Andy Mazurek, Mike Wise, Scott Zlotak, and Bob Abe. Recordings of those conversations proved very valuable when the writing got underway in earnest.

John Possidente took over the outside writing projects in the middle of 1994 and I want to thank him for helping to bring the guide to completion.

On the Prima Publishing side, I want to thank my editors, Dan Foster and Brett Skogen, for their help on this challenging collaboration. My thanks go also to Colleen Green, copy editor, and Jimmie Young, book designer.

And back at my office, which is also my home, I want to thank my wife Barbara for being so willing and understanding a partner in my writing. I must also mention with gratitude Samantha Jane, our ten pound Yorkshire terrier with the fifty pound personality, who is my exercise consultant. Yes, I believe it is time for another walk right now.

Bruce C. Shelly


INTRODUCTION
1

Within the first six months following its release, Fleet Defender quickly won acclaim as one of the most realistic and challenging flight simulators in the entertainment software industry.

Meanwhile, responses have been collected from the first generation of Fleet Defender players. These include information about the more difficult parts of the game to understand, strategies and tactics that have been discovered, and requests for additional information from the players themselves. This strategy guide addresses these player requests and passes along additional information that will add to your enjoyment of Fleet Defender.

Another purpose of this guide is to provide additional and correcting information that is not included in the original game documentation. In entertainment software development, the documentation that is included with the product is usually completed long before the software itself. Game development may continue for weeks or months after the manuals or sent off to the printer. Although most of the game design is finished in time for inclusion in the documentation, there are usually a few things added, deleted, or changed that don't make it into the game manual. Reporting these differences is one of the purposes of this guide.

Finally, the release of Fleet Defender Gold adds six new campaigns and many new missions to the original game. This guide discusses these enhancements, as well.

Before describing the contents of this guide in more detail, let’s discuss the design and implementation of Fleet Defender.


DESIGNING FLEET DEFENDER
The F-14 was selected for MicroProse’s next flight game because a quality detailed simulation of modern carrier aircraft had not yet been achieved. The F-14 plays a unique role in the modern air battlefield, and the design team believed that simulating that role offered many interesting game situations.

Early on in the design process, the Fleet Defender development team decided on several goals. One goal was to strive for a high level of realism. Often in entertainment software, realism is ignored or downgraded in favor of gameplay—as it should be. But the designers felt that selective use of realism would enhance the game.

As part of the drive to provide a balanced combination of realism and entertainment, the designers built a rich mission environment in which the player plays one role while many other characters act out theirs. Although the player’s actions are an important determinant in how individual missions proceed, other encounters may occur simultaneously that also contribute to the mission's outcome. This is known as the big picture. For example, while the player leads an escort team on an air strike in one part of the world, other friendly aircraft might attack another enemy installation. The overall success of the mission may hinge on the player’s group’s performance, but the player of other battles going on around him.

The big picture includes the normal CAP patrols around the carrier, ASW patrols, search and rescue helicopters on standby to pick up downed crews, the Hawkeye performing its AWACS mission, the other ships of the carrier task force, enemy recon aircraft, neutral air forces defending their airspace, and even the occasional civilian passenger aircraft passing by. The inclusion of the Reverse Tactical View makes it possible for the player to jump to the scene of other action in the world. While he carries out his role, he can witness the performances on other parts of the stage.

The player functions as part of a team, in this case the F-14 squadron based on the carrier. While the player’s personal success is the main motivation for play, the success of his squadron is also important and perhaps critical to a successful campaign. To ultimately succeed, the player must occasionally forgo personal satisfaction in favor of team accomplishment. The player enjoys the payoffs of his own promotions and medals, plus those of his squadron. Fleet Defender offers the chance to play on the championship team, as well as the satisfaction of becoming Most Valuable Player.

The team aspect of Fleet Defender is somewhat of a break from the traditional view of solitaire entertainment software, in which the player is the hero. In that view, there is no team. Success or failure depends solely on the player. While the player has the opportunity to be the hero in Fleet Defender and must do very well at a minimum, he must share part of the action and glory with his squadron. At times in the game the player has little to do, because friendly F-14s win the air battles before you can make a significant impact.

To make all this happen, the designers set smaller goals for the game that add to a significant whole. Among these are simulating the role of the F-14, providing a realistic and useful wingman, implementing a sophisticated artificial intelligence, and building campaigns of challenging and interesting missions.