Differences

This shows you the differences between two versions of the page.

--- javascript_terminal_v3 [2023/11/29 03:58] – appledog
+++ javascript_terminal_v3 [2025/12/05 02:36] (current) – appledog
@@ Line 1: / Line 1: @@
 = JavaScript Terminal v3
-Based on the ideas I came up with trying to write a terminal emulator for NetWhack in different languages and environments I hit upon the idea of having the game itself start out as a terminal emulator, and then the game would rely on the terminal emulator side of the software, as if it were a game engine.
+When I began to write NetWhack, I decided that the game would start out as a terminal emulator, and then the game would rely on the terminal emulator side of the software as if it were a game engine. I liked this 'old school' environment because it was nostalgic for me. It is how I learned to code, way back in the day, so I thought it would be a fun little project to write a interface that would look like a Commodore or a PC or some kind of monochrome terminal.
-Further, to get around the problem of not having a way to do blocking string input, I hit upon the idea of using the terminal idea to simulate string input by marking where we began input and keeping track of which characters were being pressed; then, when the user hit ENTER, the string could be sent to a queue for processing (ex. SET_NAME <value>). In Javascript it looked like this:
+The main problem I encountered was that modern, event driven systems like Android, Javascript and iOS don't allow you to do blocking string input. Trying to do getkey() or input() is impossible. Eventually I found a way to simulate it within the environment of the terminal simulator by sending the line that the cursor was on to a "command processor", which would interpret the line like a command. This was close to a shell running on an OS, but there were no clear definitions of what was the OS, what was the shell, what was the hardware. Then I wrote an actual input() function that allowed me to prompt the user and set it to a keyword which could be evaluated by the game engine later:
 <Code:JavaScript>
@@ Line 8: / Line 8: @@
 </Code>
-However, I had never managed to solve the problem of context; I was able to simulate string input but it required that every time I accepted string input I would have to lose program context to allow the user to type the response, then pick up the event in a new context by calling a function to handle the SET_NAME queue command.
+When the user pressed ENTER, a console command "SET_NAME <value>" would be sent to the event queue (the game engine) for processing like a console command.
-Thus I began to be pulled towards creating a virtual machine. I realized that it didn't make sense to have a terminal mode and a run mode, so I merged them for v3. I started to write a sort of scripting language (using line numbers, like BASIC, to keep the oldschool feel). If I could save the value of the string input within the state machine of the scripting language's environment, and then within that scripting language process it, and even end up calling other javascript functions, then I would have what I needed to maintain context in my string input. I wouldn't be writing in JavaScript anymore, but I could make any language I want.
+I then began experimenting with a kind of in-terminal scripting, like BASIC. The concept was simple, I would see if the first part of the string sent to the command processor was a number. If it was, it sent it to an array indexed by that number. This became a program listing which I could "RUN" with an interpreter.
-== new control system
+This would finally solve the context problem; normally you cnanot store and use the value of the input locally ex. "a = input()", because JavaScript (as does LibGDX, PyGame, and many others) runs its game engine code on the UI thread. So every time I accepted string input I would have to lose program context, then respond to the SET_NAME event later on. This was simulated string input, but not simulated blocking string input.
-For v3 I moved away from using a 'gameState' variable. Now, the io processing is "always on" and we control the terminal echo, cursor, etc with variables and flags.
+== Tradeoffs
+This is really the best you can do. If you try and expand the scripting aspect you will eventually find yourself rewriting the entire game in the virtual scripting language. It might not be worth it, if you can break up your code just a little. With that in mind I set out to make V3 the best damn terminal simulator it could be, but with a structure that would allow someone to turn it into a state machine very easily, if desired.
+=== Refactoring gameState
+gameState was removed and flags were added to control the terminal. As a result, we can run the event queue continuously.
 For example, Terminal mode (when the terminal is reset):
@@ Line 20: / Line 25: @@
 * runmode off
