advice on creating ASCII game engine

dnoah · July 25, 2025

So, I've always wanted to make an oldschool roguelike in the vein of ADoM, Zangband etc, but with a more open-world, sandboxy feel. I've done some back-of-the-napkin coding and some very amateurish mod dev here and there, but I've no idea what tools (language or free engines) are good now. Like, this decade. Worried mostly about legal/licence stuff, that might intervene with sharing my project. Oh and, no adult stuff, just pure gameplay/gameflow, in the base game, at least. Any advice appreciated <3.

VideNoir · July 25, 2025

use a mud, maybe coffeemud. Idk about license things but Sorta weird to say no adult stuff in this funny land of loverslab lol.

dnoah · July 25, 2025

15 minutes ago, VideNoir said:

use a mud, maybe coffeemud. Idk about license things but Sorta weird to say no adult stuff in this funny land of loverslab lol.

Thx, I'll check it out, although not sure whether inherent multiplayer features of mud would get in my way. Well, LL is the only place where I've ever met some really good mod devs, so hopefully some of them might have some advice :).

blank_v · July 25, 2025

Joined Jul 8 2014...

273 messages posted...

Description relating to Pentium CPU bug? - Freeze CPU bug... or is the F0 0F C7 C8 having different meanning?

Foh-Zoff Sih-Sev Sate?

Or just "funny" 4chan user? Ehh well whatever.

What do You mean by ASCII Game Engine?

ASCII stands for American Standard Code for Information Interchange, in short just a table of characters.

If You want to make "ASCII game engine" You can simply grab any C++ enviroment, even the old DevC++ would do...

Simply output text via cout, like I did in my console RPG game in 2017:

Spoiler

		Color(2);
	cout<<"     =||========================="<<endl;Color(10);
	cout<<"      :: Your Health:            "<<endl;Color(2);
	cout<<"==||==||========================="<<endl;Color(10);
	cout<<"  Skills:                        "<<endl;
	cout<<"  :: 1)                          "<<endl;
	cout<<"  :: 2)                          "<<endl;
	cout<<"  :: 3)                          "<<endl;
	cout<<"  :: 4)                          "<<endl;
	cout<<"  :: 5)                          "<<endl;Color(2);
	cout<<"==||==||========================="<<endl;Color(10);
	cout<<"      :: Mana:                   "<<endl;
	cout<<"      :: Durability:             "<<endl;Color(2);
	cout<<"     =||========================="<<endl;Color(10);
	cout<<"      :: 6) Inventory            "<<endl;
	cout<<"      :: 7) Run away             "<<endl;Color(2);
	cout<<"     =||========================="<<endl;

	Color(2);
	 setpos(34,2);		cout<<"==-||-====--      --========"<<endl;
	 setpos(34,3);		cout<<"       --====||========---- "<<endl;Color(10);
	 setpos(34,4);		cout<<"            Enemies:        "<<endl;Color(2);
	 setpos(34,5);		cout<<"            -||- -======-- -"<<endl;Color(10);
	 setpos(34,6);		cout<<"             :: 1)          "<<endl;
	 setpos(34,7);		cout<<"             :: Health:     "<<endl;Color(2);
	 setpos(34,8);		cout<<"            -||- -======-- -"<<endl;Color(10);
	 setpos(34,9);		cout<<"             :: 2)          "<<endl;
	 setpos(34,10);		cout<<"             :: Health:     "<<endl;Color(2);
	 setpos(34,11);		cout<<"            -||- -======-- -"<<endl;Color(10);
	 setpos(34,12);		cout<<"             :: 3)          "<<endl;
	 setpos(34,13);		cout<<"             :: Health:     "<<endl;Color(2);
	 setpos(34,14);		cout<<"       --====||========---- "<<endl;
	 setpos(34,15);		cout<<"==-||-====--      --========"<<endl;

if You are using Windows Console You will have 16 colors to use ( 4 bit depth ) You can set colors as:

