Evento Reação

// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ //
// -- Créditos • Khivory -------------------------------------------------------------------------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ //


#include <a_samp>
#include <math>
#include <zcmd>


// ---------------------------------------- //
// -- Defines ----------------------------- //


#define D_REACTION_EVENT 													5000
#define D_REACTION_EVENT_DIFFICULTY											5001

// ----- //

#define COLOR_REACTION_EVENT                                                FF0066
#define MAXIMUM_REWARD_REACTION_EVENT										750
#define INTERVAL_REASON_EVENT												60 /*- Tempo em Segundos -*/

// ----- //

#define RANDOM_NUMBER_REASON_EVENT 											(1 * (InfoReaction[DIFFICULTY_REACTION] + 1) * 25) + random(((InfoReaction[DIFFICULTY_REACTION] + 1) * 250) - (1 * (InfoReaction[DIFFICULTY_REACTION] + 1) * 25))
#define RANDOM_REWARD_REASON_EVENT											(1 * (InfoReaction[DIFFICULTY_REACTION] + 1) * 15) + random(((InfoReaction[DIFFICULTY_REACTION] + 1) * 150) - (1 * (InfoReaction[DIFFICULTY_REACTION] + 1) * 15))


// ---------------------------------------- //
// -- Variáveis --------------------------- //


static 	gStr[128],
		gString[256];

// ----- //

static 	TIMER_REACTION_EVENT;

// ----- //

static 	pNome[MAX_PLAYERS][30];


// ---------------------------------------- //
// -- Enums & Arrays ---------------------- //


enum Enum_InfoReaction {
	CATEGORY_REACTION,
	DIFFICULTY_REACTION,
	ANSWERED_REACTION,
	REWARD_REACTION,
	CODE_REACTION[50],
	RESULT_REACTION[20],
}

// ----- //

static InfoReaction[Enum_InfoReaction];


// -------------------- //
// -------------------- //


enum _:STATES_EVENT {
	STOPPED_EVENT,
	CALCULATIONS_EVENT,
	CHARACTERS_EVENT,
}

// ----- //

enum _:STEPS_EVENT {
	STEP_NEW_CHALLENGE,
	STEP_INTERVAL_CHALLENGE,
}

// ----- //

enum _:DIFFICULTIES_EVENT {
	VERY_EASY,
	EASY,
	MEDIUM,
	HARD,
	VERY_HARD,
}


// -------------------- //
// -------------------- //


static const InfoAlfabeto[1 + ('z' - 'a')] =
	{'a', 'b', ...};

// ----- //

static const InfoNumeros[1 + ('9' - '0')] =
	{'0', '1', ...};

// ----- //

static const InfoOperations[][] =
	{" + ", " - ", " * ", " / "};

// ----- //

static const InfoDifficulties[][] =
	{"Muito Fácil", "Fácil", "Médio", "Difícil", "Muito Difícil"};


main() {
	printf("Script by Khivory");
}


// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// -- Publics --------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

