main.cpp File Reference

file with the main() function More...

#include "controls.h"
#include "draw.h"
#include "events.h"
#include "file_io.h"
#include "format.h"
#include "graph.h"
#include "random_price.h"
#include "stock.h"
#include "nonstdlibs/VariadicTable.h"
#include <cmath>
#include <fstream>
#include <numeric>

Include dependency graph for main.cpp:

Go to the source code of this file.

Macros
#define	enableWindowsVTProcessing()

Enumerations
enum	mode { normal , dev }
	hiding mean/sd/uplim/lowlim/event_id columns in the table More...

Functions
void	get_hsi (std::vector< Stock > stocks_list, std::vector< float > &hsi_history)
std::vector< Stock_event >	get_ongoing_events (std::vector< Stock > stocks_list)
	Get all the ongoing events.
void	initializePlayerSaves (std::vector< Stock > &stocks_list, std::vector< float > &hsi_history)
int	main (void)
void	new_events_next_round (std::vector< Stock > &stocks_list)
	Generate new events and apply them to the stocks.
void	next_round_routine (unsigned int &_rounds, std::vector< Stock > &stocks_list)
void	print_table (std::vector< Stock > stocks_list, float _playerBal, mode m=dev)
	Print the table of stocks.
std::string	vectorToString (const std::vector< unsigned int > &vec)

Variables
float	balance = 1000.0f
	Player's balance.
std::string	playerName
	Player's name.
unsigned int	rounds_played = 1
	Number of rounds played.
const float	trading_fees_percent = 0.1 / 100
	/ 100 means charging % more/portion of the money involved in stock operations.

Detailed Description

file with the main() function

Definition in file main.cpp.

Macro Definition Documentation

enableWindowsVTProcessing

#define enableWindowsVTProcessing

(

)

Definition at line 58 of file main.cpp.

Referenced by main().

Enumeration Type Documentation

mode

enum mode

hiding mean/sd/uplim/lowlim/event_id columns in the table

Enumerator
normal
dev

Definition at line 104 of file main.cpp.

{ normal, dev };

Function Documentation

get_hsi()

void get_hsi	(	std::vector< Stock >	stocks_list,
		std::vector< float > &	hsi_history )

Definition at line 82 of file main.cpp.

                                                                           {
    float hsi = 0;
    std::string filesave =
        SAVE_FOLDER_PREFIX + playerName + "/hsi" + SAVE_FILE_EXTENSION_TXT;
    std::vector<float> total;
    for (unsigned int i = 0; i < stocks_list.size(); i++) {
        total.emplace_back(
            stocks_list[i].get_price() / stocks_list[i].get_initial_price() * 1000 *
            static_cast<float>(std::pow(2, stocks_list[i].get_split_count())));
        // HSI formula = (price/initial price) * 1000 * 2^split count
    }
    hsi = std::reduce(total.begin(), total.end()) / total.size();
    hsi_history.emplace_back(hsi);
    std::ofstream fout;
    fout.open(filesave.c_str(), std::ios::app);
    fout << hsi << ' ';
    fout.close();
}

References playerName, SAVE_FILE_EXTENSION_TXT, and SAVE_FOLDER_PREFIX.

Referenced by main().

Here is the caller graph for this function:

get_ongoing_events()

std::vector< Stock_event > get_ongoing_events

(

std::vector< Stock >

stocks_list

)

Get all the ongoing events.

Parameters

stocks_list

A vector of stocks.

Returns

A vector of Stock_event

Definition at line 202 of file main.cpp.

                                                                        {
    // Return a vector of ongoing events without duplicates
    std::vector<Stock_event> ongoing_events = {};
    for (unsigned int i = 0; i < stocks_list.size(); i++) {
        std::list<Stock_event> events = stocks_list[i].get_events();
        for (const Stock_event & event : events) {
            // Side note: Events with duration <= 0 are automatically removed from the
            // stock's event list. By stock.cpp Stock::next_round() which uses
            // Stock::remove_obselete_event()
            if (event.duration > 0) {
                // If the event is not in the ongoing_events, add it.
                if (std::find(ongoing_events.begin(), ongoing_events.end(), event) ==
                    ongoing_events.end()) {
                    ongoing_events.emplace_back(event);
                }
            }
        }
    }
    return ongoing_events;
}

