API tools faq
paste
Advertisement
Splux

SFML2 Unhandled Exception

Splux
May 4th, 2012
146
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 24.61 KB | None | 0 0
raw download clone embed print report
  1. /* Game.cpp */
  2. #include "Game.hpp"
  3. #include <sstream>
  4.  
  5. void Game::Init()
  6. {
  7.     mainWindow.create(sf::VideoMode(800, 600, 32), "NTI Zombie-Survival! _ALPHA_");
  8.     mainWindow.display();
  9.  
  10.     std::srand(time(NULL));
  11.     if(!zombieTexture.loadFromFile("img/zombie.bmp"))
  12.     {
  13.         printf("zombie.bmp could not be loaded");
  14.     }
  15.  
  16.     for(int i = 0; i < 100; i++)
  17.         blood[i] = NULL;
  18.  
  19.     Player1 = new Player();
  20.     std::vector<Zombie>::iterator it;
  21.     zombie.resize(100);
  22.  
  23.     iKillsMoreZombies = 10;//start value for more ZOMBIES =D=D=D=D=D
  24.     iNrOfZombies = 5;
  25.     zombieMultiplier = 1.6;
  26.     for(int i = 0; i < iNrOfZombies; i++)
  27.     {
  28.         zombie.push_back(Zombie());
  29.         zombie[i].Init(zombieTexture);
  30.     }
  31.    
  32.    
  33.    
  34.     midtow = new Castle();
  35.    
  36.     if(!bloodLoad.loadFromFile("img/blood_splatter.bmp"))
  37.     {
  38.         printf("blood_splatter.bmp could not be loaded");
  39.     }
  40.  
  41.     if(!bgTexture.loadFromFile("img/background.png"))
  42.     {
  43.         printf("background.jpg could not be loaded");
  44.     }
  45.     bg.setTexture(bgTexture);
  46.  
  47.     iKillCounter = 0;
  48.     Kills.setPosition(750, 30);
  49.     Kills.setColor(sf::Color::Black);
  50.  
  51.     GameState = Game::Running;
  52.     gameLoop();
  53. }
  54.  
  55. void Game::gameLoop()
  56. {  
  57.     /*mainWindow.draw(Player1->drawSprite());
  58.    
  59.     for(int i = 0; i < iNrOfZombies; i++)
  60.     {
  61.         mainWindow.draw(zombie[i].drawSprite());
  62.     }
  63.  
  64.     mainWindow.display();*/
  65.  
  66.     while(mainWindow.isOpen())
  67.     {
  68.         sf::Event ev;
  69.         while(mainWindow.pollEvent(ev))//in case you press that nice, big, red X... uhm, big nice x... *press*
  70.         {
  71.             switch(ev.type)
  72.             {
  73.             case sf::Event::Closed:
  74.                 GameState = Game::Exiting;
  75.                 break;
  76.             default:
  77.                 break;
  78.             }
  79.         }
  80.         switch(GameState)
  81.         {
  82.         case Running:
  83.  
  84.             if(midtow->getHealth() <= 0)// <= 0 means that tower is blown up, duh
  85.             {
  86.                 GameState = Game::Lost;
  87.             }
  88.  
  89.             //check for input
  90.             if(Player1->getTime() > 50.0f)//lets the user move 20x/sec
  91.             {
  92.                 input();
  93.                 Player1->restartClock();
  94.             }
  95.            
  96.             for(int i = 0; i < iNrOfZombies; i++)//check to see if any of the zombies needs to move, in that case - move.
  97.             {
  98.                     if(zombie[i].getTime() > 50.0f)
  99.                     {
  100.                         zombie[i].restartClock();
  101.                         moveZombie();
  102.                         break;
  103.                     }
  104.                     else
  105.                     {
  106.                         break;
  107.                     }
  108.             }
  109.  
  110.            
  111.             if(iKillCounter == iKillsMoreZombies && iNrOfZombies + 5 < 120)//add le more awesome zombies
  112.             {
  113.                 for(int i = iNrOfZombies; i < iNrOfZombies + 5; i++)
  114.                 {
  115.                     zombie.push_back(Zombie());
  116.                     zombie[i].Init(zombieTexture);
  117.                 }
  118.                 iNrOfZombies += 5;
  119.                 iKillsMoreZombies *= zombieMultiplier;
  120.             }
  121.  
  122.             //check collisions:
  123.             collision();
  124.             //draw everything on the screen
  125.             drawScreen();
  126.             break;
  127.  
  128.         case Exiting:
  129.             Exit();
  130.             break;
  131.  
  132.         case Paused:
  133.             isPaused();
  134.             break;
  135.            
  136.         case Lost:
  137.             gameLost();
  138.             break;
  139.         }
  140.     }
  141. }
  142.  
  143. void Game::drawScreen()
  144. {
  145.     //clear and draw sprites + display
  146.     mainWindow.clear();//clear all previous stuff
  147.     mainWindow.draw(bg);//draw background
  148.     Kills.setString(KillsToString());//convert the integer of kills into a string
  149.     mainWindow.draw(Kills);//draw number of kills
  150.     drawZombies();//draw zombies
  151.     mainWindow.draw(Player1->drawSprite());//draw player
  152.     mainWindow.draw(midtow->drawSprite());//draw midtower
  153.     mainWindow.draw(midtow->drawText());//draw number of lifes left
  154.     mainWindow.display();//display all the things we have drawn
  155. }
  156.  
  157. void Game::drawZombies()
  158. {
  159.     /*for(int i = 0; i < iNrOfZombies; i++)
  160.     {
  161.         if(zombie[i] != NULL)
  162.         {
  163.             if(zombie[i]->isDead())
  164.             {
  165.                 blood.setPosition(zombie[i]->getPosition());
  166.                 mainWindow.draw(blood);
  167.             }
  168.         }
  169.     }*/
  170.     int i = 0;
  171.     //for(std::vector<Zombie>::iterator it = zombie.end(); it > zombie.begin(); it--)//loop through all zombies
  172.     //{
  173.     //  if(zombie[i].isDead())
  174.     //  {
  175.     //      //blood.setPosition(zombie.at(i).getPosition());
  176.     //      //mainWindow.draw(blood);//draw blood instead of a zombie
  177.     //      for(int q = 0; q < iNrOfZombies; q++)
  178.     //      {
  179.     //          if(blood2[q] == NULL)
  180.     //          {
  181.     //              blood2[q] = new Blood(bloodLoad, zombie[i].getPosition());
  182.     //              zombie[i].becameBloody(true);
  183.     //          }
  184.     //      }
  185.     //  }
  186.     //  i++;
  187.     //}
  188.     for(; i < iNrOfZombies; i++)
  189.     {
  190.         if(blood[i] != NULL)
  191.         {
  192.             if(blood[i]->getTime() > 7)
  193.             {
  194.                 delete blood[i];
  195.                 blood[i] = NULL;
  196.             }
  197.             else
  198.             {
  199.                 mainWindow.draw(blood[i]->getSprite());
  200.             }
  201.         }
  202.     }
  203.     i = 0;
  204.     for(std::vector<Zombie>::iterator it = zombie.begin() + iNrOfZombies; it > zombie.begin(); it--)
  205.     {
  206.         if(!zombie[i].isDead())
  207.         {
  208.             mainWindow.draw(zombie[i].drawSprite());//draw the zombie sprite since he's not killed
  209.         }
  210.         else if(zombie[i].getTimeDead() > 7)//zombie respawner
  211.         {
  212.             zombie[i].respawn();
  213.         }
  214.         i++;
  215.     }
  216.     //for(int i = 0; i < iNrOfZombies; i++)
  217.     //{
  218.     //  if(zombie[i] != NULL)
  219.     //  {
  220.     //      if(!zombie[i]->isDead())//draw zombies
  221.     //          mainWindow.draw(zombie[i]->drawSprite());
  222.     //      else if(zombie[i]->getTimeDead() > 7)//respawn timer.
  223.     //      {
  224.     //          delete zombie[i];
  225.     //          /*zombie[i] = NULL;
  226.     //          zombie[i] = new Zombie(zombieTexture);*/
  227.     //          zombie.erase((zombie.begin() + i )-1);
  228.     //      }
  229.     //  }
  230.     //}
  231.    
  232. }
  233.  
  234. void Game::collision()
  235. {
  236.     sf::FloatRect plFl = Player1->getFR();
  237.     sf::FloatRect caFl = midtow->getFR();
  238.     sf::FloatRect zmFl;
  239.     int i = 0;
  240.     for(std::vector<Zombie>::iterator it = zombie.end(); it > zombie.begin(); it--)//10 zombies = 10 loops.
  241.     {
  242.         zmFl  = zombie[i].getFR();
  243.         if(plFl.intersects(zmFl))//checks for intersections
  244.         {
  245.             if(!zombie[i].isDead())
  246.             {
  247.                 zombie[i].setKilled(true);//zombie is killed, woho
  248.                 for(int x = 0; x < iNrOfZombies; x++)
  249.                 {
  250.                     if(blood[x] == NULL)
  251.                     {
  252.                         blood[x] = new Blood(bloodLoad, zombie[i].getPosition());
  253.                         zombie[i].becameBloody(true);
  254.                         break;
  255.                     }
  256.                 }
  257.                 iKillCounter++;
  258.             }
  259.         }
  260.         if(zmFl.intersects(caFl))
  261.         {
  262.             zombie[i].respawn();//respawn zombie at a new place
  263.             midtow->redHealth();//reduce health on tower
  264.         }
  265.         i++;
  266.     }
  267. }
  268.  
  269. void Game::moveZombie()
  270. {
  271.     int i = 0;
  272.     for(std::vector<Zombie>::iterator it = zombie.end(); it > zombie.begin(); it--)
  273.     {
  274.         if(!zombie[i].isDead())         //check if the zombie is dead
  275.             zombie[i].moveZombie();     //else move it
  276.         i++;
  277.     }
  278.  
  279.     //for(int i = 0; i < iNrOfZombies; i++)//worthless way to move zombie.. :C
  280.     //{
  281.     //  if(zombie[i] != NULL)
  282.     //  {
  283.     //      if(!zombie[i]->isDead())
  284.     //      {
  285.     //          if(zombie[i]->getPosition().x <= midtow->getPosition().x + 20 &&
  286.     //              zombie[i]->getPosition().x >= midtow->getPosition().x - 20)
  287.     //          {
  288.     //              if(zombie[i]->getPosition().y <= midtow->getPosition().y)
  289.     //              {
  290.     //                  if(zombie[i]->getRotation() != 0.0f)
  291.     //                  {
  292.     //                      zombie[i]->setRotation(0.0f);
  293.     //                  }
  294.     //                  zombie[i]->changePosition(0, zombie[i]->getMoveSpeed());
  295.     //              }
  296.     //              else
  297.     //              {
  298.     //                  if(zombie[i]->getRotation() != 180.0f)
  299.     //                  {
  300.     //                      zombie[i]->setRotation(180.0f);
  301.     //                  }
  302.     //                  zombie[i]->changePosition(0, -zombie[i]->getMoveSpeed());
  303.     //              }
  304.     //          }
  305.     //          else if(zombie[i]->getPosition().y <= midtow->getPosition().y + 20 &&
  306.     //                  zombie[i]->getPosition().y >= midtow->getPosition().y - 20)
  307.     //          {
  308.     //              if(zombie[i]->getPosition().x >= midtow->getPosition().x)
  309.     //              {
  310.     //                  if(zombie[i]->getRotation() != 90.0f)
  311.     //                  {
  312.     //                      zombie[i]->setRotation(90.f);
  313.     //                  }
  314.     //                  zombie[i]->changePosition(-zombie[i]->getMoveSpeed(), 0);
  315.     //              }
  316.     //              else
  317.     //              {
  318.     //                  if(zombie[i]->getRotation() != 270.0f)
  319.     //                  {
  320.     //                      zombie[i]->setRotation(270.0f);
  321.     //                  }
  322.     //                  zombie[i]->changePosition(zombie[i]->getMoveSpeed(), 0);
  323.     //              }
  324.     //          }
  325.     //          else if(zombie[i]->getPosition().x > midtow->getPosition().x &&
  326.     //              zombie[i]->getPosition().y > midtow->getPosition().y)
  327.     //          {
  328.     //              if(zombie[i]->getRotation() != 135.0f)
  329.     //              {
  330.     //                  zombie[i]->setRotation(135.0f);
  331.     //              }
  332.     //              zombie[i]->changePosition(-zombie[i]->getMoveSpeed(), -zombie[i]->getMoveSpeed());
  333.     //          }
  334.     //          else if(zombie[i]->getPosition().x < midtow->getPosition().x &&
  335.     //                  zombie[i]->getPosition().y > midtow->getPosition().y)
  336.     //          {
  337.     //              if(zombie[i]->getRotation() != 225.0f)
  338.     //              {
  339.     //                  zombie[i]->setRotation(225.0f);
  340.     //              }
  341.     //              zombie[i]->changePosition(zombie[i]->getMoveSpeed(), -zombie[i]->getMoveSpeed());
  342.     //          }
  343.     //          else if(zombie[i]->getPosition().x > midtow->getPosition().x &&
  344.     //                  zombie[i]->getPosition().y < midtow->getPosition().y)
  345.     //          {
  346.     //              if(zombie[i]->getRotation() != 45.0f)
  347.     //              {
  348.     //                  zombie[i]->setRotation(45.0f);
  349.     //              }
  350.     //              zombie[i]->changePosition(-zombie[i]->getMoveSpeed(), zombie[i]->getMoveSpeed());
  351.     //          }
  352.     //          else if(zombie[i]->getPosition().x < midtow->getPosition().x &&
  353.     //                  zombie[i]->getPosition().y < midtow->getPosition().y)
  354.     //          {
  355.     //              if(zombie[i]->getRotation() != 315.0f)
  356.     //              {
  357.     //                  zombie[i]->setRotation(315.0f);
  358.     //              }
  359.     //              zombie[i]->changePosition(zombie[i]->getMoveSpeed(), zombie[i]->getMoveSpeed());
  360.     //          }
  361.     //     
  362.     //      }
  363.     //  }
  364.     //}
  365. }
  366.  
  367. void Game::input()//check input, left, right, up, down and escape and some more
  368. {
  369.     if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left) && sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
  370.     {
  371.         if(Player1->getRotation() != 135.0f)
  372.         {
  373.             Player1->setRotation(135.0f);
  374.         }
  375.         Player1->changePosition(-Player1->getMoveSpeed(), -Player1->getMoveSpeed());
  376.     }
  377.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up) && sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
  378.     {
  379.         if(Player1->getRotation() != 225.0f)
  380.         {
  381.             Player1->setRotation(225.0f);
  382.         }
  383.         Player1->changePosition(Player1->getMoveSpeed(), -Player1->getMoveSpeed());
  384.     }
  385.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right) && sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
  386.     {
  387.         if(Player1->getRotation() != 315.0f)
  388.         {
  389.             Player1->setRotation(315.0f);
  390.         }
  391.         Player1->changePosition(Player1->getMoveSpeed(), Player1->getMoveSpeed());
  392.     }
  393.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down) && sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
  394.     {
  395.         if(Player1->getRotation() != 45.0f)
  396.         {
  397.             Player1->setRotation(45.0f);
  398.         }
  399.         Player1->changePosition(-Player1->getMoveSpeed(), Player1->getMoveSpeed());
  400.     }
  401.    
  402.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
  403.     {
  404.         if(Player1->getRotation() != 90.0f)
  405.         {
  406.             Player1->setRotation(90.0f);
  407.         }
  408.         Player1->changePosition(-Player1->getMoveSpeed(), 0.0f);
  409.     }
  410.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
  411.     {
  412.         if(Player1->getRotation() != 270.0f)
  413.         {
  414.             Player1->setRotation(270.0f);
  415.         }
  416.         Player1->changePosition(Player1->getMoveSpeed(), 0.0f);
  417.     }
  418.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
  419.     {
  420.         if(Player1->getRotation() != 180.0f)
  421.         {
  422.             Player1->setRotation(180.0f);
  423.         }
  424.         Player1->changePosition(0.0f, -Player1->getMoveSpeed());
  425.     }
  426.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
  427.     {
  428.         if(Player1->getRotation() != 0.0f)
  429.         {
  430.             Player1->setRotation(0.0f);
  431.         }
  432.         Player1->changePosition(0.0f, Player1->getMoveSpeed());
  433.     }
  434.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
  435.     {
  436.         GameState = Game::Exiting;
  437.     }
  438.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::P))
  439.     {
  440.         GameState = Game::Paused;
  441.     }
  442.     else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Return))
  443.     {
  444.         Init();
  445.     }
  446.  
  447.     //checking for illegal movement:
  448.     //obs: -1 will not change the position.
  449.     sf::Vector2f f = Player1->getPosition();
  450.     if(f.x > 800)
  451.     {
  452.         Player1->setPosition(800, -1);
  453.     }
  454.     else if(f.x < 0)
  455.     {
  456.         Player1->setPosition(0, -1);
  457.     }
  458.     if(f.y > 600)
  459.     {
  460.         Player1->setPosition(-1, 600);
  461.     }
  462.     else if(f.y < 0)
  463.     {
  464.         Player1->setPosition(-1, 0);
  465.     }
  466. }
  467.  
  468. void Game::Exit()//clean up and close window.
  469. {
  470.     delete Player1;
  471.     Player1 = NULL;
  472.     int i = 0;
  473.     /*for(std::vector<Zombie*>::iterator it = zombie.begin(); it < zombie.end(); it++)
  474.     {
  475.         delete zombie[i];
  476.         zombie.erase(it);
  477.     }*/
  478.     std::vector<Zombie>::iterator it = zombie.begin();
  479.     for(; i < iNrOfZombies; i++)
  480.         zombie.pop_back();
  481.     for(i = 0; i < iNrOfZombies; i++)
  482.     {
  483.         if(blood[i] != NULL)
  484.         {
  485.             delete blood[i];
  486.             blood[i] = NULL;
  487.         }
  488.     }
  489.     //delete [] zombie;
  490.     delete midtow;
  491.     midtow = NULL;
  492.     mainWindow.close();
  493. }
  494.  
  495. void Game::isPaused()//while paused
  496. {
  497.     sf::Time t = sf::seconds(0.2f);
  498.     sf::sleep(t);
  499.  
  500.     sf::Text text("GAME IS PAUSED, PRESS 'P' TO UNPAUSE");
  501.     text.setCharacterSize(30);
  502.     text.setColor(sf::Color::Red);
  503.     text.setFont(sf::Font::getDefaultFont());
  504.     sf::Event ev;
  505.     while(mainWindow.isOpen() && GameState == Game::Paused)
  506.     {
  507.         while(mainWindow.pollEvent(ev))
  508.         {
  509.             switch(ev.type)
  510.             {
  511.             case sf::Event::Closed:
  512.                 Exit();
  513.             }
  514.         }
  515.         if(sf::Keyboard::isKeyPressed(sf::Keyboard::P))
  516.         {
  517.             GameState = Game::Running;
  518.             sf::sleep(t);
  519.         }
  520.        
  521.         mainWindow.draw(text);
  522.         mainWindow.display();
  523.     }
  524. }
  525.  
  526. void Game::gameLost()//game lost, will show some stats.
  527. {
  528.     sf::Event ev;
  529.     sf::Text lost;
  530.     sf::Text kills;
  531.     lost.setString("Game Over, press [ENTER] to restart or [ESC] to exit");
  532.     lost.setPosition(150, 300);
  533.     lost.setColor(sf::Color::Red);
  534.  
  535.     kills.setString("Number of kills: ");
  536.     kills.setPosition(350, 350);
  537.     Kills.setPosition(350, 400);
  538.     Kills.setColor(sf::Color::White);
  539.     while(mainWindow.isOpen() && GameState == Game::Lost)
  540.     {
  541.         while(mainWindow.pollEvent(ev))
  542.         {
  543.             switch(ev.type)
  544.             {
  545.             case sf::Event::Closed:
  546.                 GameState = Game::Exiting;
  547.                 break;
  548.             }
  549.         }
  550.         if(sf::Keyboard::isKeyPressed(sf::Keyboard::Return))
  551.         {
  552.             for(int i = 0; i < iNrOfZombies; i++)
  553.             {
  554.                 zombie.pop_back();
  555.             }
  556.             Init();
  557.         }
  558.         mainWindow.clear();
  559.         mainWindow.draw(lost);
  560.         mainWindow.draw(kills);
  561.         mainWindow.draw(Kills);
  562.         mainWindow.display();
  563.     }
  564. }
  565.  
  566. std::string Game::KillsToString()
  567. {
  568.     std::string s;
  569.     std::stringstream ss;
  570.     ss << iKillCounter;
  571.     s = ss.str();
  572.     return s;
  573. }
  574.  
  575. //static variable declaration:
  576. Game::gameState Game::GameState;
  577. sf::RenderWindow Game::mainWindow;
  578. Player * Game::Player1;
  579. //Zombie * Game::zombie[120];
  580. std::vector <Zombie> Game::zombie;
  581. sf::Texture Game::bloodLoad;
  582. Castle * Game::midtow;
  583. int Game::iKillCounter;
  584. sf::Text Game::Kills;
  585. int Game::iNrOfZombies;
  586. int Game::iKillsMoreZombies;
  587. sf::Texture Game::bgTexture;
  588. sf::Sprite Game::bg;
  589. sf::Texture Game::zombieTexture;
  590. float Game::zombieMultiplier;
  591. Blood * Game::blood[100];
  592.  
  593. /* Game.hpp */
  594. #include "Player.hpp"
  595. #include "Zombie.hpp"
  596. #include "Castle.hpp"
  597. #include "Blood.hpp"
  598. #include <vector>
  599.  
  600. class Game
  601. {
  602. public:
  603.     static void Init();
  604.    
  605. private:
  606.  
  607.     //enumerated thingys
  608.     static enum gameState {UnInit, Running, Paused, Exiting, Lost};
  609.     static gameState GameState;
  610.  
  611.     //renderwindows
  612.     static sf::RenderWindow mainWindow;
  613.  
  614.     //textures/sprites
  615.     static sf::Texture bloodLoad;
  616.     static sf::Texture bgTexture;
  617.     static sf::Sprite bg;
  618.     static sf::Texture zombieTexture;
  619.    
  620.     //different texts
  621.     static sf::Text Kills;
  622.  
  623.     //classes and pointers to classes
  624.     static Player * Player1;
  625.     //static Zombie * zombie[];
  626.     static Blood * blood[];
  627.     static Castle * midtow;
  628.     static std::vector<Zombie> zombie;
  629.  
  630.     //values of any sort
  631.     static int iKillCounter;
  632.     static int iNrOfZombies;
  633.     static int iKillsMoreZombies;
  634.     static float zombieMultiplier;
  635.  
  636.     //methods
  637.     static void moveZombie();
  638.     static void input();
  639.     static void gameLoop();
  640.     static void Exit();
  641.     static void collision();
  642.     static void isPaused();
  643.     static void drawZombies();
  644.     static void gameLost();
  645.     static void drawScreen();
  646.     static std::string KillsToString();
  647. };
  648.  
  649. /* Zombie.cpp */
  650. #include "Zombie.hpp"
  651.  
  652. Zombie::Zombie()
  653. {
  654.     b_isKilled = false;
  655.     b_firstMove = true;
  656.     b_isBloody = false;
  657. }
  658.  
  659. void Zombie::Init(sf::Texture &z)
  660. {
  661.     /*if(!zmTexture.loadFromFile("img/zombie.bmp"))
  662.     {
  663.         printf("Zombieskin unable to load");
  664.         zmSprite.setColor(sf::Color::White);
  665.         return;
  666.     }*/
  667.  
  668.     zmSprite.setTexture(z);
  669.     int x = rand () % 800 + 1, y = rand () % 600 + 1;
  670.     /*if(x >= 400 && x <= 600)
  671.         x += 100;
  672.     else if(y <= 400 && y > 200)
  673.         y -= 100;*/
  674.     if(x >= 350 && x <= 650)
  675.         x += 125;
  676.     else if(y <= 450 && y > 150)
  677.         y -= 125;
  678.  
  679.     zmSprite.setOrigin((float)8, (float)8); //set center of sprite, easier to rotate ;)
  680.     zmSprite.setPosition((float)x, (float)y);   //sets random position.
  681.  
  682.     /*flMoveSpeed = 1.3;*/
  683.     flMoveY = (float)0, flMoveX = (float)0;
  684. }
  685.  
  686. void Zombie::respawn()
  687. {
  688.     b_isKilled = false;
  689.     b_firstMove = true;
  690.  
  691.     int x = rand () % 800 + 1, y = rand () % 600 + 1;//position randomizer
  692.     if(x >= 400 && x <= 600)
  693.         x += 100;
  694.     else if(y <= 400 && y > 200)
  695.         y -= 100;
  696.     zmSprite.setPosition((float)x, (float)y);   //sets random position.
  697.     flMoveY = (float)0, flMoveX = (float)0;
  698. }
  699.  
  700. sf::Sprite Zombie::drawSprite()
  701. {
  702.     return zmSprite;
  703. }
  704.  
  705. void Zombie::setRotation(float r)
  706. {
  707.     zmSprite.setRotation(r);
  708. }
  709.  
  710. void Zombie::changePosition(float x, float y)
  711. {
  712.     zmSprite.move(x, y);
  713. }
  714.  
  715. bool Zombie::isDead()
  716. {
  717.     return b_isKilled;
  718. }
  719.  
  720. int Zombie::getTime()
  721. {
  722.     zmTime = zmClock.getElapsedTime();
  723.     return zmTime.asMilliseconds();
  724. }
  725.  
  726. float Zombie::getMoveSpeed()
  727. {
  728.     return flMoveSpeed;
  729. }
  730.  
  731. float Zombie::getRotation()
  732. {
  733.     return zmSprite.getRotation();
  734. }
  735.  
  736. void Zombie::restartClock()
  737. {
  738.     zmClock.restart();
  739. }
  740.  
  741. void Zombie::setKilled(bool b)
  742. {
  743.     b_isKilled = b;
  744.     cDead.restart();
  745.     timeDead = cDead.getElapsedTime();
  746. }
  747.  
  748. sf::FloatRect Zombie::getFR()
  749. {
  750.     sf::FloatRect fl = zmSprite.getGlobalBounds();
  751.  
  752.     return fl;
  753. }
  754.  
  755. float Zombie::getTimeDead()
  756. {
  757.     timeDead = cDead.getElapsedTime();
  758.     return timeDead.asSeconds();
  759. }
  760.  
  761. sf::Vector2f Zombie::getPosition()
  762. {
  763.     return zmSprite.getPosition();
  764. }
  765.  
  766. void Zombie::moveZombie()
  767. {
  768.     float wy = 300, wx = 400;
  769.     float zombieY = zmSprite.getPosition().y, zombieX = zmSprite.getPosition().x;
  770.     float dirY = zombieY - wy, dirX = zombieX - wx;
  771.     float rot = (float)(std::atan2f(dirY, dirX) / PI) * 180 - 90;//get radians and convert into degrees, easier to work with
  772.     if(rot < 0)
  773.         rot += 360;
  774.     //decide which direction to go
  775.     if(moveclock.getElapsedTime().asSeconds() > 1.0f || b_firstMove)
  776.     {
  777.         moveclock.restart();
  778.         b_firstMove = false;
  779.         if(rot <= 45 + 22.5 && rot > 45 - 22.5)
  780.         {
  781.             rot = 45 + 180;
  782.             zmSprite.setRotation(rot);
  783.             flMoveX = (float)0.6, flMoveY = (float)-0.6;
  784.             zmSprite.move(flMoveX, flMoveY);
  785.         }
  786.         else if(rot <= 90 + 22.5 && rot > 90 - 22.5)
  787.         {
  788.             rot = 90 + 180;
  789.             zmSprite.setRotation(rot);
  790.             flMoveX = (float)0.6, (float)flMoveY = 0;
  791.             zmSprite.move(flMoveX, 0);
  792.         }
  793.         else if(rot <= 135 + 22.5 && rot > 135 - 22.5)
  794.         {
  795.             rot = 135 + 180;
  796.             zmSprite.setRotation(rot);
  797.             flMoveX = (float)0.6, flMoveY = (float)0.6;
  798.             zmSprite.move(flMoveX, flMoveY);
  799.  
  800.         }
  801.         else if(rot <= 180 + 22.5 && rot > 180 - 22.5)
  802.         {
  803.             rot = 0;
  804.             zmSprite.setRotation(rot);
  805.             flMoveX = (float)0, flMoveY = (float)0.6;
  806.             zmSprite.move(flMoveX, flMoveY);
  807.         }
  808.         else if(rot <= 225 + 22.5 && rot > 225 - 22.5)
  809.         {
  810.             rot = 45;
  811.             zmSprite.setRotation(rot);
  812.             flMoveX = (float)-0.6, flMoveY = (float)0.6;
  813.             zmSprite.move(flMoveX, flMoveY);
  814.         }
  815.         else if(rot <= 270 + 22.5 && rot > 270 - 22.5)
  816.         {
  817.             rot = 90;
  818.             zmSprite.setRotation(rot);
  819.             flMoveX = (float)-0.6, flMoveY = (float)0;
  820.             zmSprite.move(flMoveX, flMoveY);
  821.            
  822.         }
  823.         else if(rot <= 315 + 22.5 && rot > 315 - 22.5)
  824.         {
  825.             rot = 135;
  826.             zmSprite.setRotation(rot);
  827.             flMoveX = (float)-0.6, flMoveY = (float)-0.6;
  828.             zmSprite.move(flMoveX, flMoveY);
  829.            
  830.         }
  831.         else
  832.         {
  833.             rot = 180;
  834.             zmSprite.setRotation(rot);
  835.             flMoveY = (float)-0.6, flMoveX = (float) 0;
  836.             zmSprite.move(flMoveX, flMoveY);
  837.         }
  838.     }
  839.     else
  840.     {
  841.         zmSprite.move(flMoveX, flMoveY);
  842.     }
  843. }
  844.  
  845. void Zombie::becameBloody(bool b)
  846. {
  847.     b_isBloody = b;
  848. }
  849.  
  850. bool Zombie::isBloody()
  851. {
  852.     return b_isBloody;
  853. }
  854.  
  855. /* Zombie.hpp */
  856. #include <SFML2\Graphics.hpp>
  857. #include <math.h>
  858.  
  859. #define PI 3.14159265
  860.  
  861. class Zombie
  862. {
  863. public:
  864.     Zombie();
  865.  
  866.     void Init(sf::Texture &);
  867.     void respawn();
  868.     void setRotation(float);
  869.     void changePosition(float, float);
  870.     void setKilled(bool);
  871.     void restartClock();
  872.     void moveZombie();
  873.     void becameBloody(bool);// For future use, got no sprite for a dead zombie yet...
  874.    
  875.     float getRotation();
  876.     float getMoveSpeed();
  877.     float getTimeDead();
  878.    
  879.     int getTime();
  880.    
  881.     bool isDead();
  882.     bool isBloody();
  883.    
  884.     sf::Sprite drawSprite();
  885.     sf::FloatRect getFR();
  886.     sf::Vector2f getPosition();
  887.    
  888. private:
  889.     sf::Sprite zmSprite;
  890.  
  891.     sf::Clock zmClock;
  892.     sf::Time zmTime;
  893.  
  894.     sf::Clock moveclock;
  895.  
  896.     sf::Clock cDead;
  897.     sf::Time timeDead;
  898.  
  899.     bool b_isKilled;
  900.     bool b_firstMove;
  901.     bool b_isBloody;
  902.  
  903.     float flMoveSpeed;
  904.  
  905.     float flMoveY, flMoveX;
  906.     /*int iAttackSpeed;
  907.     int iAttackRange;*/
  908. };
  909.  
  910. /* Castle.cpp */
  911. #include "Castle.hpp"
  912.  
  913.  
  914. Castle::Castle()
  915. {
  916.     if(!texture.loadFromFile("img/midtower3.jpg"))
  917.     {
  918.         printf("NO CAN HAZ MIDDLE TOWER");
  919.         return;
  920.     }
  921.     s_Castle.setTexture(texture);
  922.     s_Castle.setOrigin(32, 32);
  923.     s_Castle.setPosition(400, 300);
  924.  
  925.     iHealth = 20;
  926. }
  927.  
  928. sf::Sprite Castle::drawSprite()
  929. {
  930.     return s_Castle;
  931. }
  932.  
  933. void Castle::redHealth()
  934. {
  935.     iHealth--;
  936.  
  937. }
  938.  
  939. sf::Vector2f Castle::getPosition()
  940. {
  941.     return s_Castle.getPosition();
  942. }
  943.  
  944. std::string Castle::intToString()
  945. {
  946.     std::string s;
  947.     std::stringstream ss;
  948.     ss << iHealth;
  949.     s = ss.str();
  950.     return s;
  951. }
  952.  
  953. sf::Text Castle::drawText()
  954. {
  955.     Health.setString(intToString());
  956.     if(iHealth <= 5)
  957.         Health.setColor(sf::Color::Red);
  958.     else if(iHealth <= 10)
  959.         Health.setColor(sf::Color::Yellow);
  960.     else
  961.         Health.setColor(sf::Color::Green);
  962.     return Health;
  963. }
  964.  
  965. sf::FloatRect Castle::getFR()
  966. {
  967.     sf::FloatRect f = s_Castle.getGlobalBounds();
  968.     return f;
  969. }
  970.  
  971. int Castle::getHealth()
  972. {
  973.     return iHealth;
  974. }
  975.  
  976. /* Castle.hpp */
  977. #include <SFML2\Graphics.hpp>
  978. #include <sstream>
  979.  
  980. class Castle
  981. {
  982. public:
  983.     Castle();
  984.    
  985.     void redHealth();
  986.  
  987.     sf::FloatRect getFR();
  988.     sf::Sprite drawSprite();
  989.     sf::Text drawText();
  990.     sf::Vector2f getPosition();
  991.     int getHealth();
  992.  
  993. private:
  994.     int iHealth;
  995.  
  996.     std::string intToString();
  997.  
  998.     sf::Texture texture;
  999.     sf::Text Health;
  1000.     sf::Sprite s_Castle;
  1001.  
  1002. };
  1003.  
  1004. /* Blood.cpp */
  1005. #include "Blood.hpp"
  1006.  
  1007. Blood::Blood(sf::Texture &b, sf::Vector2f v)
  1008. {
  1009.     spBlood.setTexture(b);
  1010.     spBlood.setOrigin(spBlood.getGlobalBounds().width / 2, spBlood.getGlobalBounds().height / 2);
  1011.     spBlood.setPosition(v);
  1012.     time.restart();
  1013. }
  1014.  
  1015. void Blood::Draw(sf::RenderWindow &w)
  1016. {
  1017.     w.draw(spBlood);
  1018. }
  1019.  
  1020. sf::Sprite Blood::getSprite()// temporarily, used for debugging purpose - wasn't the issue I had at that moment  == will be removed later when I've got time
  1021. {
  1022.     return spBlood;
  1023. }
  1024.  
  1025. float Blood::getTime()
  1026. {
  1027.     return time.getElapsedTime().asSeconds();
  1028. }
  1029.  
  1030. /* Blood.hpp */
  1031. #include <SFML2/Graphics.hpp>
  1032.  
  1033. class Blood
  1034. {
  1035. public:
  1036.     Blood(sf::Texture &b, sf::Vector2f v);
  1037.     ~Blood(){}
  1038.     void Draw(sf::RenderWindow &w);
  1039.     float getTime();
  1040.     sf::Sprite getSprite();
  1041. private:
  1042.     sf::Sprite spBlood;
  1043.     sf::Clock time;
  1044. };
  1045. /* Player.cpp */
  1046. #include "Player.hpp"
  1047.  
  1048. Player::Player()
  1049. {
  1050.     if(!plTexture.loadFromFile("img/human.bmp"))
  1051.     {
  1052.         printf("error");
  1053.         return;
  1054.     }
  1055.    
  1056.     plSprite.setTexture(plTexture);
  1057.     plSprite.setPosition(450, 350);
  1058.     plSprite.setOrigin(8, 8);
  1059.  
  1060.     plClock.restart();
  1061.     plTime = plClock.getElapsedTime();
  1062.  
  1063.     iAttackSpeed = 1150;
  1064.     flMoveSpeed = 4;
  1065. }
  1066.  
  1067. void Player::setRotation(float i)
  1068. {
  1069.     plSprite.setRotation(i);
  1070.     /*plSprite.move(16, 0);*/
  1071. }
  1072.  
  1073. float Player::getRotation()
  1074. {
  1075.     return plSprite.getRotation();
  1076. }
  1077.  
  1078. void Player::changePosition(float x, float y)
  1079. {
  1080.     plSprite.move(x, y);
  1081. }
  1082.  
  1083. float Player::getMoveSpeed()
  1084. {
  1085.     return flMoveSpeed;
  1086. }
  1087.  
  1088. int Player::getTime()
  1089. {
  1090.     plTime = plClock.getElapsedTime();
  1091.     return plTime.asMilliseconds();
  1092. }
  1093.  
  1094. void Player::restartClock()
  1095. {
  1096.     plClock.restart();
  1097. }
  1098.  
  1099. sf::Sprite Player::drawSprite()
  1100. {
  1101.     return plSprite;
  1102. }
  1103.  
  1104. sf::FloatRect Player::getFR()
  1105. {
  1106.     sf::FloatRect fl = plSprite.getGlobalBounds();
  1107.  
  1108.     return fl;
  1109. }
  1110.  
  1111. sf::Vector2f Player::getPosition()
  1112. {
  1113.     sf::Vector2f f = plSprite.getPosition();
  1114.     return f;
  1115. }
  1116.  
  1117. void Player::setPosition(float x, float y)
  1118. {
  1119.     if(y < 0)
  1120.         y = plSprite.getPosition().y;
  1121.     else if(x < 0)
  1122.         x = plSprite.getPosition().x;
  1123.     plSprite.setPosition(x, y);
  1124. }
  1125.  
  1126. /*
  1127. sf::Texture plTexture;
  1128. sf::Sprite plSprite;
  1129. int iAttackSpeed;
  1130. int iAttackRange;
  1131. int iMove;
  1132. */
  1133. // above was used a reminder, my friends didn't allow me to use VS11 =(
  1134.  
  1135. /* Player.hpp */
  1136. #include <SFML2\Graphics.hpp>
  1137.  
  1138. class Player
  1139. {
  1140. public:
  1141.     Player();
  1142.  
  1143.     void setRotation(float);
  1144.     void changePosition(float, float);
  1145.     float getRotation();
  1146.     float getMoveSpeed();
  1147.     int getTime();
  1148.     void restartClock();
  1149.     sf::FloatRect getFR();
  1150.     sf::Sprite drawSprite();
  1151.     sf::Vector2f getPosition();
  1152.     void setPosition(float, float);//OBSERVE: ONLY FOR OUT-OF-BOX, use changePosition for movement.
  1153.  
  1154.    
  1155. private:
  1156.     sf::Sprite plSprite;
  1157.     sf::Texture plTexture;
  1158.     sf::Clock plClock;
  1159.     sf::Time plTime;
  1160.  
  1161.  
  1162.     float flMoveSpeed;
  1163.     int iAttackSpeed;
  1164.     int iAttackRange;
  1165. };
  1166.  
  1167. /*Main.cpp*/
  1168. #include "Game.hpp"
  1169.  
  1170. int main(void)
  1171. {
  1172.     Game::Init();
  1173.     return 0;
  1174. }// When running in debug - it gets to this point, then throws me into xmemory at line 64.
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!