#include <iostream>
#include <vector>
#include <memory>
 
using std::shared_ptr;
using std::make_shared;
 
int const income_interval = 6;
int const start_money = 650;
int const start_income = 50;
//just under 07:00 minutes is usually when the game ends
int const game_time = 400;
 
// multiple of time required to be spent
int const require_spent_multiple = 10;
// initial delay before spending is required
int const require_spent_delay = 30;
 
struct plan {
	//plan acquisition cost
	int cost;
	//resulting increase in revenue
	int increase;
	//timeout before repeat purchase
	int regen;
};
std::vector<plan> plans({
	{ 50, 2, 4 },
	{ 300, 15, 13 },
	{ 1000, 70, 60 },
});
 
struct game_state {
	// how much money we have now
	int money;
	//income on each income interval
	int income;
	//total money we had/have
	int total;
	//money spent on upgrades
	int spent;
	//money invested for income
	int invested;
	//block purchase of the plan for regen time
	std::vector<int> plan_timeout;
	//total elapsed time
	int time;
 
	game_state() {
		money = start_money;
		income = start_income;
		total = money;
		plan_timeout.resize( plans.size(), 0 );
		time = 0;
		spent = 0;
		invested = 0;
	}
 
	void step() {
		time++;
 
		//step plan regen time
		for( auto & pt : plan_timeout ) {
			if( pt > 0 ) {
				pt--;
			}
		}
 
		//add new money each interval
		if( time % income_interval == 0 ) {
			money += income;
			total += income;
		}
	}
 
	bool can_buy_plan(size_t i) {
		return money >= plans[i].cost 
			&& plan_timeout[i] == 0;
	}
 
	void buy_plan(int i) {
		plan_timeout[i] += plans[i].regen;
		invested += plans[i].cost;
		money -= plans[i].cost;
		income += plans[i].increase;
	}
};
 
struct strategy {
	shared_ptr<game_state> state;
	//name of this strategy
	std::string name;
	//stop investing at this time, if -1 then never stop
	int stop_invest_when;
 
	strategy( std::string const & name ) :
		state( new game_state ),
		name(name) {
		stop_invest_when = -1;
	}
	strategy( std::string const & name, shared_ptr<game_state> state ) :
		state( state ),
		name( name ) {
		stop_invest_when = -1;
	}
 
	void step(int spend) {
		//ensure we're spending enough
		if( state->spent < spend ) {
			int a = std::min( spend, state->money );
			state->money -= a;
			state->spent += a;
		}
 
		state->step();
		step_impl();
	}
 
	virtual void step_impl() = 0;
 
	virtual bool should_buy_plan( int i ) {
		if( stop_invest_when >= 0 && state->time >= stop_invest_when ) {
			return false;
		}
		return state->can_buy_plan(i);
	}
};
 
struct buy_all : public strategy {
	buy_all() : strategy( "buy_all" ) { }
 
	void step_impl() {
		for( int i=plans.size()-1; i >=0; --i ) {
			if( should_buy_plan(i) ) {
				state->buy_plan(i);
			}
		}
	}
};
 
struct buy_one_plan : public strategy {
	static std::string plan_name( int i ) {
		char buf[32];
		sprintf( buf, "Plan%d", i );
		return buf;
	}
 
	int plan;
 
	buy_one_plan(int i) : 
		strategy( plan_name(i) ),
		plan(i) {
	}
 
	void step_impl() {
		if( should_buy_plan(plan) ) {
			state->buy_plan(plan);
		}
	}
};
 
struct buy_none : public strategy {
	buy_none() :
		strategy( "none" ) {
	}
 
	void step_impl() {
	}
};
 
typedef std::vector<shared_ptr<strategy>> strategies;
 
/**
	The main simulation driver. It steps through the strategies and outputs
	the results at regular intervals.
*/
void run( std::string const & name, strategies const & all ) {
	std::cout << std::endl;
	std::cout << " - - " << name << " - - " << std::endl;
 
	for( int i=0; i < game_time; ++i ) {
		//must have spent at least this much by this time
		int spend = i * require_spent_multiple;
		if( i < require_spent_delay ) {
			spend = 0;
		}
 
		for( auto & s : all ) {
			s->step(spend);
		}
 
		//write opdate regularly
		if( i % 30 == 0 ) {
			for( auto & s : all ) {
				std::cout << s->name << ": " << s->state->money << "/" << s->state->total << "\t";
			}
			std::cout << std::endl;
		}
	}
 
	std::cout << "Spent/Invested" << std::endl;
	for( auto & s : all ) {
		std::cout << s->name << ": " << (s->state->spent+s->state->money) 
			<< "/" << s->state->invested <<  "\t";
	}
	std::cout << std::endl;
}
 
//build a stopping strategy
shared_ptr<strategy> stop_at( int time, shared_ptr<strategy> st ) {
	st->stop_invest_when = time;
 
	char buf[32];
	sprintf( buf, "Stop@%d", time );
	st->name += buf;
 
	return st;
}
 
int main() {
	run( "Variety", {
		make_shared<buy_none>(),
		make_shared<buy_all>(),
		make_shared<buy_one_plan>(0),
		make_shared<buy_one_plan>(1),
		make_shared<buy_one_plan>(2),
	});
 
	//buy_all appears best, so check when to stop
	run( "Stopping", {
		stop_at( 180, make_shared<buy_all>() ),
		stop_at( 240, make_shared<buy_all>() ),
		stop_at( 300, make_shared<buy_all>() ),
		stop_at( 360, make_shared<buy_all>() ),
	});
 
	//with spending the Plan0/1 appears good
	run( "Stopping Plan0", {
		stop_at( 180, make_shared<buy_one_plan>(1) ),
		stop_at( 240, make_shared<buy_one_plan>(1) ),
		stop_at( 300, make_shared<buy_one_plan>(1) ),
		stop_at( 360, make_shared<buy_one_plan>(1) ),
	});
}
 

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