public void DeleteRoom()
{
if (AreaIndex == IndexNone)
{
return;
}
var a = new ActiveItems(this);
if (ForceDeleteRoom())
{
HandlingSelection = true;
ForceSelectRoom(Math.Min(RoomIndex, Rooms [AreaIndex].Count - 1));
RoomListChanged?.Invoke(this, new ListLoadEventArgs(RoomIndex));
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
public void AddFxData(int doorIndex)
{
if (ActiveFx == null)
{
return;
}
var a = new ActiveItems(this);
if (ForceAddFxData(doorIndex))
{
HandlingSelection = true;
ForceSelectFxData(0);
FxDataListChanged?.Invoke(this, new ListLoadEventArgs(FxDataIndex));
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
public void DeleteDoor()
{
if (ActiveRoom?.MyDoorSet == null || ActiveDoor == null)
{
return;
}
var a = new ActiveItems(this);
if (ForceRemoveDoor())
{
HandlingSelection = true;
ForceSelectDoor(Math.Max(DoorIndex, ActiveRoom.MyDoorSet.DoorCount - 1));
DoorListChanged?.Invoke(this, new ListLoadEventArgs(DoorIndex));
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
private float GetComboDamage(Obj_AI_Base target)
{
var rStacks = GetRStacks();
var comboDamage = 0d;
int mode = menu.Item("Combo_mode", true).GetValue <StringList>().SelectedIndex;
if (mode == 0)
{
if (Q.IsReady())
{
comboDamage += (Player.GetSpellDamage(target, SpellSlot.Q) +
Player.CalcDamage(target, Damage.DamageType.Magical,
(45 + 35 * Q.Level + 0.5 * Player.FlatMagicDamageMod)));
}
}
else if (Q.IsReady())
{
comboDamage += (Player.GetSpellDamage(target, SpellSlot.Q) + Player.CalcDamage(target, Damage.DamageType.Magical, (45 + 35 * Q.Level + 0.5 * Player.FlatMagicDamageMod))) * 2;
}
if (E.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.E);
}
if (HasBuff(target, "AkaliMota"))
{
comboDamage += Player.CalcDamage(target, Damage.DamageType.Magical, (45 + 35 * Q.Level + 0.5 * Player.FlatMagicDamageMod));
}
comboDamage += Player.CalcDamage(target, Damage.DamageType.Magical, CalcPassiveDmg());
if (rStacks > 0)
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.R) * rStacks;
}
if (Ignite_Ready())
{
comboDamage += Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
}
comboDamage = ActiveItems.CalcDamage(target, comboDamage);
return((float)(comboDamage + Player.GetAutoAttackDamage(target)));
}
//========================================================================================
// Object management - exposed methods.
public void AddRoom()
{
if (AreaIndex == IndexNone)
{
return;
}
var a = new ActiveItems(this);
if (ForceAddRoom(1, 1, 1, 1, "(new room)"))
{
HandlingSelection = true;
ForceSelectRoom(Rooms [AreaIndex].Count - 1);
RoomListChanged?.Invoke(this, new ListLoadEventArgs(RoomIndex));
//RoomStateListChanged?.Invoke (this, new ListLoadEventArgs (RoomStateIndex));
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
public void DeleteFxData()
{
if (ActiveFx == null || FxDataIndex == IndexNone)
{
return;
}
var a = new ActiveItems(this);
if (ForceDeleteFxData())
{
HandlingSelection = true;
int newIndex = Math.Min(FxDataIndex, ActiveFx.FxDataCount - 1);
ForceSelectFxData(newIndex);
FxDataListChanged?.Invoke(this, new ListLoadEventArgs(FxDataIndex));
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
public void SelectFxData(int index)
{
if (HandlingSelection)
{
return;
}
if (ActiveFx == null || index == FxDataIndex || index < -1 ||
index >= ActiveFx.FxDataCount)
{
return;
}
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectFxData(index);
RaiseChangeEvents(a);
HandlingSelection = false;
}
public void SelectEnemyGfx(int index)
{
if (HandlingSelection)
{
return;
}
if (ActiveRoomState == null || index == EnemyGfxIndex || index < -1 ||
index >= ActiveRoomState.MyEnemyGfx.EnemyGfxCount)
{
return;
}
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectEnemyGfx(index);
RaiseChangeEvents(a);
HandlingSelection = false;
}
public void SelectRoomState(int index)
{
if (HandlingSelection)
{
return;
}
if (ActiveRoom == null || index == RoomStateIndex || index < -1 ||
index >= ActiveRoom.RoomStates.Count)
{
return;
}
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectRoomState(index);
RaiseChangeEvents(a);
HandlingSelection = false;
}
public void SelectDoor(int index)
{
if (HandlingSelection)
{
return;
}
if (ActiveRoom == null || index == DoorIndex || index < -1 ||
index >= ActiveRoom.MyDoorSet.DoorCount)
{
return;
}
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectDoor(index);
RaiseChangeEvents(a);
HandlingSelection = false;
}
public void SelectRoom(int index)
{
if (HandlingSelection)
{
return;
}
if (AreaIndex == IndexNone || index == RoomIndex || index < -1 ||
index >= Rooms [AreaIndex].Count)
{
return;
}
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectRoom(index);
RaiseChangeEvents(a);
HandlingSelection = false;
}
private float GetComboDamage(Obj_AI_Base enemy)
{
if (enemy == null)
{
return(0);
}
double damage = 0d;
if (Q.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
damage += Player.GetSpellDamage(enemy, SpellSlot.Q, 1);
}
if (Dfg.IsReady())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
}
if (W.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
}
if (_rOn)
{
damage += Player.GetSpellDamage(enemy, SpellSlot.R) * RCount();
}
else if (R.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.R) * 3;
}
damage = ActiveItems.CalcDamage(enemy, damage);
if (E.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
return((float)damage);
}
public void DeleteEnemyGfx()
{
if (ActiveRoomState?.MyEnemyGfx == null || EnemyGfxIndex == IndexNone)
{
return;
}
var a = new ActiveItems(this);
if (ForceDeleteEnemyGfx())
{
HandlingSelection = true;
int newIndex = Math.Min(EnemyGfxIndex,
ActiveRoomState.MyEnemyGfx.EnemyGfxCount - 1);
ForceSelectEnemyGfx(newIndex);
EnemyGfxListChanged?.Invoke(this, new ListLoadEventArgs(EnemyGfxIndex));
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
public void DeactivateItem(object item, bool close)
{
var guard = item as IGuardClose;
if (guard != null)
{
guard.CanClose(result =>
{
if (result)
{
CloseActiveItem(ActiveItems.Single(x => x == (IScreenWithClose)item));
}
});
}
else
{
CloseActiveItem(ActiveItems.Single(x => x == (IScreenWithClose)item));
}
}
public void ShootArrow()
{
if (ActiveItems.FindAll((IUsableItem item) => item is UsableArrow).Count > 0)
{
return;
}
if (ItemCounts[ItemType.Bow] == 0)
{
return;
}
if (ItemCounts[ItemType.Arrow] <= 0)
{
return;
}
if (ItemCounts[ItemType.Rupee] <= 0)
{
return;
}
State.ShootArrow();
}
private float GetComboDamage(Obj_AI_Base target)
{
double comboDamage = 0;
if (Q.IsReady())
comboDamage += Player.GetSpellDamage(target, SpellSlot.Q) * 2;
if (W.IsReady())
comboDamage += Player.GetSpellDamage(target, SpellSlot.W);
if (E.IsReady())
comboDamage += Player.GetSpellDamage(target, SpellSlot.E) * 2;
if ((target.Health / target.MaxHealth * 100) <= 50)
comboDamage += CalcPassive(target);
if (HasBuff(target, "zedulttargetmark"))
{
if (R.Level == 1)
comboDamage += comboDamage * 1.2;
else if(R.Level == 2)
comboDamage += comboDamage * 1.35;
else if(R.Level == 3)
comboDamage += comboDamage * 1.5;
}
if (R.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.R);
if (R.Level == 1)
comboDamage += comboDamage * 1.2;
else if (R.Level == 2)
comboDamage += comboDamage * 1.35;
else if (R.Level == 3)
comboDamage += comboDamage * 1.5;
}
comboDamage = ActiveItems.CalcDamage(target, comboDamage);
return (float)(comboDamage + Player.GetAutoAttackDamage(target) * 2);
}
/*
public override void ObjAiHeroOnOnIssueOrder(Obj_AI_Base sender, GameObjectIssueOrderEventArgs args)
{
if (!sender.IsEnemy || !menu.Item("qAA", true).GetValue<KeyBind>().Active || (args.Target is Obj_AI_Minion))
return;
if (sender.IsValidTarget(Q.Range))
Q.Cast(sender.ServerPosition, packets());
}*/
/*static void Game_OnGameProcessPacket(GamePacketEventArgs args)
{
GamePacket g = new GamePacket(args.PacketData);
if (g.Header != 0xFE)
return;
if (menu.Item("qAA", true).GetValue<KeyBind>().Active)
{
if (Packet.MultiPacket.OnAttack.Decoded(args.PacketData).Type == Packet.AttackTypePacket.TargetedAA)
{
g.Position = 1;
var k = ObjectManager.GetUnitByNetworkId<Obj_AI_Base>(g.ReadInteger());
if (k is Obj_AI_Hero && k.IsEnemy)
{
if (Vector3.Distance(k.Position, Player.Position) <= Q.Range)
{
Q.Cast(k.Position, packets());
}
}
}
}
}*/
private float GetComboDamage(Obj_AI_Base enemy)
{
double damage = 0d;
if (Q.IsReady())
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
if (W.IsReady())
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
if (E.IsReady())
damage += Player.GetSpellDamage(enemy, SpellSlot.E) * 2;
if (R.IsReady())
damage += GetUltDmg((Obj_AI_Hero)enemy);
damage = ActiveItems.CalcDamage(enemy, damage);
return (float)damage;
}
//----------------------------------------------------------------------------------------
// Check if tile in room is door tile; if it is, select the destination room.
public bool NavigateThroughDoor(int row, int col, out int screenX, out int screenY)
{
screenX = 0;
screenY = 0;
if (ActiveRoom?.MyDoorSet == null || ActiveLevelData == null)
{
return(false);
}
List <Door> doors = ActiveRoom.MyDoorSet.MyDoors;
if (GetBtsType(row, col) != 0x9) // return if not door
{
return(false);
}
int index = GetBtsValue(row, col);
if (index >= doors.Count)
{
return(false);
}
Room targetRoom = doors [index].MyTargetRoom;
if (targetRoom == null)
{
return(false);
}
int targetArea = targetRoom.Area;
screenX = doors [index].ScreenX;
screenY = doors [index].ScreenY;
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectArea(targetArea);
ForceSelectRoom(Rooms [targetArea].FindIndex(x => x == targetRoom));
RaiseChangeEvents(a);
HandlingSelection = false;
return(true);
}
//----------------------------------------------------------------------------------------
// Renders a screen from a room.
public void RenderScreen(int areaIndex, int roomIndex, BlitImage screenImage,
int x, int y)
{
if (areaIndex >= 0 && areaIndex < AreaCount &&
roomIndex >= 0 && roomIndex < Rooms [areaIndex].Count)
{
ActiveItems a = new ActiveItems(this);
ActiveRoom = (Room)Rooms [areaIndex] [roomIndex];
ActiveRoomState = ActiveRoom.RoomStates.Last();
LoadRoomTiles(ActiveRoomState.TileSet);
LoadBackground();
RenderScreen(screenImage, x, y);
ActiveRoom = a.ActiveRoom;
ActiveRoomState = a.ActiveRoomState;
LoadRoomTiles(ActiveRoomState.TileSet);
LoadBackground();
}
else
{
screenImage.Black();
}
}
public void ChangeMemberStatus(IEMember member, int newStatus)
{
switch (member.Status)
{
case IEMember.MEMBER_NEW:
NewItems.Remove(member);
break;
case IEMember.MEMBER_REJECTED:
RejectedItems.Remove(member);
break;
default:
ActiveItems.Remove(member);
break;
}
member.Status = newStatus;
switch (member.Status)
{
case IEMember.MEMBER_NEW:
NewItems.Add(member);
break;
case IEMember.MEMBER_REJECTED:
RejectedItems.Add(member);
break;
default:
ActiveItems.Add(member);
break;
}
NewItems.Sort();
RejectedItems.Sort();
ActiveItems.Sort();
SaveMember(member);
}
public void TryCloseActiveItem()
{
if (_isClosing)
{
return;
}
lock (_closeLock)
{
_isClosing = true;
if (ActiveItems.None())
{
return;
}
var item = ActiveItems.Last();
var screen = item;
var busyScreen = screen as IGetBusy;
if (busyScreen != null && busyScreen.IsBusy)
{
Task.Run(async() => await CloseWaitingItem(new WaitingToClose(item)));
_isClosing = false;
return;
}
screen.TryClose();
var disposable = screen as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
_isClosing = false;
}
}
private float GetComboDamage(Obj_AI_Base enemy)
{
if (enemy == null)
{
return(0);
}
var damage = 0d;
if (_canQcd == 0 && _canEcd == 0 && Q.Level > 0 && E.Level > 0)
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q) * 1.4;
}
else if (_canQcd == 0 && Q.Level > 0)
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (_hamQcd == 0 && Q.Level > 0)
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q, 1);
}
if (_hamWcd == 0 && W.Level > 0)
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
}
if (_hamEcd == 0 && E.Level > 0)
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
damage = ActiveItems.CalcDamage(enemy, damage);
damage += Player.GetAutoAttackDamage(enemy) * 3;
return((float)damage);
}
private float GetComboDamage(Obj_AI_Base enemy)
{
var damage = 0d;
if (Q.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (E.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
if (R.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.R);
}
damage += Player.GetAutoAttackDamage(enemy);
damage = ActiveItems.CalcDamage(enemy, damage);
return((float)damage);
}
private float GetComboDamage(Obj_AI_Base target)
{
double comboDamage = 0;
if (Q.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.Q) * 2;
}
if (W.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.W);
}
if (R.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.R) * GetShots();
}
comboDamage = ActiveItems.CalcDamage(target, comboDamage);
return((float)(comboDamage + Player.GetAutoAttackDamage(target) * 2));
}
private float GetComboDamage(Obj_AI_Base target)
{
double comboDamage = 0;
if (Q.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.Q) * 2;
}
if (W.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.W);
}
if (R.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.R) / countEnemiesNearPosition(target.ServerPosition, R.Range);
}
comboDamage = ActiveItems.CalcDamage(target, comboDamage);
return((float)(comboDamage + Player.GetAutoAttackDamage(target) * 3));
}
private float GetComboDamage(Obj_AI_Base target)
{
double comboDamage = 0;
if (Q.IsReady())
{
comboDamage += GetCurrentHeat() > 50 ? Player.GetSpellDamage(target, SpellSlot.Q) * 2 : Player.GetSpellDamage(target, SpellSlot.Q);
}
if (E.IsReady())
{
comboDamage += GetCurrentHeat() > 50 ? Player.GetSpellDamage(target, SpellSlot.E) * 1.5: Player.GetSpellDamage(target, SpellSlot.E);
}
if (R.IsReady())
{
comboDamage += Player.GetSpellDamage(target, SpellSlot.R) * 3;
}
comboDamage = ActiveItems.CalcDamage(target, comboDamage);
return((float)(comboDamage + Player.GetAutoAttackDamage(target)));
}
// Add a new PLM.
public void AddPlm(int col, int row)
{
if (ActivePlmSet == null || ActivePlmType == null)
{
return;
}
if (ForceAddPlm(col, row))
{
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectPlm(ActivePlmSet.PlmCount - 1);
PlmListChanged?.Invoke(this, new ListLoadEventArgs(PlmIndex));
var e = new LevelDataEventArgs()
{
ScreenXmin = 0,
ScreenXmax = RoomWidthInScreens - 1,
ScreenYmin = 0,
ScreenYmax = RoomHeightInScreens - 1
};
LevelDataModified?.Invoke(this, e);
RaiseChangeEvents(a);
HandlingSelection = false;
}
}
// Select PLM at given tile position (col, row), updates row, col, width & height to
// exact position and size of PLM.
public bool SelectPlmAt(int col, int row)
{
if (ActivePlmSet == null)
{
return(false);
}
for (int index = 0; index < ActivePlmSet.PlmCount; index++)
{
Plm p = ActivePlmSet.Plms [index];
int width = p.MyPlmType?.Graphics.Width / 16 ?? 0;
int height = p.MyPlmType?.Graphics.Height / 16 ?? 0;
if (col >= p.PosX && col < p.PosX + width &&
row >= p.PosY && row < p.PosY + height)
{
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectPlm(index);
RaiseChangeEvents(a);
HandlingSelection = false;
return(true);
}
}
return(false);
}
private float GetComboDamage(Obj_AI_Base enemy)
{
if (enemy == null)
{
return(0);
}
double damage = 0d;
if (Q.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (W.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W) * 3;
}
if (E.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
if (R.IsReady())
{
damage += damage * 1.2;
damage += Player.GetSpellDamage(enemy, SpellSlot.R);
}
damage += Player.GetAutoAttackDamage(enemy) * 3;
damage = ActiveItems.CalcDamage(enemy, damage);
return((float)damage);
}
// Select enemy at given pixel position (x, y), updates x, y, width & height to
// exact position and size of enemy.
public bool SelectEnemyAt(double x, double y)
{
if (ActiveEnemySet == null)
{
return(false);
}
for (int index = 0; index < ActiveEnemySet.EnemyCount; index++)
{
Enemy e = ActiveEnemySet.Enemies [index];
double width = e.MyEnemyType?.Graphics.Width ?? 1.0;
double height = e.MyEnemyType?.Graphics.Height ?? 1.0;
if (x >= e.PosX - width / 2 && x < e.PosX + width / 2 &&
y >= e.PosY - height / 2 && y < e.PosY + height / 2)
{
HandlingSelection = true;
var a = new ActiveItems(this);
ForceSelectEnemy(index);
RaiseChangeEvents(a);
HandlingSelection = false;
return(true);
}
}
return(false);
}
