//Finds the wrestler who will have an action first.
protected Wrestler GetNextActiveWrestler()
{
Wrestler activeWrestler = wrestlers [0];
float minimumTimer = activeWrestler.GetActionTimer();
//Output.AddToOutput (wrestlers [0].GetName () + "'s timer: " + minimumTimer);
for (byte i = 1; i < wrestlers.Length; i++)
{
float currentTimer = wrestlers [i].GetActionTimer();
//Output.AddToOutput (wrestlers [i].GetName () + "'s timer: " + currentTimer);
if (currentTimer < minimumTimer)
{
activeWrestler = wrestlers [i];
minimumTimer = currentTimer;
if (wrestlers [i].IsStunned())
{
minimumTimer /= 2;
}
}
}
PassTime(minimumTimer);
return(activeWrestler);
}
//Replace words in move descriptions
protected string FormatText(string text, Wrestler attackingWrestler, Wrestler receivingWrestler)
{
text = FormatText(text, attackingWrestler);
text = text.Replace("{Receiver}", receivingWrestler.GetName());
return(text);
}
//Replace words in move descriptions
protected string FormatText(string text, Wrestler attackingWrestler, Wrestler receivingWrestler, IMove move)
{
text = FormatText(text, attackingWrestler, receivingWrestler);
text = text.Replace("{Move}", move.GetName());
return(text);
}
protected void ChangePosition(Wrestler wrestler, WrestlerPosition newPosition)
{
string outputText = null;
switch (newPosition)
{
case WrestlerPosition.GROGGY:
outputText = "{Attacker} gets up off of the mat";
break;
case WrestlerPosition.STANDING:
outputText = "{Attacker} regains their bearings";
break;
case WrestlerPosition.GROUNDED:
outputText = "{Attacker} drops down to the mat";
break;
case WrestlerPosition.CORNER:
outputText = "{Attacker} moves to the corner";
break;
case WrestlerPosition.RUNNING:
outputText = "{Attacker} runs and bounces off of the ropes";
break;
}
outputText = FormatText(outputText, wrestler);
Output.AddToOutput(outputText);
wrestler.AddCooldown(0.5f);
wrestler.ChangePosition(newPosition);
}
//Move with a destination
public void MoveToAdjacentNode(Wrestler wrestler, NodeIndex start, NodeIndex destination)
{
if (!IsValidNode(start) || !IsValidNode(destination))
{
throw new Exception("The path you requested cannot be done.");
}
NodeIndex difference = start - destination;
if (Math.Abs(start.x) > 1)
{
NodeIndex newDestination = start + new NodeIndex((sbyte)Math.Sign(difference.x), (sbyte)0);
MoveToAdjacentNode(wrestler, start, newDestination);
MoveToAdjacentNode(wrestler, newDestination, destination);
}
if (Math.Abs(start.y) > 1)
{
NodeIndex newDestination = start + new NodeIndex((sbyte)0, (sbyte)Math.Sign(difference.y));
MoveToAdjacentNode(wrestler, start, newDestination);
MoveToAdjacentNode(wrestler, newDestination, destination);
}
allNodes [start.y, start.x].RemoveWrestlerFromNode(wrestler);
allNodes [destination.y, destination.x].AddWrestlerToNode(wrestler);
wrestler.SetEnvironment(this, destination);
wrestler.AddCooldown(0.5f);
}
protected void ChangeReceiverPosition(Wrestler attackingWrestler, Wrestler receivingWrestler, WrestlerPosition newPosition)
{
string outputText = null;
switch (newPosition)
{
case WrestlerPosition.GROGGY:
outputText = "{Attacker} picks {Receiver} up off of the mat";
break;
case WrestlerPosition.STANDING:
outputText = "{Attacker} stands {Receiver} back up";
break;
case WrestlerPosition.GROUNDED:
outputText = "{Attacker} puts {Receiver} down onto the floor";
break;
case WrestlerPosition.CORNER:
outputText = "{Attacker} whips {Receiver} into the corner";
break;
case WrestlerPosition.RUNNING:
outputText = "{Attacker} irish whip's {Receiver}";
break;
}
outputText = FormatText(outputText, attackingWrestler, receivingWrestler);
Output.AddToOutput(outputText);
attackingWrestler.AddCooldown(0.5f);
receivingWrestler.AddStun(0.25f);
receivingWrestler.ChangePosition(newPosition);
}
private bool CanWrestlerBreakPin(Wrestler attackingWrestler, Wrestler receivingWrestler)
{
if (wrestlers.Length == 2)
{
return(false); //one-on-one match, no one else can break up the pin
}
for (ushort i = 0; i < wrestlers.Length; i++)
{
if (wrestlers [i] == attackingWrestler || wrestlers [i] == receivingWrestler)
{
continue;
}
if (wrestlers [i].GetActionTimer() < 0.01f)
{
if (wrestlers [i].IsWrestlerInSameNode(attackingWrestler))
{
string textToOutput = "{Attacker} has broken up {Receiver}'s pin";
wrestlers [i].ChangeTarget(attackingWrestler);
attackingWrestler.ChangeTarget(wrestlers [i]);
textToOutput = FormatText(textToOutput, wrestlers [i], attackingWrestler);
Output.AddToOutput(textToOutput);
return(true);
}
}
}
return(false);
}
public void SetWrestlerNode(Wrestler wrestler, NodeIndex index)
{
if (!IsValidNode(index))
{
throw new Exception("Node is not valid.");
}
wrestler.SetEnvironment(this, index);
allNodes [index.y, index.x].AddWrestlerToNode(wrestler);
}
//Move without a destination
public void MoveToAdjacentNode(Wrestler wrestler, NodeIndex start)
{
NodeIndex destination;
do
{
destination = start + new NodeIndex((sbyte)UsefulActions.RandomiseNumber(-1, 2), (sbyte)UsefulActions.RandomiseNumber(-1, 2));
} while (!IsValidNode(destination));
MoveToAdjacentNode(wrestler, start, destination);
}
protected bool CanUseSpecialMove(Wrestler attackingWrestler, Wrestler receivingWrestler, float bonusChance)
{
float attackerStamina = attackingWrestler.GetStaminaAsAPercentage();
float receiverHealth = receivingWrestler.GetHealthAsAPercentage();
float chance = 5 + receiverHealth * 20;
chance -= (1 - attackerStamina) * 15;
chance *= bonusChance;
return(UsefulActions.RandomiseChance(chance));
}
protected List <Wrestler> GetOtherWrestlers(Wrestler ignoreWrestler)
{
List <Wrestler> result = new List <Wrestler> ();
for (byte i = 0; i < wrestlers.Length; i++)
{
if (wrestlers [i] != ignoreWrestler)
{
result.Add(wrestlers [i]);
}
}
return(result);
}
protected MoveResult AttemptMove(Wrestler attackingWrestler, Wrestler receivingWrestler, IMove move, MoveType moveType)
{
MoveResult result = MoveResult.NORMAL;
switch (moveType)
{
case MoveType.NORMAL:
result = attackingWrestler.AttemptMove(receivingWrestler, (MoveData)move);
break;
case MoveType.SIGNATURE:
result = attackingWrestler.AttemptSignature(receivingWrestler, (SpecialMove)move);
break;
case MoveType.FINISHER:
result = attackingWrestler.AttemptFinisher(receivingWrestler, (SpecialMove)move);
break;
}
string textToBuffer = null;
MoveData moveData = move.GetMove();
switch (result)
{
case MoveResult.NORMAL:
textToBuffer = moveData.description;
if (move is SpecialMove)
{
textToBuffer += " executing the {Move}";
}
break;
case MoveResult.BLOCKED:
textToBuffer = "{Receiver} blocked the {Move} attempt from {Attacker}";
break;
case MoveResult.COUNTERED:
textToBuffer = "{Receiver} countered {Attacker}'s {Move} attempt";
break;
case MoveResult.DODGED:
textToBuffer = "{Receiver} dodged {Attacker}'s {Move} attempt";
break;
}
textToBuffer = FormatText(textToBuffer, attackingWrestler, receivingWrestler, move);
Output.AddToOutput(textToBuffer);
return(result); //MoveResult is used as a return type so a subclass can decide what happens next
}
public NormalMatch(Wrestler wrestler1, Wrestler wrestler2)
{
availableLocations = new Environment[1];
availableLocations [0] = new Environment();
wrestlers = new Wrestler[2];
wrestlers [0] = wrestler1;
wrestlers [1] = wrestler2;
wrestler1.ChangeTarget(wrestler2);
wrestler2.ChangeTarget(wrestler1);
NodeIndex defaultPosition = new NodeIndex((sbyte)1, (sbyte)1);
availableLocations [0].SetWrestlerNode(wrestler1, defaultPosition);
availableLocations [0].SetWrestlerNode(wrestler2, defaultPosition);
momentumReserve = 0;
}
public static void Main(string[] args)
{
UsefulActions.InitialiseRandom();
MoveDictionary.Initialise();
WrestlerDictionary.Initialise();
Console.WriteLine("Welcome to my Wrestling Simulator!");
Console.WriteLine("Currently you can only do pin-fall only matches which require at least 2 wrestlers (can do multi-man matches).");
Console.WriteLine("\nHere's the list of all available wrestlers:");
WrestlerDictionary.ListAllWrestlers();
Console.WriteLine("\nList all wrestlers you wish to add into the match, then type START when you're done.");
List <Wrestler> wrestlersInMatch = new List <Wrestler> ();
string userInput = "";
while (!userInput.Equals("START"))
{
userInput = Console.ReadLine();
WrestlerData wrestlerDetails = WrestlerDictionary.GetWrestler(userInput);
if (wrestlerDetails == null)
{
Console.WriteLine("The wrestler: '{0}' does not exist.", userInput);
continue;
}
Wrestler wrestler = new Wrestler(wrestlerDetails);
wrestlersInMatch.Add(wrestler);
Console.WriteLine("{0} has been added.", userInput);
}
/*Wrestler wrestlerA = new Wrestler (WrestlerDictionary.GetWrestler ("Bob Dylan"));
* Wrestler wrestlerB = new Wrestler (WrestlerDictionary.GetWrestler ("Jake Matthews"));
* Wrestler wrestlerC = new Wrestler (WrestlerDictionary.GetWrestler ("Michael Lopez"));
* Wrestler[] wrestlerList = new Wrestler[] { wrestlerA, wrestlerB, wrestlerC };*/
Match.instance = new NormalMatch(wrestlersInMatch.ToArray());
Match.instance.ProcessMatch();
Console.WriteLine("The program will end after you press enter.");
Console.ReadLine();
}
protected void PinAttempt(Wrestler attackingWrestler, Wrestler receivingWrestler, float chanceMultiplier)
{
Output.AddToOutput(FormatText("{Attacker} gets into a pinning position", attackingWrestler, receivingWrestler));
Output.AddToOutput("The referee starts counting");
if (receivingWrestler.AttemptPinEscape(0.125f * chanceMultiplier))
{
return;
}
if (CanWrestlerBreakPin(attackingWrestler, receivingWrestler))
{
return;
}
Output.AddToOutput("...1...");
PassTime(1);
if (receivingWrestler.AttemptPinEscape(0.5f * chanceMultiplier))
{
return;
}
if (CanWrestlerBreakPin(attackingWrestler, receivingWrestler))
{
return;
}
Output.AddToOutput("...2...");
PassTime(1);
if (receivingWrestler.AttemptPinEscape(2 * chanceMultiplier))
{
return;
}
if (CanWrestlerBreakPin(attackingWrestler, receivingWrestler))
{
return;
}
Output.AddToOutput("3!");
PassTime(1);
Win(new Wrestler[] { attackingWrestler });
}
public void ChangeTargetToSelection(Wrestler[] selectableWrestlers)
{
targettingWrestler = selectableWrestlers [0];
for (byte i = 1; i < selectableWrestlers.Length; i++)
{
byte chance = 20;
if (selectableWrestlers [i].IsStunned())
{
chance = 5;
}
if (selectableWrestlers [i].IsTargettingWrestler(this))
{
chance = 50;
}
if (UsefulActions.RandomiseChance(chance))
{
targettingWrestler = selectableWrestlers [i];
break;
}
}
}
//Left public because in the future there may be match specific moves
public MoveResult AttemptMove(Wrestler receivingWrestler, IMove move, float costMultiplier = 1)
{
float staminaCost = 0.4f * (byte)move.GetStaminaCost() * costMultiplier;
float maxSuccessChance = myData.technique / staminaCost;
//Without increasing this value, people with less technique than someone's counter stat can never ever land a move
maxSuccessChance *= UsefulActions.ClampValue(GetStaminaAsAPercentage()) * 3;
MoveData moveData = move.GetMove();
float damage = GetDamageByOffenceType(moveData) * staminaCost;
damage = UsefulActions.RandomiseNumber(damage);
ConsumeStamina(MOVE_BASE_STAMINA_COST * staminaCost);
MoveResult result = receivingWrestler.ReceiveMove(maxSuccessChance, moveData, damage);
receivingWrestler.ChangeTarget(this); //Without this, multi-man matches get kinda silly with someone getting beat up for free
if (result == MoveResult.COUNTERED)
{
AddStun(receivingWrestler.GetCounterStunLength());
ChangePosition(moveData.reversalPosition);
return(result);
}
if (result == MoveResult.NORMAL)
{
AddMomentum(MOVE_BASE_MOMENTUM_GAIN + damage / 50); //No charisma stat, simply made it so that wrestlers who hit harder gain more momentum
}
float moveTime = UsefulActions.RandomiseNumber(moveData.lowerMoveTime, moveData.upperMoveTime); //How long the move took
AddCooldown(moveTime);
receivingWrestler.AddStun(moveTime);
return(result);
}
public bool ContainsWrestler(Wrestler wrestler)
{
return(containingWrestlers.Contains(wrestler));
}
public void RemoveWrestlerFromNode(Wrestler wrestler)
{
containingWrestlers.Remove(wrestler);
}
public void AddWrestlerToNode(Wrestler wrestler)
{
containingWrestlers.Add(wrestler);
}
public bool IsWrestlerInSameNode(Wrestler wrestler)
{
return(currentEnvironment.ContainsWrestler(wrestler, currentNodeIndex));
}
public bool IsTargettingWrestler(Wrestler wrestler)
{
return(targettingWrestler == wrestler);
}
public void ChangeTarget(Wrestler wrestler)
{
targettingWrestler = wrestler;
}
//Same as AttemptMove, but 2 times the damage
public MoveResult AttemptSignature(Wrestler receivingWrestler, SpecialMove move)
{
//PositionLayout currentLayout = GetCurrentPositionLayout ();
UseMomentum(SIGNATURE_MOMENTUM_COST);
return(AttemptMove(receivingWrestler, move, 2));
}
public MoveResult AttemptMove(Wrestler receivingWrestler, float costMultiplier = 1)
{
PositionLayout currentLayout = GetCurrentPositionLayout();
return(AttemptMove(receivingWrestler, myData.myMoves.GetRandomMove(currentLayout), costMultiplier));
}
//Same as AttemptMove, but 4 times the damage (and risk)
public MoveResult AttemptFinisher(Wrestler receivingWrestler, SpecialMove move)
{
UseMomentum(FINISHER_MOMENTUM_COST);
return(AttemptMove(receivingWrestler, move, 4));
}
public bool ContainsWrestler(Wrestler wrestler, NodeIndex nodePosition)
{
return(allNodes [nodePosition.y, nodePosition.x].ContainsWrestler(wrestler));
}
protected string FormatText(string text, Wrestler wrestler)
{
text = text.Replace("{Attacker}", wrestler.GetName());
return(text);
}
protected bool CanUseFinisher(Wrestler attackingWrestler, Wrestler receivingWrestler)
{
return(CanUseSpecialMove(attackingWrestler, receivingWrestler, 1));
}
protected bool CanUseSignature(Wrestler attackingWrestler, Wrestler receivingWrestler)
{
return(CanUseSpecialMove(attackingWrestler, receivingWrestler, 2));
}
