Jazz Jackrabbit 2 Online

funcdef void TimerVDictionaryFunction(dictionary @);
class TimerV : jjBEHAVIORINTERFACE
{
	TimerV(int time, jjVOIDFUNC @callback)
	{
		@_callback = @callback;
		_start(time);
	}
	TimerV(int time, TimerVDictionaryFunction @callback, dictionary @arguments)
	{
		@_callbackWithArguments = @callback;
		@_arguments = @arguments;
		_start(time);
	}
	bool get_Active() const
	{
		return cast<jjBEHAVIORINTERFACE @>(_object.behavior) is this;
	}
	int get_Elapsed() const
	{
		if (Active)
			return _object.age;
		return -1;
	}
	int get_Total() const
	{
		if (Active)
			return _object.counter;
		return -1;
	}
	int get_Remaining() const
	{
		if (Active)
			return _object.counter - _object.age;
		return -1;
	}
	bool Stop()
	{
		if (Active && _object.age < _object.counter)
		{
			_object.delete();
			return true;
		}
		return false;
	}
	bool Paused = false;

private
	jjVOIDFUNC @_callback = null;
private
	TimerVDictionaryFunction @_callbackWithArguments;
private
	dictionary @_arguments;
private
	jjOBJ @_object;
private
	int _startTime;
private
	void _start(int time)
	{
		if (time > 0)
		{
			@_object = jjObjects[jjAddObject(OBJECT::BEES, -1000, -1000, 0, CREATOR::OBJECT, BEHAVIOR::BEES)];
			_object.behavior = this;
			_object.counter = time;
			_object.age = 0;
			_object.playerHandling = HANDLING::PARTICLE;
			_object.deactivates = false;
			_startTime = jjGameTicks;
		}
		else
		{
			@_object = jjObjects[0]; // avoid null pointer access
			_pickCallback();
		}
	}
private
	void onBehave(jjOBJ @obj)
	{
		if (!Paused && jjGameTicks > _startTime && obj is _object && ++_object.age >= _object.counter)
		{
			_pickCallback();
			_object.delete();
		}
	}
private
	void _pickCallback()
	{
		if (_callback !is null)
			_callback();
		else
			_callbackWithArguments(_arguments);
	}
}

class Key
{
	string id;
	uint code;

	Key(string id, uint code)
	{
		this.id = id;
		this.code = code;
	}
}

jjRNG stvutilRNG = jjRNG();
jjTEXTAPPEARANCE normalTextAppearance = jjTEXTAPPEARANCE(STRING::NORMAL);

