bool Kambot::OnChat(int PlayerID,TextMessageEnum Type,const wchar_t *Message,int recieverID)
{
	Kambot_Commands(PlayerID,Type,Message,recieverID);

	return true;
}

void Kambot_Commands(int PlayerID,TextMessageEnum Type,const wchar_t *Message,int recieverID)
{
	Console_Input("msg functie ok");
	StringClass Msg;
	Msg.Format("msg %s",Message);
	Console_Input(Msg);
	if (wcsstr(Message,L"!") != NULL)
	{
		Console_Input("msg message ok");

void KB_keyhook::KeyHook()
{
	if((The_Game()->Get_Game_Duration_S() - LastPress) >= 1){
		StringClass Msg;
		const wchar_t* message = (const wchar_t*)Get_Parameter("Command");
		Kambot_Commands(Get_Player_ID(Owner()),TEXT_MESSAGE_TEAM,message,-1);
		Msg.Format("msg %s",(const wchar_t*)Get_Parameter("Command"));
		Console_Input(Msg);
		LastPress = The_Game()->Get_Game_Duration_S();
	}
}
ScriptRegistrant<KB_keyhook> KB_keyhook_Registrant("KB_keyhook","Key:string,Command:string");

// Console_Input() taking formatted input
void Console(const char *Format, ...)
{
	char buffer[256];
	va_list va;
	_crt_va_start(va, Format);
	vsnprintf(buffer, 256, Format, va);
	va_end(va);
	Console_Input(buffer);
}

// Call Kambot_Commands() via chat
bool Kambot::OnChat(int PlayerID,TextMessageEnum Type,const wchar_t *Message,int recieverID)
{
	StringClass Msg = Message;
	Kambot_Commands(PlayerID, Type, Msg, recieverID);

	return true;
}

void Kambot_Commands(int PlayerID,TextMessageEnum Type, StringClass Msg,int recieverID)
{
	Console("MSG Debug: Kambot_Commands() called"); // DEBUG CRAP
	Console("MSG Debug: Kambot_Commands() MSG == %s", Msg); // DEBUG CRAP
	if (Msg[0] == '!')
	{
		Console("MSG Debug: Kambot_Commands() Command triggered"); // DEBUG CRAP
	}
}

// Call Kambot_Commands() via a Keyhook (using keys.cfg keys)
void KB_keyhook::KeyHook()
{
	if((The_Game()->Get_Game_Duration_S() - LastPress) >= 1)
	{
		StringClass Msg = Get_Parameter("Command");

		Kambot_Commands(Get_Player_ID(Owner()), TEXT_MESSAGE_TEAM, Msg, -1); // Last parameter isn't used
		Console("MSG Debug: KeyHook() called with %s", Msg); // DEBUG CRAP

		LastPress = The_Game()->Get_Game_Duration_S();
	}
}

#include "Tokenizer.h"

void Tokenizer::Build(const StringClass &Text, int Pos) 
{
	Tokens.Clear();
	VectorSize = 0;
	StringClass Temp2, All;

	StringClass Tokenz = Text;
	char *p = strtok(Tokenz.Peek_Buffer()," ");

	if (!Pos) 
	{
		Tokens.Add(Text);
	}
	else 
	{
		int i = 0;
		while (i < Pos) 
		{
			p = strtok(0, " ");
			++i;
		}
	}
	while (p) 
	{
		Temp2 = p;

		Tokens.Add(Temp2);
		p = strtok(0, " ");
		++VectorSize;

		if (Pos) 
		{
			All += Temp2;
			if (p) All += " ";
		}
	}
	if (Pos) 
	{
		Tokens.Add_Head(All);
	}
}

Tokenizer::Tokenizer(const Tokenizer &Copy) 
{
	Tokens = Copy.Tokens;
	VectorSize = Copy.VectorSize;
}

Tokenizer::Tokenizer() 
{ 
}

Tokenizer::Tokenizer(const StringClass &Text, int Pos) 
{
	Build(Text, Pos);
}

Tokenizer& Tokenizer::operator=(const Tokenizer &Copy)
{
	Tokens = Copy.Tokens;
	VectorSize = Copy.VectorSize;
	return *this;
}

Tokenizer& Tokenizer::operator=(const StringClass &Text) 
{
	Build(Text,0);
	return *this;
}

StringClass Tokenizer::operator[](int Pos) 
{
	if (VectorSize < Pos) 
	{
		return "";
	}
	return Tokens[Pos];
}

StringClass Tokenizer::operator()(int Start,int End) 
{
	if (VectorSize < Start || VectorSize < End) 
	{
		return "";
	}
	StringClass Ret;
	if (!End) {
		End = Tokens.Count();
	}
	int i = Start;

	while (i <= End && i <= VectorSize) 
	{
		Ret += Tokens[i];
		++i;
		if (i <= End) 
			Ret += StringClass(" ");
	}
	return Ret;
}

int Tokenizer::Size() 
{
	return VectorSize;
}

void Tokenizer::Erase(int Pos) 
{
	if (VectorSize < Pos) return;

	Tokens.Delete(Pos);
	VectorSize--;
}

void Tokenizer::Replace(int Pos, const StringClass &Rep) 
{
	if (VectorSize < Pos || !Pos) return;

	Tokens[Pos] = Rep;
}

 /* inline void Tokenizer::Erase_Global(int Pos) 
{
	if (VectorSize < Pos) return;

	StringClass Temp = Tokens[0];
	Temp.Replace(Temp.find(Tokens[Pos]),Tokens[Pos].size()+1,"");
	Tokens[0] = Temp;
	Erase(Pos);
} */

inline void Tokenizer::Add(const StringClass &Text, int Pos) 
{
	if (!Pos) 
	{
		Tokens.Add(Text);
		++VectorSize;
	}
	else if (VectorSize < Pos) 
	{
		return;
	}
	else 
	{
		Tokens.Insert(Pos, Text);
		++VectorSize;
	}
}

#pragma once

#include "gmplugin.h"

// First position in the Tokenizer string contains the full string, so use [1] instead of [0]
// for the first string

class Tokenizer 
{
private:
	DynamicVectorClass<StringClass> Tokens;
	int VectorSize;
	void Build(const StringClass &Text, int Pos);

public:
	Tokenizer();
	Tokenizer(const Tokenizer &Copy);
	Tokenizer(const StringClass &Text, int Pos = 0);
	Tokenizer& operator=(const Tokenizer &Copy);
	Tokenizer& operator=(const StringClass &Text);
	StringClass operator[](int Pos); 
	StringClass operator()(int Start, int End = 0);
	int Size();
	void Erase(int Pos);
	void Replace(int Pos,const StringClass &Rep);
//	void Erase_Global(int Pos);
	void Add(const StringClass &Text, int Pos = 0);
};