void DockBase::GroupMenuAction(String name, int command, int alignment)
{
DockableCtrl* ctrl = NULL;
Vector<int>& ids = groups.Get(name);
int ncount = ids.GetCount();
bool aligned = (alignment >= DockableCtrl::DOCK_LEFT && alignment <= DockableCtrl::DOCK_BOTTOM);
for(int i = 0; i < ncount * 2; i++)
{
if(i < ncount)
{
ctrl = GetCtrlRecordFromId(ids[i])->ctrl;
ASSERT(ctrl);
ctrl->Shut();
}
else
{
if(i == ncount) RefreshTabWindowList();
ctrl = GetCtrlRecordFromId(ids[i - ncount])->ctrl;
ASSERT(ctrl);
switch(command)
{
case 0: Dock(ctrl->DockingStyle(alignment, DockableCtrl::STATE_SHOW)); break;
case 1: Dock(ctrl->SetSizeHint(Size(0,0)).DockingStyle(alignment, DockableCtrl::STATE_AUTO)); break;
case 2: Dock(ctrl->DockFloat()); break;
case 3: if (i - ncount == 0) TabifyGroupAndDock(name, alignment); break;
case 4: if (i - ncount == 0) TabifyGroupAndAutoHide(name, alignment); break;
case 5: if (i - ncount == 0) TabifyGroupAndFloat(name); break;
}
}
}
}
void Client (int argc, char **argv, const int id)
{
Complex *recv_msg = new Complex[1];
int send_msg = id;
const int dst = 0;
MPI_Status status;
const int mytag = 0;
while (1) {
MPI_Send (&send_msg, 1, MPI_INT, dst, mytag, MPI_COMM_WORLD);
printf ("%-20s \t\t\t\t\t client %02d request\n", argv[0], id);
MPI_Recv (recv_msg, 1, MPI_JOB, dst, mytag, MPI_COMM_WORLD, &status);
if (recv_msg->signal == FINISH_SIGNAL) {
printf ("%-20s \t\t\t\t\t\t\t\t\t\t client %02d retired\n", argv[0], id);
break;
}
else {
printf ("%s start docking\n", argv[0]);
Dock (recv_msg, argv[0], id);
}
}
delete[]recv_msg;
}
void DockWindow::DockGroup(int align, String group, int pos)
{
ALIGN_ASSERT(align);
bool all = group == "All";
for (int i = 0; i < dockers.GetCount(); i++)
if (all || dockers[i]->GetGroup() == group && IsDockAllowed(align, *dockers[i]))
Dock(align, *dockers[i], pos);
}
JBoolean
JXDockWidget::Dock
(
JXWindowDirector* d,
const JBoolean reportError
)
{
return Dock(d->GetWindow(), reportError);
}
BOOL CDockManager::Initialize(CWnd* pMainWnd, CWnd* pDockWnd,
DM_POS nPos, DM_POS nLastPos,
int nWidthDocked, int nWidthDockedMax,
int nHeightDocked, int nHeightDockedMax)
{
if (!HookWindow(*pMainWnd) || !ScHookWindow(*pDockWnd))
return FALSE;
m_nLastDockPos = nLastPos;
m_nWidthDocked = nWidthDocked;
m_nWidthDockedMax = nWidthDockedMax;
m_nHeightDocked = nHeightDocked;
m_nHeightDockedMax = nHeightDockedMax;
return Dock(nPos);
}
BOOL CMainFrame::OnViewText()
{
DWORD dwStyle = DS_NO_UNDOCK | DS_NO_CAPTION | DS_CLIENTEDGE;
if (m_pDockText->IsDocked())
{
m_pDockText->Hide();
GetFrameMenu().CheckMenuItem(IDM_VIEW_TEXT, MF_UNCHECKED);
}
else
{
Dock(m_pDockText, dwStyle | DS_DOCKED_RIGHT);
GetFrameMenu().CheckMenuItem(IDM_VIEW_TEXT, MF_CHECKED);
}
return TRUE;
}
void TKlingonBC::Do_ai()
{
// Destruction rules
if (m_lstHealth[HLT_HULL]<=0)
{
Explode();
}
else
{
double tsx,tsy;
m_blPhaserOn = false;
if (m_lstHealth[HLT_SENSOR]<30)
{
m_pTarget=NULL;
}
else
{
if ((m_nTask==TSK_CONTACT)||(m_nTask==TSK_STRIKE))
{
m_pTarget=(TShip *) m_pEngine->Seek(ID_PLAYER,m_dViewDistance,m_dX,m_dY);
}
else
{
m_pTarget = (TShip *) m_pEngine->Seek(MEM_KLINGON,true,m_dViewDistance,m_dX,m_dY);
}
if ((m_pTarget!=NULL)&&(m_pTarget->m_blDestroyed)) m_pTarget=NULL;
}
if (((m_pTarget!=NULL)&&((m_pTarget->m_blDestroyed)||(m_pTarget->m_CloakState == CS_CLOAKED)))||(m_lstHealth[HLT_SENSOR]<30)||(m_lstHealth[HLT_COMPUTER]<30)) m_pTarget=NULL;
if ((m_pTarget==NULL)||(m_pTarget->m_blDocked==true))
{
if ((m_AI==AI_CHASE)||(m_AI==AI_EVADE))
{
m_AI=AI_WANDER;
}
}
else
{
m_dTargetDistance = Distance(m_dX,m_dY,m_pTarget->GetX(),m_pTarget->GetY());
if (m_AI==AI_WANDER) m_AI=AI_CHASE;
if (m_nTask==TSK_STANDARD)
{
if ((m_lstHealth[HLT_PHOTON]<50)&&(m_lstHealth[HLT_PHASER]<=20)) m_AI=AI_EVADE;
}
}
if ((m_lstHealth[HLT_PHOTON]<40)||(m_nTorpedoes==0))
{
if (! TryEnterDocking())
{
m_AI=AI_EVADE;
}
}
else if (m_pTarget==NULL)
{
bool blShouldDock = false;
for (size_t i=0;i<m_lstHealth.size();i++)
{
if (m_lstHealth[i] < (m_nMaxHealth-50)) blShouldDock = true;
if (m_nTorpedoes<50) blShouldDock = true;
}
if (blShouldDock)
{
if(! TryEnterDocking())
{
m_dWaypointX=rand() % SECTORSIZE;
m_dWaypointY=rand() % SECTORSIZE;
m_AI=AI_WANDER;
}
}
}
switch(m_AI)
{
case AI_WANDER:
{
SetSpeed(100);
m_dAngleSeek=WayPoint(m_dWaypointX,m_dWaypointY);
double dDistance = Distance(m_dX,m_dY,m_dWaypointX,m_dWaypointY);
if (dDistance<40)
{
m_dWaypointX=rand() % SECTORSIZE;
m_dWaypointY=rand() % SECTORSIZE;
}
if ((m_nCloakCharge>=CLOAK_DELAY)&&((m_lstHealth[HLT_CLOAK]>60)||(m_nEnergy>500))&&((m_CloakState == CS_UNCLOAKED)||(m_CloakState == CS_DECLOAKING)))
{
m_CloakState = CS_CLOAKING;
}
}
break;
case AI_CHASE:
if (m_pTarget!=NULL)
{
if (((m_CloakState == CS_CLOAKED)||(m_CloakState == CS_CLOAKING))&&(m_dTargetDistance<1000))
{
m_CloakState = CS_DECLOAKING;
m_nCloakCharge=0;
}
tsx=m_pTarget->GetX()+cos(m_pTarget->GetAngle())*m_pTarget->GetSpeed();
tsy=m_pTarget->GetY()+sin(m_pTarget->GetAngle())*m_pTarget->GetSpeed();
m_dAngleSeek=WayPoint(tsx,tsy);
SetSpeed(m_dTargetDistance/4);
double t=m_dAngleSeek-m_dAngle;
if (t<0) t=-t;
if (m_nTask!=TSK_CONTACT)
{
if ((m_dTargetDistance<=600)&&(m_dTargetDistance>150)&&(t<0.1))
{
fire_photon();
}
if (m_dTargetDistance<100) m_AI=AI_EVADE;
}
}
else
{
m_dWaypointX=rand() % SECTORSIZE;
m_dWaypointY=rand() % SECTORSIZE;
m_AI=AI_WANDER;
}
break;
case AI_EVADE:
if (m_pTarget!=NULL)
{
if (((m_CloakState == CS_CLOAKED)||(m_CloakState == CS_CLOAKING))&&(m_dTargetDistance<1000))
{
m_CloakState = CS_DECLOAKING;
m_nCloakCharge=0;
}
tsx=m_pTarget->GetX()+cos(m_pTarget->GetAngle())*m_pTarget->GetSpeed();
tsy=m_pTarget->GetY()+sin(m_pTarget->GetAngle())*m_pTarget->GetSpeed();
m_dAngleSeek=WayPoint(tsx,tsy);
SetSpeed(m_dMaxSpeed);
double t=m_dAngleSeek-m_dAngle;
if (t<0) t=-t;
if (m_nTask!=TSK_CONTACT)
{
if ((m_dTargetDistance<=600)&&(m_dTargetDistance>100)&&(t<0.1))
{
fire_photon();
}
if (m_dTargetDistance>400) m_AI=AI_CHASE;
}
m_dAngleSeek-=PI;
}
else
{
m_dWaypointX=rand() % SECTORSIZE;
m_dWaypointY=rand() % SECTORSIZE;
m_AI=AI_WANDER;
}
break;
case AI_DOCK:
if (! m_blDocked)
{
m_pBaseTarget = (TShip *) m_pEngine->Seekstarbase(m_Member,false,SECTORSIZE * 2,m_dX,m_dY);
if ((m_pBaseTarget!=NULL) && ( !Dock(m_pBaseTarget) ))
{
m_dAngleSeek=WayPoint(m_pBaseTarget->GetX(),m_pBaseTarget->GetY());
}
}
else
{
bool can_go=true;
if (m_blNoRelease) can_go=false;
for (size_t i=0;i<m_lstHealth.size();i++)
{
if (m_lstHealth[i]<m_nMaxHealth) can_go=false;
if (m_nTorpedoes<50) can_go=false;
}
if (can_go)
{
m_blDocked = false;
m_blDocking = false;
m_blReleasing = true;
m_AI=AI_RELEASE;
}
}
break;
case AI_RELEASE:
if (m_blReleasing)
{
Release(m_pBaseTarget);
}
else
{
m_blDocked = false;
m_blDocking = false;
m_blReleasing = false;
m_dWaypointX=rand() % SECTORSIZE;
m_dWaypointY=rand() % SECTORSIZE;
m_AI=AI_WANDER;
}
break;
default:
break;
}
//*******************************************************************************
DoEngineering();
if (m_nEnergy>0)
{
m_dSteer = m_lstHealth[HLT_THRUSTER]*0.0003;
m_dAngleSeek = GetEvasiveAngle(m_dAngleSeek);
Control();
}
else if (m_lstHealth[HLT_WARPCORE]<20)
{
m_lstHealth[HLT_HULL]=0;
}
}
if (((m_nEnergy<20)||(m_lstHealth[HLT_CLOAK]<50))&&((m_CloakState == CS_CLOAKED)||(m_CloakState == CS_CLOAKING)))
{
m_CloakState = CS_DECLOAKING;
m_nCloakCharge=0;
}
if (m_dSpeed>(m_dMaxSpeed*m_lstHealth[HLT_IMPULSE])/100)
{
m_dSpeed=(m_dMaxSpeed*m_lstHealth[HLT_IMPULSE])/100;
}
if (m_dSpeed <0)
{
m_dSpeed =0;
}
if ((m_blDocked)&&
((m_pBaseTarget==NULL)||((m_pBaseTarget!=NULL)&&
(m_pBaseTarget->m_blDestroyed))))
{
Die();
}
}
void DockBase::TabifyGroupAndFloat(String groupname)
{
Dock(TabifyGroup(groupname).DockFloat());
}
void DockBase::TabifyGroupAndAutoHide(String groupname, int alignment)
{
Dock(TabifyGroup(groupname).DockingStyle(alignment, DockableCtrl::STATE_AUTO));
}
LRESULT CDockManager::ScWindowProc(HWND hRealWnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_MOVE:
if (IsDocked())
{
LRESULT lr = ScDefault(hRealWnd);
if (m_bResizeUpdate)
UpdateMainWindowPos();
return lr;
}
break;
case WM_SIZE:
if (IsDocked())
{
LRESULT lr = ScDefault(hRealWnd);
if (m_bResizeUpdate)
UpdateMainWindowPos();
// save dock width
if (m_bSizeUpdate && ::IsWindowVisible(ScGetHwnd()))
{
CRect rDock;
::GetWindowRect(ScGetHwnd(), rDock);
if (IsMaximized())
{
if (m_nDockPos == DMP_BELOW)
m_nHeightDockedMax = rDock.Height();
else
m_nWidthDockedMax = rDock.Width();
}
else
{
if (m_nDockPos == DMP_BELOW)
m_nHeightDocked = rDock.Height();
else
m_nWidthDocked = rDock.Width();
}
}
return lr;
}
break;
case WM_SYSCOMMAND:
if (IsDocked())
{
switch (wp)
{
// hide system menu
case SC_KEYMENU:
case SC_MOUSEMENU:
return 0;
// don't allow docked window to be minimized or maximized directly
// instead, send the message to the main window
case SC_MAXIMIZE:
case SC_MINIMIZE:
return SendMessage(msg, wp, lp);
// if the dock window is being closed and the main window is maximized
// then readjust the main window rect
case SC_CLOSE:
if (IsMaximized())
{
LRESULT lr = ScDefault(hRealWnd);
OnMaximize();
return lr;
}
break;
}
}
break;
case WM_NCRBUTTONDOWN:
// if this is in the caption then eat it
if (IsDocked() && wp == HTCAPTION)
{
// activate the window first
ScSendMessage(WM_ACTIVATE, WA_CLICKACTIVE, NULL);
return 0;
}
break;
case WM_NCLBUTTONDOWN:
// if this is in the caption and the main window in maxed
// then eat
if (IsDocked() && wp == HTCAPTION && IsMaximized())
{
// activate the window first
ScSendMessage(WM_ACTIVATE, WA_CLICKACTIVE, NULL);
return 0;
}
break;
case WM_NCLBUTTONDBLCLK:
if (wp == HTCAPTION)
{
// toggle the docked state
if (IsDocked())
UnDock();
else
Dock(m_nLastDockPos);
// and eat the message
return 0;
}
break;
case WM_NCHITTEST:
if (IsDocked())
{
UINT nHitTest = ScDefault(hRealWnd);
// if the main window is _not_ unmaximized then don't let the
// docked window be resized on it's docked edge
// because its not intuitive and causes no end of trouble :)
if (!IsMaximized())
{
switch (m_nDockPos)
{
case DMP_LEFT:
if (nHitTest == HTRIGHT || nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT)
nHitTest = HTCLIENT;
break;
case DMP_RIGHT:
if (nHitTest == HTLEFT || nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT)
nHitTest = HTCLIENT;
break;
case DMP_BELOW:
if (nHitTest == HTTOP || nHitTest == HTTOPLEFT || nHitTest == HTTOPRIGHT)
nHitTest = HTCLIENT;
break;
default:
ASSERT(0);
break;
}
}
// else main window is maximized so _only_ let it be resized on its
// docked edge and resize the main window afterwards
else
{
switch (m_nDockPos)
{
case DMP_LEFT:
if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT ||
nHitTest == HTLEFT || nHitTest == HTTOPLEFT ||
nHitTest == HTBOTTOMLEFT || nHitTest == HTTOP || nHitTest == HTBOTTOM)
{
nHitTest = HTCLIENT;
}
break;
case DMP_RIGHT:
if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT ||
nHitTest == HTRIGHT || nHitTest == HTTOPLEFT ||
nHitTest == HTBOTTOMLEFT || nHitTest == HTTOP || nHitTest == HTBOTTOM)
{
nHitTest = HTCLIENT;
}
break;
case DMP_BELOW:
if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT ||
nHitTest == HTRIGHT || nHitTest == HTTOPLEFT ||
nHitTest == HTBOTTOMLEFT || nHitTest == HTLEFT || nHitTest == HTBOTTOM)
{
nHitTest = HTCLIENT;
}
break;
default:
ASSERT(0);
break;
}
}
return nHitTest;
}
break;
case WM_GETMINMAXINFO:
if (IsDocked())
{
LRESULT lr = ScDefault(hRealWnd);
// save off our last min size
LPMINMAXINFO pMMI = (LPMINMAXINFO)lp;
m_sizeDockMin = pMMI->ptMinTrackSize;
OnMinMaxInfo(pMMI, FALSE);
return lr;
}
case WM_WINDOWPOSCHANGED:
// if the dock window is being shown/hidden and the main window is maximized
// then adjust the main window rect
if (IsDocked() && IsMaximized())
{
LPWINDOWPOS lpwp = (LPWINDOWPOS)lp;
BOOL bVisible = ::IsWindowVisible(hRealWnd);
BOOL bWantHide = (lpwp->flags & SWP_HIDEWINDOW);
//BOOL bWantShow = (lpwp->flags & SWP_SHOWWINDOW);
if (bVisible && bWantHide) // special case
{
CAutoFlag af(m_bResizeUpdate, FALSE);
LRESULT lr = ScDefault(hRealWnd);
CRect rMain = GetWorkArea();
MoveWindow(GetCWnd(), rMain);
return lr;
}
else //if (!bVisible && bWantShow)
{
LRESULT lr = ScDefault(hRealWnd);
OnMaximize();
return lr;
}
}
break;
}
return ScDefault(hRealWnd);
}
void TEnterprise::Do_ai()
{
if (g_blGodMode)
{
for (size_t i=0;i< m_lstHealth.size();i++)
{
if (m_lstHealth[i]<m_nMaxHealth)
{
m_lstHealth[i] = m_nMaxHealth;
}
}
}
// Destruction rules
if (m_lstHealth[HLT_HULL]<=0)
{
al_stop_sample(&phaser_id);
Explode();
}
else if (m_blDocking)
{
Dock(m_pBaseTarget);
}
else if (m_blReleasing)
{
Release(m_pBaseTarget);
}
else
{
if (((m_pTarget!=NULL)&&((m_pTarget->m_blDocked)||
(m_pTarget->m_blDestroyed)||
(m_pTarget->m_CloakState == CS_CLOAKED)))||
(m_lstHealth[HLT_SENSOR]<30)||
(m_lstHealth[HLT_COMPUTER]<30)) m_pTarget=NULL;
if (m_pEngine->m_blKeys[SEEK_TARGET])
{
if (!m_blDocked)
{
if (m_lstHealth[HLT_SENSOR]>30)
{
if (m_lstHealth[HLT_COMPUTER]>30)
{
m_pTarget = (TShip*)m_pEngine->Seek(m_Member,true,m_dViewDistance,m_dX,m_dY);
}
else
{
g_pCommunication->AddMessage(11,CREW_SPOCK," The computer is having trouble");
}
}
else
{
g_pCommunication->AddMessage(12,CREW_SPOCK," Our sensors are in a weak condition");
}
}
else
{
g_pCommunication->AddMessage(13,CREW_SPOCK," We are docked jim !");
}
}
else if (m_pEngine->m_blKeys[SEEK_FRIEND])
{
if (!m_blDocked)
{
if (m_lstHealth[HLT_SENSOR]>30)
{
if (m_lstHealth[HLT_COMPUTER]>30)
{
if (g_blGodMode)
{
m_pTarget = (TShip*)m_pEngine->Seek(ID_ROMULAN_BASE, m_dViewDistance, m_dX,m_dY);
}
else
{
m_pTarget = (TShip*)m_pEngine->Seek(m_Member,false,m_dViewDistance,m_dX,m_dY);
}
}
else
{
g_pCommunication->AddMessage(11,CREW_SPOCK," The computer is having trouble");
}
}
else
{
g_pCommunication->AddMessage(12,CREW_SPOCK," Our sensors are in a weak condition");
}
}
else
{
g_pCommunication->AddMessage(13,CREW_SPOCK," We are docked jim !");
}
}
if (m_pEngine->m_blKeys[PHASER])
{
if (!m_blDocked)
{
if (m_lstHealth[HLT_PHASER]>30)
{
if (m_pTarget!=NULL)
{
if (m_dTargetDistance<500)
{
if ( m_nPhaserEnergy > 10)
{
if (!m_blPhaserOn)
{
SoundManager::LoopSound(SOUND::PHASER,1.0,&phaser_id);
m_blPhaserOn = true;
}
}
else
{
if (m_blPhaserOn)
{
SoundManager::StopSound(&phaser_id);
m_blPhaserOn = false;
}
}
}
else
{
g_pCommunication->AddMessage(15,CREW_SPOCK," Target out of range");
if (m_blPhaserOn)
{
SoundManager::StopSound(&phaser_id);
m_blPhaserOn = false;
}
}
}
else
{
if (m_blPhaserOn)
{
SoundManager::StopSound(&phaser_id);
m_blPhaserOn = false;
}
else
{
g_pCommunication->AddMessage(15,CREW_SPOCK," There is nothing to lock on");
}
}
}
else
{
g_pCommunication->AddMessage(16,CREW_SPOCK," Phasers are in bad shape");
if (m_blPhaserOn)
{
SoundManager::StopSound(&phaser_id);
m_blPhaserOn = false;
}
}
}
else
{
g_pCommunication->AddMessage(14,CREW_SPOCK," Your actions seem illogical");
if (m_blPhaserOn)
{
SoundManager::StopSound(&phaser_id);
m_blPhaserOn = false;
}
}
}
else
{
if (m_blPhaserOn)
{
SoundManager::StopSound(&phaser_id);
m_blPhaserOn = false;
}
}
if (m_pEngine->m_blKeys[PHOTON])
{
m_dAimangle=m_dAngle;
PrecalcFireAngles(75);
FirePhoton(false);
}
else if (m_pEngine->m_blKeys[PHOTON_BACK])
{
m_dAimangle=m_dAngle+PI;
PrecalcFireAngles(30);
FirePhoton(true);
}
else if (m_pEngine->m_blKeys[PROBE])
{
LaunchProbe();
}
if ((!m_blDocked)&&(!m_blDocking)&&(!m_blReleasing))
{
if ((!m_blDocked)&&(!m_blDocking)&&(m_pEngine->m_blKeys[DOCK]))
{
m_pBaseTarget=(TShip *) m_pEngine->Seekstarbase(MEM_FEDERATION,false,m_dViewDistance,m_dX,m_dY);
if ((m_pBaseTarget!=NULL)&&(!m_pBaseTarget->m_blDestroyed))
{
double b_distance = Distance(m_dX,m_dY,m_pBaseTarget->GetX(),m_pBaseTarget->GetY());
if (b_distance< 250)
{
m_pTarget=m_pBaseTarget;
m_blDocking=true;
m_blReleasing=false;
}
}
}
if (m_nWarpFactor>0)
{
if ((m_pEngine->m_blKeys[DOWN])||(m_pEngine->m_blKeys[WARP_0]))
{
StopWarp();
}
else if (m_pEngine->m_blKeys[LEFT])
{
if (g_nScreenMode == MODE_MAINSCREEN)
{
m_dAngle-=m_lstHealth[HLT_THRUSTER]*0.0001;
}
}
else if (m_pEngine->m_blKeys[RIGHT])
{
if (g_nScreenMode == MODE_MAINSCREEN)
{
m_dAngle+=m_lstHealth[HLT_THRUSTER]*0.0001;
}
}
else
{
DoWarp();
}
}
else
{
if (m_pEngine->m_blKeys[WARP_1])
{
StartWarp(1);
}
else if (m_pEngine->m_blKeys[WARP_2])
{
StartWarp(2);
}
else if (m_pEngine->m_blKeys[WARP_3])
{
StartWarp(3);
}
else if (m_pEngine->m_blKeys[WARP_4])
{
StartWarp(4);
}
else if (m_pEngine->m_blKeys[WARP_5])
{
StartWarp(5);
}
if (m_pEngine->m_blKeys[UP])
{
if (g_nScreenMode == MODE_MAINSCREEN)
{
SetSpeed(m_dSpeed+5);
}
}
else if (m_pEngine->m_blKeys[DOWN])
{
if (g_nScreenMode == MODE_MAINSCREEN)
{
SetSpeed(m_dSpeed-5);
}
}
if (m_pEngine->m_blKeys[LEFT])
{
if (g_nScreenMode == MODE_MAINSCREEN)
{
m_dAngle-=m_lstHealth[HLT_THRUSTER]*0.0006;
}
}
else if (m_pEngine->m_blKeys[RIGHT])
{
if (g_nScreenMode == MODE_MAINSCREEN)
{
m_dAngle+=m_lstHealth[HLT_THRUSTER]*0.0006;
}
}
}
}
if ((m_blDocked)&&(!m_blReleasing)&&(m_pEngine->m_blKeys[RELEASE]))
{
m_blReleasing=true;
m_blDocking=false;
}
DoEngineering();
if ((m_pTarget!=NULL)&&(!m_pTarget->m_blDestroyed))
{
m_dTargetDistance = Distance(m_dX,m_dY,m_pTarget->GetX(),m_pTarget->GetY());
}
if (m_lstHealth[HLT_SENSOR]<30)
{
m_pEngine->m_blSensorStatic=true;
}
else
{
m_pEngine->m_blSensorStatic=false;
}
}
if ((m_nWarpFactor==0) && (m_dSpeed>(m_dMaxSpeed*m_lstHealth[HLT_IMPULSE])/100))
{
m_dSpeed=(m_dMaxSpeed*m_lstHealth[HLT_IMPULSE])/100;
}
if (m_dSpeed <0)
{
m_dSpeed =0;
}
if ((m_blPhaserOn)&&(m_pTarget==NULL))
{
al_stop_sample(&phaser_id);
m_blPhaserOn = false;
}
if ((m_blDocked)&&
((m_pBaseTarget==NULL)||((m_pBaseTarget!=NULL)&&
(m_pBaseTarget->m_blDestroyed))))
{
Die();
}
if (!m_blWasDocked && m_blDocked)
{
g_pCommunication->AddMessage(3,CREW_CHECOV," Enterprise is docked captain !");
m_blWasDocked=true;
}
}
