DOS/4GW Port of FTE

March 31, 2019 dos code

A long time back, hidden away in a much larger post, I indicated that I wanted to port the FTE text editor to build against the Watcom toolchain so that it ran under DOS/4GW instead of CWSDPMI which the current (old) DOS build built with DJGPP uses. The reasons for this are that FTE includes menu options for running external tools (such as compilers, debuggers, etc) but because it runs under CWSDPMI, if you try to run most things that use DOS/4GW, they will crash. Different DOS extenders shouldn't be mixed.

I finally did this today. Hooray! Well, I'm probably the only person out there who cares about this, but still, hooray!

I've uploaded the changes to a Github project which includes a binary release for anyone else who may be interested in such a thing.

In addition to being build with the Watcom toolchain, I also took the opportunity to fix the broken / un-implemented DOS support for different sized screen text modes, such as 80x50 which I consider mandatory for a text editor under DOS these days. The non-platform-specific bits of code was already set up to work with a variety of different screen sizes. However, the DOS-specific bits that existed in the project (which was intended for DJGPP) did not include support for different DOS text modes via interrupt 10h. A rather curious omission since there was a non-trivial amount of other DOS VGA work that had to be done in the code to get it running under DOS in the first place by whoever did the DJGPP port way back when. Perhaps that person only used 80x25 and decided to just leave it at that. I suppose I'll never know. Meh.

Tools Development and The Need For GUI Code

December 24, 2018 dos code

As some of the "foundational" pieces of code have been coming together, I've realized that I need to get some tools created to assist me in content creation. This would be for things from asset conversion to tilemap editors.

Asset conversion tools (e.g. going from BMP/PCX to a game-engine specific format optimized for faster loading) can really just be command-line driven which makes it simple enough to create. For more involved things such as a tilemap editor, this requires some GUI code.

I made a few tools in straight DOS using QBasic back in 1998/1999 or so with my own homebrew GUI code that was pretty terrible as I recall. But it was my very first experience writing such code (and only a few years after I first learned to program), so perhaps I should not be too hard on myself. I actually want to add a "projects" section to this website in the near future where I can post that old code just for fun, but currently I don't have it in a presentable format to share for this post.

Very soon after, I moved to Visual Basic (first v4, and then v6) and of course, that made writing such tools infinitely easier. I was actually pretty happy with the tilemap editor I wrote (from scratch entirely in a weekend):

For my current DOS projects, I once again need to revisit GUI code 20 years later. There are some libraries I could use of course, but I am going the "Do It Yourself" route (a.k.a. the "Not Invented Here Syndrome" route) for fun and for the (re-)learning experience. With that in mind, I decided I wanted to pursue an Immediate Mode GUI implementation. Probably the most well known implementation of this these days is the Dear ImGui library.

I began reading up on it in more detail, having not implemented such a system before in any project I'd worked on. This video in particular is a great introduction to it (and I believe, the original video on it) if you're not too familiar with why this method of implementing a GUI might be useful and where/when. As well, I found this tutorial series to be quite useful.

Eventually I did get something working myself:

It's far from perfect, but I'm happy with how it's coming along.

while not KeyState[KeyEsc] do begin
    event := PollEvents;
    if event <> nil then UIProcessEvent(event);


    if UIBeginMenu('File', 100) then begin
        UIMenuItem('Save As');
    if UIBeginMenu('Edit', 100) then begin
    if UIBeginMenu('Help', 100) then begin

    UIBeginWindow(50, 30, 250, 180, 'window!');

    if UIButton('button 1') then
        clicked := true;
    if UIButton('button 2') then

    UIVertScrollBar('', 20, 0, 2, value);
    UIHorizScrollBar('slider!', 0, 0, 200, value2);

    UICheckBox('checkbox', checked);
    UIListBox('list!', 0, 3, list, listScrollY, listSelection);

    if UIRadioButton('one', (radio = 1)) then radio := 1;
    if UIRadioButton('two', (radio = 2)) then radio := 2;
    if UIRadioButton('three', (radio = 3)) then radio := 3;




