//------------------------------------------------------------------------------------- // This is the update callback function and is called at each update frame // before rendering. You should update the game logic here. // //------------------------------------------------------------------------------------- void GameApp::Update() { JGE* engine = JGE::GetInstance(); // do a screen shot when the TRIANGLE button is pressed if (engine->GetButtonClick(PSP_CTRL_TRIANGLE)) { char s[80]; // save screen shot to root of Memory Stick sprintf(s, "ms0:/screenshot.png"); JRenderer::GetInstance()->ScreenShot(s); } // exit when the CROSS button is pressed if (engine->GetButtonClick(PSP_CTRL_CROSS)) { engine->End(); return; } float dt = engine->GetDelta(); // Get time elapsed since last update. mAngle += 2.0f*dt; if (mAngle >= M_PI*2) mAngle = 0; }
bool GameOptionKeyBindings::read(string input) { istringstream iss(input); vector<pair<LocalKeySym, JButton> > assoc; while (iss.good()) { stringstream s; iss.get(*(s.rdbuf()), ','); iss.get(); LocalKeySym local = 0; char sep = 0; u32 button = 0; s >> local >> sep >> button; if (':' != sep) return false; assoc.push_back(make_pair(local, u32_to_button(button))); } if (assoc.empty()) return false; JGE* j = JGE::GetInstance(); j->ClearBindings(); for (vector<pair<LocalKeySym, JButton> >::const_iterator it = assoc.begin(); it != assoc.end(); ++it) j->BindKey(it->first, it->second); return true; }
//------------------------------------------------------------------------------------- // This is the update callback function and is called at each update frame // before rendering. You should update the game logic here. // //------------------------------------------------------------------------------------- void GameApp::Update() { JGE* engine = JGE::GetInstance(); // do a screen shot when the TRIANGLE button is pressed if (engine->GetButtonClick(PSP_CTRL_TRIANGLE)) { char s[80]; // save screen shot to root of Memory Stick sprintf(s, "ms0:/screenshot.png"); JRenderer::GetInstance()->ScreenShot(s); } // exit when the CROSS button is pressed if (engine->GetButtonClick(PSP_CTRL_CROSS)) { engine->End(); return; } if (engine->GetButtonClick(PSP_CTRL_CIRCLE)) { Reset(); return; } if (engine->GetButtonClick(PSP_CTRL_RIGHT)) { mCurr++; if (mCurr >= DEMO_COUNT) mCurr = 0; Reset(); return; } if (engine->GetButtonClick(PSP_CTRL_LEFT)) { mCurr--; if (mCurr < 0) mCurr = DEMO_COUNT-1; Reset(); return; } float dt = engine->GetDelta(); // Get time elapsed since last update. // // Your updating code here... // if (mBox2D) mBox2D->Update(dt); }
bool GameOptionKeyBindings::write(std::ofstream* file, string name) { JGE* j = JGE::GetInstance(); *file << name << "="; JGE::keybindings_it start = j->KeyBindings_begin(), end = j->KeyBindings_end(); if (start != end) { *file << start->first << ":" << start->second; ++start; } for (JGE::keybindings_it it = start; it != end; ++it) *file << "," << it->first << ":" << it->second; *file << endl; return true; }
SimplePad * GameSettings::keypadStart(string input, string * _dest, bool _cancel, bool _numpad, float _x, float _y) { if (keypad == NULL) keypad = NEW SimplePad(); // show keyboard #ifdef IOS JGE *engine = JGE::GetInstance(); engine->SendCommand( "displayKeyboard", input); #elif ANDROID JGE *engine = JGE::GetInstance(); engine->SendCommand( "displayKeyboard:" + input); #endif keypad->bShowCancel = _cancel; keypad->bShowNumpad = _numpad; keypad->mX = _x; keypad->mY = _y; keypad->Start(input, _dest); return keypad; }
void GameApp::Render() { if (systemError.size()) { fprintf(stderr, "%s", systemError.c_str()); WFont * mFont = WResourceManager::Instance()->GetWFont(Fonts::MAIN_FONT); if (mFont) mFont->DrawString(systemError.c_str(), 1, 1); return; } JRenderer * renderer = JRenderer::GetInstance(); renderer->ClearScreen(ARGB(0,0,0,0)); if (mCurrentState) mCurrentState->Render(); #ifdef DEBUG_CACHE WResourceManager::Instance()->DebugRender(); #endif #if defined(DEBUG) && !defined(IOS) JGE* mEngine = JGE::GetInstance(); float fps = mEngine->GetFPS(); totalFPS += fps; nbUpdates+=1; WFont * mFont= WResourceManager::Instance()->GetWFont(Fonts::MAIN_FONT); char buf[512]; sprintf(buf, "avg:%.02f - %.02f fps",totalFPS/nbUpdates, fps); if (mFont) { mFont->SetColor(ARGB(255,255,255,255)); mFont->DrawString(buf, 10, SCREEN_HEIGHT-25); } #endif }
void GameApp::Update() { JGE* engine = JGE::GetInstance(); if (engine->GetButtonClick(PSP_CTRL_TRIANGLE)) // do a screen shot when the TRIANGLE button is pressed { char s[80]; sprintf(s, "ms0:/screenshot.png"); JRenderer::GetInstance()->ScreenShot(s); } if (engine->GetButtonClick(PSP_CTRL_CROSS)) // exit when the CROSS button is pressed { engine->End(); return; } if (engine->GetButtonClick(PSP_CTRL_CIRCLE)) { mShowSpline = !mShowSpline; } float dt = engine->GetDelta(); mPlane->Update(dt); mCounter += 100*dt; int curr = (int) mCounter; if (mIndex != curr) // Update position of the plane { if (curr >= mSpline->GetPixelCount()) { mCounter = 0.0f; curr = 0; } mIndex = curr; Point pt; mSpline->GetPixel(pt, mIndex); mPlane->SetPosition(pt.x, pt.y); mSpline->GetPixel(pt, mIndex+1); mPlane->SetDirection(pt.x, pt.y); } }
//------------------------------------------------------------------------------------- // This is the update callback function and is called at each update frame // before rendering. You should update the game logic here. // //------------------------------------------------------------------------------------- void GameApp::Update() { JGE* engine = JGE::GetInstance(); float dt = engine->GetDelta(); if (dt > 35.0f) // min 30 FPS ;) dt = 35.0f; scroller->Update(dt); timer+=dt; if (timer > 15) { startTransition(); timer = 0; }; transition+=(int)(dt * 300); if (transition > 255) endTransition(); if (gameToExtract.size()) { if (!subMenu) { switch(currentGameState) { case GAME_STATE_EXTRACTING_DONE: subMenu = new SimpleMenu(1, this,mFont,10,200, "installed to " + extractFolder); subMenu->Add(MENU_NO, "OK","", true); break; default: //TODO Check contents of file to see if it matches the zip format. subMenu = new SimpleMenu(1, this,mFont,10,200, "Do you want to install this homebrew?"); subMenu->Add(MENU_YES, "yes"); subMenu->Add(MENU_NO, "Cancel"); break; } } subMenu->Update(dt); switch(currentGameState) { case GAME_STATE_EXTRACTING: SAFE_DELETE(subMenu); ensureExtractFilesList(); if (extractError) { extractError = 0; currentGameState = GAME_STATE_EXTRACTING_CANCEL; return; } extractOneFile(); if (zipFiles.empty()) { currentZipFile.close(); loadFiles(base.c_str()); //reload menu to update folders currentGameState = GAME_STATE_EXTRACTING_DONE; } break; case GAME_STATE_EXTRACTING_CANCEL: SAFE_DELETE(subMenu); gameToExtract = ""; currentGameState = GAME_STATE_MENU; break; case GAME_STATE_EXTRACTING_DONE: break; default: break; } return; } menu->Update(dt); if (gameSelected == -2) { loadFiles(base.c_str()); gameSelected = -1; } if (gameSelected > -1) { engine->End(); return; } // exit when the TRIANGLE button is pressed if ( engine->GetButtonState(JGE_BTN_CANCEL)) { strcpy((char *)ebootPath, "quit"); engine->End(); return; } if ( engine->GetButtonState(JGE_BTN_PRI)) { JRenderer::GetInstance()->ScreenShot("ms0:/picture/wMenu.png"); } if ( engine->GetButtonState(JGE_BTN_PREV)) { base = "ms0:/PSP/SAVEDATA"; loadFiles(base.c_str()); return; } if ( engine->GetButtonState(JGE_BTN_NEXT)) { base = "ms0:/PSP/GAME"; loadFiles(base.c_str()); return; } }
//------------------------------------------------------------------------------------- // This is the init callback function. You should load and create your in-game // resources here. // //------------------------------------------------------------------------------------- void GameApp::Create() { JLOG("GameApp:Create 1"); JFileSystem::init("./"); //to avoid having subfolders JLOG("GameApp:Create 2"); JRenderer* renderer = JRenderer::GetInstance(); JLOG("GameApp:Create 3"); loadWalls("."); if (wallpapers.size()) { JLOG("GameApp:Create 4"); int rnd = (rand() % wallpapers.size()); backTex=renderer->LoadTexture(wallpapers[rnd].c_str()); if (backTex) backQuad = new JQuad(backTex, 0, 0, 480, 272); } JLOG("GameApp:Create 5"); // Load a font mFont=new JLBFont("font", 11); JLOG("GameApp:Create 6"); scroller = new TextScroller(mFont, SCREEN_WIDTH/2 - 190 , SCREEN_HEIGHT-20,380); const char * const CreditsText[] = { "Thanks to n00b81, Tyranid, devs of the PSPSDK, Hitmen, Fanjita & Noobz, psp-hacks.com", "wMenu uses the JGE++ library ( http://code.google.com/p/wagic )" }; menu = NULL; #ifdef WIN32 strcpy(dummy, "D:/Stuff/Programming/wmenu/projects/wmenu/bin/samples"); #else strcpy(dummy, "ms0:/PSP/GAME"); #endif ebootPath = dummy; JLOG("GameApp:Create 7"); JGE* engine = JGE::GetInstance(); vector<string>argv = engine->GetARGV(); int settingsAddr = 0; JLOG("GameApp:Create 8"); if (argv.size() > 1) { string hex = argv[1]; hex[8] = 0; //bug in HBL ? fprintf(stderr, "Location: 0x %s\n", hex.c_str()); settingsAddr = xstrtoi(hex.c_str(), 8); } fprintf(stderr, " settingsAddr : %d\n", settingsAddr); if (settingsAddr) { settings = (tMenuApi *) settingsAddr; ebootPath = (void *) settings->filename; } int size = sizeof(CreditsText) / sizeof(CreditsText[0]); string scroll = "wMenu 0.4 by Wololo http://wololo.net "; stringCode(scroll); scroll.append("--- HBL Info ---"); if (settings) { scroll.append(settings->VersionName); scroll.append(" by "); scroll.append(settings->Credits); scroll.append(" "); } for (int i = 0; i < size; i++) { scroll.append(CreditsText[i]); scroll.append(" "); } scroller->Add(scroll); JLOG("GameApp:Create 9"); loadFiles((char *)ebootPath); if (fileExists("menu.wav")) { menuSfx = JSoundSystem::GetInstance()->LoadSample("menu.wav"); //runSfx = JSoundSystem::GetInstance()->LoadSample("run.wav"); JSoundSystem::GetInstance()->SetSfxVolume(100); } JLOG("GameApp:Create 10"); currentGameState = GAME_STATE_NONE; }
bool CardDisplay::CheckUserInput(JButton key) { if (JGE_BTN_SEC == key || JGE_BTN_PRI == key || JGE_BTN_UP == key || JGE_BTN_DOWN == key) { if (listener) { listener->ButtonPressed(mId, 0); return true; } } if (!mObjects.size()) return false; if (mActionButton == key) { if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()) { CardGui * cardg = (CardGui *) mObjects[mCurr]; if (tc) { tc->toggleTarget(cardg->card); return true; } else { if (observer) observer->ButtonPressed(cardg); return true; } } return true; } switch (key) { case JGE_BTN_LEFT: { int n = mCurr; n--; if (n < start_item) { if (n < 0) { n = 0; } else { rotateLeft(); } } if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(JGE_BTN_LEFT)) { mCurr = n; mObjects[mCurr]->Entering(); } return true; } case JGE_BTN_RIGHT: { int n = mCurr; n++; if (n >= (int) (mObjects.size())) { n = mObjects.size() - 1; } if (n >= start_item + nb_displayed_items) { rotateRight(); } if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(JGE_BTN_RIGHT)) { mCurr = n; mObjects[mCurr]->Entering(); } return true; } default: { bool result = false; unsigned int distance2; unsigned int minDistance2 = -1; int n = mCurr; int x1,y1; JButton key; JGE* jge = observer?observer->getInput():JGE::GetInstance(); if(jge) { if (jge->GetLeftClickCoordinates(x1, y1)) { for (size_t i = 0; i < mObjects.size(); i++) { float top, left; if (mObjects[i]->getTopLeft(top, left)) { distance2 = static_cast<unsigned int>((top - y1) * (top - y1) + (left - x1) * (left - x1)); if (distance2 < minDistance2) { minDistance2 = distance2; n = i; } } } if (n < mCurr) key = JGE_BTN_LEFT; else key = JGE_BTN_RIGHT; if (n < start_item) { rotateLeft(); } else if (n >= (int)(mObjects.size()) && mObjects.size()) { n = mObjects.size() - 1; } if (n >= start_item + nb_displayed_items) { rotateRight(); } if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(key)) { mCurr = n; mObjects[mCurr]->Entering(); result = true; } jge->LeftClickedProcessed(); } } return result; } } return false; }
//------------------------------------------------------------------------------------- // This is the update callback function and is called at each update frame // before rendering. You should update the game logic here. // //------------------------------------------------------------------------------------- void GameApp::Update() { JGE* engine = JGE::GetInstance(); // do a screen shot when the TRIANGLE button is pressed if (engine->GetButtonClick(PSP_CTRL_TRIANGLE)) { char s[80]; // save screen shot to root of Memory Stick sprintf(s, "ms0:/screenshot.png"); JRenderer::GetInstance()->ScreenShot(s); } // exit when the CROSS button is pressed if (engine->GetButtonClick(PSP_CTRL_CROSS)) { engine->End(); return; } int quadIdx[] = { 7, 15, 0, 5, 7, 0, 1, 15, 4 }; // change particle image if PSP_CTRL_LEFT or PSP_CTRL_RIGHT is down if (engine->GetButtonClick(PSP_CTRL_LEFT)) { mCurrParticle--; if (mCurrParticle < 0) mCurrParticle = 15; mParticleSys->info.sprite = mParticles[mCurrParticle]; mMovingParticleSys->info.sprite = mParticles[15-mCurrParticle]; } if (engine->GetButtonClick(PSP_CTRL_RIGHT)) { mCurrParticle++; if (mCurrParticle > 15) mCurrParticle = 0; mParticleSys->info.sprite = mParticles[mCurrParticle]; mMovingParticleSys->info.sprite = mParticles[15-mCurrParticle]; } // change particle system if PSP_CTRL_DOWN or PSP_CTRL_UP is down if (engine->GetButtonClick(PSP_CTRL_DOWN)) { mCurrParticleSys--; if (mCurrParticleSys < 0) mCurrParticleSys = 8; mCurrParticle = quadIdx[mCurrParticleSys]; LoadNewParticleSys(); } if (engine->GetButtonClick(PSP_CTRL_UP)) { mCurrParticleSys++; if (mCurrParticleSys > 8) mCurrParticleSys = 0; mCurrParticle = quadIdx[mCurrParticleSys]; LoadNewParticleSys(); } float dt = engine->GetDelta(); // Get time elapsed since last update. mTimer += dt; mAngle += 2.0f*dt; if (mAngle >= M_PI*2) mAngle = 0; if (mTimer > 0.01f) // update the moving circle and particle at about 100fps { if (engine->GetAnalogX()<64) dx-=mSpeed*mTimer; if (engine->GetAnalogX()>192) dx+=mSpeed*mTimer; if (engine->GetAnalogY()<64) dy-=mSpeed*mTimer; if (engine->GetAnalogY()>192) dy+=mSpeed*mTimer; // Do some movement calculations and collision detection dx *= mFriction; dy *= mFriction; x += dx; y += dy; if (x>470) { x=470-(x-470); dx=-dx; } if (x<16) { x=16+16-x; dx=-dx; } if (y>260) { y=260-(y-260); dy=-dy; } if (y<16) { y=16+16-y; dy=-dy; } // Update particle system mMovingParticleSys->info.nEmission=(int) (dx*dx+dy*dy)*2; mMovingParticleSys->MoveTo(x,y); mTimer = 0.0f; } mMovingParticleSys->Update(dt); mParticleSys->Update(dt); }
bool CardSelector::CheckUserInput(JButton key) { if (!active) { for (vector<Target*>::iterator it = cards.begin(); it != cards.end(); ++it) if ((NULL == limitor) || (limitor->select(*it))) { active = *it; active->Entering(); return true; } return true; } Target* oldactive = active; timer = 800; int x,y; JGE* jge = observer->getInput(); if(!jge) return false; if(jge->GetLeftClickCoordinates(x, y)) { active = closest<CardSelectorTrue> (cards, limitor, static_cast<float> (x), static_cast<float> (y)); } switch (key) { case JGE_BTN_SEC: observer->cancelCurrentAction(); goto switch_active; break; case JGE_BTN_OK: observer->ButtonPressed(active); goto switch_active; break; case JGE_BTN_LEFT: active = closest<CardSelectorLeft> (cards, limitor, active); break; case JGE_BTN_RIGHT: active = closest<CardSelectorRight> (cards, limitor, active); break; case JGE_BTN_UP: active = closest<CardSelectorUp> (cards, limitor, active); break; case JGE_BTN_DOWN: active = closest<CardSelectorDown> (cards, limitor, active); break; case JGE_BTN_CANCEL: mDrawMode = (mDrawMode + 1) % DrawMode::kNumDrawModes; if (mDrawMode == DrawMode::kText) options[Options::DISABLECARDS].number = 1; else options[Options::DISABLECARDS].number = 0; return true; default: { if(!jge->GetLeftClickCoordinates(x, y)) { return false; } } } if(key != JGE_BTN_NONE) { if (active != oldactive) { CardView::SelectorZone oldowner, owner; if (CardView *q = dynamic_cast<CardView*>(oldactive)) oldowner = q->owner; else oldowner = CardView::nullZone; if (CardView *q = dynamic_cast<CardView*>(active)) owner = q->owner; else owner = CardView::nullZone; if (oldowner != owner) { if (CardView::nullZone != owner) { if (PlayGuiObject* old = fetchMemory(lasts[owner])) switch (key) { case JGE_BTN_LEFT: if (old->x < oldactive->x) active = old; break; case JGE_BTN_RIGHT: if (old->x > oldactive->x) active = old; break; case JGE_BTN_UP: if (old->y < oldactive->y) active = old; break; case JGE_BTN_DOWN: if (old->y > oldactive->y) active = old; break; default: if (old) active = old; break; } } lasts[oldowner] = SelectorMemory(oldactive); } } else { // active card hasn't changed - that means we're probably at an edge of the battlefield. // check if we're not already a selected avatar - if not, select one depending whether we're going up/down. GuiAvatar* avatar = dynamic_cast<GuiAvatar*> (active); if (!avatar) { if (key == JGE_BTN_DOWN) { active = duel->GetAvatars()->GetSelf(); } else if (key == JGE_BTN_UP) { active = duel->GetAvatars()->GetOpponent(); } } } } switch_active: if (active != oldactive) { { PlayGuiObject* c = dynamic_cast<PlayGuiObject*> (oldactive); if (c) c->zoom = 1.0f; } { PlayGuiObject* c = dynamic_cast<PlayGuiObject*> (active); if (c) c->zoom = 1.4f; } if (oldactive) oldactive->Leaving(JGE_BTN_NONE); if (active) active->Entering(); } else { timer = 800; } return true; }
void GameApp::Update() { if (systemError.size()) return; JGE* mEngine = JGE::GetInstance(); #if defined (PSP) if (mEngine->GetButtonState(JGE_BTN_MENU) && mEngine->GetButtonClick(JGE_BTN_CANCEL)) { char s[80]; sprintf(s, "ms0:/psp/photo/MTG%d.png", mScreenShotCount++); JRenderer::GetInstance()->ScreenShot(s); } //Exit when START and X ARE PRESSED SIMULTANEOUSLY if (mEngine->GetButtonState(JGE_BTN_MENU) && mEngine->GetButtonState(JGE_BTN_SEC)) { mEngine->End(); return; } //Restart Rendering engine when START and SQUARE ARE PRESSED SIMULTANEOUSLY if (mEngine->GetButtonState(JGE_BTN_MENU) && mEngine->GetButtonState(JGE_BTN_PRI)) JRenderer::Destroy(); #endif //PSP float dt = mEngine->GetDelta(); if (dt > 35.0f) // min 30 FPS ;) dt = 35.0f; TransitionBase * mTrans = NULL; if (mCurrentState) { mCurrentState->Update(dt); if (mGameStates[GAME_STATE_TRANSITION] == mCurrentState) mTrans = (TransitionBase *) mGameStates[GAME_STATE_TRANSITION]; } //Check for finished transitions. if (mTrans && mTrans->Finished()) { mTrans->End(); if (mTrans->to != NULL && !mTrans->bAnimationOnly) { SetCurrentState(mTrans->to); SAFE_DELETE(mGameStates[GAME_STATE_TRANSITION]); mCurrentState->Start(); } else { SetCurrentState(mTrans->from); SAFE_DELETE(mGameStates[GAME_STATE_TRANSITION]); } } if (mNextState != NULL) { if (mCurrentState != NULL) mCurrentState->End(); SetCurrentState(mNextState); #if defined (PSP) /* int maxLinear = ramAvailableLineareMax(); int ram = ramAvailable(); char buf[512]; sprintf(buf, "Ram : linear max: %i - total : %i\n",maxLinear, ram); fprintf(stderr,buf); */ #endif mCurrentState->Start(); mNextState = NULL; } }
void GameStateOptions::Update(float dt) { timer += dt * 10; if (options.keypadActive()) { options.keypadUpdate(dt); if (newProfile != "") { newProfile = options.keypadFinish(); if (newProfile != "") { options[Options::ACTIVE_PROFILE] = newProfile; options.reloadProfile(); optionsTabs->Reload(); } newProfile = ""; } } else switch (mState) { default: case SAVE: switch (optionsTabs->needsConfirm()) { case WGuiBase::CONFIRM_CANCEL: mState = SHOW_OPTIONS; break; case WGuiBase::CONFIRM_OK: optionsTabs->save(); JSoundSystem::GetInstance()->SetSfxVolume(options[Options::SFXVOLUME].number); JSoundSystem::GetInstance()->SetMusicVolume(options[Options::MUSICVOLUME].number); mParent->DoTransition(TRANSITION_FADE, GAME_STATE_MENU); mState = SHOW_OPTIONS; break; case WGuiBase::CONFIRM_NEED: optionsTabs->yieldFocus(); break; } // Note : No break here : must continue to continue updating the menu elements. case SHOW_OPTIONS: { JGE* j = JGE::GetInstance(); JButton key = JGE_BTN_NONE; int x, y; if (grabber) { LocalKeySym sym; if (LOCAL_KEY_NONE != (sym = j->ReadLocalKey())) grabber->KeyPressed(sym); } else while ((key = JGE::GetInstance()->ReadButton()) || JGE::GetInstance()->GetLeftClickCoordinates(x,y)) { if (!optionsTabs->CheckUserInput(key) && key == JGE_BTN_MENU) mState = SHOW_OPTIONS_MENU; } optionsTabs->Update(dt); break; } case SHOW_OPTIONS_MENU: optionsMenu->Update(dt); break; } if (mReload) { options.reloadProfile(); Translator::EndInstance(); Translator::GetInstance()->init(); optionsTabs->Reload(); mReload = false; } }