Ticket #979: entity_randomization_svn_25feb12.patch

source/graphics/ObjectBase.cpp

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2012 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -335 +335 @@
 
         // Remember which props were chosen, so we can call CalculateVariationKey on them
         // at the end.
-        CObjectBase::Variant& var ((*grp)[match]);
-        for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
+        Variant& var ((*grp)[match]);
+        for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
         {
             // Erase all existing props which are overridden by this variant:
-            for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
+            for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
                 chosenProps.erase(it->m_PropPointName);
             // and then insert the new ones:
-            for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
+            for (std::vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
                 if (! it->m_ModelName.empty())
                     chosenProps.insert(make_pair(it->m_PropPointName, it->m_ModelName));
         }
@@ -437 +437 @@
 {
     rng_t rng;
     rng.seed(seed);
-    return CalculateRandomVariation(rng, initialSelections);
+
+    std::set<CStr> remainingSelections = CalculateRandomRemainingSelections(rng, std::vector<std::set<CStr> >(1, initialSelections));
+    remainingSelections.insert(initialSelections.begin(), initialSelections.end());
+
+    return remainingSelections; // now actually a complete set of selections
 }
 
-std::set<CStr> CObjectBase::CalculateRandomVariation(rng_t& rng, const std::set<CStr>& initialSelections)
+std::set<CStr> CObjectBase::CalculateRandomRemainingSelections(uint32_t seed, const std::vector<std::set<CStr> >& initialSelections)
 {
-    std::set<CStr> selections = initialSelections;
+    rng_t rng;
+    rng.seed(seed);
+    return CalculateRandomRemainingSelections(rng, initialSelections);
+}
 
-    std::multimap<CStr, CStrW> chosenProps;
+std::set<CStr> CObjectBase::CalculateRandomRemainingSelections(rng_t& rng, const std::vector<std::set<CStr> >& initialSelections)
+{
+    using std::set;
+    using std::vector;
+    using std::multimap;
 
+    set<CStr> remainingSelections;
+    multimap<CStr, CStrW> chosenProps;
+
     // Calculate a complete list of selections, so there is at least one
     // (and in most cases only one) per group.
     // In each group, if one of the variants has a name matching a string in
@@ -456 +470 @@
     // When choosing randomly, make use of each variant's frequency. If all
     // variants have frequency 0, treat them as if they were 1.
 
-    for (std::vector<std::vector<CObjectBase::Variant> >::iterator grp = m_VariantGroups.begin();
+    for (vector<vector<Variant> >::iterator grp = m_VariantGroups.begin();
         grp != m_VariantGroups.end();
         ++grp)
     {
@@ -475 +489 @@
         else
         {
             // See if a variant (or several, but we only care about the first)
-            // is already matched by the selections we've made
+            // is already matched by the selections we've made, keeping their
+            // priority order into account
 
-            for (size_t i = 0; i < grp->size(); ++i)
+            for (size_t s = 0; s < initialSelections.size(); ++s)
             {
-                if (selections.count((*grp)[i].m_VariantName))
+                for (size_t i = 0; i < grp->size(); ++i)
                 {
-                    match = (int)i;
+                    if (initialSelections[s].count((*grp)[i].m_VariantName))
+                    {
+                        match = (int)i;
+                        break;
+                    }
+                }
+
+                if (match >= 0)
                     break;
-                }
             }
 
             // If there was one, we don't need to do anything now because there's
@@ -509 +530 @@
                     randNum -= (allZero ? 1 : (*grp)[i].m_Frequency);
                     if (randNum < 0)
                     {
-                        selections.insert((*grp)[i].m_VariantName);
-                        // (If this change to 'selections' interferes with earlier
-                        // choices, then we'll get some non-fatal inconsistencies
-                        // that just break the randomness. But that shouldn't
-                        // happen, much.)
+                        remainingSelections.insert((*grp)[i].m_VariantName);
+                        // (If this change to 'remainingSelections' interferes with earlier choices, then 
+                        // we'll get some non-fatal inconsistencies that just break the randomness. But that
+                        // shouldn't happen, much.)
+                        // (As an example, suppose you have a group with variants "a" and "b", and another
+                        // with variants "a" and "c"; now if random selection choses "b" for the first
+                        // and "a" for the second, then the selection of "a" from the second group will
+                        // cause "a" to be used in the first instead of the "b").
                         match = (int)i;
                         break;
                     }
@@ -526 +550 @@
 
         // Remember which props were chosen, so we can call CalculateRandomVariation on them
         // at the end.
-        CObjectBase::Variant& var ((*grp)[match]);
-        for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
+        Variant& var ((*grp)[match]);
+        for (vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
         {
             // Erase all existing props which are overridden by this variant:
-            for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
+            for (vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
                 chosenProps.erase(it->m_PropPointName);
             // and then insert the new ones:
-            for (std::vector<CObjectBase::Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
+            for (vector<Prop>::iterator it = var.m_Props.begin(); it != var.m_Props.end(); ++it)
                 if (! it->m_ModelName.empty())
                     chosenProps.insert(make_pair(it->m_PropPointName, it->m_ModelName));
         }
     }
 
     // Load each prop, and add their required selections to ours:
-    for (std::multimap<CStr, CStrW>::iterator it = chosenProps.begin(); it != chosenProps.end(); ++it)
+    for (multimap<CStr, CStrW>::iterator it = chosenProps.begin(); it != chosenProps.end(); ++it)
     {
         CObjectBase* prop = m_ObjectManager.FindObjectBase(it->second);
         if (prop)
         {
-            std::set<CStr> propSelections = prop->CalculateRandomVariation(rng, selections);
-            // selections = union(propSelections, selections)
-            std::set<CStr> newSelections;
-            std::set_union(propSelections.begin(), propSelections.end(),
-                selections.begin(), selections.end(),
-                std::inserter(newSelections, newSelections.begin()));
-            selections.swap(newSelections);
+            vector<set<CStr> > propInitialSelections = initialSelections;
+            if (remainingSelections.size() > 0)
+                propInitialSelections.push_back(remainingSelections);
 
+            set<CStr> propRemainingSelections = prop->CalculateRandomRemainingSelections(rng, propInitialSelections);
+            remainingSelections.insert(propRemainingSelections.begin(), propRemainingSelections.end());
+
             // Add the prop's used files to our own (recursively) so we can hotload
             // when any prop is changed
             m_UsedFiles.insert(prop->m_UsedFiles.begin(), prop->m_UsedFiles.end());
         }
     }
 
-    return selections;
+    return remainingSelections;
 }
 
 std::vector<std::vector<CStr> > CObjectBase::GetVariantGroups() const

source/graphics/ObjectBase.h

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2012 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -113 +113 @@
     // and choosing randomly where a choice is necessary. 
     std::set<CStr> CalculateRandomVariation(uint32_t seed, const std::set<CStr>& initialSelections);
 
+    // Given a prioritized vector of selection string sets that partially specify
+    // a variation, calculates a remaining set of selection strings such that the resulting 
+    // set merged with the initial selections fully specifies an exact variation of
+    // the actor. The resulting selections are selected randomly, but only where a choice
+    // is necessary (i.e. where there are multiple variants but the initial selections,
+    // applied in priority order, fail to select one).
+    std::set<CStr> CalculateRandomRemainingSelections(uint32_t seed, const std::vector<std::set<CStr> >& initialSelections);
+
     // Get a list of variant groups for this object, plus for all possible
     // props. Duplicated groups are removed, if several props share the same
     // variant names.
@@ -160 +168 @@
     // so use a better one that appears to avoid those patterns
     typedef boost::mt19937 rng_t;
 
-    std::set<CStr> CalculateRandomVariation(rng_t& rng, const std::set<CStr>& initialSelections);
+    std::set<CStr> CalculateRandomRemainingSelections(rng_t& rng, const std::vector<std::set<CStr> >& initialSelections);
 
     std::vector< std::vector<Variant> > m_VariantGroups;
     CObjectManager& m_ObjectManager;

source/graphics/Unit.cpp

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2012 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -105 +105 @@
     selections.push_back(m_EntitySelections);
     selections.push_back(m_ActorSelections);
 
+    // randomly select any remain selections necessary to completely identify a variation (e.g., the new selection
+    // made might define some additional props that require a random variant choice). Also, FindObjectVariation
+    // expects the selectors passed to it to be complete.
+    // see http://trac.wildfiregames.com/ticket/979
+    
+    // Use the entity ID as randomization seed (same as when the unit was first created)
+    std::set<CStr> remainingSelections = m_Object->m_Base->CalculateRandomRemainingSelections(m_ID, selections);
+    if (remainingSelections.size() > 0)
+        selections.push_back(remainingSelections);
+
     // If these selections give a different object, change this unit to use it
     CObjectEntry* newObject = m_ObjectManager.FindObjectVariation(m_Object->m_Base, selections);
     if (newObject && newObject != m_Object)