#include "precompiled.h"

const char *CCSTutor::m_TutorIdentifierList[] =
{
	"YOU_FIRED_A_SHOT",
	"YOU_SHOULD_RELOAD",
	"YOU_ARE_OUT_OF_AMMO",
	"YOU_KILLED_A_TEAMMATE",
	"YOU_KILLED_PLAYER",
	"YOU_KILLED_PLAYER_ONE_LEFT",
	"YOU_KILLED_LAST_ENEMY",
	"YOU_KILLED_PLAYER_HEADSHOT",
	"YOU_KILLED_PLAYER_HEADSHOT_ONE_LEFT",
	"YOU_KILLED_LAST_ENEMY_HEADSHOT",
	"YOU_DIED",
	"YOU_DIED_HEADSHOT",
	"YOU_FELL_TO_YOUR_DEATH",
	"YOU_WERE_JUST_HURT",
	"YOU_ARE_BLIND_FROM_FLASHBANG",
	"YOU_ATTACKED_TEAMMATE",
	"BUY_TIME_BEGIN",
	"BOMB_PLANTED_T",
	"BOMB_PLANTED_CT",
	"TEAMMATE_KILLED",
	"TEAMMATE_KILLED_ONE_LEFT",
	"LAST_TEAMMATE_KILLED",
	"ENEMY_KILLED",
	"ENEMY_KILLED_ONE_LEFT",
	"LAST_ENEMY_KILLED",
	"YOU_SPAWNED",
	"YOU_SEE_FRIEND",
	"YOU_SEE_ENEMY",
	"YOU_SEE_FRIEND_CORPSE",
	"YOU_SEE_ENEMY_CORPSE",
	"YOU_SEE_LOOSE_BOMB_T",
	"YOU_SEE_LOOSE_BOMB_CT",
	"YOU_SEE_BOMB_CARRIER_T",
	"YOU_SEE_BOMB_CARRIER_CT",
	"YOU_SEE_PLANTED_BOMB_T",
	"YOU_SEE_PLANTED_BOMB_CT",
	"YOU_ARE_BOMB_CARRIER",
	"YOU_SEE_LOOSE_WEAPON",
	"YOU_SEE_LOOSE_DEFUSER",
	"YOU_SEE_BOMBSITE_T",
	"YOU_SEE_BOMBSITE_CT",
	"YOU_SEE_BOMBSITE_T_BOMB",
	"YOU_SEE_HOSTAGE_T",
	"YOU_SEE_HOSTAGE_CT",
	"YOU_SEE_HOSTAGE_CT_EXAMINE",
	"YOU_USED_HOSTAGE_MORE_LEFT",
	"YOU_USED_HOSTAGE_NO_MORE_LEFT",
	"ALL_HOSTAGES_FOLLOWING_T",
	"ALL_HOSTAGES_FOLLOWING_CT",
	"HOSTAGE_RESCUED_T",
	"HOSTAGE_RESCUED_CT",
	"YOU_RESCUED_HOSTAGE",
	"YOU_ARE_IN_BOMBSITE_T",
	"YOU_ARE_IN_BOMBSITE_CT",
	"YOU_ARE_IN_BOMBSITE_T_BOMB",
	"ALL_HOSTAGES_RESCUED_T",
	"ALL_HOSTAGES_RESCUED_CT",
	"YOU_DAMAGED_HOSTAGE",
	"YOU_KILLED_HOSTAGE",
	"ALL_HOSTAGES_DEAD",
	"YOU_HAVE_BEEN_SHOT_AT",
	"TIME_RUNNING_OUT_DE_T",
	"TIME_RUNNING_OUT_DE_CT",
	"TIME_RUNNING_OUT_CS_T",
	"TIME_RUNNING_OUT_CS_CT",
	"DEFUSING_WITHOUT_KIT",
	"BOMB_DEFUSED_T",
	"BOMB_DEFUSED_CT",
	"YOU_DEFUSED_BOMB",
	"BOMB_EXPLODED_T",
	"BOMB_EXPLODED_CT",
	"ROUND_START_DE_T",
	"ROUND_START_DE_CT",
	"ROUND_START_CS_T",
	"ROUND_START_CS_CT",
	"ROUND_OVER",
	"ROUND_DRAW",
	"CT_WIN",
	"T_WIN",
	"DEATH_CAMERA_START",
	"RADIO_COVER_ME",
	"RADIO_YOU_TAKE_THE_POINT",
	"RADIO_HOLD_THIS_POSITION",
	"RADIO_REGROUP_TEAM",
	"RADIO_FOLLOW_ME",
	"RADIO_TAKING_FIRE",
	"RADIO_GO_GO_GO",
	"RADIO_TEAM_FALL_BACK",
	"RADIO_STICK_TOGETHER_TEAM",
	"RADIO_GET_IN_POSITION_AND_WAIT",
	"RADIO_STORM_THE_FRONT",
	"RADIO_REPORT_IN_TEAM",
	"RADIO_AFFIRMATIVE",
	"RADIO_ENEMY_SPOTTED",
	"RADIO_NEED_BACKUP",
	"RADIO_SECTOR_CLEAR",
	"RADIO_IN_POSITION",
	"RADIO_REPORTING_IN",
	"RADIO_GET_OUT_OF_THERE",
	"RADIO_NEGATIVE",
	"RADIO_ENEMY_DOWN",
	"BUY_NEED_PRIMARY",
	"BUY_NEED_PRIMARY_AMMO",
	"BUY_NEED_SECONDARY_AMMO",
	"BUY_NEED_ARMOR",
	"BUY_NEED_DEFUSE_KIT",
	"BUY_NEED_GRENADE",
	"CAREER_TASK_DONE_MORE_LEFT",
	"CAREER_TASK_DONE_ONE_LEFT",
	"CAREER_TASK_DONE_ALL_DONE",
	"HINT_BEGIN",
	"HINT_1",
	"HINT_2",
	"HINT_3",
	"HINT_4",
	"HINT_5",
	"HINT_10",
	"HINT_11",
	"HINT_12",
	"HINT_13",
	"HINT_14",
	"HINT_15",
	"HINT_20",
	"HINT_21",
	"HINT_22",
	"HINT_23",
	"HINT_24",
	"HINT_25",
	"HINT_26",
	"HINT_30",
	"HINT_31",
	"HINT_32",
	"HINT_33",
	"HINT_34",
	"HINT_40",
	"HINT_50",
	"HINT_51",
	"HINT_52",
	"HINT_53",
	"HINT_60",
	"HINT_61",
	"HINT_70",
	"HINT_71",
	"HINT_72",
	"HINT_73",
	"HINT_END",
	"INGAME_HINT_BEGIN",
	"INGAME_HINT_1",
	"INGAME_HINT_2",
	"INGAME_HINT_3"
};

CCSTutor::CCSTutor()
{
	m_stateSystem = new CCSTutorStateSystem;

	m_nextViewableCheckTime = 0;
	m_currentlyShownMessageID = TUTOR_NUM_MESSAGES;
	m_currentMessageEvent = nullptr;
	m_messageTypeMask = TUTORMESSAGETYPE_ALL;
	m_lastScenarioEvent = nullptr;
	m_haveSpawned = false;
	m_lastHintShown = HINT_BEGIN;
	m_lastInGameHintShown = INGAME_HINT_BEGIN;

	ReadTutorMessageFile();
	ApplyPersistentDecay();
	ResetPlayerDeathInfo();
}

CCSTutor::~CCSTutor()
{
	if (m_stateSystem)
	{
		delete m_stateSystem;
		m_stateSystem = nullptr;
	}

	if (m_currentMessageEvent)
	{
		DeleteEvent(m_currentMessageEvent);
		m_currentMessageEvent = nullptr;
	}

	if (m_lastScenarioEvent)
	{
		DeleteEvent(m_lastScenarioEvent);
		m_lastScenarioEvent = nullptr;
	}

	ClearCurrentEvent();
	ClearEventList();
}

