Jump to content

  • Log In with Google      Sign In   
  • Create Account

Pixel → Tile → World



Playing around with environment lighting mockups

Posted by , 19 March 2015 - - - - - - · 1,554 views

I've been playing around in Paint Shop Pro to mockup different environment lightings. These are conceptual (they aren't in-game):

Posted Image

This is stylistic practice for a certain scene I have in-mind that'll occur about a third of the way into the game.

Posted Image

The tree shadows are facing the wrong direction in this one. Posted Image

I'm also considering applying normal-mapping to my 2D sprites:
Posted Image
(Blown up 4x the regular size)


Cross platform filepath conventions and folder organization - Suggestions?

Posted by , 20 July 2012 - - - - - - · 1,339 views
organization, development and 2 more...
I have alot of folders and files that I use for programming, and sometimes it's a pain when I manually have to go through them in Windows Explorer. To make it easier, I use a couple tricks:

1) I set icons to folders I use frequently, usually icons that can be at a glance distinguished from each other, so I don't even need to read the folder names if I'm familiar with where I'm heading.

2) I also wrap folders or files that I access more frequently with some symbol that Windows automatically sorts to the top of the folder. I usually wrap them in either '(' ')' or else '[' and ']'.

It's that second item that is causing me problems - My code is meant to be cross-platform, so I use GNU tools alot. Unfortunately, GNU tools, being designed for Unix-like systems, sporadically mess up when dealing with such symbols. Posted Image

So, I'm looking for another symbol system that is compatible with Linux, Mac OSX, and Windows folder-naming conventions. Is there a "minimum requirements to be cross-platform" filenaming guide to view? How do you keep your own programming files organized for cross-platform use?

Another thing that bothers me is I'm a sucker for aesthetically-pleasing names, which is why I used brackets (symmetrically at beginning and end of the name) instead of just slapping an underscore or exclamation mark at the front of everything.

Posted Image
(I probably sound like a super neat freak - Actually it's the opposite, I'm pretty messy, so I try to find ways to organize and control my mess)

One thing I dislike is underscores instead of spaces. Ugh. However, since spaces aren't tolerated by some programming tools, I normally use one-word folder names or camel-case instead. They just look neater to me that way, and if they look neater, I feel happier coding, so it's kinda a psychology trick I guess.

My file directories are a mess, in bad need of organization, so I guess the real solution is to just clean up the files and folders and make sure there are no more than a dozen subfolders in each folder - even so, I'd like your thoughts on the matter. How do you keep everything rapidly accessible? (And yes, I do have a shortcut to my current project at the root directory)

More importantly, what do I need to do to make sure my filepaths are compatible with GNU tools?
I was thinking of using a new scheme of putting a numeral before each folder, followed by a period. The numeral will be sorted before the letters are, thus making any numeral-based folder rise to the top.

"Programming" would thus become "1. Programming". Does that run afoul of some Linux standards?

As an example of my current problem, this path keeps messing up some build tools:
D:/Jamin/(Programming)/(Projects)/(AdventureFar)\etc...

Any thoughts?


Steam Greenlight? ...and a few other things

Posted by , in Uncategorized, AdventureFar 09 July 2012 - - - - - - · 1,765 views

Valve just announced a new way for developers to get onto Steam. They're calling it Steam Greenlight.

Posted Image

Basically, developers early in development start posting stuff about their game, and if the community likes it enough, they upvote the game, and if the game gets enough community support, it brings increased awareness of the game to Valve who are more likely to release the game on Steam once it is finished.

Steam Greenlight will go live August 30th, which is 50-ish days away. I'm seriously thinking about putting AdventureFar on Steam Greenlight.
Hopefully, I'll actually-truly-for-real have the editor functioning enough by then to have good screenshots of my game to submit, as well as video of me walking around a town. We'll see if I can get it done in time.

Posted Image

On another note, I use MinGW, and I'm also loving alot of the new C++11 features. MinGW released a new version last month, bringing it up to GCC 4.7.

I also use QtCreator as my IDE of choice, and furthermore, I use the Qt API for native GUI widgets for the editor. Unfortunately, some of the Qt signal-and-slot macroes choke up C++11 with GCC 4.7, and makes the whole code refuse to compile.

If anyone else is running into the same problem, the solution can be found here.
Basically, you fix the broken Qt macro, which interferes with C++11 user-defined literals.
#define QLOCATION "\0" __FILE__ ":" QTOSTRING(__LINE__)

