void KillStats::action(const gcn::ActionEvent &event)
{
const std::string &eventId = event.getId();
if (eventId == "reset")
{
mKillCounter = 0;
mExpCounter = 0;
mLine3->setCaption(strprintf("1%% = %d exp, avg mob for 1%%: %s",
PlayerInfo::getAttribute(PlayerInfo::EXP_NEEDED) / 100, "?"));
// TRANSLATORS: kill stats window label
mLine4->setCaption(strprintf(_("Kills: %s, total exp: %s"), "?", "?"));
// TRANSLATORS: kill stats window label
mLine5->setCaption(strprintf(_("Avg Exp: %s"), "?"));
mLine6->setCaption(strprintf(
// TRANSLATORS: kill stats window label
_("No. of avg mob to next level: %s"), "?"));
resetTimes();
}
else if (eventId == "timer")
{
mKillTimer = 0;
mKillTCounter = 0;
mExpTCounter = 0;
mLine7->setCaption(strprintf(
// TRANSLATORS: kill stats window label
_("Kills/Min: %s, Exp/Min: %s"), "?", "?"));
resetTimes();
}
}
void MotionTracker::loop()
{
long currentTime = millis();
switch (state)
{
case INSIDE:
if (accelerometerOutside())
{
if (timeOutside <= 0) timeOutside = currentTime;
else if (currentTime - timeOutside > 500)
{
resetTimes();
display.ssd1306_command(SSD1306_DISPLAYOFF);
state = OUTSIDE;
}
}
else
{
if (timeInside <= 0) timeInside = currentTime;
else if (currentTime - timeInside > 2000)
{
Serial.println("Derp");
resetTimes();
display.dim(true);
state = INSIDE_TIMEOUT;
}
}
break;
case INSIDE_TIMEOUT:
if (accelerometerOutside())
{
resetTimes();
display.dim(false);
state = OUTSIDE;
}
break;
case OUTSIDE:
if (!accelerometerOutside())
{
if (timeInside <= 0) timeInside = currentTime;
else if (currentTime - timeInside > 500)
{
resetTimes();
display.ssd1306_command(SSD1306_DISPLAYON);
state = INSIDE_TIMEOUT;
}
}
break;
}
}
ConsoleOutput::ConsoleOutput(QWidget *parent, bool enabled)
:QTextEdit(parent)
,m_enabled(false)
,m_timerId(0)
,m_mode(CompileMode)
,m_nextMode(CompileMode)
,m_parseColors(true)
,m_parseVar(0)
,m_stdout_tie_stream(&m_stdout_tie_stream_buf)
{
setReadOnly(true);
setFont(QFont("Monospace"));
QPalette pal=palette();
pal.setColor(QPalette::Text,Qt::lightGray);
pal.setColor(QPalette::Base,Qt::black);
setPalette(pal);
enable(enabled);
resetTimes();
setUndoRedoEnabled(false);
setTextInteractionFlags(Qt::TextBrowserInteraction);
QAction* hideAction = new QAction("hide", this);
addAction(hideAction);
connect(hideAction, SIGNAL(triggered()), this, SLOT(hide()));
QAction* clearAction = new QAction("clear", this);
addAction(clearAction);
connect(clearAction, SIGNAL(triggered()), this, SLOT(clear()));
QAction* biggerAction = new QAction("bigger", this);
addAction(biggerAction);
biggerAction->setShortcut(Qt::CTRL + Qt::Key_Plus);
connect(biggerAction, SIGNAL(triggered()), this, SLOT(bigger()));
QAction* smallerAction = new QAction("smaller", this);
addAction(smallerAction);
smallerAction->setShortcut(Qt::CTRL + Qt::Key_Minus);
connect(smallerAction, SIGNAL(triggered()), this, SLOT(smaller()));
setContextMenuPolicy(Qt::ActionsContextMenu);
s_instance = this;
std::cout.tie(&m_stdout_tie_stream);
// std::cout.setf(std::ios::unitbuf);
}
ConsoleOutput::ConsoleOutput(bool enabled)
:QTextEdit()
,m_enabled(false)
,m_timerId(0)
,m_mode(CompileMode)
,m_nextMode(CompileMode)
,m_parseColors(true)
,m_parseVar(0)
,m_stdout_tie_stream(&m_stdout_tie_stream_buf)
{
setReadOnly(true);
setFont(QFont("Monospace"));
QPalette pal=palette();
pal.setColor(QPalette::Text,Qt::lightGray);
pal.setColor(QPalette::Base,Qt::black);
setPalette(pal);
enable(enabled);
resetTimes();
setUndoRedoEnabled(false);
setTextInteractionFlags(Qt::TextBrowserInteraction);
s_instance = this;
std::cout.tie(&m_stdout_tie_stream);
// std::cout.setf(std::ios::unitbuf);
}
void TestCase::doTests(dtNavMesh* navmesh, dtNavMeshQuery* navquery)
{
if (!navmesh || !navquery)
return;
resetTimes();
static const int MAX_POLYS = 256;
dtPolyRef polys[MAX_POLYS];
float straight[MAX_POLYS*3];
const float polyPickExt[3] = {2,4,2};
for (Test* iter = m_tests; iter; iter = iter->next)
{
delete [] iter->polys;
iter->polys = 0;
iter->npolys = 0;
delete [] iter->straight;
iter->straight = 0;
iter->nstraight = 0;
dtQueryFilter filter;
filter.setIncludeFlags(iter->includeFlags);
filter.setExcludeFlags(iter->excludeFlags);
// Find start points
TimeVal findNearestPolyStart = getPerfTime();
dtPolyRef startRef, endRef;
navquery->findNearestPoly(iter->spos, polyPickExt, &filter, &startRef, iter->nspos);
navquery->findNearestPoly(iter->epos, polyPickExt, &filter, &endRef, iter->nepos);
TimeVal findNearestPolyEnd = getPerfTime();
iter->findNearestPolyTime += getPerfTimeUsec(findNearestPolyEnd - findNearestPolyStart);
if (!startRef || ! endRef)
continue;
if (iter->type == TEST_PATHFIND)
{
// Find path
TimeVal findPathStart = getPerfTime();
navquery->findPath(startRef, endRef, iter->spos, iter->epos, &filter, polys, &iter->npolys, MAX_POLYS);
TimeVal findPathEnd = getPerfTime();
iter->findPathTime += getPerfTimeUsec(findPathEnd - findPathStart);
// Find straight path
if (iter->npolys)
{
TimeVal findStraightPathStart = getPerfTime();
navquery->findStraightPath(iter->spos, iter->epos, polys, iter->npolys,
straight, 0, 0, &iter->nstraight, MAX_POLYS);
TimeVal findStraightPathEnd = getPerfTime();
iter->findStraightPathTime += getPerfTimeUsec(findStraightPathEnd - findStraightPathStart);
}
// Copy results
if (iter->npolys)
{
iter->polys = new dtPolyRef[iter->npolys];
memcpy(iter->polys, polys, sizeof(dtPolyRef)*iter->npolys);
}
if (iter->nstraight)
{
iter->straight = new float[iter->nstraight*3];
memcpy(iter->straight, straight, sizeof(float)*3*iter->nstraight);
}
}
else if (iter->type == TEST_RAYCAST)
{
float t = 0;
float hitNormal[3], hitPos[3];
iter->straight = new float[2*3];
iter->nstraight = 2;
iter->straight[0] = iter->spos[0];
iter->straight[1] = iter->spos[1];
iter->straight[2] = iter->spos[2];
TimeVal findPathStart = getPerfTime();
navquery->raycast(startRef, iter->spos, iter->epos, &filter, &t, hitNormal, polys, &iter->npolys, MAX_POLYS);
TimeVal findPathEnd = getPerfTime();
iter->findPathTime += getPerfTimeUsec(findPathEnd - findPathStart);
if (t > 1)
{
// No hit
dtVcopy(hitPos, iter->epos);
}
else
{
// Hit
dtVlerp(hitPos, iter->spos, iter->epos, t);
}
// Adjust height.
if (iter->npolys > 0)
{
float h = 0;
navquery->getPolyHeight(polys[iter->npolys-1], hitPos, &h);
hitPos[1] = h;
}
dtVcopy(&iter->straight[3], hitPos);
if (iter->npolys)
{
iter->polys = new dtPolyRef[iter->npolys];
memcpy(iter->polys, polys, sizeof(dtPolyRef)*iter->npolys);
}
}
}
printf("Test Results:\n");
int n = 0;
for (Test* iter = m_tests; iter; iter = iter->next)
{
const int total = iter->findNearestPolyTime + iter->findPathTime + iter->findStraightPathTime;
printf(" - Path %02d: %.4f ms\n", n, (float)total/1000.0f);
printf(" - poly: %.4f ms\n", (float)iter->findNearestPolyTime/1000.0f);
printf(" - path: %.4f ms\n", (float)iter->findPathTime/1000.0f);
printf(" - straight: %.4f ms\n", (float)iter->findStraightPathTime/1000.0f);
n++;
}
}
int Control( demux_t *p_demux_filter, int i_query, va_list args )
{
if( !m_enabled && i_query != DEMUX_FILTER_ENABLE )
return demux_vaControl( p_demux_filter->p_next, i_query, args );
switch (i_query)
{
case DEMUX_GET_POSITION:
{
double pos = getPosition();
if( pos >= 0 )
{
*va_arg( args, double * ) = pos;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
}
case DEMUX_GET_TIME:
{
vlc_tick_t time = getTime();
if( time >= 0 )
{
*va_arg(args, vlc_tick_t *) = time;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
}
case DEMUX_GET_LENGTH:
{
int ret;
va_list ap;
va_copy( ap, args );
ret = demux_vaControl( p_demux_filter->p_next, i_query, args );
if( ret == VLC_SUCCESS )
m_length = *va_arg( ap, vlc_tick_t * );
va_end( ap );
return ret;
}
case DEMUX_CAN_SEEK:
{
int ret;
va_list ap;
va_copy( ap, args );
ret = demux_vaControl( p_demux_filter->p_next, i_query, args );
if( ret == VLC_SUCCESS )
m_can_seek = *va_arg( ap, bool* );
va_end( ap );
return ret;
}
case DEMUX_SET_POSITION:
{
double pos = va_arg( args, double );
/* Force unprecise seek */
int ret = demux_Control( p_demux->p_next, DEMUX_SET_POSITION, pos, false );
if( ret != VLC_SUCCESS )
return ret;
resetTimes();
resetDemuxEof();
return VLC_SUCCESS;
}
case DEMUX_SET_TIME:
{
vlc_tick_t time = va_arg( args, vlc_tick_t );
/* Force unprecise seek */
int ret = demux_Control( p_demux->p_next, DEMUX_SET_TIME, time, false );
if( ret != VLC_SUCCESS )
return ret;
resetTimes();
resetDemuxEof();
return VLC_SUCCESS;
}
case DEMUX_SET_PAUSE_STATE:
{
va_list ap;
va_copy( ap, args );
int paused = va_arg( ap, int );
va_end( ap );
setPauseState( paused != 0 );
break;
}
case DEMUX_SET_ES:
/* Seek back to the last known pos when changing tracks. This will
* flush sout streams, make sout del/add called right away and
* clear CC buffers. */
seekBack(m_last_time, m_last_pos);
resetTimes();
resetDemuxEof();
break;
case DEMUX_FILTER_ENABLE:
p_renderer = static_cast<chromecast_common *>(
var_InheritAddress( p_demux, CC_SHARED_VAR_NAME ) );
assert(p_renderer != NULL);
m_enabled = true;
init();
return VLC_SUCCESS;
case DEMUX_FILTER_DISABLE:
deinit();
/* Seek back to last known position. Indeed we don't want to resume
* from the input position that can be more than 1 minutes forward
* (depending on the CC buffering policy). */
seekBack(m_last_time, m_last_pos);
m_enabled = false;
p_renderer = NULL;
return VLC_SUCCESS;
}
return demux_vaControl( p_demux_filter->p_next, i_query, args );
}
void TestCase::doTests(dtNavMesh* navmesh, dtNavMeshQuery* navquery)
{
if (!navmesh || !navquery)
return;
resetTimes();
static const int MAX_POLYS = 256;
dtPolyRef polys[MAX_POLYS];
float straight[MAX_POLYS*3];
const float polyPickExt[3] = {2,4,2};
for (Test* iter = m_tests; iter; iter = iter->next)
{
delete [] iter->polys;
iter->polys = 0;
iter->npolys = 0;
delete [] iter->straight;
iter->straight = 0;
iter->nstraight = 0;
dtQueryFilter filter;
filter.setIncludeFlags((unsigned short)iter->includeFlags);
filter.setExcludeFlags((unsigned short)iter->excludeFlags);
// Find start points
TimeVal findNearestPolyStart = getPerfTime();
dtPolyRef startRef, endRef;
navquery->findNearestPoly(iter->spos, polyPickExt, &filter, &startRef, 0);
navquery->findNearestPoly(iter->epos, polyPickExt, &filter, &endRef, 0);
TimeVal findNearestPolyEnd = getPerfTime();
iter->findNearestPolyTime += getPerfDeltaTimeUsec(findNearestPolyStart, findNearestPolyEnd);
if (!startRef || ! endRef)
continue;
// Find path
TimeVal findPathStart = getPerfTime();
navquery->findPath(startRef, endRef, iter->spos, iter->epos, &filter, polys, &iter->npolys, MAX_POLYS);
TimeVal findPathEnd = getPerfTime();
iter->findPathTime += getPerfDeltaTimeUsec(findPathStart, findPathEnd);
// Find straight path
if (iter->npolys)
{
TimeVal findStraightPathStart = getPerfTime();
navquery->findStraightPath(iter->spos, iter->epos, polys, iter->npolys,
straight, 0, 0, &iter->nstraight, MAX_POLYS);
TimeVal findStraightPathEnd = getPerfTime();
iter->findStraightPathTime += getPerfDeltaTimeUsec(findStraightPathStart, findStraightPathEnd);
}
// Copy results
if (iter->npolys)
{
iter->polys = new dtPolyRef[iter->npolys];
memcpy(iter->polys, polys, sizeof(dtPolyRef)*iter->npolys);
}
if (iter->nstraight)
{
iter->straight = new float[iter->nstraight*3];
memcpy(iter->straight, straight, sizeof(float)*3*iter->nstraight);
}
}
printf("Test Results:\n");
int n = 0;
for (Test* iter = m_tests; iter; iter = iter->next)
{
const int total = iter->findNearestPolyTime + iter->findPathTime + iter->findStraightPathTime;
printf(" - Path %02d: %.4f ms\n", n, (float)total/1000.0f);
printf(" - poly: %.4f ms\n", (float)iter->findNearestPolyTime/1000.0f);
printf(" - path: %.4f ms\n", (float)iter->findPathTime/1000.0f);
printf(" - straight: %.4f ms\n", (float)iter->findStraightPathTime/1000.0f);
n++;
}
}
void TestCase::doTests(dtNavMesh* navmesh)
{
if (!navmesh)
return;
resetTimes();
static const int MAX_POLYS = 256;
dtPolyRef polys[MAX_POLYS];
float straight[MAX_POLYS*3];
const float polyPickExt[3] = {2,4,2};
for (Test* iter = m_tests; iter; iter = iter->next)
{
delete [] iter->polys;
iter->polys = 0;
iter->npolys = 0;
delete [] iter->straight;
iter->straight = 0;
iter->nstraight = 0;
dtQueryFilter filter;
filter.includeFlags = (unsigned short)iter->includeFlags;
filter.excludeFlags = (unsigned short)iter->excludeFlags;
// Find start points
rcTimeVal findNearestPolyStart = rcGetPerformanceTimer();
dtPolyRef startRef = navmesh->findNearestPoly(iter->spos, polyPickExt, &filter, 0);
dtPolyRef endRef = navmesh->findNearestPoly(iter->epos, polyPickExt, &filter, 0);
rcTimeVal findNearestPolyEnd = rcGetPerformanceTimer();
iter->findNearestPolyTime += rcGetDeltaTimeUsec(findNearestPolyStart, findNearestPolyEnd);
if (!startRef || ! endRef)
continue;
// Find path
rcTimeVal findPathStart = rcGetPerformanceTimer();
iter->npolys = navmesh->findPath(startRef, endRef, iter->spos, iter->epos, &filter, polys, MAX_POLYS);
rcTimeVal findPathEnd = rcGetPerformanceTimer();
iter->findPathTime += rcGetDeltaTimeUsec(findPathStart, findPathEnd);
// Find straight path
if (iter->npolys)
{
rcTimeVal findStraightPathStart = rcGetPerformanceTimer();
iter->nstraight = navmesh->findStraightPath(iter->spos, iter->epos, polys, iter->npolys,
straight, 0, 0, MAX_POLYS);
rcTimeVal findStraightPathEnd = rcGetPerformanceTimer();
iter->findStraightPathTime += rcGetDeltaTimeUsec(findStraightPathStart, findStraightPathEnd);
}
// Copy results
if (iter->npolys)
{
iter->polys = new dtPolyRef[iter->npolys];
memcpy(iter->polys, polys, sizeof(dtPolyRef)*iter->npolys);
}
if (iter->nstraight)
{
iter->straight = new float[iter->nstraight*3];
memcpy(iter->straight, straight, sizeof(float)*3*iter->nstraight);
}
}
}
void CPage::resetPage()
{
Trace("resetPage()", "", 0);
// this should be called between 'top level' pages to reset the counts etc.
// if we need to reset the cookies then do so, else they will be preserved from the previous run
if (getResetCookies())
{
#ifdef SC_NON_WEBKIT
{ // scope for lock
Mutex::Lock lock(sm_cookieListLock);
while (sm_cookieList.size() > 0)
{
CCookie* pCookie = sm_cookieList.front();
// remove it from the list...
sm_cookieList.pop_front();
delete pCookie;
pCookie = NULL;
}
}
Trace("ResettingCookies - After", "", 0);
#else // SC_NON_WEBKIT
CookieHandler* cookieHandler = CookieHandler::instance();
return cookieHandler->deleteCookies();
#endif
}
if (getResetCache())
{
Trace("ResettingCache", "", 0);
{ // scope for lock
Mutex::Lock lock(sm_urlListLock);
while(m_totalUrlList.size() > 0)
{
m_totalUrlList.pop_front();
}
while(m_urlList.size() > 0)
{
m_urlList.pop_front();
}
}
}
// 3.1.2
resetTimes();
sm_componentNo = 0;
sm_totalBytes = 0;
sm_totalBytesSoFar = 0;
sm_overallResultCode = SC_HEADER_RESULT_SUCCESS;
// reset the rude word check
sm_ContentErrorFound = false;
sm_SiteConErrorFound = false;
/*
// delete all of the components
{ // scope for lock
Mutex::Lock lock(CWebPage::Instance()->sm_resultListLock);
while (CWebPage::Instance()->sm_resultList.size() > 0)
{
CResultDetail* pResultDetail = CWebPage::Instance()->sm_resultList.front();
// remove it from the list...
CWebPage::Instance()->sm_resultList.pop_front();
delete pResultDetail;
pResultDetail = NULL;
}
}
*/
}