#define Color(a) SetConsoleTextAttribute(console, (a))

Going back in time it was quite braindead way to make enemies in my game xD

image.png.863d9a9ece287cca1d9ae909dd5b8e25.png

struct ArenaEnemyST
{
	int hp,mp;
	int exp,gold;

	int atack;
	string Name;

	bool (*MyAttack)(&ArenaDataST);
	SpellST SpellList[4];

}ArenaEnemy[]={

Also I use above quite a lot the SetPos() function, its simply a small wrapper for Windows function:

void setpos(int x,int y){
	COORD pos;
pos.X=x;
pos.Y=y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
}

Example AI: ( Healer - checks if any of the teammates is on low HP, if so then heals, otherwise it just does base attacks )

Spoiler

bool HealerFightData(ArenaDataST &Data,int EnemyID)
{
	if(Data.Enemy[EnemyID].SpellList[0].is)
	{
		if((Data.Enemy[0].hp < Data.Enemy[0].hp * 0.25))
		{
			Data.Enemy[EnemyID].SpellList[0].Use(Data,0);
				return true;
		}
		else if((Data.Enemy[1].hp < Data.Enemy[1].hp * 0.25))
		{
			Data.Enemy[EnemyID].SpellList[0].Use(Data,1);
				return true;
		}
		else if((Data.Enemy[2].hp < Data.Enemy[2].hp * 0.25))
		{
			Data.Enemy[EnemyID].SpellList[0].Use(Data,2);
				return true;
		}

	}
	else
	{
		msg += Data.Enemy[EnemyID].Name;
		msg += " is attacking You with base attack !...";
		AddMessage(msg);
	Data.PlayerHp -= Data.Enemy[EnemyID].atack;
		return true;
	}
	return true;
}

So if You want to make ASCII game engine, all You need to do is to grab any C++ compiler, and write a code,

and don't worry, unless You use some licensed compiler made by for example Intel - that was good 10 years ago, now its pretty much nothing different than standard GCC GNU - You dont have to worry about the license, as there is pretty much none.

if You dont want to download anything, and / or compile anything, You can simply use JavaScript, unless You writing from phone You have a browser like Chrome or Firefox or pretty much any browser that would allow You to write JS code and write game in Browser...

This way You could actually make game that have a lot more than just ASCII, how about UNICODE and Emojis?

But if You want to go with just ASCII then C++ or JS can do that... well Python can do that too...

dnoah · July 25, 2025

54 minutes ago, ̖̪. said:

So if You want to make ASCII game engine, all You need to do is to grab any C++ compiler, and write a code,

and don't worry, unless You use some licensed compiler made by for example Intel - that was good 10 years ago, now its pretty much nothing different than standard GCC GNU - You dont have to worry about the license, as there is pretty much none.

TY. Any drawbacks to using an open-source .NET engine (SadConsole)?

EDIT: ASCII works well enough, I think. Dwarf Fortress does perfectly fine with ASCII, and it's a very complex game.

Edited July 25, 2025 by dnoah

belegost · July 26, 2025

Far as I know DF was written in C. ASCII output is just because Toady didn't know how to draw stuff.

You can talk to the guy that made Warsim: The Realms of Aslona. He's pretty cool and helpful dude. You can contact him on any of the social media he attends.

Thomas Biskup is also still around.

Edited July 26, 2025 by belegost

VideNoir · July 26, 2025

13 hours ago, dnoah said:

Thx, I'll check it out, although not sure whether inherent multiplayer features of mud would get in my way. Well, LL is the only place where I've ever met some really good mod devs, so hopefully some of them might have some advice :).

coffeemud has alot of built in fantasy features, just need to build a world etc but yes, though you could make players unable to harm each other i suppose it'd still need hosting and would not be singleplayer...

dnoah · July 26, 2025

1 hour ago, belegost said:

Far as I know DF was written in C. ASCII output is just because Toady didn't know how to draw stuff.

You can talk to the guy that made Warsim: The Realms of Aslona. He's pretty cool and helpful dude. You can contact him on any of the social media he attends.

IKR Warsim's popularity has been inspirational for me, even if it's probably not my kind of game. And I could try its Steam page and DF forums with questions.

Yeah from what I've been reading, C/C++ is still very much viable for a project like this. Found that Tales of Maj'Eyal has its engine source open. It's also in C. Whether I can make heads or tails of it, is a different matter XD.

elsaeraser · July 28, 2025

If you want something really easy to use, I can recommend PureBasic. It isn't free, but it is only 79€. It has nice features for a "graphical console" which supports writing text at whatever part of the screen your want. FreePascal is... well free... and has really nice textout features that allow you to write to a specific part of a text screen as well.

Of course you can use plain ol' C or C++, those usually only have the option to write a whole line of text, without a "cursor", but that is okay. You would have to construct the whole screen in a buffer and than write everything at once per frame or find a library like ncurses for the os/language of your choice.

You could also just use SDL for a graphical window where you show your game as a simple tilemap using free graphics from opengameart. It wouldn't be any more difficult if you just draw a tile for everything, as even if you use a textmode window you would still more or less treat it as a tilemap.

Hope this was helpful

dnoah · July 28, 2025

21 minutes ago, elsaeraser said:

snip

Thank you, that was very informative, although I nearly choked on my water at "only 79€" :'D. Yeah, I played around with some C++, spending ~16 hrs on trying to get PDCurses to work. Couldn't get neither mingw nor Msys2 to make me the dll I needed, unfortunately, so had to use conio.h instead, which has everything I'd need. But I won't be making anything of this scale on C/C++, with just how complex they are, not if I wanna see the project through. I'll probably be looking at Python next, after I'm done messing around with C++, as well as look into some more open source engines available.

Qviddhartha · July 28, 2025

I suggest you look at ncurses and aalib if you intend to write the game engine from scratch using C or C++.

Back in the day, people played Doom (an early quasi-3D first person shooter) using aalib. Most dungeon crawlers like Nethack used ncurses.

Well, that's from a real old timer's perspective.

Edit: At times, this old timer dreams of porting nethack to javascript...

Edited July 28, 2025 by Qviddhartha

dnoah · July 28, 2025

43 minutes ago, Qviddhartha said:

snip

Thx for the info. Isn't PDCurses a version of ncurses for windows? That's what I read, at least. Couldn't get it to work, unfortunately. But I think I'll be moving away from C/C++, due to their sheer complexity.

Doom in ASCII... whoa. Now I gotta take a look at that . Doom is still very much alive, though. New speedruns, maps that are completely out of this world (like MyHouse.wad -- if you still partake, I highly recommend), etc.

edit: MyHouse.wad is Doom 2, apparently. My bad.

Edited July 28, 2025 by dnoah

elsaeraser · July 29, 2025

I didn't even consider Python, but that could be a good alternative.

I just remembered there is a JavaScript Toolkit for making roguelike games called rot.js. I have never used it myself though and it would banish your game to the web browser.

dnoah · July 29, 2025

19 minutes ago, elsaeraser said:

I didn't even consider Python, but that could be a good alternative.

I just remembered there is a JavaScript Toolkit for making roguelike games called rot.js. I have never used it myself though and it would banish your game to the web browser.

Thank you! My knowledge of js is at absolute zero, but rot.js appears to have some actual ADoM graphics on its homepage, so at least by that metric, it looks very promising!

belegost · July 30, 2025

On 7/28/2025 at 11:30 PM, dnoah said:

Doom in ASCII... whoa. Now I gotta take a look at that

There's Doom the Roguelike. It was pretty cool game last time I played it... which was 20 years ago.

Still being maintained from what I see.

Edited July 30, 2025 by belegost

