Hello, Everyone.Me and Wesley had a long talk about the noise in the thread, and I think it's safe to say that there won't be any more chitchat from now on.
I actually have a big announcement to make regarding the project... Quite a few of them actually.
The project is officially over a year old now, and a lot has happened in the past year that we've been developing this.
The original goal, a full year ago, was just to make a game library for shits and giggles.
In the past few months, our project's goal has completely changed. Now we're actually making a game library that intends to just
stay simple and
avoid the unnecessary. That's pretty much it. We figured that if we want others to recognize this mindset, we need to turn our entire development philosophy around. To get a head start, we're officially going to rename the project to something much simpler and recognizable.
From now on, the project is just going to be called...
Mercury.That's right, I'm serious. From now on there will be no more of those 3 annoying capitalized letters.
Incase you were wondering what they were there for, it was supposed to be a cheesy recursive acronym:
"MERCury's Easy, Reliable, (and) Capable!"Enough said about that, let's move on to the code itself!
For the past week and a half I've been tinkering around and fixing many kinks and bugs in the library. (Changelog
here) And honestly, there is a lot of stuff wrong with it right now. Currently, our main issue is the staggering amount of leftover code in the library from its early days. In-case some of you hadn't known, Mercury had originally started out as a 3D library and 'downgraded' to 2D about a week in for the sake of making things less time-consuming. There were still a few tools built into the library to deliver not-so-good support for it, and now they've finally been removed in my latest commit.
I'm also proud to say that the way Core's are setup now has been
completely reworked as well. I'm just going to let the code explain for itself.
Here is what your average class would be like, using Mercury just but
a couple days ago:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class MyClass extends Core {
Runner runner = Runner.getInstance();
public MyClass() {
super("Hello");
runner.init(this, 800, 600);
runner.run();
}
public void init() {}
public void update(float delta) {}
public void render(Graphics g) {}
public void cleanup() {}
public static void main(String[] args) {
new MyClass();
}
} |
While this is extremely short when compared to class setups in things like Slick2D, I figured that we could do this better and in a much more simplistic manner.
Here's how the basic layout of a Mercury program looks
now:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class MyClass extends Core {
public MyClass() {
super("Hello", 800, 600);
}
public void init() {}
public void update(float delta) {}
public void render(Graphics g) {}
public void cleanup() {}
public static void main(String[] args) {
new MyClass().start();
}
} |
This is perfect in my opinion. Now the user doesn't have to do anything with the Runner nor know exactly what it does to get a basic program going. Not the biggest change in the world, but still pretty awesome I feel.
Granted, a bit of hackery was required to get this to work. All of the code for it should be cleaned up
very soon, probably by Me or Wesley.
With that out of the way, there's still even more to discuss. Remember that awful Color class? We've already gotten
some complaints about that one. I'm
very happy to say that now it's much easier to use, yet less buggy too. I've additionally added new g.setColor(); functions that simply take in 1, 3 and/or 4 variables containing each component. So now you have the choice of either creating a new object for your colors or passing in all of the variables for one right there. Pretty neat stuff IMO. I've also re-done the color palette
entirely. This time, I've decided to do it with easy-on-the-eye colors that I feel
are and
will be very delightful to use in different projects.
Demos of the library are also now in development, and most of the classes in the test package have been removed for the sake of keeping the library clean. The code for them tends to be very awful. I've also made a few changes regarding splash-screens, now you don't have to manually display them in your render function. I've also brought back the drawRectangle() function, for it was gone a while back and replaced with drawPolygon(). (Still not replacing drawPolygon() though)
We're only about
80% done with the renaming process and going through all of the files to make sure we don't miss anything. Right now we're still in the middle of having to update splash screens, leftover documentation, GitHub-related things, and a bunch of other junk. Feel free to contact me or Wesley to report any files/code that still uses the 'MERCury' name. The Wiki will also be updated later. So don't worry about that.
That's pretty much it really. A lot of other things have been changed, but they're not significant enough for me to need to mention them in this post.
Again, check the (horribly-written) change-log if you really want to know all of what happened.
TL;DR Update:Core's are now much easier to setup,
We've changed the project's name to 'Mercury,'
We've turned our entire development philosophy around,
1.0.1 Beta, our first official release, will be released later within the next 1-2 months with various changes,
Many bugs have been, will be, and
are being fixed.
You can download the latest build here:
[dead link]The code is still really hackish right now and everything is still a bit buggy, so don't expect a stable build out of this.
Thanks, hopefully that can give you guys a bit of an idea of what we've been doing lately.
I've probably made a ton of grammatical errors in this post and may have not worded things too well, I'm tired from having worked on the project all night. I'll probably just make a second edit later with some typo-fixes. Happy coding,
- Jev
EDIT: Yep, I know the versions on the JARs are all messed up. Fixed.