array<Key @>
	KEYS = {
		Key("F2", 0x71),			 // 0
		Key("F5", 0x74),			 // 1
		Key("F6", 0x75),			 // 2
		Key("F7", 0x76),			 // 3
		Key("F10", 0x79),			 // 4
		Key("F11", 0x7A),			 // 5
		Key("Insert", 0x2D),		 // 6
		Key("Home", 0x24),			 // 7
		Key("PageUp", 0x21),		 // 8
		Key("Delete", 0x2E),		 // 9
		Key("End", 0x23),			 // 10
		Key("PageDown", 0x22),		 // 11
		Key("Colon", 0xBA),			 // 12
		Key("QuotationMark", 0xDE),	 // 13
		Key("Backspace", 0x08),		 // 14
		Key("Backslash", 0xDC),		 // 15
		Key("Backquote", 0xC0),		 // 16
		Key("BracketLeft", 0xDB),	 // 17
		Key("BracketRight", 0xDD),	 // 18
		Key("Comma", 0xBC),			 // 19
		Key("Minus", 0xBD),			 // 20
		Key("Period", 0xBE),		 // 21
		Key("Slash", 0xBF),			 // 22
		Key("Plus", 0xBB),			 // 23
		Key("Shift", 0x10),			 // 24
		Key("Alt", 0x12),			 // 25
		Key("Control", 0x11),		 // 26
		Key("Tab", 0x09),			 // 27
		Key("Caps Lock", 0x14),		 // 28
		Key("Space", 0x20),			 // 29
		Key("Up", 0x26),			 // 30
		Key("Down", 0x28),			 // 31
		Key("Left", 0x25),			 // 32
		Key("Right", 0x27),			 // 33
		Key("NumpadSlash", 0x6F),	 // 34
		Key("NumpadAsterisk", 0x6A), // 35
		Key("NumpadMinus", 0x6D),	 // 36
		Key("NumpadPlus", 0x6B),	 // 37
		Key("Numpad1", 0x61),		 // 38
		Key("Numpad2", 0x62),		 // 39
		Key("Numpad3", 0x63),		 // 40
		Key("Numpad4", 0x64),		 // 41
		Key("Numpad5", 0x65),		 // 42
		Key("Numpad6", 0x66),		 // 43
		Key("Numpad7", 0x67),		 // 44
		Key("Numpad8", 0x68),		 // 45
		Key("Numpad9", 0x69),		 // 46
		Key("Numpad0", 0x60),		 // 47
		Key("NumpadPeriod", 0x6E),	 // 48
		Key("0", 0x30),				 // 49
		Key("1", 0x31),				 // 50
		Key("2", 0x32),				 // 51
		Key("3", 0x33),				 // 52
		Key("4", 0x34),				 // 53
		Key("5", 0x35),				 // 54
		Key("6", 0x36),				 // 55
		Key("7", 0x37),				 // 56
		Key("8", 0x38),				 // 57
		Key("9", 0x39),				 // 58
		Key("A", 0x41),				 // 59
		Key("B", 0x42),				 // 60
		Key("C", 0x43),				 // 61
		Key("D", 0x44),				 // 62
		Key("E", 0x45),				 // 63
		Key("F", 0x46),				 // 64
		Key("G", 0x47),				 // 65
		Key("H", 0x48),				 // 66
		Key("I", 0x49),				 // 67
		Key("J", 0x4A),				 // 68
		Key("K", 0x4B),				 // 69
		Key("L", 0x4C),				 // 70
		Key("M", 0x4D),				 // 71
		Key("N", 0x4E),				 // 72
		Key("O", 0x4F),				 // 73
		Key("P", 0x50),				 // 74
		Key("Q", 0x51),				 // 75
		Key("R", 0x52),				 // 76
		Key("S", 0x53),				 // 77
		Key("T", 0x54),				 // 78
		Key("U", 0x55),				 // 79
		Key("V", 0x56),				 // 80
		Key("W", 0x57),				 // 81
		Key("X", 0x58),				 // 82
		Key("Y", 0x59),				 // 83
		Key("Z", 0x5A),				 // 84
		Key("Enter", 0x0D),			 // 85
};

class AnimatedSprite
{
	int id;
	float frame;
	int frame_count;
	int x;
	int y;
	double anim_speed;
	bool can_reverse;
	bool reverse = false;
	bool visible = true;
	ANIM::Set animSet = ANIM::AMMO;
	SPRITE::Mode spriteMode = SPRITE::NORMAL;
	int spriteModeParam = 123;
	SPRITE::Direction direction = SPRITE::FLIPNONE;

	AnimatedSprite(int id, int frame, int x, int y, double anim_speed, bool can_reverse)
	{
		this.id = id;
		this.frame = frame;
		this.x = x;
		this.y = y;
		this.anim_speed = anim_speed;
		this.can_reverse = can_reverse;
		this.frame_count = jjAnimations[jjAnimSets[animSet].firstAnim + id].frameCount;
	}

	void setVisible(bool visible)
	{
		this.visible = visible;
	}

	void setAnimSet(ANIM::Set animSet)
	{
		this.animSet = animSet;
		this.frame_count = jjAnimations[jjAnimSets[animSet].firstAnim + id].frameCount;
	}

	void setId(uint id)
	{
		this.id = id;
		this.frame_count = jjAnimations[jjAnimSets[this.animSet].firstAnim + id].frameCount;
	}

	void update()
	{
		if (this.reverse == false)
		{
			this.frame += this.anim_speed;
		}
		else
		{
			this.frame -= this.anim_speed;
		}

		if (this.frame > this.frame_count)
		{
			if (this.can_reverse == true)
			{
				this.reverse = not this.reverse;
			}
			else
			{
				this.frame = 0;
			}
		}

		if (this.frame <= 0)
		{
			if (this.can_reverse == true)
			{
				this.reverse = not this.reverse;
			}
			else
			{
				this.frame = 0;
			}
		}
	}

