Unity3D In-Game Context Menus - Strange behaviour - unity3d

Question

What happens when you add an Action to a Dictionary from another object?
First off, I'm trying to design some decent in-game context menus. My goal is to dynamically generate each item. Each item is loaded from a Dictionary that stores Actions. The dictionary is accessed from up to 3 components of each gameObject with a GamePiece component attached.
First, there is a dictionary with Actions living as a component of each type GamePiece:
public class GamePiece : MonoBehaviour {
protected bool rightClickable = true;
protected StatManager statManager;
Transform ui;
CanvasManager canvas;
SpriteRenderer sprite;
Color spriteColor;
public Dictionary<string, Action> actions;
void Awake(){
statManager = GameObject.Find("StatPanel").GetComponent<StatManager>();
actions = new Dictionary<string, Action>();
actions.Add("Deconstruct", Deconstruct);
}
The problem is that no matter how I populate the dictionary, the last added dictionary item is called. So if I were to add a "Destroy()" call and a "SupplyPower()" call. The dictionary will only ever call "Supply Power". This is particularly odd because the menus themselves are displaying the correct buttons.
I suspect the problem to be that I'm adding dictionary items from other components on the same gameObject. For instance, The GamePiece component holds the dictionary and adds some basic actions, and then a Generator component will access that an add a reference to it's own SupplyPower() method
public class Generator: MonoBehaviour {
public Structure structure;
void Start () {
structure = gameObject.GetComponent<Structure>();
structure.gamePiece.actions.Add("Supply Power", SupplyPower);
}
}
So here's what happens when the context menu is created:
public class ContextMenu : MonoBehaviour {
public Transform menuItem;
//Takes a ref from the calling gameObject, t. And is called from CanvasManager.cs
public void PopulateContextMenu(GameObject t)
{
Transform selections = transform.FindChild("Selections").transform; //Parent for items.
//gamePiece holds the dictionary.
GamePiece gamePiece = t.GetComponent<GamePiece>();
foreach (KeyValuePair<string, Action> kVp in gamePiece.actions)
{
GameObject menuItem =
(GameObject)Instantiate(Resources.Load("MenuItem"));
menuItem.name = kVp.Key;
menuItem.GetComponent<Text>().text = kVp.Key;
//Adding functuionality.
menuItem.GetComponent<Button>().onClick.AddListener
(() => { kVp.Value.Invoke(); });
menuItem.GetComponent<Button>().onClick.AddListener
(() => { CloseContextMenu(); });
menuItem.transform.SetParent(selections, false);
}
}
public void CloseContextMenu()
{
Destroy(this.gameObject);
}
}
The PopulateContextMenu function is called from the CanvasManager class:
public class CanvasManager : MonoBehaviour {
public void ToggleContextMenu(GameObject t) {
GameObject newMenu = (GameObject)Resources.Load("ContextMenu");
newMenu = Instantiate(newMenu) as GameObject;
//Passing gameObject t into PopulatContextMenu
newMenu.GetComponent<ContextMenu>().PopulateContextMenu(t);
}
}
Here, ToggleContextMenu() is called from the gameObjects OnMouseOver() callback:
public class GamePiece : MonoBehaviour {
void OnMouseOver(){
if (Input.GetMouseButtonDown(1) && rightClickable) {
canvas.ToggleContextMenu(this.gameObject);
}
}
}
So when this is called, it's passing a reference to itself to the CanvasManager and then getting handed off the ContextMenu.

Answer 1

Store the Actions locally before invoking and you're good to go.
In ContextMenu:
Action newAction =kVp.Value;
menuItem.GetComponent<Button>().onClick.AddListener(() => {newAction.Invoke();});