Referenced by main(), and new_events_next_round().

Here is the caller graph for this function:

initializePlayerSaves()

void initializePlayerSaves	(	std::vector< Stock > &	stocks_list,
		std::vector< float > &	hsi_history )

Definition at line 290 of file main.cpp.

                                                                    {
    std::string EMPTY_INPUT = "";
    std::string loadsave = EMPTY_INPUT;
    while (loadsave.compare(EMPTY_INPUT) == 0) {
        std::cout << USER_SAVE_OPTION_PROMPT;
        std::cin >> loadsave;
        while (!checkValidInput(loadsave)) {
            std::cout << "Invalid input.\n" << USER_SAVE_OPTION_PROMPT;
            std::cin >> loadsave; // choose new file or load previous file
        }
        if (loadsave.compare(USER_SAVE_OPTION::NEW_GAME) == 0) {
            createplayer(playerName);
            savestatus(rounds_played, stocks_list, balance, playerName);
        }
        if (loadsave.compare(USER_SAVE_OPTION::LOAD_GAME) == 0) {
            loadstatus(rounds_played, stocks_list, balance, playerName, hsi_history);
        }
        if (loadsave.compare(USER_SAVE_OPTION::DELETE_GAME) == 0) {
            delsave(loadsave);
            loadsave = EMPTY_INPUT;
        }
        if (loadsave.compare(USER_SAVE_OPTION::EXIT_GAME) == 0) {
            std::cout << "Goodbye! Hope you had a good luck in the stock market!"
                      << std::endl;
            exit(EXIT_SUCCESS);
        }
    }
}

References balance, checkValidInput(), createplayer(), USER_SAVE_OPTION::DELETE_GAME, delsave(), USER_SAVE_OPTION::EXIT_GAME, USER_SAVE_OPTION::LOAD_GAME, loadstatus(), USER_SAVE_OPTION::NEW_GAME, playerName, rounds_played, savestatus(), and USER_SAVE_OPTION_PROMPT.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

void

)

Definition at line 320 of file main.cpp.

               {
    enableWindowsVTProcessing();
    std::cout << "The game was compiled on " << __DATE__ << " at " << __TIME__
              << std::endl;
 
    bool advance;          // Whether to advance to the next round
    bool gameQuit = false; // Whether the player wants to quit the game
    bool viewMode = false; // 0 to view table, 1 to view graph
    bool overlayEvent;     // Whether the event bar is being shown
    bool flush;            // Whether the screen needs updating
    int row;               // Number of characters to fit in a column
    int col;               // Number of characters to fit in a row
    fetchConsoleDimensions(row, col);
 
    std::vector<Stock> stocks_list;
    stocks_list.reserve(initial_stock_count);
    for (int i = 0; i < initial_stock_count; i++) {
        stocks_list.emplace_back();
    }
 
    sortStocksList(stocks_list, by_category, ascending);
 
    assertion_check_uniq_events();
    if (assertion_check_mutual_exclusivity()) {
        exit(1);
    }
 
    drawLogo(row, col);
    time::sleep(sleepMedium);
    std::vector<float> hsi_history;
 
    initializePlayerSaves(stocks_list, hsi_history);
 
    if (hsi_history.empty()) {
        get_hsi(stocks_list, hsi_history);
    }
 
    // Done loading/creating a new file.
    std::cout << "Current trading fees are charged at " << trading_fees_percent * 100
              << " %" << std::endl;
    time::sleep(sleepMedium * 2);
 
    while (!gameQuit) {
        advance = false;
        overlayEvent = false;
        flush = false;
        if (viewMode) {
            int indexGraph =
                integerInput(row, col, "Select stock index to display (0 for HSI): ");
            while (
                indexGraph < 0 || indexGraph > static_cast<int>(stocks_list.size())) {
                std::cout << setCursorPosition(row, 3) << "\x1b[2K";
                std::cout << "Index out of range!";
                time::sleep(sleepMedium);
                indexGraph = integerInput(
                    row, col, "Select stock index to display (0 for HSI): ");
            }
            std::cout << textClear << setCursorPosition(6, 0);
            graph_plotting(playerName, indexGraph - 1, col * 2 / 3, row - 10);
        }
        else {
            std::cout << textClear << setCursorPosition(6, 0);
            print_table(stocks_list, balance); // Print the table of stocks
        }
        drawRoundInfo(row, col, rounds_played, balance, playerName,
            hsi_history[hsi_history.size() - 1]);
        drawEventBar(row, col);
        drawButton(row, col);
        while (!flush) {
            optionsInput(row, col, balance, trading_fees_percent, stocks_list,
                get_ongoing_events(stocks_list), viewMode, advance, overlayEvent, flush,
                gameQuit);
        }
 
        if (advance) {
            next_round_routine(rounds_played, stocks_list);
            get_hsi(stocks_list, hsi_history);
            savestatus(rounds_played, stocks_list, balance, playerName);
            viewMode = false;
            time::sleep(sleepLong);
        }
    }
    return EXIT_SUCCESS;
}

