static int
s35392a_attach(struct i2c_adapter* adapter, int address, int kind)
{
int ret;
struct rtc_device *rtc = NULL;
if (i2c_adapter_id(adapter) != 1) /* rtc is on i2c-1 */
{
return -ENODEV;
}
gClient.addr = address;
gClient.adapter = adapter;
gClient.driver = &s35392a_driver;
gClient.flags = 0;
strlcpy(gClient.name, S35392A_DEV_NAME, I2C_NAME_SIZE);
MYTRACE(("%s\n", __func__));
MYTRACE(("Adapter : %d\n", i2c_adapter_id(adapter)));
MYTRACE(("ADDR : %x\n", gClient.addr));
ret = i2c_attach_client(&gClient);
if (ret < 0)
{
MYTRACE(("i2c attach failed : %s\n", __func__));
}
rtc = rtc_device_register(gClient.name, &gClient.dev, &s35392a_rtc_ops, THIS_MODULE);
if (IS_ERR(rtc))
{
MYTRACE(("RTC driver regist failed!\n"));
}
return ret;
}
UINT WINAPI CPlayer::WaitNetworkPlayer(LPVOID pVoid)
{
CPlayer *player=(CPlayer*)pVoid;
PSInstance *psInstance=player->getPSInstance();
MYTRACE("[%d]thread start",player->playerNum);
// MYTRACE("isAlive:%d",player->isAlive?1:0);
while(player->isAlive)
{
// EnterCriticalSection(&player->getCriticalSection());
if(player->isMessageWait && !player->isMessageReceived)
{
MYTRACE("[%d]recvData-start",player->playerNum);
int ret=psInstance->recvData((char*)&(player->decisionInfo),sizeof(DECISION_INFO));
MYTRACE("[%d]recvData-end(ret:%d)",player->playerNum,ret);
if(ret==0)
{
player->setDead();
break;
}
player->isMessageReceived=true;
player->messageReceivedTime=DXUTGetTime();
}
//LeaveCriticalSection(&player->getCriticalSection());
Sleep(10);
}
MYTRACE("[%d]thread end",player->playerNum);
return 1;
}
BOOL CUrlPool::Get( CString &strMirrorUrl )
{
#if 1
strMirrorUrl = m_strMainUrl;
++m_nThreadFromOrig;
return TRUE;
#else
if(m_nThreadFromOrig<m_nThreadFromOrigLimit && m_nMainError<DOWNLOAD_MAINURL_MAXRETYR)
{
++m_nThreadFromOrig;
strMirrorUrl = m_strMainUrl;
MYTRACE(_T("CLocationPool :Get [Main %d/%d]%s\r\n"), m_nThreadFromOrig, m_nThreadFromOrigLimit, strMirrorUrl);
return TRUE;
}
if(m_arrMirrors.empty())
{
MYTRACE(_T("CLocationPool :Get None(MainRetry:%d)\r\n"), m_nMainError);
return FALSE;
}
strMirrorUrl = m_arrMirrors[m_arrMirrors.size()-1];
m_arrMirrors.pop_back();
m_arrRunning.push_back(strMirrorUrl);
MYTRACE(_T("CLocationPool :Get [Pool %d/%d]%s\r\n"), m_arrMirrors.size(), m_arrRunning.size(), strMirrorUrl);
return TRUE;
#endif
}
static int
s35392a_set_time(struct device* pDev, struct rtc_time* pTm)
{
unsigned char rtc_reg[7];
int ret;
MYTRACE(("%s : \n", __func__));
MYTRACE(("YY:MM:DD:HH:MM:SS(%d:%2d:%2d:%2d:%2d:%2d)\n", pTm->tm_year, pTm->tm_mon, pTm->tm_mday, pTm->tm_hour, pTm->tm_min, pTm->tm_sec));
rtc_reg[6] = BIN2BCD(pTm->tm_sec);
rtc_reg[5] = BIN2BCD(pTm->tm_min);
rtc_reg[4] = BIN2BCD(pTm->tm_hour);
rtc_reg[3] = BIN2BCD(pTm->tm_wday);
rtc_reg[2] = BIN2BCD(pTm->tm_mday);
rtc_reg[1] = BIN2BCD(pTm->tm_mon + 1); /*0~11 for linux appl, 1~12 for rtc */
rtc_reg[0] = BIN2BCD(pTm->tm_year - 100); /* 1900 for linux appl, 2000 for rtc */
/* don't use tm_yday and tm_dst */
ret = s35392a_write_reg(S35392A_REALTIME_DATA1, rtc_reg, sizeof(rtc_reg));
if (ret < 0)
{
return ret;
}
return 0;
}
static int
s35392a_read_time(struct device* pDev, struct rtc_time* pTm)
{
unsigned char rtc_reg[7];
int ret;
ret = s35392a_read_reg(S35392A_REALTIME_DATA1, rtc_reg, sizeof(rtc_reg));
if (ret < 0)
{
return ret;
}
pTm->tm_sec = BCD2BIN(rtc_reg[6] & S35392A_SEC_MASK);
pTm->tm_min = BCD2BIN(rtc_reg[5] & S35392A_MIN_MASK);
pTm->tm_hour = BCD2BIN(rtc_reg[4] & S35392A_HOUR_MASK);
pTm->tm_wday = BCD2BIN(rtc_reg[3] & S35392A_WDAY_MASK);
pTm->tm_mday = BCD2BIN(rtc_reg[2] & S35392A_DAY_MASK);
pTm->tm_mon = BCD2BIN(rtc_reg[1] & S35392A_MON_MASK) - 1; /* 0~11 for linux appl, 1~12 for rtc */
pTm->tm_year = BCD2BIN(rtc_reg[0] & S35392A_YEAR_MASK) + 100; /* 1900 for linux appl, 2000 for rtc */
/* don't use tm_yday and tm_dst */
MYTRACE(("%s : \n", __func__));
MYTRACE(("YY:MM:DD:HH:MM:SS(%d:%2d:%2d:%2d:%2d:%2d)\n", pTm->tm_year, pTm->tm_mon, pTm->tm_mday, pTm->tm_hour, pTm->tm_min, pTm->tm_sec));
return 0;
}
HRESULT WindowsFirewallTurnOff(IN INetFwProfile* fwProfile)
{
HRESULT hr = S_OK;
BOOL fwOn;
assert(fwProfile != NULL);
// Check to see if the firewall is on.
hr = WindowsFirewallIsOn(fwProfile, &fwOn);
if (FAILED(hr))
{
MYTRACE(ACE_TEXT("WindowsFirewallIsOn failed: 0x%08lx\n"), hr);
goto error;
}
// If it is, turn it off.
if (fwOn)
{
// Turn the firewall off.
hr = fwProfile->put_FirewallEnabled(VARIANT_FALSE);
if (FAILED(hr))
{
MYTRACE(ACE_TEXT("put_FirewallEnabled failed: 0x%08lx\n"), hr);
goto error;
}
MYTRACE(ACE_TEXT("The firewall is now off.\n"));
}
error:
return hr;
}
LRESULT CMainFrame::ShowCombatView(WPARAM /*wParam*/, LPARAM /*lParam*/)
{
MYTRACE("general")(MT::LEVEL_INFO, "Getting Message to Show CombatView...");
CBotEDoc* pDoc = resources::pDoc;
AssertBotE(pDoc);
// Combat View anzeigen
FullScreenMainView(true);
SelectMainView(VIEWS::COMBAT_VIEW, pDoc->GetPlayersRaceID());
// wurde Rundenende geklickt zurücksetzen
resources::pClientWorker->SetToEmpireViewFor(*pDoc->GetPlayersRace());
pDoc->m_bRoundEndPressed = false;
pDoc->m_bDataReceived = true;
// Zuletzt gedrückten Button zurücksetzen
CCombatMenuView* pView = ((CCombatMenuView*)GetView(RUNTIME_CLASS(CCombatMenuView)));
pView->OnNewRound();
pDoc->UpdateAllViews(NULL);
MYTRACE("general")(MT::LEVEL_INFO, "Showing CombatView\n");
return TRUE;
}
HRESULT WindowsFirewallIsOn(IN INetFwProfile* fwProfile, OUT BOOL* fwOn)
{
HRESULT hr = S_OK;
VARIANT_BOOL fwEnabled;
assert(fwProfile != NULL);
assert(fwOn != NULL);
*fwOn = FALSE;
// Get the current state of the firewall.
hr = fwProfile->get_FirewallEnabled(&fwEnabled);
if (FAILED(hr))
{
MYTRACE(ACE_TEXT("get_FirewallEnabled failed: 0x%08lx\n"), hr);
goto error;
}
// Check to see if the firewall is on.
if (fwEnabled != VARIANT_FALSE)
{
*fwOn = TRUE;
MYTRACE(ACE_TEXT("The firewall is on.\n"));
}
else
{
MYTRACE(ACE_TEXT("The firewall is off.\n"));
}
error:
return hr;
}
/* アンドゥ・リドゥバッファのダンプ */
void COpeBuf::DUMP()
{
#ifdef _DEBUG
int i;
MYTRACE( _T("COpeBuf.m_nCurrentPointer=[%d]----\n"), m_nCurrentPointer );
int size = (int)m_vCOpeBlkArr.size();
for( i = 0; i < size; ++i ){
MYTRACE( _T("COpeBuf.m_vCOpeBlkArr[%d]----\n"), i );
m_vCOpeBlkArr[i]->DUMP();
}
MYTRACE( _T("COpeBuf.m_nCurrentPointer=[%d]----\n"), m_nCurrentPointer );
#endif
}
static int
s35392a_probe(struct i2c_adapter* adapter)
{
int ret;
MYTRACE(("ADAPTER id : %d\n", i2c_adapter_id(adapter)));
ret = i2c_probe(adapter, &addr_data, &s35392a_attach);
MYTRACE(("%s : %d\n", __func__, ret));
return ret;
}
LRESULT CMainFrame::InitViews(WPARAM /*wParam*/, LPARAM /*lParam*/)
{
MYTRACE("general")(MT::LEVEL_INFO, "Getting Message to InitViews...");
CBotEDoc* pDoc = resources::pDoc;
AssertBotE(pDoc);
// alle rassenabhängigen Grafiken in jeder View laden
pDoc->LoadViewGraphics();
MYTRACE("general")(MT::LEVEL_INFO, "Init all Views done\n");
return TRUE;
}
LRESULT CMainFrame::UpdateViews(WPARAM /*wParam*/, LPARAM /*lParam*/)
{
MYTRACE("general")(MT::LEVEL_INFO, "Getting Message to UpdateViews...");
CBotEDoc* pDoc = resources::pDoc;
AssertBotE(pDoc);
// Views ihre Arbeiten zu jeder neuen Runde machen lassen
pDoc->DoViewWorkOnNewRound();
MYTRACE("general")(MT::LEVEL_INFO, "Updating all Views done\n");
return TRUE;
}
/// Funkion berechnet einen möglichen Angriffssektor, welcher später gesammelt angegriffen werden kann.
void CShipAI::CalcAttackSector(void)
{
// für alle Majors den Angriffssektor berechnen
map<CString, CMajor*>* pmMajors = m_pDoc->GetRaceCtrl()->GetMajors();
for (map<CString, CMajor*>::const_iterator it = pmMajors->begin(); it != pmMajors->end(); ++it)
{
int nearestSector = MAXSHORT;
// beinhaltet die Sektorkoordinate mit unserem Angriffsziel
CPoint sector = CPoint(-1,-1);
for (UINT j = 0; j < m_pSectorAI->GetOffensiveTargets(it->first)->size(); j++)
{
int space = max(abs(m_pSectorAI->GetHighestShipDanger(it->first).x - m_pSectorAI->GetOffensiveTargets(it->first)->at(j).x),
abs(m_pSectorAI->GetHighestShipDanger(it->first).y - m_pSectorAI->GetOffensiveTargets(it->first)->at(j).y));
if (space < nearestSector)
{
// Wenn dieses Ziel eine kleinere Gefahr darstellt als unsere größte Flottenansammlung oder wir
// in schon mindst 50% unserer Flotte hier versammelt haben, so wird es als Ziel aufgenommen
if ((m_pSectorAI->GetDangerOnlyFromCombatShips(it->first, m_pSectorAI->GetHighestShipDanger(it->first)) > m_pSectorAI->GetCompleteDanger(it->first, m_pSectorAI->GetOffensiveTargets(it->first)->at(j)))
|| (m_pSectorAI->GetDangerOnlyFromCombatShips(it->first, m_pSectorAI->GetHighestShipDanger(it->first)) > (m_pSectorAI->GetCompleteDanger(it->first) * 50 / 100)))
{
nearestSector = space;
sector = m_pSectorAI->GetOffensiveTargets(it->first)->at(j);
}
}
}
m_AttackSector[it->first] = sector;
MYTRACE("shipai")(MT::LEVEL_DEBUG, "Race %s: global attack sector is %d/%d\n",it->first, m_AttackSector[it->first].x, m_AttackSector[it->first].y);
}
}
CStudentInfoDoc::CStudentInfoDoc()
{
MYTRACE("Enter");
#ifdef _DEBUG
afxDump.SetDepth(1);
#endif
}
///////////////////////////////////////////////////////////////////////
// Speichern / Laden
///////////////////////////////////////////////////////////////////////
void CHull::Serialize(CArchive &ar)
{
CObject::Serialize(ar);
// wenn gespeichert wird
if (ar.IsStoring())
{
MYTRACE("shipdetails")(MT::LEVEL_DEBUG, "HULL.CPP: BaseHull:%d, CurrentHull:%d, HullMaterial:%d, MaxHull:%d, DblHull:%s, Ablative:%s, Pola:%s\n",
m_iBaseHull, m_iCurrentHull, m_iHullMaterial, m_iMaxHull,
m_bDoubleHull ? "true" : "false",
m_bAblative ? "true" : "false",
m_bPolarisation ? "true" : "false");
//HULL.CPP: BaseHull:600, CurrentHull:600, HullMaterial:0, MaxHull:600
ar << m_bDoubleHull;
ar << m_bAblative;
ar << m_bPolarisation;
ar << m_iBaseHull;
ar << m_iCurrentHull;
ar << m_iHullMaterial;
ar << m_iMaxHull;
}
// wenn geladen wird
if (ar.IsLoading())
{
ar >> m_bDoubleHull;
ar >> m_bAblative;
ar >> m_bPolarisation;
ar >> m_iBaseHull;
ar >> m_iCurrentHull;
ar >> m_iHullMaterial;
ar >> m_iMaxHull;
}
/*******************************************************************************
* 函数名称 : main
* 函数描述 : N/A
* 参数 : int argc
* 参数 : char * argv[]
* 返回值 : int
* 备注 : N/A
* 修改日期 修改人 修改内容
* -----------------------------------------------
* 2015/9/11 王全宝 新建
*******************************************************************************/
int main(int argc, char *argv [])
{
int ret = 0;
//取程序路径
string strFilePath;
CCommFunc::GetProgrammeDir(strFilePath);
string strConfigFile = strFilePath + "Config.ini";
string strLogFile = strFilePath + "LiveStore.log";
g_pConfig = new CIniFile(strConfigFile); //只读的形式建配置文件对象
if (NULL == g_pConfig)
{
return -1;
}
//从配置文件中获取日志级别
int iLogLevel = g_pConfig->ReadInt(GLOABL_SECTION, KEY_LOGLEVEL, 1);
//打开日志
g_ClientLog.Open(strLogFile.c_str(), iLogLevel);
//测试日志
MYTRACE(LOG_LEVEL_INFO, "livestore version<%s>", DISKMGR_VERSION);
CDiskinfoApp::GetInstance()->Init(argc, argv);
CDiskinfoApp::GetInstance()->Run();
CDiskinfoApp::ReleaseInstance();
return 0;
}
void CStudentInfoView::OnInitialUpdate()
{
MYTRACE("Enter");
m_StudentList = GetDocument()->GetStudentList(); // CAUTION: 这句要放在 OnInitialUpdate 之前调用, 因为 OnInitialUpdate->OnUpdate
CFormView::OnInitialUpdate();
ResizeParentToFit();
}
void CStudentInfoView::OnStudentIns()
{
MYTRACE("Enter");
InsertEntry(m_StudentListPos);
GetDocument()->SetModifiedFlag(TRUE);
GetDocument()->UpdateAllViews(this);
}
/// Diese Funktion gibt den möglichen Bonus durch die Manövriebarkeit bei einem Angriff zurück. Übergeben müssen
/// dafür die Manövrierbarkeit des Angreifers und die Manövrierbarkeit des Verteidigers werden.
BYTE CCombatShip::GetToHitBoni(BYTE Att, BYTE Def)
{
/*
Maneuvrierfähigkeit - Trefferbonus (= to hit bonus)
---0---1---2---3---4---5---6---7---8---9
0 00% 00% 00% 00% 00% 00% 00% 00% 00% 00%
1 05% 00% 00% 00% 00% 00% 00% 00% 00% 00%
2 10% 05% 00% 00% 00% 00% 00% 00% 00% 00%
3 15% 10% 05% 00% 00% 00% 00% 00% 00% 00%
4 20% 15% 10% 05% 00% 00% 00% 00% 00% 00%
5 25% 20% 15% 10% 05% 00% 00% 00% 00% 00%
6 30% 25% 20% 15% 10% 05% 00% 00% 00% 00%
7 35% 30% 25% 20% 15% 10% 05% 00% 00% 00%
8 40% 35% 30% 25% 20% 15% 10% 05% 00% 00%
9 45% 40% 35% 30% 25% 20% 15% 10% 05% 00%
*/
BYTE boni[10][10] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5, 0, 0, 0, 0, 0, 0, 0, 0, 0,
10, 5, 0, 0, 0, 0, 0, 0, 0, 0,
15, 10, 5, 0, 0, 0, 0, 0, 0, 0,
20, 15, 10, 5, 0, 0, 0, 0, 0, 0,
25, 20, 15, 10, 5, 0, 0, 0, 0, 0,
30, 25, 20, 15, 10, 5, 0, 0, 0, 0,
35, 30, 25, 20, 15, 10, 5, 0, 0, 0,
40, 35, 30, 25, 20, 15, 10, 5, 0, 0,
45, 40, 35, 30, 25, 20, 15, 10, 5, 0
};
MYTRACE("shipdetails")(MT::LEVEL_DEBUG, "boni[Att][Def]: %d, %d\n",boni[Att], boni[Def]);
return boni[Att][Def];
}
static void
__exit s35392a_exit(void)
{
MYTRACE(("%s\n", __func__));
i2c_del_driver(&s35392a_driver);
}
BOOL CSegmentInfoFile::Save( int64 iContentLength, int64 iDownloaded, const SegmentPtrs &parts )
{
TSegmentInfoFileHeader hdr = {0};
strcpy(hdr.magic, SEGMENT_INFO_FILE_MAGIC);
hdr.dwsize = sizeof(hdr) + sizeof(Segment) * parts.size();
hdr.filesize = iContentLength;
hdr.filesize_downloaded = iDownloaded;
hdr.segnum = parts.size();
char *pbuffer = new char[hdr.dwsize];
memset(pbuffer, 0, hdr.dwsize);
memcpy(pbuffer, &hdr, sizeof(hdr));
char *pb = pbuffer + sizeof(hdr);
for(size_t i=0; i<parts.size(); ++i)
{
Segment *p = parts[i];
memcpy(pb, p, sizeof(Segment));
pb += sizeof(Segment);
MYTRACE(_T("SAVE SEGMENT:%d - %I64d-%I64d-%I64d \r\n"), p->index, p->startposition, p->currentposition, p->endposition);
}
CString strSegFile;
strSegFile = m_strFilePath + DOWNLOAD_TEMP_FILE_INFO_SUFFIX;
CFileStream fs(strSegFile);
DWORD dwWrited = 0;
BOOL bRet = fs.Create() && fs.Write(pbuffer, hdr.dwsize, &dwWrited) && dwWrited==hdr.dwsize;
SAFE_DELETE_ARRAY(pbuffer);
return bRet;
}
static int
s35392a_read_reg(unsigned char reg_addr, unsigned char* buf, int buf_len)
{
struct i2c_msg msg[1];
int ret = 0;
//int i;
msg[0].addr = reg_addr;
msg[0].flags = I2C_M_RD;
msg[0].len = buf_len;
msg[0].buf = buf;
ret = i2c_transfer(gClient.adapter, msg, 1);
// MYTRACE(("%s : %d \n", __func__, ret));
if (ret < 0)
{
return -EIO;
}
s35392a_fourbit_reverse(buf, buf_len); /* convert endian */
#if 0
MYTRACE(("addr : %x\n", reg_addr));
for(i = 0; i < buf_len; i++)
{
MYTRACE(("buf[%02d] : %x\n", i, buf[i]);
}
#endif
return ret;
}
LRESULT CRygCtrl::OnSetState(WPARAM wparam, LPARAM lparam)
{
MYTRACE("wparam = %d\n", wparam);
m_State = (RYG_STAT) wparam;
Invalidate(FALSE);
return 0;
}
BOOL CUrlPool::Put( LPCTSTR szMirrorUrl, BOOL bFailed )
{
if(szMirrorUrl==m_strMainUrl)
{
--m_nThreadFromOrig;
if(bFailed) ++m_nMainError;
}
else
{
CStrings::iterator it = std::find(m_arrRunning.begin(), m_arrRunning.end(), szMirrorUrl);
ATLASSERT(it!=m_arrRunning.end());
if(it!=m_arrRunning.end())
m_arrRunning.erase(it);
if(bFailed)
{
m_arrFailed.push_back(szMirrorUrl);
}
else
{
m_arrMirrors.push_back(szMirrorUrl);
}
}
MYTRACE(_T("CLocationPool :Put %s [%d] [Main:%d/%d Mirror:%d/%d/%d]\r\n"), szMirrorUrl, !bFailed, m_nThreadFromOrig, m_nThreadFromOrigLimit, m_arrMirrors.size(), m_arrRunning.size(), m_arrFailed.size());
return TRUE;
}
void CStudentInfoView::OnStudentEnd()
{
MYTRACE("Enter");
if (!m_StudentList->IsEmpty()) {
m_StudentListPos = m_StudentList->GetTailPosition();
GetEntry(m_StudentListPos);
}
}
audio_resampler_t MakeAudioResampler(int input_channels, int input_samplerate,
int output_channels, int output_samplerate)
{
audio_resampler_t resampler;
bool ret = false;
#if defined(ENABLE_DMORESAMPLER)
DMOResampler* tmp_resample;
ACE_NEW_RETURN(tmp_resample, DMOResampler(), audio_resampler_t());
resampler = audio_resampler_t(tmp_resample);
ret = tmp_resample->Init(SAMPLEFORMAT_INT16,
input_channels,
input_samplerate,
SAMPLEFORMAT_INT16,
output_channels,
output_samplerate);
MYTRACE(ACE_TEXT("Launched DMOResampler\n"));
#elif defined(ENABLE_FFMPEG3)
FFMPEGResampler* tmp_resample;
ACE_NEW_RETURN(tmp_resample, FFMPEGResampler(), audio_resampler_t());
resampler = audio_resampler_t(tmp_resample);
ret = tmp_resample->Init(input_samplerate,
input_channels,
output_samplerate,
output_channels);
MYTRACE(ACE_TEXT("Launched FFMPEGResampler\n"));
#elif defined(ENABLE_SPEEXDSP)
SpeexResampler* tmp_resample;
ACE_NEW_RETURN(tmp_resample, SpeexResampler(), audio_resampler_t());
resampler = audio_resampler_t(tmp_resample);
ret = tmp_resample->Init(5, input_samplerate,
input_channels,
output_samplerate,
output_channels);
MYTRACE(ACE_TEXT("Launched SpeexResampler\n"));
#else
#pragma message("No resampler available")
#endif
if(!ret)
resampler.reset();
return resampler;
}
/// Funktion schickt Kriegsschiffe zu einem möglichen System, welches Bombardiert werden könnte.
/// @param pShip Zeiger des Schiffes
/// @return <code>true</code> wenn ein Bewegungsbefehl gegeben werden konnte, eine Bombardierung befohlen wurde oder das Schiff auf Verstärkung zur Bombardierung im System wartet
bool CShipAI::DoBombardSystem(CShips* pShip)
{
if (!pShip)
{
ASSERT(pShip);
return false;
}
if (pShip->GetKO() == m_BombardSector[pShip->GetOwnerOfShip()])
{
// Hier muss als erstes ein möglicher neuer Kurs gelöscht werden und ein alter Systemangriffsbefehl aufgehoben werden
pShip->SetTargetKO(CPoint(-1, -1));
// Wenn das Schiff bzw. Schiffe aus der Flotte getarnt sind, dann müssen diese erst enttarnt werden
if (!pShip->CanHaveOrder(SHIP_ORDER::ATTACK_SYSTEM, false))
{
// Schiff enttarnen
pShip->SetCurrentOrder(SHIP_ORDER::DECLOAK);
return true;
}
// Wenn die defensive Schiffsstärke im System des Angreifers ungefähr doppelt so groß als der Systemverteidigungswert
// des Verteidigers ist, wird bombardiert!
int nShipDefend = m_pDoc->GetSystem(pShip->GetKO().x, pShip->GetKO().y).GetProduction()->GetShipDefend();
nShipDefend *= 1.25;
int nShipValue = 0;
for(CShipMap::iterator i = m_pDoc->m_ShipMap.begin(); i != m_pDoc->m_ShipMap.end(); ++i)
{
if (i->second->GetOwnerOfShip() != pShip->GetOwnerOfShip())
continue;
if (i->second->GetKO() != pShip->GetKO())
continue;
nShipValue += i->second->GetHull()->GetCurrentHull();
for (CShips::iterator m = i->second->begin(); m != i->second->end(); ++m)
nShipValue += m->second->GetHull()->GetCurrentHull();
if (nShipValue > nShipDefend)
break;
}
//CString s;
//s.Format("shipValue = %d\nshipDefend = %d\nSektor = %s", shipValue, shipDefend, m_pDoc->GetSector(pShip->GetKO().x, pShip->GetKO().y).GetName(true));
//AfxMessageBox(s);
if (nShipValue > nShipDefend)
{
MYTRACE("shipai")(MT::LEVEL_INFO, "Race %s: Ship %s (%s) is bombarding system: %d,%d\n",pShip->GetOwnerOfShip(), pShip->GetShipName(), pShip->GetShipTypeAsString(), pShip->GetKO().x,pShip->GetKO().y);
pShip->SetCurrentOrder(SHIP_ORDER::ATTACK_SYSTEM);
return true;
}
}
return false;
}
/*******************************************************************************
* 函数名称 : IsHardRaid
* 函数描述 : N/A
* 返回值 : bool
* 备注 : N/A
* 修改日期 修改人 修改内容
* -----------------------------------------------
* 2015/10/26 郭家勇 新建
*******************************************************************************/
int CDiskinfoApp::IsHardRaid()
{
int ret = 0;
char get_adapnum_cmd[128] = {};
sprintf(get_adapnum_cmd, " MegaCli -pdlist -aAll | grep Adapter | wc -l");
string num;
ret = syscmd_result(get_adapnum_cmd, num);
if (ret < 0)
{
MYTRACE(LOG_LEVEL_ERROR, "get adapter number error");
return ret;
}
int adapnum = atoi(num.c_str());
MYTRACE(LOG_LEVEL_DEBUG, "get adapter number:%d ", adapnum);
return adapnum;
}
void CCoordFrame::redraw()
{
TCHAR name[MAX_PATH];
CChineseCodeLib::Gb2312ToUnicode(name, MAX_PATH, _name);
MYTRACE(L"COORD-%s %.02f, %.02f, %.02f, %.02f, %.02f, %.02f, %.02f, %.02f\n",
name,
_referframe->_real_world.x0, _referframe->_real_world.y0, _referframe->_real_world.xn, _referframe->_real_world.yn,
_referframe->_real_world.minpos, _referframe->_real_world.miny, _referframe->_real_world.maxpos, _referframe->_real_world.maxy);
}
static int
s35392a_detach(struct i2c_client* client)
{
int ret;
ret = i2c_detach_client(client);
MYTRACE(("detach : %d\n", ret));
return 0;
}
