---

/home/rdbrown/doxygen/cse125g1/src/game/client/LobbyGS.cpp

#include <stdlib.h>
#include <vector>
#include <iostream>
#include <assert.h>

#include "input/Input.h"
#include "resources/resources.h"

#include "client.h"
#include "textures.h"

#include "net/MMNet.h"
#include "LoadingGS.h"
#include "LobbyGS.h"

using namespace MMGUI;
using namespace MMNet;
using namespace TNL;
using namespace std;

static GameState *thisGS;

static void returnToMainMenu(const char *str) {
    setGameState(NULL);
    // Make sure we don't get a callback from this (we don't care about it)
    thisGS->client->disconnectFromServer();
}

static void toggleReady(const char *str) {
    thisGS->client->toggleReady();    
}

static void changeModelRobin(const char *str) {
    thisGS->client->changeModel(PlayerModelRobinHood);
}

static void changeModelLittleJohn(const char *str) {
    thisGS->client->changeModel(PlayerModelLittleJohn);
}

static void changeModelSheriff(const char *str) {
    thisGS->client->changeModel(PlayerModelSheriff);
}

static void changeModelGuard(const char *str) {
    thisGS->client->changeModel(PlayerModelGuard);
}

static void changeModelNone(const char *str) {
    thisGS->client->changeModel(PlayerModelNone);
}


LobbyGS::LobbyGS(NetClient *client) : GameState(client) {    
    assert(client != NULL);
    
    for(int i = 0; i < MAX_PLAYERS; i++) {
        slots[i] = NULL;
    }
}

void LobbyGS::init() {
    thisGS = this;  

    menuInit();
    
    initSlots();
    
    callback = new LobbyCallback(this);    
    client->setGameCallback(callback);

    Frame *pane = new Frame(WidgetAlignCenter, 800, 600);
    getRoot()->addChild(pane);
    
    exitButton = new Button(WidgetAlignBottomLeft, 100, 50);
    exitButton->setUpImage(TEXTURE_EXIT_BUTTON);
    exitButton->setDownImage(TEXTURE_EXIT_BUTTON_ON);
    exitButton->setOverImage(TEXTURE_EXIT_BUTTON_OVER); 
    exitButton->setClickFunction(returnToMainMenu);
    pane->addChild(exitButton);
    
    readyButton = new Button(WidgetAlignBottom, 140, 70);
    readyButton->setUpImage(TEXTURE_READY_BUTTON);
    readyButton->setDownImage(TEXTURE_READY_BUTTON_ON);
    readyButton->setOverImage(TEXTURE_READY_BUTTON_OVER); 
    readyButton->setClickFunction(toggleReady);
    pane->addChild(readyButton);

    pane->addChild(initModelButtons());
    
    glutPostRedisplay();
}


Frame *LobbyGS::initModelButtons() {
    
    Frame *topFrame = new Frame(WidgetAlignTop, 300, 110);
    topFrame->setBorder(1);
    topFrame->setMargin(1);
    topFrame->setBorderColor(1,1,0);
    
    Textfield *label = new Textfield(WidgetAlignTop, 300, 20);
    label->setText("Choose your character:");
    label->alignCenter();
    label->setFontColor(1,0,0);
    topFrame->addChild(label);
    
    charName = new Textfield(WidgetAlignBottom, 300, 20);
    charName->clearText();
    charName->alignCenter();
    charName->setFontColor(1,0,0);
    topFrame->addChild(charName);
    
    
    Frame *modelButtons = new Frame(WidgetAlignCenter, 270, 56);
    topFrame->addChild(modelButtons);    
    
    robinButton = new Button(0, 0, 50, 50);
    robinButton->setUpImage(TEXTURE_HEADSHOT_ROBIN);
    robinButton->setDownImage(TEXTURE_HEADSHOT_ROBIN);
    robinButton->setOverBorderColor(0,1,0);
    robinButton->setOverBorder(2);
    robinButton->setClickFunction(changeModelRobin);
    modelButtons->addChild(robinButton);

    littleJohnButton = new Button(55, 0, 50, 50);
    littleJohnButton->setUpImage(TEXTURE_HEADSHOT_LITTLEJOHN);
    littleJohnButton->setDownImage(TEXTURE_HEADSHOT_LITTLEJOHN);
    littleJohnButton->setOverBorderColor(0,1,0);
    littleJohnButton->setOverBorder(2);
    littleJohnButton->setClickFunction(changeModelLittleJohn);
    modelButtons->addChild(littleJohnButton);

    noneButton = new Button(110, 0, 50, 50);
    noneButton->setUpImage(TEXTURE_WHITE_BUTTON);
    noneButton->setDownImage(TEXTURE_WHITE_BUTTON);
    noneButton->setOverBorderColor(1,0,0);
    noneButton->setOverBorder(2);
    noneButton->setClickFunction(changeModelNone);
    modelButtons->addChild(noneButton);

    guardButton = new Button(165, 0, 50, 50);
    guardButton->setUpImage(TEXTURE_HEADSHOT_GUARD);
    guardButton->setDownImage(TEXTURE_HEADSHOT_GUARD);
    guardButton->setOverBorderColor(0.5, 0.2, 0);
    guardButton->setOverBorder(2);
    guardButton->setClickFunction(changeModelGuard);
    modelButtons->addChild(guardButton);

    sheriffButton = new Button(220, 0, 50, 50);
    sheriffButton->setUpImage(TEXTURE_HEADSHOT_SHERIFF);
    sheriffButton->setDownImage(TEXTURE_HEADSHOT_SHERIFF);
    sheriffButton->setOverBorderColor(0.5, 0.2, 0);
    sheriffButton->setOverBorder(2);
    sheriffButton->setClickFunction(changeModelSheriff);
    modelButtons->addChild(sheriffButton);

    return topFrame;
}