belegost · August 2, 2025

On 7/28/2025 at 11:30 PM, dnoah said:

MyHouse.wad is Doom 2, apparently.

John Romero has his own channel on YT and have streamed himself playing this wad. Saying he was truly impressed is an understatement.

Edited August 2, 2025 by belegost

DoomSequirrel · August 3, 2025

Personally I think that console graphics are actually a bit of trap. They seem easy, but when you want to implement features like color, resolution or proper screen refreshes they become pretty complicated.

These days I would guess that the easiest option is C# + Forms:

public partial class Form1 : Form
{
    private Font? m_font;

    public Form1()
    {
        InitializeComponent();
    }
  
    protected override void OnKeyDown(KeyEventArgs e)
    {
        base.OnKeyDown(e);
        //handle menu and normal game input here 
    }

    protected override void OnKeyPress(KeyPressEventArgs e)
    {
        base.OnKeyPress(e);
        //for text input you want to use this
    }

    protected override void OnLoad(EventArgs e)
    {
        //monospace means that every character has the same size
        m_font      = new Font(FontFamily.GenericMonospace, 12);
        MinimumSize = new Size(800, 600);
        //disable flickering
        DoubleBuffered = true;
        base.OnLoad(e);
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
        if (m_font == null)
        {
            return;
        }
        
        var viewport = ClientRectangle;

        var glyphSize   = e.Graphics.MeasureString("A", m_font);
        var pixelWidth  = (int)glyphSize.Width;
        var pixelHeight = (int)glyphSize.Height;

        //add 1 to avoid problems with halves
        var screenWidth  = viewport.Width / pixelWidth + 1;
        var screenHeight = viewport.Height / pixelHeight + 1;

        e.Graphics.FillRectangle(Brushes.Black, viewport);
        for (var y = 0; y <= screenHeight; ++y)
        {
            for (var x = 0; x <= screenWidth; ++x)
            {
                e.Graphics.DrawString("A", m_font, Brushes.Green, x * pixelWidth, y * pixelHeight);
            }
        }

        e.Graphics.Flush();
        Invalidate(); //trigger next refresh, which allows drawing during modal loop (i.e. sizing)
    }
}

Edited August 3, 2025 by DoomSequirrel

dnoah · August 3, 2025

5 hours ago, DoomSequirrel said:

Personally I think that console graphics are actually a bit of trap. They seem easy, but when you want to implement features like color, resolution or proper screen refreshes they become pretty complicated.

These days I would guess that the easiest option is C# + Forms:

Thanks for the info. Yeah, proper refresh rate is something I've been struggling with. C++ can't do it with its native libs, and curses libs doesn't want to install for me. :[. Not sure how I feel about .NET yet -- while it would be easy for me to set up, releasing something publicly that much entangled with Microsoft may not be such a good idea.

DoomSequirrel · August 3, 2025

2 hours ago, dnoah said:

Thanks for the info. Yeah, proper refresh rate is something I've been struggling with. C++ can't do it with its native libs, and curses libs doesn't want to install for me. :[. Not sure how I feel about .NET yet -- while it would be easy for me to set up, releasing something publicly that much entangled with Microsoft may not be such a good idea.

Well yeah I understand, personally I don't like .NET either but that's more because I don't get any advantage from it. if it helps here my thought process for my own stuff:

- If you don't know the basics about how a game works: Fabien Sanglard has awesome docs about how the quake engines work.

- For a game you just need to learn the following:

--> Create a window

--> Setup the message loop (or game loop)

--> Handle user input (just key presses etc.)

--> Something for drawing, OpenGL is still the easiest, followed by DX and Vulkan is straight up garbage

--> Basic audio (anybody can write a midi player)

- The target platform should be part of the OS or trivial to install for the user (Java is already too complicated + Oracle are dicks).

- For this you must be able to write something that deals with C interfaces and it should be as easy as possible.

