public Game (Player p1, Player p2) {
this.player1 = p1;
this.player2 = p2;
this.effectHandler = new EffectHandler();
this.turnHandler = new TurnHandler();
}
void ChooseAction () {
TurnHandler myAttack = new TurnHandler();
myAttack.attacker = zombie.name;
myAttack.type = "zombie";
myAttack.AttackersGameObject = this.gameObject;
myAttack.TargetsGameObject = BSM.survivorList[Random.Range(0, BSM.survivorList.Count)];
BSM.CollectAction(myAttack);
}
// Update is called once per frame
void Update()
{
switch (battleStates)
{
case (PerformAction.WAIT):
if (performList.Count > 0)
{
battleStates = PerformAction.TAKEACTION;
}
break;
case (PerformAction.TAKEACTION):
GameObject performer = GameObject.Find(performList[0].attacker);
if (performList[0].type == "Enemy")
{
EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>();
ESM.targetToAttack = performList[0].targetOfAttacker;
ESM.currentState = EnemyStateMachine.TurnState.ACTION;
}
if (performList[0].type == "Hero")
{
HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>();
HSM.targetToAttack = performList[0].targetOfAttacker;
HSM.currentState = HeroStateMachine.TurnState.ACTION;
}
battleStates = PerformAction.PERFORMACTION;
break;
case (PerformAction.PERFORMACTION):
break;
}
switch (heroInput)
{
case (HeroGUI.ACTIVATE):
if (heroesToManage.Count > 0)
{
heroesToManage[0].transform.FindChild("Selector").gameObject.SetActive(true);
heroChoice = new TurnHandler();
attackPanel.SetActive(true);
heroInput = HeroGUI.WAITING;
}
break;
case (HeroGUI.WAITING):
//idle
break;
case (HeroGUI.DONE):
heroInputDone();
break;
}
}
public void TestInitialize()
{
var dice = new Dice();
board = new Board(banker, dice);
var turnHandler = new TurnHandler(board, banker, dice);
var roundHandler = new RoundHandler(turnHandler);
var game = new Game(banker, roundHandler);
playerCar = game.CreatePlayerAccount("Car");
}
//public bool canWalk = true;
// Use this for initialization
private void Start()
{
// get the components on the object we need ( should not be null due to require component so no need to check )
turnHandler = GameObject.Find("Turn Handler").GetComponent <TurnHandler>();
agent = GetComponentInChildren <NavMeshAgent>();
m_Animator = GetComponent <Animator>();
camera = (GameObject)GameObject.Find("Main Camera");
agent.updateRotation = false;
agent.updatePosition = true;
}
void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(gameObject);
return;
}
}
// USAGE: handling damage taken and associated consequences
public void takeDamage(int damage)
{
health -= damage;
Debug.Log("Just got hit! " + this.unitName + " lost " + damage + " health!!!");
if (health <= 0)
{
TurnHandler turnH = GameObject.Find("GameLogic").GetComponent <TurnHandler> ();
turnH.removeUnit(unitName);
turnH.checkGameStatus();
Destroy(gameObject);
}
}
public void TestInitiaize()
{
board = new Board(banker, new Dice());
bank = new Banker();
var turnHandler = new TurnHandler(board, banker, new Dice());
var roundHandler = new RoundHandler(turnHandler);
game = new Game(banker, roundHandler);
car = game.CreatePlayerAccount("Car");
horse = game.CreatePlayerAccount("Horse");
}
void Awake()
{
currentTurnTime = baseTimeInTurn;
CurrentPlayer.instance().addPlayerChangeObserver(this);
TurnHandler.instance().addEndTurnObserver(this);
txt = gameObject.GetComponent <Text>();
updateCount();
updatePlayerColor();
}
public void TestInitialize()
{
mockDice = new Mock <IDice>();
board = new Board(banker, mockDice.Object);
var turnHandler = new TurnHandler(board, banker, mockDice.Object);
var roundHandler = new RoundHandler(turnHandler);
game = new Game(banker, roundHandler);
player = game.CreatePlayerAccount("Test");
}
void ChooseAction()
{
TurnHandler myAction = new TurnHandler();
myAction.activistName = NPC.name;
myAction.characterType = "NPC";
myAction.activistObject = this.gameObject;
myAction.activistFocus = battleMachine.playerList[Random.Range(0, battleMachine.playerList.Count)];
battleMachine.CollectActions(myAction);
currentState = TurnState.WAIT;
}
protected virtual void Start()
{
spriteRenderer = GetComponent <SpriteRenderer>();
gameController = GameObject.FindGameObjectWithTag("GameController");
turnHandler = gameController.GetComponentInChildren <TurnHandler>();
map = gameController.GetComponentInChildren <Map>();
GameObject canvas = GameObject.FindGameObjectWithTag("Canvas");
messageBar = canvas.GetComponentInChildren <MessageBar>();
hpMax = hpTrueMax;
hp = hpMax;
}
void ChooseAction()
{
TurnHandler myAttack = new TurnHandler();
myAttack.attacker = enemy.theName;
myAttack.type = "Enemy";
myAttack.attackerGameObject = this.gameObject;
myAttack.targetOfAttacker = BSM.playersInBattle[Random.Range(0, BSM.playersInBattle.Count)];
int num = Random.Range(0, enemy.usableAttacks.Count);
myAttack.chosenAttack = enemy.usableAttacks[num];
BSM.CollectActions(myAttack);
}
protected override void Awake()
{
base.Awake();
CurrentPlayer.instance().addPlayerChangeObserver(this);
PlanetChangeNotifier.instance().addObserver(this);
TurnHandler.instance().addEndTurnObserver(this);
shipDisplayScrollbar.SetActive(false);
showingShipScrollbar = false;
chosenFleet = null;
currentPlayer = CurrentPlayer.instance().getCurrentPlayer();
}
virtual internal void NotifyTurnEnded()
{
if (IsMoving())
{
NotifyStopMoving(false);
}
TurnHandler handler = TurnEnded;
if (handler != null)
{
handler(this);
}
}
void selected()
{
TurnHandler atking = new TurnHandler();
atking.meme = meme.meme;
atking.type = "Musuh";
atking.atk = this.gameObject;
atking.def = target;
//int num = 1;
//atking.choosenAtk = meme.atklist[num];
//Debug.Log (atking.choosenAtk.atkDmg);
//Debug.Log (atking.def);
BSM.collectAction(atking);
}
private void Start()
{
_enemies = new List <Enemy>();
_collectables = new List <Collectable>();
_board = GetComponent <MapBoard>();
_turnHandler = GetComponent <TurnHandler>();
_board.onTurn.AddListener(() => Spawn());
GameObject spPos = new GameObject();
spPos.transform.position = transform.position;
_spawnPos = spPos.transform;
_spawnPos.name = "Spawned Entities";
_spawnPos = spPos.transform;
}
private void Start()
{
if (Players.GetCameraOffset().Equals(new Vector3(0, 0, 0)))
{
offset = transform.position - target.position;
Players.SetCameraOffset(offset);
}
else
{
offset = Players.GetCameraOffset();
}
turnHandler = GameObject.Find("Turn Handler").GetComponent <TurnHandler>();
}
public void PlayGameWithLessThan2Players_ExceptionShouldBeThrown()
{
var board = new Board(banker, dice);
var turnHandler = new TurnHandler(board, banker, dice);
var roundHandler = new RoundHandler(turnHandler);
Game testGame = new Game(banker, roundHandler);
testGame.CreatePlayerAccount("Car");
var round = 1;
testGame.Play(round);
}
private void SetupGameWithPlayers(Int32 numberOfPlayers)
{
var players = GeneratePlayerIEnumerable(numberOfPlayers);
var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);
banker = new Banker(players);
var boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);
dice = new ControlledDice();
var jailHandler = new JailHandler(dice, boardHandler, banker);
var turnHandler = new TurnHandler(dice, boardHandler, jailHandler, realEstateHandler, banker);
game = new Game(players, turnHandler, banker);
}
void ChooseAction() //Chooses the attack for the Enemy and sends it to the Turn Handler
{
TurnHandler myAttack = new TurnHandler(); //Instantiation of TurnHandler Class to collect the Attacker Information
myAttack.attacker = enemy.name; //Sets the Attacker name
myAttack.type = "Enemy"; //Sets the Attacker Type
myAttack.attackerGameObject = this.gameObject; //Sets the Attacker Game Object
myAttack.attackersTarget = bsm.playersInBattle[Random.Range(0, bsm.playersInBattle.Count)]; //Sets the Target of the Attacker
int attackIndex = Random.Range(0, enemy.attackList.Count); //Randomly perform an attack from the available attacks the enemy has available
myAttack.chosenAttack = enemy.attackList[attackIndex]; //Set the random attack
Debug.Log(this.gameObject + " has chosen " + myAttack.chosenAttack.attackName + " and inflicts " + myAttack.chosenAttack.attackDamage + " damage");
bsm.CollectActions(myAttack); //Send the Attacker Information to the BattleStateMachine
}
void ChooseAction()
{
//battleMachine.playersToManage.Add(this.gameObject);
TurnHandler myAction = new TurnHandler();
myAction.activistName = PlayerCharacter.name;
myAction.characterType = "Player";
myAction.activistObject = this.gameObject;
battleMachine.CollectActions(myAction);
currentState = TurnState.WAIT;
}
public void TestInitialize()
{
banker = new Banker();
dice = new Dice();
board = new Board(banker, dice);
var turnHandler = new TurnHandler(board, banker, dice);
mockRoundHandler = new Mock <IRoundHandler>();
game = new Game(banker, mockRoundHandler.Object);
players = new Player[2];
players[0] = game.CreatePlayerAccount("One");
players[1] = game.CreatePlayerAccount("Two");
}
public void PlayerLandsOnGoToJailEndsUpVisitingJail()
{
var banker = new Banker();
var dice = new Dice();
var board = new Board(banker, dice);
var goToJail = new GoToJail(30, "Go To Jail", 10);
var turnHandler = new TurnHandler(board, banker, dice);
var roundHandler = new RoundHandler(turnHandler);
var game = new Game(banker, roundHandler);
var player = game.CreatePlayerAccount("Car");
goToJail.Land(player);
Assert.AreEqual(10, player.Location);
}
public void NewLevel()
{
//Cleanup everything.
transform.parent.BroadcastMessage("OnNewLevel");
//Initialize everything
tiles = new GameObject[mapSize, mapSize];
rooms = new List <MapRoom>();
turnHandler = GameObject.FindGameObjectWithTag("GameController").GetComponentInChildren <TurnHandler>();
GenerateMap();
GenerateTileSprites();
PlaceShop();
PlacePlayer();
PlaceEnemies();
PlaceCuriosities();
PlaceStairs();
}
// Use this for initialization
void Start()
{
makeSwitch = GameObject.FindGameObjectWithTag("GameController").GetComponent <TurnHandler>();
if (gameObject.tag == "PlayerOne")
{
currentDirection = up1;
currentDirection = Vector3.zero;
}
if (gameObject.tag == "PlayerTwo")
{
currentDirection = up2;
currentDirection = down;
}
nextPos = Vector3.forward;
destination = transform.position;
}
public void TestInitialize()
{
dice = new Dice();
banker = new Banker();
board = new Board(banker, dice);
var turnHandler = new TurnHandler(board, banker, dice);
var roundHandler = new RoundHandler(turnHandler);
game = new Game(banker, roundHandler);
electric = board.GetNextSpace(11) as UtilityProperty;
water = board.GetNextSpace(27) as UtilityProperty;
player = game.CreatePlayerAccount("Car");
horse = game.CreatePlayerAccount("Horse");
}
public void PlayerSpendsThreeTurnsInJailPays50ToGetOut()
{
var mockDice = new Mock <IDice>();
mockDice.Setup(d => d.RollResults).Returns(3);
mockDice.Setup(d => d.Doubles).Returns(false);
var board = new Board(banker, mockDice.Object);
var turnHandler = new TurnHandler(board, banker, mockDice.Object);
var roundHandler = new RoundHandler(turnHandler);
var testGame = new Game(banker, roundHandler);
var playerCar = testGame.CreatePlayerAccount("Car");
board.SendPlayerToJail(playerCar);
turnHandler = new TurnHandler(board, banker, mockDice.Object);
List <TurnEventArgs> playerTurns = new List <TurnEventArgs>();
turnHandler.TurnFinished += (s, e) => { if (e.Player.Equals(playerCar))
{
playerTurns.Add(e);
}
};
var jailLocation = 10;
turnHandler.TakeTurn(playerCar, 0, 0);
Assert.AreEqual(jailLocation, playerCar.Location);
Assert.IsTrue(playerCar.InJail);
Assert.AreEqual(1500, banker.GetPlayerBalance(playerCar));
turnHandler.TakeTurn(playerCar, 1, 0);
Assert.AreEqual(jailLocation, playerCar.Location);
Assert.IsTrue(playerCar.InJail);
Assert.AreEqual(1500, banker.GetPlayerBalance(playerCar));
var cashBeforeTurn = banker.GetPlayerBalance(playerCar);
var costSpace13 = 140;
turnHandler.TakeTurn(playerCar, 2, 0);
Assert.AreEqual(13, playerCar.Location);
Assert.IsFalse(playerCar.InJail);
Assert.AreEqual(costSpace13 + 50, cashBeforeTurn - banker.GetPlayerBalance(playerCar));
}
public void CountOfGoal(GameObject post)
{
// ReSharper disable once SuspiciousTypeConversion.Global
if (MyPost.transform != null && post != MyPost.transform.GetChild(1).gameObject)
{
Debug.Log("Not my Post i am player " + PlayerName);
MyPost.gameObject.transform.GetChild(0)
.GetComponent <BoxCollider2D>().enabled = true; //ball lai bahira jana nadina post ko barrier on gareko
TurnHandler.GetInstance().GoaledPlayer = gameObject.GetComponent <PlayerScript>();
IncreaseScore();
}
else
{
Debug.Log("My Post i am player " + PlayerName);
}
}
/// <summary>
/// Chose an action. This communicates to the specific IA of the enemy to decide the attack according to the battle.
/// </summary>
void ChooseAction()
{
//Test function to decide if the attack is gonna be an area attack or not. This must be replaced with a call to the enemy IA, returning a list with the enemies to attack.
TurnHandler myAttack = new TurnHandler()
{
attacker = enemy.stats.myName,
type = "Enemy",
attackerGameObject = gameObject,
attack = IA(),
targets = heroesToAttack
};
isAreaAttack = myAttack.targets.Count > 1 ? true : false;
BSM.CollectActions(myAttack);
}
public void TestInitialize()
{
var dice = new Dice();
board = new Board(banker, dice);
readingRailRoad = board.GetNextSpace(4) as RailRoadProperty;
pennsylvaniaRailRoad = board.GetNextSpace(14) as RailRoadProperty;
bAndORailRoad = board.GetNextSpace(24) as RailRoadProperty;
shortLineRailRoad = board.GetNextSpace(34) as RailRoadProperty;
var turnHandler = new TurnHandler(board, banker, dice);
var roundHandler = new RoundHandler(turnHandler);
game = new Game(banker, roundHandler);
player = game.CreatePlayerAccount("Car");
horse = game.CreatePlayerAccount("Horse");
}
public GameplayState(BoardSetup yourBoard, BoardSetup opponentBoard, bool _yourTurn)
{
TurnHandler turnHandler = new TurnHandler();
turnHandler.SetSuccessor(new ChatHandler()).SetSuccessor(new UserHandler()).SetSuccessor(new HelpHandler());
turnHandler.instance = new GameInstance(yourBoard, opponentBoard, _yourTurn);
handler = turnHandler;
if (_yourTurn)
{
Console.WriteLine("Your turn");
}
else
{
Console.WriteLine("Its opponents turn");
}
}
// Use this for initialization
void Start()
{
foreach (Transform child in transform)
{
if (child.tag == _animTag)
{
anim = child.GetComponent<Animator>();
break;
}
}
hp = maxHp;
hpIndicator = GetComponentInChildren<CanvasObjectFollowGameObject>();
weapon = GetComponent<BaseWeapon>();
BaseArmor tempArmorVar = GetComponent<BaseArmor>();
resist = tempArmorVar.resist;
vunerable = tempArmorVar.vunerable;
hpIndicator.ChangeText(hp);
turnhandler = GameObject.FindGameObjectWithTag(_turnHandler).GetComponent<TurnHandler>();
}
public ChangeActiveFactionEvent(EventID eventID, object sender, EventArgs<TurnHandler> e)
: base(eventID, sender, e)
{
this.turnHandler = e.Value;
}
public void CollectAction (TurnHandler myTurn) {
TurnList.Add (myTurn);
}
// Use this for initialization
void Start()
{
layout = GameObject.Find ("GameHandler").GetComponent<GenerateMap> ();
turnSignaler = GameObject.Find ("GameHandler").GetComponent<TurnHandler> ();
targetPositions = new GameObject[0];
layout.showingTargets = false;
moveTo = transform.position;
timer = 0;
computerTurn = true;
moving = false;
}
/*
int CalculateFoundTotalSurvivors () {
float odds = 50.0f;
int sum = 0;
float roll = UnityEngine.Random.Range (0.0f, 100.0f);
if ( roll >= odds) {
sum += UnityEngine.Random.Range (0, 4);
}
totalSurvivorsFound = sum;
return sum;
}
int CalculateActiveSurvivorsFound () {
float oddsOfBeingActive = 55.0f;
int activeSurvivors = 0;
if (totalSurvivorsFound <= 0 ) {
return activeSurvivors;
} else {
for (int i = 0; i < totalSurvivorsFound; i++ ) {
float roll = UnityEngine.Random.Range (0.0f, 100.0f);
if (roll <= oddsOfBeingActive) {
activeSurvivors++;
}
}
return activeSurvivors;
}
}
*/
//this is activated on the GUI button press.
public void AttackButtonPressed () {
TurnHandler myAttack = new TurnHandler();
myAttack.attacker = survivorTurnList[0].name;
myAttack.type = "survivor";
myAttack.AttackersGameObject = survivorTurnList[0];
if (playerTarget != null) {
myAttack.TargetsGameObject = playerTarget;
} else {
//pick a random zombie
//myAttack.TargetsGameObject = zombieList[Random.Range(0, zombieList.Count)];
//based on player weapon type find the most vulnerable type zombie to attack
SurvivorStateMachine attackingSSM = survivorTurnList[0].GetComponent<SurvivorStateMachine>();
// Debug.Log(attackingSSM.survivor.weaponEquipped.name);
if (attackingSSM.survivor.weaponEquipped != null) {
if (attackingSSM.survivor.weaponEquipped.GetComponent<BaseWeapon>().weaponType == BaseWeapon.WeaponType.KNIFE) {
foreach (GameObject zombie in zombieList) {
//Debug.Log(zombie.GetComponent<ZombieStateMachine>().zombie.zombieType.ToString());
if (zombie.GetComponent<ZombieStateMachine>().zombie.zombieType.ToString() == "SKINNY") {
myAttack.TargetsGameObject = zombie;
break;
}
Debug.Log("did not find a matching zombie to select for auto-attack");
//if the foreach completes without finding a match- pick randomly
myAttack.TargetsGameObject = zombieList[UnityEngine.Random.Range(0, zombieList.Count)];
}
} else if (attackingSSM.survivor.weaponEquipped.GetComponent<BaseWeapon>().weaponType == BaseWeapon.WeaponType.CLUB) {
foreach (GameObject zombie in zombieList) {
//Debug.Log(zombie.GetComponent<ZombieStateMachine>().zombie.zombieType.ToString());
if (zombie.GetComponent<ZombieStateMachine>().zombie.zombieType.ToString() == "NORMAL") {
myAttack.TargetsGameObject = zombie;
break;
}
Debug.Log("did not find a matching zombie to select for auto-attack");
//if the foreach completes without finding a match- pick randomly
myAttack.TargetsGameObject = zombieList[UnityEngine.Random.Range(0, zombieList.Count)];
}
} else if (attackingSSM.survivor.weaponEquipped.GetComponent<BaseWeapon>().weaponType == BaseWeapon.WeaponType.GUN) {
foreach (GameObject zombie in zombieList) {
//Debug.Log(zombie.GetComponent<ZombieStateMachine>().zombie.zombieType.ToString());
if (zombie.GetComponent<ZombieStateMachine>().zombie.zombieType.ToString() == "FAT") {
myAttack.TargetsGameObject = zombie;
break;
}
Debug.Log("did not find a matching zombie to select for auto-attack");
//if the foreach completes without finding a match- pick randomly
myAttack.TargetsGameObject = zombieList[UnityEngine.Random.Range(0, zombieList.Count)];
}
}
} else {
myAttack.TargetsGameObject = zombieList[UnityEngine.Random.Range(0, zombieList.Count)];
}
}
CollectAction(myAttack);
survivorTurnList.RemoveAt(0);
}