References ascending, assertion_check_mutual_exclusivity(), assertion_check_uniq_events(), balance, by_category, drawButton(), drawEventBar(), drawLogo(), drawRoundInfo(), enableWindowsVTProcessing, fetchConsoleDimensions(), get_hsi(), get_ongoing_events(), graph_plotting(), initial_stock_count, initializePlayerSaves(), integerInput(), next_round_routine(), optionsInput(), playerName, print_table(), rounds_played, savestatus(), setCursorPosition(), time::sleep(), sleepLong, sleepMedium, sortStocksList(), textClear, and trading_fees_percent.

Here is the call graph for this function:

new_events_next_round()

void new_events_next_round

(

std::vector< Stock > &

stocks_list

)

Generate new events and apply them to the stocks.

Should be called at the beginning of each round.

Parameters

stocks_list

A vector of stocks. Pass by reference to modify the stocks.

Note

numEvents is the sum of these three values:

• 1
• A random integer between 0 and 1 (uniform distribution)
• 1 if more than 10 rounds have been played If there was already more than 5 events, we will not generate more events.

Definition at line 228 of file main.cpp.

                                                           {
    /** @note numEvents is the sum of these three values:
     * - 1
     * - A random integer between 0 and 1 (uniform distribution)
     * - 1 if more than 10 rounds have been played
     * If there was already more than 5 events, we will not generate more events.
     */
    unsigned int numEvents = 1 + random_integer(1) + (rounds_played / 5 > 2) * 1;
    if (get_ongoing_events(stocks_list).size() > 5) {
        return;
    }
    std::vector<Stock_event> picked_events = pick_events(all_stock_events, numEvents);
    for (const Stock_event & event : picked_events) {
        switch (event.type_of_event) {
            case all_stocks:
                for (unsigned int i = 0; i < stocks_list.size(); i++) {
                    stocks_list[i].add_event(event);
                }
                break;
            case category:
                for (unsigned int i = 0; i < stocks_list.size(); i++) {
                    if (stocks_list[i].get_category() == event.category) {
                        stocks_list[i].add_event(event);
                    }
                }
                break;
            case pick_random_stock: {
                std::vector<unsigned int> stocks_indices_not_suitable = {};
                while (!stocks_list.empty() &&
                       stocks_list.size() < stocks_indices_not_suitable.size()) {
                    // Pick a random stock
                    unsigned int choice = random_integer(stocks_list.size());
                    Stock lucky_stock = stocks_list[choice];
                    if (!lucky_stock.can_add_event(event)) {
                        stocks_indices_not_suitable.emplace_back(choice);
                    }
                    else {
                        Stock_event modified_event = event;
                        modified_event.text = lucky_stock.get_name() + " " + event.text;
                        lucky_stock.add_event(modified_event);
                        break;
                    }
                }
                break;
            }
            default:
                // Should not reach here, but if it does, break the loop
                // so that the player can continue playing the game.
                break;
        }
    }
}

