=================OpenRA, UberWaffe's Custom Warhead "How To Guide"=================

	Let's say you want to make a new Warhead that does MindControl.
	You've already made two traits called MindController and MindControlable.

	MindController - This goes on the actor doing the mind controlling, and needs to keep track of which actors is under its command.

	MindControlable - This goes on the victim actors, and keeps track of whom (if any) is mind controlling it. And who it originally belonged to.

	What you need is to create the link between these two when mind control occurs. I.e. tell the controller that the new controlable is now affected.
	And tell the victim whom its new boss is.


	So you make the new custom warhead. One which will setup these links.
	And since it is a warhead, you get the functionality of weapons for free (i.e. autotarget, range checks, target types, diplomacy checks, etc.)


--Create a new Warhead class--
	So first, you make a class called MindControllerWarheadInfo.

		public class MindControllerWarheadInfo
		{

		}

	The "WarheadInfo" part is standard. The "MindController" part is what you want it to be called.

	In yaml you can create your warhead type by doing this:

		Warhead@Whateveryouwant: MindController

	The "Whateveryouwant" bit is anything you want, and is just for allowing multiple warheads on a single weapon.
	The ": MindController" part is so that the code will know what type of warhead you want.
	What the code does is take the bit after the ":" (in this case "MindController") and sticks "WarheadInfo" at the back, and then creates an instance of that class.


--Give the new class some basic guts--
	Now, your new warhead class has to implement the "IWarheadInfo" interface, so that there is a standard way for the weapon code to interact with your new warhead.
	You will have to make functions for all the bits of the interface.

	But since the valid checks are done in a rather standard fashion (i.e. we check allowed types against the victim's TargetTypes), there is also a base warhead class called BaseWarhead.
	If you inherit from BaseWarhead, like this:

		public class MindControllerWarheadInfo : BaseWarhead, IWarheadInfo
		{

			public MindControllerWarheadInfo() : base() { }
		}

	Then your warhead can already understand:
	* What is valid targets and what is not (including diplomacy keywords such as "Ally", "Neutral", Enemy").
	* How to load its values from yaml.

	But it will not know how to:
	* Do an impact. In fact, its DoImpact() simply logs a warning to the debug.log
	* Check for effectiveness. It will always say it is 100% effective against everything. (Arrogant little warhead.)


--Tell your warhead what it must do on an impact--
	Allright, so now we want to make our MindControl warhead create the link.
	So we have to put something inside its DoImpact.

		public new void DoImpact(WPos pos, WeaponInfo weapon, Actor firedBy, float firepowerModifier)
		{

		}

	But what to put in there?

	Let us take a look at the DoImpact of DamagerWarhead in GameRules > Warheads.

	We can see it does a check for what type of damage model it is. We don't have that, so we look inside the Normal damage model just because.
	Ah!
		var hitActors = world.FindActorsInCircle(pos, maxSpread);

	It finds all the actors within the spread of the warhead.
	We probably also have spread, so we'll have to do the same.
	(Remember, that warheads detonate at a position, even when targeting an actor. So we need some sort of spread check
	if we want to affect actors and not just positions.)

	Now, we look further:
		foreach (var victim in hitActors)

	Ah, it iterates over all the victims it found within range of its spread. Then for each victim, it figures out what happened.
	Firstly, it makes sure that the victim can be affected by the warhead:
		if (IsValidAgainst(victim, firedBy))

	Then it figures out how much damage to do and (here comes another important bit) does this:
		victim.InflictDamage(firedBy, damage, this);

	Effectively it calls the InflictDamage() function from the Health trait on the actor!

	Aha! So we can do something similar for our MindControlable and MindController traits!

		public new void DoImpact(WPos pos, WeaponInfo weapon, Actor firedBy, float firepowerModifier)
		{
			var world = firedBy.World;
			var targetTile = world.Map.CellContaining(pos);

			var hitActors = world.FindActorsInCircle(pos, Spread.Range);

			foreach (var victim in hitActors)
			{
				if (IsValidAgainst(victim, firedBy))
				{

				}
			}
		}

	But wait!! Health is always included, but our traits might not be, so we will have to do some sort of check to make sure the victim has the MindControlable trait.
	So we will need to overwrite IsValidAgainst from our inherited base, using the "new" flag.

		public new bool IsValidAgainst(Actor victim, Actor firedBy)
		{
			//A target type is valid if it is in the valid targets list, and not in the invalid targets list.
			return CheckTargetList(victim, firedBy, this.ValidTargets) &&
				!CheckTargetList(victim, firedBy, this.InvalidTargets);
		}

	So, since we can only mindcontrol victims that have the MindControlable trait, we add that into the IsValidAgainst check.

		public new bool IsValidAgainst(Actor victim, Actor firedBy)
		{
			var brainTrait = victim.TraitOrDefault<MindControlable>();
			if (brainTrait == null)
				return false;

			//A target type is valid if it is in the valid targets list, and not in the invalid targets list.
			return CheckTargetList(victim, firedBy, this.ValidTargets) &&
				!CheckTargetList(victim, firedBy, this.InvalidTargets);
		}

	This now means that if we check a victim that doesn't have the trait, our IsValidAgainst will tell us "No! No touchies!" and we will know we can't mindcontrol it.
	Now back to DoImpact:

		public new void DoImpact(WPos pos, WeaponInfo weapon, Actor firedBy, float firepowerModifier)
		{
			var world = firedBy.World;
			var targetTile = world.Map.CellContaining(pos);

			var hitActors = world.FindActorsInCircle(pos, Spread.Range);

			foreach (var victim in hitActors)
			{
				if (IsValidAgainst(victim, firedBy))
				{
					var brainTrait = victim.TraitOrDefault<MindControlable>();
					brainTrait.MyMindIsYours(firedBy); //We call the MyMindIsYours(Actor thePuppeteer) function on the MindControlable function to create the first half of the link.

					var puppeteerTrait = firedBy.TraitOrDefault<MindController>();
					puppeteerTrait.HisMindIsWeak(victim); //We call the HisMindIsWeak(Actor thePuppet) function on the MindController function to create the other half of the link.
				}
			}
		}

	And we are nearly done! We need some other checks, but for the most part our new warhead can now setup mindcontrol links!

	We probably still want to update IsValidAgainst to also check that the mindcontroller has spare capacity:

		public new bool IsValidAgainst(Actor victim, Actor firedBy)
		{
			var brainTrait = victim.TraitOrDefault<MindControlable>();
			if (brainTrait == null)
				return false;

			var superiorBrainTrait = firedBy.TraitOrDefault<MindController>();
			if (superiorBrainTrait == null)
				return false; //Mind Controller must be able to mind control, otherwise this won't work.

			if (superiorBrainTrait.HasSpareCapacity() == false)
				return false; //Sorry, the mind can take no more strain!

			//A target type is valid if it is in the valid targets list, and not in the invalid targets list.
			return CheckTargetList(victim, firedBy, this.ValidTargets) &&
				!CheckTargetList(victim, firedBy, this.InvalidTargets);
		}

--Make the YAML happen--
Warhead@theleftbrain: MindController
	Spread: 42