//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)); }