+Now the question is over the queue. Do we use one monolithic atomic queue or try to use multiple queues?
-=== The Same Queue
+=== Monolithic Atomic Queue
-If all events are atomic they will eventually be on the same queue. Like a message queue. This has benefits. A running program would be the addition of a 'RUN' command to the atomic queue, or 'ISC' (instruction set cycle). This would pull an instruction, add it to the queue, and it would execute. IO commands on the same queue would be executed in-sequence alongside "CPU" or "PROGRAM" commands. The execution model for a 'RUN' could be that the instruction is pulled from memory, added to the queue, and then another RUN (or ISC) is added after it in sequence, causing a loop but also maintaining the control of the "main" command queue.
+If all events are atomic they are effectively on the same queue so a single queue for all events would be used. Like a message queue. This has a lot of benefits, primarily keeping things simple. The big downside is that there is a massive jump table required, but this can be partially solved by using keywords for various processing modes. such as an ISC command which pulls opcodes, an ENTER command which deals with the user pressing ENTER in terminal "shell" mode, a LINE command which causes program lines to be put into the program listing array, and so forth. These could be separate functions in separate files to keep things neat and tidy.
-The downside is that it will be very difficult to maintain a very large switch statement, a lot of IFs, or a jump table. Hopefully it can be refactored later.
 === Multiple Queues