- Many media libraries like SDL, GLFW,etc. do the same job but they don't provide a good user experience (no support for locales, different window behavior, etc.)

- Consider them as candidates for learning / prototyping

- I'm also no lawyer but many of those seem to have weird licensing shit that makes them hard to recommend

- If you can't write your own, start with C++ and check out the good old Nehe tutorials (or pixel game engine on youtube)

I myself have shifted to .NET core because (note: .NET core is not the same as .NET):

- I don't want to bother with all the different compiler vendor nonsense

- Easy support for OSX & Linux

- Easy package system for third party libraries (in case it's ever needed)

- It's easy to integrate your own C & C++ libraries (in case that's needed)

And here's the general setup I need for a game (probably takes about a day or 2):

1.) implement my own IServiceProvider for dependency injection & lifetime management (highly recommended)

2.) implement a simple service for native library loading3.) implement my wrappers for Win32 API & OpenGL32

4.) implement service for the main window, keyboard & mouse

4a.) Keyboard is tricky, so don't worry too much if you screw up a little here

5a.) implement configurable service for video output

5b.) implement one service configuration for OpenGL

6.) Implement extentable service for image loading

6a.) Implement tga loading (easy)

6b.) Implement bmp loading (also easy)

6c.) Implement dds loading (more advanced but easier than png or jpeg)

7.) Implement basic sound (again the pixel game engine guy on youtube has a good tutorial)

7a) Implement tracker

7b) Implement a bunch of instruments

8.) now write your game, try to implement something simple first:

8a.) copy a byte array to a texture

8b.) draw a textured fullscreen rect with that texture

8c.) later on you can add multiple quads & textures, and add abitrary sizes etc.

8d.) congrats you can now do anything with sprites & text

8e.) optimize with hardware instance

8f.) replace quads with models if you want to be extra fancy ... add lighting, PBR materials, raytracing

here's all the dependencies that I need to import from the windows OS / video driver to get something up & running:

(these should be separated neatly in their own modules / classes so you can swap.)

//window
libraryLoader.LoadFunction("kernel32", "GetModuleHandleW", out GetModuleHandle);
libraryLoader.LoadFunction("user32", "CreateWindowExW", out CreateWindowEx);
libraryLoader.LoadFunction("user32", "DefWindowProcW", out DefaultWindowProc);
libraryLoader.LoadFunction("user32", "DestroyWindow", out DestroyWindow);
libraryLoader.LoadFunction("user32", "DispatchMessageW", out DispatchMessage);
libraryLoader.LoadFunction("user32", "GetWindowRect", out GetWindowRect);
libraryLoader.LoadFunction("user32", "GetClientRect", out GetClientRect);
libraryLoader.LoadFunction("user32", "LoadCursorW", out LoadCursor);
libraryLoader.LoadFunction("user32", "LoadIconW", out LoadIcon);
libraryLoader.LoadFunction("user32", "MsgWaitForMultipleObjects", out MsgWaitForMultipleObjects);
libraryLoader.LoadFunction("user32", "PeekMessageW", out PeekMessage);
libraryLoader.LoadFunction("user32", "RegisterClassExW", out RegisterClassEx);
libraryLoader.LoadFunction("user32", "SetFocus", out SetFocus);
libraryLoader.LoadFunction("user32", "SetForegroundWindow", out SetForegroundWindow);
libraryLoader.LoadFunction("user32", "SetWindowPos", out SetWindowPos);
libraryLoader.LoadFunction("user32", "SetWindowTextW", out SetWindowText);
libraryLoader.LoadFunction("user32", "ShowWindow", out ShowWindow);
libraryLoader.LoadFunction("user32", "TranslateMessage", out TranslateMessage);
libraryLoader.LoadFunction("user32", "UnregisterClassW", out UnregisterClass);
libraryLoader.LoadFunction("user32", "GetWindowLongW", out GetWindowLong);
libraryLoader.LoadFunction("user32", "SetWindowLongW", out SetWindowLong);
libraryLoader.LoadFunction("user32", "BeginPaint", out BeginPaint);
libraryLoader.LoadFunction("user32", "EndPaint", out EndPaint);
libraryLoader.LoadFunction("user32", "InvalidateRect", out InvalidateRect);
libraryLoader.LoadFunction("user32", "GetMessageTime", out GetMessageTime);

