moving header files to include directory & moving resources in it's own directory

i know currently there is race condition, but the code is getting too
messy, i will continue to this after i make a vis tool to analyse how i
should split up files & stuff

the code rn needs intense restructing for it to make any more progress

10 files changed, 76 insertions, 855 deletions

diff --git a/src/uci/UCI-Protocol-Specification.txt b/src/uci/UCI-Protocol-Specification.txt
deleted file mode 100644
index f28b730..0000000
--- a/src/uci/UCI-Protocol-Specification.txt
+++ /dev/null
@@ -1,544 +0,0 @@
-// Dowloaded from: http://download.shredderchess.com/div/uci.zip
-
-Description of the universal chess interface (UCI)    April  2006
-=================================================================
-
-* The specification is independent of the operating system. For Windows,
-  the engine is a normal exe file, either a console or "real" windows application.
-
-* all communication is done via standard input and output with text commands,
-
-* The engine should boot and wait for input from the GUI,
-  the engine should wait for the "isready" or "setoption" command to set up its internal parameters
-  as the boot process should be as quick as possible.
-
-* the engine must always be able to process input from stdin, even while thinking.
-
-* all command strings the engine receives will end with '\n',
-  also all commands the GUI receives should end with '\n',
-  Note: '\n' can be 0x0d or 0x0a0d or any combination depending on your OS.
-  If you use Engine and GUI in the same OS this should be no problem if you communicate in text mode,
-  but be aware of this when for example running a Linux engine in a Windows GUI.
-
-* arbitrary white space between tokens is allowed
-  Example: "debug on\n" and  "   debug     on  \n" and "\t  debug \t  \t\ton\t  \n"
-  all set the debug mode of the engine on.
-
-* The engine will always be in forced mode which means it should never start calculating
-  or pondering without receiving a "go" command first.
-
-* Before the engine is asked to search on a position, there will always be a position command
-  to tell the engine about the current position.
-
-* by default all the opening book handling is done by the GUI,
-  but there is an option for the engine to use its own book ("OwnBook" option, see below)
-
-* if the engine or the GUI receives an unknown command or token it should just ignore it and try to
-  parse the rest of the string in this line.
-  Examples: "joho debug on\n" should switch the debug mode on given that joho is not defined,
-            "debug joho on\n" will be undefined however.
-
-* if the engine receives a command which is not supposed to come, for example "stop" when the engine is
-  not calculating, it should also just ignore it.
-  
-
-Move format:
-------------
-
-The move format is in long algebraic notation.
-A nullmove from the Engine to the GUI should be sent as 0000.
-Examples:  e2e4, e7e5, e1g1 (white short castling), e7e8q (for promotion)
-
-
-
-GUI to engine:
---------------
-
-These are all the command the engine gets from the interface.
-
-* uci
-	tell engine to use the uci (universal chess interface),
-	this will be sent once as a first command after program boot
-	to tell the engine to switch to uci mode.
-	After receiving the uci command the engine must identify itself with the "id" command
-	and send the "option" commands to tell the GUI which engine settings the engine supports if any.
-	After that the engine should send "uciok" to acknowledge the uci mode.
-	If no uciok is sent within a certain time period, the engine task will be killed by the GUI.
-
-* debug [ on | off ]
-	switch the debug mode of the engine on and off.
-	In debug mode the engine should send additional infos to the GUI, e.g. with the "info string" command,
-	to help debugging, e.g. the commands that the engine has received etc.
-	This mode should be switched off by default and this command can be sent
-	any time, also when the engine is thinking.
-
-* isready
-	this is used to synchronize the engine with the GUI. When the GUI has sent a command or
-	multiple commands that can take some time to complete,
-	this command can be used to wait for the engine to be ready again or
-	to ping the engine to find out if it is still alive.
-	E.g. this should be sent after setting the path to the tablebases as this can take some time.
-	This command is also required once before the engine is asked to do any search
-	to wait for the engine to finish initializing.
-	This command must always be answered with "readyok" and can be sent also when the engine is calculating
-	in which case the engine should also immediately answer with "readyok" without stopping the search.
-
-* setoption name <id> [value <x>]
-	this is sent to the engine when the user wants to change the internal parameters
-	of the engine. For the "button" type no value is needed.
-	One string will be sent for each parameter and this will only be sent when the engine is waiting.
-	The name and value of the option in <id> should not be case sensitive and can inlude spaces.
-	The substrings "value" and "name" should be avoided in <id> and <x> to allow unambiguous parsing,
-	for example do not use <name> = "draw value".
-	Here are some strings for the example below:
-	   "setoption name Nullmove value true\n"
-      "setoption name Selectivity value 3\n"
-	   "setoption name Style value Risky\n"
-	   "setoption name Clear Hash\n"
-	   "setoption name NalimovPath value c:\chess\tb\4;c:\chess\tb\5\n"
-
-* register
-	this is the command to try to register an engine or to tell the engine that registration
-	will be done later. This command should always be sent if the engine	has sent "registration error"
-	at program startup.
-	The following tokens are allowed:
-	* later
-	   the user doesn't want to register the engine now.
-	* name <x>
-	   the engine should be registered with the name <x>
-	* code <y>
-	   the engine should be registered with the code <y>
-	Example:
-	   "register later"
-	   "register name Stefan MK code 4359874324"
-
-* ucinewgame
-   this is sent to the engine when the next search (started with "position" and "go") will be from
-   a different game. This can be a new game the engine should play or a new game it should analyse but
-   also the next position from a testsuite with positions only.
-   If the GUI hasn't sent a "ucinewgame" before the first "position" command, the engine shouldn't
-   expect any further ucinewgame commands as the GUI is probably not supporting the ucinewgame command.
-   So the engine should not rely on this command even though all new GUIs should support it.
-   As the engine's reaction to "ucinewgame" can take some time the GUI should always send "isready"
-   after "ucinewgame" to wait for the engine to finish its operation.
-   
-* position [fen <fenstring> | startpos ]  moves <move1> .... <movei>
-	set up the position described in fenstring on the internal board and
-	play the moves on the internal chess board.
-	if the game was played  from the start position the string "startpos" will be sent
-	Note: no "new" command is needed. However, if this position is from a different game than
-	the last position sent to the engine, the GUI should have sent a "ucinewgame" inbetween.
-
-* go
-	start calculating on the current position set up with the "position" command.
-	There are a number of commands that can follow this command, all will be sent in the same string.
-	If one command is not sent its value should be interpreted as it would not influence the search.
-	* searchmoves <move1> .... <movei>
-		restrict search to this moves only
-		Example: After "position startpos" and "go infinite searchmoves e2e4 d2d4"
-		the engine should only search the two moves e2e4 and d2d4 in the initial position.
-	* ponder
-		start searching in pondering mode.
-		Do not exit the search in ponder mode, even if it's mate!
-		This means that the last move sent in in the position string is the ponder move.
-		The engine can do what it wants to do, but after a "ponderhit" command
-		it should execute the suggested move to ponder on. This means that the ponder move sent by
-		the GUI can be interpreted as a recommendation about which move to ponder. However, if the
-		engine decides to ponder on a different move, it should not display any mainlines as they are
-		likely to be misinterpreted by the GUI because the GUI expects the engine to ponder
-	   on the suggested move.
-	* wtime <x>
-		white has x msec left on the clock
-	* btime <x>
-		black has x msec left on the clock
-	* winc <x>
-		white increment per move in mseconds if x > 0
-	* binc <x>
-		black increment per move in mseconds if x > 0
-	* movestogo <x>
-      there are x moves to the next time control,
-		this will only be sent if x > 0,
-		if you don't get this and get the wtime and btime it's sudden death
-	* depth <x>
-		search x plies only.
-	* nodes <x>
-	   search x nodes only,
-	* mate <x>
-		search for a mate in x moves
-	* movetime <x>
-		search exactly x mseconds
-	* infinite
-		search until the "stop" command. Do not exit the search without being told so in this mode!
-    
-* stop
-	stop calculating as soon as possible,
-	don't forget the "bestmove" and possibly the "ponder" token when finishing the search
-
-* ponderhit
-	the user has played the expected move. This will be sent if the engine was told to ponder on the same move
-	the user has played. The engine should continue searching but switch from pondering to normal search.
-
-* quit
-	quit the program as soon as possible
-
-
-Engine to GUI:
---------------
-
-* id
-	* name <x>
-		this must be sent after receiving the "uci" command to identify the engine,
-		e.g. "id name Shredder X.Y\n"
-	* author <x>
-		this must be sent after receiving the "uci" command to identify the engine,
-		e.g. "id author Stefan MK\n"
-
-* uciok
-	Must be sent after the id and optional options to tell the GUI that the engine
-	has sent all infos and is ready in uci mode.
-
-* readyok
-	This must be sent when the engine has received an "isready" command and has
-	processed all input and is ready to accept new commands now.
-	It is usually sent after a command that can take some time to be able to wait for the engine,
-	but it can be used anytime, even when the engine is searching,
-	and must always be answered with "isready".
-
-* bestmove <move1> [ ponder <move2> ]
-	the engine has stopped searching and found the move <move> best in this position.
-	the engine can send the move it likes to ponder on. The engine must not start pondering automatically.
-	this command must always be sent if the engine stops searching, also in pondering mode if there is a
-	"stop" command, so for every "go" command a "bestmove" command is needed!
-	Directly before that the engine should send a final "info" command with the final search information,
-	the the GUI has the complete statistics about the last search.
-
-* copyprotection
-	this is needed for copyprotected engines. After the uciok command the engine can tell the GUI,
-	that it will check the copy protection now. This is done by "copyprotection checking".
-	If the check is ok the engine should send "copyprotection ok", otherwise "copyprotection error".
-	If there is an error the engine should not function properly but should not quit alone.
-	If the engine reports "copyprotection error" the GUI should not use this engine
-	and display an error message instead!
-	The code in the engine can look like this
-      TellGUI("copyprotection checking\n");
-	   // ... check the copy protection here ...
-	   if(ok)
-	      TellGUI("copyprotection ok\n");
-      else
-         TellGUI("copyprotection error\n");
-         
-* registration
-	this is needed for engines that need a username and/or a code to function with all features.
-	Analog to the "copyprotection" command the engine can send "registration checking"
-	after the uciok command followed by either "registration ok" or "registration error".
-	Also after every attempt to register the engine it should answer with "registration checking"
-	and then either "registration ok" or "registration error".
-	In contrast to the "copyprotection" command, the GUI can use the engine after the engine has
-	reported an error, but should inform the user that the engine is not properly registered
-	and might not use all its features.
-	In addition the GUI should offer to open a dialog to
-	enable registration of the engine. To try to register an engine the GUI can send
-	the "register" command.
-	The GUI has to always answer with the "register" command	if the engine sends "registration error"
-	at engine startup (this can also be done with "register later")
-	and tell the user somehow that the engine is not registered.
-	This way the engine knows that the GUI can deal with the registration procedure and the user
-	will be informed that the engine is not properly registered.
-	      
-* info
-	the engine wants to send information to the GUI. This should be done whenever one of the info has changed.
-	The engine can send only selected infos or multiple infos with one info command,
-	e.g. "info currmove e2e4 currmovenumber 1" or
-	     "info depth 12 nodes 123456 nps 100000".
-	Also all infos belonging to the pv should be sent together
-	e.g. "info depth 2 score cp 214 time 1242 nodes 2124 nps 34928 pv e2e4 e7e5 g1f3"
-	I suggest to start sending "currmove", "currmovenumber", "currline" and "refutation" only after one second
-	to avoid too much traffic.
-	Additional info:
-	* depth <x>
-		search depth in plies
-	* seldepth <x>
-		selective search depth in plies,
-		if the engine sends seldepth there must also be a "depth" present in the same string.
-	* time <x>
-		the time searched in ms, this should be sent together with the pv.
-	* nodes <x>
-		x nodes searched, the engine should send this info regularly
-	* pv <move1> ... <movei>
-		the best line found
-	* multipv <num>
-		this for the multi pv mode.
-		for the best move/pv add "multipv 1" in the string when you send the pv.
-		in k-best mode always send all k variants in k strings together.
-	* score
-		* cp <x>
-			the score from the engine's point of view in centipawns.
-		* mate <y>
-			mate in y moves, not plies.
-			If the engine is getting mated use negative values for y.
-		* lowerbound
-	      the score is just a lower bound.
-		* upperbound
-		   the score is just an upper bound.
-	* currmove <move>
-		currently searching this move
-	* currmovenumber <x>
-		currently searching move number x, for the first move x should be 1 not 0.
-	* hashfull <x>
-		the hash is x permill full, the engine should send this info regularly
-	* nps <x>
-		x nodes per second searched, the engine should send this info regularly
-	* tbhits <x>
-		x positions where found in the endgame table bases
-	* sbhits <x>
-		x positions where found in the shredder endgame databases
-	* cpuload <x>
-		the cpu usage of the engine is x permill.
-	* string <str>
-		any string str which will be displayed be the engine,
-		if there is a string command the rest of the line will be interpreted as <str>.
-	* refutation <move1> <move2> ... <movei>
-	   move <move1> is refuted by the line <move2> ... <movei>, i can be any number >= 1.
-	   Example: after move d1h5 is searched, the engine can send
-	   "info refutation d1h5 g6h5"
-	   if g6h5 is the best answer after d1h5 or if g6h5 refutes the move d1h5.
-	   if there is no refutation for d1h5 found, the engine should just send
-	   "info refutation d1h5"
-		The engine should only send this if the option "UCI_ShowRefutations" is set to true.
-	* currline <cpunr> <move1> ... <movei>
-	   this is the current line the engine is calculating. <cpunr> is the number of the cpu if
-	   the engine is running on more than one cpu. <cpunr> = 1,2,3....
-	   if the engine is just using one cpu, <cpunr> can be omitted.
-	   If <cpunr> is greater than 1, always send all k lines in k strings together.
-		The engine should only send this if the option "UCI_ShowCurrLine" is set to true.
-	
-
-* option
-	This command tells the GUI which parameters can be changed in the engine.
-	This should be sent once at engine startup after the "uci" and the "id" commands
-	if any parameter can be changed in the engine.
-	The GUI should parse this and build a dialog for the user to change the settings.
-	Note that not every option needs to appear in this dialog as some options like
-	"Ponder", "UCI_AnalyseMode", etc. are better handled elsewhere or are set automatically.
-	If the user wants to change some settings, the GUI will send a "setoption" command to the engine.
-	Note that the GUI need not send the setoption command when starting the engine for every option if
-	it doesn't want to change the default value.
-	For all allowed combinations see the examples below,
-	as some combinations of this tokens don't make sense.
-	One string will be sent for each parameter.
-	* name <id>
-		The option has the name id.
-		Certain options have a fixed value for <id>, which means that the semantics of this option is fixed.
-		Usually those options should not be displayed in the normal engine options window of the GUI but
-		get a special treatment. "Pondering" for example should be set automatically when pondering is
-		enabled or disabled in the GUI options. The same for "UCI_AnalyseMode" which should also be set
-		automatically by the GUI. All those certain options have the prefix "UCI_" except for the
-		first 6 options below. If the GUI gets an unknown Option with the prefix "UCI_", it should just
-		ignore it and not display it in the engine's options dialog.
-		* <id> = Hash, type is spin
-			the value in MB for memory for hash tables can be changed,
-			this should be answered with the first "setoptions" command at program boot
-			if the engine has sent the appropriate "option name Hash" command,
-			which should be supported by all engines!
-			So the engine should use a very small hash first as default.
-		* <id> = NalimovPath, type string
-			this is the path on the hard disk to the Nalimov compressed format.
-			Multiple directories can be concatenated with ";"
-		* <id> = NalimovCache, type spin
-			this is the size in MB for the cache for the nalimov table bases
-			These last two options should also be present in the initial options exchange dialog
-			when the engine is booted if the engine supports it
-		* <id> = Ponder, type check
-			this means that the engine is able to ponder.
-			The GUI will send this whenever pondering is possible or not.
-			Note: The engine should not start pondering on its own if this is enabled, this option is only
-			needed because the engine might change its time management algorithm when pondering is allowed.
-		* <id> = OwnBook, type check
-			this means that the engine has its own book which is accessed by the engine itself.
-			if this is set, the engine takes care of the opening book and the GUI will never
-			execute a move out of its book for the engine. If this is set to false by the GUI,
-			the engine should not access its own book.
-		* <id> = MultiPV, type spin
-			the engine supports multi best line or k-best mode. the default value is 1
-		* <id> = UCI_ShowCurrLine, type check, should be false by default,
-			the engine can show the current line it is calculating. see "info currline" above.
-		* <id> = UCI_ShowRefutations, type check, should be false by default,
-			the engine can show a move and its refutation in a line. see "info refutations" above.
-		* <id> = UCI_LimitStrength, type check, should be false by default,
-			The engine is able to limit its strength to a specific Elo number,
-		   This should always be implemented together with "UCI_Elo".
-		* <id> = UCI_Elo, type spin
-			The engine can limit its strength in Elo within this interval.
-			If UCI_LimitStrength is set to false, this value should be ignored.
-			If UCI_LimitStrength is set to true, the engine should play with this specific strength.
-		   This should always be implemented together with "UCI_LimitStrength".
-		* <id> = UCI_AnalyseMode, type check
-		   The engine wants to behave differently when analysing or playing a game.
-		   For example when playing it can use some kind of learning.
-		   This is set to false if the engine is playing a game, otherwise it is true.
-		 * <id> = UCI_Opponent, type string
-		   With this command the GUI can send the name, title, elo and if the engine is playing a human
-		   or computer to the engine.
-		   The format of the string has to be [GM|IM|FM|WGM|WIM|none] [<elo>|none] [computer|human] <name>
-		   Examples:
-		   "setoption name UCI_Opponent value GM 2800 human Gary Kasparov"
-		   "setoption name UCI_Opponent value none none computer Shredder"
-		 * <id> = UCI_EngineAbout, type string
-		   With this command, the engine tells the GUI information about itself, for example a license text,
-		   usually it doesn't make sense that the GUI changes this text with the setoption command.
-		   Example:
-			"option name UCI_EngineAbout type string default Shredder by Stefan Meyer-Kahlen, see www.shredderchess.com"
-		* <id> = UCI_ShredderbasesPath, type string
-			this is either the path to the folder on the hard disk containing the Shredder endgame databases or
-			the path and filename of one Shredder endgame datbase.
-	   * <id> = UCI_SetPositionValue, type string
-	      the GUI can send this to the engine to tell the engine to use a certain value in centipawns from white's
-	      point of view if evaluating this specifix position. 
-	      The string can have the formats:
-	      <value> + <fen> | clear + <fen> | clearall
-	   		
-	* type <t>
-		The option has type t.
-		There are 5 different types of options the engine can send
-		* check
-			a checkbox that can either be true or false
-		* spin
-			a spin wheel that can be an integer in a certain range
-		* combo
-			a combo box that can have different predefined strings as a value
-		* button
-			a button that can be pressed to send a command to the engine
-		* string
-			a text field that has a string as a value,
-			an empty string has the value "<empty>"
-	* default <x>
-		the default value of this parameter is x
-	* min <x>
-		the minimum value of this parameter is x
-	* max <x>
-		the maximum value of this parameter is x
-	* var <x>
-		a predefined value of this parameter is x
-	Examples:
-    Here are 5 strings for each of the 5 possible types of options
-	   "option name Nullmove type check default true\n"
-      "option name Selectivity type spin default 2 min 0 max 4\n"
-	   "option name Style type combo default Normal var Solid var Normal var Risky\n"
-	   "option name NalimovPath type string default c:\\n"
-	   "option name Clear Hash type button\n"
-
-
-
-Examples:
----------
-
-This is how the communication when the engine boots can look like:
-
-GUI     engine
-
-// tell the engine to switch to UCI mode
-uci
-
-// engine identify  
-      id name Shredder
-		id author Stefan MK
-
-// engine sends the options it can change
-// the engine can change the hash size from 1 to 128 MB
-		option name Hash type spin default 1 min 1 max 128
-
-// the engine supports Nalimov endgame tablebases
-		option name NalimovPath type string default <empty>
-		option name NalimovCache type spin default 1 min 1 max 32
-
-// the engine can switch off Nullmove and set the playing style
-	   option name Nullmove type check default true
-  		option name Style type combo default Normal var Solid var Normal var Risky
-
-// the engine has sent all parameters and is ready
-		uciok
-
-// Note: here the GUI can already send a "quit" command if it just wants to find out
-//       details about the engine, so the engine should not initialize its internal
-//       parameters before here.
-// now the GUI sets some values in the engine
-// set hash to 32 MB
-setoption name Hash value 32
-
-// init tbs
-setoption name NalimovCache value 1
-setoption name NalimovPath value d:\tb;c\tb
-
-// waiting for the engine to finish initializing
-// this command and the answer is required here!
-isready
-
-// engine has finished setting up the internal values
-		readyok
-
-// now we are ready to go
-
-// if the GUI is supporting it, tell the engine that is is
-// searching on a game that it hasn't searched on before
-ucinewgame
-
-// if the engine supports the "UCI_AnalyseMode" option and the next search is supposed to
-// be an analysis, the GUI should set "UCI_AnalyseMode" to true if it is currently
-// set to false with this engine
-setoption name UCI_AnalyseMode value true
-
-// tell the engine to search infinite from the start position after 1.e4 e5
-position startpos moves e2e4 e7e5
-go infinite
-
-// the engine starts sending infos about the search to the GUI
-// (only some examples are given)
-
-
-		info depth 1 seldepth 0
-		info score cp 13  depth 1 nodes 13 time 15 pv f1b5 
-		info depth 2 seldepth 2
-		info nps 15937
-		info score cp 14  depth 2 nodes 255 time 15 pv f1c4 f8c5 
-		info depth 2 seldepth 7 nodes 255
-		info depth 3 seldepth 7
-		info nps 26437
-		info score cp 20  depth 3 nodes 423 time 15 pv f1c4 g8f6 b1c3 
-		info nps 41562
-		....
-
-
-// here the user has seen enough and asks to stop the searching
-stop
-
-// the engine has finished searching and is sending the bestmove command
-// which is needed for every "go" command sent to tell the GUI
-// that the engine is ready again
-		bestmove g1f3 ponder d8f6
-
-
-
-Chess960
-========
-
-UCI could easily be extended to support Chess960 (also known as Fischer Random Chess).
-
-The engine has to tell the GUI that it is capable of playing Chess960 and the GUI has to tell
-the engine that is should play according to the Chess960 rules.
-This is done by the special engine option UCI_Chess960. If the engine knows about Chess960
-it should send the command 'option name UCI_Chess960 type check default false'
-to the GUI at program startup.
-Whenever a Chess960 game is played, the GUI should set this engine option to 'true'.
-
-Castling is different in Chess960 and the white king move when castling short is not always e1g1.
-A king move could both be the castling king move or just a normal king move.
-This is why castling moves are sent in the form king "takes" his own rook.
-Example: e1h1 for the white short castle move in the normal chess start position.
-
-In EPD and FEN position strings specifying the castle rights with w and q is not enough as
-there could be more than one rook on the right or left side of the king.
-This is why the castle rights are specified with the letter of the castle rook's line.
-Upper case letters for white's and lower case letters for black's castling rights.
-Example: The normal chess position would be:
-rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w AHah -
-
diff --git a/src/uci/command.c b/src/uci/command.c
index d82c50c..02d6e0f 100644
--- a/src/uci/command.c
+++ b/src/uci/command.c
@@ -1,6 +1,6 @@
 #include <assert.h>
