public static void OpenStatusBar()
{
Client.Game.Scene.Audio.StopWarMusic();
if (StatusGumpBase.GetStatusGump() == null)
{
UIManager.Add(StatusGumpBase.AddStatusGump(100, 100));
}
}
public List <Gump> ReadGumps(string path)
{
List <Gump> gumps = new List <Gump>();
// #########################################################
// [FILE_FIX]
// TODO: this code is a workaround to port old macros to the new xml system.
string skillsGroupsPath = Path.Combine(path, "skillsgroups.bin");
if (File.Exists(skillsGroupsPath))
{
try
{
using (BinaryReader reader = new BinaryReader(File.OpenRead(skillsGroupsPath)))
{
int version = reader.ReadInt32();
int groupCount = reader.ReadInt32();
for (int i = 0; i < groupCount; i++)
{
int entriesCount = reader.ReadInt32();
string groupName = reader.ReadUTF8String(reader.ReadInt32());
SkillsGroup g = new SkillsGroup();
g.Name = groupName;
for (int j = 0; j < entriesCount; j++)
{
byte idx = (byte)reader.ReadInt32();
g.Add(idx);
}
g.Sort();
SkillsGroupManager.Add(g);
}
}
}
catch (Exception e)
{
SkillsGroupManager.MakeDefault();
Log.Error(e.StackTrace);
}
SkillsGroupManager.Save();
try
{
File.Delete(skillsGroupsPath);
}
catch
{
}
}
string binpath = Path.Combine(path, "gumps.bin");
if (File.Exists(binpath))
{
using (BinaryReader reader = new BinaryReader(File.OpenRead(binpath)))
{
if (reader.BaseStream.Position + 12 < reader.BaseStream.Length)
{
GumpsVersion = reader.ReadUInt32();
uint empty = reader.ReadUInt32();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
try
{
int typeLen = reader.ReadUInt16();
string typeName = reader.ReadUTF8String(typeLen);
int x = reader.ReadInt32();
int y = reader.ReadInt32();
Type type = Type.GetType(typeName, true);
Gump gump = (Gump)Activator.CreateInstance(type);
gump.Restore(reader);
gump.X = x;
gump.Y = y;
//gump.SetInScreen();
if (gump.LocalSerial != 0)
{
UIManager.SavePosition(gump.LocalSerial, new Point(x, y));
}
if (!gump.IsDisposed)
{
gumps.Add(gump);
}
}
catch (Exception e)
{
Log.Error(e.StackTrace);
}
}
}
}
SaveGumps(path);
gumps.Clear();
try
{
File.Delete(binpath);
}
catch
{
}
}
// #########################################################
// load skillsgroup
//SkillsGroupManager.Load();
SkillsGroupManager.Load();
// load gumps
string gumpsXmlPath = Path.Combine(path, "gumps.xml");
if (File.Exists(gumpsXmlPath))
{
XmlDocument doc = new XmlDocument();
try
{
doc.Load(gumpsXmlPath);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
return(gumps);
}
XmlElement root = doc["gumps"];
if (root != null)
{
foreach (XmlElement xml in root.ChildNodes /*.GetElementsByTagName("gump")*/)
{
if (xml.Name != "gump")
{
continue;
}
try
{
GumpType type = (GumpType)int.Parse(xml.GetAttribute(nameof(type)));
int x = int.Parse(xml.GetAttribute(nameof(x)));
int y = int.Parse(xml.GetAttribute(nameof(y)));
uint serial = uint.Parse(xml.GetAttribute(nameof(serial)));
Gump gump = null;
switch (type)
{
case GumpType.Buff:
gump = new BuffGump();
break;
case GumpType.Container:
gump = new ContainerGump();
break;
case GumpType.CounterBar:
gump = new CounterBarGump();
break;
case GumpType.HealthBar:
if (CustomBarsToggled)
{
gump = new HealthBarGumpCustom();
}
else
{
gump = new HealthBarGump();
}
break;
case GumpType.InfoBar:
gump = new InfoBarGump();
break;
case GumpType.Journal:
gump = new JournalGump();
break;
case GumpType.MacroButton:
gump = new MacroButtonGump();
break;
case GumpType.MiniMap:
gump = new MiniMapGump();
break;
case GumpType.PaperDoll:
gump = new PaperDollGump();
break;
case GumpType.SkillMenu:
if (StandardSkillsGump)
{
gump = new StandardSkillsGump();
}
else
{
gump = new SkillGumpAdvanced();
}
break;
case GumpType.SpellBook:
gump = new SpellbookGump();
break;
case GumpType.StatusGump:
gump = StatusGumpBase.AddStatusGump(0, 0);
break;
//case GumpType.TipNotice:
// gump = new TipNoticeGump();
// break;
case GumpType.AbilityButton:
gump = new UseAbilityButtonGump();
break;
case GumpType.SpellButton:
gump = new UseSpellButtonGump();
break;
case GumpType.SkillButton:
gump = new SkillButtonGump();
break;
case GumpType.RacialButton:
gump = new RacialAbilityButton();
break;
case GumpType.WorldMap:
gump = new WorldMapGump();
break;
case GumpType.Debug:
gump = new DebugGump(100, 100);
break;
case GumpType.NetStats:
gump = new NetworkStatsGump(100, 100);
break;
}
if (gump == null)
{
continue;
}
gump.LocalSerial = serial;
gump.Restore(xml);
gump.X = x;
gump.Y = y;
if (gump.LocalSerial != 0)
{
UIManager.SavePosition(gump.LocalSerial, new Point(x, y));
}
if (!gump.IsDisposed)
{
gumps.Add(gump);
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
foreach (XmlElement group in root.GetElementsByTagName("anchored_group_gump"))
{
int matrix_width = int.Parse(group.GetAttribute("matrix_w"));
int matrix_height = int.Parse(group.GetAttribute("matrix_h"));
AnchorManager.AnchorGroup ancoGroup = new AnchorManager.AnchorGroup();
ancoGroup.ResizeMatrix(matrix_width, matrix_height, 0, 0);
foreach (XmlElement xml in group.GetElementsByTagName("gump"))
{
try
{
GumpType type = (GumpType)int.Parse(xml.GetAttribute("type"));
int x = int.Parse(xml.GetAttribute("x"));
int y = int.Parse(xml.GetAttribute("y"));
uint serial = uint.Parse(xml.GetAttribute("serial"));
int matrix_x = int.Parse(xml.GetAttribute("matrix_x"));
int matrix_y = int.Parse(xml.GetAttribute("matrix_y"));
AnchorableGump gump = null;
switch (type)
{
case GumpType.SpellButton:
gump = new UseSpellButtonGump();
break;
case GumpType.SkillButton:
gump = new SkillButtonGump();
break;
case GumpType.HealthBar:
if (CustomBarsToggled)
{
gump = new HealthBarGumpCustom();
}
else
{
gump = new HealthBarGump();
}
break;
case GumpType.AbilityButton:
gump = new UseAbilityButtonGump();
break;
case GumpType.MacroButton:
gump = new MacroButtonGump();
break;
}
if (gump != null)
{
gump.LocalSerial = serial;
gump.Restore(xml);
gump.X = x;
gump.Y = y;
if (!gump.IsDisposed)
{
if (UIManager.AnchorManager[gump] == null && ancoGroup.IsEmptyDirection(matrix_x, matrix_y))
{
gumps.Add(gump);
UIManager.AnchorManager[gump] = ancoGroup;
ancoGroup.AddControlToMatrix(matrix_x, matrix_y, gump);
}
else
{
gump.Dispose();
}
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
}
}
}
return(gumps);
}
public List <Gump> ReadGumps(string path)
{
List <Gump> gumps = new List <Gump>();
// load skillsgroup
SkillsGroupManager.Load();
// load gumps
string gumpsXmlPath = Path.Combine(path, "gumps.xml");
if (File.Exists(gumpsXmlPath))
{
XmlDocument doc = new XmlDocument();
try
{
doc.Load(gumpsXmlPath);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
return(gumps);
}
XmlElement root = doc["gumps"];
if (root != null)
{
foreach (XmlElement xml in root.ChildNodes /*.GetElementsByTagName("gump")*/)
{
if (xml.Name != "gump")
{
continue;
}
try
{
GumpType type = (GumpType)int.Parse(xml.GetAttribute(nameof(type)));
int x = int.Parse(xml.GetAttribute(nameof(x)));
int y = int.Parse(xml.GetAttribute(nameof(y)));
uint serial = uint.Parse(xml.GetAttribute(nameof(serial)));
Gump gump = null;
switch (type)
{
case GumpType.Buff:
gump = new BuffGump();
break;
case GumpType.Container:
gump = new ContainerGump();
break;
case GumpType.CounterBar:
gump = new CounterBarGump();
break;
case GumpType.HealthBar:
if (CustomBarsToggled)
{
gump = new HealthBarGumpCustom();
}
else
{
gump = new HealthBarGump();
}
break;
case GumpType.InfoBar:
gump = new InfoBarGump();
break;
case GumpType.Journal:
gump = new JournalGump();
break;
case GumpType.MacroButton:
gump = new MacroButtonGump();
break;
case GumpType.MiniMap:
gump = new MiniMapGump();
break;
case GumpType.PaperDoll:
gump = new PaperDollGump();
break;
case GumpType.SkillMenu:
if (StandardSkillsGump)
{
gump = new StandardSkillsGump();
}
else
{
gump = new SkillGumpAdvanced();
}
break;
case GumpType.SpellBook:
gump = new SpellbookGump();
break;
case GumpType.StatusGump:
gump = StatusGumpBase.AddStatusGump(0, 0);
break;
//case GumpType.TipNotice:
// gump = new TipNoticeGump();
// break;
case GumpType.AbilityButton:
gump = new UseAbilityButtonGump();
break;
case GumpType.SpellButton:
gump = new UseSpellButtonGump();
break;
case GumpType.SkillButton:
gump = new SkillButtonGump();
break;
case GumpType.RacialButton:
gump = new RacialAbilityButton();
break;
case GumpType.WorldMap:
gump = new WorldMapGump();
break;
case GumpType.Debug:
gump = new DebugGump(100, 100);
break;
case GumpType.NetStats:
gump = new NetworkStatsGump(100, 100);
break;
}
if (gump == null)
{
continue;
}
gump.LocalSerial = serial;
gump.Restore(xml);
gump.X = x;
gump.Y = y;
if (gump.LocalSerial != 0)
{
UIManager.SavePosition(gump.LocalSerial, new Point(x, y));
}
if (!gump.IsDisposed)
{
gumps.Add(gump);
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
foreach (XmlElement group in root.GetElementsByTagName("anchored_group_gump"))
{
int matrix_width = int.Parse(group.GetAttribute("matrix_w"));
int matrix_height = int.Parse(group.GetAttribute("matrix_h"));
AnchorManager.AnchorGroup ancoGroup = new AnchorManager.AnchorGroup();
ancoGroup.ResizeMatrix(matrix_width, matrix_height, 0, 0);
foreach (XmlElement xml in group.GetElementsByTagName("gump"))
{
try
{
GumpType type = (GumpType)int.Parse(xml.GetAttribute("type"));
int x = int.Parse(xml.GetAttribute("x"));
int y = int.Parse(xml.GetAttribute("y"));
uint serial = uint.Parse(xml.GetAttribute("serial"));
int matrix_x = int.Parse(xml.GetAttribute("matrix_x"));
int matrix_y = int.Parse(xml.GetAttribute("matrix_y"));
AnchorableGump gump = null;
switch (type)
{
case GumpType.SpellButton:
gump = new UseSpellButtonGump();
break;
case GumpType.SkillButton:
gump = new SkillButtonGump();
break;
case GumpType.HealthBar:
if (CustomBarsToggled)
{
gump = new HealthBarGumpCustom();
}
else
{
gump = new HealthBarGump();
}
break;
case GumpType.AbilityButton:
gump = new UseAbilityButtonGump();
break;
case GumpType.MacroButton:
gump = new MacroButtonGump();
break;
}
if (gump != null)
{
gump.LocalSerial = serial;
gump.Restore(xml);
gump.X = x;
gump.Y = y;
if (!gump.IsDisposed)
{
if (UIManager.AnchorManager[gump] == null && ancoGroup.IsEmptyDirection(matrix_x, matrix_y))
{
gumps.Add(gump);
UIManager.AnchorManager[gump] = ancoGroup;
ancoGroup.AddControlToMatrix(matrix_x, matrix_y, gump);
}
else
{
gump.Dispose();
}
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
}
}
}
return(gumps);
}
private int Process(MacroObject macro)
{
if (macro == null)
{
return(0);
}
int result = 0;
switch (macro.Code)
{
case MacroType.Say:
case MacroType.Emote:
case MacroType.Whisper:
case MacroType.Yell:
MacroObjectString mos = (MacroObjectString)macro;
if (!string.IsNullOrEmpty(mos.Text))
{
MessageType type = MessageType.Regular;
ushort hue = Engine.Profile.Current.SpeechHue;
switch (macro.Code)
{
case MacroType.Emote:
type = MessageType.Emote;
hue = Engine.Profile.Current.EmoteHue;
break;
case MacroType.Whisper:
type = MessageType.Whisper;
hue = Engine.Profile.Current.WhisperHue;
break;
case MacroType.Yell:
type = MessageType.Yell;
break;
}
GameActions.Say(mos.Text, hue, type);
}
break;
case MacroType.Walk:
byte dt = (byte)Direction.Up;
if (macro.SubCode != MacroSubType.NW)
{
dt = (byte)(macro.SubCode - 2);
if (dt > 7)
{
dt = 0;
}
}
if (!Pathfinder.AutoWalking)
{
World.Player.Walk((Direction)dt, false);
}
break;
case MacroType.WarPeace:
GameActions.ChangeWarMode();
break;
case MacroType.Paste:
if (SDL.SDL_HasClipboardText() != SDL.SDL_bool.SDL_FALSE)
{
string s = SDL.SDL_GetClipboardText();
if (!string.IsNullOrEmpty(s))
{
Engine.UI.SystemChat.textBox.Text += s;
}
}
break;
case MacroType.Open:
case MacroType.Close:
case MacroType.Minimize:
case MacroType.Maximize:
switch (macro.Code)
{
case MacroType.Open:
switch (macro.SubCode)
{
case MacroSubType.Configuration:
OptionsGump opt = Engine.UI.GetGump <OptionsGump>();
if (opt == null)
{
Engine.UI.Add(opt = new OptionsGump());
opt.SetInScreen();
}
else
{
opt.SetInScreen();
opt.BringOnTop();
}
break;
case MacroSubType.Paperdoll:
GameActions.OpenPaperdoll(World.Player);
break;
case MacroSubType.Status:
if (StatusGumpBase.GetStatusGump() == null)
{
StatusGumpBase.AddStatusGump(100, 100);
}
break;
case MacroSubType.Journal:
JournalGump journalGump = Engine.UI.GetGump <JournalGump>();
if (journalGump == null)
{
Engine.UI.Add(new JournalGump
{
X = 64, Y = 64
});
}
else
{
journalGump.SetInScreen();
journalGump.BringOnTop();
}
break;
case MacroSubType.Skills:
World.SkillsRequested = true;
NetClient.Socket.Send(new PSkillsRequest(World.Player));
break;
case MacroSubType.MageSpellbook:
case MacroSubType.NecroSpellbook:
case MacroSubType.PaladinSpellbook:
case MacroSubType.BushidoSpellbook:
case MacroSubType.NinjitsuSpellbook:
case MacroSubType.SpellWeavingSpellbook:
case MacroSubType.MysticismSpellbook:
SpellBookType type = SpellBookType.Magery;
switch (macro.SubCode)
{
case MacroSubType.NecroSpellbook:
type = SpellBookType.Necromancy;
break;
case MacroSubType.PaladinSpellbook:
type = SpellBookType.Chivalry;
break;
case MacroSubType.BushidoSpellbook:
type = SpellBookType.Bushido;
break;
case MacroSubType.NinjitsuSpellbook:
type = SpellBookType.Ninjitsu;
break;
case MacroSubType.SpellWeavingSpellbook:
type = SpellBookType.Spellweaving;
break;
case MacroSubType.MysticismSpellbook:
type = SpellBookType.Mysticism;
break;
case MacroSubType.BardSpellbook:
type = SpellBookType.Bardic;
break;
}
NetClient.Socket.Send(new POpenSpellBook((byte)type));
break;
case MacroSubType.Chat:
Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");
break;
case MacroSubType.Backpack:
Item backpack = World.Player.Equipment[(int)Layer.Backpack];
if (backpack != null)
{
GameActions.DoubleClick(backpack);
}
break;
case MacroSubType.Overview:
MiniMapGump miniMapGump = Engine.UI.GetGump <MiniMapGump>();
if (miniMapGump == null)
{
Engine.UI.Add(new MiniMapGump());
}
else
{
miniMapGump.ToggleSize();
miniMapGump.SetInScreen();
miniMapGump.BringOnTop();
}
break;
case MacroSubType.WorldMap:
Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");
break;
case MacroSubType.Mail:
case MacroSubType.PartyManifest:
var party = Engine.UI.GetGump <PartyGumpAdvanced>();
if (party == null)
{
Engine.UI.Add(new PartyGumpAdvanced());
}
else
{
party.BringOnTop();
}
break;
case MacroSubType.Guild:
GameActions.OpenGuildGump();
break;
case MacroSubType.QuestLog:
GameActions.RequestQuestMenu();
break;
case MacroSubType.PartyChat:
case MacroSubType.CombatBook:
case MacroSubType.RacialAbilitiesBook:
case MacroSubType.BardSpellbook:
Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");
break;
}
break;
case MacroType.Close:
case MacroType.Minimize: // TODO: miniminze/maximize
case MacroType.Maximize:
switch (macro.SubCode)
{
case MacroSubType.Configuration:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <OptionsGump>()?.Dispose();
}
break;
case MacroSubType.Paperdoll:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <PaperDollGump>()?.Dispose();
}
break;
case MacroSubType.Status:
if (macro.Code == MacroType.Close)
{
StatusGumpBase.GetStatusGump()?.Dispose();
}
break;
case MacroSubType.Journal:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <JournalGump>()?.Dispose();
}
break;
case MacroSubType.Skills:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <SkillGumpAdvanced>()?.Dispose();
}
break;
case MacroSubType.MageSpellbook:
case MacroSubType.NecroSpellbook:
case MacroSubType.PaladinSpellbook:
case MacroSubType.BushidoSpellbook:
case MacroSubType.NinjitsuSpellbook:
case MacroSubType.SpellWeavingSpellbook:
case MacroSubType.MysticismSpellbook:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <SpellbookGump>()?.Dispose();
}
break;
case MacroSubType.Chat:
Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");
break;
case MacroSubType.Overview:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <MiniMapGump>()?.Dispose();
}
break;
case MacroSubType.Mail:
Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");
break;
case MacroSubType.PartyManifest:
if (macro.Code == MacroType.Close)
{
Engine.UI.GetGump <PartyGumpAdvanced>()?.Dispose();
}
break;
case MacroSubType.PartyChat:
case MacroSubType.CombatBook:
case MacroSubType.RacialAbilitiesBook:
case MacroSubType.BardSpellbook:
Log.Message(LogTypes.Warning, $"Macro '{macro.SubCode}' not implemented");
break;
}
break;
}
break;
case MacroType.OpenDoor:
GameActions.OpenDoor();
break;
case MacroType.UseSkill:
int skill = macro.SubCode - MacroSubType.Anatomy;
if (skill >= 0 && skill < 24)
{
skill = _skillTable[skill];
if (skill != 0xFF)
{
GameActions.UseSkill(skill);
}
}
break;
case MacroType.LastSkill:
GameActions.UseSkill(GameActions.LastSkillIndex);
break;
case MacroType.CastSpell:
int spell = macro.SubCode - MacroSubType.Clumsy + 1;
if (spell > 0 && spell <= 151)
{
int totalCount = 0;
int spellType = 0;
for (spellType = 0; spellType < 7; spellType++)
{
totalCount += _spellsCountTable[spellType];
if (spell < totalCount)
{
break;
}
}
if (spellType < 7)
{
spell += spellType * 100;
if (spellType > 2)
{
spell += 100;
}
GameActions.CastSpell(spell);
}
}
break;
case MacroType.LastSpell:
GameActions.CastSpell(GameActions.LastSpellIndex);
break;
case MacroType.Bow:
case MacroType.Salute:
int index = macro.Code - MacroType.Bow;
const string BOW = "bow";
const string SALUTE = "salute";
GameActions.EmoteAction(index == 0 ? BOW : SALUTE);
break;
case MacroType.QuitGame:
Engine.SceneManager.GetScene <GameScene>()?.RequestQuitGame();
break;
case MacroType.AllNames:
GameActions.AllNames();
break;
case MacroType.LastObject:
if (World.Get(GameActions.LastObject) != null)
{
GameActions.DoubleClick(GameActions.LastObject);
}
break;
case MacroType.UseItemInHand:
Item itemInLeftHand = World.Player.Equipment[(int)Layer.OneHanded];
if (itemInLeftHand != null)
{
GameActions.DoubleClick(itemInLeftHand.Serial);
}
else
{
Item itemInRightHand = World.Player.Equipment[(int)Layer.TwoHanded];
if (itemInRightHand != null)
{
GameActions.DoubleClick(itemInRightHand.Serial);
}
}
break;
case MacroType.LastTarget:
//if (WaitForTargetTimer == 0)
// WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;
if (TargetManager.IsTargeting)
{
//if (TargetManager.TargetingState != TargetType.Object)
//{
// TargetManager.TargetGameObject(TargetManager.LastGameObject);
//}
//else
TargetManager.TargetGameObject(World.Get(TargetManager.LastTarget));
WaitForTargetTimer = 0;
}
else if (WaitForTargetTimer < Engine.Ticks)
{
WaitForTargetTimer = 0;
}
else
{
result = 1;
}
break;
case MacroType.TargetSelf:
//if (WaitForTargetTimer == 0)
// WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;
if (TargetManager.IsTargeting)
{
TargetManager.TargetGameObject(World.Player);
WaitForTargetTimer = 0;
}
else if (WaitForTargetTimer < Engine.Ticks)
{
WaitForTargetTimer = 0;
}
else
{
result = 1;
}
break;
case MacroType.ArmDisarm:
int handIndex = 1 - (macro.SubCode - MacroSubType.LeftHand);
GameScene gs = Engine.SceneManager.GetScene <GameScene>();
if (handIndex < 0 || handIndex > 1 || gs.IsHoldingItem)
{
break;
}
if (_itemsInHand[handIndex] != 0)
{
Item item = World.Items.Get(_itemsInHand[handIndex]);
if (item != null)
{
GameActions.PickUp(item, 1);
gs.WearHeldItem(World.Player);
}
_itemsInHand[handIndex] = 0;
}
else
{
Item backpack = World.Player.Equipment[(int)Layer.Backpack];
if (backpack == null)
{
break;
}
Item item = World.Player.Equipment[(int)Layer.OneHanded + handIndex];
if (item != null)
{
_itemsInHand[handIndex] = item.Serial;
GameActions.PickUp(item, 1);
GameActions.DropItem(item, Position.INVALID, backpack);
}
}
break;
case MacroType.WaitForTarget:
if (WaitForTargetTimer == 0)
{
WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;
}
if (TargetManager.IsTargeting || WaitForTargetTimer < Engine.Ticks)
{
WaitForTargetTimer = 0;
}
else
{
result = 1;
}
break;
case MacroType.TargetNext:
if (TargetManager.LastTarget.IsMobile)
{
Mobile mob = World.Mobiles.Get(TargetManager.LastTarget);
if (mob == null)
{
break;
}
if (mob.HitsMax == 0)
{
NetClient.Socket.Send(new PStatusRequest(mob));
}
TargetManager.LastAttack = mob.Serial;
}
break;
case MacroType.AttackLast:
GameActions.Attack(TargetManager.LastTarget);
break;
case MacroType.Delay:
MacroObjectString mosss = (MacroObjectString)macro;
string str = mosss.Text;
if (!string.IsNullOrEmpty(str) && int.TryParse(str, out int rr))
{
_nextTimer = Engine.Ticks + rr;
}
break;
case MacroType.CircleTrans:
Engine.Profile.Current.UseCircleOfTransparency = !Engine.Profile.Current.UseCircleOfTransparency;
break;
case MacroType.CloseGump:
Engine.UI.Gumps
.Where(s => !(s is TopBarGump) && !(s is BuffGump) && !(s is WorldViewportGump))
.ToList()
.ForEach(s => s.Dispose());
break;
case MacroType.AlwaysRun:
Engine.Profile.Current.AlwaysRun = !Engine.Profile.Current.AlwaysRun;
GameActions.Print($"Always run is now {(Engine.Profile.Current.AlwaysRun ? "on" : "off")}.");
break;
case MacroType.SaveDesktop:
Engine.Profile.Current?.Save(Engine.UI.Gumps.OfType <Gump>().Where(s => s.CanBeSaved).Reverse().ToList());
break;
case MacroType.EnableRangeColor:
Engine.Profile.Current.NoColorObjectsOutOfRange = true;
break;
case MacroType.DisableRangeColor:
Engine.Profile.Current.NoColorObjectsOutOfRange = false;
break;
case MacroType.ToggleRangeColor:
Engine.Profile.Current.NoColorObjectsOutOfRange = !Engine.Profile.Current.NoColorObjectsOutOfRange;
break;
case MacroType.AttackSelectedTarget:
// TODO:
break;
case MacroType.UseSelectedTarget:
// TODO:
break;
case MacroType.CurrentTarget:
// TODO:
break;
case MacroType.TargetSystemOnOff:
// TODO:
break;
case MacroType.BandageSelf:
case MacroType.BandageTarget:
if (FileManager.ClientVersion < ClientVersions.CV_5020 || Engine.Profile.Current.BandageSelfOld)
{
if (WaitingBandageTarget)
{
if (WaitForTargetTimer == 0)
{
WaitForTargetTimer = Engine.Ticks + Constants.WAIT_FOR_TARGET_DELAY;
}
if (TargetManager.IsTargeting)
{
TargetManager.TargetGameObject(macro.Code == MacroType.BandageSelf ? World.Player : World.Mobiles.Get(TargetManager.LastTarget));
}
else
{
result = 1;
}
WaitingBandageTarget = false;
WaitForTargetTimer = 0;
}
else
{
var bandage = World.Player.FindBandage();
if (bandage != null)
{
WaitingBandageTarget = true;
GameActions.DoubleClick(bandage);
result = 1;
}
}
}
else
{
var bandage = World.Player.FindBandage();
if (bandage != null)
{
if (macro.Code == MacroType.BandageSelf)
{
NetClient.Socket.Send(new PTargetSelectedObject(bandage.Serial, World.Player.Serial));
}
else
{
// TODO: NewTargetSystem
Log.Message(LogTypes.Warning, "BandageTarget (NewTargetSystem) not implemented yet.");
}
}
}
break;
case MacroType.SetUpdateRange:
case MacroType.ModifyUpdateRange:
if (macro is MacroObjectString moss && !string.IsNullOrEmpty(moss.Text) && byte.TryParse(moss.Text, out byte res))
{
if (res < Constants.MIN_VIEW_RANGE)
{
res = Constants.MIN_VIEW_RANGE;
}
else if (res > Constants.MAX_VIEW_RANGE)
{
res = Constants.MAX_VIEW_RANGE;
}
World.ClientViewRange = res;
GameActions.Print($"ClientViewRange is now {res}.");
}
break;
case MacroType.IncreaseUpdateRange:
World.ClientViewRange++;
if (World.ClientViewRange > Constants.MAX_VIEW_RANGE)
{
World.ClientViewRange = Constants.MAX_VIEW_RANGE;
}
GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");
break;
case MacroType.DecreaseUpdateRange:
World.ClientViewRange--;
if (World.ClientViewRange < Constants.MIN_VIEW_RANGE)
{
World.ClientViewRange = Constants.MIN_VIEW_RANGE;
}
GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");
break;
case MacroType.MaxUpdateRange:
World.ClientViewRange = Constants.MAX_VIEW_RANGE;
GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");
break;
case MacroType.MinUpdateRange:
World.ClientViewRange = Constants.MIN_VIEW_RANGE;
GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");
break;
case MacroType.DefaultUpdateRange:
World.ClientViewRange = Constants.MAX_VIEW_RANGE;
GameActions.Print($"ClientViewRange is now {World.ClientViewRange}.");
break;
case MacroType.SelectNext:
case MacroType.SelectPrevious:
case MacroType.SelectNearest:
// TODO:
int scantype = macro.SubCode - MacroSubType.Hostile;
int scanRange = macro.Code - MacroType.SelectNext;
switch (scanRange)
{
case 0:
break;
case 1:
break;
case 2:
break;
}
break;
case MacroType.ToggleBuffIconGump:
BuffGump buff = Engine.UI.GetGump <BuffGump>();
if (buff != null)
{
buff.Dispose();
}
else
{
Engine.UI.Add(new BuffGump(100, 100));
}
break;
case MacroType.InvokeVirtue:
byte id = (byte)(macro.SubCode - MacroSubType.Honor + 31);
NetClient.Socket.Send(new PInvokeVirtueRequest(id));
break;
case MacroType.PrimaryAbility:
GameActions.UsePrimaryAbility();
break;
case MacroType.SecondaryAbility:
GameActions.UseSecondaryAbility();
break;
case MacroType.ToggleGargoyleFly:
if (World.Player.Race == RaceType.GARGOYLE)
{
NetClient.Socket.Send(new PToggleGargoyleFlying());
}
break;
case MacroType.EquipLastWeapon:
NetClient.Socket.Send(new PEquipLastWeapon());
break;
case MacroType.KillGumpOpen:
// TODO:
break;
case MacroType.DefaultScale:
Engine.SceneManager.GetScene <GameScene>().Scale = 1;
break;
case MacroType.ToggleChatVisibility:
Engine.UI.SystemChat?.ToggleChatVisibility();
break;
case MacroType.MovePlayer:
switch (macro.SubCode)
{
case MacroSubType.Top:
break;
case MacroSubType.Right:
break;
case MacroSubType.Down:
break;
case MacroSubType.Left:
break;
}
break;
case MacroType.Aura:
// hold to draw
break;
case MacroType.AuraOnOff:
Engine.AuraManager.ToggleVisibility();
break;
case MacroType.Grab:
GameActions.Print("Target an Item to grab it.");
TargetManager.SetTargeting(CursorTarget.Grab, Serial.INVALID, TargetType.Neutral);
break;
case MacroType.SetGrabBag:
GameActions.Print("Target the container to Grab items into.");
TargetManager.SetTargeting(CursorTarget.SetGrabBag, Serial.INVALID, TargetType.Neutral);
break;
case MacroType.NamesOnOff:
NameOverHeadManager.ToggleOverheads();
break;
case MacroType.UsePotion:
scantype = macro.SubCode - MacroSubType.ConfusionBlastPotion;
ushort start = (ushort)(0x0F06 + scantype);
Item potion = World.Player.FindItemByGraphic(start);
if (potion != null)
{
GameActions.DoubleClick(potion);
}
break;
}
return(result);
}