public bool Destroy(string key) { IEntityTemplate found = this.m_Templates.FirstOrDefault(template => template.CreatureType.Equals(key, StringComparison.OrdinalIgnoreCase)); return(!(found is null) && this.m_Templates.Remove(found)); }
public IEntity CreateFromTemplate(IEntityTemplate template, Vector2Int position, string name = null, IDictionary <string, IEntityStatistic> statistics = null, IDictionary <string, IDerivedValue> derivedValues = null, IDictionary <string, IEntitySkill> skills = null, IEnumerable <IAbility> abilities = null, IEnumerable <ICulture> cultures = null, IGender gender = null, IBioSex sex = null, ISexuality sexuality = null, IRomance romance = null, IJob job = null, IEnumerable <ISpriteState> sprites = null, IWorldInstance world = null, IDriver driver = null) { string selectedName = name; IJob selectedJob = job; IGender selectedGender = gender; IBioSex selectedSex = sex; ISexuality selectedSexuality = sexuality; IRomance selectedRomance = romance; IEnumerable <ISpriteState> selectedSprites = sprites; List <ICulture> creatureCultures = new List <ICulture>(); IDriver selectedDriver = driver; IDictionary <string, IEntityStatistic> selectedStatistics = statistics; IDictionary <string, IDerivedValue> selectedDVs = derivedValues; IDictionary <string, IEntitySkill> selectedSkills = skills; IEnumerable <IAbility> selectedAbilities = abilities; if (!(cultures is null)) { creatureCultures.AddRange(cultures); }
List <IEntityTemplate> IEnemyGroupMaker.MakeEnemyGroup(IEntityTemplate forThis) { int baseThreat = forThis.Rating.GetThreat(null); var matchesWithRating = (this as IEntityManager).EnityMatchRating( forThis, baseThreat - m_ratingRange, baseThreat + m_ratingRange); int maxThreatRating = baseThreat + m_ratingRange; int threatSoFar = 0; var targetEnemies = new List <IEntityTemplate>(matchesWithRating); var group = new List <IEntityTemplate>(); do { int idx = m_random.Next() % targetEnemies.Count; int thisThreat = targetEnemies[idx].Rating.GetThreat(forThis.Rating); if (thisThreat + threatSoFar <= maxThreatRating) { group.Add(targetEnemies[idx]); threatSoFar += thisThreat; } else { // remove an enemy that will not contribute targetEnemies.RemoveAt(idx); } }while (threatSoFar < maxThreatRating && targetEnemies.Count > 0); return(group); }
private static Bitmap GetEntityTemplateImage([NotNull] IEntityTemplate template, ImageSize size) { Bitmap result; switch (size) { case ImageSize.Small: result = template.SmallImage; break; case ImageSize.Medium: result = template.Image; break; case ImageSize.Big: result = template.BigImage; break; default: result = null; break; } return(result); }
/// <summary>Initializes all.</summary> /// <param name="processAttributes">if set to <see langword="true" /> [process attributes].</param> /// <param name="assembliesToScan">The assemblies to scan.</param> /// <exception cref="Exception">propertyComponentPool is null.</exception> internal void InitializeAll(bool processAttributes, IEnumerable <Assembly> assembliesToScan = null) { if (processAttributes) { IDictionary <Type, List <Attribute> > types; if (assembliesToScan == null) { #if FULLDOTNET || METRO || UNITY5 types = AttributesProcessor.Process(AttributesProcessor.SupportedAttributes); #else types = AttributesProcessor.Process(AttributesProcessor.SupportedAttributes, null); #endif } else { types = AttributesProcessor.Process(AttributesProcessor.SupportedAttributes, assembliesToScan); } foreach (KeyValuePair <Type, List <Attribute> > item in types) { #if METRO if (typeof(EntitySystem).GetTypeInfo().IsAssignableFrom(item.Key.GetTypeInfo())) #else if (typeof(EntitySystem).IsAssignableFrom(item.Key)) #endif { Type type = item.Key; ArtemisEntitySystem pee = (ArtemisEntitySystem)item.Value[0]; EntitySystem instance = (EntitySystem)Activator.CreateInstance(type); this.SetSystem(instance, pee.GameLoopType, pee.Layer, pee.ExecutionType); } #if METRO else if (typeof(IEntityTemplate).GetTypeInfo().IsAssignableFrom(item.Key.GetTypeInfo())) #else else if (typeof(IEntityTemplate).IsAssignableFrom(item.Key)) #endif { Type type = item.Key; ArtemisEntityTemplate pee = (ArtemisEntityTemplate)item.Value[0]; IEntityTemplate instance = (IEntityTemplate)Activator.CreateInstance(type); this.entityWorld.SetEntityTemplate(pee.Name, instance); } #if METRO else if (typeof(ComponentPoolable).GetTypeInfo().IsAssignableFrom(item.Key.GetTypeInfo())) #else else if (typeof(ComponentPoolable).IsAssignableFrom(item.Key)) #endif { this.CreatePool(item.Key, item.Value); } } } for (int index = 0, j = this.mergedBag.Count; index < j; ++index) { this.mergedBag.Get(index).LoadContent(); } }
public ProcessTemplateRuleNode(IEntityTemplate entityTemplate) : base(entityTemplate) { if (entityTemplate.EntityType != EntityType.Process) { throw new ArgumentException(); } this.Name = "Process Template"; }
public DataStoreTemplateRuleNode(IEntityTemplate entityTemplate) : base(entityTemplate) { if (entityTemplate.EntityType != EntityType.DataStore) { throw new ArgumentException(); } this.Name = "Data Store Template"; }
private void OnImageChanged([NotNull] IEntityTemplate template, ImageSize size) { var row = GetRow(template); if (row != null) { row.Cells[0].CellStyles.Default.Image = template.GetImage(ImageSize.Small); } }
public ExternalInteractorTemplateRuleNode(IEntityTemplate entityTemplate) : base(entityTemplate) { if (entityTemplate.EntityType != EntityType.ExternalInteractor) { throw new ArgumentException(); } Name = "External Interactor Template"; }
/// <summary> /// Initializes all systems. /// </summary> /// <param name="processAttributes">if set to <see langword="true" /> [process attributes].</param> /// <param name="assembliesToScan">The assemblies to scan.</param> /// <exception cref="Exception">propertyComponentPool is null.</exception> internal void InitializeAll( bool processAttributes, IEnumerable <Assembly> assembliesToScan = null) { if (processAttributes) { IDictionary <Type, List <Attribute> > types; if (assembliesToScan == null) { types = AttributesProcessor.Process( supportedAttributes: AttributesProcessor.SupportedAttributes, assembliesToScan: null); } else { types = AttributesProcessor.Process( supportedAttributes: AttributesProcessor.SupportedAttributes, assembliesToScan: assembliesToScan); } foreach (KeyValuePair <Type, List <Attribute> > item in types) { Type type = item.Key; List <Attribute> attributes = item.Value; if (typeof(EntitySystem).IsAssignableFrom(type)) { EntitySystemAttribute entitySystemAttribute = (EntitySystemAttribute)attributes[0]; EntitySystem instance = (EntitySystem)Activator.CreateInstance(type); SetSystem( instance, entitySystemAttribute.UpdateType, entitySystemAttribute.Layer, entitySystemAttribute.ExecutionType); } else if (typeof(IEntityTemplate).IsAssignableFrom(type)) { EntityTemplateAttribute entitySystemAttribute = (EntityTemplateAttribute)attributes[0]; IEntityTemplate instance = (IEntityTemplate)Activator.CreateInstance(type); this.entityWorld.SetEntityTemplate(entitySystemAttribute.Name, instance); } else if (typeof(ComponentPoolable).IsAssignableFrom(type)) { CreatePool(type, attributes); } } } for (int index = 0, j = this.mergedBag.Count; index < j; ++index) { this.mergedBag.Get(index).LoadContent(); } }
public IEnumerable <IEntityTemplate> EnityMatchRating(IEntityTemplate forThis, int minRating, int maxRating) { return(m_enityList.Where((e) => { if (e.Faction.IsFriend(forThis.Faction)) { return false; } return (e.Rating.Threat >= minRating && e.Rating.Threat <= maxRating); }) .AsEnumerable <IEntityTemplate>()); }
IEnumerable <IEntityTemplate> IEntityManager.EnityMatchRating(IEntityTemplate forThis, int minRating, int maxRating) { return(m_enityList.Where((e) => { if (e.Faction.IsFriend(forThis.Faction)) { return false; } int threatForThis = forThis.Rating.GetThreat(e.Rating); return (threatForThis >= minRating && threatForThis <= maxRating); }) .AsEnumerable <IEntityTemplate>()); }
public IEnumerable <IAbility> GetAvailableAbilities( IEntityTemplate template, ICollection <IEntityStatistic> stats, ICollection <IEntitySkill> skills, ICollection <IDerivedValue> derivedValues) { List <IBasicValue <int> > data = new List <IBasicValue <int> >(); data.AddRange(stats); data.AddRange(skills); data.AddRange(derivedValues); return(this.Abilities.Where(ability => ability.MeetsPrerequisites(data))); }
protected void SetUpAbilities( IEntityTemplate template, ICollection <IEntityStatistic> stats, ICollection <IEntitySkill> skills, ICollection <IDerivedValue> derivedValues) { var abilities = this.AbilityHandler.GetAvailableAbilities( template, stats, skills, derivedValues); this.AbilityList.Points = ABILITY_PICKS_MAX; this.AbilityList.Abilities = abilities.ToArray(); }
public void Add([NotNull] IEntityTemplate entityTemplate) { if (entityTemplate is IThreatModelChild child && child.Model != this) { throw new ArgumentException(); } if (_entityTemplates == null) { _entityTemplates = new List <IEntityTemplate>(); } _entityTemplates.Add(entityTemplate); SetDirty(); ChildCreated?.Invoke(entityTemplate); }
public IEntity AddEntity <T>([Required] string name, IEntityTemplate template) where T : IEntity { IEntity result = null; if (typeof(T) == typeof(IProcess)) { result = new Process(this, name) { _templateId = template?.Id ?? Guid.Empty } } ; if (typeof(T) == typeof(IExternalInteractor)) { result = new ExternalInteractor(this, name) { _templateId = template?.Id ?? Guid.Empty } } ; if (typeof(T) == typeof(IDataStore)) { result = new DataStore(this, name) { _templateId = template?.Id ?? Guid.Empty } } ; if (result != null) { if (_entities == null) { _entities = new List <IEntity>(); } _entities.Add(result); RegisterEvents(result); Dirty.IsDirty = true; ChildCreated?.Invoke(result); } return(result); }
/// <summary> /// Create an entity from a template. /// </summary> /// <param name="entityUniqueId">ID to give new entity (assigns a new ID if null).</param> /// <param name="entityTemplate">Template instance to create the entity from.</param> /// <param name="templateArgs">Additional template arguments.</param> /// <returns></returns> public Entity CreateEntityFromTemplate( int?entityUniqueId, IEntityTemplate entityTemplate, params object[] templateArgs) { if (entityTemplate == null) { throw new MissingEntityTemplateException("Entity template was null."); } Entity entity = entityUniqueId != null ? this.EntityManager.Create(entityUniqueId.Value) : this.EntityManager.Create(); entity = entityTemplate.BuildEntity(entity, this, templateArgs); RefreshEntity(entity); return(entity); }
// REVIEW: This eventually needs to use Html.RenderView with view engine-independent rendering public static string DynamicEntity(this HtmlHelper html, object entity, string uiHint, DataBoundControlMode mode) { // REVIEW: How can we pass along the model to avoid MetaModel.Default? var table = MetaModel.Default.GetTable(entity.GetType()); // REVIEW: MetaTable does not have a UIHint. Should it? IEntityTemplate entityTemplate = MetaModel.Default.GetEntityTemplateFactory().CreateEntityTemplate(table, ref mode, uiHint /* ?? table.UIHint */); ViewUserControl entityTemplateControl = entityTemplate as ViewUserControl; if (entityTemplateControl == null) { throw new InvalidOperationException("Cannot render a dynamic entity whose entity template is not a ViewUserControl"); } entityTemplate.SetHost(new SimpleEntityTemplateHost() { Table = table, Mode = mode }); return(html.RenderViewUserControl(entityTemplateControl, entity)); }
protected void SetUpSkills(IEntityTemplate template) { this.SkillsList.Points = SKILL_POINTS_MAX; var skills = this.SkillHandler.GetDefaultSkillBlock().Values; var templateSkills = template.Skills.Values; foreach (IEntitySkill skill in skills) { var found = templateSkills.FirstOrDefault(entitySkill => entitySkill.Name.Equals(skill.Name, StringComparison.OrdinalIgnoreCase)); if (found is null) { continue; } skill.ModifyValue(found.Value); } this.SkillsList.Skills = skills; }
public void Link(Contexts contexts, GameEntity entity, IEntityTemplate template) { this.contexts = contexts; this.entity = entity; this._template = (UnityEntityTemplate)template; var link = this.gameObject.GetEntityLink(); if (link != null && link.entity != null) { this.link = link; } else { this.link = this.gameObject.Link(entity, contexts.game); } Initialize(contexts, entity); RegisterListeners(entity); entity.AddGameToDestroyListener(this); }
protected void OnCultureChange(IEntityTemplate template) { var culture = this.BasicPlayerInfo.CurrentCulture; this.GUIManager.SetUIColours( culture.BackgroundColours, culture.CursorColours, culture.FontColours, true, true, 1f); this.RandomiseName(); this.SetUpStatistics(template); this.SetUpDerivedValues(); this.SetUpSkills(template); this.SetUpAbilities( template, this.StatisticsList.Statistics, this.SkillsList.Skills, this.DerivedValuesList.DerivedValues); }
public List <IEntityTemplate> MakeEnemyGroup(IEntityTemplate forThis) { var matches = (this as IEntityManager).EnityMatchRating( forThis, forThis.Rating.Threat - m_ratingRange, forThis.Rating.Threat + m_ratingRange); int maxThreatRating = forThis.Rating.Threat + m_ratingRange; int threatSoFar = 0; var group = new List <IEntityTemplate>(); var targetEnemies = new List <IEntityTemplate>(matches); if (targetEnemies.Count == 0) { return(group); } do { int idx = m_random.Next() % targetEnemies.Count; int thisThreat = targetEnemies[idx].Rating.Threat + threatSoFar; thisThreat = Math.Max(1, thisThreat); if (thisThreat + threatSoFar <= maxThreatRating) { group.Add(targetEnemies[idx]); threatSoFar += thisThreat; } else { // remove an enemy that will not contribute targetEnemies.RemoveAt(idx); } }while (threatSoFar < maxThreatRating && targetEnemies.Count != 0); return(group); }
public static bool IsPlayer(this IEntityTemplate entityTemplate) { return(entityTemplate.Entity.Tags.Contain(EntityTags.Player)); }
/// <summary>Sets the entity template.</summary> /// <param name="entityTag">The entity tag.</param> /// <param name="entityTemplate">The entity template.</param> public void SetEntityTemplate(string entityTag, IEntityTemplate entityTemplate) { this.entityTemplates.Add(entityTag, entityTemplate); }
public bool Add(IEntityTemplate value) { this.m_Templates.Add(value); return(true); }
public void Add(IEntityTemplate e) { m_enityList.Add(e); }
public void Remove(IEntityTemplate e) { m_enityList.Remove(e); }
void IEntityManager.Remove(IEntityTemplate e) { m_enityList.Remove(e); }
void IEntityManager.Add(IEntityTemplate e) { m_enityList.Add(e); }
public void SetEntityTemplate(string entityTag, IEntityTemplate entityTemplate) { entityTemplates.Add(entityTag, entityTemplate); }
public EntityTemplateRuleNode(IEntityTemplate entityTemplate) { this.Name = "Entity Template"; this.EntityTemplate = entityTemplate?.Id ?? Guid.Empty; }