Merge maint16_4 changes into master

tturocy · web-flow · commit 1cb87a48f413 · 2025-12-04T18:19:39.000Z
diff --git a/ChangeLog b/ChangeLog
@@ -33,6 +33,12 @@
   when changing the number of strategies in the game (#571)
 - Fixed improper shared pointer handling when writing a .nfg file based on a game in
   extensive form.
+- Fixed a regression in the GUI in which unique action labels were not being generated when
+  adding a move via drag-and-drop of a player icon (#618)
+- Fixed a regression generating null pointer dereference errors when setting the outcome of
+  a node to the null outcome (#625, #647)
+- Fixed a regression in calculating payoff quantities for mixed strategy profiles derived from
+  mixed behavior profiles (#616)
 
 
 ## [16.3.2] - unreleased
diff --git a/src/games/game.h b/src/games/game.h
@@ -781,15 +781,17 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   {
     throw UndefinedException();
   }
-  virtual GameInfoset AppendMove(GameNode p_node, GamePlayer p_player, int p_actions)
+  virtual GameInfoset AppendMove(GameNode p_node, GamePlayer p_player, int p_actions,
+                                 bool p_generateLabels = false)
   {
     throw UndefinedException();
   }
   virtual GameInfoset AppendMove(GameNode p_node, GameInfoset p_infoset)
   {
     throw UndefinedException();
   }
-  virtual GameInfoset InsertMove(GameNode p_node, GamePlayer p_player, int p_actions)
+  virtual GameInfoset InsertMove(GameNode p_node, GamePlayer p_player, int p_actions,
+                                 bool p_generateLabels = false)
   {
     throw UndefinedException();
   }
@@ -811,7 +813,10 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
     throw UndefinedException();
   }
   virtual void DeleteAction(GameAction) { throw UndefinedException(); }
-  virtual void SetOutcome(GameNode, const GameOutcome &p_outcome) { throw UndefinedException(); }
+  virtual void SetOutcome(const GameNode &p_node, const GameOutcome &p_outcome)
+  {
+    throw UndefinedException();
+  }
 
   /// @name Dimensions of the game
   //@{
diff --git a/src/games/gameobject.h b/src/games/gameobject.h
@@ -96,14 +96,10 @@ template <class T> class GameObjectPtr {
   /// game element held by this object and throws an exception if the object is the
   /// null object, or is no longer valid (has been removed from the game)
   ///
-  /// @exception NullException if the object holds a reference to a null element
   /// @exception InvalidObjectException if the element referred to has been deleted from its game
   std::shared_ptr<T> get_shared() const
   {
-    if (!m_rep) {
-      throw NullException();
-    }
-    if (!m_rep->IsValid()) {
+    if (m_rep && !m_rep->IsValid()) {
       throw InvalidObjectException();
     }
     return m_rep;
@@ -129,16 +125,16 @@ template <class T> class GameObjectPtr {
   }
 
   bool operator==(const GameObjectPtr<T> &r) const { return (m_rep == r.m_rep); }
-  bool operator==(const std::shared_ptr<T> r) const { return (m_rep == r); }
-  bool operator==(const std::shared_ptr<const T> r) const { return (m_rep == r); }
-  bool operator==(const std::nullptr_t) const { return !bool(m_rep); }
+  bool operator==(const std::shared_ptr<T> &r) const { return (m_rep == r); }
+  bool operator==(const std::shared_ptr<const T> &r) const { return (m_rep == r); }
+  bool operator==(const std::nullptr_t &) const { return m_rep == nullptr; }
   bool operator!=(const GameObjectPtr<T> &r) const { return (m_rep != r.m_rep); }
-  bool operator!=(const std::shared_ptr<T> r) const { return (m_rep != r); }
-  bool operator!=(const std::shared_ptr<const T> r) const { return (m_rep != r); }
-  bool operator!=(const std::nullptr_t) const { return bool(m_rep); }
+  bool operator!=(const std::shared_ptr<T> &r) const { return (m_rep != r); }
+  bool operator!=(const std::shared_ptr<const T> &r) const { return (m_rep != r); }
+  bool operator!=(const std::nullptr_t &) const { return m_rep != nullptr; }
   bool operator<(const GameObjectPtr<T> &r) const { return (m_rep < r.m_rep); }
 
-  operator bool() const noexcept { return bool(m_rep); }
+  operator bool() const noexcept { return m_rep != nullptr; }
   operator std::shared_ptr<T>() const { return m_rep; }
 };
 
diff --git a/src/games/gametree.cc b/src/games/gametree.cc
@@ -345,17 +345,17 @@ void GameNodeRep::DeleteOutcome(GameOutcomeRep *outc)
   }
 }
 
-void GameTreeRep::SetOutcome(GameNode p_node, const GameOutcome &p_outcome)
+void GameTreeRep::SetOutcome(const GameNode &p_node, const GameOutcome &p_outcome)
 {
-  IncrementVersion();
   if (p_node->m_game != this) {
     throw MismatchException();
   }
   if (p_outcome && p_outcome->m_game != this) {
     throw MismatchException();
   }
-  if (p_outcome.get() != p_node->m_outcome) {
-    p_node->m_outcome = p_outcome.get();
+  if (const auto newOutcome = p_outcome.get_shared().get(); newOutcome != p_node->m_outcome) {
+    p_node->m_outcome = newOutcome;
+    IncrementVersion();
     ClearComputedValues();
   }
 }
@@ -592,7 +592,8 @@ GameInfoset GameTreeRep::LeaveInfoset(GameNode p_node)
   return node->m_infoset->shared_from_this();
 }
 
-GameInfoset GameTreeRep::AppendMove(GameNode p_node, GamePlayer p_player, int p_actions)
+GameInfoset GameTreeRep::AppendMove(GameNode p_node, GamePlayer p_player, int p_actions,
+                                    bool p_generateLabels)
 {
   GameNodeRep *node = p_node.get();
   if (p_actions <= 0 || !node->m_children.empty()) {
@@ -606,6 +607,10 @@ GameInfoset GameTreeRep::AppendMove(GameNode p_node, GamePlayer p_player, int p_
   auto newInfoset = std::make_shared<GameInfosetRep>(this, p_player->m_infosets.size() + 1,
                                                      p_player.get(), p_actions);
   p_player->m_infosets.push_back(newInfoset);
+  if (p_generateLabels) {
+    std::for_each(newInfoset->m_actions.begin(), newInfoset->m_actions.end(),
+                  [act = 1](const GameAction &a) mutable { a->SetLabel(std::to_string(act++)); });
+  }
   return AppendMove(p_node, newInfoset);
 }
 
@@ -632,7 +637,8 @@ GameInfoset GameTreeRep::AppendMove(GameNode p_node, GameInfoset p_infoset)
   return node->m_infoset->shared_from_this();
 }
 
-GameInfoset GameTreeRep::InsertMove(GameNode p_node, GamePlayer p_player, int p_actions)
+GameInfoset GameTreeRep::InsertMove(GameNode p_node, GamePlayer p_player, int p_actions,
+                                    bool p_generateLabels)
 {
   if (p_actions <= 0) {
     throw UndefinedException();
@@ -645,6 +651,10 @@ GameInfoset GameTreeRep::InsertMove(GameNode p_node, GamePlayer p_player, int p_
   auto newInfoset = std::make_shared<GameInfosetRep>(this, p_player->m_infosets.size() + 1,
                                                      p_player.get(), p_actions);
   p_player->m_infosets.push_back(newInfoset);
+  if (p_generateLabels) {
+    std::for_each(newInfoset->m_actions.begin(), newInfoset->m_actions.end(),
+                  [act = 1](const GameAction &a) mutable { a->SetLabel(std::to_string(act++)); });
+  }
   return InsertMove(p_node, newInfoset);
 }
 
diff --git a/src/games/gametree.h b/src/games/gametree.h
@@ -136,9 +136,11 @@ class GameTreeRep : public GameExplicitRep {
 
   /// @name Modification
   //@{
-  GameInfoset AppendMove(GameNode p_node, GamePlayer p_player, int p_actions) override;
+  GameInfoset AppendMove(GameNode p_node, GamePlayer p_player, int p_actions,
+                         bool p_generateLabels = false) override;
   GameInfoset AppendMove(GameNode p_node, GameInfoset p_infoset) override;
-  GameInfoset InsertMove(GameNode p_node, GamePlayer p_player, int p_actions) override;
+  GameInfoset InsertMove(GameNode p_node, GamePlayer p_player, int p_actions,
+                         bool p_generateLabels = false) override;
   GameInfoset InsertMove(GameNode p_node, GameInfoset p_infoset) override;
   void CopyTree(GameNode dest, GameNode src) override;
   void MoveTree(GameNode dest, GameNode src) override;
@@ -151,7 +153,7 @@ class GameTreeRep : public GameExplicitRep {
   Game SetChanceProbs(const GameInfoset &, const Array<Number> &) override;
   GameAction InsertAction(GameInfoset, GameAction p_where = nullptr) override;
   void DeleteAction(GameAction) override;
-  void SetOutcome(GameNode, const GameOutcome &p_outcome) override;
+  void SetOutcome(const GameNode &p_node, const GameOutcome &p_outcome) override;
 
   std::vector<GameNode> GetPlays(GameNode node) const override;
   std::vector<GameNode> GetPlays(GameInfoset infoset) const override;
diff --git a/src/games/stratmixed.h b/src/games/stratmixed.h
@@ -49,7 +49,11 @@ template <class T> class MixedStrategyProfileRep {
     return m_probs[m_profileIndex.at(p_strategy)];
   }
   /// Returns the probability the strategy is played
-  T &operator[](const GameStrategy &p_strategy) { return m_probs[m_profileIndex.at(p_strategy)]; }
+  T &operator[](const GameStrategy &p_strategy)
+  {
+    InvalidateCache();
+    return m_probs[m_profileIndex.at(p_strategy)];
+  }
   /// Set the strategy of the corresponding player to a pure strategy
   void SetStrategy(const GameStrategy &p_strategy)
   {
diff --git a/src/gui/gamedoc.cc b/src/gui/gamedoc.cc
@@ -547,10 +547,7 @@ void GameDocument::DoAppendMove(GameNode p_node, GameInfoset p_infoset)
 
 void GameDocument::DoInsertMove(GameNode p_node, GamePlayer p_player, unsigned int p_actions)
 {
-  const GameInfoset infoset = m_game->InsertMove(p_node, p_player, p_actions);
-  auto actions = infoset->GetActions();
-  std::for_each(actions.begin(), actions.end(),
-                [act = 1](const GameAction &a) mutable { a->SetLabel(std::to_string(act)); });
+  m_game->InsertMove(p_node, p_player, p_actions, true);
   m_game->SortInfosets();
   UpdateViews(GBT_DOC_MODIFIED_GAME);
 }
diff --git a/tests/test_node.py b/tests/test_node.py
@@ -19,10 +19,17 @@ def test_get_infoset():
 def test_get_outcome():
     """Test to ensure that we can retrieve an outcome for a given node"""
     game = games.read_from_file("basic_extensive_game.efg")
-    assert game.root.children[0].children[1].children[0].outcome == game.outcomes[1]
+    assert game.root.children[0].children[1].children[0].outcome == game.outcomes["Outcome 1"]
     assert game.root.outcome is None
 
 
+def test_set_outcome_null():
+    """Test to set an outcome to the null outcome."""
+    game = games.read_from_file("basic_extensive_game.efg")
+    game.set_outcome(game.root.children[0].children[0].children[0], None)
+    assert game.root.children[0].children[0].children[0].outcome is None
+
+
 def test_get_player():
     """Test to ensure that we can retrieve a player for a given node"""
     game = games.read_from_file("basic_extensive_game.efg")

Original file line number	Diff line number	Diff line change
`@@ -781,15 +781,17 @@ class GameRep : public std::enable_shared_from_this<GameRep> {`
`781`	`781`	`{`
`782`	`782`	`throw UndefinedException();`
`783`	`783`	`}`
`784`		`- virtual GameInfoset AppendMove(GameNode p_node, GamePlayer p_player, int p_actions)`
	`784`	`+ virtual GameInfoset AppendMove(GameNode p_node, GamePlayer p_player, int p_actions,`
	`785`	`+ bool p_generateLabels = false)`
`785`	`786`	`{`
`786`	`787`	`throw UndefinedException();`
`787`	`788`	`}`
`788`	`789`	`virtual GameInfoset AppendMove(GameNode p_node, GameInfoset p_infoset)`
`789`	`790`	`{`
`790`	`791`	`throw UndefinedException();`
`791`	`792`	`}`
`792`		`- virtual GameInfoset InsertMove(GameNode p_node, GamePlayer p_player, int p_actions)`
	`793`	`+ virtual GameInfoset InsertMove(GameNode p_node, GamePlayer p_player, int p_actions,`
	`794`	`+ bool p_generateLabels = false)`
`793`	`795`	`{`
`794`	`796`	`throw UndefinedException();`
`795`	`797`	`}`
`@@ -811,7 +813,10 @@ class GameRep : public std::enable_shared_from_this<GameRep> {`
`811`	`813`	`throw UndefinedException();`
`812`	`814`	`}`
`813`	`815`	`virtual void DeleteAction(GameAction) { throw UndefinedException(); }`
`814`		`- virtual void SetOutcome(GameNode, const GameOutcome &p_outcome) { throw UndefinedException(); }`
	`816`	`+ virtual void SetOutcome(const GameNode &p_node, const GameOutcome &p_outcome)`
	`817`	`+ {`
	`818`	`+ throw UndefinedException();`
	`819`	`+ }`
`815`	`820`
`816`	`821`	`/// @name Dimensions of the game`
`817`	`822`	`//@{`
Original file line number	Diff line number	Diff line change
`@@ -345,17 +345,17 @@ void GameNodeRep::DeleteOutcome(GameOutcomeRep *outc)`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
`348`		`-void GameTreeRep::SetOutcome(GameNode p_node, const GameOutcome &p_outcome)`
	`348`	`+void GameTreeRep::SetOutcome(const GameNode &p_node, const GameOutcome &p_outcome)`
`349`	`349`	`{`
`350`		`- IncrementVersion();`
`351`	`350`	`if (p_node->m_game != this) {`
`352`	`351`	`throw MismatchException();`
`353`	`352`	`}`
`354`	`353`	`if (p_outcome && p_outcome->m_game != this) {`
`355`	`354`	`throw MismatchException();`
`356`	`355`	`}`
`357`		`- if (p_outcome.get() != p_node->m_outcome) {`
`358`		`- p_node->m_outcome = p_outcome.get();`
	`356`	`+ if (const auto newOutcome = p_outcome.get_shared().get(); newOutcome != p_node->m_outcome) {`
	`357`	`+ p_node->m_outcome = newOutcome;`
	`358`	`+ IncrementVersion();`
`359`	`359`	`ClearComputedValues();`
`360`	`360`	`}`
`361`	`361`	`}`
`@@ -592,7 +592,8 @@ GameInfoset GameTreeRep::LeaveInfoset(GameNode p_node)`
`592`	`592`	`return node->m_infoset->shared_from_this();`
`593`	`593`	`}`
`594`	`594`
`595`		`-GameInfoset GameTreeRep::AppendMove(GameNode p_node, GamePlayer p_player, int p_actions)`
	`595`	`+GameInfoset GameTreeRep::AppendMove(GameNode p_node, GamePlayer p_player, int p_actions,`
	`596`	`+ bool p_generateLabels)`
`596`	`597`	`{`
`597`	`598`	`GameNodeRep *node = p_node.get();`
`598`	`599`	`if (p_actions <= 0 \|\| !node->m_children.empty()) {`
`@@ -606,6 +607,10 @@ GameInfoset GameTreeRep::AppendMove(GameNode p_node, GamePlayer p_player, int p_`
`606`	`607`	`auto newInfoset = std::make_shared<GameInfosetRep>(this, p_player->m_infosets.size() + 1,`
`607`	`608`	`p_player.get(), p_actions);`
`608`	`609`	`p_player->m_infosets.push_back(newInfoset);`
	`610`	`+ if (p_generateLabels) {`
	`611`	`+ std::for_each(newInfoset->m_actions.begin(), newInfoset->m_actions.end(),`
	`612`	`+ [act = 1](const GameAction &a) mutable { a->SetLabel(std::to_string(act++)); });`
	`613`	`+ }`
`609`	`614`	`return AppendMove(p_node, newInfoset);`
`610`	`615`	`}`
`611`	`616`
`@@ -632,7 +637,8 @@ GameInfoset GameTreeRep::AppendMove(GameNode p_node, GameInfoset p_infoset)`
`632`	`637`	`return node->m_infoset->shared_from_this();`
`633`	`638`	`}`
`634`	`639`
`635`		`-GameInfoset GameTreeRep::InsertMove(GameNode p_node, GamePlayer p_player, int p_actions)`
	`640`	`+GameInfoset GameTreeRep::InsertMove(GameNode p_node, GamePlayer p_player, int p_actions,`
	`641`	`+ bool p_generateLabels)`
`636`	`642`	`{`
`637`	`643`	`if (p_actions <= 0) {`
`638`	`644`	`throw UndefinedException();`
`@@ -645,6 +651,10 @@ GameInfoset GameTreeRep::InsertMove(GameNode p_node, GamePlayer p_player, int p_`
`645`	`651`	`auto newInfoset = std::make_shared<GameInfosetRep>(this, p_player->m_infosets.size() + 1,`
`646`	`652`	`p_player.get(), p_actions);`
`647`	`653`	`p_player->m_infosets.push_back(newInfoset);`
	`654`	`+ if (p_generateLabels) {`
	`655`	`+ std::for_each(newInfoset->m_actions.begin(), newInfoset->m_actions.end(),`
	`656`	`+ [act = 1](const GameAction &a) mutable { a->SetLabel(std::to_string(act++)); });`
	`657`	`+ }`
`648`	`658`	`return InsertMove(p_node, newInfoset);`
`649`	`659`	`}`
`650`	`660`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,11 @@ template <class T> class MixedStrategyProfileRep {`
`49`	`49`	`return m_probs[m_profileIndex.at(p_strategy)];`
`50`	`50`	`}`
`51`	`51`	`/// Returns the probability the strategy is played`
`52`		`- T &operator[](const GameStrategy &p_strategy) { return m_probs[m_profileIndex.at(p_strategy)]; }`
	`52`	`+ T &operator[](const GameStrategy &p_strategy)`
	`53`	`+ {`
	`54`	`+ InvalidateCache();`
	`55`	`+ return m_probs[m_profileIndex.at(p_strategy)];`
	`56`	`+ }`
`53`	`57`	`/// Set the strategy of the corresponding player to a pure strategy`
`54`	`58`	`void SetStrategy(const GameStrategy &p_strategy)`
`55`	`59`	`{`
Original file line number	Diff line number	Diff line change
`@@ -547,10 +547,7 @@ void GameDocument::DoAppendMove(GameNode p_node, GameInfoset p_infoset)`
`547`	`547`
`548`	`548`	`void GameDocument::DoInsertMove(GameNode p_node, GamePlayer p_player, unsigned int p_actions)`
`549`	`549`	`{`
`550`		`- const GameInfoset infoset = m_game->InsertMove(p_node, p_player, p_actions);`
`551`		`- auto actions = infoset->GetActions();`
`552`		`- std::for_each(actions.begin(), actions.end(),`
`553`		`- [act = 1](const GameAction &a) mutable { a->SetLabel(std::to_string(act)); });`
	`550`	`+ m_game->InsertMove(p_node, p_player, p_actions, true);`
`554`	`551`	`m_game->SortInfosets();`
`555`	`552`	`UpdateViews(GBT_DOC_MODIFIED_GAME);`
`556`	`553`	`}`