-#include <stdlib.h>
 #include <string.h>
+#include <stdlib.h>
 #include "command.h"
 
 ucicmd ucicmd_init() {
diff --git a/src/uci/command.h b/src/uci/command.h
deleted file mode 100644
index ba9c51d..0000000
--- a/src/uci/command.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef UCI_COMMAND_H
-#define UCI_COMMAND_H
-
-#define MAX_TOKEN_SIZE 32
-
-typedef struct {
-  char root[MAX_TOKEN_SIZE];
-  int args_count;
-  int args_capacity;
-  char* args;
-  bool empty;
-} ucicmd;
-
-ucicmd ucicmd_init();
-void ucicmd_add(ucicmd* cmd, const char* token);
-void ucicmd_set_root(ucicmd* cmd, const char* token);
-void ucicmd_append_arg(ucicmd* cmd, const char* token);
-char* ucicmd_get_arg(ucicmd cmd, int i);
-void ucicmd_deinit(ucicmd cmd);
-
-#endif // UCI_COMMAND_H
diff --git a/src/uci/draft-1.pdf b/src/uci/draft-1.pdf
deleted file mode 100644
index 9c68adb..0000000
--- a/src/uci/draft-1.pdf
+++ /dev/null
diff --git a/src/uci/draft-2.pdf b/src/uci/draft-2.pdf
deleted file mode 100644
index d0d4707..0000000
--- a/src/uci/draft-2.pdf
+++ /dev/null
diff --git a/src/uci/response.c b/src/uci/response.c
index 6208a54..7ebe49c 100644
--- a/src/uci/response.c
+++ b/src/uci/response.c
@@ -3,8 +3,9 @@
 #include <stdlib.h>
 
 #include "response.h"
-#include "../fen.h"
-#include "../bitboard.h"
+#include "ipc.h"
+#include "fen.h"
+#include "bitboard.h"
 
 void apply_option(uci_state *state, char *name, char *buffer) {
   int settings_count = sizeof(state->option_settings)/sizeof(option_setting_t);
@@ -212,6 +213,48 @@ void handle_idle(
   } else if (strcmp(cmd.root, "isready") == 0) {
     current_state = STATE_SYNC;
   } else if (strcmp(cmd.root, "go") == 0) {
+    state->go_args = malloc(sizeof(struct go_args));
+    struct go_args *info = state->go_args;
+    for (int i = 0; i < cmd.args_count; i++) {
+      if (strcmp(ucicmd_get_arg(cmd, i), "searchmoves") == 0) {
+        info->searchmoves = comm_moves_init();
+        for (i++; i < cmd.args_count; i++) {
+          char* move_str = ucicmd_get_arg(cmd, i);
+          if (move_str[1] < '0' || move_str[1] > '9') break;
+
+          add_comm_move(&info->searchmoves, (struct uci_move) {
+            (move_str[0] - 'a') * 8 + (move_str[1] - '1'),
+            (move_str[2] - 'a') * 8 + (move_str[3] - '1')
+          });
+        }
+        i--;
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "ponder") == 0) {
+        info->ponder = true;
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "wtime") == 0) {
+        info->wtime = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "btime") == 0) {
+        info->btime = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "winc") == 0) {
+        info->winc = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "binc") == 0) {
+        info->binc = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "movestogo") == 0) {
+        info->movestogo = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "depth") == 0) {
+        info->depth = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "nodes") == 0) {
+        info->nodes = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "mate") == 0) {
+        info->mate = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "movetime") == 0) {
+        info->movetime = atoi(ucicmd_get_arg(cmd, ++i));
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "infinite") == 0) {
+        info->infinite = true;
+      } else if (strcmp(ucicmd_get_arg(cmd, i), "perft") == 0) {
+        info->perft = atoi(ucicmd_get_arg(cmd, ++i));
+      }
+    }
+
     atomic_store(&state->go, 1);
     current_state = STATE_ACTIVE;
   } else {
@@ -247,17 +290,31 @@ void handle_active(
   engine_messages* engine_messages,
   ucicmd cmd
 ) {
+  while (atomic_load(&state->go_ready_receive) == 0);
+
+  bool ended = false;
   for (int i = 0; i < engine_messages->count; i++) {
     struct engine_message *old = engine_messages->data[i];
+    if (old == NULL) continue;
     if (!old->ready) continue;
     old->ready = 0;
 
     printf(
-      "info depth %d seldepth %d multipv %d score cp %d nodes %d nps %d hashfull %d tbhits %d time %d pv",
+      "info depth %d seldepth %d multipv %d ",
       old->depth,
       old->seldepth,
-      old->multipv,
-      old->score_cp,
+      old->multipv
+    );
+    if (old->mate) {
+      printf("mate %d ", old->mate);
+    } else {
+      printf("score cp %d ", old->score_cp);
+    }
+    if (old->node_limit) {
+      printf("upperbound ");
+    }
+    printf(
+      "nodes %d nps %d hashfull %d tbhits %d time %d pv",
       old->nodes,
       old->nps,
       old->hashfull,
@@ -278,6 +335,7 @@ void handle_active(
     printf("\n");
 
     if (old->best_move.from != 0 && old->best_move.to != 0) {
+      ended = true;
       printf(
         "bestmove %c%c%c%c",
         (old->best_move.from / 8) + 'a',
@@ -300,8 +358,13 @@ void handle_active(
     engine_messages->data[i] = old->next;
     free(old->pv.moves);
     free(old);
+
+    if (ended) {
+      printf("ENDED\n");
+      atomic_store(&state->cleanup, 1);
+      current_state = STATE_IDLE;
+    }
   }
-  // TODO: this section will call the engine to analysis
   if (cmd.empty) {
     return;
   }
@@ -316,9 +379,9 @@ void handle_active(
 
 void handle_halt(uci_state *state, ucicmd cmd) {
   // TIMEOUT NOTICE: THE FOLLOWING BLOCK SHOULDN'T TAKE MORE THAN 1 SECONDS
-  
+ 
+  atomic_store(&state->stop, 1);
   
   // ---
-  printf("bestmove 0000\n"); // TODO: idk get it rn
   current_state = STATE_IDLE;
 }
diff --git a/src/uci/response.h b/src/uci/response.h
deleted file mode 100644
index 16652d2..0000000
--- a/src/uci/response.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "command.h"
-#include "state.h"
-#include "../ipc.h"
-
-void handle_uci(
-  uci_state *state,
-  engine_messages* engine_message,
-  ucicmd cmd
-);
-void handle_initial(uci_state *state, ucicmd cmd);
-void handle_idle(uci_state *state, ucicmd cmd);
-void handle_sync(uci_state *state, ucicmd cmd);
-void handle_ping(uci_state *state, ucicmd cmd);
-void handle_active(
-  uci_state *state,
-  engine_messages* engine_message,
-  ucicmd cmd
-);
-void handle_halt(uci_state *state, ucicmd cmd);
diff --git a/src/uci/state.c b/src/uci/state.c
index f64b5cf..56e0b04 100644
--- a/src/uci/state.c
+++ b/src/uci/state.c
@@ -9,7 +9,7 @@ option_setting_t option_setting_combo(
   combo_t *combo
 ) {
   option_setting_t output = {0};
-  memcpy(output.option_name, option_name, 32);
+  strncpy(output.option_name, option_name, 32);
   output.type = OPTION_COMBO;
   output.data.combo = (option_combo_setting_t) {
     combinations,
@@ -29,7 +29,7 @@ option_setting_t option_setting_spin(
   spin_t *spin
 ) {
   option_setting_t output = {0};
-  memcpy(output.option_name, option_name, 32);
+  strncpy(output.option_name, option_name, 32);
   output.type = OPTION_SPIN;
   output.data.spin = (option_spin_setting_t) { min, max, default_value };
   output.value.spin = spin;
@@ -43,7 +43,7 @@ option_setting_t option_setting_check(
   check_t *check
 ) {
   option_setting_t output = {0};
-  memcpy(output.option_name, option_name, 32);
+  strncpy(output.option_name, option_name, 32);
   output.type = OPTION_CHECK;
   output.data.check_default = default_value;
   output.value.check = check;
@@ -72,7 +72,7 @@ option_setting_t option_setting_button(
   button_t *button
 ) {
   option_setting_t output = {0};
-  memcpy(output.option_name, option_name, 32);
+  strncpy(output.option_name, option_name, 32);
   output.type = OPTION_BUTTON;
   output.value.button = button;
   *button = false;
diff --git a/src/uci/state.h b/src/uci/state.h
deleted file mode 100644
index 9c59a3a..0000000
--- a/src/uci/state.h
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef UCI_STATE_H
-#define UCI_STATE_H
-
-#include <stdatomic.h>
-#include "../fen.h"
-
-typedef struct {
-  char* data;
-  int length;
-} str_t;
-
-typedef bool check_t;
-typedef int spin_t;
-typedef int combo_t;
-// the button isn't actually a value thing
-// it's more like an event.
-// so we parse a button type, we set this to true, handle it
-// then set it to false again
-typedef bool button_t;
-
-typedef struct {
-  char** combination;
-  int count;
-  int default_index;
-} option_combo_setting_t;
-typedef struct {
-  int min;
-  int max;
-  int default_value;
-} option_spin_setting_t;
-enum { OPTION_SPIN, OPTION_COMBO, OPTION_CHECK, OPTION_STRING, OPTION_BUTTON };
-typedef struct {
-  char option_name[32];
-  int type;
-  union {
-    option_combo_setting_t combo;
-    option_spin_setting_t spin;
-    bool check_default;
-    const char* string_default;
-  } data;
-  union {
-    combo_t *combo;
-    spin_t *spin;
-    check_t *check;
-    str_t *string;
-    button_t *button;
-  } value;
-} option_setting_t;
-
-option_setting_t option_setting_combo(
-  char* option_name,
-  char** combinations,
-  int combinations_count,
-  int default_index,
-  combo_t *combo
-);
-option_setting_t option_setting_spin(
-  const char* option_name,
-  int min,
-  int max,
-  int default_value,
-  spin_t *spin
-);
-option_setting_t option_setting_check(
-  const char* option_name,
-  bool default_value,
-  check_t *check
-);
-option_setting_t option_setting_string(
-  const char* option_name,
-  const char* default_value,
-  str_t *string
-);
-option_setting_t option_setting_button(
-  const char* option_name,
-  button_t *button
-);
-
-typedef struct {
-  char name[32];
-  char author[32];
-  bool debug;
-
-  atomic_int go;
-  atomic_int quit;
-
-  position_t position;
-  struct uci_move *moves;
-  int moves_count;
-
-  option_setting_t option_settings[11];
-
-  // options
-  spin_t threads;
-  spin_t hash;
-  button_t clear_hash;
-  // str_t nalimovpath;
-  // spin_t nalimovcache;
-  // check_t ponder;
-  // check_t ownbook;
-  // spin_t multipv;
-  check_t uci_showcurrline;
-  check_t uci_showrefutations;
-  check_t uci_limitstrength;
-  spin_t uci_elo;
-  check_t uci_analysemode;
-  str_t uci_opponent;
-  str_t uci_engineabout;
-  // str_t uci_shredderbasespath;
-  str_t uci_setpositionvalue;
-} uci_state;
-
-struct uci_move {
-  int from;
-  int to;
-};
-
-#endif // UCI_STATE_H
diff --git a/src/uci/uci_min.txt b/src/uci/uci_min.txt
deleted file mode 100644
index 58a85b6..0000000
--- a/src/uci/uci_min.txt
+++ /dev/null
@@ -1,140 +0,0 @@
-GUI to engine:
-* uci
-* debug [ on | off ]
-* isready
-* setoption name <id> [value <x>]
-	Here are some strings for the example below:
-	   "setoption name Nullmove value true\n"
-     "setoption name Selectivity value 3\n"
-	   "setoption name Style value Risky\n"
-	   "setoption name Clear Hash\n"
-	   "setoption name NalimovPath value c:\chess\tb\4;c:\chess\tb\5\n"
-
-* register
-	The following tokens are allowed:
-	* later
-	   the user doesn't want to register the engine now.
-	* name <x>
-	   the engine should be registered with the name <x>
-	* code <y>
-	   the engine should be registered with the code <y>
-	Example:
-	   "register later"
-	   "register name Stefan MK code 4359874324"
-
-* ucinewgame
-* position [fen <fenstring> | startpos ]  moves <move1> .... <movei>
-* go
-	* searchmoves <move1> .... <movei>
-		Example: After "position startpos" and "go infinite searchmoves e2e4 d2d4"
-		the engine should only search the two moves e2e4 and d2d4 in the initial position.
-	* ponder
-	* wtime <x>
-	* btime <x>
-	* winc <x>
-	* binc <x>
-	* movestogo <x>
-	* depth <x>
-	* nodes <x>
-	* mate <x>
-	* movetime <x>
-	* infinite
-* stop
-* ponderhit
-* quit
-
-
-Engine to GUI:
-* id
-	* name <x>
-		e.g. "id name Shredder X.Y\n"
-	* author <x>
-		e.g. "id author Stefan MK\n"
-* uciok
-* readyok
-* bestmove <move1> [ ponder <move2> ]
-* copyprotection
-* registration
-* info
-	e.g. "info currmove e2e4 currmovenumber 1" or
-	     "info depth 12 nodes 123456 nps 100000".
-	e.g. "info depth 2 score cp 214 time 1242 nodes 2124 nps 34928 pv e2e4 e7e5 g1f3"
-	Additional info:
-	* depth <x>
-	* seldepth <x>
-	* time <x>
-	* nodes <x>
-	* pv <move1> ... <movei>
-	* multipv <num>
-	* score
-		* cp <x>
-		* mate <y>
-		* lowerbound
-		* upperbound
-	* currmove <move>
-	* currmovenumber <x>
-	* hashfull <x>
-	* nps <x>
-	* tbhits <x>
-	* sbhits <x>
-	* cpuload <x>
-	* string <str>
-	* refutation <move1> <move2> ... <movei>
-	   Example: after move d1h5 is searched, the engine can send
-	   "info refutation d1h5 g6h5"
-	   if g6h5 is the best answer after d1h5 or if g6h5 refutes the move d1h5.
-	   if there is no refutation for d1h5 found, the engine should just send
-	   "info refutation d1h5"
-	* currline <cpunr> <move1> ... <movei>
-	
-
-* option
-	* name <id>
-		* <id> = Hash, type is spin
-		* <id> = NalimovPath, type string
-		* <id> = NalimovCache, type spin
-		* <id> = Ponder, type check
-		* <id> = OwnBook, type check
-		* <id> = MultiPV, type spin
-		* <id> = UCI_ShowCurrLine, type check, should be false by default,
-		* <id> = UCI_ShowRefutations, type check, should be false by default,
-		* <id> = UCI_LimitStrength, type check, should be false by default,
-		* <id> = UCI_Elo, type spin
-		* <id> = UCI_AnalyseMode, type check
-		 * <id> = UCI_Opponent, type string
-		   Examples:
-		   "setoption name UCI_Opponent value GM 2800 human Gary Kasparov"
-		   "setoption name UCI_Opponent value none none computer Shredder"
-		 * <id> = UCI_EngineAbout, type string
-		   Example:
-			"option name UCI_EngineAbout type string default Shredder by Stefan Meyer-Kahlen, see www.shredderchess.com"
-		* <id> = UCI_ShredderbasesPath, type string
-	   * <id> = UCI_SetPositionValue, type string
-	   		
-	* type <t>
-		* check
-			a checkbox that can either be true or false
-		* spin
-			a spin wheel that can be an integer in a certain range
-		* combo
-			a combo box that can have different predefined strings as a value
-		* button
-			a button that can be pressed to send a command to the engine
-		* string
-			a text field that has a string as a value,
-			an empty string has the value "<empty>"
-	* default <x>
-		the default value of this parameter is x
-	* min <x>
-		the minimum value of this parameter is x
-	* max <x>
-		the maximum value of this parameter is x
-	* var <x>
-		a predefined value of this parameter is x
-	Examples:
-    Here are 5 strings for each of the 5 possible types of options
-	   "option name Nullmove type check default true\n"
-      "option name Selectivity type spin default 2 min 0 max 4\n"
-	   "option name Style type combo default Normal var Solid var Normal var Risky\n"
-	   "option name NalimovPath type string default c:\\n"
-	   "option name Clear Hash type button\n"