public void UpdateHealth(UnitView unit, float health)
{
if (unit == this.unit)
{
ui.SetHealth(health);
}
}
public void OnHitHandler(UnitView unitView, int damage)
{
fortModel.CurrentHealth -= damage;
fortViewUi.SetupCurrentHealth(fortModel.CurrentHealth);
float destrVal = (1f - (fortModel.CurrentHealth / (float)fortModel.MaxHP));
if (destrVal > 0.9f)
{
fortView.SetFortState(FortModel.DestructionState.Major);
}
else if (destrVal > 0.6f)
{
fortView.SetFortState(FortModel.DestructionState.Minor);
}
else if (destrVal > 0.3f)
{
fortView.SetFortState(FortModel.DestructionState.Low);
}
if (fortModel.CurrentHealth <= 0)
{
OnFortDestroyed();
}
}
public AttackState(UnitView owner, UnitView target, float attackSpeed, int attackValue)
{
this.owner = owner;
this.target = target;
this.attackSpeed = attackSpeed;
this.attackValue = attackValue;
}
private void DetectEnemyUnits()
{
Collider[] targetsInViewRadius = Physics.OverlapSphere(transform.position, m_viewRadius, m_targetMask);
List <UnitView> enemies = new List <UnitView>();
for (int i = 0; i < targetsInViewRadius.Length; i++)
{
Transform target = targetsInViewRadius[i].transform;
Vector3 dirToTarget = (target.position - transform.position).normalized;
if (Vector3.Angle(transform.forward, dirToTarget) < m_viewAngle * 0.5f)
{
float distToTarget = Vector3.Distance(transform.position, target.position);
if (!Physics.Raycast(transform.position, dirToTarget, distToTarget, m_obstacleMask))
{
UnitView unit = targetsInViewRadius[i].GetComponent <UnitView>();
if (!unit.PhotonView.isMine)
{
enemies.Add(unit);
}
}
}
}
//Send Combat Encounter To Combat Manager
if (enemies.Count != 0)
{
GameManager.Instance.CombatManager.CreateCombatEncounter(m_unitView, enemies);
}
}
public IActionResult UnitDetails(int id)
{
var unit = new UnitView();
var url = "https://localhost:44354/api/unit/get/" + id;
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.Method = "GET";
var response = httpWebRequest.GetResponse();
{
string responseData;
Stream responseStream = response.GetResponseStream();
try
{
StreamReader streamReader = new StreamReader(responseStream);
try
{
responseData = streamReader.ReadToEnd();
}
finally
{
((IDisposable)streamReader).Dispose();
}
}
finally
{
((IDisposable)responseStream)?.Dispose();
}
unit = JsonConvert.DeserializeObject <UnitView>(responseData);
}
return(View(unit));
}
public void Init(GameStateUpdateService updateService, LevelService levelService, Transform parent, UnitLevelModel model, UnitView view, Canvas canvas)
{
_updateService = updateService;
_levelService = levelService;
_model = model;
_view = view;
_oldHealth = _model.State.Health;
_levelService.OnUnitSelected += OnUnitSelected;
_levelService.OnUnitCanTurn += OnUnitCanTurn;
_updateService.OnStateUpdated += OnStateUpdated;
_updateService.AddHandler <AttackCommand>(OnAttackUnit);
_updateService.AddHandler <KillUnitCommand>(OnKillUnit);
SelectView();
UpdateSelection(false);
UpdateInteractable(model.IsPlayerUnit);
UpdateHealth();
transform.SetParent(parent, false);
_view.transform.SetParent(canvas.transform, false);
_view.transform.position = Camera.main.WorldToScreenPoint(transform.position);
var distance = transform.position.z - Camera.main.transform.position.z;
_view.UpdateDistance(distance);
_view.SelectColor(model.IsPlayerUnit);
}
private void TurnOnUnitID(UnitView unitView)
{
if (unitView == m_unitView)
{
m_unitID.enabled = true;
}
}
// --------------------------------------------------------------------------------------------
private void OnPointerUp(object sender, EventSystemEventArgs e)
{
bool upOnUnitView = false;
PointerEventData pointerEventData = e.eventData as PointerEventData;
if (Time.time - _potentialSelectedUnitTime < SelectUnitTimeLimit && _potentialSelectedUnitView != null)
{
// if we have no potential selected unit yet, try to find one
Ray ray = _game.gameCamera.ScreenPointToRay(pointerEventData.position);
if (Physics.Raycast(ray, out RaycastHit hit))
{
// if pointer up is called and we hit same potential selected unit, then we've selected that unit!
UnitView view = hit.collider.GetComponentInParent <UnitView>();
if (view != null && view == _potentialSelectedUnitView)
{
foreach (IListener listener in _listeners)
{
listener.OnSelectedUnitView(view);
}
upOnUnitView = true;
}
}
}
if (!upOnUnitView)
{
foreach (IListener listener in _listeners)
{
listener.OnReleasedBoard(pointerEventData.position);
}
}
_potentialSelectedUnitView = null;
}
//If We're not moving we assume we're attacking
public void ShowActionTiles(UnitAction unitAction)
{
m_unitView = unitAction.unit;
HideActionTiles(m_unitView);
Vector3 unitPosition = unitAction.unit.transform.position;
m_activatedTiles.Clear();
int unitX = Mathf.RoundToInt(unitPosition.x);
int unitY = Mathf.RoundToInt(unitPosition.z);
int actionRange = unitAction.isMoving ? m_unitView.UnitData.movementRange : m_unitView.UnitData.weapon.weaponRange;
for (int x = -actionRange; x <= actionRange; x++)
{
for (int y = -actionRange; y <= actionRange; y++)
{
if (x == 0 && y == 0)
{
continue;
}
if (Mathf.Abs(x) + Mathf.Abs(y) > actionRange)
{
continue;
}
int xPos = unitX + x;
int yPos = unitY + y;
Vector3 worldPoint = new Vector3(xPos, 0, yPos);
if (IsPositionWithinBoard(xPos, yPos))
{
bool actionable = !(Physics.CheckSphere(worldPoint, 0.4f, unitAction.collisionMask));
if (unitAction.isMoving)
{
if (actionable)
{
PathRequestManager.RequestPath(unitPosition, new Vector3(xPos, 0, yPos), OnPathFound);
}
}
else if (!unitAction.isMoving)
{
actionable = !actionable; //Reverse collision bool as we're looking for tiles with animals
if (actionable)
{
m_tileGrid[xPos, yPos].SetActive(true);
m_activatedTiles.Add(m_tileGrid[xPos, yPos]);
}
}
}
}
}
}
//修改层信息
public ActionResult EditUnit(string id)
{
var model = new UnitView();
var m = unitSer.FirstOrDefault(x => x.U_ID == id);
model.CopyFrom(m);
return(View(model));
}
public Unit(UnitData data, UnitView view)
{
Data = data;
View = view;
Damagable = new Damagable {
CurrentHealth = data.Health
};
}
private void Start()
{
Debug.Log("_model prefabPath " + _model.prefabPath);
App.AssetManager.Load(_model.prefabPath, (bool successful, GameObject payload) =>
{
_view = Instantiate(payload, transform, false).GetComponent <UnitView>();
});
}
//
// GET: /Unit/
public ActionResult Details(string id)
{
var model = unitSer.Find(id);
var viewModel = new UnitView();
viewModel.CopyFrom(model);
return(View(viewModel));
}
private void Awake()
{
UnitView.Preload();
_battle = new Battle(_unitContainer);
_button.onClick.AddListener(GameStart);
GameStart();
}
public void HideActionTiles(UnitView unitView)
{
if (m_unitView == unitView)
{
for (int i = 0; i < m_activatedTiles.Count; i++)
{
m_activatedTiles[i].SetActive(false);
}
}
}
private void Start()
{
m_unitView = transform.parent.GetComponent <UnitView>();
m_unitID = GetComponent <SpriteRenderer>();
PlayerInteraction.SelectedUnit += TurnOnUnitID;
PlayerInteraction.DeselectedUnit += TurnOffUnitID;
TurnOffUnitID();
}
private void CancelSelection()
{
if (m_selectedUnitTransform != null)
{
m_selectedUnitTransform = null;
m_selectedUnitView = null;
this.enabled = true;
}
}
private IUnitView SpawnUnit(UnitView view, Vector3 position)
{
IUnitView unit = _unit_factory.Create(view);
unit.SetPosition(position);
unit.Initialize();
_location_model.AddUnit(unit);
return(unit);
}
public void InitializeUnit(BattleUnit Target)
{
mCurrentHealth = StartingHealth;
mCurrentSquadSize = StartingUnitsInSquad;
mCurrentAttackCD = 0;
mTarget = Target;
transform.position = StartingPosition;
mUI = GetComponent <UnitView>();
mUI.Setup(mCurrentSquadSize);
StartFight();
}
private void SpawnUnit(TeamFlag flag, UnitInfo info, int x, int y)
{
if (_grid[x, y] != null)
{
throw new ArgumentException($"Supplied coords ({x},{y}) already taken");
}
var view = UnitView.Create(flag, _container);
var unit = new Unit(flag, info, view, this);
PlaceUnit(unit, x, y);
_units.Add(unit);
}
private void GetFocusedRowData(int index)
{
if (index >= 0 && UnitView.RowCount > 0)
{
UnitView.FocusedRowHandle = index;
btnSave.Enabled = false;
btnAddNew.Enabled = btnModify.Enabled = true;
txtUnitCode.Text = UnitView.GetRowCellValue(index, UnitManager.UnitDetails.UnitCode.ToString()).ToString();
txtUnitName.Text = UnitView.GetRowCellValue(index, UnitManager.UnitDetails.UnitName.ToString()).ToString();
CategorySearch.EditValue = UnitView.GetRowCellValue(index, UnitManager.UnitDetails.catCode.ToString()).ToString();
}
}
void OnEnable()
{
unitView = GetComponent <UnitView>();
turnController = FindObjectOfType <TurnController>();
turnController.onTurnEnded += RefreshMovement;
if (location)
{
transform.localPosition = location.Position;
Grid.IncreaseVisibility(location, visionRange);
}
}
private static EnemyMovement InitComponents(GameObject instance, Unit unit)
{
EnemyController enemyController = instance.GetComponent <EnemyController>();
EnemyMovement enemyMovement = instance.GetComponent <EnemyMovement>();
EnemyHealth enemyHealth = instance.GetComponent <EnemyHealth>();
UnitView unitView = instance.GetComponent <UnitView>();
enemyController.Init(unit);
enemyMovement.Init(unit);
enemyHealth.Init(unit);
unitView.Init(unit);
return(enemyMovement);
}
//添加层信息
public ActionResult AddUnit(UnitView model)
{
if (!ModelState.IsValid)
{
return(WriteStatusError(ModelState));
}
Unit modelUnit = new Unit();
model.CopyFrom(model);
unitSer.Add(modelUnit);
modelUnit.U_ID = Guid.NewGuid().ToString();
unitSer.SaveChanges();
return(WriteSuccess("添加成功"));
}
private void SetUnitInfo(UnitView unit)
{
m_currentUnit = unit;
unitNameText.text = m_currentUnit.UnitData.unitName;
//Set Delegates
moveActionButton.onClick.AddListener(delegate { m_currentUnit.UnitMovement.MovementInit(); });
attackActionButton.onClick.AddListener(delegate { m_currentUnit.UnitAttack.AttackInit(); });
m_currentUnit.UnitMovement.UnitMoving += TurnOffUIUnitInfo;
m_currentUnit.UnitMovement.UnitStoppedMoving += TurnOnUIUnitInfo;
TurnOnUIUnitInfo();
}
public override void ReceiveDamage(UnitView sender, int dmg)
{
base.ReceiveDamage(sender, dmg);
try
{
GameObject splash = SplashPool.Instance.GetSplash();
splash.transform.parent = transform;
splash.transform.localPosition = Vector3.zero;
}
catch (MissingReferenceException ex)
{
Debug.Log(ex.StackTrace);
}
}
public Unit(TeamFlag team, UnitInfo info, UnitView view, Battle battle)
{
Team = team;
_info = info;
Health = MaxHealth;
Mana = 0;
_logic = UnitLogicFactory.Create(info, this, battle);
View = view;
_battle = battle;
_state = State.Spawn;
}
private void SelectUnit(RaycastHit unit)
{
m_selectedUnitTransform = unit.transform;
m_selectedUnitView = m_selectedUnitTransform.GetComponent <UnitView>();
if (m_selectedUnitView.PhotonView.isMine)
{
m_selectedUnitView.UnitBehaviour.TurnAction(m_playerView, CancelSelection, CancelSelection);
if (TurnManager.GetTurnPhase == TurnManager.TurnPhase.Movement || TurnManager.GetTurnPhase == TurnManager.TurnPhase.Shooting)
{
this.enabled = false;
}
}
}
public static UnitView CreateUnitView(Transform parent, MapView mapView, Unit unit, string prefabName)
{
var unitPrefab = Resources.Load <UnitView>("Units/" + prefabName);
if (unitPrefab == null)
{
Debug.LogError("Can't load unit " + prefabName);
return(null);
}
UnitView unitView = Instantiate(unitPrefab);
unitView.gameObject.SetActive(true);
unitView.transform.parent = parent;
unitView.Init(unit, mapView.CellCoordToPosition(unit.Coordinate));
return(unitView);
}
private void OnHitHandler(UnitView sender, int damage)
{
enemyModel.Health -= damage;
if (enemyModel.Health < 90)
{
if (enemyView != null)
{
OnDie(enemyView.gameObject);
enemyView.DieState();
if (sender != null)
{
sender.Kill(enemyModel.ExpForKill);
}
}
}
}
public UnitTreeLister(
ICommandService commandService,
IControlHostService controlHostService,
IContextRegistry contextRegistry,
ISettingsService settings,
TextEditing.TextEditor textEditor
)
: base(commandService)
{
m_controlHostService = controlHostService;
m_contextRegistry = contextRegistry;
this.settings = settings;
this.TreeControl.ImageList = ResourceUtil.GetImageList16();
TreeView = new UnitView();
}