void ParseMessageParameters(char *&messageData, TutorMessage *ret)
{
	char *token;

	while (true)
	{
		messageData = SharedParse((char *)messageData);
		token = SharedGetToken();

		if (!messageData || !Q_stricmp(token, "End"))
		{
			break;
		}

		if (!Q_stricmp(token, "String"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_text = Q_strdup(SharedGetToken());
		}
		else if (!Q_stricmp(token, "Duration"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_duration = Q_atoi(SharedGetToken());
		}
		else if (!Q_stricmp(token, "Priority"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_priority = Q_atoi(SharedGetToken());
		}
		else if (!Q_stricmp(token, "KeepOld"))
		{
			messageData = SharedParse((char *)messageData);
			token = SharedGetToken();

			if (!Q_stricmp(token, "true"))
			{
				ret->m_keepOld = TUTORMESSAGEKEEPOLDTYPE_KEEP_OLD;
			}
			else if (!Q_stricmp(token, "updatecontent"))
			{
				ret->m_keepOld = TUTORMESSAGEKEEPOLDTYPE_UPDATE_CONTENT;
			}
			else
			{
				ret->m_keepOld = TUTORMESSAGEKEEPOLDTYPE_DONT_KEEP_OLD;
			}
		}
		else if (!Q_stricmp(token, "Class"))
		{
			messageData = SharedParse((char *)messageData);

			if (!Q_stricmp(SharedGetToken(), "Examine"))
			{
				ret->m_class = TUTORMESSAGECLASS_EXAMINE;
			}
			else
			{
				ret->m_class = TUTORMESSAGECLASS_NORMAL;
			}
		}
		else if (!Q_stricmp(token, "Decay"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_decay = Q_atoi(SharedGetToken());
		}
		else if (!Q_stricmp(token, "Type"))
		{
			messageData = SharedParse((char *)messageData);
			token = SharedGetToken();

			if (!Q_stricmp(token, "FriendDeath"))
			{
				ret->m_type = TUTORMESSAGETYPE_FRIEND_DEATH;
			}
			else if (!Q_stricmp(token, "EnemyDeath"))
			{
				ret->m_type = TUTORMESSAGETYPE_ENEMY_DEATH;
			}
			else if (!Q_stricmp(token, "Scenario"))
			{
				ret->m_type = TUTORMESSAGETYPE_SCENARIO;
			}
			else if (!Q_stricmp(token, "Buy"))
			{
				ret->m_type = TUTORMESSAGETYPE_BUY;
			}
			else if (!Q_stricmp(token, "Career"))
			{
				ret->m_type = TUTORMESSAGETYPE_CAREER;
			}
			else if (!Q_stricmp(token, "Hint"))
			{
				ret->m_type = TUTORMESSAGETYPE_HINT;
			}
			else if (!Q_stricmp(token, "InGameHint"))
			{
				ret->m_type = TUTORMESSAGETYPE_INGAME_HINT;
			}
			else if (!Q_stricmp(token, "EndGame"))
			{
				ret->m_type = TUTORMESSAGETYPE_END_GAME;
			}
			else
			{
				ret->m_type = TUTORMESSAGETYPE_DEFAULT;
			}
		}
		else if (!Q_stricmp(token, "Lifetime"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_lifetime = Q_atoi(SharedGetToken());
		}
		else if (!Q_stricmp(token, "DuplicateID"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_duplicateID = Q_atoi(SharedGetToken());
		}
		else if (!Q_stricmp(token, "Interrupt"))
		{
			messageData = SharedParse((char *)messageData);

			if (!Q_stricmp(SharedGetToken(), "Now"))
			{
				ret->m_interruptFlag = TUTORMESSAGEINTERRUPTFLAG_NOW_DAMMIT;
			}
			else
			{
				ret->m_interruptFlag = TUTORMESSAGEINTERRUPTFLAG_DEFAULT;
			}
		}
		else if (!Q_stricmp(token, "MinDisplayTimeOverride"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_minDisplayTimeOverride = Q_atof(SharedGetToken());
		}
		else if (!Q_stricmp(token, "MinRepeatInterval"))
		{
			messageData = SharedParse((char *)messageData);
			ret->m_minRepeatInterval = Q_atof(SharedGetToken());
		}
	}
}

TutorMessage *ConstructTutorMessage(char *&messageData, TutorMessage *defaults)
{
	TutorMessage *msg = new TutorMessage;

	msg->m_text = nullptr;
	msg->m_duplicateID = defaults->m_duplicateID;
	msg->m_keepOld = defaults->m_keepOld;
	msg->m_duration = defaults->m_duration;
	msg->m_priority = defaults->m_priority;
	msg->m_class = defaults->m_class;
	msg->m_type = defaults->m_type;
	msg->m_decay = defaults->m_decay;
	msg->m_lifetime = defaults->m_lifetime;
	msg->m_interruptFlag = defaults->m_interruptFlag;
	msg->m_minDisplayTimeOverride = defaults->m_minDisplayTimeOverride;
	msg->m_minRepeatInterval = defaults->m_minRepeatInterval;
	msg->m_examineStartTime = -1.0f;
	msg->m_timesShown = 0;
	msg->m_lastCloseTime = 0;

	ParseMessageParameters(messageData, msg);

	return msg;
}

void ReadDefaultValues(char *&messageData, TutorMessage *defaults)
{
	ParseMessageParameters(messageData, defaults);
}

void CCSTutor::ReadTutorMessageFile()
{
	int messageFileLen = 0;

	char *messageFile;
	char *messageData;
	TutorMessage defaultMessage;

	messageFile = messageData = (char *)LOAD_FILE_FOR_ME("tutordata.txt", &messageFileLen);

	if (!messageFile)
	{
		if (AreRunningCZero())
		{
			CONSOLE_ECHO("Warning: Cannot access tutor message file tutordata.txt\n");
		}

		return;
	}

	defaultMessage.m_duplicateID = 0;
	defaultMessage.m_keepOld = TUTORMESSAGEKEEPOLDTYPE_DONT_KEEP_OLD;
	defaultMessage.m_duration = 1;
	defaultMessage.m_priority = 0;
	defaultMessage.m_class = TUTORMESSAGECLASS_NORMAL;
	defaultMessage.m_type = TUTORMESSAGETYPE_DEFAULT;
	defaultMessage.m_decay = 10;
	defaultMessage.m_lifetime = 10;
	defaultMessage.m_interruptFlag = TUTORMESSAGEINTERRUPTFLAG_DEFAULT;
	defaultMessage.m_minDisplayTimeOverride = 0;
	defaultMessage.m_minRepeatInterval = 0;

	while (true)
	{
		messageData = SharedParse(messageData);
		if (!messageData)
			break;

		char *token = SharedGetToken();
		if (!Q_stricmp(token, "TutorMessage"))
		{
			messageData = SharedParse(messageData);
			token = SharedGetToken();

			std::string identifier = token;
			TutorMessage *tm = ConstructTutorMessage(messageData, &defaultMessage);

			m_messageMap[identifier] = tm;
		}
		else if (!Q_stricmp(token, "Defaults"))
		{
			ReadDefaultValues(messageData, &defaultMessage);
		}
	}

	FREE_FILE(messageFile);
}

void CCSTutor::ApplyPersistentDecay()
{
	for (TutorMessageID mid = YOU_FIRED_A_SHOT; mid < TUTOR_NUM_MESSAGES; mid++)
	{
		TutorMessage *definition = GetTutorMessageDefinition(mid);
		if (definition)
		{
			int timesShown = GET_TIMES_TUTOR_MESSAGE_SHOWN(mid);
			if (timesShown != -1)
			{
				definition->m_timesShown = timesShown;
			}
		}
	}
}

bool CCSTutor::HasCurrentWindowBeenActiveLongEnough(float time)
{
	return (m_currentlyShownMessageID < 0 || m_currentlyShownMessageID >= TUTOR_NUM_MESSAGES || time > m_currentlyShownMessageMinimumCloseTime);
}

bool CCSTutor::ShouldShowMessageEvent(TutorMessageEvent *event, float time)
{
	if (!event)
		return false;

	TutorMessage *message = GetTutorMessageDefinition(event->GetID());
	if (!message)
		return false;

	if (message->m_class == TUTORMESSAGECLASS_NORMAL)
	{
		if (message->m_decay)
		{
			if (message->m_timesShown >= message->m_decay)
				return false;
		}
	}

	if (!(m_messageTypeMask & message->m_type) || (time - message->m_lastCloseTime < message->m_minRepeatInterval))
		return false;

	if (HasCurrentWindowBeenActiveLongEnough(time))
		return true;

	if (message->m_interruptFlag != TUTORMESSAGEINTERRUPTFLAG_NOW_DAMMIT)
		return false;

	TutorMessage *current = GetTutorMessageDefinition(m_currentlyShownMessageID);
	if (!current || (DoMessagesHaveSameID(event->GetID(), m_currentlyShownMessageID) && current->m_keepOld != TUTORMESSAGEKEEPOLDTYPE_DONT_KEEP_OLD))
		return false;

	if (message->m_priority > current->m_priority
		|| message->m_priority == current->m_priority
		|| m_currentMessageEvent->GetTimeActive(time) < event->GetTimeActive(time))
	{
		return true;
	}

	return false;
}

void CCSTutor::CheckForInterruptingMessageEvent(float time)
{
	bool newEvent = false;

	TutorMessageEvent *event = m_eventList;
	TutorMessage *oldMessage = GetTutorMessageDefinition(m_currentlyShownMessageID);
	TutorMessageEvent *oldEvent = m_currentMessageEvent;

	while (event)
	{
		if (ShouldShowMessageEvent(event, time))
		{
			newEvent = true;
			ShowTutorMessage(event);
		}

		event = event->GetNext();
	}

	if (!newEvent)
	{
		return;
	}

	if (oldEvent)
	{
		ProcessShownDeathsForEvent(event);
		DeleteEvent(oldEvent);
	}

	CloseCurrentWindow();
	if (oldMessage)
	{
		oldMessage->m_lastCloseTime = time;
	}

	DeleteEventFromEventList(m_currentMessageEvent);
	ConstructMessageAndDisplay();
}

void CCSTutor::TutorThink(float time)
{
	if (m_nextViewableCheckTime <= time)
	{
		CheckForBombViewable();
		CheckForLooseWeaponViewable();
		CheckForLooseDefuserViewable();
		CheckForTimeRunningOut();
		CheckForBombsiteViewable();
		CheckForHostageViewable();
		CheckExamineMessages(time);
		CheckHintMessages(time);
		CheckInGameHintMessages(time);
		CheckForNeedToReload(true);

		if (m_haveSpawned && CanLocalPlayerBuyStuff())
		{
			m_messageTypeMask = TUTORMESSAGETYPE_BUY;
			CreateAndAddEventToList(BUY_TIME_BEGIN);
			m_haveSpawned = false;
		}

		if (CanLocalPlayerBuyStuff() && m_messageTypeMask == TUTORMESSAGETYPE_BUY)
		{
			CheckBuyZoneMessages();
		}
		else
		{
			if (!CanLocalPlayerBuyStuff() && m_messageTypeMask == TUTORMESSAGETYPE_BUY)
			{
				OnEvent(EVENT_PLAYER_LEFT_BUY_ZONE);
			}
		}

		m_nextViewableCheckTime = cv_tutor_viewable_check_interval.value + time;
	}

	CheckForInactiveEvents(time);
	CheckForWindowClose(time);
	CheckForContentUpdate();
	CheckForInterruptingMessageEvent(time);
}

void CCSTutor::CheckForWindowClose(float time)
{
	if (m_currentlyShownMessageID < 0 || m_currentlyShownMessageID >= TUTOR_NUM_MESSAGES || time <= m_currentlyShownMessageCloseTime)
		return;

	TutorMessageEvent *event = GetTutorMessageUpdateEvent();
	if (!event)
	{
		ClearCurrentEvent();
		return;
	}

	UpdateCurrentMessage(event);
	DeleteEventFromEventList(event);
}

void CCSTutor::CheckForContentUpdate()
{
	if (m_currentlyShownMessageID < 0 || m_currentlyShownMessageID >= TUTOR_NUM_MESSAGES)
		return;

	TutorMessage *definition = GetTutorMessageDefinition(m_currentlyShownMessageID);
	if (!definition || definition->m_keepOld != TUTORMESSAGEKEEPOLDTYPE_UPDATE_CONTENT)
		return;

	TutorMessageEvent *event = GetTutorMessageUpdateEvent();
	if (event)
	{
		UpdateCurrentMessage(event);
		DeleteEventFromEventList(event);
	}
}

void CCSTutor::ClearCurrentEvent(bool closeWindow, bool processDeathsForEvent)
{
	TutorMessage *oldMessage = GetTutorMessageDefinition(m_currentlyShownMessageID);
	if (oldMessage)
	{
		oldMessage->m_lastCloseTime = gpGlobals->time;
	}

	if (processDeathsForEvent)
	{
		ProcessShownDeathsForEvent(m_currentMessageEvent);
	}

	if (closeWindow)
	{
		CloseCurrentWindow();
	}

	m_currentlyShownMessageID = TUTOR_NUM_MESSAGES;
	m_currentlyShownMessageCloseTime = 0;
	m_currentlyShownMessageMinimumCloseTime = 0;

	if (m_currentMessageEvent)
	{
		DeleteEvent(m_currentMessageEvent);
		m_currentMessageEvent = nullptr;
	}
}

void CCSTutor::ProcessShownDeathsForEvent(TutorMessageEvent *event)
{
	if (!event)
		return;

	for (auto& info : m_playerDeathInfo)
	{
		if (info.m_event == event) {
			info.m_hasBeenShown = true;
			info.m_event = nullptr;
		}
	}
}

TutorMessageEvent *CCSTutor::GetTutorMessageUpdateEvent()
{
	TutorMessage *definition = GetTutorMessageDefinition(m_currentlyShownMessageID);
	if (!definition || definition->m_keepOld == TUTORMESSAGEKEEPOLDTYPE_DONT_KEEP_OLD)
		return nullptr;

	for (TutorMessageEvent *event = m_eventList; event; event = event->GetNext())
	{
		if (DoMessagesHaveSameID(event->GetID(), m_currentlyShownMessageID))
		{
			return event;
		}
	}

	return nullptr;
}

bool CCSTutor::GetDuplicateMessagesFromEventList(TutorMessageEvent *&event1, TutorMessageEvent *&event2)
{
	for (event1 = m_eventList; event1; event1 = event1->GetNext())
	{
		for (event2 = event1->GetNext(); event2; event2 = event2->GetNext())
		{
			if (DoMessagesHaveSameID(event1->GetID(), event2->GetID()))
			{
				return true;
			}
		}
	}

	return false;
}

void CCSTutor::CheckForInactiveEvents(float time)
{
	TutorMessageEvent *event = m_eventList;
	while (event)
	{
		if (!event->IsActive(time))
		{
			TutorMessageEvent *temp = event->GetNext();

			DeleteEventFromEventList(event);
			DeleteEvent(event);

			event = temp;
		}
		else
			event = event->GetNext();
	}

	TutorMessageEvent *event1 = nullptr;
	TutorMessageEvent *event2 = nullptr;

	if (GetDuplicateMessagesFromEventList(event1, event2))
	{
		if (event1->GetTimeActive(time) < event2->GetTimeActive(time))
		{
			TransferDeathEvents(event2, event1);
			DeleteEventFromEventList(event2);
			DeleteEvent(event2);
		}
		else
		{
			TransferDeathEvents(event1, event2);
			DeleteEventFromEventList(event1);
			DeleteEvent(event1);
		}
	}
}

void CCSTutor::CancelEvent(TutorMessageID mid)
{
	if (m_currentlyShownMessageID == mid)
		ClearCurrentEvent();

	TutorMessageEvent *event = m_eventList;
	while (event)
	{
		TutorMessageEvent *temp = event->GetNext();

		if (event->GetID() == mid)
		{
			DeleteEventFromEventList(event);
			DeleteEvent(event);
		}

		event = temp;
	}

	if (m_lastScenarioEvent && m_lastScenarioEvent->GetID() == mid)
	{
		DeleteEvent(m_lastScenarioEvent);
		m_lastScenarioEvent = nullptr;
	}
}

NOXREF void CCSTutor::LookupHotKey(TutorMessageID mid, int paramNum, wchar_t *buf, int buflen)
{
#ifdef _WIN32
	_snwprintf(buf, buflen - 1, L"KEY%d", paramNum);
#endif
}

TutorMessageEvent *CCSTutor::CreateTutorMessageEvent(TutorMessageID mid, CBaseEntity *entity, CBaseEntity *other)
{
	char enemyList[2048];
	char teammateList[2048];

	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return nullptr;

	TutorMessage *message = GetTutorMessageDefinition(mid);
	if (!message)
		return nullptr;

	TutorMessageEvent *event = new TutorMessageEvent
	(
		mid,
		message->m_duplicateID,
		gpGlobals->time,
		message->m_lifetime,
		message->m_priority
	);

	switch (mid)
	{
	case YOU_KILLED_PLAYER_ONE_LEFT:
	case YOU_KILLED_LAST_ENEMY:
	case YOU_KILLED_PLAYER_HEADSHOT_ONE_LEFT:
	case YOU_KILLED_LAST_ENEMY_HEADSHOT:
	case ENEMY_KILLED_ONE_LEFT:
	case LAST_ENEMY_KILLED:
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
			ConstructRecentDeathsList(TERRORIST, enemyList, sizeof(enemyList), event);
			event->AddParameter(enemyList);
			break;
		case TERRORIST:
			ConstructRecentDeathsList(CT, teammateList, sizeof(teammateList), event);
			event->AddParameter(teammateList);
			break;
		}
		break;
	}
	case YOU_KILLED_PLAYER:
	case YOU_KILLED_PLAYER_HEADSHOT:
	case ENEMY_KILLED:
	{
		int numT, numCT;
		char numTStr[16], numCTStr[16];

		GetNumPlayersAliveOnTeams(numT, numCT);

		Q_snprintf(numTStr, sizeof(numTStr), "%i", numT);
		Q_snprintf(numCTStr, sizeof(numCTStr), "%i", numCT);

		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
			event->AddParameter(numCTStr);
			ConstructRecentDeathsList(TERRORIST, enemyList, sizeof(enemyList), event);
			event->AddParameter(enemyList);
			break;
		case TERRORIST:
			event->AddParameter(numTStr);
			ConstructRecentDeathsList(CT, teammateList, sizeof(teammateList), event);
			event->AddParameter(teammateList);
			break;
		}
		break;
	}
	case CAREER_TASK_DONE_MORE_LEFT:
	{
		char numLeftStr[16];
		int numtasks = 0;

		if (TheCareerTasks)
		{
			numtasks = TheCareerTasks->GetNumRemainingTasks();
		}
		Q_sprintf(numLeftStr, "%d", numtasks);
		event->AddParameter(numLeftStr);
		break;
	}
	case YOU_KILLED_A_TEAMMATE:
	case TEAMMATE_KILLED_ONE_LEFT:
	case LAST_TEAMMATE_KILLED:
		ConstructRecentDeathsList(pLocalPlayer->m_iTeam, enemyList, sizeof(enemyList), event);
		event->AddParameter(enemyList);
		break;
	case TEAMMATE_KILLED:
	{
		int numT;
		int numCT;

		char numTStr[16];
		char numCTStr[16];

		GetNumPlayersAliveOnTeams(numT, numCT);

		if (pLocalPlayer->IsAlive())
		{
			switch (pLocalPlayer->m_iTeam)
			{
			case CT:        numCT--; break;
			case TERRORIST: numT--;  break;
			}
		}

		Q_snprintf(numTStr, sizeof(numTStr), "%i", numT);
		Q_snprintf(numCTStr, sizeof(numCTStr), "%i", numCT);

		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
			event->AddParameter(numCTStr);
			break;
		case TERRORIST:
			event->AddParameter(numTStr);
			break;
		}

		ConstructRecentDeathsList(pLocalPlayer->m_iTeam, teammateList, sizeof(teammateList), event);
		event->AddParameter(teammateList);
		break;
	}
	}

	return event;
}

void CCSTutor::AddToEventList(TutorMessageEvent *event)
{
	if (event)
	{
		event->SetNext(m_eventList);
		m_eventList = event;
	}
}

void CCSTutor::CreateAndAddEventToList(TutorMessageID mid, CBaseEntity *entity, CBaseEntity *other)
{
	auto event = CreateTutorMessageEvent(mid, entity, other);
	if (event)
	{
		auto message = GetTutorMessageDefinition(mid);
		if (message && message->m_type == TUTORMESSAGETYPE_SCENARIO)
		{
			if (m_lastScenarioEvent)
			{
				DeleteEvent(m_lastScenarioEvent);
				m_lastScenarioEvent = nullptr;
			}

			m_lastScenarioEvent = CreateTutorMessageEvent(mid, entity, other);
		}

		AddToEventList(event);
	}
}

void CCSTutor::DeleteEventFromEventList(TutorMessageEvent *event)
{
	if (!event)
		return;

	TutorMessageEvent *temp = m_eventList;

	if (temp != event)
	{
		if (temp)
		{
			while (event != temp->GetNext())
			{
				temp = temp->GetNext();
				if (!temp)
				{
					return;
				}
			}

			if (temp && temp->GetNext() == event)
			{
				temp->SetNext(temp->GetNext()->GetNext());
			}
		}
	}
	else
	{
		m_eventList = m_eventList->GetNext();
	}
}

void CCSTutor::ClearEventList()
{
	while (m_eventList)
	{
		TutorMessageEvent *temp = m_eventList;
		m_eventList = m_eventList->GetNext();

		DeleteEvent(temp);
	}
}

void CCSTutor::DeleteEvent(TutorMessageEvent *event)
{
	for (auto& info : m_playerDeathInfo)
	{
		if (info.m_event == event) {
			info.m_event = nullptr;
		}
	}

	delete event;
}

void CCSTutor::PurgeMessages()
{
	ClearCurrentEvent();
	ClearEventList();

	if (m_lastScenarioEvent)
	{
		DeleteEvent(m_lastScenarioEvent);
		m_lastScenarioEvent = nullptr;
	}
}

void CCSTutor::ComputeDisplayTimesForMessage()
{
	TutorMessage *message = GetTutorMessageDefinition(m_currentlyShownMessageID);
	if (!message)
	{
		m_currentlyShownMessageCloseTime = gpGlobals->time;
		return;
	}

	m_currentlyShownMessageCloseTime = message->m_duration + gpGlobals->time;
	m_currentlyShownMessageMinimumCloseTime = cv_tutor_message_minimum_display_time.value;

	int stringLength = GET_LOCALIZED_STRING_LENGTH(message->m_text);
	float minShowTime = stringLength * cv_tutor_message_character_display_time_coefficient.value;

	if (minShowTime > m_currentlyShownMessageMinimumCloseTime)
	{
		m_currentlyShownMessageMinimumCloseTime = minShowTime;
	}

	if (message->m_minDisplayTimeOverride <= m_currentlyShownMessageMinimumCloseTime)
	{
		message->m_minDisplayTimeOverride = m_currentlyShownMessageMinimumCloseTime;
	}

	m_currentlyShownMessageMinimumCloseTime = message->m_minDisplayTimeOverride + gpGlobals->time;

	if (m_currentlyShownMessageMinimumCloseTime > m_currentlyShownMessageCloseTime)
	{
		m_currentlyShownMessageCloseTime = m_currentlyShownMessageMinimumCloseTime;
	}
}

NOXREF bool CCSTutor::ShouldUpdateCurrentMessage(TutorMessageID messageID)
{
	if (DoMessagesHaveSameID(messageID, m_currentlyShownMessageID))
	{
		TutorMessage *definition = GetTutorMessageDefinition(messageID);
		if (definition && definition->m_keepOld != TUTORMESSAGEKEEPOLDTYPE_DONT_KEEP_OLD)
		{
			return true;
		}
	}

	return false;
}

void CCSTutor::UpdateCurrentMessage(TutorMessageEvent *event)
{
	TransferDeathEvents(m_currentMessageEvent, event);

	if (m_currentMessageEvent)
	{
		DeleteEvent(m_currentMessageEvent);
		m_currentMessageEvent = nullptr;
	}

	m_currentlyShownMessageID = (TutorMessageID)event->GetID();
	m_currentMessageEvent = event;

	TutorMessage *definition = GetTutorMessageDefinition(event->GetID());
	if (definition)
	{
		CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
		if (pLocalPlayer)
		{
			m_currentlyShownMessageCloseTime = definition->m_duration + gpGlobals->time;

			if (definition->m_keepOld == TUTORMESSAGEKEEPOLDTYPE_UPDATE_CONTENT)
			{
				CloseCurrentWindow();
				DisplayMessageToPlayer(pLocalPlayer, event->GetID(), definition->m_text, event);
			}
		}
	}
}

void CCSTutor::ShowTutorMessage(TutorMessageEvent *event)
{
	TutorMessageID mid = static_cast<TutorMessageID>(event->GetID());
	if (mid < 0 || mid >= TUTOR_NUM_MESSAGES)
		return;

	TutorMessage *message = GetTutorMessageDefinition(mid);
	if (message)
	{
		m_currentlyShownMessageID = mid;
		m_currentMessageEvent = event;

		m_currentlyShownMessageCloseTime = 0;
		m_currentlyShownMessageMinimumCloseTime = 0;
	}
}

void CCSTutor::ConstructMessageAndDisplay()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (pLocalPlayer && !pLocalPlayer->IsBot())
	{
		TutorMessageID mid = static_cast<TutorMessageID>(m_currentMessageEvent->GetID());
		if (mid < 0 || mid >= TUTOR_NUM_MESSAGES)
			return;

		TutorMessage *message = GetTutorMessageDefinition(mid);
		if (message)
		{
			message->m_timesShown++;
			ComputeDisplayTimesForMessage();
			DisplayMessageToPlayer(pLocalPlayer, mid, message->m_text, m_currentMessageEvent);
		}
	}
}

void CCSTutor::CallEventHandler(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
{
	switch (event)
	{
	case EVENT_WEAPON_FIRED:
		HandleWeaponFired(entity, other);
		break;
	case EVENT_WEAPON_FIRED_ON_EMPTY:
		HandleWeaponFiredOnEmpty(entity, other);
		break;
	case EVENT_WEAPON_RELOADED:
		HandleWeaponReloaded(entity, other);
		break;
	case EVENT_BEING_SHOT_AT:
		HandleBeingShotAt(entity, other);
		break;
	case EVENT_PLAYER_BLINDED_BY_FLASHBANG:
		HandlePlayerBlindedByFlashbang(entity, other);
		break;
	case EVENT_PLAYER_DIED:
		HandlePlayerDied(entity, other);
		break;
	case EVENT_PLAYER_TOOK_DAMAGE:
		HandlePlayerTookDamage(entity, other);
		break;
	case EVENT_HOSTAGE_DAMAGED:
		HandleHostageDamaged(entity, other);
		break;
	case EVENT_HOSTAGE_KILLED:
		HandleHostageKilled(entity, other);
		break;
	case EVENT_BOMB_PLANTED:
		HandleBombPlanted(entity, other);
		break;
	case EVENT_BOMB_DEFUSING:
		HandleBombDefusing(entity, other);
		break;
	case EVENT_BOMB_DEFUSED:
		HandleBombDefused(entity, other);
		break;
	case EVENT_BOMB_EXPLODED:
		HandleBombExploded(entity, other);
		break;
	case EVENT_HOSTAGE_USED:
		HandleHostageUsed(entity, other);
		break;
	case EVENT_HOSTAGE_RESCUED:
		HandleHostageRescued(entity, other);
		break;
	case EVENT_ALL_HOSTAGES_RESCUED:
		HandleAllHostagesRescued(entity, other);
		break;
	case EVENT_TERRORISTS_WIN:
		HandleTWin(entity, other);
		break;
	case EVENT_CTS_WIN:
		HandleCTWin(entity, other);
		break;
	case EVENT_ROUND_DRAW:
		HandleRoundDraw(entity, other);
		break;
	case EVENT_ROUND_START:
		HandleRoundStart(entity, other);
		break;
	case EVENT_PLAYER_SPAWNED:
		HandlePlayerSpawned(entity, other);
		break;
	case EVENT_PLAYER_LEFT_BUY_ZONE:
		HandlePlayerLeftBuyZone(entity, other);
		break;
	case EVENT_DEATH_CAMERA_START:
		HandleDeathCameraStart(entity, other);
		break;
	case EVENT_TUTOR_BUY_MENU_OPENNED:
		HandleBuyMenuOpenned(entity, other);
		break;
	case EVENT_TUTOR_AUTOBUY:
		HandleAutoBuy(entity, other);
		break;
	case EVENT_TUTOR_NOT_BUYING_ANYTHING:
		HandleNotBuyingAnything(entity, other);
		break;
	case EVENT_TUTOR_NEED_TO_BUY_PRIMARY_WEAPON:
		HandleNeedToBuyPrimaryWeapon(entity, other);
		break;
	case EVENT_TUTOR_NEED_TO_BUY_PRIMARY_AMMO:
		HandleNeedToBuyPrimaryAmmo(entity, other);
		break;
	case EVENT_TUTOR_NEED_TO_BUY_SECONDARY_AMMO:
		HandleNeedToBuySecondaryAmmo(entity, other);
		break;
	case EVENT_TUTOR_NEED_TO_BUY_ARMOR:
		HandleNeedToBuyArmor(entity, other);
		break;
	case EVENT_TUTOR_NEED_TO_BUY_DEFUSE_KIT:
		HandleNeedToBuyDefuseKit(entity, other);
		break;
	case EVENT_TUTOR_NEED_TO_BUY_GRENADE:
		HandleNeedToBuyGrenade(entity, other);
		break;
	case EVENT_CAREER_TASK_DONE:
		HandleCareerTaskDone(entity, other);
		break;
	case EVENT_RADIO_COVER_ME:
		HandleRadioCoverMe(entity, other);
		break;
	case EVENT_RADIO_YOU_TAKE_THE_POINT:
		HandleRadioYouTakeThePoint(entity, other);
		break;
	case EVENT_RADIO_HOLD_THIS_POSITION:
		HandleRadioHoldThisPosition(entity, other);
		break;
	case EVENT_RADIO_REGROUP_TEAM:
		HandleRadioRegroupTeam(entity, other);
		break;
	case EVENT_RADIO_FOLLOW_ME:
		HandleRadioFollowMe(entity, other);
		break;
	case EVENT_RADIO_TAKING_FIRE:
		HandleRadioTakingFire(entity, other);
		break;
	case EVENT_RADIO_GO_GO_GO:
		HandleRadioGoGoGo(entity, other);
		break;
	case EVENT_RADIO_TEAM_FALL_BACK:
		HandleRadioTeamFallBack(entity, other);
		break;
	case EVENT_RADIO_STICK_TOGETHER_TEAM:
		HandleRadioStickTogetherTeam(entity, other);
		break;
	case EVENT_RADIO_GET_IN_POSITION_AND_WAIT:
		HandleRadioGetInPositionAndWait(entity, other);
		break;
	case EVENT_RADIO_STORM_THE_FRONT:
		HandleRadioStormTheFront(entity, other);
		break;
	case EVENT_RADIO_REPORT_IN_TEAM:
		HandleRadioReportInTeam(entity, other);
		break;
	case EVENT_RADIO_AFFIRMATIVE:
		HandleRadioAffirmative(entity, other);
		break;
	case EVENT_RADIO_ENEMY_SPOTTED:
		HandleRadioEnemySpotted(entity, other);
		break;
	case EVENT_RADIO_NEED_BACKUP:
		HandleRadioNeedBackup(entity, other);
		break;
	case EVENT_RADIO_SECTOR_CLEAR:
		HandleRadioSectorClear(entity, other);
		break;
	case EVENT_RADIO_IN_POSITION:
		HandleRadioInPosition(entity, other);
		break;
	case EVENT_RADIO_REPORTING_IN:
		HandleRadioReportingIn(entity, other);
		break;
	case EVENT_RADIO_GET_OUT_OF_THERE:
		HandleRadioGetOutOfThere(entity, other);
		break;
	case EVENT_RADIO_NEGATIVE:
		HandleRadioNegative(entity, other);
		break;
	case EVENT_RADIO_ENEMY_DOWN:
		HandleRadioEnemyDown(entity, other);
		break;
	default:
		break;
	}
}

void CCSTutor::HandleWeaponFired(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer || !pLocalPlayer->IsAlive())
		return;

	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer == pLocalPlayer)
	{
		CheckForNeedToReload();
	}
}

void CCSTutor::HandleWeaponFiredOnEmpty(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer->IsPlayer() && pPlayer == pLocalPlayer)
	{
		CBasePlayerWeapon *pCurrentWeapon = static_cast<CBasePlayerWeapon *>(pPlayer->m_pActiveItem);
		if (pCurrentWeapon && pPlayer->m_rgAmmo[pCurrentWeapon->m_iPrimaryAmmoType] <= 0)
		{
			TutorMessage *message = GetTutorMessageDefinition(YOU_ARE_OUT_OF_AMMO);
			if (message)
			{
				message->m_lastCloseTime = 0;
			}

			CreateAndAddEventToList(YOU_ARE_OUT_OF_AMMO);
		}
	}
}

