API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 26th, 2020
206
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.24 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <math.h>
  4. #include <stdio.h>
  5. #include <time.h>
  6. #include <chrono>
  7. #include <ctime>
  8. #include <SFML/Network.hpp>
  9. #include <SFML/Graphics.hpp>
  10. #include <SFML/Graphics/RectangleShape.hpp>
  11. #include <SFML/System/Vector2.hpp>
  12. #include <vector>
  13. #include <thread>
  14. #include <string>
  15. #include <sstream>
  16. #include "Database.h"
  17.  
  18. #pragma region CONSTANTS
  19. #define SIZE 10.F
  20.  
  21. //Tamaño en pixeles de la ventana
  22. #define W_WINDOW_PX 800
  23. #define H_WINDOW_PX 600
  24.  
  25. //Tamaño en celdas de la ventana
  26. #define W_WINDOW_TITLE 80
  27. #define H_WINDOW_TITLE 60
  28. #pragma endregion
  29.  
  30. enum class GameState {AWAKE, INIT, LOGIN, REGISTER, GAME, ROULETTE};
  31.  
  32. bool connected;
  33. GameState gameState;
  34. std::vector<sf::TcpSocket*> sockets;
  35. Database database;
  36.  
  37. void Disconnect(sf::TcpSocket* _socket)
  38. {
  39.     sockets.erase(std::remove(sockets.begin(), sockets.end(), _socket));
  40.     delete _socket;
  41.     connected = false;
  42.     std::cout << "Client has been disconnected" << std::endl;
  43. }
  44.  
  45. void AskForRegisterOrLogin(sf::Packet &_packet, std::string &_send, std::string &_recieve, sf::TcpSocket* _socket)
  46. {
  47.     // PASO1: Preguntamos al cliente que quiere hacer (Loguearse o registrarse)
  48.     _send = "Press L to Log In or Press R to Register";
  49.     _packet.clear();
  50.     _packet <<  _send;
  51.     if(_socket->send(_packet) != sf::Socket::Done)
  52.     {
  53.         std::cout << "Error: Can't send packet to client (Ask1)" << std::endl;
  54.         Disconnect(_socket);
  55.     }
  56.     else
  57.     {
  58.         // PASO2: Recibimos la información que ha dado el cliente
  59.         if(_socket->receive(_packet) != sf::Socket::Done)
  60.         {
  61.             std::cout << "Error: Unable to receive packet from client (Ask2)" << std::endl;
  62.             Disconnect(_socket);
  63.         }
  64.         else
  65.         {
  66.             _packet >> _recieve;
  67.  
  68.             // PASO3: Cambiamos el estado del servidor según lo que demanda el cliente
  69.             if(_recieve == "R" || _recieve == "r")
  70.             {
  71.                 gameState = GameState::REGISTER;
  72.             }
  73.             else if(_recieve == "L" || _recieve == "l")
  74.             {
  75.                 gameState = GameState::LOGIN;
  76.             }
  77.             else
  78.             {
  79.                 gameState = GameState::INIT;
  80.             }
  81.         }
  82.     }
  83.     _packet.clear();
  84. }
  85.  
  86. void Login(sf::Packet &_packet, std::string &_send, std::string &_recieve, sf::TcpSocket* _socket, int &_userID)
  87. {
  88.     std::string username, password;
  89.  
  90.     // PASO1: Envia mensaje conforme ha entrado en LOGIN
  91.     _send = " ------ LOGIN ------ ";
  92.     _packet.clear();
  93.     _packet << _send;
  94.     if(_socket->send(_packet) != sf::Socket::Done)
  95.     {
  96.         std::cout << "Error: Can't send packet to client (Login1)" << std::endl;
  97.         Disconnect(_socket);
  98.     }
  99.     else
  100.     {
  101.         // PASO2: Envia mensaje para informar al usuario que tiene que introducir el username
  102.         _send = "Enter your username: ";
  103.         _packet.clear();
  104.         _packet <<  _send;
  105.         if(_socket->send(_packet) != sf::Socket::Done)
  106.         {
  107.             std::cout << "Error: Can't send packet to client (Login2)" << std::endl;
  108.             Disconnect(_socket);
  109.         }
  110.         else
  111.         {
  112.             // PASO3: Recibe el username introducido por el usuario
  113.             if(_socket->receive(_packet) != sf::Socket::Done)
  114.             {
  115.                 std::cout << "Error: Unable to receive packet from client (Login3)" << std::endl;
  116.                 Disconnect(_socket);
  117.             }
  118.             else
  119.             {
  120.                 _packet >> _recieve;
  121.  
  122.                 // PASO4: Guardamos el username para comprobar más adelante si ha iniciado sesión correctamente
  123.                 username = _recieve;
  124.  
  125.                 // PASO5: Envia mensaje para informar al usuario que tiene que introducir la password
  126.                 _send = "Enter your password: ";
  127.                 _packet.clear();
  128.                 _packet <<  _send;
  129.                 if(_socket->send(_packet) != sf::Socket::Done)
  130.                 {
  131.                     std::cout << "Error: Can't send packet to client (Login5)" << std::endl;
  132.                     Disconnect(_socket);
  133.                 }
  134.                 else
  135.                 {
  136.                     // PASO6: Recibe la password introducida por el usuario
  137.                     if(_socket->receive(_packet) != sf::Socket::Done)
  138.                     {
  139.                         std::cout << "Error: Unable to receive packet from client (Login6)" << std::endl;
  140.                         Disconnect(_socket);
  141.                     }
  142.                     else
  143.                     {
  144.                         _packet >> _recieve;
  145.  
  146.                         // PASO7: Guardamos la password para comprobar más adelante si ha iniciado sesión correctamente
  147.                         password = _recieve;
  148.  
  149.                         // PASO8: Comprobar que ha iniciado sesión correctamente y mandar al usuario al paso correspondiente
  150.                         if(database.Login(username, password))
  151.                         {
  152.                             _send = "true";
  153.                             _packet.clear();
  154.                             _packet << _send;
  155.                             //PASO 9: Enviar true para saber que se ha conectado correctamente
  156.                             if(_socket->send(_packet) != sf::Socket::Done)
  157.                             {
  158.                                 std::cout << "Error: unable to send packet to client (Login7)" << std::endl;
  159.                                 Disconnect(_socket);
  160.                             }
  161.                             else
  162.                             {
  163.                                 _userID = database.UserID(username);
  164.                                 gameState = GameState::ROULETTE;
  165.                             }
  166.                         }
  167.                         else
  168.                         {
  169.                             _send = "false";
  170.                             _packet.clear();
  171.                             _packet << _send;
  172.                             //PASO 10: Enviar false para saber que no se ha conectado correctamente
  173.                             if(_socket->send(_packet) != sf::Socket::Done)
  174.                             {
  175.                                 std::cout << "Error: unable to send packet to client (Login8)" << std::endl;
  176.                                 Disconnect(_socket);
  177.                             }
  178.                             else
  179.                             {
  180.                                 gameState = GameState::INIT;
  181.                             }
  182.                         }
  183.                     }
  184.                 }
  185.             }
  186.         }
  187.     }
  188.     _packet.clear();
  189. }
  190.  
  191. void Register(sf::Packet &_packet, std::string &_send, std::string &_recieve, sf::TcpSocket* _socket)
  192. {
  193.      std::string username, password, r_password;
  194.  
  195.     // PASO1: Envia mensaje conforme ha entrado en REGISTER
  196.     _send = " ------ REGISTER ------ ";
  197.     _packet.clear();
  198.     _packet << _send;
  199.     if(_socket->send(_packet) != sf::Socket::Done)
  200.     {
  201.         std::cout << "Error: Can't send packet to client (Register1)" << std::endl;
  202.         Disconnect(_socket);
  203.     }
  204.     else
  205.     {
  206.         // PASO2: Envia mensaje para informar al usuario que tiene que introducir el username
  207.         _send = "Choose your username: ";
  208.         _packet.clear();
  209.         _packet <<  _send;
  210.         if(_socket->send(_packet) != sf::Socket::Done)
  211.         {
  212.             std::cout << "Error: Can't send packet to client (Register2)" << std::endl;
  213.             Disconnect(_socket);
  214.         }
  215.         else
  216.         {
  217.             // PASO3: Recibe el username introducido y comprueba que no existe
  218.             _packet.clear();
  219.             if(_socket->receive(_packet) != sf::Socket::Done)
  220.             {
  221.                 std::cout << "Error: Unable to receive packet from client (Register3)" << std::endl;
  222.                 Disconnect(_socket);
  223.             }
  224.             else
  225.             {
  226.                 _packet >> _recieve;
  227.                 username = _recieve;
  228.                 if(database.UserExist(username))
  229.                 {
  230.                     _send = "true";
  231.                     _packet.clear();
  232.                     _packet << _send;
  233.                     if(_socket->send(_packet) != sf::Socket::Done)
  234.                     {
  235.                         std::cout << "Error: Unable to send packet to client (Register4)";
  236.                         Disconnect(_socket);
  237.                     }
  238.                     else
  239.                     {
  240.                         gameState = GameState::INIT;
  241.                     }
  242.                 }
  243.                 else
  244.                 {
  245.                     _send = "false";
  246.                     _packet.clear();
  247.                     _packet << _send;
  248.                     if(_socket->send(_packet) != sf::Socket::Done)
  249.                     {
  250.                         std::cout << "Error: Unable to send packet to client (Register5)";
  251.                         Disconnect(_socket);
  252.                     }
  253.                     else
  254.                     {
  255.                         //PASO 4: Enviar mensaje de password
  256.                         _send = "Set a password for your account: ";
  257.                         _packet.clear();
  258.                         _packet << _send;
  259.                         if(_socket->send(_packet) != sf::Socket::Done)
  260.                         {
  261.                             std::cout << "Error: Unable to send packet to client (Register6)";
  262.                             Disconnect(_socket);
  263.                         }
  264.                         else
  265.                         {
  266.                             _packet.clear();
  267.                             if(_socket->receive(_packet) != sf::Socket::Done)
  268.                             {
  269.                                 std::cout << "Error: Unable to receive packet from client (Register7)";
  270.                                 Disconnect(_socket);
  271.                             }
  272.                             else
  273.                             {
  274.                                 _packet >> _recieve;
  275.                                 password = _recieve;
  276.  
  277.                                 //PASO 5: Por seguridad volvemos a pedir la password
  278.                                 _send = "Repeat your password for security: ";
  279.                                 _packet.clear();
  280.                                 _packet << _send;
  281.                                 if(_socket->send(_packet) != sf::Socket::Done)
  282.                                 {
  283.                                     std::cout << "Error: Unable to send packet to client (Register8)";
  284.                                     Disconnect(_socket);
  285.                                 }
  286.                                 else
  287.                                 {
  288.                                     _packet.clear();
  289.                                     if(_socket->receive(_packet) != sf::Socket::Done)
  290.                                     {
  291.                                         std::cout << "Error: Unable to receive packet from client (Register9)";
  292.                                         Disconnect(_socket);
  293.                                     }
  294.                                     else
  295.                                     {
  296.                                         _packet >> _recieve;
  297.                                         r_password = _recieve;
  298.  
  299.                                         //PASO 6: Comprobamos que ambas contraseñas son iguales
  300.                                         if(password == r_password)
  301.                                         {
  302.                                             _send = "true";
  303.                                             _packet.clear();
  304.                                             _packet << _send;
  305.                                             if(_socket->send(_packet) != sf::Socket::Done)
  306.                                             {
  307.                                                 std::cout << "Error: Unable to send packet to client (Register10)";
  308.                                                 Disconnect(_socket);
  309.                                             }
  310.                                             else
  311.                                             {
  312.                                                 database.Register(username, password);
  313.                                                 gameState = GameState::INIT;
  314.                                             }
  315.                                         }
  316.                                         else
  317.                                         {
  318.                                             _send = "false";
  319.                                             _packet.clear();
  320.                                             _packet << _send;
  321.                                             if(_socket->send(_packet) != sf::Socket::Done)
  322.                                             {
  323.                                                 std::cout << "Error: Unable to send packet to client (Register11)";
  324.                                                 Disconnect(_socket);
  325.                                             }
  326.                                             else
  327.                                             {
  328.                                                 gameState = GameState::INIT;
  329.                                             }
  330.                                         }
  331.                                     }
  332.                                 }
  333.                             }
  334.                         }
  335.                     }
  336.                 }
  337.             }
  338.         }
  339.     }
  340.     _packet.clear();
  341. }
  342.  
  343. void DrawField()
  344. {
  345.     sf::RenderWindow window(sf::VideoMode(800, 600), "Game Screen");
  346.     sf::RectangleShape shape(sf::Vector2f(SIZE, SIZE));
  347.     shape.setOutlineColor(sf::Color::Black);
  348.     shape.setOutlineThickness(2.f);
  349.     while (window.isOpen())
  350.     {
  351.         sf::Event event;
  352.         bool playerMoved = false;
  353.         while (window.pollEvent(event))
  354.         {
  355.             switch(event.type)
  356.             {
  357.                 case sf::Event::Closed:
  358.                     window.close();
  359.                     break;
  360.             }
  361.         }
  362.         window.clear();
  363.         for (int i = 0; i < W_WINDOW_TITLE; ++i)
  364.         {
  365.             for (int j= 0; j < H_WINDOW_TITLE; ++j)
  366.             {
  367.  
  368.                 shape.setFillColor(sf::Color(90, 90, 90, 255));
  369.  
  370.                 shape.setPosition(sf::Vector2f(i*SIZE, j*SIZE));
  371.                 window.draw(shape);
  372.             }
  373.         }
  374.  
  375.         window.display();
  376.     }
  377. }
  378.  
  379. void Game()
  380. {
  381.     DrawField();
  382. }
  383.  
  384. std::string CurrentDateTime() {
  385.     time_t     now = time(0);
  386.     struct tm  tstruct;
  387.     char buf[80];
  388.     tstruct = *localtime(&now);
  389.  
  390.     strftime(buf, sizeof(buf), "%Y%m%d%H%M", &tstruct);
  391.  
  392.     return buf;
  393. }
  394.  
  395. long CurrentDateToLong()
  396. {
  397.     std::string s = CurrentDateTime();
  398.  
  399.     int i = -1;
  400.     long aux = 0;
  401.     for (char c: s)
  402.     {
  403.         i++;
  404.     }
  405.     for (char c: s)
  406.     {
  407.         aux += ((int)c - 48) * std::pow(10, i);
  408.         i--;
  409.     }
  410.  
  411.     return aux;
  412. }
  413.  
  414. int TiraleAlaRuleta()
  415. {
  416.    return rand() % 5;
  417. }
  418.  
  419. void Roulette(std:: string &_send, std:: string &_recieve, sf::Packet &_packet, sf::TcpSocket* _socket, int &_userID, int (&_gems)[5])
  420. {
  421.     if(database.CanRoulette(_userID) < CurrentDateToLong())
  422.     {
  423.         _send = "true";
  424.         _packet.clear();
  425.         _packet << _send;
  426.         if(_socket->send(_packet) != sf::Socket::Done)
  427.         {
  428.             std::cout << "Error: Can not send packet to client (Roulette1)" << std::endl;
  429.             Disconnect(_socket);
  430.         }
  431.         else
  432.         {
  433.             //Recibimos si o no desde el cliente
  434.             _packet.clear();
  435.             if(_socket->receive(_packet) != sf::Socket::Done)
  436.             {
  437.                 std::cout << "Error: Can not receive packet from client(Roulette3)" << std::endl;
  438.                 Disconnect(_socket);
  439.             }
  440.             else
  441.             {
  442.                 _packet >> _recieve;
  443.                 if(_recieve == "y" || _recieve == "Y")
  444.                 {
  445.                     int aux = TiraleAlaRuleta();
  446.                     switch(aux)
  447.                     {
  448.                         case 0:
  449.                             _send = "You've got a diamond";
  450.                             break;
  451.                         case 1:
  452.                             _send = "You've got a emerald";
  453.                             break;
  454.                         case 2:
  455.                             _send = "You've got a saphire";
  456.                             break;
  457.                         case 3:
  458.                             _send = "You've got a ruby";
  459.                             break;
  460.                         case 4:
  461.                             _send = "You've got a ambar";
  462.                             break;
  463.                     }
  464.                     _gems[aux] += 1;
  465.                     database.WriteGems(_userID, _gems);
  466.                     _packet.clear();
  467.                     _packet << _send;
  468.                     if(_socket->send(_packet) != sf::Socket::Done)
  469.                     {
  470.                         std::cout << "Error: Can not send packet to client (Roulette1)" << std::endl;
  471.                         Disconnect(_socket);
  472.                     }
  473.                     else
  474.                     {
  475.                         //Actualizar el tiempo de conexion
  476.                         long auxLong = CurrentDateToLong() + 100;
  477.                         database.UpdateRoulette(_userID, auxLong);
  478.                         gameState = GameState::GAME;
  479.                     }
  480.                 }
  481.                 else if(_recieve == "n" || _recieve == "N")
  482.                 {
  483.                     database.ReadGems(_userID, _gems);
  484.                     for(int i = 0; i < 5; ++i)
  485.                     {
  486.                         std::cout << _gems[i] << ", ";
  487.                     }
  488.                     std::cout << std::endl;
  489.                     gameState = GameState::GAME;
  490.  
  491.                 }
  492.             }
  493.         }
  494.     }
  495.     else
  496.     {
  497.         _send = "false";
  498.         _packet.clear();
  499.         _packet << _send;
  500.         if(_socket->send(_packet) != sf::Socket::Done)
  501.         {
  502.             std::cout << "Error: Can not send packet to client (Roulette2)" << std::endl;
  503.             Disconnect(_socket);
  504.         }
  505.         else
  506.         {
  507.             gameState = GameState::GAME;
  508.         }
  509.     }
  510. }
  511.  
  512. void GameController(std:: string &_send, std:: string &_recieve, sf::Packet &_packet, sf::TcpSocket* _socket, int &_userID, int (&_gems)[5])
  513. {
  514.     switch(gameState)
  515.     {
  516.         case GameState::INIT:
  517.             AskForRegisterOrLogin(_packet, _send, _recieve, _socket);
  518.             break;
  519.         case GameState::REGISTER:
  520.             Register(_packet, _send, _recieve, _socket);
  521.             break;
  522.         case GameState::LOGIN:
  523.             Login(_packet, _send, _recieve, _socket, _userID);
  524.             break;
  525.         case GameState::GAME:
  526.             Game();
  527.             break;
  528.         case GameState::ROULETTE:
  529.             Roulette(_send, _recieve, _packet, _socket, _userID, _gems);
  530.             break;
  531.     }
  532. }
  533.  
  534. void Connection(sf::TcpSocket* _socket)
  535. {
  536.     std::string send, recieve;
  537.     int userID = 0;
  538.     int gems[5];
  539.     sf::Packet packet;
  540.     connected = true;
  541.     gameState = GameState::INIT;
  542.  
  543.     while(connected)
  544.     {
  545.         GameController(send, recieve, packet, _socket, userID, gems);
  546.     }
  547. }
  548.  
  549. int main()
  550. {
  551.     connected = false;
  552.     gameState = GameState::AWAKE;
  553.  
  554.     sf::TcpListener dispatcher;
  555.     sf::Socket::Status status = dispatcher.listen(53005);
  556.  
  557.     sf::TcpSocket* socket = new sf::TcpSocket;
  558.  
  559.     if(status != sf::Socket::Done)
  560.     {
  561.         std::cout << "Error: Unable to create listener (Server1)" << std::endl;
  562.         return 0;
  563.     }
  564.     else
  565.     {
  566.         while(1)
  567.         {
  568.             if(dispatcher.accept(*socket) != sf::Socket::Done)
  569.             {
  570.                 std::cout << "Error: Unable to connect (Server2)" << std::endl;
  571.                 socket->disconnect();
  572.             }
  573.             else
  574.             {
  575.                 std::cout << "New client connected" << std::endl;
  576.                 sockets.push_back(socket);
  577.                 std::thread connections(&Connection, socket);
  578.                 connections.detach();
  579.             }
  580.         }
  581.     }
  582.  
  583.     socket->disconnect();
  584.     dispatcher.close();
  585.  
  586.     return 0;
  587. }
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!