public ZMemory(byte[] data,
Action restart)
{
_restart = restart;
Header = new ZHeader(data.AsSpan(0, 31));
if (Header.Version > 5)
{
throw new NotSupportedException("ZMachine > V5 not currently supported");
}
// Version specific offsets
Offsets = VersionedOffsets.For(Header.Version);
Manager = new MemoryManager(data);
// ZMachine tables
Abbreviations = new ZAbbreviations(Header, Manager);
Dictionary = new ZDictionary(Header, Manager, Abbreviations);
ObjectTree = new ZObjectTree(Header, Manager, Abbreviations);
Globals = new ZGlobals(Header, Manager);
// Custom Stack with some abstractions for better testing.
Stack = new ZStack();
// Simple managers to abstract variable and argument usage
VariableManager = new VariableManager(Stack, Globals);
OperandManager = new OperandManager(Manager, Stack, VariableManager);
}
public void validade()
{
if (CheckChars())
{
registered.enabled = false;
invalid.enabled = true;
okButton.interactable = false;
}
else if (ExistsIn(name.text, systemVars))
{
registered.enabled = false;
invalid.enabled = true;
okButton.interactable = false;
}
else if (ExistsIn(name.text, VariableManager.ListNames()))
{
registered.enabled = true;
invalid.enabled = false;
okButton.interactable = false;
}
else
{
registered.enabled = false;
invalid.enabled = false;
okButton.interactable = true;
}
}
private static void Command_AddJournal(string[] parameters)
{
string text = String.Join(",", parameters);
VariableManager.Inject(ref text);
JournalManager2.AddTextToJournal(text);
}
private void _service_Connected(object sender, PviEventArgs e)
{
string serviceName = String.Empty;
if (sender is Service service)
{
serviceName = service.FullName;
}
var cpuWrapper = new CpuWrapper(_service, _eventNotifier);
var variableWrapper = new VariableWrapper(_service, _eventNotifier);
var fw = new FileWrapper();
var cpuManager = new CpuManager(cpuWrapper);
var variableInfo = new VariableInfoCollection(fw);
var variableManager = new VariableManager(variableWrapper, variableInfo);
var pviEventMsg = Utils.FormatPviEventMessage($"ServiceWrapper._service_Connected; ServiceName={serviceName}", e);
_eventNotifier.OnPviServiceConnected(sender, new PviApplicationEventArgs()
{
Message = pviEventMsg,
ServiceWrapper = this,
CpuManager = cpuManager,
CpuWrapper = cpuWrapper,
VariableManager = variableManager,
VariableWrapper = variableWrapper
});
_pollingService = new PollingService(_service, cpuManager);
_pollingService.Start();
}
/// <summary>
/// Look for variable and change parameter values accordingly
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public static IEnumerable <string> ParseParameter(IList <string> parameters, VariableManager varManager)
{
foreach (var param in parameters)
{
yield return(ParseParameter(param, varManager));
}
}
void Start()
{
vm = GameObject.Find("Managers").GetComponent <VariableManager> ();
tm = GameObject.Find("Managers").GetComponent <TextManager> ();
sbt = GameObject.Find("Managers").GetComponent <SetBowlingText> ();
try{
bm = GameObject.Find("Bowling Manager").GetComponent <BowlingManager> ();
vm.SetFastBowling(bm.GetFastBowling());
vm.SetSpinBowling(bm.GetSpinBowling());
vm.SetFastSpin(bm.GetFastSpinBowling());
if (bm.GetFastSpinBowling())
{
vm.SetFastBowling(true); // for first over;
}
StartCoroutine(WaitAndSetText());
Destroy(GameObject.Find("Bowling Manager"));
} catch (NullReferenceException e) {
print("GameObject could not be found");
//GameObject.Find ("Managers").RemoveComponent ();
}
}
public override IMethodValue VisitFunctionAssignment_Ex([NotNull] ClepsParser.FunctionAssignmentContext context)
{
var oldCurrMethodRegister = CurrMethodGenerator;
VariableManager variableManager = new VariableManager();
VariableManagers.Add(variableManager);
ClepsType returnType = VoidClepsType.GetVoidType();
if (context.FunctionReturnType != null)
{
returnType = Visit(context.FunctionReturnType) as ClepsType;
}
List <ClepsVariable> functionParameters = context._FunctionParameters.Select(p => Visit(p) as ClepsVariable).ToList();
FunctionClepsType functionType = new FunctionClepsType(functionParameters.Select(p => p.VariableType).ToList(), returnType);
var newMethod = CodeGenerator.CreateNewMethod(functionType);
CurrMethodGenerator = newMethod;
CurrMethodGenerator.SetFormalParameterNames(functionParameters.Select(p => p.VariableName).ToList());
functionParameters.ForEach(variable => {
variableManager.AddLocalVariable(variable, CurrMethodGenerator.GetFormalParameterRegister(variable.VariableName));
});
Visit(context.statementBlock());
VariableManagers.RemoveAt(VariableManagers.Count - 1);
CurrMethodGenerator = oldCurrMethodRegister;
return(newMethod);
}
public override object VisitFunctionVariableDeclarationStatement([NotNull] ClepsParser.FunctionVariableDeclarationStatementContext context)
{
ClepsVariable variable = Visit(context.variableDeclaration()) as ClepsVariable;
VariableManager variableManager = VariableManagers.Last();
if (!variableManager.IsVariableNameAvailable(variable.VariableName))
{
string errorMessage = String.Format("Variable {0} is already defined", variable.VariableName);
Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage));
//Use a different variable name to avoid stopping the compilation
string newVariableName = variableManager.GetAvailableVariableName(variable.VariableName);
variable = new ClepsVariable(newVariableName, variable.VariableType, variable.IsConstant);
}
IValue value = null;
if (context.rightHandExpression() != null)
{
value = Visit(context.rightHandExpression()) as IValue;
if (variable.VariableType != value.ExpressionType)
{
throw new NotImplementedException("Assignment for non identical types not supported yet");
}
}
IValueRegister variableRegister = CurrMethodGenerator.CreateNewVariable(variable, value);
variableManager.AddLocalVariable(variable, variableRegister);
return(variable);
}
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="SdlDotNet.Core.TickEventArgs"/> instance containing the event data.</param>
public override void Tick(object sender, SdlDotNet.Core.TickEventArgs e)
{
base.Tick(sender, e);
Gl.glViewport(0, 0, BackbufferWidth, BackbufferHeight);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluOrtho2D(0, BackbufferWidth, BackbufferHeight, 0);
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
// render the current game screen
GameScreenManager.CurrentGameScreen.Render();
// render the FPS
VariableManager.SetVariable("FPS", e.Fps);
// Video.Screen.Blit(FontManager.DrawText("fntMain", e.Fps.ToString(), Color.Yellow), new Point(100, 20));
// render the mouse cursor
cursor.Draw(MouseX - cursor.RealSize.Width / 2, MouseY - cursor.RealSize.Height / 2);
Gl.glFlush();
Video.GLSwapBuffers();
}
public Operand(string input)
{
if (VariableManager.HasVariable(input, out dynamic value))
{
Value = value;
}
else if (input[0] == '"' && input[input.Length - 1] == '"')
{
Value = input.Trim('"');
}
else if (bool.TryParse(input, out bool boolResult))
{
Value = boolResult;
}
else if (int.TryParse(input, out int intResult))
{
Value = intResult;
}
else if (float.TryParse(input, out float floatResult))
{
Value = floatResult;
}
else if (char.TryParse(input, out char charResult))
{
Value = charResult;
}
else
{
Value = input; //throw new NotImplementedException("Cannot identify type at line: " + (Program.Line + 1));
}
}
public override object VisitFunctionAssignment_Ex([NotNull] ClepsParser.FunctionAssignmentContext context)
{
VariableManager variableManager = new VariableManager();
VariableManagers.Add(variableManager);
ClepsType returnType = VoidType.GetVoidType();
if (context.FunctionReturnType != null)
{
returnType = Visit(context.FunctionReturnType) as ClepsType;
}
List <ClepsType> parameterTypes = context._FunctionParameterTypes.Select(t => Visit(context.FunctionReturnType) as ClepsType).ToList();
FunctionClepsType functionType = new FunctionClepsType(parameterTypes, returnType);
IMethodRegister methodRegister = CodeGenerator.GetMethodRegister(FullyQualifiedClassName, CurrMemberIsStatic, CurrMemberType, CurrMemberName);
var formalParameterNames = context._FormalParameters.Select(p => Visit(p) as string).ToList();
methodRegister.SetFormalParameterNames(formalParameterNames);
formalParameterNames.Zip(parameterTypes, (name, clepsType) => new ClepsVariable(name, clepsType))
.ToList().ForEach(variable =>
{
variableManager.AddLocalVariable(variable, methodRegister.GetFormalParameterRegister(variable.VariableName));
});
Visit(context.statementBlock());
VariableManagers.RemoveAt(VariableManagers.Count - 1);
return(functionType);
}
public override object VisitFunctionAssignment_Ex([NotNull] ClepsParser.FunctionAssignmentContext context)
{
VariableManager variableManager = new VariableManager();
VariableManagers.Add(variableManager);
ClepsType returnType = VoidType.GetVoidType();
if(context.FunctionReturnType != null)
{
returnType = Visit(context.FunctionReturnType) as ClepsType;
}
List<ClepsType> parameterTypes = context._FunctionParameterTypes.Select(t => Visit(context.FunctionReturnType) as ClepsType).ToList();
FunctionClepsType functionType = new FunctionClepsType(parameterTypes, returnType);
IMethodRegister methodRegister = CodeGenerator.GetMethodRegister(FullyQualifiedClassName, CurrMemberIsStatic, CurrMemberType, CurrMemberName);
var formalParameterNames = context._FormalParameters.Select(p => Visit(p) as string).ToList();
methodRegister.SetFormalParameterNames(formalParameterNames);
formalParameterNames.Zip(parameterTypes, (name, clepsType) => new ClepsVariable(name, clepsType))
.ToList().ForEach(variable =>
{
variableManager.AddLocalVariable(variable, methodRegister.GetFormalParameterRegister(variable.VariableName));
});
Visit(context.statementBlock());
VariableManagers.RemoveAt(VariableManagers.Count - 1);
return functionType;
}
private bool DoesVariableExist(string variableName, string correctValue, VariableManager manager)
{
string input = "_ " + variableName;
input = manager.ProcessCommand(input);
return(input.Split(" ")[1].Trim() == correctValue.Trim());
}
// Use this for initialization
void Start()
{
milestoneCheck = 50;
vm = GameObject.Find("Managers").GetComponent <VariableManager> ();
tm = GameObject.Find("Managers").GetComponent <TextManager> ();
audio = GameObject.Find("Managers").GetComponent <AudioSource> ();
}
public override IMethodValue VisitFunctionAssignment_Ex([NotNull] ClepsParser.FunctionAssignmentContext context)
{
var oldCurrMethodRegister = CurrMethodGenerator;
VariableManager variableManager = new VariableManager();
VariableManagers.Add(variableManager);
ClepsType returnType = VoidClepsType.GetVoidType();
if (context.FunctionReturnType != null)
{
returnType = Visit(context.FunctionReturnType) as ClepsType;
}
List<ClepsVariable> functionParameters = context._FunctionParameters.Select(p => Visit(p) as ClepsVariable).ToList();
FunctionClepsType functionType = new FunctionClepsType(functionParameters.Select(p => p.VariableType).ToList(), returnType);
var newMethod = CodeGenerator.CreateNewMethod(functionType);
CurrMethodGenerator = newMethod;
CurrMethodGenerator.SetFormalParameterNames(functionParameters.Select(p => p.VariableName).ToList());
functionParameters.ForEach(variable => {
variableManager.AddLocalVariable(variable, CurrMethodGenerator.GetFormalParameterRegister(variable.VariableName));
});
Visit(context.statementBlock());
VariableManagers.RemoveAt(VariableManagers.Count - 1);
CurrMethodGenerator = oldCurrMethodRegister;
return newMethod;
}
private void DumpGlobals(Node globalVarsNode)
{
var vars = new VariableManager(VariablesHelper);
vars.Load(globalVarsNode);
DumpVariables("Globals", vars);
}
private void DumpCharacter(Node characterNode)
{
if (characterNode.Children.TryGetValue("VariableManager", out var varNodes))
{
var characterVars = new VariableManager(VariablesHelper);
characterVars.Load(varNodes[0]);
var key = characterNode.Attributes["CurrentTemplate"].Value.ToString();
if (characterNode.Attributes.ContainsKey("Stats"))
{
key += " (" + (string)characterNode.Attributes["Stats"].Value + ")";
}
else if (characterNode.Children.ContainsKey("PlayerData"))
{
var playerData = characterNode.Children["PlayerData"][0]
.Children["PlayerCustomData"][0];
if (playerData.Attributes.TryGetValue("Name", out NodeAttribute name))
{
key += " (Player " + (string)name.Value + ")";
}
}
DumpVariables(key, characterVars);
}
}
internal BlockContext(IContext parent)
: base(parent)
{
this.RegisterInstance <IBlockContext>(this);
variableManager = new VariableManager(this);
exceptions = new Dictionary <string, int>(StringComparer.OrdinalIgnoreCase);
}
IEnumerator Running()
{
//VariableManager.Inject(ref dialogue);
string[] parts = dialogue.Split('[', ']');
for (int i = 0; i < parts.Length; i++)
{
bool isOdd = i % 2 != 0;
if (isOdd)
{
DialogueEvents.HandleEvent(parts[i], this);
allCurrentlyExecutedEvents.Add(parts[i]);
i++;
}
string targDialogue = parts[i];
VariableManager.Inject(ref targDialogue);
//Debug.Log("SAY THIS-" + targDialogue);
DialogueSystem.instance.Say(targDialogue, line.speaker, i > 0 ? true : pretext != "");
architect = DialogueSystem.instance.TextArchitect;
while (architect.isConstructing)
{
yield return(new WaitForEndOfFrame());
}
}
running = null;
}
public override void UpdateUI(bool isOk)
{
if (isOk)
{
Compiler.instance.Uncompile();
oldI = i.text;
type = GetNewType(typeInput.text);
if (!(oldVar == var.text))
{
if (VariableManager.Create(var.text, type, VariableManager.StructureType.Array))
{
VariableManager.RemoveFromList(oldVar);
oldVar = var.text;
oldType = typeInput.text;
}
}
else if (!(oldType == typeInput.text))
{
VariableManager.RemoveFromList(oldVar);
VariableManager.Create(var.text, type, VariableManager.StructureType.Array);
oldVar = var.text;
oldType = typeInput.text;
}
Bloco.changed = true;
ToUI();
}
else
{
var.text = oldVar;
i.text = oldI;
typeInput.text = oldType;
}
}
void Start()
{
fm = GameObject.Find("Managers").GetComponent <FireworksManager> ();
audio = GameObject.Find("Managers").GetComponent <AudioSource> ();
vm = GameObject.Find("Managers").GetComponent <VariableManager> ();
tm = GameObject.Find("Managers").GetComponent <TextManager> ();
}
/// <summary>
/// Called every time the simulation is advanced.
/// </summary>
public virtual void Advance()
{
Console.WriteLine("Advance!");
Time += 1;
VariableManager.SetVariable("time", FormattedTime);
CustomComponents.Advance();
}
public override void Execute(params string[] args)
{
string name = args[1];
string op = args[2];
string value = args[3];
if (op != "=")
{
CommandResult.AddErrorMessage("Error: Must use '=' to set value.");
return;
}
if (VariableManager.Contains(name))
{
VariableManager.Set(name, value);
}
else
{
Variable nv = new Variable();
nv.Name = name;
nv.Environment = false;
VariableManager.GetType(nv, value);
VariableManager.Add(nv);
}
}
protected virtual void Start()
{
foreach (var condition in m_Conditions)
{
VariableManager.RegisterVariable(condition.Variable);
}
}
public override void UpdateUI(bool isOk)
{
if (isOk)
{
oldI = i.text;
type = GetType(typeInput.text);
if (!(oldVar == var.text))
{
if (VariableManager.Create(var.text, type, VariableManager.StructureType.Array))
{
VariableManager.RemoveFromList(oldVar);
oldVar = var.text;
oldType = typeInput.text;
}
}
else if (!(oldType == typeInput.text))
{
VariableManager.RemoveFromList(oldVar);
VariableManager.Create(var.text, type, VariableManager.StructureType.Array);
oldVar = var.text;
oldType = typeInput.text;
}
}
else
{
var.text = oldVar;
i.text = oldI;
typeInput.text = oldType;
}
ToUI();
return;
}
public override void UpdateUI(bool isOk)
{
if (isOk)
{
Compiler.instance.Uncompile();
type = GetNewType(typeInput.text);
Debug.Log("teste " + type);
if (!(oldVar == var.text))
{
if (VariableManager.Create(var.text, type, VariableManager.StructureType.Variable))
{
VariableManager.RemoveFromList(oldVar);
oldVar = var.text;
oldType = typeInput.text;
Bloco.changed = true;
}
}
else if (!(oldType == typeInput.text))
{
VariableManager.RemoveFromList(oldVar);
VariableManager.Create(var.text, type, VariableManager.StructureType.Variable);
oldVar = var.text;
oldType = typeInput.text;
Bloco.changed = true;
}
}
else
{
var.text = oldVar;
}
Debug.Log(oldVar);
Bloco.changed = true;
ToUI();
return;
}
void UpdateVariable()
{
switch (m_Operator)
{
case Operator.Add:
{
VariableManager.SetValue(m_Variable, VariableManager.GetValue(m_Variable) + m_Value);
break;
}
case Operator.Subtract:
{
VariableManager.SetValue(m_Variable, VariableManager.GetValue(m_Variable) - m_Value);
break;
}
case Operator.Multiply:
{
VariableManager.SetValue(m_Variable, VariableManager.GetValue(m_Variable) * m_Value);
break;
}
case Operator.Set:
{
VariableManager.SetValue(m_Variable, m_Value);
break;
}
}
}
void Start()
{
if (this.setColor)
{
this.GetComponent <Renderer>().material.color = VariableManager.GetVariableColor(this.colorSetIndex, this.colorIndex);
}
if (this.setColorInChild)
{
this.GetComponentInChildren <Renderer>().material.color = VariableManager.GetVariableColor(this.colorSetIndex, this.colorIndex);
}
if (this.setRotation)
{
VariableManager.RaceTurn turnDirection = VariableManager.GetVariableTurn(this.turnIndex);
switch (turnDirection)
{
case VariableManager.RaceTurn.Left:
this.transform.Rotate(0, 0, 90);
break;
case VariableManager.RaceTurn.Right:
this.transform.Rotate(0, 0, -90);
break;
}
}
if (this.remove)
{
if (VariableManager.GetVariableTurn(this.turnIndex) == this.turnDirection)
{
Destroy(this.gameObject);
}
}
}
public void SetAndGet()
{
var vars = new VariableManager();
vars["test1"] = 1;
vars["test1"] = "5";
vars["test1"] = 6;
Assert.Equal(6, vars["test1"]);
vars["test1"] = "foobar";
Assert.Equal("foobar", vars["test1"]);
vars["test1"] = vars["test1"] + "_test";
Assert.Equal("foobar_test", vars["test1"]);
vars["test2"] = ((string)vars["test1"]).Substring(0, "foo".Length) + "bar";
Assert.Equal("foobar", vars["test2"]);
Assert.Equal(null, vars["test3"]);
Assert.Throws(typeof(InvalidCastException), () => { var test2 = (int)vars["test2"]; });
Assert.DoesNotThrow(() => { var test2 = (string)vars["test2"]; });
Assert.Throws(typeof(InvalidCastException), () => { var test1 = vars.Get <int>("test1", 0); });
Assert.DoesNotThrow(() => { var test1 = vars.Get <string>("test1", null); });
}
public override void DisplayLayout(Rect layoutRect, GUIStyle label)
{
Variables = EditorGUILayout.ObjectField("Variables", Variables, typeof(VariableManager), false) as VariableManager;
if (Variables != null && Variables.Variables.Count > 0)
{
VariableIndex = EditorGUILayout.Popup(VariableIndex, Variables.VariableNames());
}
}
public TransactionContext(IDatabaseContext databaseContext)
: base(databaseContext)
{
VariableManager = new VariableManager(this);
CursorManager = new CursorManager(this);
EventRegistry = new TransactionRegistry(this);
}
void Start()
{
audio = GameObject.Find("Managers").GetComponent <AudioSource> ();
controller = GameObject.Find("Managers").GetComponent <BallLauncher> ();
batRigidBody = this.gameObject.GetComponent <Rigidbody> ();
vm = GameObject.Find("Managers").GetComponent <VariableManager> ();
tm = GameObject.Find("Managers").GetComponent <TextManager> ();
}
protected override void Awake()
{
SetUpInput();
variableManager = GetComponent<VariableManager>();
menuManager = GetComponentInChildren<MenuManager>();
hud = menuManager.GetComponentInChildren<HUD>();
SetUpTouchIndicators();
qualityText = GetComponent<ObjectPool>();
base.Awake();
}
void Awake()
{
controller = transform.parent.GetComponentInChildren<Controller>();
purchaseManager = transform.parent.FindChild("SOOMLA").GetComponent<PurchaseManager>();
frogPackages = GetComponentInParent<FrogPackages>();
variableManager = GetComponentInParent<VariableManager>();
advertisingManager = GetComponentInParent<AdvertisingManager>();
canvas = GetComponent<RectTransform>();
titleTransform = canvas.FindChild("Title").GetComponent<RectTransform>();
mainMenu = canvas.FindChild("MainMenu").GetComponent<CanvasGroup>();
frogButton = mainMenu.transform.FindChild("FrogButton").GetComponent<RectTransform>();
settingsButton = mainMenu.transform.FindChild("SettingsButton").GetComponent<RectTransform>();
settingsMenu = canvas.FindChild("SettingsPanel").GetComponent<CanvasGroup>();
musicToggle = settingsMenu.transform.GetChild(0).FindChild("MusicToggle").GetComponent<Toggle>();
hud = transform.FindChild("HUD").GetComponent<HUD>();
hudCanvas = hud.GetComponent<CanvasGroup>();
hudRect = hud.GetComponent<RectTransform>();
qualityCountPanelCG = canvas.FindChild("QualityCountPanel").GetComponent<CanvasGroup>();
qualityCountPanel = qualityCountPanelCG.GetComponent<RectTransform>();
perfectCount = qualityCountPanel.FindChild("PerfectCount").GetComponent<TextMeshProUGUI>();
greatCount = qualityCountPanel.FindChild("GreatCount").GetComponent<TextMeshProUGUI>();;
okCount = qualityCountPanel.FindChild("OKCount").GetComponent<TextMeshProUGUI>();;
flyIconPosition = new Vector2(screenWidth, 50);
flyButton = canvas.FindChild ("FlyPanel").GetComponent<Button>();
flyPanelCG = flyButton.GetComponent<CanvasGroup>();
flyTextAnimator = flyButton.transform.FindChild("FlyCount").GetComponent<Animator>();
flyCount = flyButton.transform.FindChild("FlyCount").GetComponent<TextMeshProUGUI>();
flyToGoText = flyButton.transform.FindChild("ToGoText").GetComponent<TextMeshProUGUI>();
tameFlyNet = Instantiate(tameFlyNetPrefab, flyIconPosition, Quaternion.identity) as GameObject;
arrowPanelCG = canvas.FindChild("ArrowPanel").GetComponent<CanvasGroup>();
arrowPanel = arrowPanelCG.GetComponent<RectTransform>();
frogName = arrowPanel.FindChild("FrogName").GetComponent<TextMeshProUGUI>();
arrowPanelBuyButton = arrowPanel.FindChild("BuyButton").gameObject;
returnPanel = canvas.FindChild("ReturnPanel").GetComponent<CanvasGroup>();
returnButton = returnPanel.transform.FindChild("ReturnButton").GetComponent<RectTransform>();
Transform endGameTransform = canvas.FindChild("EndGamePanel");
endGamePanel = endGameTransform.GetComponent<CanvasGroup>();
giftButton = endGameTransform.FindChild("GiftsButton").gameObject;
adButton = endGameTransform.FindChild("AdsButton").gameObject;
timeUntilGiftText = endGameTransform.FindChild("TimeUntilGift").GetComponent<TextMeshProUGUI>();
buyButtonObject = endGameTransform.FindChild("BuyButton").gameObject;
buyButton = buyButtonObject.GetComponent<Button>();
buyButtonText = buyButton.transform.FindChild("Text").GetComponent<TextMeshProUGUI>();
buyButtonImage = buyButton.transform.FindChild("Image").GetComponent<Image>();
}
void Awake()
{
purchaseManager = GetComponentInChildren<PurchaseManager>();
menuManager = GetComponentInChildren<MenuManager>();
variableManager = GetComponent<VariableManager>();
controller = transform.GetComponentInChildren<Controller>();
//Clear any saved purchases
if(ResetPackagesOnStart)
{
PlayerPrefs.DeleteAll();
//PlayerPrefs.DeleteKey("FrogPackages");
}
LoadPackages();
}