void CCSTutor::HandleWeaponReloaded(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer->IsPlayer() && pPlayer == UTIL_GetLocalPlayer())
	{
		CancelEvent(YOU_SHOULD_RELOAD);
	}
}

void CCSTutor::HandlePlayerDied(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pVictim = static_cast<CBasePlayer *>(entity);
	CBasePlayer *pAttacker = static_cast<CBasePlayer *>(other);

	if (pVictim && !pVictim->IsPlayer())
	{
		pVictim = nullptr;
	}

	if (pAttacker && !pAttacker->IsPlayer())
	{
		pAttacker = nullptr;
	}

	if (pVictim == pLocalPlayer && !pAttacker)
	{
		if (pLocalPlayer->m_bKilledByBomb)
		{
			CreateAndAddEventToList(YOU_DIED, entity, other);
		}
		else
		{
			CreateAndAddEventToList(YOU_FELL_TO_YOUR_DEATH);
		}
	}

	if (!pVictim || !pAttacker)
		return;

	if (pVictim == pAttacker && pVictim == pLocalPlayer)
	{
		CreateAndAddEventToList(YOU_DIED, entity, other);
		return;
	}

	int numT, numCT;
	GetNumPlayersAliveOnTeams(numT, numCT);

	if (pAttacker == pLocalPlayer)
	{
		if (pVictim->m_iTeam == pAttacker->m_iTeam)
		{
			CreateAndAddEventToList(YOU_KILLED_A_TEAMMATE, entity, other);
			return;
		}

		if (pVictim->m_bHeadshotKilled)
		{
			switch (pAttacker->m_iTeam)
			{
			case CT:
			{
				switch (numT)
				{
				case 0: CreateAndAddEventToList(YOU_KILLED_LAST_ENEMY_HEADSHOT, entity, other); break;
				case 1: CreateAndAddEventToList(YOU_KILLED_PLAYER_HEADSHOT_ONE_LEFT, entity, other); break;
				default: CreateAndAddEventToList(YOU_KILLED_PLAYER_HEADSHOT, entity, other); break;
				}
				break;
			}
			case TERRORIST:
			{
				switch (numCT)
				{
				case 0: CreateAndAddEventToList(YOU_KILLED_LAST_ENEMY_HEADSHOT, entity, other); break;
				case 1: CreateAndAddEventToList(YOU_KILLED_PLAYER_HEADSHOT_ONE_LEFT, entity, other); break;
				default: CreateAndAddEventToList(YOU_KILLED_PLAYER_HEADSHOT, entity, other); break;
				}
				break;
			}
			}
		}
		else
		{
			switch (pAttacker->m_iTeam)
			{
			case CT:
			{
				switch (numT)
				{
				case 0: CreateAndAddEventToList(YOU_KILLED_LAST_ENEMY, entity, other); break;
				case 1: CreateAndAddEventToList(YOU_KILLED_PLAYER_ONE_LEFT, entity, other); break;
				default: CreateAndAddEventToList(YOU_KILLED_PLAYER, entity, other); break;
				}
				break;
			}
			case TERRORIST:
			{
				switch (numCT)
				{
				case 0: CreateAndAddEventToList(YOU_KILLED_LAST_ENEMY, entity, other); break;
				case 1: CreateAndAddEventToList(YOU_KILLED_PLAYER_ONE_LEFT, entity, other); break;
				default: CreateAndAddEventToList(YOU_KILLED_PLAYER, entity, other); break;
				}
				break;
			}
			}
		}
	}
	else if (pVictim == pLocalPlayer)
	{
		CreateAndAddEventToList(pVictim->m_bHeadshotKilled ? YOU_DIED_HEADSHOT : YOU_DIED, entity, other);
	}
	else if (pVictim->m_iTeam == pLocalPlayer->m_iTeam)
	{
		switch (pVictim->m_iTeam)
		{
		case CT:
		{
			if (pLocalPlayer->IsAlive())
			{
				if (numCT == 1)
				{
					CreateAndAddEventToList(LAST_TEAMMATE_KILLED, entity, other);
				}
				else if (numCT == 2)
				{
					CreateAndAddEventToList(TEAMMATE_KILLED_ONE_LEFT, entity, other);
				}
				else
				{
					CreateAndAddEventToList(TEAMMATE_KILLED, entity, other);
				}
			}
			else
			{
				if (numCT == 1)
				{
					CreateAndAddEventToList(TEAMMATE_KILLED_ONE_LEFT, entity, other);
				}
				else if (numCT > 1)
				{
					CreateAndAddEventToList(TEAMMATE_KILLED, entity, other);
				}
			}
			break;
		}
		case TERRORIST:
		{
			if (pLocalPlayer->IsAlive())
			{
				if (numT == 1)
				{
					CreateAndAddEventToList(LAST_TEAMMATE_KILLED, entity, other);
				}
				else if (numT == 2)
				{
					CreateAndAddEventToList(TEAMMATE_KILLED_ONE_LEFT, entity, other);
				}
				else
				{
					CreateAndAddEventToList(TEAMMATE_KILLED, entity, other);
				}
			}
			else
			{
				if (numT == 1)
				{
					CreateAndAddEventToList(TEAMMATE_KILLED_ONE_LEFT, entity, other);
				}
				else if (numT > 1)
				{
					CreateAndAddEventToList(TEAMMATE_KILLED, entity, other);
				}
			}
			break;
		}
		}
	}
	else
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
		{
			switch (numT)
			{
			case 0: CreateAndAddEventToList(LAST_ENEMY_KILLED, entity, other); break;
			case 1: CreateAndAddEventToList(ENEMY_KILLED_ONE_LEFT, entity, other); break;
			default: CreateAndAddEventToList(ENEMY_KILLED, entity, other); break;
			}
			break;
		}
		case TERRORIST:
		{
			switch (numCT)
			{
			case 0: CreateAndAddEventToList(LAST_ENEMY_KILLED, entity, other); break;
			case 1: CreateAndAddEventToList(ENEMY_KILLED_ONE_LEFT, entity, other); break;
			default: CreateAndAddEventToList(ENEMY_KILLED, entity, other); break;
			}
			break;
		}
		}
	}
}

