// To make the AI throw items, add the following lines of code:



// In human.h:



CHARACTER(humanoid, character)

{

	public:

	...

	virtual truth CheckThrowItemOpportunity();

	...

}



CHARACTER(axethrowerdwarf, humanoid)

{

 public:

  virtual void GetAICommand();

  virtual void CreateInitialEquipment(int);

 protected:

  virtual int GetTorsoMainColor() const;

  virtual int GetGauntletColor() const;

  virtual int GetLegMainColor() const;

  virtual v2 GetDrawDisplacement(int) const;

  virtual int GetWSkillHits() const { return 10000; }

  virtual truth IsElite() const { return false; }

};



// In human.cpp:



void axethrowerdwarf::CreateInitialEquipment(int SpecialFlags)

{

  SetRightWielded(meleeweapon::Spawn(AXE, SpecialFlags));

	SetLeftWielded(meleeweapon::Spawn(AXE, SpecialFlags));

	for(int k = 0; k < 6; k++)

	{

		GetStack()->AddItem(meleeweapon::Spawn(AXE));

	}

	GetStack()->AddItem(lantern::Spawn());

  GetCWeaponSkill(AXES)->AddHit(GetWSkillHits());

  GetCurrentRightSWeaponSkill()->AddHit(GetWSkillHits());

}



void axethrowerdwarf::GetAICommand()

{

	if(CheckThrowItemOpportunity())

		return;

		

  character::GetAICommand();

}



v2 axethrowerdwarf::GetDrawDisplacement(int j) const

{

  static v2 DrawDisplacement[] = { v2(0, 0), v2(0, 1), v2(0, -1), v2(0, -1), v2(0, -1), v2(0, 0), v2(0, 0) };

  return DrawDisplacement[j];

}



col16 axethrowerdwarf::GetTorsoMainColor() const

{

  return GetMasterGod()->GetColor();

}



col16 axethrowerdwarf::GetGauntletColor() const

{

  return GetMasterGod()->GetColor();

}



col16 axethrowerdwarf::GetLegMainColor() const

{

  return GetMasterGod()->GetColor();

}



truth humanoid::CheckThrowItemOpportunity()

{

	if(!HasAUsableArm())

		return false;

	else

		return character::CheckThrowItemOpportunity();

}





// In char.dat:



character

{

	...

	IsRangedAttacker = false;

}



axethrowerdwarf

{

  DefaultArmStrength = 20;

  DefaultLegStrength = 20;

  DefaultDexterity = 20;

  DefaultAgility = 10;

  DefaultEndurance = 12;

  DefaultPerception = 18;

  DefaultIntelligence = 10;

  DefaultWisdom = 5;

  DefaultCharisma = 10;

  DefaultMana = 10;

  HeadBitmapPos = 112, 160;

  TorsoBitmapPos = 48, 16;

  ArmBitmapPos = 80, 0;

  LegBitmapPos = 0, 208;

  HairColor = rgb16(144, 72, 0);

  BeltColor = rgb16(72, 56, 16);

  TotalVolume = 50000;

  TotalSize = 100;

  CanRead = true;

  NameSingular = "axethrower dwarf";

  NamePlural = "axethrower dwarves";

  CanBeGenerated = true;

  CreateDivineConfigurations = true;

  IsAbstract = true;

  /* Equipment initialization is overridden */

  PanicLevel = 1;

  Inventory == IRON meleeweapon(AXE) {Times = 6;}

  FleshMaterial = DWARF_FLESH;

  DeathMessage = "@Dd dies in agony.";

  IgnoreDanger = true;

  Frequency = 300;

  HostileReplies == "\"In the name of @Gd I will slash you to pieces!\"";

  AttachedGod = NONE;

  UndeadVersions = false;

  WieldedPosition = -1, -2;

  FriendlyReplies =

  {

    4,

    "\"Would you like me to teach you the best way to slice tomatoes?\"",

    "@Dd shouts: \"Death to disbelievers!\"",

    "@Dd praises @Gd with numerous hymns. @Pp is obviously a very devoted follower.",

    "\"One day, Holy War will break out, hopefully I will earn my backpack by then!\"";

  }

	IsRangedAttacker = true;

	KnownCWeaponSkills == AXES;

	CWeaponSkillHits == 100;

  RightSWeaponSkillHits = 50;

	UsesLongArticle = true;

}



// In database.cpp:



template<> void databasecreator<character>::CreateDataBaseMemberMap()

{

	...

	ADD_MEMBER(IsRangedAttacker);

}



template<> void databasecreator<item>::CreateDataBaseMemberMap()

{

	...

	ADD_MEMBER(IsThrowingWeapon);

}



// In item.dat:



item

{

	...

	IsThrowingWeapon = false;

}



	Config AXE;

  {

    ...

		IsThrowingWeapon = true;

  }

	

	Config DAGGER; // if you like throwing daggers :E

  {

    ...

		IsThrowingWeapon = true;

  }



// In item.h:



struct itemdatabase : public databasebase

{

	...

	truth IsThrowingWeapon;

};



class item : public object

{

	...

	DATA_BASE_TRUTH(IsThrowingWeapon);

	...

}



// In char.h:



struct characterdatabase : public databasebase

{

	...

	truth IsRangedAttacker;

};



class character : public entity, public id

{

 public:

	...

	truth TryToAddToInventory(item*);

	...

	DATA_BASE_TRUTH(IsRangedAttacker);

