Clarify install requirements for linux

Add simple benchmark script

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,20 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe your issue**
+A clear and concise description.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '26 5 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 sam-astro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,6 +1,56 @@
-# Z#, Z-Sharp
-Z-Sharp is a custom programming language I made because I don't like c++ very much (Z-Sharp's interpreter is written in c++ though). It used to be called Slang, standing for "Stupid Lang", but another programmig langauge called Slang already exists :(. Z-Sharp scripts have the file extension .zs. The base syntax and formatting I would say is quite similar to C#, but differs as task complexity increases. It has support for graphics using SDL2, and by default is not enabled. Here is some example code.
-```c#
+<img src="https://raw.githubusercontent.com/sam-astro/Z-Sharp/master/ExtraResources/ZS-Gem-Icon-Small.png"/><img src="https://raw.githubusercontent.com/sam-astro/Z-Sharp/master/ExtraResources/ZS-Logo-Light-Small.png"/>
+
+> Z-Sharp is no longer in development! This project was never meant to go beyond the scope of a simple thing I could make pong in, yet people continue to ask for features and fixes, and I continue to oblige. So sadly, even though this was a cool project in which I learned a lot, it will be ending now. I will eventually make some docs and standards for the syntax, and will still leave this repository open. This way anybody can make their own interpreter or compiler for it. I will also still accept pull requests for any changes to this repository.
+
+## Introduction
+Z-Sharp is a custom programming language I made because I don't like c++ very much (Z-Sharp's interpreter is written in c++ though). Z-Sharp scripts have the file extension .ZS. The base syntax and formatting I would say is quite similar to C# or Python, but differs as task complexity increases. It also has support for graphics using SDL2.
+
+Before using Z#:
+There is ***no documentation***, ***strings*** barely work, ***performance*** isn't great, the syntax is ***very specific***, and most errors just cause it to ***crash without warning***. I am just a *single developer* working on this during my free time; between school, other projects, and YouTube. Z-Sharp will most likely never be finished, since it was really supposed to end when the video was published about it.
+If you are trying to use a common programming language feature, ask yourself this: ***Is this feature required to play pong?*** If not, then most likely that feature ***has not been implemented yet***. I initially only made the language so I could create pong and make a video about it, so it really is the ***bare minimum***.
+
+## Documentation and getting started:
+[The docs and tutorial](https://spazelectro.github.io/ZSharpDocs/#/README)
+
+## Installation
+Downloading or installing is very simple, here is how depending on your version and operating system:
+### Windows
+1. Navigate to [the most recent release](https://github.com/sam-astro/Z-Sharp/releases) and download `ZSharp-Win-Installer.zip`.
+2. Unzip `ZSharp-Win-Installer.zip` and open the unzipped folder.
+3. Inside is a single file titled `ZSharp-Setup.exe`. Run it, and follow the setup instructions.
+4. If it fails to run, make sure the `MS Visual Runtime and MSVC C++ Redistribute` are installed. You can download them [here from Microsoft](https://docs.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist)
+5. Now that it is installed, there are a few ways to use it:
+    * (recommended) Any ZSharp file that ends with .ZS will automatically be associated with the interpreter. Just double-click it, and the interpreter will run.
+    * Drag and drop any .ZS script directly onto the executable.
+    * Use command line, providing path to interpreter and then to script like so:
+    `> ./ZSharp.exe ./Pong-Example-Project/script.zs`
+6. Feel free to use and edit the `Pong-Example-Project`. It is a single script called `script.zs`, and you can open it with any of the methods above. It is also located on the releases page.
+> If you don't want to install ZSharp on your device, or you want easier acces to the executable and .DLLs, another version is provided called `ZS_Win_Base_Raw.zip`. This just contains all of the files the installer puts on your computer.
+### Linux
+1. Install requirements: `SDL2, SDL2 Image, SDL2 TTF` Commands for `apt` and `pacman` below:
+
+#### Debian
+
+```
+$ sudo apt install libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev
+```
+
+#### Arch
+
+```
+$ sudo pacman -S sdl2 sdl2_image sdl2_ttf
+```
+
+2. Navigate to [the most recent release](https://github.com/sam-astro/Z-Sharp/releases) and download `ZSharp-Linux.zip`.
+3. Unzip `ZSharp-Linux.zip` and open the unzipped folder.
+4. You will see some files. The Z# interpreter is `ZSharp`. Any time you want to execute a script, this is the program that will be used. You can use it like so:
+    * Use terminal, providing path to executable and then to script like so:
+    `$ ./ZSharp ./Pong-Example-Project/script.zs`
+5. Feel free to use and edit the included `Pong-Example-Project`. It is a single script called `script.zs`, and you can open it with any of the methods above.
+
+
+## Here is some example code:
+```c++
 // Comments are indicated by two forward slashes
 // They can only be on their own line
 //    int j = 4 // <- This is invalid comment placement
@@ -23,7 +73,7 @@ func Main()
     
     if s == "r"
     {
-        print s + " is r"
+        Printl(s + " is r")
     }
     
     int functionNumber = ExampleFunction("A", s)
@@ -37,8 +87,8 @@ func Main()
 /// be assigned at all on execute and can be left blank
 func ExampleFunction(inputA, inputB)
 {
-    print "In A is: " + inputA
-    print "In B is: " + inputB
+    Printl("In A is: " + inputA)
+    Printl("In B is: " + inputB)
     
     // Return a value to the valling location
     return 4
@@ -52,7 +102,7 @@ func GlobalFunction()
 }
 ```
 Here is how to use graphics:
-```c#
+```c++
 func Main()
 {
     int screenWidth = 500
@@ -75,9 +125,28 @@ func Start()
 }
 
 // Executes each frame
-func Update()
+func Update(deltaTime)
 {
     // Draws the image created in Start(). This is usually at the end of update.
     ZS.Graphics.Draw(exampleSprite)   
 }
 ```
+Currently, ZSharp is ***VERY*** strict with formatting, and can throw an error if you forget to put a space somewhere.
+Also, speaking of errors, if your code has any it will show in the console. Errors are colored red, and warnings are colored yellow. A line number will also usually be provided. This is ***Not*** the line relative to the *documents* beginning, but rather the *functions* beginning.
+Example:
+```
+ERROR: line 5 in function Main
+```
+This is the 5th line *inside of Main*.
+```c++
+func Main()
+{
+   // line 1
+   // line 2
+   // line 3
+   // line 4
+   int g = "s"
+   // ^ above line is the error, since it is line 5
+}
+```
+I am planning to change how error reporting works to report the document line number as well, but this is how it is for now.

Z-Sharp.sln

@@ -5,8 +5,6 @@ VisualStudioVersion = 17.0.31612.314
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ZSharp", "ZSharp\ZSharp.vcxproj", "{D5F150F8-1F83-41EB-A195-1B5C3CA9322A}"
 EndProject
-Project("{54435603-DBB4-11D2-8724-00A0C9A8B90C}") = "ZSharp Installer", "ZSharp-Installer\ZSharp-Installer.vdproj", "{42EA0B7A-2068-4065-B9EB-041F32933A66}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
@@ -23,12 +21,6 @@ Global
 		{D5F150F8-1F83-41EB-A195-1B5C3CA9322A}.Release|x64.Build.0 = Release|x64
 		{D5F150F8-1F83-41EB-A195-1B5C3CA9322A}.Release|x86.ActiveCfg = Release|Win32
 		{D5F150F8-1F83-41EB-A195-1B5C3CA9322A}.Release|x86.Build.0 = Release|Win32
-		{42EA0B7A-2068-4065-B9EB-041F32933A66}.Debug|x64.ActiveCfg = Release
-		{42EA0B7A-2068-4065-B9EB-041F32933A66}.Debug|x64.Build.0 = Release
-		{42EA0B7A-2068-4065-B9EB-041F32933A66}.Debug|x86.ActiveCfg = Debug
-		{42EA0B7A-2068-4065-B9EB-041F32933A66}.Release|x64.ActiveCfg = Release
-		{42EA0B7A-2068-4065-B9EB-041F32933A66}.Release|x64.Build.0 = Release
-		{42EA0B7A-2068-4065-B9EB-041F32933A66}.Release|x86.ActiveCfg = Release
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

ZSharp/CMakeLists.txt

@@ -7,7 +7,7 @@ project(ZSharp)
 SET(programName Slang)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMakeFiles/")
 
-add_executable (ZSharp Main.cpp main.h anyops.h builtin.h strops.cpp strops.h eval.cpp eval.h graphics.h ZS.h)
+add_executable (ZSharp Main.cpp main.h anyops.h builtin.h strops.cpp strops.h eval.cpp eval.h graphics.h ZS.h color.hpp)
 
 find_package(SDL2 REQUIRED)
 find_package(SDL2_image REQUIRED)

ZSharp/Main.cpp

@@ -2,8 +2,10 @@
 #include <iostream>
 #include <fstream>
 #include <string>
+//bool DEVELOPER_MESSAGES = true;
 #define DEVELOPER_MESSAGES false
 #define EXAMPLE_PROJECT false
+#define NAMEVERSION "ZSharp v2.1.3-alpha"
 
 #if defined(__unix__)
 #define UNIX true
@@ -22,6 +24,7 @@
 #include <unordered_map>
 #include <stdio.h>
 #include <codecvt>
+#include <thread>
 
 #if UNIX
 #include <unistd.h>
@@ -72,14 +75,19 @@ boost::any GetVariableValue(const string& varName, const unordered_map<string, b
 		return outputValue;
 }
 
+// Check if there is a variable with the specified name
 bool IsVar(const string& varName, const unordered_map<string, boost::any>& variableValues)
 {
-	if (variableValues.find(split(varName, '.')[0]) != variableValues.end() && split(varName, '.')[0] != "ZS")
-		return true;
-	else
+	if (split(varName, '.')[0] == "ZS")
 		return false;
+
+	if (variableValues.find(split(varName, '.')[0]) != variableValues.end())
+		return true;
+
+	return false;
 }
 
+// Return a vector of values that correspond to a vector of input variable names
 vector<boost::any> VarValues(const vector<string>& varNames, unordered_map<string, boost::any>& variableValues)
 {
 	vector<boost::any> realValues;
@@ -107,6 +115,20 @@ vector<boost::any> VarValues(const vector<string>& varNames, unordered_map<strin
 	return realValues;
 }
 
+void printVarValues(const vector<string>& vec, unordered_map<string, boost::any>& variableValues)
+{
+	cout << "<";
+	for (int i = 0; i < vec.size(); i++)
+	{
+		cout << AnyAsString(GetVariableValue(vec.at(i), globalVariableValues));
+		cout << AnyAsString(GetVariableValue(vec.at(i), variableValues));
+		cout << " | ";
+	}
+	cout << ">";
+	cout << endl;
+}
+
+
 bool IsFunction(const string& funcName)
 {
 	if (functionValues.find(funcName) != functionValues.end())
@@ -116,10 +138,7 @@ bool IsFunction(const string& funcName)
 }
 bool IsZSFunction(const string& funcName)
 {
-	if (funcName[0] == 'Z' && funcName[1] == 'S' && funcName[2] == '.')
-		return true;
-	else
-		return false;
+	return startsWith(funcName, "ZS.");
 }
 
 boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& variableValues)
@@ -128,7 +147,7 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 	bool inQuotes = false;
 
 #if DEVELOPER_MESSAGES == true
-	InterpreterLog("	old expression: |" + expression + "|");
+	//InterpreterLog("	old expression: |" + expression + "|");
 #endif
 
 	bool isFunc = IsFunction(split(expression, '(')[0]);
@@ -136,31 +155,32 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 	// If no operations are applied, then return self
 	if ((countOutsideParenthesis(expression, '+') == 0 && countOutsideParenthesis(expression, '-') == 0 && countOutsideParenthesis(expression, '*') == 0 && countOutsideParenthesis(expression, '/') == 0 && countOutsideParenthesis(expression, '^') == 0) || split(expression, '.')[0] == "ZS")
 	{
-		bool isFunc = IsFunction(split(expression, '(')[0]);
+		//bool isFunc = IsFunction(split(expression, '(')[0]);
 		if (isFunc && !inQuotes)
 		{
-			//cout << split(expression, '(')[0] << endl;
-			string argContents = "";
-			int y = indexInStr(expression, '(') + 1;
-			while (y < expression.size() && expression[y] != ')')
-			{
-				argContents += expression[y];
-
-				y++;
-			}
-			return ExecuteFunction(split(expression, '(')[0], VarValues(split(argContents, ','), variableValues));
+			// start -> FuncCall(0, x, OtherFunc(a))
+			// changeto -> 0, x, OtherFunc(a)
+			string insideFunArgs = betweenChars(expression, '(', ')');
+			vector<string> argList = splitNoOverlap(insideFunArgs, ',', '(', ')');
+#if DEVELOPER_MESSAGES == true
+			cout << split(expression, '(')[0] << "  [" << unWrapVec(argList) << "]" << endl;
+			printVarValues(argList, variableValues);
+#endif
+			vector<boost::any> funcArgs = VarValues(argList, variableValues);
+			return ExecuteFunction(split(expression, '(')[0], funcArgs);
 		}
-		else if (split(expression, '.')[0] == "ZS" && !inQuotes)
+		else if (isZS && !inQuotes)
 		{
-			string argContents = "";
-			int y = indexInStr(expression, '(') + 1;
-			while (y < expression.size() && expression[y] != ')')
-			{
-				argContents += expression[y];
-
-				y++;
-			}
-			return ZSFunction(split(expression, '(')[0], VarValues(split(argContents, ','), variableValues));
+			// start -> FuncCall(0, x, OtherFunc(a))
+			// changeto -> 0, x, OtherFunc(a)
+			string insideFunArgs = betweenChars(expression, '(', ')');
+			vector<string> argList = splitNoOverlap(insideFunArgs, ',', '(', ')');
+#if DEVELOPER_MESSAGES == true
+			cout << split(expression, '(')[0] << "  [" << unWrapVec(argList) << "]" << endl;
+			printVarValues(argList, variableValues);
+#endif
+			vector<boost::any> funcArgs = VarValues(argList, variableValues);
+			return ZSFunction(split(expression, '(')[0], funcArgs);
 		}
 		else
 			return GetVariableValue(expression, variableValues);
@@ -171,14 +191,14 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 
 	for (int i = 0; i < expression.size(); i++)
 	{
-		if (expression[i] == '\"')
+		if (expression[i] == '\"' && !isEscaped(newExpression, i))
 			inQuotes = !inQuotes;
 
-		if (isalpha(expression[i]))
+		if (isalpha(expression[i]) || expression[i] == '_')
 		{
 			string name = "";
 
-			while (i < expression.size() && (isalpha(expression[i]) || expression[i] == '.'))
+			while (i < expression.size() && (isalpha(expression[i]) || expression[i] == '.' || expression[i] == '_'))
 			{
 				name += expression[i];
 				i++;
@@ -188,29 +208,30 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 			bool isFunc = IsFunction(name);
 			if (isFunc && !inQuotes)
 			{
-				string argContents = "";
-				i++;
-				while (i < expression.size() && expression[i] != ')')
-				{
-					argContents += expression[i];
-
-					i++;
-				}
-				string returnVal = AnyAsString(ExecuteFunction(name, VarValues(split(argContents, ','), variableValues)));
+				// start -> FuncCall(0, x, OtherFunc(a))
+				// changeto -> 0, x, OtherFunc(a)
+				string insideFunArgs = betweenChars(expression, '(', ')');
+				vector<string> argList = splitNoOverlap(insideFunArgs, ',', '(', ')');
+#if DEVELOPER_MESSAGES == true
+				cout << "[" << unWrapVec(argList) << "]" << endl;
+				printVarValues(argList, variableValues);
+#endif
+				vector<boost::any> funcArgs = VarValues(argList, variableValues);
+				string returnVal = AnyAsString(ExecuteFunction(split(expression, '(')[0], funcArgs));
 				newExpression += returnVal;
 			}
 			else if (split(name, '.')[0] == "ZS" && !inQuotes)
 			{
-				string argContents = "";
-				int y = indexInStr(expression, '(') + 1;
-				while (y < expression.size() && expression[y] != ')')
-				{
-					argContents += expression[y];
-
-					y++;
-				}
-				//cout << split(expression, '(')[0] << " " << argContents << endl;
-				string returnVal = AnyAsString(ZSFunction(split(name, '(')[0], VarValues(split(argContents, ','), variableValues)));
+				// start -> FuncCall(0, x, OtherFunc(a))
+				// changeto -> 0, x, OtherFunc(a)
+				string insideFunArgs = betweenChars(expression, '(', ')');
+				vector<string> argList = splitNoOverlap(insideFunArgs, ',', '(', ')');
+#if DEVELOPER_MESSAGES == true
+				cout << "[" << unWrapVec(argList) << "]" << endl;
+				printVarValues(argList, variableValues);
+#endif
+				vector<boost::any> funcArgs = VarValues(argList, variableValues);
+				string returnVal = AnyAsString(ZSFunction(split(expression, '(')[0], funcArgs));
 				newExpression += returnVal;
 			}
 			else
@@ -229,12 +250,12 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 		}
 	}
 #if DEVELOPER_MESSAGES == true
-	InterpreterLog("	new expression: |" + newExpression + "|");
+	//InterpreterLog("	new expression: |" + newExpression + "|");
 #endif
 
 	bool addStrings = false;
 	for (int i = 0; i < (int)newExpression.size(); i++)
-		if (isalpha(newExpression[i]) || newExpression[i] == '\"')
+		if (isalpha(newExpression[i]) || (newExpression[i] == '\"' && !isEscaped(newExpression, i)))
 		{
 			addStrings = true;
 			break;
@@ -245,7 +266,7 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 		string withoutParenthesis = "";
 		for (int i = 0; i < (int)newExpression.size(); i++)
 		{
-			if (newExpression[i] == '\"')
+			if (newExpression[i] == '\"' && !isEscaped(newExpression, i))
 			{
 				inQuotes = !inQuotes;
 				continue;
@@ -263,27 +284,33 @@ boost::any EvalExpression(const string& ex, unordered_map<string, boost::any>& v
 		return evaluate(newExpression);
 }
 
-bool BooleanLogic(const string& valA, const string& determinant, const string& valB, unordered_map<string, boost::any>& variableValues)
+bool BooleanLogic(const string& valA, const string& comparer, const string& valB, unordered_map<string, boost::any>& variableValues)
 {
-	boost::any valARealValue = EvalExpression(valA, variableValues);
-	boost::any valBRealValue = EvalExpression(valB, variableValues);
+	boost::any valARealValue;
+	boost::any valBRealValue;
+	if (valA != "")
+		valARealValue = EvalExpression(valA, variableValues);
+	if (valB != "")
+		valBRealValue = EvalExpression(valB, variableValues);
 #if DEVELOPER_MESSAGES == true
-	InterpreterLog(AnyAsString(valARealValue) + " " + determinant + " " + AnyAsString(valBRealValue) + " : " + AnyAsString(valA) + " " + determinant + " " + AnyAsString(valB) + " : " + to_string(AnyAsString(valARealValue) == AnyAsString(valBRealValue)));
+	InterpreterLog(AnyAsString(valARealValue) + " " + comparer + " " + AnyAsString(valBRealValue) + " : " + AnyAsString(valA) + " " + comparer + " " + AnyAsString(valB) + " : " + to_string(AnyAsString(valARealValue) == AnyAsString(valBRealValue)));
 #endif
-	if (determinant == "==")
+	if (comparer == "==")
 		return any_compare(valARealValue, valBRealValue);
-	else if (determinant == "!=")
+	else if (comparer == "!=")
 		return !any_compare(valARealValue, valBRealValue);
-	else if (determinant == ">=")
+	else if (comparer == ">=")
 		return AnyAsFloat(valARealValue) >= AnyAsFloat(valBRealValue);
-	else if (determinant == "<=")
+	else if (comparer == "<=")
 		return AnyAsFloat(valARealValue) <= AnyAsFloat(valBRealValue);
-	else if (determinant == ">")
+	else if (comparer == ">")
 		return AnyAsFloat(valARealValue) > AnyAsFloat(valBRealValue);
-	else if (determinant == "<")
+	else if (comparer == "<")
 		return AnyAsFloat(valARealValue) < AnyAsFloat(valBRealValue);
+	else if (comparer == "")
+		return AnyAsBool(valARealValue) == true;
 	else
-		LogWarning("unrecognized determinant \'" + determinant + "\'");
+		LogWarning("unrecognized comparer \'" + comparer + "\'");
 
 	return false;
 }
@@ -368,48 +395,85 @@ int varOperation(const vector<string>& str, unordered_map<string, boost::any>& v
 	return 1;
 }
 
-boost::any ProcessLine(const vector<vector<string>>& words, int lineNum, unordered_map<string, boost::any>& variableValues)
+boost::any ProcessLine(const vector<vector<string>>& words, int& lineNum, unordered_map<string, boost::any>& variableValues)
 {
-	if (words.at(lineNum).at(0)[0] == '/' && words.at(lineNum).at(0)[1] == '/')
-		return nullType;
+	//// Check if the first two chars are '//', which would make it a comment
+	//if (startsWith(words.at(lineNum).at(0), "//"))
+	//	return nullType;
 
 	// If print statement (deprecated, now use ZS.System.Print() function)
-	else if (words.at(lineNum).at(0) == "print")
+	if (words.at(lineNum).at(0) == "print")
 	{
 		cout << StringRaw(AnyAsString(EvalExpression(unWrapVec(vector<string>(words.at(lineNum).begin() + 1, words.at(lineNum).end())), variableValues))) << endl;
 		return nullType;
 	}
 
-	// Check if function return
+	// Check if it is a function return
 	else if (words.at(lineNum).at(0) == "return")
 		return EvalExpression(unWrapVec(vector<string>(words.at(lineNum).begin() + 1, words.at(lineNum).end())), variableValues);
 
-	// Check if it is ZS Builtin function
-	else if (words.at(lineNum).at(0)[0] == 'Z' && words.at(lineNum).at(0)[1] == 'S' && words.at(lineNum).at(0)[2] == '.')
+	// Check if it is ZS Builtin function call
+	else if (startsWith(words.at(lineNum).at(0), "ZS."))
 		return EvalExpression(unWrapVec(words.at(lineNum)), variableValues);
 
-	// Check if it is function
-	else if (IsFunction(trim(split(words.at(lineNum).at(0), '(')[0])))
+	// Check if it is function call
+	else if (IsFunction(split(words.at(lineNum).at(0), '(')[0]))
 	{
-		if (count(words.at(lineNum).at(0), '(') > 0 && count(words.at(lineNum).at(0), ')') > 0)
-			ExecuteFunction(trim(split(words.at(lineNum).at(0), '(')[0]), vector<boost::any>());
-		else
-			ExecuteFunction(trim(split(words.at(lineNum).at(0), '(')[0]), VarValues(split(RMParenthesis("(" + split(unWrapVec(rangeInVec(words.at(lineNum), 0, (int)words.at(lineNum).size() - 1)), '(')[1]), ','), variableValues));
+		// start -> FuncCall(0, x, OtherFunc(a))
+		// changeto -> 0, x, OtherFunc(a)
+		string insideFunArgs = betweenChars(unWrapVec(words.at(lineNum)), '(', ')');
+		vector<string> argList = splitNoOverlap(insideFunArgs, ',', '(', ')');
+#if DEVELOPER_MESSAGES == true
+		cout << unWrapVec(argList) << endl;
+		printVarValues(argList, variableValues);
+#endif
+		vector<boost::any> funcArgs = VarValues(argList, variableValues);
+		ExecuteFunction(split(words.at(lineNum).at(0), '(')[0], funcArgs);
+		return nullType;
+	}
+
+	// Check if it is a SplitThread call
+	else if (startsWith(words.at(lineNum).at(0), "SplitThread"))
+	{
+		vector<string> lineContents = words.at(lineNum);
+		cout << "New Thread: " << words.at(lineNum).at(0) << endl;
+		//lineContents.at(0) = betweenChars(lineContents.at(0), '(', ')');
+
+		//cout << "debug: " << lineContents.at(0) << endl;
+
+		//if (betweenChars(lineContents.at(0), '(', ')') == "")
+		//	std::thread thread_obj(ExecuteFunction, trim(split(lineContents.at(0), '(')[0]), vector<boost::any>());
+		//else
+		//	std::thread thread_obj(ExecuteFunction, trim(split(lineContents.at(0), '(')[0]), VarValues(split(RMParenthesis("(" + split(unWrapVec(rangeInVec(lineContents, 0, (int)lineContents.size() - 2)), '(')[1]), ','), variableValues));
 		return nullType;
 	}
 
 	// Check if global variable declaration
-	else if (trim(words.at(lineNum).at(0)) == "global")
+	else if (words.at(lineNum).at(0) == "global")
 	{
-		globalVariableValues[words.at(lineNum).at(2)] = EvalExpression(unWrapVec(slice(words.at(lineNum), 4, -1)), variableValues);
+		try
+		{
+			globalVariableValues[words.at(lineNum).at(2)] = EvalExpression(unWrapVec(slice(words.at(lineNum), 4, -1)), variableValues);
+		}
+		catch (const std::exception&)
+		{
+			LogCriticalError("Error at line: " + to_string(lineNum) + ", " + unWrapVec(words.at(lineNum)) + ", couldn't initialize variable.");
+		}
 		return nullType;
 	}
 
 	// Iterate through all types to see if line inits or
 	// re-inits a variable then store it with it's value
-	else if (countInVector(types, trim(words.at(lineNum).at(0))) > 0)
+	else if (countInVector(types, words.at(lineNum).at(0)) > 0)
 	{
-		variableValues[words.at(lineNum).at(1)] = EvalExpression(unWrapVec(slice(words.at(lineNum), 3, -1)), variableValues);
+		try
+		{
+			variableValues[words.at(lineNum).at(1)] = EvalExpression(unWrapVec(slice(words.at(lineNum), 3, -1)), variableValues);
+		}
+		catch (const std::exception&)
+		{
+			LogCriticalError("Error at line: " + to_string(lineNum) + ", " + unWrapVec(words.at(lineNum)) + ", couldn't initialize variable.");
+		}
 		return nullType;
 	}
 
@@ -422,7 +486,7 @@ boost::any ProcessLine(const vector<vector<string>>& words, int lineNum, unorder
 		return nullType;
 	}
 
-	// Check existing variables: To see if class sub component matches
+	// Check existing variables: To see if accessing class sub component
 	else if (count(words.at(lineNum).at(0), '.') > 0 && IsVar(split(words.at(lineNum).at(0), '.')[0], variableValues) || IsVar(split(words.at(lineNum).at(0), '.')[0], globalVariableValues))
 	{
 		if (IsVar(split(words.at(lineNum).at(0), '.')[0], variableValues))
@@ -432,49 +496,112 @@ boost::any ProcessLine(const vector<vector<string>>& words, int lineNum, unorder
 		return nullType;
 	}
 
-	// Gathers while loop contents
+	// If declaring a while loop, loop until false
 	else if (words.at(lineNum).at(0) == "while")
 	{
 		vector<vector<string>> whileContents;
 		vector<string> whileParameters;
 
-		for (int w = 1; w < (int)words.at(lineNum).size(); w++)
-			whileParameters.push_back(words.at(lineNum)[w]);
+		// Gather the parameters that must be == true for the loop to run
+		int numOfBrackets = 0;
+		for (int w = 1; w < (int)words.at(lineNum).size(); w++) {
+			if (count(words.at(lineNum).at(w), '{') == 0)
+				whileParameters.push_back(words.at(lineNum)[w]);
+			else
+			{
+				whileParameters.push_back(replace(words.at(lineNum)[w], "{", ""));
+				numOfBrackets = 1;
+				break;
+			}
+		}
 
-		int numOfBrackets = 1;
-		for (int p = lineNum + 2; p < (int)words.size(); p++)
+		// If the statement is already false, don't bother gathering the contents
+		if (BooleanLogic(whileParameters.at(0), whileParameters.at(1), whileParameters.at(2), variableValues) == false) {
+			lineNum++;
+			while (lineNum < (int)words.size())
+			{
+				numOfBrackets += countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
+				if (numOfBrackets == 0)
+					break;
+				lineNum++;
+			}
+			return nullType;
+		}
+
+		// Gather the contents
+		lineNum++;
+		while (lineNum < (int)words.size())
 		{
-			numOfBrackets += countInVector(words.at(p), "{") - countInVector(words.at(p), "}");
+			numOfBrackets += countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
 			if (numOfBrackets == 0)
 				break;
-			whileContents.push_back(words.at(p));
+			whileContents.push_back(words.at(lineNum));
+			lineNum++;
 		}
-		whileContents = removeTabsWdArry(whileContents, 1);
 
+		//whileContents = removeTabsWdArry(whileContents, 1);
+
+		// Loop while true
 		while (BooleanLogic(whileParameters.at(0), whileParameters.at(1), whileParameters.at(2), variableValues))
 		{
 			//Iterate through all lines in while loop
 			for (int lineNum = 0; lineNum < (int)whileContents.size(); lineNum++)
 			{
+				if (whileContents.at(lineNum).at(0) == "continue")
+					break; // Stops iterating through lines and return to beginning
+				if (whileContents.at(lineNum).at(0) == "break")
+					return nullType; // Stops iterating through lines and leave while loop
 				boost::any returnVal = ProcessLine(whileContents, lineNum, variableValues);
-				if (!returnVal.empty())
-					return returnVal;
+				if (!returnVal.empty()) {
+					try
+					{
+						BREAK t = any_cast<BREAK>(returnVal);
+						return nullType;
+					}
+					catch (boost::bad_any_cast)
+					{
+						return returnVal;
+					}
+				}
 			}
 		}
 		return nullType;
 	}
 
-	// Gathers if statement contents
+	// If declaring an if statement, only execute if true
 	else if (words.at(lineNum).at(0) == "if")
 	{
 		vector<vector<string>> ifContents;
 		vector<string> ifParameters;
 
-		for (int w = 1; w < (int)words.at(lineNum).size(); w++)
-			ifParameters.push_back(words.at(lineNum).at(w));
+		// Gather the parameters that must be == true for the loop to run
+		int numOfBrackets = 0;
+		for (int w = 1; w < (int)words.at(lineNum).size(); w++) {
+			if (count(words.at(lineNum).at(w), '{') == 0)
+				ifParameters.push_back(words.at(lineNum)[w]);
+			else
+			{
+				ifParameters.push_back(replace(words.at(lineNum)[w], "{", ""));
+				numOfBrackets = 1;
+				break;
+			}
+		}
 
-		int numOfBrackets = 1;
-		lineNum += 2;
+		// If the statement is already false, don't bother gathering the contents
+		if (BooleanLogic(ifParameters.at(0), ifParameters.at(1), ifParameters.at(2), variableValues) == false) {
+			lineNum++;
+			while (lineNum < (int)words.size())
+			{
+				numOfBrackets += countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
+				if (numOfBrackets == 0)
+					break;
+				lineNum++;
+			}
+			return nullType;
+		}
+
+		// Gather the contents
+		lineNum++;
 		while (lineNum < (int)words.size())
 		{
 			numOfBrackets += countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
@@ -483,78 +610,80 @@ boost::any ProcessLine(const vector<vector<string>>& words, int lineNum, unorder
 			ifContents.push_back(words.at(lineNum));
 			lineNum++;
 		}
-		ifContents = removeTabsWdArry(ifContents, 1);
+		//ifContents = removeTabsWdArry(ifContents, 1);
 
+		// Execute if true
 		if (BooleanLogic(ifParameters.at(0), ifParameters.at(1), ifParameters.at(2), variableValues))
 		{
 			//Iterate through all lines in if statement
 			for (int l = 0; l < (int)ifContents.size(); l++)
 			{
+				if (ifContents.at(l).at(0) == "break")
+					return breakReOp; // Stops iterating through lines and leave while loop
 				boost::any returnVal = ProcessLine(ifContents, l, variableValues);
 				if (!returnVal.empty())
 					return returnVal;
 			}
 		}
-		//else if (words.size() > lineNum + 1)
-		//	if (words[lineNum + 1][0] == "else")
-		//	{
-		//		lineNum += 1;
+		else if (words.size() > lineNum)
+		{
+			if (words[lineNum].at(0) == "else")
+			{
+				vector<vector<string>> elseContents;
+				vector<string> elseParameters;
 
-		//		vector<string> elseContents;
+				int numOfBrackets = 0;
+				for (int w = 1; w < (int)words.at(lineNum).size(); w++) {
+					if (count(words.at(lineNum).at(w), '{') != 0)
+					{
+						numOfBrackets = 1;
+						break;
+					}
+				}
 
-		//		int numOfBrackets = 1;
-		//		while (lineNum < (int)words.size())
-		//		{
-		//			numOfBrackets += countInVector(words[lineNum], "{") - countInVector(words[lineNum], "}");
-		//			if (numOfBrackets == 0)
-		//				break;
-		//			elseContents.push_back("");
-		//			for (int w = 0; w < (int)words[lineNum].size(); w++)
-		//			{
-		//				elseContents[(int)elseContents.size() - 1] += words[lineNum][w] + " ";
-		//			}
-		//			lineNum++;
-		//		}
-		//		elseContents = removeTabs(elseContents, 2);
+				lineNum++;
+				while (lineNum < (int)words.size())
+				{
+					numOfBrackets += countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
+					if (numOfBrackets == 0)
+						break;
+					elseContents.push_back(words.at(lineNum));
+					lineNum++;
+				}
 
-		//		vector<vector<string>> innerWords;
-		//		for (int i = 0; i < (int)elseContents.size(); i++)
-		//			innerWords.push_back(split(elseContents[i], ' '));
+				//elseContents = removeTabsWdArry(elseContents, 1);
 
-		//		//Iterate through all lines in else statement
-		//		for (int lineNum = 0; lineNum < (int)elseContents.size(); lineNum++)
-		//		{
-		//			ProcessLine(innerWords, lineNum, variableValues);
-		//		}
-		//		return nullType;
-		//	}
+				//Iterate through all lines in else statement
+				for (int l = 0; l < (int)elseContents.size(); l++)
+				{
+					boost::any returnVal = ProcessLine(elseContents, l, variableValues);
+					if (!returnVal.empty())
+						return returnVal;
+				}
+
+			}
+		}
 		return nullType;
 	}
-	//// Gathers else statement contents
-	//if (words[lineNum][0] == "else")
-	//{
-	//	
-	//}
-
 	return nullType;
 }
 
 boost::any ExecuteFunction(const string& functionName, const vector<boost::any>& inputVarVals)
 {
-	// Get contents of function
+	// Get contents of function from global function map
 	std::vector<std::vector<std::string>> words = functionValues[functionName];
 
 	unordered_map<string, boost::any> variableValues = {};
-	
+
 	std::vector<std::string> funcArgs = words.at(0);
-	
+	// Set function variables equal to whatever inputs were provided
 	for (int i = 0; i < (int)inputVarVals.size(); i++)
 	{
-		if(i < funcArgs.size())
+		if (i < funcArgs.size())
 		{
 			variableValues[funcArgs[i]] = inputVarVals[i];
 #if DEVELOPER_MESSAGES == true
-			cout << functionName + "  \x1B[33m" << funcArgs[i] << " == " << AnyAsString(inputVarVals[i]) << "\033[0m\t\t" << endl;
+			cout << "in " << functionName + "  " << funcArgs[i] << " == " << AnyAsString(inputVarVals[i]) << endl;
 #endif
 		}
 	}
@@ -570,7 +699,7 @@ boost::any ExecuteFunction(const string& functionName, const vector<boost::any>&
 		}
 		catch (const std::exception&)
 		{
-			LogCriticalError("\'" + unWrapVec(words.at(lineNum)) + "\'\n                  In function: " + functionName + "\n                  Line: " + to_string(lineNum));
+			LogCriticalError("Error at line: " + to_string(lineNum) + ", " + unWrapVec(words.at(lineNum)));
 		}
 	}
 	return nullType;
@@ -578,20 +707,33 @@ boost::any ExecuteFunction(const string& functionName, const vector<boost::any>&
 
 int parseZSharp(string script)
 {
-	script = replace(script, "    ", "\t");
-	#if DEVELOPER_MESSAGES
-	InterpreterLog("Contents:\n" + script);
-	#endif
+	//script = replace(script, "    ", "\t"); // Replace spaces with tabs (not really required, and will break purposefull whitespace in strings etc.)
 
-	vector<string> lines = split(script, '\n');
+	// Split the script by newline, signifying a line ending
+	vector<string> beforeProcessLines = split(script, '\n');
+	vector<string> lines;
+	for (int i = 0; i < (int)beforeProcessLines.size(); i++) { // Then split said lines into indiviual words
+		if (!startsWith(trim(beforeProcessLines.at(i)), "//") && trim(beforeProcessLines.at(i)) != "")
+		{ // dont include line if it is a comment or if it is blank
+			lines.push_back(trim(beforeProcessLines.at(i)));
+		}
+	}
+#if DEVELOPER_MESSAGES
+	InterpreterLog("Contents:\n");
+#endif
 	vector<vector<string>> words;
-	for (int i = 0; i < (int)lines.size(); i++)
+	for (int i = 0; i < (int)lines.size(); i++) // Then split said lines into indiviual words
+	{
 		words.push_back(split(lines.at(i), ' '));
+#if DEVELOPER_MESSAGES
+		cout << unWrapVec(words.at(i)) << endl;
+#endif
+	}
 
-	#if DEVELOPER_MESSAGES
+#if DEVELOPER_MESSAGES
 	InterpreterLog("Gather variables & functions...");
-	#endif
-	// First go through entire script and iterate through all types to see if line is a variable
+#endif
+	// Go through entire script and iterate through all types to see if line is a variable
 	// or function declaration, then store it with it's value
 	for (int lineNum = 0; lineNum < (int)words.size(); lineNum++)
 	{
@@ -605,141 +747,241 @@ int parseZSharp(string script)
 			InterpreterLog("Load script function " + functName + "...");
 #endif
 
-			string args = "";
-			if (indexInStr(unWrapVec(words.at(lineNum)), ')') - indexInStr(unWrapVec(words.at(lineNum)), '(') > 1)
-				for (int w = 1; w < (int)words.at(lineNum).size(); w++) // Get all words from the instantiation line: these are the args
-				{
-					args += replace(replace(words.at(lineNum).at(w), "(", " "), ")", "");
+			//string args = "";
+			//if (indexInStr(unWrapVec(words.at(lineNum)), ')') - indexInStr(unWrapVec(words.at(lineNum)), '(') > 1)
+			//	for (int w = 0; w < (int)words.at(lineNum).size(); w++) // Get all words from the instantiation line: these are the args
+			//	{
+			//		if (count(words.at(lineNum).at(w), '{') == 0)
+			//			args += replace(replace(words.at(lineNum).at(w), "(", " "), ")", "");
+			//	}
+			string args = betweenChars(unWrapVec(words.at(lineNum)), '(', ')');
+			//cout << functName << "<" << args << ">" << endl;
+
+			//args = trim(replace(args, functName, ""));
+			functionContents.push_back(split(replace(args, " ", ""), ','));
+
+
+			int numOfBrackets = countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
+			// Gather the contents
+			lineNum++;
+			while (lineNum < (int)words.size())
+			{
+				numOfBrackets += countInVector(words.at(lineNum), "{") - countInVector(words.at(lineNum), "}");
+				if (numOfBrackets == 0)
+					break;
+				functionContents.push_back(words.at(lineNum));
+				//cout << functName << "<" << args << ">" << endl;
+				lineNum++;
+			}
+			//functionContents = removeTabsWdArry(functionContents, 1);
+
+			/*int numOfBrackets = 0;
+			for (int w = 1; w < (int)words.at(lineNum).size(); w++) {
+				if (count(words.at(lineNum).at(w), '{') != 0) {
+					numOfBrackets = 1;
+					break;
 				}
+			}
 
-			args = trim(replace(args, functName + " ", ""));
-			functionContents.push_back(split(args, ','));
-
-			int numOfBrackets = 1;
-			for (int p = lineNum + 2; p < (int)words.size(); p++)
+			for (int p = lineNum + 1; p < (int)words.size(); p++)
 			{
 				numOfBrackets += countInVector(words.at(p), "{") - countInVector(words.at(p), "}");
 				if (numOfBrackets == 0)
 					break;
 				functionContents.push_back(removeTabs(words.at(p), 1));
-			}
+			}*/
 			functionValues[functName] = functionContents;
 		}
 		else
 		{
-			if (words.at(lineNum).at(0) == "string"){
+			if (words.at(lineNum).at(0) == "include")
+			{
+				string scriptPath = StringRaw(words.at(lineNum).at(1));
+				string scriptTextContents;
+#if DEVELOPER_MESSAGES == true
+				InterpreterLog("Including from " + words.at(lineNum).at(1) + "...");
+#endif
+#if UNIX
+				// Get script contents as single string
+				auto ss = ostringstream{};
+				ifstream input_file(scriptPath);
+				ss << input_file.rdbuf();
+				scriptTextContents = ss.str();
+#if DEVELOPER_MESSAGES
+				InterpreterLog("Gather script contents...");
+#endif
+#elif WINDOWS
+				// Get script contents as single string
+				ifstream script(scriptPath);
+				stringstream scriptString;
+				scriptString << script.rdbuf();
+				scriptTextContents = scriptString.str();
+#if DEVELOPER_MESSAGES
+				InterpreterLog("Gather script contents...");
+#endif
+#endif
+				parseZSharp(scriptTextContents);
+			}
+
+
+			else if (words.at(lineNum).at(0) == "string") {
 				globalVariableValues[words.at(lineNum).at(1)] = StringRaw(words.at(lineNum).at(3));
 #if DEVELOPER_MESSAGES == true
 				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
 #endif
-}
-			else if (words.at(lineNum).at(0) == "int"){
-				globalVariableValues[words.at(lineNum).at(1)] = stoi(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
-#endif
-}
-			else if (words.at(lineNum).at(0) == "float"){
-				globalVariableValues[words.at(lineNum).at(1)] = stof(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
-#endif
-}
-			else if (words.at(lineNum).at(0) == "bool"){
-				globalVariableValues[words.at(lineNum).at(1)] = stob(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
-#endif
-}
-			/*else
-				LogWarning("unrecognized type \'" + words.at(lineNum).at(0) + "\' on line: " + to_string(lineNum));*/
+			}
+
+			// Iterate through all types to see if line inits or
+			// re-inits a variable then store it with it's value
+			else if (countInVector(types, trim(words.at(lineNum).at(0))) > 0)
+			{
+				//cout << words.at(lineNum).at(1) << "=" << unWrapVec(slice(words.at(lineNum), 3, -1)) << "=" << AnyAsString(EvalExpression(unWrapVec(slice(words.at(lineNum), 3, -1)), variableValues)) << endl;
+				globalVariableValues[words.at(lineNum).at(1)] = EvalExpression(unWrapVec(slice(words.at(lineNum), 3, -1)), globalVariableValues);
+			}
+			//			else if (words.at(lineNum).at(0) == "int") {
+			//				globalVariableValues[words.at(lineNum).at(1)] = stoi(words.at(lineNum).at(3));
+			//#if DEVELOPER_MESSAGES == true
+			//				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
+			//#endif
+			//			}
+			//			else if (words.at(lineNum).at(0) == "float") {
+			//				globalVariableValues[words.at(lineNum).at(1)] = stof(words.at(lineNum).at(3));
+			//#if DEVELOPER_MESSAGES == true
+			//				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
+			//#endif
+			//			}
+			//			else if (words.at(lineNum).at(0) == "bool") {
+			//				globalVariableValues[words.at(lineNum).at(1)] = stob(words.at(lineNum).at(3));
+			//#if DEVELOPER_MESSAGES == true
+			//				InterpreterLog("Load script variable " + words.at(lineNum).at(1) + "...");
+			//#endif
+			//			}
+			else
+				LogWarning("unrecognized type \'" + words.at(lineNum).at(0) + "\' on line: " + to_string(lineNum));
 		}
 	}
 
-	#if DEVELOPER_MESSAGES
-	InterpreterLog("Start Main()");
-	#endif
-	// Executes main, which is the starting function
-	ExecuteFunction("Main", vector<boost::any> {});
-
 	return 0;
 }
 
 int main(int argc, char* argv[])
 {
+	// Print the name of the interpreter and it's version in inverted black on white text
+	PrintColored(NAMEVERSION, blackFGColor, whiteBGColor, false);
+	cout << endl << endl;
+
 	// Gathers builtin functions and variables
-	GetBuiltins(ZSContents);
-	functionValues = builtinFunctionValues;
-	globalVariableValues = builtinVarVals;
+	parseZSharp(ZSContents);
+	//functionValues = builtinFunctionValues;
+	//globalVariableValues = builtinVarVals;
 
 	std::string scriptTextContents;
 
 	// If scriptname is supplied and not in developer mode
-	if (argc > 1)
+	if (argc > 1 || EXAMPLE_PROJECT)
 	{
-		std::string scriptPath = argv[1];
+		std::string scriptPath;
+		if (EXAMPLE_PROJECT)
+			scriptPath = "D:\\Code\\Z-Sharp\\examples\\Platformer\\script.zs";
+		else
+			scriptPath = argv[1];
 #if DEVELOPER_MESSAGES
 		cout << scriptPath << endl;
 #endif
+		if (!fileExists(scriptPath))
+			LogCriticalError("Failed to load script from path: \"" + scriptPath + "\"");
 
 		std::string projectDirectory = scriptPath.substr(0, scriptPath.find_last_of("/\\"));
 #if UNIX
-		// Get script contents
+		// Get script contents as single string
 		auto ss = ostringstream{};
 		ifstream input_file(scriptPath);
 		ss << input_file.rdbuf();
 		scriptTextContents = ss.str();
-		#if DEVELOPER_MESSAGES
+#if DEVELOPER_MESSAGES
 		InterpreterLog("Gather script contents...");
-		#endif
-		
-		chdir(projectDirectory.c_str());
-		#if DEVELOPER_MESSAGES
-		InterpreterLog("Change directory to " + projectDirectory + "...");
-		#endif
-		#if DEVELOPER_MESSAGES
-		string newPath = filesystem::current_path();
-		InterpreterLog("Current working directory is " + newPath);
-		#endif
+#endif
+
+		// Change the current working directory to that of the script
+		int chErr = chdir(projectDirectory.c_str());
+		if (chErr < 0)
+			LogCriticalError("Failed to change directory to: \"" + projectDirectory + "\", error num: " + to_string(chErr));
+
+#if DEVELOPER_MESSAGES
+		InterpreterLog("Changed directory to " + projectDirectory + "...");
+#endif
+
 #elif WINDOWS
-		// Get script contents
+		// Get script contents as single string
 		ifstream script(scriptPath);
 		stringstream scriptString;
 		scriptString << script.rdbuf();
 		scriptTextContents = scriptString.str();
-		#if DEVELOPER_MESSAGES
+#if DEVELOPER_MESSAGES
 		InterpreterLog("Gather script contents...");
-		#endif
-		
+#endif
+
+		// Change the current working directory to that of the script
 		std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
 		std::wstring wide = converter.from_bytes(projectDirectory);
 		LPCWSTR s = wide.c_str();
 		SetCurrentDirectory(s);
-		#if DEVELOPER_MESSAGES
-		InterpreterLog("Change directory to " + projectDirectory + "...");
-		#endif
+#if DEVELOPER_MESSAGES
+		InterpreterLog("Changed directory to " + projectDirectory + "...");
+#endif
 #endif
 	}
 	else
-	{
+	{ // If no script is provided as an argument throw error
 		LogWarning("No script provided! Please drag and drop .ZS file over interpreter executable file, or provide it's path as a command-line argument.");
-		cout << "Press Enter to Continue";
+		InterpreterLog("Press Enter to Exit...");
 		cin.ignore();
 		exit(1);
 	}
 
-	//system("pause");
-
-	#if DEVELOPER_MESSAGES
-	InterpreterLog("Parsing...");
-	#endif
-	parseZSharp(scriptTextContents);
-
-
 #if DEVELOPER_MESSAGES
-	cout << "Press Enter to Continue";
+	InterpreterLog("Parsing...");
+#endif
+	// Parse the script
+	parseZSharp(scriptTextContents);
+#if DEVELOPER_MESSAGES
+	InterpreterLog("Start Main()");
+#endif
+	try
+	{
+		// Executes main, which is the entry point function
+		ExecuteFunction("Main", vector<boost::any> {});
+	}
+	catch (const std::exception&)
+	{
+		//Failed with error
+	}
+
+	// Entire script has been run, exit.
+#if DEVELOPER_MESSAGES // If built with developer messages, then verify exit
+	InterpreterLog("Press Enter to Exit...");
 	cin.ignore();
 	exit(1);
-#endif
+#else
+	if (argc > 2)
+	{
+		string a = argv[2];
+		std::transform(a.begin(), a.end(), a.begin(),
+			[](unsigned char c) { return std::tolower(c); });
+
+		if (a == "-ve") // If the '-ve' (verify exit) option is used, ask for verification on exit
+		{
+			InterpreterLog("Press Enter to Exit...");
+			cin.ignore();
+			exit(1);
+		}
+	}
+	else if (AnyAsBool(GetVariableValue("EXIT_WHEN_DONE", globalVariableValues)) == false)
+	{
+		InterpreterLog("Press Enter to Exit...");
+		cin.ignore();
+		exit(1);
+	}
+#endif // Else exit automatically
 	return 0;
 }

ZSharp/ZS.h

@@ -1,13 +1,20 @@
-#include<string>
+#include <string>
 
 using namespace std;
 
 std::string ZSContents = R"(
+////////////////////////////////////////////////////////////////////////////////
+//  BUILTIN 
+////////////////////////////////////////////////////////////////////////////////
+
 // Default variables, can be overwritten
 // if re-initialized or changed
 float PI = 3.14159265358979323846264338
 float EulersNumber = 2.71828183
 
+// This variable tells the interpreter if it should close the console window when the program has finished running.
+bool EXIT_WHEN_DONE = true
+
 // Trigonometric function Sin
 func Sin(input)
 {
@@ -100,15 +107,15 @@ func SetPixel(x, y, r, g, b)
 }
 
 // Prints input value to console
-func Print(in)
+func Print(strToPrint)
 {
-	ZS.System.Print(in)
+	ZS.System.Print(strToPrint)
 }
 
 // Prints input value to console with appended newline '\n'
-func Printl(in)
+func Printl(strToPrint)
 {
-	ZS.System.PrintLine(in)
+	ZS.System.PrintLine(strToPrint)
 }
 
 // Creates new sprite class
@@ -137,5 +144,80 @@ func GetKey(keyName)
 	bool b = ZS.Input.GetKey(keyName)
 	return b
 }
+
+////////////////////////////
+// ↓ MADE BY KAPUTCHINO ↓ //
+////////////////////////////
+
+// Return the number of combinations
+func Comb(n, r)
+{
+    return Perm(n, r) / Fac(r)
+}
+
+// Return the factorial of a number
+func Fac(x)
+{
+    int r = 1
+    while x > 1
+    {
+        r = r * x
+        x = x - 1
+    }
+    return r
+}
+
+// Return exp(x) by using the taylor method, not extremly accurate
+func TaylorExp(x)
+{
+    float sum = 0
+    float term = 1
+    int i = 1
+    float sumterm = 1
+    while sum != sumterm
+    {
+        sum = sumterm
+        term = term * x / i
+        i = i + 1
+        sumterm = sumterm + term
+    }
+    return sum
+}
+
+// Return the number of permutations
+func Perm(n, r)
+{
+    if n < 0 
+    {
+        ZS.System.PrintLine("n must be superior or equal to 0")
+        return -1
+    }
+    if r < 0
+    {
+        ZS.System.PrintLine("r must be superior or equal to 0")
+        return -1
+    }
+    if r > n
+    {
+        ZS.System.PrintLine("r must be inferior or equal to n")
+        return -1
+    }
+    return Fac(n) / Fac(n - r)
+}
+
+//////////////////////////////////////////
+// ↓ MADE BY CONCHETUMARE_PRODUCTIONS ↓ //
+//////////////////////////////////////////
+func GetPercent(value, percent)
+{
+	float temp = value * percent / 100
+	return temp
+}
+//gets 100% of number
+func PercentToHundred(value, percent)
+{
+	float temp = value * 100 / percent
+	return temp
+}
 )"
-;
+;

ZSharp/ZSharp.vcxproj

@@ -83,13 +83,13 @@
     <LinkIncremental>true</LinkIncremental>
     <IncludePath>D:\Code\SDL2-2.0.18\include;D:\Code\SDL2_image-2.0.5\include;D:\Code\SDL2_ttf-2.0.15\include;$(IncludePath)</IncludePath>
     <LibraryPath>D:\Code\SDL2_ttf-2.0.15\lib\x64;D:\Code\SDL2-2.0.18\lib\x64;D:\Code\SDL2_image-2.0.5\lib\x64;$(LibraryPath)</LibraryPath>
-    <OutDir>$(SolutionDir)\Releases\$(ProjectName)</OutDir>
+    <OutDir>$(SolutionDir)\Releases\ZS_Win_Base_Raw</OutDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>D:\Code\SDL2-2.0.18\include;D:\Code\SDL2_image-2.0.5\include;D:\Code\SDL2_ttf-2.0.15\include;$(IncludePath)</IncludePath>
     <LibraryPath>D:\Code\SDL2_ttf-2.0.15\lib\x64;D:\Code\SDL2-2.0.18\lib\x64;D:\Code\SDL2_image-2.0.5\lib\x64;$(LibraryPath)</LibraryPath>
-    <OutDir>$(SolutionDir)\Releases\$(ProjectName)-Win-$(Platform)</OutDir>
+    <OutDir>$(SolutionDir)\Releases\ZS_Win_Base_Raw</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

ZSharp/ZSharpInstallerMakerInnoSetup.iss

@@ -0,0 +1,104 @@
+; Script generated by the Inno Setup Script Wizard.
+; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
+
+#define MyAppName "Z-Sharp"
+#define MyAppVersion "2.1.3-alpha"
+#define MyAppPublisher "AstroSam"
+#define MyAppURL "https://github.com/sam-astro/Z-Sharp"
+#define MyAppExeName "ZSharp.exe"
+#define MyAppAssocName MyAppName + " Script"
+#define MyAppAssocExt ".zs"
+#define MyAppAssocKey StringChange(MyAppAssocName, " ", "") + MyAppAssocExt
+
+[Setup]
+; NOTE: The value of AppId uniquely identifies this application. Do not use the same AppId value in installers for other applications.
+; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
+AppId={{F730397E-FCA8-4486-9469-C9C0D609D961}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+;AppVerName={#MyAppName} {#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+DefaultDirName={autopf}\ZSharp
+DisableDirPage=yes
+ChangesAssociations=yes
+DisableProgramGroupPage=yes
+ChangesEnvironment=true
+LicenseFile=D:\Code\Z-Sharp\LICENSE
+; Uncomment the following line to run in non administrative install mode (install for current user only.)
+;PrivilegesRequired=lowest
+PrivilegesRequiredOverridesAllowed=commandline
+OutputDir=D:\Code\Z-Sharp\Releases\ZSharp-Win-Installer
+OutputBaseFilename=ZSharp-Setup
+SetupIconFile=D:\Code\Z-Sharp\ExtraResources\installer-icon.ico
+Compression=lzma
+SolidCompression=yes
+WizardStyle=modern
+
+[Tasks]
+Name: modifypath; Description: Add application directory to your environmental path (This allows you to easily use from command line); Flags: unchecked
+
+[Code]
+const
+    ModPathName = 'modifypath';
+    ModPathType = 'system';
+
+function ModPathDir(): TArrayOfString;
+begin
+    setArrayLength(Result, 1)
+    Result[0] := ExpandConstant('{app}');
+end;
+#include "modpath.iss"
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+Name: "armenian"; MessagesFile: "compiler:Languages\Armenian.isl"
+Name: "brazilianportuguese"; MessagesFile: "compiler:Languages\BrazilianPortuguese.isl"
+Name: "bulgarian"; MessagesFile: "compiler:Languages\Bulgarian.isl"
+Name: "catalan"; MessagesFile: "compiler:Languages\Catalan.isl"
+Name: "corsican"; MessagesFile: "compiler:Languages\Corsican.isl"
+Name: "czech"; MessagesFile: "compiler:Languages\Czech.isl"
+Name: "danish"; MessagesFile: "compiler:Languages\Danish.isl"
+Name: "dutch"; MessagesFile: "compiler:Languages\Dutch.isl"
+Name: "finnish"; MessagesFile: "compiler:Languages\Finnish.isl"
+Name: "french"; MessagesFile: "compiler:Languages\French.isl"
+Name: "german"; MessagesFile: "compiler:Languages\German.isl"
+Name: "hebrew"; MessagesFile: "compiler:Languages\Hebrew.isl"
+Name: "icelandic"; MessagesFile: "compiler:Languages\Icelandic.isl"
+Name: "italian"; MessagesFile: "compiler:Languages\Italian.isl"
+Name: "japanese"; MessagesFile: "compiler:Languages\Japanese.isl"
+Name: "norwegian"; MessagesFile: "compiler:Languages\Norwegian.isl"
+Name: "polish"; MessagesFile: "compiler:Languages\Polish.isl"
+Name: "portuguese"; MessagesFile: "compiler:Languages\Portuguese.isl"
+Name: "russian"; MessagesFile: "compiler:Languages\Russian.isl"
+Name: "slovak"; MessagesFile: "compiler:Languages\Slovak.isl"
+Name: "slovenian"; MessagesFile: "compiler:Languages\Slovenian.isl"
+Name: "spanish"; MessagesFile: "compiler:Languages\Spanish.isl"
+Name: "turkish"; MessagesFile: "compiler:Languages\Turkish.isl"
+Name: "ukrainian"; MessagesFile: "compiler:Languages\Ukrainian.isl"
+
+[Files]
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\{#MyAppExeName}"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\libfreetype-6.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\libjpeg-9.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\libpng16-16.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\libtiff-5.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\libwebp-7.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\SDL2.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\SDL2_image.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\SDL2_ttf.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "D:\Code\Z-Sharp\Releases\ZS_Win_Base_Raw\zlib1.dll"; DestDir: "{app}"; Flags: ignoreversion
+; NOTE: Don't use "Flags: ignoreversion" on any shared system files
+
+[Registry]
+Root: HKA; Subkey: "Software\Classes\{#MyAppAssocExt}\OpenWithProgids"; ValueType: string; ValueName: "{#MyAppAssocKey}"; ValueData: ""; Flags: uninsdeletevalue
+Root: HKA; Subkey: "Software\Classes\{#MyAppAssocKey}"; ValueType: string; ValueName: ""; ValueData: "{#MyAppAssocName}"; Flags: uninsdeletekey
+Root: HKA; Subkey: "Software\Classes\{#MyAppAssocKey}\DefaultIcon"; ValueType: string; ValueName: ""; ValueData: "{app}\{#MyAppExeName},0"
+Root: HKA; Subkey: "Software\Classes\{#MyAppAssocKey}\shell\open\command"; ValueType: string; ValueName: ""; ValueData: """{app}\{#MyAppExeName}"" ""%1"""
+Root: HKA; Subkey: "Software\Classes\Applications\{#MyAppExeName}\SupportedTypes"; ValueType: string; ValueName: ".myp"; ValueData: ""
+
+[Icons]
+Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
+

ZSharp/builtin.h

@@ -1,6 +1,14 @@
 #ifndef BUILTIN_H
 #define BUILTIN_H
 
+#if defined(__unix__)
+#define UNIX true
+#define WINDOWS false
+#elif defined(_MSC_VER)
+#define UNIX false
+#define WINDOWS true
+#endif
+
 #include <iostream>
 #include <fstream>
 #include <string>
@@ -8,13 +16,19 @@
 #include <limits>
 #include <algorithm>
 #include <unordered_map>
-#include "strops.h"
-#include "graphics.h"
-#include "anyops.h"
 #include <boost/any.hpp>
 #include <SDL.h>
 #include <ctime>
 #include <math.h>
+#include <sys/stat.h>
+#include <cstdlib> // for console command printing
+
+#include "strops.h"
+#include "graphics.h"
+#include "anyops.h"
+#if WINDOWS
+#include "color.hpp"
+#endif
 
 //#define DEVELOPER_MESSAGES false
 
@@ -23,15 +37,57 @@ using namespace boost;
 
 vector<string> types = { "int", "float", "string", "bool", "void", "null", "Sprite", "Vec2", "Text" };
 
-unordered_map<string, vector<vector<string>>> builtinFunctionValues;
-unordered_map<string, boost::any> builtinVarVals;
+//unordered_map<string, vector<vector<string>>> builtinFunctionValues;
+//unordered_map<string, boost::any> builtinVarVals;
+
+// Foreground colors
+const std::string blackFGColor = "\x1B[30m";
+const std::string redFGColor = "\x1B[31m";
+const std::string greenFGColor = "\x1B[32m";
+const std::string yellowFGColor = "\x1B[33m";
+const std::string blueFGColor = "\x1B[34m";
+const std::string magentaFGColor = "\x1B[35m";
+const std::string cyanFGColor = "\x1B[36m";
+const std::string whiteFGColor = "\x1B[37m";
+const std::string brightBlackFGColor = "\x1B[90m";
+const std::string brightRedFGColor = "\x1B[91m";
+const std::string brightGreenFGColor = "\x1B[92m";
+const std::string brightYellowFGColor = "\x1B[93m";
+const std::string brightBlueFGColor = "\x1B[94m";
+const std::string brightMagentaFGColor = "\x1B[95m";
+const std::string brightCyanFGColor = "\x1B[96m";
+const std::string brightWhiteFGColor = "\x1B[97m";
+//Background colors
+const std::string blackBGColor = "\x1B[40m";
+const std::string redBGColor = "\x1B[41m";
+const std::string greenBGColor = "\x1B[42m";
+const std::string yellowBGColor = "\x1B[43m";
+const std::string blueBGColor = "\x1B[44m";
+const std::string magentaBGColor = "\x1B[45m";
+const std::string cyanBGColor = "\x1B[46m";
+const std::string whiteBGColor = "\x1B[47m";
+const std::string brightBlackBGColor = "\x1B[100m";
+const std::string brightRedBGColor = "\x1B[101m";
+const std::string brightGreenBGColor = "\x1B[102m";
+const std::string brightYellowBGColor = "\x1B[103m";
+const std::string brightBlueBGColor = "\x1B[104m";
+const std::string brightMagentaBGColor = "\x1B[105m";
+const std::string brightCyanBGColor = "\x1B[106m";
+const std::string brightWhiteBGColor = "\x1B[107m";
+// Reset color
+const std::string resetColor = "\033[0m";
 
 class NullType {
 public:
 	string type = "NULL";
 };
+class BREAK {
+public:
+	string type = "BREAK";
+};
 
 boost::any nullType;
+boost::any breakReOp;
 
 float clamp(float v, float min, float max)
 {
@@ -45,9 +101,63 @@ float lerp(float a, float b, float f)
 	return a + f * (b - a);
 }
 
+inline bool fileExists(const std::string& name) {
+	struct stat buffer;
+	return (stat(name.c_str(), &buffer) == 0);
+}
+
+void PrintColored(std::string text, std::string fgColor, std::string bgColor, bool isError)
+{
+#if WINDOWS
+	if (fgColor == blackFGColor)
+		cerr << hue::black;
+	else if (fgColor == redFGColor)
+		cerr << hue::red;
+	else if (fgColor == greenFGColor)
+		cerr << hue::green;
+	else if (fgColor == yellowFGColor)
+		cerr << hue::yellow;
+	else if (fgColor == blueFGColor)
+		cerr << hue::blue;
+	else if (fgColor == magentaFGColor)
+		cerr << hue::purple;
+	else if (fgColor == cyanFGColor)
+		cerr << hue::aqua;
+	else if (fgColor == whiteFGColor)
+		cerr << hue::white;
+
+	if (bgColor == blackBGColor)
+		cerr << hue::on_black;
+	else if (bgColor == redBGColor)
+		cerr << hue::on_red;
+	else if (bgColor == greenBGColor)
+		cerr << hue::on_green;
+	else if (bgColor == yellowBGColor)
+		cerr << hue::on_yellow;
+	else if (bgColor == blueBGColor)
+		cerr << hue::on_blue;
+	else if (bgColor == magentaBGColor)
+		cerr << hue::on_purple;
+	else if (bgColor == cyanBGColor)
+		cerr << hue::on_aqua;
+	else if (bgColor == whiteBGColor)
+		cerr << hue::on_white;
+
+	std::cerr << text << hue::reset;
+#else
+	if (!isError)
+		cout << fgColor + bgColor + text + resetColor;
+	else
+		cerr << fgColor + bgColor + text + resetColor;
+#endif
+}
+
 int LogWarning(const string& warningText)
 {
-	cout << "\x1B[33mWARNING: " << warningText << "\033[0m\t\t" << endl;
+	PrintColored("WARNING: ", yellowFGColor, "", true);
+	PrintColored(escaped(warningText), yellowFGColor, "", true);
+	cerr << std::endl;
+	//cout << "\x1B[33mWARNING: " << warningText << "\033[0m\t\t" << endl;
 	return 1;
 }
 
@@ -60,9 +170,17 @@ int InterpreterLog(const string& logText)
 	time_t timer = time(0);
 
 	tm bt{};
-#if defined(__unix__)
-	//localtime_r(&timer, &bt);
-#elif defined(_MSC_VER)
+#if UNIX
+	time_t currentTime;
+	struct tm* localTime;
+
+	time(&currentTime);                   // Get the current time
+	localTime = localtime(&currentTime);  // Convert the current time to the local time
+
+	Hour = localTime->tm_hour;
+	Min = localTime->tm_min;
+	Sec = localTime->tm_sec;
+#elif WINDOWS
 	localtime_s(&bt, &timer);
 	Hour = bt.tm_hour;
 	Min = bt.tm_min;
@@ -73,7 +191,11 @@ int InterpreterLog(const string& logText)
 	bt = *localtime(&timer);
 #endif
 
-	cout << "\x1B[34m[" + to_string(Hour) + ":" + to_string(Min) + ":" + to_string(Sec) + "] \x1B[33mZSharp: \x1B[32m" << logText << "\033[0m\t\t" << endl;
+	PrintColored("[" + to_string(Hour) + ":" + to_string(Min) + ":" + to_string(Sec) + "] ", blueFGColor, "", true);
+	PrintColored("ZSharp: ", yellowFGColor, "", true);
+	PrintColored(escaped(logText), greenFGColor, "", true);
+	cout << std::endl;
+	//cout << "\x1B[34m[" + to_string(Hour) + ":" + to_string(Min) + ":" + to_string(Sec) + "] \x1B[33mZSharp: \x1B[32m" << logText << "\033[0m\t\t" << endl;
 	return 1;
 }
 
@@ -85,9 +207,17 @@ int LogCriticalError(const string& errorText)
 	time_t timer = time(0);
 
 	tm bt{};
-#if defined(__unix__)
-	//localtime_r(&timer, &bt);
-#elif defined(_MSC_VER)
+#if UNIX
+	time_t currentTime;
+	struct tm* localTime;
+
+	time(&currentTime);                   // Get the current time
+	localTime = localtime(&currentTime);  // Convert the current time to the local time
+
+	Hour = localTime->tm_hour;
+	Min = localTime->tm_min;
+	Sec = localTime->tm_sec;
+#elif WINDOWS
 	localtime_s(&bt, &timer);
 	Hour = bt.tm_hour;
 	Min = bt.tm_min;
@@ -98,8 +228,15 @@ int LogCriticalError(const string& errorText)
 	bt = *localtime(&timer);
 #endif
 
-	cerr << "\x1B[34m[" + to_string(Hour) + ":" + to_string(Min) + ":" + to_string(Sec) + "] \x1B[33mZSharp: \x1B[31mERROR: " << errorText << "\033[0m\t\t" << endl;
-	exit(EXIT_FAILURE);
+	PrintColored("[" + to_string(Hour) + ":" + to_string(Min) + ":" + to_string(Sec) + "] ", blueFGColor, "", true);
+	PrintColored("ZSharp: ", yellowFGColor, "", true);
+	PrintColored(escaped(errorText), redFGColor, "", true);
+	cerr << std::endl;
+	InterpreterLog("Press Enter to Exit...");
+	cin.ignore();
+	exit(1);
+	//cerr << "\x1B[34m[" + to_string(Hour) + ":" + to_string(Min) + ":" + to_string(Sec) + "] \x1B[33mZSharp: \x1B[31mERROR: " << errorText << "\033[0m\t\t" << endl;
+	//exit(EXIT_FAILURE);
 	return 2;
 }
 
@@ -169,90 +306,90 @@ bool AxisAlignedCollision(const Sprite& a, const Sprite& b) // AABB - AABB colli
 	return collisionX && collisionY;
 }
 
-// Initial script processing, which loads variables and functions from builtin
-int GetBuiltins(std::string s)
-{
-	std::string script = replace(s, "    ", "\t");
-
-	vector<string> lines = split(script, '\n');
-	vector<vector<string>> words;
-	for (int i = 0; i < (int)lines.size(); i++)
-	{
-		words.push_back(split(lines.at(i), ' '));
-	}
-
-	// Go through entire script and iterate through all types to see if line is a
-	// function declaration, then store it with it's value
-	for (int lineNum = 0; lineNum < (int)words.size(); lineNum++)
-	{
-		//Checks if it is function
-		if (words.at(lineNum).at(0) == "func")
-		{
-			vector<vector<string>> functionContents;
-
-			string functName = split(words.at(lineNum).at(1), '(')[0];
-
-#if DEVELOPER_MESSAGES == true
-			InterpreterLog("Load builtin function " + functName + "...");
-#endif
-
-			string args = "";
-			for (int w = 1; w < (int)words.at(lineNum).size(); w++) // Get all words from the instantiation line: these are the args
-			{
-				args += replace(replace(words.at(lineNum).at(w), "(", " "), ")", "");
-			}
-
-			args = replace(args, functName + " ", "");
-			functionContents.push_back(split(args, ','));
-
-			int numOfBrackets = 1;
-			for (int p = lineNum + 2; p < (int)words.size(); p++)
-			{
-				numOfBrackets += countInVector(words.at(p), "{") - countInVector(words.at(p), "}");
-				if (numOfBrackets == 0)
-					break;
-				functionContents.push_back(removeTabs(words.at(p), 1));
-			}
-			builtinFunctionValues[functName] = functionContents;
-			//cout << functName << " is \n" << Vec2Str(functionContents) << endl << endl;
-		}
-		else
-		{
-			if (words.at(lineNum).at(0) == "string")
-			{
-				builtinVarVals[words.at(lineNum).at(1)] = StringRaw(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
-#endif
-			}
-			else if (words.at(lineNum).at(0) == "int")
-			{
-				builtinVarVals[words.at(lineNum).at(1)] = stoi(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
-#endif
-			}
-			else if (words.at(lineNum).at(0) == "float")
-			{
-				builtinVarVals[words.at(lineNum).at(1)] = stof(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
-#endif
-			}
-			else if (words.at(lineNum).at(0) == "bool")
-			{
-				builtinVarVals[words.at(lineNum).at(1)] = stob(words.at(lineNum).at(3));
-#if DEVELOPER_MESSAGES == true
-				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
-#endif
-			}
-			//else
-			//	LogWarning("unrecognized type \'" + words[lineNum][0] + "\' on line: " + to_string(lineNum));
-		}
-	}
-
-	return 0;
-}
+//// Initial script processing, which loads variables and functions from builtin
+//int GetBuiltins(std::string s)
+//{
+//	std::string script = replace(s, "    ", "\t");
+//
+//	vector<string> lines = split(script, '\n');
+//	vector<vector<string>> words;
+//	for (int i = 0; i < (int)lines.size(); i++)
+//	{
+//		words.push_back(split(lines.at(i), ' '));
+//	}
+//
+//	// Go through entire script and iterate through all types to see if line is a
+//	// function declaration, then store it with it's value
+//	for (int lineNum = 0; lineNum < (int)words.size(); lineNum++)
+//	{
+//		//Checks if it is function
+//		if (words.at(lineNum).at(0) == "func")
+//		{
+//			vector<vector<string>> functionContents;
+//
+//			string functName = split(words.at(lineNum).at(1), '(')[0];
+//
+//#if DEVELOPER_MESSAGES == true
+//			InterpreterLog("Load builtin function " + functName + "...");
+//#endif
+//
+//			string args = "";
+//			for (int w = 1; w < (int)words.at(lineNum).size(); w++) // Get all words from the instantiation line: these are the args
+//			{
+//				args += replace(replace(words.at(lineNum).at(w), "(", " "), ")", "");
+//			}
+//
+//			args = replace(args, functName + " ", "");
+//			functionContents.push_back(split(args, ','));
+//
+//			int numOfBrackets = 1;
+//			for (int p = lineNum + 2; p < (int)words.size(); p++)
+//			{
+//				numOfBrackets += countInVector(words.at(p), "{") - countInVector(words.at(p), "}");
+//				if (numOfBrackets == 0)
+//					break;
+//				functionContents.push_back(removeTabs(words.at(p), 1));
+//			}
+//			builtinFunctionValues[functName] = functionContents;
+//			//cout << functName << " is \n" << Vec2Str(functionContents) << endl << endl;
+//		}
+//		else
+//		{
+//			if (words.at(lineNum).at(0) == "string")
+//			{
+//				builtinVarVals[words.at(lineNum).at(1)] = StringRaw(words.at(lineNum).at(3));
+//#if DEVELOPER_MESSAGES == true
+//				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
+//#endif
+//			}
+//			else if (words.at(lineNum).at(0) == "int")
+//			{
+//				builtinVarVals[words.at(lineNum).at(1)] = stoi(words.at(lineNum).at(3));
+//#if DEVELOPER_MESSAGES == true
+//				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
+//#endif
+//			}
+//			else if (words.at(lineNum).at(0) == "float")
+//			{
+//				builtinVarVals[words.at(lineNum).at(1)] = stof(words.at(lineNum).at(3));
+//#if DEVELOPER_MESSAGES == true
+//				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
+//#endif
+//			}
+//			else if (words.at(lineNum).at(0) == "bool")
+//			{
+//				builtinVarVals[words.at(lineNum).at(1)] = stob(words.at(lineNum).at(3));
+//#if DEVELOPER_MESSAGES == true
+//				InterpreterLog("Load builtin variable " + words.at(lineNum).at(1) + "...");
+//#endif
+//			}
+//			//else
+//			//	LogWarning("unrecognized type \'" + words[lineNum][0] + "\' on line: " + to_string(lineNum));
+//		}
+//	}
+//
+//	return 0;
+//}
 
 // Executes 
 boost::any ZSFunction(const string& name, const vector<boost::any>& args)
@@ -274,21 +411,51 @@ boost::any ZSFunction(const string& name, const vector<boost::any>& args)
 #if DEVELOPER_MESSAGES == true
 		InterpreterLog("Init graphics");
 #endif
-		initGraphics(StringRaw(AnyAsString(args.at(0))), AnyAsInt(args.at(1)), AnyAsInt(args.at(2)));
+		if (args.size() <= 3)
+			initGraphics(StringRaw(AnyAsString(args.at(0))), AnyAsInt(args.at(1)), AnyAsInt(args.at(2)), 1);
+		else
+			initGraphics(StringRaw(AnyAsString(args.at(0))), AnyAsInt(args.at(1)), AnyAsInt(args.at(2)), AnyAsInt(args.at(3)));
 	}
 	else if (name == "ZS.Graphics.Sprite")
 	{
+		string path = StringRaw(AnyAsString(args.at(0)));
+		if (count(path, '/') == 0)
+			path = "./" + path;
+		if (!fileExists(path))
+			LogCriticalError("Failed to create 'Sprite' object: \"" + path + "\"");
+
 		Sprite s(StringRaw(AnyAsString(args.at(0))), any_cast<Vec2>(args.at(1)), any_cast<Vec2>(args.at(2)), AnyAsFloat(args.at(3)));
 		return s;
 	}
+	else if (name == "ZS.Graphics.DrawPixel")
+	{
+		SDL_SetRenderDrawColor(gRenderer, AnyAsInt(args.at(2)), AnyAsInt(args.at(3)), AnyAsInt(args.at(4)), 255);
+		SDL_RenderDrawPoint(gRenderer, AnyAsInt(args.at(0)), AnyAsInt(args.at(1)));
+		SDL_SetRenderDrawColor(gRenderer, 0, 0, 0, 0);
+	}
+		//DrawPixel(AnyAsInt(args.at(0)), AnyAsInt(args.at(1)), AnyAsInt(args.at(2)), AnyAsInt(args.at(3)), AnyAsInt(args.at(4)));
 	else if (name == "ZS.Graphics.Draw")
 		any_cast<Sprite>(args.at(0)).Draw();
 	else if (name == "ZS.Graphics.Load")
 		any_cast<Sprite>(args.at(0)).Load();
 	else if (name == "ZS.Graphics.Text")
 	{
-		Text t(StringRaw(AnyAsString(args.at(0))), StringRaw(AnyAsString(args.at(1))), any_cast<Vec2>(args.at(2)), AnyAsFloat(args.at(3)), AnyAsFloat(args.at(4)), (Uint8)AnyAsFloat(args.at(5)), (Uint8)AnyAsFloat(args.at(6)), (Uint8)AnyAsFloat(args.at(7)));
-		return t;
+		string path = StringRaw(AnyAsString(args.at(1)));
+		if (count(path, '/') == 0)
+			path = "./" + path;
+		if (!fileExists(path))
+			LogCriticalError("Failed to create 'Text' object: \"" + path + "\"");
+
+		if (args.size() <= 8)
+		{
+			Text t(StringRaw(AnyAsString(args.at(0))), path, any_cast<Vec2>(args.at(2)), AnyAsFloat(args.at(3)), AnyAsFloat(args.at(4)), (Uint8)AnyAsFloat(args.at(5)), (Uint8)AnyAsFloat(args.at(6)), (Uint8)AnyAsFloat(args.at(7)), true);
+			return t;
+		}
+		else
+		{
+			Text t(StringRaw(AnyAsString(args.at(0))), path, any_cast<Vec2>(args.at(2)), AnyAsFloat(args.at(3)), AnyAsFloat(args.at(4)), (Uint8)AnyAsFloat(args.at(5)), (Uint8)AnyAsFloat(args.at(6)), (Uint8)AnyAsFloat(args.at(7)), AnyAsBool(args.at(8)));
+			return t;
+		}
 	}
 	else if (name == "ZS.Graphics.DrawText")
 		any_cast<Text>(args.at(0)).Draw();
@@ -309,6 +476,13 @@ boost::any ZSFunction(const string& name, const vector<boost::any>& args)
 		Vec2 v(AnyAsFloat(args.at(0)), AnyAsFloat(args.at(1)));
 		return v;
 	}
+	else if (name == "ZS.System.Command"){
+		string command = StringRaw(AnyAsString(args.at(0)));
+		//int command_len = command.length();
+		//char* command_char_arr=new char[command_len + 1];
+		//strcpy(command_char_arr, command.c_str()); // string into char arr
+		int k = system(command.c_str());
+	}
 	else
 		LogWarning("ZS function \'" + name + "\' does not exist.");
 

ZSharp/color.hpp

@@ -0,0 +1,878 @@
+#ifndef COLOR_HPP
+#define COLOR_HPP
+
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <windows.h>
+
+namespace hue
+{
+    constexpr int DEFAULT_COLOR = 7;
+    constexpr int BAD_COLOR = -256;
+
+    const std::map<std::string, int> CODES = {
+        {"black",            0}, {"k",   0},
+        {"blue",             1}, {"b",   1},
+        {"green",            2}, {"g",   2},
+        {"aqua",             3}, {"a",   3},
+        {"red",              4}, {"r",   4},
+        {"purple",           5}, {"p",   5},
+        {"yellow",           6}, {"y",   6},
+        {"white",            7}, {"w",   7},
+        {"grey",             8}, {"e",   8},
+        {"light blue",       9}, {"lb",  9},
+        {"light green",     10}, {"lg", 10},
+        {"light aqua",      11}, {"la", 11},
+        {"light red",       12}, {"lr", 12},
+        {"light purple",    13}, {"lp", 13},
+        {"light yellow",    14}, {"ly", 14},
+        {"bright white",    15}, {"bw", 15}
+    };
+
+    const std::map<int, std::string> NAMES = {
+        { 0, "black"},
+        { 1, "blue"},
+        { 2, "green"},
+        { 3, "aqua"},
+        { 4, "red"},
+        { 5, "purple"},
+        { 6, "yellow"},
+        { 7, "white"},
+        { 8, "grey"},
+        { 9, "light blue"},
+        {10, "light green"},
+        {11, "light aqua"},
+        {12, "light red"},
+        {13, "light purple"},
+        {14, "light yellow"},
+        {15, "bright white"}
+    };
+
+    inline bool is_good(int c)
+    {
+        return 0 <= c && c < 256;
+    }
+
+    inline int itoc(int c)
+    {
+        return is_good(c) ? c : BAD_COLOR;
+    }
+
+    inline int itoc(int a, int b)
+    {
+        return itoc(a + b * 16);
+    }
+
+    // std::string to color
+    int stoc(std::string a)
+    {
+        // convert s to lowercase, and format variants like  "light_blue"
+        std::transform(a.begin(), a.end(), a.begin(), [](char c)
+            {
+                if ('A' <= c && c <= 'Z')
+                    c = c - 'A' + 'a';
+                else if (c == '_' || c == '-')
+                    c = ' ';
+                return c;
+            });
+
+        // operator[] on std::map is non-const, use std::map::at instead
+        return (CODES.find(a) != CODES.end()) ? CODES.at(a) : BAD_COLOR;
+    }
+
+    int stoc(std::string a, std::string b)
+    {
+        return itoc(stoc(a), stoc(b));
+    }
+
+    std::string ctos(int c)
+    {
+        return (0 <= c && c < 256) ?
+            "(text) " + NAMES.at(c % 16) + " + " +
+            "(background) " + NAMES.at(c / 16) :
+            "BAD COLOR";
+    }
+
+    int get()
+    {
+        CONSOLE_SCREEN_BUFFER_INFO i;
+        return GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &i) ?
+            i.wAttributes : BAD_COLOR;
+    }
+
+    int get_text()
+    {
+        return (get() != BAD_COLOR) ? get() % 16 : BAD_COLOR;
+    }
+
+    int get_background()
+    {
+        return (get() != BAD_COLOR) ? get() / 16 : BAD_COLOR;
+    }
+
+    void set(int c)
+    {
+        if (is_good(c))
+            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c);
+    }
+
+    void set(int a, int b)
+    {
+        set(a + b * 16);
+    }
+
+    void set(std::string a, std::string b)
+    {
+        set(stoc(a) + stoc(b) * 16);
+    }
+
+    void set_text(std::string a)
+    {
+        set(stoc(a), get_background());
+    }
+
+    void set_background(std::string b)
+    {
+        set(get_text(), stoc(b));
+    }
+
+    void reset()
+    {
+        set(DEFAULT_COLOR);
+    }
+
+    int invert(int c)
+    {
+        if (is_good(c)) {
+            int a = c % 16;
+            int b = c / 16;
+            return b + a * 16;
+        }
+        else
+            return BAD_COLOR;
+    }
+
+    std::ostream& reset(std::ostream& os) { reset();                return os; }
+    std::ostream& black(std::ostream& os) { set_text("k");          return os; }
+    std::ostream& blue(std::ostream& os) { set_text("b");          return os; }
+    std::ostream& green(std::ostream& os) { set_text("g");          return os; }
+    std::ostream& aqua(std::ostream& os) { set_text("a");          return os; }
+    std::ostream& red(std::ostream& os) { set_text("r");          return os; }
+    std::ostream& purple(std::ostream& os) { set_text("p");          return os; }
+    std::ostream& yellow(std::ostream& os) { set_text("y");          return os; }
+    std::ostream& white(std::ostream& os) { set_text("w");          return os; }
+    std::ostream& grey(std::ostream& os) { set_text("e");          return os; }
+    std::ostream& light_blue(std::ostream& os) { set_text("lb");         return os; }
+    std::ostream& light_green(std::ostream& os) { set_text("lg");         return os; }
+    std::ostream& light_aqua(std::ostream& os) { set_text("la");         return os; }
+    std::ostream& light_red(std::ostream& os) { set_text("lr");         return os; }
+    std::ostream& light_purple(std::ostream& os) { set_text("lp");         return os; }
+    std::ostream& light_yellow(std::ostream& os) { set_text("ly");         return os; }
+    std::ostream& bright_white(std::ostream& os) { set_text("bw");         return os; }
+    std::ostream& on_black(std::ostream& os) { set_background("k");    return os; }
+    std::ostream& on_blue(std::ostream& os) { set_background("b");    return os; }
+    std::ostream& on_green(std::ostream& os) { set_background("g");    return os; }
+    std::ostream& on_aqua(std::ostream& os) { set_background("a");    return os; }
+    std::ostream& on_red(std::ostream& os) { set_background("r");    return os; }
+    std::ostream& on_purple(std::ostream& os) { set_background("p");    return os; }
+    std::ostream& on_yellow(std::ostream& os) { set_background("y");    return os; }
+    std::ostream& on_white(std::ostream& os) { set_background("w");    return os; }
+    std::ostream& on_grey(std::ostream& os) { set_background("e");    return os; }
+    std::ostream& on_light_blue(std::ostream& os) { set_background("lb");   return os; }
+    std::ostream& on_light_green(std::ostream& os) { set_background("lg");   return os; }
+    std::ostream& on_light_aqua(std::ostream& os) { set_background("la");   return os; }
+    std::ostream& on_light_red(std::ostream& os) { set_background("lr");   return os; }
+    std::ostream& on_light_purple(std::ostream& os) { set_background("lp");   return os; }
+    std::ostream& on_light_yellow(std::ostream& os) { set_background("ly");   return os; }
+    std::ostream& on_bright_white(std::ostream& os) { set_background("bw");   return os; }
+    std::ostream& black_on_black(std::ostream& os) { set("k", "k");   return os; }
+    std::ostream& black_on_blue(std::ostream& os) { set("k", "b");   return os; }
+    std::ostream& black_on_green(std::ostream& os) { set("k", "g");   return os; }
+    std::ostream& black_on_aqua(std::ostream& os) { set("k", "a");   return os; }
+    std::ostream& black_on_red(std::ostream& os) { set("k", "r");   return os; }
+    std::ostream& black_on_purple(std::ostream& os) { set("k", "p");   return os; }
+    std::ostream& black_on_yellow(std::ostream& os) { set("k", "y");   return os; }
+    std::ostream& black_on_white(std::ostream& os) { set("k", "w");   return os; }
+    std::ostream& black_on_grey(std::ostream& os) { set("k", "e");   return os; }
+    std::ostream& black_on_light_blue(std::ostream& os) { set("k", "lb");  return os; }
+    std::ostream& black_on_light_green(std::ostream& os) { set("k", "lg");  return os; }
+    std::ostream& black_on_light_aqua(std::ostream& os) { set("k", "la");  return os; }
+    std::ostream& black_on_light_red(std::ostream& os) { set("k", "lr");  return os; }
+    std::ostream& black_on_light_purple(std::ostream& os) { set("k", "lp");  return os; }
+    std::ostream& black_on_light_yellow(std::ostream& os) { set("k", "ly");  return os; }
+    std::ostream& black_on_bright_white(std::ostream& os) { set("k", "bw");  return os; }
+    std::ostream& blue_on_black(std::ostream& os) { set("b", "k");   return os; }
+    std::ostream& blue_on_blue(std::ostream& os) { set("b", "b");   return os; }
+    std::ostream& blue_on_green(std::ostream& os) { set("b", "g");   return os; }
+    std::ostream& blue_on_aqua(std::ostream& os) { set("b", "a");   return os; }
+    std::ostream& blue_on_red(std::ostream& os) { set("b", "r");   return os; }
+    std::ostream& blue_on_purple(std::ostream& os) { set("b", "p");   return os; }
+    std::ostream& blue_on_yellow(std::ostream& os) { set("b", "y");   return os; }
+    std::ostream& blue_on_white(std::ostream& os) { set("b", "w");   return os; }
+    std::ostream& blue_on_grey(std::ostream& os) { set("b", "e");   return os; }
+    std::ostream& blue_on_light_blue(std::ostream& os) { set("b", "lb");  return os; }
+    std::ostream& blue_on_light_green(std::ostream& os) { set("b", "lg");  return os; }
+    std::ostream& blue_on_light_aqua(std::ostream& os) { set("b", "la");  return os; }
+    std::ostream& blue_on_light_red(std::ostream& os) { set("b", "lr");  return os; }
+    std::ostream& blue_on_light_purple(std::ostream& os) { set("b", "lp");  return os; }
+    std::ostream& blue_on_light_yellow(std::ostream& os) { set("b", "ly");  return os; }
+    std::ostream& blue_on_bright_white(std::ostream& os) { set("b", "bw");  return os; }
+    std::ostream& green_on_black(std::ostream& os) { set("g", "k");   return os; }
+    std::ostream& green_on_blue(std::ostream& os) { set("g", "b");   return os; }
+    std::ostream& green_on_green(std::ostream& os) { set("g", "g");   return os; }
+    std::ostream& green_on_aqua(std::ostream& os) { set("g", "a");   return os; }
+    std::ostream& green_on_red(std::ostream& os) { set("g", "r");   return os; }
+    std::ostream& green_on_purple(std::ostream& os) { set("g", "p");   return os; }
+    std::ostream& green_on_yellow(std::ostream& os) { set("g", "y");   return os; }
+    std::ostream& green_on_white(std::ostream& os) { set("g", "w");   return os; }
+    std::ostream& green_on_grey(std::ostream& os) { set("g", "e");   return os; }
+    std::ostream& green_on_light_blue(std::ostream& os) { set("g", "lb");  return os; }
+    std::ostream& green_on_light_green(std::ostream& os) { set("g", "lg");  return os; }
+    std::ostream& green_on_light_aqua(std::ostream& os) { set("g", "la");  return os; }
+    std::ostream& green_on_light_red(std::ostream& os) { set("g", "lr");  return os; }
+    std::ostream& green_on_light_purple(std::ostream& os) { set("g", "lp");  return os; }
+    std::ostream& green_on_light_yellow(std::ostream& os) { set("g", "ly");  return os; }
+    std::ostream& green_on_bright_white(std::ostream& os) { set("g", "bw");  return os; }
+    std::ostream& aqua_on_black(std::ostream& os) { set("a", "k");   return os; }
+    std::ostream& aqua_on_blue(std::ostream& os) { set("a", "b");   return os; }
+    std::ostream& aqua_on_green(std::ostream& os) { set("a", "g");   return os; }
+    std::ostream& aqua_on_aqua(std::ostream& os) { set("a", "a");   return os; }
+    std::ostream& aqua_on_red(std::ostream& os) { set("a", "r");   return os; }
+    std::ostream& aqua_on_purple(std::ostream& os) { set("a", "p");   return os; }
+    std::ostream& aqua_on_yellow(std::ostream& os) { set("a", "y");   return os; }
+    std::ostream& aqua_on_white(std::ostream& os) { set("a", "w");   return os; }
+    std::ostream& aqua_on_grey(std::ostream& os) { set("a", "e");   return os; }
+    std::ostream& aqua_on_light_blue(std::ostream& os) { set("a", "lb");  return os; }
+    std::ostream& aqua_on_light_green(std::ostream& os) { set("a", "lg");  return os; }
+    std::ostream& aqua_on_light_aqua(std::ostream& os) { set("a", "la");  return os; }
+    std::ostream& aqua_on_light_red(std::ostream& os) { set("a", "lr");  return os; }
+    std::ostream& aqua_on_light_purple(std::ostream& os) { set("a", "lp");  return os; }
+    std::ostream& aqua_on_light_yellow(std::ostream& os) { set("a", "ly");  return os; }
+    std::ostream& aqua_on_bright_white(std::ostream& os) { set("a", "bw");  return os; }
+    std::ostream& red_on_black(std::ostream& os) { set("r", "k");   return os; }
+    std::ostream& red_on_blue(std::ostream& os) { set("r", "b");   return os; }
+    std::ostream& red_on_green(std::ostream& os) { set("r", "g");   return os; }
+    std::ostream& red_on_aqua(std::ostream& os) { set("r", "a");   return os; }
+    std::ostream& red_on_red(std::ostream& os) { set("r", "r");   return os; }
+    std::ostream& red_on_purple(std::ostream& os) { set("r", "p");   return os; }
+    std::ostream& red_on_yellow(std::ostream& os) { set("r", "y");   return os; }
+    std::ostream& red_on_white(std::ostream& os) { set("r", "w");   return os; }
+    std::ostream& red_on_grey(std::ostream& os) { set("r", "e");   return os; }
+    std::ostream& red_on_light_blue(std::ostream& os) { set("r", "lb");  return os; }
+    std::ostream& red_on_light_green(std::ostream& os) { set("r", "lg");  return os; }
+    std::ostream& red_on_light_aqua(std::ostream& os) { set("r", "la");  return os; }
+    std::ostream& red_on_light_red(std::ostream& os) { set("r", "lr");  return os; }
+    std::ostream& red_on_light_purple(std::ostream& os) { set("r", "lp");  return os; }
+    std::ostream& red_on_light_yellow(std::ostream& os) { set("r", "ly");  return os; }
+    std::ostream& red_on_bright_white(std::ostream& os) { set("r", "bw");  return os; }
+    std::ostream& purple_on_black(std::ostream& os) { set("p", "k");   return os; }
+    std::ostream& purple_on_blue(std::ostream& os) { set("p", "b");   return os; }
+    std::ostream& purple_on_green(std::ostream& os) { set("p", "g");   return os; }
+    std::ostream& purple_on_aqua(std::ostream& os) { set("p", "a");   return os; }
+    std::ostream& purple_on_red(std::ostream& os) { set("p", "r");   return os; }
+    std::ostream& purple_on_purple(std::ostream& os) { set("p", "p");   return os; }
+    std::ostream& purple_on_yellow(std::ostream& os) { set("p", "y");   return os; }
+    std::ostream& purple_on_white(std::ostream& os) { set("p", "w");   return os; }
+    std::ostream& purple_on_grey(std::ostream& os) { set("p", "e");   return os; }
+    std::ostream& purple_on_light_blue(std::ostream& os) { set("p", "lb");  return os; }
+    std::ostream& purple_on_light_green(std::ostream& os) { set("p", "lg");  return os; }
+    std::ostream& purple_on_light_aqua(std::ostream& os) { set("p", "la");  return os; }
+    std::ostream& purple_on_light_red(std::ostream& os) { set("p", "lr");  return os; }
+    std::ostream& purple_on_light_purple(std::ostream& os) { set("p", "lp");  return os; }
+    std::ostream& purple_on_light_yellow(std::ostream& os) { set("p", "ly");  return os; }
+    std::ostream& purple_on_bright_white(std::ostream& os) { set("p", "bw");  return os; }
+    std::ostream& yellow_on_black(std::ostream& os) { set("y", "k");   return os; }
+    std::ostream& yellow_on_blue(std::ostream& os) { set("y", "b");   return os; }
+    std::ostream& yellow_on_green(std::ostream& os) { set("y", "g");   return os; }
+    std::ostream& yellow_on_aqua(std::ostream& os) { set("y", "a");   return os; }
+    std::ostream& yellow_on_red(std::ostream& os) { set("y", "r");   return os; }
+    std::ostream& yellow_on_purple(std::ostream& os) { set("y", "p");   return os; }
+    std::ostream& yellow_on_yellow(std::ostream& os) { set("y", "y");   return os; }
+    std::ostream& yellow_on_white(std::ostream& os) { set("y", "w");   return os; }
+    std::ostream& yellow_on_grey(std::ostream& os) { set("y", "e");   return os; }
+    std::ostream& yellow_on_light_blue(std::ostream& os) { set("y", "lb");  return os; }
+    std::ostream& yellow_on_light_green(std::ostream& os) { set("y", "lg");  return os; }
+    std::ostream& yellow_on_light_aqua(std::ostream& os) { set("y", "la");  return os; }
+    std::ostream& yellow_on_light_red(std::ostream& os) { set("y", "lr");  return os; }
+    std::ostream& yellow_on_light_purple(std::ostream& os) { set("y", "lp");  return os; }
+    std::ostream& yellow_on_light_yellow(std::ostream& os) { set("y", "ly");  return os; }
+    std::ostream& yellow_on_bright_white(std::ostream& os) { set("y", "bw");  return os; }
+    std::ostream& white_on_black(std::ostream& os) { set("w", "k");   return os; }
+    std::ostream& white_on_blue(std::ostream& os) { set("w", "b");   return os; }
+    std::ostream& white_on_green(std::ostream& os) { set("w", "g");   return os; }
+    std::ostream& white_on_aqua(std::ostream& os) { set("w", "a");   return os; }
+    std::ostream& white_on_red(std::ostream& os) { set("w", "r");   return os; }
+    std::ostream& white_on_purple(std::ostream& os) { set("w", "p");   return os; }
+    std::ostream& white_on_yellow(std::ostream& os) { set("w", "y");   return os; }
+    std::ostream& white_on_white(std::ostream& os) { set("w", "w");   return os; }
+    std::ostream& white_on_grey(std::ostream& os) { set("w", "e");   return os; }
+    std::ostream& white_on_light_blue(std::ostream& os) { set("w", "lb");  return os; }
+    std::ostream& white_on_light_green(std::ostream& os) { set("w", "lg");  return os; }
+    std::ostream& white_on_light_aqua(std::ostream& os) { set("w", "la");  return os; }
+    std::ostream& white_on_light_red(std::ostream& os) { set("w", "lr");  return os; }
+    std::ostream& white_on_light_purple(std::ostream& os) { set("w", "lp");  return os; }
+    std::ostream& white_on_light_yellow(std::ostream& os) { set("w", "ly");  return os; }
+    std::ostream& white_on_bright_white(std::ostream& os) { set("w", "bw");  return os; }
+    std::ostream& grey_on_black(std::ostream& os) { set("e", "k");   return os; }
+    std::ostream& grey_on_blue(std::ostream& os) { set("e", "b");   return os; }
+    std::ostream& grey_on_green(std::ostream& os) { set("e", "g");   return os; }
+    std::ostream& grey_on_aqua(std::ostream& os) { set("e", "a");   return os; }
+    std::ostream& grey_on_red(std::ostream& os) { set("e", "r");   return os; }
+    std::ostream& grey_on_purple(std::ostream& os) { set("e", "p");   return os; }
+    std::ostream& grey_on_yellow(std::ostream& os) { set("e", "y");   return os; }
+    std::ostream& grey_on_white(std::ostream& os) { set("e", "w");   return os; }
+    std::ostream& grey_on_grey(std::ostream& os) { set("e", "e");   return os; }
+    std::ostream& grey_on_light_blue(std::ostream& os) { set("e", "lb");  return os; }
+    std::ostream& grey_on_light_green(std::ostream& os) { set("e", "lg");  return os; }
+    std::ostream& grey_on_light_aqua(std::ostream& os) { set("e", "la");  return os; }
+    std::ostream& grey_on_light_red(std::ostream& os) { set("e", "lr");  return os; }
+    std::ostream& grey_on_light_purple(std::ostream& os) { set("e", "lp");  return os; }
+    std::ostream& grey_on_light_yellow(std::ostream& os) { set("e", "ly");  return os; }
+    std::ostream& grey_on_bright_white(std::ostream& os) { set("e", "bw");  return os; }
+    std::ostream& light_blue_on_black(std::ostream& os) { set("lb", "k");  return os; }
+    std::ostream& light_blue_on_blue(std::ostream& os) { set("lb", "b");  return os; }
+    std::ostream& light_blue_on_green(std::ostream& os) { set("lb", "g");  return os; }
+    std::ostream& light_blue_on_aqua(std::ostream& os) { set("lb", "a");  return os; }
+    std::ostream& light_blue_on_red(std::ostream& os) { set("lb", "r");  return os; }
+    std::ostream& light_blue_on_purple(std::ostream& os) { set("lb", "p");  return os; }
+    std::ostream& light_blue_on_yellow(std::ostream& os) { set("lb", "y");  return os; }
+    std::ostream& light_blue_on_white(std::ostream& os) { set("lb", "w");  return os; }
+    std::ostream& light_blue_on_grey(std::ostream& os) { set("lb", "e");  return os; }
+    std::ostream& light_blue_on_light_blue(std::ostream& os) { set("lb", "lb"); return os; }
+    std::ostream& light_blue_on_light_green(std::ostream& os) { set("lb", "lg"); return os; }
+    std::ostream& light_blue_on_light_aqua(std::ostream& os) { set("lb", "la"); return os; }
+    std::ostream& light_blue_on_light_red(std::ostream& os) { set("lb", "lr"); return os; }
+    std::ostream& light_blue_on_light_purple(std::ostream& os) { set("lb", "lp"); return os; }
+    std::ostream& light_blue_on_light_yellow(std::ostream& os) { set("lb", "ly"); return os; }
+    std::ostream& light_blue_on_bright_white(std::ostream& os) { set("lb", "bw"); return os; }
+    std::ostream& light_green_on_black(std::ostream& os) { set("lg", "k");  return os; }
+    std::ostream& light_green_on_blue(std::ostream& os) { set("lg", "b");  return os; }
+    std::ostream& light_green_on_green(std::ostream& os) { set("lg", "g");  return os; }
+    std::ostream& light_green_on_aqua(std::ostream& os) { set("lg", "a");  return os; }
+    std::ostream& light_green_on_red(std::ostream& os) { set("lg", "r");  return os; }
+    std::ostream& light_green_on_purple(std::ostream& os) { set("lg", "p");  return os; }
+    std::ostream& light_green_on_yellow(std::ostream& os) { set("lg", "y");  return os; }
+    std::ostream& light_green_on_white(std::ostream& os) { set("lg", "w");  return os; }
+    std::ostream& light_green_on_grey(std::ostream& os) { set("lg", "e");  return os; }
+    std::ostream& light_green_on_light_blue(std::ostream& os) { set("lg", "lb"); return os; }
+    std::ostream& light_green_on_light_green(std::ostream& os) { set("lg", "lg"); return os; }
+    std::ostream& light_green_on_light_aqua(std::ostream& os) { set("lg", "la"); return os; }
+    std::ostream& light_green_on_light_red(std::ostream& os) { set("lg", "lr"); return os; }
+    std::ostream& light_green_on_light_purple(std::ostream& os) { set("lg", "lp"); return os; }
+    std::ostream& light_green_on_light_yellow(std::ostream& os) { set("lg", "ly"); return os; }
+    std::ostream& light_green_on_bright_white(std::ostream& os) { set("lg", "bw"); return os; }
+    std::ostream& light_aqua_on_black(std::ostream& os) { set("la", "k");  return os; }
+    std::ostream& light_aqua_on_blue(std::ostream& os) { set("la", "b");  return os; }
+    std::ostream& light_aqua_on_green(std::ostream& os) { set("la", "g");  return os; }
+    std::ostream& light_aqua_on_aqua(std::ostream& os) { set("la", "a");  return os; }
+    std::ostream& light_aqua_on_red(std::ostream& os) { set("la", "r");  return os; }
+    std::ostream& light_aqua_on_purple(std::ostream& os) { set("la", "p");  return os; }
+    std::ostream& light_aqua_on_yellow(std::ostream& os) { set("la", "y");  return os; }
+    std::ostream& light_aqua_on_white(std::ostream& os) { set("la", "w");  return os; }
+    std::ostream& light_aqua_on_grey(std::ostream& os) { set("la", "e");  return os; }
+    std::ostream& light_aqua_on_light_blue(std::ostream& os) { set("la", "lb"); return os; }
+    std::ostream& light_aqua_on_light_green(std::ostream& os) { set("la", "lg"); return os; }
+    std::ostream& light_aqua_on_light_aqua(std::ostream& os) { set("la", "la"); return os; }
+    std::ostream& light_aqua_on_light_red(std::ostream& os) { set("la", "lr"); return os; }
+    std::ostream& light_aqua_on_light_purple(std::ostream& os) { set("la", "lp"); return os; }
+    std::ostream& light_aqua_on_light_yellow(std::ostream& os) { set("la", "ly"); return os; }
+    std::ostream& light_aqua_on_bright_white(std::ostream& os) { set("la", "bw"); return os; }
+    std::ostream& light_red_on_black(std::ostream& os) { set("lr", "k");  return os; }
+    std::ostream& light_red_on_blue(std::ostream& os) { set("lr", "b");  return os; }
+    std::ostream& light_red_on_green(std::ostream& os) { set("lr", "g");  return os; }
+    std::ostream& light_red_on_aqua(std::ostream& os) { set("lr", "a");  return os; }
+    std::ostream& light_red_on_red(std::ostream& os) { set("lr", "r");  return os; }
+    std::ostream& light_red_on_purple(std::ostream& os) { set("lr", "p");  return os; }
+    std::ostream& light_red_on_yellow(std::ostream& os) { set("lr", "y");  return os; }
+    std::ostream& light_red_on_white(std::ostream& os) { set("lr", "w");  return os; }
+    std::ostream& light_red_on_grey(std::ostream& os) { set("lr", "e");  return os; }
+    std::ostream& light_red_on_light_blue(std::ostream& os) { set("lr", "lb"); return os; }
+    std::ostream& light_red_on_light_green(std::ostream& os) { set("lr", "lg"); return os; }
+    std::ostream& light_red_on_light_aqua(std::ostream& os) { set("lr", "la"); return os; }
+    std::ostream& light_red_on_light_red(std::ostream& os) { set("lr", "lr"); return os; }
+    std::ostream& light_red_on_light_purple(std::ostream& os) { set("lr", "lp"); return os; }
+    std::ostream& light_red_on_light_yellow(std::ostream& os) { set("lr", "ly"); return os; }
+    std::ostream& light_red_on_bright_white(std::ostream& os) { set("lr", "bw"); return os; }
+    std::ostream& light_purple_on_black(std::ostream& os) { set("lp", "k");  return os; }
+    std::ostream& light_purple_on_blue(std::ostream& os) { set("lp", "b");  return os; }
+    std::ostream& light_purple_on_green(std::ostream& os) { set("lp", "g");  return os; }
+    std::ostream& light_purple_on_aqua(std::ostream& os) { set("lp", "a");  return os; }
+    std::ostream& light_purple_on_red(std::ostream& os) { set("lp", "r");  return os; }
+    std::ostream& light_purple_on_purple(std::ostream& os) { set("lp", "p");  return os; }
+    std::ostream& light_purple_on_yellow(std::ostream& os) { set("lp", "y");  return os; }
+    std::ostream& light_purple_on_white(std::ostream& os) { set("lp", "w");  return os; }
+    std::ostream& light_purple_on_grey(std::ostream& os) { set("lp", "e");  return os; }
+    std::ostream& light_purple_on_light_blue(std::ostream& os) { set("lp", "lb"); return os; }
+    std::ostream& light_purple_on_light_green(std::ostream& os) { set("lp", "lg"); return os; }
+    std::ostream& light_purple_on_light_aqua(std::ostream& os) { set("lp", "la"); return os; }
+    std::ostream& light_purple_on_light_red(std::ostream& os) { set("lp", "lr"); return os; }
+    std::ostream& light_purple_on_light_purple(std::ostream& os) { set("lp", "lp"); return os; }
+    std::ostream& light_purple_on_light_yellow(std::ostream& os) { set("lp", "ly"); return os; }
+    std::ostream& light_purple_on_bright_white(std::ostream& os) { set("lp", "bw"); return os; }
+    std::ostream& light_yellow_on_black(std::ostream& os) { set("ly", "k");  return os; }
+    std::ostream& light_yellow_on_blue(std::ostream& os) { set("ly", "b");  return os; }
+    std::ostream& light_yellow_on_green(std::ostream& os) { set("ly", "g");  return os; }
+    std::ostream& light_yellow_on_aqua(std::ostream& os) { set("ly", "a");  return os; }
+    std::ostream& light_yellow_on_red(std::ostream& os) { set("ly", "r");  return os; }
+    std::ostream& light_yellow_on_purple(std::ostream& os) { set("ly", "p");  return os; }
+    std::ostream& light_yellow_on_yellow(std::ostream& os) { set("ly", "y");  return os; }
+    std::ostream& light_yellow_on_white(std::ostream& os) { set("ly", "w");  return os; }
+    std::ostream& light_yellow_on_grey(std::ostream& os) { set("ly", "e");  return os; }
+    std::ostream& light_yellow_on_light_blue(std::ostream& os) { set("ly", "lb"); return os; }
+    std::ostream& light_yellow_on_light_green(std::ostream& os) { set("ly", "lg"); return os; }
+    std::ostream& light_yellow_on_light_aqua(std::ostream& os) { set("ly", "la"); return os; }
+    std::ostream& light_yellow_on_light_red(std::ostream& os) { set("ly", "lr"); return os; }
+    std::ostream& light_yellow_on_light_purple(std::ostream& os) { set("ly", "lp"); return os; }
+    std::ostream& light_yellow_on_light_yellow(std::ostream& os) { set("ly", "ly"); return os; }
+    std::ostream& light_yellow_on_bright_white(std::ostream& os) { set("ly", "bw"); return os; }
+    std::ostream& bright_white_on_black(std::ostream& os) { set("bw", "k");  return os; }
+    std::ostream& bright_white_on_blue(std::ostream& os) { set("bw", "b");  return os; }
+    std::ostream& bright_white_on_green(std::ostream& os) { set("bw", "g");  return os; }
+    std::ostream& bright_white_on_aqua(std::ostream& os) { set("bw", "a");  return os; }
+    std::ostream& bright_white_on_red(std::ostream& os) { set("bw", "r");  return os; }
+    std::ostream& bright_white_on_purple(std::ostream& os) { set("bw", "p");  return os; }
+    std::ostream& bright_white_on_yellow(std::ostream& os) { set("bw", "y");  return os; }
+    std::ostream& bright_white_on_white(std::ostream& os) { set("bw", "w");  return os; }
+    std::ostream& bright_white_on_grey(std::ostream& os) { set("bw", "e");  return os; }
+    std::ostream& bright_white_on_light_blue(std::ostream& os) { set("bw", "lb"); return os; }
+    std::ostream& bright_white_on_light_green(std::ostream& os) { set("bw", "lg"); return os; }
+    std::ostream& bright_white_on_light_aqua(std::ostream& os) { set("bw", "la"); return os; }
+    std::ostream& bright_white_on_light_red(std::ostream& os) { set("bw", "lr"); return os; }
+    std::ostream& bright_white_on_light_purple(std::ostream& os) { set("bw", "lp"); return os; }
+    std::ostream& bright_white_on_light_yellow(std::ostream& os) { set("bw", "ly"); return os; }
+    std::ostream& bright_white_on_bright_white(std::ostream& os) { set("bw", "bw"); return os; }
+}
+
+
+namespace dye
+{
+    template<typename T>
+    using bar = typename std::conditional<std::is_same<T, const char*>::value, std::string, T>::type;
+
+    template<typename T> class colorful;
+    template<typename T> class item;
+
+    template<typename T>
+    class colorful : private std::list<item<T>>
+    {
+    public:
+        using std::list<item<T>>::list;
+
+        colorful<T>& operator+=(const colorful<T>& rhs)
+        {
+            this->insert(this->end(), rhs.begin(), rhs.end());
+            return *this;
+        }
+
+        colorful<T>& operator+=(colorful<T>&& rhs)
+        {
+            this->splice(this->end(), std::move(rhs));
+            return *this;
+        }
+
+        colorful<T>& operator+=(T t)
+        {
+            this->push_back(std::move(t));
+            return *this;
+        }
+
+        void push_front(T t)
+        {
+            this->std::list<item<T>>::push_front(item<T>(std::move(t)));
+        }
+
+        void push_back(T t)
+        {
+            this->std::list<item<T>>::push_back(item<T>(std::move(t)));
+        }
+
+        colorful<T>& invert()
+        {
+            for (auto& elem : *this)
+                elem.invert();
+            return *this;
+        }
+
+        template<typename U>
+        friend std::ostream& operator<<(std::ostream&, const colorful<U>&);
+
+        template<typename U>
+        friend colorful<U> invert(colorful<U> col);
+    };
+
+    template<typename T>
+    colorful<T> operator+(colorful<T> lhs, colorful<T> rhs)
+    {
+        colorful<T> res(std::move(lhs));
+        return res += rhs;
+    }
+
+    template<typename T>
+    colorful<T> operator+(colorful<T> lhs, std::string rhs)
+    {
+        colorful<T> res(std::move(lhs));
+        res.push_back(std::move(rhs));
+        return res;
+    }
+
+    template<typename T>
+    colorful<T> operator+(const std::string& lhs, colorful<T> rhs)
+    {
+        colorful<T> res(std::move(rhs));
+        res.push_front(std::move(lhs));
+        return res;
+    }
+
+    template<typename T>
+    std::ostream& operator<<(std::ostream& os, const colorful<T>& colorful)
+    {
+        for (const auto& elem : colorful)
+            os << elem;
+        return os;
+    }
+
+    template<typename T>
+    colorful<T> invert(colorful<T> col)
+    {
+        colorful<T> res(std::move(col));
+        for (auto& elem : res)
+            elem.invert();
+        return res;
+    }
+
+    template<typename T>
+    class item
+    {
+        T thing;
+        int color;
+
+    public:
+        item(T t) : thing(std::move(t)), color(hue::get()) {}
+        item(T t, int a) : thing(std::move(t)), color(hue::itoc(a)) {}
+        item(T t, int a, int b) : thing(std::move(t)), color(hue::itoc(a, b)) {}
+        item(T t, std::string a) : thing(std::move(t)), color(hue::stoc(a)) {}
+        item(T t, std::string a, std::string b) : thing(std::move(t)), color(hue::stoc(a, b)) {}
+
+        item<T>& invert()
+        {
+            color = hue::invert(color);
+            return *this;
+        }
+
+        template<typename U>
+        friend class colorful;
+
+        template<typename U>
+        friend std::ostream& operator<<(std::ostream&, const item<U>&);
+    };
+
+    template<typename T>
+    std::ostream& operator<<(std::ostream& os, const item<T>& it)
+    {
+        hue::set(it.color);
+        os << it.thing;
+        hue::reset();
+        return os;
+    }
+
+    template<typename T> using R = colorful<bar<T>>;
+    template<typename T> using S = item<bar<T>>;
+
+    template<typename T> R<T> colorize(T t, std::string a) { return R<T> { S<T>(t, a) }; }
+    template<typename T> R<T> vanilla(T t) { return R<T> { S<T>(t) }; }
+    template<typename T> R<T> black(T t) { return R<T> { S<T>(t, "k") }; }
+    template<typename T> R<T> blue(T t) { return R<T> { S<T>(t, "b") }; }
+    template<typename T> R<T> green(T t) { return R<T> { S<T>(t, "g") }; }
+    template<typename T> R<T> aqua(T t) { return R<T> { S<T>(t, "a") }; }
+    template<typename T> R<T> red(T t) { return R<T> { S<T>(t, "r") }; }
+    template<typename T> R<T> purple(T t) { return R<T> { S<T>(t, "p") }; }
+    template<typename T> R<T> yellow(T t) { return R<T> { S<T>(t, "y") }; }
+    template<typename T> R<T> white(T t) { return R<T> { S<T>(t, "w") }; }
+    template<typename T> R<T> grey(T t) { return R<T> { S<T>(t, "e") }; }
+    template<typename T> R<T> light_blue(T t) { return R<T> { S<T>(t, "lb") }; }
+    template<typename T> R<T> light_green(T t) { return R<T> { S<T>(t, "lg") }; }
+    template<typename T> R<T> light_aqua(T t) { return R<T> { S<T>(t, "la") }; }
+    template<typename T> R<T> light_red(T t) { return R<T> { S<T>(t, "lr") }; }
+    template<typename T> R<T> light_purple(T t) { return R<T> { S<T>(t, "lp") }; }
+    template<typename T> R<T> light_yellow(T t) { return R<T> { S<T>(t, "ly") }; }
+    template<typename T> R<T> bright_white(T t) { return R<T> { S<T>(t, "bw") }; }
+    template<typename T> R<T> on_black(T t) { return R<T> { S<T>(t, "k", "k") }; }
+    template<typename T> R<T> on_blue(T t) { return R<T> { S<T>(t, "k", "b") }; }
+    template<typename T> R<T> on_green(T t) { return R<T> { S<T>(t, "k", "g") }; }
+    template<typename T> R<T> on_aqua(T t) { return R<T> { S<T>(t, "k", "a") }; }
+    template<typename T> R<T> on_red(T t) { return R<T> { S<T>(t, "k", "r") }; }
+    template<typename T> R<T> on_purple(T t) { return R<T> { S<T>(t, "k", "p") }; }
+    template<typename T> R<T> on_yellow(T t) { return R<T> { S<T>(t, "k", "y") }; }
+    template<typename T> R<T> on_white(T t) { return R<T> { S<T>(t, "k", "w") }; }
+    template<typename T> R<T> on_grey(T t) { return R<T> { S<T>(t, "k", "e") }; }
+    template<typename T> R<T> on_light_blue(T t) { return R<T> { S<T>(t, "k", "lb") }; }
+    template<typename T> R<T> on_light_green(T t) { return R<T> { S<T>(t, "k", "lg") }; }
+    template<typename T> R<T> on_light_aqua(T t) { return R<T> { S<T>(t, "k", "la") }; }
+    template<typename T> R<T> on_light_red(T t) { return R<T> { S<T>(t, "k", "lr") }; }
+    template<typename T> R<T> on_light_purple(T t) { return R<T> { S<T>(t, "k", "lp") }; }
+    template<typename T> R<T> on_light_yellow(T t) { return R<T> { S<T>(t, "k", "ly") }; }
+    template<typename T> R<T> on_bright_white(T t) { return R<T> { S<T>(t, "k", "bw") }; }
+    template<typename T> R<T> black_on_black(T t) { return R<T> { S<T>(t, "k", "k") }; }
+    template<typename T> R<T> black_on_blue(T t) { return R<T> { S<T>(t, "k", "b") }; }
+    template<typename T> R<T> black_on_green(T t) { return R<T> { S<T>(t, "k", "g") }; }
+    template<typename T> R<T> black_on_aqua(T t) { return R<T> { S<T>(t, "k", "a") }; }
+    template<typename T> R<T> black_on_red(T t) { return R<T> { S<T>(t, "k", "r") }; }
+    template<typename T> R<T> black_on_purple(T t) { return R<T> { S<T>(t, "k", "p") }; }
+    template<typename T> R<T> black_on_yellow(T t) { return R<T> { S<T>(t, "k", "y") }; }
+    template<typename T> R<T> black_on_white(T t) { return R<T> { S<T>(t, "k", "w") }; }
+    template<typename T> R<T> black_on_grey(T t) { return R<T> { S<T>(t, "k", "e") }; }
+    template<typename T> R<T> black_on_light_blue(T t) { return R<T> { S<T>(t, "k", "lb") }; }
+    template<typename T> R<T> black_on_light_green(T t) { return R<T> { S<T>(t, "k", "lg") }; }
+    template<typename T> R<T> black_on_light_aqua(T t) { return R<T> { S<T>(t, "k", "la") }; }
+    template<typename T> R<T> black_on_light_red(T t) { return R<T> { S<T>(t, "k", "lr") }; }
+    template<typename T> R<T> black_on_light_purple(T t) { return R<T> { S<T>(t, "k", "lp") }; }
+    template<typename T> R<T> black_on_light_yellow(T t) { return R<T> { S<T>(t, "k", "ly") }; }
+    template<typename T> R<T> black_on_bright_white(T t) { return R<T> { S<T>(t, "k", "bw") }; }
+    template<typename T> R<T> blue_on_black(T t) { return R<T> { S<T>(t, "b", "k") }; }
+    template<typename T> R<T> blue_on_blue(T t) { return R<T> { S<T>(t, "b", "b") }; }
+    template<typename T> R<T> blue_on_green(T t) { return R<T> { S<T>(t, "b", "g") }; }
+    template<typename T> R<T> blue_on_aqua(T t) { return R<T> { S<T>(t, "b", "a") }; }
+    template<typename T> R<T> blue_on_red(T t) { return R<T> { S<T>(t, "b", "r") }; }
+    template<typename T> R<T> blue_on_purple(T t) { return R<T> { S<T>(t, "b", "p") }; }
+    template<typename T> R<T> blue_on_yellow(T t) { return R<T> { S<T>(t, "b", "y") }; }
+    template<typename T> R<T> blue_on_white(T t) { return R<T> { S<T>(t, "b", "w") }; }
+    template<typename T> R<T> blue_on_grey(T t) { return R<T> { S<T>(t, "b", "e") }; }
+    template<typename T> R<T> blue_on_light_blue(T t) { return R<T> { S<T>(t, "b", "lb") }; }
+    template<typename T> R<T> blue_on_light_green(T t) { return R<T> { S<T>(t, "b", "lg") }; }
+    template<typename T> R<T> blue_on_light_aqua(T t) { return R<T> { S<T>(t, "b", "la") }; }
+    template<typename T> R<T> blue_on_light_red(T t) { return R<T> { S<T>(t, "b", "lr") }; }
+    template<typename T> R<T> blue_on_light_purple(T t) { return R<T> { S<T>(t, "b", "lp") }; }
+    template<typename T> R<T> blue_on_light_yellow(T t) { return R<T> { S<T>(t, "b", "ly") }; }
+    template<typename T> R<T> blue_on_bright_white(T t) { return R<T> { S<T>(t, "b", "bw") }; }
+    template<typename T> R<T> green_on_black(T t) { return R<T> { S<T>(t, "g", "k") }; }
+    template<typename T> R<T> green_on_blue(T t) { return R<T> { S<T>(t, "g", "b") }; }
+    template<typename T> R<T> green_on_green(T t) { return R<T> { S<T>(t, "g", "g") }; }
+    template<typename T> R<T> green_on_aqua(T t) { return R<T> { S<T>(t, "g", "a") }; }
+    template<typename T> R<T> green_on_red(T t) { return R<T> { S<T>(t, "g", "r") }; }
+    template<typename T> R<T> green_on_purple(T t) { return R<T> { S<T>(t, "g", "p") }; }
+    template<typename T> R<T> green_on_yellow(T t) { return R<T> { S<T>(t, "g", "y") }; }
+    template<typename T> R<T> green_on_white(T t) { return R<T> { S<T>(t, "g", "w") }; }
+    template<typename T> R<T> green_on_grey(T t) { return R<T> { S<T>(t, "g", "e") }; }
+    template<typename T> R<T> green_on_light_blue(T t) { return R<T> { S<T>(t, "g", "lb") }; }
+    template<typename T> R<T> green_on_light_green(T t) { return R<T> { S<T>(t, "g", "lg") }; }
+    template<typename T> R<T> green_on_light_aqua(T t) { return R<T> { S<T>(t, "g", "la") }; }
+    template<typename T> R<T> green_on_light_red(T t) { return R<T> { S<T>(t, "g", "lr") }; }
+    template<typename T> R<T> green_on_light_purple(T t) { return R<T> { S<T>(t, "g", "lp") }; }
+    template<typename T> R<T> green_on_light_yellow(T t) { return R<T> { S<T>(t, "g", "ly") }; }
+    template<typename T> R<T> green_on_bright_white(T t) { return R<T> { S<T>(t, "g", "bw") }; }
+    template<typename T> R<T> aqua_on_black(T t) { return R<T> { S<T>(t, "a", "k") }; }
+    template<typename T> R<T> aqua_on_blue(T t) { return R<T> { S<T>(t, "a", "b") }; }
+    template<typename T> R<T> aqua_on_green(T t) { return R<T> { S<T>(t, "a", "g") }; }
+    template<typename T> R<T> aqua_on_aqua(T t) { return R<T> { S<T>(t, "a", "a") }; }
+    template<typename T> R<T> aqua_on_red(T t) { return R<T> { S<T>(t, "a", "r") }; }
+    template<typename T> R<T> aqua_on_purple(T t) { return R<T> { S<T>(t, "a", "p") }; }
+    template<typename T> R<T> aqua_on_yellow(T t) { return R<T> { S<T>(t, "a", "y") }; }
+    template<typename T> R<T> aqua_on_white(T t) { return R<T> { S<T>(t, "a", "w") }; }
+    template<typename T> R<T> aqua_on_grey(T t) { return R<T> { S<T>(t, "a", "e") }; }
+    template<typename T> R<T> aqua_on_light_blue(T t) { return R<T> { S<T>(t, "a", "lb") }; }
+    template<typename T> R<T> aqua_on_light_green(T t) { return R<T> { S<T>(t, "a", "lg") }; }
+    template<typename T> R<T> aqua_on_light_aqua(T t) { return R<T> { S<T>(t, "a", "la") }; }
+    template<typename T> R<T> aqua_on_light_red(T t) { return R<T> { S<T>(t, "a", "lr") }; }
+    template<typename T> R<T> aqua_on_light_purple(T t) { return R<T> { S<T>(t, "a", "lp") }; }
+    template<typename T> R<T> aqua_on_light_yellow(T t) { return R<T> { S<T>(t, "a", "ly") }; }
+    template<typename T> R<T> aqua_on_bright_white(T t) { return R<T> { S<T>(t, "a", "bw") }; }
+    template<typename T> R<T> red_on_black(T t) { return R<T> { S<T>(t, "r", "k") }; }
+    template<typename T> R<T> red_on_blue(T t) { return R<T> { S<T>(t, "r", "b") }; }
+    template<typename T> R<T> red_on_green(T t) { return R<T> { S<T>(t, "r", "g") }; }
+    template<typename T> R<T> red_on_aqua(T t) { return R<T> { S<T>(t, "r", "a") }; }
+    template<typename T> R<T> red_on_red(T t) { return R<T> { S<T>(t, "r", "r") }; }
+    template<typename T> R<T> red_on_purple(T t) { return R<T> { S<T>(t, "r", "p") }; }
+    template<typename T> R<T> red_on_yellow(T t) { return R<T> { S<T>(t, "r", "y") }; }
+    template<typename T> R<T> red_on_white(T t) { return R<T> { S<T>(t, "r", "w") }; }
+    template<typename T> R<T> red_on_grey(T t) { return R<T> { S<T>(t, "r", "e") }; }
+    template<typename T> R<T> red_on_light_blue(T t) { return R<T> { S<T>(t, "r", "lb") }; }
+    template<typename T> R<T> red_on_light_green(T t) { return R<T> { S<T>(t, "r", "lg") }; }
+    template<typename T> R<T> red_on_light_aqua(T t) { return R<T> { S<T>(t, "r", "la") }; }
+    template<typename T> R<T> red_on_light_red(T t) { return R<T> { S<T>(t, "r", "lr") }; }
+    template<typename T> R<T> red_on_light_purple(T t) { return R<T> { S<T>(t, "r", "lp") }; }
+    template<typename T> R<T> red_on_light_yellow(T t) { return R<T> { S<T>(t, "r", "ly") }; }
+    template<typename T> R<T> red_on_bright_white(T t) { return R<T> { S<T>(t, "r", "bw") }; }
+    template<typename T> R<T> purple_on_black(T t) { return R<T> { S<T>(t, "p", "k") }; }
+    template<typename T> R<T> purple_on_blue(T t) { return R<T> { S<T>(t, "p", "b") }; }
+    template<typename T> R<T> purple_on_green(T t) { return R<T> { S<T>(t, "p", "g") }; }
+    template<typename T> R<T> purple_on_aqua(T t) { return R<T> { S<T>(t, "p", "a") }; }
+    template<typename T> R<T> purple_on_red(T t) { return R<T> { S<T>(t, "p", "r") }; }
+    template<typename T> R<T> purple_on_purple(T t) { return R<T> { S<T>(t, "p", "p") }; }
+    template<typename T> R<T> purple_on_yellow(T t) { return R<T> { S<T>(t, "p", "y") }; }
+    template<typename T> R<T> purple_on_white(T t) { return R<T> { S<T>(t, "p", "w") }; }
+    template<typename T> R<T> purple_on_grey(T t) { return R<T> { S<T>(t, "p", "e") }; }
+    template<typename T> R<T> purple_on_light_blue(T t) { return R<T> { S<T>(t, "p", "lb") }; }
+    template<typename T> R<T> purple_on_light_green(T t) { return R<T> { S<T>(t, "p", "lg") }; }
+    template<typename T> R<T> purple_on_light_aqua(T t) { return R<T> { S<T>(t, "p", "la") }; }
+    template<typename T> R<T> purple_on_light_red(T t) { return R<T> { S<T>(t, "p", "lr") }; }
+    template<typename T> R<T> purple_on_light_purple(T t) { return R<T> { S<T>(t, "p", "lp") }; }
+    template<typename T> R<T> purple_on_light_yellow(T t) { return R<T> { S<T>(t, "p", "ly") }; }
+    template<typename T> R<T> purple_on_bright_white(T t) { return R<T> { S<T>(t, "p", "bw") }; }
+    template<typename T> R<T> yellow_on_black(T t) { return R<T> { S<T>(t, "y", "k") }; }
+    template<typename T> R<T> yellow_on_blue(T t) { return R<T> { S<T>(t, "y", "b") }; }
+    template<typename T> R<T> yellow_on_green(T t) { return R<T> { S<T>(t, "y", "g") }; }
+    template<typename T> R<T> yellow_on_aqua(T t) { return R<T> { S<T>(t, "y", "a") }; }
+    template<typename T> R<T> yellow_on_red(T t) { return R<T> { S<T>(t, "y", "r") }; }
+    template<typename T> R<T> yellow_on_purple(T t) { return R<T> { S<T>(t, "y", "p") }; }
+    template<typename T> R<T> yellow_on_yellow(T t) { return R<T> { S<T>(t, "y", "y") }; }
+    template<typename T> R<T> yellow_on_white(T t) { return R<T> { S<T>(t, "y", "w") }; }
+    template<typename T> R<T> yellow_on_grey(T t) { return R<T> { S<T>(t, "y", "e") }; }
+    template<typename T> R<T> yellow_on_light_blue(T t) { return R<T> { S<T>(t, "y", "lb") }; }
+    template<typename T> R<T> yellow_on_light_green(T t) { return R<T> { S<T>(t, "y", "lg") }; }
+    template<typename T> R<T> yellow_on_light_aqua(T t) { return R<T> { S<T>(t, "y", "la") }; }
+    template<typename T> R<T> yellow_on_light_red(T t) { return R<T> { S<T>(t, "y", "lr") }; }
+    template<typename T> R<T> yellow_on_light_purple(T t) { return R<T> { S<T>(t, "y", "lp") }; }
+    template<typename T> R<T> yellow_on_light_yellow(T t) { return R<T> { S<T>(t, "y", "ly") }; }
+    template<typename T> R<T> yellow_on_bright_white(T t) { return R<T> { S<T>(t, "y", "bw") }; }
+    template<typename T> R<T> white_on_black(T t) { return R<T> { S<T>(t, "w", "k") }; }
+    template<typename T> R<T> white_on_blue(T t) { return R<T> { S<T>(t, "w", "b") }; }
+    template<typename T> R<T> white_on_green(T t) { return R<T> { S<T>(t, "w", "g") }; }
+    template<typename T> R<T> white_on_aqua(T t) { return R<T> { S<T>(t, "w", "a") }; }
+    template<typename T> R<T> white_on_red(T t) { return R<T> { S<T>(t, "w", "r") }; }
+    template<typename T> R<T> white_on_purple(T t) { return R<T> { S<T>(t, "w", "p") }; }
+    template<typename T> R<T> white_on_yellow(T t) { return R<T> { S<T>(t, "w", "y") }; }
+    template<typename T> R<T> white_on_white(T t) { return R<T> { S<T>(t, "w", "w") }; }
+    template<typename T> R<T> white_on_grey(T t) { return R<T> { S<T>(t, "w", "e") }; }
+    template<typename T> R<T> white_on_light_blue(T t) { return R<T> { S<T>(t, "w", "lb") }; }
+    template<typename T> R<T> white_on_light_green(T t) { return R<T> { S<T>(t, "w", "lg") }; }
+    template<typename T> R<T> white_on_light_aqua(T t) { return R<T> { S<T>(t, "w", "la") }; }
+    template<typename T> R<T> white_on_light_red(T t) { return R<T> { S<T>(t, "w", "lr") }; }
+    template<typename T> R<T> white_on_light_purple(T t) { return R<T> { S<T>(t, "w", "lp") }; }
+    template<typename T> R<T> white_on_light_yellow(T t) { return R<T> { S<T>(t, "w", "ly") }; }
+    template<typename T> R<T> white_on_bright_white(T t) { return R<T> { S<T>(t, "w", "bw") }; }
+    template<typename T> R<T> grey_on_black(T t) { return R<T> { S<T>(t, "e", "k") }; }
+    template<typename T> R<T> grey_on_blue(T t) { return R<T> { S<T>(t, "e", "b") }; }
+    template<typename T> R<T> grey_on_green(T t) { return R<T> { S<T>(t, "e", "g") }; }
+    template<typename T> R<T> grey_on_aqua(T t) { return R<T> { S<T>(t, "e", "a") }; }
+    template<typename T> R<T> grey_on_red(T t) { return R<T> { S<T>(t, "e", "r") }; }
+    template<typename T> R<T> grey_on_purple(T t) { return R<T> { S<T>(t, "e", "p") }; }
+    template<typename T> R<T> grey_on_yellow(T t) { return R<T> { S<T>(t, "e", "y") }; }
+    template<typename T> R<T> grey_on_white(T t) { return R<T> { S<T>(t, "e", "w") }; }
+    template<typename T> R<T> grey_on_grey(T t) { return R<T> { S<T>(t, "e", "e") }; }
+    template<typename T> R<T> grey_on_light_blue(T t) { return R<T> { S<T>(t, "e", "lb") }; }
+    template<typename T> R<T> grey_on_light_green(T t) { return R<T> { S<T>(t, "e", "lg") }; }
+    template<typename T> R<T> grey_on_light_aqua(T t) { return R<T> { S<T>(t, "e", "la") }; }
+    template<typename T> R<T> grey_on_light_red(T t) { return R<T> { S<T>(t, "e", "lr") }; }
+    template<typename T> R<T> grey_on_light_purple(T t) { return R<T> { S<T>(t, "e", "lp") }; }
+    template<typename T> R<T> grey_on_light_yellow(T t) { return R<T> { S<T>(t, "e", "ly") }; }
+    template<typename T> R<T> grey_on_bright_white(T t) { return R<T> { S<T>(t, "e", "bw") }; }
+    template<typename T> R<T> light_blue_on_black(T t) { return R<T> { S<T>(t, "lb", "k") }; }
+    template<typename T> R<T> light_blue_on_blue(T t) { return R<T> { S<T>(t, "lb", "b") }; }
+    template<typename T> R<T> light_blue_on_green(T t) { return R<T> { S<T>(t, "lb", "g") }; }
+    template<typename T> R<T> light_blue_on_aqua(T t) { return R<T> { S<T>(t, "lb", "a") }; }
+    template<typename T> R<T> light_blue_on_red(T t) { return R<T> { S<T>(t, "lb", "r") }; }
+    template<typename T> R<T> light_blue_on_purple(T t) { return R<T> { S<T>(t, "lb", "p") }; }
+    template<typename T> R<T> light_blue_on_yellow(T t) { return R<T> { S<T>(t, "lb", "y") }; }
+    template<typename T> R<T> light_blue_on_white(T t) { return R<T> { S<T>(t, "lb", "w") }; }
+    template<typename T> R<T> light_blue_on_grey(T t) { return R<T> { S<T>(t, "lb", "e") }; }
+    template<typename T> R<T> light_blue_on_light_blue(T t) { return R<T> { S<T>(t, "lb", "lb") }; }
+    template<typename T> R<T> light_blue_on_light_green(T t) { return R<T> { S<T>(t, "lb", "lg") }; }
+    template<typename T> R<T> light_blue_on_light_aqua(T t) { return R<T> { S<T>(t, "lb", "la") }; }
+    template<typename T> R<T> light_blue_on_light_red(T t) { return R<T> { S<T>(t, "lb", "lr") }; }
+    template<typename T> R<T> light_blue_on_light_purple(T t) { return R<T> { S<T>(t, "lb", "lp") }; }
+    template<typename T> R<T> light_blue_on_light_yellow(T t) { return R<T> { S<T>(t, "lb", "ly") }; }
+    template<typename T> R<T> light_blue_on_bright_white(T t) { return R<T> { S<T>(t, "lb", "bw") }; }
+    template<typename T> R<T> light_green_on_black(T t) { return R<T> { S<T>(t, "lg", "k") }; }
+    template<typename T> R<T> light_green_on_blue(T t) { return R<T> { S<T>(t, "lg", "b") }; }
+    template<typename T> R<T> light_green_on_green(T t) { return R<T> { S<T>(t, "lg", "g") }; }
+    template<typename T> R<T> light_green_on_aqua(T t) { return R<T> { S<T>(t, "lg", "a") }; }
+    template<typename T> R<T> light_green_on_red(T t) { return R<T> { S<T>(t, "lg", "r") }; }
+    template<typename T> R<T> light_green_on_purple(T t) { return R<T> { S<T>(t, "lg", "p") }; }
+    template<typename T> R<T> light_green_on_yellow(T t) { return R<T> { S<T>(t, "lg", "y") }; }
+    template<typename T> R<T> light_green_on_white(T t) { return R<T> { S<T>(t, "lg", "w") }; }
+    template<typename T> R<T> light_green_on_grey(T t) { return R<T> { S<T>(t, "lg", "e") }; }
+    template<typename T> R<T> light_green_on_light_blue(T t) { return R<T> { S<T>(t, "lg", "lb") }; }
+    template<typename T> R<T> light_green_on_light_green(T t) { return R<T> { S<T>(t, "lg", "lg") }; }
+    template<typename T> R<T> light_green_on_light_aqua(T t) { return R<T> { S<T>(t, "lg", "la") }; }
+    template<typename T> R<T> light_green_on_light_red(T t) { return R<T> { S<T>(t, "lg", "lr") }; }
+    template<typename T> R<T> light_green_on_light_purple(T t) { return R<T> { S<T>(t, "lg", "lp") }; }
+    template<typename T> R<T> light_green_on_light_yellow(T t) { return R<T> { S<T>(t, "lg", "ly") }; }
+    template<typename T> R<T> light_green_on_bright_white(T t) { return R<T> { S<T>(t, "lg", "bw") }; }
+    template<typename T> R<T> light_aqua_on_black(T t) { return R<T> { S<T>(t, "la", "k") }; }
+    template<typename T> R<T> light_aqua_on_blue(T t) { return R<T> { S<T>(t, "la", "b") }; }
+    template<typename T> R<T> light_aqua_on_green(T t) { return R<T> { S<T>(t, "la", "g") }; }
+    template<typename T> R<T> light_aqua_on_aqua(T t) { return R<T> { S<T>(t, "la", "a") }; }
+    template<typename T> R<T> light_aqua_on_red(T t) { return R<T> { S<T>(t, "la", "r") }; }
+    template<typename T> R<T> light_aqua_on_purple(T t) { return R<T> { S<T>(t, "la", "p") }; }
+    template<typename T> R<T> light_aqua_on_yellow(T t) { return R<T> { S<T>(t, "la", "y") }; }
+    template<typename T> R<T> light_aqua_on_white(T t) { return R<T> { S<T>(t, "la", "w") }; }
+    template<typename T> R<T> light_aqua_on_grey(T t) { return R<T> { S<T>(t, "la", "e") }; }
+    template<typename T> R<T> light_aqua_on_light_blue(T t) { return R<T> { S<T>(t, "la", "lb") }; }
+    template<typename T> R<T> light_aqua_on_light_green(T t) { return R<T> { S<T>(t, "la", "lg") }; }
+    template<typename T> R<T> light_aqua_on_light_aqua(T t) { return R<T> { S<T>(t, "la", "la") }; }
+    template<typename T> R<T> light_aqua_on_light_red(T t) { return R<T> { S<T>(t, "la", "lr") }; }
+    template<typename T> R<T> light_aqua_on_light_purple(T t) { return R<T> { S<T>(t, "la", "lp") }; }
+    template<typename T> R<T> light_aqua_on_light_yellow(T t) { return R<T> { S<T>(t, "la", "ly") }; }
+    template<typename T> R<T> light_aqua_on_bright_white(T t) { return R<T> { S<T>(t, "la", "bw") }; }
+    template<typename T> R<T> light_red_on_black(T t) { return R<T> { S<T>(t, "lr", "k") }; }
+    template<typename T> R<T> light_red_on_blue(T t) { return R<T> { S<T>(t, "lr", "b") }; }
+    template<typename T> R<T> light_red_on_green(T t) { return R<T> { S<T>(t, "lr", "g") }; }
+    template<typename T> R<T> light_red_on_aqua(T t) { return R<T> { S<T>(t, "lr", "a") }; }
+    template<typename T> R<T> light_red_on_red(T t) { return R<T> { S<T>(t, "lr", "r") }; }
+    template<typename T> R<T> light_red_on_purple(T t) { return R<T> { S<T>(t, "lr", "p") }; }
+    template<typename T> R<T> light_red_on_yellow(T t) { return R<T> { S<T>(t, "lr", "y") }; }
+    template<typename T> R<T> light_red_on_white(T t) { return R<T> { S<T>(t, "lr", "w") }; }
+    template<typename T> R<T> light_red_on_grey(T t) { return R<T> { S<T>(t, "lr", "e") }; }
+    template<typename T> R<T> light_red_on_light_blue(T t) { return R<T> { S<T>(t, "lr", "lb") }; }
+    template<typename T> R<T> light_red_on_light_green(T t) { return R<T> { S<T>(t, "lr", "lg") }; }
+    template<typename T> R<T> light_red_on_light_aqua(T t) { return R<T> { S<T>(t, "lr", "la") }; }
+    template<typename T> R<T> light_red_on_light_red(T t) { return R<T> { S<T>(t, "lr", "lr") }; }
+    template<typename T> R<T> light_red_on_light_purple(T t) { return R<T> { S<T>(t, "lr", "lp") }; }
+    template<typename T> R<T> light_red_on_light_yellow(T t) { return R<T> { S<T>(t, "lr", "ly") }; }
+    template<typename T> R<T> light_red_on_bright_white(T t) { return R<T> { S<T>(t, "lr", "bw") }; }
+    template<typename T> R<T> light_purple_on_black(T t) { return R<T> { S<T>(t, "lp", "k") }; }
+    template<typename T> R<T> light_purple_on_blue(T t) { return R<T> { S<T>(t, "lp", "b") }; }
+    template<typename T> R<T> light_purple_on_green(T t) { return R<T> { S<T>(t, "lp", "g") }; }
+    template<typename T> R<T> light_purple_on_aqua(T t) { return R<T> { S<T>(t, "lp", "a") }; }
+    template<typename T> R<T> light_purple_on_red(T t) { return R<T> { S<T>(t, "lp", "r") }; }
+    template<typename T> R<T> light_purple_on_purple(T t) { return R<T> { S<T>(t, "lp", "p") }; }
+    template<typename T> R<T> light_purple_on_yellow(T t) { return R<T> { S<T>(t, "lp", "y") }; }
+    template<typename T> R<T> light_purple_on_white(T t) { return R<T> { S<T>(t, "lp", "w") }; }
+    template<typename T> R<T> light_purple_on_grey(T t) { return R<T> { S<T>(t, "lp", "e") }; }
+    template<typename T> R<T> light_purple_on_light_blue(T t) { return R<T> { S<T>(t, "lp", "lb") }; }
+    template<typename T> R<T> light_purple_on_light_green(T t) { return R<T> { S<T>(t, "lp", "lg") }; }
+    template<typename T> R<T> light_purple_on_light_aqua(T t) { return R<T> { S<T>(t, "lp", "la") }; }
+    template<typename T> R<T> light_purple_on_light_red(T t) { return R<T> { S<T>(t, "lp", "lr") }; }
+    template<typename T> R<T> light_purple_on_light_purple(T t) { return R<T> { S<T>(t, "lp", "lp") }; }
+    template<typename T> R<T> light_purple_on_light_yellow(T t) { return R<T> { S<T>(t, "lp", "ly") }; }
+    template<typename T> R<T> light_purple_on_bright_white(T t) { return R<T> { S<T>(t, "lp", "bw") }; }
+    template<typename T> R<T> light_yellow_on_black(T t) { return R<T> { S<T>(t, "ly", "k") }; }
+    template<typename T> R<T> light_yellow_on_blue(T t) { return R<T> { S<T>(t, "ly", "b") }; }
+    template<typename T> R<T> light_yellow_on_green(T t) { return R<T> { S<T>(t, "ly", "g") }; }
+    template<typename T> R<T> light_yellow_on_aqua(T t) { return R<T> { S<T>(t, "ly", "a") }; }
+    template<typename T> R<T> light_yellow_on_red(T t) { return R<T> { S<T>(t, "ly", "r") }; }
+    template<typename T> R<T> light_yellow_on_purple(T t) { return R<T> { S<T>(t, "ly", "p") }; }
+    template<typename T> R<T> light_yellow_on_yellow(T t) { return R<T> { S<T>(t, "ly", "y") }; }
+    template<typename T> R<T> light_yellow_on_white(T t) { return R<T> { S<T>(t, "ly", "w") }; }
+    template<typename T> R<T> light_yellow_on_grey(T t) { return R<T> { S<T>(t, "ly", "e") }; }
+    template<typename T> R<T> light_yellow_on_light_blue(T t) { return R<T> { S<T>(t, "ly", "lb") }; }
+    template<typename T> R<T> light_yellow_on_light_green(T t) { return R<T> { S<T>(t, "ly", "lg") }; }
+    template<typename T> R<T> light_yellow_on_light_aqua(T t) { return R<T> { S<T>(t, "ly", "la") }; }
+    template<typename T> R<T> light_yellow_on_light_red(T t) { return R<T> { S<T>(t, "ly", "lr") }; }
+    template<typename T> R<T> light_yellow_on_light_purple(T t) { return R<T> { S<T>(t, "ly", "lp") }; }
+    template<typename T> R<T> light_yellow_on_light_yellow(T t) { return R<T> { S<T>(t, "ly", "ly") }; }
+    template<typename T> R<T> light_yellow_on_bright_white(T t) { return R<T> { S<T>(t, "ly", "bw") }; }
+    template<typename T> R<T> bright_white_on_black(T t) { return R<T> { S<T>(t, "bw", "k") }; }
+    template<typename T> R<T> bright_white_on_blue(T t) { return R<T> { S<T>(t, "bw", "b") }; }
+    template<typename T> R<T> bright_white_on_green(T t) { return R<T> { S<T>(t, "bw", "g") }; }
+    template<typename T> R<T> bright_white_on_aqua(T t) { return R<T> { S<T>(t, "bw", "a") }; }
+    template<typename T> R<T> bright_white_on_red(T t) { return R<T> { S<T>(t, "bw", "r") }; }
+    template<typename T> R<T> bright_white_on_purple(T t) { return R<T> { S<T>(t, "bw", "p") }; }
+    template<typename T> R<T> bright_white_on_yellow(T t) { return R<T> { S<T>(t, "bw", "y") }; }
+    template<typename T> R<T> bright_white_on_white(T t) { return R<T> { S<T>(t, "bw", "w") }; }
+    template<typename T> R<T> bright_white_on_grey(T t) { return R<T> { S<T>(t, "bw", "e") }; }
+    template<typename T> R<T> bright_white_on_light_blue(T t) { return R<T> { S<T>(t, "bw", "lb") }; }
+    template<typename T> R<T> bright_white_on_light_green(T t) { return R<T> { S<T>(t, "bw", "lg") }; }
+    template<typename T> R<T> bright_white_on_light_aqua(T t) { return R<T> { S<T>(t, "bw", "la") }; }
+    template<typename T> R<T> bright_white_on_light_red(T t) { return R<T> { S<T>(t, "bw", "lr") }; }
+    template<typename T> R<T> bright_white_on_light_purple(T t) { return R<T> { S<T>(t, "bw", "lp") }; }
+    template<typename T> R<T> bright_white_on_light_yellow(T t) { return R<T> { S<T>(t, "bw", "ly") }; }
+    template<typename T> R<T> bright_white_on_bright_white(T t) { return R<T> { S<T>(t, "bw", "bw") }; }
+}
+
+#endif

ZSharp/graphics.h

@@ -26,6 +26,7 @@ using namespace boost;
 
 int WINDOW_WIDTH = 1280;
 int WINDOW_HEIGHT = 720;
+int PIXEL_SCALE = 1;
 
 unordered_map<string, int> KEYS =
 {
@@ -191,7 +192,7 @@ public:
 	{
 		x *= rhs;
 		y *= rhs;
-		
+
 		return *this;
 	}
 
@@ -391,6 +392,8 @@ public:
 	{
 		SDL_RenderCopy(gRenderer, texture, NULL, &rect);
 		// Centers
+		rect.w = scale.x;
+		rect.h = scale.y;
 		rect.x = position.x - (rect.w / 2);
 		rect.y = position.y - (rect.h / 2);
 		return 0;
@@ -501,6 +504,8 @@ public:
 				scale.y /= AnyAsFloat(otherVal);
 		}
 		// Centers
+		rect.w = scale.x;
+		rect.h = scale.y;
 		rect.x = position.x - (rect.w / 2);
 		rect.y = position.y - (rect.h / 2);
 		return *this;
@@ -518,12 +523,12 @@ public:
 class Text
 {
 public:
-	Text(std::string content, std::string pathToFont, Vec2 position, float fontSize, double angle, Uint8 r, Uint8 g, Uint8 b)
-		: position(position), angle(angle), content(content), pathToFont(pathToFont), fontSize(fontSize), r(r), g(g), b(b)
+	Text(std::string content, std::string pathToFont, Vec2 position, float fontSize, double angle, Uint8 r, Uint8 g, Uint8 b, bool antialias)
+		: position(position), angle(angle), content(content), pathToFont(pathToFont), fontSize(fontSize), r(r), g(g), b(b), antialias(antialias)
 	{
 		rect.x = position.x;
 		rect.y = position.y;
-		
+
 		font = TTF_OpenFont(pathToFont.c_str(), fontSize);
 
 		Load();
@@ -533,8 +538,12 @@ public:
 	{
 		SDL_Color color = { r, g, b };
 
-		SDL_Surface* surface = TTF_RenderText_Solid(font, content.c_str(), color);
-		
+		SDL_Surface* surface;
+		if (antialias)
+			surface = TTF_RenderText_Blended(font, content.c_str(), color);
+		else
+			surface = TTF_RenderText_Solid(font, content.c_str(), color);
+
 		texture = SDL_CreateTextureFromSurface(gRenderer, surface);
 
 		TTF_SizeText(font, content.c_str(), &rect.w, &rect.h);
@@ -554,7 +563,11 @@ public:
 	{
 		SDL_Color color = { r, g, b };
 
-		SDL_Surface* surface = TTF_RenderText_Solid(font, content.c_str(), color);
+		SDL_Surface* surface;
+		if (antialias)
+			surface = TTF_RenderText_Blended(font, content.c_str(), color);
+		else
+			surface = TTF_RenderText_Solid(font, content.c_str(), color);
 
 		SDL_DestroyTexture(texture);
 		texture = SDL_CreateTextureFromSurface(gRenderer, surface);
@@ -599,6 +612,8 @@ public:
 			return content;
 		if (componentName == "pathToFont")
 			return pathToFont;
+		if (componentName == "antialias")
+			return antialias;
 		return 0;
 	}
 
@@ -706,12 +721,19 @@ public:
 			else if (oper == "+=")
 				content += AnyAsString(otherVal);
 		}
+		else if (componentName == "antialias")
+		{
+			if (oper == "=")
+				antialias = AnyAsBool(otherVal);
+		}
 
 		// Updates changes to text
 		Update();
 		return *this;
 	}
 
+	bool antialias = true;
+
 	Vec2 position;
 	Vec2 scale;
 	float fontSize;
@@ -739,6 +761,12 @@ int cleanupGraphics()
 	return 0;
 }
 
+//void DrawPixel(int x, int y, int r, int g, int b) {
+//	SDL_SetRenderDrawColor(gRenderer, r, g, b, 255);
+//	SDL_RenderDrawPoint(gRenderer, x, y);
+//	SDL_SetRenderDrawColor(gRenderer, 0, 0, 0, 0);
+//}
+
 
 int updateLoop()
 {
@@ -1017,17 +1045,21 @@ int updateLoop()
 	return 0;
 }
 
-int initGraphics(std::string windowTitle, int width, int height)
+int initGraphics(std::string windowTitle, int width, int height, int pixelScale)
 {
 	WINDOW_WIDTH = width;
 	WINDOW_HEIGHT = height;
+	PIXEL_SCALE = pixelScale;
 
 	// Initialize SDL components
 	SDL_Init(SDL_INIT_VIDEO);
 	TTF_Init();
 
-	gWindow = SDL_CreateWindow(windowTitle.c_str(), 40, 40, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+	gWindow = SDL_CreateWindow(windowTitle.c_str(), 40, 40, WINDOW_WIDTH * PIXEL_SCALE, WINDOW_HEIGHT * PIXEL_SCALE, SDL_WINDOW_SHOWN | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
 	gRenderer = SDL_CreateRenderer(gWindow, -1, 0);
+	SDL_RenderSetLogicalSize(gRenderer, WINDOW_WIDTH * PIXEL_SCALE, WINDOW_HEIGHT * PIXEL_SCALE);
+	SDL_RenderSetScale(gRenderer, PIXEL_SCALE, PIXEL_SCALE);
+	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, 0);
 
 	//Get window surface
 	gScreenSurface = SDL_GetWindowSurface(gWindow);

ZSharp/linux-build/CMakeFiles/Makefile.cmake

@@ -23,89 +23,23 @@ set(CMAKE_MAKEFILE_DEPENDS
   "/usr/lib/x86_64-linux-gnu/cmake/boost_system-1.71.0/boost_system-config.cmake"
   "/usr/lib/x86_64-linux-gnu/cmake/boost_system-1.71.0/libboost_system-variant-shared.cmake"
   "/usr/lib/x86_64-linux-gnu/cmake/boost_system-1.71.0/libboost_system-variant-static.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeCCompiler.cmake.in"
-  "/usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c"
   "/usr/share/cmake-3.16/Modules/CMakeCInformation.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeCXXCompiler.cmake.in"
-  "/usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp"
   "/usr/share/cmake-3.16/Modules/CMakeCXXInformation.cmake"
   "/usr/share/cmake-3.16/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
   "/usr/share/cmake-3.16/Modules/CMakeCommonLanguageInclude.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeCompilerIdDetection.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineCCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineCXXCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompileFeatures.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerABI.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerId.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeDetermineSystem.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeFindBinUtils.cmake"
   "/usr/share/cmake-3.16/Modules/CMakeGenericSystem.cmake"
   "/usr/share/cmake-3.16/Modules/CMakeInitializeConfigs.cmake"
   "/usr/share/cmake-3.16/Modules/CMakeLanguageInformation.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeParseImplicitIncludeInfo.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeParseImplicitLinkInfo.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeSystem.cmake.in"
   "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInformation.cmake"
   "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInitialize.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeTestCCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeTestCXXCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeTestCompilerCommon.cmake"
-  "/usr/share/cmake-3.16/Modules/CMakeUnixFindMake.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/ADSP-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Borland-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Bruce-C-DetermineCompiler.cmake"
   "/usr/share/cmake-3.16/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Compaq-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Cray-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/GHS-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/GNU-C-DetermineCompiler.cmake"
   "/usr/share/cmake-3.16/Modules/Compiler/GNU-C.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
   "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/GNU-FindBinUtils.cmake"
   "/usr/share/cmake-3.16/Modules/Compiler/GNU.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/HP-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/IAR-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Intel-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/MSVC-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/PGI-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/PathScale-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/SCO-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/SDCC-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/SunPro-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/TI-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/Watcom-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/XL-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/XLClang-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/zOS-C-DetermineCompiler.cmake"
-  "/usr/share/cmake-3.16/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
   "/usr/share/cmake-3.16/Modules/FindBoost.cmake"
   "/usr/share/cmake-3.16/Modules/FindPackageHandleStandardArgs.cmake"
   "/usr/share/cmake-3.16/Modules/FindPackageMessage.cmake"
   "/usr/share/cmake-3.16/Modules/Internal/CMakeCheckCompilerFlag.cmake"
-  "/usr/share/cmake-3.16/Modules/Internal/FeatureTesting.cmake"
-  "/usr/share/cmake-3.16/Modules/Platform/Linux-Determine-CXX.cmake"
   "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU-C.cmake"
   "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU-CXX.cmake"
   "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU.cmake"
@@ -121,11 +55,6 @@ set(CMAKE_MAKEFILE_OUTPUTS
 
 # Byproducts of CMake generate step:
 set(CMAKE_MAKEFILE_PRODUCTS
-  "CMakeFiles/3.16.3/CMakeSystem.cmake"
-  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
-  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
-  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
-  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
   "CMakeFiles/CMakeDirectoryInformation.cmake"
   )
 

ZSharp/linux-build/CMakeFiles/ZSharp.dir/CXX.includecache

@@ -75,12 +75,6 @@ algorithm
 -
 unordered_map
 -
-strops.h
-/home/sam/Z-Sharp/ZSharp/strops.h
-graphics.h
-/home/sam/Z-Sharp/ZSharp/graphics.h
-anyops.h
-/home/sam/Z-Sharp/ZSharp/anyops.h
 boost/any.hpp
 -
 SDL.h
@@ -89,6 +83,32 @@ ctime
 -
 math.h
 -
+strops.h
+/home/sam/Z-Sharp/ZSharp/strops.h
+graphics.h
+/home/sam/Z-Sharp/ZSharp/graphics.h
+anyops.h
+/home/sam/Z-Sharp/ZSharp/anyops.h
+color.hpp
+/home/sam/Z-Sharp/ZSharp/color.hpp
+
+/home/sam/Z-Sharp/ZSharp/color.hpp
+algorithm
+-
+iostream
+-
+list
+-
+map
+-
+string
+-
+type_traits
+-
+utility
+-
+windows.h
+-
 
 /home/sam/Z-Sharp/ZSharp/eval.cpp
 iostream

ZSharp/linux-build/CMakeFiles/ZSharp.dir/depend.internal

@@ -6,6 +6,7 @@ CMakeFiles/ZSharp.dir/Main.cpp.o
  /home/sam/Z-Sharp/ZSharp/ZS.h
  /home/sam/Z-Sharp/ZSharp/anyops.h
  /home/sam/Z-Sharp/ZSharp/builtin.h
+ /home/sam/Z-Sharp/ZSharp/color.hpp
  /home/sam/Z-Sharp/ZSharp/eval.h
  /home/sam/Z-Sharp/ZSharp/graphics.h
  /home/sam/Z-Sharp/ZSharp/main.h

ZSharp/linux-build/CMakeFiles/ZSharp.dir/depend.make

@@ -5,6 +5,7 @@ CMakeFiles/ZSharp.dir/Main.cpp.o: ../Main.cpp
 CMakeFiles/ZSharp.dir/Main.cpp.o: ../ZS.h
 CMakeFiles/ZSharp.dir/Main.cpp.o: ../anyops.h
 CMakeFiles/ZSharp.dir/Main.cpp.o: ../builtin.h
+CMakeFiles/ZSharp.dir/Main.cpp.o: ../color.hpp
 CMakeFiles/ZSharp.dir/Main.cpp.o: ../eval.h
 CMakeFiles/ZSharp.dir/Main.cpp.o: ../graphics.h
 CMakeFiles/ZSharp.dir/Main.cpp.o: ../main.h

ZSharp/modpath.iss

@@ -0,0 +1,219 @@
+// ----------------------------------------------------------------------------
+//
+// Inno Setup Ver:	5.4.2
+// Script Version:	1.4.2
+// Author:			Jared Breland <jbreland@legroom.net>
+// Homepage:		http://www.legroom.net/software
+// License:			GNU Lesser General Public License (LGPL), version 3
+//						http://www.gnu.org/licenses/lgpl.html
+//
+// Script Function:
+//	Allow modification of environmental path directly from Inno Setup installers
+//
+// Instructions:
+//	Copy modpath.iss to the same directory as your setup script
+//
+//	Add this statement to your [Setup] section
+//		ChangesEnvironment=true
+//
+//	Add this statement to your [Tasks] section
+//	You can change the Description or Flags
+//	You can change the Name, but it must match the ModPathName setting below
+//		Name: modifypath; Description: &Add application directory to your environmental path; Flags: unchecked
+//
+//	Add the following to the end of your [Code] section
+//	ModPathName defines the name of the task defined above
+//	ModPathType defines whether the 'user' or 'system' path will be modified;
+//		this will default to user if anything other than system is set
+//	setArrayLength must specify the total number of dirs to be added
+//	Result[0] contains first directory, Result[1] contains second, etc.
+//		const
+//			ModPathName = 'modifypath';
+//			ModPathType = 'user';
+//
+//		function ModPathDir(): TArrayOfString;
+//		begin
+//			setArrayLength(Result, 1);
+//			Result[0] := ExpandConstant('{app}');
+//		end;
+//		#include "modpath.iss"
+// ----------------------------------------------------------------------------
+
+procedure ModPath();
+var
+	oldpath:	String;
+	newpath:	String;
+	updatepath:	Boolean;
+	pathArr:	TArrayOfString;
+	aExecFile:	String;
+	aExecArr:	TArrayOfString;
+	i, d:		Integer;
+	pathdir:	TArrayOfString;
+	regroot:	Integer;
+	regpath:	String;
+
+begin
+	// Get constants from main script and adjust behavior accordingly
+	// ModPathType MUST be 'system' or 'user'; force 'user' if invalid
+	if ModPathType = 'system' then begin
+		regroot := HKEY_LOCAL_MACHINE;
+		regpath := 'SYSTEM\CurrentControlSet\Control\Session Manager\Environment';
+	end else begin
+		regroot := HKEY_CURRENT_USER;
+		regpath := 'Environment';
+	end;
+
+	// Get array of new directories and act on each individually
+	pathdir := ModPathDir();
+	for d := 0 to GetArrayLength(pathdir)-1 do begin
+		updatepath := true;
+
+		// Modify WinNT path
+		if UsingWinNT() = true then begin
+
+			// Get current path, split into an array
+			RegQueryStringValue(regroot, regpath, 'Path', oldpath);
+			oldpath := oldpath + ';';
+			i := 0;
+
+			while (Pos(';', oldpath) > 0) do begin
+				SetArrayLength(pathArr, i+1);
+				pathArr[i] := Copy(oldpath, 0, Pos(';', oldpath)-1);
+				oldpath := Copy(oldpath, Pos(';', oldpath)+1, Length(oldpath));
+				i := i + 1;
+
+				// Check if current directory matches app dir
+				if pathdir[d] = pathArr[i-1] then begin
+					// if uninstalling, remove dir from path
+					if IsUninstaller() = true then begin
+						continue;
+					// if installing, flag that dir already exists in path
+					end else begin
+						updatepath := false;
+					end;
+				end;
+
+				// Add current directory to new path
+				if i = 1 then begin
+					newpath := pathArr[i-1];
+				end else begin
+					newpath := newpath + ';' + pathArr[i-1];
+				end;
+			end;
+
+			// Append app dir to path if not already included
+			if (IsUninstaller() = false) AND (updatepath = true) then
+				newpath := newpath + ';' + pathdir[d];
+
+			// Write new path
+			RegWriteStringValue(regroot, regpath, 'Path', newpath);
+
+		// Modify Win9x path
+		end else begin
+
+			// Convert to shortened dirname
+			pathdir[d] := GetShortName(pathdir[d]);
+
+			// If autoexec.bat exists, check if app dir already exists in path
+			aExecFile := 'C:\AUTOEXEC.BAT';
+			if FileExists(aExecFile) then begin
+				LoadStringsFromFile(aExecFile, aExecArr);
+				for i := 0 to GetArrayLength(aExecArr)-1 do begin
+					if IsUninstaller() = false then begin
+						// If app dir already exists while installing, skip add
+						if (Pos(pathdir[d], aExecArr[i]) > 0) then
+							updatepath := false;
+							break;
+					end else begin
+						// If app dir exists and = what we originally set, then delete at uninstall
+						if aExecArr[i] = 'SET PATH=%PATH%;' + pathdir[d] then
+							aExecArr[i] := '';
+					end;
+				end;
+			end;
+
+			// If app dir not found, or autoexec.bat didn't exist, then (create and) append to current path
+			if (IsUninstaller() = false) AND (updatepath = true) then begin
+				SaveStringToFile(aExecFile, #13#10 + 'SET PATH=%PATH%;' + pathdir[d], True);
+
+			// If uninstalling, write the full autoexec out
+			end else begin
+				SaveStringsToFile(aExecFile, aExecArr, False);
+			end;
+		end;
+	end;
+end;
+
+// Split a string into an array using passed delimeter
+procedure MPExplode(var Dest: TArrayOfString; Text: String; Separator: String);
+var
+	i: Integer;
+begin
+	i := 0;
+	repeat
+		SetArrayLength(Dest, i+1);
+		if Pos(Separator,Text) > 0 then	begin
+			Dest[i] := Copy(Text, 1, Pos(Separator, Text)-1);
+			Text := Copy(Text, Pos(Separator,Text) + Length(Separator), Length(Text));
+			i := i + 1;
+		end else begin
+			 Dest[i] := Text;
+			 Text := '';
+		end;
+	until Length(Text)=0;
+end;
+
+
+procedure CurStepChanged(CurStep: TSetupStep);
+var
+	taskname:	String;
+begin
+	taskname := ModPathName;
+	if CurStep = ssPostInstall then
+		if IsTaskSelected(taskname) then
+			ModPath();
+end;
+
+procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
+var
+	aSelectedTasks:	TArrayOfString;
+	i:				Integer;
+	taskname:		String;
+	regpath:		String;
+	regstring:		String;
+	appid:			String;
+begin
+	// only run during actual uninstall
+	if CurUninstallStep = usUninstall then begin
+		// get list of selected tasks saved in registry at install time
+		appid := '{#emit SetupSetting("AppId")}';
+		if appid = '' then appid := '{#emit SetupSetting("AppName")}';
+		regpath := ExpandConstant('Software\Microsoft\Windows\CurrentVersion\Uninstall\'+appid+'_is1');
+		RegQueryStringValue(HKLM, regpath, 'Inno Setup: Selected Tasks', regstring);
+		if regstring = '' then RegQueryStringValue(HKCU, regpath, 'Inno Setup: Selected Tasks', regstring);
+
+		// check each task; if matches modpath taskname, trigger patch removal
+		if regstring <> '' then begin
+			taskname := ModPathName;
+			MPExplode(aSelectedTasks, regstring, ',');
+			if GetArrayLength(aSelectedTasks) > 0 then begin
+				for i := 0 to GetArrayLength(aSelectedTasks)-1 do begin
+					if comparetext(aSelectedTasks[i], taskname) = 0 then
+						ModPath();
+				end;
+			end;
+		end;
+	end;
+end;
+
+function NeedRestart(): Boolean;
+var
+	taskname:	String;
+begin
+	taskname := ModPathName;
+	if IsTaskSelected(taskname) and not UsingWinNT() then begin
+		Result := True;
+	end else begin
+		Result := False;
+	end;
+end;

ZSharp/strops.cpp

@@ -8,7 +8,8 @@
 //#include "builtin.h"
 using namespace std;
 
-const string WHITESPACE = " \n\r\t\f\v";
+const string WHITESPACE = " \t\f";
+//const string WHITESPACE = " \n\r\t\f\v";
 
 
 bool isNumber(const string& str)
@@ -25,6 +26,51 @@ bool stob(const string& str)
 	return b;
 }
 
+string unescape(const string& s)
+{
+	string res;
+	string::const_iterator it = s.begin();
+	while (it != s.end())
+	{
+		char c = *it++;
+		if (c == '\\' && it != s.end())
+		{
+			switch (*it++) {
+			case '\\': c = '\\'; break;
+			case 'n': c = '\n'; break;
+			case 't': c = '\t'; break;
+				// all other escapes
+			default:
+				// invalid escape sequence - skip it. alternatively you can copy it as is, throw an exception...
+				continue;
+			}
+		}
+		res += c;
+	}
+
+	return res;
+}
+
+std::string escaped(const std::string& input)
+{
+	std::string output;
+	output.reserve(input.size());
+	for (const char c : input) {
+		switch (c) {
+		case '\a':  output += "\\a";        break;
+		case '\b':  output += "\\b";        break;
+		case '\f':  output += "\\f";        break;
+		case '\n':  output += "\\n";        break;
+		case '\r':  output += "\\r";        break;
+		case '\t':  output += "\\t";        break;
+		case '\v':  output += "\\v";        break;
+		default:    output += c;            break;
+		}
+	}
+
+	return output;
+}
+
 string StringRaw(const string& s)
 {
 	string str = trim(s);
@@ -42,7 +88,7 @@ string StringRaw(const string& s)
 	if (str[str.size() - 1] != '\"')
 		withoutQuotes += str[str.size() - 1];
 
-	return withoutQuotes;
+	return unescape(withoutQuotes);
 }
 
 string Quoted(const string& s)
@@ -150,6 +196,81 @@ int countNoOverlap(const string& str, const char& searchFor, const char& ch1, co
 	return cnt;
 }
 
+vector<string> splitNoOverlap(const string& str, const char& splitBy, const char& openChar, const char& closeChar)
+{
+	vector<string> newStr;
+
+	int openCount = 0;
+
+	string tmpStr = "";
+	for (int i = 0; i < (int)str.size(); i++)
+	{
+		if (i == (int)str.size() - 1)
+		{
+			newStr.push_back(trim(tmpStr + str[i]));
+			break;
+		}
+
+		if (str[i] == splitBy && openCount == 0)
+		{
+			newStr.push_back(trim(tmpStr));
+			tmpStr = "";
+			continue;
+		}
+		else if (str[i] == openChar) {
+			tmpStr += str[i];
+			openCount += 1;
+		}
+		else if (str[i] == closeChar) {
+			tmpStr += str[i];
+			openCount -= 1;
+		}
+		else
+			tmpStr += str[i];
+	}
+
+	return newStr;
+}
+
+string betweenChars(const string& str, const char& openChar, const char& closeChar)
+{
+	string content = "";
+
+	int startPos = 0;
+	int endPos = (int)str.size();
+
+	for (int i = 0; i < (int)str.size(); i++)
+	{
+		if (str[i] == openChar){
+			startPos = i+1;
+			break;
+		}
+	}
+	for (int i = (int)str.size()-1; i >=0; i--)
+	{
+		if (str[i] == closeChar){
+			endPos = i-(startPos); // or startPos-1 idk I cant do math right now
+			break;
+		}
+	}
+
+	return str.substr(startPos, endPos);
+}
+
+bool startsWith(const string& str, const string& lookFor)
+{
+	if (str.empty() || lookFor.size() > str.size())
+		return false;
+
+	for (int i = 0; i < (int)lookFor.size(); i++)
+	{
+		if (str[i] != lookFor[i])
+			return false;
+	}
+
+	return true;
+}
+
 int countOutsideParenthesis(const string& str, const char& searchFor)
 {
 	int cnt = 0;
@@ -341,4 +462,13 @@ string replace(const string& str, const string& strToReplace, const string& repl
 	}
 
 	return newStr;
+}
+
+bool isEscaped(const string& str, int curChar)
+{
+	if (curChar > 0)
+		if (str[curChar - 1] == '\\')
+			return true;
+
+	return false;
 }

ZSharp/strops.h

@@ -12,6 +12,7 @@ int AnyAsInt(const boost::any& val);
 bool AnyAsBool(const boost::any& val);
 
 
+
 bool isNumber(const string& str);
 
 bool stob(const string& str);
@@ -30,6 +31,10 @@ string trim(const string& s);
 
 vector<string> split(const string& str, const char& del);
 
+string betweenChars(const string& str, const char& openChar, const char& closeChar);
+
+vector<string> splitNoOverlap(const string& str, const char& splitBy, const char& openChar, const char& closeChar);
+
 int count(const string& str, const char& ch);
 
 int countNoOverlap(const string& str, const char& searchFor, const char& ch1, const char& ch2);
@@ -60,4 +65,10 @@ float floatval(const string& s);
 
 string replace(const string& str, const string& strToReplace, const string& replaceWith);
 
+bool isEscaped(const string& str, int curChar);
+
+bool startsWith(const string& str, const string& lookFor);
+
+std::string escaped(const std::string& input);
+
 #endif

examples/Benchmark/script.zs

@@ -0,0 +1,157 @@
+int g_screenw = 256
+int g_screenh = 224
+int g_resolutionScale = 3
+
+float g_playerWalkSpeed = 150
+float g_playerRunSpeed = 210
+float g_jumpHeight = 200
+float g_currPlayerSpeed = 400
+
+bool g_running = false
+bool g_colliding = false
+
+float g_gravitySpeed = 86
+
+bool g_jumping = false
+float g_jumpingTime = 0
+
+//include "./extra-include.zs"
+
+func Main()
+{
+	//SplitThread(ThreadedFunction())
+	EXIT_WHEN_DONE = false
+	
+	// Immediately creates the window, then runs Start(), then the game loop. The game loop calls Update() every frame
+	ZS.Graphics.Init("Platformer game", g_screenw, g_screenh, g_resolutionScale)
+}
+
+func Start()
+{
+	float centerX = g_screenw / 2
+	float centerY = g_screenh / 2
+	
+	
+	global Vec2 v_aa = NVec2(g_screenw / 2 + -40, g_screenh / 2 + -40)
+	global Sprite s_aa = ZS.Graphics.Sprite("./mariostill.png", v_aa, NVec2(16, 16), 0)
+	
+	global Vec2 v_ab = NVec2(g_screenw / 2 + -30, g_screenh / 2 + -40)
+	global Sprite s_ab = ZS.Graphics.Sprite("./mariostill.png", v_ab, NVec2(16, 16), 0)
+	
+	global Vec2 v_ac = NVec2(g_screenw / 2 + -20, g_screenh / 2 + -40)
+	global Sprite s_ac = ZS.Graphics.Sprite("./mariostill.png", v_ac, NVec2(16, 16), 0)
+	
+	global Vec2 v_ad = NVec2(g_screenw / 2 + -10, g_screenh / 2 + -40)
+	global Sprite s_ad = ZS.Graphics.Sprite("./mariostill.png", v_ad, NVec2(16, 16), 0)
+	
+	global Vec2 v_ae = NVec2(g_screenw / 2 + -0, g_screenh / 2 + -40)
+	global Sprite s_ae = ZS.Graphics.Sprite("./mariostill.png", v_ae, NVec2(16, 16), 0)
+	
+	global Vec2 v_af = NVec2(g_screenw / 2 + 10, g_screenh / 2 + -40)
+	global Sprite s_af = ZS.Graphics.Sprite("./mariostill.png", v_af, NVec2(16, 16), 0)
+	
+	global Vec2 v_ag = NVec2(g_screenw / 2 + 20, g_screenh / 2 + -40)
+	global Sprite s_ag = ZS.Graphics.Sprite("./mariostill.png", v_ag, NVec2(16, 16), 0)
+	
+	global Vec2 v_ah = NVec2(g_screenw / 2 + 30, g_screenh / 2 + -40)
+	global Sprite s_ah = ZS.Graphics.Sprite("./mariostill.png", v_ah, NVec2(16, 16), 0)
+	
+	global Vec2 v_ai = NVec2(g_screenw / 2 + 40, g_screenh / 2 + -40)
+	global Sprite s_ai = ZS.Graphics.Sprite("./mariostill.png", v_ai, NVec2(16, 16), 0)
+	
+	global Vec2 v_aj = NVec2(g_screenw / 2 + -40, g_screenh / 2 + -30)
+	global Sprite s_aj = ZS.Graphics.Sprite("./mariostill.png", v_aj, NVec2(16, 16), 0)
+	
+	global Vec2 v_ak = NVec2(g_screenw / 2 + -30, g_screenh / 2 + -30)
+	global Sprite s_ak = ZS.Graphics.Sprite("./mariostill.png", v_ak, NVec2(16, 16), 0)
+	
+	global Vec2 v_al = NVec2(g_screenw / 2 + -20, g_screenh / 2 + -30)
+	global Sprite s_al = ZS.Graphics.Sprite("./mariostill.png", v_al, NVec2(16, 16), 0)
+	
+	
+}
+
+func Update(deltaTime)
+{
+	float fps = 1 / deltaTime
+	Printl("FPS: " + fps)
+
+	// // Shift key lets you sprint
+	// g_running = GetKey("SHIFT_L")
+	
+	// if g_running == true
+	// {
+		// g_currPlayerSpeed = g_playerRunSpeed
+	// }
+	
+	// if g_running == false
+	// {
+		// g_currPlayerSpeed = g_playerWalkSpeed
+	// }
+
+	// // Move Left And Right
+	// if GetKey("D") == true
+	// {
+		// g_playerTargetPosition.x += g_currPlayerSpeed * deltaTime
+	// }
+	// if GetKey("A") == true
+	// {
+		// g_playerTargetPosition.x -= g_currPlayerSpeed * deltaTime
+	// }
+	
+	
+	// // Apply gravity
+	// g_colliding = Colliding(g_playerSprite, g_groundSprite)
+	// if g_colliding == false
+	// {
+		// if g_jumping == false
+		// {
+			// g_playerTargetPosition.y += deltaTime * g_gravitySpeed
+		// }
+		// if g_jumping == true
+		// {
+			// g_playerTargetPosition.y -= (g_jumpHeight * deltaTime) + (deltaTime * g_gravitySpeed * -g_jumpingTime * 5)
+		// }
+	// }
+	// if g_colliding == true
+	// {
+		// if GetKey("SPACE") == false
+		// {
+			// if g_jumpingTime > 1
+			// {
+				// g_jumping = false
+			// }
+		// }
+		// if GetKey("SPACE") == true
+		// {
+			// g_jumping = true
+			// g_jumpingTime = 0
+			// g_playerTargetPosition.y -= 2
+		// }
+	// }
+	
+	// // Lerps from old position to destination smoothly
+	// float stopSpeed = deltaTime * 15
+	// float lerpedX = Lerp(g_playerSprite.position.x, g_playerTargetPosition.x, stopSpeed)
+	// s_aa.position = NVec2(lerpedX, g_playerTargetPosition.y)
+	
+	// Finally draws all of the sprites
+	ZS.Graphics.Draw(s_aa)
+	ZS.Graphics.Draw(s_ab)
+	ZS.Graphics.Draw(s_ac)
+	ZS.Graphics.Draw(s_ad)
+	ZS.Graphics.Draw(s_ae)
+	ZS.Graphics.Draw(s_af)
+	ZS.Graphics.Draw(s_ag)
+	ZS.Graphics.Draw(s_ah)
+	ZS.Graphics.Draw(s_ai)
+	ZS.Graphics.Draw(s_aj)
+	ZS.Graphics.Draw(s_ak)
+	ZS.Graphics.Draw(s_al)
+}
+
+func Colliding(a, b)
+{
+	bool bo = ZS.Physics.AxisAlignedCollision(a, b)
+	return bo
+}

examples/Platformer/extra-include.zs

@@ -0,0 +1,103 @@
+// This is an "included" ZS file, which can keep your main script
+// tidier and more organized or easily share the same functions
+// across multiple programs.
+
+
+func TestInclude()
+{
+	Printl("Hello World!")
+}
+//////////////////////////////////////////////////////////////////////////////
+// Benchmark, to check if performance suffers from too many functions/variables
+//////////////////////////////////////////////////////////////////////////////
+func b1()
+{
+	Printl("Hello World!")
+}
+func b2()
+{
+	Printl("Hello World!")
+}
+func b3()
+{
+	Printl("Hello World!")
+}
+func b4()
+{
+	Printl("Hello World!")
+}
+func b5()
+{
+	Printl("Hello World!")
+}
+func b6()
+{
+	Printl("Hello World!")
+}
+func b7()
+{
+	Printl("Hello World!")
+}
+func b8()
+{
+	Printl("Hello World!")
+}
+func b9()
+{
+	Printl("Hello World!")
+}
+func b10()
+{
+	Printl("Hello World!")
+}
+func b11()
+{
+	Printl("Hello World!")
+}
+func b12()
+{
+	Printl("Hello World!")
+}
+func b13()
+{
+	Printl("Hello World!")
+}
+func b14()
+{
+	Printl("Hello World!")
+}
+func b15()
+{
+	Printl("Hello World!")
+}
+func b16()
+{
+	Printl("Hello World!")
+}
+
+int a = 4
+int b = 4
+int c = 4
+int d = 4
+int e = 4
+int f = 4
+int g = 4
+int h = 4
+int i = 4
+int j = 4
+int k = 4
+int l = 4
+int m = 4
+int n = 4
+int o = 4
+int p = 4
+int q = 4
+int r = 4
+int s = 4
+int t = 4
+int u = 4
+int v = 4
+int w = 4
+int x = 4
+int y = 4
+int z = 4

examples/Platformer/script.zs

@@ -0,0 +1,128 @@
+int g_screenw = 256
+int g_screenh = 224
+int g_resolutionScale = 3
+
+float g_playerWalkSpeed = 150
+float g_playerRunSpeed = 210
+float g_jumpHeight = 200
+float g_currPlayerSpeed = 400
+
+bool g_running = false
+bool g_colliding = false
+
+float g_gravitySpeed = 86
+
+bool g_jumping = false
+float g_jumpingTime = 0
+
+//include "./extra-include.zs"
+
+func Main()
+{
+	//SplitThread(ThreadedFunction())
+	EXIT_WHEN_DONE = false
+	
+	// Immediately creates the window, then runs Start(), then the game loop. The game loop calls Update() every frame
+	ZS.Graphics.Init("Platformer game", g_screenw, g_screenh, g_resolutionScale)
+}
+
+func ThreadedFunction()
+{
+	Printl("threaded:")
+}
+
+func Start()
+{
+	float centerX = g_screenw / 2
+	float centerY = g_screenh / 2
+	global Vec2 g_screencenter = NVec2(g_screenw / 2, g_screenh / 2)
+	
+	global Sprite g_playerSprite = ZS.Graphics.Sprite("./mariostill.png", g_screencenter, NVec2(16, 16), 0)
+	
+	global Sprite g_groundSprite = ZS.Graphics.Sprite("./square.png", NVec2(g_screencenter.x, 192), NVec2(256, 16), 0)
+	
+	global Text g_instructionsText = ZS.Graphics.Text("Use Arrow Keys or WASD to Move and Spacebar to Jump", "./arial.ttf", NVec2(g_screencenter.x, g_screencenter.y), 8, 0, 255, 255, 255)
+	g_instructionsText.antialias = false
+	
+	global Vec2 g_playerTargetPosition = g_screencenter
+}
+
+func Update(deltaTime)
+{
+	float fps = 1 / deltaTime
+	g_jumpingTime += deltaTime
+	Printl("FPS: " + fps)
+	//TestInclude()
+
+	// Shift key lets you sprint
+	g_running = GetKey("SHIFT_L")
+	
+	if g_running == true
+	{
+		g_currPlayerSpeed = g_playerRunSpeed
+	}
+	
+	if g_running == false
+	{
+		g_currPlayerSpeed = g_playerWalkSpeed
+	}
+
+	// Move Left And Right
+	if GetKey("D") == true
+	{
+		g_playerTargetPosition.x += g_currPlayerSpeed * deltaTime
+	}
+	if GetKey("A") == true
+	{
+		g_playerTargetPosition.x -= g_currPlayerSpeed * deltaTime
+	}
+	
+	
+	// Apply gravity
+	g_colliding = Colliding(g_playerSprite, g_groundSprite)
+	if g_colliding == false
+	{
+		if g_jumping == false
+		{
+			g_playerTargetPosition.y += deltaTime * g_gravitySpeed
+		}
+		if g_jumping == true
+		{
+			g_playerTargetPosition.y -= (g_jumpHeight * deltaTime) + (deltaTime * g_gravitySpeed * -g_jumpingTime * 5)
+		}
+	}
+	if g_colliding == true
+	{
+		if GetKey("SPACE") == false
+		{
+			if g_jumpingTime > 1
+			{
+				g_jumping = false
+			}
+		}
+		if GetKey("SPACE") == true
+		{
+			g_jumping = true
+			g_jumpingTime = 0
+			g_playerTargetPosition.y -= 2
+		}
+	}
+	
+	// Lerps from old position to destination smoothly
+	float stopSpeed = deltaTime * 15
+	float lerpedX = Lerp(g_playerSprite.position.x, g_playerTargetPosition.x, stopSpeed)
+	g_playerSprite.position = NVec2(lerpedX, g_playerTargetPosition.y)
+	
+	// Finally draws all of the sprites
+	ZS.Graphics.Draw(g_playerSprite)
+	ZS.Graphics.Draw(g_groundSprite)
+	
+	// Draw the text
+	ZS.Graphics.DrawText(g_instructionsText)
+}
+
+func Colliding(a, b)
+{
+	bool bo = ZS.Physics.AxisAlignedCollision(a, b)
+	return bo
+}

examples/Pong-Example-Project/script.zs

@@ -13,9 +13,11 @@ float lerpSpeed = 14
 bool aiOn = false
 
 // Main is always run at the VERY BEGINNING. Start() is the start of GRAPHICS
-// so if you never call ZS.Grapgics.Init, then Start won't run
+// so if you never call ZS.Graphics.Init, then Start won't run
 func Main()
 {
+	EXIT_WHEN_DONE = false
+	
 	// Immediately creates the window, then Start(), then the game loop. The game loop calls Update() every frame
 	ZS.Graphics.Init("This is a pong game", SCREENW, SCREENH)
 }
@@ -39,7 +41,7 @@ func Start()
 	Vec2 rPaddlePosition = NVec2(rOffset, yPosPaddle)
 	global Vec2 rPaddleTargetPosition = NVec2(rOffset, yPosPaddle)
 	
-	global Sprite ballSpr = ZS.Graphics.Sprite("./square.png", ballPos, ballScale, 0)
+	global Sprite ballSpr = ZS.Graphics.Sprite("./ball.png", ballPos, ballScale, 0)
 	global Sprite lPaddle = ZS.Graphics.Sprite("./square.png", lPaddlePosition, paddleScale, 0)
 	global Sprite rPaddle = ZS.Graphics.Sprite("./square.png", rPaddlePosition, paddleScale, 0)
 	
@@ -61,75 +63,66 @@ func Start()
 
 func Update(deltaTime)
 {
-	float FPS = 1 / deltaTime
-	print "FPS: " + FPS
+	//float FPS = 1 / deltaTime
+	//Printl("FPS: " + FPS)
 
 	// Handles Left Paddle Movement
 	//
 	if GetKey("W") == true
 	{
-		float newX = lPaddle.position.x
 		// Subtract from Y to move up, because vertical coordinates are reversed
 		float newY = lPaddleTargetPosition.y - paddleMoveSpeed * deltaTime
 		newY = Clamp(newY, 0 + lPaddle.scale.y / 2, SCREENH - lPaddle.scale.y / 2)
-		lPaddleTargetPosition = NVec2(newX, newY)
+		lPaddleTargetPosition.y = newY
 	}
 	if GetKey("S") == true
 	{
-		float newX = lPaddle.position.x
 		// Add to Y to move down, because vertical coordinates are reversed
 		float newY = lPaddleTargetPosition.y + paddleMoveSpeed * deltaTime
 		newY = Clamp(newY, 0 + lPaddle.scale.y / 2, SCREENH - lPaddle.scale.y / 2)
-		lPaddleTargetPosition = NVec2(newX, newY)
+		lPaddleTargetPosition.y = newY
 	}
 	// Lerps from old position to destination smoothly
 	float oldY = lPaddle.position.y
 	float stopSpeed = deltaTime * lerpSpeed
 	float newY = lPaddleTargetPosition.y
 	float lerpedY = Lerp(oldY, newY, stopSpeed)
-	lPaddle.position = NVec2(newX, lerpedY)
+	lPaddle.position = NVec2(lPaddle.position.x, lerpedY)
 	
 	// Handles Right Paddle Movement
 	//
-	if GetKey("UP") == true
+	if aiOn == false
 	{
-		if aiOn == false
+		if GetKey("UP") == true
 		{
-			float newX = rPaddle.position.x
 			// Subtract from Y to move up, because vertical coordinates are reversed
 			float newY = rPaddleTargetPosition.y - paddleMoveSpeed * deltaTime
 			newY = Clamp(newY, 0 + rPaddle.scale.y / 2, SCREENH - rPaddle.scale.y / 2)
-			rPaddleTargetPosition = NVec2(newX, newY)
+			rPaddleTargetPosition.y = newY
 		}
-	}
-	if GetKey("DOWN") == true
-	{
-		if aiOn == false
+		if GetKey("DOWN") == true
 		{
-			float newX = rPaddle.position.x
 			// Add to Y to move down, because vertical coordinates are reversed
 			float newY = rPaddleTargetPosition.y + paddleMoveSpeed * deltaTime
 			newY = Clamp(newY, 0 + rPaddle.scale.y / 2, SCREENH - rPaddle.scale.y / 2)
-			rPaddleTargetPosition = NVec2(newX, newY)
+			rPaddleTargetPosition.y = newY
 		}
 	}
 	if aiOn == true
 	{
 		if rPaddle.position.y < ballSpr.position.y
 		{
-			float newX = rPaddle.position.x
 			// Add to Y to move down, because vertical coordinates are reversed
 			float newY = rPaddleTargetPosition.y + paddleMoveSpeed * deltaTime
 			newY = Clamp(newY, 0 + rPaddle.scale.y / 2, SCREENH - rPaddle.scale.y / 2)
-			rPaddleTargetPosition = NVec2(newX, newY)
+			rPaddleTargetPosition.y = newY
 		}
 		if rPaddle.position.y > ballSpr.position.y
 		{
-			float newX = rPaddle.position.x
 			// Subtract from Y to move up, because vertical coordinates are reversed
 			float newY = rPaddleTargetPosition.y - paddleMoveSpeed * deltaTime
 			newY = Clamp(newY, 0 + rPaddle.scale.y / 2, SCREENH - rPaddle.scale.y / 2)
-			rPaddleTargetPosition = NVec2(newX, newY)
+			rPaddleTargetPosition.y = newY
 		}
 	}
 	// Lerps from old position to destination smoothly
@@ -137,18 +130,20 @@ func Update(deltaTime)
 	float stopSpeed = deltaTime * lerpSpeed
 	float newY = rPaddleTargetPosition.y
 	float lerpedY = Lerp(oldY, newY, stopSpeed)
-	rPaddle.position = NVec2(newX, lerpedY)
+	rPaddle.position = NVec2(rPaddle.position.x, lerpedY)
 	
 	if GetKey("ENTER") == true
 	{
+		bool changeTo = false
 		if aiOn == true
 		{
-			aiOn = false
+			changeTo = false
 		}
 		if aiOn == false
 		{
-			aiOn = true
+			changeTo = true
 		}
+		aiOn = changeTo
 	}
 	
 	Vec2 scaledVelocity = ballVelocity
@@ -244,7 +239,7 @@ func HandleBallBounce()
 		difference -= ballY
 		float paddleHeight = rPaddle.scale.y
 		float normalizedRelativeIntersectionY = difference / (paddleHeight / 2)
-		float bounceAngle = normalizedRelativeIntersectionY * 0.523599
+		float bounceAngle = normalizedRelativeIntersectionY * -0.523599
 		float ballVx = ballSpeed
 		ballVx *= Cos(bounceAngle)
 		ballVx *= -1

examples/console_application.zs

@@ -0,0 +1,5 @@
+func Main()
+{
+	Printl("this is a test:")
+	ZS.System.Command("cls")
+}