/*
private float lastSynchronizationTime = 0f;
private float syncDelay = 0f;
private float syncTime = 0f;
private Vector2 syncStartPosition = Vector2.zero;
private Vector2 syncEndPosition = Vector2.zero;
*/
void Start()
{
//photonView.RPC("setMyParent", PhotonTargets.AllBuffered);
transform.SetParent (GameObject.Find ("TurnManager").transform);
myTurn = GetComponentInParent<TurnManager> ();
turn = photonView.owner.ID;
Debug.Log ("Player " + turn);
Debug.Log ("game started? " + myTurn.gameStarted);
Invoke ("joinCheck", 1);
string playerName = "Player" + turn;
transform.name = playerName;
units = new GameObject[6];
selectedLocation = true;
ready = false;
unitChoice = 0;
unitIsMoving = false;
lostGame = false;
StartingUnitCount = 0;
DeadUnitCount = 0;
isActionMenuActive = false;
unitHasMoved = false;
unitHasAttacked = false;
unitSelected = false;
networkManager = GameObject.FindGameObjectWithTag ("MainCamera").GetComponent<NetworkManager>();
audioManager = GameObject.Find ("AudioManager").GetComponent<AudioManager> ();
//userData = networkManager.GetUserData ();
Debug.Log ("Player XP is " + userData.xp);
}
public override void OnStartClient()
{
base.OnStartClient();
Instance = this;
GetComponent<RectTransform>().anchoredPosition = new Vector2(0.0f, 270.0f);
}
void Awake()
{
if(turn == null)
{
turn = this;
}
}
internal Game(IList<Player> players, IList<CardCode> supplies)
{
_players.AddRange(players);
SupplyMan = new SuppliesManager(this, supplies);
TurnMan = new TurnManager(this, true);
}
// Use this for initialization
void Awake() {
enemyUnits = new List<Unit>();
allyUnits = new List<Unit>();
parent = gameObject;
enemyUnitObjects = GameObject.Find("Enemy Units");
allyUnitObjects = GameObject.Find("Ally Units");
enemyUnitObjects.transform.parent = parent.transform;
allyUnitObjects.transform.parent = parent.transform;
pathManager = new GraphManager(parent);
pathFinder = pathManager.getGraph();
//TODO: Integrate PCG here
//OR generate more spawns than needed and randomly select from generated spawn points.
Vector2 topright = pathFinder.getTopRightBound();
Vector2 botleft = pathFinder.getBottomLeftBound();
Vector2 mid = topright - botleft;
mid /= 3;
KeyValuePair<List<Node>, List<Node>> spawnPoints = pathFinder.getSpawnPoints(topright - mid, botleft + mid, 5);
for (int i = 0; i < spawnPoints.Key.Count; i++) {
Node spawnEnemy = spawnPoints.Key[i];
Node spawnAlly = spawnPoints.Value[i];
addLongArmUnit(enemyUnits, enemyUnitObjects, "Enemy LongArm", spawnEnemy, true);
addLongArmUnit(allyUnits, allyUnitObjects, "Ally LongArm", spawnAlly, false);
}
enemyUnits.Reverse();
allyUnits.Reverse();
turnManager = new TurnManager(pathFinder, allyUnits, enemyUnits);
}
public void IWantToPromptActorForActions()
{
var member1 = new MokupMember(0,1);
var member2 = new MokupMember(1,3);
var member3 = new MokupMember(2,2);
var member4 = new MokupMember(3,4);
TurnManager mgr = new TurnManager();
mgr.Actors.Add(member3);
mgr.Actors.Add(member4);
mgr.Actors.Add(member1);
mgr.Actors.Add(member2);
mgr.Start();
mgr.Update();
//assert that current actor is the highest agility
Assert.IsTrue(mgr.CurrentActor.GetId() == 3);
//finish turn of this actor
member4.PromptFinished();
mgr.Update();
//assert that current actor is the one with 3 agility
Assert.IsTrue(mgr.CurrentActor.GetId() == 1);
member2.PromptFinished();
}
// when the program launches, Grid will check that all the needed elements are in place
// that's exactly what you do in the static constructor here:
static Grid()
{
GameObject g;
g = safeFind("Map");
map = (Map)SafeComponent(g,"Map");
g = safeFind("Controller");
controller = (Controller)SafeComponent(g,"Controller");
g = safeFind("Camera");
camera = (Camera)SafeComponent(g,"Camera");
g = safeFind("Turn Manager");
turnManager = (TurnManager)SafeComponent(g,"TurnManager");
g = safeFind("Game State");
gameState = (GameState)SafeComponent(g,"GameState");
g = safeFind("Prefab Loader");
prefabLoader = (PrefabLoader)SafeComponent(g,"PrefabLoader");
// PS. annoying arcane technical note - remember that really, in c# static constructors do not run
// until the FIRST TIME YOU USE THEM. almost certainly in any large project like this, Grid
// would be called zillions of times by all the Awake (etc etc) code everywhere, so it is
// a non-issue. but if you're just testing or something, it may be confusing that (for example)
// the wake-up alert only appears just before you happen to use Grid, rather than "when you hit play"
// you may want to call "SayHello" from the GeneralOperations.cs, just to decisively start this script.
}
/// <summary>
/// Awake is called first when the object is spawned.
/// </summary>
void Awake()
{
//Here we set our singleton.
get = this;
//And we set our first Turntime reference.
lastTurnTime = Time.realtimeSinceStartup;
}
void Awake()
{
if (instance == null)
instance = this;
else if (instance != this)
Destroy (gameObject);
currentTurnCounter = 0;
}
//public List<string> PossibleNames = new List<string>();
// Use this for initialization
void Start()
{
MyStats.MyPatient = (this);
//agent = GetComponent<NavMeshAgent> ();
//OrigX = transform.position.z;
MyTurnManager = GetManager.GetTurnManager ();
}
public State(Action<string> spub, Action<string, string> spriv, bool super)
{
Send = spub;
SendPriv = spriv;
Players = new TurnManager();
DrawDeck = CardSetup.GetDrawDeck(super);
DrawEffectDeck = CardSetup.GetEffectDeck(super);
DiscardPile = new CardPile<Card>();
}
void Start () {
brickManager = GameObject.FindObjectOfType<BrickManager> ();
turnManager = GameObject.FindObjectOfType<TurnManager> ();
spriteRenderer = GetComponentInChildren<SpriteRenderer> ();
health = turnManager.getTurn ();
MeshRenderer meshRenderer = GetComponentInChildren<MeshRenderer>();
meshRenderer.sortingLayerID = spriteRenderer.sortingLayerID;
meshRenderer.sortingOrder = spriteRenderer.sortingOrder + 1;
refreshBrick ();
}
void Awake()
{
instance = this;
DontDestroyOnLoad(gameObject);
_maxTimeTurn = 10;
_currentTimeTurn = _maxTimeTurn;
_isPlaying = false;
_whoPlays = 0;
_textTurn.text = "Player Turn";
}
private void Awake()
{
gameManager = GameObject.FindGameObjectWithTag("GameManager");
turnManager = gameManager.GetComponent<TurnManager>();
statusEffectManager = GetComponent<StatusEffectManager>();
gameInfo = gameManager.GetComponent<GameInfo>();
attackShakeTimer = gameObject.AddComponent<Timer>();
attackShakeTimer.Trigger += ShakeMe;
originalPosition = transform.position;
}
// Use this for initialization
void Start()
{
Pturn = true;
AIturn = false;
instance = this;
last_valid_x = (-1);
last_valid_y = (-1);
endgamecanvas = GameObject.Find ("WinnerCanvas");
endgamecanvas.GetComponent<Canvas> ().enabled=false;
}
void OnEnable()
{
tm = TurnManager.Instance();
GameObject playerObject = GameObject.FindGameObjectWithTag("Player");
Player playerStats = playerObject.GetComponent<Player>();
//TODO: delete this:
playerStats.attacks[0] = playerStats.atdb.attackList[0];
playerStats.attacks[1] = playerStats.atdb.attackList[1];
playerStats.attacks[2] = playerStats.atdb.attackList[2];
playerStats.attacks[3] = null;
int counter = 0;
ModalPanel.Instance().EnableAllAttacks();
foreach(Attack at in playerStats.attacks)
{
if(at != null)
counter++;
}
for(int i = 0; i < counter; i++)
{
if(playerStats.attacks[i] != null)
{
if(playerStats.attacks[i].currentCooldown > 0)
ModalPanel.Instance().DisableAttack(i);
}
}
switch(counter)
{
case 0:
//counter++;
//playerStats.getBasicAttack
Debug.Log("Error, no attacks could have been found");
break;
case 1:
ModalPanel.Instance().Show (playerStats.attacks[0].attackName, ()=>{playerStats.Attack(0,tm);},()=>{Next();});
break;
case 2:
ModalPanel.Instance().Show (playerStats.attacks[0].attackName, playerStats.attacks[1].attackName, ()=>{playerStats.Attack(0,tm);}, ()=>{playerStats.Attack(1,tm);}, ()=>{Next();});
break;
case 3:
ModalPanel.Instance().Show (playerStats.attacks[0].attackName, playerStats.attacks[1].attackName, playerStats.attacks[2].attackName, ()=>{playerStats.Attack(0,tm);}, ()=>{playerStats.Attack(1,tm);}, ()=>{playerStats.Attack(2,tm);}, ()=>{Next();});
break;
case 4:
ModalPanel.Instance().Show (playerStats.attacks[0].attackName, playerStats.attacks[1].attackName, playerStats.attacks[2].attackName, playerStats.attacks[3].attackName, ()=>{playerStats.Attack(0,tm);}, ()=>{playerStats.Attack(1,tm);}, ()=>{playerStats.Attack(2,tm);}, ()=>{playerStats.Attack(3,tm);}, ()=>{Next();});
break;
default:
Debug.Log("Wrong amount of attacks");
break;
}
}
// Use this for initialization
void Awake()
{
if (instance == null)
instance = this;
else if (instance != this)
Destroy (gameObject);
DontDestroyOnLoad (gameObject);
boardScript = GetComponent<BoardManager> ();
turnScript = GetComponent<TurnManager> ();
gridScript = GetComponent<Grid> ();
}
public void gameOver()
{
level = 1;
GameObject[] objects = GameObject.FindObjectsOfType<GameObject> ();
foreach (GameObject o in objects) {
if(!(o.name.Contains("GameManager") ||o.name.Contains ("SoundManager") || o.name.Contains("EmptyObject")||o.name.Contains("Event")||o.name.Contains("Light")))
Destroy(o);
}
boardScript = GetComponent<BoardManager> ();
turnScript = GetComponent<TurnManager> ();
gridScript = GetComponent<Grid> ();
}
private void Awake()
{
myInfo = GetComponent<CharacterInfo>();
gameManager = GameObject.FindGameObjectWithTag("GameManager");
turnManager = gameManager.GetComponent<TurnManager>();
statusEffectManager = GetComponent<StatusEffectManager>();
gameInfo = gameManager.GetComponent<GameInfo>();
myAI = GetComponent<HeroAI>();
attackDelayTimer = gameObject.AddComponent<Timer>();
attackDelayTimer.Trigger += ExecuteHeroAction;
attackShakeTimer = gameObject.AddComponent<Timer>();
attackShakeTimer.Trigger += ShakeMe;
originalPosition = transform.position;
}
// public Transform myDeckPanel;
// draw: Player[];
// GameField: GameField;
// Use this for initialization
// void Start () {
// Debug.Log("On commence");
// //chaque joeurs fait un pierre papier ciseau
// //le gagnant choisisson tour
// //on génère les cartes sur le terrain
// Debug.Log("on génère les cartes sur le terrain");
// //generateDeck();
// //chaque joeuurs piochent 5 cartes
// //chaque joeurs pioche ses cartes
// // var myDeckPanel = GameObject.FindGameObjectsWithTag("myDeckPanel");
// var myDeckPanel = GameObject.Find("myDeckPanel");
// //var panel = GameObject.Find("myDeckPanel");
// if (myDeckPanel != null) // make sure you actually found it!
// {
// GameObject a = (GameObject)Instantiate(preff);
// var components = a.GetComponentsInChildren<Text>();
// //to access values in card label
// Debug.Log(components[0].text);
// Debug.Log(components[1].text.ToString());
// Debug.Log(components[2]);
// Debug.Log(components[3]);
// Debug.Log(components[4]);
// a.transform.SetParent(myDeckPanel.transform, false);
// // a.transform.localScale = new Vector3(cardScaleX, cardScaleY, cardScaleZ);
// a.transform.localScale = new Vector3(cardScaleX, cardScaleY, cardScaleZ);
// // a.transform.localScale(cardScaleX, cardScaleY, cardScaleZ);
// // a.transform.SetParent(myDeckPanel.transform, false);
// }
// //-----------------duel loop ---------------------
// //on passe en dp du duel
// //le joueur pioche une carte
// //on passe les autres phases
// //on fait la somme des tours
// //si c'est le premier tour on ne peut pas attaquer
// //fin du tour
// //on reboucle
// }
// Update is called once per frame
// void Update () {
// }
public DuelGameManager(List <Player> duelists)
{
Debug.Log("duel gamemanager created");
//On crée le duel entre deux joueurs
this.playerList = duelists;
// on crée le deck de chaque joueurs en commencant par le first
// generatePlayerDeck(FirstPlayer);
Debug.Log("On créé visuellement toutees les cartes utilisé ici");
//on crée le gestionnaire de tours
TurnManager turn = new TurnManager();
this.counterForTurn = 0;
this.winner = null;
this.looser = null;
this.draw = null;
this.duelists = playerList;
// this.GameField = new GameField();
// this.GameField = new GameField(new PlayerSideField(), new PlayerSideField());
this.countTurns = 0;
this.FirstPlayer = this.duelists[0]; //on met le premier en premier pour tests
this.SecondPlayer = this.duelists[1]; //on met le premier en 2nd pour tests
//on shuffle le deck des joueurs
this.duelists[0].shuffleDeck();
this.duelists[1].shuffleDeck();
//on pioche 5 cartes pour chaque joueurs
this.duelists[0].beginingDuelDraw();
this.duelists[1].beginingDuelDraw();
for (int startupHand = 1; startupHand < 5; startupHand++)
{
this.FirstPlayer.drawCard();
this.SecondPlayer.drawCard();
}
Debug.Log("duelist 1 hand count ==> " + this.duelists[0].hand.Count);
Debug.Log("duelist 2 hand count ==> " + this.duelists[1].hand.Count);
// /*
// this.drawCard(this.duelists[0], 5);
// this.drawCard(this.duelists[1], 5);*/
// ///// DuelUntilVictory
this.canBegin = true;
//checking for a winner until one is selected
this.duelManagerCheckTurn();
}
public void FireGun(actionData act, TurnManager turnManager)
{
// if (act.target == act.actor) { turnManager.CheckRange(5); turnManager.resultdisplay.text = "looking at self "; Debug.Log("dont shoot im you "); }
//uiManager.UpdateScrollingText(act.actor.transform.name + " shoots at " + act.target.transform.name);
// if (act.target.team != act.actor.team)
// {
act.actor.transform.LookAt(act.target.transform);
Debug.Log("Firing gun ");
// turnManager.actionRemaining--;
turnManager.actionpointstext.text = turnManager.actionRemaining.ToString();
int tohit = turnManager.CalculateToHit();
int roll = Random.Range(1, 101);
if (tohit > roll)
{
act.target.TakeDamage(act.damage + 1);
// turnManager.lastActionPress = -1;
GameObject clone = Instantiate(turnManager.bulletPrefab2, act.actor.transform.position + act.actor.transform.forward, transform.rotation) as GameObject;
clone.GetComponent <Bullet>().holdvel = (act.target.transform.position - act.actor.transform.position);
turnManager.resultdisplay.text = " HIT : " + act.target.transform.name + " :hp: " + act.target.currenthp.ToString();
uiManager.UpdateScrollingText(act.actor.transform.name + " : HIT : " + act.target.transform.name + " :hp: " + act.target.currenthp.ToString());
}
else
{
Debug.Log("miss: Fire gun ");
//check to see if miss destroys something
Vector3 newdir = new Vector3(act.target.transform.position.x + (Random.Range(-0.3f, 1.0f)), act.target.transform.position.y + (Random.Range(-0.3f, 1.0f)), act.target.transform.position.z + (Random.Range(-0.3f, 1.0f))) - act.actor.transform.position;
turnManager.resultdisplay.text = " ::MISSED:: " + act.target.transform.name;
RaycastHit hit;
GameObject clone = Instantiate(turnManager.bulletPrefab, act.actor.transform.position + act.actor.transform.forward, transform.rotation) as GameObject;
uiManager.UpdateScrollingText(act.actor.transform.name + " ::MISSED:: " + act.target.transform.name);
clone.GetComponent <Bullet>().holdvel = newdir;
if (Physics.Raycast(turnManager.gun.transform.position, newdir, out hit, 15.0f))
{
if (hit.transform.tag == "destructable")
{
// Destroy(hit.transform.gameObject);
}
}
}
// }
// else { Debug.Log("sameteam"); uiManager.UpdateScrollingText(act.actor.transform.name + " doesnt shoot at " + act.target.transform.name); }
}
public void Start()
{
if (TurnManager.instance != null)
{
turnManager = TurnManager.instance;
}
if (RegionManager.instance != null)
{
regionManager = RegionManager.instance;
}
turnManager.EndTurnEvent.AddListener(UpdateCity);
UpdateCity();
maxFirstProd = 6;
maxSecondProd = 6;
}
//Assuming that we construct ships elsewhere (on another scene) and pass them in when the game scene is started
private void Awake()
{
shipList = new List <BaseShip>();
turnManager = new TurnManager();
targetManager = new TargetManager.TargetManager();
actionManager = ActionManager.instance;
tShip = new targetShip();
Wishbone wishbone = new Wishbone(new WishboneModel());
shipList.Add(wishbone);
targetManager.AddTarget(tShip);
eventLog = GameObject.Find("EventLog").GetComponent <PlayerLog>();
}
protected void UnitIsAlive(UnitMovement unit)
{
if (unit.GetComponent <BaseStats>().HP <= 0)
{
if (unit.tag == "Player")
{
unit.GetComponentInChildren <CharacterAnimatorController>().lateDeathAnimation = true;
}
if (unit.tag == "NPC")
{
unit.GetComponentInChildren <ZombieAnimatorController>().lateDeathAnimation = true;
}
TurnManager.RemoveUnit(unit);
}
}
void Start()
{
turnManager = new TurnManager();
turnManager.OnTurnChanged += onTurnChanged;
for (int i = 0; i < Teams.Length; i++)
{
for (int j = 0; j < Teams[i].TeamMembers.Length; j++)
{
Teams[i].TeamMembers[j].OnClicked += onClicked;
}
turnManager.AddTeam(Teams[i].TurnEntitiesList);
}
turnManager.Start();
}
// Use this for initialization
void Start()
{
selectionP2 = FindObjectOfType <SelectControllerP2>();
tankP1 = FindObjectOfType <PositionTester>();
healerP1 = FindObjectOfType <PositionHealer>();
dealerP1 = FindObjectOfType <PositionDealer>();
utilityP1 = FindObjectOfType <PositionUtility>();
tankP2 = FindObjectOfType <PositionTester2>();
healerP2 = FindObjectOfType <PositionHealer2>();
lm = FindObjectOfType <LifeManager>();
turn = FindObjectOfType <TurnManager>();
isAttack = false;
vibrato = 10;
strength = 0.1f;
}
private void Awake()
{
if (instance)
{
Destroy(gameObject);
return;
}
instance = this;
players = new List <Player>(FindObjectsOfType <Player>());
currentPlayerIndex = Random.Range(0, players.Count);
duringBuildPhase = true;
buildTurnsLeftInPhase = buildTurnsPerPhase;
//ScoreUIManager.instance.SetActiveCursor(currentPlayer);
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this.gameObject);
}
m_actionTiles = this.GetComponentInChildren <ActionTiles>();
m_turnManager = this.gameObject.AddComponent <TurnManager>();
m_unitManager = this.gameObject.AddComponent <UnitManager>();
}
protected override NodeStates Tick(Tick tick)
{
manager = tick.Target as TurnManager;
if (manager.TurnDone || !manager.Running)
{
return(NodeStates.Success);
}
else
{
manager.Update();
return(NodeStates.Running);
}
}
public void drawUnits(TurnManager tm, Control GroundPBox)
{
foreach (Unit u in tm.playingUnits)
{
TriangleField tf = getFieldGraphicByFiled(u.at, GroundPBox);
Point c = tf.getCenter();
Size s = new Size(15, 30);
c.X -= s.Width / 2;
c.Y -= s.Height;
UnitGamePiece ugp = new UnitGamePiece(u, c, s);
GroundPBox.Controls.Add(ugp);
ugp.BringToFront();
gameObjects.Add(u.at.yPos * 10 + 1, ugp);
}
}
// Use this for initialization
void Start()
{
maxEvents = 0;
MaxRegionResource = 6;
maxRegionQuality = 100;
regionQualityDecay = 0.01f;
//regionResourceAmount = Mathf.RoundToInt( ( regionQuality / maxRegionQuality) * MaxRegionResource);
material = this.GetComponent <Renderer>().material;
material.shader = Shader.Find("SFHologram/HologramShader");
if (TurnManager.instance != null)
{
turnManager = TurnManager.instance;
}
turnManager.EndTurnEvent.AddListener(UpdateRegion);
}
// Use this for initialization
void Start()
{
tileManager = TileManager.getInstance();
enemyManager = EnemyManager.getInstance();
turnManager = TurnManager.getInstance();
fogManager = FogManager.getInstance();
adjustBackground();
generateTiles();
generateFog();
generateZombies();
generateEnnemis();
generatePowerUps();
}
private void Awake()
{
if (TM == null)
{
TM = this;
}
else if (TM != this)
{
Destroy(this);
}
initiativeList = TurnOrder();
NextTurn();
}
public void SpawnAmbush()
{
TurnManager turns = FindObjectOfType <TurnManager>();
foreach (GameObject spawn in AmbushSpawnPoints)
{
Enemy enemy = Instantiate(enemySpawnTemplate, spawn.transform.position, Quaternion.identity);
TurnTaker turnTaker = enemy.GetComponent <TurnTaker>();
if (turnTaker != null)
{
turns.AddTurnTaker(enemy.GetComponent <TurnTaker>());
}
}
}
private void OnMouseDown()
{
if (!TurnManager.GetCurrTurnCharacter().tag.Contains("Enemy"))
{
if (DiceManager.CurrCombatStage == DiceManager.CombatStage.DiceAndTargets)
{
if (TurnManager.GetCurrTurnCharacter() != this.gameObject)
{
_isSelected = true;
DiceManager.ClearTargets();
DiceManager.AddTarget(this);
}
}
}
}
private double AverageTroopsPerCountry(TurnManager turnManager)
{
var info = turnManager.GetGameInfo();
var totalCountries = 0.0;
var totalTroops = 0.0;
info.GetAllCountriesOwnedByPlayer(this).ToList().ForEach(
(Country c) =>
{
totalCountries += 1;
totalTroops += c.NumberOfTroops;
});
return(totalTroops / totalCountries);
}
public void PickCard(CardView card)
{
if (card.GetCardData().state == CardState.Stacked && TurnManager.IsCardDrawn())
{
return;
}
else
{
card.GetComponent <RectTransform>().SetParent(container.transform);
card.GetComponent <RectTransform>().localRotation = Quaternion.identity;
card.GetComponent <RectTransform>().localScale = Vector3.one;
card.GetComponent <CardView>().GetCardData().state = CardState.Handed;
TurnManager.SetCardDrawn();
}
}
private void Awake()
{
gameController = GameObject.Find("GameController");
turnManager = gameController.GetComponent <TurnManager>();
uiController = gameController.GetComponent <UIControl>();
mapManager = gameController.GetComponent <ManageMap>();
tutorialManager = gameController.GetComponent <TutorialManager>();
movementController = GameObject.Find("Player").GetComponent <MovementController>();
//Awake should run before anything else in the game
gridLayout = GameObject.Find("Grid").GetComponent <GridLayout>(); //Get and store reference to the grid object
Vector3Int cellPosition = gridLayout.WorldToCell(transform.position); //Get the position of this object and convert it to the coordinates of the nearest hex
transform.position = gridLayout.CellToWorld(cellPosition); //Take the coordinates of the nearest cell, convert them back to world coordinates and assign that position to this object.
}
// Use this for initialization
void Start()
{
timer = 0.5f;
myTurn = false;
lm = FindObjectOfType <LifeManager>();
selection = FindObjectOfType <SelectionController>();
turn = FindObjectOfType <TurnManager>();
transform.position = grid.GetWorldPosition(x, y);
maxRangeHzUtilityPlayer1 = x;
maxRangeVtUtilityPlayer1 = y;
turn.isTurn = true;
contMp = 4;
att = FindObjectOfType <AttackBaseUtility>();
ab = FindObjectOfType <AbilityUtility>();
}
void Awake()
{
if (Instance == null)
{
Enemys = new List <EnemyClass>();
Instance = this;
}
else
{
if (Instance != this)
{
Destroy(gameObject);
}
}
}
// Use this for initialization
void Start()
{
contProv = 1;
timer = 0.5f;
lm = FindObjectOfType <LifeManager>();
selection = FindObjectOfType <SelectControllerP2>();
turn = FindObjectOfType <TurnManager>();
transform.position = grid.GetWorldPosition(x, y);
maxRangeHzDealerPlayer2 = x;
maxRangeVtDealerPlayer2 = y;
turn.isTurn = true;
contMp = 4;
att = FindObjectOfType <AttackBaseDealer2>();
ab = FindObjectOfType <AbilityDealer2>();
}
//protected CameraManager CameraManager;
#endregion
protected virtual void Awake()
{
AnimationManager = GetComponent <AnimationManager> ();
UIManager = GetComponent <UIManager> ();
BattleSystemClass = GetComponent <BattleSystem> ();
CalculationManager = GetComponent <CalculationManager> ();
TurnManager = GetComponent <TurnManager> ();
if (!(Camera.main is null))
{
CameraTransform = Camera.main.transform;
}
//CameraManager = GetComponent<CameraManager>();
unitData.currentHp = unitData.maxHp;
}
void Start () {
players = FindObjectsOfType(typeof(Player)) as Player[];
//ideally this would be from a player selection menu
//but that is beyond what is needed for this demo
foreach(Player player in players) {
if(player.isHuman) humanPlayer = player;
}
hud = transform.root.GetComponent<HUD>();
if(hud) hud.SetHumanPlayer(humanPlayer);
userInput = transform.root.GetComponent<UserInput>();
if(userInput) userInput.enabled = false;
soundManager = FindObjectOfType(typeof(SoundManager)) as SoundManager;
turnManager = transform.root.GetComponent<TurnManager>();
if(turnManager) turnManager.SetPlayers(players);
}
void Pausing(bool paused)
{
if ("UserViewIke".Equals(Application.loadedLevelName))
{
TurnManager.GetTurnManager().SetObjectsForPause(!paused);
}
else
{
TurnManager.GetTurnManager().SetObjectsForPause(paused);
}
if (pauseButton != null)
{
pauseButton.text = paused ? LanguageManager.instance.getString("UI_Admin", "Text_Unpause_Label") : LanguageManager.instance.getString("UI_Admin", "Text_Pause_Label");
}
}
// Use this for initialization
void Awake()
{
string tag;
if (isSecond)
{
tag = "Player2";
}
else
{
tag = "Player";
}
turnManager = GameObject.FindGameObjectWithTag(tag).GetComponent <TurnManager>();
ghostBombs = new List <GameObject>();
}
void CmdFireBullet(Vector3 position, Vector3 direction)
{
if (TurnManager.IsTurn(playerId))
{
//Fire bullet!
Bullet b = (Instantiate(bulletPrefab, position, Quaternion.identity) as GameObject).GetComponent <Bullet>();
b.transform.forward = direction;
b.SetData(b.transform.position, b.transform.forward, Network.time);
//create bullet on clients
NetworkServer.Spawn(b.gameObject);
TurnManager.NextTurn();
}
}
private void RpcOnPlayerHit(int hitPlayerID, int recipientPlayerID, int itemID)
{
Player playerHit = TurnManager.GetPlayer(hitPlayerID);
Player recipient = TurnManager.GetPlayer(recipientPlayerID);
Item weapon = ItemManager.GetItembyID(itemID);
string playerHitName = playerHit.name;
if (playerHit.id == Owner.id)
{
playerHitName = "You ";
}
Debug.Log(playerHitName + " was hit by " + recipient.name + " with a " + weapon.Data.name);
recipient.hits++;
}
public void Move()
{
if (path.Count > 0)
{
Tile t = path.Peek();
Vector3 target = t.transform.position;
//Calculate the unit's position on top of the target tile
target.y += halfHeight + t.GetComponent <Collider>().bounds.extents.y;
if (Vector3.Distance(transform.position, target) >= 0.05f)
{
bool jump = transform.position.y != target.y;
if (jump)
{
Jump(target);
}
else
{
CalculateHeading(target);
SetHorizotalVelocity();
}
//Locomotion
transform.forward = heading;
transform.position += velocity * Time.deltaTime;
}
else
{
//Tile center reached
transform.position = target;
path.Pop();
}
}
else if (attackPoints > 0)
{
Attack();
}
else
{
RemoveSelectableTiles();
moving = false;
move = 3;
TurnManager.EndTurn();
}
}
public static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var selector = new LocaleSelector();
selector.Activate();
selector.ShowDialog(null);
if (selector.DialogResult != DialogResult.OK)
{
return;
}
CultureInfo.CurrentCulture = selector.TargetCulture;
CultureInfo.CurrentUICulture = selector.TargetCulture;
CultureInfo.DefaultThreadCurrentCulture = selector.TargetCulture;
CultureInfo.DefaultThreadCurrentUICulture = selector.TargetCulture;
var rnd = new Random();
WaitRollDice.Rnd = rnd;
ItemContainer.Rnd = rnd;
var view = new MainGameForm();
// Construct the initial game data structures
var presenter = new Presenter(view);
var board = new GameBoard();
var bank = new Bank();
var playerList = new List <Player>
{
new Player(PlayerColor.Blue),
new Player(PlayerColor.Orange),
new Player(PlayerColor.Red),
new Player(PlayerColor.White)
};
var gameModel = new GameModel(board, bank, playerList, presenter);
var manager = new TurnManager(gameModel);
presenter.RegisterTurnManager(manager);
board.InitializeView(presenter);
var t = new Thread(presenter.MainLoop);
t.Start();
Application.Run(view);
}
public override void Init(Position startingPosition, TurnManager turnManager, TileManager tileManager,
BoardEntitySelector boardEntitySelector, BattleCalculator battleCalculator, Ka ka = null)
{
base.Init(startingPosition, turnManager, tileManager, boardEntitySelector, battleCalculator);
if (charactersprite != null)
{
charactersprite.transform.SetParent(FindObjectOfType <CharacterManagerMarker>().transform);
}
allCharacterBoardEntities.Add(this);
if (enemyAIBasic1 != null)
{
enemyAIBasic1.Init(tileManager, this);
}
basicAttack = new BasicAttack();
AddSkill(basicAttack);
if (charContainer != null)
{
charContainer.Init(this);
}
floatingTextGenerator = GetComponent <FloatingTextGenerator>();
this.ka = ka;
if (ka != null)
{
ka.Init(this);
if (charKaAura != null)
{
//charKaAura.SetActive(true);
//Color newColor = new Color(ka.KaColor.r, ka.KaColor.g, ka.KaColor.b, charKaAura.GetComponent<Image>().color.a);
//charKaAura.GetComponent<Image>().color = newColor;
}
}
initalized = true;
foreach (Skill skill in skills)
{
InitSkill(skill);
}
foreach (Passive passive in passives)
{
InitPassive(passive);
}
foreach (Passive p in Passives)
{
p.StartBattle();
}
}
private int getNumberOfBallsOnThisFire = 0; // onetime value
void Start () {
ballPrefab = Resources.Load("Prefab/Ball", typeof(Ball)) as Ball;
maxFireDegreeCos = Mathf.Cos(maxFireDegree * Mathf.Deg2Rad);
maxFireRightDirection = new Vector3(Mathf.Sin(Mathf.Deg2Rad * maxFireDegree), Mathf.Cos(Mathf.Deg2Rad * maxFireDegree), 0).normalized;
maxFireLeftDirection = new Vector3(-maxFireRightDirection.x, maxFireRightDirection.y, 0).normalized;
balls = new Ball[maxBallCount];
int ballsToInstantiate = Mathf.Min(currentBallCount, maxBallCount);
for (int i = 0; i < ballsToInstantiate; i++) {
balls[i] = Instantiate(ballPrefab, new Vector3(ballStartPositionX, ballStartPositionY), Quaternion.identity) as Ball;
balls[i].ballManager = this;
}
turnManager = GameObject.FindObjectOfType<TurnManager>();
}
public void PromptForActionsUntilItLoopsBackToFirstMember()
{
var member1 = new MokupMember(0, 1);
var member2 = new MokupMember(1, 3);
var member3 = new MokupMember(2, 2);
var member4 = new MokupMember(3, 4);
TurnManager mgr = new TurnManager();
mgr.Actors.Add(member3);
mgr.Actors.Add(member4);
mgr.Actors.Add(member1);
mgr.Actors.Add(member2);
mgr.Start();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 3);
member4.PromptFinished();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 1);
member2.PromptFinished();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 2);
member2.PromptFinished();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 0);
member2.PromptFinished();
//should loop back to id 3 here
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 3);
member2.PromptFinished();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 1);
member2.PromptFinished();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 2);
member2.PromptFinished();
mgr.Update();
Assert.IsTrue(mgr.CurrentActor.GetId() == 0);
member2.PromptFinished();
}
void Start()
{
Me = this;
TerrianManager = transform.FindChild("TerrainManager").GetComponent<TerrianManager>();
SpawnManager = transform.FindChild("SpawnManager").GetComponent<SpawnManager>();
TurnManager = transform.FindChild("TurnManager").GetComponent<TurnManager>();
DamageManager = transform.FindChild("DamageAndScoreManager").GetComponent<DamageManager>();
ScoreManager = transform.FindChild("DamageAndScoreManager").GetComponent<ScoreManager>();
DestroyManager = transform.FindChild("DestroyManager").GetComponent<DestroyManager>();
WeaponManager = transform.FindChild("WeaponsManager").GetComponent<WeaponsCombo>();
ModesManager = transform.FindChild("ModesManager").GetComponent<ModesCombo>();
MapsManager = transform.FindChild("MapManager").GetComponent<MapManager>();
PlayerInfos = SpawnManager.GetComponent<PlayerInfo>();
MapsManager.StartMap((MapManager.Maps) RoundManager.RandomMap);
SpawnManager.Spawn(TanksStaringCount);
TurnManager.Begin();
Wind.StartWind();
WeaponsClass.InitiallizeWeaponsQuantities();
ModesClass.InitiallizeModesQuantities();
#if (!Debug)
for (int i = 0; i < WeaponsClass.WeaponsQuantities.Count; i++)
WeaponsClass.WeaponsQuantities[WeaponsClass.WeaponsQuantities.ElementAt(i).Key] = 99;
for (int i = 0; i < ModesClass.ModesQuantities.Count; i++)
ModesClass.ModesQuantities[ModesClass.ModesQuantities.ElementAt(i).Key] = 99;
#endif
PlayerInfos.DrawPlayerInfoInUI_SinglePlayer();
//begin clouds
GameObject.Find("Cloud").GetComponent<Cload_Movement>().Begin();
GameObject.Find("Cloud (1)").GetComponent<Cload_Movement>().Begin();
GameObject.Find("Cloud (2)").GetComponent<Cload_Movement>().Begin();
//
GameObject.Find("UIButtons").GetComponent<UIButtonClick>().InitilizeButtons();
//show round loadout
GameObject fade = GameObject.Find("Fade");
fade.GetComponent<Fade>().ShowLoadout();
HideHUDS();
}
public void CreateTurnManager()
{
TurnManager mgr = new TurnManager();
Assert.IsNotNull(mgr);
}
public void SetupTwoTeamsWithMembersOrderBySpeed()
{
var member1 = new MokupMember(1,1);
var member2 = new MokupMember(2,3);
var member3 = new MokupMember(3,2);
var member4 = new MokupMember(4,4);
TurnManager mgr = new TurnManager();
mgr.Actors.Add(member3);
mgr.Actors.Add(member4);
mgr.Actors.Add(member1);
mgr.Actors.Add(member2);
mgr.Start();
Assert.AreEqual(mgr.Actors[0].GetStatNamed("Agility").TotalValue, 4);
Assert.AreEqual(mgr.Actors[1].GetStatNamed("Agility").TotalValue, 3);
Assert.AreEqual(mgr.Actors[2].GetStatNamed("Agility").TotalValue, 2);
Assert.AreEqual(mgr.Actors[3].GetStatNamed("Agility").TotalValue, 1);
}
// Use this for initialization
void Start()
{
this.menuActive = false;
// pauseButton.Resize (Screen.width/9, Screen.width/9);
paused = false;
showInstructions = false;
adjustVolume = false;
tm = GameObject.Find ("Player").GetComponent<TurnManager> ();
insFormatting = new GUIStyle();
insFormatting.alignment = TextAnchor.UpperLeft;
insFormatting.clipping = TextClipping.Clip;
insFormatting.wordWrap = true;
insFormatting.font = chewy;
insFormatting.fontSize = Screen.width/20;
insFormatting.richText = true;
gs2 = new GUIStyle();
gs2.stretchWidth = true;
gs2.stretchHeight = true;
gs2.fixedHeight = 5 * Screen.width / 6;
gs2.fixedWidth = Screen.width;
gs = new GUIStyle();
gs.font = chewy;
gs.fontSize = Screen.width/10;
gs.alignment = TextAnchor.MiddleCenter;
gs.stretchWidth = true;
gs.stretchHeight = true;
gs.richText = true;
volumeSliders = new GUIStyle();
volumeSliders.stretchWidth = true;
volumeSliders.stretchHeight = true;
volumeSliders.font = chewy;
volumeSliders.richText = true;
volumeSliders.fontSize = Screen.width/18;
//
//
//get values here
//values should be scaled
// 0 to 1 -> 25 to Screen.width - 25
//
//
//sets volume to the player prefrence or if undefined to baseVolume(25)
musicVolume = PlayerPrefs.GetFloat(musicVolKey,baseVolume) * (Screen.width - 50) + 25;
effectVolume = PlayerPrefs.GetFloat(effectVolKey,baseVolume) * 2 * (Screen.width - 50) + 25;
voiceVolume = PlayerPrefs.GetFloat(voiceVolKey,baseVolume) * 2 * (Screen.width - 50) + 25;
}
[PunRPC] public void setMyParent()
{
transform.SetParent (GameObject.Find ("TurnManager").transform);
myTurn = GetComponentInParent<TurnManager> ();
}
// Use this for initialization
void Start()
{
agent = GetComponent<NavMeshAgent> ();
MyTurnManager = GetManager.GetTurnManager ();
}
// Use this for initialization
void Start()
{
agent = GetComponent<NavMeshAgent> ();
OrigX = transform.position.z;
MyTurnManager = GetManager.GetTurnManager ();
}
void Awake()
{
instance = this;
playerIdList = new List<int>();
}