void CCSTutor::HandlePlayerTookDamage(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pVictim = static_cast<CBasePlayer *>(entity);
	CBasePlayer *pAttacker = static_cast<CBasePlayer *>(other);

	if (pVictim && !pVictim->IsPlayer())
	{
		pVictim = nullptr;
	}

	if (pAttacker && !pAttacker->IsPlayer())
	{
		pAttacker = nullptr;
	}

	if (pVictim && pVictim == pLocalPlayer)
	{
		CreateAndAddEventToList(YOU_WERE_JUST_HURT);
	}
	else if (pAttacker && pVictim && pAttacker == pLocalPlayer && pVictim->m_iTeam == pLocalPlayer->m_iTeam)
	{
		CreateAndAddEventToList(YOU_ATTACKED_TEAMMATE);
	}
}

void CCSTutor::HandlePlayerBlindedByFlashbang(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer->IsPlayer() && pPlayer == pLocalPlayer)
	{
		CreateAndAddEventToList(YOU_ARE_BLIND_FROM_FLASHBANG);
	}
}

void CCSTutor::HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (!pPlayer || !pPlayer->IsPlayer() || pPlayer != UTIL_GetLocalPlayer())
		return;

	m_haveSpawned = true;
	m_lastInGameHintShown = INGAME_HINT_BEGIN;
	CreateAndAddEventToList(YOU_SPAWNED, entity, other);
}

