What happens if you do a delay for keys that already support multiple presses?

It doesn't matter what key you use, since you're reading the key directly instead of using GetCSC.

If you want an example of this code in action, read the source for Eitrix.

Hey guys! Version 0.6 is out! Here's what's new!
Version 0.6:
- Antidotes!
   - 25% of all Special Blocks (more in single player) will be empowered with Antidotes.
   - Clear the block to add 1 Antidote to your total.
   - Antidotes are kept in a stockpile of up to 65535 antidotes.
   - Use an Antidote by pressing MODE
   - When you use an Antidote, all attacks you are currently recieving will be deactivated,
     and any future attacks you recieve over the next few seconds will be negated.
- Diseases!
   - These attacks last perpetually and do not affect the grid directly
   - Clear them away with Antidotes.
   - Specials Added: No More Hints, Static Background, Zee Virus, and Blindness
- Removed Interrupts once and for all! Now it works in both MOS and DCS!
- Changed the Slow Down symbol to a turtle (courtesy of stiny.net)
- Hit CLEAR from the main menu to quickly quit the game
- Several other bug fixes

This will probably be my last Work in Progress release before I publish the 1.0 beta, since there is so little that has to be done now. Just more specials, and seeing your opponent's grid height.

I would have on request. A replacement/alternative for NoteFolio, with PC support. NoteFolio is pretty good but I would like to see smoother scrolling and a smaller font, maybe zoom levels? .txt support would be nice too and imagine what you could do if you could make like these "chapters" so that if you open the file you can jump to one chapter or another, that would be truly great. It is not even that impossible....

To an extent, that is Document DE 7 for Doors CS. That program could use some improvement as well, but it appears that the files that Document creates are the same format as the ones Notefolio creates.

I don't think I understand the purpose of OOP. Why would you use data abstraction and encapsulation for something like, to use your example, updating ships? Since you're presumably only manipulating a single ship at a time, wouldn't it be more logical to maintain an array of data about all ships. The data about that ship could be loaded into the variables you're manipulating and then reloaded into the array when you're done. It could actually work out very easily if you use "pointers" to the data in the array and a simple subroutine to manipulate the pointers and simultaneously updating the data in the array. It seems like encapsulating the ship data just pushes the mechanics of the program onto the interpreter/compiler. That certainly makes things easier to manage, but computers also have a tendency to write less efficient code than humans.

Also, I genuinely don't understand why you would want local variables. Doesn't that make things confusing when the variable "ShipSpeed" is used differently by three different subroutines? Plus, the OS/program has to maintain a table of all of the local variables, look them up, retrieve them from memory, and swap the appropriate ones in when necessary. That's not a lot of overhead, but it might not be suitable for high speed applications. It would also appear to be less memory efficient than maintaining global variables and being careful not to modify them.

PS: Your "Calcnet" example seems to be similar to calling another program or subroutine.

First, as my example shows, if you don't use OOP programming, you would simply keep a multidimensional array of all of the properties of each of the ships. Now, if you have already defined what you want the ship to do, that's fine. But what if you want to add a property to the ship? You would have to change all of your array offsets to fit the new ship! However, if you instead kept an array of Ships, then adding a property isn't a problem.

Private variables are another important thing. For the Ship class, we don't really need any local variables. A better example of where you would need private variables is in a networking class. You don't want to have to tell the program to connect to such and such a port or use such and such a timeout. But the network class needs to know about these things. So, when you write the networking class, all of the little details are hidden from you, so all you have to worry about is doing things with the network. Private variables also prevent you from making foolish mistakes, like modifying variables you shouldn't be.

Also, what classes help us do is make code more portable and mobile. In non-OOP, a lot of pieces of code are interweaved and hard to seperate when you want to use them somewhere else. If you use OOP right, you can take that class into another application and use it again. For example, you might have a method that draws all of the game objects to the screen. However, if you are developing for multiple problems, you might want multiple "DrawTool" classes that respond to different protocols (e.g. one that draws on an 89, one that draws on an old PC, and one that draws on an XBox).

He can choose whatever he wants to name his program. I think that Scout wanted it to be uPong instead of UPong because the former is easier to type.

I'm glad you like my explanation. What I wrote up there is just the surface of OOP. There are a lot of other cool topics you can learn about, such as:

• Properties (set conditions on access to variables)
• Inheritance and polymorphism (make one class act like another class)
• Types and type casting (convert one variable type to another)
• Namespaces and libraries (subassemblies)
• Reference and value types
• Interfaces

Just let me know what you would like to know about, and I'll write a short explanation.

I had a cool idea for a game that I want to do for computer, but not necessarily for calculator. Basically, you enter a dungeon with a lit torch and the object is to get to the other side of the maze. The main novel idea of the game is that a flame and a monster cancel each other out (the flame goes out as the monster dies). However, more torches line the wall, and you can light them to provide yourself with backup flame. Additionally, flames and monsters can be enhanced: a flame of a higher level does not go out when hitting a lower level monster, and vice versa. There could also be other cool ideas, such as annoying moths, trolls that bust through walls, wind chambers that snuff your flame out, dragons that breathe fire at you (which can light your torches if it doesn't incinerate you first) and stuff like that.

EDIT:

I would like a search engine hook or something like on Casio calcs, because it can be helpful for that. Go up/down would be good too for large programs. Casio had this on their calc for over 15 years now. Maybe a future program editor, hook or Doors CS7 addition?

The best solution would be a new program editor entirely. Another feature I'd like in such a revamped program editor is an Intellisense list (when you type in a function, it will show you the syntax under your cursor). Find/replace would also be nice.