public OnGameModeInit() {
	InfoReaction[DIFFICULTY_REACTION] = MEDIUM;
	return true;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

public OnPlayerConnect(playerid) {
	GetPlayerName(playerid, pNome[playerid], MAX_PLAYER_NAME);
	return true;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

public OnPlayerText(playerid, text[]) {
	switch(InfoReaction[CATEGORY_REACTION]) {
		case CALCULATIONS_EVENT, CHARACTERS_EVENT: {
			if(!InfoReaction[ANSWERED_REACTION]) {
				if(!strcmp(InfoReaction[InfoReaction[CATEGORY_REACTION] == CALCULATIONS_EVENT ? RESULT_REACTION : CODE_REACTION], text, false)) {

					if(InfoReaction[CATEGORY_REACTION] == CALCULATIONS_EVENT)
						format(gString, sizeof(gString), "› {"#COLOR_REACTION_EVENT"}O(A) jogador(a) {FFFFFF}%s{"#COLOR_REACTION_EVENT"} é o(a) vencedor(a) do Evento de Reação ({FFFFFF}%s = %s{"#COLOR_REACTION_EVENT"}).", pName(playerid), InfoReaction[CODE_REACTION], InfoReaction[RESULT_REACTION]);
					else format(gString, sizeof(gString), "› {"#COLOR_REACTION_EVENT"}O(A) jogador(a) {FFFFFF}%s{"#COLOR_REACTION_EVENT"} é o(a) vencedor(a) do Evento de Reação ({FFFFFF}%s{"#COLOR_REACTION_EVENT"}).", pName(playerid), InfoReaction[CODE_REACTION]);

					SendClientMessageToAll(-1, gString);
					GivePlayerMoney(playerid, InfoReaction[REWARD_REACTION]);

					InfoReaction[ANSWERED_REACTION] = 1;
					FunctionsReactionEvent(STEP_INTERVAL_CHALLENGE);
				}
			}
		}
	}
	return false;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[]) {
	switch(dialogid) {
		case D_REACTION_EVENT: {
			if(response) {
				switch(listitem) {
					case 0, 1: /*- Cálculos e Caracteres -*/ {
						if(InfoReaction[CATEGORY_REACTION] == (listitem + 1))
							return SendClientMessage(playerid, -1, "[ x ] Já existe um evento de reação deste tipo em andamento!");

						format(gStr, sizeof(gStr), "›{"#COLOR_REACTION_EVENT"} Evento Reação '{FFFFFF}%s{"#COLOR_REACTION_EVENT"}' iniciado com sucesso!", listitem + 1 == CALCULATIONS_EVENT ? ("Cálculos") : ("Caracteres"));
						SendClientMessage(playerid, -1, gStr);

						InfoReaction[CATEGORY_REACTION] = listitem + 1;
						FunctionsReactionEvent(STEP_NEW_CHALLENGE);
					}

					// ----- //

					case 2: /*- Dificuldade -*/
						return ShowPlayerDialog(playerid, D_REACTION_EVENT_DIFFICULTY, DIALOG_STYLE_LIST, "{FFFFFF}•{"#COLOR_REACTION_EVENT"} Evento Reação - Dificuldade", "{"#COLOR_REACTION_EVENT"}›{FFFFFF} Muito Fácil\n{"#COLOR_REACTION_EVENT"}›{FFFFFF} Fácil\n{"#COLOR_REACTION_EVENT"}›{FFFFFF} Média\t\t{"#COLOR_REACTION_EVENT"}(Padrão)\n{"#COLOR_REACTION_EVENT"}›{FFFFFF} Difícil\n{"#COLOR_REACTION_EVENT"}›{FFFFFF} Muito Difícil", "Alterar", "Voltar");

					// ----- //

					case 3: /*- Parar Evento -*/ {
						if(InfoReaction[CATEGORY_REACTION] == STOPPED_EVENT)
							return SendClientMessage(playerid, -1, "[ x ] Não há nenhum evento de reação em andamento!");

						format(gStr, sizeof(gStr), "›{"#COLOR_REACTION_EVENT"} Evento Reação '{FFFFFF}%s{"#COLOR_REACTION_EVENT"}' parado com sucesso!", InfoReaction[CATEGORY_REACTION] == CALCULATIONS_EVENT ? ("Cálculos") : ("Caracteres"));
		                SendClientMessage(playerid, -1, gStr);

						InfoReaction[CATEGORY_REACTION] = STOPPED_EVENT;
						KillTimer(TIMER_REACTION_EVENT);
					}
				}
			}
		}

		// ----- //

		case D_REACTION_EVENT_DIFFICULTY: {
			if(response) {
				format(gStr, sizeof(gStr), "›{"#COLOR_REACTION_EVENT"} Você alterou a dificuldade do Evento de Reação de {FFFFFF}%s{"#COLOR_REACTION_EVENT"} para {FFFFFF}%s{"#COLOR_REACTION_EVENT"}.", InfoDifficulties[InfoReaction[DIFFICULTY_REACTION]], InfoDifficulties[listitem]);
				SendClientMessage(playerid, -1, gStr);

				InfoReaction[DIFFICULTY_REACTION] = listitem;
                return true;
			}

            format(gString, 200, "Cálculos\t\t%s\nCaracteres\t\t%s\n{"#COLOR_REACTION_EVENT"}› {FFFFFF}Dificuldade\t\t{"#COLOR_REACTION_EVENT"}(%s)\n{"#COLOR_REACTION_EVENT"}›{FFFFFF} Parar Evento", InfoReaction[CATEGORY_REACTION] == CALCULATIONS_EVENT ? ("{"#COLOR_REACTION_EVENT"}(Atual)") : (""), InfoReaction[CATEGORY_REACTION] == CHARACTERS_EVENT ? ("{"#COLOR_REACTION_EVENT"}(Atual)") : (""), InfoDifficulties[InfoReaction[DIFFICULTY_REACTION]]);
            ShowPlayerDialog(playerid, D_REACTION_EVENT, DIALOG_STYLE_LIST, "{FFFFFF}•{"#COLOR_REACTION_EVENT"} Evento Reação - Painel", gString, "Selecionar", "Sair");
		}
	}
	return true;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// -- Comandos -------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

CMD:ereason(playerid) {
    if(!IsPlayerAdmin(playerid))
        return SendClientMessage(playerid, -1, "[ x ] Você não tem permissão!");

    format(gString, 200, "Cálculos\t\t%s\nCaracteres\t\t%s\n{"#COLOR_REACTION_EVENT"}› {FFFFFF}Dificuldade\t\t{"#COLOR_REACTION_EVENT"}(%s)\n{"#COLOR_REACTION_EVENT"}›{FFFFFF} Parar Evento", InfoReaction[CATEGORY_REACTION] == CALCULATIONS_EVENT ? ("{"#COLOR_REACTION_EVENT"}(Atual)") : (""), InfoReaction[CATEGORY_REACTION] == CHARACTERS_EVENT ? ("{"#COLOR_REACTION_EVENT"}(Atual)") : (""), InfoDifficulties[InfoReaction[DIFFICULTY_REACTION]]);
    ShowPlayerDialog(playerid, D_REACTION_EVENT, DIALOG_STYLE_LIST, "{FFFFFF}•{"#COLOR_REACTION_EVENT"} Evento Reação - Painel", gString, "Selecionar", "Sair");
    return true;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// -- Timers ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

forward FunctionsReactionEvent(STEP);
public FunctionsReactionEvent(STEP) {
	KillTimer(TIMER_REACTION_EVENT);

	switch(STEP) {
		case STEP_NEW_CHALLENGE: {
			InfoReaction[ANSWERED_REACTION] = 0;
			InfoReaction[CODE_REACTION] = EOS;

			switch(InfoReaction[CATEGORY_REACTION]) {
				case CALCULATIONS_EVENT: {
					for(new i; i < (2 + InfoReaction[DIFFICULTY_REACTION]); ++i) {
						format(gStr, 10, "%d%s", RANDOM_NUMBER_REASON_EVENT, i == (2 + InfoReaction[DIFFICULTY_REACTION]) -1 ? "" : InfoOperations[random(sizeof(InfoOperations))]);
						strcat(InfoReaction[CODE_REACTION], gStr);
					}

					if(!IsAnInteger(MathEval(InfoReaction[CODE_REACTION])))
					    format(InfoReaction[RESULT_REACTION], 10, "%.2f", MathEval(InfoReaction[CODE_REACTION]));
					else format(InfoReaction[RESULT_REACTION], 10, "%d", floatround(InfoReaction[CODE_REACTION], floatround_round));
				}

				// ----- //

				case CHARACTERS_EVENT:
					format(InfoReaction[CODE_REACTION], 50, "%s", gRandomString(10 + (InfoReaction[DIFFICULTY_REACTION] * 2)));
			}

			InfoReaction[REWARD_REACTION] = RANDOM_REWARD_REASON_EVENT;

			if(InfoReaction[REWARD_REACTION] > MAXIMUM_REWARD_REACTION_EVENT)
				InfoReaction[REWARD_REACTION] = MAXIMUM_REWARD_REACTION_EVENT;

			format(gStr, sizeof(gStr), "›{"#COLOR_REACTION_EVENT"} O(A) jogador(a) que %s '{FFFFFF}%s{"#COLOR_REACTION_EVENT"}' ganhará {FFFFFF}R$%d{"#COLOR_REACTION_EVENT"}.", InfoReaction[CATEGORY_REACTION] == CALCULATIONS_EVENT ? ("calcular") : ("digitar"), InfoReaction[CODE_REACTION], InfoReaction[REWARD_REACTION]);
			SendClientMessageToAll(-1, gStr);

			TIMER_REACTION_EVENT = SetTimerEx("FunctionsReactionEvent", 25000 / floatround(InfoReaction[DIFFICULTY_REACTION] + 0.5, floatround_round), false, "d", STEP_INTERVAL_CHALLENGE);
			return true;
		}

		// ----- //

		case STEP_INTERVAL_CHALLENGE: {
			TIMER_REACTION_EVENT = SetTimerEx("FunctionsReactionEvent", INTERVAL_REASON_EVENT * 1000, false, "d", STEP_NEW_CHALLENGE);
			return true;
		}
	}
	return true;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// -- Stocks ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

stock pName(playerid)
	return pNome[playerid];

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

stock IsAnInteger(const Float:sFloat) {
	format(gStr, 10, "%2.f", sFloat);
	return strfind(gStr, ".00", true) != -1;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //

stock gRandomString(sSize = 0xff)
{
    static stringBuff[0xff];

	if(sSize < 0xff && sSize) {
	    for(new i; i < sSize; ++i)
	        stringBuff[i] = bool: random(2) ? InfoAlfabeto[random(sizeof(InfoAlfabeto))] : InfoNumeros[random(sizeof(InfoNumeros))];

		stringBuff[sSize] = EOS;
	}
	return stringBuff;
}

// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //