elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado:


+  Foro de elhacker.net
|-+  Informática
| |-+  Juegos y Consolas
| | |-+  Juego SDL
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Juego SDL  (Leído 740 veces)
Luffy97

Desconectado Desconectado

Mensajes: 15


Ver Perfil
Juego SDL
« en: 21 Enero 2017, 13:52 »

Hola gente, Estamos haciendo con un grupo de alumnos de clase un juego con SDL 2.0 y ahora tengo un problema a la hora de implementar el movimiento de el jugador en un método propio de su clase.
La estructura de clases es la siguiente:
Entity(Clase padre) es donde contiene el método move();
Player(Clase hija) Hereda la clase move() de Entity i el resto de sus mètodos y atributos.

Ahora me viene el problema (Que no se si es posible realizar lo que quiero hacer), la manera en la cual he pensado hacer el mètodo és la siguiente:
Código
  1. void CPlayer::movee(SDL_Event evento) {
  2. switch (evento.key.keysym.sym) {
  3.  
  4. //Eventos de teclado depende del que se clique un movimiento o otro
  5. case SDLK_UP:
  6. if (y > 0)
  7. //Se resta la posicion y
  8. y = y - 10;
  9.  
  10. break;
  11. case SDLK_DOWN:
  12. if (y < 340)
  13. //Se suma la posicion y
  14. y = y + 10;
  15.  
  16. break;
  17. case SDLK_LEFT:
  18. //Se resta la posicion x
  19. if (x > 0)
  20. x = x - 10;
  21.  
  22. break;
  23. case SDLK_RIGHT:
  24. //Se resta la posicion y
  25. if (x < 540)
  26. x = x + 10;
  27. break;
  28. }
  29. }

Como veis se tiene que pasar como paràmetros un dato del tipo SDL_Event, pero como en la clase padre no esta definido me da error, mi pregunta es si hay alguna manera de hacer override o otra cosa o de lo contrario alguna idea de como implementar el movimiento en la clase Player. Aquí les dejare todo el còdigo de todo lo que està implicado.

Entity.cpp
Código
  1. #include "Entity.h"
  2. #include "Sprite.h"
  3.  
  4.  
  5. CEntity::CEntity()
  6. {
  7. }
  8.  
  9. CEntity::CEntity(char * file, int x, int y, int hight, int width, SDL_Renderer * window)
  10. {
  11. this->file = file;
  12. this->x = x;
  13. this->y = y;
  14. this->hight = hight;
  15. this->width = width;
  16. this->window = window;
  17. }
  18.  
  19.  
  20. CEntity::~CEntity()
  21. {
  22. }
  23.  
  24. int CEntity::get_x()
  25. {
  26. return x;
  27. }
  28.  
  29. int CEntity::get_y()
  30. {
  31. return y;
  32. }
  33.  
  34. int CEntity::get_hight()
  35. {
  36. return hight;
  37. }
  38.  
  39. int CEntity::get_width()
  40. {
  41. return width;
  42. }
  43.  
  44. char CEntity::get_file()
  45. {
  46. return *file;
  47. }
  48.  
  49.  
  50. //Dona erroer es te que mirar, tot i que per el moment no es necessari mes endevant pot ser que ho necessitem
  51. /*SDL_Renderer CEntity::get_window() {
  52. return window;
  53. }*/
  54.  
  55. void CEntity::set_x(int x)
  56. {
  57. this->x = x;
  58. }
  59.  
  60. void CEntity::set_y(int y)
  61. {
  62. this->y = y;
  63. }
  64.  
  65. void CEntity::set_hight(int hight)
  66. {
  67. this->hight = hight;
  68. }
  69.  
  70. void CEntity::set_width(int width)
  71. {
  72. this->width = width;
  73. }
  74.  
  75. void CEntity::set_file(char* file) {
  76. this->file = file;
  77. }
  78.  
  79. void CEntity::set_window(SDL_Renderer* window) {
  80. this->window = window;
  81. }
  82.  
  83. void CEntity::load()
  84. {
  85. //Carga la imagen del pj
  86. image = Sprite::Load(file, window);
  87. }
  88.  
  89. void CEntity::draw()
  90. {
  91. //Dibuja el pj
  92. Sprite::Draw(window, image, x, y, width, hight);
  93. }
  94.  

Entity.h
Código
  1. #pragma once
  2. #include <SDL.h>
  3. class CEntity
  4. {
  5. public:
  6. CEntity();
  7. CEntity(char * file, int x, int y, int hight, int width, SDL_Renderer* window);
  8. ~CEntity();
  9. int get_x();
  10. int get_y();
  11. int get_hight();
  12. int get_width();
  13. SDL_Renderer get_window();
  14. char get_file();
  15. void set_file(char* file);
  16. void set_window(SDL_Renderer*  Window);
  17. void set_x(int x);
  18. void set_y(int y);
  19. void set_hight(int hight);
  20. void set_width(int width);
  21.  
  22. virtual void move() = 0;
  23. void load();
  24. void draw();
  25.  
  26. private:
  27. SDL_Renderer* window;
  28. SDL_Texture* image;
  29. char* file;
  30.  
  31. protected:
  32. int hight;
  33. int width;
  34. int x;
  35. int y;
  36.  
  37. };
  38.  