References Stock::add_event(), all_stock_events, all_stocks, Stock::can_add_event(), category, Stock::get_name(), get_ongoing_events(), pick_events(), pick_random_stock, random_integer(), rounds_played, and Stock_event::text.

Referenced by next_round_routine().

Here is the call graph for this function:

Here is the caller graph for this function:

next_round_routine()

void next_round_routine	(	unsigned int &	_rounds,
		std::vector< Stock > &	stocks_list )

Definition at line 281 of file main.cpp.

                                                                                {
    _rounds++; // Increment the round number
    new_events_next_round(
        stocks_list); // Generate new events and apply them to the stocks
    for (unsigned int i = 0; i < stocks_list.size(); i++) {
        stocks_list[i].next_round(); // Update the stock price
    }
}

References new_events_next_round().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_table()

void print_table	(	std::vector< Stock >	stocks_list,
		float	_playerBal,
		mode	m = dev )

Print the table of stocks.

We put it in a function so we can call it multiple times.

Parameters

stocks_list	A vector of stocks. The stocks to be printed.
_playerBal	How much money the player has.
m	mode to hide mean/sd/uplim/lowlim/event_id columns in the table

Definition at line 111 of file main.cpp.

                                                                               {
    std::vector<std::string> defaultColumns = {
        "#", "Category", "Name", "$Price", "Change", R"(%Change)", "#Has", "#Max"};
    VariadicTable<unsigned int, std::string, std::string, float, float, float,
        unsigned int, unsigned int>
        defaultTable(defaultColumns);
    if (m == dev) {
        defaultColumns.emplace_back(" Mean ");
        defaultColumns.emplace_back(" SD ");
        defaultColumns.emplace_back(" up ");
        defaultColumns.emplace_back(" low ");
        defaultColumns.emplace_back("event_id");
        // Create a table, note that R"(% Change)" is a raw string literal (C++11
        // feature).
        VariadicTable<unsigned int, std::string, std::string, float, float, float,
            unsigned int, unsigned int, float, float, float, float, std::string>
            devTable({defaultColumns});
        /* Set the precision and format of the columns.
         * Note: Precision and Format is ignored for std::string columns. */
        devTable.setColumnPrecision({0, 0, 0, 2, 2, 2, 0, 0, 1, 0, 0, 0, 0});
        devTable.setColumnFormat({VariadicTableColumnFormat::AUTO,
            VariadicTableColumnFormat::AUTO, VariadicTableColumnFormat::AUTO,
            VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::FIXED,
            VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::FIXED,
            VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::FIXED,
            VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::FIXED,
            VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::AUTO});
        for (unsigned int i = 0; i < stocks_list.size(); i++) {
            std::map<stock_modifiers, float> modifiers =
                getProcessedModifiers(stocks_list[i]);
            devTable.addRow(i + 1, stocks_list[i].category_name(),
                stocks_list[i].get_name(), stocks_list[i].get_price(),
                stocks_list[i].delta_price(),
                stocks_list[i].delta_price_percentage() * 100,
                stocks_list[i].get_quantity(),
                stocks_list[i].num_stocks_affordable(_playerBal, trading_fees_percent),
                modifiers[mean], modifiers[standard_deviation], modifiers[upper_limit],
                modifiers[lower_limit], vectorToString(stocks_list[i].get_event_ids()));
        }
        devTable.print(std::cout);
    }
    else {
        /* Set the precision and format of the columns.
         * Note: Precision and Format is ignored for std::string columns. */
        defaultTable.setColumnPrecision({0, 0, 0, 2, 2, 2, 0, 0});
        defaultTable.setColumnFormat(
            {VariadicTableColumnFormat::AUTO, VariadicTableColumnFormat::AUTO,
                VariadicTableColumnFormat::AUTO, VariadicTableColumnFormat::FIXED,
                VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::FIXED,
                VariadicTableColumnFormat::FIXED, VariadicTableColumnFormat::FIXED});
        for (unsigned int i = 0; i < stocks_list.size(); i++) {
            defaultTable.addRow(i + 1, stocks_list[i].category_name(),
                stocks_list[i].get_name(), stocks_list[i].get_price(),
                stocks_list[i].delta_price(),
                stocks_list[i].delta_price_percentage() * 100,
                stocks_list[i].get_quantity(),
                stocks_list[i].num_stocks_affordable(_playerBal, trading_fees_percent));
        }
        defaultTable.print(std::cout);
    }
    // Modify the stringstream so that for the column "Change", the text
    // "Increase" is green and "Decrease" is red.
    // @note This is a workaround because VariadicTable does not support
    // modifying the text color of a specific cell.
    // Warning: This is a hack and may not work in the future!
    for (unsigned int i = 0; i < stocks_list.size(); i++) {
        std::string index = std::to_string(i + 1);
        if (i < 10 - 1) {
            index = " " + index;
        }
        if (stocks_list[i].delta_price() > 0) {
            std::cout << setCursorPosition(i + 9, 3) << textGreen << index;
        }
        else if (stocks_list[i].delta_price() < 0) {
            std::cout << setCursorPosition(i + 9, 3) << textRed << index;
        }
    }
    std::cout << textWhite;
    /* Display 2 decimal places for balance.
     * This line reverts the precision back to default after the table is printed.
     * Since the table uses std::auto (VariadicTableColumnFormat::AUTO), we need to
     * revert it back to default.
     */
    std::cout << std::fixed << std::setprecision(2);
}