You can fix the define in QObjectDef.h (without recompiling Qt).
(Note: This fix has already been patched into Qt 4.8.1, but I'm still on Qt 4.7)

(Error messages included for increased Google-abillity for others encountering the same issue:)
inconsistent user-defined literal suffixes '__FILE__' and 'QTOSTRING' in string literal
error: unable to find string literal operator 'operator"" __FILE__'

Posted Image


I'm working to get the interface up and running for adding/deleting and manipulating floors and layers of area chunks. Here's a screenshot:

Posted Image

Almost done. The logic has been there, behind the scenes, since before I even had a dev journal. It's getting everything connected to interfaces that take all my time. Posted Image

http://img215.imageshack.us/img215/3950/textdivider2.png

Other notes: Last night and the night before last, I knocked out the rough draft for the final section of the final Act of the game, including the ending scene. I still need to touch it up, and fill in the fine details and step-by-step events, but at least now I know how the game ends:

Spoiler


Here's the current status of the plot (rough guesses):

Act 1 - 100% rough drafted, 25% fine details (the beginning third, and some later sections)
Act 2 - 90% rough drafted, 10% fine details
Act 3 - 30% super rough drafted, 10% fine details on a piece of scrap paper somewhere
Act 4 - 70% super rough drafted, 5% fine details (the ending)

I came up with some new side quest ideas for the final act as well, and some enemy ideas.

Maybe I'll knock some more out later tonight. I really need to marshal all of it together and at least get all the Acts 100% drafted.


Strongly-typed typedefs in C++ in MinGW and GCC (C++11, GCC v4.6)

Posted by , 29 May 2012 - - - - - - · 4,040 views
template, macro, typedef, gcc and 3 more...
C++ typedefs are weak - they are only a simple alias of the original type, and are implicitly converted to and from the original type.

Here's a basic example:
struct Point
{
	 int x, y;
};

typedef Point MyPoint;
typedef Point MyOtherPoint;

int main(int argc, char *argv[])
{
	Point point;
	MyPoint myPoint;
	MyOtherPoint myOtherPoint;

	point = myPoint; //Implict conversion from typedef and original.
	myPoint = point; //Implicit conversion from original to typedef.
	myOtherPoint = myPoint; //Implicit conversion between two different typedefs.

	return 0;
}

Unfortunately, C++11 doesn't add strong typedefs either, but using some of the new features in C++11 I created a template/macro that adds strong typedefs to the language.

Here's how it's used:
//typedef Point MyPoint;
//typedef Point MyOtherPoint;

strong_typedef( Point, MyPoint);
strong_typedef( Point, MyOtherPoint);

int main(int argc, char *argv[])
{
	Point point;
	MyPoint myPoint;
	MyOtherPoint myOtherPoint;

	point = myPoint; //Implict conversion from typedef and original.
	myPoint = point; //error: static assertion failed: "MyPoint can not implicitly be assigned from Point-derived classes or strong Point typedefs"
	myOtherPoint = myPoint; //error: static assertion failed: "MyPoint can not implicitly be assigned from Point-derived classes or strong Point typedefs"

	return 0;
}

The 'strong_typedef' template/macro allows you to use the same constructors as the original, and even inherits most operators, but blocks implicit conversion when accidentally mixing types in an operation (myPoint += myOtherPoint; //compile error! Mixing types).

The macro also adds two new functions the the new types, to allow explicit conversion: "ToBaseClass()" and "FromBaseClass()".

There may be a few problems with this macro still, and if so, I'd love to hear it. Especially since template-metaprogramming type stuff is new to me, I may be making mistakes somewhere - if more experienced users would peer-review and enhance the code, we all benefit.

Here's the complete class, with example usage: (Requires GCC 4.6 or greater, and you must enable C++11 features)
#include <iostream>
#include <sstream>
#include <string>

#include <type_traits>

//Uncomment this line if you want two seperate strong typedefs to allow non-strong comparison ("strongTypeA > strongTypeB", and etc...).
//This only applies to comparisons - assignment, manipulation, and construction is still strong.
//#define STRONG_TYPEDEF_ALLOW_WEAK_COMPARISONS

//---------------------------------------------------------------------------------
//These macroes are used by 'strong_typedef'.

#define strtype_enable_if_has_function(parentTemplateArgument, function, returnValue) \
    typename std::enable_if< std::is_member_function_pointer<decltype(&parentTemplateArgument::function)>::value , returnValue>::type

#define strtype_assert_can_call(parentType, newTypeName, templateArg, errorMessage)                                                                    \
    static_assert((std::is_base_of<parentType, typename std::remove_cv< typename std::remove_reference< templateArg >::type >::type >::value == false) \
    || std::is_same<newTypeName, typename std::remove_cv< typename std::remove_reference< templateArg >::type >::type >::value, errorMessage)

#define strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, function)                          \
    template<class Arg, class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                       \
    strtype_enable_if_has_function(Parent, function, newTypeName)                                                                            \
    function(const Arg &other) const                                                                                                         \
    {                                                                                                                                        \
        strtype_assert_can_call(parentType, newTypeName, Arg,                                                                                \
            "" #newTypeName " is not implicitly convertible with " #parentType "-derived classes or strong " #parentType " typedefs");      \
        return From ## toFromFunctionParentName(this->Parent::function(other));                                                              \
    }                                                                                                                                        \
    /*newTypeName function(const parentType &other) = delete */ /* Delete the direct conversion */

#define strtype_inherit_compound_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, function)                            \
    template<class Arg, class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                       \
    strtype_enable_if_has_function(Parent, function, const newTypeName &)                                                                    \
    function(const Arg &other)                                                                                                               \
    {                                                                                                                                        \
        strtype_assert_can_call(parentType, newTypeName, Arg,                                                                                \
            "" #newTypeName " is not implicitly convertible with " #parentType "-derived classes or strong " #parentType " typedefs");       \
        this->Parent::function(other);                                                                                                       \
        return *this;                                                                                                                        \
    }                                                                                                                                        \
    /*const newTypeName &function(const parentType &other) = delete*/ /* Delete the direct conversion */

#ifdef STRONG_TYPEDEF_ALLOW_WEAK_COMPARISONS
    #define strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, function)                                     \
        template<class Arg, class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                       \
        strtype_enable_if_has_function(Parent, function, bool)                                                                                   \
        function(const Arg &other) const                                                                                                         \
        {                                                                                                                                        \
            return this->Parent::function(other);                                                                                                \
        }                                                                                                                                        \
        /*const newTypeName &function(const parentType &other) = delete*/ /* Delete the direct conversion */
#else
    #define strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, function)                                     \
        template<class Arg, class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                       \
        strtype_enable_if_has_function(Parent, function, bool)                                                                                   \
        function(const Arg &other) const                                                                                                         \
        {                                                                                                                                        \
            strtype_assert_can_call(parentType, newTypeName, Arg,                                                                                \
                "" #newTypeName " is not implicitly comparable to " #parentType "-derived classes or strong " #parentType " typedefs."            \
                "  (To implicitly allow weak type comparison, define STRONG_TYPEDEF_ALLOW_WEAK_COMPARISONS)");                                      \
                                                                                                                                                 \
            return this->Parent::function(other);                                                                                                \
        }                                                                                                                                        \
        /*const newTypeName &function(const parentType &other) = delete*/ /* Delete the direct conversion */
#endif

#define strtype_inherit_suffix_operator(parentType, toFromFunctionParentName, newTypeName, function)                                         \
    template<class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                                  \
    strtype_enable_if_has_function(Parent, function, newTypeName)                                                                            \
    function(int dummy) const                                                                                                                \
    {                                                                                                                                        \
        return From ## toFromFunctionParentName(this->Parent::function(dummy));                                                              \
    }                                                                                                                                        \
    /*const newTypeName &function(const parentType &other) = delete*/ /* Delete the direct conversion */

#define strtype_inherit_prefix_operator(parentType, toFromFunctionParentName, newTypeName, function)                                         \
    template<class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                                  \
    strtype_enable_if_has_function(Parent, function, newTypeName &)                                                                          \
    function() const                                                                                                                         \
    {                                                                                                                                        \
        this->Parent::function();                                                                                                            \
        return *this;                                                                                                                        \
    }                                                                                                                                        \
    /*const newTypeName &function(const parentType &other) = delete*/ /* Delete the direct conversion */

/*
    Example usage:

    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator+,
                                    "" #newTypeName " cannot be assigned from " #parentType "-derived classes or strong " #parentType " typedefs")
*/
//---------------------------------------------------------------------------------

//Defines a new type that behaves exactly as 'parentType', with the added benefit that
//you can't implicitly convert between types, which helps reduce errors.
#define strong_typedef(parentType, newTypeName) \
class newTypeName : public parentType                                     \
{                                                                         \
    public:                                                               \
    /* No-arg constructor */                               \
    newTypeName() {}                                       \
                                                           \
    /* Copy-constructor */                                 \
    newTypeName(const newTypeName &other)                  \
    {                                                      \
        this->operator=(other);                            \
    }                                                      \
                                                                                           \
    /* Single-argument constructor passes arguments to parent's constructor, but */        \
    /* generates a compile-time error if you try to use the parent's copy-constructor. */  \
    template<typename Arg>                                                                 \
    newTypeName(Arg &&arg) : parentType(std::forward<Arg>(arg))                            \
    {                                                                                      \
          static_assert((std::is_base_of<parentType, typename std::remove_cv< typename std::remove_reference<Arg>::type >::type >::value == false) \
                        || std::is_same<newTypeName, typename std::remove_cv< typename std::remove_reference<Arg>::type >::type >::value,          \
                        "" #newTypeName " cannot be constructed from " #parentType "-derived classes or strong " #parentType " typedefs");         \
    }                                                                                      \
                                                                                           \
    /* Multi-argument constructor, passes parameters to parent's constructor. */   \
    template<typename... Args>                                                     \
    newTypeName(Args &&... args) : parentType(std::forward<Args>(args)...) {  }    \
                                                                                   \
    /* Explicitly convert me from parent */                                        \
    static newTypeName From ## parentType(const parentType &other)   \
    {                                                                              \
        newTypeName newType;                                            \
        newType.parentType::operator=(other);                           \
        return newType;                                                 \
    }                                                                   \
                                                                        \
    /* Explicitly convert me to parent */                               \
    const parentType &To ## parentType() const            \
    {                                                                   \
        return *this;                                                   \
    }                                                                   \
                                                                        \
    /* Assignment operator */                                                                                                                \
    template<class Arg, class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                       \
    strtype_enable_if_has_function(Parent, operator=, newTypeName &)                                                                         \
    operator=(const Arg &other) const                                                                                                        \
    {                                                                                                                                        \
        strtype_assert_can_call(parentType, newTypeName, Arg,                                                                                \
            "" #newTypeName " can not implicitly be assigned from " #parentType "-derived classes or strong " #parentType " typedefs");      \
                                                                                                                                             \
        return this->Parent::operator=(other);                                                                                               \
    }                                                                                                                                        \
                                                                                                                                             \
    /* Negation operator (Logical NOT) */                                                                                                    \
    template<class Parent = parentType /* Trick to avoid compiling errors - Ignore the second parameter */>                                  \
    strtype_enable_if_has_function(Parent, operator!, bool)                                                                                  \
    operator!() const                                                                                                                        \
    {                                                                                                                                        \
        return this->Parent::operator!();                                                                                                    \
    }                                                                                                                                        \
                                                                                                                                             \
    /* Other operators */                                                                                                                    \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator+); \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator-); \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator/); \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator*); \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator%); \
                                                                                                                  \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator<<); \
    strtype_inherit_standalone_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator>>); \
                                                                                                                  \
    strtype_inherit_compound_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator+=); \
    strtype_inherit_compound_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator-=); \
    strtype_inherit_compound_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator/=); \
    strtype_inherit_compound_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator*=); \
    strtype_inherit_compound_arithmatic_operator(parentType, toFromFunctionParentName, newTypeName, operator%=); \
                                                                                                                 \
    strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, operator==); \
    strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, operator!=); \
    strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, operator>);  \
    strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, operator<);  \
    strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, operator>=); \
    strtype_inherit_comparison_operator(parentType, toFromFunctionParentName, newTypeName, operator<=); \
                                                                                                        \
    strtype_inherit_suffix_operator(parentType, toFromFunctionParentName, newTypeName, operator++); \
    strtype_inherit_suffix_operator(parentType, toFromFunctionParentName, newTypeName, operator--); \
                                                                                                    \
    strtype_inherit_prefix_operator(parentType, toFromFunctionParentName, newTypeName, operator++); \
    strtype_inherit_prefix_operator(parentType, toFromFunctionParentName, newTypeName, operator--); \
}

