void
CameraDirector::SetViewObjectGroup(ListIter<Ship> group, bool quick)
{
if (!ship) return;
Starshatter* stars = Starshatter::GetInstance();
if (!stars->InCutscene()) {
// only view solid contacts:
while (++group) {
Ship* s = group.value();
if (s->GetIFF() != ship->GetIFF()) {
Contact* c = ship->FindContact(s);
if (!c || !c->ActLock())
return;
}
if (s->Life() == 0 || s->IsDying() || s->IsDead())
return;
}
}
group.reset();
if (external_group.size() > 1 &&
external_group.size() == group.size()) {
bool same = true;
for (int i = 0; same && i < external_group.size(); i++) {
if (external_group[i] != group.container()[i])
same = false;
}
if (same) {
SetMode(MODE_ZOOM);
return;
}
}
ClearGroup();
if (quick) {
mode = MODE_ORBIT;
transition = 0;
}
else {
SetMode(MODE_TRANSLATE);
}
external_group.append(group.container());
ListIter<Ship> iter = external_group;
while (++iter) {
Ship* s = iter.value();
region = s->GetRegion();
Observe(s);
}
}
void
KeyDlg::OnApply(AWEvent* event)
{
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
KeyMap& keymap = stars->GetKeyMap();
KeyMapEntry* map = keymap.GetKeyMap(key_index);
if (key_clear) {
map->key = 0;
map->alt = 0;
map->joy = 0;
}
if (key_key) {
map->key = key_key;
map->alt = key_shift;
}
if (key_joy) {
map->joy = key_joy;
}
}
if (manager)
manager->ShowCtlDlg();
}
void
JoyDlg::OnApply(AWEvent* event)
{
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
KeyMap& keymap = stars->GetKeyMap();
keymap.Bind(KEY_AXIS_YAW, map_axis[0]+KEY_JOY_AXIS_X, 0);
keymap.Bind(KEY_AXIS_PITCH, map_axis[1]+KEY_JOY_AXIS_X, 0);
keymap.Bind(KEY_AXIS_ROLL, map_axis[2]+KEY_JOY_AXIS_X, 0);
keymap.Bind(KEY_AXIS_THROTTLE, map_axis[3]+KEY_JOY_AXIS_X, 0);
keymap.Bind(KEY_AXIS_YAW_INVERT, invert_checkbox[0]->GetButtonState(), 0);
keymap.Bind(KEY_AXIS_PITCH_INVERT, invert_checkbox[1]->GetButtonState(), 0);
keymap.Bind(KEY_AXIS_ROLL_INVERT, invert_checkbox[2]->GetButtonState(), 0);
keymap.Bind(KEY_AXIS_THROTTLE_INVERT, invert_checkbox[3]->GetButtonState(), 0);
keymap.SaveKeyMap("key.cfg", 256);
stars->MapKeys();
}
if (manager)
manager->ShowCtlDlg();
}
void
CmpLoadDlg::ExecFrame()
{
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
if (lbl_activity) lbl_activity->SetText(stars->GetLoadActivity());
if (lbl_progress) lbl_progress->SetValue(stars->GetLoadProgress());
}
}
void
ExitDlg::OnApply(AWEvent* event)
{
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
::Print("Exit Confirmed.\n");
stars->Exit();
}
}
void
CmpSceneDlg::Show()
{
FormWindow::Show();
Starshatter* stars = Starshatter::GetInstance();
if (stars->InCutscene()) {
Sim* sim = Sim::GetSim();
if (sim) {
cam_view->UseCamera(CameraDirector::GetInstance()->GetCamera());
cam_view->UseScene(sim->GetScene());
}
// initialize lens flare bitmaps:
if (stars->LensFlare()) {
cam_view->LensFlareElements(flare1, flare4, flare2, flare3);
cam_view->LensFlare(true);
}
// if lens flare disabled, just create the corona:
else if (stars->Corona()) {
cam_view->LensFlareElements(flare1, 0, 0, 0);
cam_view->LensFlare(true);
}
if (disp_view) {
old_disp_win = disp_view->GetWindow();
disp_view->SetWindow(mov_scene);
mov_scene->AddView(disp_view);
}
if (subtitles_box) {
subtitles_box->SetText(stars->GetSubtitles());
subtitles_delay = 0;
subtitles_time = 0;
}
}
}
void
KeyDlg::Show()
{
FormWindow::Show();
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
KeyMap& keymap = stars->GetKeyMap();
if (command)
command->SetText(keymap.DescribeAction(key_index));
if (current_key)
current_key->SetText(keymap.DescribeKey(key_index));
}
key_clear = false;
new_key->SetText("");
SetFocus();
}
void
CmpSceneDlg::ExecFrame()
{
Starshatter* stars = Starshatter::GetInstance();
Mission* cutscene_mission = stars->GetCutsceneMission();
if (cutscene_mission && disp_view) {
disp_view->ExecFrame();
if (subtitles_box && subtitles_box->GetLineCount() > 0) {
if (subtitles_delay == 0) {
int nlines = subtitles_box->GetLineCount();
MissionEvent* begin_scene = cutscene_mission->FindEvent(MissionEvent::BEGIN_SCENE);
MissionEvent* end_scene = cutscene_mission->FindEvent(MissionEvent::END_SCENE);
if (begin_scene && end_scene) {
double total_time = end_scene->Time() - begin_scene->Time();
subtitles_delay = total_time / nlines;
subtitles_time = Game::RealTime() / 1000.0 + subtitles_delay;
}
else {
subtitles_delay = -1;
}
}
if (subtitles_delay > 0) {
double seconds = Game::RealTime() / 1000.0;
if (subtitles_time <= seconds) {
subtitles_time = seconds + subtitles_delay;
subtitles_box->Scroll(ScrollWindow::SCROLL_DOWN);
}
}
}
}
else {
manager->ShowCmdDlg();
}
}
void
DebriefDlg::OnClose(AWEvent* event)
{
Sim* sim = Sim::GetSim();
sim->CommitMission();
sim->UnloadMission();
NetLobby* lobby = NetLobby::GetInstance();
if (lobby && lobby->IsHost()) {
lobby->SelectMission(0);
lobby->ExecFrame();
}
Player* player = Player::GetCurrentPlayer();
if (player && player->ShowAward()) {
manager->ShowAwardDlg();
}
else {
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
Mouse::Show(false);
Campaign* campaign = Campaign::GetCampaign();
if (campaign && campaign->GetCampaignId() < Campaign::SINGLE_MISSIONS)
stars->SetGameMode(Starshatter::CMPN_MODE);
else
stars->SetGameMode(Starshatter::MENU_MODE);
}
else {
Game::Panic("DebriefDlg::OnClose() - Game instance not found");
}
}
}
void
LoadScreen::ShowLoadDlg()
{
if (load_dlg) load_dlg->Hide();
if (cmp_load_dlg) cmp_load_dlg->Hide();
Starshatter* stars = Starshatter::GetInstance();
// show campaign load dialog if available and loading campaign
if (stars && cmp_load_dlg) {
if (stars->GetGameMode() == Starshatter::CLOD_MODE ||
stars->GetGameMode() == Starshatter::CMPN_MODE) {
cmp_load_dlg->Show();
Mouse::Show(false);
return;
}
}
// otherwise, show regular load dialog
if (load_dlg) {
load_dlg->Show();
Mouse::Show(false);
}
}
void
LoadDlg::ExecFrame()
{
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
if (title) {
if (stars->GetGameMode() == Starshatter::CLOD_MODE ||
stars->GetGameMode() == Starshatter::CMPN_MODE)
title->SetText(Game::GetText("LoadDlg.campaign"));
else if (stars->GetGameMode() == Starshatter::MENU_MODE)
title->SetText(Game::GetText("LoadDlg.tac-ref"));
else
title->SetText(Game::GetText("LoadDlg.mission"));
}
activity->SetText(stars->GetLoadActivity());
progress->SetValue(stars->GetLoadProgress());
}
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
int result = 0;
int test_mode = 0;
int do_server = 0;
if (strstr(lpCmdLine, "-server"))
ErrLog = fopen("serverlog.txt", "w");
else
ErrLog = fopen("errlog.txt", "w");
PrintLogHeader();
if (strstr(lpCmdLine, "-test")) {
Print(" Request TEST mode\n");
test_mode = 1;
}
if (strstr(lpCmdLine, "-fps")) {
HUDView::ShowFPS(true);
}
if (strstr(lpCmdLine, "-dump")) {
Print(" Request dump dynamic missions\n");
dump_missions = 1;
}
if (strstr(lpCmdLine, "-lan")) {
Print(" Request LAN ONLY mode\n");
NetBrokerClient::Disable();
}
if (strstr(lpCmdLine, "-server")) {
do_server = 1;
Print(" Request Standalone Server Mode\n");
}
char* d3dinfo = strstr(lpCmdLine, "-d3d");
if (d3dinfo) {
int n = d3dinfo[4] - '0';
if (n >= 0 && n <= 5)
VD3D_describe_things = n;
Print(" D3D Info Level: %d\n", VD3D_describe_things);
}
else {
VD3D_describe_things = 0;
}
// FREE VERSION - AUTHORIZATION DISABLED
/*
::Print(" Checking authorization codes...\n");
if (!Authorization::IsUserAuthorized()) {
if (!DataLoader::GetLoader()) {
DataLoader::Initialize();
DataLoader::GetLoader()->EnableDatafile("content.dat");
}
Game* game = new Game();
game->InitContent();
MessageBox(0, FormatTextEscape(Game::GetText("main.auth-invalid")).data(),
Game::GetText("main.title.error").data(), MB_OK);
::Print(" Not authorized.\n");
delete game;
DataLoader::Close();
}
else {
::Print(" Authorized\n");
*/
try {
NetLayer net;
if (do_server) {
StarServer* server = new(__FILE__,__LINE__) StarServer();
if (server->Init(hInstance, hPrevInstance, lpCmdLine, nCmdShow))
result = server->Run();
Print("\n+====================================================================+\n");
Print(" Begin Shutdown...\n");
delete server;
}
else {
Starshatter* stars = 0;
stars = new(__FILE__,__LINE__) Starshatter;
stars->SetTestMode(test_mode);
if (stars->Init(hInstance, hPrevInstance, lpCmdLine, nCmdShow))
result = stars->Run();
Print("\n+====================================================================+\n");
Print(" Begin Shutdown...\n");
delete stars;
}
Token::close();
if (*Game::GetPanicMessage())
MessageBox(0, Game::GetPanicMessage(), "Starshatter - Error", MB_OK);
}
catch (const char* msg) {
Print(" FATAL EXCEPTION: '%s'\n", msg);
}
/* } */
Memory::Stats();
Memory::DumpLeaks();
Memory::CloseLog();
Print("+====================================================================+\n");
Print(" END OF LINE.\n");
fclose(ErrLog);
return result;
}
void
CameraDirector::SetViewObject(Ship* obj, bool quick)
{
if (!ship) return;
if (!obj) {
obj = ship;
region = ship->GetRegion();
}
external_body = 0;
external_point = Point();
Starshatter* stars = Starshatter::GetInstance();
if (obj->GetIFF() != ship->GetIFF() && !stars->InCutscene()) {
// only view solid contacts:
Contact* c = ship->FindContact(obj);
if (!c || !c->ActLock())
return;
}
if (mode == MODE_TARGET) {
ClearGroup();
if (external_ship) {
external_ship = 0;
}
}
else if (mode >= MODE_ORBIT) {
if (quick) {
mode = MODE_ORBIT;
transition = 0;
}
else {
SetMode(MODE_TRANSLATE);
}
if (external_group.size()) {
ClearGroup();
if (external_ship) {
external_ship = 0;
}
}
else {
if ((obj == external_ship) || (obj==ship && external_ship==0)) {
if (!quick)
SetMode(MODE_ZOOM);
}
else if (external_ship) {
external_ship = 0;
}
}
}
if (external_ship != obj) {
external_ship = obj;
if (external_ship) {
region = external_ship->GetRegion();
if (external_ship->Life() == 0 || external_ship->IsDying() || external_ship->IsDead()) {
external_ship = 0;
range_min = 100;
}
else {
Observe(external_ship);
if (sim)
sim->ActivateRegion(external_ship->GetRegion());
range_min = external_ship->Radius() * 1.5;
}
}
Observe(external_ship);
ExternalRange(1);
}
}
void
QuitView::ExecFrame()
{
sim = Sim::GetSim();
if (show_menu) {
Color::SetFade(1, Color::Black, 0);
int action = 0;
if (Mouse::LButton()) {
mouse_latch = true;
}
else if (mouse_latch) {
mouse_latch = false;
if (Mouse::X() > xcenter - w2 && Mouse::X() < xcenter + w2) {
int y0 = ycenter - h2;
for (int i = 0; i < 4; i++)
if (Mouse::Y() >= y0 + 75 + i * 30 && Mouse::Y() <= y0 + 105 + i * 30)
action = i+1;
}
}
for (int i = 1; i <= 4; i++) {
if (Keyboard::KeyDown('0' + i))
action = i;
}
// was mission long enough to accept?
if (action == 1 && !CanAccept()) {
Button::PlaySound(Button::SND_REJECT);
action = 3;
}
// exit and accept:
if (action == 1) {
CloseMenu();
Game::SetTimeCompression(1);
Starshatter* stars = Starshatter::GetInstance();
stars->SetGameMode(Starshatter::PLAN_MODE);
}
// quit and discard results:
else if (action == 2) {
CloseMenu();
Game::SetTimeCompression(1);
Starshatter* stars = Starshatter::GetInstance();
Campaign* campaign = Campaign::GetCampaign();
// discard mission and events:
if (sim) sim->UnloadMission();
else ShipStats::Initialize();
if (campaign && campaign->GetCampaignId() < Campaign::SINGLE_MISSIONS) {
campaign->RollbackMission();
stars->SetGameMode(Starshatter::CMPN_MODE);
}
else {
stars->SetGameMode(Starshatter::MENU_MODE);
}
}
// resume:
else if (action == 3) {
CloseMenu();
}
// controls:
else if (action == 4) {
GameScreen* game_screen = GameScreen::GetInstance();
if (game_screen)
game_screen->ShowCtlDlg();
else
CloseMenu();
}
}
}
void
CameraDirector::ExecFrame(double seconds)
{
if (!ship)
return;
hud = HUDView::GetInstance();
int flight_phase = ship->GetFlightPhase();
if (flight_phase < Ship::LOCKED)
SetMode(MODE_DOCKING);
if (ship->IsAirborne()) {
if (flight_phase >= Ship::DOCKING)
SetMode(MODE_DOCKING);
}
else {
if (flight_phase >= Ship::RECOVERY)
SetMode(MODE_DOCKING);
}
if (flight_phase >= Ship::LOCKED && flight_phase < Ship::ACTIVE) {
int m = GetMode();
if (m != MODE_COCKPIT && m != MODE_VIRTUAL)
SetMode(MODE_COCKPIT);
}
if (ship->InTransition()) {
SetMode(MODE_DROP);
}
// automatically restore mode after transition:
else if (old_mode != MODE_NONE) {
mode = old_mode;
requested_mode = old_mode;
old_mode = MODE_NONE;
}
int op_mode = mode;
if (requested_mode > mode)
op_mode = requested_mode;
Starshatter* stars = Starshatter::GetInstance();
// if we are in padlock, and have not locked a ship
// try to padlock the current target:
if (op_mode == MODE_TARGET && !external_ship) {
SimObject* tgt = ship->GetTarget();
if (tgt && tgt->Type() == SimObject::SIM_SHIP)
SetViewObject((Ship*) tgt);
}
// if in an external mode, check the external ship:
else if (op_mode >= MODE_TARGET && op_mode <= MODE_ZOOM) {
if (external_ship && external_ship != ship && !stars->InCutscene()) {
Contact* c = ship->FindContact(external_ship);
if (!c || !c->ActLock()) {
SetViewObject(ship);
}
}
}
if (ship->Rep()) {
if (op_mode == MODE_COCKPIT) {
ship->HideRep();
ship->HideCockpit();
}
else if (op_mode == MODE_VIRTUAL || op_mode == MODE_TARGET) {
if (ship->Cockpit()) {
ship->HideRep();
ship->ShowCockpit();
}
else {
ship->ShowRep();
}
}
else {
ship->Rep()->SetForeground(op_mode == MODE_DOCKING);
ship->ShowRep();
ship->HideCockpit();
}
}
if (hud && hud->Ambient() != Color::Black)
sim->GetScene()->SetAmbient( hud->Ambient() );
else
sim->GetScene()->SetAmbient( sim->GetStarSystem()->Ambient() );
switch (op_mode) {
default:
case MODE_COCKPIT: Cockpit(seconds); break;
case MODE_CHASE: Chase(seconds); break;
case MODE_TARGET: Target(seconds); break;
case MODE_THREAT: Threat(seconds); break;
case MODE_VIRTUAL: Virtual(seconds); break;
case MODE_ORBIT:
case MODE_TRANSLATE:
case MODE_ZOOM: Orbit(seconds); break;
case MODE_DOCKING: Docking(seconds); break;
case MODE_DROP: Drop(seconds); break;
}
if (ship->Shake() > 0 &&
(op_mode < MODE_ORBIT ||
(op_mode == MODE_VIRTUAL && ship->Cockpit()))) {
Point vib = ship->Vibration() * 0.2;
camera.MoveBy(vib);
camera.Aim(0, vib.y, vib.z);
}
Transition(seconds);
DetailSet::SetReference(region, camera.Pos());
}
void
ShipCtrl::ExecFrame(double seconds)
{
Starshatter* stars = Starshatter::GetInstance();
if (stars && stars->GetChatMode()) return;
if (!ship) return;
const int DELTA_THROTTLE = 5;
controller->Acquire();
if (ship->IsStarship() && ship->GetFLCSMode() == Ship::FLCS_HELM) {
ship->ApplyHelmPitch(controller->Pitch() * seconds);
ship->ApplyHelmYaw(controller->Yaw() * seconds);
}
else {
ship->ApplyRoll(controller->Roll());
ship->ApplyPitch(controller->Pitch());
ship->ApplyYaw(controller->Yaw());
}
ship->SetTransX(controller->X() * ship->Design()->trans_x);
ship->SetTransY(controller->Y() * ship->Design()->trans_y);
ship->SetTransZ(controller->Z() * ship->Design()->trans_z);
bool augmenter = false;
if (controller->Throttle() > 0.05) {
if (throttle_active) {
ship->SetThrottle(controller->Throttle() * 100);
if (controller->Throttle() >= 0.99)
augmenter = true;
}
else if (!launch_latch || controller->Throttle() > 0.5) {
throttle_active = true;
launch_latch = false;
}
}
else if (throttle_active) {
ship->SetThrottle(0);
throttle_active = false;
}
ship->ExecFLCSFrame();
static double time_til_change = 0.0;
if (time_til_change < 0.001) {
if (KeyDown(KEY_THROTTLE_UP)) {
ship->SetThrottle(ship->Throttle() + DELTA_THROTTLE);
time_til_change = 0.05;
}
else if (KeyDown(KEY_THROTTLE_DOWN)) {
ship->SetThrottle(ship->Throttle() - DELTA_THROTTLE);
time_til_change = 0.05;
}
else if (KeyDown(KEY_THROTTLE_ZERO)) {
ship->SetThrottle(0);
if (ship->GetFLCS())
ship->GetFLCS()->FullStop();
time_til_change = 0.05;
}
else if (KeyDown(KEY_THROTTLE_FULL)) {
ship->SetThrottle(100);
time_til_change = 0.05;
}
else if (KeyDown(KEY_FLCS_MODE_AUTO)) {
ship->CycleFLCSMode();
time_til_change = 0.5f;
}
else if (KeyDown(KEY_CYCLE_PRIMARY)) {
HUDSounds::PlaySound(HUDSounds::SND_WEP_MODE);
ship->CyclePrimary();
time_til_change = 0.5f;
}
else if (KeyDown(KEY_CYCLE_SECONDARY)) {
HUDSounds::PlaySound(HUDSounds::SND_WEP_MODE);
ship->CycleSecondary();
time_til_change = 0.5f;
}
if (ship->GetShield()) {
Shield* shield = ship->GetShield();
double level = shield->GetPowerLevel();
if (KeyDown(KEY_SHIELDS_FULL)) {
HUDSounds::PlaySound(HUDSounds::SND_SHIELD_LEVEL);
shield->SetPowerLevel(100);
time_til_change = 0.5f;
}
else if (KeyDown(KEY_SHIELDS_ZERO)) {
HUDSounds::PlaySound(HUDSounds::SND_SHIELD_LEVEL);
shield->SetPowerLevel(0);
time_til_change = 0.5f;
}
else if (KeyDown(KEY_SHIELDS_UP)) {
if (level < 25) level = 25;
else if (level < 50) level = 50;
else if (level < 75) level = 75;
else level = 100;
HUDSounds::PlaySound(HUDSounds::SND_SHIELD_LEVEL);
shield->SetPowerLevel(level);
time_til_change = 0.5f;
}
else if (KeyDown(KEY_SHIELDS_DOWN)) {
if (level > 75) level = 75;
else if (level > 50) level = 50;
else if (level > 25) level = 25;
else level = 0;
HUDSounds::PlaySound(HUDSounds::SND_SHIELD_LEVEL);
shield->SetPowerLevel(level);
time_til_change = 0.5f;
}
}
if (ship->GetSensor()) {
Sensor* sensor = ship->GetSensor();
if (sensor->GetMode() < Sensor::PST) {
if (KeyDown(KEY_SENSOR_MODE)) {
int sensor_mode = sensor->GetMode() + 1;
if (sensor_mode > Sensor::GM)
sensor_mode = Sensor::PAS;
sensor->SetMode((Sensor::Mode) sensor_mode);
time_til_change = 0.5f;
}
else if (KeyDown(KEY_SENSOR_GROUND_MODE)) {
if (ship->IsAirborne()) {
sensor->SetMode(Sensor::GM);
time_til_change = 0.5f;
}
}
}
else {
// manual "return to search" command for starships:
if (KeyDown(KEY_SENSOR_MODE)) {
ship->DropTarget();
}
}
if (KeyDown(KEY_SENSOR_RANGE_PLUS)) {
sensor->IncreaseRange();
time_til_change = 0.5f;
}
else if (KeyDown(KEY_SENSOR_RANGE_MINUS)) {
sensor->DecreaseRange();
time_til_change = 0.5f;
}
}
if (KeyDown(KEY_EMCON_PLUS)) {
ship->SetEMCON(ship->GetEMCON()+1);
time_til_change = 0.5f;
}
else if (KeyDown(KEY_EMCON_MINUS)) {
ship->SetEMCON(ship->GetEMCON()-1);
time_til_change = 0.5f;
}
}
else
time_til_change -= seconds;
if (controller->ActionMap(KEY_ACTION_0))
ship->FirePrimary();
if (controller->ActionMap(KEY_ACTION_1)) {
if (!pickle_latch)
ship->FireSecondary();
pickle_latch = true;
}
else {
pickle_latch = false;
}
if (controller->ActionMap(KEY_ACTION_3)) {
if (!target_latch)
ship->LockTarget(SimObject::SIM_SHIP);
target_latch = true;
}
else {
target_latch = false;
}
ship->SetAugmenter(augmenter || (KeyDown(KEY_AUGMENTER) ? true : false));
if (Toggled(KEY_DECOY))
ship->FireDecoy();
if (Toggled(KEY_LAUNCH_PROBE))
ship->LaunchProbe();
if (Toggled(KEY_GEAR_TOGGLE))
ship->ToggleGear();
if (Toggled(KEY_NAVLIGHT_TOGGLE))
ship->ToggleNavlights();
if (Toggled(KEY_LOCK_TARGET))
ship->LockTarget(SimObject::SIM_SHIP, false, true);
else if (Toggled(KEY_LOCK_THREAT))
ship->LockTarget(SimObject::SIM_DRONE);
else if (Toggled(KEY_LOCK_CLOSEST_SHIP))
ship->LockTarget(SimObject::SIM_SHIP, true, false);
else if (Toggled(KEY_LOCK_CLOSEST_THREAT))
ship->LockTarget(SimObject::SIM_DRONE, true, false);
else if (Toggled(KEY_LOCK_HOSTILE_SHIP))
ship->LockTarget(SimObject::SIM_SHIP, true, true);
else if (Toggled(KEY_LOCK_HOSTILE_THREAT))
ship->LockTarget(SimObject::SIM_DRONE, true, true);
else if (Toggled(KEY_CYCLE_SUBTARGET))
ship->CycleSubTarget(1);
else if (Toggled(KEY_PREV_SUBTARGET))
ship->CycleSubTarget(-1);
if (Toggled(KEY_AUTO_NAV)) {
ship->SetAutoNav(true);
// careful: this object has just been deleted!
return;
}
if (Toggled(KEY_DROP_ORBIT)) {
ship->DropOrbit();
// careful: this object has just been deleted!
return;
}
}
void
RadioView::Refresh()
{
sim = Sim::GetSim();
if (!font)
return;
font->SetColor(txt_color);
font->SetAlpha(1);
if (sim && ship != sim->GetPlayerShip()) {
ship = sim->GetPlayerShip();
history.Clear();
if (ship) {
if (ship->Life() == 0 || ship->IsDying() || ship->IsDead()) {
ship = 0;
}
else {
Observe(ship);
}
}
}
QuantumView* qv = QuantumView::GetInstance();
if (!qv || !qv->IsMenuShown()) {
Menu* menu = history.GetCurrent();
if (menu) {
Rect menu_rect(width-115, 10, 115, 12);
font->DrawText(menu->GetTitle(), 0, menu_rect, DT_CENTER);
menu_rect.y += 15;
ListIter<MenuItem> item = menu->GetItems();
while (++item) {
if (ship->GetEMCON() < 2 ||
(TargetRequired(item.value()) && !ship->GetTarget()) ||
item->GetText().contains("KIA")) {
item->SetEnabled(false);
font->SetAlpha(0.35);
}
else {
item->SetEnabled(true);
font->SetAlpha(1);
}
font->DrawText(item->GetText(), 0, menu_rect, DT_LEFT);
menu_rect.y += 10;
}
}
}
int message_queue_empty = true;
// age messages:
for (int i = 0; i < MAX_MSG; i++) {
if (msg_time[i] > 0) {
msg_time[i] -= Game::GUITime();
if (msg_time[i] <= 0) {
msg_time[i] = 0;
msg_text[i] = "";
}
message_queue_empty = false;
}
}
if (!message_queue_empty) {
// advance message pipeline:
for (int i = 0; i < MAX_MSG; i++) {
if (msg_time[0] == 0) {
for (int j = 0; j < MAX_MSG-1; j++) {
msg_time[j] = msg_time[j+1];
msg_text[j] = msg_text[j+1];
}
msg_time[MAX_MSG-1] = 0;
msg_text[MAX_MSG-1] = "";
}
}
bool hud_off = false;
if (HUDView::GetInstance())
hud_off = (HUDView::GetInstance()->GetHUDMode() == HUDView::HUD_MODE_OFF);
// draw messages:
if (!hud_off) {
for (int i = 0; i < MAX_MSG; i++) {
if (msg_time[i] > 0) {
Rect msg_rect(0, 95 + i*10, width, 12);
if (msg_time[i] > 1)
font->SetAlpha(1);
else
font->SetAlpha(0.5 + 0.5*msg_time[i]);
font->DrawText(msg_text[i].data(), msg_text[i].length(), msg_rect, DT_CENTER);
}
}
font->SetAlpha(1);
}
}
Starshatter* stars = Starshatter::GetInstance();
if (stars && stars->GetChatMode()) {
Text chat;
switch (stars->GetChatMode()) {
case 1: chat = "ALL: "; break;
case 2: chat = "TEAM: "; break;
case 3: chat = "WING: "; break;
case 4: chat = "UNIT: "; break;
}
chat += stars->GetChatText();
Rect chat_rect(width/2 - 250, height-150, 500, 12);
font->DrawText(chat, 0, chat_rect, DT_LEFT);
chat_rect.Inflate(2,2);
window->DrawRect(chat_rect, hud_color);
}
}
void
GameScreen::ExecFrame()
{
sim = Sim::GetSim();
if (sim) {
cam_view->UseCamera(CameraDirector::GetInstance()->GetCamera());
cam_view->UseScene(sim->GetScene());
Ship* player = sim->GetPlayerShip();
if (player) {
bool dialog_showing = false;
if (hud_view) {
hud_view->UseCameraView(cam_view);
hud_view->ExecFrame();
}
if (quit_view && quit_view->IsMenuShown()) {
quit_view->ExecFrame();
dialog_showing = true;
}
if (navdlg && navdlg->IsShown()) {
navdlg->SetShip(player);
navdlg->ExecFrame();
dialog_showing = true;
}
if (engdlg && engdlg->IsShown()) {
engdlg->SetShip(player);
engdlg->ExecFrame();
dialog_showing = true;
}
if (fltdlg && fltdlg->IsShown()) {
fltdlg->SetShip(player);
fltdlg->ExecFrame();
dialog_showing = true;
}
if (auddlg && auddlg->IsShown()) {
auddlg->ExecFrame();
dialog_showing = true;
}
if (viddlg && viddlg->IsShown()) {
viddlg->ExecFrame();
dialog_showing = true;
}
if (optdlg && optdlg->IsShown()) {
optdlg->ExecFrame();
dialog_showing = true;
}
if (ctldlg && ctldlg->IsShown()) {
ctldlg->ExecFrame();
dialog_showing = true;
}
if (keydlg && keydlg->IsShown()) {
keydlg->ExecFrame();
dialog_showing = true;
}
if (joydlg && joydlg->IsShown()) {
joydlg->ExecFrame();
dialog_showing = true;
}
if (moddlg && moddlg->IsShown()) {
moddlg->ExecFrame();
dialog_showing = true;
}
if (quantum_view && !dialog_showing) {
quantum_view->ExecFrame();
}
if (radio_view && !dialog_showing) {
radio_view->ExecFrame();
}
if (wep_view && !dialog_showing) {
wep_view->ExecFrame();
}
if (tac_view && !dialog_showing) {
if (cam_view)
tac_view->UseProjector(cam_view->GetProjector());
tac_view->ExecFrame();
}
}
if (disp_view) {
disp_view->ExecFrame();
}
}
Starshatter* stars = Starshatter::GetInstance();
if (stars) {
if (stars->LensFlare()) {
cam_view->LensFlareElements(flare1, flare4, flare2, flare3);
cam_view->LensFlare(true);
}
else if (stars->Corona()) {
cam_view->LensFlareElements(flare1, 0, 0, 0);
cam_view->LensFlare(true);
}
else {
cam_view->LensFlare(false);
}
}
}
void
GameScreen::Setup(Screen* s)
{
if (!s)
return;
screen = s;
loader->UseFileSystem(true);
// create windows
gamewin = new(__FILE__,__LINE__) Window(screen, 0, 0, screen->Width(), screen->Height());
// attach views to windows (back to front)
// fade in:
gamewin->AddView(new(__FILE__,__LINE__) FadeView(gamewin, 1, 0, 0));
// camera:
cam_dir = CameraDirector::GetInstance();
cam_view = new(__FILE__,__LINE__) CameraView(gamewin, cam_dir->GetCamera(), 0);
if (cam_view)
gamewin->AddView(cam_view);
// HUD:
hud_view = new(__FILE__,__LINE__) HUDView(gamewin);
gamewin->AddView(hud_view);
wep_view = new(__FILE__,__LINE__) WepView(gamewin);
gamewin->AddView(wep_view);
quantum_view = new(__FILE__,__LINE__) QuantumView(gamewin);
gamewin->AddView(quantum_view);
radio_view = new(__FILE__,__LINE__) RadioView(gamewin);
gamewin->AddView(radio_view);
tac_view = new(__FILE__,__LINE__) TacticalView(gamewin, this);
gamewin->AddView(tac_view);
disp_view = DisplayView::GetInstance();
// note: quit view must be last in chain
// so it can release window surface
quit_view = new(__FILE__,__LINE__) QuitView(gamewin);
gamewin->AddView(quit_view);
Starshatter* stars = Starshatter::GetInstance();
// initialize lens flare bitmaps:
if (stars->LensFlare()) {
cam_view->LensFlareElements(flare1, flare4, flare2, flare3);
cam_view->LensFlare(true);
}
// if lens flare disabled, just create the corona:
else if (stars->Corona()) {
cam_view->LensFlareElements(flare1, 0, 0, 0);
cam_view->LensFlare(true);
}
screen->AddWindow(gamewin);
FormDef aud_def("AudDlg", 0);
aud_def.Load("AudDlg");
auddlg = new(__FILE__,__LINE__) AudDlg(screen, aud_def, this);
FormDef ctl_def("CtlDlg", 0);
ctl_def.Load("CtlDlg");
ctldlg = new(__FILE__,__LINE__) CtlDlg(screen, ctl_def, this);
FormDef opt_def("OptDlg", 0);
opt_def.Load("OptDlg");
optdlg = new(__FILE__,__LINE__) OptDlg(screen, opt_def, this);
FormDef vid_def("VidDlg", 0);
vid_def.Load("VidDlg");
viddlg = new(__FILE__,__LINE__) VidDlg(screen, vid_def, this);
FormDef mod_def("ModDlg", 0);
mod_def.Load("ModDlg");
moddlg = new(__FILE__,__LINE__) ModDlg(screen, mod_def, this);
FormDef joy_def("JoyDlg", 0);
joy_def.Load("JoyDlg");
joydlg = new(__FILE__,__LINE__) JoyDlg(screen, joy_def, this);
FormDef key_def("KeyDlg", 0);
key_def.Load("KeyDlg");
keydlg = new(__FILE__,__LINE__) KeyDlg(screen, key_def, this);
FormDef mod_info_def("ModInfoDlg", 0);
mod_info_def.Load("ModInfoDlg");
modInfoDlg = new(__FILE__,__LINE__) ModInfoDlg(screen, mod_info_def, this);
FormDef nav_def("NavDlg", 0);
nav_def.Load("NavDlg");
navdlg = new(__FILE__,__LINE__) NavDlg(screen, nav_def, this);
FormDef eng_def("EngDlg", 0);
eng_def.Load("EngDlg");
engdlg = new(__FILE__,__LINE__) EngDlg(screen, eng_def, this);
FormDef flt_def("FltDlg", 0);
flt_def.Load("FltDlg");
fltdlg = new(__FILE__,__LINE__) FltDlg(screen, flt_def, this);
if (engdlg) engdlg->Hide();
if (fltdlg) fltdlg->Hide();
if (navdlg) navdlg->Hide();
if (auddlg) auddlg->Hide();
if (viddlg) viddlg->Hide();
if (optdlg) optdlg->Hide();
if (ctldlg) ctldlg->Hide();
if (keydlg) keydlg->Hide();
if (joydlg) joydlg->Hide();
if (moddlg) moddlg->Hide();
if (modInfoDlg) modInfoDlg->Hide();
screen->SetBackgroundColor(Color::Black);
frame_rate = 0;
loader->UseFileSystem(Starshatter::UseFileSystem());
}
void
CmdIntelDlg::ExecFrame()
{
CmdDlg::ExecFrame();
if (campaign != Campaign::GetCampaign() || campaign->GetUpdateTime() != update_time) {
campaign = Campaign::GetCampaign();
update_time = campaign->GetUpdateTime();
lst_news->ClearItems();
txt_news->SetText("");
if (img_news)
img_news->SetPicture(bmp_default);
}
if (campaign) {
List<CombatEvent>& events = campaign->GetEvents();
bool auto_scroll = false;
if (events.size() > lst_news->NumItems()) {
while (events.size() > lst_news->NumItems()) {
CombatEvent* info = events[lst_news->NumItems()];
const char* unread = info->Visited() ? " " : "*";
int i = lst_news->AddItemWithData(unread, (DWORD) info) - 1;
char dateline[32];
FormatDayTime(dateline, info->Time());
lst_news->SetItemText(i, 1, dateline);
lst_news->SetItemText(i, 2, info->Title());
lst_news->SetItemText(i, 3, info->Region());
lst_news->SetItemText(i, 4, Game::GetText(info->SourceName()));
if (!info->Visited())
auto_scroll = true;
}
if (lst_news->GetSortColumn() > 0)
lst_news->SortItems();
}
else if (events.size() < lst_news->NumItems()) {
lst_news->ClearItems();
for (int i = 0; i < events.size(); i++) {
CombatEvent* info = events[i];
const char* unread = info->Visited() ? " " : "*";
int j = lst_news->AddItemWithData(unread, (DWORD) info) - 1;
char dateline[32];
FormatDayTime(dateline, info->Time());
lst_news->SetItemText(j, 1, dateline);
lst_news->SetItemText(j, 2, info->Title());
lst_news->SetItemText(j, 3, info->Region());
lst_news->SetItemText(j, 4, Game::GetText(info->SourceName()));
if (!info->Visited())
auto_scroll = true;
}
if (lst_news->GetSortColumn() > 0)
lst_news->SortItems();
txt_news->SetText("");
if (img_news)
img_news->SetPicture(bmp_default);
}
if (auto_scroll) {
int first_unread = -1;
for (int i = 0; i < lst_news->NumItems(); i++) {
if (lst_news->GetItemText(i, 0) == "*") {
first_unread = i;
break;
}
}
if (first_unread >= 0)
lst_news->ScrollTo(first_unread);
}
}
Starshatter* stars = Starshatter::GetInstance();
if (start_scene > 0) {
ShowMovie();
start_scene--;
if (start_scene == 0) {
if (stars && campaign) {
stars->ExecCutscene(event_scene, campaign->Path());
if (stars->InCutscene()) {
Sim* sim = Sim::GetSim();
if (sim) {
cam_view->UseCamera(CameraDirector::GetInstance()->GetCamera());
cam_view->UseScene(sim->GetScene());
}
}
}
event_scene = "";
}
}
else {
if (dsp_view)
dsp_view->ExecFrame();
if (stars->InCutscene())
ShowMovie();
else
HideMovie();
}
}
void
MissionEvent::Execute(bool silent)
{
Starshatter* stars = Starshatter::GetInstance();
HUDView* hud = HUDView::GetInstance();
Sim* sim = Sim::GetSim();
Ship* player = sim->GetPlayerShip();
Ship* ship = 0;
Ship* src = 0;
Ship* tgt = 0;
Element* elem = 0;
int pan = 0;
bool end_mission = false;
if (event_ship.length())
ship = sim->FindShip(event_ship);
else
ship = player;
if (event_source.length())
src = sim->FindShip(event_source);
if (event_target.length())
tgt = sim->FindShip(event_target);
if (ship)
elem = ship->GetElement();
else if (event_ship.length()) {
elem = sim->FindElement(event_ship);
if (elem)
ship = elem->GetShip(1);
}
// expire the delay, if any remains
delay = 0;
// fire the event action
switch (event) {
case MESSAGE:
if (event_message.length() > 0) {
if (ship) {
RadioMessage* msg = new(__FILE__,__LINE__) RadioMessage(ship, src, event_param[0]);
msg->SetInfo(event_message);
msg->SetChannel(ship->GetIFF());
if (tgt)
msg->AddTarget(tgt);
RadioTraffic::Transmit(msg);
}
else if (elem) {
RadioMessage* msg = new(__FILE__,__LINE__) RadioMessage(elem, src, event_param[0]);
msg->SetInfo(event_message);
msg->SetChannel(elem->GetIFF());
if (tgt)
msg->AddTarget(tgt);
RadioTraffic::Transmit(msg);
}
}
if (event_sound.length() > 0) {
pan = event_param[0];
}
break;
case OBJECTIVE:
if (elem) {
if (event_param[0]) {
elem->ClearInstructions();
elem->ClearObjectives();
}
Instruction* obj = new(__FILE__,__LINE__) Instruction(event_param[0], 0);
obj->SetTarget(event_target);
elem->AddObjective(obj);
if (elem->Contains(player)) {
HUDView* hud = HUDView::GetInstance();
if (hud)
hud->ShowHUDInst();
}
}
break;
case INSTRUCTION:
if (elem) {
if (event_param[0])
elem->ClearInstructions();
elem->AddInstruction(event_message);
if (elem->Contains(player) && event_message.length() > 0) {
HUDView* hud = HUDView::GetInstance();
if (hud)
hud->ShowHUDInst();
}
}
break;
case IFF:
if (elem) {
elem->SetIFF(event_param[0]);
}
else if (ship) {
ship->SetIFF(event_param[0]);
}
break;
case DAMAGE:
if (ship) {
ship->InflictDamage(event_param[0]);
if (ship->Integrity() < 1) {
NetUtil::SendObjKill(ship, 0, NetObjKill::KILL_MISC);
ship->DeathSpiral();
Print(" %s Killed By Scripted Event %d (%s)\n", (const char*) ship->Name(), id, FormatGameTime());
}
}
else {
Print(" EVENT %d: Could not apply damage to ship '%s' (not found).\n", id, (const char*) event_ship);
}
break;
case JUMP:
if (ship) {
SimRegion* rgn = sim->FindRegion(event_target);
if (rgn && ship->GetRegion() != rgn) {
if (rgn->IsOrbital()) {
QuantumDrive* quantum_drive = ship->GetQuantumDrive();
if (quantum_drive) {
quantum_drive->SetDestination(rgn, Point(0,0,0));
quantum_drive->Engage(true); // request immediate jump
}
else if (ship->IsAirborne()) {
ship->MakeOrbit();
}
}
else {
ship->DropOrbit();
}
}
}
break;
case HOLD:
if (elem)
elem->SetHoldTime(event_param[0]);
break;
case SKIP: {
for (int i = 0; i < event_nparams; i++) {
int skip_id = event_param[i];
ListIter<MissionEvent> iter = sim->GetEvents();
while (++iter) {
MissionEvent* e = iter.value();
if (e->EventID() == skip_id) {
if (e->status != COMPLETE)
e->status = SKIPPED;
}
}
}
}
break;
case END_MISSION:
Print(" END MISSION By Scripted Event %d (%s)\n", id, FormatGameTime());
end_mission = true;
break;
//
// NOTE: CUTSCENE EVENTS DO NOT APPLY IN MULTIPLAYER
//
case BEGIN_SCENE:
Print(" ------------------------------------\n");
Print(" Begin Cutscene '%s'\n", event_message.data());
stars->BeginCutscene();
break;
case END_SCENE:
Print(" End Cutscene '%s'\n", event_message.data());
Print(" ------------------------------------\n");
stars->EndCutscene();
break;
case CAMERA:
if (stars->InCutscene()) {
CameraDirector* cam_dir = CameraDirector::GetInstance();
if (!cam_dir->GetShip())
cam_dir->SetShip(player);
switch (event_param[0]) {
case 1:
if (cam_dir->GetMode() != CameraDirector::MODE_COCKPIT)
cam_dir->SetMode(CameraDirector::MODE_COCKPIT, event_rect.x);
break;
case 2:
if (cam_dir->GetMode() != CameraDirector::MODE_CHASE)
cam_dir->SetMode(CameraDirector::MODE_CHASE, event_rect.x);
break;
case 3:
if (cam_dir->GetMode() != CameraDirector::MODE_ORBIT)
cam_dir->SetMode(CameraDirector::MODE_ORBIT, event_rect.x);
break;
case 4:
if (cam_dir->GetMode() != CameraDirector::MODE_TARGET)
cam_dir->SetMode(CameraDirector::MODE_TARGET, event_rect.x);
break;
}
if (event_target.length()) {
::Print("Mission Event %d: setting camera target to %s\n", id, (const char*) event_target);
Ship* s_tgt = 0;
if (event_target.indexOf("body:") < 0)
s_tgt = sim->FindShip(event_target);
if (s_tgt) {
::Print(" found ship %s\n", s_tgt->Name());
cam_dir->SetViewOrbital(0);
if (cam_dir->GetViewObject() != s_tgt) {
if (event_param[0] == 6) {
s_tgt->DropCam(event_param[1], event_param[2]);
cam_dir->SetShip(s_tgt);
cam_dir->SetMode(CameraDirector::MODE_DROP, 0);
}
else {
Ship* cam_ship = cam_dir->GetShip();
if (cam_ship && cam_ship->IsDropCam()) {
cam_ship->CompleteTransition();
}
if (cam_dir->GetShip() != sim->GetPlayerShip())
cam_dir->SetShip(sim->GetPlayerShip());
cam_dir->SetViewObject(s_tgt, true); // immediate, no transition
}
}
}
else {
const char* body_name = event_target.data();
if (!strncmp(body_name, "body:", 5))
body_name += 5;
Orbital* orb = sim->FindOrbitalBody(body_name);
if (orb) {
::Print(" found body %s\n", orb->Name());
cam_dir->SetViewOrbital(orb);
}
}
}
if (event_param[0] == 3) {
cam_dir->SetOrbitPoint(event_point.x, event_point.y, event_point.z);
}
else if (event_param[0] == 5) {
cam_dir->SetOrbitRates(event_point.x, event_point.y, event_point.z);
}
}
break;
case VOLUME:
if (stars->InCutscene()) {
AudioConfig* audio_cfg = AudioConfig::GetInstance();
audio_cfg->SetEfxVolume(event_param[0]);
audio_cfg->SetWrnVolume(event_param[0]);
}
break;
case DISPLAY:
if (stars->InCutscene()) {
DisplayView* disp_view = DisplayView::GetInstance();
if (disp_view) {
Color color;
color.Set(event_param[0]);
if (event_message.length() && event_source.length()) {
if (event_message.contains('$')) {
Campaign* campaign = Campaign::GetCampaign();
Player* user = Player::GetCurrentPlayer();
CombatGroup* group = campaign->GetPlayerGroup();
if (user) {
event_message = FormatTextReplace(event_message, "$NAME", user->Name().data());
event_message = FormatTextReplace(event_message, "$RANK", Player::RankName(user->Rank()));
}
if (group) {
event_message = FormatTextReplace(event_message, "$GROUP", group->GetDescription());
}
if (event_message.contains("$TIME")) {
char timestr[32];
FormatDayTime(timestr, campaign->GetTime(), true);
event_message = FormatTextReplace(event_message, "$TIME", timestr);
}
}
disp_view->AddText( event_message,
FontMgr::Find(event_source),
color,
event_rect,
event_point.y,
event_point.x,
event_point.z);
}
else if (event_target.length()) {
DataLoader* loader = DataLoader::GetLoader();
if (loader) {
loader->SetDataPath(0);
loader->LoadBitmap(event_target, image, 0, true);
}
if (image.Width() && image.Height())
disp_view->AddImage( &image,
color,
Video::BLEND_ALPHA,
event_rect,
event_point.y,
event_point.x,
event_point.z);
}
}
}
break;
case FIRE_WEAPON:
if (ship) {
// fire single weapon:
if (event_param[0] >= 0) {
ship->FireWeapon(event_param[0]);
}
// fire all weapons:
else {
ListIter<WeaponGroup> g_iter = ship->Weapons();
while (++g_iter) {
ListIter<Weapon> w_iter = g_iter->GetWeapons();
while (++w_iter) {
Weapon* w = w_iter.value();
w->Fire();
}
}
}
}
break;
default:
break;
}
sim->ProcessEventTrigger(TRIGGER_EVENT, id);
if (!silent && !sound && event_sound.length()) {
DataLoader* loader = DataLoader::GetLoader();
bool use_fs = loader->IsFileSystemEnabled();
DWORD flags = pan ? Sound::LOCKED|Sound::LOCALIZED :
Sound::LOCKED|Sound::AMBIENT;
loader->UseFileSystem(true);
loader->SetDataPath("Sounds/");
loader->LoadSound(event_sound, sound, flags);
loader->SetDataPath(0);
if (!sound) {
loader->SetDataPath("Mods/Sounds/");
loader->LoadSound(event_sound, sound, flags);
loader->SetDataPath(0);
}
if (!sound) {
loader->LoadSound(event_sound, sound, flags);
}
loader->UseFileSystem(use_fs);
// fire and forget:
if (sound) {
if (sound->GetFlags() & Sound::STREAMED) {
sound->SetFlags(flags | sound->GetFlags());
sound->SetVolume(AudioConfig::VoxVolume());
sound->Play();
}
else {
sound->SetFlags(flags);
sound->SetVolume(AudioConfig::VoxVolume());
sound->SetPan(pan);
sound->SetFilename(event_sound);
sound->AddToSoundCard();
sound->Play();
}
}
}
status = COMPLETE;
if (end_mission) {
StarServer* server = StarServer::GetInstance();
if (stars) {
stars->EndMission();
}
else if (server) {
// end mission event uses event_target member
// to forward server to next mission in the chain:
if (event_target.length())
server->SetNextMission(event_target);
server->SetGameMode(StarServer::MENU_MODE);
}
}
}
