public List <Encounters> FillEncounters(IEntryCollection entryCollection, string name)
{
List <Encounters> encounters = new List <Encounters>();
foreach (IEntry entryitem in entryCollection)
{
Encounters ptEncounters = new Encounters();
IEncounter entryEncounter = entryitem.AsEncounter;
IEntryRelationship entryRelationItem = entryEncounter.EntryRelationship.FirstOrDefault();
if (entryRelationItem != null)
{
IObservation observation = entryRelationItem.AsObservation;
IIVL_TS efftime = observation.EffectiveTime;
if (efftime == null)
{
throw new InvalidOperationException();
}
IANY observationvalue = observation.Value.FirstOrDefault();
ICD str = (ICD)observationvalue;
string location = observation.Participant.Count > 0 ? observation.Participant[0].ParticipantRole.AsPlayingEntity.Name[0].Text : null;
ptEncounters.Code = str.Code;
ptEncounters.EncounterDescription = str.DisplayName;
ptEncounters.PerformerName = name;
//ptEncounters.EncounterDate = efftime != null ? efftime.Low != null ? efftime.Low.Value != null ? new DateTime?(Convert.ToDateTime(efftime.Low.AsDateTime)) : null : null : efftime.Value != null ? new DateTime?(Convert.ToDateTime(efftime.AsDateTime)) : null;
}
encounters.Add(ptEncounters);
}
return(encounters);
}
public virtual async Task <GridTargetAction> GetNextActionAsync(IEncounter encounter)
{
GridTargetAction action = null;
if (CanAttack)
{
action = Actions.Count > 0 ? Actions.Dequeue() :(GridTargetAction)await Intelligence.GetNextActionAsync(encounter);
if (TargetPreference != null && encounter.Dead.Contains(TargetPreference))
{
TargetPreference = null;
}
if (TargetPreference != null && (action.TargetType == TargetTypes.Enemy &&
!action.TargetEntities.Any()))
{
action.TargetEntities.Add(TargetPreference);
}
LastAction = DateTime.Now;
}
return(action);
}
public IEncounter CreateNewEncounter()
{
player = CharacterFactory.CreatePlayerCharacter();
monster = CharacterFactory.CreateMonster();
encounter = new Encounter(player, monster);
return encounter;
}
private Task HandleRemoveEncounter(IEncounter encounter)
{
encounter.ActionExecuted -= Encounter_ActionExecuted;
encounter.Ended -= Encounter_Ended;
return(Task.CompletedTask);
}
public TimeSpan GetEncounterDuration(IEncounter encounter)
{
// TODO: This should be a method on Encounter
var phases = encounter.GetPhases().ToArray();
var start = phases.Min(x => x.StartTime);
var end = phases.Max(x => x.EndTime);
return(new TimeSpan(0, 0, 0, 0, (int)(end - start)));
}
/// <summary>
/// Return what the current actor should do given the current state of the encounter.
/// </summary>
/// <param name="actor"></param>
/// <param name="encounter"></param>
/// <returns></returns>
public static IActionDecision DecideAction(this IActor actor, IEncounter encounter)
{
var chosenOpponent = encounter.Factions
.Where(f => !f.Participants.SelectMany(p => p).Contains(actor))
.SelectMany(f => f.Participants)
.SelectMany(p => p)
.FirstOrDefault(a => a.HitPoints.CurrentHitPoints > 0);
if (chosenOpponent == null)
{
return(default);
public void ProcessEncounter()
{
switch (CurrentLevelSet.Type)
{
case LevelType.Battle:
BattleEncounter();
return;
case LevelType.Exit:
State = GameState.Exit;
break;
case LevelType.BranchingPath:
break;
case LevelType.SafeZone:
break;
case LevelType.TreasureChest:
break;
case LevelType.Mimic:
break;
case LevelType.MagicFountain:
break;
case LevelType.StorageRoom:
break;
case LevelType.Shop:
break;
case LevelType.Character:
State = GameState.Character;
break;
case LevelType.Trap:
break;
default:
break;
}
IEncounter encounter = CurrentLevelSet.encounterObjects.GetComponentInChildren <IEncounter>();
encounter.Encounter();
}
public Control GetView(IEncounter encounter)
{
if (encounter is Fight)
{
return new FightView(encounter as Fight, window);
}
else if (encounter is Treasure)
{
return new TreasureView(encounter as Treasure, window);
}
else if (encounter is Merchant)
{
return new MerchantView(encounter as Merchant, window);
}
throw new Exception("Encounter type not recognized!");
}
public Task <ICombatAction> GetNextActionAsync(IEncounter encounter)
{
var defaultAttack = new GridTargetAction()
{
Id = _defaultAction.Id, Name = _defaultAction.Name, Element = _defaultAction.Element, TargetType = _defaultAction.TargetType, Modifiers = _defaultAction.Modifiers.Select(m => (IActionModifier) new GridActionModifier()
{
Name = m.Name, TargetType = m.TargetType, ModifierType = m.ModifierType, Min = m.Min, Max = m.Max
}).ToList()
};
// no intelligence right now..just set a command to find any enemy and dmg the health
// mod this with stats eventually
return(Task.FromResult((ICombatAction)defaultAttack));
}
private async Task HandleNewEncounter(IEncounter encounter)
{
encounter.ActionExecuted += Encounter_ActionExecuted;
encounter.Ended += Encounter_Ended;
var map = ((GridPlayer)encounter.Combatants.First().Key).Map;
await Game.Network.SendViewCommandsToMapAsync(map,
MudLikeViewBuilder.Start()
.AddOperation(
MudLikeOperationBuilder.Start($"enc_{encounter.Id}")
.StartContainer($"enc_{encounter.Id}")
.AddTextLine("Combat Starting")
.EndContainer($"enc_{encounter.Id}")
.Build()
)
.Build());
}
public virtual Task SetDefaultTargetAsync(IEncounter encounter)
{
return(Task.CompletedTask);
}
public override Task SetDefaultTargetAsync(IEncounter encounter)
{
var gridEncounter = (GridEncounter)encounter;
switch (TargetType)
{
case TargetTypes.Self:
TargetEntities.Add(SourceEntity);
break;
case TargetTypes.Enemy:
foreach (var factionName in gridEncounter.Factions.Keys.ToList())
{
var faction = gridEncounter.Factions[factionName];
if (!faction.Contains(SourceEntity))
{
TargetEntities.Add((GridEntity)faction.FirstOrDefault(e => !encounter.Dead.Contains(e)));
break;
}
}
break;
case TargetTypes.EnemyArea:
foreach (var factionName in gridEncounter.Factions.Keys.ToList())
{
var faction = gridEncounter.Factions[factionName];
if (!faction.Contains(SourceEntity))
{
foreach (var target in faction)
{
TargetEntities.Add((GridEntity)target);
}
}
}
break;
case TargetTypes.Friend:
foreach (var factionName in gridEncounter.Factions.Keys.ToList())
{
var faction = gridEncounter.Factions[factionName];
if (faction.Contains(SourceEntity))
{
TargetEntities.Add((GridEntity)faction.FirstOrDefault(e => !encounter.Dead.Contains(e)));
break;
}
}
break;
case TargetTypes.FriendArea:
foreach (var factionName in gridEncounter.Factions.Keys.ToList())
{
var faction = gridEncounter.Factions[factionName];
if (faction.Contains(SourceEntity))
{
foreach (var target in faction)
{
TargetEntities.Add((GridEntity)target);
}
}
}
break;
}
return(Task.CompletedTask);
}
private Task EncounterEnded(IEncounter encounter, EncounterEndings endingType)
{
_logger.LogInformation("Encounter ended");
return(RemoveEncounterAsync((GridEncounter)encounter));
}
public Dictionary <string, ArrayList> GetDataCollection(ISection sections, PatientClinicalInformation ptInformation)
{
Dictionary <string, ArrayList> componententries = new Dictionary <string, ArrayList>();
IEntryCollection entries = sections.Entry;
IStrucDocText sectiontext = sections.Text;
IStrucDocElementCollection textitem = sectiontext.Items;
if (entries.Count() > 0)
{
int count = 0;
foreach (IEntry singlerecord in entries)
{
itemAct = singlerecord.AsAct;
itemEncounter = singlerecord.AsEncounter;
itemSubstanceAdministration = singlerecord.AsSubstanceAdministration;
observation = singlerecord.AsObservation;
organizer = singlerecord.AsOrganizer;
procedure = singlerecord.AsProcedure;
//if(sections.Code.Code== "18776-5")
// {
// }
ArrayList arrayList = new ArrayList();
if (itemAct != null)
{
entryRelationship = itemAct.EntryRelationship;
IIVL_TS efftime = itemAct.EffectiveTime;
if (efftime != null && efftime.Low != null)
{
if (efftime.Low.Value != null)
{
arrayList.Add(efftime.Low.AsDateTime.ToString());
}
else
{
arrayList.Add("null");
}
}
else
{
arrayList.Add("null");
}
if (entryRelationship != null && entryRelationship.Count > 0)
{
observation = entryRelationship.Select(o => o.AsObservation).FirstOrDefault();
if (observation != null)
{
if (observation.Participant.Count() > 0)
{
string participent = observation.Participant.Select(p => p.ParticipantRole).FirstOrDefault().AsPlayingEntity.Name.FirstOrDefault().Text;
arrayList.Add(participent);
}
entity = observation.EntryRelationship;
foreach (IEntryRelationship singlentity in entity)
{
IObservation entityobservation = singlentity.AsObservation;
IANY observationvalue = entityobservation.Value.FirstOrDefault();
if (observationvalue != null)
{
var obj = observationvalue.GetType();
string objname = obj.Name;
switch (objname)
{
default:
ICD strcd = (ICD)observationvalue;
arrayList.Add(strcd.Code);
arrayList.Add(strcd.DisplayName);
break;
case "PQ":
IPQ strpq = (IPQ)observationvalue;
arrayList.Add(strpq.Value.ToString() + " " + strpq.Unit.ToString());
break;
}
}
}
componententries.Add(count.ToString(), arrayList);
count++;
}
}
else
{
arrayList.Add(itemAct.Text.Text);
componententries.Add(count.ToString(), arrayList);
count++;
}
}
else if (itemEncounter != null)
{
entryRelationship = itemEncounter.EntryRelationship;
if ((entryRelationship.Select(t => t.TypeCode).FirstOrDefault().ToString()) == "RSON")
{
observation = entryRelationship.Select(o => o.AsObservation).FirstOrDefault();
IIVL_TS efftime = observation.EffectiveTime;
IANY observationvalue = observation.Value.FirstOrDefault();
ICD str = (ICD)observationvalue;
arrayList.Add(str.DisplayName);
arrayList.Add(ptInformation.ptClinicInformation.ClinicName);
if (efftime.Low != null)
{
arrayList.Add(efftime.Low.AsDateTime);
}
else
{
arrayList.Add(null);
}
arrayList.Add(str.Code);
}
componententries.Add(count.ToString(), arrayList);
count++;
}
else if (itemSubstanceAdministration != null)
{
consumable = itemSubstanceAdministration.Consumable;
manufacturedProduct = consumable.ManufacturedProduct;
material = manufacturedProduct.AsMaterial;
arrayList.Add(material.Code.Code);
arrayList.Add(itemSubstanceAdministration.StatusCode.Code.ToString());
ISXCM_TSCollection efftime = itemSubstanceAdministration.EffectiveTime;
if (efftime.Count > 1)
{
foreach (IVL_TS daterange in efftime)
{
string startdatetime = daterange.Low != null ? daterange.Low.Value != null?daterange.Low.AsDateTime.ToString() : "null" : "null";
string EndDAtetime = daterange.High != null ? daterange.High.Value != null?daterange.High.AsDateTime.ToString() : "null" : "null";
arrayList.Add(startdatetime);
arrayList.Add(EndDAtetime);
break;
}
}
else
{
arrayList.Add(efftime[0].AsDateTime.ToString());
}
arrayList.Add(material.Code.DisplayName);
if (itemSubstanceAdministration.DoseQuantity != null)
{
arrayList.Add(itemSubstanceAdministration.DoseQuantity.Value.ToString() + " " + itemSubstanceAdministration.DoseQuantity.Unit.ToString());
}
else
{
arrayList.Add("NA");
}
if (manufacturedProduct.ManufacturerOrganization != null)
{
arrayList.Add(manufacturedProduct.ManufacturerOrganization.Name.ToString());
}
else
{
arrayList.Add("NA");
}
componententries.Add(count.ToString(), arrayList);
count++;
}
else if (observation != null)
{
if (observation.Value.Count > 0)
{
IANY observationvalue = observation.Value.FirstOrDefault();
ICD str = (ICD)observationvalue;
arrayList.Add(str.Code);
arrayList.Add(str.DisplayName);
IIVL_TS efftime = observation.EffectiveTime;
if (efftime != null && efftime.Low != null)
{
if (efftime.Low.Value != null)
{
arrayList.Add(efftime.Low.AsDateTime.ToString());
}
else
{
arrayList.Add("null");
}
}
else
{
arrayList.Add("null");
}
}
else
{
arrayList.Add(null);
arrayList.Add(null);
arrayList.Add(null);
}
componententries.Add(count.ToString(), arrayList);
count++;
}
else if (organizer != null)
{
IComponent4Collection orgComponent = organizer.Component;
foreach (IComponent4 objItem in orgComponent)
{
IObservation orgObservation = objItem.AsObservation;
arrayList.Add(orgObservation.Code.DisplayName);
if (orgObservation.Value != null)
{
IANY observationvalue = orgObservation.Value.FirstOrDefault();
var obj = observationvalue.GetType();
string objname = obj.Name;
switch (objname)
{
default:
ICD strcd = (ICD)observationvalue;
arrayList.Add(strcd.Code);
arrayList.Add(strcd.DisplayName);
break;
case "PQ":
IPQ strpq = (IPQ)observationvalue;
arrayList.Add(strpq.Value.ToString() + " " + strpq.Unit.ToString());
break;
}
//IPQ str = (IPQ)observationvalue;
//arrayList.Add(str.Value.ToString() + " " + str.Unit.ToString());
}
IIVL_TS efftime = orgObservation.EffectiveTime;
if (efftime != null && efftime.Low != null)
{
if (efftime.Low.Value != null)
{
arrayList.Add(efftime.Low.AsDateTime.ToString());
}
else
{
arrayList.Add("null");
}
}
else
{
arrayList.Add("null");
}
if (orgObservation.ReferenceRange != null)
{
if (orgObservation.ReferenceRange.Count > 0)
{
arrayList.Add(orgObservation.ReferenceRange[0].ObservationRange.Text.Text);
}
else
{
arrayList.Add("NA");
}
}
}
arrayList.Add(organizer.Code.Code);
componententries.Add(count.ToString(), arrayList);
count++;
}
else if (procedure != null)
{
if (procedure.Code != null)
{
arrayList.Add(procedure.Code.Code);
arrayList.Add(procedure.Code.DisplayName);
}
else
{
arrayList.Add(null);
arrayList.Add(null);
}
componententries.Add(count.ToString(), arrayList);
count++;
}
}
}
return(componententries);
}
private static void resetLearningHelper()
{
if (learningHelperClass != null)
{
try
{
learningHelperClass.endEncounter();
inController = false;
learningHelperClass.onEndEncounter();
inController = true;
}
catch (Exception e2)
{
inController = true;
debug("learningHelper processChatLine", getEngineVsEncounter(learningHelperClass), e2);
}
learningHelperClass = null;
}
try
{
refreshIgnoreMobsList();
// Start learning helper for a new encounter
LearningHelper abc = new LearningHelper();
setupNewClass((IEncounter)abc);
learningHelperClass = abc;
debug("LearningHelper started", DBMErrorLevel.Trace);
}
catch (Exception e2)
{
debug("learningHelper setupNewClass", getEngineVsEncounter(learningHelperClass), e2);
}
}
public static void endEncounter()
{
try
{
if (learningHelperClass != null)
{
try
{
learningHelperClass.endEncounter();
learningHelperClass.onEndEncounter();
}
catch (Exception e2)
{
debug("learningHelper endEncounter", getEngineVsEncounter(learningHelperClass), e2);
}
learningHelperClass = null;
}
if (implementationClass != null)
{
debug("endEncounter removed " + handleRemoveEntryName + "(" + handleRemoveEntry + ")", DBMErrorLevel.Trace);
try
{
inController = false;
implementationClass.endEncounter();
implementationClass.onEndEncounter();
inController = true;
}
catch (Exception e2)
{
debug("endEncounter", getEngineVsEncounter(implementationClass), e2);
inController = true;
}
implementationClass = null;
}
_agroList.Clear();
_enmityCached.Clear();
_mobCached.Clear();
encounterStarted = false;
endEncounterAt = DateTime.MaxValue;
}
catch (Exception ex2)
{
debug("endEncounter error: ", DBMErrorLevel.EngineErrors, ex2);
}
}
public int CompareTo(IEncounter other)
{
return(EncounterIndex.CompareTo(other.EncounterIndex));
}
public void StartEncounter(IEncounter encounter)
{
this.encounter = encounter;
UpdateModel();
UpdateEventLog();
}
static void checkForNewAgro()
{
List<uint> diff = null;
try
{
// Check for new entries in the enmity list
diff = playerEntity.EnmityEntries.Select(x => x.ID).Except(_enmityCached.Select(y => y.ID)).ToList();
if (diff.Any())
{
// loop through the new enmity entries
foreach (uint ID in diff)
{
ActorEntity currentEntity = null;
if (_mobCached.ContainsKey(ID))
{
currentEntity = _mobCached[ID];
}
else if (_mobList.ContainsKey(ID))
{
currentEntity = _mobList[ID];
}
if (currentEntity != null)
{
if (currentEntity.IsValid && currentEntity.HPCurrent > 0) // && currentEntity.ClaimedByID != 0 && currentEntity.ClaimedByID < 0xE0000000)
{
if (!_agroList.Any() && implementationClass == null && learningHelperClass == null)
{
// This is the first enmity entry we found. Start the encounter timer.
started = DateTime.Now;
}
// make sure it's our own copy so it won't mysteriously disappear or change without our knowledge
currentEntity = cloneActorEntity(currentEntity);
if (_agroList.Any())
{
firstAgro = DateTime.Now;
}
_agroList.Add(currentEntity);
endEncounterAt = DateTime.MaxValue;
if (implementationClass != null)
{
// send the new mobs to the encounter script
try
{
debug("Agroed Mob: " + currentEntity.Name, DBMErrorLevel.Trace);
inController = false;
implementationClass.onMobAgro(currentEntity);
inController = true;
}
catch (Exception e2)
{
debug("onMobAgro", getEngineVsEncounter(implementationClass), e2);
inController = true;
}
try
{
implementationClass.bossCheck(currentEntity);
}
catch (Exception e2)
{
debug("bossCheck", getEngineVsEncounter(implementationClass), e2);
}
}
else
{
if (useTestEncounter)
{
IEncounter inst = (IEncounter)(new TestEncounter());
implementationClass = inst;
setupNewClass(inst);
debug("TestEncounter started", DBMErrorLevel.Trace);
debug("Agroed Mob: " + currentEntity.Name, DBMErrorLevel.Trace);
}
else
{
// No encounter script loaded. Lets see if we have one that matches this mob
Regex rgx = new Regex("[^a-zA-Z0-9 -]");
string mobName = rgx.Replace(currentEntity.Name, "");
string dir = getScriptsDirectory();
checkRecompile(currentEntity.Name);
if (encounters.ContainsKey(mobName))
{
IEncounter inst = findEntryPoint(encounters[mobName]);
implementationClass = inst;
if (implementationClass != null)
{
setupNewClass(inst);
debug("Encounter started (" + dir + @"\" + mobName + ".cs)", DBMErrorLevel.Trace);
debug("Agroed Mob: " + currentEntity.Name, DBMErrorLevel.Trace);
resetLearningHelper();
}
else
{
debug("Couldn't find entry point in class: " + dir + @"\" + mobName + ".cs", DBMErrorLevel.EngineErrors);
}
}
}
}
if (learningHelperClass != null)
{
// send the new mobs to the learning helper
try
{
learningHelperClass.onMobAgro(currentEntity);
}
catch (Exception e2)
{
debug("learningHelper onMobAgro", getEngineVsEncounter(learningHelperClass), e2);
}
try
{
learningHelperClass.bossCheck(currentEntity);
}
catch (Exception e2)
{
debug("learningHelper bossCheck", getEngineVsEncounter(learningHelperClass), e2);
}
}
else
{
refreshIgnoreMobsList();
// Start learning helper for a new encounter
LearningHelper abc = new LearningHelper();
setupNewClass((IEncounter)abc);
learningHelperClass = abc;
debug("LearningHelper started (" + currentEntity.Name + ")", DBMErrorLevel.Trace);
}
}
else
{
debug("New agro invalid: IsValid: " + currentEntity.IsValid + ", HPCurrent: " + currentEntity.HPCurrent + ", ClaimedByID: " + currentEntity.ClaimedByID, DBMErrorLevel.Notice);
}
}
else
{
debug("New agro not found (ID: " + ID + ")", DBMErrorLevel.Notice);
}
}
}
}
catch (Exception e2)
{
debug("updateData check for new agro", DBMErrorLevel.EngineErrors, e2);
}
}
public static void compileScripts()
{
try
{
string dir = getScriptsDirectory();
DirectoryInfo di = new DirectoryInfo(dir);
FileInfo[] files = di.GetFiles("*.cs");
if (implementationClass != null)
{
endEncounter();
implementationClass = null;
}
foreach (FileInfo fi in files)
{
if (File.Exists(fi.FullName))
{
string key = Path.GetFileNameWithoutExtension(fi.FullName);
if (!encounters.ContainsKey(key) || fi.LastWriteTimeUtc != classModified[key])
{
try
{
Assembly tmpAssembly = loadAssemblyFile(fi.FullName);
if (tmpAssembly != null)
{
encounters[key] = tmpAssembly;
classModified[key] = fi.LastWriteTimeUtc;
debug("Compiled (" + fi.FullName + ".cs)", DBMErrorLevel.Notice);
}
}
catch (Exception e)
{
debug("Compile error (" + fi.FullName + "): ", DBMErrorLevel.EncounterErrors, e);
}
}
}
}
}
catch (Exception ex)
{
debug("Error compiling scripts", DBMErrorLevel.EngineErrors, ex);
}
}
private static DBMErrorLevel getEngineVsEncounter(IEncounter controller)
{
try
{
if (controller == null)
{
return DBMErrorLevel.EngineErrors;
}
return (controller.inController() ? DBMErrorLevel.EngineErrors : DBMErrorLevel.EncounterErrors);
}
catch (Exception ex2)
{
debug("getEngineVsEncounter error: ", DBMErrorLevel.EngineErrors, ex2);
}
return DBMErrorLevel.EngineErrors;
}
private async Task Encounter_ActionExecuted(IEncounter encounter, ICombatAction action)
{
// this whole thing can be optimized to send way smaller replacement segments later
var combatView = MudLikeOperationBuilder.Start($"enc_{encounter.Id}")
.StartContainer($"enc_{encounter.Id}")
.AddTextLine("");
var gridEncounter = (GridEncounter)encounter;
var entityAction = (GridTargetAction)action;
//var dmgDone = encounter.ActionLog.Select((a) => (ICombatAction<GridEntity>)a)
// .GroupBy(a => new { a.SourceEntity })
// .Select(a => new { Attacker = a.Key.SourceEntity, Damage = a.Sum(s => s.DamageDone) })
// .ToList();
//var dmgTaken = encounter.ActionLog.Select((a) => (GridSingleTargetAction)a)
// .GroupBy(a => new { a.TargetEntity })
// .Select(a => new { Attacked = a.Key.TargetEntity, Damage = a.Sum(s => s.DamageDone) })
// .ToList();
foreach (var factionName in gridEncounter.Factions.Keys)
{
var factionEntities = gridEncounter.Factions[factionName];
foreach (var entity in factionEntities)
{
combatView
.AddText(entity.Name, (entity.IsAlive && !encounter.Dead.Contains(entity) ? TextColor.Normal : TextColor.Red));
if (entity.IsAlive && !encounter.Dead.Contains(entity))
{
combatView
.AddText($" {entity.Stats.FirstOrDefault(s => s.Name == "health")?.Value}", TextColor.Green)
.AddText($" {entity.Stats.FirstOrDefault(s => s.Name == "mana")?.Value}", TextColor.Blue)
.AddText($" {entity.Stats.FirstOrDefault(s => s.Name == "stamina")?.Value}", TextColor.Yellow)
;
}
else
{
combatView.AddText(" Dead", TextColor.Red, TextSize.Small);
}
//var entityDmgDone = dmgDone.FirstOrDefault(d => d.Attacker == entity);
//if (entityDmgDone != null)
//{
// combatView
// .AddText($" Dmg {entityDmgDone.Damage}", TextColor.Teal);
// ;
//}
//var entityDmgTaken = dmgTaken.FirstOrDefault(d => d.Attacked == entity);
//if (entityDmgTaken != null)
//{
// combatView
// .AddText($" Taken {entityDmgTaken.Damage}", TextColor.Teal);
// ;
//}
combatView.AddLineBreak();
}
combatView.AddTextLine("---------------------------");
}
// add last X actions
var actions = encounter.ActionLog.OrderByDescending(a => a.ExecutedTime).Take(10).OrderBy(a => a.ExecutedTime).ToList();
actions.ForEach((a) => a.AppendToOperation(combatView));
combatView.EndContainer($"enc_{encounter.Id}");
var view = MudLikeViewBuilder.Start()
.AddOperation(combatView.Build()
).Build();
if (entityAction.TargetEntities.Contains(entityAction.SourceEntity) || entityAction.TargetEntities.Count == 0)
{
await Game.Network.SendViewCommandsToMapAsync(entityAction.SourceEntity.Map, view);
}
else
{
var maps = new List <IMap>()
{
entityAction.SourceEntity.Map
};
maps.AddRange(entityAction.TargetEntities.Where(t => t.Map != entityAction.SourceEntity.Map).Select(t => t.Map).Distinct());
maps.ForEach(async m => await Game.Network.SendViewCommandsToMapAsync(m, view));
}
}
public LevelSceneData(string sceneName, IEncounter encounter, PlayerController player)
{
SceneName = sceneName;
this.encounter = encounter;
this.player = player;
}
private async Task Encounter_Ended(IEncounter encounter, EncounterEndings ending)
{
encounter.ActionExecuted -= Encounter_ActionExecuted;
encounter.Ended -= Encounter_Ended;
if (ending == EncounterEndings.Expired)
{
return;
}
var gridEncounter = (GridEncounter)encounter;
// allocate experience to winners
var factionInfo = gridEncounter.Factions.Select(f => new
{
FactionName = f.Key,
FactionEntities = f.Value,
isWinner = f.Value.Count(e => !gridEncounter.Dead.Contains(e)) > 0,
AverageLevel = f.Value.Average(e => e.Stats.FirstOrDefault(s => s.Name == "level")?.Value).GetValueOrDefault(0),
MinLevel = f.Value.Min(e => e.Stats.FirstOrDefault(s => s.Name == "level")?.Value).GetValueOrDefault(0),
MaxLevel = f.Value.Max(e => e.Stats.FirstOrDefault(s => s.Name == "level")?.Value).GetValueOrDefault(0)
}).ToList();
// this would need updated to support more than 2 factions properly
var winners = factionInfo.FirstOrDefault(f => f.isWinner);
var losers = factionInfo.FirstOrDefault(f => !f.isWinner);
var cancelExperience = false;
if (winners.MinLevel < winners.MaxLevel - 5)
{
cancelExperience = true;
}
var experienceScaler = 1 + (losers.AverageLevel - winners.AverageLevel) * 0.2;
var experience = (3 * losers.AverageLevel) * experienceScaler;
if (!cancelExperience)
{
foreach (var winner in winners.FactionEntities)
{
// players and monsters both gain experience the same for now
var experienceStat = (BasicStat)winner.Stats.FirstOrDefault(s => s.Name == "experience");
await experienceStat?.ApplyAsync(Convert.ToInt32(experience));
if (experienceStat != null)
{
// check if leveled
if (experienceStat.Value == experienceStat.Base)
{
var levelStat = winner.Stats.FirstOrDefault(s => s.Name == "level");
await levelStat?.ApplyAsync(1);
await experienceStat.RebaseAsync(Convert.ToInt32(experienceStat.Base * 1.5), 0);
// fill stats
var vitalStats = new List <string>()
{
"health", "mana", "stamina"
};
foreach (BasicStat stat in winner.Stats.Where(s => vitalStats.Contains(s.Name)).ToList())
{
await stat.Fill();
}
}
}
}
}
foreach (var faction in factionInfo)
{
var players = faction.FactionEntities.Where(e => e.IsPlayer()).Select(e => e).Distinct();
if (!players.Any())
{
continue;
}
var combatView = MudLikeOperationBuilder.Start($"enc_{encounter.Id}")
.StartContainer($"enc_{encounter.Id}").AddLineBreak();
foreach (var entity in faction.FactionEntities)
{
var experienceStat = entity.Stats.FirstOrDefault(s => s.Name == "experience");
combatView
.AddText(entity.Name, (entity.IsAlive && !encounter.Dead.Contains(entity) ? TextColor.Normal : TextColor.Red));
if (entity.IsAlive && !encounter.Dead.Contains(entity))
{
combatView
.AddText($" {entity.Stats.FirstOrDefault(s => s.Name == "health")?.Value}", TextColor.Green)
.AddText($" {entity.Stats.FirstOrDefault(s => s.Name == "mana")?.Value}", TextColor.Blue)
.AddText($" {entity.Stats.FirstOrDefault(s => s.Name == "stamina")?.Value}", TextColor.Yellow)
.AddText($" Lv {experienceStat.Value}/{experienceStat.Base}", TextColor.Yellow)
;
}
else
{
combatView.AddText(" Dead", TextColor.Red, TextSize.Small);
}
combatView.AddLineBreak();
}
if (faction.isWinner)
{
combatView.AddTextLine($"You earned {experience} experience");
}
else
{
combatView.AddTextLine($"You lost the encounter.");
}
combatView.EndContainer($"enc_{encounter.Id}");
var view = MudLikeViewBuilder.Start().AddOperation(combatView.Build()).Build();
await Game.Network.SendViewCommandsToPlayersAsync(players.Cast <IPlayer>(), view);
}
}
public Task <ICombatAction> GetNextActionAsync(IEncounter encounter)
{
GridTargetAction selectedAction = null;
// what do we want to know in our generic intel?
// randomly cast a buff? keeping it simple for now just healing and dmg
// healing
var hpstat = Entity.Stats.FirstOrDefault(s => s.Name == "health");
if (hpstat != null)
{
if (hpstat.Value < hpstat.Base / 2)
{
var potentialActions = _actionsHeal.Where(action => Entity.CurrentStatsAtLeast(action.Modifiers.Where(m => m.TargetType == ModifierTargetTypes.Caster && m.Min < 0))).ToList();
if (potentialActions.Count() > 0)
{
// how much hp do we need? find the closest heal ...add some factoring of heal to mana cost effeciency later
var hpNeeded = hpstat.Base - hpstat.Value;
var differences = potentialActions.Select(action => new { Action = action, Difference = Math.Abs(hpNeeded - action.Modifiers.FirstOrDefault(m => m.Name == "health").Value) });
selectedAction = differences.OrderBy(d => d.Difference).FirstOrDefault().Action;
}
}
}
// damage
if (selectedAction == null)
{
// pick the hardest hitting health stat we can afford to cast
// AI cheat boost here by knowing the randomization result of the modifier..
var potentialActions = _actionsDmg.OrderByDescending(action => Math.Abs(action.Modifiers.FirstOrDefault(m => m.Name == "health").Value));
foreach (var action in potentialActions)
{
if (_random.Next(1, 101) > 50)
{
continue;
}
var consumerMods = action.Modifiers.Where(m => m.TargetType == ModifierTargetTypes.Caster && m.Min < 0).ToList();
// can we meet all requirements?
var affordable = Entity.CurrentStatsAtLeast(consumerMods);
if (affordable)
{
selectedAction = action;
break;
}
}
}
// randomly skip the ability altogether to add some feel of variety
if (_random.Next(1, 101) > 50)
{
selectedAction = null;
}
if (selectedAction == null && Entity.CurrentStatsAtLeast(_defaultAction.Modifiers.Where(m => m.TargetType == ModifierTargetTypes.Caster)))
{
selectedAction = _defaultAction;
}
if (selectedAction == null)
{
return(Task.FromResult((ICombatAction)null));
}
var actionCopy = new GridTargetAction()
{
Element = selectedAction.Element, Modifiers = selectedAction.Modifiers.Select(m => (IActionModifier) new GridActionModifier()
{
Name = m.Name, TargetType = m.TargetType, ModifierType = m.ModifierType, Min = m.Min, Max = m.Max
}).ToList(), Id = selectedAction.Id, Name = selectedAction.Name, TargetType = selectedAction.TargetType
};
return(Task.FromResult((ICombatAction)actionCopy));
}
public static void setupNewClass(IEncounter inst)
{
try
{
encounterStarted = true;
try
{
inController = false;
inst.onStartEncounter();
inController = true;
}
catch (Exception e2)
{
debug("onStartEncounter", getEngineVsEncounter(inst), e2);
inController = true;
}
try
{
inst.setPhase(1);
}
catch (Exception e2)
{
debug("setPhase", getEngineVsEncounter(inst), e2);
}
foreach (ActorEntity tmpEnt in _agroList)
{
try
{
inController = false;
inst.onMobAgro(tmpEnt);
inController = true;
}
catch (Exception e2)
{
debug("onMobAgro", getEngineVsEncounter(inst), e2);
inController = true;
}
try
{
inst.bossCheck(tmpEnt);
}
catch (Exception e2)
{
debug("bossCheck", getEngineVsEncounter(inst), e2);
}
}
foreach (var KVP in _mobCached)
{
ActorEntity tmpEnt = KVP.Value;
try
{
if (inst == implementationClass)
{
debug("Added Mob (Setup): " + tmpEnt.Name + " ID: " + tmpEnt.ID + " NPCID1: " + tmpEnt.NPCID1 + " NPCID2: " + tmpEnt.NPCID2, DBMErrorLevel.Trace);
}
inController = false;
inst.onMobAdded(tmpEnt);
inController = true;
}
catch (Exception e2)
{
debug("onMobAdded", getEngineVsEncounter(inst), e2);
}
}
}
catch (Exception ex2)
{
debug("setupNewClass error: ", DBMErrorLevel.EngineErrors, ex2);
}
}