References dev, getProcessedModifiers(), lower_limit, mean, setCursorPosition(), standard_deviation, textGreen, textRed, textWhite, trading_fees_percent, upper_limit, and vectorToString().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

vectorToString()

std::string vectorToString

(

const std::vector< unsigned int > &

vec

)

Definition at line 75 of file main.cpp.

                                                              {
    return std::accumulate(
        vec.begin(), vec.end(), std::string(), [](const std::string & s, int v) {
            return s.empty() ? std::to_string(v) : s + " " + std::to_string(v);
        });
}

Referenced by print_table().

Here is the caller graph for this function:

Variable Documentation

balance

float balance = 1000.0f

Player's balance.

Definition at line 68 of file main.cpp.

Referenced by buyStocks(), drawRoundInfo(), initializePlayerSaves(), loadstatus(), main(), Stock::num_stocks_affordable(), optionsInput(), Stock::purchase(), savestatus(), Stock::sell(), and sellStocks().

playerName

std::string playerName

Player's name.

Definition at line 73 of file main.cpp.

Referenced by createplayer(), get_hsi(), initializePlayerSaves(), Stock::load(), load_hsi(), loadstatus(), main(), Stock::save(), and savestatus().

rounds_played

unsigned int rounds_played = 1

Number of rounds played.

Definition at line 70 of file main.cpp.

Referenced by initializePlayerSaves(), loadstatus(), main(), new_events_next_round(), and savestatus().

trading_fees_percent

const float trading_fees_percent = 0.1 / 100

/ 100 means charging % more/portion of the money involved in stock operations.

Definition at line 65 of file main.cpp.

Referenced by Stock::calculateStockValue(), Stock::calculateTradingFeesLost(), main(), Stock::num_stocks_affordable(), print_table(), Stock::purchase(), and Stock::sell().