[SILL]

So as I mentioned last post, I’m currently working on a small game at the same time I’m working on the Sill / Manual as a way to maintain motivation on the project.  One of the first things I needed to do for my game project was make a simple menu for the user to interact with…and just like that I was back working on Sill, changing things to accommodate this ‘feature’.

As you may be aware, Sill has a built-in menu API for making selection menus.  The first iteration of this API was an overly complex mess that tried to support every menu type imaginable (circle, dynamic, etc).  That version of the API was eventually scrapped and rebuilt in order to limit the bloat (only supported context style menus and limited display options) and to fix some bugs (which, in the end, didn’t require a rewrite after all).

Well, now I scrapped that version and have made a new menu API that is not only way simpler to use and understand, but also streamlined internally for performance and user control (also, currently fully stable with no bugs ^^).

SILL_API sill_menu_create(SILL_RESOURCE *menu);
SILL_API sill_menu_error_exists(SILL_RESOURCE menu);
SILL_API sill_menu_destroy(SILL_RESOURCE menu);
SILL_API sill_menu_destroy_all();

SILL_API sill_menu_input_add(SILL_RESOURCE menu, SILL_UINT key, SILL_MENU_OPERATION_TYPE operation, SILL_UINT op_ext, SILL_UINT item_id);
SILL_API sill_menu_input_remove(SILL_RESOURCE menu, SILL_UINT key);
SILL_API sill_menu_input_mouse(SILL_RESOURCE menu, SILL_UINT enable);

SILL_API sill_menu_item_add(SILL_RESOURCE menu, SILL_UINT item_id, SILL_REAL x, SILL_REAL y, SILL_UINT width, SILL_UINT height);
SILL_API sill_menu_item_set_position(SILL_RESOURCE menu, SILL_UINT item_id, SILL_REAL x, SILL_REAL y);
SILL_API sill_menu_item_get_position(SILL_REAL *x, SILL_REAL *y, SILL_RESOURCE menu, SILL_UINT item_id);
SILL_API sill_menu_item_set_size(SILL_RESOURCE menu, SILL_UINT item_id, SILL_UINT width, SILL_UINT height);
SILL_API sill_menu_item_get_size(SILL_UINT *width, SILL_UINT *height, SILL_RESOURCE menu, SILL_UINT item_id);
SILL_API sill_menu_item_remove(SILL_RESOURCE menu, SILL_UINT item_id);

SILL_API sill_menu_set_texture(SILL_RESOURCE menu, SILL_RESOURCE texture);
SILL_API sill_menu_get_texture(SILL_RESOURCE *texture, SILL_RESOURCE menu);
SILL_API sill_menu_remove_texture(SILL_RESOURCE menu);

SILL_API sill_menu_set_parent(SILL_RESOURCE menu, SILL_RESOURCE parent_menu);
SILL_API sill_menu_get_parent(SILL_RESOURCE *parent_menu, SILL_RESOURCE menu);
SILL_API sill_menu_remove_parent(SILL_RESOURCE menu);

SILL_API sill_menu_start(SILL_RESOURCE menu, SILL_REAL x, SILL_REAL y);
SILL_API sill_menu_simulate(SILL_RESOURCE menu, SILL_MENU_OPERATION_TYPE operation, SILL_UINT op_ext, SILL_UINT item_id);
SILL_API sill_menu_status(SILL_MENU_OPERATION_TYPE *operation, SILL_UINT *op_ext, SILL_UINT *item_id, SILL_RESOURCE menu);
SILL_API sill_menu_stop(SILL_RESOURCE menu);
SILL_API sill_menu_stop_children(SILL_RESOURCE parent_menu);

SILL_API sill_menu_set_position(SILL_RESOURCE menu, SILL_REAL x, SILL_REAL y);
SILL_API sill_menu_get_position(SILL_REAL *x, SILL_REAL *y, SILL_RESOURCE menu);
SILL_API sill_menu_is_running(SILL_UINT *running, SILL_RESOURCE menu);

SILL_API sill_menu_debug(SILL_RESOURCE menu, SILL_UINT enable, SILL_UINT color);
SILL_API sill_menu_lock(SILL_RESOURCE menu);
SILL_API sill_menu_unlock(SILL_RESOURCE menu);
SILL_API sill_menu_is_locked(SILL_UINT *locked, SILL_RESOURCE menu);

^Still WIP API^

