- Mech Fabricator can be built. Contruction path is almost the same as for lathes, but you'll require 2 Matter Bins, 1 Manipulator, 1 Micro-Laser and 1 Console Screen.

- Added design for mech fabricator circuitboard.
- Added origin_tech for some mech equipment.
- Examining mecha chassis will show what construction step you're currently on.
- Made Gygax construction reversible.
- Moved global_iterator.dm and construction_datum.dm to code/datums/helper_datums
- Split mecha_construction.dm into mecha_parts.dm and mecha_construction_paths.dm
- Fixed wrong logic for mecha dna-checks.

git-svn-id: http://tgstation13.googlecode.com/svn/trunk@1402 316c924e-a436-60f5-8080-3fe189b3f50e

code/datums/helper_datums/construction_datum.dm

@@ -0,0 +1,110 @@
+#define FORWARD -1
+#define BACKWARD 1
+
+/datum/construction
+	var/list/steps
+	var/atom/holder
+	var/result
+	var/list/steps_desc
+
+	New(atom)
+		..()
+		holder = atom
+		if(!holder) //don't want this without a holder
+			spawn
+				del src
+		set_desc(steps.len)
+		return
+
+	proc/next_step()
+		steps.len--
+		if(!steps.len)
+			spawn_result()
+		else
+			set_desc(steps.len)
+		return
+
+	proc/action(atom/used_atom,mob/user as mob)
+		return
+
+	proc/check_step(atom/used_atom,mob/user as mob) //check last step only
+		var/valid_step = is_right_key(used_atom)
+		if(valid_step)
+			if(custom_action(valid_step, used_atom, user))
+				next_step()
+				return 1
+		return 0
+
+	proc/is_right_key(atom/used_atom) // returns current step num if used_atom is of the right type.
+		var/list/L = steps[steps.len]
+		if(istype(used_atom, text2path(L["key"])))
+			return steps.len
+		return 0
+
+	proc/custom_action(step, used_atom, user)
+		return 1
+
+	proc/check_all_steps(atom/used_atom,mob/user as mob) //check all steps, remove matching one.
+		for(var/i=1;i<=steps.len;i++)
+			var/list/L = steps[i];
+			if(istype(used_atom, text2path(L["key"])))
+				if(custom_action(i, used_atom, user))
+					steps[i]=null;//stupid byond list from list removal...
+					clear_nulls(steps);
+					if(!steps.len)
+						spawn_result()
+					return 1
+		return 0
+
+
+	proc/spawn_result()
+		if(result)
+			new result(get_turf(holder))
+			spawn()
+				del holder
+		return
+
+	proc/clear_nulls(list/L)
+		while(null in L)
+			L -= null
+		return
+
+	proc/set_desc(index as num)
+		var/list/step = steps[index]
+		holder.desc = step["desc"]
+		return
+
+/datum/construction/reversible
+	var/index
+
+	New(atom)
+		..()
+		index = steps.len
+		return
+
+	proc/update_index(diff as num)
+		index+=diff
+		if(index==0)
+			spawn_result()
+		else
+			set_desc(index)
+		return
+
+	is_right_key(atom/used_atom) // returns index step
+		var/list/L = steps[index]
+		if(istype(used_atom, L["key"]))
+			return FORWARD //to the first step -> forward
+		else if(L["backkey"] && istype(used_atom, L["backkey"]))
+			return BACKWARD //to the last step -> backwards
+		return 0
+
+	check_step(atom/used_atom,mob/user as mob)
+		var/diff = is_right_key(used_atom)
+		if(diff)
+			if(custom_action(index, diff, used_atom, user))
+				update_index(diff)
+				return 1
+		return 0
+
+	custom_action(index, diff, used_atom, user)
+		return 1

code/datums/helper_datums/global_iterator.dm