//mouse is easily implement with the normal window events
//keyboard requires some additional stuff to handle combined keys & sticky pairs
libraryLoader.LoadFunction("user32", "MapVirtualKeyW", out MapVirtualKey);
libraryLoader.LoadFunction("user32", "GetAsyncKeyState", out GetAsyncKeyState);
libraryLoader.LoadFunction("user32", "GetKeyState", out GetKeyState);

//opengl32
libraryLoader.LoadFunction("user32", "GetDC", out GetDeviceContext);
libraryLoader.LoadFunction("user32", "ReleaseDC", out ReleaseDeviceContext);
libraryLoader.LoadFunction("gdi32", "ChoosePixelFormat", out ChoosePixelFormat);
libraryLoader.LoadFunction("gdi32", "SetPixelFormat", out SetPixelFormat);
libraryLoader.LoadFunction("gdi32", "SwapBuffers", out SwapBuffers);
libraryLoader.LoadFunction("opengl32", "wglCreateContext", out WglCreateContext);
libraryLoader.LoadFunction("opengl32", "wglDeleteContext", out WglDeleteContext);
libraryLoader.LoadFunction("opengl32", "wglMakeCurrent", out WglMakeCurrent);
libraryLoader.LoadFunction("opengl32", "wglGetProcAddress", out WglGetProcAddress);