Some stuff doesn't work completely yet (such as the menus). As well, I'm missing two main widget types: textboxes and dropdown lists. Actually, I'm not expecting textbox widgets to be too difficult to implement. In fact, the input events system that I originally added to libDGL was originally added purely because I knew I was going to need such a thing to more easily implement such a textbox widget in the future!

However, I am relatively happy that things like automatic layout/positioning mostly works well, as well as automatic widget ID generation. Well, except that, as you can see above, there is an escape hatch for this in the form of UISetNextID that can be used when/if needed.

The idea with pretty much all of the widgets is that the widget function (e.g. UIButton, UICheckBox, etc) takes simple properties like a label string and maybe a couple other common style- or functionality-related properties as well as state variable(s) which are passed by pointer/reference to the widget. If the widget state changes, the variable(s) are updated immediately with the new state and the widget function will return a boolean to indicate that the state was changed. This boolean indicating that the "state was changed" is a bit context-dependant. For example, for a UIButton, it doesn't take in any explicit state variable itself (that is managed by the UI system in the form of widget IDs being tracked for what widget the mouse is currently hovering over, etc). But, the UIButton still returns true/false to indicate if it was clicked or not. For a UICheckBox which does require an explicit state variable to be passed to it, it returns true/false to indicate that that state variable was changed in response to a user action. This allows the application code to easily respond to the most common user interaction events for widgets with just simple if logic. Which is really, really nice actually! The previously linked video on immediate mode GUIs explains this idea really well and why it's nice for programs which do real-time rendering.

The key thing for me with this GUI code is that I do not want to create a totally generic UI framework. I only need to create something that will allow me to create some basic tools easily enough. Maybe eventually I'll want to add support for things like custom themes so that this could be used directly in an actual game project while matching the game's look and feel. Or, later on I might need more widget types. The list goes on, but I do not want to get lost in a never ending quest to get a "perfect" UI framework up and running, because well, it really would be a never ending quest and frankly, I don't need such a thing!

Right now I think I'm still going a bit too far with this by keeping support for things like tabbing between widgets. Will I actually use this feature in tools I create for myself? That remains to be seen (I suspect not, but you never know).

Some of the widgets leak implementation concerns a bit here and there which I'm not happy with. I've decided to just roll with it for now and hope that inspiration will kick in later and I'll be able to clean up these warts later on.

For example, the UIListBox widget requires two UI state variables to be provided to it. One of them, listSelection, is obviously needed (it holds the user's currently selection). The other one, listScrollY, holds the list's internal scrollbar scroll position and is kind of silly, but I didn't have any clever ideas for how to efficiently and automatically manage state of internal child widgets (the UIListBox widget internally uses a UIVertScrollBar widget).

Another example of this is in the menu code (which is mostly unimplemented as I write this). UIBeginMenu takes a second parameter which is the horizontal width of the menu to be created. This is kind of unfortunate, but I'm not exactly sure as of yet how to have this automatically figured out in a way that doesn't involve some kind of deferred rendering approach. I'm currently against the deferred rendering approach as I don't want to have to keep that kind of state around in memory somewhere... but it might be the best approach as it also solves another problem with my current approach which is that overlapping sub-menus would not render correctly. I might leave deferred rendering as a "v2.0" feature, heh.

Anyway, I'm hoping to have the UI stuff finalized in a workable state (even if it's not perfect) within the next week which will allow me to move onto creating tools for myself. Additionally, this UI code will need to be ported back to C so I can use it with libDGL eventually. I've been doing it with Turbo Pascal mainly for the reasons mentioned in my last post ... I find Turbo Pascal to be quite a bit faster for prototyping and experimentation.

Turbo Pascal

October 14, 2018 dos code

Turbo Pascal is one of those development tools from the late 80's / early 90's that I had heard of but never actually used or even seen. In fact, the Pascal programming language as a whole I can describe the same way as it pertains to myself. Until 2018.