struct Size
{
    Size(int width = 0, int height = 0) : width(width), height(height) { }
    Size(const Size &size) { *this = size; }
    ~Size() { }

    int width;
    int height;

    bool operator==(const Size &other) const
    {
        return (this->width == other.width && this->height == other.height);
    }

    bool operator!=(const Size &other) const
    {
        return !(*this == other);
    }

    Size &operator=(const Size &other) //Assignment operator
    {
        if(this == &other) return *this; //Self-assignment protection.

        this->width = other.width;
        this->height = other.height;

        return *this;
    }

    Size operator+(const Size &other) const
    {
        return Size(this->width + other.width,
                     this->height + other.height);
    }

    Size &operator+=(const Size &other)
    {
        this->width += other.width;
        this->height += other.height;

        return *this;
    }

    Size operator-(const Size &other) const
    {
        return Size(this->width - other.width,
                     this->height - other.height);
    }

    Size &operator-=(const Size &other)
    {
        this->width -= other.width;
        this->height -= other.height;

        return *this;
    }
};

strong_typedef(Size, MySize, Size);
strong_typedef(Size, MyOtherSize, Size);

int main(int argc, char *argv[])
{
    Size originalSize;

    MySize mySizeA;
    MySize mySizeB;

    MyOtherSize myOtherSize;

    mySizeA += mySizeB;
    mySizeA = (mySizeA + mySizeB);

    mySizeA -= mySizeB;
    mySizeA = (mySizeA - mySizeB);

    //Only compiles if the original type has those operators implemented:
    {
        //mySizeA /= mySizeB;
        //mySizeA = (mySizeA / mySizeB);

        //mySizeA *= mySizeB;
        //mySizeA = (mySizeA * mySizeB);
    }

    bool isEqualTo = (mySizeA == mySizeB);
    bool isNotEqualTo = (mySizeA != mySizeB);

    //Only compiles if the original type has those operators implemented:
    {
        //(mySizeA >= mySizeB);
        //(mySizeA <= mySizeB);
        //(mySizeA > mySizeB);
        //(mySizeA < mySizeB);
    }

    //Fails to compile when accidentally mixing types:
    //static assertion failed: "MySize cannot be constructed from Size-derived classes or strong Size typedefs"
    {
        //mySizeA = myOtherSize;

        //mySizeA += myOtherSize;
        //mySizeA -= myOtherSize;
        //mySizeA *= myOtherSize;
        //mySizeA /= myOtherSize;

        //mySizeA = (mySizeA + myOtherSize);
        //mySizeA = (mySizeA - myOtherSize);
        //mySizeA = (mySizeA * myOtherSize);
        //mySizeA = (mySizeA / myOtherSize);

        //mySizeA = originalSize;
    }

    //Only compiles if 'STRONG_TYPEDEF_ALLOW_WEAK_COMPARISONS' is defined.
    //static assertion failed: "MySize is not implicitly comparable to Size-derived classes or strong Size typedefs"
    {
        //bool isEqualTo = (mySizeA == myOtherSize);
        //bool isNotEqualTo = (mySizeA != myOtherSize);
    }

    return 0;
}