The biggest change from the previous versions of the menu API is that the new one doesn’t keep track of any internal Z-ordering or drawing procedures.  These two abilities are now the responsibility of the programmer using the API (which makes sense, since both of these are highly dependent on the type of application being made).  This allows for the menu API to be streamlined to a bare-bones input handling system while opening up a lot of control options for developers to customize and expand on the existing foundation.  In a nut shell, menus can now be way more dynamic (circle, angled, scatter, animated, etc) while still being simple to build.

Some of the new features:

• Internal support for mouse and keyboard input.
  (customizable input and can be disabled independently)
• Programmer controlled parenting and current state lock/unlock options.
  (For Z-order development and/or disabling menu interaction)
• Simulate input or set a menu state.
  (For making custom input methods or forcing a menu state)
• Dynamic item adding/removing, positioning and sizing on the fly.
  (Possibility for reactive or animated menus)
• Texture assignment for displaying on a dedicated menu layer.
  (Above view layer and below the draw overlay layer)
  (Keep in mind that the texture can be part of a draw buffer)
• Simple polling style status results
• Debug interface, for testing internal input handling

I plan to document the menu API here shortly (next few days) just so it’s covered in the manual, then I’ll be shifting focus back to the game…which will hopefully make some decent progress before I’m fixing / updating Sill again…

~Brandon

So, as usual, I end up disappearing for a long time, completely forgetting about this blog and my development work.  This is then usually followed by an update post about how ‘I’m back’, blaming the lack of updates on <insert game here> and that it will never happen again…  I think by now any long time reader (if I actually have any) knows this is just a cycle that will repeat itself every few months.  I predict the next time will be Guild Wars 2…

Anyway, as the title suggests, I spent the last month putting some serious time into Eve Online, which is a complex, and immensely time sucking, MMO that inevitably draws me back in from time to time.  After about a month or so of playing this ‘game’ to death, I’m starting to get a ‘this is wasting way too much of my free time’ feeling and realizing I have so many wonderful projects collecting dust that I should be working on instead.

The TL;DR - I’m back and will hopefully do something productive before I disappear again.

[SILL]

Just some quick changes to make note of:

The ‘constant updating’ of the online manual (currently on the site) is going to stop (some of you may have noted how quickly that fell apart).  I was spending way to much time uploading/maintaining the ‘online’ part which would be better spent working on the manual as a whole.  I’ll still update from time to time, but definitely not on a regular or daily basis.

I’m also going to put more focus on a game project rather then just straight up working on the manual.  The idea (hope) here is that some game development (small as it may be) will keep me motivated for the entire project (switching between fixing Sill for my game, working on the game itself and updating the manual as needed) which in turn will keep me from ‘disappearing’ so often and for long stretches of time.

More details on the game once I have something to actually show.

~Brandon

[SILL]

I uploaded part of Sill’s manual yesterday to the website (the manual button on the left actually works now!).  It’s still heavily under construction and far from complete, but hopefully the public access will help keep me motivated to work on it.  There are also some aspects I’d like to hear some feedback on, such as the overall layout and how the information is presented.  A help manual isn’t much help if users can’t understand it or have a hard time navigating it.

Also, as some of you may have noticed, Sill’s pending license agreement is also included in the manual.  Licenses are something I’m still very new to when it comes to software development (mainly because I never released anything that required one, other then your typical ‘as is’ clause).  I was told the best approach is to ‘link to’ an existing license, but most of the ones I found (which could possibly work) didn’t include everything I wanted (or had specific clauses that would conflict with my intentions).  So I wrote up my own license specific to my needs.

My goal with the license is to have a library/engine that anyone can use (be their product is freeware or commercial) with minimal hassle for the developers.  I also want to protect the Sill project, and myself, from individuals that may want to cause problems in one way or another.  Feel free to get in contact with me if you have any concerns, questions or suggestions about the license as I would like to have any conflicts/issues ironed out before release.  So with that said, the specifics of the license are still under consideration and may change before Sill’s official release. 

Speaking of release, another bit of information you may have picked up was the ‘released later this year’ phrase in the introduction page.  As I stated before, Sill is basically done, pending this manual and a few additions (notably the particle engine).  I still plan to have a ‘pre-release’ build sometime before the manual is complete (probably when most of the require systems/functions are documented) followed by a ‘full release’ after the manual is done.  The actual timing of all this is still up in the air, but I would be really shocked if I don’t have it up by 2013.  So it’s safe to say that this is the year I release Sill publicly.

…and maybe, we can start seeing some games made with it before the year is out.

~Brandon

[SILL]

