private void Awake()
{
// Enforce single instance
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(this.gameObject);
// Find menu components before they get hidden
selectedIcon = GameObject.Find("Selected Icon").GetComponent <Image>();
selectedText = GameObject.Find("Selected Text").GetComponent <Text>();
}
void Awake()
{
if (AbilitiesManager.Instance != null)
{
DestroyImmediate(gameObject);
return;
}
_instance = this;
TextAsset asset = new TextAsset();
asset = (TextAsset)Resources.Load("AbilityData", typeof(TextAsset));
doc.LoadXml(asset.text);
//doc.Load(Application.dataPath + "/AbilityData.xml");
Initialize();
}
public static bool ActiveAbility()
{
AbilitiesManager manager = AbilitiesManager.GetInstance();
bool result = false;
if (manager.IsPrimaryEnabled)
{
result = true;
}
else if (manager.IsSecondaryEnabled)
{
result = true;
}
return(result);
}
void Start()
{
photonView = GetComponent <PhotonView>();
playerMovement = GetComponent <PlayerMovement>();
playerCombat = GetComponent <PlayerCombat>();
abilitiesManager = GetComponent <AbilitiesManager>();
if (int.TryParse(PhotonNetwork.NickName, out roomNumber))
{
print("Room number parsed " + roomNumber);
}
transform.position = LevelManager.instance.spawnPoints[roomNumber - 1].position;
if (photonView.IsMine)
{
photonView.RPC("RPC_AddCharacter", RpcTarget.AllBuffered, PlayerInfo.instance.selectedCharacter);
}
}
void Update()
{
if (PauseMenu_HTML.IsPaused)
{
return;
}
if (SoloEvolution)
{
UnitEvolution.Update(this);
}
if (GroupUtil.IsNeutral(Group))
{
return;
}
AbilitiesManager.UpdateUnitAbilities(this);
}
private static bool OnUseRequest(ref byte[] packet, ref int length)
{
int serial = (packet[1] << 24) | (packet[2] << 16) | (packet[3] << 8) | packet[4];
if (Options.CurrentOptions.CheckHandsPotions)
{
return(AbilitiesManager.GetInstance().CheckHands(serial));
}
if (Options.CurrentOptions.UseObjectQueue)
{
ActionPacketQueue.EnqueuePacket(new UseObject(serial), QueuePriority.High);
return(true);
}
return(false);
}
public void OnNodeInitialised()
{
//Debug.Log(GetNodeVariable<string>("Variable Name") + " " + name);
Tuple <int, int, int> nodeId = AbilitiesManager.GetAssetData(GetCentralInst().GetPlayerId()).globalVariables[GetNodeVariable <string>("Variable Name")];
//Debug.LogWarning("Node ID: " + nodeId + " " + name);
// Handles callback from subnodes.
if (!(nodeId.Item1 == GetCentralInst().ReturnPlayerCasted() && nodeId.Item2 == GetCentralId() && nodeId.Item3 == GetNodeId()))
{
if (!GetCentralInst().CheckIfReferenced(GetNodeId(), GetVariableId("Variable Value")))
{
//Debug.Log(nodeId[1]);
GetCentralInst().InstanceNode(GetNodeId(), nodeId);
//Debug.Log(GetNodeVariable<string>("Variable Name") + " " + name);
//AbilityTreeNode globalVarSource = AbilitiesManager.GetAssetData(nodeId[0]).playerSpawnedCentrals.l[0].GetNode(nodeId[1]);
//InstanceThisNode(globalVarSource);
}
}
}
public static void UseType(object type, int hue = -1, object container = null, bool skipQueue = false)
{
int serial = AliasCommands.ResolveSerial(type);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
if (container == null)
{
container = Engine.Player?.Backpack?.Serial;
}
int containerSerial = AliasCommands.ResolveSerial(container);
if (!Engine.Items.GetItem(containerSerial, out Item containerItem))
{
UOC.SystemMessage(Strings.Cannot_find_container___);
return;
}
Item useItem = hue == -1
? containerItem.Container?.SelectEntity(i => i.ID == serial)
: containerItem.Container?.SelectEntity(i => i.ID == serial && i.Hue == hue);
if (useItem == null)
{
UOC.SystemMessage(Strings.Cannot_find_item___);
return;
}
if (!AbilitiesManager.GetInstance().CheckHands(useItem.Serial))
{
ActionPacketQueue.EnqueuePacket(new UseObject(useItem.Serial),
skipQueue ? QueuePriority.Immediate : QueuePriority.Medium);
}
}
private static void OnEncodedCommand(PacketReader reader)
{
int serial = reader.ReadInt32();
int command = reader.ReadInt16();
switch (command)
{
case 0x19:
{
reader.ReadByte();
int abilityIndex = reader.ReadInt32();
AbilitiesManager.GetInstance().CheckAbility(abilityIndex);
break;
}
}
}
public void WillTogglePrimaryAbility()
{
AbilitiesManager manager = AbilitiesManager.GetInstance();
Engine.Player = new PlayerMobile(0x01);
manager.Enabled = AbilityType.None;
Engine.InternalPacketSentEvent += ExpectAbilityPacket;
AbilitiesCommands.SetAbility("primary");
bool result = _are.WaitOne(5000);
if (!result)
{
Assert.Fail();
}
Assert.AreEqual(AbilityType.Primary, manager.Enabled);
Assert.IsTrue(manager.IsPrimaryEnabled);
AbilitiesCommands.SetAbility("primary");
result = _are.WaitOne(5000);
if (!result)
{
Assert.Fail();
}
Assert.AreEqual(AbilityType.None, manager.Enabled);
Assert.IsFalse(manager.IsPrimaryEnabled);
Engine.InternalPacketSentEvent -= ExpectAbilityPacket;
Engine.Player = null;
}
public void WillClearAbilities()
{
Engine.Player = new PlayerMobile(0x01);
AbilitiesManager manager = AbilitiesManager.GetInstance();
Engine.InternalPacketSentEvent += ExpectAbilityPacket;
manager.Enabled = AbilityType.Primary;
AbilitiesCommands.ClearAbility();
bool result = _are.WaitOne(5000);
if (!result)
{
Assert.Fail();
}
Assert.AreEqual(AbilityType.None, manager.Enabled);
manager.Enabled = AbilityType.Secondary;
AbilitiesCommands.ClearAbility();
result = _are.WaitOne(5000);
if (!result)
{
Assert.Fail();
}
Assert.AreEqual(AbilityType.None, manager.Enabled);
Engine.InternalPacketSentEvent -= ExpectAbilityPacket;
Engine.Player = null;
}
private static void OnMobileIncoming(PacketReader reader)
{
int serial = reader.ReadInt32();
ItemCollection container = new ItemCollection(serial);
Mobile mobile = serial == Engine.Player?.Serial ? Engine.Player : Engine.GetOrCreateMobile(serial);
mobile.ID = reader.ReadInt16();
mobile.X = reader.ReadInt16();
mobile.Y = reader.ReadInt16();
mobile.Z = reader.ReadSByte();
mobile.Direction = (Direction)(reader.ReadByte() & 0x07);
mobile.Hue = reader.ReadUInt16();
mobile.Status = (MobileStatus)reader.ReadByte();
mobile.Notoriety = (Notoriety)reader.ReadByte();
bool useNewIncoming = Engine.ClientVersion >= new Version(7, 0, 33, 1);
for ( ;;)
{
int itemSerial = reader.ReadInt32();
if (itemSerial == 0)
{
break;
}
Item item = Engine.GetOrCreateItem(itemSerial);
item.Owner = serial;
item.ID = reader.ReadUInt16();
item.Layer = (Layer)reader.ReadByte();
if (useNewIncoming)
{
item.Hue = reader.ReadUInt16();
}
else
{
if ((item.ID & 0x8000) != 0)
{
item.ID ^= 0x8000;
item.Hue = reader.ReadUInt16();
}
}
container.Add(item);
}
mobile.Equipment.Clear();
mobile.Equipment.Add(container.GetItems());
foreach (Item item in container.GetItems())
{
mobile.SetLayer(item.Layer, item.Serial);
}
Engine.Items.Add(container.GetItems());
if (!(mobile is PlayerMobile))
{
Engine.Mobiles.Add(mobile);
}
else
{
AbilitiesManager manager = AbilitiesManager.GetInstance();
manager.ResendGump(manager.Enabled);
}
MobileIncomingEvent?.Invoke(mobile, container);
}
void RetrieveStartNodes()
{
int nonPsuedoNodes = dataVar.Length - 2;
AutoPopulationList <bool> connected = new AutoPopulationList <bool>(nonPsuedoNodes);
for (int i = 0; i < nonPsuedoNodes; i++)
{
int totalCurrLinks = 0;
for (int j = 0; j < dataVar[i].Length; j++)
{
totalCurrLinks += dataVar[i][j].links.Length;
for (int k = 0; k < dataVar[i][j].links.Length; k++)
{
int[] currLink = dataVar[i][j].links[k];
// Marks target as true so it can't be root.
connected.ModifyElementAt(currLink[0], true);
}
}
if (totalCurrLinks == 0)
{
dataVar[i][dataVar[i].Length - 1].links = new int[][] { new int[] { dataVar.Length - 1, 0, 0 } }
}
;
}
List <int[]> rC = new List <int[]>();
for (int i = 0; i < connected.l.Count; i++)
{
if (!connected.l[i])
{
rC.Add(new int[] { i, 0, 1 });
}
}
rootSubclasses = rC.ToArray();
}
void RunNodeFlow(int nextNode, int targetVar, Tuple <int, int, int>[] pN = null)
{
int[] lC = LoadedData.loadedNodeInstance[dataType[nextNode]].ReturnLinkChannels();
for (int k = 0; k < lC.Length; k++)
{
if (pN != null)
{
Tuple <int, int, int> precedingNode = pN[lC[k]];
if (linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2] == null)
{
linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2] = new HashSet <Tuple <int, int, int> >();
}
Tuple <int, int, int> currNode = Tuple.Create(nextNode, targetVar, precedingNode.Item3);
if (!linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2].Contains(currNode))
{
linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2].Add(currNode);
}
}
}
//if(LoadedData.loadedNodeInstance[dataType[nextNode]] is INodeNetworkPoint)
//progenitor = nextNode;
//Debug.LogFormat("Curr Node: {0}, {1}", nextNode,dataType[nextNode]);
for (int i = 0; i < dataVar[nextNode].Length; i++)
{
for (int j = 0; j < dataVar[nextNode][i].links.Length; j++)
{
int[] currLink = dataVar[nextNode][i].links[j];
// Adds links to rhs.
Tuple <int, int, int, int> rhslinkTup = Tuple.Create(currLink[0], currLink[1], currLink[2], j);
if (!linkData[nextNode].rHS.Contains(rhslinkTup))
{
linkData[nextNode].rHS.Add(rhslinkTup);
}
// Adds links to target lhs.
Tuple <int, int, int, int> lhslinkTup = Tuple.Create(nextNode, i, currLink[2], j);
if (!linkData[currLink[0]].lHS.Contains(lhslinkTup))
{
linkData[currLink[0]].lHS.Add(lhslinkTup);
}
Tuple <int, int, int> nextNodeRef = Tuple.Create <int, int, int>(nextNode, i, currLink[2]);
List <Tuple <int, int, int> > precedingArray = new List <Tuple <int, int, int> >();
if (pN != null)
{
precedingArray.AddRange(pN);
}
else
{
precedingArray.Add(null);
precedingArray.Add(null);
}
for (int k = 0; k < lC.Length; k++)
{
precedingArray[lC[k]] = nextNodeRef;
}
// Iterates to target.
RunNodeFlow(currLink[0], currLink[1], precedingArray.ToArray());
}
}
//Debug.LogWarningFormat("End of Node: {0}, {1}", nextNode, dataType[nextNode]);
}
void GenerateLinks()
{
// Generate links after
generatedLinks = new int[linkGenerator.Length][][][][];
for (int i = 0; i < linkGenerator.Length; i++)
{
generatedLinks[i] = new int[linkGenerator[i].Length][][][];
for (int j = 0; j < linkGenerator[i].Length; j++)
{
generatedLinks[i][j] = new int[linkGenerator[i][j].Length][][];
for (int k = 0; k < linkGenerator[i][j].Length; k++)
{
List <int[]> convertedLinks = new List <int[]>();
//generatedLinks[i][j][k] = new int[linkGenerator[i][j][k].Count];
if (linkGenerator[i][j][k] != null)
{
foreach (var item in linkGenerator[i][j][k])
{
convertedLinks.Add(new int[] { item.Item1, item.Item2, item.Item3 });
}
}
//Debug.LogFormat("Generating for: {0}, {1}, {2}", i, j, k);
generatedLinks[i][j][k] = convertedLinks.ToArray();
}
}
}
}
void EditLinks()
{
lM = new LinkModifier();
for (currBuildNode = 0; currBuildNode < dataType.Length; currBuildNode++)
{
LoadedData.loadedNodeInstance[dataType[currBuildNode]].ConstructionPhase(this);
}
//LoadedData.loadedNodeInstance[dataType[i]].LinkEdit(i, lD, lM, dataVar);
foreach (var add in lM.add)
{
List <int[]> links = new List <int[]>(dataVar[add.Key.Item1][add.Key.Item2].links);
foreach (var ele in add.Value)
{
links.Add(new int[] { ele.Item1, ele.Item2, ele.Item3 });
Debug.LogFormat("Adding to {0},{1}. Content: {2},{3}", add.Key.Item1, add.Key.Item2, ele.Item1, ele.Item2);
}
dataVar[add.Key.Item1][add.Key.Item2].links = links.ToArray();
}
foreach (var rm in lM.remove)
{
int[] rmArr = rm.Value.ToArray();
Array.Sort(rmArr);
List <int[]> links = new List <int[]>(dataVar[rm.Key.Item1][rm.Key.Item2].links);
for (int i = rmArr.Length - 1; i >= 0; i--)
{
Debug.LogFormat("Removing at {0},{1}. Content: {2},{3}", rm.Key.Item1, rm.Key.Item2, links[rmArr[i]][0], links[rmArr[i]][0]);
links.RemoveAt(rmArr[i]);
}
dataVar[rm.Key.Item1][rm.Key.Item2].links = links.ToArray();
}
}
void BeginDepenciesBuild()
{
nodeBranchingData = new int[dataVar.Length];
autoManagedVariables = new int[dataVar.Length][];
boolData = new AbilityBooleanData(dataVar);
for (int i = 0; i < dataVar.Length; i++)
{
List <int> aMVar = new List <int>();
List <int> networkVariables = new List <int>();
//Debug.Log("Printing for Node: " + i);
for (int j = 0; j < dataVar[i].Length; j++)
{
//Debug.Log("Printing for Variable: " + j);
bool interchangeable = LoadedData.GetVariableType(dataType[i], j, VariableTypes.INTERCHANGEABLE);
AutoPopulationList <List <int[]> > varLinks = new AutoPopulationList <List <int[]> >(1);
for (int k = 0; k < dataVar[i][j].links.Length; k++)
{
int[] currLink = dataVar[i][j].links[k];
//Debug.LogFormat("{0},{1}", currLink[0], currLink[1]);
bool signal = currLink[2] == (int)LinkMode.SIGNAL ? true : false;//LoadedData.GetVariableType(dataType[i], j, VariableTypes.SIGNAL_ONLY);
// Marks target as true so it will be blocked.
if (!signal)
{
if (dataVar[i][j].field.t == dataVar[currLink[0]][currLink[1]].field.t || interchangeable)
{
boolData.varsBlocked[currLink[0]][currLink[1]] = true;
//Debug.LogFormat("From Node {0} Variable {1} link {2} name {3}", i, j, k, dataVar[i][j].field.n);
//Debug.LogFormat("To Node {0} Variable {1} link {2} signal {3} interchange {4} name {5}", currLink[0], currLink[1], k, signal, interchangeable, dataVar[i][j].field.n);
//Debug.Log("This was called true.");
}
}
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.BLOCKED))
{
boolData.varsBlocked[i][j] = true;
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.AUTO_MANAGED))
{
aMVar.Add(j);
}
if (!LoadedData.GetVariableType(dataType[i],j,VariableTypes.NON_LINK))
{
nodeBranchingData[i] += dataVar[i][j].links.Length;
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.GLOBAL_VARIABLE))
{
string gVN = (dataVar[i][j].field as RuntimeParameters <string>).v;
if (!AbilitiesManager.GetAssetData(playerId).globalVariables.ContainsKey(gVN))
{
AbilitiesManager.GetAssetData(playerId).globalVariables.Add(gVN,null);
}
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.NETWORK))
{
networkVariables.Add(j);
}
}
autoManagedVariables[i] = aMVar.ToArray();
if (networkVariables.Count > 0)
{
nodeNetworkVariables.Add(i,networkVariables.ToArray());
}
//aMVar.Add(j);
}
}
private static void OnEquipRequest(PacketReader reader)
{
AbilitiesManager manager = AbilitiesManager.GetInstance();
manager.ResendGump(manager.Enabled);
}
private void Start()
{
//Time.timeScale = 5;
player = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerController>();
player.canShoot = false;
abilitiesManager = player.GetComponent <AbilitiesManager> ();
position = "S1P1";
inventory = GameObject.Find("PlayerInventory").GetComponent <PlayerInventory>();
if (Global.startAt2)
{
position = "S1END";
inventory.addWeapon(Global.CANNON2);
inventory.addWeapon(Global.SHOTGUN2);
inventory.SortInventory();
inventory.SortAbilityInventory();
}
if (Global.startAt3)
{
inventory.addWeapon(Global.RNG2);
inventory.addWeapon(Global.SATCANNON);
//Stage 1 Boss Rewards
inventory.addAbility(Global.DRONEMKII);
inventory.addAbility(Global.ROCKETRING);
inventory.addAbility(Global.COMPANIONDRONEII);
//Stage 2 Boss Rewards
inventory.addAbility(Global.HEAL);
inventory.addAbility(Global.REGENERATOR);
//inventory.addAbility(Global.STASISBUBBLE);
position = "S2END";
inventory.SortInventory();
inventory.SortAbilityInventory();
}
if (Global.startAt4)
{
inventory.addWeapon(Global.RPR);
inventory.addWeapon(Global.LAS1);
position = "S3END";
//Stage 1 Boss Rewards
inventory.addAbility(Global.DRONEMKII);
inventory.addAbility(Global.ROCKETRING);
inventory.addAbility(Global.COMPANIONDRONEII);
//Stage 2 Boss Rewards
inventory.addAbility(Global.HEAL);
inventory.addAbility(Global.REGENERATOR);
//inventory.addAbility(Global.STASISBUBBLE);
//Stage 1 Boss Rewards
inventory.addAbility(Global.SWORDRING);
inventory.addAbility(Global.SHIELD);
inventory.addAbility(Global.SWORD);
inventory.addAbility(Global.SHIELDPASSIVE);
inventory.SortInventory();
inventory.SortAbilityInventory();
}
if (Global.startAt5)
{
inventory.addWeapon(Global.SNIPER2);
inventory.addWeapon(Global.FLAMETHROWER);
position = "S4END";
inventory.addAbility(Global.DRONEMKII);
inventory.addAbility(Global.ROCKETRING);
inventory.addAbility(Global.COMPANIONDRONEII);
//Stage 2 Boss Rewards
inventory.addAbility(Global.HEAL);
inventory.addAbility(Global.REGENERATOR);
//inventory.addAbility(Global.STASISBUBBLE);
//Stage 1 Boss Rewards
inventory.addAbility(Global.SWORDRING);
inventory.addAbility(Global.SHIELD);
inventory.addAbility(Global.SWORD);
inventory.addAbility(Global.SHIELDPASSIVE);
inventory.addAbility(Global.PHASE);
inventory.addAbility(Global.TELEPORT);
inventory.addAbility(Global.EMP);
inventory.SortInventory();
inventory.SortAbilityInventory();
}
if (Global.startAt6)
{
inventory.addWeapon(Global.MJOLNIR);
inventory.addWeapon(Global.RPR2);
position = "S5END";
inventory.addAbility(Global.DRONEMKII);
inventory.addAbility(Global.ROCKETRING);
inventory.addAbility(Global.COMPANIONDRONEII);
//Stage 2 Boss Rewards
inventory.addAbility(Global.HEAL);
inventory.addAbility(Global.REGENERATOR);
//inventory.addAbility(Global.STASISBUBBLE);
//Stage 1 Boss Rewards
inventory.addAbility(Global.SWORDRING);
inventory.addAbility(Global.SHIELD);
inventory.addAbility(Global.SWORD);
inventory.addAbility(Global.SHIELDPASSIVE);
inventory.addAbility(Global.PHASE);
inventory.addAbility(Global.TELEPORT);
inventory.addAbility(Global.EMP);
inventory.addAbility(Global.BFOLASER);
inventory.addAbility(Global.TIMESLOW);
inventory.SortInventory();
inventory.SortAbilityInventory();
}
if (Global.bossMedley)
{
inventory.addWeapon(Global.RNG);
inventory.addWeapon(Global.BLITZGUN);
inventory.addWeapon(Global.REDOX);
inventory.addWeapon(Global.PLAYERICEWEP);
position = "S1M";
inventory.SortInventory();
inventory.SortAbilityInventory();
}
//ip.gameObject.SetActive (false);
}
void OnApplicationQuit()
{
_instance = null;
}
public static void SetPlayer(PlayerMobile mobile)
{
Player = mobile;
PlayerInitializedEvent?.Invoke(mobile);
mobile.MobileStatusUpdated += (status, newStatus) =>
{
if (!Options.CurrentOptions.UseDeathScreenWhilstHidden)
{
return;
}
if (newStatus.HasFlag(MobileStatus.Hidden))
{
SendPacketToClient(new MobileUpdate(mobile.Serial, mobile.ID == 0x191 ? 0x193 : 0x192, mobile.Hue,
newStatus, mobile.X,
mobile.Y, mobile.Z, mobile.Direction));
}
};
Task.Run(async() =>
{
try
{
GitHubClient client = new GitHubClient(new ProductHeaderValue("ClassicAssist"));
IReadOnlyList <Release> releases =
await client.Repository.Release.GetAll("Reetus",
"ClassicAssist");
Release latestRelease = releases.FirstOrDefault();
if (latestRelease == null)
{
return;
}
Version latestVersion = Version.Parse(latestRelease.TagName);
if (!Version.TryParse(
FileVersionInfo.GetVersionInfo(Path.Combine(StartupPath, "ClassicAssist.dll"))
.ProductVersion,
out Version localVersion))
{
return;
}
if (latestVersion > localVersion && AssistantOptions.UpdateGumpVersion < latestVersion)
{
IReadOnlyList <GitHubCommit> commits =
await client.Repository.Commit.GetAll("Reetus", "ClassicAssist");
IEnumerable <GitHubCommit> latestCommits =
commits.OrderByDescending(c => c.Commit.Author.Date).Take(7);
StringBuilder commitMessage = new StringBuilder();
foreach (GitHubCommit gitHubCommit in latestCommits)
{
commitMessage.AppendLine($"{gitHubCommit.Commit.Author.Date.Date.ToShortDateString()}:");
commitMessage.AppendLine();
commitMessage.AppendLine(gitHubCommit.Commit.Message);
commitMessage.AppendLine();
}
StringBuilder message = new StringBuilder();
message.AppendLine(Strings.ProductName);
message.AppendLine($"{Strings.New_version_available_} {latestVersion}");
message.AppendLine();
message.AppendLine(commitMessage.ToString());
UpdateMessageGump gump = new UpdateMessageGump(message.ToString(), latestVersion);
byte[] packet = gump.Compile();
SendPacketToClient(packet, packet.Length);
}
}
catch (Exception)
{
// Squash all
}
});
AbilitiesManager.GetInstance().Enabled = AbilityType.None;
}
public static void SetAbility(string ability, string onOff = "toggle")
{
AbilitiesManager manager = AbilitiesManager.GetInstance();
if (ability.ToLower().Equals("stun"))
{
Engine.SendPacketToServer(new StunRequest());
return;
}
if (ability.ToLower().Equals("disarm"))
{
Engine.SendPacketToServer(new DisarmRequest());
return;
}
bool primary;
switch (ability.ToLower())
{
case "primary":
primary = true;
break;
default:
primary = false;
break;
}
string onOffNormalized = onOff.Trim().ToLower();
if (onOffNormalized != "toggle")
{
switch (onOffNormalized)
{
case "on":
{
if (primary && manager.IsPrimaryEnabled || !primary && manager.IsSecondaryEnabled)
{
if (!MacroManager.QuietMode)
{
UOC.SystemMessage(Strings.Ability_already_set___, 0x3F);
}
return;
}
break;
}
case "off":
{
if (primary && !manager.IsPrimaryEnabled || !primary && !manager.IsSecondaryEnabled)
{
if (!MacroManager.QuietMode)
{
UOC.SystemMessage(Strings.Ability_not_set___, 0x3F);
}
return;
}
break;
}
}
}
UOC.SystemMessage(string.Format(Strings.Setting_ability___0_____, ability), 0x3F);
manager.SetAbility(primary ? AbilityType.Primary : AbilityType.Secondary);
}