Note: This macro only works with structs and classes, not with basic types like floats and ints (I haven't actually tried it, but I'd guess it wouldn't compile - you can use BOOST_STRONG_TYPEDEF for basic types instead. Boost's strong typedef doesn't work for classes and structs, which is why I made my version).

I don't suggest using strong_typedefs to randomly replace regular typedefs everywhere you use them, but I do think it's wise to use strong_typedefs for types that are likely to cause hard-to-find bugs. Unit conversions, in my case; I have Point classes that sometime are measured in pixels, and other times are measured in tiles. Sometimes they are in pixels from the origin of the world, and sometimes only from the origin of the currently loaded maps. Accidental implicit conversions are likely to occur in such situations, but making the different unit measures their own strongly typed typedefs provides compile-time error messages when a mistake occurs, instead of run-time logical bugs that are harder to locate.

Review and enhancement of the code by more advanced programmers is definitely welcome and requested! In particular, am I using perfect forwarding correctly in the constructors and operators? And also, I'm having difficulties getting the array subscript 'operator[]' and function-call 'operator()' operators to work properly in a generic way (since the return value types of those operators aren't know, using it with std::enable_if is causing me difficulties).


Main menu, (the corner of the) map visible, game state diagram

Posted by , in Uncategorized, AdventureFar 14 March 2012 - - - - - - · 1,581 views
game, development
I can see my world again! For quite awhile (many months) while doing alot of architectural changes to my code, I could no longer see the maps being displayed onscreen because I had disabled that part of the engine. Since I wasn't specifically working on the visual side of things, I hadn't bothered to get it back working.

