Slitherine

Code: Select all

	if (side == 0)
		{
			// Render Saxons uncontrollable
			team = 1;
			for (i = 0; i < GetUnitCount(0); i++)
				{
					id = GetUnitID(0,i);
					if (id != -1)
						{
							if (GetUnitTeam(id) == team)
								{
									SetCannotControl(id, 1);
								}
						}
				}
		}

Code: Select all

FUNCTION StartTurnPost(side)
{
	int i;
	int id;
   int team;

	if (side == 0)
		{
			// Render Saxons uncontrollable
			team = 1;
			for (i = 0; i < GetUnitCount(0); i++)
				{
					id = GetUnitID(0,i);
					if (id != -1)
						{
							if (GetUnitTeam(id) == team)
								{
									SetCannotControl(id, 1);
								}
						}
				}
		}

Code: Select all

include "Tools.BSF"


// called at the start of every turn.
// You would tend to use this for events
FUNCTION StartTurn(side)
{
	if (GetTurn() == -1)
		{
			// Setup anything that needs setting up at the start of the game
			PreBattleSetup();

			// Use the following code here if you want to use the standard deployment restrictions as outlined in the manual.
          SetUniversalVar("StandardDeployment", 1);
          SetStandardDeploymentBounds();
		}
	else
		{


		}

}


   FUNCTION StartTurnPost(side)
    {
       int i;
       int id;
       int team;

       if (side == 0)
          {
             // Render Saxons uncontrollable
             team = 1;
             for (i = 0; i < GetUnitCount(0); i++)
                {
                   id = GetUnitID(0,i);
                   if (id != -1)
                      {
                         if (GetUnitTeam(id) == team)
                            {
                               SetCannotControl(id, 1);
                            }
                      }
                }
          }




{
	// Scenario-specific AI code goes here - you can look at some of the historical scenarios for examples.
	if (side == 1)
		{
			// AI_Masterplan() can be used to provide automated AI for encounter battles where Side 0 is on the left side of the map and Side 1 is on the right side of the map.
			// Be warned that it may not cope well with unusual AI deployments.
			// If used, PreBattleSetup() must include AI_ReassignTeams(1);
			// The parameter is the turn on which the AI side will start to advance its infantry if it has not done so already. (Turn 0 is side 0's first turn, Turn 1 is Side 1's first turn, and so on).
			// If the value is set at -1 the infantry will only ever advance if the tactical situation merits it.

//      AI_Masterplan(15);

			// If you want to use AI_Masterplan() in a scenario where the AI foot is defending fortifications you need to use the following code here
//      SetUniversalVar("SkirmishGame",1);
//      SetUniversalVar("ScenarioType",0);
//      AI_Masterplan(-1);
//      SetUniversalVar("SkirmishGame",0);
			// You would also need to set the position of the fortification line in PreBattleSetup(), using
//        SetUniversalVar("FootMinX", 24); // X-coordinate of bottom end of fortifications line
//        SetUniversalVar("FootMaxX", 28); // X-coordinate of upper end of fortifications line
//        SetUniversalVar("FrontLine", 26); // Y-coordinate of fortifications line


			// Otherwise insert any custom AI code here
		}
		
	// Set up MP scenario to use adjusted MP victory conditions:
	// SetMPForceRatio();
}


FUNCTION PreBattleSetup()
{
	// Set multiplier for unit strength reporting. 100 is 100% - i.e. units are vanilla strength.
	// If you set this at 50, units will be around half the size specified in the TotalMen column in the Squads file.
	SetUniversalVar("StrengthMultiplier", 100);

// Needs to be set if scenario uses deadline (turn limit) - note that side 0's first turn is turn 0, side 1's first turn is turn 1, side 0's second turn is turn 2 and so on.
// If it is set at 0, or not set at all, the scenario will have no turn limit.
// SetUniversalVar("ScenarioDeadline", 32);

	// Customise units for scenarios
	CustomiseUnits();

// Reassign teams - Only use if using AI_Masterplan() for AI orders - see above.
//  AI_ReassignTeams(1);

}

// This function applies standard victory conditions. The actual StandardVictoryConditions() function code can be found in MoreScenarioTools.BSF.
// The parameters are (breakpoint0a, breakpoint0b, breakpoint1a, breakpoint1b, drawdecider, MPgame)
// breakpoint0a is Side 0 first breakpoint (in % troops UNrouted), breakpoint0b is Side 0 second breakpoint.
// breakpoint1a is Side 1 first breakpoint (in % troops UNrouted), breakpoint1b is Side 1 second breakpoint.
// An army is defeated if it reaches its second breakpoint, or if it reaches its first breakpoint (or anywhere between that and its second breakpoint)
// and the enemy has at least 25% more troops UNrouted.
// drawdecider indicates which side wins if the game is drawn ("ScenarioDeadline" turn limit reached or both sides are "defeated" on same turn).
// drawdecider == 0 means that Side 0 wins draws. drawdecider == 1 means that Side 1 wins draws. drawdecider == 2 means that whichever side is ahead wins draws.
// MPgame = 1 means that the game is an MP game. In non-random MP games, the victory conditions can automatically be adjusted to take account of initial disparity in forces,
// so that the losing army will win the scenario if the enemy victory was too Pyrrhic. To implement this, the StartTurnPost() function needs to include SetMPForceRatio();
// If this is likely to happen, the ScenarioUI text in the top left of the screen will report that the losing side is “ahead on points”.
// Special victory conditions can be applied using SpecialScenarioVictoryConditions() - see Lostwithiel.BSF for an example of this. If present in the scenario .bsf file,
// this function is run by StandardVictoryConditions() if neither army is broken.
FUNCTION VictoryConditions()
{
	StandardVictoryConditions(60, 40, 60, 40, 2, 0); // The last parameter should be 1 instead of 0 for Multiplayer scenarios.
	
	return 1; // VictoryConditions() must return a non-zero value so that the main program knows it exists and therefore not to use the default version.
}


// called every game tick.
// You would tend to use this for reactive logic and win situations etc
FUNCTION Tick(side)
{

}


FUNCTION DrawScenarioUI()
	{
		StandardScenarioUI("IDS_SCENUI_VC_STANDARD", 1);  // You can of course write your own custom UI if you prefer.
		
		return 1; // DrawScenarioUI() must return a non-zero value so that the main program knows it exists and therefore not to use the default version.
	}


FUNCTION WIN_SCENARIO_CALLBACK(winner)
{
			if( GetGlobal("victory") == 1 )
				{
						return 0 ;
				}
			else
				{
						return -1 ;
				}
}



// Any scenario that needs units to vary from their standard definition should have a version of this function
// The basic function just randomises the number of men in the unit slightly.
FUNCTION CustomiseUnits()
{
	int i;
	int id;
	int starting_strength; // starting strength - percent of full base unit strength

	// Adjust starting unit strengths
	for (i = 0; i < GetUnitCount(0); i++)
	{
		id = GetUnitID(0,i);
		if (id != -1)
			{
				starting_strength = 100;

				RandomiseStartingStrength(id, starting_strength);
			}
	}

	for (i = 0; i < GetUnitCount(1); i++)
	{
		id = GetUnitID(1,i);
		if (id != -1)
			{
				starting_strength = 100;

				RandomiseStartingStrength(id, starting_strength);
			}
	}
}

// Adjust available points according to difficulty. This over-rides the points set in the editor.
// The units that will be chosen from with these points need to be set as Unfixed in the editor.
// If all the units are Fixed, then this function will have no effect.
// MP scenarios are all played on normal difficulty.
FUNCTION FORCE_POINTS_CALLBACK(side, points)
{
	int mode;
	int i;
	int id;

	mode = GetDiffMode();

	if (mode == 0) // Normal
		{
			return 200;
		}

		if ((mode == 1) || (mode == 2)) // Easy / Very Easy. (Very Easy mode also adjusts the quality of player units slightly upwards and AI units slightly downwards).
		{
			return 400;
		}

	if ((mode == 3) || (mode == 4)) // Hard / Very Hard. (Very Hard mode also adjusts the quality of player units slightly downwards and AI units slightly upwards).
		{
			return 0;
		}

}