void LobbyGS::disableModelButtons() {
    sheriffButton->setDisabled(true);
    robinButton->setDisabled(true);
    guardButton->setDisabled(true);
    littleJohnButton->setDisabled(true);
    noneButton->setDisabled(true);
}

void LobbyGS::enableModelButtons() {
    sheriffButton->setDisabled(false);
    robinButton->setDisabled(false);
    guardButton->setDisabled(false);
    littleJohnButton->setDisabled(false);
    noneButton->setDisabled(false);
}


void LobbyGS::updateModelButtons() {

    // first check if this player is ready. 
        if(client->game->myPlayer && client->game->myPlayer->isReady()) {
        return;
    }
     
#if 0

  //Attempt at disabling buttons of chars that are used...doesn't work atm


    enum PlayerModel model;
    // run through all the players and disable buttons which they are.
    // enable them all by default, and we'll disable them as we find them.
    enableModelButtons(); 
    for(int i = 0; i < MAX_PLAYERS; i++) {
        if(slots[i] != NULL && slots[i]->isValid() == true) {
           model = slots[i]->getModel();

            switch(model) {
                case PlayerModelSheriff:
                    sheriffButton->setDisabled(true); break; 
                case PlayerModelGuard:
                    guardButton->setDisabled(true); break;
                case PlayerModelRobinHood:
                    robinButton->setDisabled(true); break;
                case PlayerModelLittleJohn:
                    littleJohnButton->setDisabled(true); break;
                default:
                    break;                     
            }
        }
    }    

#endif    
    
    // If the last one still is where the mouse is, do nothing
    if(lastOver != NULL && lastOver->isMouseOver()) {
        return;
    }
    
    // check which button (if any) has the mouseover
    if(robinButton->isMouseOver()) {              
        charName->setText("Robin Hood");
        lastOver = robinButton;
    } else if(littleJohnButton->isMouseOver()) {
        charName->setText("Little John");        
        lastOver = littleJohnButton;
    } else if(guardButton->isMouseOver()) {
        charName->setText("Sheriff's Guard");        
        lastOver = guardButton;
    } else if(sheriffButton->isMouseOver()) {
        charName->setText("The Sheriff");        
        lastOver = sheriffButton;
    } else if(noneButton->isMouseOver()) {    
        charName->clearText();        
        lastOver = noneButton;
    } else {
        // None of the buttons has it, so lets see if we really need to 
        // redisplay.
        if(lastOver == NULL) {
            return;
        }
        lastOver = NULL;
        charName->clearText();
    }
    glutPostRedisplay();   
}
    
void LobbyGS::display(void) {
    glClearColor(0,0,0,0); //must have black background
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    menuDraw();   
    
    glutSwapBuffers();
}

void LobbyGS::exit() {
    for(int i = 0; i < MAX_PLAYERS; i++) {          
           delete slots[i];
    }
    
    client->setGameCallback(NULL);
    delete callback;
    menuClear();
}

void LobbyGS::update(void) {
    updateSlots();
    updateModelButtons();
}

void LobbyGS::setupGame(TNL::U32 seed) {
    this->seed = seed;
    
    client->game->levelSeed = seed;
    
    setGameState(new LoadingGS(client));
}

void LobbyGS::updateSlots() {            
    for(int i = 0; i < MAX_PLAYERS; i++) {                
        if(slots[i] != NULL) {
            slots[i]->update();                           
        }
    }
}

void LobbyGS::initSlots() {            

    Frame *slotFrame = new Frame(WidgetAlignCenter, (SLOT_WIDTH * 4) + (SLOT_MARGIN * 3), SLOT_HEIGHT);    
    getRoot()->addChild(slotFrame);
    
    // We want 4 columns by 1 row       
    for(int i = 0; i < MAX_PLAYERS; i++) {                        
        // make sure we don't have any slots left over from last time (unlikely)        
        if(slots[i] != NULL) {
            slotFrame->removeChild(slots[i]);
            delete slots[i];
        }
        slots[i] = new PlayerSlot(client->game, this, i, (i * (SLOT_WIDTH + SLOT_MARGIN)), 0);
        slotFrame->addChild(slots[i]);
    }        
}

bool LobbyGS::allReady() {
    for(int i = 0; i < MAX_PLAYERS; i++) {
        if(slots[i]->isValid() == true && slots[i]->isReady() == false) {
            return false;
        }
    }    
    return true;    
}

---