Anyway, yesterday I re-enabled that section of the code, and this appeared:

Posted Image

This is a picture of a test map from some many months previous, and the clear-color in the background.
Sure it's not as beautiful as some other work I've uploaded, but having not seen it in a long time, it's comforting to know the map rendering still works.
I'm currently re-factoring part of the movement, collision, and player data code to make things less interdependent, so I can't scroll the screen atm, since that code is being worked on. Even so, just seeing that little corner of a test map is nice. Posted Image

Oh, I've done some work on a main-menu of the game:

Posted Image

I'm thinking of adding dynamic sparkles to the static ocean image, to make it look prettier more manly. Posted Image

I've also done some work on adding GameStates to the game, since the GameState system was already implemented.
I was getting a few stack order issues messed up in my head while working, so I sketched out the states on a piece of paper:

Posted Image

Not all GameStates shown have been added yet. There are also going to be more GameStates than just those shown, but I was only interested in two specific branches (MainMenu and PlayingGame) when I drew that.
None of the states shown are actually completed yet, I'll continue working on them and tweaking them throughout development I'm sure.

Pardon the uneven lines and poor pensmanship! It looks like a child drew it with a crayon, and it's leaning over like the Pisa leaning tower.
In a family full of incredibly amazing artists, whatever gene enhances your fine hand-motor skills must've skipped me. http://public.gamedev.net//public/style_emoticons/default/tongue.png