Now that Journey is behind me (or at least, a break from the title), I am now back working on Sill and I’m making some excellent progress (taking some time away from programming is a great way to rebuild motivation).

Today, along with a few other minor issues, I fixed a critical bug where using sill_instance_destroy(self); in an event that was called using sill_instance_event(object_handle); would cause a pointer exception crash.  Talk about a special case situation I just happened to stumble on oO.  (I’m sure many more of these will appear once public testing begins).

On top of bug fixes, I can now definitely say I have the networking engine done (that includes the ‘simple to use’ api as well as raw sockets), with the only thing left to do is some ‘real world’ testing (as in across the internet rather then my local network).  I’m currently in the process of developing a small server/client application to do just that (something my test users can actually enjoy rather then looking at command prompts the entire time).

Also, as if that wasn’t enough to report, I have started planning out the particle system and it’s components for future development.  I hope to start actual coding of that part sometime before April.

Whew…and then there is the online manual.  Probably one of the most important parts of the entire Sill project and I just haven’t found the time work on it.  Which is real shame, considering that’s the main reason I haven’t released Sill yet.  Maybe I should devote this entire week to just working on the manual ;).  Yeah, that sounds like a good idea.

So, in a nut shell, I’m back to working on Sill ‘full time’ (when not at my day job) and putting my priorities on developing the manual so I can get this lovely engine out to you guys ASAP.  Also, Sill will include the networking and particle systems on first release, rather then added at a later release.

Making progress, one semicolon at a time;

~Brandon

A few screens from my many captured moments, purposely trying to avoid showing spoilers.

So Journey has been an awesome experience, one which I highly recommend every PS3 owner to get their hands on.  I have played the game, from beginning to end, about 10 times now and it never seems to get old (even after unlocking everything).

Every session I played, I captured it on video just so I can have a ‘physical record’ of every moment I had in the title (along with the people I had them with).  I may make a tribute video sometime (maybe after the majority of people have had a chance to play it first hand), but we’ll see if time allows.

The game has a lot going for it.  The story, music, game mechanics, graphical polish and even the difficulty pacing are, I consider, downright perfect.

But what really makes this game stand above and beyond many of the other titles I’ve played is the co-op.  Each time I played, the experience was very different but always enjoyable.  Although I would end up revisiting many of the same locations time and time again, I would come across them in completely different ways with a variety of companion types (from the new careful/fearful players, to the driven ‘collect everything’ explorers, the ‘I got everything’ show off, the ‘I want to get a specific trophy’ collector, to the person that follows your every move down to the button press).  Even the people I ran into that would have probably been a ‘bad experience’ in most other games became helpful (and sometimes comical) allies during the journey.

And I think that’s the point, and the main reason I keep coming back to the title after every play session.  It isn’t about the collectables, the achievements, the locations or even the final destination.  It’s all about the journey, and how it plays out with the companion(s) you’ve come across during those brief moments together.

This game has instantly become a classic in my mind and the experience(s) I’ve had with it will be fondly remembered for a long time.

~Brandon

If everything goes according to plan, I will be broadcasting my first play session of Journey (PS3) this Wednesday morning at the usual time schedule (10am to 12pm ET).  I encourage anyone who is interested in the title to join me and see what this adventure is all about.

You can go directly to my http://twitch.tv/shaltif page or press the broadcast menu button on the left to watch.

I got around to updating the menu on the left, which you may notice the following changes [Which may require a manual reload of the menu pane (right-click -> refresh/reload)]:

• I removed the Sill VDE section as those plans have been put on hold for the foreseeable future.  I may consider it down the line, but for now I want to put full focus on Sill, the manual and game projects.
• I’ve added a game list link, which shouldn’t be too big of a surprise to those who knew about it.  It’s essentially an on-going WIP list of every game I currently own (excluding freeware titles).  It’s the most complete list I have ever made and is still being actively updated. I recommend checking it out if curious and maybe recommend a new title or two via my twitter.

Speaking of twitter, I am aware of the bug in the website design that causes display conflicts when trying to go to my twitter feed directly from the website (ie: left-clicking any of the twitter links on the right).  The current work around is to right-click and ‘open in new tab/window’.  I think the issue is because of the frame situation my index page uses to showcase the blog.

Anyway, just wanted to explain some of the changes made to the website so far.  I hope to get some updated news on the status of Sill in the next blog post.  Until then, keep following me on twitter for the latest on everything Shaltif ^^.

~Brandon

Long story short, you can blame my sister for this one =P.  After much reluctance to get involved in all the ‘social media’ sites, I finally gave in and jumped on twitter.

