shitgame/input.c

/*Troy Rosin*/

#include <SDL2/SDL.h>
#include <game.h>
#include <main.h>
#include <overworld.h>
#include <host.h>
#include <mydebug.h>
#include <options.h>
#include <net.h>


int prev_state;

void mainmenu_selection_state();
void handle_input_mainmenu(SDL_Event *e);
void handle_input_battle(SDL_Event *e);
void handle_input_overworld(SDL_Event *e);
void handle_input_host(SDL_Event *e);
void handle_input_join(SDL_Event *e);
void handle_input_options(SDL_Event *e);

//main event handler
void handle_event(SDL_Event *e){
  while(SDL_PollEvent(e))
  {
    switch(state)
    {
      case TITLE:
        if(e->type == SDL_KEYDOWN)
        { 
          handle_input_mainmenu(e);
        }
        if(e->type == SDL_MOUSEBUTTONDOWN)
        {
          mainmenu_selection_state();
        }
        break;
      case BATTLE:
        switch (e->type)
        {
          case SDL_KEYDOWN:
            handle_input_battle(e);
            break;
          case SDL_MOUSEBUTTONDOWN:
            dragging = GRAB_NEW;
            break;
          case SDL_MOUSEBUTTONUP:
            dragging = LETGO;
        } 
        break;
      case OVERWORLD:
        switch(e->type)
        {
          case SDL_KEYDOWN:
            handle_input_overworld(e);
            break;
        }
        break;
      case HOST:
        handle_input_host(e);      
        break;
      case JOIN:
        handle_input_join(e);
        break;
      case OPTIONS:
        handle_input_options(e);
        break;
      default:
        if(e->type == SDL_KEYDOWN && e->key.keysym.sym == SDLK_ESCAPE)
        {
          running = 0;
        }
 
    }
  return;
  }
}

void mainmenu_selection_state()
{
  switch (selected_index)
  {
    case START_GAME:          
      state = START; 
      break;
    case HOST_GAME:
      state = HOST;
      break;
    case JOIN_GAME:
      state = JOIN;
      break;
    case OPTIONS_MENU:
      prev_state = state;
      state = OPTIONS;
      break;
    case EXIT_GAME:
      running = 0;
      break;
  }
}

void handle_input_mainmenu(SDL_Event *e)
{
  switch(e->key.keysym.sym){
    case SDLK_UP:
    case SDLK_w:
      if (selected_index) { selected_index--; }
      else { selected_index = MAIN_SELECTIONS - 1; }
      selected_index %= MAIN_SELECTIONS;
      break;
    case SDLK_DOWN:
    case SDLK_s:
      selected_index++;
      selected_index %= MAIN_SELECTIONS;
      break;
    case SDLK_RETURN:
      mainmenu_selection_state();
      break; 
  }
  return;
}


void handle_input_battle(SDL_Event *e)
{
  switch(e->key.keysym.sym)
  {
    case SDLK_ESCAPE:
      running = 0;
      break;
  }
  return;
}

void handle_input_overworld(SDL_Event *e)
{
  PLAYER *plr = get_this_player();
  switch(e->key.keysym.sym)
  {
    case SDLK_ESCAPE:
      prev_state = state;
      state = OPTIONS;
      break;
    case SDLK_UP:
    case SDLK_w:
      plr->pos.y -= 1;
      break;
    case SDLK_DOWN:
    case SDLK_s:
      plr->pos.y += 1;
      break;
    case SDLK_RIGHT:
    case SDLK_d:
      plr->pos.x += 1;
      break;
    case SDLK_LEFT:
    case SDLK_a:
      plr->pos.x -= 1;
      break;
  }
  return;
}