	...

#endif

	...

	truth CheckThrowItemOpportunity();

	...

}



// In char.cpp



truth character::CheckForUsefulItemsOnGround(truth CheckFood)

{

  ...



  for(uint c = 0; c < ItemVector.size(); ++c)

    if(ItemVector[c]->CanBeSeenBy(this) && ItemVector[c]->IsPickable(this))

    {

      if(!(CommandFlags & DONT_CHANGE_EQUIPMENT)

				&& TryToEquip(ItemVector[c]))

				return true;



      if(CheckFood && UsesNutrition() && !CheckIfSatiated()

				&& TryToConsume(ItemVector[c]))

				return true;



			if( (ItemVector[c])->IsThrowingWeapon() && IsRangedAttacker() 

				&& TryToAddToInventory(ItemVector[c]))

				return true; 



    }

  return false;

}



truth character::TryToAddToInventory(item* Item)

{

  if(!(GetBurdenState() > STRESSED)

     || !CanUseEquipment()

     || Item->GetSquaresUnder() != 1)

    return false;



  room* Room = GetRoom();



	if(!Room || Room->PickupItem(this, Item, 1))

	{

		if(CanBeSeenByPlayer())

			ADD_MESSAGE("%s picks up %s from the ground.", CHAR_NAME(DEFINITE), Item->CHAR_NAME(INDEFINITE));



		Item->MoveTo(GetStack());

		DexterityAction(5);

		return true;

	}



  return false;

}





//finally, the algorithm itself



truth character::CheckThrowItemOpportunity()

{

  if(!IsRangedAttacker() || !CanThrow() || !IsHumanoid() || !IsSmall() || !IsEnabled()) // total gum

    return false;

	

	// Steps:

	// (1) - Acquire target as nearest enemy

	// (2) - Check that this enemy is in range, and is in appropriate direction

	//			 No friendly fire!

	// (3) - check inventory for throwing weapon, select this weapon

	// (4) - throw item in direction where the enemy is

	

	//Check the visible area for hostiles

	v2 Pos = GetPos();

	v2 TestPos;

	int RangeMax = GetLOSRange();

	int CandidateDirections[7] = {0, 0, 0, 0, 0, 0, 0};

	int HostileFound = 0;

	

	for(int r = 1; r <= RangeMax; ++r) 

	{

		for(int dir = 0; dir < 8; ++dir) 

		{

			switch(dir)

			{

				case 0: 

				TestPos = v2(Pos.X - r, Pos.Y - r);

				break;

				case 1: 

				TestPos = v2(Pos.X, Pos.Y - r);

				break;

				case 2: 

				TestPos = v2(Pos.X + r, Pos.Y - r);

				break;

				case 3: 

				TestPos = v2(Pos.X - r, Pos.Y);

				break;

				case 4: 

				TestPos = v2(Pos.X + r, Pos.Y);

				break;

				case 5: 

				TestPos = v2(Pos.X - r, Pos.Y + r);

				break;

				case 6: 

				TestPos = v2(Pos.X, Pos.Y + r);

				break;

				case 7: 

				TestPos = v2(Pos.X + r, Pos.Y + r);

				break;

			}

			

			level* Level = GetLevel();

			

			if(Level->IsValidPos(TestPos))

			{

				square* TestSquare = GetNearSquare(TestPos);

				character* Dude = TestSquare->GetCharacter();

				

				if((Dude && Dude->IsEnabled() && (GetRelation(Dude) != HOSTILE)

								&& Dude->CanBeSeenBy(this, false, true))) 

				{

					CandidateDirections[dir] = BLOCKED;

				}

				

				if(Dude && Dude->IsEnabled() && (GetRelation(Dude) == HOSTILE)

								&& Dude->CanBeSeenBy(this, false, true)

								&& (CandidateDirections[dir] != BLOCKED))

				{

					//then load this candidate position direction into the vector of possible throw directions

					CandidateDirections[dir] = SUCCESS;

					HostileFound = 1;

				}

			}

		}

	}

	

	int ThrowDirection = 0;

	int TargetFound = 0;

	

	if(HostileFound)

	{

		for(int dir = 0; dir < 8; ++dir)

		{

			if( (CandidateDirections[dir] == SUCCESS) && !TargetFound)

			{

				ThrowDirection = dir;

				TargetFound = 1;

			}

		}

		if(!TargetFound)

		{

			return false;

		}

	}

	else

	return false;

	

	//check inventory for throwing weapon

	itemvector ItemVector;

  GetStack()->FillItemVector(ItemVector);

	item* ToBeThrown = 0;



  for(uint c = 0; c < ItemVector.size(); ++c)

    if(ItemVector[c]->IsThrowingWeapon())

		{

      ToBeThrown = ItemVector[c];

			break;

		}

	

	if(!ToBeThrown)

		return false;

	

	if(CanBeSeenByPlayer())

    ADD_MESSAGE("%s throws %s.", CHAR_NAME(DEFINITE), ToBeThrown->CHAR_NAME(INDEFINITE));

	ThrowItem(ThrowDirection, ToBeThrown);

  EditExperience(ARM_STRENGTH, 75, 1 << 8);

  EditExperience(DEXTERITY, 75, 1 << 8);

  EditExperience(PERCEPTION, 75, 1 << 8);

  EditNP(-50);

  DexterityAction(5);

	TerminateGoingTo();

	return true;

	

}



// the end