// $Id: playmodel.cc,v 1.6 2006/08/07 17:24:48 matthew Exp $

//  Fish Supper
//  Copyright (C) 2006 Matthew Clarke <matthew_larcke@lycos.co.uk>
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
// 
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//  02111-1307, USA.




#include "playmodel.h"




extern bool test_level;
extern char * test_file;




// *******************
// *** CONSTRUCTOR ***
// *******************
FS::PlayModel::PlayModel()
{
    // ...
    
} // FS::PlayModel::PlayModel()

// ******************
// *** DESTRUCTOR ***
// ******************
FS::PlayModel::~PlayModel()
{
    // ...
    
} // FS::PlayModel::~PlayModel()




// ************************
// *** MEMBER FUNCTIONS ***
// ************************

// **************************************************

void FS::PlayModel::load_level(int lev)
{
    // construct filename from 'lev'
    char my_filename[256];
    if ( test_level )
    {
        strcpy(my_filename, test_file);
    }
    else
    {
        sprintf(my_filename, PKG_DATA_DIR "/levels/level_%02d.fsl", lev);
    } // if ... else
    
    // open file - if can't open it that's a v. serious error so exit
    // program with message
    std::ifstream fin(my_filename);
    if (!fin.is_open())
    {
        std::cerr << "Can't open " << my_filename << ".\n";
        exit(EXIT_FAILURE);
    } // if
    
    // Used to hold lines as read from file...
    std::string my_line;
    
    // max crystals
    getline(fin, my_line);
    my_player_data.set_max_crystals( atoi( my_line.c_str() ) );
    
    // number of starting crystals
    getline(fin, my_line);
    num_starting_crystals = atoi( my_line.c_str() );
    
    // the starting crystals themselves - stored in this class 
    // in case we need to restart the level
    int start = 0;
    int comma_pos;
    getline(fin, my_line);
    for (int i = 0; i < num_starting_crystals; ++i)
    {
        comma_pos = my_line.find(',', start);
        starting_crystals[i] = (CrystalColor) atoi(
                my_line.substr( start, comma_pos - start ).c_str() );
        start = comma_pos + 1;
    } // for
    my_player_data.set_crystals_held(starting_crystals, num_starting_crystals); 

    // Hand stream over to MapEngine to let it initialize itself.
    my_map_engine.load_map(fin);
        
    fin.close();
    
} // FS::PlayModel::load_level()

// **************************************************

FS::PlayReport FS::PlayModel::update(int gt, KeyboardEvent * events, int n, bool running)
{
    my_map_engine.update(gt - start_time);
    
    PlayReport my_report = PR_OK;   // initial value to keep compiler happy
    
    switch ( my_sprite_mngr.update(gt - start_time, events, n, running, 
            my_map_engine.get_current_start_pixels(), my_map_engine.get_pixels_to_move(), 
            my_map_engine.get_old_pixels_to_move(), my_map_engine.get_directions()) )
    {
        case SpriteManager::PLAYING_GAME:
            my_report = PR_OK;
            break;
        case SpriteManager::REQUEST_LEVEL_RESTART:
            my_player_data.set_crystals_held(starting_crystals, num_starting_crystals);
            my_sprite_mngr.restart_level();
            my_map_engine.restart_level(gt - start_time);
            my_report = PR_OK;
            break;
        case SpriteManager::LEVEL_COMPLETED:
            my_player_data.inc_level();
            
            // FIXME: write a proper sequence for when game is completed.
            if ( my_player_data.get_level() > NUM_LEVELS )
            {
                my_report = PR_GAME_OVER;
            }
            else
            {
                my_report = PR_LEVEL_COMPLETED;
            } // if ... else
            
            break;
        case SpriteManager::GAME_OVER:
            my_report = PR_GAME_OVER;
            break;
        case SpriteManager::RUNNING_LEVEL_COMPLETED_ROUTINE:
        case SpriteManager::RUNNING_GAME_OVER_ROUTINE:
            my_report = PR_OK;
            break;
    } // switch
    
    return my_report;
    
} // FS::PlayModel::update()

// **************************************************

void FS::PlayModel::init_sprite_manager(PlayDisplay * pd, SoundEngine * se)
{
    my_sprite_mngr.set_play_display(pd);
    my_sprite_mngr.set_player_data(&my_player_data);
    my_sprite_mngr.set_sound_engine(se);
    my_sprite_mngr.set_map_engine(&my_map_engine);
    
} // FS::PlayModel::init_sprite_manager()
      
// **************************************************

void FS::PlayModel::new_game(int start_level)
{
    my_player_data.reset(start_level);
    
} // FS::PlayModel::new_game()
     
// **************************************************

void FS::PlayModel::new_level(int st)
{
    load_level(my_player_data.get_level());
    
    my_sprite_mngr.create_map_sprites(my_map_engine.get_row_lengths(), 
            my_map_engine.get_blocks(), my_map_engine.get_row_lengths_pixels(), 
            my_map_engine.get_directions());
    
    my_sprite_mngr.reset();
    my_map_engine.reset();
    
    start_time = st;
    
} // FS::PlayModel::new_level()

// **************************************************
// **************************************************
// **************************************************
// **************************************************