void GameSession::run(LevelDefinitionBase* level) {
_levelDefinition = level;
startLevel();
const Pad& pad = Hardware::getPad();
while (isRunning()) {
checkLevelComplete();
animate();
timer();
move();
if (pad.isStartNewPress()) {
pause();
} else if (pad.isSelectNewPress() && _isMapAvailable) {
showMap();
} else if (pad.isLHeld() && pad.isRHeld()) {
commitSuicide();
}
Hardware::waitForVBlank();
}
}
void GameSession::move() {
_movementTimer++;
if (_movementTimer != MOVEMENT_TIME) return;
_movementTimer = 0;
movePlayer();
_level->iterate(isGravityInverted());
_isOddIteration = !_isOddIteration;
decreaseGravityTime();
// If the last iteration of the game caused the player to die, we either
// need to reset the level to its default state or end the game
if (_level->getPlayerBlock()->isDestroyed()) {
if (_lives > 0) {
startLevel();
} else {
_isRunning = false;
_isGameOver = true;
}
}
}
void KJezzball::newGame()
{
// Check for running game
closeGame();
if ( m_state==Idle )
{
// untoggles the pause button in case it was toggled
m_pauseButton->setChecked(false);
// update displays
m_game.level = 1;
m_game.score = 0;
m_levelLCD->display( m_game.level );
m_scoreLCD->display( m_game.score );
statusBar()->clear();
// start new game
m_state = Running;
createLevel( m_game.level );
startLevel();
}
}
void Lobby::checkFreeUsers(float p_DeltaTime)
{
std::lock_guard<std::mutex> lock(m_UserLock);
handlePackages();
auto removeIt = std::remove_if(m_FreeUsers.begin(), m_FreeUsers.end(),
[] (User::wPtr p_User)
{
User::ptr user = p_User.lock();
return !user || user->getState() != User::State::LOBBY;
});
m_FreeUsers.erase(removeIt, m_FreeUsers.end());
for (auto& level : m_Levels)
{
if (!level.m_JoinedUsers.empty())
{
level.m_WaitedTime += p_DeltaTime;
}
if (level.m_WaitedTime > level.m_TimeoutLength)
{
startLevel(level);
}
}
}
void GameSession::checkLevelComplete() {
if (_isLevelComplete) {
SoundPlayer::stopAll();
SoundPlayer::playLevelComplete();
while (_remainingTime > 0) {
_remainingTime -= _remainingTime >= 4 ? 4 : _remainingTime;
addScore(_remainingTime >= 4 ? 4 : _remainingTime); // One point per second
_hud.drawTimerBar(_remainingTime);
Hardware::waitForVBlank();
}
runTransition();
if (_levelDefinition->getNextLevel() != NULL) {
_levelDefinition = _levelDefinition->getNextLevel();
startLevel();
} else {
_isRunning = false;
_isGameComplete = true;
}
}
}
void playGame()
{
lives = MAX_LIVES;
score = 0;
startLevel();
resetLevel();
int resetPressed = FALSE;
// game loop
while (lives > 0)
{
//test select button release
if (KEY_DOWN_NOW(BUTTON_SELECT))
{
resetPressed = TRUE;
}
if (resetPressed && !KEY_DOWN_NOW(BUTTON_SELECT))
{
titleScreen();
}
waitForVBlank();
erase();
updateVars();
checkOutsideScreen();
generateObjs();
draw();
}
gameOverScreen();
}
/*
* Just starts a new game
*/
void startGame() {
level = 0; // reset level
difficulty = 0; // reset difficulty level
gameSpeed = 0; // reset game seep level
timeEnd = pow(2, 5); // sets the time endo to default (2Hz)
startLevel(); // starts a new level
playMusic(3); // plays the tetris theme
}
void scum(unsigned long startingSeed, short numberOfSeedsToScan, short scanThroughDepth) {
unsigned long theSeed;
char path[BROGUE_FILENAME_MAX];
item *theItem;
creature *monst;
char buf[500];
FILE *logFile;
logFile = fopen("Brogue seed catalog.txt", "w");
rogue.nextGame = NG_NOTHING;
getAvailableFilePath(path, LAST_GAME_NAME, GAME_SUFFIX);
strcat(path, GAME_SUFFIX);
fprintf(logFile, "Brogue seed catalog, seeds %li to %li, through depth %i.\n\n\
To play one of these seeds, press control-N from the title screen \
and enter the seed number. Knowing which items will appear on \
the first %i depths will, of course, make the game significantly easier.",
startingSeed, startingSeed + numberOfSeedsToScan - 1, scanThroughDepth, scanThroughDepth);
for (theSeed = startingSeed; theSeed < startingSeed + numberOfSeedsToScan; theSeed++) {
fprintf(logFile, "\n\nSeed %li:", theSeed);
printf("\nScanned seed %li.", theSeed);
rogue.nextGamePath[0] = '\0';
randomNumbersGenerated = 0;
rogue.playbackMode = false;
rogue.playbackFastForward = false;
rogue.playbackBetweenTurns = false;
strcpy(currentFilePath, path);
initializeRogue(theSeed);
rogue.playbackOmniscience = true;
for (rogue.depthLevel = 1; rogue.depthLevel <= scanThroughDepth; rogue.depthLevel++) {
startLevel(rogue.depthLevel == 1 ? 1 : rogue.depthLevel - 1, 1); // descending into level n
fprintf(logFile, "\n Depth %i:", rogue.depthLevel);
for (theItem = floorItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
itemName(theItem, buf, true, true, NULL);
upperCase(buf);
fprintf(logFile, "\n %s", buf);
if (pmap[theItem->xLoc][theItem->yLoc].machineNumber > 0) {
fprintf(logFile, " (vault %i)", pmap[theItem->xLoc][theItem->yLoc].machineNumber);
}
}
for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
scumMonster(monst, logFile);
}
for (monst = dormantMonsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
scumMonster(monst, logFile);
}
}
freeEverything();
remove(currentFilePath); // Don't add a spurious LastGame file to the brogue folder.
}
fclose(logFile);
}
void SnakesGameManager::ReceiveMessage(Message* message)
{
if(message->GetMessageName() == "StartGame")
{
startLevel(1);
}
else if(message->GetMessageName() == "ShowMenu"){
showMenu();
}
}
void GameEngine::StartLevel(std::string _lvlName)
{
m_levelImporter->LoadLevel(_lvlName);
m_currentLevelName = _lvlName;
Event startLevel(_lvlName);
m_eventEngine->dispatch(LEVEL_START, &startLevel);
m_levelStarted = true;
}
BasicWork::State
ApplyBucketsWork::onRun()
{
// Check if we're at the beginning of the new level
if (isLevelComplete())
{
startLevel();
}
// The structure of these if statements is motivated by the following:
// 1. mCurrApplicator should never be advanced if mSnapApplicator is
// not false. Otherwise it is possible for curr to modify the
// database when the invariants for snap are checked.
// 2. There is no reason to advance mSnapApplicator or mCurrApplicator
// if there is nothing to be applied.
if (mSnapApplicator)
{
if (*mSnapApplicator)
{
advance("snap", *mSnapApplicator);
return State::WORK_RUNNING;
}
mApp.getInvariantManager().checkOnBucketApply(
mSnapBucket, mApplyState.currentLedger, mLevel, false);
mSnapApplicator.reset();
mSnapBucket.reset();
mBucketApplySuccess.Mark();
}
if (mCurrApplicator)
{
if (*mCurrApplicator)
{
advance("curr", *mCurrApplicator);
return State::WORK_RUNNING;
}
mApp.getInvariantManager().checkOnBucketApply(
mCurrBucket, mApplyState.currentLedger, mLevel, true);
mCurrApplicator.reset();
mCurrBucket.reset();
mBucketApplySuccess.Mark();
}
mApp.getCatchupManager().logAndUpdateCatchupStatus(true);
if (mLevel != 0)
{
--mLevel;
CLOG(DEBUG, "History")
<< "ApplyBuckets : starting next level: " << mLevel;
return State::WORK_RUNNING;
}
CLOG(DEBUG, "History") << "ApplyBuckets : done, restarting merges";
mApp.getBucketManager().assumeState(mApplyState, mMaxProtocolVersion);
return State::WORK_SUCCESS;
}
void KJezzball::focusInEvent ( QFocusEvent *ev )
{
if ( m_state==Suspend )
{
startLevel();
m_state = Running;
statusBar()->clear();
m_pauseButton->setChecked(false);
//m_gameWidget->display( QString::null );
}
KMainWindow::focusInEvent( ev );
}
GameScene::GameScene(QObject *parent) :
QGraphicsScene(parent),
currentParticleNumber(0),
_dt(0),
firstStep(true),
particlesToAdd(0)
{
setSceneRect(0,0,800,480);
currentParticleNumber = 0;
startLevel(1);
time.start();
connect(&advanceTimer, SIGNAL(timeout()), SLOT(advance()));
advanceTimer.start(1);
}
void Lobby::joinLevel(User::ptr p_User, const std::string& p_LevelName)
{
for (auto& level : m_Levels)
{
if (level.m_LevelName == p_LevelName)
{
level.m_JoinedUsers.push_back(p_User);
p_User->setState(User::State::WAITING_FOR_GAME);
if (level.m_JoinedUsers.size() >= level.m_MaxPlayers)
{
startLevel(level);
}
break;
}
}
}
void GameSession::commitSuicide() {
SoundPlayer::playSuicide();
while (_remainingTime > 0) {
_remainingTime -= 4;
_hud.drawTimerBar(_remainingTime);
Hardware::waitForVBlank();
}
decreaseLives();
if (_lives > 0) {
startLevel();
render();
} else {
_isRunning = false;
_isGameOver = true;
}
}
bool NormalGameModeManager::LevelUp() {
int match = 1, i=0;
while (match && i<theHeriswapGridSystem.Types) {
if (remain[i] != 0) match=0;
i++;
}
//si on a tous les objectifs
if (match) {
successMgr->sLevel1For2K(level, points);
time -= glm::min(20 * 8.f / theHeriswapGridSystem.GridSize, time);
PROFILE("NormalGameModeManager", "changeLevel", InstantEvent);
startLevel(level+1);
}
return match;
}
int main(int argc, char **argv) {
pgInit(argc,argv);
pgRegisterApp(PG_APP_NORMAL,"Blackout",0);
/*** Top-level widgets: toolbar and canvas */
wToolbar = pgNewWidget(PG_WIDGET_TOOLBAR,0,0);
wCanvas = pgNewWidget(PG_WIDGET_CANVAS,0,0);
pgBind(PGDEFAULT,PG_WE_BUILD,&evtDrawBoard,NULL);
pgBind(PGDEFAULT,PG_WE_PNTR_DOWN,&evtMouseDown,NULL);
/* Toolbar thingies */
pgNewWidget(PG_WIDGET_BUTTON,PG_DERIVE_INSIDE,wToolbar);
pgSetWidget(PGDEFAULT,
PG_WP_TEXT,pgNewString("Menu"),
PG_WP_EXTDEVENTS,PG_EXEV_PNTR_DOWN,
0);
pgBind(PGDEFAULT,PG_WE_PNTR_DOWN,&btnMenu,NULL);
wStatusLabel = pgNewWidget(PG_WIDGET_LABEL,0,0);
pgSetWidget(PGDEFAULT,
PG_WP_SIDE,PG_S_ALL,
PG_WP_TRANSPARENT,0,
PG_WP_ALIGN,PG_A_CENTER,
// PG_WP_FONT,pgNewFont(NULL,10,PG_FSTYLE_BOLD),
0);
/*** Allocate default game board */
srand(time(NULL));
boardwidth = 5;
boardheight = 5;
boardsize = sizeof(light) * boardwidth * boardheight;
board = (light *) malloc(boardsize);
solution = (light *) malloc(boardsize);
startLevel(1);
/*** Event loop */
pgEventLoop();
return 0;
}
void KJezzball::switchLevel()
{
m_game.score += m_level.score;
// make sure the LCD provides enough digits for the score
// (fixes #96841)
int numDigits=0;
int temp_score = m_game.score;
for ( ; temp_score > 0; ++numDigits ) temp_score /= 10;
if ( numDigits < 5 ) numDigits = 5; // set numDigits to at least 5, otherwise it does not look well
m_scoreLCD->setNumDigits( numDigits );
m_scoreLCD->display( m_game.score );
QString score;
score.setNum( m_level.score );
QString level;
level.setNum( m_game.level );
QString foo = QString(
i18n("You have successfully cleared more than 75% of the board.\n") +
i18n("%1 points: 15 points per remaining life\n").arg(m_level.lifes*15) +
i18n("%1 points: Bonus\n").arg((m_gameWidget->percent()-75)*2*(m_game.level+5)) +
i18n("%1 points: Total score for this level\n").arg(score) +
i18n("On to level %1. Remember you get %2 lives this time!")).arg(m_game.level+1).arg(m_game.level+2);
KMessageBox::information( this,foo );
// KMessageBox::information( this, i18n("You've completed level %1 with "
// "a score of %2.\nGet ready for the next one!").arg(level).arg(score));
m_game.level++;
m_levelLCD->display( m_game.level );
createLevel( m_game.level );
startLevel();
}
/* Clickski! */
int evtMouseDown(struct pgEvent *evt) {
int lx,ly;
light *p;
int i;
/* What light was it in? */
lx = (evt->e.pntr.x - bx) / lightw;
ly = (evt->e.pntr.y - by) / lighth;
if (evt->e.pntr.x < bx || lx >= boardwidth ||
evt->e.pntr.y < by || ly >= boardwidth)
return 0;
invertLight(lx,ly);
invertLight(lx-1,ly);
invertLight(lx+1,ly);
invertLight(lx,ly-1);
invertLight(lx,ly+1);
SOLUTION(lx,ly) ^= 1;
/* Update the screen */
pgWriteCmd(evt->from,PGCANVAS_INCREMENTAL,0);
moves++;
updateStatus();
/* A win condition? */
for (i=boardsize,p=board;i;i--,p++)
if (*p)
return 0; /* Nope. */
/* Yep! */
pgMessageDialogFmt("Blackout!",0,
"You completed level %d!\n\n"
"Moves: %d",level,moves);
startLevel(level+1);
return 0;
}
void KJezzball::pauseGame()
{
switch ( m_state )
{
case Running:
m_state = Paused;
statusBar()->message(i18n("Game paused.") );
//m_gameWidget->display( i18n("Game paused. Press P to continue!") );
stopLevel();
break;
case Paused:
case Suspend:
m_state = Running;
statusBar()->clear();
//m_gameWidget->display( QString::null );
startLevel();
break;
case Idle:
break;
}
}
// This is the basic program loop.
// When the program launches, or when a game ends, you end up here.
// If the player has already said what he wants to do next
// (by storing it in rogue.nextGame -- possibilities listed in enum NGCommands),
// we'll do it. The path (rogue.nextGamePath) is essentially a parameter for this command, and
// tells NG_VIEW_RECORDING and NG_OPEN_GAME which file to open. If there is a command but no
// accompanying path, and it's a command that should take a path, then pop up a dialog to have
// the player specify a path. If there is no command (i.e. if rogue.nextGame contains NG_NOTHING),
// then we'll display the title screen so the player can choose.
void mainBrogueJunction() {
rogueEvent theEvent;
char path[BROGUE_FILENAME_MAX], buf[100], seedDefault[100];
char maxSeed[20];
short i, j, k;
boolean seedTooBig;
// clear screen and display buffer
for (i=0; i<COLS; i++) {
for (j=0; j<ROWS; j++) {
displayBuffer[i][j].character = 0;
displayBuffer[i][j].needsUpdate = false;
displayBuffer[i][j].opacity = 100;
for (k=0; k<3; k++) {
displayBuffer[i][j].foreColorComponents[k] = 0;
displayBuffer[i][j].backColorComponents[k] = 0;
}
plotCharWithColor(' ', i, j, &black, &black);
}
}
initializeLaunchArguments(&rogue.nextGame, rogue.nextGamePath, &rogue.nextGameSeed);
do {
rogue.gameHasEnded = false;
rogue.playbackFastForward = false;
rogue.playbackMode = false;
switch (rogue.nextGame) {
case NG_NOTHING:
// Run the main menu to get a decision out of the player.
// Seth: Added
setBrogueGameEvent(BrogueGameEventShowTitle);
titleMenu();
break;
case NG_NEW_GAME:
case NG_NEW_GAME_WITH_SEED:
rogue.nextGamePath[0] = '\0';
randomNumbersGenerated = 0;
rogue.playbackMode = false;
rogue.playbackFastForward = false;
rogue.playbackBetweenTurns = false;
getAvailableFilePath(path, LAST_GAME_NAME, GAME_SUFFIX);
strcat(path, GAME_SUFFIX);
strcpy(currentFilePath, path);
if (rogue.nextGame == NG_NEW_GAME_WITH_SEED) {
if (rogue.nextGameSeed == 0) { // Prompt for seed; default is the previous game's seed.
sprintf(maxSeed, "%lu", ULONG_MAX);
if (previousGameSeed == 0) {
seedDefault[0] = '\0';
} else {
sprintf(seedDefault, "%lu", previousGameSeed);
}
if (getInputTextString(buf, "Generate dungeon with seed number:",
log10(ULONG_MAX) + 1,
seedDefault,
"",
TEXT_INPUT_NUMBERS,
true)
&& buf[0] != '\0') {
seedTooBig = false;
if (strlen(buf) > strlen(maxSeed)) {
seedTooBig = true;
} else if (strlen(buf) == strlen(maxSeed)) {
for (i=0; maxSeed[i]; i++) {
if (maxSeed[i] > buf[i]) {
break; // we're good
} else if (maxSeed[i] < buf[i]) {
seedTooBig = true;
break;
}
}
}
if (seedTooBig) {
rogue.nextGameSeed = ULONG_MAX;
} else {
sscanf(buf, "%lu", &rogue.nextGameSeed);
}
} else {
rogue.nextGame = NG_NOTHING;
break; // Don't start a new game after all.
}
}
} else {
rogue.nextGameSeed = 0; // Seed based on clock.
}
// Seth: Added
setBrogueGameEvent(BrogueGameEventStartNewGame);
rogue.nextGame = NG_NOTHING;
initializeRogue(rogue.nextGameSeed);
startLevel(rogue.depthLevel, 1); // descending into level 1
mainInputLoop();
freeEverything();
break;
case NG_OPEN_GAME:
rogue.nextGame = NG_NOTHING;
// Seth: Added
setBrogueGameEvent(BrogueGameEventBeginOpenGame);
path[0] = '\0';
if (rogue.nextGamePath[0]) {
strcpy(path, rogue.nextGamePath);
rogue.nextGamePath[0] = '\0';
} else {
dialogChooseFile(path, GAME_SUFFIX, "Open saved game:");
//chooseFile(path, "Open saved game: ", "Saved game", GAME_SUFFIX);
}
if (openFile(path)) {
loadSavedGame();
// Seth: Added
setBrogueGameEvent(BrogueGameEventOpenGame);
mainInputLoop();
freeEverything();
} else {
//dialogAlert("File not found.");
}
rogue.playbackMode = false;
rogue.playbackOOS = false;
// Seth: Added
setBrogueGameEvent(BrogueGameEventOpenGameFinished);
break;
case NG_VIEW_RECORDING:
rogue.nextGame = NG_NOTHING;
// Seth: Added
setBrogueGameEvent(BrogueGameEventBeginOpenGame);
path[0] = '\0';
if (rogue.nextGamePath[0]) {
strcpy(path, rogue.nextGamePath);
rogue.nextGamePath[0] = '\0';
} else {
dialogChooseFile(path, RECORDING_SUFFIX, "View recording:");
//chooseFile(path, "View recording: ", "Recording", RECORDING_SUFFIX);
}
if (openFile(path)) {
// Seth: Added
setBrogueGameEvent(BrogueGameEventPlayRecording);
randomNumbersGenerated = 0;
rogue.playbackMode = true;
initializeRogue(0); // Seed argument is ignored because we're in playback.
if (!rogue.gameHasEnded) {
startLevel(rogue.depthLevel, 1);
pausePlayback();
displayAnnotation(); // in case there's an annotation for turn 0
}
while(!rogue.gameHasEnded && rogue.playbackMode) {
rogue.RNG = RNG_COSMETIC; // dancing terrain colors can't influence recordings
rogue.playbackBetweenTurns = true;
nextBrogueEvent(&theEvent, false, true, false);
rogue.RNG = RNG_SUBSTANTIVE;
executeEvent(&theEvent);
}
freeEverything();
} else {
// announce file not found
}
rogue.playbackMode = false;
rogue.playbackOOS = false;
break;
case NG_HIGH_SCORES:
rogue.nextGame = NG_NOTHING;
// Seth: Added
setBrogueGameEvent(BrogueGameEventShowHighScores);
printHighScores(false);
break;
case NG_SCUM:
rogue.nextGame = NG_NOTHING;
scum(1, 1000, 5);
break;
case NG_QUIT:
// No need to do anything.
break;
default:
break;
}
} while (rogue.nextGame != NG_QUIT);
}
// This is the basic program loop.
// When the program launches, or when a game ends, you end up here.
// If the player has already said what he wants to do next
// (by storing it in rogue.nextGame -- possibilities listed in enum NGCommands),
// we'll do it. The path (rogue.nextGamePath) is essentially a parameter for this command, and
// tells NG_VIEW_RECORDING and NG_OPEN_GAME which file to open. If there is a command but no
// accompanying path, and it's a command that should take a path, then pop up a dialog to have
// the player specify a path. If there is no command (i.e. if rogue.nextGame contains NG_NOTHING),
// then we'll display the title screen so the player can choose.
void mainBrogueJunction() {
rogueEvent theEvent;
char path[BROGUE_FILENAME_MAX], buf[100], seedDefault[100];
char maxSeed[64];
short i;
boolean seedTooBig;
if (ioInitialize() != 0) {
printf("Failure to initialize display\n");
exit(1);
}
initializeLaunchArguments(&rogue.nextGame, rogue.nextGamePath, &rogue.nextGameSeed);
do {
rogue.gameHasEnded = false;
rogue.playbackFastForward = false;
rogue.playbackMode = false;
switch (rogue.nextGame) {
case NG_NOTHING:
// Run the main menu to get a decision out of the player.
titleMenu();
break;
case NG_NEW_GAME:
case NG_NEW_GAME_WITH_SEED:
rogue.nextGamePath[0] = '\0';
randomNumbersGenerated = 0;
rogue.playbackMode = false;
rogue.playbackFastForward = false;
rogue.playbackBetweenTurns = false;
getAvailableFilePath(path, LAST_GAME_NAME, GAME_SUFFIX);
strcat(path, GAME_SUFFIX);
strcpy(currentFilePath, path);
if (rogue.nextGame == NG_NEW_GAME_WITH_SEED) {
if (rogue.nextGameSeed == 0) { // Prompt for seed; default is the previous game's seed.
sprintf(maxSeed, "%lu", ULONG_MAX);
if (previousGameSeed == 0) {
seedDefault[0] = '\0';
} else {
sprintf(seedDefault, "%lu", previousGameSeed);
}
if (getInputTextString(buf, "输入随机数种子生成地下城：",
log10(ULONG_MAX) + 1 + 6, // pad for header text
seedDefault,
"",
TEXT_INPUT_NUMBERS,
true)
&& buf[0] != '\0') {
seedTooBig = false;
if (strlen(buf) > strlen(maxSeed)) {
seedTooBig = true;
} else if (strlen(buf) == strlen(maxSeed)) {
for (i=0; maxSeed[i]; i++) {
if (maxSeed[i] > buf[i]) {
break; // we're good
} else if (maxSeed[i] < buf[i]) {
seedTooBig = true;
break;
}
}
}
if (seedTooBig) {
rogue.nextGameSeed = ULONG_MAX;
} else {
sscanf(buf, "%lu", &rogue.nextGameSeed);
}
} else {
rogue.nextGame = NG_NOTHING;
break; // Don't start a new game after all.
}
}
} else {
rogue.nextGameSeed = 0; // Seed based on clock.
}
rogue.nextGame = NG_NOTHING;
initializeRogue(rogue.nextGameSeed);
startLevel(rogue.depthLevel, 1); // descending into level 1
mainInputLoop();
freeEverything();
break;
case NG_OPEN_GAME:
rogue.nextGame = NG_NOTHING;
path[0] = '\0';
if (rogue.nextGamePath[0]) {
strcpy(path, rogue.nextGamePath);
rogue.nextGamePath[0] = '\0';
} else {
dialogChooseFile(path, GAME_SUFFIX, "选择中断存档进行读取：");
//chooseFile(path, "Open saved game: ", "Saved game", GAME_SUFFIX);
}
if (openFile(path)) {
loadSavedGame();
mainInputLoop();
freeEverything();
} else {
//dialogAlert("File not found.");
}
rogue.playbackMode = false;
rogue.playbackOOS = false;
break;
case NG_VIEW_RECORDING:
rogue.nextGame = NG_NOTHING;
path[0] = '\0';
if (rogue.nextGamePath[0]) {
strcpy(path, rogue.nextGamePath);
rogue.nextGamePath[0] = '\0';
} else {
dialogChooseFile(path, RECORDING_SUFFIX, "选择录像文件进行回放：");
//chooseFile(path, "View recording: ", "Recording", RECORDING_SUFFIX);
}
if (openFile(path)) {
randomNumbersGenerated = 0;
rogue.playbackMode = true;
initializeRogue(0); // Seed argument is ignored because we're in playback.
if (!rogue.gameHasEnded) {
startLevel(rogue.depthLevel, 1);
pausePlayback();
displayAnnotation(); // in case there's an annotation for turn 0
}
while(!rogue.gameHasEnded && rogue.playbackMode) {
rogue.RNG = RNG_COSMETIC; // dancing terrain colors can't influence recordings
rogue.playbackBetweenTurns = true;
nextBrogueEvent(&theEvent, false, true, false);
rogue.RNG = RNG_SUBSTANTIVE;
executeEvent(&theEvent);
}
freeEverything();
} else {
// announce file not found
}
rogue.playbackMode = false;
rogue.playbackOOS = false;
break;
case NG_HIGH_SCORES:
rogue.nextGame = NG_NOTHING;
printHighScores(false);
break;
case NG_SCUM:
rogue.nextGame = NG_NOTHING;
scum(1, 1000, 5);
break;
case NG_QUIT:
// No need to do anything.
break;
default:
break;
}
} while (rogue.nextGame != NG_QUIT);
}
GameEngine::GameEngine(SDL_Renderer * renderer)
{
this->renderer = renderer;
this->menu = new Menu(renderer);
//this->logic = new Logic();
this->mapEditor = new MapEditor(renderer);
this->userInput = new UserInput();
this->renderObject = new RenderObject(renderer);
//this->logic = new Logic();
this->critterFactory = new CritterFactory();
renderObject->setRenderer();
//Renders basic menu and default grid
menu->renderMenu();
mapEditor->drawGrid();
//mapEditor->renderToTextureGrid();
//mapEditor->renderGrid();
SDL_RenderPresent(renderer);
//Here input the userinput option, for the user to decide between picking one map or another map;
//Phase 1, user decides between loading a premade map, or editting their own map
menu->renderEditOrPremade();
switch (UserInput::mapEditorSelect(0))
{
case 1:
//menu loads a "finished" button
//Edit their own map
mapEditor->editGrid(0);
//Turn map into file. Not used.
mapEditor->makePremade();
break;
case 2:
//menu loads options;
menu->renderPremadeMapSelection();
//Load premade map from map folder
mapEditor->loadPremade();
//draw premade map;
mapEditor->drawGrid();
}
menu->renderStartEnd();
//Set starting and ending points
switch (UserInput::mapEditorSelect(0))
{
case 1:
mapEditor->editGrid(1);
break;
case 2:
mapEditor->editGrid(2);
break;
}
switch (UserInput::mapEditorSelect(0))
{
case 1:
mapEditor->editGrid(1);
break;
case 2:
mapEditor->editGrid(2);
break;
}
//TESTING THE PATH;
mapEditor->pathTest();
//CREATE THE FINAL GRID;
mapEditor->renderToTextureGrid();
menu->renderMenu();
mapEditor->renderGrid();
SDL_RenderPresent(renderer);
//FINISHED PREPARATION
//GAME STARTS HERE
startLevel();
//Render to texture
//mapEditor->completeGridRender();
///START THE GAME!
}
int main(int argc, char *argv[])
{
int i;
float r = 0;
Space *space;
Entity *cube1,*cube2;
char bGameLoopRunning = 1;
Vec3D cameraPosition = {-10,3,0};
Vec3D cameraRotation = {180,0,180};
SDL_Event e;
Obj *bgobj;
Sprite *bgtext;
//my variables
Ship *playerShip;
int specMode;
init_logger("gametest3d.log");
if (graphics3d_init(1024,768,1,"gametest3d",33) != 0)
{
return -1;
}
model_init();
obj_init();
entity_init(255);
initShips();
bgobj = obj_load("models/mountainvillage.obj");
bgtext = LoadSprite("models/mountain_text.png",1024,1024);
//cube1 = newCube(vec3d(0,0,0),"Cubert");
//cube2 = newCube(vec3d(10,0,0),"Hobbes");
//cube1->body.velocity.x = 0.1;
space = space_new();
space_set_steps(space,100);
space_add_body(space,&cube1->body);
space_add_body(space,&cube2->body);
//my variables
specMode = 0;
numShips = 0;
shipVel = 0;
shipRot = 0;
turretRot = 0;
gunElev = 0;
realTurrRot = 0;
playerShip = spawnShip(space, vec3d(-10,0,0), 1);
while (bGameLoopRunning)
{
updateAllShipPos();
for (i = 0; i < 100;i++)
{
space_do_step(space);
}
updateAllShipComp();
applyGrav();
if(specMode == 0)
{
cameraPosition.x = playerShip->hull->body.position.x;
cameraPosition.y = (playerShip->hull->body.position.y + 5);
cameraPosition.z = playerShip->hull->body.position.z;
}
while ( SDL_PollEvent(&e) )
{
if (e.type == SDL_QUIT)
{
bGameLoopRunning = 0;
}
else if (e.type == SDL_KEYDOWN)
{
if (e.key.keysym.sym == SDLK_ESCAPE)
{
bGameLoopRunning = 0;
}
else if (e.key.keysym.sym == SDLK_SPACE)
{
cameraPosition.z++;
}
else if (e.key.keysym.sym == SDLK_z)
{
cameraPosition.z--;
}
else if (e.key.keysym.sym == SDLK_w)
{
vec3d_add(
cameraPosition,
cameraPosition,
vec3d(
-sin(cameraRotation.z * DEGTORAD),
cos(cameraRotation.z * DEGTORAD),
0
));
}
else if (e.key.keysym.sym == SDLK_s)
{
vec3d_add(
cameraPosition,
cameraPosition,
vec3d(
sin(cameraRotation.z * DEGTORAD),
-cos(cameraRotation.z * DEGTORAD),
0
));
}
else if (e.key.keysym.sym == SDLK_d)
{
vec3d_add(
cameraPosition,
cameraPosition,
vec3d(
cos(cameraRotation.z * DEGTORAD),
sin(cameraRotation.z * DEGTORAD),
0
));
}
else if (e.key.keysym.sym == SDLK_a)
{
vec3d_add(
cameraPosition,
cameraPosition,
vec3d(
-cos(cameraRotation.z * DEGTORAD),
-sin(cameraRotation.z * DEGTORAD),
0
));
}
else if (e.key.keysym.sym == SDLK_LEFT)
{
cameraRotation.y -= 1;
}
else if (e.key.keysym.sym == SDLK_RIGHT)
{
cameraRotation.y += 1;
}
else if (e.key.keysym.sym == SDLK_UP)
{
cameraRotation.x += 1;
}
else if (e.key.keysym.sym == SDLK_DOWN)
{
cameraRotation.x -= 1;
}
else if (e.key.keysym.sym == SDLK_y && shipVel < 0.4)
{
shipVel += 0.1;
}
else if (e.key.keysym.sym == SDLK_h && shipVel > 0.05)
{
shipVel -= 0.1;
}
else if (e.key.keysym.sym == SDLK_j)
{
shipRot += 0.5;
if(shipRot >= 360){shipRot -= 360;}
}
else if (e.key.keysym.sym == SDLK_g)
{
shipRot -= 0.5;
if(shipRot < 0){shipRot += 360;}
}
else if (e.key.keysym.sym == SDLK_m && turretRot < 135)
{
turretRot += 1;
}
else if (e.key.keysym.sym == SDLK_b && turretRot > -135)
{
turretRot -= 1;
}
else if (e.key.keysym.sym == SDLK_o && gunElev < 50)
{
gunElev += 0.5;
}
else if (e.key.keysym.sym == SDLK_l && gunElev > -5)
{
gunElev -= 0.5;
}
else if (e.key.keysym.sym == SDLK_q)
{
if(specMode == 0){specMode = 1;}
else {specMode = 0;}
}
else if (e.key.keysym.sym == SDLK_p)
{
fireBullet(space, playerShip->gun->body.position, realTurrRot, gunElev, 0.5, -1);
}
else if (e.key.keysym.sym == SDLK_x)
{
fireBullet(space, playerShip->hull->body.position, shipRot, 0, 0, -2);
}
else if (e.key.keysym.sym == SDLK_1)
{
startLevel(space, 1);
}
else if (e.key.keysym.sym == SDLK_2)
{
startLevel(space, 2);
}
else if (e.key.keysym.sym == SDLK_3)
{
startLevel(space, 3);
}
}
}
graphics3d_frame_begin();
glPushMatrix();
set_camera(
cameraPosition,
cameraRotation);
entity_draw_all();
//updateAllShipModels();
obj_draw(
bgobj,
vec3d(0,0,2),
vec3d(90,90,0),
vec3d(5,5,5),
vec4d(1,1,1,1),
bgtext
);
if (r > 360)r -= 360;
glPopMatrix();
/* drawing code above here! */
graphics3d_next_frame();
}
return 0;
}
//----------------------------------------------------------------------------------------------------------------------
GameWorld::GameWorld(int _level)
{
L = luaL_newstate();
registerLua(L);
m_entityMgr = new EntityManager();
m_win = 0;
m_lose = 0;
m_numberOfRiotersDead = 0;
m_numberOfRiotersHome = 0;
m_activePolice = 0;
m_resetID = 1;
// get a different lua level based in input level
switch (_level)
{
case 1 :
{
luabridge::LuaRef startLevel = luabridge::getGlobal(L, "level1");
startLevel();
break;
}
case 2 :
{
luabridge::LuaRef startLevel = luabridge::getGlobal(L, "level2");
startLevel();
break;
}
case 3 :
{
luabridge::LuaRef startLevel = luabridge::getGlobal(L, "level3");
startLevel();
break;
}
case 4 :
{
luabridge::LuaRef startLevel = luabridge::getGlobal(L, "level4");
startLevel();
break;
}
case 5 :
{
luabridge::LuaRef startLevel = luabridge::getGlobal(L, "level5");
startLevel();
break;
}
default :
{
std::cout<<"Error: Invalid level"<<std::endl;
break;
}
}
// load in the meshes
m_streetMesh = new ngl::Obj(m_streetMeshFile); //Obj for roads, should be tris
m_buildingMesh = new ngl::Obj(m_buildingMeshFile); //Obj for buildings, should be tris
m_streetMesh->createVAO();
m_buildingMesh->createVAO();
m_cellGraph = new CellGraph(m_cellGraphFile, 1); //Obj for cell graph, must be quads
m_cellGraph->generateWalls();
m_policeMesh = new ngl::Obj("models/policeMan.obj");
m_rioterMesh = new ngl::Obj("models/rioterMan.obj");
m_treeMesh = new ngl::Obj("models/tree.obj");
m_streetLightMesh = new ngl::Obj("models/streetLight.obj");
std::vector<ngl::Vec3> wallCentres = m_cellGraph->getWallCentres();
std::vector<ngl::Vec3> wallNormals = m_cellGraph->getWallNormals();
std::vector<int> wallRotations = m_cellGraph->getWallRotations();
m_policeMesh->createVAO();
m_rioterMesh->createVAO();
m_treeMesh->createVAO();
m_streetLightMesh->createVAO();
//initialise rioters
for (int i = 0; i < m_initialNumberOfRioters ; ++i)
{
Rioter* newRioter = new Rioter(this, m_rioterMesh);
newRioter->setBoudingRadius(0.5f);
newRioter->setDetectionRadius(3.5f);
newRioter->setHeading(ngl::Vec3(-1+2*((float)rand())/RAND_MAX, 0.f, -1+2*((float)rand())/RAND_MAX));
newRioter->setPos(ngl::Vec3(-25+50*((float)rand())/RAND_MAX, 0.f, -25+50*((float)rand())/RAND_MAX));
m_cellGraph->initializeCells(m_entityMgr->getEntityFromID(newRioter->getID()));
while (newRioter->getCurrentCellID() < 0)
{
newRioter->setPos(ngl::Vec3(-50+100*((float)rand())/RAND_MAX, 0.f, -50+100*((float)rand())/RAND_MAX));
m_cellGraph->initializeCells(m_entityMgr->getEntityFromID(newRioter->getID()));
}
m_rioters.push_back(newRioter);
}
m_numberOfRioters = m_rioters.size();
// initialise trees
for (int i = 0; i < m_numberOfTrees ; ++i)
{
StaticEntity* newTree = new StaticEntity(this, ngl::Vec3(0,0,0),ngl::Vec3(0.0f,360*((float)rand()/RAND_MAX),0.0f),1.0,obstacleTree,m_treeMesh);
newTree->setPos(ngl::Vec3(-25+50*((float)rand())/RAND_MAX, 0.f, -25+50*((float)rand())/RAND_MAX));
m_cellGraph->initializeCells(m_entityMgr->getEntityFromID(newTree->getID()));
while (newTree->getCurrentCellID() < 0)
{
newTree->setPos(ngl::Vec3(-50+100*((float)rand())/RAND_MAX, 0.f, -50+100*((float)rand())/RAND_MAX));
m_cellGraph->initializeCells(m_entityMgr->getEntityFromID(newTree->getID()));
}
m_obstacles.push_back(newTree);
}
int numberOfWalls = wallCentres.size();
//pick random streetlight positions
int sample[m_numberOfStreetLights];
std::vector<int> choices;
int choice;
for (int i=0; i<numberOfWalls; i++)
{
choices.push_back(i);
}
srand (time(NULL));
assert (m_numberOfStreetLights<=numberOfWalls && "too many streetlights for the map size!");
for(int i=0; i<m_numberOfStreetLights; i++)
{
do
{
choice = rand() % numberOfWalls;
}
while((choices[choice]==-1));
choices[choice]=-1; // prevents duplicate choices
sample[i] = choice;
}
for (int i = 0; i < m_numberOfStreetLights ; i++)
{
StaticEntity* newStreetLight = new StaticEntity(this, wallCentres[sample[i]]+(0.3*wallNormals[sample[i]]), ngl::Vec3(0.0f,wallRotations[sample[i]],0.0f), 0.2, obstacleStreetLight, m_streetLightMesh);
m_cellGraph->initializeCells(m_entityMgr->getEntityFromID(newStreetLight->getID()));
m_obstacles.push_back(newStreetLight);
}
m_numberOfObstacles = m_obstacles.size();
}
/** Called whenever the timer goes off. Handles animation and triggers Things' functions for motion
*/
void GameSpace::handleTimer()
{
// Update the player's position, independent of period_; also makes player movement very smooth
player_->updatePrecisePos(WINDOW_MAX_X, WINDOW_MAX_Y);
player_->move();
// If player is invincible, update invincibility
if(timerCount_ % 300 == 0 && player_->invincible()) { player_->invincible()--; }
// Add a new strength potion every number of periods below
if(timerCount_ % 20000 == 0 && level_ > 1)
{
Item* newItem = new PotionStrength(*potionStrengthPic_, this, player_);
// Initialize the potion's position, add it to items list, add it to the scene
newItem->randomPos(WINDOW_MAX_X, WINDOW_MAX_Y);
items_.push_back(newItem);
scene_->addItem(newItem);
}
// Check if new level is reached
if( (timerCount_%(50000+30000*level_) == 0) && (level_ < 3)) { startLevel(true, level_+1); return; }
if(timerCount_ % period_ == 0)
{
// ------------------- ADD NEW THINGS ----------------------
// Add a new enemy every specified number of periods
if(periodCount_ % 63 == 0)
{
Thing* newEnemy = NULL;
switch(rand()%(level_+2))
{
case 0: newEnemy = new Zombie(*zombiePic_, this, player_);
break;
case 1: newEnemy = new Spider(*spiderPic_, this, player_);
break;
case 2: newEnemy = new Creeper(*creeperPic_, this, player_);
break;
case 3: newEnemy = new Skeleton(*skeletonPic_, this, player_);
break;
case 4: newEnemy = new Enderman(*endermanPic_, this, player_);
break;
}
// Initialize the enemy's position
newEnemy->randomPos(WINDOW_MAX_X, WINDOW_MAX_Y);
// Add the enemy to the list of enemies and to the scene
enemies_.push_back(newEnemy);
scene_->addItem(newEnemy);
}
// Add a new heart every number of periods below
if(periodCount_ % 376 == 0)
{
Item* newItem = new Heart(*heartPic_, this, player_);
// Initialize the heart's position, add it to vector, add it to the scene
newItem->randomPos(WINDOW_MAX_X, WINDOW_MAX_Y);
items_.push_back(newItem);
scene_->addItem(newItem);
}
// ------------------------ UPDATE THINGS ---------------------------------
// Update each item & check for collisions between items and the player
for(unsigned int i = 0; i < items_.size(); i++)
{
// Move the item (hearts don't move, potions do)
items_[i]->updatePrecisePos(WINDOW_MAX_X, WINDOW_MAX_Y);
items_[i]->move();
if(items_[i]->collidesWithItem(player_))
{
items_[i]->playerEffect();
score_+=100;
delete items_[i]; // remove from scene & delete data
items_.erase(items_.begin()+i); // remove pointer form vector
}
}
// Update each enemy & check for collisions
for(unsigned int i = 0; i < enemies_.size(); i++)
{
enemies_[i]->updatePrecisePos(WINDOW_MAX_X, WINDOW_MAX_Y);
enemies_[i]->move();
if(enemies_[i]->collidesWithItem(player_))
{
delete enemies_[i]; // remove from scene & delete data
enemies_.erase(enemies_.begin()+i); // remove pointer form vector
if(player_->invincible()==0) player_->changeHealth(-1); // if player is not invincible, give him damage
if(gameOverFlag_) return; // in case a game ends when the player's health changes, stop trying to detect collisions
}
}
// Update score
if(periodCount_ % 4 == 0 && !gameOverFlag_) score_++;
// Update MainWindow's labels
parent_->updateLabels();
// Increase period count
periodCount_++;
}
// Every certain number of timer pulses, speed up the game by decreasing the period (does not affect player's speed)
if(timerCount_ % 18000 == 0 && period_ > 8) period_--;
timerCount_++;
}
void menuNewGame(void) {
if (pgMessageDialog("Give Up","Start over at level 1?",
PG_MSGBTN_YES | PG_MSGBTN_NO) == PG_MSGBTN_YES)
startLevel(1);
}
void menuRestartLevel(void) {
if (pgMessageDialogFmt("Scratching Head",
PG_MSGBTN_YES | PG_MSGBTN_NO,
"Try level %d again?",level) == PG_MSGBTN_YES)
startLevel(level);
}
void NormalGameModeManager::changeLevel(int lvl) {
startLevel(lvl);
generateLeaves(0, theHeriswapGridSystem.Types);
uiHelper.game->setupGameProp();
}
void World::nextLevel() {
startLevel(currentLevel+1);
}