NOXREF void CCSTutor::HandleClientCorpseSpawned(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (!pPlayer || !pPlayer->IsPlayer())
		return;

	ClientCorpseStruct *corpse = new ClientCorpseStruct;

	corpse->m_position = pPlayer->pev->origin;
	corpse->m_team = pPlayer->m_iTeam;

	m_clientCorpseList.push_back(corpse);
}

void CCSTutor::HandleBuyMenuOpenned(CBaseEntity *entity, CBaseEntity *other)
{
	if (m_currentlyShownMessageID == BUY_TIME_BEGIN)
	{
		ClearCurrentEvent();
		CheckBuyZoneMessages();
	}
}

void CCSTutor::HandleAutoBuy(CBaseEntity *entity, CBaseEntity *other)
{
	if (m_currentlyShownMessageID == BUY_TIME_BEGIN)
	{
		ClearCurrentEvent();
	}
}

NOXREF void CCSTutor::HandleBuyTimeStart(CBaseEntity *entity, CBaseEntity *other)
{
	;
}

void CCSTutor::HandlePlayerLeftBuyZone(CBaseEntity *entity, CBaseEntity *other)
{
	m_messageTypeMask = (TUTORMESSAGETYPE_DEFAULT | TUTORMESSAGETYPE_FRIEND_DEATH | TUTORMESSAGETYPE_ENEMY_DEATH | TUTORMESSAGETYPE_SCENARIO | TUTORMESSAGETYPE_CAREER | TUTORMESSAGETYPE_INGAME_HINT | TUTORMESSAGETYPE_END_GAME);

	ClearEventList();
	ClearCurrentEvent();

	if (m_lastScenarioEvent)
	{
		m_lastScenarioEvent->SetActivationTime(gpGlobals->time);
		AddToEventList(m_lastScenarioEvent);
		m_lastScenarioEvent = nullptr;
	}
}

void CCSTutor::HandleBombPlanted(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	if (pLocalPlayer->IsAlive() && pLocalPlayer->m_iTeam == CT)
	{
		CreateAndAddEventToList(BOMB_PLANTED_CT, entity, other);
	}
	else
	{
		CreateAndAddEventToList(BOMB_PLANTED_T, entity, other);
	}
}

void CCSTutor::HandleBombDefused(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pDefuser = static_cast<CBasePlayer *>(entity);
	if (pDefuser && pDefuser->IsPlayer() && pDefuser == pLocalPlayer)
	{
		CreateAndAddEventToList(YOU_DEFUSED_BOMB);
		return;
	}

	switch (pLocalPlayer->m_iTeam)
	{
	case CT:        CreateAndAddEventToList(BOMB_DEFUSED_CT); break;
	case TERRORIST: CreateAndAddEventToList(BOMB_DEFUSED_T); break;
	default:        CreateAndAddEventToList(ROUND_OVER); break;
	}
}

void CCSTutor::HandleBombDefusing(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer->IsPlayer() && pPlayer == pLocalPlayer && !pPlayer->m_bHasDefuser)
	{
		CreateAndAddEventToList(DEFUSING_WITHOUT_KIT);
	}
}

void CCSTutor::HandleBombExploded(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	switch (pLocalPlayer->m_iTeam)
	{
	case CT:        CreateAndAddEventToList(BOMB_EXPLODED_CT); break;
	case TERRORIST: CreateAndAddEventToList(BOMB_EXPLODED_T); break;
	default: break;
	}
}

void CCSTutor::HandleRoundStart(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();

	m_roundStartTime = gpGlobals->time;
	if (!pLocalPlayer)
		return;

	if (IsBombMap())
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
			CreateAndAddEventToList(ROUND_START_DE_CT);
			break;
		case TERRORIST:
		{
			if (pLocalPlayer->m_bHasC4)
				CreateAndAddEventToList(YOU_ARE_BOMB_CARRIER, entity, other);
			else
				CreateAndAddEventToList(ROUND_START_DE_T);
			break;
		}
		}
	}
	else if (IsHostageMap())
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:        CreateAndAddEventToList(ROUND_START_CS_CT); break;
		case TERRORIST: CreateAndAddEventToList(ROUND_START_CS_T); break;
		}
	}
}

