// ------------------------------------------------------------------------------------ // public void onTouchBegan(GameTouchController gameTouchController, GameTouchParams gameTouchParams) { // Check active unit if (gameTouchParams.touchGameObject.tag.Equals(UnitBase.UNIT_TAG)) { UnitBase unit = gameTouchParams.touchGameObject.GetComponent<UnitBase>(); if (unit != null && unit.isUnitMaster()) { if (activeUnit != null && activeUnit.Equals(unit)) { activeUnit.setActive(false); activeUnit = null; } else { setNewActiveUnit(unit); } return; } } // Move active unit if not return if (activeUnit != null) { ((UnitMasterBase) activeUnit).moveAtPosition(gameTouchParams.touchPosition); } }
protected WidgetBase(UnitBase unit) { Unit = unit; // by setting the widget's datacontext to the unit, we enable WPF's binding listeners DataContext = unit; }
public IEnumerator AttackUnitBase(UnitBase targetUnitBase, int damage) { isAttacking = true; var fort = targetUnitBase as Fort; if (fort) { var fortIndex = fort.index; var fortLife = fort.rebornsLeft; Element targetElement; while (Data.GamePaused || !Data.Replay.Elements.TryGetValue(fortIndex, out targetElement) || (targetElement as Fort).life != fortLife) yield return null; targetUnitBase = targetElement as UnitBase; } var targetPosition = targetUnitBase.transform.WorldCenterOfElement(); yield return StartCoroutine(AimAtPosition(targetPosition)); targetAmmo -= AmmoOnce(); if (targetUnitBase) { yield return StartCoroutine(FireAtUnitBase(targetUnitBase)); targetUnitBase.targetHP -= damage; Data.Replay.TargetScores[team] += Constants.Score.PerDamage * damage; } else yield return StartCoroutine(FireAtPosition(targetPosition)); }
public static void addToBucket(UnitBase unitAdded, int team) { if (team == 1) Team1Bucket.Add(unitAdded); else Team2Bucket.Add(unitAdded); }
public void ApplySteering(UnitBase[] units) { // accumulate forces and apply to the creep if(GetComponent<UnitBase>().attacking) return; Vector2 targetForce = target-u.position; targetForce = targetForce.normalized * maxSpeed; targetForce -= vel; targetForce = Vector2.ClampMagnitude(targetForce, maxForce); Vector2 attract = Attract(units); Vector2 sep = Sep(units); if(attract != Vector2.zero){ targetForce *= 0.7f; sep *= 0.2f; acc += sep; acc += attract; }else{ targetForce *= 0.5f; sep *= 0.5f; acc += targetForce; acc += sep; } vel += acc; vel = Vector2.ClampMagnitude(vel, maxSpeed); u.position += vel; acc = Vector2.zero; }
public void Initialize(UnitBase attacker, UnitBase targetUnitBase, Level bombLevel) { this.attacker = attacker; this.targetUnitBase = targetUnitBase; targetPosition = targetUnitBase.transform.WorldCenterOfElement(); level = bombLevel; }
public void CheckNeighbors(UnitBase[] units) { targets.Clear(); foreach(UnitBase unit in units){ if(unit.GetComponent<PlayerManager>()&&unit.u.owner == u.owner){ float dist = Vector2.Distance(unit.u.position, u.position); if(dist - unit.u.displaySize < GetComponent<UnitBase>().attackRadius){ // we are within the attack radius! unit.temporaryDistance = dist; targets.Add(unit); } } } targets.Sort(delegate(UnitBase p1, UnitBase p2) { return (p1.temporaryDistance > p2.temporaryDistance)?-1:1; } ); GetComponent<UnitBase>().attacking = false; if(targets.Count > 0){ // if the nearest target is our player, then heal to the maximum if(targets[0].GetComponent<PlayerManager>() && targets[0].u.owner == u.owner){ // heal! GetComponent<PhotonView>().RPC("SetCooldown", PhotonTargets.AllBuffered, u.attackCooldown); targets[0].GetComponent<PhotonView>().RPC("SetHealth", PhotonTargets.AllBuffered, targets[0].u.health+targets[0].u.fullHealth*0.5f); }else if(targets[0].u.owner != u.owner){ GetComponent<UnitBase>().attacking = true; GetComponent<UnitBase>().AttackTarget(targets[0]); } } }
public IBattleObject FindEnemy(UnitBase finder) { foreach (var unit in units) { if (unit is MilitaryUnit && unit != finder) return unit; } return null; }
public void addUnit(UnitBase unit) { if (!myUnitList.Contains(unit)) { myUnitList.Add(unit); numUnitsInGroup++; } }
public EnemyUnit(World world, UnitBase target) : base(world, WorldLaw.EnemyUnitCreationSpeed, WorldLaw.DefaultEnemyLifeCount) { State = EnemyState.Running; Target = target; }
public BulletUnit(World world, PointF point, UnitBase sender) : base(world, WorldLaw.BulletUnitCreationSpeed, WorldLaw.DefaultEnemyLifeCount) { SetLocation(point.X, point.Y); Sender = sender; BulletState = BulletUnitState.Running; }
public void AttackUnit(UnitBase unit) { if (dealDamage(ActiveUnit, unit)) { positionToClean = ActiveUnit.Position; ActivateNextUnit(NextTurnQueue); } }
public StatementWidget(UnitBase unit) : base(unit) { // Workaround that fixes WPF DataBinding problem where values are properly bound but not UI updated SubscribeDataBinding(); InitializeComponent(); }
// ------------------------------------------------------------------------------------ // public override void initialize(UnitBase unit) { base.initialize(unit); _unit.registerObserver((IUnitCollisionObserver) this); _unitMaster.registerObserver((IUnitMasterObserver) this); deltaPosition = _unitMaster.UnitPosition - _unit.UnitPosition; }
protected override IEnumerator FireAtUnitBase(UnitBase targetUnitBase) { ++explosionsLeft; (Instantiate(Resources.Load("Bomb"), transform.position, transform.rotation) as GameObject).GetComponent<BombManager>().Initialize(this, targetUnitBase, BombManager.Level.Small); isAttacking = false; while (explosionsLeft > 0) yield return null; --Data.Replay.AttacksLeft; }
// ------------------------------------------------------------------------------------ // public override void initialize(UnitBase unit) { _positionStart = _unitMaster.UnitPosition; moveDistance = Vector3.Distance(_positionStart, _positionEnd); moveTime = moveDistance / speed; _unitMaster.registerObserver((IUnitCollisionObserver) this); }
// ------------------------------------------------------------------------------------ // private void setNewActiveUnit(UnitBase unit) { if (activeUnit != null) { activeUnit.setActive(false); } activeUnit = unit; activeUnit.setActive(true); }
///<summer> /// When called it adds a UnitBase instance to the PartyMembers list. ///</summer> public void JoinParty(UnitBase plr) { if (!partyMembers.Contains(plr)) { partyMembers.Add(plr); } else throw new System.ArgumentException("Already exists in " + this.ToString(), plr.gameObject.name); }
public void CloneTo(UnitBase unitbase) { unitbase.Name = this.Name; unitbase.Armor = this.Armor; unitbase.EnemyLayer = this.EnemyLayer; unitbase.GroundLayer = this.GroundLayer; unitbase.WallLayer = this.WallLayer; unitbase.MaxHP = this.MaxHP; unitbase.HP = this.HP; }
public override void Apply(UnitBase caster, UnitBase unit) { var statusToAdd = ScriptableObject.CreateInstance<Status>(); statusToAdd.Duration = status.Duration; statusToAdd.Parmanent = status.Parmanent; statusToAdd.Removable = status.Removable; statusToAdd.Rule = status.Rule; statusToAdd.Type = status.Type; unit.Statuses.Add(statusToAdd); }
public static void setAttackHUD(UnitBase unit) { activeButtons = 0; foreach(Attack x in unit.attacks) { setButtonText(activeButtons, unit.attacks[activeButtons].aName); setButtonActive(activeButtons, true); activeButtons++; } }
public IEnumerator Supply(UnitBase target, int fuel, int ammo, int metal) { var elapsedTime = Mathf.Max((fuel * Settings.Replay.FuelMultiplier + ammo * Settings.Replay.AmmoMultiplier + metal * Settings.Replay.MetalMultiplier) / Settings.Replay.SupplyRate, 0.1f); StartCoroutine(Beam(target, elapsedTime, BeamType.Supply)); yield return new WaitForSeconds((target.transform.WorldCenterOfElement() - Beamer.position).magnitude / Settings.Replay.BeamSpeed); target.FlashingOn(); var effectedFuel = 0; var effectedAmmo = 0; var effectedMetal = 0; for (float t, startTime = Time.time; (t = (Time.time - startTime) / elapsedTime) < 1;) { if (!Data.GamePaused) { var deltaFuel = Mathf.RoundToInt(fuel * t - effectedFuel); if (deltaFuel > 0) { targetFuel -= deltaFuel; target.targetFuel += deltaFuel; effectedFuel += deltaFuel; } var deltaAmmo = Mathf.RoundToInt(ammo * t - effectedAmmo); if (deltaAmmo > 0) { targetAmmo -= deltaAmmo; target.targetAmmo += deltaAmmo; effectedAmmo += deltaAmmo; } var deltaMetal = Mathf.RoundToInt(metal * t - effectedMetal); if (deltaMetal > 0) { targetMetal -= deltaMetal; target.targetMetal += deltaMetal; effectedMetal += deltaMetal; } } yield return null; } targetFuel -= fuel - effectedFuel; target.targetFuel += fuel - effectedFuel; targetAmmo -= ammo - effectedAmmo; target.targetAmmo += ammo - effectedAmmo; targetMetal -= metal - effectedMetal; target.targetMetal += metal - effectedMetal; target.FlashingOff(); string message; if (metal == 0) if (ammo == 0) message = fuel > 0 ? "F: +" + fuel : "0"; else message = (fuel > 0 ? "F: +" + fuel + " " : "") + "A: +" + ammo; else message = (fuel > 0 ? "F: +" + fuel + " " : "") + (ammo > 0 ? "A: +" + ammo + " " : "") + "M: +" + metal; yield return StartCoroutine(Data.Replay.Instance.ShowMessageAt(target, message)); --Data.Replay.SuppliesLeft; }
// Update is called once per frame void Update() { //Selection if (Input.GetMouseButtonDown(0)) { //If no units are selected if(Equals(Selector.selected, null)) { //If we are hovering a possible unit if(Selector.hovered != null) { //Hover Over a friendly unit shows the selection circle int layerValue = (1 << Selector.hovered.layer); if ((layerValue & currentAllyLayer.value) > 0) { unit1 = Selector.hovered.GetComponent<UnitBase>(); selectScript.setSelected(unit1.unit); AtkHUD.setAttackHUD(unit1); } } //TODO //Sets the button names and activates them } //UnitPreviously selected may be unselected only if no actions have been taken already else if (!EventSystem.current.IsPointerOverGameObject() && !Equals(unit1, null) && !unit1.hasActed && !unit1.hasMoved) { //Immediatly Select another unit if (Selector.hovered != null) { //Hover Over a friendly unit shows the selection circle int layerValue = (1 << Selector.hovered.layer); if ((layerValue & currentAllyLayer.value) > 0) { Selector.clearTargetted(UnitHandler.unit1); unit1 = Selector.hovered.GetComponent<UnitBase>(); selectScript.setSelected(unit1.unit); } } //We want to unselect a selected unit clearUnit(UnitHandler.unit1); Debug.Log("Unselected"); } //Mouse is over menu else { Debug.Log("OverMenu!"); } } }
public EnemyUnit(World world, Point position, UnitBase target) : base(world, WorldLaw.EnemyUnitCreationSpeed, WorldLaw.DefaultEnemyLifeCount) { State = EnemyState.Running; Target = target; SetLocation(position.X, position.Y); m_prevLocation.X = position.X; m_prevLocation.Y = position.Y; }
// todo: need refactoring private void TryAddScore(UnitBase sender, UnitBase deadOn) { var possiblePlayer = sender as PlayerUnit; var possibleEnemy = deadOn as EnemyUnit; if (possiblePlayer != null && possibleEnemy != null) { possiblePlayer.Score.Count += 1; if ((possiblePlayer.Score.Count % WorldLaw.LevelUpThreshold) == 0) { sender.World.WorldState.LevelUp = true; } } }
public void IssueOrder(Order order) { foreach (var sel in currentSelection) { UnitBase b = sel as UnitBase; DonateOrder d = order as DonateOrder; if (d != null && (b == null || !b.canDonate)) { continue; } sel.SetOrder(order); } ClearSelection(); }
public AoeField(UnitBase caster, AoeRegion region, float duration, float interval, List <BuffEmitter> emitters) { Caster = caster; mRegion = region; Interval = interval; Duration = duration; mElapseTime = 0; mCdTime = 0; for (int i = 0; i < emitters.Count; ++i) { emitters[i].Caster = caster; } BuffEmitters = emitters; }
// helper function public UnitBase findNearestUnit(Vector3 destination) { UnitBase nearestUnit = myUnitList[0]; foreach (UnitBase t in myUnitList) { if (Vector3.Distance(nearestUnit.transform.position, destination) > Vector3.Distance(t.transform.position, destination)) { nearestUnit = t; } } return(nearestUnit); }
protected virtual void DamageFunc(UnitBase unitBase) { if (MultyManager.Inst != null) { if (unitBase.photonView != null && !unitBase.photonView.isMine) { unitBase.photonView.RPC("GetDamage", PhotonTargets.AllBufferedViaServer, m_nValue); } } else { unitBase.GetDamage(m_nValue); } }
protected override void DoDamage(UnitBase unitToDealDamage) { //Añado este if para el count de honor del samurai if (currentFacingDirection == FacingDirection.North && unitToDealDamage.currentFacingDirection == FacingDirection.South || currentFacingDirection == FacingDirection.South && unitToDealDamage.currentFacingDirection == FacingDirection.North || currentFacingDirection == FacingDirection.East && unitToDealDamage.currentFacingDirection == FacingDirection.West || currentFacingDirection == FacingDirection.West && unitToDealDamage.currentFacingDirection == FacingDirection.East ) { LM.honorCount++; } base.DoDamage(unitToDealDamage); }
protected override void Awake() { if (this.unit == null) { this.unit = this.transform.GetComponent <UnitBase>(); this.controller = this.unit.controller; } this.FindUI(this.transform, UIValues.Unit.UNITUI); base.Awake(); if (this._spCircle == null) { this._spCircle = this.transform.Find(UIValues.Unit.SELECTIONCIRCLE).GetComponent <SpriteRenderer>(); } this._spCircle.gameObject.SetActive(false); if (this._btnEnd == null) { this._btnEnd = this.FindButton(this._tSelected, UIValues.Unit.ENDBUTTON); } if (this._btnCancel == null) { this._btnCancel = this.FindButton(this._tSelected, UIValues.Unit.CANCELBUTTON); } this._btnCancel.gameObject.SetActive(false); if (this._btnAttack == null) { this._btnAttack = this.FindButton(this._tSelected, UIValues.Unit.ATTACKBUTTON); } if (this._btnMove == null) { this._btnMove = this.FindButton(this._tSelected, UIValues.Unit.MOVEBUTTON); } if (this._btnFinishMove == null) { this._btnFinishMove = this.FindButton(this._tSelected, "Finish_BTN"); } this._btnFinishMove.gameObject.SetActive(false); if (this._textInfo == null) { this._textInfo = this._tHover.Find(UIValues.Unit.INFOTEXT).GetComponent <Text>(); } }
public override void Action(UnitBase _base) { if (_base.SelfFunction) { _base.Action(this); return; } if (CanMove(_base)) { //Debug.Log("enter"); transform.position += MoveDir; _base.transform.position += MoveDir; _base.curmoveTime = 0; } }
/// <summary> /// Initializes a new instance of the <see cref="MultiSelectionUnitDecorator" /> class. /// </summary> /// <param name="unit">A <see cref="Unit" />.</param> public MultiSelectionUnitDecorator(UnitBase unit) { this._unit = unit; this._subordinates = new List <IUnitDecorator>(); var higherUnit = Unit as HigherUnit; if (higherUnit != null) { foreach (var subordinate in higherUnit.Subordinates.OrderBy(subordinate => subordinate, UnitComparer)) { this._subordinates.Add(new MultiSelectionUnitDecorator(subordinate)); } } }
public static string Format(long size, UnitBase @base = UnitBase.Base2, UnitStyle format = UnitStyle.Smart) { bool neg = size < 0; ulong fmt_size = size switch { // Math.Abs(long.MinValue) is out of range for long so we handle it separately long.MinValue => ((ulong)long.MaxValue) + 1, < 0 => (ulong)Math.Abs(size), _ => (ulong)size, }; var formatted = Format(fmt_size, @base, format); return(neg ? "-" + formatted : formatted); }
private void ServerHandleBaseDespawned(UnitBase unitBase) { bases.Remove(unitBase); if (bases.Count != 1) { return; } int playerId = bases[0].connectionToClient.connectionId; // only one player base left in list, so they must be the winner RpcGameOver($"Player {playerId}"); ServerOnGameOver?.Invoke(); }
/// <summary> /// 单位濒临死亡 /// </summary> /// <param name="unit">死亡单位</param> /// <param name="slayer">攻击者</param> /// <returns>是否进入死亡</returns> public static bool OnUnitWillDie(UnitBase unit, UnitBase slayer) { #if DEBUG Debug.LogFormat("OnUnitWillDie unit = {0} slayer = {1} ", unit.ID, slayer.ID); #endif bool res = true; for (int i = mUnitWillDieList.Count - 1; i >= 0; --i) { if (!mUnitWillDieList[i].OnUnitWillDie(unit, slayer)) { res = false; } } return(res); }
private static int CalculateFinalDamageAmount(UnitBase damageDealer, UnitBase target, float totalDamage, bool isCritical) { totalDamage *= damageDealer.Unit.damageModFromPassives; totalDamage *= target.Unit.damageTakenModFromPassives; if (!isCritical) { return(totalDamage < 0 ? 0 : Random.Range((int)(0.97f * totalDamage), (int)(1.03f * totalDamage))); } totalDamage = (int)(totalDamage * GlobalVariables.Instance.criticalDamageFactor); target.Unit.targetHasCrit = true; return(totalDamage < 0 ? 0 : Random.Range((int)(0.97f * totalDamage), (int)(1.03f * totalDamage))); }
void SendLocalPlayerData() { UnitBase localPlayer = PlayerController.Instance.localPlayer; if (localPlayer) { // send data at least once in two seconds if (PlayerController.Instance.HasCommand() || Time.time - lastTimestamp > 0.1) { localPlayer.ValidatePlayerData(); PlayerUpdateMsg puMsg = new PlayerUpdateMsg(clientId, localPlayer.GetPlayerData(), PlayerController.Instance.PopCommands()); SendToServer(JsonUtility.ToJson(puMsg)); } } }
void GetTarget() { if (!m_Seeking) { StartCoroutine("Seek"); } m_CurrentTarget = PickBestSuitableTarget(); if (m_CurrentTarget) { StopCoroutine("Seek"); m_Seeking = false; m_CurrentTarget.UnitDied += DropTarget; } }
private void Update() { _spawnTimer += Time.deltaTime; if (_currentSpawns < _maxSimultaneousSpawns && (MaxSpawns > 0 || _endlessSpawn) && _spawnTimer > SpawnCooldown && (!_ActivatorExists || Activator.Active)) { UnitBase enemy = Spawn(); enemy.transform.position = transform.position; _spawnTimer = 0; _currentSpawns++; if (!_endlessSpawn) { MaxSpawns--; } } }
//Calculate damage when damage is not known public static int calculateDamage(UnitBase attacker, UnitBase defender, Attack attack) { float attackFactor = 1f; float defenceFactor = 1f; float damage = rollDamage(attack.roll, attack.dmg, attack.nDice); foreach(DamageType x in attack.getTypes()) { attackFactor *= attacker.typeAtk[(int)x]; defenceFactor *= defender.typeDef[(int)x]; } return (int)(damage *= (attackFactor/defenceFactor)); }
/// <summary> /// 更新物体的坐标和所属格子 /// </summary> /// <param name="obj"></param> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public void UpdateNode(UnitBase obj) { var cur = GetGridNodeByPosition(obj.position.x, obj.position.y); if (obj.mGridNode != null && obj.mGridNode != cur) { obj.mGridNode.Remove(obj); cur.Add(obj); } else { cur.Add(obj); } obj.mGridNode = cur; }
int SetControll(GameObject takeObject) { if (takeObject != null) { moveObject = takeObject; if (takeObject.name.Contains("Tower")) { turretScript = moveObject.GetComponent<TurretBase>(); turretScript.takenOver = true; return 1; } else if (takeObject.name.Contains("Cat")) { unitScript = moveObject.GetComponent<UnitBase>(); unitScript.takenOver = true; moveSpeed = unitScript.moveSpeed; return 2; } else return 0; } else return 0; }
private bool ExecuteMoveInternal(UnitBase unit, MobilityExtension.StepForwardMove move) { var dirVec = GetDirectionVector(unit.Facing); var pos = _gameWorldService.GetEntityPosition(unit); if (!pos.HasValue) { return(false); } var targetPos = (x : pos.Value.x + dirVec.x, y : pos.Value.y + dirVec.y); return(MoveUnitToPosition(unit, targetPos)); }
private float CurrentRotationSet(UnitBase unit) { var currentRotation = MathHelper.WrapAngle(MathExt.Angle(unit.Movement.MovementVectorValue) - 0.786f); if (currentRotation < 0) { currentRotation = -currentRotation + 3.14f; } else { currentRotation = -(currentRotation - 3.14f); } currentRotation = MathHelper.ToDegrees(currentRotation); return(currentRotation); }
private static void TempestUpdater() { if (TempestManager.Tempest != null && TempestManager.Tempest.IsValid) { ItemPanel.GetItemPanel().Load(); TempestHero = new Tempest(); TempestHero.Init(); UpdateManager.Unsubscribe(TempestUpdater); AutoMidas.GetNewInstance(TempestHero); DelayAction.Add(200, () => { PushLaneSelector.GetInstance().Load(); }); } }
private void ServerHandleBaseDespawned(UnitBase unitBase) { bases.Remove(unitBase); if (bases.Count != 1) { return; } int playerID = bases[0].connectionToClient.connectionId; RpcGameOver($"Player {playerID}"); ServerOnGameOver?.Invoke(); }
private void SetupEnemyStatusBox(UnitBase clone, GameObject enemyGo) { var position = enemyGo.transform.position; var newPosition = new Vector3(position.x, position.y + 2.25f, position.z); var statusBox = Instantiate(database.enemyStatusBox, newPosition, database.enemyStatusBox.rotation); statusBox.transform.SetParent(clone.Unit.transform); var statusBoxController = statusBox.GetComponentInChildren <StatusEffectControllerUI>(); statusBoxController.member = clone; statusBoxController.Initialize(); }
public UnitBase GetNearestEnemyUnit(Vector3 point, float distance = float.MaxValue) { UnitBase nearestEnemy = null; foreach (UnitBase enemy in enemyTeams[0].units) { float currentDistance = Vector3.Distance(point, enemy.transform.position); if (currentDistance < distance) { distance = currentDistance; nearestEnemy = enemy; } } return(nearestEnemy); }
/// <summary> /// Creates a building object and returns that object. If specified type does not exists returns null. /// </summary> /// <param name="unitType"></param> /// <returns></returns> public UnitBase Create(UnitType unitType) { UnitBase unitBase = null; switch (unitType) { case UnitType.Barrack: unitBase = new Barracks(new UnitSpawnTileSelector()) { XDimension = 4, YDimension = 4, MoveableUnitPrototypes = { CreateMoveableUnit("soldier") } }; break; case UnitType.PowerPlant: unitBase = new PowerPlants() { XDimension = 2, YDimension = 3 }; break; case UnitType.Camp: unitBase = new Camp(new UnitSpawnTileSelector()) { XDimension = 3, YDimension = 2, MoveableUnitPrototypes = { CreateMoveableUnit("camper"), CreateMoveableUnit("soldier") } }; break; default: Debug.LogError("This type of product is not specified."); break; } return(unitBase); }
public override void ReceiveDamage(int damageReceived, UnitBase unitAttacker) { if (parryOn && unitToParry != null) { particleParryAttack.SetActive(true); if (parryOn2) { if (unitAttacker == unitToParry) { damageReceived = 0; DoDamage(unitToParry); UIM.RefreshHealth(); parryIcon.SetActive(false); } else if (unitToParry != null) { if ((unitAttacker.currentFacingDirection == FacingDirection.North || unitAttacker.currentFacingDirection == FacingDirection.South && currentFacingDirection == FacingDirection.West || currentFacingDirection == FacingDirection.East) || (unitAttacker.currentFacingDirection == FacingDirection.West || unitAttacker.currentFacingDirection == FacingDirection.East && currentFacingDirection == FacingDirection.North || currentFacingDirection == FacingDirection.South)) { base.ReceiveDamage(damageReceived, unitAttacker); DoDamage(unitToParry); UIM.RefreshHealth(); parryIcon.SetActive(false); } } } else if (unitAttacker == unitToParry) { damageReceived = 0; DoDamage(unitToParry); UIM.RefreshHealth(); parryIcon.SetActive(false); } } else { base.ReceiveDamage(damageReceived, unitAttacker); } }
public void Wall(UnitBase unit) { unit.unitCounters.Add("ap", 1); unit.unitCounters.Add("apMax", 1); unit.unitCounters.Add("iniciative", 1); unit.unitCounters.Add("reqInfluence", 1); unit.unitCounters.Add("hp", 10); unit.unitCounters.Add("speed", 2); unit.unitCounters.Add("maxSpeed", 2); unit.unitCounters.Add("isEnemy", 0); unit.audioMenager = Instantiate(unit._audioMenager, new Vector3(0, 0, 0), Quaternion.identity) as GameObject; unit.audioMenager.GetComponent <AudioMenager>().initAudio("building"); unit.unitDescription.setCardDescription("Ściana", "Zwykła ściana nic dodać nic ująć"); unit.beforeEffects.Add(new InfluenceEffect(unit, Zone.frame(2), materialHolder)); unit.afterEffects.Add(new AttackEffect(unit, new Zone(), materialHolder)); }
public TeachBoxViewModel() { LengthUnitCollection = new ObservableCollection <UnitBase>() { new Millimeter(), new Micron(), new Nano() }; AngleUnitCollection = new ObservableCollection <UnitBase> { new Degree(), new Radian(), }; _currentLengthUint = LengthUnitCollection[0]; _currentAngleUint = AngleUnitCollection[0]; }
public override void readFromNbt(NbtCompound tag) { base.readFromNbt(tag); this.fireCooldown = tag.getFloat("fireCooldown"); MapObject obj = this.map.findMapObjectFromGuid <MapObject>(tag.getGuid("targetGuid")); if (obj is UnitBase) { this.target = (UnitBase)obj; } else { this.target = null; } }
void Start() { shopImage = transform.Find("ShopImage").GetComponent <Image>(); shopImageBack = transform.Find("ShopImageBack").GetComponent <Image>(); text = transform.Find("Text").GetComponent <TextMeshProUGUI>(); hireCountText = transform.Find("HireCount").GetComponent <TextMeshProUGUI>(); unitBase = buildPrefab.GetComponent <UnitBase>(); shopImage.fillAmount = 0; text.text += $" {unitBase.price.meat}"; startingAlpha = shopImageBack.color.a; hireCount = 0; hireCountText.text = hireCount.ToString(); Hide(); }
public void GolompEnemy(UnitBase unit) { //Debug.Log("enemy load"); unit.unitCounters.Add("ap", 0); unit.unitCounters.Add("apMax", 2); unit.unitCounters.Add("iniciative", 3); unit.unitCounters.Add("hp", 3); unit.unitCounters.Add("speed", 2); unit.unitCounters.Add("maxSpeed", 2); unit.unitCounters.Add("isEnemy", 1); unit.audioMenager = Instantiate(unit._audioMenager, new Vector3(0, 0, 0), Quaternion.identity) as GameObject; unit.audioMenager.GetComponent <AudioMenager>().initAudio("enemy"); unit.unitDescription.setCardDescription("Nieumarly pryskacz", "Szybki i do tego pluje"); unit.afterEffects.Add(new MoveEffect(unit, Zone.one(), materialHolder)); unit.afterEffects.Add(new AttackEffect(unit, Zone.frame(2), materialHolder)); }
public void BasicEnemy(UnitBase unit) { //Debug.Log("enemy load"); unit.unitCounters.Add("ap", 0); unit.unitCounters.Add("apMax", 2); unit.unitCounters.Add("iniciative", 1); unit.unitCounters.Add("hp", 3); unit.unitCounters.Add("speed", 2); unit.unitCounters.Add("maxSpeed", 2); unit.unitCounters.Add("isEnemy", 1); unit.audioMenager = Instantiate(unit._audioMenager, new Vector3(0, 0, 0), Quaternion.identity) as GameObject; unit.audioMenager.GetComponent <AudioMenager>().initAudio("enemy"); unit.unitDescription.setCardDescription("Nieumarly alien", "Jeden z pierwszych odkrytych nieumarłych lecz nieżywych ocalałych"); unit.afterEffects.Add(new MoveEffect(unit, Zone.one(), materialHolder)); unit.afterEffects.Add(new AttackEffect(unit, Zone.frame(1), materialHolder)); }
public void CheckNeighbors(UnitBase[] units) { BuildTargetList(); GetComponent<UnitBase>().attacking = false; if(targets.Count > 0){ if(currentMode == Modes.HEAL && GetComponent<UnitBase>().attackCooldownCounter <= 0){ Debug.Log("Healing"); GetComponent<UnitBase>().attackCooldownCounter = u.attackCooldown; GetComponent<PhotonView>().RPC("SetCooldown", PhotonTargets.AllBuffered, u.attackCooldown); targets[0].GetComponent<PhotonView>().RPC("SetHealth", PhotonTargets.AllBuffered, targets[0].u.health + 20); lines.AddLine(u.pos3.Variation(1), targets[0].u.pos3.Variation(1), ourColor); return; } if(currentMode == Modes.ATTACK){ GetComponent<UnitBase>().attackCooldownCounter = u.attackCooldown; GetComponent<UnitBase>().attacking = true; GetComponent<UnitBase>().AttackTarget(targets[0]); } } }
public override void launchAttack() { target = null; Debug.Log("DEBUG: LaunchAttack Single Target"); RaycastHit hit; if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, Mathf.Infinity, UnitHandler.currentEnnemyLayer)) { Debug.Log("AttackConnected!"); Debug.Log(hit.collider.transform.root.gameObject.GetComponent<UnitBase>().uName); target = UnitHandler.units.Find(x => x.getId() == hit.collider.transform.root.gameObject.GetInstanceID()); target.printName(); //If we have an active unit and an active target if (!(Equals(UnitHandler.unit1, null))) { //Unit 1 attacks his target setTargets(Effector.getTargets()); if(target!= null) UnitHandler.unit1.attackUnit(target, this); endAttack(); } } }
/**********************************************/ /*REMOVE UNITS FROM TEAM BUCKETS*/ /*New turn starts for other team when all moves are done -- Might become a new function*/ /********************************************************/ public static void removeFromBucket(UnitBase unitRemoved, int team) { if (team == 1) { Team1Bucket.Remove(unitRemoved); if (Team1Bucket.Count == 0) { Debug.Log("No more units in 1"); if (isTeam1Turn) teamSwitch(); } } else { Team2Bucket.Remove(unitRemoved); if (Team2Bucket.Count == 0) { Debug.Log("No more units in 2"); if(!isTeam1Turn) teamSwitch(); } } }