key = Greenfoot.getKey();
if (key != null){
    switch (key){
        etc.
        etc.
    }
}

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.io.File;
import java.io.IOException;

/**
 * Write a description of class MyWorld here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Calculator extends World
{
    private String[] numButton = 
        { "0", "", "", "", "1", "2", "3", "", "4", "5", "6", "", "7", "8", "9"};

    private String[] operationButton = 
        { "", ".", "=", "÷", "", "", "", "x", "", "", "", "-", "", "", "", "+"};

    private String[] operationButtonName = 
        { "", "Decimal", "Equal", "Divide", "", "", "", "Multiply", "", "", "", "Minus", "", "", "", "Plus", "", ""};
    
    private String[] advOperationButton = /**edit*/
        { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "$a$", "(", ")", "()!", "", "#s(", "#c(", "#t(", "|()|", "()&√&()", "()&^&()", "()&/&()"};
    
    private String[] advOperationButtonName = /**edit*/
        { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Ans", " (", " )", " x!", "", "Sin", "Cos", "Tan", "Abs", " √", "x^y", "☐/☐"};
    /**when searching thru calc to check for pronumerals, search for *, then do placeholderstring,
     * (excluding first '*') then go 'if placeholderstring.firstindexof(*) is 1 then pronumeral = 
     * character at index 0, then search thru file b4 replacing with value using
     * plcehlderstrngs 2&3
     */
    //Button coordinates
    int xCoordStart = 90;
    int yCoordStart = 550;
    int xCoord1 = xCoordStart;
    int yCoord1 = yCoordStart;
    int xCoord2 = xCoordStart;
    int yCoord2 = yCoordStart;
    int xCoord3 = xCoordStart;
    int yCoord3 = yCoordStart;
    int buttonSpacingXVal = 80;
    int buttonSpacingYVal = 40;
    //the initial value of yCoord3 does not matter (it is autocorrected)...
    //...this was unintentional. The same applies for yCoord2.
    
    //Input display coordinates
    int xCoord4 = 350;
    int yCoord4 = 100;
    

    int count = 0;
    String text = "";
    String currentNum = "";

    Calculate myCalculator = new Calculate();
    GreenfootImage img = getBackground();
    /**
     * Constructor for objects of class Calculator.
     * 
     */
    public Calculator()
    {    
        super(420, 600, 1);
        printInitialMessage();
        makeNumButtons();
        makeOpButtons();
        makeAdvOpButtons();
        makeActionButtons();
        makeArrowButtons();
        prepare();
        updateDisplay();
        createFiles();
    }
    
    public void printInitialMessage(){
        System.out.println("NOTICE FOR THE USER:");
        System.out.println("It is vital that any bugs in this software are reported");
        System.out.println("to the development team for possible maintenance.");
        System.out.println("Some issues can go unnoticed in the development of a");
        System.out.println("software, despite extensive bug testing.");
        System.out.println("The development team wish to maintain a quality product,");
        System.out.println("and user feedback is highly effective and highly valued");
        System.out.println("in the maintenance of this product.");
    }

    public void makeNumButtons(){
        for(int i = 0; i < 15; i++) { /**change 17 to length of array*/
            if(!numButton[i].equals("")){
                Button myButton = new Button(numButton[i]);
                addObject(myButton, xCoord1, yCoord1);
            }
            xCoord1 += buttonSpacingXVal;
            if((i+1)%4 == 0){
                xCoord1 = xCoordStart;
                yCoord1 = (yCoordStart - buttonSpacingYVal) - buttonSpacingYVal * ((i-3)/4);
            }
        }
    }

    public void makeOpButtons(){
        for(int i = 0; i < 16; i++) { /**change 17 to length of array*/
            if(!operationButton[i].equals("")){
                Button myButton = new Button(operationButton[i]);
                addObject(myButton, xCoord2, yCoord2);
            }
            xCoord2 += buttonSpacingXVal;
            if((i+1)%4 == 0){
                xCoord2 = xCoordStart;
                yCoord2 = (yCoordStart - buttonSpacingYVal) - buttonSpacingYVal * ((i-3)/4);
            }
        }
    }
    
    public void makeAdvOpButtons(){ /**change 17 to length of array*/
        for(int i = 0; i < 28; i++) {
            if(!advOperationButton[i].equals("")){
                Button myButton = new Button(advOperationButton[i], advOperationButtonName[i]);
                addObject(myButton, xCoord3, yCoord3);
            }
            xCoord3 += buttonSpacingXVal;
            if((i+1)%4 == 0){
                xCoord3 = xCoordStart;
                yCoord3 = (yCoordStart - buttonSpacingYVal) - buttonSpacingYVal * ((i-3)/4);
            }
        }
        
        //Clear and Delete buttons
        Button clear = new Button("Clear", " AC");
        addObject(clear, xCoordStart + (buttonSpacingXVal * 3), yCoordStart - (buttonSpacingYVal * 8));
        Button delete = new Button("Delete", "Del");
        addObject(delete, xCoordStart + (buttonSpacingXVal * 5 / 2), yCoordStart - (buttonSpacingYVal * 7));
    }
    
    public void makeActionButtons(){
        StoreButton store = new StoreButton();
        ModeButton mode = new ModeButton();
        AlphaButton alpha = new AlphaButton();
        addObject(store, xCoordStart, yCoordStart - (buttonSpacingYVal * 5));
        addObject(mode, xCoordStart, yCoordStart - (buttonSpacingYVal * 8));
        addObject(alpha, xCoordStart + (buttonSpacingXVal/2), yCoordStart - (buttonSpacingYVal * 7));
    }
    
    public void makeArrowButtons(){ /**change 17 to length of array*/
        //make the area that the buttons will occupy
        Arrows arrowCircle = new Arrows();
        addObject(arrowCircle, (getWidth() / 2 + 5), (getHeight() / 2 - 60));
        
        DownArrow down = new DownArrow();
        addObject(down, (getWidth() / 2 + 5), (getHeight() / 2 - 27));
        
        UpArrow up = new UpArrow();
        addObject(up, (getWidth() / 2 + 5), (getHeight() / 2 - 97));
        
        LeftArrow left = new LeftArrow();
        addObject(left, (getWidth() / 2 - 30), (getHeight() / 2 - 62));
        
        RightArrow right = new RightArrow();
        addObject(right, (getWidth() / 2 + 39), (getHeight() / 2 - 62));
    }
    
    public void prepare(){
        CheckKeyPress keypress = new CheckKeyPress();
        addObject(keypress, 0, 0);
    }
    
    public void updateDisplay(){
        String displayCalculation = myCalculator.getCurrentCalculation();
        String cursor = ":";
        int index = myCalculator.getCurrentIndex();
        if (!displayCalculation.equals("")){
            displayCalculation = myCalculator.insert(displayCalculation, index, cursor);
        }
        else{
            displayCalculation = "0";
        }
        showText(displayCalculation, xCoord4, yCoord4);
    }
    
    public void createFiles(){
        //Source code: https://www.w3schools.com/java/java_files_create.asp
        try {
            File varFile = new File("Variables.txt");
            if (varFile.createNewFile()) {
                System.out.println("File created: " + varFile.getName());
            }
            else {
                System.out.println("Variables file already exists.");
            }
            File constantFile = new File("Constants.txt");
            if (varFile.createNewFile()) {
                System.out.println("File created: " + constantFile.getName());
            }
            else {
                System.out.println("Constants file already exists.");
            }
        }
        catch (IOException exception) {
            System.out.println("An error occurred.");
            exception.printStackTrace();
        }
    }
    
    public void act()
    {
        /**currentNum = myCalculator.currentNum();
        if(currentNum.equals("num1")){
            text = myCalculator.getNumber();
        }
        if(currentNum.equals("num2")){
            text = myCalculator.getNumber();
        }
        if(currentNum.equals("operator")){
            text = myCalculator.getOperator();
        }
        if(currentNum.equals("final")){
            text = myCalculator.getAnswer();
        }
        showText(text, xCoord4, yCoord4);*/
    }
    
    public void stopped(){ /**I wrote this, but is it necessary? maybe*/
        myCalculator.add("Clear");
        updateDisplay();
    }
}

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.util.ArrayList;

/**
 * Write a description of class solutionSteps here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class SolutionSteps extends Actor
{
    private static ArrayList<String> solutionSteps = new ArrayList<String>();
    private static String initial;
    private static String returnSolSteps;
    private static String foundSteps;
    /**
     * Act - do whatever the solutionSteps wants to do. This method is called whenever
     * the 'Act' or 'Run' button gets pressed in the environment.
     */
    public void act() 
    {
        // Add your action code here.
    }    
    
    public static String getSolSteps(String initialInput){
        returnSolSteps = "An error occurred. Failed to read solution steps.";
        foundSteps = "";
        for (String steps : solutionSteps){
            initial = steps.substring(0, steps.indexOf("?/c/?"));
            if (initial.equals(initialInput)){
                foundSteps = steps;
                break;
            }
        } 
        if (! foundSteps.equals("")){
            returnSolSteps = foundSteps.substring(0, foundSteps.indexOf("?/c/?"));
            foundSteps = foundSteps.substring(foundSteps.indexOf("?/c/?") + 5);
            while (foundSteps.contains("?/c/?")){
                returnSolSteps = returnSolSteps + ", ";
                returnSolSteps = returnSolSteps + foundSteps.substring(0, foundSteps.indexOf("?/c/?"));
                foundSteps = foundSteps.substring(foundSteps.indexOf("?/c/?") + 5);
            }
            returnSolSteps = returnSolSteps + ", ";
            returnSolSteps = returnSolSteps + foundSteps.substring(0, foundSteps.indexOf("?/a/?"));
            foundSteps = foundSteps.substring(foundSteps.indexOf("?/a/?") + 5);
            returnSolSteps = returnSolSteps + " =";
            returnSolSteps = returnSolSteps + foundSteps.substring(0, foundSteps.indexOf("?/n/?"));
        }
        return returnSolSteps;
    }
    
    public static void setSolSteps(String stepsAndAns){
        solutionSteps.add(stepsAndAns); //Format: "[step]?/c/?[step]?/c/?[etc.]?/a/?[answer]?/n/?"
    }
    public static void clearSolSteps(){
        solutionSteps.clear();
    }
}

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.util.HashMap;
import java.io.File;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.FileNotFoundException;  // Import this class to handle errors
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * Write a description of class Variable here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */ 
public class Variable extends Actor
{
    private static HashMap<String, String> variableDictionary = new HashMap<String, String>();
    private static String writeString = "";
    private static String readString = "";
    private static FileReader fr;
    private static BufferedReader br;
    private static FileWriter fw;
    private static String pronumeral;
    private static String value;
    private static int indexA;
    private static int indexB;
    
    public Variable(){
        try{
            this.fr = new FileReader("Variables.txt");
            this.br = new BufferedReader(fr); 
            //https://www.quora.com/How-do-I-clear-a-file-in-Java-before-writing-to-it-again
            this.fw = new FileWriter("Variables.txt",false); //False means the file is OVERWRITTEN
            System.out.println("Variables file reader/writer successfully initialised.");
        }
        catch (IOException exception) {
            System.out.println("Variables file reader/writer failed to initialise.");
            exception.printStackTrace();
        }
    }
    
    /**
     * Act - do whatever the Variable wants to do. This method is called whenever
     * the 'Act' or 'Run' button gets pressed in the environment.
     */
    public void act() 
    {
        // Add your action code here.
    }    
    
    public static void setVariable(String var, String val){
        if (variableDictionary.get(var) != null){
            System.out.println("Variable " + var + " overwritten.");
        }
        variableDictionary.put(var, val);
        writeVariables(variableDictionary);
    }
    public static HashMap<String, String> readVariables(){
        variableDictionary.clear();
        try {
            readString = new String(Files.readAllBytes(Paths.get("Variables.txt")));
        }
        catch (FileNotFoundException e) {
            System.out.println("Failed to read Variables.txt file; File not found.");
            e.printStackTrace();
        }
        catch(IOException e){
            System.out.println("Failed to read Variables.txt file.");
            e.printStackTrace();
        }
        catch(OutOfMemoryError e){
            System.out.println("Failed to read Variables.txt file.");
            System.out.println("Ran out of memory while reading Variables.txt file.");
            e.printStackTrace();
        }
        while (!readString.equals("")){
            if (readString.length() < 6 || !readString.contains("?/n/?")){
                readString = "";
                break;
            }
            indexA = readString.indexOf("?/p/?") + 5;
            indexB = readString.indexOf("?/v/?");
            pronumeral = readString.substring(indexA, indexB);
            indexA = readString.indexOf("?/v/?") + 5;
            indexB = readString.indexOf("?/n/?");
            value = readString.substring(indexA, indexB);
            readString = readString.substring(indexB + 5);
            variableDictionary.put(pronumeral, value);
        }
        return variableDictionary;
    }
    public static void writeVariables(HashMap<String, String> hashmap){
        try{
            writeString = "";
            for (String key : hashmap.keySet()){ //keySet means array of values of the keys
                writeString = writeString + "?/p/?" + key + "?/v/?";
                writeString = writeString + hashmap.get(key) + "?/n/?";
            }
            fw.write(writeString);
            fw.close();
        }
        catch(IOException e) {
            System.out.println("Failed to write to Variables.txt file.");
            e.printStackTrace();
        }
    }
}

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.util.HashMap;
import java.io.File;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.FileNotFoundException;  // Import this class to handle errors
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * Write a description of class Constant here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Constant extends Actor
{
    private static HashMap<String, String> constantDictionary = new HashMap<String, String>();
    private static String writeString = "";
    private static String readString = "";
    private static FileReader fr;
    private static BufferedReader br;
    private static FileWriter fw;
    private static FileWriter fc;
    private static String pronumeral;
    private static String value;
    private static int indexA;
    private static int indexB;
    private static String clearConstants;
    
    public Constant(){
        try{
            this.fr = new FileReader("Constants.txt");
            this.br = new BufferedReader(fr); 
            //https://www.quora.com/How-do-I-clear-a-file-in-Java-before-writing-to-it-again
            this.fw = new FileWriter("Constants.txt",true); //True means the file is appended to
            this.fc = new FileWriter("Constants.txt",false);
            System.out.println("Constants file reader/writer successfully initialised.");
        }
        catch (IOException exception) {
            System.out.println("Constants file reader/writer failed to initialise.");
            exception.printStackTrace();
        }
    }
    
    /**
     * Act - do whatever the Constant wants to do. This method is called whenever
     * the 'Act' or 'Run' button gets pressed in the environment.
     */
    public void act() 
    {
        // Add your action code here.
    }    
    
    public static void setConstant(String cons, String val){
        if (cons.equals("Clear")){
            constantDictionary.clear();
            writeConstants();
            return;
        }
        else if (constantDictionary.get(cons) != null){
            System.out.println("Constant " + cons + " already exists.");
            clear();
            return;
        }
        else{
            constantDictionary.put(cons, val);
            writeConstants(cons, val);
        }
    }
    private static void clear(){
        clearConstants = Greenfoot.ask("Clear constants? (y/n)");
        switch (clearConstants){
            case "y":
                System.out.println("Clearing constants file...");
                setConstant("Clear", "0");
            case "n":
                System.out.println("Constants file was not cleared (selected \"no\")");
                return;
            default:
                System.out.println("Invalid input.");
                clear();
                return;
        }
    }
    public static HashMap<String, String> readConstants(){
        constantDictionary.clear();
        try {
            readString = new String(Files.readAllBytes(Paths.get("Constants.txt")));
        }
        catch (FileNotFoundException e) {
            System.out.println("Failed to read Constants.txt file; File not found.");
            e.printStackTrace();
        }
        catch(IOException e){
            System.out.println("Failed to read Constants.txt file.");
            e.printStackTrace();
        }
        catch(OutOfMemoryError e){
            System.out.println("Failed to read Constants.txt file.");
            System.out.println("Ran out of memory while reading Constants.txt file.");
            e.printStackTrace();
        }
        while (!readString.equals("")){
            if (readString.length() < 6 || !readString.contains("?/n/?")){
                readString = "";
                break;
            }
            indexA = readString.indexOf("?/p/?") + 5;
            indexB = readString.indexOf("?/v/?");
            pronumeral = readString.substring(indexA, indexB);
            indexA = readString.indexOf("?/v/?") + 5;
            indexB = readString.indexOf("?/n/?");
            value = readString.substring(indexA, indexB);
            readString = readString.substring(indexB + 5);
            constantDictionary.put(pronumeral, value);
        }
        return constantDictionary;
    }
    public static void writeConstants(String cons, String val){
        try{
            writeString = "?/p/?" + cons + "?/v/?" + val + "?/n/?";
            fw.write(writeString);
            fw.close();
        }
        catch(IOException e) {
            System.out.println("Failed to write to Constants.txt file.");
            e.printStackTrace();
        }
    }
    public static void writeConstants(){
        try{
            fc.write("");
            fc.close();
        }
        catch(IOException e) {
            System.out.println("Failed to clear Constants.txt file.");
            e.printStackTrace();
        }
    }
}

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.util.HashMap;
import java.io.File;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.FileNotFoundException;  // Import this class to handle errors
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * Write a description of class Calculations here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Calculations extends Actor
{
    private static HashMap<String, String> calcHisDictionary = new HashMap<String, String>();
    private static String writeString = "";
    private static String readString = "";
    private static FileReader fr;
    private static BufferedReader br;
    private static FileWriter fw;
    private static FileWriter fc;
    private static String calculation;
    private static String answer;
    private static int indexA;
    private static int indexB;
    private static String clearHistory;
    SolutionSteps SS = new SolutionSteps();
    
    public Calculations(){
        try{
            this.fr = new FileReader("CalcHistory.txt");
            this.br = new BufferedReader(fr); 
            //https://www.quora.com/How-do-I-clear-a-file-in-Java-before-writing-to-it-again
            this.fw = new FileWriter("CalcHistory.txt",true); //False means the file is OVERWRITTEN
            this.fc = new FileWriter("CalcHistory.txt",false);
        }
        catch (IOException exception) {
            System.out.println("Calculation History file reader/writer failed to initialise.");
            exception.printStackTrace();
        }
    }
    
    /**
     * Act - do whatever the Calculations wants to do. This method is called whenever
     * the 'Act' or 'Run' button gets pressed in the environment.
     */
    public void act() 
    {
        // Add your action code here.
    }    
    
    
    public static HashMap<String, String> readCalcHistory(){
        calcHisDictionary.clear();
        try {
            readString = new String(Files.readAllBytes(Paths.get("CalcHistory.txt")));
        }
        catch (FileNotFoundException e) {
            System.out.println("Failed to read CalcHistory.txt file; File not found.");
            e.printStackTrace();
        }
        catch(IOException e){
            System.out.println("Failed to read CalcHistory.txt file.");
            e.printStackTrace();
        }
        catch(OutOfMemoryError e){
            System.out.println("Failed to read CalcHistory.txt file.");
            System.out.println("Ran out of memory while reading CalcHistory.txt file.");
            e.printStackTrace();
        }
        while (!readString.equals("")){
            if (readString.length() < 6 || !readString.contains("?/n/?")){
                readString = "";
                break;
            }
            indexA = readString.indexOf("?/c/?") + 5;
            indexB = readString.indexOf("?/a/?");
            calculation = readString.substring(indexA, indexB);
            indexA = readString.indexOf("?/a/?") + 5;
            indexB = readString.indexOf("?/n/?");
            answer = readString.substring(indexA, indexB);
            readString = readString.substring(indexB + 5);
            calcHisDictionary.put(calculation, answer);
        }
        return calcHisDictionary;
    }
    private static void clear(){
        clearHistory = Greenfoot.ask("Clear history? (y/n)");
        switch (clearHistory){
            case "y":
                System.out.println("Clearing constants file...");
                writeCalcHistory();
            case "n":
                System.out.println("Constants file was not cleared (selected \"no\")");
                return;
            default:
                System.out.println("Invalid input.");
                clear();
                return;
        }
    }
    public static void writeCalcHistory(String initialCalc, String ans){
        calcHisDictionary.put(initialCalc, ans);
        try{
            writeString = "?/c/?" + initialCalc + "?/a/?" + ans + "?/n/?";
            fw.write(writeString);
            fw.close();
        }
        catch(IOException e) {
            System.out.println("Failed to write to CalcHistory.txt file.");
            e.printStackTrace();
        }
    }
    public static void writeCalcHistory(){
        try{
            fc.write("");
            fc.close();
        }
        catch(IOException e) {
            System.out.println("Failed to clear CalcHistory.txt file.");
            e.printStackTrace();
        }
    }
}

Calculator world = ((Calculator)getWorld());

if(getWorld() instanceof Calculator){
    Calculator world = ((Calculator)getWorld());
}

myCalculator.world = this;

this("0");

for (Object obj : getWorld().getObjects(Button.class)) ((Button)obj).changeButtonImage();

finalCalculation.replaceAll("(\\D*+)(\\d++)(\\D*+)","$1"+"["+"$2"+"]"+"$3");