I connected it to the site (or more correctly, my blog) so that others out there can ‘follow’ what I’m doing during the times between blog posts.  It also gives a method for people to comment back about my blog if they so desire (not sure how many readers, if any, I still retain at this point =P).

[SILL]

I have the network API done now (Woo!), which ended up being over 3000 lines of code…now to start testing to make sure that it actually works =P.  Once that’s done, going to possibly get the particle system in or maybe just make a game.  My plans are still up in the air when it comes to the release schedule, as usual.  The manual is still at a slow crawl, so a public release of the development library is still pending.

But at least I’m still making progress ^^.

~Brandon

So last update I posted about how I’ve been broadcasting ‘daily’ over at my twitch.tv channel.  Well, that’s still true, tho not as ‘time constricted’ as I originally posted.  I’ve moved back to a more ‘when free time allows’ setup because trying to hit that same 2 hour time slot every day caused all types of real world schedule conflicts.  For more specific info, head over to my http://twitch.tv/shaltif channel and read the info page.

[SILL]

Bring up Sill, it is still being worked on (duh).  I’m currently re-coding the network engine (oh noes!) for better performance and to meet some slightly different design goals.  Here is what the API looks like as of this post:

// NETWORK API (sill_network.cpp)
SILL_API sill_network_system_create();
SILL_API sill_network_system_error_exists();
SILL_API sill_network_system_destroy();
SILL_API sill_network_system_lookup(SILL_CHAR *ip, SILL_CHAR *hostname);

SILL_API sill_connection_close(SILL_RESOURCE connection);
SILL_API sill_connection_close_all();

SILL_API sill_connection_tcp_listen_open(SILL_RESOURCE *listen_connection, SILL_UINT port, SILL_UINT backlog);
SILL_API sill_connection_tcp_listen_error_exists(SILL_RESOURCE listen_connection);
SILL_API sill_connection_tcp_listen_accept(SILL_RESOURCE *tcp_connection, SILL_RESOURCE listen_connection, SILL_UINT max_send_buffer, SILL_UINT max_recv_buffer);

SILL_API sill_connection_tcp_open(SILL_RESOURCE *tcp_connection, SILL_CHAR *ip, SILL_UINT port, SILL_UINT max_send_buffer, SILL_UINT max_recv_buffer);
SILL_API sill_connection_tcp_error_exists(SILL_RESOURCE tcp_connection);
SILL_API sill_connection_tcp_set_delimiter(SILL_RESOURCE tcp_connection, SILL_CHAR delimiter);
SILL_API sill_connection_tcp_get_delimiter(SILL_CHAR *delimiter, SILL_RESOURCE tcp_connection);
SILL_API sill_connection_tcp_send(SILL_RESOURCE tcp_connection, SILL_CHAR *message);
SILL_API sill_connection_tcp_receive(SILL_CHAR *message, SILL_RESOURCE tcp_connection, SILL_UINT peek);
SILL_API sill_connection_tcp_receive_exists(SILL_RESOURCE tcp_connection);
SILL_API sill_connection_tcp_ip(SILL_CHAR *ip, SILL_RESOURCE tcp_connection);

SILL_API sill_connection_udp_open(SILL_RESOURCE *udp_connection, SILL_UINT port, SILL_UINT max_send_buffer, SILL_UINT max_recv_buffer, SILL_UINT max_message_log);
SILL_API sill_connection_udp_error_exists(SILL_RESOURCE udp_connection);
SILL_API sill_connection_udp_send(SILL_RESOURCE udp_connection, SILL_CHAR *ip, SILL_UINT port, SILL_CHAR *message);
SILL_API sill_connection_udp_receive(SILL_CHAR *message, SILL_CHAR *ip, SILL_UINT *port, SILL_RESOURCE udp_connection, SILL_UINT peek);
SILL_API sill_connection_upd_receive_exists(SILL_RESOURCE udp_connection);

SILL_API sill_network_server_create(SILL_RESOURCE *network, SILL_UINT port, SILL_CHAR *password);
SILL_API sill_network_server_client_total(SILL_UINT *total, SILL_RESOURCE network);
SILL_API sill_network_server_client_list(SILL_UINT *list, SILL_RESOURCE network);
SILL_API sill_network_server_client_ip(SILL_CHAR *ip, SILL_RESOURCE network, SILL_UINT client_id);
SILL_API sill_network_server_client_kick(SILL_RESOURCE network, SILL_UINT client_id, SILL_CHAR message);
SILL_API sill_network_server_set_ping_interval(SILL_RESOURCE network, SILL_UINT interval);
SILL_API sill_network_server_get_ping_interval(SILL_UINT *interval, SILL_RESOURCE network);
SILL_API sill_network_server_set_password(SILL_RESOURCE network, SILL_CHAR *password);
SILL_API sill_network_server_get_password(SILL_CHAR *password, SILL_RESOURCE network);

