bool BuffManager::BuildStub(BuffModify *e)
{
if (!e)
return false;
MY_ASSERT(1 != e->m_WillActTimes);
m_buffList[e->m_ID] = e;
e->m_curStep = 0;
if (0 != e->m_WillActTimes)
EventManager::GetInstance().Register(e, e->m_Margin);
// 主动触发第一个事件
//if (e->m_WillActTimes>2)
{
e->OnTimer(0);
}
e->SendNotify(true);
// 建立Buff组映射
BuffGroup::iterator it = m_buffGroup.find(e->m_GroupID);
MY_ASSERT(it == m_buffGroup.end());
m_buffGroup.insert(make_pair(e->m_GroupID, e->m_ID));
// 加入交叉索引
e->m_pusher->m_buffMgr.m_buffToOther.insert(e);
return TRUE;
}
void test_for_each() {
int idx = 0;
for ( const auto &it: enum_info<myenum0>::values ) {
switch ( idx ) {
case 0: MY_ASSERT(
0 == strcmp(it.name, "myenum0::member0") &&
0 == strcmp("myenum0::member0", enum_cast(it.value)) &&
it.ivalue == static_cast<enum_info<myenum0>::underlying_type>(it.value) &&
0 == it.ivalue
);
break;
case 1: MY_ASSERT(
0 == strcmp(it.name, "myenum0::member1") &&
0 == strcmp("myenum0::member1", enum_cast(it.value)) &&
it.ivalue == static_cast<enum_info<myenum0>::underlying_type>(it.value) &&
1 == it.ivalue
);
break;
case 2: MY_ASSERT(
0 == strcmp(it.name, "myenum0::member2") &&
0 == strcmp("myenum0::member2", enum_cast(it.value)) &&
it.ivalue == static_cast<enum_info<myenum0>::underlying_type>(it.value) &&
2 == it.ivalue
);
break;
default: MY_ASSERT(0)
}
++idx;
}
std::cout << "test_for_each() PASSED" << std::endl;
}
//main
int main(int argc , char *argv[])
{
int fd_listen, fd_client;
MY_ASSERT((fd_listen = socket(AF_INET, SOCK_STREAM , 0)) != -1 ,"listen socket init");//socket
struct sockaddr_in seraddr, clientaddr;
socklen_t sock_len = sizeof(clientaddr);
memset(&seraddr, 0, sizeof(seraddr));
seraddr.sin_family = AF_INET;
seraddr.sin_port = htons(atoi(argv[2]) );
seraddr.sin_addr.s_addr = inet_addr(argv[1]);
MY_ASSERT(bind(fd_listen, (struct sockaddr*)&seraddr, sizeof(seraddr))==0, "bind");//bind
MY_ASSERT(listen(fd_listen, 5) == 0, "listen");//listen
while(1)
{
sock_len =sizeof(clientaddr);
memset(&clientaddr, 0, sock_len);
fd_client = accept(fd_listen ,(struct sockaddr*)&clientaddr, &sock_len );
printf("client %s:%d connect!\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
if(fork() == 0)
{
close(fd_listen);
child_main(fd_client);
close(fd_client);
exit(1);
}
close(fd_client);
}
}
void test_out() {
std::stringstream s1;
myenum1 e1 = myenum1::member2;
s1 << e1;
MY_ASSERT(0 == strcmp(s1.str().c_str(), "myenum1::member2"));
std::stringstream s2;
myenum2 e2 = myenum2::member5;
s2 << e2;
MY_ASSERT(0 == strcmp(s2.str().c_str(), "myenum2::member5"));
std::stringstream s3;
myenum3 e3 = myenum3::member8;
s3 << e3;
MY_ASSERT(0 == strcmp(s3.str().c_str(), "myenum3::member8"));
std::stringstream s4;
myenum4 e4 = myenum4::member11;
s4 << e4;
MY_ASSERT(0 == strcmp(s4.str().c_str(), "myenum4::member11"));
std::stringstream s5;
myenum5 e5 = myenum5::member13;
s5 << e5;
MY_ASSERT(0 == strcmp(s5.str().c_str(), "myenum5::member13"));
std::cout << "test_out() PASSED" << std::endl;
}
void range_test()
{
vector<point_t> points;
vector<range_t> ranges;
for (size_t i = 0; i < 1000; ++i)
{
const coord_t x = rand();
const coord_t y = rand();
points.push_back(point_t(x, y));
points.push_back(point_t(x, rand()));
}
for (size_t i = 0; i < 1000; ++i)
{
coord_t inf = rand();
coord_t sup = rand();
if (sup < inf)
std::swap(inf, sup);
ranges.push_back(range_t(inf, sup));
}
/*
for (size_t i = 0; i < 10; ++i)
points.push_back(point_t(i, 5));
*/
const range_tree_t range_tree(points);
// auto ind = range_tree.query(range_t(2, 8), range_t(4, 9));
vector<bool> returned;
for (size_t i = 0; i < ranges.size() / 2; ++i)
{
returned.resize(range_tree.points().size(), false);
range_t x_range = ranges.at(i * 2 + 0);
range_t y_range = ranges.at(i * 2 + 1);
const auto indices = range_tree.query(x_range, y_range);
BOOST_FOREACH(const auto index, indices)
{
returned.at(index) = true;
const point_t point = range_tree.points().at(index);
MY_ASSERT(point.x >= x_range.inf && point.x < x_range.sup && point.y >= y_range.inf && point.y < y_range.sup);
}
for (size_t index = 0; index < range_tree.points().size(); ++index)
{
const point_t point = range_tree.points().at(index);
if (!returned.at(index))
MY_ASSERT(point.x < x_range.inf || point.x >= x_range.sup || point.y < y_range.inf || point.y >= y_range.sup);
}
}
static void Test1()
{
printf("Test1...\n");
emThread::StartUnmanaged(ThreadFunc1,(void*)"hello 1");
MY_ASSERT(!Event1.Receive(1,1000));
MY_ASSERT(Event1.Receive(1,1000));
}
//------------------------------------------------------------------------------------------
bool CGraphicDevice::Reset(int i_nWidth, int i_nHeight )
{
HRESULT hr;
// サーフェースの破棄
SAFE_RELEASE( m_pd3dSurface9 );
// デバイスのリセット
// Presentation Parameter の初期化
m_d3dpp.BackBufferWidth = i_nWidth;
m_d3dpp.BackBufferHeight = i_nHeight;
hr = m_pd3dDevice9->Reset( &m_d3dpp );
MY_ASSERT( SUCCEEDED(hr) );
// サーフェースを新しいサイズで再作成
bool ret = CreateRenderTarget( i_nWidth, i_nHeight );
MY_ASSERT( ret );
m_nWidth = i_nWidth;
m_nHeight = i_nHeight;
// ビューポートの設定
m_viewport.X = 0;
m_viewport.Y = 0;
m_viewport.Width = i_nWidth;
m_viewport.Height = i_nHeight;
m_viewport.MinZ = 0.0f;
m_viewport.MaxZ = 1.0f;
return ret;
}
void read_public_key(drown_ctx * dctx, char *filename)
{
// Read file
FILE * fp = fopen(filename, "r");
MY_ASSERT(fp != NULL, "can't open certificate file");
// Read cert
X509 *cert = PEM_read_X509(fp, NULL, NULL, NULL);
MY_ASSERT(cert != NULL, "file is not a certificate");
// Read public key
EVP_PKEY * pkey = X509_get_pubkey(cert);
MY_ASSERT(pkey != NULL, "can't get public key from certificate");
// Check RSA key
MY_ASSERT(pkey->type == EVP_PKEY_RSA, "public key is not RSA");
MY_ASSERT(EVP_PKEY_bits(pkey) == 2048, "only RSA-2048 is supported for now");
// Read RSA key
RSA *rsa = EVP_PKEY_get1_RSA(pkey);
// Copy the public key
BN_copy(dctx->n, rsa->n);
BN_copy(dctx->e, rsa->e);
RSA_free(rsa);
EVP_PKEY_free(pkey);
X509_free(cert);
fclose(fp);
}
void CExchangeGoods::ExchgLoseStatus()
{
CPlayer *pPlayer = static_cast<CPlayer *>(this);
if (!pPlayer)
return;
// 首先看看是否在等待交易回应
if (pPlayer->m_ChxSentOut.size())
{
for (CPlayer::CHXQuestList::iterator it = pPlayer->m_ChxSentOut.begin(); it != pPlayer->m_ChxSentOut.end(); ++it)
{
CPlayer *pDestPlayer = (CPlayer *)GetPlayerByGID(it->first)->DynamicCast(IID_PLAYER);
if (!pDestPlayer)
continue;
MY_ASSERT(pDestPlayer->m_CurHp);
pDestPlayer->m_ChxGetIn.erase(pPlayer->GetGID());
}
pPlayer->m_ChxSentOut.clear();
}
// 是否在等待响应交易请求
if (pPlayer->m_ChxGetIn.size())
{
CPlayer::CHXQuestList tempCopy(pPlayer->m_ChxGetIn);
for (CPlayer::CHXQuestList::iterator it = tempCopy.begin(); it != tempCopy.end(); ++it)
{
CPlayer *pQuest = (CPlayer *)GetPlayerByGID(it->first)->DynamicCast(IID_PLAYER);
if (pQuest)
{
MY_ASSERT(pQuest->m_CurHp);
// 超时，拒绝
SQQuestExchangeMsg rejectMsg;
rejectMsg.bAccept = false;
rejectMsg.dnidClient = 0;
rejectMsg.dwDestGID = pPlayer->GetGID();
rejectMsg.dwSrcGID = it->first;
RecvQuestExchangeMsg(&rejectMsg, true);
}
else
{
MY_ASSERT(0);
pPlayer->m_ChxGetIn.erase(it->first);
}
}
MY_ASSERT(pPlayer->m_ChxGetIn.empty());
}
// 是否处于交易中
if (pPlayer->InExchange())
{
CExchangeGoods::TheEnd();
}
}
static int ThreadFunc1(void * arg)
{
MY_ASSERT(strcmp((char*)arg,"hello 1")==0);
emSleepMS(1500);
MY_ASSERT(Event1.GetCount()==-1);
Event1.Send();
return 0;
}
bool BuffManager::CanAddBuff(const SBuffBaseData *pData, CFightObject *pSender)
{
if (!pData)
{
rfalse(4,1,"BuffManager::CanAddBuff(const SBuffBaseData *pData)1");
return false;
}
if (m_curObj&&pSender)
{
if (m_curObj->GetGID() != pSender->GetGID()) //给目标添加BUFF
{
if (!m_curObj->m_bPlayerAction[CST_ADDBUFF])
{
rfalse(2, 1, "目标当前无法添加BUFF");
return false;
}
}
}
BuffGroup::iterator groupIt = m_buffGroup.find(pData->m_GroupID);
if (groupIt == m_buffGroup.end())
{
//rfalse(2, 1, "玩家身上没有Buff组%d中的Buff", pData->m_GroupID);
//MY_ASSERT(m_buffList.end() == m_buffList.find(pData->m_ID));
return true;
}
BuffList::iterator buffIt = m_buffList.find(groupIt->second);
if (buffIt == m_buffList.end())
{
rfalse(4,1,"BuffManager::CanAddBuff(const SBuffBaseData *pData)2");
return false;
}
MY_ASSERT(m_buffList.end() != buffIt);
//TODO:Tony Modify [2012-3-11]Comment:[IF语句后面有;]
//if (pData->m_GroupID != buffIt->second->m_GroupID);
///////////////////////////////////////////////////////////////////
if (pData->m_GroupID != buffIt->second->m_GroupID)
{
rfalse(4,1,"BuffManager::CanAddBuff(const SBuffBaseData *pData)3");
return false;
}
MY_ASSERT(pData->m_GroupID == buffIt->second->m_GroupID);
if (!buffIt->second->m_CanBeReplaced)
return false;
// 如果可被替换，那么查看权重
if (buffIt->second->m_Weight > pData->m_Weight)
return false;
// 顶替
RemoveBuff(buffIt->second);
return true;
}
void CExchangeGoods::ExchangeCancel(CPlayer *pDestPlayer, bool isSrc)
{
if (!pDestPlayer)
return;
CPlayer *pSrcPlayer = static_cast<CPlayer *>(this);
if (!pSrcPlayer)
return;
// 交易取消，需要恢复被锁定的道具和金钱
for (int i=0; i<m_MyBox.m_SellNumber; i++)
{
SPackageItem &item = m_MyBox.m_GoodsArray[i];
SPackageItem *pItem = pSrcPlayer->FindItemByPos(item.wCellPos, XYD_FT_ONLYLOCK);
if (!pItem)
{
rfalse(4, 1, "ExchangeGoods.cpp - ExchangeCancel() - !pItem");
return;
}
MY_ASSERT(pItem);
pSrcPlayer->LockItemCell(pItem->wCellPos, false);
}
for (int i=0; i<m_YouBox.m_SellNumber; i++)
{
SPackageItem &item = m_YouBox.m_GoodsArray[i];
SPackageItem *pItem = pDestPlayer->FindItemByPos(item.wCellPos, XYD_FT_ONLYLOCK);
if (!pItem)
{
rfalse(4, 1, "ExchangeGoods.cpp - ExchangeCancel() - !pItem");
return;
}
MY_ASSERT(pItem);
pDestPlayer->LockItemCell(pItem->wCellPos, false);
}
// 清除当前的交易状态（包括了金钱的锁定）
memset((CExchangeGoods *)pSrcPlayer, 0, sizeof(CExchangeGoods));
memset((CExchangeGoods *)pDestPlayer, 0, sizeof(CExchangeGoods));
// 通知客户端交易被取消
SAExchangeOperationMsg opmsg;
opmsg.dwSrcGID = pSrcPlayer->GetGID();
opmsg.dwDestGID = pDestPlayer->GetGID();
opmsg.isSrc = isSrc;
opmsg.operation = SAExchangeOperationMsg::CANCEL;
g_StoreMessage(pSrcPlayer->m_ClientIndex, &opmsg, sizeof(SAExchangeOperationMsg));
g_StoreMessage(pDestPlayer->m_ClientIndex, &opmsg, sizeof(SAExchangeOperationMsg));
return;
}
/*****************************************************************************
*
* Class : NativeView
* Method : getNativeWindow
* Signature : ()J
* Description: returns the native systemw window handle of this object
*/
JNIEXPORT jlong JNICALL Java_NativeView_getNativeWindow
(JNIEnv * env, jobject obj_this)
{
jboolean result ;
jint lock ;
JAWT awt ;
JAWT_DrawingSurface* ds ;
JAWT_DrawingSurfaceInfo* dsi ;
JAWT_Win32DrawingSurfaceInfo* dsi_win ;
HDC hdc ;
HWND hWnd ;
LONG hFuncPtr;
/* Get the AWT */
awt.version = JAWT_VERSION_1_3;
result = JAWT_GetAWT(env, &awt);
MY_ASSERT(result!=JNI_FALSE,"wrong jawt version");
/* Get the drawing surface */
if ((ds = awt.GetDrawingSurface(env, obj_this)) == NULL)
return 0L;
/* Lock the drawing surface */
lock = ds->Lock(ds);
MY_ASSERT((lock & JAWT_LOCK_ERROR)==0,"can't lock the drawing surface");
/* Get the drawing surface info */
dsi = ds->GetDrawingSurfaceInfo(ds);
/* Get the platform-specific drawing info */
dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;
hdc = dsi_win->hdc;
hWnd = dsi_win->hwnd;
/* Free the drawing surface info */
ds->FreeDrawingSurfaceInfo(dsi);
/* Unlock the drawing surface */
ds->Unlock(ds);
/* Free the drawing surface */
awt.FreeDrawingSurface(ds);
/* Register own window procedure
Do it one times only! Otherwhise
multiple instances will be registered
and calls on such construct produce
a stack overflow.
*/
if (GetProp( hWnd, OLD_PROC_KEY )==0)
{
hFuncPtr = SetWindowLong( hWnd, GWL_WNDPROC, (DWORD)NativeViewWndProc );
SetProp( hWnd, OLD_PROC_KEY, (HANDLE)hFuncPtr );
}
return ((jlong)hWnd);
}
static void Test6()
{
printf("Test6...\n");
emThreadMutex c[5];
DiningPhilosopher * p[5];
char str[256],str2[256];
emUInt64 clk;
int i;
for (i=0; i<5; i++) p[i]=new DiningPhilosopher(c[i],c[(i+1)%5]);
clk=emGetClockMS();
str2[0]=0;
while (emGetClockMS()-clk<3000) {
PrintEvent.Receive();
strcpy(str,
" ? \n"
" - - \n"
"? ?\n"
" - - \n"
" ? - ? \n"
);
PrintDataMutex.Lock();
MY_ASSERT(!p[0]->IsEating() || !p[1]->IsEating());
MY_ASSERT(!p[1]->IsEating() || !p[2]->IsEating());
MY_ASSERT(!p[2]->IsEating() || !p[3]->IsEating());
MY_ASSERT(!p[3]->IsEating() || !p[4]->IsEating());
MY_ASSERT(!p[4]->IsEating() || !p[0]->IsEating());
if (p[0]->IsThinking()) str[04]='T';
if (p[1]->IsThinking()) str[28]='T';
if (p[2]->IsThinking()) str[47]='T';
if (p[3]->IsThinking()) str[41]='T';
if (p[4]->IsThinking()) str[20]='T';
if (p[0]->IsEating()) str[04]='E';
if (p[1]->IsEating()) str[28]='E';
if (p[2]->IsEating()) str[47]='E';
if (p[3]->IsEating()) str[41]='E';
if (p[4]->IsEating()) str[20]='E';
if (c[0].IsLocked()) str[12]=' ';
if (c[1].IsLocked()) str[16]=' ';
if (c[2].IsLocked()) str[37]=' ';
if (c[3].IsLocked()) str[44]=' ';
if (c[4].IsLocked()) str[31]=' ';
PrintDataMutex.Unlock();
if (strcmp(str,str2)!=0) {
strcpy(str2,str);
printf("\n\n%s",str);
}
}
for (i=0; i<5; i++) delete p[i];
}
/*****************************************************************************
*
* Class : NativeView
* Method : getNativeWindow
* Signature : ()J
* Description: returns the native systemw window handle of this object
*/
JNIEXPORT jlong JNICALL Java_embeddedobj_test_NativeView_getNativeWindow
(JNIEnv * env, jobject obj_this)
{
jboolean result ;
jint lock ;
JAWT awt ;
JAWT_DrawingSurface* ds ;
JAWT_DrawingSurfaceInfo* dsi ;
#ifdef WNT
JAWT_Win32DrawingSurfaceInfo* dsi_win ;
#else
// FIXME: Where is dsi_x11 defined?
// Added below because I'm guessing this test breaks
// JAWT_X11DrawingSurfaceInfo*dsi_x11 ;
#endif
jlong drawable;
/* Get the AWT */
awt.version = JAWT_VERSION_1_3;
result = JAWT_GetAWT(env, &awt);
MY_ASSERT(result!=JNI_FALSE,"wrong jawt version");
/* Get the drawing surface */
if ((ds = awt.GetDrawingSurface(env, obj_this)) == NULL)
return 0L;
/* Lock the drawing surface */
lock = ds->Lock(ds);
MY_ASSERT((lock & JAWT_LOCK_ERROR)==0,"can't lock the drawing surface");
/* Get the drawing surface info */
dsi = ds->GetDrawingSurfaceInfo(ds);
/* Get the platform-specific drawing info */
#ifdef WNT
dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;
drawable = (jlong)dsi_win->hwnd;
#else
dsi_x11 = (JAWT_X11DrawingSurfaceInfo*)dsi->platformInfo;
drawable = (jlong)dsi_x11->drawable;
#endif
/* Free the drawing surface info */
ds->FreeDrawingSurfaceInfo(dsi);
/* Unlock the drawing surface */
ds->Unlock(ds);
/* Free the drawing surface */
awt.FreeDrawingSurface(ds);
return drawable;
}
static void Test4()
{
printf("Test4...\n");
emThread t;
Int4=0;
Mutex4a.Lock();
t.Start(ThreadFunc4,NULL);
emSleepMS(100);
MY_ASSERT(Int4++==0);
Mutex4a.Unlock();
emSleepMS(100);
Mutex4a.Lock();
MY_ASSERT(Int4++==3);
emSleepMS(100);
MY_ASSERT(Int4++==4);
Mutex4a.Unlock();
Mutex4b.Lock();
MY_ASSERT(Int4++==7);
emSleepMS(500);
MY_ASSERT(Int4++==8);
Mutex4b.Unlock();
emSleepMS(100);
Mutex4c.Lock();
MY_ASSERT(Int4++==11);
MY_ASSERT(Mutex4b.Lock(0));
MY_ASSERT(t.WaitForTermination(1000)==true);
}
static int ThreadFunc4(void * arg)
{
Mutex4a.Lock();
MY_ASSERT(Int4++==1);
emSleepMS(200);
MY_ASSERT(Int4++==2);
Mutex4b.Lock();
Mutex4a.Unlock();
emSleepMS(100);
Mutex4a.Lock();
Mutex4a.Unlock();
MY_ASSERT(Int4++==5);
emSleepMS(100);
MY_ASSERT(Int4++==6);
Mutex4b.Unlock();
emSleepMS(100);
MY_ASSERT(!Mutex4b.LockReadOnly(100));
MY_ASSERT(Mutex4b.LockReadOnly(1000));
Mutex4c.Lock();
Mutex4b.UnlockReadOnly();
MY_ASSERT(Int4++==9);
emSleepMS(200);
MY_ASSERT(Int4++==10);
Mutex4c.Unlock();
return 0;
}
void test_cast_from_char() {
MY_ASSERT(myenum1::member2 == enum_cast<myenum1>("myenum1::member2"));
MY_ASSERT(myenum1::member2 == enum_cast<myenum1>("member2"));
MY_ASSERT(myenum2::member5 == enum_cast<myenum2>("myenum2::member5"));
MY_ASSERT(myenum2::member5 == enum_cast<myenum2>("member5"));
MY_ASSERT(myenum3::member8 == enum_cast<myenum3>("myenum3::member8"));
MY_ASSERT(myenum3::member8 == enum_cast<myenum3>("member8"));
MY_ASSERT(myenum4::member11 == enum_cast<myenum4>("myenum4::member11"));
MY_ASSERT(myenum4::member11 == enum_cast<myenum4>("member11"));
MY_ASSERT(myenum5::member13 == enum_cast<myenum5>("myenum5::member13"));
MY_ASSERT(myenum5::member13 == enum_cast<myenum5>("member13"));
std::cout << "test_cast_from_char() PASSED" << std::endl;
}
static void Test2()
{
printf("Test2...\n");
emThread t;
t.Start(ThreadFunc2a,(void*)"hello 2a");
MY_ASSERT(!t.WaitForTermination(1000));
MY_ASSERT(t.WaitForTermination(1000));
MY_ASSERT(t.GetExitStatus()==4711);
t.Start(ThreadFunc2b,(void*)&t);
MY_ASSERT(t.WaitForTermination(500));
MY_ASSERT(t.GetExitStatus()==-12343782);
}
bool HwAccelManager::SetAccelerationLevel(long ulMode)
{
if (!isEnabled_)
return false;
HKEY hkDevice;
DWORD dwAccLevel;
if (!OpenAccelerationLevel(&hkDevice, &dwAccLevel))
return false;
if ((long) dwAccLevel != ulMode)
{
if (ulMode != 0x0)
{
dwAccLevel = ulMode;
DWORD dwLength = sizeof DWORD;
LONG result = ::RegSetValueEx(hkDevice,
_T("Acceleration.Level"),
0,
REG_DWORD,
(LPBYTE) &dwAccLevel,
dwLength);
::RegCloseKey(hkDevice);
MY_ASSERT((result == ERROR_SUCCESS),
_T("Could not set video hardware acceleration level."));
}
else
{
// delete Acceleration.Level key
LONG result = ::RegDeleteValue(hkDevice, _T("Acceleration.Level"));
::RegCloseKey(hkDevice);
MY_ASSERT((result == ERROR_SUCCESS),
_T("Could not fully enable video hardware acceleration level."));
}
// Now tickle Windows to reload settings
DEVMODE devMode;
BOOL success = ::EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devMode);
MY_ASSERT((success == TRUE),
_T("Could not retrieve current video device settings."));
::ChangeDisplaySettings(&devMode, CDS_RESET);
}
else
{
::RegCloseKey(hkDevice);
}
return true;
}
void test_cast_to_char() {
MY_ASSERT(0 == strcmp("myenum1::member2", enum_cast(myenum1::member2)));
MY_ASSERT(0 == strcmp("myenum2::member5", enum_cast(myenum2::member5)));
MY_ASSERT(0 == strcmp("myenum3::member8", enum_cast(myenum3::member8)));
MY_ASSERT(0 == strcmp("myenum4::member11", enum_cast(myenum4::member11)));
MY_ASSERT(0 == strcmp("myenum5::member13", enum_cast(myenum5::member13)));
MY_ASSERT(0 == strcmp("member2", enum_cast(myenum1::member2, false)));
MY_ASSERT(0 == strcmp("member5", enum_cast(myenum2::member5, false)));
MY_ASSERT(0 == strcmp("member8", enum_cast(myenum3::member8, false)));
MY_ASSERT(0 == strcmp("member11", enum_cast(myenum4::member11, false)));
MY_ASSERT(0 == strcmp("member13", enum_cast(myenum5::member13, false)));
std::cout << "test_cast_to_char() PASSED" << std::endl;
}
void CExchangeGoods::TheEnd()
{
if (0 == m_dwOtherPlayerGID)
return;
CPlayer *pPlayer = static_cast<CPlayer *>(this);
if (!pPlayer)
return;
CPlayer *pSrcPlayer = 0;
CPlayer *pDestPlayer = 0;
bool isSrc = false;
// 如果对方是交易目标
if (m_dwOtherPlayerGID == m_dwDestPlayerGID)
{
isSrc = true;
pSrcPlayer = pPlayer;
pDestPlayer = (CPlayer *)GetPlayerByGID(m_dwDestPlayerGID)->DynamicCast(IID_PLAYER);
if (!pDestPlayer || !pDestPlayer->InExchange())
return;
if (!pDestPlayer->m_CurHp)
{
rfalse(4, 1, "ExchangeGoods.cpp - TheEnd() - !pDestPlayer->m_CurHp");
return;
}
MY_ASSERT(pDestPlayer->m_CurHp);
}
else if (m_dwOtherPlayerGID == m_dwSrcPlayerGID)
{
pDestPlayer = pPlayer;
pSrcPlayer = (CPlayer *)GetPlayerByGID(m_dwSrcPlayerGID)->DynamicCast(IID_PLAYER);
if (!pSrcPlayer || !pSrcPlayer->InExchange())
return;
if (!pDestPlayer->m_CurHp)
{
rfalse(4, 1, "ExchangeGoods.cpp - TheEnd() - !pSrcPlayer->m_CurHp");
return;
}
MY_ASSERT(pSrcPlayer->m_CurHp);
}
pSrcPlayer->ExchangeCancel(pDestPlayer, isSrc);
}
NativeEngine::NativeEngine(struct android_app *app) {
LOGD("NativeEngine: initializing.");
mApp = app;
mHasFocus = mIsVisible = mHasWindow = false;
mHasGLObjects = false;
mEglDisplay = EGL_NO_DISPLAY;
mEglSurface = EGL_NO_SURFACE;
mEglContext = EGL_NO_CONTEXT;
mEglConfig = 0;
mSurfWidth = mSurfHeight = 0;
mApiVersion = 0;
mJniEnv = NULL;
memset(&mState, 0, sizeof(mState));
mIsFirstFrame = true;
if (app->savedState != NULL) {
// we are starting with previously saved state -- restore it
mState = *(struct NativeEngineSavedState*) app->savedState;
}
// only one instance of NativeEngine may exist!
MY_ASSERT(_singleton == NULL);
_singleton = this;
VLOGD("NativeEngine: querying API level.");
LOGD("NativeEngine: API version %d.", mApiVersion);
}
void OurActivity_ResetEncouragementToasts(int score) {
struct JniSetup *setup = GetJNISetup();
jmethodID m_postResetEncouragementToasts = setup->env->GetMethodID(setup->clazz,
"postResetEncouragementToasts", "(I)V");
MY_ASSERT(m_postResetEncouragementToasts);
setup->env->CallVoidMethod(setup->thiz, m_postResetEncouragementToasts, score);
}
//------------------------------------------------------------------------------------------
void CPreviewerView::Render()
{
CGraphicDevice* pDevice = CApp::GetInstance()->GetGraphicDevice(); MY_ASSERT( pDevice );
// カメラ設定
CCameraController *pCameraController = dynamic_cast<CCameraController*>( m_pMouseHandler );
pDevice->SetCameraInfo( pCameraController->GetCameraInfo() );
// ライト設定
// 0 Fill
D3DXVECTOR3 vLightDir0( 1, -1, -1); D3DXVec3Normalize( &vLightDir0, &vLightDir0);
pDevice->SetDirLightDir( 0, vLightDir0.x, vLightDir0.y, vLightDir0.z );
pDevice->SetDirLightColor( 0, 1.0f, 1.0f, 1.0f );
// 1 Back
D3DXVECTOR3 vLightDir1( 0, 0, -1); D3DXVec3Normalize( &vLightDir1, &vLightDir1);
pDevice->SetDirLightDir( 1, vLightDir1.x, vLightDir1.y, vLightDir1.z );
pDevice->SetDirLightColor( 1, 0.0f, 0.0f, 0.0f );
// 2 Key
D3DXVECTOR3 vLightDir2( -1, -1, 0); D3DXVec3Normalize( &vLightDir2, &vLightDir2);
pDevice->SetDirLightDir( 2, vLightDir2.x, vLightDir2.y, vLightDir2.z );
pDevice->SetDirLightColor( 2, 0.0f, 0.0f, 0.0f );
// モデルをレンダリング
m_pModel->Render();
}
MlSlotStats MlSlotList::calculate_stats() {
MlSlotStats::l1_size_t l1_occ;
MlSlotStats::l2_size_t l2_occ;
size_t tot_l1 = 0, tot_l2 = 0;
for(uint32_t i=0; i<l1_len; ++i) {
l1_occ[i] = algo(count_if, l1_slots[i], not_empty);
tot_l1 += l1_occ[i];
}
for(uint32_t i=0; i<l2_len; ++i) {
l2_occ[i] = algo(count_if, l2_slots[i], not_empty);
tot_l2 += l2_occ[i];
}
double wasted_perc = 100. * (tot_fix_len - tot_l1 - tot_l2) / tot_fix_len;
MY_ASSERT(wasted_perc >= 0.0);
MlSlotStats stats = {
l1_occ,
l2_occ,
last_resort.size(),
calculate_compaction(),
wasted_perc,
};
return stats;
}
//return new pRoot
element* table_insert(element* pRoot, element* pBlock) {
element* pCur = pRoot;
if (element_size(pCur) == element_size(pBlock)) {
//pCur->pBlock->pChild
element_child(pBlock) = element_child(pCur);
element_child(pCur) = pBlock;
}
else if (element_size(pCur) > element_size(pBlock)) {
//pBlock
//pCur
element_sibling(pBlock) = pCur;
pCur = pBlock;
}
else {
//pCur
//pBlock
MY_ASSERT(element_size(pCur) < element_size(pBlock));
if (element_sibling(pCur) != NULL) {
element_sibling(pCur) = table_insert(element_sibling(pCur), pBlock);
}
else {
element_sibling(pCur) = pBlock;
}
}
return pCur;
};
void BuffManager::RemoveBuff(BuffModify *buff)
{
if (!buff)
{
rfalse(4,1,"BuffManager::RemoveBuff(BuffModify *buff)1");
return;
}
/*if (buff->m_ActedTimes == 1)
{
rfalse(4,1,"BuffManager::RemoveBuff(BuffModify *buff)2");
return;
}*/
MY_ASSERT(buff);
//MY_ASSERT(1 != buff->m_WillActTimes);
// 首先判断是否为永久Buff
if (0 == buff->m_WillActTimes)
{
// 如果为永久Buff，则跳过从事件管理器获取Buff
buff->OnCancel();
buff->SelfDestory();
}
else
buff->Interrupt();
return;
}
bool NativeEngine::InitContext() {
// need a display
MY_ASSERT(mEglDisplay != EGL_NO_DISPLAY);
EGLint attribList[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; // OpenGL 2.0
if (mEglContext != EGL_NO_CONTEXT) {
// nothing to do
LOGD("NativeEngine: no need to init context (already had one).");
return true;
}
LOGD("NativeEngine: initializing context.");
// create EGL context
mEglContext = eglCreateContext(mEglDisplay, mEglConfig, NULL, attribList);
if (mEglContext == EGL_NO_CONTEXT) {
LOGE("Failed to create EGL context, EGL error %d", eglGetError());
return false;
}
LOGD("NativeEngine: successfull initialized context.");
return true;
}
static void Test5()
{
printf("Test5...\n");
# define Test5_Threads 20
emThread t[Test5_Threads];
int i;
MaxReaders5=0;
for (i=0; i<Test5_Threads; i++) t[i].Start(ThreadFunc5,NULL);
emSleepMS(3000);
QuitEvent5.Send(Test5_Threads);
for (i=0; i<Test5_Threads; i++) t[i].WaitForTermination();
MY_ASSERT(Readers5==0);
MY_ASSERT(Writers5==0);
MY_ASSERT(MaxReaders5>1);
}
