Name: olcPixelGameEngine
Uploaded: 2020-03-27T17:43:40.000Z
Duration: 20 min 17 s
Description: Thousands of YouTube videos with English-Chinese subtitles! Now you can learn to understand native speakers, expand your vocabulary, and improve your pronunciation...

I'd like to introduce the one lone Koda pixel gay mentioned not long after starting this channel.

I created ahead of file called the OLC Consul Game engine.

And this was a little utility file that allowed me to harness the Windows Command prompt in such a way that we could display graphics and accept user input.

And I used it to create many game demos on algorithm demos.

And I think the response to this game engine has been really quite fantastic.

There's quite a lot of people using it on.

I think the simplicity of using it really appeals.

You just include the head of file and you start writing the code that matters.

That's my YouTube channel has evolved that the demands I've been putting on the console game engine have been growing and growing on.

It has been a little bit of a competition in some way to see just what can I do next with the command prompt.

The recent code it yourself three D graphics engine, Siri's, has highlighted some of the limitations that I'm facing with the console.

Primarily it doesn't do graphics, and instead we've had to resort to approximating graphics in interesting ways.

We saw in the Web camera the council video on subsequently some of the community's efforts to make that even better, that you can approximate graphics quite realistically.

But on the whole, the performance begins to really slow down.

And in the texting part of the three D graphics engine Siri's, we began to see performance issues due to how the windows subsystem renders the council.

There are a lot more interesting algorithms I'd like to display on this channel, but I do need some sort of higher Fidelity graphics in order to do so.

I guess they will be predominantly graphical algorithms, but I'm a little bit conscious of the fact that the videos of becoming about how do we do graphics in the council rather than focusing on the algorithms underneath.

And so I decided to create the woman code, a pixel game engine, the pixel game engine, like the council game engine.

Before it is a single head of file solution on, I've decided to create my own license to use it.

It's a variation off the BSD three license.

Fundamentally, it's the same But it does insist that you give me a little bit of a nod.

If you use the code in something public now, I want to get this clear straight away.

I'm not going to stop using the council game engine.

It's still appropriate for a lot of things that I want to do.

If my applications have predominantly text based, I'll use the council.

If the predominantly graphic space I'll use the pixel gay mentioned and one of the things that I've tried to do, mainly due to the success of the council game injured is emulators much functionality of the council game engine as possible.

So it's a very, very similar experience for the user.

In fact, you can take most of my existing code import.

We'll see some examples of that later on.

One of the things I've tried to get right from the start this time.

And remember when I started this YouTube channel, I never really expected it to gain any kind of subscriber base it all, so compiling on other platforms wasn't a priority.

However, this head of file has been compiled in Lenox first, and I took this approach to really try and ensure the maximum compatibility we can have with his many users and operating systems as possible.

I've also tried to rely on libraries, which are effectively standard with any development in stall.

And so compiling code that uses the pixel game engine should be quite simple.

I've also made an effort to support code blocks on Windows.

Everybody has access to visual studio on Windows on one of the most frequent comment is How do I get your code to work on code blocks?

So I guess there are parts of the world where code blocks is still quite popular, so the pixel game engine should compile on code blocks to in the standard Windows environment.

You no longer have to do anything at all to get the project to run.

It will self load the library's on visual studio in code blocks.

You need to add four libraries, but it's quite clearly highlighted which for they are and you will have them in your default code box installation.

I've also worked on quite a bit to get it to be a character type agnostic, so it doesn't really matter whether you're using Unicode or not.

Now, the first major change is all of the pixel game engine code exists in an O.

L C name space, and I've adopted this approach to allow me to wear extensions later on that can exist within this name space without contaminating the rest of the programs instead of characters.

The fundamental unit you operate upon is the pixel, which is a 32 bit full color, well, pixel.

And so, yes, the pixel game engine supports transparency.

In the console game engine, we had something called an ol sea sprite.

Well, we have a no well see sprite again.

This time it's just called Sprite on DIT loads a PNG file.

So the pixel game engine works with P and G files fundamentally underneath.

I will walk us through a little demonstration later on, but I just want to highlight some of the features of the head of file.

There's a lot of familiarity with the council game engine.

You first need to construct on instance off the pixel game engine and you give it a width and a height instead of this time giving it a font width and a height.

So this means that pixels in the pixel game engine don't necessarily have to have a want a one relationship with screen pixels on.

This will allow us to have this retro blocky effect, which I quite like, but we don't have to have a retro blocky effect.

In fact, we can have very high definition algorithms to next.

We see two very familiar functions to the council game.

Engine on user, create on on user update.

These function exactly the same as they did before.

If you didn't know the consul game agent also has on user destroyed, but I don't think I've used it in any videos.

The nature of interacting with user input is exactly the same.

We can get this state of a key, and we can get this state of a mouse.

We can interrogate the primary display of the pixel game engine exactly the same as with the council game engine, with the functions, screen wit and screen height through a few more now, which we may go into detail in in later videos And if you have any familiarity with counsel game engine, you'll recognize a lot of these functions straight away.

We can draw single pixels, draw lines, draw circle, outlines, Phil circles.

I've now I did a draw, a rectangle function and a film rectangle function.

We've got the drawer triangle and Phil Triangle, which have exploited a lot of recently and draw spite on draw partial Sprite.

So hopefully you can see that very little has changed from how they use it interacts with the pixel game engine.

Ironically, one of the more complicated things to do now is actually draw text, but I have provided a drawstring function.

We may look at the implementation of that later, too.

As we stroll down the aisle C pixel game engine, head of file, we discover a gap.

Everything above this gap has been the declarations and everything.

Below it has been the definitions, so this means we can create the object oriented programming alternatives to the pixel game engine very trivially.

Now I think I'll do a separate video some point in the future on the actual mechanics behind how the pixel game engine works.

But it's very, very similar to the console game engine.

The only difference this time is it needs to create Windows for the platforms that it supports.

When I introduce the council game engine, I created a very quick demonstration to display noise on the screen.

It's just kind of the council game engine Hello, world equivalent.

So I'll do the same with a pixel game engine, starting with a blank source file in a blank project.

I'm going to include the pixel game engine, head of file.

Now we need to create a class that derives from the pixel game engine.

So I called the class example, which inherits publicly from a well see pixel game engine.

Now remember, the OLC is a separate name space.

Now, when we create a new class, it's typical to override the constructor.

And as with counsel game agent, you have the opportunity to name your application.

Typically, they're two functions we always want to override.

In this instance, we don't need to create any resources, so I'm just going to return.

True to say that this function successfully completed the main function where all of the guts of the game engine Lies is on user update, which takes in a floating point variable called F Elapsed Time Again, we'll make it return.

True to say, Please don't terminate the application with those two basic functions now declared will implement the main function.

So the first thing is to create an instance of our class now, before we used to call a function called Construct Counsel in exactly the same way.

Subtitles ListPlay Video

olcPixelGameEngine

constant

straight

instance

texture