__declspec(dllexport) int DllRegisterServerEx(LPCSTR fileName)
{
VS("DllRegisterServerEx from thread %x", GetCurrentThreadId());
if (gPythoncom == 0)
startUp();
return Pyc_DllRegisterServerEx(fileName);
}
Boolean FreducedFoldNode::walk(void){
switch(entryPoint){
case firstVertex:
if(v==ZERO)nodeErr(4);
if(v->Qideal())nodeErr(11);
startUp();
foldThisVertex(v->bv);
entryPoint=nextVertex;
//control flows directly to nextVertex
case nextVertex:{
// if we find a vertex that isn't dead, we
// fold it. It is the responsibility of the
// folding routine to set the vertex ID to IDnotInStack
// when it is done.
Ptr DEREF;
GLref ref;
while(TRUE){
childVertices->Pop(ref);
if(isNull(ref)){
return finish();
}
v->bv=ref;
if(!v->isDead()) break;
}
entryPoint=firstVertex;
func=FGLwalkNode::vertexFunc;
return TRUE;
}
default: nodeErr(6);
}
nodeErr(8);
}
void snake::getInput() {
//Checking if key is pressed
if (_kbhit()) {
//Checking which character is pressed
switch (_getch())
{
case 'a':
direction = gameInput::LEFT; // 'a' will be left
break;
case 'd':
direction = gameInput::RIGHT; // 'd' will be right
break;
case 'w':
direction = gameInput::UP; // 'w' will be up
break;
case 's':
direction = gameInput::DOWN; // 's' will be down
break;
case 'x':
startUp(); // 'x' will exit the game
break;
default:
break;
}
}
}
Boolean FrTreeNode::walk(void){
switch(entryPoint){
case firstVertex:
if(v==ZERO)nodeErr(4);
if(v->Qideal())nodeErr(11);
startUp();
virginVertex(v->bv);
entryPoint=nextVertex;
case nextVertex:
return(processVertex());
case firstEdge:
// Create the first admissible edge, if it exists.
// if there is no admissible edge, control flows to nextVertex
v->e=0;
entryPoint=nextEdge;
// control flows to next case
case nextEdge:
if(((FrTree*)v)->eNext()){
v->V();
virginVertex(v->cv);
return(TRUE);
}
else{
entryPoint=nextVertex;
return(TRUE);
}
default: nodeErr(6);
}
nodeErr(8);
}
int main(void)
{
init();
startUp();
for (int i = 1; i < 4; i++) LEEnabel(i);
while (1)
{
fireMode = getFireMode();
newMagSize = getMag(); //save the Mag size
if(newMagSize == -1)
{
newMag = 0; //Mag-slot empty
ammoCounter = -1;
}
if(((newMag == 0) & !(newMagSize == -1))) //Mag-slot not empty anymore
{
ammoCounter = newMagSize;
newMag = 1;
}
if(adcOn == 0) display(ammoCounter);
if(adcOn == 1)
{
volt |= (ADCL);
volt |= (ADCH << 8);
volt = volt *15;
volt = volt /1023;
display(volt);
}
displaySpeed(speed, motorOn);
setSpeed(speed, motorOn);
}
}
STDAPI DllUnregisterServer()
{
int rc, pyrc;
if (gPythoncom == 0)
startUp();
PI_PyEval_AcquireThread(thisthread);
rc = callSimpleEntryPoint("DllUnregisterServer", &pyrc);
PI_PyEval_ReleaseThread(thisthread);
return rc==0 ? pyrc : SELFREG_E_CLASS;
}
void CClientRegister::setRhoconnectCredentials(const String& user, const String& pass, const String& session)
{
LOG(INFO) + "New Sync credentials - user: "******", sess: " + session;
setState(stRegister);
notifyLoggedIn(user,pass,session);
startUp();
}
/**
* Main.
*
* Initialises SDL and launches game.
*/
int main(int argc, char *argv[]) {
int ret;
// Early platform init
#ifdef PSP
pspDebugScreenInit();
atexit(sceKernelExitGame);
sceIoChdir("ms0:/PSP/GAME/OpenJazz");
#elif defined(WII)
fatInitDefault();
Wii_SetConsole();
#endif
// Initialise SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK) < 0) {
logError("Could not start SDL", SDL_GetError());
return -1;
}
// Load configuration and establish a window
try {
startUp(argc, argv);
} catch (int e) {
SDL_Quit();
return -1;
}
// Play the opening cutscene, run the main menu, etc.
ret = play();
// Save configuration and shut down
shutDown();
SDL_Quit();
return ret;
}
//__declspec(dllexport) int __stdcall DllGetClassObject(void *rclsid, void *riid, void *ppv)
HRESULT __stdcall DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
{
HRESULT rc;
VS("DllGetClassObject from thread %x", GetCurrentThreadId());
if (gPythoncom == 0)
startUp();
rc = Pyc_DllGetClassObject(rclsid, riid, ppv);
VS("DllGetClassObject set %x and returned %x", *ppv, rc);
return rc;
}
void CClientRegister::setDevicehPin(const String& pin)
{
m_strDevicePin = pin;
if (pin.length() > 0)
{
startUp();
} else
{
doStop();
}
}
void CWsShellLogon::ConstructL(RFs &)
{
CActiveScheduler::Add(this);
TPtrC shellCmd;
_LIT(KWSERVIniFileVarShellCmd,"SHELLCMD");
WsIniFile->FindVar(KWSERVIniFileVarShellCmd,shellCmd);
_LIT(KWSERVShellName,"SHELL");
TPtrC startUp(KWSERVShellName);
_LIT(KWSERVIniFileVarStartUp,"STARTUP");
WsIniFile->FindVar(KWSERVIniFileVarStartUp,startUp);
TParse fileName;
_LIT(KWSERVArmShellLocationPattern,"Z:\\sys\\bin\\.EXE");
User::LeaveIfError(fileName.SetNoWild(startUp,&KWSERVArmShellLocationPattern,NULL));
#if defined(__WINS__)
TInt err=iShellProcess.Create(fileName.FullName(),shellCmd);
if (err == KErrNone)
{
Request();
iShellProcess.Resume();
}
else
{
// Try loading the matching DLL name instead?
_LIT(KWSERVShellExtension,"Z:.DLL");
User::LeaveIfError(fileName.Set(KWSERVShellExtension,&startUp,NULL));
User::LeaveIfError(iLib.Load(fileName.FullName()));
ShellEntryPoint libFunc=(ShellEntryPoint)iLib.Lookup(1);
if (!libFunc)
User::Leave(KErrGeneral);
TBuf<256> name;
TInt num=0;
TInt ret=KErrNone;
do
{
_LIT(KWSERVWinsShellInstanceName,"Shell%d");
name.Format(KWSERVWinsShellInstanceName,num++);
ret=iShellThread.Create(name,libFunc,KDefaultStackSize,&shellCmd,&iLib,NULL,KHeapSize,KMaxHeapSize,EOwnerProcess);
} while(ret==KErrAlreadyExists);
User::LeaveIfError(ret);
Request();
iShellThread.Resume();
}
#else // not __WINS__
User::LeaveIfError(iShell.Create(fileName.FullName(),shellCmd));
Request();
iShell.Resume();
#endif
return;
}
void CClientRegister::dropRhoconnectCredentials(const String& session,const String& clientID)
{
LOG(INFO) + "Dropping credentials - sess: " + session;
setState(stUnregister);
m_unregisterSession = session;
m_unregisterClientID = clientID;
notifyLoggedOut(session);
startUp();
}
void game::play (
) {
startUp ();
while (m_gameaction != gameaction::Exit) {
m_rw.clear (sf::Color::Green);
prepareData ();
prepareScreenElements ();
draw (m_ses, m_rw);
m_rw.display ();
handleEvents ();
}
shutDown ();
}
//__declspec(dllexport) int __stdcall DllCanUnloadNow(void)
//__declspec(dllexport)
//STDAPI
HRESULT __stdcall DllCanUnloadNow(void)
{
HRESULT rc;
VS("DllCanUnloadNow from thread %x", GetCurrentThreadId());
if (gPythoncom == 0)
startUp();
rc = Pyc_DllCanUnloadNow();
VS("DllCanUnloadNow returns %x", rc);
//if (rc == S_OK)
// PyCom_CoUninitialize();
return rc;
}
//--------------------------------------------------------------------------------------------------------
HFragmentVector ImplFragmentor::fragment(
HAlignment & ali,
const HAlignandum & row,
const HAlignandum & col)
{
startUp(ali, row, col );
performFragmentation( ali, row, col );
cleanUp( ali, row, col );
return mFragments;
}
Q_DECL_EXPORT Controller::Controller(int argc, char *argv[], QObject *parent) :
QObject(parent)
{
//qInstallMessageHandler(customMessageHandler);
app = new QApplication(argc, argv);
qmlviewer = new QQuickView();
setScreenControllers();
setQmlProperties();
startUp();
setMainWindow();
qmlRegisterType<FileIO, 1>("FileIO", 1, 0, "FileIO");
screenSettings->setAudioDevices(settings->m_inputDevice.m_name, settings->m_outputDevice.m_name);
}
// timer callback
int
EventHandler::handle_timeout(const ACE_Time_Value &, const void *arg)
{
switch ((const int)arg) {
case STARTUP:
startUp();
break;
case WATCHDOG:
watchdogCancel();
break;
default:
throw Miro::Exception("mcpEventHandler: Unknown timeout type.");
}
return 0;
}
bool ExtraRfbServers::reload(bool asService, RfbClientManager *mgr)
{
Log::detail(_T("Considering to reload extra RFB servers"));
Conf newConf;
getConfiguration(&newConf);
bool noConfigChanges = newConf.equals(&m_effectiveConf);
bool enoughServers = (newConf.extraPorts.count() == m_servers.size());
Log::detail(_T("Same Extra Ports configuration = %d, enough servers = %d"),
(int)noConfigChanges, (int)enoughServers);
if (noConfigChanges && enoughServers) {
return true;
}
Log::message(_T("Need to reconfigure extra RFB servers"));
shutDown();
return startUp(asService, mgr);
}
void TestSuite::run(TestOutput& output)
{
mOutput = &output;
startUp();
for (auto& testEntry : mTests)
{
mActiveTestName = testEntry.name;
(this->*(testEntry.test))();
}
for (auto& suite : mSuites)
{
suite->run(output);
}
shutDown();
}
ManagerGui::ManagerGui(QWidget *parent) :
QWidget(parent),
ui(new Ui::ManagerGui)
{
ui->setupUi(this);
//Tables init:
//Those lines adapt the vertical headers within the content leaving users resize capabilities.
ui->sentTable->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
ui->notSentTable->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
//Window init:
this->centerWindow();
setWindowTitle(tr("OpenGooDebugSenderTool Manager"));
setWindowIcon(QIcon(":/res/images/res/icon.png"));
startUp();
//TODO: Check for new updates downloading the xml file with solved uuid.
}
void MainWindow::verifyCredentialsFinished(const QTweetUser& userinfo)
{
qDebug() << "Verify Credential succesfull";
QTweetAccountVerifyCredentials *tweetVerifyCredentials = qobject_cast<QTweetAccountVerifyCredentials*>(sender());
if (tweetVerifyCredentials) {
QSettings settings(QSettings::IniFormat, QSettings::UserScope, "QTwitdget", "QTwitdget");
settings.setValue("oauth_token", m_oauthTwitter->oauthToken());
settings.setValue("oauth_token_secret", m_oauthTwitter->oauthTokenSecret());
settings.setValue("user_id", userinfo.id());
settings.setValue("user_screenname", userinfo.screenName());
m_userId = userinfo.id();
m_userScreenName = userinfo.screenName();
emit userScreenNameChanged();
tweetVerifyCredentials->deleteLater();
startUp();
}
}
bool ExtraRfbServers::reload(bool asService, RfbClientManager *mgr)
{
m_log->detail(_T("Considering to reload extra RFB servers"));
Conf newConf;
getConfiguration(&newConf);
bool noConfigChanges = newConf.equals(&m_effectiveConf);
bool enoughServers = (newConf.extraPorts.count() == m_servers.size());
m_log->detail(_T("Same Extra Ports configuration = %d, enough servers = %d"),
(int)noConfigChanges, (int)enoughServers);
if (noConfigChanges && enoughServers) {
return true; // no work needed, no errors encountered
}
// Either configuration was actually changed, or our number of actually
// running servers does not match the configuration. In either case,
// restart the servers.
m_log->message(_T("Need to reconfigure extra RFB servers"));
shutDown();
return startUp(asService, mgr);
}
int main() {
//Call start up function
startUp();
//Create image processor
//imageProcessor processor = imageProcessor();
//Init the processing of images
//processor.init();
//Create solver and cube objects
rCube rcube1 = rCube();
solver solver1 = solver();
rcube1.printCube();
//Apply random solver to the cube
solver1.randomSolver(rcube1);
renderCube(rcube1);
return 0;
}
int main()
{
if(!startUp())
{
std::cout << "\n\tGame failed to start!\n\n";
}
else
{
bool quit = false;
SDL_Event userEvent;
// initialize character EDIT: as this exists now, it's just a test rendering.
character sophia;
sophia.setTexurePath("./rsc/img/character/SophiaBig.png");
sophia.load_texture(gScreen, sophia.getTexturePath());
while(!quit)
{
while(SDL_PollEvent(&userEvent) != 0)
{
if(userEvent.type == SDL_QUIT)
{
quit = true;
}
}
SDL_RenderClear(gScreen);
sophia.draw(gScreen); // This is where we would call the getScene() function *Ref: TODO #2*
SDL_RenderPresent(gScreen);
}
}
close();
return 0;
}
//------------------------------------------------------------------------------------------------------------------------------
void ImplTreetorDistance::calculateTree(
HTree & tree,
const HMultipleAlignment & mali ) const
{
debug_func_cerr( 5 );
startUp( tree, mali );
DistanceMatrixSize swap_temp; // for swapping indices
#define SWAP(x,y) { swap_temp = x; x = y; y = swap_temp; }
//------------------------------------------------------------------------------------------
// start up
DistanceMatrixSize width = mWorkMatrix->getWidth();
DistanceMatrixSize i;
/* in this algorithm I assume that the matrix I use is only a half-matrix using the lower diagonal */
tree->setNumLeaves( width ); // allocate memory for tree
mIndices = new Node[width]; /* allocate array to keep track of indices */
for (i = 0; i < width; i++) mIndices[i] = i;
//----------------------------------------------------------------------------------------------------
// Perform hierarchical clustering
DistanceMatrixSize last_row = width - 1;
/* shrink distance matrix, until it contains only a single cluster */
while (last_row > 0)
{
debug_cerr( 6, "Last row " << last_row );
debug_cerr( 6, "Work matrix " << endl << *mWorkMatrix );
// find minimum distance in matrix
/*
-
--
---
----
-x---
------
-------
--------
*/
calculateMinimumDistance();
DistanceMatrixSize min_row = mMinimumCoord.row;
DistanceMatrixSize min_col = mMinimumCoord.col;
debug_cerr( 5, "Joining nodes -> "
<< "minimum distance :" << mMinimumValue << " "
<< "node 1: " << mIndices[min_row] << " (" << min_row << ") "
<< "node 2: " << mIndices[min_col] << " (" << min_col << ") " );
//------------------------------------------------------------------------------------------------------
// move rows around, so that the last two joined cluster are in the two last rows
/*
- -
y- --
-y- ---
-y-- -> ----
xOxx- -----
-y--x- ------
-y--x-- xxxxxxx
-y--x--- yyyyyyyy
*/
DistanceMatrixSize second_row = last_row - 1; // second to last row
// exchange row with last row
mWorkMatrix->swap( min_row, last_row);
SWAP( mIndices[min_row], mIndices[last_row]);
swapHelpers( min_row, last_row);
// exchange col with second to last row
mWorkMatrix->swap( min_col, second_row);
SWAP( mIndices[min_col], mIndices[second_row]);
swapHelpers( min_col, second_row);
//------------------------------------------------------------------------------------------------------
// join the two nodes in the tree giving the correct edge weights
Node new_node = joinNodes( tree, second_row, last_row );
debug_cerr( 6, "-> new node " << new_node );
//------------------------------------------------------------------------------------------------------
// calculate distance to new cluster and put them in second to last row
updateDistanceMatrix( tree, second_row, last_row);
/* delete last row, update mIndices, so that the last row now
contains the number of the new cluster id */
/*
- -
-- --
--- ---
---- -> ----
----- -----
------ ------
xxxxxxx xxxxxxx
yyyyyyyy
*/
mWorkMatrix->shrink();
mIndices[last_row - 1] = new_node;
last_row = mWorkMatrix->getWidth() - 1;
}
delete [] mIndices;
cleanUp(); // cleans up mWorkMatrix
}
void SCollision::update(Map * world, float frameTime)
{
EntityManager * entM = world->getEntityManager();
// if entity manager has changed, ( happens when switching worlds ), cache new entity manager's entities who have hitboxes
if( this->entM != entM )
startUp( entM );
auto deletedlist = entM->getDeletedEntities();
auto newlist = entM->getNewEntities();
PPosition * pos1, * pos2;
PBoundingBox * hitbox1, * hitbox2;
PImage * img1, * img2;
// query entity manager for newly created entities and
// update system's vectors with new entities if new entities exist
acknowledgeInserts( newlist, entM );
for(size_t cache_index = 0; cache_index < pboxes.size(); cache_index++)
{
pos1 = pposes[cache_index];
hitbox1 = pboxes[cache_index];
img1 = images[cache_index];
// clear this entity of the previous pass's colliding entities.
if ( cache_index == 0 )
hitbox1->collidingEntities.clear();
// if this entity was marked for deletion...
if( removeDelEnt( deletedlist, hitbox1->entity_id, cache_index ) )
{
// continue on to next entity
cache_index--;
continue;
}
for( size_t cache_index_inner = cache_index+1; cache_index_inner < pboxes.size(); cache_index_inner++ )
{
pos2 = pposes[cache_index_inner];
hitbox2 = pboxes[cache_index_inner];
img2 = images[cache_index_inner];
if ( cache_index == 0 )
hitbox2->collidingEntities.clear();
// if this entity was marked for deletion...
if( removeDelEnt( deletedlist, hitbox2->entity_id, cache_index_inner ) )
{
// continue on to next entity
cache_index_inner--;
continue;
}
if(hitbox1->active && hitbox2->active)
{
if(collisionOccurring(entM, pos1, hitbox1, pos2, hitbox2))
{
hitbox1->collidingEntities.push_back(hitbox2->entity_id);
hitbox2->collidingEntities.push_back(hitbox1->entity_id);
// notify scripts of collision event
LuaDoa::fireEventMulti(ON_COLLIDE, hitbox1->entity_id, hitbox2->entity_id);
LuaDoa::fireEventMulti(ON_COLLIDE, hitbox2->entity_id, hitbox1->entity_id);
}
}
}
}
// acknowledge the deletions so that the entity manager may remove marked entities from store
for(auto it = deletedlist.begin(); it != deletedlist.end(); it++)
{
if(!entM->acknowledgedDelete[this->sys_id][(*it)])
entM->acknowledgeDelete(this->sys_id, (*it));
}
}
__declspec(dllexport) int DllUnregisterServerEx(LPCSTR fileName)
{
if (gPythoncom == 0)
startUp();
return Pyc_DllUnregisterServerEx(fileName);
}
Boolean FTTdriverNode::walk(void){
// the following code is identical to that of FGLwalkNode::walk().
// We need to repeat it here so that FTTdriverNode overriding
// subroutines virginVertex and processEdge will be called
//
// Is there a more elegant solution that doesn't require
// code replication?
switch(entryPoint){
case firstVertex:
if(v==ZERO)nodeErr(4);
if(v->Qideal())nodeErr(11);
// OUTPUT DISPLAY
//@rn tout <= "*** pass " <= pTree->passNumber <=" ***" <= "\n";
//@rn ask me if I care
// END OUTPUT DISPLAY
startUp();
virginVertex(v->bv);
entryPoint=nextVertex;
case nextVertex:
return(processVertex());
case firstEdge:{
// Process the first edge, if there is one.
// if there is no defined edge, control flows to GLnextVertex
Ptr DEREF=v&v->bv;
GLref startRef;
v->xGetPacketRef(startRef,GLr,DEREF);
v-v->bv;
if(isNull(startRef)){
entryPoint=nextVertex; // no real link
return(TRUE);
}
// start search for first edge at the very beginning
GLref entryPacketRef;
v->xsetToFirstPacket(entryPacketRef,startRef);
if(itsStepper->firstEdge(entryPacketRef)){
// first edge detected
GLref ref;
v->xEdgeEntryToOwner(ref,itsStepper->refDatum);
v->cv=ref;
entryPoint=nextEdge;
return(processEdge());
}
else{
// real link has no edges
entryPoint=nextVertex;
return(TRUE);
}
}
case nextEdge:{
if(itsStepper->nextEdge()){
// next edge detected
GLref ref;
v->xEdgeEntryToOwner(ref,itsStepper->refDatum);
v->cv=ref;
entryPoint=nextEdge;
return(processEdge());
}
else{
// real link has no more edges
entryPoint=nextVertex;
return(TRUE);
}
}
default: nodeErr(6);
}
nodeErr(8);
}
Boolean FcloneNode::walk(void){
switch(entryPoint){
case firstVertex:
if(v==ZERO)nodeErr(4);
if(v->Qideal())nodeErr(11);
startUp();
virginCloneVertex(v->bv,vClone->bv);
entryPoint=nextVertex;
//control flows directly to GLrun
case nextVertex:
return(processVertex());
case firstEdge:{
// Process the first edge, if there is one.
// if there is no defined edge, control flows to GLnextVertex
Ptr DEREF=v&v->bv;
GLref startRef;
v->xGetPacketRef(startRef,GLr,DEREF);
v-v->bv;
if(isNull(startRef)){
entryPoint=nextVertex; // no real link
return(TRUE);
}
// start search for first edge at the very beginning
GLref entryPacketRef;
v->xsetToFirstPacket(entryPacketRef,startRef);
if(itsStepper->firstEdge(entryPacketRef)){
// first edge detected
GLref ref;
v->xEdgeEntryToOwner(ref,itsStepper->refDatum);
v->cv=ref;
entryPoint=nextEdge;
return(processEdge());
}
else{
// real link has no edges
entryPoint=nextVertex;
return(TRUE);
}
}
case nextEdge:{
if(itsStepper->nextEdge()){
// next edge detected
GLref ref;
v->xEdgeEntryToOwner(ref,itsStepper->refDatum);
v->cv=ref;
entryPoint=nextEdge;
return(processEdge());
}
else{
// real link has no more edges
entryPoint=nextVertex;
return(TRUE);
}
}
default: nodeErr(6);
}
nodeErr(8);
}
int GameManager::startUp() {
return startUp(false, time(NULL));
}