private static EphemeralRealm Initialize(Player owner, WorldRealm baseRealm, List <Realm> appliedRealms)
        {
            string          key          = baseRealm.Realm.Id.ToString();
            RulesetTemplate template     = null;
            RulesetTemplate prevTemplate = baseRealm.RulesetTemplate;

            for (int i = 0; i < appliedRealms.Count; i++)
            {
                var appliedRealm = appliedRealms[i];
                key     += $".{appliedRealm.Id}";
                template = RealmManager.GetEphemeralRealmRulesetTemplate(key);
                if (template == null)
                {
                    template = RulesetTemplate.MakeRuleset(prevTemplate, appliedRealm);
                    RealmManager.CacheEphemeralRealmTemplate(key, template);
                }
                prevTemplate = template;
            }

            if (template == null)
            {
                template = prevTemplate;
            }
            return(new EphemeralRealm(owner, template));
        }
 private static AppliedRealmProperty GetRandomProperty(RulesetTemplate template)
 {
     if (template.PropertiesForRandomization?.Count == 0)
     {
         return(null);
     }
     return(template.PropertiesForRandomization[random.Next(template.PropertiesForRandomization.Count - 1)]);
 }
 protected void CopyDicts(RulesetTemplate copyFrom)
 {
     if (copyFrom.Realm.PropertyCountRandomized.HasValue)
     {
         var count = copyFrom.Realm.PropertyCountRandomized.Value;
         var props = TakeRandomProperties(count, copyFrom);
         foreach (var prop in props)
         {
             if (prop is AppliedRealmProperty <bool> a)
             {
                 PropertiesBool.Add((RealmPropertyBool)a.PropertyKey, new AppliedRealmProperty <bool>(a));
             }
             else if (prop is AppliedRealmProperty <int> b)
             {
                 PropertiesInt.Add((RealmPropertyInt)b.PropertyKey, new AppliedRealmProperty <int>(b));
             }
             else if (prop is AppliedRealmProperty <double> c)
             {
                 PropertiesFloat.Add((RealmPropertyFloat)c.PropertyKey, new AppliedRealmProperty <double>(c));
             }
             else if (prop is AppliedRealmProperty <long> d)
             {
                 PropertiesInt64.Add((RealmPropertyInt64)d.PropertyKey, new AppliedRealmProperty <long>(d));
             }
             else if (prop is AppliedRealmProperty <string> e)
             {
                 PropertiesString.Add((RealmPropertyString)e.PropertyKey, new AppliedRealmProperty <string>(e));
             }
         }
     }
     else
     {
         foreach (var item in copyFrom.PropertiesBool)
         {
             PropertiesBool.Add(item.Key, new AppliedRealmProperty <bool>(item.Value));
         }
         foreach (var item in copyFrom.PropertiesFloat)
         {
             PropertiesFloat.Add(item.Key, new AppliedRealmProperty <double>(item.Value));
         }
         foreach (var item in copyFrom.PropertiesInt)
         {
             PropertiesInt.Add(item.Key, new AppliedRealmProperty <int>(item.Value));
         }
         foreach (var item in copyFrom.PropertiesInt64)
         {
             PropertiesInt64.Add(item.Key, new AppliedRealmProperty <long>(item.Value));
         }
         foreach (var item in copyFrom.PropertiesString)
         {
             PropertiesString.Add(item.Key, new AppliedRealmProperty <string>(item.Value));
         }
     }
 }
        private void ComposeFrom(RulesetTemplate parentTemplate, bool invertRules = false)
        {
            if (parentTemplate == null)
            {
                return;
            }
            var parent = MakeRerolledRuleset(parentTemplate);

            ApplyRulesetDict(parent.PropertiesBool, PropertiesBool, invertRules);
            ApplyRulesetDict(parent.PropertiesFloat, PropertiesFloat, invertRules);
            ApplyRulesetDict(parent.PropertiesInt, PropertiesInt, invertRules);
            ApplyRulesetDict(parent.PropertiesInt64, PropertiesInt64, invertRules);
            ApplyRulesetDict(parent.PropertiesString, PropertiesString, invertRules);
        }
        public static RulesetTemplate MakeTopLevelRuleset(Realm entity)
        {
            var ruleset = new RulesetTemplate();

            ruleset.Realm = entity;

            ruleset.PropertiesBool   = new Dictionary <RealmPropertyBool, AppliedRealmProperty <bool> >(entity.PropertiesBool);
            ruleset.PropertiesFloat  = new Dictionary <RealmPropertyFloat, AppliedRealmProperty <double> >(entity.PropertiesFloat);
            ruleset.PropertiesInt    = new Dictionary <RealmPropertyInt, AppliedRealmProperty <int> >(entity.PropertiesInt);
            ruleset.PropertiesInt64  = new Dictionary <RealmPropertyInt64, AppliedRealmProperty <long> >(entity.PropertiesInt64);
            ruleset.PropertiesString = new Dictionary <RealmPropertyString, AppliedRealmProperty <string> >(entity.PropertiesString);
            ruleset.Jobs             = entity.Jobs;

            ruleset.MakeRandomizationList();
            return(ruleset);
        }
        /// <summary>
        /// Imprints a ruleset template onto a new Active Ruleset, applying all rules as configured
        /// </summary>
        /// <param name="template"></param>
        /// <returns></returns>
        internal static AppliedRuleset MakeRerolledRuleset(RulesetTemplate template)
        {
            var result = new AppliedRuleset(template);

            result.CopyDicts(template);
            if (template.ParentRuleset != null)
            {
                result.ComposeFrom(template.ParentRuleset);
            }
            foreach (var job in template.Jobs.Where(x => x.Type == RealmRulesetLinkType.apply_after_inherit))
            {
                result.ApplyJob(job);
            }

            // Composition needs to happen first before rerolling,
            // so that random properties that depend on other random
            // properties with a composition rule can be applied in sequence
            result.RerollAllRules();
            return(result);
        }
        public static RulesetTemplate MakeRuleset(RulesetTemplate baseset, Realm subset)
        {
            if (baseset.Realm.Type == ACE.Entity.Enum.RealmType.Ruleset && subset.Type == ACE.Entity.Enum.RealmType.Realm)
            {
                throw new Exception("Realms may not inherit from rulesets at this time.");
            }
            var ruleset = new RulesetTemplate();

            ruleset.ParentRuleset = baseset;
            ruleset.Realm         = subset;

            ruleset.PropertiesBool   = new Dictionary <RealmPropertyBool, AppliedRealmProperty <bool> >(subset.PropertiesBool);
            ruleset.PropertiesFloat  = new Dictionary <RealmPropertyFloat, AppliedRealmProperty <double> >(subset.PropertiesFloat);
            ruleset.PropertiesInt    = new Dictionary <RealmPropertyInt, AppliedRealmProperty <int> >(subset.PropertiesInt);
            ruleset.PropertiesInt64  = new Dictionary <RealmPropertyInt64, AppliedRealmProperty <long> >(subset.PropertiesInt64);
            ruleset.PropertiesString = new Dictionary <RealmPropertyString, AppliedRealmProperty <string> >(subset.PropertiesString);
            ruleset.Jobs             = subset.Jobs;

            ruleset.MakeRandomizationList();
            return(ruleset);
        }
 private EphemeralRealm(Player owner, RulesetTemplate template)
 {
     this.Owner           = owner;
     this.RulesetTemplate = template;
 }
 //Deep copy
 private AppliedRuleset(RulesetTemplate template)
 {
     Template = template;
     InitializePropertyDictionaries();
 }
        private IEnumerable <AppliedRealmProperty> TakeRandomProperties(ushort amount, RulesetTemplate template)
        {
            if (PropertiesString.TryGetValue(RealmPropertyString.Description, out var desc))
            {
                amount++;
            }

            var total = PropertiesBool.Count +
                        PropertiesInt.Count +
                        PropertiesInt64.Count +
                        PropertiesFloat.Count +
                        PropertiesString.Count;

            if (amount <= total / 2)
            {
                var set = new HashSet <AppliedRealmProperty>();
                if (desc != null)
                {
                    set.Add(desc);
                }
                while (set.Count < amount)
                {
                    set.Add(GetRandomProperty(template));
                }
                return(set);
            }
            else
            {
                var all = new List <AppliedRealmProperty>(template.PropertiesForRandomization);
                if (amount >= all.Count)
                {
                    return(all);
                }
                var set = new HashSet <AppliedRealmProperty>(all);
                while (set.Count > amount)
                {
                    var next = GetRandomProperty(template);
                    if (next is AppliedRealmProperty <string> s && s.PropertyKey == (ushort)RealmPropertyString.Description)
                    {
                        continue;
                    }
                    set.Remove(next);
                }
                return(set);
            }
        }
Пример #11
0
 public WorldRealm(Realm realmEntity, RulesetTemplate ruleset)
 {
     Realm           = realmEntity;
     RulesetTemplate = ruleset;
     StandardRules   = AppliedRuleset.MakeRerolledRuleset(RulesetTemplate);
 }