public static void RegisterPlayer(string _netID, SoldierController _player)
{
string _playerID = PLAYER_ID_PREFIX + _netID;
playerDict.Add(_playerID, _player);
_player.transform.name = _playerID;
}
private void OnCollisionWithSoldier(GameObject soldier)
{
SoldierController sc = soldier.GetComponent <SoldierController>();
sc.OnHit(damage);
Destroy(gameObject);
}
private void Update()
{
if (isFind)
{
float oldDistance = 1000f;
SoldierController _targetContrl = null;
foreach (Collider col in Physics.OverlapSphere(transform.position, SoldierInterface.DetectionRadius))
{
if (col.tag == enemyTeamTag.ToString() && col.transform.GetChild(0).GetComponent <SoldierController>().IsAlive)
{
var currentDistance = Vector3.Distance(col.transform.position, GetPositions());
if (oldDistance > currentDistance)
{
oldDistance = currentDistance; _targetContrl = col.transform.GetChild(0).GetComponent <SoldierController>();
}
}
}
if (_targetContrl != null)
{
isFind = false;
targetContrl = _targetContrl;
AttackInterface.AttackTarget(targetContrl);
}
}
if (isMove && isMoveToTarget && targetContrl != null)
{
if (Vector3.Distance(GetPositions(), TargetContr.GetPositions()) <= SoldierInterface.AttackRange)
{
isMove = false;
isMoveToTarget = false;
agent.Stop();
agent.ResetPath();
AttackInterface.AttackTarget(targetContrl);
}
else
{
MoveInterface.MoveTo(TargetContr.GetPositions());
}
}
if (isMove && !isMoveToTarget)
{
if (agent.remainingDistance <= agent.stoppingDistance)
{
isMove = false;
isFind = true;
}
}
if (targetContrl != null)
{
Vector3 lookPos = targetContrl.GetPositions() - GetPositions();
if (lookPos != Vector3.zero)
{
Quaternion rotation = Quaternion.LookRotation(lookPos);
myTransform.rotation = Quaternion.Slerp(myTransform.rotation, rotation, Time.deltaTime * SoldierInterface.RotationSpeed);
}
}
}
////////////
protected virtual void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.tag.Equals("Soldier"))
{
SoldierController comCollision = collision.gameObject.GetComponent <SoldierController>();
if (comCollision.team == Team)
{
if (comCollision.endTarget.Equals(this.transform.position))// nếu chạm vào nhà mình là đích
{
this.AddSoidier();
Destroy(comCollision.gameObject);
}
else // nếu chạm vào nhà mình kp đích
{
// print("đi qua");
}
}
else// nếu chạm vào nhà địch
{
if (CurHealth <= 0)
{
ChangeTeam(comCollision.team);
}
else
{
ReceiveDamege(comCollision.damege);
}
Destroy(comCollision.gameObject);
}
}
}
IEnumerator SimulateProjectile(SoldierController soldierContr)
{
Vector3 TargetPos = soldierContr.GetPositions();
TargetPos.y = 0f;
GameObject newPlane = Instantiate(planePrefab, airstrip.position, airstrip.rotation);
float targetDistance = Vector3.Distance(airstrip.position, TargetPos);
float projectileVelocity = targetDistance / (Mathf.Sin(2f * angle * Mathf.Deg2Rad) / gravity);
newPlane.GetComponent <Plane>().AttackPower = myContrl.SoldierInterface.AttackPower;
newPlane.GetComponent <Plane>().EnemyTeamTag = myContrl.EnemyTeamTag;
newPlane.GetComponent <Plane>().DestinationPoint = TargetPos;
float Vx = Mathf.Sqrt(projectileVelocity) * Mathf.Cos(angle * Mathf.Deg2Rad);
float Vy = Mathf.Sqrt(projectileVelocity) * Mathf.Sin(angle * Mathf.Deg2Rad);
float flightDuration = targetDistance / Vx;
newPlane.transform.rotation = Quaternion.LookRotation(TargetPos - newPlane.transform.position);
float elapseTime = 0;
while (elapseTime < flightDuration)
{
newPlane.transform.Translate(0, (Vy - (gravity * elapseTime)) * Time.deltaTime, Vx * Time.deltaTime);
elapseTime += Time.deltaTime;
yield return(null);
}
}
public void AttackSoldier(SoldierController target)
{
// Swap again for the attack animation to create more unique soldiers
SwapAnimationController();
transform.LookAt(target.gameObject.transform);
animator.SetTrigger(ATTACK_TRIGGER);
}
/**
* If the gun is shootable, shoot
*
* @param soldierController: The soldier that is holding a representation of this gun
*/
public void Shoot(SoldierController soldierController)
{
if (currentAmmo != 0 && !IsBusy())
{
StartCoroutine(ShootCR(soldierController));
}
}
/**
* This should be called when the gun is shot. This will determine what hit the gun and call the appropriate reaction
* function for the object that was hit. The logic for this function is based on the raycasting code from Lab 4.
*/
public static void PhysicsRaycasts(Quaternion shooterRotation)
{
Vector3 centreOfScreen = new Vector3(Screen.width * 0.5f, Screen.height * 0.5f, 0);
Ray centreOfScreenRay = Camera.main.ScreenPointToRay(centreOfScreen);
RaycastHit hit;
if (Physics.Raycast(centreOfScreenRay, out hit))
{
hit.transform.GetComponent <ObjectManagerBase>().photonView.RPC("Hit", PhotonTargets.All, new object[] { hit.point, shooterRotation });
GameObject hitGameObject = hit.transform.root.gameObject;
if (hitGameObject.tag == "BlueSoldier" || hitGameObject.tag == "RedSoldier") // i.e. another player
{
SoldierController hitSoldierController = hitGameObject.GetComponent <SoldierController>();
if (!hitSoldierController.GetIsDead()) // Decrease health if not dead
{
hitSoldierController.photonView.RPC("DecreaseHealth", PhotonTargets.AllBuffered, new object[] { 10 });
if (hitSoldierController.GetIsDead()) // If they died, increment your kills
{
GameManager.Instance.IncrementKills();
}
}
else
{
// Make the ragdoll move in the direction it was shot at
hit.transform.GetComponent <ObjectManagerBase>().photonView.RPC("HitRigidbody", PhotonTargets.All, new object[] { hit.point });
}
}
else if (hitGameObject.tag == "Grenade")
{
hit.transform.GetComponent <ObjectManagerBase>().photonView.RPC("HitRigidbody", PhotonTargets.All, new object[] { hit.point });
}
}
}
public void Execute()
{
var target = TargetSelector.GetTarget(1100, DamageType.Magical);
if (target == null || !target.IsValidTarget())
{
return;
}
var predictionR = R.GetPrediction(target);
if (DmgLib.R(target) > target.Health && R.IsReady() && R.IsInRange(target) && predictionR.HitChance >= HitChance.Medium && Misc.isChecked(ComboMenu, "finisherR"))
{
R.Cast(predictionR.CastPosition);
}
if (DmgLib.E(target) > target.Health && E.IsReady() && Misc.isChecked(ComboMenu, "finisherE"))
{
foreach (var validAzirSoldier in Azir.AzirSoldiers)
{
if (target.Position.Between(_Player.Position, validAzirSoldier.ServerPosition))
{
E.Cast();
}
}
}
if (Misc.isChecked(ComboMenu, "comboSoldiers"))
{
SoldierController.AutoPilot(Azir.AzirSoldiers, target);
}
}
// Update is called once per frame
void UpdateSelection()
{
if (selectedUnit != null && !selectedUnit.gameObject.activeInHierarchy)
{
selectedUnit = null;
}
var hoverUnit = FindHoverUnit();
if (hoverUnit == selectedUnit)
{
hoverUnit = null;
}
hoverIndicator.gameObject.SetActive(hoverUnit != null);
if (hoverUnit != null)
{
hoverIndicator.position = hoverUnit.transform.position;
}
if (Input.GetMouseButtonDown(0))
{
selectedUnit = hoverUnit;
if (selectedUnit != null)
{
GameManager.instance.audioSource.PlayOneShot(GameManager.instance.selection);
IntroManager.instance.OnSelectionMade();
}
}
selectionIndicator.gameObject.SetActive(selectedUnit != null);
if (selectedUnit != null)
{
selectionIndicator.position = selectedUnit.transform.position;
}
}
public void SelectedUnit(SelectableUnit selectedUnit)
{
if (!this.IsValidCommand(this.nextCommand))
{
Debug.LogWarningFormat(this, "{0} wont move. cause {1} has invalid command {2}", selectedUnit.name, this.name, nextCommand);
return;
}
SoldierController soldier = selectedUnit.GetComponent <SoldierController> ();
if (soldier != null)
{
if (soldier.Team != this.playerId)
{
return;
}
if (this.selectedUnit != null)
{
this.selectedUnit.Deselect();
}
this.selectedUnit = selectedUnit;
this.selectedUnit.Select();
this.gameManager.IssueCommandTo(this.playerId, soldier, this.nextCommand);
if (this.isNetworkedScene && messanger != null)
{
messanger.SendMessage(this.playerId.ToString() + "-" + soldier.id + "-" + this.nextCommand.ToString());
}
this.gameManager.EndTurn(this.playerId);
}
}
public void Run()
{
var input = reader.ReadLine();
ISoldierController soldierController = new SoldierController();
AmmunitionFactory ammunitionFactory = new AmmunitionFactory();
IOutputGiver outputGiver = new Output();
Army army = new Army();
IWareHouse wareHouse = new WareHouse();
SoldierFactory soldiersFactory = new SoldierFactory();
MissionFactory missionFactory = new MissionFactory();
MissionController missionController = new MissionController(army, wareHouse);
var gameController = new GameController(soldierController, soldiersFactory, ammunitionFactory, outputGiver, army, wareHouse, missionController, missionFactory);
var result = new StringBuilder();
while (!input.Equals("Enough! Pull back!"))
{
try
{
gameController.GiveInputToGameController(input);
}
catch (ArgumentException arg)
{
result.AppendLine(arg.Message);
}
input = reader.ReadLine();
}
gameController.RequestResult(result);
writer.WriteLine(result.ToString());
}
void Update()
{
// Only attempt to spawn when the user touches the screen
if (Input.touchCount <= 0)
{
return;
}
Touch touch = Input.GetTouch(0);
// Only attempt to spawn at the start of the touch
if (touch.phase == TouchPhase.Began)
{
// Determine the position of the touch on the plane
if (raycastManager.Raycast(touch.position, hits, UnityEngine.XR.ARSubsystems.TrackableType.PlaneWithinPolygon))
{
// Use the first hit's Pose
Pose pose = hits[0].pose;
// Instantiate a new soldier
int soldierIndex = Random.Range(0, soldierPrefabs.Length);
SoldierController newSoldier = Instantiate(soldierPrefabs[soldierIndex], pose.position, pose.rotation);
newSoldier.transform.Rotate(new Vector3(0, 180, 0));
soldiers.Add(newSoldier);
// If this soldier completes a pair, start the attack sequence
if (soldiers.Count % 2 == 0)
{
BeginAttack();
}
}
}
}
void Initialize()
{
actions = character.GetComponent <Actions> ();
controller = character.GetComponent <SoldierController> ();
foreach (SoldierController.Arsenal a in controller.arsenal)
{
CreateWeaponButton(a.name);
}
CreateActionButton("Stay");
CreateActionButton("Walk");
CreateActionButton("Run");
CreateActionButton("Sitting");
CreateActionButton("Jump");
CreateActionButton("Aiming");
CreateActionButton("Attack");
CreateActionButton("Damage");
CreateActionButton("Death Reset", "Death");
cameras = GameObject.FindObjectsOfType <Camera> ();
var sort = from s in cameras orderby s.name select s;
foreach (Camera c in sort)
{
CreateCameraButton(c);
}
camerasPanel.GetChild(0).GetComponent <Button>().onClick.Invoke();
}
// Use this for initialization
void Start()
{
controller = GetComponent <SoldierController>();
weapon = GetComponentInChildren <Weapon>();
agentState = controller.GetState();
targetState = agentState.enemyState;
}
void Start()
{
controller = GetComponent <SoldierController>();
InitTree();
Dispatcher.GetInstance().SendEvent(new ControllerInited(aiTools.agentState.side, GameDefines.ControllerType.BehaviorTree));
}
public bool CanMakeMove(SoldierController soldier, Direction movementDirection)
{
Vector2 soldierPos = soldier.Position;
Vector2 targetPos = GetTargetPos(soldierPos, movementDirection);
var targetTile = GetTile(targetPos);
return(targetTile != null && (targetTile.OccupiedBy == null || targetTile.OccupiedBy.Team != soldier.Team));
}
public void EndTurn(PlayerController pl)
{
foreach (var soldier in pl.Data.Soldiers)
{
SoldierController ctrl = soldier.GetComponent <SoldierController>();
ctrl.Data.ActionsRemaining = ctrl.Data.MaxActionsPerTurn;
}
}
public void SetTeam(TeamTag tag)
{
SoldierInterface.Tag = tag;
transform.parent.gameObject.tag = tag.ToString();
SelectInterface.ChangeColor(SoldierInterface.Tag);
targetContrl = null;
enemyTeamTag = SoldierInterface.Tag == TeamTag.BadGuy ? TeamTag.GoodGuy : TeamTag.BadGuy;
}
public bool Reset(bool isForce, bool smoothblend = true)
{
if (isForce)
{
isInit = false;
}
if (isInit)
{
return(true);
}
if (target == null)
{
return(false);
}
if (CurCameraProperty == null || CurCameraProperty.configType == 0)
{
CurCameraProperty = gameObject.GetComponent <CameraProperty>();
if (CurCameraProperty == null)// || soldierController == null || mouseCtrl==null)
{
Trace.LogError("摄像机获取CameraProperty组件");
return(false);
}
CurCameraProperty.SpeedScale = ASpeedGame.Data.GameSettingConfig.GameSettingConfig.Instance.GetGameSettingFloatValue(ASpeedGame.Data.GameSettingConfig.GameSettingIndex.CameraSpeed);
}
if (soldier == null || !soldier.gameObject || EntityFactory.MainHero == null)
{
return(false);
}
target.parent = null;
soldierController = EntityFactory.MainHero.GetComponent <SoldierController>();
mouseCtrl = EntityFactory.MainHero.GetComponent <MouseCtrl>();
if (!m_Camera)
{
m_Camera = Initialize.mainCam;
}
camTransform = m_Camera.transform;
if (camCtrl != null)
{
camCtrl.Reset(CurCameraProperty, smoothblend);
if (!smoothblend)
{
apprTran = m_userCurTran;
apprFov = m_userCurFov;
apprDistance = m_userCurDistance;
}
}
if (EntityFactory.MainHeroView != null && EntityFactory.MainHeroView.Property != null)
{
isInit = true;
return(true);
}
return(false);
}
public GameController(MissionController missionController, Output output)
{
this.Army = new Dictionary <string, List <Soldier> >();
this.WearHouse = new Dictionary <string, List <Ammunition> >();
this.MissionControllerField = missionController;
this.result = new StringBuilder();
this.output = output;
this.soldierController = new SoldierController();
}
public void DeleateSoldier(SoldierController soldier)
{
foreach (SoldierController sc in soldiers.ToArray())
{
if (soldier == sc)
{
soldiers.Remove(sc);
}
}
}
private void BeginAttack()
{
// Grab the two most recently created soldiers
SoldierController first = soldiers[soldiers.Count - 1];
SoldierController second = soldiers[soldiers.Count - 2];
// Tell them to attack each other
first.AttackSoldier(second);
second.AttackSoldier(first);
}
void Start()
{
aiTools = GetComponent <AiTools>();
controller = GetComponent <SoldierController>();
aiTools.Init();
aiTools.terrain.SetWeightsNormalizationEnabled(true);
Init();
Dispatcher.GetInstance().SendEvent(new ControllerInited(aiTools.agentState.side, GameDefines.ControllerType.FuzzyLogic));
}
public void Execute()
{
if (!Misc.isChecked(HarassMenu, "hsSoldiers"))
{
return;
}
var target = TargetSelector.GetTarget(1100, DamageType.Magical);
SoldierController.AutoPilot(Azir.AzirSoldiers, target);
}
// Use this for initialization
void Start()
{
controller = GetComponent <SoldierController>();
state = controller.GetState();
navMeshAgent = GetComponent <NavMeshAgent>();
floorMask = LayerMask.GetMask("Floor");
path = new NavMeshPath();
movementDestinationMarker = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
movementDestinationMarker.GetComponent <Collider>().enabled = false;
movementDestinationMarker.transform.localScale = new Vector3(0.4f, 2.0f, 0.4f);
}
public GameController()
{
this.army = new Dictionary <string, List <ISoldier> >();
this.wearHouse = new Dictionary <string, List <IAmmunition> >();
this.armyClass = new Army();
this.wareHouse = new WareHouse();
this.missionControllerField = new MissionController(armyClass, wareHouse);
this.ammoFactory = new AmmunitionFactory();
this.soldiersFactory = new SoldierFactory();
this.soldierController = new SoldierController();
this.missionFactory = new MissionFactory();
}
public bool SoldierUpdate(PlayerId team, SoldierController soldier, Vector2 nextPosition)
{
bool soldierOk = true;
var soldierPos = soldier.Position;
var enemy = this.logicalGrid.EncounterEnemy(team, nextPosition);
if (enemy != null)
{
int rnd = Random.Range(0, 10);
int winner = rnd % 2;
if (PlayerIdToInt(team) == winner)
{
enemy.Kill();
}
else
{
soldier.Kill();
soldierOk = false;
}
}
if (soldierPos.y == gridCreator.gridHeight && PlayerIdToInt(team) == 0)
{
teamBFinished = true;
}
else if (soldierPos.y == 0 && PlayerIdToInt(team) == 1)
{
teamAFinished = true;
}
// update game state
if (teamAFinished && teamBFinished)
{
currentGameState = GameState.Draw;
}
else if (teamAFinished)
{
currentGameState = GameState.TeamAWon;
}
else if (teamBFinished)
{
currentGameState = GameState.TeamBWon;
}
if (currentGameState != GameState.InProgress)
{
this.Finish();
}
return(soldierOk);
}
private bool CheckUnit(SoldierController unit)
{
bool result = false;
foreach (SoldierController soldier in unitSelected)
{
if (soldier == unit)
{
result = true;
}
}
return(result);
}
void Spawn()
{
for (int i = 0; i < number; i++)
{
float num = Random.Range(0, 125);
Vector3 pos = RandomCircle(this.transform.localPosition, num);
soldierList.Add(Instantiate(prefab, pos, this.transform.localRotation) as GameObject);
}
foreach (GameObject obj in soldierList)
{
SoldierController s = obj.GetComponent <SoldierController>();
soldierComponentList.Add(s);
}
}
public SoldierPathManager(SoldierController Soldier, ja2.TerrainTile[] Tiles)
{
ja2.TerrainTile previous = null;
// Move distance
ushort move_distance = 0;
// Last direction
ja2.Map.Direction last_direction = ja2.Map.Direction.NONE;
// Create action controller
soldierActions = new ja2.SoldierActionController(Soldier);
// Actual vertex
foreach (var tile in Tiles)
{
// Not first tile
if (previous != null)
{
// Get actual direction
ja2.Map.Direction dir = ja2.Map.GetDirection(previous, tile);
// Direction change
if (last_direction != dir)
{
// Queue move first if needed
if (move_distance > 0)
{
var action = new ja2.SoldierActionMove(move_distance);
soldierActions.Add(action);
move_distance = 0;
}
// Set rotation
soldierActions.Add(new ja2.SoldierActionRotate(ja2.LookDirectionConverter.Convert(dir)));
}
// byte rot = (byte)ja2.LookDirectionConverter.Convert(dir);
// Must be move
++move_distance;
// Update last direction
last_direction = dir;
}
// Update previous tile
previous = tile;
}
// Queue move if was any
if (move_distance != 0)
{
var action = new ja2.SoldierActionMove(move_distance);
soldierActions.Add(action);
}
}
