public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
var entryGold = combatLogEntry as CombatLogEntryGold;
var currentTime = entry.Map.ClockTime;
var additionalGold = currentTime / 30;
var predictedGold = 40 + additionalGold;
/*|| predictedGold + 2 >= entryGold.Gold &&
* predictedGold - 2 <= entryGold.Gold*/
if ((entryGold.Target != "npc_dota_hero_alchemist" ||
!(predictedGold * AlchemistBountyRuneMultiplier + 2 >= entryGold.Gold) ||
!(predictedGold * AlchemistBountyRuneMultiplier - 2 <= entryGold.Gold)) &&
(predictedGold + 2 < entryGold.Gold || predictedGold - 2 > entryGold.Gold))
{
return;
}
/*if (predictedGold + 2 < entryGold.Gold || entryGold.Gold < predictedGold - 2) return;*/
var member = entry.Members.SearchByHeroName(entryGold.Target);
var gold = entryGold.Gold;
Console.WriteLine($"{member.Hero.Name} got {gold} gold for someone picked up the bounty rune");
OnPickedUp(new BountyRunePickedupEventAegs {
Gold = gold, Member = member
});
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
foreach (var memberItem in _items)
{
var member = memberItem.Key;
var item = memberItem.Value;
switch (item.Name)
{
case "item_gem":
OnImportantItemRemoved(new ImportantItemRemovedEventArgs {
Member = member, IsGemAdded = true
});
break;
case "item_rapier":
OnImportantItemRemoved(new ImportantItemRemovedEventArgs {
Member = member, IsRapierAdded = true
});
break;
case "item_aegis":
OnImportantItemRemoved(new ImportantItemRemovedEventArgs {
Member = member, IsAegisAdded = true
});
break;
}
}
}
public CombatLogEntry GetCombatLogEntry(string combatLogEntryName)
{
CombatLogEntry dummyCombatLogEntry = new CombatLogEntry();
dummyCombatLogEntry.Name = "Dummy";
return(dummyCombatLogEntry);
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
var gold = combatLogEntry as CombatLogEntryGold;
OnGold(new KillsGoldEventArgs {
Member = entry.Members.SearchByHeroName(gold.Target), Gold = gold.Gold
});
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
OnModifierAdded(new RuneModifierAddedEventArgs
{
Member = entry.Members.SearchByHeroName(_hero),
Rune = _rune
});
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
if (combatLogEntry == null)
{
OnGameStateEventsCountChange(++_gameStateCount);
}
else
{
OnCombatLogEventsCountChange(++_combatLogCount);
}
}
public List <CombatLogEntry> GetCombatLogEntries(string fittingName)
{
List <CombatLogEntry> combatLogEntries = new List <CombatLogEntry>();
CombatLogEntry dummyCombatLogEntry = new CombatLogEntry();
dummyCombatLogEntry.Name = "Dummy";
combatLogEntries.Add(dummyCombatLogEntry);
return(combatLogEntries);
}
public bool EventPredicator(CombatLogEntry entry)
{
var gameState = entry as CombatLogEntryGameState;
if (gameState == null)
{
return(false);
}
if (gameState.State != (int)Map.GameState.DOTA_GAMERULES_STATE_GAME_IN_PROGRESS)
{
return(false);
}
return(true);
}
public bool EventPredicator(CombatLogEntry entry)
{
var entryGold = entry as CombatLogEntryGold;
if (entryGold == null)
{
return(false);
}
if (entryGold.GoldReason != GoldReason.Unspecified)
{
return(false);
}
return(true);
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
/*var radiant = entry.Members.Where(m => m.Player.TeamName == "radiant");
* var dire = entry.Members.Where(m => m.Player.TeamName == "dire");
*
* var networthRadiant = radiant.Sum(m => (double)m.Player.NetWorth);
* var networthDire = dire.Sum(m => (double)m.Player.NetWorth);
*
* var networthesRadiant = radiant.Select(member => Math.Round(member.Player.NetWorth / networthRadiant * 100, 1));
* var networthesDire = dire.Select(member => Math.Round(member.Player.NetWorth / networthDire * 100, 1));
*
* Percentages = networthesRadiant.Concat(networthesDire);*/
Networthes = entry.Members.Select(m => m.Player.NetWorth);
}
public bool EventPredicator(CombatLogEntry entry)
{
if (entry.Type != CombatLogEntryTypes.Gold)
{
return(false);
}
var gold = entry as CombatLogEntryGold;
if (gold.GoldReason != GoldReason.HeroKill)
{
return(false);
}
return(true);
}
public bool EventPredicator(CombatLogEntry entry)
{
if (entry.Type != CombatLogEntryTypes.Item)
{
return(false);
}
var item = (CombatLogEntryItem)entry;
if (item.Inflictor != "item_black_king_bar")
{
return(false);
}
_hero = item.AttackerName;
return(true);
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
var item = (CombatLogEntryItem)combatLogEntry;
var seconds = 10;
switch (item.AbilityLevel)
{
case 1:
seconds = 9;
break;
case 2:
seconds = 8;
break;
case 3:
seconds = 7;
break;
case 4:
seconds = 6;
break;
case 5:
seconds = 5;
break;
case 6:
seconds = 5;
break;
default:
break;
}
var args = new BkbUsedEventArgs
{
Member = entry.Members.SearchByHeroName(_hero),
Seconds = seconds
};
OnBkbUsed(args);
}
public void Add(CombatLogEntry entry)
{
_combatLogList.Add(entry);
if ((entry.SourceId == Assets.Scripts.Manager.NakamaManager.Instance.Session.UserId || entry.DestinationId == Assets.Scripts.Manager.NakamaManager.Instance.Session.UserId) && entry.TypeCase == CombatLogEntry.TypeOneofCase.Damage)
{
if (entry.Damage.Critical > 0)
{
OnNewDamage?.Invoke(entry.SourceId, new FloatingDamageEvent {
Target = entry.DestinationId, Value = entry.Damage.Amount + entry.Damage.Critical, Critical = true
});
}
else
{
OnNewDamage?.Invoke(entry.SourceId, new FloatingDamageEvent {
Target = entry.DestinationId, Value = entry.Damage.Amount, Critical = false
});
}
}
}
public void FullDBHelper()
{
IDBHelper db = new DBHelper_InMemory.DBHelper();
db.Init();
Fitting firstFitting = new Fitting();
string firstFittingName = "First Fitting Name";
firstFitting.Name = firstFittingName;
db.CreateFitting(firstFitting);
var getFirstFitting = db.GetFitting(firstFittingName);
Assert.AreEqual(getFirstFitting.Name.ToUpperInvariant(), firstFittingName.ToUpperInvariant());
var allFittings = db.GetAllFittings();
getFirstFitting = allFittings[0];
Assert.AreEqual(getFirstFitting.Name.ToUpperInvariant(), firstFittingName.ToUpperInvariant());
CombatLogEntry firstCombatLogEntry = new CombatLogEntry();
string firstCombatLogEntryName = "First Combat Log Entry Name";
firstCombatLogEntry.Name = firstCombatLogEntryName;
db.CreateCombatLogEntry(firstFittingName, firstCombatLogEntry);
var getCombatLogEntry = db.GetCombatLogEntry(firstCombatLogEntryName);
Assert.AreEqual(getCombatLogEntry.Name.ToUpperInvariant(), firstCombatLogEntryName.ToUpperInvariant());
CombatLogEntry secondCombatLogEntry = new CombatLogEntry();
string secondCombatLogEntryName = "Second Combat Log Entry Name";
secondCombatLogEntry.Name = secondCombatLogEntryName;
db.CreateCombatLogEntry(firstFittingName, secondCombatLogEntry);
getCombatLogEntry = db.GetCombatLogEntry(secondCombatLogEntryName);
Assert.AreEqual(getCombatLogEntry.Name.ToUpperInvariant(), secondCombatLogEntryName.ToUpperInvariant());
}
private static void CombatLogEventReceived(object sender, CombatLogEntry entry)
{
var stateEntry = _eyeStateIntegrator.StateEntry;
if (entry.Type == CombatLogEntryTypes.Damage)
{
var entryDamage = entry as CombatLogEntryDamage;
var attacker = stateEntry.Members.SearchByHeroName(entryDamage.AttackerName);
if (attacker == null)
{
return;
}
var target = stateEntry.Members.SearchByHeroName(entryDamage.Target);
Console.WriteLine($"{attacker.Player.Name}[{attacker.Hero.Name}] hit {(target != null ? target.Player.Name + $"[{target.Hero.Name}]" : entryDamage.Target)}");
}
/*if (entry.Type == CombatLogEntryTypes.ModifierAdd ||
* entry.Type == CombatLogEntryTypes.ModifierRemove)
* {
* var entryModifierChanged = entry as CombatLogEntryModifierAdd;
*
* var member = stateEntry.Members.SearchByHeroName(entryModifierChanged.Target);
* if(member == null) return;
*
* var name = member.Hero.Name;
* var modifiers = string.Join(", ", member.Modifiers.ActiveModifiers.Select(m => m.Name));
*
*
* Console.SetCursorPosition(0, member.Index);
* Console.Write(" ".PadLeft(Console.LargestWindowWidth - 1));
* Console.SetCursorPosition(0, member.Index + 1);
* Console.Write(" ".PadLeft(Console.LargestWindowWidth - 1));
*
*
* Console.SetCursorPosition(0, member.Index * 2);
* Console.Write(member.Hero.Alive ?
* $"{name} have {modifiers}!" :
* $"{name} dead!");
*
* }*/
}
private void CombatLogEventReceived(object sender, CombatLogEntry combatLogEntry)
{
AddToken(combatLogEntry.Token);
if (combatLogEntry.Token != CurrentToken)
{
return;
}
var combatlogEvents = _events.Where(e => e is IEyeStateComatLogEvent);
foreach (IEyeStateComatLogEvent combatlogEvent in combatlogEvents)
{
if (combatlogEvent.EventPredicator(combatLogEntry))
{
combatlogEvent.Execute(_entry, combatLogEntry);
}
}
}
private void CombatLogDataReceived(object sender, CombatLogEntry e)
{
if (!IsConnected)
{
return;
}
e.Token = _token;
var json = JsonConvert.SerializeObject(e);
var packet = new NetPacket();
packet.Write(0);
packet.Write(json);
Send(packet);
//Trace.WriteLine("CombatLog sended");
}
public bool EventPredicator(CombatLogEntry entry)
{
var modifierAdd = entry as CombatLogEntryModifierAdd;
if (modifierAdd == null)
{
return(false);
}
if (modifierAdd.Inflictor != "modifier_smoke_of_deceit")
{
return(false);
}
if (!modifierAdd.Target.StartsWith("npc_dota_hero"))
{
return(false);
}
_hero = modifierAdd.Target;
return(true);
}
public void DeleteCombatLogEntry(string combatLogEntryName)
{
var query = from Fitting fitting in _fittings.Values
from CombatLogEntry combatLogEntry in fitting.CombatLogEntries
where combatLogEntry.Name == combatLogEntryName
select fitting;
var fittingContainer = query.First <Fitting>();
CombatLogEntry toDelete = null;
foreach (CombatLogEntry combatLogEntry in fittingContainer.CombatLogEntries)
{
if (combatLogEntry.Name == combatLogEntryName)
{
toDelete = combatLogEntry;
}
}
if (!(toDelete == null))
{
fittingContainer.CombatLogEntries.Remove(toDelete);
}
}
public bool EventPredicator(CombatLogEntry entry)
{
var modifierAdd = entry as CombatLogEntryModifierAdd;
if (modifierAdd == null)
{
return(false);
}
if (!modifierAdd.Inflictor.StartsWith("modifier_rune"))
{
return(false);
}
if (!modifierAdd.Target.StartsWith("npc_dota_hero"))
{
return(false);
}
_hero = modifierAdd.Target;
_rune = modifierAdd.Inflictor.Replace("modifier_rune_", "");
return(true);
}
public static void Log(CombatLogMessageType type, string message) // Establishes how a Log should behave in the Combat UI
{
var entry = new CombatLogEntry();
entry.CombatLogMessageType = type;
entry.LogTime = DateTime.Now;
entry.LogTimeString = GetFormatedDate(entry.LogTime);
entry.LogMessage = message;
AddEntry(entry);
if (UseDebugLog) // In case there is an error with broadcasting messages in the CombatLog
{
switch (type)
{
case CombatLogMessageType.Error: Debug.LogError(message); break;
case CombatLogMessageType.Warning: Debug.LogWarning(message); break;
default: Debug.LogWarning(message); break;
}
}
if (OrderDesc)
{
OrderDescending();
}
else
{
OrderAscending();
}
if (LogEntries.Count > MaxLogEntries)
{
RemoveEntry(MaxLogEntries);
}
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
HeroesDamage = entry.Members.Select(m => m.Player.HeroDamage);
}
public bool EventPredicator(CombatLogEntry entry)
{
return(true);
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
OnGameEnded();
}
public void Execute(EyeStateEntry entry, CombatLogEntry combatLogEntry)
{
OnStateChanged(_state);
}
protected virtual void OnCombatLogReceived(CombatLogEntry e)
{
CombatLogReceived?.Invoke(this, e);
}
private void OnCombatLogReceived(object sender, CombatLogEntry entry)
{
OnCombatLogReceived(entry);
}
public static CombatLogEntry ParseRow(string RawEvent, DateTime timeStamp)
{
CombatLogEntry thisEntry = new CombatLogEntry();
string[] eventParameters = RawEvent.Split(',');
thisEntry.TimeStamp = timeStamp;
thisEntry.EventType = eventParameters[0];
thisEntry.SrcGuid = eventParameters[1];
thisEntry.DestGuid = eventParameters[4];
int baseParam = 7;
string[] eventTypeSplit = thisEntry.EventType.Split('_');
int next = 1;
switch (eventTypeSplit[0])
{
case "SWING":
break;
case "ENVIRONMENTAL":
baseParam = 8;
break;
case "DAMAGE":
if (eventTypeSplit.Length >= 3)
{
eventTypeSplit[2] = "MISSED";
next = 2;
}
else
eventTypeSplit[1] = "DAMAGE";
baseParam = 10;
thisEntry.SpellName = eventParameters[8].Trim('"');
thisEntry.SpellSchool = eventParameters[9];
break;
case "SPELL":
if (eventTypeSplit[1] == "PERIODIC" || eventTypeSplit[1] == "BUILDING")
next = 2;
baseParam = 10;
thisEntry.SpellID = eventParameters[7];
thisEntry.SpellName = eventParameters[8].Trim('"');
thisEntry.SpellSchool = eventParameters[9];
break;
case "RANGE":
if (eventTypeSplit[1] == "PERIODIC" || eventTypeSplit[1] == "BUILDING")
next = 2;
baseParam = 10;
thisEntry.SpellID = eventParameters[7];
thisEntry.SpellName = eventParameters[8].Trim('"');
thisEntry.SpellSchool = eventParameters[9];
break;
}
switch (eventTypeSplit[next])
{
case "DAMAGE":
thisEntry.Damage = Convert.ToInt32(eventParameters[baseParam]);
thisEntry.Overkill = Convert.ToInt32(eventParameters[baseParam + 1]);
thisEntry.DamageSchool = eventParameters[baseParam + 2];
thisEntry.Resisted = Convert.ToInt32(eventParameters[baseParam + 3]);
thisEntry.Blocked = Convert.ToInt32(eventParameters[baseParam + 4]);
thisEntry.Absorbed = Convert.ToInt32(eventParameters[baseParam + 5]);
if (eventParameters[baseParam + 6] == "1")
thisEntry.Critical = true;
else
thisEntry.Critical = false;
break;
case "MISSED":
thisEntry.MissType = eventParameters[baseParam];
if (eventParameters.Length == 9)
thisEntry.AmountMissed = Convert.ToInt32(eventParameters[baseParam + 1]);
break;
case "HEAL":
thisEntry.Healing = Convert.ToInt32(eventParameters[baseParam]);
thisEntry.Overhealing = Convert.ToInt32(eventParameters[baseParam + 1]);
if (eventParameters[baseParam + 2] == "1")
thisEntry.Critical = true;
else
thisEntry.Critical = false;
break;
case "ENERGIZE":
thisEntry.EnergizeAmount = Convert.ToInt32(eventParameters[baseParam]);
thisEntry.PowerType = eventParameters[baseParam + 1];
break;
case "DRAIN":
thisEntry.EnergizeAmount = Convert.ToInt32(eventParameters[baseParam]) * -1;
thisEntry.PowerType = eventParameters[baseParam + 1];
thisEntry.ExtraAmount = Convert.ToInt32(eventParameters[baseParam + 2]);
break;
case "LEECH":
thisEntry.EnergizeAmount = Convert.ToInt32(eventParameters[baseParam]) * -1;
thisEntry.PowerType = eventParameters[baseParam + 1];
thisEntry.ExtraAmount = Convert.ToInt32(eventParameters[baseParam + 2]);
break;
case "INTERRUPT":
thisEntry.ExtraSpellName = eventParameters[baseParam + 1];
thisEntry.ExtraSpellSchool = eventParameters[baseParam + 2];
break;
case "DISPEL":
thisEntry.ExtraSpellName = eventParameters[baseParam + 1];
thisEntry.ExtraSpellSchool = eventParameters[baseParam + 2];
if (eventTypeSplit.Length < next + 2)
thisEntry.AuraType = eventParameters[baseParam + 3];
break;
case "STOLEN":
thisEntry.ExtraSpellName = eventParameters[baseParam + 1];
thisEntry.ExtraSpellSchool = eventParameters[baseParam + 2];
thisEntry.AuraType = eventParameters[baseParam + 3];
break;
case "EXTRA":
thisEntry.ExtraAttacks = Convert.ToInt32(eventParameters[baseParam]);
break;
case "AURA":
if (eventTypeSplit[next + 1] == "BROKEN" && eventTypeSplit.Length >= next + 3)
{
thisEntry.ExtraSpellName = eventParameters[baseParam + 1];
thisEntry.ExtraSpellSchool = eventParameters[baseParam + 2];
thisEntry.AuraType = eventParameters[baseParam + 3];
}
if (eventTypeSplit[next + 1] == "APPLIED")
thisEntry.Applied = 1;
if (eventTypeSplit[next + 1] == "REMOVED")
thisEntry.Applied = -1;
thisEntry.AuraType = eventParameters[baseParam];
if (eventTypeSplit.Length >= next + 3 && eventTypeSplit[next + 2] == "DOSE")
thisEntry.Doses = Convert.ToInt32(eventParameters[baseParam + 1]);
break;
case "CAST":
if (eventTypeSplit[next + 1] == "FAILED")
thisEntry.FailedType = eventParameters[baseParam];
break;
}
return thisEntry;
}
public void UpdateCombatLogEntry(string combatLogEntryName, CombatLogEntry combatLogEntry)
{
//Todo
}
public void CreateCombatLogEntry(string fittingName, CombatLogEntry combatLogEntry)
{
//TODO
}