Actually, some members of my family are helping out with art for the game as shown previously (over a year ago!):
Rat


You'll see more of my 'art' next week when I post some concept blueprints of potential in-game towns. You'll also have plenty opportunity to compare it to my siblings' skills when I post some excellent character concept art the weeks following that.


NomenRationarium - A tool for organizing character and area names

Posted by , in Uncategorized, Tool 16 February 2012 - - - - - - · 1,059 views
free, tools, writing
NomenRationarium is a tool I've made for my own usages, and the usage of my siblings. Despite us all working on different projects in different mediums (One writing a book, another writing a manga, and myself a video game), we found we had a common need: A way to organize potential character or area names.

NomenRationarium, meaning "Name list" in butchered latin, provides a common place for you to store all your name ideas.

My siblings and I use the same tool, and sync our master list of names via DropBox. For each of our individual projects, we have a NomenRationarium file with the names we are using in that project (whether from the master list, or by creating unique project-only names).

NomenRationarium allows you to individually tag each name with mutliple tags, and search for names by filtering tags and usage.

Posted Image

(This is a picture of a clean usage. When I run the program on my computer, the main list contains almost 300 names already - shared via DropBox)

The tool is definitely functional; however, if I recoded it from scratch I'd do it alot differently. Maybe someday in the future! But at the moment, I'm too busy with my AdventureFar game project (which is making good progress, thank you for asking!) to let myself be distracted any longer by working this tool.

Download NomenRationarium

Or, if plot-related tools don't interest you:
Download Cheesecake


ViewTiled - A small tool for artists

Posted by , in Uncategorized, Tool 09 February 2012 - - - - - - · 1,931 views
tool, free, art, tools

When I work on pixel art, I use MS Paint and Paint Shop Pro 11. It works fine for me making simple game graphics, though I'm sure professionals would prefer something else.

When making pixel art (primarily tiles), I need to view the image tiled side by side to see if it's seamless or not. If I'm currently working in MS Paint and don't have Paint Shop Pro 11 open, I need to:

Open Paint Shop Pro -> wait for it to load -> Paste the image in -> (And in the menu:) "Effects -> Image Effects -> Seamless tiling..." -> Check 'Show preview' -> In the preview window, check 'Show original'


Not cool. So I made a tool that I made that lets you right-click on a image file in Windows Explorer, and select "View image tiled", and wallah!

Posted Image


Note: This does not change any file ascosiations; your files will open using the same preffered default program they always do. All it does is add a single simple 'View image tiled' context menu command, and only on the file extensions you select (Supports: PNG, Gif, Jpg, BMP, and Tiff). You don't even have to enable the context menu integration at all, if you don't want to. You can just open the tool and drag-and-drop or copy-and-paste your images in for viewing.

