protected virtual void CommandUnits(List<Unit> units, UnitCommand command, params object[] args)
{
for (int i = 0; i < units.Count; i++)
{
command(units[i], args);
}
}
public void ExecuteUnitCommand()
{
UnitCommand unitCommand = unitCommandsToExecute.Dequeue();
unitCommand.Execute();
unitCommandsExecuted.Enqueue(unitCommand);
}
public virtual void AttackMove()
{
setRunning(true);
unitScript.unitTargetScript.UpdateTarget();
if(unitScript.unitTargetScript.attackTarget) {
previousCommand = unitScript.currentCommand;
unitScript.currentCommand = UnitCommand.Attack;
return;
}
if(unitScript.movementScript.followTarget == null) {
if(unitScript.movementScript.hasReachedDestination(unitScript.spreadDistance / 2.0f)) {
unitScript.unitTargetScript.resetTarget();
unitScript.currentIdleTime = 0.0f;
unitScript.movementScript.UpdateDestination(unitScript.newIdlePosition(unitScript.unitGroupScript.transform.position, unitScript.spreadDistance));
unitScript.currentCommand = UnitCommand.Idle;
}
} else {
if(unitScript.movementScript.isWithinGroupRange()) {
unitScript.unitTargetScript.resetTarget();
unitScript.currentIdleTime = 0.0f;
unitScript.movementScript.UpdateDestination(unitScript.newIdlePosition(unitScript.unitGroupScript.transform.position, unitScript.spreadDistance));
unitScript.currentCommand = UnitCommand.Idle;
}
}
}
public static IEnumerator Defend(Unit origin, float duration)
{
bool isAlly = origin.GetType() == typeof(Ally);
Ally originAsAlly = null;
UnitCommand[] commandCache = null;
if (isAlly)
{
originAsAlly = origin as Ally;
commandCache = originAsAlly.commands;
UnitCommand stopCommand = new UnitCommand(UnitActions.Stop, 0);
originAsAlly.commands = new UnitCommand[] { stopCommand };
origin.state = UnitStates.CannotAction;
yield return(null);
}
origin.state = UnitStates.CanAction;
origin.isGuarding = true;
for (float timer = 0; true; timer += Time.deltaTime)
{
if (origin.state == UnitStates.InterruptAction || (!isAlly && timer > duration))
{
break;
}
yield return(null);
}
origin.isGuarding = false;
if (isAlly)
{
originAsAlly.commands = commandCache;
MenuManager.Instance.FillMenu(originAsAlly);
}
origin.state = UnitStates.CanAction;
}
public void AttackTarget()
{
AttackCommand command = (AttackCommand)currentCommand;
Vector3 targetPos = new Vector3(command.target.transform.position.x, 0f, command.target.transform.position.y);
float dist = Vector3.Distance(targetPos, transform.position);
Debug.Log(dist);
if (dist > attackRange)
{
agent.destination = targetPos;
}
else
{
if (isMelee)
{
//punch
}
else
{
GameObject go;
go = GameObject.Instantiate(Resources.Load <GameObject>("Prefabs/Projectile"));
go.transform.position = transform.position;
Projectile projectile = go.GetComponent <Projectile>();
projectile.target = command.target;
projectile.speed = projectileSpeed;
currentCommand = null;
agent.destination = transform.position;
}
}
}
protected virtual void CommandUnits(List <Unit> units, UnitCommand command, params object[] args)
{
for (int i = 0; i < units.Count; i++)
{
command(units[i], args);
}
}
static void Postfix(UnitCommand command, ref float?__state)
{
if (__state.HasValue)
{
command.SetTimeSinceStart(__state.Value);
}
}
public AboutViewModel()
{
OpenEmail = new DelegateCommand <string>(email => {
var emailTask = new EmailComposeTask()
{
Subject = "MusicPimp Feedback",
Body = "Great app! I'm using " + NameAndVersion + " for Windows Phone.",
To = email
};
emailTask.Show();
});
OpenWebsite = new DelegateCommand <string>(url => {
var browserTask = new WebBrowserTask();
var uri = new Uri(url, UriKind.RelativeOrAbsolute);
browserTask.Uri = uri;
browserTask.Show();
});
OpenMarketPlace = new UnitCommand(() => {
var reviewTask = new MarketplaceReviewTask();
reviewTask.Show();
//var marketplaceDetailTask = new MarketplaceDetailTask();
//marketplaceDetailTask.ContentIdentifier = "d31b505b-ac9f-4d93-8812-6b649734a5a6";
//marketplaceDetailTask.ContentType = MarketplaceContentType.Applications;
//marketplaceDetailTask.Show();
});
}
virtual public void setTarget(GameObject target, int priority)
{
if (unitCombatTarget != null)
{
unitCombatTarget.SendMessage("removeUnitTargetingMe", this, SendMessageOptions.DontRequireReceiver);
}
CancelInvoke("attackTarget");
if (target == null)
{
unitTargetPriority = priority;
unitCombatTarget = null;
}
else if (priority > unitTargetPriority)
{
unitTargetPriority = priority;
unitCombatTarget = target;
unitCommand = UnitCommand.Attack;
unitCombatTarget.SendMessage("addUnitTargetingMe", this, SendMessageOptions.DontRequireReceiver);
if (unitCombatTarget.GetComponent <NavMeshAgent>())
{
enemyUnitRadius = unitCombatTarget.GetComponent <NavMeshAgent>().radius;
}
else
{
enemyUnitRadius = 0.5f;
}
}
}
public virtual void AttackMove()
{
setRunning(true);
unitScript.unitTargetScript.UpdateTarget();
if (unitScript.unitTargetScript.attackTarget)
{
previousCommand = unitScript.currentCommand;
unitScript.currentCommand = UnitCommand.Attack;
return;
}
if (unitScript.movementScript.followTarget == null)
{
if (unitScript.movementScript.hasReachedDestination(unitScript.spreadDistance / 2.0f))
{
unitScript.unitTargetScript.resetTarget();
unitScript.currentIdleTime = 0.0f;
unitScript.movementScript.UpdateDestination(unitScript.newIdlePosition(unitScript.unitGroupScript.transform.position, unitScript.spreadDistance));
unitScript.currentCommand = UnitCommand.Idle;
}
}
else
{
if (unitScript.movementScript.isWithinGroupRange())
{
unitScript.unitTargetScript.resetTarget();
unitScript.currentIdleTime = 0.0f;
unitScript.movementScript.UpdateDestination(unitScript.newIdlePosition(unitScript.unitGroupScript.transform.position, unitScript.spreadDistance));
unitScript.currentCommand = UnitCommand.Idle;
}
}
}
public EndpointEditorViewModel()
{
Tester = new EndpointTester();
Add = new AsyncUnitCommand(AddEndpoint);
Cancel = new UnitCommand(Close);
DisplayHelp = new UnitCommand(() => Send(MusicItemsBase.AppHelpHeader, MusicItemsBase.AppHelpMessage));
}
static bool Prefix(UnitCombatState __instance, UnitCommand.CommandType commandType, ref bool __result)
{
if (IsInCombat() && __instance.Unit.IsInCombat)
{
switch (commandType)
{
case UnitCommand.CommandType.Free:
__result = false;
break;
case UnitCommand.CommandType.Move:
__result = !__instance.Unit.HasMoveAction();
break;
case UnitCommand.CommandType.Standard:
UnitCommand moveCommand = __instance.Unit.Commands.GetCommand(UnitCommand.CommandType.Move);
__result = (moveCommand != null && moveCommand.IsRunning) || !__instance.Unit.HasStandardAction();
break;
case UnitCommand.CommandType.Swift:
__result = __instance.Cooldown.SwiftAction > 0f;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(false);
}
return(true);
}
static bool Prefix(UnitCommand command)
{
if (IsInCombat() && command.Executor.IsInCombat)
{
if (command is UnitAttack unitAttack)
{
if (command.Executor.PreparedSpellCombat())
{
UnitPartMagus unitPartMagus = command.Executor.Get <UnitPartMagus>();
unitAttack.IgnoreCooldown(unitPartMagus.AttackIgnoringCooldownBeforeTime);
unitPartMagus.Owner.AddBuff(
BlueprintRoot.Instance.SystemMechanics.MagusSpellCombatBuff,
unitPartMagus.Owner.Unit, 1.Rounds().Seconds, null);
}
else if (command.Executor.PreparedSpellStrike())
{
UnitPartMagus unitPartMagus = command.Executor.Get <UnitPartMagus>();
unitAttack.IgnoreCooldown(unitPartMagus.AttackIgnoringCooldownBeforeTime);
unitAttack.IsSingleAttack = true;
}
}
return(false);
}
return(true);
}
static void Prefix(UnitCommand command)
{
if (IsInCombat() && command.Executor.IsInCombat && command.IsSpellCombatAttack())
{
command.Executor.CombatState.Cooldown.MoveAction += TIME_MOVE_ACTION;
}
}
static void Postfix(UnitCommand cmd, ref UnitCommands.CustomHandlerData?customHandler)
{
if (Mod.Enabled && FixKineticistWontStopPriorCommand &&
customHandler.HasValue && (customHandler.Value.ExecuteBefore ?? cmd) != cmd)
{
UnitCommands commands = cmd.Executor.Commands;
// remove conflicting command
UnitCommand prior = commands.Raw[(int)cmd.Type] ?? commands.GetPaired(cmd);
if (Game.Instance.IsPaused && commands.PreviousCommand == null && prior != null && prior.IsRunning)
{
commands.PreviousCommand = prior;
commands.PreviousCommand.SuppressAnimation();
commands.Raw[(int)commands.PreviousCommand.Type] = null;
}
else
{
commands.InterruptAndRemoveCommand(cmd.Type);
}
// update target
if (cmd.Type == UnitCommand.CommandType.Standard || commands.Standard == null)
{
commands.UpdateCombatTarget(cmd);
}
}
}
public uint PlayerCommand(UnitCommand cmd)
{
cmd._orderSequence = _orderSequence;
++_orderSequence;
_brain.AddCommand(cmd);
return(cmd._orderSequence);
}
static void Prefix(UnitCommand __instance)
{
if (IsInCombat() && __instance.Executor.IsInCombat && !__instance.IsActed)
{
__instance.SetIsActed(true);
}
}
public static void UpdateCooldowns(this UnitEntityData unit, UnitCommand command)
{
if (!command.IsIgnoreCooldown)
{
UnitCombatState.Cooldowns cooldown = unit.CombatState.Cooldown;
switch (command.Type)
{
case UnitCommand.CommandType.Free:
break;
case UnitCommand.CommandType.Move:
cooldown.MoveAction += TIME_MOVE_ACTION;
break;
case UnitCommand.CommandType.Standard:
cooldown.StandardAction += TIME_STANDARD_ACTION;
if (command.IsFullRoundAction())
{
cooldown.MoveAction += TIME_MOVE_ACTION;
}
break;
case UnitCommand.CommandType.Swift:
cooldown.SwiftAction += TIME_SWIFT_ACTION;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
private void HandleOrders()
{
switch (this.commandState)
{
case UnitCommand.NO_ORDERS:
if (Input.GetMouseButtonUp(1))
{
Move();
}
else if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.D))
{
this.commandState = UnitCommand.NO_ORDERS;
this.actionState = UnitState.WAITING_FOR_ORDERS;
}
break;
case UnitCommand.MOVE_ORDER:
if (Input.GetMouseButtonUp(1))
{
Move();
}
break;
default:
break;
}
}
private void WaitingOnOrders()
{
if (this.commandState.Equals(UnitCommand.NO_ORDERS) && this.actionState.Equals(UnitState.WAITING_FOR_ORDERS))
{
if (Input.GetKeyUp(KeyCode.A))
{
this.commandState = UnitCommand.ATTACK_ORDER;
Debug.Log("ATTACK ORDER");
}
else if (Input.GetKeyUp(KeyCode.S))
{
this.commandState = UnitCommand.SPLIT_ORDER;
Debug.Log("SPLIT ORDER");
}
else if (Input.GetKeyUp(KeyCode.D))
{
this.commandState = UnitCommand.MERGE_ORDER;
Debug.Log("MERGE ORDER");
}
else if (Input.GetMouseButtonUp(1))
{
this.commandState = UnitCommand.MOVE_ORDER;
Move();
Debug.Log("MOVE ORDER");
}
else if (Input.GetMouseButtonUp(0))
{
this.commandState = UnitCommand.NO_ORDERS;
this.actionState = UnitState.IDLE;
Debug.Log("CANCEL ORDER");
}
}
}
static void Postfix(UnitEntityData __instance, ref UnitCommand __state)
{
if (__state != null)
{
__instance.Commands.Raw[(int)UnitCommand.CommandType.Standard] = __state;
}
}
static void Prefix(UnitEntityData __instance, ref UnitCommand __state)
{
if (IsEnabled())
{
__state = __instance.Commands.Standard;
__instance.Commands.Raw[(int)UnitCommand.CommandType.Standard] = null;
}
}
/// <summary>
/// Commands a unit
/// </summary>
/// <param name="cmd"></param>
public void CommandUnit(UnitCommand cmd)
{
ConsoleManager.Instance.WriteLine($"Commanded {AllUnits.Find(u => u.InstanceID == cmd.UnitInstanceID).Name} - {cmd.CommandID}");
Packet p = new Packet((int)PacketHeader.UnitCommand, cmd);
SelectedCommand = UnitCommandID.UNITCMD_NULL;
client.SendData(p);
}
public bool Equals(UnitCommand obj)
{
if (obj == null)
{
return(false);
}
return(obj.swigCPtr.Handle == this.swigCPtr.Handle);
}
public static void NastavAktualniCasQueued(int addr)
{
Logger.Info("");
var uc = new UnitCommand(() => _unitDictionary[addr].SetCas(DateTime.Now), "NastavAktualniCas", addr);
_unitCommandsQueue.Enqueue(uc);
}
public bool changeCommand(UnitCommand newCommand)
{
if(newCommand <= unitGroupCommand) {
unitGroupCommand = newCommand;
return true;
}
return false;
}
public static bool IsOffensiveCommand(this UnitCommand command)
{
UnitEntityData executor;
UnitEntityData target;
return(command != null && !command.IsFinished && (command is UnitAttack || command is UnitUseAbility) &&
(target = command.TargetUnit) != null && target != (executor = command.Executor) && executor.CanAttack(target));
}
// Start is called before the first frame update
void Start()
{
_agent = GetComponent <NavMeshAgent>();
_unitCommand = UnitCommand.instance;
OnUnitSelected += AddToSelectedList;
OnUnitDeselected += RemoveFromSelectedList;
}
public bool changeCommand(UnitCommand newCommand)
{
if (newCommand <= unitGroupCommand)
{
unitGroupCommand = newCommand;
return(true);
}
return(false);
}
public void SendUnitCommand(UnitCommand uc)
{
byte[] data;
data = NetworkingMessageTranslator.GenerateUnitCommandNetworkingMessage(uc);
// Reliable because we only send once.
cc.Send(data, Valve.Sockets.SendFlags.Reliable, null);
}
private void HandleGamepadButton(string buttonName, UnitCommand command, Unit unit, float amount)
{
var buttonDown = Input.GetButton(buttonName);
if (buttonDown && command != null)
{
command.Execute(unit, amount);
}
}
static bool Prefix(UnitCommand command)
{
if (IsInCombat() && command.Executor.IsInCombat)
{
command.Executor.UpdateCooldowns(command);
return(false);
}
return(true);
}
public static byte[] GenerateUnitCommandNetworkingMessage(UnitCommand uc)
{
NetworkingMessage nm = new NetworkingMessage();
nm.type = NetworkingMessageType.USER_COMMANDS;
nm.content = ToByteArray(uc);
return(ToByteArray(nm));
}
public static UnitCommand unloadAll(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_unloadAll__SWIG_1(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand build(Unit unit, TilePosition target, UnitType type) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_build(Unit.getCPtr(unit), TilePosition.getCPtr(target), UnitType.getCPtr(type)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand attack(Unit unit, Position target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_attack__SWIG_1(Unit.getCPtr(unit), Position.getCPtr(target)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool opGreaterThan(UnitCommand other) {
bool ret = bwapiPINVOKE.UnitCommand_opGreaterThan(swigCPtr, UnitCommand.getCPtr(other));
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand useTech(Unit unit, TechType tech, Unit target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_useTech__SWIG_2(Unit.getCPtr(unit), TechType.getCPtr(tech), Unit.getCPtr(target)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand cancelTrain(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_cancelTrain__SWIG_1(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand rightClick(Unit unit, Unit target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_rightClick__SWIG_3(Unit.getCPtr(unit), Unit.getCPtr(target)), true);
return ret;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(UnitCommand obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public static UnitCommand holdPosition(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_holdPosition__SWIG_1(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand holdPosition(Unit unit, bool shiftQueueCommand) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_holdPosition__SWIG_0(Unit.getCPtr(unit), shiftQueueCommand), true);
return ret;
}
public static UnitCommand setRallyPoint(Unit unit, Unit target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_setRallyPoint__SWIG_1(Unit.getCPtr(unit), Unit.getCPtr(target)), true);
return ret;
}
public static UnitCommand upgrade(Unit unit, UpgradeType upgrade) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_upgrade(Unit.getCPtr(unit), UpgradeType.getCPtr(upgrade)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand research(Unit unit, TechType tech) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_research(Unit.getCPtr(unit), TechType.getCPtr(tech)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand morph(Unit unit, UnitType type) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_morph(Unit.getCPtr(unit), UnitType.getCPtr(type)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand rightClick(Unit unit, Position target, bool shiftQueueCommand) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_rightClick__SWIG_0(Unit.getCPtr(unit), Position.getCPtr(target), shiftQueueCommand), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand rightClick(Unit unit, Unit target, bool shiftQueueCommand) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_rightClick__SWIG_2(Unit.getCPtr(unit), Unit.getCPtr(target), shiftQueueCommand), true);
return ret;
}
public static UnitCommand returnCargo(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_returnCargo__SWIG_1(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand haltConstruction(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_haltConstruction(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand repair(Unit unit, Unit target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_repair__SWIG_1(Unit.getCPtr(unit), Unit.getCPtr(target)), true);
return ret;
}
public static UnitCommand cancelUpgrade(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_cancelUpgrade(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand lift(Unit unit) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_lift(Unit.getCPtr(unit)), true);
return ret;
}
public static UnitCommand placeCOP(Unit unit, TilePosition target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_placeCOP(Unit.getCPtr(unit), TilePosition.getCPtr(target)), true);
if (bwapiPINVOKE.SWIGPendingException.Pending) throw bwapiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static UnitCommand unload(Unit unit, Unit target) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_unload(Unit.getCPtr(unit), Unit.getCPtr(target)), true);
return ret;
}
public bool Equals(UnitCommand obj)
{
if (obj == null) return false;
return (obj.swigCPtr.Handle == this.swigCPtr.Handle);
}
public static UnitCommand unloadAll(Unit unit, bool shiftQueueCommand) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_unloadAll__SWIG_0(Unit.getCPtr(unit), shiftQueueCommand), true);
return ret;
}
public static UnitCommand gather(Unit unit, Unit target, bool shiftQueueCommand) {
UnitCommand ret = new UnitCommand(bwapiPINVOKE.UnitCommand_gather__SWIG_0(Unit.getCPtr(unit), Unit.getCPtr(target), shiftQueueCommand), true);
return ret;
}
public virtual void setTarget(GameObject target, int priority)
{
if(unitCombatTarget != null) {
unitCombatTarget.SendMessage("removeUnitTargetingMe", this, SendMessageOptions.DontRequireReceiver);
}
CancelInvoke("attackTarget");
if(target == null) {
unitTargetPriority = priority;
unitCombatTarget = null;
}
else if(priority > unitTargetPriority) {
unitTargetPriority = priority;
unitCombatTarget = target;
unitCommand = UnitCommand.Attack;
unitCombatTarget.SendMessage("addUnitTargetingMe", this, SendMessageOptions.DontRequireReceiver);
if(unitCombatTarget.GetComponent<NavMeshAgent>()) {
enemyUnitRadius = unitCombatTarget.GetComponent<NavMeshAgent>().radius;
} else {
enemyUnitRadius = 0.5f;
}
}
}