@@ -0,0 +1,140 @@
+/*
+README:
+
+The global_iterator datum is supposed to provide a simple and robust way to
+create some constantly "looping" processes with ability to stop and restart them at will.
+Generally, the only thing you want to play with (meaning, redefine) is the process() proc.
+It must contain all the things you want done.
+
+Control functions:
+	new - used to create datum. First argument (optional) - var list(to use in process() proc) as list,
+	second (optional) - autostart control.
+	If autostart == TRUE, the loop will be started immediately after datum creation.
+
+	start(list/arguments) - starts the loop. Takes arguments(optional) as a list, which is then used
+	by process() proc. Returns null if datum already active, 1 if loop started succesfully and 0 if there's
+	an error in supplied arguments (not list or empty list).
+
+	stop() - stops the loop. Returns null if datum is already inactive and 1 on success.
+
+	set_delay(new_delay) - sets the delay between iterations. Pretty selfexplanatory.
+	Returns 0 on error(new_delay is not numerical), 1 otherwise.
+
+	set_process_args(list/arguments) - passes the supplied arguments to the process() proc.
+
+	active() - Returns 1 if datum is active, 0 otherwise.
+
+	toggle() - toggles datum state. Returns new datum state (see active()).
+
+Misc functions:
+
+	get_last_exec_time() - Returns the time of last iteration.
+
+	get_last_exec_time_as_text() - Returns the time of last iteration as text
+
+
+Control vars:
+
+	delay - 	delay between iterations
+
+	check_for_null - if equals TRUE, on each iteration the supplied arguments will be checked for nulls.
+	If some varible equals null (and null only), the loop is stopped.
+	Usefull, if some var unexpectedly becomes null - due to object deletion, for example.
+	Of course, you can also check the variables inside process() proc to prevent runtime errors.
+
+Data storage vars:
+
+	result - stores the value returned by process() proc
+*/
+
+/datum/global_iterator
+	var/control_switch = 0
+	var/delay = 10
+	var/list/arg_list = new
+	var/last_exec = null
+	var/check_for_null = 1
+	var/forbid_garbage = 0
+	var/result
+
+	New(list/arguments=null,autostart=1)
+		if(forbid_garbage) //prevents garbage collection with tag != null
+			tag = "\ref[src]"
+		set_process_args(arguments)
+		if(autostart)
+			start()
+		return
+
+	proc/main()
+		while(src && control_switch)
+			last_exec = world.timeofday
+			if(check_for_null && has_null_args())
+				return src.stop()
+			result = src.process(arglist(arg_list))
+			sleep(delay)
+		return
+
+	proc/start(list/arguments=null)
+		if(src.active())
+			return
+		if(arguments)
+			if(!set_process_args(arguments))
+				return 0
+		control_switch = 1
+		spawn()
+			src.main()
+		return 1
+
+	proc/stop()
+		if(!src.active())
+			return
+		control_switch = 0
+		return 1
+
+	proc/process()
+		return
+
+	proc/active()
+		return control_switch
+
+	proc/has_null_args()
+		if(null in arg_list) //Hope no "" or 0 errors here.
+			return 1
+/*
+			for(var/V in arg_list)
+				if(isnull(V))
+					return 1
+*/
+		return 0
+
+
+	proc/set_delay(new_delay)
+		if(isnum(new_delay))
+			delay = new_delay
+			return 1
+		else
+			return 0
+
+	proc/get_last_exec_time()
+		return (last_exec||0)
+
+	proc/get_last_exec_time_as_text()
+		return (time2text(last_exec)||"Wasn't executed yet")
+
+	proc/set_process_args(list/arguments)
+		if(arguments && istype(arguments, /list) && arguments.len)
+			arg_list = arguments
+			return 1
+		else
+//			world << "\red Invalid arguments supplied for [src.type], ref = \ref[src]"
+			return 0
+
+	proc/toggle_null_checks()
+		src.check_for_null = !src.check_for_null
+		return src.check_for_null
+
+	proc/toggle()
+		if(!src.stop())
+			src.start()
+		return src.active()
+
+