void CCSTutor::HandleBeingShotAt(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer->IsPlayer() && pPlayer == pLocalPlayer && pLocalPlayer->IsAlive())
	{
		CreateAndAddEventToList(YOU_HAVE_BEEN_SHOT_AT, entity, other);
	}
}

void CCSTutor::HandleHostageUsed(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pActivator = static_cast<CBasePlayer *>(entity);
	if (pActivator && pActivator->IsPlayer())
	{
		bool unusedHostages = !CheckForAllHostagesFollowingSomeone();
		if (pActivator == pLocalPlayer)
		{
			CreateAndAddEventToList(unusedHostages ? YOU_USED_HOSTAGE_MORE_LEFT : YOU_USED_HOSTAGE_NO_MORE_LEFT);
		}
		else if (!unusedHostages)
		{
			switch (pLocalPlayer->m_iTeam)
			{
			case CT:        CreateAndAddEventToList(ALL_HOSTAGES_FOLLOWING_CT); break;
			case TERRORIST: CreateAndAddEventToList(ALL_HOSTAGES_FOLLOWING_T); break;
			}
		}
	}
}

void CCSTutor::HandleHostageRescued(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pRescuer = static_cast<CBasePlayer *>(entity);
	if (pRescuer && pRescuer->IsPlayer())
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:        CreateAndAddEventToList((pLocalPlayer == pRescuer) ? YOU_RESCUED_HOSTAGE : HOSTAGE_RESCUED_CT); break;
		case TERRORIST: CreateAndAddEventToList(HOSTAGE_RESCUED_T); break;
		}
	}
}

void CCSTutor::HandleAllHostagesRescued(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	switch (pLocalPlayer->m_iTeam)
	{
	case CT:        CreateAndAddEventToList(ALL_HOSTAGES_RESCUED_CT); break;
	case TERRORIST: CreateAndAddEventToList(ALL_HOSTAGES_RESCUED_T); break;
	}
}

void CCSTutor::HandleHostageDamaged(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pAttacker = static_cast<CBasePlayer *>(other);
	if (entity && pAttacker && pAttacker->IsPlayer() && pLocalPlayer == pAttacker)
	{
		CreateAndAddEventToList(YOU_DAMAGED_HOSTAGE);
	}
}

void CCSTutor::HandleHostageKilled(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CheckForAllHostagesDead();

	CBasePlayer *pAttacker = static_cast<CBasePlayer *>(other);
	if (entity && pAttacker && pAttacker->IsPlayer())
	{
		bool unusedHostages = CheckForAllHostagesFollowingSomeone();
		if (pLocalPlayer == pAttacker)
		{
			CreateAndAddEventToList(YOU_KILLED_HOSTAGE);
		}

		if (unusedHostages)
		{
			switch (pLocalPlayer->m_iTeam)
			{
			case CT:        CreateAndAddEventToList(ALL_HOSTAGES_FOLLOWING_CT); break;
			case TERRORIST: CreateAndAddEventToList(ALL_HOSTAGES_FOLLOWING_T); break;
			}
		}
	}
}

void CCSTutor::HandleRoundDraw(CBaseEntity *entity, CBaseEntity *other)
{
	if (CSGameRules()->m_iTotalRoundsPlayed)
	{
		CreateAndAddEventToList(ROUND_DRAW);
	}

	ResetPlayerDeathInfo();
}

void CCSTutor::HandleCTWin(CBaseEntity *entith, CBaseEntity *other)
{
	CreateAndAddEventToList(CT_WIN);
	ResetPlayerDeathInfo();
}

void CCSTutor::HandleTWin(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(T_WIN);
	ResetPlayerDeathInfo();
}

void CCSTutor::HandleDeathCameraStart(CBaseEntity *entity, CBaseEntity *other)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBasePlayer *pPlayer = static_cast<CBasePlayer *>(entity);
	if (pPlayer && pPlayer->IsPlayer() && pPlayer == pLocalPlayer)
	{
		m_messageTypeMask = (TUTORMESSAGETYPE_FRIEND_DEATH | TUTORMESSAGETYPE_ENEMY_DEATH | TUTORMESSAGETYPE_HINT | TUTORMESSAGETYPE_END_GAME);
		CreateAndAddEventToList(DEATH_CAMERA_START);
	}
}

void CCSTutor::HandleRadioCoverMe(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_COVER_ME, entity, other);
}

void CCSTutor::HandleRadioYouTakeThePoint(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_YOU_TAKE_THE_POINT, entity, other);
}

void CCSTutor::HandleRadioHoldThisPosition(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_HOLD_THIS_POSITION, entity, other);
}

void CCSTutor::HandleRadioRegroupTeam(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_REGROUP_TEAM, entity, other);
}

void CCSTutor::HandleRadioFollowMe(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_FOLLOW_ME, entity, other);
}

void CCSTutor::HandleRadioTakingFire(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_TAKING_FIRE, entity, other);
}

void CCSTutor::HandleRadioGoGoGo(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_GO_GO_GO, entity, other);
}

void CCSTutor::HandleRadioTeamFallBack(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_TEAM_FALL_BACK, entity, other);
}

void CCSTutor::HandleRadioStickTogetherTeam(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_STICK_TOGETHER_TEAM, entity, other);
}

void CCSTutor::HandleRadioGetInPositionAndWait(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_GET_IN_POSITION_AND_WAIT, entity, other);
}

void CCSTutor::HandleRadioStormTheFront(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_STORM_THE_FRONT, entity, other);
}

void CCSTutor::HandleRadioReportInTeam(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_REPORT_IN_TEAM, entity, other);
}

void CCSTutor::HandleRadioAffirmative(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_AFFIRMATIVE, entity, other);
}

void CCSTutor::HandleRadioEnemySpotted(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_ENEMY_SPOTTED, entity, other);
}

void CCSTutor::HandleRadioNeedBackup(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_NEED_BACKUP, entity, other);
}

void CCSTutor::HandleRadioSectorClear(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_SECTOR_CLEAR, entity, other);
}

void CCSTutor::HandleRadioInPosition(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_IN_POSITION, entity, other);
}

void CCSTutor::HandleRadioReportingIn(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_REPORTING_IN, entity, other);
}

void CCSTutor::HandleRadioGetOutOfThere(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_GET_OUT_OF_THERE, entity, other);
}

void CCSTutor::HandleRadioNegative(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_NEGATIVE, entity, other);
}

void CCSTutor::HandleRadioEnemyDown(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(RADIO_ENEMY_DOWN, entity, other);
}

void CCSTutor::HandleNotBuyingAnything(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_TIME_BEGIN, entity, other);
}

void CCSTutor::HandleNeedToBuyPrimaryWeapon(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_NEED_PRIMARY, entity, other);
}

void CCSTutor::HandleNeedToBuyPrimaryAmmo(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_NEED_PRIMARY_AMMO, entity, other);
}

void CCSTutor::HandleNeedToBuySecondaryAmmo(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_NEED_SECONDARY_AMMO, entity, other);
}

void CCSTutor::HandleNeedToBuyArmor(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_NEED_ARMOR, entity, other);
}

void CCSTutor::HandleNeedToBuyDefuseKit(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_NEED_DEFUSE_KIT, entity, other);
}

void CCSTutor::HandleNeedToBuyGrenade(CBaseEntity *entity, CBaseEntity *other)
{
	CreateAndAddEventToList(BUY_NEED_GRENADE, entity, other);
}

void CCSTutor::HandleCareerTaskDone(CBaseEntity *entity, CBaseEntity *other)
{
	int numTasksRemaining = 0;

	if (TheCareerTasks && (numTasksRemaining = TheCareerTasks->GetNumRemainingTasks()) > 0)
		CreateAndAddEventToList((numTasksRemaining == 1) ? CAREER_TASK_DONE_ONE_LEFT : CAREER_TASK_DONE_MORE_LEFT);
	else
		CreateAndAddEventToList(CAREER_TASK_DONE_ALL_DONE);
}

void CCSTutor::HandleShotFired(Vector source, Vector target)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	float d1, d, angle, flFiringLineDistanceToPlayer;

	d1 = (source - pLocalPlayer->pev->origin).Length();

	if (d1 > 32.0f)
	{
		d = (target - source).Length();
		angle = d1 / d;

		flFiringLineDistanceToPlayer = Q_sin(Q_acos(angle)) * d1;

		if (flFiringLineDistanceToPlayer <= 3000.0f)
		{
			OnEvent(EVENT_BEING_SHOT_AT, pLocalPlayer);
		}
	}
}

void CCSTutor::GetNumPlayersAliveOnTeams(int &numT, int &numCT)
{
	numT = numCT = 0;

	for (int i = 1; i <= gpGlobals->maxClients; i++)
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);
		if (!pPlayer || !pPlayer->IsAlive())
			continue;

		switch (pPlayer->m_iTeam)
		{
		case CT:        numCT++; break;
		case TERRORIST: numT++;  break;
		}
	}
}

void CCSTutor::CheckForLooseWeaponViewable()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	TutorMessage *message = GetTutorMessageDefinition(YOU_SEE_LOOSE_WEAPON);
	if (message && message->m_class == TUTORMESSAGECLASS_EXAMINE)
		return;

	CBaseEntity *weapon = nullptr;
	while ((weapon = UTIL_FindEntityByClassname(weapon, "weaponbox")))
	{
		if (IsEntityInViewOfPlayer(weapon, pLocalPlayer))
		{
			CreateAndAddEventToList(YOU_SEE_LOOSE_WEAPON);
			break;
		}
	}
}

void CCSTutor::CheckForLooseDefuserViewable()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer || pLocalPlayer->m_iTeam != CT)
		return;

	TutorMessage *message = GetTutorMessageDefinition(YOU_SEE_LOOSE_DEFUSER);
	if (message && message->m_class == TUTORMESSAGECLASS_EXAMINE)
		return;

	CBaseEntity *pDefuser = nullptr;
	while ((pDefuser = UTIL_FindEntityByClassname(pDefuser, "item_thighpack")))
	{
		if (IsEntityInViewOfPlayer(pDefuser, pLocalPlayer))
		{
			CreateAndAddEventToList(YOU_SEE_LOOSE_DEFUSER);
			break;
		}
	}
}