Posted Image

You can download it for free from GD.net's marketplace (Windows only). If you find it useful, donate $5 and buy me a pizza*.

*Warning: Money will not actually be spent on pizza. Chances are that it'll go to further my raw cookie-dough or Dr Pepper addictions, or perhaps blown on a indie game.


Physical-lizing a digital collection

Posted by , in Uncategorized, Indie games 08 January 2012 - - - - - - · 1,309 views
indie, physical distribution and 1 more...
Physical-lizing a digital collection As part of my cleaning up and organizing files, as mentioned in my previous post, I decided it'd be a good idea to backup the almost 30GB of DRM-free indie games I've purchased over the past few years.

I happened to have on-hand 20 blank DVDs with cases which I picked up on the cheap a few years back but never used (because, grr, I discovered my disc drive couldn't write DVDs after the purchase).

So I popped open Microsoft Word, creates a Slim-DVD case slipcover template, and got busy sorting, organizing and backing everything up to disc.

Here's the result:

Posted Image
Crummy real-world photo.

The backs of some of the cases are even more awesome, showing screenshot of the games.


Spring cleaning in the snow

Posted by , 07 January 2012 - - - - - - · 647 views
non-game
I've been busy working on a number of small cool tools, more info on that in a future post.

I've also been busy doing some "spring cleaning" (in the middle of winter) of my computer.
My dev machine (Also known as 'my computer', seeing as it's the only one I have) is starting to show it's age (bought in the fall of 2007), but I plan for it to last me another year before upgrading. Partly to eek as much value from it as practical, partly because it's served me well and still has the potential to do what I need it to for AdventureFar's continued development (it's a 2D tile based game - It doesn't exactly require high minimum specs), and partly because I expect Windows 8 to be released in fall of 2012, and if I'm going to upgrade, I might as well do so sometime after the new OS ships to kill two birds with one stone (three, actually: I plan to migrate to 64bit at the same time).

So my intent to cleanup and tuneup my current computer consists of several steps:

1) Organize and sort all my files currently on the computer.
(Yep, organizing 70GB of files sounds like fun - luckily I already did most of it. It's 70 GB now but was probably 90GB when I started)
2) Install another GB of RAM (bringing me up to... 3GB! I definitely feel like 2007), install a second 350GB harddrive (already arrived from Newegg).
(I also regreased my Videocard's fan, because it seems the lubricant on the fan sleeve bearing keeps evaporating. I first greased it 6-8 months ago, so once or twice a year isn't bad now that I know how to. I really ought to clean out the dust every so often anyway)
3) Reinstall, reformat, and re-partition the machine.
(It was a Vista machine originally, so I'll have to first install Vista (OEM 2007), then use a Windows 7 (Amazon pre-order in 2009) update disc)

I'm very confident that this tuneup will make the machine run smoothly - even just installing the 1GB of RAM (which I tossed in earlier this week) brought a noticeable improvement.

Before I actually do the reinstallation, I'm going to use the opportunity to install a bunch of largish applications I want to test drive; if I don't like them, I simply wont re-install them after I reformat, thus not worrying about their installation/uninstallation leaving artifacts on the machine.


At a distance

Posted by , in Uncategorized, Indie games 08 December 2011 - - - - - - · 926 views
game, review, indie
I'm just stepping in for a moment, to highlight the very fun game called 'At a distance' by Terry Cavanagh, the same guy who made VVVVVV (you should go play that one too, if you haven't already).

At a distance is a blindingly ugly 'retro graphics' game. It's a 3D cooperative game which requires two people playing together helping each other figure out what to do and where to go in the game world. I wont mention what you do in the game, as it kinda ruins it - it's the figuring out what to do that is the entire gameplay of the game. The first 5 minutes were really confusing, but things steadily fell into place as my coop partner and I gained greather understanding of how the game worked.

The game is completely free, though it requires two separate computers that are best if physically side-by-side so you can see each other's screens. However, the game is very simple graphically, and a cheap netbook could probably run it just fine.


Download it from Terry's site here: [At a distance]

We beat the game in about 45 minutes, but it was very enjoyable and just the right size (any longer and my eyes would've killed me).





Recent Entries

Recent Comments

Latest Visitors



PARTNERS