I actually now greatly regret that my younger self in the mid 90's did not get a chance to use Turbo Pascal at that time. As I've written about before, I started out with QBasic and then moved on to C/C++, and then soon after went back to QuickBASIC 4.5 while adding assembly into the mix to do more performant graphics. The reason I ended up moving back to QuickBASIC from C/C++ was that I greatly preferred the easier/quicker edit-compile-run cycle and the simpler debugging environment (plus the inline help system in QBasic/QuickBASIC is really awesome too).

That last point is what really makes me, in 2018 looking at Turbo Pascal for the first time, think to myself: "Wow! This is what I really would've loved at that time!"

I've actually had this since early this year but only really dug into it over the summer. I originally got it after reading posts on some vintage/retro computing forums with a number of people praising Turbo Pascal as a great development tool mixing a great IDE, ease of use, inline help and advanced features (pointers, inline assembly, etc). I was intrigued and I figured that maybe it might be good to play with a bit, as I had been interested in getting into FreePascal and Lazarus a bit anyway (maybe, for various reasons which I could probably write a whole post about).

So what do I like about Turbo Pascal and why do I think my younger self would've really liked it as well? In no particular order:

  • Easy to learn language with (to me anyway) a kind of "BASIC-like" feel to it.
  • Really awesome modules/units system. This honestly feels like it was way ahead of anything else at the time. It makes code re-use between projects incredibly simple. Just copy the TPU file (compiled unit) around and reference it in your program under the uses directive to start using it. Really easy.
  • Pointers!
  • Inline assembly (though, 16-bit / 286 only). Huge deal for me, as I remember getting annoyed at debugging assembly issues in my QuickBASIC/assembly mixed language projects. The 16-bit only limitation can be worked around in a hacky way by directly writing hex opcodes into your inline assembly if needed. It amuses me that I've actually heard Turbo Pascal referred to as a "shell for assembly", referring to the fact that a lot of projects where speed really mattered would have large amounts of inline assembly everywhere. For me in 2018, if I ever work on a project that gets to that point, I'd likely just switch it over to C honestly.
  • Slightly more advanced type system than BASIC, but still quite simple. One thing I've noticed so far is that I do generally feel a bit safer writing Pascal code that uses pointers (for example) then I do with C, I think due mostly to the type system.
  • Very fast compiler! And your code is actually running compiled (even from the IDE) rather then being interpreted, as in the case of QBasic. So your code is going to be a fair bit faster then QBasic right away. One side-effect I've noticed as a result of the blazing fast compiler is that I'll often compile my code as I write it (even if I don't intend to run it quite yet) simply as a check for any syntax mistakes, etc.
  • Beginner-friendly IDE that is very fast and that allows you to immediately start writing code and running it (exactly like QBasic). Also includes debugging support that is roughly on par with QuickBASIC (but does have some extras, like inspecting register values while stepping through your inline assembly).
  • Syntax coloured highlighting in the IDE!
  • Inline help system with search and plenty of examples.
  • Run-time checks to help you debug code (which can all be turned off for additional performance).
  • The IDE runs itself under DPMI (optionally) so that your code (which always runs in real-mode) has access to all of the remaining 640k conventional memory. This is a massive improvement over QuickBASIC! I very vividly recall getting really frustrated with one of my late QuickBASIC projects which was becoming impossible to run from the IDE due to it always sucking up 200-300k of conventional memory.

I've often read from people who learnt to program as kids in the 90's that they progressed from BASIC to Pascal and then to C/C++. I can kind of see now why that progression makes sense. To me, Turbo Pascal really does feel like either a much more advanced QBasic, or a kind of C/C++ "on training wheels" (sort of).

Turbo Pascal 7 also includes some object-oriented programming features. Actually, this was introduced I think in Turbo Pascal 5 or so, but people seem to say that it wasn't until version 7 that Borland had ironed out most of the bugs. I don't see myself using any OOP features that much (if at all), for the same reasons I now stick to C. I just prefer the procedural approach.

The limitation of your code needing to run in DOS real-mode is unfortunate to me in 2018, but if anything this just enforces developing for DOS the way it really was done for most of it's life... with 640k conventional memory, heh. Of note, Borland Pascal 7 (from what I gather, is the "professional" version of Turbo Pascal) apparently did include some ability to have your code run under DPMI and also added some 32-bit / 386 assembly support. However, I've read enough bad things about Borland's DPMI support in general that I'm not particularly interested in trying it out for myself.

For my current "retro" programming projects, I don't see myself using Turbo Pascal to tackle some of my more ambitious ideas (such as the Doom-style engine I still want to try doing), but for simple 2D graphics stuff I actually think this will be an interesting alternative to C.

The quicker edit-compile-run cycle is definitely handy. It makes prototyping or otherwise just quickly experimenting with ideas much easier. On my 486, it feels like instant compile times except maybe if I'm doing a full rebuild (which still completes in maybe two seconds). Contrast that to Watcom C where even for simple changes to a single source file, you're still waiting at least several seconds (if not longer). It makes a big difference over a day spent working on a project. I guess that is why many people who do retro programming today tend to use DOSbox or something else on their modern computers. I still refuse to go down this road though, preferring to stick with completely era-appropriate software and hardware!

"Old School" Magic: The Gathering

July 11, 2018 mtg

Over the past two years I've got back into collecting and playing Magic: The Gathering a little bit.

I was first introduced to the game by some friends in my fifth grade class in 1995 (actually, it was a grade five/six split class, I was in fifth grade though). I remember we used to actually sneak in games during class. I was really intrigued by all the cards and the artwork especially. Thinking back now, I recall that the majority of these cards were from the Fourth Edition, Chronicles and Ice Age sets, which all would have been current at that time. One card that I remember one of my friends had which sticks out the most in my mind that I thought was just the coolest creature card ever:

I mean, a 7/7 flying dragon that makes your opponent discard their entire hand when they take damage from him. Wow! I really wanted one! Of course, only years later did I realize that it was really a rather poor card from a playability perspective. 8 mana total casting cost with a 3 mana upkeep? Both of these costs comprised of 3 different colours? Yeah, no thanks! By the time you had enough mana out on the table available for use, the game would probably be almost over... if it even got that far.

But then again, thinking back to how I remember our games going at the time... a lot of them really did go on for a long time! I certainly don't remember anyone at the time having optimized decks. Everyone I knew who played was younger (11-12 years old) and it was their parents who were buying them cards. As a result, assuming you even had enough cards to build a deck (60 cards or more), you were playing with what you had. It might have even been with all that you had. Which probably meant you were playing with some really "janky" stuff. Maybe even (*shudder*) a four or five colour deck! So, the idea of playing something like Nicol Bolas in your deck at the time didn't really seem so crazy as it does to me now. And no, none of us had dual lands, and certainly not any of the power nine cards!

Regardless, even though I really wanted a Nicol Bolas card for myself, it wouldn't be until 23 years later that I got one, heh.

Getting a specific card wasn't even the first problem for me at that time. Getting any cards was the problem. I didn't have any money. Heck, I didn't even know where to go to buy Magic cards in the first place. I lived on a farm near a small town out in the "middle of no-where." There were no stores around that sold such things (so far as I knew). Darn! As luck would have it, later on during that school year, one of my other friends who had moved away the previous year (but who I still would occasionally go and visit, spending the weekend at his house) gave me his collection of Magic cards! I didn't even know he had any, but I showed up one weekend, and noticed he had a bunch in his room, carelessly strewn about. I asked about them and he replied "Do you want them?" I was absolutely thrilled. I think it ended up being a little over 100 or so cards all told. Again, they ended up being all from current (at the time) sets. A majority of Fourth Edition, and a smattering of Fallen Empires, Ice Age and Chronicles. A lot of the cards were in poor condition, clearly having been played many times over asphalt at school during recess or lunch before my friend ultimately got bored of the game. Finally, I could play with my own cards!

My younger brother was also interested in the game after he saw these cards and I remember we would play at home. I don't think we had quite enough cards to build a deck for each of us (I seem to recall we were somewhat short on lands) so what we ended up doing was sharing the same deck. We would play as normal, but both would draw our cards from the same deck. At first, we didn't have a rulebook so we were playing from my recollection of the rules that I learnt from my friends at school... and even that wasn't so perfect (plus I don't think we were 100% correct in following the rules during our games at school anyway). A few things I recall us doing incorrectly: we allowed attacking one (or more) of your opponents creatures directly, there was no distinction between sorceries, instants or interrupts (and I don't even think we ever played them during the opponents turn... not sure we understood that aspect of interrupts and instants), we allowed attacking with walls, regeneration could be played from cards long-since put into the graveyard. There's probably more I'm forgetting, but if you're familiar with the actual rules of the game, that should give you an idea of our games. Also, I do distinctly remember that, in an effort to not upset the other, we wouldn't attack at all until we had run out of cards in our shared deck. At which point it would turn into a real battle-royale! Early on for our games we did attacks early in the game (as soon as a creature was in play), but due to the hodge-podge of cards in our shared deck, games would often be very one-sided, especially early on and the early attacks ended up just upsetting whoever was taking a beating so we stopped doing that. Hey, we were both young after all!

The summer after school ended that year, I remember being in the mall with my Grandmother (during a visit to her place, there was no mall within an hour's drive of my house) and her buying me a Fourth Edition starter deck (60 cards!) and a couple booster packs of Alliances at some kiosk near the food court that sold Magic cards. My brother also got some cards at some point (if I recall correctly, a Mirage starter box later that year). Our games started taking better shape, which was good because I was also playing with friends at school less and less as time went on.

I ended up staying somewhat into Magic cards into 2001/2002 or so and kept collecting here and there (in particular, I remember getting quite a lot of Mercadian Masques in 1999 and early 2000). I was in high school at the time and in 2001 I remember I discovered one of the history teachers left his room open for students to come and hang out in during lunch. There was a group of -- well, I can only describe most of them in one way -- "comic book store"-type nerds who played Magic there during lunch. I hadn't played the game with anyone other then my brother in a few years at that point, so I was excited to play against some new opponents. I "endured" it for a while, but ultimately got put off playing the game by this group. Really, just a rude bunch of players that clearly weren't there to have fun but rather, seemed to have their fun by insulting people like me who were not playing with well optimized decks and had less overall experience playing the game. So, I put the game aside from a number of years.

After finishing college in 2007, I was contacted by my friend who had originally introduced me to the game in 1995 inviting me to come to a "draft" he was organizing. I hadn't played in quite a while and the game, as I discovered when I went to this draft, had changed quite a bit in the look and feel of it. The core rules were of course mostly the same, but the look had changed to what I always felt was a more generic or even "sterile" look and the artwork on the cards generally felt a lot less inspired and seemed to lack the character or "charm" that a lot of the original cards that I remembered had.

But more then that, after attending a few such drafts over the next year or two I began to realize that the sets now were largely designed with drafting in mind. There weren't really any of the fun, imbalanced, and/or just plain weird cards that you would see in the older sets. This never really felt that fun to me, it just added to the generic/sterile feeling I was getting about the game. At some point in 2008 or 2009 I declined going to further drafts just saying that I'd basically lost interest in the game.

Fast forward to 2016. I don't really remember what made me want to look up Magic again. Probably I was looking at the box in my closet that had all my old cards in it. But I started thinking about how I enjoyed the older cards much more and wouldn't it be cool if there was some group of people out there who played strictly with these older cards? After googling a bit, I discovered that, indeed, this was actually a thing! Not an official format mind you. But heck, that's probably a good thing anyway given my dislike of where the game has gone over the past 15-20 years.

Most people interested in this format stuck with cards from the original sets released in 1993/94 which was a bit before I started playing, but since Fourth Edition and Chronicles were comprised of all reprints of cards from the original sets, it was all the same cards to me anyway. Great!

Looking up some cards on eBay and such ... wow, Magic cards sure are expensive! Especially the older cards! However, I proceeded forward and ultimately, much of my disposable income in 2016 went into buying older Magic cards. Eventually, I was able to piece together quite a collection of cards that fit into the much more strict Swedish rules for "Old School 93/94" Magic, which is the ruleset that I had decided at the time that I was going to build for (mainly because I largely consider the much cheaper Revised edition cards to look somewhat ugly).

Currently, I am happy that I've been able to build three separate decks for this format:

They are most certainly not the best most optimized decks out there, and my ability to actually play the game is still rather limited due to not getting much experience at it, but even still, when I do get to play I enjoy it. This era of Magic was just a lot more fun to me and I attribute that (and only that) to my regaining interest in the game over the past two years.

Unfortunately for me, while there seems to have been a much bigger "Old School" Magic community here in Toronto years back (see here and here), it has diminished drastically since then. I currently know of only one other person in Toronto who plays and one other in Hamilton. I meet up with the person from Toronto every other month or so for some games and we have fun, but even still, it doesn't scratch my itch to play a bit more.

Thankfully this "lack of players" problem seems to be common, which you can imagine for what is a very niche (and especially now in 2018, prohibitively expensive) format of the game. So people in the online community from around the world have started playing games over Skype and other webcam-enabled methods of communication. I've only played one game this way so far, and wasn't sure what to expect exactly (I was imagining lots of connectivity and audio issues, as that's how almost every Google Hangouts session I've ever been in has gone), but it went better then I expected and I'm looking forward to playing more this way! It's nice that in 2018 there exists another way to connect all these people who enjoy this particular format of the game.

Recently, I figured that since my introduction to the game was largely via the Fourth Edition set originally released 23 years ago in 1995, that I would treat myself to some sealed old stock of this set. Buying any sealed old stock of Magic and opening it is guaranteed to lose you money, so one cannot treat it as an investment, but rather as an indulgence into nostalgia.

I suppose it's important to point out that, with my goal of building my "old school" decks within the boundaries of the stricter Swedish rules, using Fourth Edition cards in my decks is not possible. Unless I decide to follow the more lenient Eternal Central rules, which I may do at some point given the way that prices are going up recently... At any rate, I bought this just for fun, nothing else!

One of the two player "gift boxes" for Fourth Edition. Containing two 60 card decks, a rule book (a slightly bigger one then you'd get ordinarily with a starter deck box), and a (in my opinion) kind of nice flannel bag with glass counters. There was also a mostly equivalent gift box set for Revised Edition, but it's far more expensive due to the possibility of it having dual lands (which are expensive cards).

The bag holding the glass counters had broken open on it's own somehow over the past 23 years and they were scattered in the box when I opened it, but no harm was done. It's kind of funny seeing the mail-in response cards. A part of me wants to try sending it in, but I think I'll just leave it here in the box for completeness. The little black flannel bag to hold the counters is a bit nicer then I expected. Not super great quality or anything, but after seeing this now, I think I'm definitely going to use it with these glass counters for all my games going forward. As I understand it, the counters were intended to be used to track the the player's life during a game. However, nowadays there are mobile apps that do this task just as well (if not better). Instead, using these to track tokens and counters as needed for cards during a game seems a much better use to me.

But let's get on to the sealed decks. As per the description on the back of the box shown above, "this box contains everything two people need to play", so what will these decks actually look like?

Heh. So, if you've ever opened a Magic starter deck box (60 cards), then you'll instantly know that despite the fact that these two "decks" were packaged differently in a "two player" set ... this gift box just contains two normal starter decks. That is, 60 randomly assorted cards with lands, and the usual amount of rares, uncommons and commons. They're not specially prepared into anything even remotely resembling what one could consider to be a playable deck.

Well, actually now let me think about that, heh. If I think back to how I used to play this game with my brother back in the mid-90's (described above in this post) then actually for me, these two "decks" here are actually quite reminiscent of how we played! Lots of random cards with no theme or strategy. Just a "play with what you have" kind of feel to it. Now, if you were a player who had money and was not a young kid just getting into the game and had the knowledge to construct an optimized deck, then no, these two decks most certainly are not "playable" to you.

Aside from all of that, it brought a big smile to my face shuffling through these cards. It's always fun to see a Craw Wurm. Who doesn't like big creatures. And 6/4 was pretty damn big! With the way my brother and I played back in the day, Howl from Beyond was a very strong card given that we typically left our attacks until the end of the game (at which point you had a lot of lands out and could hugely buff one of your attackers... and at that point, we only had one Howl from Beyond, so it often was a game winner). I remember we both never really thought much of Erg Raiders ("why would you want to play a card that hurts you every turn you don't attack with it!?"). Always nice to see a Lightning Bolt of course. Terror was a card that we also had only one or two of back then, and it was something we loved drawing and using to instantly kill something of the others. Cards like Holy Armor and Firebreathing were also quite sought-after for us during games, as anything that buffed your creatures was good for our typical end-of-game battle-royale-style attacks. For me now in 2018, seeing Greed, Hypnotic Specter, Fellwar Stone, Strip Mine, Millstone, Power Surge amongst others are also all quite nice.

Fourth Edition, and to a little bit of a lesser extent, Ice Age will always remain my favourite sets of Magic. Not just because it's what I started playing with, but also because I always thought that the cards looked their best (highly subjective opinion of course) at this early point in the game's life while still retaining the majority of the original cards and artwork (in the case of Fourth Edition anyway). Chronicles also continues that, though with a smaller pool of cards. Revised edition, as I mentioned earlier, looked rather ugly to me. Alpha, Beta and Unlimited edition cards look rather nice (I prefer Beta to the more rounded corners of Alpha), but to me there was always a certain ... crudeness (?)... to them. I'm not sure if that's really the right word honestly. Perhaps it is, but I feel someone will read that and get an exaggerated impression of what I mean. They were of course the earliest editions (as evidenced by the names "alpha" and "beta", heh), but they did always have a little tiny bit of an unpolished feel to me. However, that feeling could largely be because I didn't see these editions until after I was already accustomed to Fourth Edition, Chronicles, and beyond. I can see how these simpler looking cards from the earliest editions would be more appealing to some. And to be clear, I am not saying I dislike them by any means. Quite the contrary as I covet my existing collection of Alpha/Beta/Unlimited cards!

(Just ignore the blatantly obvious centering issue on the Fourth Edition card on the bottom right, heh. That kind of thing happens in any edition.)

I suppose this all just helps to demonstrate how our early encounters with things colour our perceptions of it later on.

Updated libDGL Code

April 28, 2018 code dos

A quick post just to point out that I updated the libDGL Github repository with the most up to date working code that I currently have.

Since I originally pushed libDGL code to Github last November, not much new functionality/features has been added. Kind of disappointing for me to think about actually, heh. That being said, over all that time, I do feel like I fixed up a bunch of bugs and generally improved the performance of what was there. However, looking at my to-do list that is left for libDGL, I still really have my work cut out for me:

  • Scaled/rotated blitting support
  • Blending
  • "Mode 7" like support
  • Custom font loading (BIOS-like format?)
  • Joystick / Gravis GamePad support
  • Input device (keyboard/mouse/joystick) events
  • PC speaker sounds
  • Sound Blaster compatible sound/music
  • Gravis Ultrasound compatible sound/music
  • Sine/cosine lookup table optimizations
  • BMP, LBM, GIF image loading (and saving?)
  • Simple immediate mode GUI

This list is definitely not in any particular order. I want to start building a simple 2D map editor tool (since the old QBasic one I have sitting here is missing source code, so I cannot even just extend it as a quick alternative), so the last item about a "simple immediate mode GUI" is probably going to be my next task.

Following that, I kind of what to do something with audio. I've been focusing a lot on graphics lately and feel like a change would be nice. More specifically, I think starting with some MIDI playback might be fun. I just recently picked up a Roland Sound Canvas SC-88VL (through which, MIDI songs sound absolutely exquisite) and this is most probably influencing that decision, heh. However, I think I'd likely want to start with writing MIDI playback code for a Yamaha OPL as that was far more commonplace, but supporting general MIDI devices also sounds like a nice second step.