void CCSTutor::CheckForBombViewable()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CGrenade *pBomb = (CGrenade *)UTIL_FindEntityByClassname(nullptr, "grenade");
	if (pBomb && pBomb->m_bIsC4 && IsEntityInViewOfPlayer(pBomb, pLocalPlayer))
	{
		TutorMessageID mid = TUTOR_NUM_MESSAGES;
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
		{
			mid = YOU_SEE_PLANTED_BOMB_CT;
			break;
		}
		case TERRORIST:
		{
			mid = YOU_SEE_PLANTED_BOMB_T;
			break;
		}
		}

		if (mid != TUTOR_NUM_MESSAGES)
		{
			TutorMessage *message = GetTutorMessageDefinition(mid);
			if (!message || message->m_class != TUTORMESSAGECLASS_EXAMINE)
			{
				CreateAndAddEventToList(mid);
			}
		}
	}
	else
	{
		CBasePlayer *pBombCarrier = nullptr;
		for (int i = 1; i <= gpGlobals->maxClients; i++)
		{
			CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);
			if (pPlayer && pPlayer->m_bHasC4)
			{
				pBombCarrier = pPlayer;
				break;
			}
		}

		CBaseEntity *pC4 = UTIL_FindEntityByClassname(nullptr, "weapon_c4");
		if (pC4 && IsEntityInViewOfPlayer(pC4, pLocalPlayer))
		{
			if (pBombCarrier)
			{
				if (pBombCarrier != pLocalPlayer)
				{
					switch (pLocalPlayer->m_iTeam)
					{
					case CT:
					{
						TutorMessage *message = GetTutorMessageDefinition(YOU_SEE_BOMB_CARRIER_CT);
						if (!message || message->m_class != TUTORMESSAGECLASS_EXAMINE)
						{
							CreateAndAddEventToList(YOU_SEE_BOMB_CARRIER_CT);
						}
						break;
					}
					case TERRORIST:
					{
						TutorMessage *message = GetTutorMessageDefinition(YOU_SEE_BOMB_CARRIER_T);
						if (!message || message->m_class != TUTORMESSAGECLASS_EXAMINE)
						{
							CreateAndAddEventToList(YOU_SEE_BOMB_CARRIER_T);
						}
						break;
					}
					}
				}
			}
			else
			{
				TutorMessageID mid = TUTOR_NUM_MESSAGES;
				switch (pLocalPlayer->m_iTeam)
				{
				case CT:
				{
					mid = YOU_SEE_LOOSE_BOMB_CT;
					break;
				}
				case TERRORIST:
				{
					mid = YOU_SEE_LOOSE_BOMB_T;
					break;
				}
				}

				if (mid != TUTOR_NUM_MESSAGES)
				{
					TutorMessage *message = GetTutorMessageDefinition(mid);
					if (!message || message->m_class != TUTORMESSAGECLASS_EXAMINE)
					{
						CreateAndAddEventToList(mid);
					}
				}
			}
		}
	}
}

void CCSTutor::CheckForBombsiteViewable()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	TutorMessageID mid = CheckForInBombZone();
	if (mid != TUTOR_NUM_MESSAGES)
	{
		CreateAndAddEventToList(mid);
		return;
	}

	switch (pLocalPlayer->m_iTeam)
	{
	case CT:
	{
		mid = YOU_SEE_BOMBSITE_CT;
		break;
	}
	case TERRORIST:
	{
		if (pLocalPlayer->m_bHasC4)
		{
			mid = YOU_SEE_BOMBSITE_T_BOMB;
		}
		else if (!TheCSBots() || !TheCSBots()->IsBombPlanted())
		{
			mid = YOU_SEE_BOMBSITE_T;
		}
		break;
	}
	}

	TutorMessage *definition = GetTutorMessageDefinition(mid);
	if (!definition || definition->m_class != TUTORMESSAGECLASS_EXAMINE)
	{
		if (IsBombPlantedInBombZone("func_bomb_target")
			|| IsBombPlantedInBombZone("info_bomb_target"))
		{
			CreateAndAddEventToList(mid);
			return;
		}
	}
}

TutorMessageID CCSTutor::CheckForInBombZone()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (pLocalPlayer && pLocalPlayer->m_iTeam == CT)
	{
		if (IsBombPlantedInBombZone("func_bomb_target")
			|| IsBombPlantedInBombZone("info_bomb_target"))
		{
			return YOU_SEE_PLANTED_BOMB_CT;
		}
	}

	return TUTOR_NUM_MESSAGES;
}

bool CCSTutor::IsBombPlantedInBombsite(CBaseEntity *bombTarget)
{
	CGrenade *pBomb = nullptr;
	while ((pBomb = (CGrenade *)UTIL_FindEntityByClassname(pBomb, "grenade")))
	{
		if (pBomb->m_bIsC4 && IsEntityInBombsite(pBomb, bombTarget))
		{
			return true;
		}
	}

	return false;
}

bool CCSTutor::IsBombPlantedInBombZone(const char *pszBombZone)
{
	CBaseEntity *bombSite = nullptr;
	while ((bombSite = UTIL_FindEntityByClassname(bombSite, pszBombZone)))
	{
		if (IsBombPlantedInBombsite(bombSite))
		{
			return true;
		}
	}

	return false;
}

void CCSTutor::CheckForHostageViewable()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	CBaseEntity *pHostageEntity = nullptr;
	while ((pHostageEntity = UTIL_FindEntityByClassname(pHostageEntity, "hostage_entity")))
	{
		bool bValidHostage = false;
		CHostage *pHostage = static_cast<CHostage *>(pHostageEntity);

		if (pHostage->IsAlive())
		{
			if (!pHostage->IsFollowingSomeone())
			{
				bValidHostage = true;
			}
		}

		if (bValidHostage && IsEntityInViewOfPlayer(pHostage, pLocalPlayer))
		{
			TutorMessageID mid = TUTOR_NUM_MESSAGES;
			switch (pLocalPlayer->m_iTeam)
			{
			case CT:
			{
				mid = YOU_SEE_HOSTAGE_CT;
				break;
			}
			case TERRORIST:
			{
				mid = YOU_SEE_HOSTAGE_T;
				break;
			}
			}

			if (mid != TUTOR_NUM_MESSAGES)
			{
				TutorMessage *message = GetTutorMessageDefinition(mid);
				if (!message || message->m_class != TUTORMESSAGECLASS_EXAMINE)
				{
					CreateAndAddEventToList(mid);
				}
			}

			break;
		}
	}
}

void CCSTutor::CheckForTimeRunningOut()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer || CSGameRules()->IsFreezePeriod() || CSGameRules()->GetRoundRemainingTime() > 30.0f)
		return;

	if (IsBombMap())
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
			CreateAndAddEventToList(TIME_RUNNING_OUT_DE_CT);
			break;
		case TERRORIST:
			CreateAndAddEventToList(TIME_RUNNING_OUT_DE_T);
			break;
		}
	}
	else if (IsHostageMap())
	{
		switch (pLocalPlayer->m_iTeam)
		{
		case CT:
			CreateAndAddEventToList(TIME_RUNNING_OUT_CS_CT);
			break;
		case TERRORIST:
			CreateAndAddEventToList(TIME_RUNNING_OUT_CS_T);
			break;
		}
	}
}

void CCSTutor::CheckForAllHostagesDead()
{
	bool foundLiveOne = false;
	CHostage *pHostage = nullptr;

	while ((pHostage = (CHostage *)UTIL_FindEntityByClassname(pHostage, "hostage_entity")))
	{
		if (pHostage->IsAlive())
		{
			foundLiveOne = true;
			break;
		}
	}

	if (!foundLiveOne)
	{
		CreateAndAddEventToList(ALL_HOSTAGES_DEAD);
	}
}

bool CCSTutor::CheckForAllHostagesFollowingSomeone()
{
	bool foundUnusedOne = false;
	CHostage *pHostage = nullptr;

	while ((pHostage = (CHostage *)UTIL_FindEntityByClassname(pHostage, "hostage_entity")))
	{
		if (pHostage->IsAlive())
		{
			if (!pHostage->IsFollowingSomeone())
			{
				foundUnusedOne = true;
				break;
			}
		}
	}

	return foundUnusedOne ? false : true;
}

TutorMessage *CCSTutor::GetTutorMessageDefinition(int messageID)
{
	if (messageID < 0 || messageID >= TUTOR_NUM_MESSAGES)
		return nullptr;

	TutorMessageMapIter iter = m_messageMap.find(m_TutorIdentifierList[messageID]);
	if (iter != m_messageMap.end())
	{
		return (*iter).second;
	}

	return nullptr;
}

CBaseEntity *CCSTutor::GetEntityForMessageID(int messageID, CBaseEntity *last)
{
	CBaseEntity *pEntity = nullptr;

	switch (messageID)
	{
		case YOU_SEE_FRIEND:
		case YOU_SEE_ENEMY:
			pEntity = UTIL_FindEntityByClassname(last, "player");
			break;
		case YOU_SEE_FRIEND_CORPSE:
		{
			// TODO: this code is noxref
			// this code fucked my brain, in that pointer Vector * is passed through the CBaseEntity *

#if 1
			CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
			if (pLocalPlayer)
			{
				if (m_clientCorpseList.empty())
					return nullptr;

				ClientCorpseStruct *lastCorpse = nullptr;
				ClientCorpseListIter iter;

				if (last)
				{
					iter = m_clientCorpseList.begin();

					while (iter != m_clientCorpseList.end())
					{
						lastCorpse = (*iter);

						if ((CBaseEntity *)lastCorpse == last)
							break;

						iter++;
					}

					while (iter != m_clientCorpseList.end())
					{
						ClientCorpseStruct *corpse = (*iter);

						if (corpse->m_team == pLocalPlayer->m_iTeam)
							return (CBaseEntity *)&corpse->m_position;

						iter++;
					}

					return nullptr;
				}
				else
					return (CBaseEntity *)&m_clientCorpseList.front()->m_position;
			}
#endif
			break;
		}
		case YOU_SEE_LOOSE_BOMB_T:
		case YOU_SEE_LOOSE_BOMB_CT:
		case YOU_SEE_BOMB_CARRIER_T:
		case YOU_SEE_BOMB_CARRIER_CT:
			pEntity = UTIL_FindEntityByClassname(last, "weapon_c4");
			break;
		case YOU_SEE_PLANTED_BOMB_T:
		case YOU_SEE_PLANTED_BOMB_CT:
			pEntity = UTIL_FindEntityByClassname(last, "grenade");
			break;
		case YOU_SEE_LOOSE_WEAPON:
			pEntity = UTIL_FindEntityByClassname(last, "weaponbox");
			break;
		case YOU_SEE_LOOSE_DEFUSER:
			pEntity = UTIL_FindEntityByClassname(last, "item_thighpack");
			break;
		case YOU_SEE_HOSTAGE_T:
		case YOU_SEE_HOSTAGE_CT:
		case YOU_SEE_HOSTAGE_CT_EXAMINE:
			pEntity = UTIL_FindEntityByClassname(last, "hostage_entity");
			break;
	}

	return pEntity;
}

