MovementPhase.cpp

#include "MovementPhase.h"
#include <random> 
#include "Input.h"
#include <algorithm>

MovementPhase::MovementPhase(Grid * pGrid)
:currentPlayer(pGrid->GetCurrentPlayer())
{
    this->pGrid = pGrid;
    pOut = pGrid->GetOutput();
    player0 = pGrid->GetPlayer(0);
    player1 = pGrid->GetPlayer(1);

}

void MovementPhase::displayRandomCommands(Player * currentPlayer)
{


    ////random number generator
    std::random_device engine; 
    std::uniform_int_distribution<int> distrib(1, 8);
    ///

    int comsize = min(5,(currentPlayer->GetHealth()));
    pOut->PrintMessage(std::to_string((currentPlayer->GetHealth())));
    int x,y;
    Input * pIn;
    pIn = pOut->CreateInput();
    pIn->GetPointClicked(x,y);

    Command* savedCommands = new Command[comsize];
    //Command savedCommands[5];
    for (int i = 0; i < comsize; i++)
    {
        savedCommands[i] = NO_COMMAND;
    }
    
    Command availableCommands[10];
    for (int i = 0; i < 10; i++)
    {
        //
        availableCommands[i] = Command(distrib(engine));
    }
    pOut->CreateCommandsBar(savedCommands, comsize, availableCommands, 10);

    
    // delete[] savedCommands;
    // savedCommands = NULL;

    /////

    
}

void MovementPhase::selectCommands(Player* currentPlayer)
{
    // Determine the size of commands to be selected (at most 5 commands, or player's health)
    int comsize = min(5, currentPlayer->GetHealth());
   
    // Initialize savedCommands to NO_COMMAND
    Command* savedCommands = new Command[comsize];
    for (int i = 0; i < comsize; i++) {
        savedCommands[i] = NO_COMMAND;
    }

    // Generate 10 random commands using random_device and uniform_int_distribution
    int availableSize = 10;
    Command* availableCommands = new Command[availableSize];

    std::random_device engine;
    std::uniform_int_distribution<int> distrib(1, 8); // Assuming 1 to 8 maps to Command enums

    // Fill availableCommands with random commands
    for (int i = 0; i < availableSize; i++) {
        availableCommands[i] = static_cast<Command>(distrib(engine));
    }

    // Input for selection
    Input* pIn = pOut->CreateInput();
    int selectedIndex = 0;

    // Allow the player to select 'comsize' number of commands
    for (int i = 0; i < comsize; i++) {
        // Display the available commands
        pOut->CreateCommandsBar(savedCommands, comsize, availableCommands, availableSize);

        // Prompt the player for a selection
        pOut->PrintMessage("Select a command: ");
        selectedIndex = pIn->GetSelectedCommandIndex();

        // Ensure valid selection
        if (selectedIndex >= 0 && selectedIndex < availableSize) {
            // Save the selected command
            savedCommands[i] = availableCommands[selectedIndex];

            // Remove the selected command from availableCommands
            // Shift the remaining commands to the left
            for (int j = selectedIndex; j < availableSize - 1; j++) {
                availableCommands[j] = availableCommands[j + 1];
            }

            // Set the last element in the availableCommands to NO_COMMAND (so that it's not reused)
            availableCommands[availableSize - 1] = NO_COMMAND;

            // Decrease the size of availableCommands
            availableSize--;
        } else {
            // Invalid selection, retry for this slot
            pOut->PrintMessage("Invalid selection. Try again.");
            i--; // Retry the same command slot
        }
        
        pOut->CreateCommandsBar(savedCommands, comsize, availableCommands, availableSize);
    }

    //////////explicitly set the last selected ccommand "if removed ui becomes crazy":
    

    // Final display of saved commands for debugging
    std::string debugMessage = "Saved Commands: ";
    for (int i = 0; i < comsize; i++) {
        debugMessage += std::to_string(savedCommands[i]) + " ";
    }
    pOut->PrintMessage(debugMessage);

    ////////////////////////////////////////////////////
   
    //savedMoves[i] = savedCommands[i];
        
    ////////////////////////////////////////////////////////////////////////
    //////////////Execution at instant, نص العمى ولا العمى كله
    ////////////////////////////////////////////////////////////////////////

   
    currentPlayer->Move(pGrid,savedCommands);
      
    

    
    
    
    // dead function :(
    delete[] savedCommands;
    delete[] availableCommands;
    
}






void MovementPhase::execute(Player* currentPlayer)
{
    if (!(currentPlayer->CanMove()))
    {
       pGrid->PrintErrorMessage("This player cant move this round");
       return;
    }
    
    Input * pIn;
    pIn = pOut->CreateInput();
    int x,y;
    ////display random commands:
    
    //displayRandomCommands(currentPlayer);
    pIn->GetPointClicked(x,y);
    ////select commands:
    selectCommands(currentPlayer);
    ////---/////logic will be implemented later.

    ////execute commands:
   


    /////clear commands bar:
    //  pOut->ClearCommandsBar();


 
}