	void draw(jjCANVAS @canvas)
	{
		if (this.visible)
		{
			canvas.drawSprite(this.x, this.y, this.animSet, this.id, int(this.frame), this.direction, this.spriteMode, this.spriteModeParam);
		}
	}
}

class Vector2
{
	uint x;
	uint y;

	Vector2(int x, int y)
	{
		this.x = x;
		this.y = y;
	}

	float magnitude(Vector2 @otherVector)
	{
		return sqrt((this.x + this.y) - (otherVector.x + otherVector.y));
	}
};

class Box
{
	uint x;
	uint y;
	uint width;
	uint height;

	Box(uint x, uint y, uint width, uint height)
	{
		this.x = x;
		this.y = y;
		this.width = width;
		this.height = height;
	}

	void draw(jjCANVAS @canvas)
	{
		canvas.drawRectangle(this.x, this.y, this.width, this.height, 0, SPRITE::NORMAL, 0);
	}
}

// incomplete
enum RabbitState {
	IDLE,
	WALKING,
	RUNNING,
	JUMPING,
	FALLING,
	DYING,
	DEAD,
	SHOOTING,
	PUSHING,
	HURT
};

class RabbitFur {
	// this isn't RGBA but its instead of using "abcd"
	int r, g, b, a;

	RabbitFur(int r, int g, int b, int a) {
		this.r = r;
		this.g = g;
		this.b = b;
		this.a = a;
	}

	// use SPRITE::PLAYER and spriteParam as the result
	int emulateFur() {
		getFreePlayer().furSet(this.r, this.g, this.b, this.a);

		return getFreePlayer().clientID;
	}
}

class RabbitNPC {
	RabbitState state;
	string name;
	RabbitFur@ fur;

	RabbitNPC(string name, RabbitFur fur) {
		this.name = name;
		@this.fur  = fur;
		this.state = RabbitState::IDLE;
	}
}

jjPLAYER@ getFreePlayer() {
	for (int i = 0; i < 32; i++)
	{
		if (!jjPlayers[i].isActive)
			return jjPlayers[i];
	}

	return jjPlayers[1];
}

uint getStringLength(string str)
{
	string str2 = str;
	uint i = 0;

	while (i < str2.length())
	{
		if (str2[i] == "|"[0])
		{
			str2 = str2.substr(0, i) + str2.substr(i + 1);
		}

		i++;
	}

	return str2.length();
}

uint getStringHeight(string str)
{
	uint height = 0;

	for (uint i = 0; i < str.length(); i++)
	{
		if (str[i] == "@"[0])
		{
			height += 1;
		}
	}

	return height * 20;
}

bool parseBool(string str)
{
	if (str == "true" || str == "1" || str == "yes")
		return true;
	return false;
}

string formatBool(bool b)
{
	if (b)
		return "1";
	return "0";
}

string formatSize(STRING::Size size)
{
	if(size == STRING::SMALL) return "small";
	if(size == STRING::MEDIUM) return "medium";
	return "large";
}

STRING::Size parseSize(string size)
{
	if(size == "small") return STRING::SMALL;
	if(size == "medium") return STRING::MEDIUM;
	return STRING::LARGE;
}

string formatBoolToStringInteger(bool b)
{
	if (b)
		return "1";
	return "0";
}

CHAR::Char parseCharacter(string str)
{
	if (str == "SPAZ")
		return CHAR::SPAZ;
	if (str == "LORI")
		return CHAR::LORI;
	if (str == "BIRD")
		return CHAR::BIRD;
	if (str == "FROG")
		return CHAR::FROG;
	if (str == "BIRD2")
		return CHAR::BIRD2;

	return CHAR::JAZZ;
}