void CCSTutor::CheckHintMessages(float time)
{
	if (m_deadAirStartTime <= 0.0f || (time - m_deadAirStartTime <= cv_tutor_hint_interval_time.value))
		return;

	m_lastHintShown++;

	while (true)
	{
		bool confusingHint = false;
		if (IsHostageMap())
		{
			if (m_lastHintShown >= HINT_BOMB_START && m_lastHintShown <= HINT_BOMB_END)
			{
				confusingHint = true;
			}
		}
		else if (IsBombMap())
		{
			if (m_lastHintShown >= HINT_HOSTAGE_START && m_lastHintShown <= HINT_HOSTAGE_END)
			{
				confusingHint = true;
			}
		}

		if (!confusingHint)
		{
			break;
		}

		m_lastHintShown++;

		if (m_lastHintShown <= HINT_BEGIN || m_lastHintShown >= HINT_END)
		{
			m_lastHintShown = HINT_1;
		}
	}

	if (m_lastHintShown <= HINT_BEGIN || m_lastHintShown >= HINT_END)
	{
		m_lastHintShown = HINT_1;
	}

	TutorMessage *message = GetTutorMessageDefinition(m_lastHintShown);
	if (message)
	{
		CreateAndAddEventToList(m_lastHintShown);
	}
}

void CCSTutor::CheckInGameHintMessages(float time)
{
	if (m_deadAirStartTime <= 0.0f || (time - m_deadAirStartTime <= cv_tutor_hint_interval_time.value))
		return;

	m_lastInGameHintShown++;

	if (m_lastInGameHintShown <= INGAME_HINT_BEGIN || m_lastInGameHintShown >= INGAME_HINT_END)
		return;

	TutorMessage *message = GetTutorMessageDefinition(m_lastInGameHintShown);
	if (message)
	{
		CreateAndAddEventToList(m_lastInGameHintShown);
	}
}

void CCSTutor::CheckForNeedToReload(bool isPassiveCheck)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer || !pLocalPlayer->IsPlayer())
		return;

	CBasePlayerWeapon *pCurrentWeapon = static_cast<CBasePlayerWeapon *>(pLocalPlayer->m_pActiveItem);
	if (!pCurrentWeapon || !pCurrentWeapon->IsWeapon())
		return;

	ItemInfo itemInfo;
	Q_memset(&itemInfo, 0, sizeof(itemInfo));
	pCurrentWeapon->GetItemInfo(&itemInfo);

	if (itemInfo.iSlot && itemInfo.iSlot != 1)
		return;

	if (pLocalPlayer->m_rgAmmo[pCurrentWeapon->m_iPrimaryAmmoType])
	{
		if (isPassiveCheck)
		{
			if ((2 * pCurrentWeapon->m_iClip) < pCurrentWeapon->iMaxClip() && !pCurrentWeapon->m_fInReload)
			{
				CreateAndAddEventToList(YOU_SHOULD_RELOAD);
			}
		}
		else
		{
			if ((5 * pCurrentWeapon->m_iClip) < pCurrentWeapon->iMaxClip() && !pCurrentWeapon->m_fInReload)
			{
				TutorMessage *message = GetTutorMessageDefinition(YOU_SHOULD_RELOAD);
				if (message)
				{
					message->m_lastCloseTime = 0;
				}

				CreateAndAddEventToList(YOU_SHOULD_RELOAD);
			}
			else
			{
				TutorMessage *message = GetTutorMessageDefinition(YOU_SHOULD_RELOAD);
				if (message)
				{
					message->m_lastCloseTime = gpGlobals->time;
				}
			}
		}
	}
	else if (!pCurrentWeapon->m_iClip)
	{
		if (!isPassiveCheck)
		{
			TutorMessage *message = GetTutorMessageDefinition(YOU_ARE_OUT_OF_AMMO);
			if (message)
			{
				message->m_lastCloseTime = 0;
			}
		}

		CreateAndAddEventToList(YOU_ARE_OUT_OF_AMMO);
	}
}

void CCSTutor::CheckExamineMessages(float time)
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer)
		return;

	for (int i = 0; i < TUTOR_NUM_MESSAGES; i++)
	{
		TutorMessage *message = GetTutorMessageDefinition(i);
		if (!message || message->m_class != TUTORMESSAGECLASS_EXAMINE)
			continue;

		CBaseEntity *pEntity = nullptr;
		bool isPlayerLooking = false;

		while ((pEntity = GetEntityForMessageID(i, pEntity)))
		{
			if (i == YOU_SEE_FRIEND_CORPSE || i == YOU_SEE_ENEMY_CORPSE)
			{
				if (IsPlayerLookingAtPosition((Vector *)pEntity, pLocalPlayer))
				{
					isPlayerLooking = true;
					break;
				}
			}
			else if (i == YOU_SEE_HOSTAGE_CT_EXAMINE || i == YOU_SEE_FRIEND || i == YOU_SEE_ENEMY)
			{
				if (IsPlayerLookingAtEntity(pEntity, pLocalPlayer))
				{
					isPlayerLooking = true;
					break;
				}
			}
			else if (IsPlayerLookingAtPosition(&pEntity->pev->origin, pLocalPlayer))
			{
				isPlayerLooking = true;
				break;
			}
		}

		if (isPlayerLooking)
		{
			if (message->m_examineStartTime == -1.0f)
				continue;

			if (time - message->m_examineStartTime <= cv_tutor_examine_time.value)
				continue;

			bool validEntity = false;
			if (i == YOU_SEE_FRIEND)
			{
				CBasePlayer *pPlayer = static_cast<CBasePlayer *>(pEntity);
				if (pPlayer->IsPlayer() && pPlayer->IsAlive() && pPlayer->m_iTeam == pLocalPlayer->m_iTeam)
				{
					validEntity = true;
				}
			}
			else if (i == YOU_SEE_ENEMY)
			{
				CBasePlayer *pPlayer = static_cast<CBasePlayer *>(pEntity);
				if (pPlayer->IsPlayer() && pPlayer->IsAlive() && pPlayer->m_iTeam == pLocalPlayer->m_iTeam)
				{
					if ((pPlayer->m_iTeam != CT || pLocalPlayer->m_iTeam == TERRORIST) && (pPlayer->m_iTeam != TERRORIST || pLocalPlayer->m_iTeam == CT))
					{
						validEntity = true;
					}
				}
			}
			else if (i == YOU_SEE_HOSTAGE_CT_EXAMINE)
			{
				CHostage *pHostage = static_cast<CHostage *>(pEntity);
				if (pEntity->IsAlive())
				{
					if (!pHostage->IsFollowingSomeone())
					{
						validEntity = true;
					}
				}
			}

			if (validEntity)
			{
				CreateAndAddEventToList((TutorMessageID)i, pEntity);
			}
		}
		else
		{
			message->m_examineStartTime = -1.0f;
		}
	}
}

bool CCSTutor::CanLocalPlayerBuyStuff()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (pLocalPlayer)
	{
		return pLocalPlayer->CanPlayerBuy();
	}

	return false;
}

void CCSTutor::CheckBuyZoneMessages()
{
	CBasePlayer *pLocalPlayer = UTIL_GetLocalPlayer();
	if (!pLocalPlayer || m_currentlyShownMessageID == BUY_TIME_BEGIN)
		return;

	CBasePlayerWeapon *pPrimaryWeapon = static_cast<CBasePlayerWeapon *>(pLocalPlayer->m_rgpPlayerItems[PRIMARY_WEAPON_SLOT]);
	CBasePlayerWeapon *pSecondaryWeapon = static_cast<CBasePlayerWeapon *>(pLocalPlayer->m_rgpPlayerItems[PISTOL_SLOT]);

	if (pPrimaryWeapon)
	{
		if (pLocalPlayer->NeedsPrimaryAmmo() && pLocalPlayer->CanAffordPrimaryAmmo())
		{
			TheTutor->OnEvent(EVENT_TUTOR_NEED_TO_BUY_PRIMARY_AMMO);
			return;
		}
	}
	else
	{
		if (pLocalPlayer->CanAffordPrimary())
		{
			TheTutor->OnEvent(EVENT_TUTOR_NEED_TO_BUY_PRIMARY_WEAPON);
			return;
		}
	}

	if (pSecondaryWeapon && pLocalPlayer->NeedsSecondaryAmmo() && pLocalPlayer->CanAffordSecondaryAmmo())
	{
		TheTutor->OnEvent(EVENT_TUTOR_NEED_TO_BUY_SECONDARY_AMMO);
	}
	else if (pLocalPlayer->NeedsArmor() && pLocalPlayer->CanAffordArmor())
	{
		TheTutor->OnEvent(EVENT_TUTOR_NEED_TO_BUY_ARMOR);
	}
	else if (pLocalPlayer->NeedsDefuseKit() && pLocalPlayer->CanAffordDefuseKit())
	{
		TheTutor->OnEvent(EVENT_TUTOR_NEED_TO_BUY_DEFUSE_KIT);
	}
	else if (pLocalPlayer->NeedsGrenade() && pLocalPlayer->CanAffordGrenade())
	{
		TheTutor->OnEvent(EVENT_TUTOR_NEED_TO_BUY_GRENADE);
	}
	else
	{
		TheTutor->OnEvent(EVENT_TUTOR_NOT_BUYING_ANYTHING);
	}
}

bool CCSTutor::IsHostageMap()
{
	return UTIL_FindEntityByClassname(nullptr, "hostage_entity") != nullptr;
}

bool CCSTutor::IsBombMap()
{
	return CSGameRules()->m_bMapHasBombTarget;
}

void CCSTutor::ResetPlayerDeathInfo()
{
	for (auto& playerDeathInfo : m_playerDeathInfo) {
		playerDeathInfo.m_hasBeenShown = false;
		playerDeathInfo.m_event = nullptr;
	}
}

void CCSTutor::ConstructRecentDeathsList(TeamName team, char *buf, int buflen, TutorMessageEvent *event)
{
	if (!buf || !buflen)
		return;

	char scratch[32];
	buf[0] = '\0';

	for (int i = 1; i <= gpGlobals->maxClients; i++)
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);

		if (!pPlayer)
			continue;

		// ignore alive players
		if (pPlayer->IsAlive())
			continue;

		if (pPlayer->m_iTeam != team)
			continue;

		Q_strcat(buf, "  %n");
		Q_sprintf(scratch, "%d\n", i);
		Q_strcat(buf, scratch);

		m_playerDeathInfo[i].m_event = event;
	}
}

void CCSTutor::TransferDeathEvents(TutorMessageEvent *oldEvent, TutorMessageEvent *newEvent)
{
	for (auto& playerDeathInfo : m_playerDeathInfo)
	{
		if (playerDeathInfo.m_event == oldEvent) {
			playerDeathInfo.m_event = newEvent;
		}
	}
}