SILL_API sill_network_server_event_send_all(SILL_RESOURCE network, SILL_NETWORK_EVENT_TYPE net_event, SILL_UINT client_id, SILL_CHAR *message);
SILL_API sill_network_server_event_send_direct(SILL_RESOURCE network, SILL_UINT to_client_id, SILL_NETWORK_EVENT_TYPE net_event, SILL_UINT client_id, SILL_CHAR *message);
SILL_API sill_network_server_event_send_group(SILL_RESOURCE network, SILL_UINT *to_client_id_list, SILL_UINT size, SILL_NETWORK_EVENT_TYPE net_event, SILL_UINT client_id, SILL_CHAR *message);

SILL_API sill_network_server_access_ip_add(SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type, SILL_CHAR *ip);
SILL_API sill_network_server_access_ip_remove(SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type, SILL_CHAR *ip);
SILL_API sill_network_server_access_ip_exists(SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type, SILL_CHAR *ip);
SILL_API sill_network_server_access_ip_matching(SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type, SILL_CHAR *ip);
SILL_API sill_network_server_access_list_total(SILL_UINT *total, SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type);
SILL_API sill_network_server_access_list_entry(SILL_CHAR *ip, SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type, SILL_UINT pos);
SILL_API sill_network_server_access_list_clear(SILL_RESOURCE network, SILL_NETWORK_ACCESS_TYPE type);

SILL_API sill_network_client_connect(SILL_RESOURCE *network, SILL_CHAR *hostname_ip, SILL_UINT port, SILL_CHAR *password);
SILL_API sill_network_client_set_ping_timeout(SILL_RESOURCE network, SILL_UINT timeout);
SILL_API sill_network_client_get_ping_timeout(SILL_UINT *timeout, SILL_RESOURCE network);

SILL_API sill_network_message_send_server(SILL_RESOURCE network, SILL_CHAR *message);
SILL_API sill_network_message_send_all(SILL_RESOURCE network, SILL_CHAR *message);
SILL_API sill_network_message_send_direct(SILL_RESOURCE network, SILL_UINT client_id, SILL_CHAR *message);
SILL_API sill_network_message_send_group(SILL_RESOURCE network, SILL_UINT *client_id_list, SILL_UINT size, SILL_CHAR *message);

SILL_API sill_network_event(SILL_NETWORK_EVENT_TYPE *net_event, SILL_UINT *client_id, SILL_CHAR *message, SILL_RESOURCE network);
SILL_API sill_network_error_exists(SILL_RESOURCE network);
SILL_API sill_network_destroy(SILL_RESOURCE network);
SILL_API sill_network_update(SILL_RESOURCE network);

Should make network coding much easier to implement in my future projects when it’s complete…just wish network coding wasn’t so taxing on the mind.

Anyway, just wanted to give a short update, will post more ‘in da future!’

~Brandon

About time I get another update on this =P.

As most of you are aware, I have a twitch.tv stream which I use to broadcast my gaming experiences (you can easily tune in by clicking the ‘broadcast’ menu item to the left).  In the past, I used this mainly as a way to show my friends and family games they may be interested in or just to show off something on my computer screen.  However, after getting some rather positive feedback, I have decided to make my broadcasts a recurring event with a ‘hopefully’ fixed time schedule and open for anyone to watch.

Every week day, from ~10am to ~12pm (ET or GMT -5) you can tune in and view me playing a variety of games spanning many platforms (console and PC titles).  I haven’t nailed down a weekend schedule (probably late evening, something like 12 midnight to 3am or something), but I plan to broadcast during weekends as well.

I’m currently testing the waters to see how well this venture turns out and whether people generally enjoy watching me play.

Right now I’m currently battling my way through a normal play session of The Legend of Zelda: A Link to the Past (Wii US VC) and on Friday I plan to complete dungeons 6 and 7 to hopefully beat the game (so tune in!).  Late Friday into early Saturday I plan to play Limbo from the PS3 (12am to 3am ET or GMT -5) to end the week.  What games I’ll play after that I may leave up to the viewers to decide, tho I have a few titles already on my list to help keep things going.

Hope to see ya there,

~Brandon