//and once the opengl context is created you'll need to load with wglGetProcAddress
//also check out how to create core contexts with wglCreateContextAttribsARB
//you'll need to load the following functions to get a minimal opengl setup
openGlLoader.LoadFunction(nameof(glEnable), out glEnable);
openGlLoader.LoadFunction(nameof(glDisable), out glDisable);
openGlLoader.LoadFunction(nameof(glClearColor), out glClearColor);
openGlLoader.LoadFunction(nameof(glClearDepth), out glClearDepth);
openGlLoader.LoadFunction(nameof(glClear), out glClear);
openGlLoader.LoadFunction(nameof(glBlendColor), out glBlendColor);
openGlLoader.LoadFunction(nameof(glBlendFunc), out glBlendFunc);
openGlLoader.LoadFunction(nameof(glDepthMask), out glDepthMask);
openGlLoader.LoadFunction(nameof(glDepthFunc), out glDepthFunc);
openGlLoader.LoadFunction(nameof(glCullFace), out glCullFace);
openGlLoader.LoadFunction(nameof(glFrontFace), out glFrontFace);
openGlLoader.LoadFunction(nameof(glGetError), out glGetError);
openGlLoader.LoadFunction(nameof(glColorMask), out glColorMask);
openGlLoader.LoadFunction(nameof(glViewport), out glViewport);
openGlLoader.LoadFunction(nameof(glScissor), out glScissor);
openGlLoader.LoadFunction(nameof(glCreateProgram), out glCreateProgram);
openGlLoader.LoadFunction(nameof(glDeleteProgram), out glDeleteProgram);
openGlLoader.LoadFunction(nameof(glUseProgram), out glUseProgram);
openGlLoader.LoadFunction(nameof(glLinkProgram), out glLinkProgram);
openGlLoader.LoadFunction(nameof(glGetProgramiv), out glGetProgramiv);
openGlLoader.LoadFunction(nameof(glGetProgramInfoLog), out glGetProgramInfoLog);
openGlLoader.LoadFunction(nameof(glAttachShader), out glAttachShader);
openGlLoader.LoadFunction(nameof(glDetachShader), out glDetachShader);
openGlLoader.LoadFunction(nameof(glCreateShader), out glCreateShader);
openGlLoader.LoadFunction(nameof(glDeleteShader), out glDeleteShader);
openGlLoader.LoadFunction(nameof(glShaderSource), out glShaderSource);
openGlLoader.LoadFunction(nameof(glCompileShader), out glCompileShader);
openGlLoader.LoadFunction(nameof(glGetShaderiv), out glGetShaderiv);
openGlLoader.LoadFunction(nameof(glGetShaderInfoLog), out glGetShaderInfoLog);
openGlLoader.LoadFunction(nameof(glGetUniformLocation), out glGetUniformLocation);
openGlLoader.LoadFunction(nameof(glGetAttribLocation), out glGetAttribLocation);
openGlLoader.LoadFunction(nameof(glUniform1i), out glUniform1i);
openGlLoader.LoadFunction(nameof(glUniform1f), out glUniform1f);
openGlLoader.LoadFunction(nameof(glUniform2f), out glUniform2f);
openGlLoader.LoadFunction(nameof(glUniform3f), out glUniform3f);
openGlLoader.LoadFunction(nameof(glUniform4f), out glUniform4f);
openGlLoader.LoadFunction(nameof(glUniformMatrix4fv), out glUniformMatrix4fv);
openGlLoader.LoadFunction(nameof(glGenVertexArrays), out glGenVertexArrays);
openGlLoader.LoadFunction(nameof(glDeleteVertexArrays), out glDeleteVertexArrays);
openGlLoader.LoadFunction(nameof(glBindVertexArray), out glBindVertexArray);
openGlLoader.LoadFunction(nameof(glEnableVertexAttribArray), out glEnableVertexAttribArray);
openGlLoader.LoadFunction(nameof(glDisableVertexAttribArray), out glDisableVertexAttribArray);
openGlLoader.LoadFunction(nameof(glVertexAttribPointer), out glVertexAttribPointer);
openGlLoader.LoadFunction(nameof(glVertexAttribDivisor), out glVertexAttribDivisor);
openGlLoader.LoadFunction(nameof(glDrawArrays), out glDrawArrays);
openGlLoader.LoadFunction(nameof(glDrawArraysInstanced), out glDrawArraysInstanced);
openGlLoader.LoadFunction(nameof(glGenBuffers), out glGenBuffers);
openGlLoader.LoadFunction(nameof(glDeleteBuffers), out glDeleteBuffers);
openGlLoader.LoadFunction(nameof(glBindBuffer), out glBindBuffer);
openGlLoader.LoadFunction(nameof(glBufferData), out glBufferData);
openGlLoader.LoadFunction(nameof(glBufferSubData), out glBufferSubData);
openGlLoader.LoadFunction(nameof(glActiveTexture), out glActiveTexture);
openGlLoader.LoadFunction(nameof(glBindTexture), out glBindTexture);
openGlLoader.LoadFunction(nameof(glDeleteTextures), out glDeleteTextures);
openGlLoader.LoadFunction(nameof(glGenTextures), out glGenTextures);
openGlLoader.LoadFunction(nameof(glTexImage2D), out glTexImage2D);
openGlLoader.LoadFunction(nameof(glTexParameteri), out glTexParameteri);
openGlLoader.LoadFunction(nameof(glTexSubImage2D), out glTexSubImage2D);

Edited August 3, 2025 by DoomSequirrel

AhuwgaZ · August 3, 2025

I think there are some advance stuff here, but the advice to use mud is where I recommend starting.
When I was a kid, muds were coded in C, but you have options now. I definitely recommend using python. Ton of tools, ton of support, ton of versatility, easy as fuck to write.

Here's what you get with a python approach:
pyfiglet makes ASCII art out of text

ASCII-magic Makes ASCII art out of images

python-roguelike-framework The name says it all
An example for you to follow: https://github.com/eklavya-joshi/Python-Roguelike-Game

