void CompositeStochasticTask::random_child(Agent* pAgent) { BEHAVIAC_ASSERT(!this->GetNode() || CompositeStochastic::DynamicCast(this->GetNode())); const CompositeStochastic* pNode = (const CompositeStochastic*)(this->GetNode()); if (this->m_set.size() != this->m_children.size()) { this->m_set.resize(this->m_children.size()); } uint32_t n = this->m_set.size(); for (uint32_t i = 0; i < n; ++i) { this->m_set[i] = i; } for (uint32_t i = 0; i < n; ++i) { uint32_t index1 = (uint32_t)(n * GetRandomValue(pNode ? pNode->m_method : 0, pAgent)); BEHAVIAC_ASSERT(index1 < n); uint32_t index2 = (uint32_t)(n * GetRandomValue(pNode ? pNode->m_method : 0, pAgent)); BEHAVIAC_ASSERT(index2 < n); //swap if (index1 != index2) { uint32_t old = this->m_set[index1]; this->m_set[index1] = this->m_set[index2]; this->m_set[index2] = old; } } }
static void UpdateIncomingFire() { static int missileIndex = 0; // Launch missile if (framesCounter % MISSILE_LAUNCH_FRAMES == 0) { float module; float sideX; float sideY; // Activate the missile missile[missileIndex].active = true; // Assign start position missile[missileIndex].origin = (Vector2){ GetRandomValue(20, screenWidth - 20), -10 }; missile[missileIndex].position = missile[missileIndex].origin; missile[missileIndex].objective = (Vector2){ GetRandomValue(20, screenWidth - 20), screenHeight + 10 }; // Calculate speed module = sqrt( pow(missile[missileIndex].objective.x - missile[missileIndex].origin.x, 2) + pow(missile[missileIndex].objective.y - missile[missileIndex].origin.y, 2)); sideX = (missile[missileIndex].objective.x - missile[missileIndex].origin.x)*MISSILE_SPEED/module; sideY = (missile[missileIndex].objective.y - missile[missileIndex].origin.y)*MISSILE_SPEED/module; missile[missileIndex].speed = (Vector2){ sideX, sideY }; // Update missileIndex++; if (missileIndex == MAX_MISSILES) missileIndex = 0; } }
//------------------------------------------------------------------------------ CRenderAudio::CRenderAudio(const CRegionAI& AudioInfo,const SString& AudioName,ILogicHandler* pHandler) : CRenderNode(pHandler),m_uUnitSetIndex(0) { m_pAEmitter = GetAudioModule()->CreateAudioEmitter(); m_pAEmitter->SetAutoStop(true); m_uUnitSetIndex = AudioInfo.SetIndex; SetPosition(AudioInfo.cX,AudioInfo.cY,AudioInfo.cZ); m_bPlayNotRepeat = AudioInfo.bPlayNotRepeat; m_uPlayTimeLenMin = AudioInfo.uPlayTimeLenMin; m_uPlayTimeLenMax = AudioInfo.uPlayTimeLenMax; m_uPlayIntervalMin = AudioInfo.uPlayIntervalMin; m_uPlayIntervalMax = AudioInfo.uPlayIntervalMax; m_uCurRandomPlayTime = GetRandomValue(m_uPlayTimeLenMin, m_uPlayTimeLenMax); m_uCurRandomInterval = GetRandomValue(m_uPlayIntervalMin, m_uPlayIntervalMax); m_strAudioName = AudioName; CVector3f mMin = CVector3f(-30.0f, 0.0f, -30.0f); CVector3f mMax = CVector3f( 30.0f, 60.0f, 30.0f); float fRange = eGridSpan * AudioRange; mMin = mMin - CVector3f(fRange, fRange, fRange); mMax = mMax + CVector3f(fRange, fRange, fRange); m_OrgAABB.setExtents(mMin, mMax); UpdateBox(); m_pAEmitter->SetPosition(GetPosition()); m_bNeedPlayBegin = true; m_bNeedIntervalBegin = true; m_bPlayError = false; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values"); int framesCounter = 0; // Variable used to count frames int randValue = GetRandomValue(-8,5); // Get a random integer number between -8 and 5 (both included) SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- framesCounter++; // Every two seconds (120 frames) a new random value is generated if (((framesCounter/120)%2) == 1) { randValue = GetRandomValue(-8,5); framesCounter = 0; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON); DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
static void inline PlasmaPixel(Image *image,double x,double y) { register PixelPacket *q; q=GetImagePixels(image,(long) ceil(x-0.5),(long) ceil(y-0.5),1,1); if (q == (PixelPacket *) NULL) return; q->red=ScaleAnyToQuantum(GetRandomValue(),1.0); q->green=ScaleAnyToQuantum(GetRandomValue(),1.0); q->blue=ScaleAnyToQuantum(GetRandomValue(),1.0); (void) SyncImagePixels(image); }
void InitialiseScene(void) { //Code for the rigid bodies is now nice and tidy, but look at cleaning up Sweep and Prune / Better visualising it! prevFrameTimeSinceStart = glutGet(GLUT_ELAPSED_TIME); bodyShader = new Shader("vTexture.shader", "fTexture.shader"); lineShader = new Shader("vLine.shader", "fLine.shader"); simpleCamera = new SimpleCamera(); sceneBodies.push_back(new BasicCube()); for(int i = 1; i < rigidBodyCount; i++) sceneBodies.push_back(new BasicCube(glm::vec3(GetRandomValue(-1.0f, 1.0f), GetRandomValue(-1.0f, 1.0f), GetRandomValue(-1.0f, 1.0f)), glm::vec3(GetRandomValue(-1.0f, 1.0f), GetRandomValue(-1.0f, 1.0f), GetRandomValue(-1.0f, 1.0f)), glm::vec3(GetRandomValue(-1.0f, 1.0f), GetRandomValue(-1.0f, 1.0f), GetRandomValue(-1.0f, 1.0f)))); curSelectedCube = sceneBodies[0]; for(int i = 0; i < sceneBodies.size(); i++) AddToSweepPrune(sceneBodies[i]->GetBoundingBox()); activeColliders.resize(sceneBodies.size()); collisionTable = vector<vector<int>>(); collisionTable.resize(sceneBodies.size()); for(int i = 0; i < sceneBodies.size(); i++) { collisionTable[i].resize(sceneBodies.size()); for(int j = 0; j < sceneBodies.size(); j++) { collisionTable[i][j] = 0; } } SortSweepPrune(); }
// Initialize game variables void InitGame(void) { // Initialize game variables shootRate = 0; pause = false; gameOver = false; victory = false; smooth = false; wave = FIRST; activeEnemies = FIRST_WAVE; enemiesKill = 0; score = 0; alpha = 0; // Initialize player player.rec.x = 20; player.rec.y = 50; player.rec.width = 20; player.rec.height = 20; player.speed.x = 5; player.speed.y = 5; player.color = BLACK; // Initialize enemies for (int i = 0; i < NUM_MAX_ENEMIES; i++) { enemy[i].rec.width = 10; enemy[i].rec.height = 10; enemy[i].rec.x = GetRandomValue(screenWidth, screenWidth + 1000); enemy[i].rec.y = GetRandomValue(0, screenHeight - enemy[i].rec.height); enemy[i].speed.x = 5; enemy[i].speed.y = 5; enemy[i].active = true; enemy[i].color = GRAY; } // Initialize shoots for (int i = 0; i < NUM_SHOOTS; i++) { shoot[i].rec.x = player.rec.x; shoot[i].rec.y = player.rec.y + player.rec.height/4; shoot[i].rec.width = 10; shoot[i].rec.height = 5; shoot[i].speed.x = 7; shoot[i].speed.y = 0; shoot[i].active = false; shoot[i].color = MAROON; } }
// Level06 Screen Initialization logic void InitLevel06Screen(void) { // Initialize Level06 screen variables here! framesCounter = 0; finishScreen = 0; centerRec = (Rectangle){ GetScreenWidth()/2 - 100, 0, 200, GetScreenHeight() }; for (int i = 0; i < 4; i++) { movingRecs[i] = (Rectangle){ GetRandomValue(0, 5)*150, (i*150) + 90, 100, 100 }; stoppedRec[i] = false; speedRecs[i] = GetRandomValue(4, 8); } }
void FluidSim::InitialiseParticles(void) { KernelPow9 = glm::pow(SmoothingKernelSize, 9.0f); KernelPow6 = glm::pow(SmoothingKernelSize, 6.0f); KernelPow2 = glm::pow(SmoothingKernelSize, 2.0f); float pi = glm::pi<float>(); DefaultKernelConstant = 315.0f / (64.0f * pi * KernelPow9); NormalKernelConstant = -945.0f / (32.0f * pi * KernelPow9); SurfaceKernelConstant = NormalKernelConstant; PressureKernelConstant = -45.0f / (pi * KernelPow6); ViscosityKernelConstant = 45.0f / (pi * KernelPow6); particles.reserve(ParticleCount); for(int x = 0; x < ParticlesPerDimension; x++) for(int y = 0; y < ParticlesPerDimension; y++) for(int z = 0; z < ParticlesPerDimension; z++) { Particle* particle = new Particle(ParticleMass); particle->SetPosition(GetRandomValue(-HorizontalBounds, HorizontalBounds), GetRandomValue(0.0f, HorizontalBounds), GetRandomValue(-HorizontalBounds, HorizontalBounds)); //particle->SetPosition(0.0f, 0.0f, 0.0f); particle->SetVelocity(0.0f, 0.0f, 0.0f); particles.push_back(particle); } container = Capsule(); container.radius = HorizontalBounds; container.length = HorizontalBounds; container.centre = glm::vec3(); innerContainer = Capsule(); innerRadius = HorizontalBounds / 2.0f; innerLength = HorizontalBounds / 2.0f; innerContainer.radius = innerRadius; innerContainer.length = innerLength; innerContainer.centre = glm::vec3(); container.CalculateCapsulePosition(glm::vec3()); innerContainer.CalculateCapsulePosition(glm::vec3()); crashCapsule = brokenCapsule = showNeighbours = showSurfaceParticles = hideSurfaceParticles = false; particleHighlightID = 0; wallEnabled = true; }
static inline void PlasmaPixel(Image *image,double x,double y) { register PixelPacket *q; q=GetImagePixels(image,(long) ceil(x-0.5),(long) ceil(y-0.5),1,1); if (q == (PixelPacket *) NULL) return; q->red=ScaleAnyToQuantum((unsigned long) (65535.0*GetRandomValue()+0.5),16UL); q->green=ScaleAnyToQuantum((unsigned long) (65535.0*GetRandomValue()+0.5),16UL); q->blue=ScaleAnyToQuantum((unsigned long) (65535.0*GetRandomValue()+0.5),16UL); (void) SyncImagePixels(image); }
int main() { srand(static_cast<unsigned>(time(NULL))); double variables[MaxVarCount]; for (int i = 0; i < MaxVarCount; i++) { variables[i] = GetRandomValue(MaxVarValue); } std::map<std::string, double> expressions; std::ofstream output; output.open("../ADTest/TestFunctions.h"); std::vector<std::string> lines; lines.push_back("#ifndef TESTFUNCTIONS_H"); lines.push_back("#define TESTFUNCTIONS_H"); lines.push_back(""); lines.push_back("const int DataInSize = " + IntToStr(MaxVarCount) + ";"); lines.push_back("const int SimpleTestCases = " + IntToStr(SimpleTestCases) + ";"); lines.push_back("const int ComplexTestCases = " + IntToStr(ComplexTestCases) + ";"); lines.push_back("const int LoopTestCases = " + IntToStr(LoopTestCases) + ";"); lines.push_back("const int TotalTestCases = " + IntToStr(TotalTestCases) + ";"); lines.push_back("const int LoopIterations = " + IntToStr(LoopIterations) + ";"); lines.push_back(""); std::string arguments = ""; for (int i = 0; i < MaxVarCount; i++) { arguments += DoubleToStr(variables[i]) + ", "; } arguments = arguments.substr(0, arguments.size() - 2); lines.push_back("const real realArgs[DataInSize] = {" + arguments + "};"); lines.push_back(""); lines.push_back("template<typename ADType>"); lines.push_back("struct FunctionBase {"); lines.push_back(" virtual ADType TestFunction(const ADType(&x)[DataInSize]) = 0;"); lines.push_back("};"); lines.push_back(""); GenerateSimpleTestCases(0, lines, expressions, variables); GenerateComplexTestCases(SimpleTestCases, lines, expressions, variables); GenerateLoopTestCases(SimpleTestCases + ComplexTestCases, lines, expressions, variables); lines.push_back("template<typename ADType>"); lines.push_back("void Initialize(FunctionBase<ADType>* testArray[TotalTestCases]) {"); for (int i = 0; i < TotalTestCases; i++) { lines.push_back(" testArray[" + IntToStr(i) + "] = new FunctionSpec" + IntToStr(i) + "<ADType>();"); } lines.push_back("};"); lines.push_back(""); lines.push_back("template<typename ADType>"); lines.push_back("void Finalize(FunctionBase<ADType>* testArray[TotalTestCases]) {"); lines.push_back(" for (int i = 0; i < TotalTestCases; i++)"); lines.push_back(" delete testArray[i]; "); lines.push_back("};"); lines.push_back(""); lines.push_back("#endif // TESTFUNCTIONS_H"); for (std::vector<std::string>::iterator line = lines.begin(); line != lines.end(); line++) { output << *line << '\n'; } output.close(); return 0; };
void AddConstants(std::map<std::string, double>& expressions) { for (int i = 0; i < MaxConstCount; i++) { double constant = GetRandomValue(MaxConstValue); std::string key = DoubleToStr(constant); if (constant < 0.0) { key = "(" + key + ")"; } expressions[key] = constant; } };
EBTStatus SelectorProbabilityTask::update(Agent* pAgent, EBTStatus childStatus) { BEHAVIAC_ASSERT(SelectorProbability::DynamicCast(this->GetNode())); const SelectorProbability* pSelectorProbabilityNode = (const SelectorProbability*)(this->GetNode()); if (childStatus != BT_RUNNING) { return childStatus; } //check if we've already chosen a node to run if (this->m_activeChildIndex != CompositeTask::InvalidChildIndex) { BehaviorTask* pNode = this->m_children[this->m_activeChildIndex]; EBTStatus status = pNode->exec(pAgent); return status; } BEHAVIAC_ASSERT(this->m_weightingMap.size() == this->m_children.size()); //generate a number between 0 and the sum of the weights double chosen = this->m_totalSum * GetRandomValue(pSelectorProbabilityNode->m_method, pAgent); double sum = 0; for (uint32_t i = 0; i < this->m_children.size() ; ++i) { int w = this->m_weightingMap[i]; sum += w; if (w > 0 && sum >= chosen) //execute this node { BehaviorTask* pChild = this->m_children[i]; EBTStatus status = pChild->exec(pAgent); if (status == BT_RUNNING) { this->m_activeChildIndex = i; } else { this->m_activeChildIndex = CompositeTask::InvalidChildIndex; } return status; } } return BT_FAILURE; }
// FAST LOOP: 50 Hz-ish void RAMBLERBot::loop50Hz() { // Check if the speed should accelerate or decelerate if (speedLimit(&motor_left_, motor_left_goal_)) { motors_.setLeftSpeed(motor_left_); } // Check if the speed should accelerate or decelerate if (speedLimit(&motor_right_, motor_right_goal_)) { motors_.setRightSpeed(motor_right_); } // Reset 50 Hz Count if necessary if (++count50Hz_ >= 5) { count50Hz_ = 0; } // Perform Operations on the 50 Hz time if (count50Hz_ == 1) { rand1_ = GetRandomValue(); } if (count50Hz_ == 2) { rand2_ = GetRandomValue(); } if (count50Hz_ == 3) { rand3_ = GetRandomValue(); } if (count50Hz_ == 4) { whiskers_.GetWhiskerValues(&ant_right_, &ant_left_); } }
int main(void) { // Initialization //-------------------------------------------------------------------------------------- const int screenWidth = 800; const int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles blending"); // Particles pool, reuse them! Particle mouseTail[MAX_PARTICLES] = { 0 }; // Initialize particles for (int i = 0; i < MAX_PARTICLES; i++) { mouseTail[i].position = (Vector2){ 0, 0 }; mouseTail[i].color = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; mouseTail[i].alpha = 1.0f; mouseTail[i].size = (float)GetRandomValue(1, 30)/20.0f; mouseTail[i].rotation = (float)GetRandomValue(0, 360); mouseTail[i].active = false; } float gravity = 3.0f; Texture2D smoke = LoadTexture("resources/smoke.png"); int blending = BLEND_ALPHA; SetTargetFPS(60); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // Activate one particle every frame and Update active particles // NOTE: Particles initial position should be mouse position when activated // NOTE: Particles fall down with gravity and rotation... and disappear after 2 seconds (alpha = 0) // NOTE: When a particle disappears, active = false and it can be reused. for (int i = 0; i < MAX_PARTICLES; i++) { if (!mouseTail[i].active) { mouseTail[i].active = true; mouseTail[i].alpha = 1.0f; mouseTail[i].position = GetMousePosition(); i = MAX_PARTICLES; } } for (int i = 0; i < MAX_PARTICLES; i++) { if (mouseTail[i].active) { mouseTail[i].position.y += gravity; mouseTail[i].alpha -= 0.01f; if (mouseTail[i].alpha <= 0.0f) mouseTail[i].active = false; mouseTail[i].rotation += 5.0f; } } if (IsKeyPressed(KEY_SPACE)) { if (blending == BLEND_ALPHA) blending = BLEND_ADDITIVE; else blending = BLEND_ALPHA; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(DARKGRAY); BeginBlendMode(blending); // Draw active particles for (int i = 0; i < MAX_PARTICLES; i++) { if (mouseTail[i].active) DrawTexturePro(smoke, (Rectangle){ 0.0f, 0.0f, (float)smoke.width, (float)smoke.height }, (Rectangle){ mouseTail[i].position.x, mouseTail[i].position.y, smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size }, (Vector2){ (float)(smoke.width*mouseTail[i].size/2.0f), (float)(smoke.height*mouseTail[i].size/2.0f) }, mouseTail[i].rotation, Fade(mouseTail[i].color, mouseTail[i].alpha)); } EndBlendMode(); DrawText("PRESS SPACE to CHANGE BLENDING MODE", 180, 20, 20, BLACK); if (blending == BLEND_ALPHA) DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK); else DrawText("ADDITIVE BLENDING", 280, screenHeight - 40, 20, RAYWHITE); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(smoke); CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
// Ending Screen Initialization logic void InitEndingScreen(void) { framesCounter = -10; finishScreen = 0; drawTimer = 15; replayTimer = 0; replaying = false; finalYears = initYears + (seasons/4); yearsElapsed = seasons/4; playButton = (Rectangle){ GetScreenWidth()*0.871, GetScreenHeight()*0.096, 123, 123}; shopButton = (Rectangle){ GetScreenWidth()*0.871, GetScreenHeight()*0.303, 123, 123}; trophyButton = (Rectangle){ GetScreenWidth()*0.871, GetScreenHeight()*0.513, 123, 123}; shareButton = (Rectangle){ GetScreenWidth()*0.871, GetScreenHeight()*0.719, 123, 123}; buttonPlayColor = WHITE; buttonShopColor = WHITE; buttonTrophyColor = WHITE; buttonShareColor = WHITE; currentScore = 0; seasonsCounter = 0; currentLeavesEnding = 0; endingCounter = DELAY; backgroundColor = (Color){ 176, 167, 151, 255}; for (int j = 0; j < 20; j++) { leafParticles[j].active = false; leafParticles[j].position = (Vector2){ GetRandomValue(-20, 20), GetRandomValue(-20, 20) }; leafParticles[j].speed = (Vector2){ (float)GetRandomValue(-500, 500)/100, (float)GetRandomValue(-500, 500)/100 }; leafParticles[j].size = (float)GetRandomValue(3, 10)/5; leafParticles[j].rotation = GetRandomValue(0, 360); leafParticles[j].color = WHITE; leafParticles[j].alpha = 1; } // Seasons death texts if (initSeason == 0) { sprintf(initMonthText, "SUMMER"); clockRotation = 225; initRotation = 225; } else if (initSeason == 1) { sprintf(initMonthText, "AUTUMN"); clockRotation = 135; initRotation = 135; } else if (initSeason == 2) { sprintf(initMonthText, "WINTER"); clockRotation = 45; initRotation = 45; } else if (initSeason == 3) { sprintf(initMonthText, "SPRING"); clockRotation = 315; initRotation = 315; } if (currentSeason == 0) { sprintf(finalMonthText, "SUMMER"); finalRotation = 225 + 360*yearsElapsed; } else if (currentSeason == 1) { sprintf(finalMonthText, "AUTUMN"); finalRotation = 135 + 360*yearsElapsed; } else if (currentSeason == 2) { sprintf(finalMonthText, "WINTER"); finalRotation = 45 + 360*yearsElapsed; } else if (currentSeason == 3) { sprintf(finalMonthText, "SPRING"); finalRotation = 315 + 360*yearsElapsed; } for (int i = 0; i < MAX_KILLS; i++) active[i] = false; }
int main() { // Initialization //-------------------------------------------------------------------------------------- const int screenWidth = 1280; const int screenHeight = 720; // Init window ShowLogo(); InitWindow(screenWidth, screenHeight, "Dr. Turtle & Mr. GAMERA"); // Initialize audio device InitAudioDevice(); // Load game resources: textures Texture2D sky = LoadTexture("resources/sky.png"); Texture2D mountains = LoadTexture("resources/mountains.png"); Texture2D sea = LoadTexture("resources/sea.png"); Texture2D title = LoadTexture("resources/title.png"); Texture2D turtle = LoadTexture("resources/turtle.png"); Texture2D gamera = LoadTexture("resources/gamera.png"); Texture2D shark = LoadTexture("resources/shark.png"); Texture2D orca = LoadTexture("resources/orca.png"); Texture2D swhale = LoadTexture("resources/swhale.png"); Texture2D fish = LoadTexture("resources/fish.png"); Texture2D gframe = LoadTexture("resources/gframe.png"); // Load game resources: fonts SpriteFont font = LoadSpriteFont("resources/komika.png"); // Load game resources: sounds Sound eat = LoadSound("resources/eat.wav"); Sound die = LoadSound("resources/die.wav"); Sound growl = LoadSound("resources/gamera.wav"); // Start playing streaming music PlayMusicStream("resources/speeding.ogg"); // Define scrolling variables int backScrolling = 0; int seaScrolling = 0; // Define current screen GameScreen currentScreen = TITLE; // Define player variables int playerRail = 1; Rectangle playerBounds = { 30 + 14, playerRail*120 + 90 + 14, 100, 100 }; bool gameraMode = false; // Define enemies variables Rectangle enemyBounds[MAX_ENEMIES]; int enemyRail[MAX_ENEMIES]; int enemyType[MAX_ENEMIES]; bool enemyActive[MAX_ENEMIES]; float enemySpeed = 10; // Init enemies variables for (int i = 0; i < MAX_ENEMIES; i++) { // Define enemy type (all same probability) //enemyType[i] = GetRandomValue(0, 3); // Probability system for enemies type int enemyProb = GetRandomValue(0, 100); if (enemyProb < 30) enemyType[i] = 0; else if (enemyProb < 60) enemyType[i] = 1; else if (enemyProb < 90) enemyType[i] = 2; else enemyType[i] = 3; // define enemy rail enemyRail[i] = GetRandomValue(0, 4); // Make sure not two consecutive enemies in the same row if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; enemyActive[i] = false; } // Define additional game variables int score = 0; float distance = 0.0f; int hiscore = 0; float hidistance = 0.0f; int foodBar = 0; int framesCounter = 0; unsigned char blue = 200; float timeCounter = 0; SetTargetFPS(60); // Setup game frames per second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- framesCounter++; // Sea color tint effect blue = 210 + 25 * sin(timeCounter); timeCounter += 0.01; // Game screens management switch (currentScreen) { case TITLE: { // Sea scrolling seaScrolling -= 2; if (seaScrolling <= -screenWidth) seaScrolling = 0; // Press enter to change to gameplay screen if (IsKeyPressed(KEY_ENTER)) { currentScreen = GAMEPLAY; framesCounter = 0; } } break; case GAMEPLAY: { // Background scrolling logic backScrolling--; if (backScrolling <= -screenWidth) backScrolling = 0; // Sea scrolling logic seaScrolling -= (enemySpeed - 2); if (seaScrolling <= -screenWidth) seaScrolling = 0; // Player movement logic if (IsKeyPressed(KEY_DOWN)) playerRail++; else if (IsKeyPressed(KEY_UP)) playerRail--; // Check player not out of rails if (playerRail > 4) playerRail = 4; else if (playerRail < 0) playerRail = 0; // Update player bounds playerBounds = (Rectangle){ 30 + 14, playerRail*120 + 90 + 14, 100, 100 }; // Enemies activation logic (every 40 frames) if (framesCounter > 40) { for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i] == false) { enemyActive[i] = true; i = MAX_ENEMIES; } } framesCounter = 0; } // Enemies logic for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i]) { enemyBounds[i].x -= enemySpeed; } // Check enemies out of screen if (enemyBounds[i].x <= 0 - 128) { enemyActive[i] = false; enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); // Make sure not two consecutive enemies in the same row if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; } } if (!gameraMode) enemySpeed += 0.005; // Check collision player vs enemies for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i]) { if (CheckCollisionRecs(playerBounds, enemyBounds[i])) { if (enemyType[i] < 3) // Bad enemies { if (gameraMode) { if (enemyType[i] == 0) score += 50; else if (enemyType[i] == 1) score += 150; else if (enemyType[i] == 2) score += 300; foodBar += 15; enemyActive[i] = false; // After enemy deactivation, reset enemy parameters to be reused enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); // Make sure not two consecutive enemies in the same row if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; PlaySound(eat); } else { // Player die logic PlaySound(die); currentScreen = ENDING; framesCounter = 0; // Save hiscore and hidistance for next game if (score > hiscore) hiscore = score; if (distance > hidistance) hidistance = distance; } } else // Sweet fish { enemyActive[i] = false; enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); // Make sure not two consecutive enemies in the same row if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; if (!gameraMode) foodBar += 80; else foodBar += 25; score += 10; if (foodBar == 400) { gameraMode = true; PlaySound(growl); } PlaySound(eat); } } } } // Gamera mode logic if (gameraMode) { foodBar--; if (foodBar <= 0) { gameraMode = false; enemySpeed -= 2; if (enemySpeed < 10) enemySpeed = 10; } } // Update distance counter distance += 0.5f; } break; case ENDING: { // Press enter to play again if (IsKeyPressed(KEY_ENTER)) { currentScreen = GAMEPLAY; // Reset player playerRail = 1; playerBounds = (Rectangle){ 30 + 14, playerRail*120 + 90 + 14, 100, 100 }; gameraMode = false; // Reset enemies data for (int i = 0; i < MAX_ENEMIES; i++) { int enemyProb = GetRandomValue(0, 100); if (enemyProb < 30) enemyType[i] = 0; else if (enemyProb < 60) enemyType[i] = 1; else if (enemyProb < 90) enemyType[i] = 2; else enemyType[i] = 3; //enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); // Make sure not two consecutive enemies in the same row if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; enemyActive[i] = false; } enemySpeed = 10; // Reset game variables score = 0; distance = 0.0; foodBar = 0; framesCounter = 0; } } break; default: break; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); // Draw background (common to all screens) DrawTexture(sky, 0, 0, WHITE); DrawTexture(mountains, backScrolling, 0, WHITE); DrawTexture(mountains, screenWidth + backScrolling, 0, WHITE); if (!gameraMode) { DrawTexture(sea, seaScrolling, 0, (Color){ 16, 189, blue, 255}); DrawTexture(sea, screenWidth + seaScrolling, 0, (Color){ 16, 189, blue, 255}); } else { DrawTexture(sea, seaScrolling, 0, (Color){ 255, 113, 66, 255}); DrawTexture(sea, screenWidth + seaScrolling, 0, (Color){ 255, 113, 66, 255}); } switch (currentScreen) { case TITLE: { // Draw title DrawTexture(title, screenWidth/2 - title.width/2, screenHeight/2 - title.height/2 - 80, WHITE); // Draw blinking text if ((framesCounter/30) % 2) DrawTextEx(font, "PRESS ENTER", (Vector2){ screenWidth/2 - 150, 480 }, GetFontBaseSize(font), 0, WHITE); } break; case GAMEPLAY: { // Draw water lines for (int i = 0; i < 5; i++) DrawRectangle(0, i*120 + 120, screenWidth, 110, Fade(SKYBLUE, 0.1f)); // Draw player if (!gameraMode) DrawTexture(turtle, playerBounds.x - 14, playerBounds.y - 14, WHITE); else DrawTexture(gamera, playerBounds.x - 64, playerBounds.y - 64, WHITE); // Draw player bounding box //if (!gameraMode) DrawRectangleRec(playerBounds, Fade(GREEN, 0.4f)); //else DrawRectangleRec(playerBounds, Fade(ORANGE, 0.4f)); // Draw enemies for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i]) { // Draw enemies switch(enemyType[i]) { case 0: DrawTexture(shark, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; case 1: DrawTexture(orca, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; case 2: DrawTexture(swhale, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; case 3: DrawTexture(fish, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; default: break; } // Draw enemies bounding boxes /* switch(enemyType[i]) { case 0: DrawRectangleRec(enemyBounds[i], Fade(RED, 0.5f)); break; case 1: DrawRectangleRec(enemyBounds[i], Fade(RED, 0.5f)); break; case 2: DrawRectangleRec(enemyBounds[i], Fade(RED, 0.5f)); break; case 3: DrawRectangleRec(enemyBounds[i], Fade(GREEN, 0.5f)); break; default: break; } */ } } // Draw gameplay interface DrawRectangle(20, 20, 400, 40, Fade(GRAY, 0.4f)); DrawRectangle(20, 20, foodBar, 40, ORANGE); DrawRectangleLines(20, 20, 400, 40, BLACK); DrawTextEx(font, FormatText("SCORE: %04i", score), (Vector2){ screenWidth - 300, 20 }, GetFontBaseSize(font), -2, ORANGE); DrawTextEx(font, FormatText("DISTANCE: %04i", (int)distance), (Vector2){ 550, 20 }, GetFontBaseSize(font), -2, ORANGE); if (gameraMode) { DrawText("GAMERA MODE", 60, 22, 40, GRAY); DrawTexture(gframe, 0, 0, Fade(WHITE, 0.5f)); } } break; case ENDING: { // Draw a transparent black rectangle that covers all screen DrawRectangle(0, 0, screenWidth, screenHeight, Fade(BLACK, 0.4f)); DrawTextEx(font, "GAME OVER", (Vector2){ 300, 160 }, GetFontBaseSize(font)*3, -2, MAROON); DrawTextEx(font, FormatText("SCORE: %04i", score), (Vector2){ 680, 350 }, GetFontBaseSize(font), -2, GOLD); DrawTextEx(font, FormatText("DISTANCE: %04i", (int)distance), (Vector2){ 290, 350 }, GetFontBaseSize(font), -2, GOLD); DrawTextEx(font, FormatText("HISCORE: %04i", hiscore), (Vector2){ 665, 400 }, GetFontBaseSize(font), -2, ORANGE); DrawTextEx(font, FormatText("HIDISTANCE: %04i", (int)hidistance), (Vector2){ 270, 400 }, GetFontBaseSize(font), -2, ORANGE); // Draw blinking text if ((framesCounter/30) % 2) DrawTextEx(font, "PRESS ENTER to REPLAY", (Vector2){ screenWidth/2 - 250, 520 }, GetFontBaseSize(font), -2, LIGHTGRAY); } break; default: break; } EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- // Unload textures UnloadTexture(sky); UnloadTexture(mountains); UnloadTexture(sea); UnloadTexture(gframe); UnloadTexture(title); UnloadTexture(turtle); UnloadTexture(shark); UnloadTexture(orca); UnloadTexture(swhale); UnloadTexture(fish); UnloadTexture(gamera); // Unload font texture UnloadSpriteFont(font); // Unload sounds UnloadSound(eat); UnloadSound(die); UnloadSound(growl); StopMusicStream(); // Stop music CloseAudioDevice(); // Close audio device CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
// // Swap cards between two hands // // - take a high face card from the nSource hand and swap it // for a lower card in the nDest hand // double CEasyBDoc::SwapPoints(int nDest, int nSource, double fMax, int nGameCode, int nSuitCode, int nSlamCode) { // double fSrcPoints = PLAYER(nSource).CountCardPoints(); double fDestPoints = PLAYER(nDest).CountCardPoints(); CCard *pSrcCard,*pDestCard; double fDiff, fTotalLeft = fMax; int i,nSrcCard,nDestCard,nSrcVal,nDestVal; int nSuit,nOuterLoopCount,nInnerLoopCount; int nTopmostLoopCount = 0; double fValSwapped = 0; do { // values needed to observe Ace/King constraints int numAcesRequired = theApp.GetValue(tnumAcesForSlam,nSlamCode); int numAcesHeld = PLAYER(SOUTH).GetNumCardsOf(ACE) + PLAYER(NORTH).GetNumCardsOf(ACE); int numKingsRequired = theApp.GetValue(tnumKingsForSlam,nSlamCode); int numKingsHeld = PLAYER(SOUTH).GetNumCardsOf(KING) + PLAYER(NORTH).GetNumCardsOf(KING); // first see if there's an honor card in the source hand int nSum = 0; BOOL bIsHonor = FALSE; for(i=0;i<13;i++) { if (ISHONOR(nSource,i)) { bIsHonor = TRUE; break; } // nSum += HONOR_VALUE(PLAYER(nSource).m_holdings[i]->GetFaceValue()); } // if (nSum == 0) if (!bIsHonor) return fValSwapped; // out of high cards // else swap cards randomly // begin outer loop nOuterLoopCount = 0; do { // first grab an honor from the source hand BOOL bInvalid; nInnerLoopCount = 0; do { bInvalid = FALSE; nSrcCard = GetRandomValue(12); pSrcCard = PLAYER(nSource).GetCardByPosition(nSrcCard); nSrcVal = pSrcCard->GetFaceValue(); nSuit = pSrcCard->GetSuit(); // check that dest has cards in this suit if (PLAYER(nDest).GetNumCardsInSuit(nSuit) == 0) { bInvalid = TRUE; } else if (nSuitCode == 1) { // check for suit preference // if minor suit, don't pull a clubs or // diamonds honor above minimum if ( ((nSuit == CLUBS) || (nSuit == DIAMONDS)) && ((nSource == SOUTH) || (nSource == NORTH)) && (nSrcVal >= theApp.GetValue(tnMinTopMinorCard)) ) bInvalid = TRUE; } else if (nSuitCode == 2) { if ( ((nSuit == HEARTS) || (nSuit == SPADES)) && ((nSource == SOUTH) || (nSource == NORTH)) && (nSrcVal >= theApp.GetValue(tnMinTopMajorCard)) ) bInvalid = TRUE; } // if dealing slam, don't pull an ace from N/S // if that will put partnership below limit if ((nGameCode == 2) && (nSrcVal == ACE) && ((nSource == SOUTH) || (nSource == NORTH)) ) { if (numAcesHeld <= numAcesRequired) bInvalid = TRUE; } // likewise, also don't pull a king from N/S // if that will put partnership below limit if ((nGameCode == 2) && (nSrcVal == KING) && ((nSource == SOUTH) || (nSource == NORTH)) ) { if (numKingsHeld <= numKingsRequired) bInvalid = TRUE; } nInnerLoopCount++; } while ( ((!ISHONOR(nSource, nSrcCard)) || (bInvalid)) && (nInnerLoopCount < 40)); if (nInnerLoopCount >= 40) break; // then grab a lesser card from the dest hand of // the same suit // this could fail under certain circumstances nInnerLoopCount = 0; bInvalid = FALSE; do { nDestCard = GetRandomValue(PLAYER(nDest).GetNumCardsInSuit(nSuit)-1); pDestCard = PLAYER(nDest).GetCardInSuit(nSuit,nDestCard); if (pDestCard == NULL) { // shouldn't happen, but does -- dunno why nInnerLoopCount++; continue; } nDestVal = (pDestCard->GetFaceValue() > 10)? pDestCard->GetFaceValue() : 10; fDiff = nSrcVal - nDestVal; // check to see that we don't replace a king with an ace // thus possibly violating a minimum king count requirement if ((nGameCode == 2) && (nSrcVal == ACE) && (nDestVal == KING) && ((nDest == SOUTH) || (nDest == NORTH)) ) { if (numKingsHeld <= numKingsRequired) bInvalid = TRUE; } // increment counter -- this loop could possibly fail nInnerLoopCount++; } while (((fDiff <= 0) || (fDiff > fTotalLeft) || (bInvalid)) && (nInnerLoopCount < 40)); if (nInnerLoopCount >= 40) break; nOuterLoopCount++; // continue looping until a suitable pair of cards is found } while ((fDiff > fTotalLeft) && (nOuterLoopCount < 40)); // if ((fDiff > 0) && (fDiff <= fTotalLeft) && (nInnerLoopCount < 40) && (nOuterLoopCount < 40)) { // success -- swap the two cards PLAYER(nSource).RemoveCardFromHand(pSrcCard); PLAYER(nDest).RemoveCardFromHand(pDestCard); PLAYER(nDest).AddCardToHand(pSrcCard,TRUE); PLAYER(nSource).AddCardToHand(pDestCard,TRUE); // PLAYER(nDest).CountCardPoints(TRUE); PLAYER(nSource).CountCardPoints(TRUE); // fValSwapped += fDiff; fTotalLeft -= fDiff; } nTopmostLoopCount++; } while ((fTotalLeft > 0) && (nTopmostLoopCount < 30)); // return fValSwapped; }
int main() { // Initialization //-------------------------------------------------------------------------------------- const int screenWidth = 1280; const int screenHeight = 720; // Init window InitWindow(screenWidth, screenHeight, "Dr. Turtle & Mr. GAMERA"); // Load game resources: textures Texture2D sky = LoadTexture("resources/sky.png"); Texture2D mountains = LoadTexture("resources/mountains.png"); Texture2D sea = LoadTexture("resources/sea.png"); Texture2D title = LoadTexture("resources/title.png"); Texture2D turtle = LoadTexture("resources/turtle.png"); Texture2D gamera = LoadTexture("resources/gamera.png"); Texture2D shark = LoadTexture("resources/shark.png"); Texture2D orca = LoadTexture("resources/orca.png"); Texture2D swhale = LoadTexture("resources/swhale.png"); Texture2D fish = LoadTexture("resources/fish.png"); // Define scrolling variables int backScrolling = 0; int seaScrolling = 0; // Define current screen GameScreen currentScreen = TITLE; // Define player variables int playerRail = 1; Rectangle playerBounds = { 30 + 14, playerRail*120 + 90 + 14, 100, 100 }; bool gameraMode = false; // Define enemies variables Rectangle enemyBounds[MAX_ENEMIES]; int enemyRail[MAX_ENEMIES]; int enemyType[MAX_ENEMIES]; bool enemyActive[MAX_ENEMIES]; float enemySpeed = 10; // Init enemies variables for (int i = 0; i < MAX_ENEMIES; i++) { // Define enemy type (all same probability) enemyType[i] = GetRandomValue(0, 3); // Define enemy rail enemyRail[i] = GetRandomValue(0, 4); // Define enemy bounding box enemyBounds[i] = (Rectangle) { screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; enemyActive[i] = false; } // Define additional game variables int foodBar = 0; int framesCounter = 0; SetTargetFPS(60); // Setup game frames per second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- framesCounter++; // Game screens management switch (currentScreen) { case TITLE: { // Sea scrolling seaScrolling -= 2; if (seaScrolling <= -screenWidth) seaScrolling = 0; // Press enter to change to gameplay screen if (IsKeyPressed(KEY_ENTER)) { currentScreen = GAMEPLAY; framesCounter = 0; } } break; case GAMEPLAY: { // Background scrolling logic backScrolling--; if (backScrolling <= -screenWidth) backScrolling = 0; // Sea scrolling logic seaScrolling -= (enemySpeed - 2); if (seaScrolling <= -screenWidth) seaScrolling = 0; // Player movement logic if (IsKeyPressed(KEY_DOWN)) playerRail++; else if (IsKeyPressed(KEY_UP)) playerRail--; // Check player not out of rails if (playerRail > 4) playerRail = 4; else if (playerRail < 0) playerRail = 0; // Update player bounds playerBounds = (Rectangle) { 30 + 14, playerRail*120 + 90 + 14, 100, 100 }; // Enemies activation logic (every 40 frames) if (framesCounter > 40) { for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i] == false) { enemyActive[i] = true; i = MAX_ENEMIES; } } framesCounter = 0; } // Enemies logic for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i]) { enemyBounds[i].x -= enemySpeed; } // Check enemies out of screen if (enemyBounds[i].x <= 0 - 128) { enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle) { screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; enemyActive[i] = false; } } // Enemies speed increase every frame if (!gameraMode) enemySpeed += 0.005; // Check collision player vs enemies for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i]) { if (CheckCollisionRecs(playerBounds, enemyBounds[i])) { if (enemyType[i] < 3) // Bad enemies { if (gameraMode) { foodBar += 15; // After enemy deactivation, reset enemy parameters to be reused enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle) { screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; enemyActive[i] = false; } else { // Player die logic currentScreen = ENDING; framesCounter = 0; } } else // Sweet fish { enemyActive[i] = false; enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle) { screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; if (!gameraMode) foodBar += 80; else foodBar += 25; if (foodBar == 400) { gameraMode = true; } } } } } // Gamera mode logic if (gameraMode) { foodBar--; if (foodBar <= 0) { gameraMode = false; enemySpeed -= 2; if (enemySpeed < 10) enemySpeed = 10; } } } break; case ENDING: { // Press enter to play again if (IsKeyPressed(KEY_ENTER)) { currentScreen = GAMEPLAY; // Reset player playerRail = 1; playerBounds = (Rectangle) { 30 + 14, playerRail*120 + 90 + 14, 100, 100 }; gameraMode = false; // Reset enemies data for (int i = 0; i < MAX_ENEMIES; i++) { enemyType[i] = GetRandomValue(0, 3); enemyRail[i] = GetRandomValue(0, 4); enemyBounds[i] = (Rectangle) { screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 }; enemyActive[i] = false; } enemySpeed = 10; // Reset game variables foodBar = 0; framesCounter = 0; } } break; default: break; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); // Draw background (common to all screens) DrawTexture(sky, 0, 0, WHITE); DrawTexture(mountains, backScrolling, 0, WHITE); DrawTexture(mountains, screenWidth + backScrolling, 0, WHITE); if (!gameraMode) { DrawTexture(sea, seaScrolling, 0, BLUE); DrawTexture(sea, screenWidth + seaScrolling, 0, BLUE); } else { DrawTexture(sea, seaScrolling, 0, RED); DrawTexture(sea, screenWidth + seaScrolling, 0, RED); } switch (currentScreen) { case TITLE: { // Draw title DrawTexture(title, screenWidth/2 - title.width/2, screenHeight/2 - title.height/2 - 80, WHITE); // Draw blinking text if ((framesCounter/30) % 2) DrawText("PRESS ENTER", 480, 480, 40, BLACK); } break; case GAMEPLAY: { // Draw water lines for (int i = 0; i < 5; i++) DrawRectangle(0, i*120 + 120, screenWidth, 110, Fade(SKYBLUE, 0.1f)); // Draw player if (!gameraMode) DrawTexture(turtle, playerBounds.x - 14, playerBounds.y - 14, WHITE); else DrawTexture(gamera, playerBounds.x - 64, playerBounds.y - 64, WHITE); // Draw player bounding box //if (!gameraMode) DrawRectangleRec(playerBounds, Fade(GREEN, 0.4f)); //else DrawRectangleRec(playerBounds, Fade(ORANGE, 0.4f)); // Draw enemies for (int i = 0; i < MAX_ENEMIES; i++) { if (enemyActive[i]) { // Draw enemies /* switch(enemyType[i]) { case 0: DrawTexture(shark, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; case 1: DrawTexture(orca, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; case 2: DrawTexture(swhale, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; case 3: DrawTexture(fish, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break; default: break; } */ // Draw enemies bounding boxes switch(enemyType[i]) { case 0: DrawRectangleRec(enemyBounds[i], RED); break; case 1: DrawRectangleRec(enemyBounds[i], RED); break; case 2: DrawRectangleRec(enemyBounds[i], RED); break; case 3: DrawRectangleRec(enemyBounds[i], GREEN); break; default: break; } } } // Draw gameplay interface // Draw food bar DrawRectangle(20, 20, 400, 40, Fade(GRAY, 0.4f)); DrawRectangle(20, 20, foodBar, 40, ORANGE); DrawRectangleLines(20, 20, 400, 40, BLACK); if (gameraMode) { DrawText("GAMERA MODE", 60, 22, 40, GRAY); } } break; case ENDING: { // Draw a transparent black rectangle that covers all screen DrawRectangle(0, 0, screenWidth, screenHeight, Fade(BLACK, 0.4f)); DrawText("GAME OVER", 300, 200, 100, MAROON); // Draw blinking text if ((framesCounter/30) % 2) DrawText("PRESS ENTER to REPLAY", 400, 420, 30, LIGHTGRAY); } break; default: break; } EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- // Unload textures UnloadTexture(sky); UnloadTexture(mountains); UnloadTexture(sea); UnloadTexture(title); UnloadTexture(turtle); UnloadTexture(gamera); UnloadTexture(shark); UnloadTexture(orca); UnloadTexture(swhale); UnloadTexture(fish); CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
// Ending Screen Update logic void UpdateEndingScreen(void) { framesCounter += 1*TIME_FACTOR; switch (endingCounter) { case DELAY: { if(framesCounter >= 10) { endingCounter = SEASONS; framesCounter = 0; } } break; case SEASONS: { if (seasons > 0) { seasonsCounter = (int)LinearEaseIn((float)framesCounter, 0.0f, (float)(seasons), 90.0f); clockRotation = LinearEaseIn((float)framesCounter, (float)initRotation, (float)-(finalRotation - initRotation), 90.0f); if (framesCounter >= 90) { endingCounter = LEAVES; framesCounter = 0; } } else endingCounter = LEAVES; #if (defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)) if (IsGestureDetected(GESTURE_TAP)) { seasonsCounter = seasons; clockRotation = finalRotation; framesCounter = 0; endingCounter = LEAVES; } #elif (defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)) if (IsKeyPressed(KEY_ENTER)) { seasonsCounter = seasons; clockRotation = finalRotation; framesCounter = 0; endingCounter = LEAVES; } #endif } break; case LEAVES: { if (currentLeaves > 0) { if (currentLeavesEnding == currentLeaves) { endingCounter = KILLS; framesCounter = 0; } else if (currentLeavesEnding < currentLeaves) { if (framesCounter >= 4) { currentLeavesEnding += 1; framesCounter = 0; } for (int i = 0; i < 20; i++) { if (!leafParticles[i].active) { leafParticles[i].position = (Vector2){ GetScreenWidth()*0.46, GetScreenHeight()*0.32}; leafParticles[i].alpha = 1.0f; leafParticles[i].active = true; } } } } else endingCounter = KILLS; #if (defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)) if (IsGestureDetected(GESTURE_TAP)) { currentLeavesEnding = currentLeaves; framesCounter = 0; endingCounter = KILLS; } #elif (defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)) if (IsKeyPressed(KEY_ENTER)) { currentLeavesEnding = currentLeaves; framesCounter = 0; endingCounter = KILLS; } #endif } break; case KILLS: { if (score > 0) { if (framesCounter <= 90 && !replaying) { currentScore = (int)LinearEaseIn((float)framesCounter, 0.0f, (float)(score), 90.0f); } framesKillsCounter += 1*TIME_FACTOR; for (int i = 0; i < MAX_KILLS; i++) { if (framesKillsCounter >= drawTimer && active[i] == false) { active[i] = true; framesKillsCounter = 0; } } if (framesCounter >= 90) { endingCounter = REPLAY; framesCounter = 0; } } else endingCounter = REPLAY; #if (defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)) if (IsGestureDetected(GESTURE_TAP)) { currentScore = score; framesCounter = 0; for (int i = 0; i < MAX_KILLS; i++) active[i] = true; endingCounter = REPLAY; } #elif (defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)) if (IsKeyPressed(KEY_ENTER)) { currentScore = score; framesCounter = 0; for (int i = 0; i < MAX_KILLS; i++) active[i] = true; endingCounter = REPLAY; } #endif } break; case REPLAY: { #if (defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)) if (IsGestureDetected(GESTURE_TAP)) replaying = true; #elif (defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)) if (IsKeyPressed(KEY_ENTER)) replaying = true; #endif if (replaying) { replayTimer += 1*TIME_FACTOR; if (replayTimer >= 30) { finishScreen = 1; initSeason = GetRandomValue(0, 3); } buttonPlayColor = GOLD; } } break; } for (int i = 0; i < 20; i++) { if (leafParticles[i].active == true) { leafParticles[i].position.x += leafParticles[i].speed.x; leafParticles[i].position.y += leafParticles[i].speed.y; leafParticles[i].rotation += 6; leafParticles[i].alpha -= 0.03f; leafParticles[i].size -= 0.004; if (leafParticles[i].size <= 0) leafParticles[i].size = 0.0f; if (leafParticles[i].alpha <= 0) { leafParticles[i].alpha = 0.0f; leafParticles[i].active = false; } } } // Buttons logic #if (defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)) if ((IsGestureDetected(GESTURE_TAP)) && CheckCollisionPointRec(GetTouchPosition(0), playButton)) { endingCounter = REPLAY; replaying = true; } #elif (defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)) if (CheckCollisionPointRec(GetMousePosition(), playButton)) { buttonPlayColor = GOLD; if (IsMouseButtonPressed(0)) { endingCounter = REPLAY; replaying = true; } } else buttonPlayColor = WHITE; if (CheckCollisionPointRec(GetMousePosition(), shopButton)) buttonShopColor = GOLD; else buttonShopColor = WHITE; if (CheckCollisionPointRec(GetMousePosition(), trophyButton)) buttonTrophyColor = GOLD; else buttonTrophyColor = WHITE; if (CheckCollisionPointRec(GetMousePosition(), shareButton)) buttonShareColor = GOLD; else buttonShareColor = WHITE; #endif }
int main(void) { // Initialization //-------------------------------------------------------------------------------------- const int screenWidth = 800; const int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera"); Rectangle player = { 400, 280, 40, 40 }; Rectangle buildings[MAX_BUILDINGS] = { 0 }; Color buildColors[MAX_BUILDINGS] = { 0 }; int spacing = 0; for (int i = 0; i < MAX_BUILDINGS; i++) { buildings[i].width = GetRandomValue(50, 200); buildings[i].height = GetRandomValue(100, 800); buildings[i].y = screenHeight - 130 - buildings[i].height; buildings[i].x = -6000 + spacing; spacing += buildings[i].width; buildColors[i] = (Color){ GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255 }; } Camera2D camera = { 0 }; camera.target = (Vector2){ player.x + 20, player.y + 20 }; camera.offset = (Vector2){ 0, 0 }; camera.rotation = 0.0f; camera.zoom = 1.0f; SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsKeyDown(KEY_RIGHT)) { player.x += 2; // Player movement camera.offset.x -= 2; // Camera displacement with player movement } else if (IsKeyDown(KEY_LEFT)) { player.x -= 2; // Player movement camera.offset.x += 2; // Camera displacement with player movement } // Camera target follows player camera.target = (Vector2){ player.x + 20, player.y + 20 }; // Camera rotation controls if (IsKeyDown(KEY_A)) camera.rotation--; else if (IsKeyDown(KEY_S)) camera.rotation++; // Limit camera rotation to 80 degrees (-40 to 40) if (camera.rotation > 40) camera.rotation = 40; else if (camera.rotation < -40) camera.rotation = -40; // Camera zoom controls camera.zoom += ((float)GetMouseWheelMove()*0.05f); if (camera.zoom > 3.0f) camera.zoom = 3.0f; else if (camera.zoom < 0.1f) camera.zoom = 0.1f; // Camera reset (zoom and rotation) if (IsKeyPressed(KEY_R)) { camera.zoom = 1.0f; camera.rotation = 0.0f; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); BeginMode2D(camera); DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY); for (int i = 0; i < MAX_BUILDINGS; i++) DrawRectangleRec(buildings[i], buildColors[i]); DrawRectangleRec(player, RED); DrawLine(camera.target.x, -screenHeight*10, camera.target.x, screenHeight*10, GREEN); DrawLine(-screenWidth*10, camera.target.y, screenWidth*10, camera.target.y, GREEN); EndMode2D(); DrawText("SCREEN AREA", 640, 10, 20, RED); DrawRectangle(0, 0, screenWidth, 5, RED); DrawRectangle(0, 5, 5, screenHeight - 10, RED); DrawRectangle(screenWidth - 5, 5, 5, screenHeight - 10, RED); DrawRectangle(0, screenHeight - 5, screenWidth, 5, RED); DrawRectangle( 10, 10, 250, 113, Fade(SKYBLUE, 0.5f)); DrawRectangleLines( 10, 10, 250, 113, BLUE); DrawText("Free 2d camera controls:", 20, 20, 10, BLACK); DrawText("- Right/Left to move Offset", 40, 40, 10, DARKGRAY); DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, DARKGRAY); DrawText("- A / S to Rotate", 40, 80, 10, DARKGRAY); DrawText("- R to reset Zoom and Rotation", 40, 100, 10, DARKGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
// // DealSpecial() // // Possible codes: // --------------- // Game Code: 0 = Any (Random) // 1 = Game // 2 = Slam // Suit Code: 0 = Any // 1 = Minor // 2 = Major // 3 = NoTrump // Slam Code: 0 = Any // 1 = Small Slam // 2 = Grand Slam // void CEasyBDoc::DealSpecial(int nGameCode, int nSuitCode, int nSlamCode, int nTeam, int nDealNumber) { CString strFeedback; // CMainFrame::SetStatusMessage("Performing deal..."); // validate inputs if ((nGameCode < 0 ) || (nGameCode > 2) || (nSuitCode < 0 ) || (nSuitCode > 3) || (nSlamCode < 0 ) || (nSlamCode > 2) ) return; // first clear all hands InitNewHand(); // delete document info if (!m_bReviewingGame) DeleteContents(); // save special deal code m_nSpecialDealCode = (nGameCode << 6) | (nSuitCode << 4) | (nSlamCode << 2) | nTeam; // perform the initial shuffle m_nDealNumber = deck.Shuffle(nDealNumber); // set busy cursor pVIEW->SetCurrentMode(CEasyBView::MODE_WAITSPECIALDEAL); // first set target points int nMin, nMax; double fScoreTarget; // switch (nGameCode) { case 0: // any random deal break; case 1: // game deal nMin = theApp.GetValue(tnRequiredPointsForGame,nSuitCode,0); nMax = theApp.GetValue(tnRequiredPointsForGame,nSuitCode,1); fScoreTarget = nMin + GetRandomValue(nMax - nMin); switch(nSuitCode) { case 0: // game hand, any suit strFeedback.Format("Dealt game hand\n"); break; case 1: // game hand, minor suit strFeedback.Format("Dealt Minor game hand\n"); break; case 2: // game hand, major suit strFeedback.Format("Dealt Major game hand\n"); break; case 3: // game hand, notrumps strFeedback.Format("Dealt NoTrump game hand\n"); break; } break; case 2: // slam deal nMin = theApp.GetValue(tnRequiredPointsForSlam,nSlamCode,0); nMax = theApp.GetValue(tnRequiredPointsForSlam,nSlamCode,1); fScoreTarget = nMin + GetRandomValue(nMax - nMin); switch(nSlamCode) { case 0: // any slam strFeedback.Format("Dealt slam hand\n"); break; case 1: // small slam strFeedback.Format("Dealt small slam hand\n"); break; case 2: // grand slam strFeedback.Format("Dealt grand slam hand\n"); break; } break; } // declare loop counters int i; int nOuterLoopCount = 0; int nAceLoopCount1, nAceLoopCount2; int nKingLoopCount1, nKingLoopCount2; int nPointSwapLoopCount, nFailCount; shuffle: nOuterLoopCount++; // check if we've exceeded the limit on iterations if (nOuterLoopCount >= MAX_SPECIAL_DEAL_ITERATIONS) { AfxMessageBox("Failed to meet hand requirements. Try again."); pVIEW->ClearMode(); return; } /* // every 100 count, reseed the random # generator if (((nOuterLoopCount % 100) == 0) && (nOuterLoopCount > 0)) srand((unsigned)time(NULL)); */ // assign new hands DealCards(); // //---------------------------------------------------------- // // Now check the strength of N/S's hands // double fSouthPoints, fNorthPoints; if (nSuitCode != 3) { fSouthPoints = PLAYER(SOUTH).GetTotalPoints(); fNorthPoints = PLAYER(NORTH).GetTotalPoints(); } else { // No Trumps; count high card points only fSouthPoints = PLAYER(SOUTH).GetHCPoints(); fNorthPoints = PLAYER(NORTH).GetHCPoints(); } double fTotalPoints = fSouthPoints + fNorthPoints; double fDiff, fSwapped; int nSource,nDest; // at this point, check cards' distribution int numInSuit[4]; BOOL bSuitFit[4]; for(i=0;i<4;i++) { numInSuit[i] = PLAYER(SOUTH).GetNumCardsInSuit(i) + PLAYER(NORTH).GetNumCardsInSuit(i); // check for a proper card distribution (min 4/3) int nDistIndex = theApp.GetValue(tnMinSuitDistributions,nSuitCode-1); int nDistVal[2]; nDistVal[0] = theApp.GetValue(tnMinSuitDistributions,nSuitCode-1,nDistIndex,0); nDistVal[1] = theApp.GetValue(tnMinSuitDistributions,nSuitCode-1,nDistIndex,1); if ((nSuitCode == 1) || (nSuitCode == 2)) { if ( ((PLAYER(SOUTH).GetNumCardsInSuit(i) >= nDistVal[0]) && (PLAYER(NORTH).GetNumCardsInSuit(i) >= nDistVal[1])) || ((PLAYER(NORTH).GetNumCardsInSuit(i) >= nDistVal[0]) && (PLAYER(SOUTH).GetNumCardsInSuit(i) >= nDistVal[1])) ) bSuitFit[i] = TRUE; else bSuitFit[i] = FALSE; } else { // generic suit or no trumps specified; default to // 4/3 for fit determination if ( ((PLAYER(SOUTH).GetNumCardsInSuit(i) >= 3) && (PLAYER(NORTH).GetNumCardsInSuit(i) >= 4)) || ((PLAYER(NORTH).GetNumCardsInSuit(i) >= 3) && (PLAYER(SOUTH).GetNumCardsInSuit(i) >= 4)) ) bSuitFit[i] = TRUE; else bSuitFit[i] = FALSE; } } // if (nSuitCode == 3) { // No Trump contract -- check hand balance int nMaxImbalance = theApp.GetValue(tnMaxImbalanceForNT); if (theApp.GetValue(tbNeedTwoBalancedTrumpHands)) { // both players need balanced hands if ((PLAYER(SOUTH).GetBalanceValue() > nMaxImbalance) || (PLAYER(NORTH).GetBalanceValue() > nMaxImbalance)) goto shuffle; } else { // at least one player has balanced hand if ((PLAYER(SOUTH).GetBalanceValue() > nMaxImbalance) && (PLAYER(NORTH).GetBalanceValue() > nMaxImbalance)) goto shuffle; } } else if (nSuitCode == 2) { // major suit game -- need at least one major suit // that has >= min cards int nCardsInMajor = theApp.GetValue(tnMinCardsInMajor); if ((numInSuit[HEARTS] < nCardsInMajor) && (numInSuit[SPADES] < nCardsInMajor)) goto shuffle; // also need a minimum 4-3 fit in a major suit if ((!bSuitFit[HEARTS]) && (!bSuitFit[SPADES])) goto shuffle; // and also check that the suit is adequately topped BOOL bTopped = FALSE; int nMinTopMajorCard = theApp.GetValue(tnMinTopMajorCard); if ((bSuitFit[HEARTS]) && (PLAYER(SOUTH).GetNumCardsInSuit(HEARTS) >= 4) && (PLAYER(SOUTH).GetCardInSuit(HEARTS,0)->GetFaceValue() >= nMinTopMajorCard)) bTopped = TRUE; if ((bSuitFit[SPADES]) && (PLAYER(SOUTH).GetNumCardsInSuit(SPADES) >= 4) && (PLAYER(SOUTH).GetCardInSuit(SPADES,0)->GetFaceValue() >= nMinTopMajorCard)) bTopped = TRUE; if ((bSuitFit[HEARTS]) && (PLAYER(NORTH).GetNumCardsInSuit(HEARTS) >= 4) && (PLAYER(NORTH).GetCardInSuit(HEARTS,0)->GetFaceValue() >= nMinTopMajorCard)) bTopped = TRUE; if ((bSuitFit[SPADES]) && (PLAYER(NORTH).GetNumCardsInSuit(SPADES) >= 4) && (PLAYER(NORTH).GetCardInSuit(SPADES,0)->GetFaceValue() >= nMinTopMajorCard)) bTopped = TRUE; if (!bTopped) goto shuffle; } else if (nSuitCode == 1) { // minor suit game -- need at least one major suit // that has >= min cards int nCardsInMinor = theApp.GetValue(tnMinCardsInMinor); if ((numInSuit[CLUBS] < nCardsInMinor) && (numInSuit[DIAMONDS] < nCardsInMinor)) goto shuffle; // also need a minimum 4-3 fit in a minor suit if ((!bSuitFit[CLUBS]) && (!bSuitFit[DIAMONDS])) goto shuffle; // and also check that the suit is adequately topped BOOL bTopped = FALSE; int nMinTopMinorCard = theApp.GetValue(tnMinTopMinorCard); if ((bSuitFit[CLUBS]) && (PLAYER(SOUTH).GetNumCardsInSuit(CLUBS) >= 4) && (PLAYER(SOUTH).GetCardInSuit(CLUBS,0)->GetFaceValue() >= nMinTopMinorCard)) bTopped = TRUE; if ((bSuitFit[DIAMONDS]) && (PLAYER(SOUTH).GetNumCardsInSuit(DIAMONDS) >= 4) && (PLAYER(SOUTH).GetCardInSuit(DIAMONDS,0)->GetFaceValue() >= nMinTopMinorCard)) bTopped = TRUE; if ((bSuitFit[CLUBS]) && (PLAYER(NORTH).GetNumCardsInSuit(CLUBS) >= 4) && (PLAYER(NORTH).GetCardInSuit(CLUBS,0)->GetFaceValue() >= nMinTopMinorCard)) bTopped = TRUE; if ((bSuitFit[DIAMONDS]) && (PLAYER(NORTH).GetNumCardsInSuit(DIAMONDS) >= 4) && (PLAYER(NORTH).GetCardInSuit(DIAMONDS,0)->GetFaceValue() >= nMinTopMinorCard)) bTopped = TRUE; if (!bTopped) goto shuffle; } // //---------------------------------------------------------- // // Fudging time -- // // for a grand slam hand, check to make sure there are some // non-ace, non-king honors in the N/S suits. This will make // it easier to trade down points later on if ((nGameCode == 2) && (nSlamCode == 2)) { double fDiff1 = m_pPlayer[SOUTH]->GetHCPoints() - (m_pPlayer[SOUTH]->GetNumCardsOf(ACE)*4 + m_pPlayer[SOUTH]->GetNumCardsOf(KING)*3); double fDiff2 = m_pPlayer[NORTH]->GetHCPoints() - (m_pPlayer[NORTH]->GetNumCardsOf(ACE)*4 + m_pPlayer[NORTH]->GetNumCardsOf(KING)*3); // #### TEMP #### double fHC1 = m_pPlayer[SOUTH]->GetHCPoints(); int nAces1 = m_pPlayer[SOUTH]->GetNumCardsOf(ACE); int nKings1 = m_pPlayer[SOUTH]->GetNumCardsOf(KING); double fHC2 = m_pPlayer[NORTH]->GetHCPoints(); int nAces2 = m_pPlayer[NORTH]->GetNumCardsOf(ACE); int nKings2 = m_pPlayer[NORTH]->GetNumCardsOf(KING); ASSERT((fDiff1 >= 0) && (fDiff2 >= 0)); // if ((fDiff1 < 2) || (fDiff2 < 2)) goto shuffle; } // //---------------------------------------------------------- // // slam hand -- check for aces if necessary // int numAcesRequired; int numAcesHeld; if (nGameCode == 2) { numAcesRequired = theApp.GetValue(tnumAcesForSlam,nSlamCode); numAcesHeld = PLAYER(SOUTH).GetNumCardsOf(ACE) + PLAYER(NORTH).GetNumCardsOf(ACE); int numCards,nSrcPlayer,nDestPlayer,nSuit1,nSuit2,nDestCard; int fDiff = numAcesRequired - numAcesHeld; // trade aces with opponents if (fDiff > 0) { for(i=0;i<fDiff;i++) { // first pick a source opponent, semi-randomly // 0 or 1; 0 means west, unless west has zero aces if ( ((GetRandomValue(1) == 0) && (PLAYER(WEST).GetNumCardsOf(ACE) > 0)) || (PLAYER(EAST).GetNumCardsOf(ACE) == 0) ) nSrcPlayer = WEST; else nSrcPlayer = EAST; ASSERT(PLAYER(nSrcPlayer).GetNumCardsOf(ACE) != 0); // and likewise pick a dest player; 0=South int nVal = GetRandomValue(1); if ( ((nVal == 0) && (PLAYER(SOUTH).GetNumCardsOf(ACE) < 4)) || (PLAYER(NORTH).GetNumCardsOf(ACE) == 4) ) nDestPlayer = SOUTH; else nDestPlayer = NORTH; // now pick a source suit and a dest suit nAceLoopCount1 = 0; do { // search for a source suit with an ace nSuit1 = GetRandomValue(3); if ((PLAYER(nSrcPlayer).GetNumCardsInSuit(nSuit1) > 0) && (PLAYER(nSrcPlayer).GetCardInSuit(nSuit1,0)->GetFaceValue() == ACE)) { break; } nAceLoopCount1++; } while (nAceLoopCount1 < 100); if (nAceLoopCount1 >= 100) { AfxMessageBox("Failed to meet deal constraints (Ace search stage 1 failure)."); break; } // nAceLoopCount2 = 0; do { nSuit2 = GetRandomValue(3); // make sure the dest suit has > 1 cards in it, // or if it has only one card, that it's not an ace if ((PLAYER(nDestPlayer).GetNumCardsInSuit(nSuit2) > 1) || ((PLAYER(nDestPlayer).GetNumCardsInSuit(nSuit2) == 1) && (PLAYER(nDestPlayer).GetCardInSuit(nSuit2,0)->GetFaceValue() != ACE)) ) { break; } nAceLoopCount2++; } while (nAceLoopCount2 < 100); if (nAceLoopCount2 >= 100) { AfxMessageBox("Failed to meet deal constraints (Ace search stage 2 failure)."); break; } // and then pick a nonace card from the dest suit numCards = PLAYER(nDestPlayer).GetNumCardsInSuit(nSuit2); do { nDestCard = GetRandomValue(numCards-1); } while (PLAYER(nDestPlayer).GetCardInSuit(nSuit2,nDestCard)->GetFaceValue() == ACE); // and finally, then swap cards SwapPlayersCards(nSrcPlayer,nDestPlayer, nSuit1, nSuit2, 0, nDestCard, TRUE); } } } // //---------------------------------------------------------- // // likewise, check for kings if necessary // int numKingsRequired; int numKingsHeld; if (nGameCode == 2) { numKingsRequired = theApp.GetValue(tnumKingsForSlam,nSlamCode); numKingsHeld = PLAYER(SOUTH).GetNumCardsOf(KING) + PLAYER(NORTH).GetNumCardsOf(KING); int numCards,nSrcPlayer,nDestPlayer,nSuit1,nSuit2,nDestCard,nSrcCard; int fDiff = numKingsRequired - numKingsHeld; // trade kings with opponents if (fDiff > 0) { for(i=0;i<fDiff;i++) { // first pick a source opponent, semi-randomly // 0 or 1; 0 means west, unless west has zero kings if ( ((GetRandomValue(1) == 0) && (PLAYER(WEST).GetNumCardsOf(KING) > 0)) || (PLAYER(EAST).GetNumCardsOf(KING) == 0) ) nSrcPlayer = WEST; else nSrcPlayer = EAST; // and likewise pick a dest player; 0=South if ( ((GetRandomValue(1) == 0) && (PLAYER(SOUTH).GetNumCardsOf(KING) < 4)) || (PLAYER(NORTH).GetNumCardsOf(KING) == 4) ) nDestPlayer = SOUTH; else nDestPlayer = NORTH; // now pick a source suit and a dest suit nKingLoopCount1 = 0; do { // search for a source suit with a king nSuit1 = GetRandomValue(3); if ((PLAYER(nSrcPlayer).GetNumCardsInSuit(nSuit1) >= 1) && (PLAYER(nSrcPlayer).GetCardInSuit(nSuit1,0)->GetFaceValue() == KING)) { nSrcCard = 0; break; } if ((PLAYER(nSrcPlayer).GetNumCardsInSuit(nSuit1) >= 2) && (PLAYER(nSrcPlayer).GetCardInSuit(nSuit1,1)->GetFaceValue() == KING)) { nSrcCard = 1; break; } nKingLoopCount1++; } while (nKingLoopCount1 < 100); if (nKingLoopCount1 >= 100) { AfxMessageBox("Failed to meet deal constraints (King search stage 1 failure)."); break; } // nKingLoopCount2 = 0; do { nSuit2 = GetRandomValue(3); // make sure the dest suit has > 1 cards in it, including a // card lower than a king which can be swapped out int nNum = PLAYER(nDestPlayer).GetNumCardsInSuit(nSuit2); if ((nNum >= 1) && (PLAYER(nDestPlayer).GetCardInSuit(nSuit2,nNum-1)->GetFaceValue() < KING)) { break; } nKingLoopCount2++; } while (nKingLoopCount2 < 100); if (nKingLoopCount2 >= 100) { AfxMessageBox("Failed to meet deal constraints (King search stage 2 failure)."); break; } // and then pick a non-king, non-ace card from the dest suit numCards = PLAYER(nDestPlayer).GetNumCardsInSuit(nSuit2); do { nDestCard = GetRandomValue(numCards-1); } while ((PLAYER(nDestPlayer).GetCardInSuit(nSuit2,nDestCard)->GetFaceValue() == KING) || (PLAYER(nDestPlayer).GetCardInSuit(nSuit2,nDestCard)->GetFaceValue() == ACE)); // and finally, then swap cards SwapPlayersCards(nSrcPlayer,nDestPlayer,nSuit1,nSuit2,nSrcCard,nDestCard,TRUE); } } } // //---------------------------------------------------------- // // now, adjust hand points if necessary // note that we must maintain card topping requirements // fDiff = fTotalPoints - fScoreTarget; // srand((unsigned)time(NULL)); BOOL bSouthHoldsExtraHonors,bNorthHoldsExtraHonors; nPointSwapLoopCount = 0; nFailCount = 0; // while (fDiff != 0) { // check some hand parameters to ensure success of swap routine // see if N/S have high cards available to swap down int nSouthAces = m_pPlayer[SOUTH]->GetNumCardsOf(ACE); int nSouthKings = m_pPlayer[SOUTH]->GetNumCardsOf(KING); if ((m_pPlayer[SOUTH]->GetHCPoints() > nSouthAces*4 + nSouthKings*3) || ((nSouthAces > 0) && (numAcesHeld > numAcesRequired)) || ((nSouthKings > 0) && (numKingsHeld > numKingsRequired)) ) bSouthHoldsExtraHonors = TRUE; else bSouthHoldsExtraHonors = FALSE; int nNorthAces = m_pPlayer[NORTH]->GetNumCardsOf(ACE); int nNorthKings = m_pPlayer[NORTH]->GetNumCardsOf(KING); if ((m_pPlayer[NORTH]->GetHCPoints() > nNorthAces*4 + nNorthKings*3) || ((nNorthAces > 0) && (numAcesHeld > numAcesRequired)) || ((nNorthKings > 0) && (numKingsHeld > numKingsRequired)) ) bNorthHoldsExtraHonors = TRUE; else bNorthHoldsExtraHonors = FALSE; // nDest = (GetRandomValue(1)==0)? EAST: WEST; if (fDiff < 0) { // adjust hand upwards if ((theApp.GetValue(tbBalanceTeamHands)) && ((fSouthPoints >= 13) || (fNorthPoints >= 13)) ) { if (fSouthPoints < fNorthPoints) nSource = SOUTH; else nSource = NORTH; } else { nSource = (GetRandomValue(1)==0)? NORTH: SOUTH; } fSwapped = SwapPoints(nSource, nDest, Abs(fDiff), nGameCode, nSuitCode, nSlamCode); } else { // adjust hand down if ((numAcesHeld <= numAcesRequired) && (numKingsHeld <= numKingsRequired) && (!bSouthHoldsExtraHonors) && (!bNorthHoldsExtraHonors)) { // neither hand has a high card to trade down while // meeting Aces/Kings requirement, just give up break; } // else proceed if ((theApp.GetValue(tbBalanceTeamHands)) && ((fSouthPoints >= 13) || (fNorthPoints >= 13)) ) { // deduct points from hand with the most points, unless that hand // lacks honors below a king (which must be held) if ( ((fSouthPoints > fNorthPoints) && (bSouthHoldsExtraHonors)) || ((bSouthHoldsExtraHonors) && (!bNorthHoldsExtraHonors)) ) nSource = SOUTH; else nSource = NORTH; } else { nSource = (GetRandomValue(1)==0)? NORTH: SOUTH; } fSwapped = SwapPoints(nDest, nSource, Abs(fDiff), nGameCode, nSuitCode, nSlamCode); } // if (fSwapped == 0) { nFailCount++; if (nFailCount > 40) break; // could've run out of high cards } // and re-evaluate PLAYER(SOUTH).CountCardPoints(TRUE); PLAYER(NORTH).CountCardPoints(TRUE); if (nSuitCode != 3) { fSouthPoints = PLAYER(SOUTH).GetTotalPoints(); fNorthPoints = PLAYER(NORTH).GetTotalPoints(); } else { // No Trumps; count high card points only fSouthPoints = PLAYER(SOUTH).GetHCPoints(); fNorthPoints = PLAYER(NORTH).GetHCPoints(); } fTotalPoints = fSouthPoints + fNorthPoints; fDiff = fTotalPoints - fScoreTarget; nPointSwapLoopCount++; } // //---------------------------------------------------------------- // now report on success of the special deal // CString strTemp; /* strTemp.Format("Iterations: O=%d, A1=%d, A2=%d, K1=%d, K2=%d, PS=%d, FL=%d\n", nOuterLoopCount,nAceLoopCount1,nAceLoopCount2, nKingLoopCount1, nKingLoopCount2, nPointSwapLoopCount,nFailCount); strFeedback += strTemp; */ for(i=0;i<4;i++) PLAYER(i).CountCardPoints(TRUE); // strTemp.Format("S: %d/%d pts; N: %d/%d pts (Total: %d/%d/%d)\nEast: %d/%d pts; West: %d/%d pts (Total E/W: %d)", PLAYER(SOUTH).GetHCPoints(), PLAYER(SOUTH).GetTotalPoints(), PLAYER(NORTH).GetHCPoints(), PLAYER(NORTH).GetTotalPoints(), PLAYER(SOUTH).GetHCPoints() + PLAYER(NORTH).GetHCPoints(), fTotalPoints,fScoreTarget, PLAYER(EAST).GetHCPoints(), PLAYER(EAST).GetTotalPoints(), PLAYER(WEST).GetHCPoints(), PLAYER(WEST).GetTotalPoints(), PLAYER(EAST).GetTotalPoints() + PLAYER(WEST).GetTotalPoints()); strFeedback += strTemp; strTemp.Format("\nQT's: N: %3.1f S: %3.1f; Stoppers: N: %d S: %d", PLAYER(NORTH).GetNumQuickTricks(), PLAYER(SOUTH).GetNumQuickTricks(), PLAYER(NORTH).GetNumSuitsStopped(), PLAYER(SOUTH).GetNumSuitsStopped()); strFeedback += strTemp; if (nGameCode == 2) { int numAcesRequired = theApp.GetValue(tnumAcesForSlam,nSlamCode); int numAcesHeld = PLAYER(SOUTH).GetNumCardsOf(ACE) + PLAYER(NORTH).GetNumCardsOf(ACE); int numKingsRequired = theApp.GetValue(tnumKingsForSlam,nSlamCode); int numKingsHeld = PLAYER(SOUTH).GetNumCardsOf(KING) + PLAYER(NORTH).GetNumCardsOf(KING); strTemp.Format("\nAces, Kings held by team = %d/%d, %d/%d", numAcesHeld,numAcesRequired, numKingsHeld,numKingsRequired); strFeedback += strTemp; } FEEDBACK(strFeedback); // swap hands if desired if (nTeam == EAST_WEST) RotatePlayersHands(0, FALSE, FALSE); // copy hands to the initial hands for(i=0;i<4;i++) PLAYER(i).InitializeHand(); // turn off game auto-play if ((theApp.GetValue(tnCardPlayMode) == CEasyBApp::PLAY_FULL_AUTO) || (theApp.GetValue(tnCardPlayMode) == CEasyBApp::PLAY_FULL_AUTO_EXPRESS)) theApp.SetValue(tnCardPlayMode, CEasyBApp::PLAY_NORMAL); // done dealing CMainFrame::ResetStatusMessage(); // mark that the deal # is available m_bDealNumberAvailable = TRUE; // reset view mode pVIEW->ClearMode(); // and begin play InitPlay(); }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 1280; int screenHeight = 960; InitWindow(screenWidth, screenHeight, "raylib example - Bunnymark"); Texture2D texBunny = LoadTexture("resources/wabbit_alpha.png"); Bunny *bunnies = (Bunny *)malloc(MAX_BUNNIES*sizeof(Bunny)); // Bunnies array int bunniesCount = 0; // Bunnies counter SetTargetFPS(60); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) { // Create more bunnies for (int i = 0; i < 100; i++) { bunnies[bunniesCount].position = GetMousePosition(); bunnies[bunniesCount].speed.x = (float)GetRandomValue(250, 500)/60.0f; bunnies[bunniesCount].speed.y = (float)(GetRandomValue(250, 500) - 500)/60.0f; bunniesCount++; } } // Update bunnies for (int i = 0; i < bunniesCount; i++) { bunnies[i].position.x += bunnies[i].speed.x; bunnies[i].position.y += bunnies[i].speed.y; if ((bunnies[i].position.x > GetScreenWidth()) || (bunnies[i].position.x < 0)) bunnies[i].speed.x *= -1; if ((bunnies[i].position.y > GetScreenHeight()) || (bunnies[i].position.y < 0)) bunnies[i].speed.y *= -1; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); for (int i = 0; i < bunniesCount; i++) { // NOTE: When internal QUADS batch limit is reached, a draw call is launched and // batching buffer starts being filled again; before launching the draw call, // updated vertex data from internal buffer is send to GPU... it seems it generates // a stall and consequently a frame drop, limiting number of bunnies drawn at 60 fps DrawTexture(texBunny, bunnies[i].position.x, bunnies[i].position.y, RAYWHITE); } DrawRectangle(0, 0, screenWidth, 40, LIGHTGRAY); DrawText("raylib bunnymark", 10, 10, 20, DARKGRAY); DrawText(FormatText("bunnies: %i", bunniesCount), 400, 10, 20, RED); DrawFPS(260, 10); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- free(bunnies); CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main(void) { // Initialization //-------------------------------------------------------------------------------------- const int screenWidth = 800; const int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values"); int score = 0; int hiscore = 0; int framesCounter = 0; SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsKeyPressed(KEY_R)) { score = GetRandomValue(1000, 2000); hiscore = GetRandomValue(2000, 4000); } if (IsKeyPressed(KEY_ENTER)) { StorageSaveValue(STORAGE_SCORE, score); StorageSaveValue(STORAGE_HISCORE, hiscore); } else if (IsKeyPressed(KEY_SPACE)) { // NOTE: If requested position could not be found, value 0 is returned score = StorageLoadValue(STORAGE_SCORE); hiscore = StorageLoadValue(STORAGE_HISCORE); } framesCounter++; //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText(FormatText("SCORE: %i", score), 280, 130, 40, MAROON); DrawText(FormatText("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK); DrawText(FormatText("frames: %i", framesCounter), 10, 10, 20, LIME); DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY); DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY); DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
//---------------------------------------------------------------------------------- // Main entry point //---------------------------------------------------------------------------------- int main() { // Initialization //-------------------------------------------------------------------------------------- const char windowTitle[30] = "raylib functionality demo"; //SetupFlags(FLAG_FULLSCREEN_MODE); InitWindow(screenWidth, screenHeight, windowTitle); InitAudioDevice(); // Initialize audio device // TITLE screen variables Initialization fontAlagard = LoadSpriteFont("resources/fonts/alagard.rbmf"); // rBMF font loading fontPixelplay = LoadSpriteFont("resources/fonts/pixelplay.rbmf"); // rBMF font loading fontMecha = LoadSpriteFont("resources/fonts/mecha.rbmf"); // rBMF font loading fontSetback = LoadSpriteFont("resources/fonts/setback.rbmf"); // rBMF font loading fontRomulus = LoadSpriteFont("resources/fonts/romulus.rbmf"); // rBMF font loading pongBallPosition = (Vector2){ screenWidth/2, screenHeight/2 + 20 }; pongBallSpeed = (Vector2){ 6, 6 }; pongPlayerRec = (Rectangle){ 20, screenHeight/2 - 50 + 40, 20, 100 }; pongEnemyRec = (Rectangle){ screenWidth - 40, screenHeight/2 - 60, 20, 120 }; // LOGO screen variables Initialization logoPositionX = screenWidth/2 - 128; logoPositionY = screenHeight/2 - 128; // MODULES screen variables Initialization raylibWindow = LoadTexture("resources/raylib_window.png"); raylibWindow01 = LoadTexture("resources/raylib_window_01.png"); raylibWindow02 = LoadTexture("resources/raylib_window_02.png"); raylibWindow03 = LoadTexture("resources/raylib_window_03.png"); platforms = LoadTexture("resources/platforms.png"); raylibLogoB = LoadTexture("resources/raylib_logo128x128.png"); lena = LoadTexture("resources/lena.png"); mandrill = LoadTexture("resources/mandrill.png"); texAlagard = LoadTexture("resources/fonts/custom_alagard.png"); fontMechaC = LoadSpriteFont("resources/fonts/custom_mecha.png"); fontAlagardC = LoadSpriteFont("resources/fonts/custom_alagard.png"); fontJupiterC = LoadSpriteFont("resources/fonts/custom_jupiter_crash.png"); ballPosition = (Vector2){ 520 + 656/2, 220 + 399/2 }; camera = (Camera){{ 0.0, 12.0, 15.0 }, { 0.0, 3.0, 0.0 }, { 0.0, 1.0, 0.0 }}; catTexture = LoadTexture("resources/catsham.png"); // Load model texture cat = LoadModel("resources/cat.obj"); // Load OBJ model SetModelTexture(&cat, catTexture); fxWav = LoadSound("resources/audio/weird.wav"); // Load WAV audio file fxOgg = LoadSound("resources/audio/tanatana.ogg"); // Load OGG audio file for (int i = 0; i < MAX_BALLS; i++) { soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) }; soundBallsColor[i] = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; soundBallsRadius[i] = GetRandomValue(2, 50); soundBallsAlpha[i] = 1.0f; soundBallsActive[i] = false; } // ENDING screen variables Initialization raylibLogoA = LoadTexture("resources/raylib_logo.png"); #ifndef PLATFORM_WEB SetTargetFPS(60); #endif #if defined(PLATFORM_WEB) emscripten_set_main_loop(UpdateDrawOneFrame, 0, 1); #else //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose() && !closeWindow) // Detect window close button or ESC key { UpdateDrawOneFrame(); } #endif // De-Initialization //-------------------------------------------------------------------------------------- // Unload all loaded data (textures, fonts, audio) UnloadSpriteFont(fontAlagard); // SpriteFont unloading UnloadSpriteFont(fontPixelplay); // SpriteFont unloading UnloadSpriteFont(fontMecha); // SpriteFont unloading UnloadSpriteFont(fontSetback); // SpriteFont unloading UnloadSpriteFont(fontRomulus); // SpriteFont unloading UnloadTexture(raylibWindow); UnloadTexture(raylibWindow01); UnloadTexture(raylibWindow02); UnloadTexture(raylibWindow03); UnloadTexture(platforms); UnloadTexture(raylibLogoA); UnloadTexture(raylibLogoB); UnloadTexture(lena); UnloadTexture(mandrill); UnloadTexture(texAlagard); UnloadSpriteFont(fontMechaC); UnloadSpriteFont(fontAlagardC); UnloadSpriteFont(fontJupiterC); UnloadTexture(catTexture); UnloadModel(cat); UnloadSound(fxWav); UnloadSound(fxOgg); CloseAudioDevice(); CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void UpdateDrawOneFrame(void) { // Update //---------------------------------------------------------------------------------- if (!onTransition) { switch(currentScreen) { case LOADING: { // Update LOADING screen variables framesCounter++; // Count frames if ((loadBarWidth < loadBarMaxWidth) && ((framesCounter%30) == 0)) loadBarWidth++; if (IsKeyDown(KEY_SPACE) && (loadBarWidth < loadBarMaxWidth)) loadBarWidth += 4; if (IsKeyPressed(KEY_ENTER) && (loadBarWidth >= loadBarMaxWidth)) TransitionToScreen(LOGO); } break; case LOGO: { // Update LOGO screen variables if (logoScreenState == 0) // State 0: Small box blinking { framesCounter++; if (framesCounter == 120) { logoScreenState = 1; framesCounter = 0; // Reset counter... will be used later... } } else if (logoScreenState == 1) // State 1: Top and left bars growing { topSideRecWidth += 4; leftSideRecHeight += 4; if (topSideRecWidth == 256) logoScreenState = 2; } else if (logoScreenState == 2) // State 2: Bottom and right bars growing { bottomSideRecWidth += 4; rightSideRecHeight += 4; if (bottomSideRecWidth == 256) { lettersCounter = 0; for (int i = 0; i < strlen(msgBuffer); i++) msgBuffer[i] = ' '; logoScreenState = 3; } } else if (logoScreenState == 3) // State 3: Letters appearing (one by one) { framesCounter++; // Every 12 frames, one more letter! if ((framesCounter%12) == 0) raylibLettersCount++; switch (raylibLettersCount) { case 1: raylib[0] = 'r'; break; case 2: raylib[1] = 'a'; break; case 3: raylib[2] = 'y'; break; case 4: raylib[3] = 'l'; break; case 5: raylib[4] = 'i'; break; case 6: raylib[5] = 'b'; break; default: break; } if (raylibLettersCount >= 10) { // Write raylib description messages if ((framesCounter%2) == 0) lettersCounter++; if (!msgLogoADone) { if (lettersCounter <= strlen(msgLogoA)) strncpy(msgBuffer, msgLogoA, lettersCounter); else { for (int i = 0; i < strlen(msgBuffer); i++) msgBuffer[i] = ' '; lettersCounter = 0; msgLogoADone = true; } } else if (!msgLogoBDone) { if (lettersCounter <= strlen(msgLogoB)) strncpy(msgBuffer, msgLogoB, lettersCounter); else { msgLogoBDone = true; framesCounter = 0; } } } } // Press enter to change to MODULES screen if (IsKeyPressed(KEY_ENTER) && msgLogoBDone) TransitionToScreen(MODULES); else if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(LOGO); } break; case MODULES: { // Update MODULES screen variables here! framesCounter++; if (IsKeyPressed(KEY_RIGHT) && (selectedModule < 5)) { selectedModule++; framesCounter = 0; } else if (IsKeyPressed(KEY_LEFT) && (selectedModule > 0)) { selectedModule--; framesCounter = 0; } if (selectedModule == CORE) { if ((framesCounter > 60) && (windowOffset < 40)) { windowOffset++; ballPosition.x++; ballPosition.y++; } if (framesCounter > 140) { if (IsKeyDown('A')) ballPosition.x -= 5; if (IsKeyDown('D')) ballPosition.x += 5; if (IsKeyDown('W')) ballPosition.y -= 5; if (IsKeyDown('S')) ballPosition.y += 5; if (IsKeyPressed('1')) coreWindow = 1; if (IsKeyPressed('2')) coreWindow = 2; if (IsKeyPressed('3')) coreWindow = 3; if (IsKeyPressed('4')) coreWindow = 4; } } if (selectedModule == TEXTURES) scaleFactor = (sinf(2*PI/240*framesCounter) + 1.0f)/2; if (selectedModule == AUDIO) { if (IsKeyPressed(KEY_SPACE) && !MusicIsPlaying()) PlayMusicStream("resources/audio/guitar_noodling.ogg"); // Play music stream if (IsKeyPressed('S')) { StopMusicStream(); timePlayed = 0.0f; for (int i = 0; i < MAX_BALLS; i++) { soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) }; soundBallsColor[i] = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; soundBallsRadius[i] = GetRandomValue(2, 50); soundBallsAlpha[i] = 1.0f; soundBallsActive[i] = false; } } if (MusicIsPlaying()) { timePlayed = GetMusicTimePlayed() / GetMusicTimeLength() * 100 * 4; if ((framesCounter%10) == 0) { for (int i = 0; i < MAX_BALLS; i++) { if (!soundBallsActive[i]) { soundBallsActive[i] = true; break; } } } for (int i = 0; i < MAX_BALLS; i++) { if (soundBallsActive[i]) soundBallsAlpha[i] -= 0.005f; if (soundBallsAlpha[i] <= 0) { soundBallsActive[i] = false; // Reset ball random soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) }; soundBallsColor[i] = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; soundBallsRadius[i] = GetRandomValue(2, 60); soundBallsAlpha[i] = 1.0f; } } } if (IsKeyPressed('N')) PlaySound(fxWav); //if (IsKeyPressed('M')) PlaySound(fxOgg); } // Press enter to change to ENDING screen if (IsKeyPressed(KEY_ENTER)) TransitionToScreen(ENDING); else if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(LOGO); } break; case PONG: { // Update SECRET screen variables here! framesCounter++; if (IsKeyPressed('P')) pongPaused = !pongPaused; if (!pongPaused) { pongBallPosition.x += pongBallSpeed.x; pongBallPosition.y += pongBallSpeed.y; if ((pongBallPosition.x >= screenWidth - 5) || (pongBallPosition.x <= 5)) pongBallSpeed.x *= -1; if ((pongBallPosition.y >= screenHeight - 5) || (pongBallPosition.y <= 5)) pongBallSpeed.y *= -1; if (IsKeyDown(KEY_UP) || IsKeyDown('W')) { pongPlayerRec.y -= 5; pongAutoMode = false; pongAutoCounter = 180; } else if (IsKeyDown(KEY_DOWN) || IsKeyDown('S')) { pongPlayerRec.y += 5; pongAutoMode = false; pongAutoCounter = 180; } else if (pongAutoCounter > 0) { pongAutoCounter--; if (pongAutoCounter == 0) pongAutoMode = true; } if ((pongBallPosition.x < 600) && pongAutoMode) { if (pongBallPosition.y > (pongPlayerRec.y + pongPlayerRec.height/2)) pongPlayerRec.y += 5; else if (pongBallPosition.y < (pongPlayerRec.y + pongPlayerRec.height/2)) pongPlayerRec.y -= 5; } if (pongPlayerRec.y <= 0) pongPlayerRec.y = 0; else if ((pongPlayerRec.y + pongPlayerRec.height) >= screenHeight) pongPlayerRec.y = screenHeight - pongPlayerRec.height; if (pongBallPosition.x > screenWidth - 600) { if (pongBallPosition.y > (pongEnemyRec.y + pongEnemyRec.height/2)) pongEnemyRec.y += 5; else if (pongBallPosition.y < (pongEnemyRec.y + pongEnemyRec.height/2)) pongEnemyRec.y -= 5; if (pongEnemyRec.y <= 0) pongEnemyRec.y = 0; else if ((pongEnemyRec.y + pongEnemyRec.height) >= screenHeight) pongEnemyRec.y = screenHeight - pongEnemyRec.height; } if ((CheckCollisionCircleRec(pongBallPosition, 10, pongPlayerRec)) || (CheckCollisionCircleRec(pongBallPosition, 10, pongEnemyRec))) pongBallSpeed.x *= -1; if (pongBallPosition.x >= screenWidth - 5) pongScorePlayer++; else if (pongBallPosition.x <= 5) pongScoreEnemy++; } // Press enter to move back to MODULES screen if (IsKeyPressed(KEY_ENTER)) TransitionToScreen(ENDING); if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(ENDING); } break; case ENDING: { // Update ENDING screen framesCounter++; // Press enter to move back to MODULES screen if (IsKeyPressed(KEY_ENTER)) TransitionToScreen(PONG); if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(MODULES); } break; default: break; } if ((currentScreen != LOADING) && (timeCounter < totalTime)) timeCounter++; } else UpdateTransition(); // Update transition (fade-in, fade-out) //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); switch(currentScreen) { case LOADING: { // Draw LOADING screen if ((loadBarWidth < loadBarMaxWidth) && ((framesCounter/40)%2)) DrawText(msgLoading, 360, 240, 40, DARKGRAY); DrawRectangle(360 - 4, 300 - 4, loadBarMaxWidth + 8, 60 + 8, LIGHTGRAY); DrawRectangle(360, 300, loadBarWidth - 1, 60, DARKGRAY); DrawRectangleLines(360 - 4, 300 - 5, loadBarMaxWidth + 8, 60 + 8, DARKGRAY); if (loadBarWidth >= loadBarMaxWidth) { //DrawText(msgLoading, 360, 240, 40, DARKGRAY); if ((framesCounter/30)%2) DrawText(msgPressEnter, screenWidth/2 - MeasureText(msgPressEnter, 40)/2 + 20, 400, 40, DARKGRAY); } else DrawText("PRESS SPACE to ACCELERATE LOADING! ;)", screenWidth/2 - 200, 400, 20, LIGHTGRAY); } break; case LOGO: { // Draw LOGO screen if (logoScreenState == 0) { if ((framesCounter/15)%2) DrawRectangle(logoPositionX, logoPositionY - 60, 16, 16, BLACK); } else if (logoScreenState == 1) { DrawRectangle(logoPositionX, logoPositionY - 60, topSideRecWidth, 16, BLACK); DrawRectangle(logoPositionX, logoPositionY - 60, 16, leftSideRecHeight, BLACK); } else if (logoScreenState == 2) { DrawRectangle(logoPositionX, logoPositionY - 60, topSideRecWidth, 16, BLACK); DrawRectangle(logoPositionX, logoPositionY - 60, 16, leftSideRecHeight, BLACK); DrawRectangle(logoPositionX + 240, logoPositionY - 60, 16, rightSideRecHeight, BLACK); DrawRectangle(logoPositionX, logoPositionY + 240 - 60, bottomSideRecWidth, 16, BLACK); } else if (logoScreenState == 3) { DrawRectangle(logoPositionX, logoPositionY - 60, topSideRecWidth, 16, BLACK); DrawRectangle(logoPositionX, logoPositionY + 16 - 60, 16, leftSideRecHeight - 32, BLACK); DrawRectangle(logoPositionX + 240, logoPositionY + 16 - 60, 16, rightSideRecHeight - 32, BLACK); DrawRectangle(logoPositionX, logoPositionY + 240 - 60, bottomSideRecWidth, 16, BLACK); DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112 - 60, 224, 224, RAYWHITE); DrawText(raylib, screenWidth/2 - 44, screenHeight/2 + 48 - 60, 50, BLACK); if (!msgLogoADone) DrawText(msgBuffer, screenWidth/2 - MeasureText(msgLogoA, 30)/2, 460, 30, GRAY); else { DrawText(msgLogoA, screenWidth/2 - MeasureText(msgLogoA, 30)/2, 460, 30, GRAY); if (!msgLogoBDone) DrawText(msgBuffer, screenWidth/2 - MeasureText(msgLogoB, 30)/2, 510, 30, GRAY); else { DrawText(msgLogoB, screenWidth/2 - MeasureText(msgLogoA, 30)/2, 510, 30, GRAY); if ((framesCounter > 90) && ((framesCounter/30)%2)) DrawText("PRESS ENTER to CONTINUE", 930, 650, 20, GRAY); } } } } break; case MODULES: { // Draw MODULES screen DrawTexture(raylibLogoB, 40, 40, WHITE); DrawText("raylib is composed of 6 main modules:", 128 + 40 + 30, 50, 20, GRAY); if (framesCounter < 120) { if (((framesCounter/30)%2) == 0) DrawRectangle(128 + 40 + 30 - 4 + 175*selectedModule, 128 + 40 - 70 - 8 - 4, 158, 78, RED); } else DrawRectangle(128 + 40 + 30 - 4 + 175*selectedModule, 128 + 40 - 70 - 8 - 4, 158, 78, RED); if (selectedModule != AUDIO) { DrawTriangle((Vector2){950 - 40, 685 - 10}, (Vector2){950 - 60, 685}, (Vector2){950 - 40, 685 + 10}, GRAY); DrawTriangle((Vector2){950 - 30, 685 - 10}, (Vector2){950 - 30, 685 + 10}, (Vector2){950 - 10, 685}, GRAY); DrawText("PRESS RIGHT or LEFT to EXPLORE MODULES", 960, 680, 10, GRAY); } switch (selectedModule) { case CORE: { DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x5c5a5aff)); DrawTextEx(fontRomulus, "Open-Close Window", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); DrawTextEx(fontRomulus, "Manage Drawing Area", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); DrawTextEx(fontRomulus, "Manage Inputs", (Vector2){ 48, 290 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); DrawTextEx(fontRomulus, "Manage Timming", (Vector2){ 48, 320 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); DrawTextEx(fontRomulus, "Auxiliar Functions", (Vector2){ 48, 350 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); switch (coreWindow) { case 1: DrawTexture(raylibWindow, 520, 220, WHITE); break; case 2: DrawTextureEx(raylibWindow01, (Vector2){ 450, 220 - 45 }, 0.0f, 4.0f, WHITE); break; case 3: DrawTextureEx(raylibWindow02, (Vector2){ 430, 220 - 40 }, 0.0f, 4.0f, WHITE); break; case 4: DrawTextureEx(raylibWindow03, (Vector2){ 470, 220 - 65 }, 0.0f, 4.0f, WHITE); break; default: DrawTexture(raylibWindow, 520, 220, WHITE); break; } if (framesCounter > 140) DrawText("Check the possible windows raylib can run on. PRESS KEY: 1, 2, 3 or 4", 520 + 8 + windowOffset + 160, 220 + windowOffset + 10, 10, LIGHTGRAY); DrawText("Compile raylib C code for the folowing platforms:", 48, 400, 10, MAROON); DrawTextureRec(platforms, (Rectangle){ 0, 0, platforms.width, platforms.height}, (Vector2){ 75, 420 }, WHITE); DrawRectangle(520 + 8 + windowOffset, 220 + 31 + windowOffset, 640, 360, RAYWHITE); DrawRectangleLines(520 + 8 + windowOffset - 1, 220 + 31 + windowOffset - 2, 640 + 2, 360 + 2, GRAY); DrawFPS(520 + 8 + windowOffset + 10, 220 + 31 + windowOffset + 10); DrawRectangle(ballPosition.x - 50, ballPosition.y - 50, 100, 100, Fade(MAROON, 0.5f)); DrawRectangleRec(GetCollisionRec((Rectangle){ 520 + 8 + windowOffset - 1, 220 + 31 + windowOffset - 1, 640 + 2, 360 + 2 }, (Rectangle){ (int)ballPosition.x - 50, (int)ballPosition.y - 50, 100, 100 }), MAROON); if (framesCounter > 140) { DrawTextEx(fontMecha, "MOVE ME", (Vector2){ ballPosition.x - 26, ballPosition.y - 20 }, GetFontBaseSize(fontMecha), 2, BLACK); DrawTextEx(fontMecha, "[ W A S D ]", (Vector2){ ballPosition.x - 36, ballPosition.y }, GetFontBaseSize(fontMecha), 2, BLACK); } } break; case SHAPES: { DrawText("This module give you functions to:", 48, 200, 10, GetColor(0xcd5757ff)); DrawTextEx(fontRomulus, "Draw Basic Shapes", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0xcd5757ff)); DrawTextEx(fontRomulus, "Basic Collision Detection", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0xcd5757ff)); DrawCircle(screenWidth/4, 120 + 240, 35, DARKBLUE); DrawCircleGradient(screenWidth/4, 220 + 240, 60, GREEN, SKYBLUE); DrawCircleLines(screenWidth/4, 340 + 240, 80, DARKBLUE); DrawRectangle(screenWidth/4*2 - 110, 100 + 180, 220, 100, LIME); DrawRectangleGradient(screenWidth/4*2 - 90, 170 + 240, 180, 130, MAROON, GOLD); DrawRectangleLines(screenWidth/4*2 - 80, 320 + 240, 160, 80, ORANGE); DrawTriangle((Vector2){screenWidth/4*3, 60 + 220}, (Vector2){screenWidth/4*3 - 60, 160 + 220}, (Vector2){screenWidth/4*3 + 60, 160 + 220}, VIOLET); DrawTriangleLines((Vector2){screenWidth/4*3, 140 + 220}, (Vector2){screenWidth/4*3 - 60, 210 + 260}, (Vector2){screenWidth/4*3 + 60, 210 + 260}, SKYBLUE); DrawPoly((Vector2){screenWidth/4*3, 320 + 240}, 6, 80, 0, BROWN); } break; case TEXTURES: { DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x60815aff)); DrawTextEx(fontRomulus, "Load Images and Textures", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x60815aff)); DrawTextEx(fontRomulus, "Draw Textures", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x60815aff)); DrawRectangle(138, 348, 260, 260, GRAY); DrawTexturePro(lena, (Rectangle){ 0, 0, lena.width, lena.height }, (Rectangle){ 140 + 128, 350 + 128, lena.width/2*scaleFactor, lena.height/2*scaleFactor }, (Vector2){ lena.width/4*scaleFactor, lena.height/4*scaleFactor }, 0.0f, WHITE); DrawTexture(lena, 600, 180, Fade(WHITE, 0.3f)); DrawTextureRec(lena, (Rectangle){ 225, 240, 155, 50 }, (Vector2){ 600 + 256 - 82 + 50, 180 + 241 }, PINK); DrawTexturePro(mandrill, (Rectangle){ 0, 0, mandrill.width, mandrill.height }, (Rectangle){ screenWidth/2 - 40, 350 + 128, mandrill.width/2, mandrill.height/2 }, (Vector2){ mandrill.width/4, mandrill.height/4 }, framesCounter, GOLD); } break; case TEXT: { DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x377764ff)); DrawTextEx(fontRomulus, "Load SpriteFonts", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x377764ff)); DrawTextEx(fontRomulus, "Draw Text", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x377764ff)); DrawTextEx(fontRomulus, "Text Formatting", (Vector2){ 48, 290 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x377764ff)); DrawTexture(texAlagard, 60, 360, WHITE); DrawTextEx(fontMechaC, msg1, (Vector2){ 540 + 168, 210 }, GetFontBaseSize(fontMechaC), -3, WHITE); DrawTextEx(fontAlagardC, msg2, (Vector2){ 460 + 140, 260 }, GetFontBaseSize(fontAlagardC), -2, WHITE); DrawTextEx(fontJupiterC, msg3, (Vector2){ 640 + 70, 300 }, GetFontBaseSize(fontJupiterC), 2, WHITE); DrawTextEx(fontAlagard, "It also includes some...", (Vector2){ 650 + 70, 400 }, GetFontBaseSize(fontAlagard)*2, 2, MAROON); DrawTextEx(fontPixelplay, "...free fonts in rBMF format...", (Vector2){ 705 - 26, 450 }, GetFontBaseSize(fontPixelplay)*2, 4, ORANGE); DrawTextEx(fontMecha, "...to be used even in...", (Vector2){ 700 + 40, 500 }, GetFontBaseSize(fontMecha)*2, 4, DARKGREEN); DrawTextEx(fontSetback, "...comercial projects...", (Vector2){ 710, 550 }, GetFontBaseSize(fontSetback)*2, 4, DARKBLUE); DrawTextEx(fontRomulus, "...completely for free!", (Vector2){ 710 + 17, 600 }, GetFontBaseSize(fontRomulus)*2, 3, DARKPURPLE); DrawText("This is a custom font spritesheet, raylib can load it automatically!", 228, 360 + 295, 10, GRAY); } break; case MODELS: { DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x417794ff)); DrawTextEx(fontRomulus, "Draw Geometric Models", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x417794ff)); DrawTextEx(fontRomulus, "Load 3D Models", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x417794ff)); DrawTextEx(fontRomulus, "Draw 3D Models", (Vector2){ 48, 290 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x417794ff)); Begin3dMode(camera); DrawCube((Vector3){-4, 0, 2}, 2, 5, 2, RED); DrawCubeWires((Vector3){-4, 0, 2}, 2, 5, 2, GOLD); DrawCubeWires((Vector3){-4, 0, -2}, 3, 6, 2, MAROON); DrawSphere((Vector3){-1, 0, -2}, 1, GREEN); DrawSphereWires((Vector3){1, 0, 2}, 2, 16, 16, LIME); DrawCylinder((Vector3){4, 0, -2}, 1, 2, 3, 4, SKYBLUE); DrawCylinderWires((Vector3){4, 0, -2}, 1, 2, 3, 4, DARKBLUE); DrawCylinderWires((Vector3){4.5, -1, 2}, 1, 1, 2, 6, BROWN); DrawCylinder((Vector3){1, 0, -4}, 0, 1.5, 3, 8, GOLD); DrawCylinderWires((Vector3){1, 0, -4}, 0, 1.5, 3, 8, PINK); DrawModelEx(cat, (Vector3){ 8.0f, 0.0f, 2.0f }, (Vector3){ 0.0f, 0.5f*framesCounter, 0.0f }, (Vector3){ 0.1f, 0.1f, 0.1f }, WHITE); DrawGizmo((Vector3){ 8.0f, 0.0f, 2.0f }); DrawGrid(10.0, 1.0); // Draw a grid End3dMode(); DrawFPS(900, 220); } break; case AUDIO: { DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x8c7539ff)); DrawTextEx(fontRomulus, "Load and Play Sounds", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x8c7539ff)); DrawTextEx(fontRomulus, "Play Music (streaming)", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x8c7539ff)); DrawText("PRESS SPACE to START PLAYING MUSIC", 135, 350, 20, GRAY); DrawRectangle(150, 390, 400, 12, LIGHTGRAY); DrawRectangle(150, 390, (int)timePlayed, 12, MAROON); if (MusicIsPlaying()) { DrawText("PRESS 'S' to STOP PLAYING MUSIC", 165, 425, 20, GRAY); for (int i = 0; i < MAX_BALLS; i++) { if (soundBallsActive[i]) DrawPoly(soundBallsPosition[i], 18, soundBallsRadius[i], 0.0f, Fade(soundBallsColor[i], soundBallsAlpha[i])); } } DrawText("PRESS 'N' to PLAY a SOUND", 200, 540, 20, VIOLET); if ((framesCounter/30)%2) DrawText("PRESS ENTER to CONTINUE", 930, 650, 20, GRAY); } break; default: break; } // Draw modules menu DrawRectangle(128 + 40 + 30, 128 + 40 - 70 - 8, 150, 70, GetColor(0x898888ff)); DrawRectangle(128 + 40 + 30 + 8, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xe1e1e1ff)); DrawText("CORE", 128 + 40 + 30 + 8 + 38, 128 + 40 - 50, 20, GetColor(0x5c5a5aff)); DrawRectangle(128 + 40 + 30 + 175, 128 + 40 - 70 - 8, 150, 70, GetColor(0xe66666ff)); DrawRectangle(128 + 40 + 30 + 8 + 175, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xf0d6d6ff)); DrawText("SHAPES", 128 + 40 + 30 + 8 + 175 + 28, 128 + 40 - 50, 20, GetColor(0xcd5757ff)); DrawRectangle(128 + 40 + 30 + 175*2, 128 + 40 - 70 - 8, 150, 70, GetColor(0x75a06dff)); DrawRectangle(128 + 40 + 30 + 8 + 175*2, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xc8eabfff)); DrawText("TEXTURES", 128 + 40 + 30 + 175*2 + 8 + 9, 128 + 40 - 50, 20, GetColor(0x60815aff)); DrawRectangle(128 + 40 + 30 + 175*3, 128 + 40 - 70 - 8, 150, 70, GetColor(0x52b296ff)); DrawRectangle(128 + 40 + 30 + 8 + 175*3, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xbef0ddff)); DrawText("TEXT", 128 + 40 + 30 + 8 + 175*3 + 38, 128 + 40 - 50, 20, GetColor(0x377764ff)); DrawRectangle(128 + 40 + 30 + 175*4, 128 + 40 - 70 - 8, 150, 70, GetColor(0x5d9cbdff)); DrawRectangle(128 + 40 + 30 + 8 + 175*4, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xbedce8ff)); DrawText("MODELS", 128 + 40 + 30 + 8 + 175*4 + 28, 128 + 40 - 50, 20, GetColor(0x417794ff)); DrawRectangle(128 + 40 + 30 + 175*5, 128 + 40 - 70 - 8, 150, 70, GetColor(0xd3b157ff)); DrawRectangle(128 + 40 + 30 + 8 + 175*5, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xebddaeff)); DrawText("AUDIO", 128 + 40 + 30 + 8 + 175*5 + 36, 128 + 40 - 50, 20, GetColor(0x8c7539ff)); } break; case ENDING: { // Draw ENDING screen DrawTextEx(fontAlagard, "LEARN VIDEOGAMES PROGRAMMING", (Vector2){ screenWidth/2 - MeasureTextEx(fontAlagard, "LEARN VIDEOGAMES PROGRAMMING", GetFontBaseSize(fontAlagard)*4, 4).x/2, 80 }, GetFontBaseSize(fontAlagard)*4, 4, MAROON); DrawTexture(raylibLogoA, logoPositionX, logoPositionY - 40, WHITE); DrawText(msgWeb, screenWidth/2 - MeasureText(msgWeb, 40)/2, 470, 40, DARKGRAY); if (framesCounter > 60) DrawText(msgCredits, screenWidth/2 - MeasureText(msgCredits, 30)/2, 550, 30, GRAY); if (framesCounter > 120) if ((framesCounter/30)%2) DrawText("PRESS ENTER to CONTINUE", screenWidth/2 - MeasureText("PRESS ENTER to CONTINUE", 20)/2, 640, 20, LIGHTGRAY); } break; case PONG: { // Pong DrawCircleV(pongBallPosition, 10, LIGHTGRAY); DrawRectangleRec(pongPlayerRec, GRAY); DrawRectangleRec(pongEnemyRec, GRAY); DrawText(FormatText("%02i", pongScorePlayer), 150, 10, 80, LIGHTGRAY); DrawText(FormatText("%02i", pongScoreEnemy), screenWidth - MeasureText("00", 80) - 150, 10, 80, LIGHTGRAY); if (pongPaused) if ((framesCounter/30)%2) DrawText("GAME PAUSED [P]", screenWidth/2 - 100, 40, 20, MAROON); } break; default: break; } if (currentScreen != LOADING) DrawRectangle(0, screenHeight - 10, ((float)timeCounter/(float)totalTime)*screenWidth, 10, LIGHTGRAY); if (onTransition) DrawTransition(); EndDrawing(); //---------------------------------------------------------------------------------- }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "Floppy Bird"); InitAudioDevice(); // Initialize audio device Sound coin = LoadSound("resources/coin.wav"); Sound jump = LoadSound("resources/jump.wav"); Texture2D background = LoadTexture("resources/background.png"); Texture2D tubes = LoadTexture("resources/tubes.png"); Texture2D floppy = LoadTexture("resources/floppy.png"); Vector2 floppyPos = { 80, screenHeight/2 - floppy.height/2 }; Vector2 tubesPos[MAX_TUBES]; int tubesSpeedX = 2; for (int i = 0; i < MAX_TUBES; i++) { tubesPos[i].x = 400 + 280*i; tubesPos[i].y = -GetRandomValue(0, 120); } Rectangle tubesRecs[MAX_TUBES*2]; bool tubesActive[MAX_TUBES]; for (int i = 0; i < MAX_TUBES*2; i += 2) { tubesRecs[i].x = tubesPos[i/2].x; tubesRecs[i].y = tubesPos[i/2].y; tubesRecs[i].width = tubes.width; tubesRecs[i].height = 255; tubesRecs[i+1].x = tubesPos[i/2].x; tubesRecs[i+1].y = 600 + tubesPos[i/2].y - 255; tubesRecs[i+1].width = tubes.width; tubesRecs[i+1].height = 255; tubesActive[i/2] = true; } int backScroll = 0; int score = 0; int hiscore = 0; bool gameover = false; bool superfx = false; SetTargetFPS(60); //--------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- backScroll--; if (backScroll <= -800) backScroll = 0; for (int i = 0; i < MAX_TUBES; i++) tubesPos[i].x -= tubesSpeedX; for (int i = 0; i < MAX_TUBES*2; i += 2) { tubesRecs[i].x = tubesPos[i/2].x; tubesRecs[i+1].x = tubesPos[i/2].x; } if (IsKeyDown(KEY_SPACE) && !gameover) floppyPos.y -= 3; else floppyPos.y += 1; if (IsKeyPressed(KEY_SPACE) && !gameover) PlaySound(jump); // Check Collisions for (int i = 0; i < MAX_TUBES*2; i++) { if (CheckCollisionCircleRec((Vector2){ floppyPos.x + floppy.width/2, floppyPos.y + floppy.height/2 }, floppy.width/2, tubesRecs[i])) { gameover = true; } else if ((tubesPos[i/2].x < floppyPos.x) && tubesActive[i/2] && !gameover) { score += 100; tubesActive[i/2] = false; PlaySound(coin); superfx = true; if (score > hiscore) hiscore = score; } } if (gameover && IsKeyPressed(KEY_ENTER)) { for (int i = 0; i < MAX_TUBES; i++) { tubesPos[i].x = 400 + 280*i; tubesPos[i].y = -GetRandomValue(0, 120); } for (int i = 0; i < MAX_TUBES*2; i += 2) { tubesRecs[i].x = tubesPos[i/2].x; tubesRecs[i].y = tubesPos[i/2].y; tubesRecs[i+1].x = tubesPos[i/2].x; tubesRecs[i+1].y = 600 + tubesPos[i/2].y - 255; tubesActive[i/2] = true; } floppyPos.x = 80; floppyPos.y = screenHeight/2 - floppy.height/2; gameover = false; score = 0; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawTexture(background, backScroll, 0, WHITE); DrawTexture(background, screenWidth + backScroll, 0, WHITE); if (!gameover) { DrawTextureEx(floppy, floppyPos, 0, 1.0, WHITE); //DrawCircleLines(floppyPos.x + floppy.width/2, floppyPos.y + floppy.height/2, floppy.width/2, RED); } for (int i = 0; i < MAX_TUBES; i++) { if (tubesPos[i].x <= 800) DrawTextureEx(tubes, tubesPos[i], 0, 1.0, WHITE); //DrawRectangleLines(tubesRecs[i*2].x, tubesRecs[i*2].y, tubesRecs[i*2].width, tubesRecs[i*2].height, RED); //DrawRectangleLines(tubesRecs[i*2 + 1].x, tubesRecs[i*2 + 1].y, tubesRecs[i*2 + 1].width, tubesRecs[i*2 + 1].height, RED); } DrawText(FormatText("%04i", score), 20, 20, 40, PINK); DrawText(FormatText("HI-SCORE: %04i", hiscore), 20, 70, 20, VIOLET); if (gameover) { DrawText("GAME OVER", 100, 180, 100, MAROON); DrawText("PRESS ENTER to RETRY!", 280, 280, 20, RED); } if (superfx) { DrawRectangle(0, 0, screenWidth, screenHeight, GOLD); superfx = false; } EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(background); // Texture unloading UnloadTexture(tubes); // Texture unloading UnloadTexture(floppy); // Texture unloading UnloadSound(coin); // Unload sound data UnloadSound(jump); // Unload sound data CloseAudioDevice(); // Close audio device CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
// Update game (one frame) void UpdateGame(void) { if (!gameOver) { if (IsKeyPressed('P')) pause = !pause; if (!pause) { switch (wave) { case FIRST: { if (!smooth) { alpha += 0.02f; if (alpha >= 1.0f) smooth = true; } if (smooth) alpha -= 0.02f; if (enemiesKill == activeEnemies) { enemiesKill = 0; for (int i = 0; i < activeEnemies; i++) { if (!enemy[i].active) enemy[i].active = true; } activeEnemies = SECOND_WAVE; wave = SECOND; smooth = false; alpha = 0.0f; } } break; case SECOND: { if (!smooth) { alpha += 0.02f; if (alpha >= 1.0f) smooth = true; } if (smooth) alpha -= 0.02f; if (enemiesKill == activeEnemies) { enemiesKill = 0; for (int i = 0; i < activeEnemies; i++) { if (!enemy[i].active) enemy[i].active = true; } activeEnemies = THIRD_WAVE; wave = THIRD; smooth = false; alpha = 0.0f; } } break; case THIRD: { if (!smooth) { alpha += 0.02f; if (alpha >= 1.0f) smooth = true; } if (smooth) alpha -= 0.02f; if (enemiesKill == activeEnemies) victory = true; } break; default: break; } // Player movement if (IsKeyDown(KEY_RIGHT)) player.rec.x += player.speed.x; if (IsKeyDown(KEY_LEFT)) player.rec.x -= player.speed.x; if (IsKeyDown(KEY_UP)) player.rec.y -= player.speed.y; if (IsKeyDown(KEY_DOWN)) player.rec.y += player.speed.y; // Player collision with enemy for (int i = 0; i < activeEnemies; i++) { if (CheckCollisionRecs(player.rec, enemy[i].rec)) gameOver = true; } // Enemy behaviour for (int i = 0; i < activeEnemies; i++) { if (enemy[i].active) { enemy[i].rec.x -= enemy[i].speed.x; if (enemy[i].rec.x < 0) { enemy[i].rec.x = GetRandomValue(screenWidth, screenWidth + 1000); enemy[i].rec.y = GetRandomValue(0, screenHeight - enemy[i].rec.height); } } } // Wall behaviour if (player.rec.x <= 0) player.rec.x = 0; if (player.rec.x + player.rec.width >= screenWidth) player.rec.x = screenWidth - player.rec.width; if (player.rec.y <= 0) player.rec.y = 0; if (player.rec.y + player.rec.height >= screenHeight) player.rec.y = screenHeight - player.rec.height; //Shoot initialization if (IsKeyDown(KEY_SPACE)) { shootRate += 5; for (int i = 0; i < NUM_SHOOTS; i++) { if (!shoot[i].active && shootRate%20 == 0) { shoot[i].rec.x = player.rec.x; shoot[i].rec.y = player.rec.y + player.rec.height/4; shoot[i].active = true; break; } } } // Shoot logic for (int i = 0; i < NUM_SHOOTS; i++) { if (shoot[i].active) { // Movement shoot[i].rec.x += shoot[i].speed.x; // Collision with enemy for (int j = 0; j < activeEnemies; j++) { if (enemy[j].active) { if (CheckCollisionRecs(shoot[i].rec, enemy[j].rec)) { shoot[i].active = false; enemy[j].rec.x = GetRandomValue(screenWidth, screenWidth + 1000); enemy[j].rec.y = GetRandomValue(0, screenHeight - enemy[j].rec.height); shootRate = 0; enemiesKill++; score += 100; } if (shoot[i].rec.x + shoot[i].rec.width >= screenWidth) { shoot[i].active = false; shootRate = 0; } } } } } } } else { if (IsKeyPressed(KEY_ENTER)) { InitGame(); gameOver = false; } } }