Player.cpp
Código
  1. #include "Player.h"
  2. #include "Entity.h"
  3.  
  4. CPlayer::CPlayer(char * file, int x, int y, int hight, int width, SDL_Renderer * window) : CEntity(file, x, y, hight, width, window)
  5. {
  6.  
  7. }
  8. CPlayer::CPlayer()
  9. {
  10. }
  11. void CPlayer::movee(SDL_Event evento) {
  12. switch (evento.key.keysym.sym) {
  13.  
  14. //Eventos de teclado depende del que se clique un movimiento o otro
  15. case SDLK_UP:
  16. if (y > 0)
  17. //Se resta la posicion y
  18. y = y - 10;
  19.  
  20. break;
  21. case SDLK_DOWN:
  22. if (y < 340)
  23. //Se suma la posicion y
  24. y = y + 10;
  25.  
  26. break;
  27. case SDLK_LEFT:
  28. //Se resta la posicion x
  29. if (x > 0)
  30. x = x - 10;
  31.  
  32. break;
  33. case SDLK_RIGHT:
  34. //Se resta la posicion y
  35. if (x < 540)
  36. x = x + 10;
  37. break;
  38. }
  39. }
  40.  
  41. void CPlayer::move()
  42. {
  43. }
  44.  

Player.h
Código
  1. #pragma once
  2. #include<SDL.h>
  3. #include"Sprite.h"
  4. #include "Entity.h"
  5. class CPlayer : public CEntity
  6. {
  7. public:
  8. CPlayer(char * file, int x, int y, int hight, int width, SDL_Renderer* window);
  9. CPlayer();
  10. void movee(SDL_Event evento);
  11. void move();
  12.  
  13. private:
  14. };

PlayState.cpp
Código
  1. #include <stdio.h>
  2.  
  3. #include "SDL.h"
  4. #include "Game.h"
  5. #include "PlayState.h"
  6. #include "PauseState.h"
  7. #include "Player.h"
  8.  
  9. PlayState PlayState::m_PlayState;
  10.  
  11. void PlayState::Init(Game* game)
  12. {
  13. playSprite = NULL;
  14.  
  15. playSprite = Sprite::Load("sprites/playstate.bmp", game->GetRenderer());
  16.  
  17. //Constructor del jugador, se passa la ubicacion de la imagen i sus datos igual que
  18. //el renderer donde se carga
  19. player = CPlayer("sprites/macaco.bmp", 200, 200, 64, 64, game->GetRenderer());
  20. //Defino la posicion inicial del enemigo
  21.  
  22. enemy_x = posicions_x[0];
  23. enemy_y = posicions_y[0];
  24. //Cargo la imagen del enemigo
  25. enemy = Sprite::Load("sprites/crab.bmp", game->GetRenderer());
  26.  
  27. //Cargo la imagen del jugador
  28. player.load();
  29.  
  30. printf("PlayState Init Successful\n");
  31. }
  32.  
  33. void PlayState::Clean()
  34. {
  35. printf("PlayState Clean Successful\n");
  36. }
  37.  
  38. void PlayState::Pause()
  39. {
  40. printf("PlayState Paused\n");
  41. }
  42.  
  43. void PlayState::Resume()
  44. {
  45. printf("PlayState Resumed\n");
  46. }
  47.  
  48. void PlayState::HandleEvents(Game* game)
  49. {
  50. SDL_Event event;
  51.  
  52. if (SDL_PollEvent(&event)) {
  53. switch (event.type) {
  54. case SDL_QUIT:
  55. game->Quit();
  56. break;
  57.  
  58. case SDL_KEYDOWN:
  59. switch (event.key.keysym.sym) {
  60.  
  61. //Eventos de teclado depende del que se clique un movimiento o otro
  62. case SDLK_SPACE:
  63. game->PushState(PauseState::Instance());
  64. break;
  65. }
  66. player.movee(event);
  67.  
  68.  
  69. //Comproba el contador per el seguiment del enemic
  70. if (cont < 8) {
  71. //Guarda les posicions anterior del pj a les cordenades del enemic
  72. enemy_x = posicions_x[cont];
  73. enemy_y = posicions_y[cont];
  74. //Esborra les cordenades utilitzades ara i les actualitza amb les actuals
  75. posicions_x[cont] = player.get_x();
  76. posicions_y[cont] = player.get_y();
  77. //Suma el contador
  78. cont++;
  79. }
  80.  
  81. else
  82. {
  83. //El contador arriba al maxim i es torna a possar a 0
  84. cont = 0;
  85. }
  86. }
  87. }
  88.  
  89. }
  90.  
  91. void PlayState::Update(Game* game)
  92. {
  93. }
  94.  
  95. void PlayState::Draw(Game* game)
  96. {
  97. Sprite::DrawFullScreen(game->GetRenderer(), playSprite);
  98. //Dibuja el enemigo
  99. Sprite::Draw(game->GetRenderer(), enemy, enemy_x, enemy_y, 64, 64);
  100. //Dibuja el personaje
  101. player.draw();
  102. SDL_RenderPresent(game->GetRenderer());
  103. }

En este ejemplo que he puesto hay un método propio de la clase Player llamado movee que es funcional y actualmente funciona perfectamente, pero claro yo lo que quiero es que lo pueda heredar de la clase entity y en la propia clase Player poder modificarlo como esta aquí, ya que el método move() de la clase Entity también serà utilizado por los enemigos clase Enemy. Gracias por vuestra ayuda, Si teneis alguna otra solución o alguna idea de como realizar el movimiento se lo agradezco.
Saludos!
;-) >:D ;-) >:D :laugh: :rolleyes:


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines