G'day....

Well, I'm back, and I think the project has made some significant forward progress. To be honest I wish I spent more time trying to learn to programme before attempting something complicated like this project. I mean, it isn't really complicated relative to people that know what they are doing but it is a far cry from the questions in the book asking things of me like : "Write a program then prints out a Christmas tree of stars using for loops". I was just so keen to jump in and do something fun!

I feel like the project has taught me a lot but I am unconvinced about the efficiency of this method of learning by "jumping in the deep end". The problem is that I am really not pushing my understanding of the larger things. As I am trying to produce actual results, I am simply working in the framework of my current understanding. For example, I haven't made any progress in learning INHERITANCE,  POLYMORPHISM, VIRTUAL METHODS and ABSTRACT CLASSES. Even though I am sure that some of these are how I should have done things. Also my understanding of the Stack and Heap and all that is still spotty at best!

So I feel I am not actually learning at the same pace as when I started. What I am getting though is an understanding of how the stuff I know can be used. Over this learning project, I have done some pretty radical re-writes. Each time the code has been drastically simplified.

For example, a snippet from my last push to GitHub. This old code reads data from a file into my area class......

        private void ProcessData()
        {
            area.SetName(ReadDataFile.Read_RawSingleLine(areaKeys.areaName, fileData));
            area.SetLook_Description(ReadDataFile.Read_RawSingleLine(areaKeys.areaLook_Description, fileData));
            area.SetCinimatic(ReadDataFile.BetweenUniqueBrackets(areaKeys.areaCinamatic_Start, areaKeys.areaCinamatic_End));
            ProcessAllItems();
            ProcessAllExits();
        }
        private void ProcessAllItems()
        {
            BracketCounts brackets = new BracketCounts();
            brackets = ReadDataFile.Read_BracketCount(areaKeys.itemsStart, areaKeys.itemsEnd, fileData);
            for (int i = brackets.start[0] + 1; i < brackets.end[0]; i++)
            {
                DataRead_Items BuildItem = new DataRead_Items(fileData[i]);
                area.AddItem(BuildItem.GetItem());
            }
        }

        private void ProcessAllExits()
        {
            BracketCounts brackets = new BracketCounts();
            brackets = ReadDataFile.Read_BracketCount(areaKeys.exitStart, areaKeys.exitEnd, fileData);

            int exitAmount = brackets.bracketCount;
            List<int> bracketIndex_Start = brackets.start as List<int>;
            List<int> bracketIndex_End = brackets.end as List<int>;

            for (int i = 0; i < exitAmount; i++)
            {
                DataRead_Exits BuildExits = new DataRead_Exits();
                area.AddExit(BuildExits.ProcessExits(bracketIndex_Start[i], bracketIndex_End[i], fileData));
            }
}

By splitting my readData functions into separate and specific things, I have cut down what each individual file actually does. This makes it super easy to read, and also easy to find stuff as I do not need to dig through a gigantic and generic readAreaClass that may even have duplicate functions, with say readItemData, or whatever. I have split it all out and focused each class to take in and output small packets of data in what are effectively single functions. I mean a single class might have multiple methods in it, but the basically takes in something manipulates it so it outputs what I want and does nothing else but that. (for the most part) so I can reduce the code in a way that allows me to simply "read" it in a very clear way... and if I need to know HOW it works I can go deeper, by just following the program flow.

The new code below does the exact same thing as the snippet above, but all the considribaly cleaned up "guts" are now behind vey neat and simple in/out class functions. So when reading the above code it is a mess, but reading below is super easy, even if you do not have any idea what is going on....

            area.areaName = readLine.Get(KeyName, fileData);
            area.areaLook = readLine.Get(KeyLook, fileData);
            area.cinimatic = readCinematic.Get(CinimaStart, CinimaEnd, fileData);
            area.itemsList = readItems.Get(ItemStart, ItemEnd, fileData);
            area.exitsList = readExits.Get(ExitStart, ExitEnd, fileData);

So you re-wrote it AGAIN.... Any actual progress?

Yes actually. I have completely implemented the dynamic keyword generation system. My biggest fear with this project right now is that I never did a proper proof of concept to skeleton or whatever it is called. I basically have no idea if this keyword system I am doing is going to work as I envisioned it. I should have experimented with a simple project and some hardwired word lists and determined exactly how and if it all works.

As I haven't done this, I am just trusting to the original plan.

A big part of that was to simplify the commandphraser by limiting what it is actually looking for. If I give the app a series of keywords and key actions I only need to code the app to understand THOSE things. Say I have a box in the scene (and only a box) Any command phrase that the payer enters which does not contain the word Box can be ignored or throw and error or something.

As the player moves around, the app looks at the items in the room and is able to construct from my word list files dynamically. So words that are active in one room would be inactive in another.

Anyway, I am literally falling asleep as I type this! lol... can't be bothered checking.. bed now

Thanks for reading

--A4L