string formatCharacter(CHAR::Char charc)
{
	if (charc == CHAR::SPAZ)
		return "SPAZ";
	if (charc == CHAR::LORI)
		return "LORI";
	if (charc == CHAR::BIRD)
		return "BIRD";
	if (charc == CHAR::FROG)
		return "FROG";
	if (charc == CHAR::BIRD2)
		return "BIRD2";

	return "JAZZ";
}

GEM::Color parseGem(string str)
{
	if (str == "GREEN")
		return GEM::GREEN;
	if (str == "BLUE")
		return GEM::BLUE;
	if (str == "PURPLE")
		return GEM::PURPLE;

	return GEM::RED;
}

string formatGem(GEM::Color g)
{
	if (g == GEM::GREEN)
		return "GREEN";
	if (g == GEM::BLUE)
		return "BLUE";
	if (g == GEM::PURPLE)
		return "PURPLE";

	return "RED";
}

array<string> cloneStringArray(array<string> arr)
{
	array<string> newArray;

	for (uint itemIndex = 0; itemIndex < arr.length; itemIndex++)
	{
		newArray.insertLast(arr[itemIndex]);
	}

	return newArray;
}

int boolToInt(bool b)
{
	if (b)
		return 1;
	else
		return 0;
}

string getPipeColor(int pipeCount)
{
	string color = "white";

	switch (pipeCount)
	{
	case 1:
		color = "green";
		break;
	case 2:
		color = "red";
		break;
	case 3:
		color = "blue";
		break;
	case 4:
		color = "yellow";
		break;
	case 5:
		color = "pink";
		break;
	case 6:
		color = "white";
		break;
	case 7:
		color = "green";
		break;
	case 8:
		color = "cyan";
		break;
	}

	return color;
}

string restartPipePattern(string str)
{
	// fix this
	// w|g|r|b|y|p|w|g|c|(restart from g)
	// white-green-red-blue-yellow-pink-white(ish)-green-cyan(i think)

	int pipeCount = 0;
	string color = "white";

	for (uint i = 0; i < str.length(); i++)
	{
		if (str[i] == "|"[0])
		{
			pipeCount += 1;

			if (pipeCount > 8)
			{
				pipeCount = 1;
			}
		}
	}

	color = getPipeColor(pipeCount);

	while (color != "white")
	{
		str = str + "|";

		pipeCount += 1;

		if (pipeCount > 8)
		{
			pipeCount = 1;
		}
	}

	return str;
}

Key @isAnyKeyDown()
{
	Key @keyThatIsDown;

	for (uint i = 0; i < KEYS.length() - 1; i++)
	{
		Key @key = KEYS[i];

		if (jjKey[key.code])
		{
			@keyThatIsDown = key;
		}
	}

	return keyThatIsDown;
}

bool isKeyDown(Key @key)
{
	return jjKey[key.code];
}

Key @getKeyById(string id)
{
	Key @foundKey;

	for (uint i = 0; i < KEYS.length() - 1; i++)
	{
		Key @key = KEYS[i];

		if (key.id == id)
		{
			@foundKey = key;
			break;
		}
	}

	return foundKey;
}

int getRandomNumber(int min, int max)
{
	int num = stvutilRNG();

	if (num < 0)
		num *= -1;

	num = (num % (max - min + 1)) + min;

	return num;
}

int getPlayerCount()
{
	int count = 0;

	for (int i = 0; i < 32; i++)
	{
		if (jjPlayers[i].isActive)
			count++;
	}

	return count;
}

jjPLAYER @getRandomPlayer()
{
	jjPLAYER @user = jjPlayers[getRandomNumber(0, getPlayerCount())];

	if (user.isActive and !user.isOut)
		return user;
	else
		return getRandomPlayer();
}

funcdef void KeyPressCallback(uint);

array<bool> prevKeys(256, false);
array<KeyPressCallback@> keyPressCallbacks;

void updateKeys()
{
    for (uint keyCode = 0; keyCode < 256; keyCode++)
    {
        if (jjKey[keyCode] && !prevKeys[keyCode])
        {
            for (uint i = 0; i < keyPressCallbacks.length; i++)
            {
                keyPressCallbacks[i](keyCode);
            }
        }

        prevKeys[keyCode] = jjKey[keyCode];
    }
}