// PROVIDED BY: M. Scott Leuthaeuser
// CONTACT E-MAIL: michael (dot) leuthaeuser [at] gmail (dot) com
// FILE: ChiSim.cpp
// VERSION: 0.1.0.A
// PURPOSE: Simulate Enveloping Mist uptime under ideal conditions

// DIRECTIVES -----------------------------------------------------------------
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <ctime>
#include <string>
#include <conio.h>
using namespace std;
// ----------------------------------------------------------------------------

// STRUCTURES------------------------------------------------------------------
struct Sim
{
	float time;
	int chiGenerated;
	int chiWasted;
	float downtime;
};
// ----------------------------------------------------------------------------

// GLOBAL CONSTANTS -----------------------------------------------------------
const int G_CHI_PROBABILITY = 35;	// Probability of generating 1 Chi each tick
const int G_ITERATIONS = 100000;	// Number of iterations
const float G_TIME = 300.0;			// Average total sim duration
const float G_VARIANCE = 0.2;		// Variation on total sim duration as a percent of G_TIME
const float G_DURATION = 7.0;		// Enveloping duration in ticks
const float G_REFRESH = 1.0;		// Number of ticks you can fresh early and still get full duration
const int G_CHI_MAX = 4;			// Max Chi pool
const int G_CHI_INIT = 3;			// How much Chi you start with
const int G_CHI_REQ = 3;			// How much Chi Enveloping consumes
// ----------------------------------------------------------------------------

// FUNCTION PROTOTYPES --------------------------------------------------------
Sim simulate(float time);
// ----------------------------------------------------------------------------

// ============================================================================
int main()
{
	Sim total, iteration;

	total.time = 0;
	total.chiGenerated = 0;
	total.chiWasted = 0;
	total.downtime = 0;

	srand(time(0));

	// Simulate
	for(int c = 0; c < G_ITERATIONS; ++c)
	{
		iteration = simulate(G_TIME * (1.0 + 
			(G_VARIANCE*2*((rand()%101)/100.0) - G_VARIANCE)));
			
		total.time += iteration.time;
		total.chiGenerated += iteration.chiGenerated;
		total.chiWasted += iteration.chiWasted;
		total.downtime += iteration.downtime;
	}

	// Output results
	cout << "AVERAGE DOWNTIME: " << total.downtime/G_ITERATIONS << " / " << total.time/G_ITERATIONS << " (" << total.downtime/total.time*100 << "%)" << endl;
	cout << "AVERAGE CHI WASTED: " << (float)total.chiWasted/G_ITERATIONS << " / " << (float)total.chiGenerated/G_ITERATIONS << " (" << (float)total.chiWasted/(float)total.chiGenerated*100 << "%)" << endl;

	// Pause
	cout << endl << "Press any key to continue...";
	cin.sync();
	_getch();

	// Exit
	return 0;
}
// ============================================================================

Sim simulate(float time)
{
	Sim i;
	i.time = 0;
	i.chiGenerated = 0;
	i.chiWasted = 0;
	i.downtime = 0;

	int chi = G_CHI_INIT;
	float remDuration = 0;

	for(i.time; i.time < time; i.time++)
	{
//		cout << "TIME: " << i.time << ", CHI: " << chi << ", DURATION: " << remDuration;
		if(remDuration < G_REFRESH && chi >= G_CHI_REQ)
		{
//			cout << " REFRESH!";
			chi -= G_CHI_REQ;
			remDuration += G_DURATION;
		}
		
		if(remDuration == 0)
		{
//			cout << " DOWNTIME!";
			i.downtime++;
		}
		
		if(rand()%100 < G_CHI_PROBABILITY)
		{
			if(chi == G_CHI_MAX)
			{
//				cout << " CHI WASTED!";
				i.chiWasted++;
			}
			else
			{
//				cout << " CHI GENERATED!";
				chi++;
			}
			i.chiGenerated++;
		}
		
//		cout << endl;
		if(remDuration > 1.0)
			remDuration--;
		else
			remDuration = 0;
	}
	
	return i;
}

Uplift manacost (through Chi):
2*11700 [Jab] - 2*3000*(1+%Crit) [Manatea] = Crit%=20% = 2*11700 - 6000*1.2 = 16200
Uplift manacost (with glyph):
300000*0.06 = 18000