void handle_input_host(SDL_Event *e)
{
  int oldlen, inputlen;
  char tempname[MAX_NAMESZ], *nameptr;
  nameptr = get_this_name(-1);
  strcpy(tempname, nameptr);
  oldlen = strlen(tempname);
 
  switch(e->type)
  {
    case SDL_KEYUP:
      break;
    case SDL_KEYDOWN:
      switch(e->key.keysym.sym)
      {
        case SDLK_ESCAPE:
          PRINT_M(TELL SERVER IM NOT A HOST)
          state = TITLE;
          break;
        case SDLK_BACKSPACE:
          PRINT_M(got backspace)
          if(oldlen == 0){ break; }
          tempname[oldlen - 1] = '\0';
          strcpy(nameptr, tempname);
          break;
      }
      break;
    case SDL_TEXTINPUT:
      inputlen = strlen(e->text.text);
      PRINT_M(got text input event)
      if(oldlen + inputlen > MAX_NAMESZ -1){ break; }
      strcat(tempname, e->text.text);
      strcpy(nameptr, tempname);
      break;
    case SDL_MOUSEBUTTONDOWN:
      switch(over_object)
      {
        case NO_OBJECT:
          break;
        case SET_NAME_BUTTON:
          strcpy(get_this_name(0), nameptr);
          break;
        case START_GAME_BUTTON:
          PRINT_M(CHECK THAT NAME IS VALID!!)
          if(strlen(get_this_name(0)) >= 1 && !lobby_has_name){
            if(new_host(get_this_name(0))){
              lobby_has_name = 1;
            }
            else{
              PRINT_M(ERROR GOT NEG FOR NEW HOST)
            }
          }
          else{//were in the lobby waiting for homies
            PRINT_M(START COOP GAME)
          }
          break;
      }
  }
  return;
}

void handle_input_join(SDL_Event *e)
{
  int oldlen, inputlen;
  char tempname[MAX_NAMESZ], *nameptr;
  nameptr = join_get_name_ptr();
  strcpy(tempname, nameptr);
  oldlen = strlen(tempname);
 
  switch(e->type)
  {
    case SDL_KEYUP:
      break;
    case SDL_KEYDOWN:
      switch(e->key.keysym.sym)
      {
        case SDLK_ESCAPE:
          state = TITLE;
          break;
        case SDLK_BACKSPACE:
          PRINT_M(got backspace)
          if(oldlen == 0){ break; }
          tempname[oldlen - 1] = '\0';
          strcpy(nameptr, tempname);
          break;
      }
      break;
    case SDL_TEXTINPUT:
      inputlen = strlen(e->text.text);
      PRINT_M(got text input event)
      if(oldlen + inputlen > MAX_NAMESZ -1){ break; }
      strcat(tempname, e->text.text);
      strcpy(nameptr, tempname);
      break;
    
    case SDL_MOUSEBUTTONDOWN:
      switch(join_over_object())
      {
        case NO_OBJECT:
          break;
        case JOIN_GAME_BUTTON:
          PRINT_M(JOIN_GAME BUTTON)
          //check name field and send it off bb
          break;
        case LOBBY_NAME_BOX:
          join_set_selected(LOBBY_NAME_SEL);  
          break;
        case PLAYER_NAME_BOX:
          join_set_selected(PLAYER_NAME_SEL);
          break;
      }
      break;
  }
  return;
}

void options_select(int sel)
{
  switch(sel)
  {
    case GP_OPT_SEL:
      PRINT_M(GAMEPLAY OPTIONS)
      break;
    case VID_OPT_SEL:
      PRINT_M(VIDEO OPTIONS)
      break;
    case AUD_OPT_SEL:
      PRINT_M(AUDIO OPTIONS)
      break;
    case MM_OPT_SEL:
      PRINT_M(HANDLE EXITING GRACEFULLY I.E. SAVING GAME)
      prev_state = state = TITLE;
      break;
    case EXT_OPT_SEL:
      PRINT_M(EXIT GAME)
      running = 0;
      break;
    default:
      PRINT_M(UNKNOWN OPTION PASSED)
      break;
  }
  return;
}

void handle_input_options(SDL_Event *e)
{
  int sel = get_sel_opt();
  if(e->type == SDL_KEYUP){ return; }
  switch(e->key.keysym.sym){
    case SDLK_ESCAPE:
      PRINT_M(NEED TO GET PREV STATE)
      state = prev_state;
      break;
    case SDLK_UP:
    case SDLK_w:
      if (sel) { sel--; }
      else { sel = NUM_OPTIONS - 1; }
      break;
    case SDLK_DOWN:
    case SDLK_s:
      ++sel;
      sel %= NUM_OPTIONS;
      break;
    case SDLK_RETURN:
      options_select(sel);
      break; 
  }
  set_sel_opt(sel); 
  return;
}