-Say, a 'system' queue (i/o), an 'os' queue, a 'program' queue, a 'terminal' queue, a 'cpu' queue, and so forth. The problem with this is scheduling, Ideally you would have a priority queue for things like cpu register value changes. Or would you? If you enter a write command on a priority queue followed by a read on a nonpriority queue, its fine. But if you enter a priority read followed by a priority write there could be a problem. Ultimately it's a pipeline problem because we are in a single threaded environment; i.e. we cannot determine (at speed) whether or not one command is necessarily dependant on another. We do know however that if there are 100 commands on the execution stack that a value change must be inserted before the next command. This insinuates a priority queue for things that must be done in direct support of the current command. For example, setting a zero flag in the case where multiple instructions are in the queue. We cannot append it, if a subsequent command relies on the zero flag.
+Multiple queues won't work. If you need a value set it will be set by the host (in JavaScript). If you need to process an opcode as a subroutine of other opcodes (ex. ADD is a construct of other opcodes and runs on the CPU and not in JavaScript) you can just replace AND by inserting the replacement code directly. If you need to set a value immediately that can be inserted before the next command, too. Multiple queues will be a distraction and are unlikely to speed up emulation in a single threaded environment.
-The very idea of a program stored in memory is already a queue. We do not need to modify it while it is actually running. So we would only ever be running one command (ISC) at a time.
+Note that if we are in a multi-threaded environment we can always have the game engine running in an off-UI thread. Or the implementation can launch copies in their own threads vs, manual task and context swithching which you would need to simulate in an (ex. JavaScript) implementation. But it would be transparent to the code written for the virtual machine.
-The question is then what if we implement an opcode (for example) as a series of 'other' opcodes? In such a case there is a CPU state which must be modified immediately no matter what. Ultimately, the idea of a priority queue is inferior to the idea of a single threaded system supporting a monolithic atomic queue.
+== It's really an interpreter
+Like BASIC. The whole thing with INPUT and SET_NAME feels like you are writing your own programming language and interpreter. But on top of that, there's the actual BASIC interpreter which works exactly the same way:
+=== BASIC Interpreter
+<Code:BASIC>
+PRINT A
+GOTO 40
+PRINT B
+PRINT C
+PRINT D
+LIST
+RUN
+A
+C
+D
+</Code>
+Instead of refactoring into a state machine, I threw together a quick BASIC class which processed commands in a program[] array. It handles print, and goto. Since it is a quick design it can not handle infinite loops or very long programs, since there is no time for the game loop to process updates and render or for the UI to make those changes to canvas. Then I realized... refactor into a state machine? Did I even realize what I had just said?
+== It's really a CPU
+A monolithic atomic queue is kind of like a CPU. Since we don't have a ROM, we write high level commands in JavaScript. Slowly, we can implement opcodes and start working more with the state machine.
+This kind of blew my mind at the time so I took a lot of time off from the project thinking about it.
+== Aside
+==== Jump Table in JavaScript
+<Code:JavaScript>
+// Define functions
+function function1() {
+    console.log("Function 1");
+}
+function function2() {
+    console.log("Function 2");
+}
+function function3() {
+    console.log("Function 3");
+}
+// Create a jump table
+const jumpTable = {
+    "func1": function1,
+    "func2": function2,
+    "func3": function3
+};
+// Example of calling a function dynamically based on a string parameter
+function callFunctionByName(name) {
+    const selectedFunction = jumpTable[name];
+    if (selectedFunction && typeof selectedFunction === 'function') {
+        selectedFunction();
+    } else {
+        console.error("Function not found");
+    }
+}
+</Code>
-However, not all events are equal. A user typing 'HELP' should never reach the queue if we are in some kind of ISC or RUN mode and we did, for example, A = INPUT(). So we can turn off console mode during run and so forth.
+This example is how to support a large number of opcodes/commands quickly.
-This is a mid-way simulation, and it only points in one way.
+== Refactoring Needed
+V3 is V2 but with changes made in how terminal is controlled by the main program. The code has also become somewhat spaghetti. I partially addressed this by removing the Tile class from V3 and adding BASIC command processing into its own class. But much more work needs to be done on this. The BASIC class should maintain the copy of the program code, and the Terminal class might need to offload it's draw funcion to a Screen class. We might even move event checking into an OS or CPU class. Or both. But the OS class would eventually be replaced by programs running on the CPU (a ROM).
-=== It's really a CPU
+In a real VM, the code would not be stored in a program[] array but in memory[] and read from there by the interpreter. There are lots of little design clashes between the idea of a VM, the idea of a Game (NetWhack) and the idea of s hybrid scripting language written in Javascript. They are not really compatable. So for a V4 the goal will be to pare down and really isolate the functionality of Terminal, and to clean up main by making a class Screen, and also perhaps a class Keyboard, class Mouse, etc.
-Ultimately, all of this should be done in the instruction set we write for a cpu system. That is really the end goal. Maybe we should start with commands like HELP and just throw them onto the queue and slowly start to add basic instructions and then start writing a ROM and moving everything into the ROM. Yes, there will be a performance hit, but, it is an incremental thing, and there can actually be multiple instruction sets available at the same time. Just because one instruction set is used does not mean the other doesn't work. This would allow us to program in assembly as easily as in BASIC on a C64 -- consider the beauty of 10 LDA #56 and mixing basic with assembly. It could work.
-== Program Simulator
+== Final Thoughts
-main.js is getting too big and it might make sense to start refactoring things a little. But starting out with a full CPU simulator is too big. To demonstrate the principle of how the new system works, a small BASIC interpreter is most likely what is called for. Also, we will continue to use a monolithic atomic queue for everything, although, as the ROM is written this will begin to be just a CPU simulator. For now, it takes the role of program simulator or program support. The game/program will be written in Javascript, but the system will be controlled by queue commands.
+Today's computers are many millions of times faster than (ex. a C64). Even a C65 running at 3.5mhz can 'software' simulate a C64. People have written Sega Master System (Z80) system simulators on 386 quality systems. The point is that today's processors are in many cases over a million times faster than a C64 or 8086 style processor and are overkill for this. Therefore if we move in the direction of a full cpu and system simulator the main problem will not be processing speed, but writing the software. We don't have a ROM/BIOS and we don't have an OS, and those two are both rabbitholes greater than or equal to a 'JavaScript NetWhack'. It's just a little too big to deal with before we write the game.
-== Will it work?
+As it stands, V3 is a sort of kludge, filled with stop-gaps. I will need time to think over everything I have learned, and one day, approach V4 from a different direction.
-Today's computers are many millions of times faster than a C64, but even a C64 (6502 processor) can run Linux. Even an 8086 can run Minix. Yeah, I never tried it, but the point is that today's processors are over 100,000 times faster than a 486 and that's ignoring more efficient instructions, more efficient instructions per cycle, and multithreading. Even if I just wrote a whole new VM from scratch it would run fast enough for any kind of yesteryear game. I mean, look at modern emulators. You can do dreamcast at 60fps on anything these days.
-An 80486 had five pipelines and ran at 100mhz. Today's computers could easily simulate a handful of those. We are far beyond the technical specifications for this kind of virtual system by more than an order of magnitude. A JavaScript implementation of this would be expected to run on anything (even a phone) quite easily. It might even work on an early 2020's Apple Watch.
+(--Me, in 2022).
-== Existing Projects
-I don't think anything like this really exists. Web assembly looks like it was designed to be a failure. It can't fork(), it can't getkey(), and it can't access the DOM. They dropped the ball -- if you're going to have a programming language in the browser, then make it a real programming language. All of the artificial restrictions and poor design choices need to be fixed.