// Init and spawn anything in preperation for update job state
public override bool OnStartJob()
{
// Clean up old inventories if they are currently open ( This may need adjusting given multiple inventories could be accessed on the same tick )
GameController.Instance.crewTargetDirection.ForceCleanupMenu();
GameController.Instance.crewTargetDirection.ForceCleanUpInventories();
if (directedToTarget & character)
{
character.inventory.SetOpen(true);
// Clean up opened DIRECTED TO inventory panel ON ARRIVAL JOB
switch (directedToTarget.TargetSelectionProfile.selectionType)
{
case SelectionType.Character:
SelectableCharacter character = directedToTarget as SelectableCharacter;
character.inventory.SetOpen(true);
break;
case SelectionType.Container:
SelectableContainer container = directedToTarget as SelectableContainer;
container.container.SetOpen(true);
break;
}
return(true);
}
return(false);
}
public void SetCharacter(SelectableCharacter selectableCharacter)
{
foreach (SelectableCharacter character in selectableCharacters)
{
character.go.SetActive(character == selectableCharacter);
}
}
internal void SetTargetCharacter(SelectableCharacter character)
{
playerSelectionTargetUI.transform.position = character.transform.position;
playerSelectionUI.ChangeToSelectedCharacter(character);
targetCharacter = character;
canSelect = false;
remainingTimeBeforeNextSelectionMoveIsAllowed = SELECTIONTIMER;
}
/// <summary>
/// Возвращает ближайшего к myChar персонажа типа SelectableCharacter
/// путем перебора сначала по близости на оси X, а затем выбирая ближайшего из них по оси Z
/// </summary>
/// <param name="myChar"></param>
/// <returns></returns>
SelectableCharacter FindClosestEnemy(SelectableCharacter myChar)
{
float closestEnemyDistanceX = Mathf.Infinity; // приравняли в рекорд бесконечность
SelectableCharacter closestEnemy = null; // приравняли что нету клозеста
List <SelectableCharacter> closestEnemiesByX = new List <SelectableCharacter>(); //массив перебора ближайших по Х
var otherCharacters = FindObjectsOfType <SelectableCharacter>(); //найдем всех персонажей
foreach (SelectableCharacter otherChar in otherCharacters)
{
if (otherChar.characterSheet.teamId == myChar.characterSheet.teamId) //пропускаем персонажей своей команды
{
continue;
}
var newAttackVector = (otherChar.gameObject.transform.position - myChar.gameObject.transform.position); //получим вектор направленный от нашего персонажа на врага - на того которого мы перебираем
var distance = Mathf.Abs(Mathf.Round(newAttackVector.x)); //дистанция до перебираемого врага. мы ещё и округляем
if (distance < closestEnemyDistanceX) //наиболее близкого запишем
{
closestEnemiesByX.Clear(); //очистим список ближайших
closestEnemyDistanceX = distance; //наименьшая дистанция по X теперь такая
closestEnemy = otherChar; //ближайший враг
closestEnemiesByX.Add(otherChar); //он лишь один среди ближайших по оси Х
}
else if (distance == closestEnemyDistanceX)
{
closestEnemiesByX.Add(otherChar); //другие враги столь же близкие по оси Х добавляем в массив
}
}
Debug.Log("Число врагов в ближайшем не пустом ряду " + closestEnemiesByX.Count);
var closestEnemyDistanceZ = Mathf.Infinity;
//найдем ближайнего по Z из тех, кто в ближайшем непустом ряду по X
foreach (var enemy in closestEnemiesByX)
{
var newAttackVector = (enemy.gameObject.transform.position - myChar.gameObject.transform.position);
float distance = Mathf.Abs(newAttackVector.z);
if (distance <= closestEnemyDistanceZ)
{
closestEnemyDistanceZ = distance;
closestEnemy = enemy;
}
}
return(closestEnemy);
}
public void OnCharacterPointerExited(SelectableCharacter clickedCharacter)
{
var selectedAbility = abilityBar.getSelectedAbility();
if (selectedAbility != null)
{
selectedAbility.DisableAimingEffect();
}
}
bool CanBeAppliedDistanceCheck(SelectableCharacter myChar, SelectableCharacter targetChar) //Проверка применяемости по дистанции
{
bool result = false;
switch (distanceType)
{
case DISTANCE_TYPE.MELEE:
result = true;
var attackVector = (targetChar.gameObject.transform.position - myChar.gameObject.transform.position);
var distance = attackVector.magnitude;
if (distance <= MaxUseDistance)
{
//Если цель находится в радиусе, значит можем бить всегда
//Debug.Log("Can attack in radius " + distance);
}
else
{
var onTheWay = AllyOnTheWay(myChar);
if (onTheWay == true)
{
result = false;
}
else
{
//Если цель делеко, то проверим, нет ли кого-то ближе
var closestEnemy = FindClosestEnemy(myChar);
if (closestEnemy != targetChar)
{
result = false;
if (Mathf.Round(closestEnemy.transform.position.x) == Mathf.Round(targetChar.transform.position.x))
{
if (Mathf.Abs(targetChar.transform.position.z - myChar.transform.position.z) <= MaxUseDistance)
{
result = true;
}
}
//Debug.LogWarning("Can't attack, closest enemy is " + closestEnemy.gameObject.name);
}
}
}
break;
case DISTANCE_TYPE.RANGED:
result = true;
break;
case DISTANCE_TYPE.MAGICAL:
result = true;
break;
}
return(result);
}
public void SetTarget(SelectableTarget currentTarget)
{
// Disable character target line renderer
if (this.currentTarget != null)
{
// Destroy the old selection world radial menu
if (WorldUIRadial.Instance != null)
{
Destroy(WorldUIRadial.Instance.gameObject);
}
switch (this.currentTarget.TargetSelectionProfile.selectionType)
{
case SelectionType.Character:
{
SelectableCharacter character = (SelectableCharacter)(this.currentTarget);
character.pathTracer.SetNavPathTrace(false);
character.inventory.SetOpen(false);
}
break;
case SelectionType.Container:
{
SelectableContainer container = (SelectableContainer)(this.currentTarget);
container.container.SetOpen(false);
}
break;
}
GameController.Instance.crewTargetDirection.ForceCleanupMenu();
GameController.Instance.crewTargetDirection.ForceCleanUpInventories();
}
// Set the new target
this.currentTarget = currentTarget;
// If character, turn on line renderer
// Disable character target line renderer
if (this.currentTarget != null)
{
WorldUIRadial radialMenu = Instantiate(worldUIMenuPrefab, GameController.Instance.selectionDisplay.transform).GetComponent <WorldUIRadial>();
radialMenu.Init(currentTarget);
switch (this.currentTarget.TargetSelectionProfile.selectionType)
{
case SelectionType.Character:
{
((SelectableCharacter)(this.currentTarget)).pathTracer.SetNavPathTrace(true);
}
break;
}
}
}
public bool DoTargetSearch(Vector3 WSMousePos, SelectableCharacter selectedDirecting)
{
ForceCleanupMenu();
this.selectedDirecting = selectedDirecting;
Vector2 mousePos2D = new Vector2(WSMousePos.x, WSMousePos.y);
RaycastHit2D[] hits = Physics2D.RaycastAll(mousePos2D, Vector2.zero);
targets = new List <SelectableTarget>();
bool clicked = false;
if (hits.Length > 0)
{
foreach (RaycastHit2D hit in hits)
{
// Check hit targets for selectables
SelectableTarget targetCandidate = hit.collider.GetComponent <SelectableTarget>();
if (targetCandidate != GameController.Instance.targetSelection.CurrentTarget)
{
if (targetCandidate != null)
{
// Add candidate to new track list
if (targetCandidate.TargetSelectionProfile.selectionType == SelectionType.Character || targetCandidate.TargetSelectionProfile.selectionType == SelectionType.Container)
{
clicked = true;
targets.Add(targetCandidate);
}
}
}
}
// Found containers and characters to add as direction options
if (targets.Count > 0)
{
// Open details options menu
directionOptionsPanel = GameController.Instance.panelController.AddPanel(PanelType.DirectionOptions, "Interact with");
directionOptionsPanel.transform.position = Input.mousePosition;
Vector3 screenPos = GameController.Instance.mainCamera.WorldToScreenPoint(targets[0].transform.position);
((DirectionOptionsMenu)directionOptionsPanel).InitMenu(targets);
}
}
return(clicked);
}
private void SetUpHotbar(SelectableCharacter character, GameObject hotbar)
{
Button[] buttons = hotbar.GetComponentsInChildren <Button>();
buttons[0].onClick.AddListener(delegate {
ButtonTask(character, 0);
});
buttons[1].onClick.AddListener(delegate {
ButtonTask(character, 1);
});
buttons[2].onClick.AddListener(delegate {
ButtonTask(character, 2);
});
}
// Update is called once per frame
void Update()
{
if (selectManager.GetNumSelected() == 1)
{
hotbar.SetActive(true);
GameObject currHotbar = null;
SelectableCharacter currChar = null;
if (meleeChar != null && meleeChar.GetSelected())
{
currHotbar = meleeHotbar;
currChar = meleeChar;
rangedHotbar.SetActive(false);
}
else if (rangedChar != null && rangedChar.GetSelected())
{
currHotbar = rangedHotbar;
currChar = rangedChar;
meleeHotbar.SetActive(false);
}
if (currChar != null && currHotbar != null)
{
currHotbar.SetActive(true);
Ability[] abilities = currChar.GetAbilities();
for (int i = 0; i < abilities.Length; i++)
{
Ability ability = abilities[i];
if (ability.Cooldown() > 0)
{
GameObject abilityCd = currHotbar.transform.GetChild(i).GetChild(0).gameObject;
abilityCd.SetActive(true);
abilityCd.transform.GetComponentInChildren <Text>().text = ability.Cooldown() + "";
}
else
{
currHotbar.transform.GetChild(i).GetChild(0).gameObject.SetActive(false);
}
}
}
else
{
hotbar.SetActive(false);
}
}
else
{
hotbar.SetActive(false);
}
}
protected override void Process(IClient client, CListEnd packet)
{
LoginOption option = client.GetOption <LoginOption>();
SelectableCharacter character = option.SelectableCharacters.FirstOrDefault(x => option.CharacterSelector.Invoke(x));
if (character == null)
{
Logger.Error("Can't found character matching predicate");
return;
}
client.SendPacket($"select {character.Slot}");
Logger.Debug($"Character {character.Name} selected");
}
bool CanBeAppliedDistanceCheck(SelectableCharacter myChar, SelectableCharacter targetChar)
{
bool result = false;
var distance = (myChar.gameObject.transform.position - targetChar.gameObject.transform.position).magnitude;
if (distance <= MaxUseDistance)
{
switch (distanceType)
{
case DISTANCE_TYPE.MELEE:
result = true;
var rayStart = myChar.GetComponent <Collider>().bounds.center;
var ray = new Ray(rayStart, targetChar.GetComponent <Collider>().bounds.center - rayStart);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo, MaxUseDistance))
{
Debug.DrawLine(ray.origin, hitInfo.point, Color.red, 1.0f);
if (hitInfo.collider.gameObject == targetChar.gameObject)
{
result = true;
}
else
{
result = false;
Debug.Log(myChar.name + "CAN'T perform MELEE attack to " + targetChar.name + " due to occlusion");
}
}
else
{
Debug.DrawRay(ray.origin, ray.direction, Color.green, 1.0f);
}
break;
case DISTANCE_TYPE.RANGED:
result = true;
break;
case DISTANCE_TYPE.MAGICAL:
result = true;
break;
}
}
else
{
Debug.Log(myChar.name + "CAN'T perform attack to " + targetChar.name + " due to DISTANCE: " + distance + ">" + MaxUseDistance);
result = false;
}
return(result);
}
private void SetUp()
{
boxStartPosition = Vector3.zero;
boxEndPosition = Vector3.zero;
selectableChars = FindObjectsOfType <SelectableCharacter>();
if (selectableChars[0].GetComponent <RangedPlayerScript>() != null)
{
SelectableCharacter temp = selectableChars[0];
selectableChars[0] = selectableChars[1];
selectableChars[1] = temp;
}
mainCamera = Camera.main;
mainCameraScript = mainCamera.GetComponent <CameraScript>();
numSelected = 0;
overButton = false;
}
public void UseAbility(ref Ability ability, SelectableCharacter targetCharacter) //ссылка на конкретную применяемую абилку, потом пишем когда надо - если что-то то юз абилити
{
if (ability == null || string.IsNullOrEmpty(ability.name)) // если абюилки нет или её имя не задано
{
Debug.LogWarning("No ability was selected to use", gameObject); // то тогда сообщение об ошибке
return;
}
if (targetCharacter == null)
{
Debug.LogWarning("No targetCharacter was selected to use onto", gameObject);
return;
}
Debug.Log(name + " used ability " + ability.name + " on " + targetCharacter.name, this);
ability.ApplyEffectTo(targetCharacter.gameObject);
}
public void OnCharacterPointed(SelectableCharacter pointedCharacter)
{
Debug.Log("pointed " + pointedCharacter.name);
var selectedAbility = abilityBar.getSelectedAbility();
if (selectedAbility != null)
{
if (selectedAbility.CanBeAppliedTo(pointedCharacter.gameObject))
{
//Debug.Log("abilityBar.selectedAbility " + abilityBar.getSelectedAbility().name + " CAN be applied to " + pointedCharacter.name);
selectedAbility.CreateAimingEffect(pointedCharacter.gameObject);
}
else
{
Debug.Log("abilityBar.selectedAbility " + abilityBar.getSelectedAbility().name + " CAN'T be applied to " + pointedCharacter.name);
}
}
}
public void OnCharacterWasClicked(SelectableCharacter clickedCharacter)
{
//Debug.Log("OnCharacterWasClicked "+character);
if (clickedCharacter.characterSheet.teamId == 0)
{
selectedCharacter = clickedCharacter;
Debug.Log("selectedCharacter: " + selectedCharacter, selectedCharacter);
}
else
{
if (selectedCharacter != null)
{
var ability = abilityBar.getSelectedAbility();
selectedCharacter.UseAbility(ref ability, clickedCharacter);
}
}
}
void ShowAbilityBar(SelectableCharacter character)
{
if (abilityBar == null)
{
Debug.LogError("abilityBar was not set properly!", gameObject);
enabled = false;
return;
}
if (character != null)
{
abilityBar.gameObject.SetActive(true);
abilityBar.ShowAbilities(character.abilities);
}
else
{
abilityBar.gameObject.SetActive(false);
}
}
bool AllyOnTheWay(SelectableCharacter myChar)
{
bool allyOnTheWay = false;
var otherCharacters = FindObjectsOfType <SelectableCharacter>(); //найдем всех персонажей
foreach (SelectableCharacter otherChar in otherCharacters)
{
if (otherChar.characterSheet.teamId == myChar.characterSheet.teamId)
{
var oneStep = myChar.transform.position.x + 0.1f;
if (otherChar.transform.position.x >= oneStep)
{
allyOnTheWay = true;
break;
}
}
}
return(allyOnTheWay);
}
public void OnCharacterWasClicked(SelectableCharacter clickedCharacter) //При клике на чара если он в нашей тиме то селектед станеи им
{
//Debug.Log("OnCharacterWasClicked "+character);
if (clickedCharacter.characterSheet.teamId == 0)
{
selectedCharacter = clickedCharacter;
Debug.Log("selectedCharacter: " + selectedCharacter, selectedCharacter);
}
else
{
if (selectedCharacter != null)
{
var ability = abilityBar.getSelectedAbility();
if (ability.CanBeAppliedTo(clickedCharacter.gameObject))
{
selectedCharacter.UseAbility(ref ability, clickedCharacter);
}
}
}
}
bool CanBeAppliedTypeCheck(SelectableCharacter myChar, SelectableCharacter targetChar) //Проверка применяемости по типу (враги-союзники)
{
switch (targetType)
{
case TARGET_TYPE.ALL:
return(true);
case TARGET_TYPE.ALLIES:
if (myChar != null && myChar.characterSheet.teamId == targetChar.characterSheet.teamId)
{
return(true);
}
return(false);
case TARGET_TYPE.FOES:
if (myChar != null && myChar.characterSheet.teamId != targetChar.characterSheet.teamId)
{
return(true);
}
return(false);
case TARGET_TYPE.SELF:
if (myChar == targetChar)
{
return(true);
}
return(false);
case TARGET_TYPE.OBJECTS:
if (targetChar == null)
{
return(true);
}
return(false);
}
return(true);
}
public void UseAbility(ref Ability ability, SelectableCharacter targetCharacter)
{
if (ability == null || string.IsNullOrEmpty(ability.name))
{
Debug.LogWarning("No ability was selected to use", gameObject);
return;
}
if (targetCharacter == null)
{
Debug.LogWarning("No targetCharacter was selected to use onto", gameObject);
return;
}
Debug.Log(name + " used ability " + ability.name + " on " + targetCharacter.name, this);
//if (ability.effectPrefab != null)
//{
// GameObject.Instantiate(ability.effectPrefab, targetCharacter.transform);
//}
ability.ApplyEffectTo(targetCharacter.gameObject);
}
public void ForceCleanUpInventories()
{
if (directedTo.Count > 0)
{
foreach (SelectableTarget directables in directedTo)
{
// Clean up opened DIRECTED TO inventory panel
switch (directables.TargetSelectionProfile.selectionType)
{
case SelectionType.Character:
SelectableCharacter character = directables as SelectableCharacter;
character.inventory.SetOpen(false);
break;
case SelectionType.Container:
SelectableContainer container = directables as SelectableContainer;
container.container.SetOpen(false);
break;
}
}
}
}
public void TryOpenSelection()
{
SelectableTarget currentTarget = GameController.Instance.targetSelection.CurrentTarget;
if (currentTarget != null)
{
switch (currentTarget.TargetSelectionProfile.selectionType)
{
case SelectionType.Character:
{
SelectableCharacter character = (SelectableCharacter)currentTarget;
character.inventory.SetOpen(true);
}
break;
case SelectionType.Container:
{
SelectableContainer container = (SelectableContainer)currentTarget;
container.container.SetOpen(true);
}
break;
}
}
}
// Update is called once per frame
void Update()
{
bool overBar;
Panel panelHover = GameController.Instance.panelController.TestOverPanel(out overBar);
if (panelHover != null)
{
panelHover.OnPanelHover();
}
// Left click try and select target
if (Input.GetMouseButtonDown(0))
{
// hoverring main panel and clicked, bring to front
if (panelHover != null)
{
GameController.Instance.panelController.BringToFront(panelHover);
if (overBar) // Clicked a drag bar of panel
{
GameController.Instance.panelController.StartDrag();
}
else // Clicked a window of panel
{
panelHover.OnPanelClick();
}
}
else
{
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
if (!GameController.Instance.selectionDisplay.TestSelectionButtons()) // Test if clicked selection buttons
{
// Test if clicked radial menu
bool radialClicked = false;
WorldUIRadial radialMenuCandidate = WorldUIRadial.Instance;
if (radialMenuCandidate != null)
{
radialClicked = radialMenuCandidate.TestWorldClickButtons();
}
if (!radialClicked)
{
GameController.Instance.targetSelection.DoTargetSearch(mousePos);
}
}
}
}
if (!Input.GetMouseButton(0))
{
GameController.Instance.panelController.ForceStopDrag();
}
// Left mouse button UP do release logic on target window
if (Input.GetMouseButtonUp(0))
{
// hoverring main panel and released, bring to front
if (panelHover != null)
{
GameController.Instance.panelController.BringToFront(panelHover);
if (!overBar) // Released on main window, not bar
{
panelHover.OnPanelReleaseClick();
}
}
}
// Right click, direct selected character to target location
if (Input.GetMouseButtonDown(1))
{
SelectableTarget currentTarget = GameController.Instance.targetSelection.CurrentTarget;
if (currentTarget != null)
{
switch (currentTarget.TargetSelectionProfile.selectionType)
{
case SelectionType.Character:
{
SelectableCharacter character = (SelectableCharacter)currentTarget;
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
if (!GameController.Instance.crewTargetDirection.DoTargetSearch(mousePos, character))
{
character.playerCrewAI.NavToMouse();
}
}
break;
}
}
}
}
public JobOpenTransferInventoriesDirection(string name, params object[] requiredObjects) : base(name, requiredObjects)
{
character = requiredObjects[0] as SelectableCharacter;
directedToTarget = requiredObjects[1] as SelectableTarget;
}
internal void ChangeToSelectedCharacter(SelectableCharacter character)
{
//Debug.Log(this.name + ": Changing to selected character - " + character.name);
sr.sprite = character.GetComponent <SpriteRenderer>().sprite;
}
internal void SetTargetCharacter(SelectableCharacter character)
{
transform.position = character.transform.position;
}
private void ButtonTask(SelectableCharacter character, int abilityIndex)
{
character.HotbarClicked();
character.PrepareAbility(abilityIndex);
}
internal void SelectCharacter(SelectableCharacter selectedCharacter)
{
this.playerSelectableCharacter = selectedCharacter;
this.SessionId = dataContext.CreateSession(selectedCharacter.CharacterId);
}