And, if you wanted to make a web socket, python is the way to go. Nobody uses gmud/zmud or whatever it is these days, except the die hards... or rather undead old nerds. If you want a multi-user-dungeon, you'll want to make a browser based solution and python is your best choice for that, unless you're a masochist, then you would use java.

dnoah · August 4, 2025

21 hours ago, DoomSequirrel said:

I myself have shifted to .NET core because (note: .NET core is not the same as .NET):

- I don't want to bother with all the different compiler vendor nonsense

- Easy support for OSX & Linux

- Easy package system for third party libraries (in case it's ever needed)

- It's easy to integrate your own C & C++ libraries (in case that's needed)

Thank you I was not aware of .NET Core. Well hopefully OpenGL can handle text as well as graphics -- I'd rather not concern myself with graphics at this point.

dnoah · August 4, 2025

20 hours ago, AhuwgaZ said:

I think there are some advance stuff here, but the advice to use mud is where I recommend starting.
When I was a kid, muds were coded in C, but you have options now. I definitely recommend using python. Ton of tools, ton of support, ton of versatility, easy as fuck to write.

Here's what you get with a python approach:
pyfiglet makes ASCII art out of text

ASCII-magic Makes ASCII art out of images

python-roguelike-framework The name says it all
An example for you to follow: https://github.com/eklavya-joshi/Python-Roguelike-Game

And, if you wanted to make a web socket, python is the way to go. Nobody uses gmud/zmud or whatever it is these days, except the die hards... or rather undead old nerds. If you want a multi-user-dungeon, you'll want to make a browser based solution and python is your best choice for that, unless you're a masochist, then you would use java.

Thx yeah I've been looking at what's available in Python for my needs. Lots of useful stuff like what you linked. I'm not particularly looking at the MUDs, because they're essentially designed for online multiplayer, involving client-server & running in real time, which is not what I intend.

DoomSequirrel · August 5, 2025

13 hours ago, dnoah said:

Thank you I was not aware of .NET Core. Well hopefully OpenGL can handle text as well as graphics -- I'd rather not concern myself with graphics at this point.

Well the good news is that it doesn't really matter

Except for some weird setups drawing text is exactly the same as drawing sprites from a sheet. You just have an atlas with all the glyphs instead of icons. Older games like ultima even used an atlas with glyphs & icons in order to handle text & graphics with just one thing.

It also doesn't really matter what kind of API or language you are using, they all can do the same thing. High level APIs like Java's Swing or Forms just give you nice little wrappers for rendering text, but they can be annoying when dealing with some of the details (i.e. it's really hard to do old school pixel art with them).

OpenGL, Vulkan and D3D are pure graphics APIs and you would need to implement that part on your own, but since you do it yourself you can solve detail issues like filtering etc.. The only one that I would suggest to avoid is Vulkan because that is just an extremely tedious setup for 0 benefit.

From what you are describing there are 2 easy setups that I would suggest:

a) You can start with a fullscreen quad that just displays one texture (most tutorials will teach that right after the hello world examples). Each frame you then replace the pixel data of that texture. This is the way that the youtube series I suggested earlier does the rendering. Very simple and straight forward. For text / icons, you just need to copy their pixel array to the one for the actual texture + you can easily extend it in order to draw other interesting shapes.

b) Once you get A running, you'll note that you can also just draw multiple quads at different coordinates with just parts of your texture. That way you can skip the copying of pixel data and leave it to the hardware. It'll give you a lot of speed or improve the quality with more advanced blending, but you can no longer draw arbitrary pixel data.

In the end you probably want to write your code in a way that supports both -> you'll have a really nice 2D engine at this point.

Edited August 5, 2025 by DoomSequirrel

Sign In

advice on creating ASCII game engine

Recommended Posts

Create an account or sign in to comment

Create an account

Sign in

Recently Browsing 0 members