Jump to content

  • Log In with Google      Sign In   
  • Create Account

slayemin

Member Since 23 Feb 2001
Offline Last Active Yesterday, 09:44 PM

#5201374 Being approached by a publisher

Posted by on 02 January 2015 - 01:58 PM

First and foremost, you don't want to get ripped off. You don't want to sign a contract which signs your rights away, gives up creative control, or gives up your intellectual property rights. So, be careful for any terms which may do so without appropriate compensation.

If they're paying you money to make this game you've prototyped, you should also keep in mind that you may not want to work on this game as a solo developer. You may find that a few months down the road, you need help in areas that you don't have a good skill set in, or you just have too much work for one person. This means hiring someone to work with you and that usually equals paying wages and that means you have to have a place for them to work, and that comes with some slight facilities costs. Whatever happens, you'll want more money than you personally need due to unforeseen cost overruns or future expenses.

 

That being said, since you're dealing with someone who you've never done business with before, you can't necessarily trust them. Especially as an international relationship. The simple response is to agree to some contracts, but what happens if one party breaks the terms of the agreement? How are the contract terms enforced in international law setting? It would be easy for someone like you to take the money and just disappear without a trace and there's very little legal recourse. Or, you could sign some agreement where you deliver a finished game and expect to get paid for it, but never do. I think, in a scenario like this, what would probably work best is some sort of milestone payment system, where you and the publisher agree on a set of milestones for the project, and you get paid each time you reach one. And, to get things started, you'd need some seed money both to start working and as a sign of good faith and commitment on behalf of the publisher.

Keep in mind, every publisher is treating your product as a risky investment. They want to make money off of it to recoup their up front costs, so you're going to get pressure to monetize the game. You'll have to explain to them how you plan to make money off of this, and if you don't, they'll plan it for you (and you may not like their monetization strategy).

Anyways, take my words with a heavy grain of salt. I've never worked with a publisher myself since I'm independent. But these are things I'd look out for.




#5201065 First Game Guidance

Posted by on 31 December 2014 - 05:19 PM

Welcome!

Have you read the FAQ on the right? I know its easy to miss, but its got lots of valuable information for people just getting started.

 

I have two recommendations for you:
1) keep your first games SUPER simple. For a complete beginner, making a game like pong would be quite challenging but also a good introduction to making games. To accomplish that task, you have to understand the game loop, how to handle user input, how to display scores, how to trigger victory and loss conditions, how to write AI and where that fits in, how to move things on the screen in real time, etc. You can even accomplish this with a black background and white rectangles, no need for graphics yet.

 

2) The best resource for getting started is a solid book on beginning game programming. I recommend something on C# with XNA (ignore that its deprecated). Sure, books cost money, but who cares? You get super high quality content which has been vetted and compiled into a coherent series of chapters. Its rare to get that by reading online articles. If you really resist buying a good book, the second best starting place is probably over on Riemers XNA tutorials. He also publishes a book, which is probably better than his online articles.

 

Again, start super simple and buy a book. Every great project has humble beginnings. The first step is always to get something to show up on the screen. Good luck!




#5199044 Where should I start learning game development?

Posted by on 18 December 2014 - 08:47 PM

You can also check out Unreal Engine 4. They have a special student license so it will help you with learning without paying.

 

UE4 comes with a bunch of starter content and a bunch of documentation and tutorials, so you can literally place a textured cube into a game world in less than a minute. There are some nice video tutorials which go through how to build a house, step by step, and wire it up with blueprints to get some interactivity going (ie, push a button to open a door). No code required!




#5198911 Is Java a good Language for Games?

Posted by on 18 December 2014 - 03:20 AM

Short answer: Yes.

 

Java is a tool (like a paint brush). A tool is only as good as the person using it.

 

Bad artists will make bad art, regardless of how good their tools are.

 

Good artists will make good art, regardless of how bad their tools are.

 

Sensible artists will make amazing art with the best tools they can get their hands on, but their tools won't limit what they can and can't do.

 

I mean, Rollercoaster tycoon was written in Assembly. That's insane. But the developers still made a great game. There's tons of free game engines out there and people still make terrible games with them.




#5198910 Need Guidance and Advice

Posted by on 18 December 2014 - 03:15 AM

1) Personally, if I was in your position, I'd keep my job as a financial adviser. You can do your job and make lots of money and just play games in your free time. Making games is entirely different from playing them and not nearly as financially rewarding.

2) If you want to get into game development anyways and lift the curtain behind it all, here is what I'd recommend:

IF you want to be a programmer:
Get good at mathematics. Get proficient at everything up to and including Calculus and linear algebra. The cartesian coordinate system will be something you use every day. Start super simple. Pace yourself. And most importantly, be dedicated. Don't give up when things get hard and frustrating. Push hard to overcome all of the challenges you'll be faced with, because there will be many. There are tons of resources online to help you get started, so the internet is your oyster...

IF you want to be an artist:
Get good at drawing. Draw till your hands hurt and your room is full of art. Don't just fill your room with trash, try to improve. Get familiar with the digital tools used by most artists (Photoshop, Maya, Mudbox, X Normal, etc). Get smart with materials and shaders.

 

IF you want to be a producer:
Read up on PMP and start figuring out how you can put what you read into practice. Learn about the unforgiving iron triangle of money, features and time and how you need to balance it all out.

 

IF you want to be a game designer:
Hah. Good luck. Everyone wants to be a game designer. But, legitimately, you're going to have to design a lot of games and prove you know what you're doing. A designer will have to work quite hard to figure out how to balance the game, come up with interesting game mechanics, design levels, etc. It's harder than the mystique suggests.

 

If you want to be a game tester:
Its a pretty good foot in the door job with less technical skills required (just write well and be analytical). It's not a fun job though. You play the same god damned game over and over again for 8+ hours a day, doing the same things and trying to break the game and then documenting how you broke it and what happened. It gets tedious quickly and you have to test games you may have no interest in ever playing (unicorn adventures III anyone?).




#5198906 My Game Plan

Posted by on 18 December 2014 - 02:53 AM

C# is a good starting point.

 

Keep in mind, you're going to be learning two things at the same time:
1) How to write C# code
2) How to write a program using logical instructions

The two are not the same. You can accomplish #2 in any language, but the means you're using in this case is via C#. So, when you're struggling to make something work, you need to be careful to ask the question: "Is this a language syntax issue or an issue with trying to figure out how to correctly write instructions sequentially?"

 

So, with #2, you can actually accomplish this by writing your instructions in english using pseudo-code, such as "Add two to the value X." or "Turn the space ship by 45 degrees and then apply the thruster."

Why is this important? Because you're going to eventually get to a point where you say, "How do I write a for loop in language XYZ which iterates over ten items?". The end result is the same (logically speaking) but implemented differently depending on which language you are implementing it in. So, "programming" is a language independent, abstract discipline, in which you get good at it through lots of indirect practice.

When you're just getting starting with making *any* type of program, you want to start SUPER small and simple. Start with printing the classic "Hello World" onto the screen. Then create a "Guess my number" type game, where the computer picks a random number and you have a fixed number of tries to guess it. Then, create tic-tac-toe. Then try creating something more complicated, like break out. Graduate to tetris. Then maybe pac man or some other old school atari games. Stick to 2D until you get really familiar with the game development process. When / if you eventually shift to 3D, your literally adding an additional dimension and the amount of work grows in an order of magnitude and the complexity increases equally (ie, you can figure out what someone is clicking on very easily in 2D, but in 3D you need to shoot a ray out into the game world and intersect it with a 3D object).

When things get difficult, I find what helps the best is to try to write out what I'm doing in pseudo-code and work out the solution to the problem on a hand-held whiteboard. If I can't solve the problem outside of code, what hope would I have of solving the problem with the additional complexity of code?

Also: If you *really* want to get good at writing code, get good at mathematics! Get good at trigonometry, linear algebra, algebra, etc. You'll be relying on the strength of your math skills every day. You don't want your math skills to be your lowest common denominator which limits your capabilities. Getting good at math should also directly help you get better at writing and conceptualizing good code. for example, if you know the quadratic equation and you want to write a function to solve it, you already know what the objective is and what the answers should be when you test them, and you should be able to break the algorithm down into its component steps and verify that the values are the expected values. This is essentially what all programming boils down to: Do the steps make sense? Do the values match the expected values? Does the final product match the expected product? Now, put it all together to build a program which appears to do magic!
 




#5198899 0 experience in programming and game development

Posted by on 18 December 2014 - 02:23 AM

Well, im finishing school this year and i am leaned to begin a career as a game dev, i really like animations, modeling, cinematics, etc. but i never tried making any of these, also i have 0 experience in programming, i love playing games and thats why im choosing to start in this trade.

 

Please guys, advise me and give me tips to begin learning before starting university with 0 experience.

 

Thanks!

 

P.S: im bad at drawing sad.png

If you like animations, modeling and cinematics, and that's what you want to get into, then you need to get good at producing those types of work to a high degree of quality. That means you need to get good at producing art. The fact that you aren't good at *drawing* is concerning, though not a show stopping problem. Get better at it through practice!

Game programming has very little to do with the artistic side. The closest you'll get in programming to artwork is becoming a graphics programmmer, and most of that is more science related than art related (such as figuring out how light interacts with surfaces of different materials and shapes and distilling that into mathematical formulas).

My best recommendation is to pick up the book titled "Game Plan". It gives you a detailed synopsis of all of the various roles necessary to building and shipping a game. The roles aren't just limited to art and programming, there are tons of other roles and needs which need to be filled by people who know what they're doing! Check out the book and find the role which aligns most closely with your interests and skill set, then get better at that.

One thing to keep in the back of your mind: Video games are software. Game development is a subset of software development. So, getting good at various parts of the software development process will make you valuable as a game developer, and when you are tired of making games (which may happen based on industry statistics), you can move on to other sectors of the software development industry. You have a fall back plan for financial and career security!




#5192738 Corrupting of the view if far from world center

Posted by on 13 November 2014 - 04:48 PM

Yep, its almost certainly caused by floating point precision errors. The farther from 0 a value gets, the less precise a float gets. I think the step size between float values increases exponentially as you get further and further away from zero.

 

With your airplane model, what ends up happening is that the calculated vertex positions hit on a value which is between the ranges of a float, so the float just truncates the value? (or it might round?). ie, 9.00000000001 would fall between the value 9.0 and 9.0000000000234, and just become 9.0. The visual effect is that the airplane model verticies get mushed together and the end result is something that looks like a bad low-poly version of the plane.

 

What's the fix?

A) try to keep your floating point values near 0 because the step values are very close

B) use doubles to get more precision on higher numbers (Though you're just kicking the problem farther down the road)

 

Techniques & options:

A) keep the camera at 0 (as mentioned above) and move the world around the camera, easiest solution with least complexity

B) At certain fixed distances from 0, translate everything in the world to recenter on zero (ie, at 10k, shift everything by 10k to get back to 0). This can get tricky and cause bugs.

C) Just use smaller worlds in your design

D) Scale the world down




#5191387 XML vs Database

Posted by on 05 November 2014 - 01:24 PM

If you need multiple users to connect to and access data which may change at any time, use a database.

 

If you need to protect the integrity of your data and have a way to update it across the board for all users, use a database.

 

If you don't care about players tampering with the game data stored on their local disk (ie, it's their fault if they break the game), then you can just store the config/data files on their local machines and load it into memory when the game loads.

 

 

When it comes to storing the data, whether you use XML or a SQL table, you'll need to figure out some way to map the stored data to your internal class variables. I can't really tell you how to do this since it's very dependent on how you want to manage your data. Generally, what I do is create two methods in each class which needs to be persistent, and each method is responsible for saving and loading its state to some location.

Class MyGameObject
{
    int myValue = 5;

    public void SaveObject(string path)
    {
         //saves myValue to disk by writing "5" to the file in the given path
         SaveValueToFile(path, myValue);
    }

    public void LoadObject(string path) //<-- could also be a constructor arg
    {
        //loads the value from disk and sets it
        int diskValue = GetValueFromFile(path);
        
        //sanity check on the loaded value
        if(diskValue < 100 && diskValue >= 0)
            myValue = diskValue;
        else
            myValue = 5;
    }

}



#5191381 Resource management

Posted by on 05 November 2014 - 01:04 PM

I implemented pretty much what you're describing.

* It tries to keep a reference counter on each resource. When it reaches zero, I have the option to unload the resource from memory. I'm not really using this feature yet because I haven't needed to.

* I don't actually load an asset into memory until it's actually needed. I just store the disk path to the asset. When an object calls the "get" method for the asset, it will pull it from disk and put it into memory if its not in memory yet.

* Users of the class interact with their assets by giving them a name. They can get an object by name. The integer ID is used on the backend, but is very unfriendly for people. I ended up asking "okay, what texture do I get when I ask for ID# 23? I have no idea!"

* My asset database is used as a singleton within another class, though there's no reason you can't have multiple asset managers.
* I use separate content datastructures for each asset type, so one for textures, one for models, one for effects, one for fonts, etc. There's no reason assets can't use the same name so long as they're different asset types. This may make it easier for the user to manage their bundled assets, ie, "GetTexture("Peasant"), GetModel("Peasant"), GetEffect("Peasant")"

 

 

Here is my complete implementation class (~950 lines of code):

#define DEBUG_MODE

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;

namespace EricsLib.ContentDatabases
{
    /// <summary>
    /// This is the asset database for storing and managing all assets being used within the game.
    /// </summary>
    /// <example>
    /// Usage:
    /// AssetDB m_db = new AssetDB();
    /// m_db.AddTexture("Textures\\Grass", "Grass");        //insertion
    /// Texture2D grassTexture = m_db.GetTexture("Grass");  //retrieval
    /// m_db.ReleaseTexture("Grass");                       //release handle
    /// </example>
    public class AssetDB
    {
        /*Implemented feature: We keep an internal database for asset tracking. If the asset hasn't been used for a long time or the asset is no longer being
         used by any objects, we can release the main memory of the asset. If the asset is requested later on, we can load it back into memory. This feature would
         allow us to have a smaller memory footprint.
         
         Optional Feature: We could use multi-threading to load external assets into and out of memory so that the main game doesn't have to wait for an asset to be loaded.
         */
        #region Fields
        struct _Texture
        {
            public Texture2D asset;
            public int refCount;
            public string path;
            public bool loaded;

            /// <summary>
            /// Creates a new texture object
            /// </summary>
            /// <param name="AssetPath">The relative content path to the asset</param>
            public _Texture(string AssetPath)
            {
                asset = null;
                refCount = 0;
                loaded = false;
                path = AssetPath;
            }

            /// <summary>
            /// This unloads the asset but keeps the path in case we want to reload it later.
            /// </summary>
            public void Unload()
            {
                loaded = false;
                asset = null;
                refCount = 0;
            }

            /// <summary>
            /// This loads the asset into main memory by using the given content manager.
            /// </summary>
            /// <param name="content">the content manager to use for loading the asset</param>
            public void Load(ContentManager content)
            {
                asset = content.Load<Texture2D>(path);
                loaded = true;
                refCount = 0;   //just because we've loaded the asset doesn't guarantee that its being used...
            }
        }

        struct _Model
        {
            public Model asset;
            public int refCount;
            public string path;
            public bool loaded;
            public BoundingBox boundingBox;
            public BoundingSphere boundingSphere;

            public _Model(string Path)
            {
                asset = null;
                refCount = 0;
                path = Path;
                loaded = false;
                boundingBox = new BoundingBox();
                boundingSphere = new BoundingSphere();
            }

            public void Unload()
            {
                loaded = false;
                asset = null;
                refCount = 0;
            }

            public void Load(ContentManager content)
            {
                asset = content.Load<Model>(path);
                loaded = true;
                refCount = 0;
                CalculateBounds();
            }

            public BoundingBox CalculateBounds()
            {
                if (loaded)
                {
                    List<Vector3> vertList = new List<Vector3>();
                    foreach (ModelMesh mm in asset.Meshes)
                    {
                        foreach (ModelMeshPart mmp in mm.MeshParts)
                        {
                            VertexBuffer vb = mmp.VertexBuffer;
                            Vector3[] data = new Vector3[vb.VertexCount];
                            vb.GetData<Vector3>(data);
                            vertList.AddRange(data);
                        }
                    }
                    boundingBox = BoundingBox.CreateFromPoints(vertList);
                    boundingSphere = BoundingSphere.CreateFromPoints(vertList);
                }

                return boundingBox;
            }
        }

        struct _Effect
        {
            public Effect asset;
            public int refCount;
            public string path;
            public bool loaded;

            public _Effect(string AssetPath)
            {
                asset = null;
                refCount = 0;
                path = AssetPath;
                loaded = false;
            }

            public void Unload()
            {
                loaded = false;
                asset = null;
                refCount = 0;
            }

            public void Load(ContentManager content)
            {
                asset = content.Load<Effect>(path);
                asset.Name = path;
                loaded = true;
                refCount = 0;
            }
        }

        struct _Font
        {
            public SpriteFont asset;
            public int refCount;
            public string path;
            public bool loaded;

            public _Font(string AssetPath)
            {
                asset = null;
                refCount = 0;
                path = AssetPath;
                loaded = false;
            }

            public void Unload()
            {
                loaded = false;
                asset = null;
                refCount = 0;
            }

            public void Load(ContentManager content)
            {
                asset = content.Load<SpriteFont>(path);
                loaded = true;
                refCount = 0;
            }
        }

        /* The readonly keyword is different from the const keyword. A const field can only be initialized at the declaration of the field. 
         * A readonly field can be initialized either at the declaration or in a constructor. Therefore, readonly fields can have different 
         * values depending on the constructor used. Also, while a const field is a compile-time constant, the readonly field can be used 
         * for runtime constants.
         * See: http://msdn.microsoft.com/en-us/library/acdd6hb7.aspx
         */

        //The data is keyed by integers
        readonly Dictionary<int, _Texture> m_textureDB;
        readonly Dictionary<int, _Model> m_modelDB;
        readonly Dictionary<int, _Effect> m_effectDB;
        readonly Dictionary<int, _Font> m_fontDB;

        

        //these are lookup keys which can be used to find the internal key 
        Dictionary<string, int> m_textureLookup;
        Dictionary<string, int> m_modelLookup;
        Dictionary<string, int> m_effectLookup;
        Dictionary<string, int> m_fontLookup;

        int m_textureIndex;
        int m_modelIndex;
        int m_effectIndex;
        int m_fontIndex;

        ContentManager m_content;
        #endregion

        #region Initialization

        public AssetDB(ContentManager content)
        {
            m_content = content;

            m_textureIndex = 0;
            m_modelIndex = 0;
            m_effectIndex = 0;
            m_fontIndex = 0;

            m_textureDB = new Dictionary<int, _Texture>();
            m_modelDB = new Dictionary<int, _Model>();
            m_effectDB = new Dictionary<int, _Effect>();
            m_fontDB = new Dictionary<int, _Font>();

            m_textureLookup = new Dictionary<string, int>();
            m_modelLookup = new Dictionary<string, int>();
            m_effectLookup = new Dictionary<string, int>();
            m_fontLookup = new Dictionary<string, int>();

            CreateSolidTexture();
            CreateDebugTexture();
        }
        #endregion

        #region Texture Interface

        /// <summary>
        /// There's no guarantee that your user will know to add a solid texture, so let's create it dynamically.
        /// </summary>
        private void CreateSolidTexture()
        {
            Texture2D solid = new Texture2D(BaseSettings.Graphics, 128, 128);
            int size = 128*128;
            Color[] col = new Color[size];

            for (int a = 0; a < size; a++)
                col[a] = Color.White;

            solid.SetData<Color>(col);

            if (!m_textureLookup.ContainsKey("Solid"))
            {
                _Texture tmp = new _Texture();
                tmp.asset = solid;
                tmp.loaded = true;
                tmp.refCount = 1;

                m_textureLookup.Add("Solid", m_textureIndex);
                m_textureDB.Add(m_textureIndex, tmp);
                m_textureIndex++;
            }
        }

        private void CreateDebugTexture()
        {
            //Rather than throwing exceptions when a texture doesn't exist, we just present this one!

            const int SIZE = 256;
            Texture2D solid = new Texture2D(BaseSettings.Graphics, SIZE, SIZE);
            int size = SIZE * SIZE;
            Color[] col = new Color[size];


            for (int y = 0; y < SIZE; y++)
            {
                int fy = (int)(y / 32f) % 2;
                for (int x = 0; x < SIZE; x++)
                {
                    int fx = (int)(x / 32f) % 2;
                    if (fy == 0)
                    {
                        if (fx == 0)
                            col[y * SIZE + x] = Color.Gray;
                        else
                            col[y * SIZE + x] = Color.Magenta;
                    }
                    else
                    {
                        if (fx == 0)
                            col[y * SIZE + x] = Color.Magenta;
                        else
                            col[y * SIZE + x] = Color.Gray;
                    }
                }
            }

            solid.SetData<Color>(col);

            if (!m_textureLookup.ContainsKey("Invalid"))
            {
                _Texture tmp = new _Texture();
                tmp.asset = solid;
                tmp.loaded = true;
                tmp.refCount = 1;

                m_textureLookup.Add("Invalid", m_textureIndex);
                m_textureDB.Add(m_textureIndex, tmp);
                m_textureIndex++;
            }
        }

        public bool HasTexture(string Handle)
        {
            return m_textureLookup.ContainsKey(Handle);
        }

        public bool HasTexture(int TextureID)
        {
            return m_textureDB.ContainsKey(TextureID);
        }

        /// <summary>
        /// Gets the requested texture from the database, provided you've added a texture with the given handle
        /// </summary>
        /// <param name="AssetName">The handle to the texture</param>
        /// <returns>The requested texture</returns>
        /// <remarks>This will load the texture from disk into main memory if it has not been loaded already.</remarks>
        public Texture2D GetTexture(string AssetName)
        {
            if (m_textureLookup.ContainsKey(AssetName))
            {
                return GetTexture(m_textureLookup[AssetName]);
            }
            else
            {
                #if DEBUG_MODE
                throw new Exception("GetTexture(): " + AssetName + " key doesn't exist in the database");
                #else
                return GetTexture(m_textureLookup["Invalid"]);
                #endif
            }
        }

        public Rectangle GetTextureSize(string AssetName)
        {
            if (m_textureLookup.ContainsKey(AssetName))
            {
                Texture2D tmp = GetTexture(m_textureLookup[AssetName]);
                return new Rectangle(0, 0, tmp.Width, tmp.Height);
            }
            else
            {
#if DEBUG_MODE
                throw new Exception("GetTextureSize(): " + AssetName + " key doesn't exist in the database.");
#else
                Texture2D tmp = GetTexture(m_textureLookup["Invalid"]);
                return new Rectangle(0, 0, tmp.Width, tmp.Height);
#endif
            }
                
        }


        /// <summary>
        /// Gets the texture.
        /// </summary>
        /// <param name="TextureID">The texture identifier.</param>
        /// <returns>Texture2D.</returns>
        /// <exception cref="System.Exception">GetTexture():  + TextureID +  key doesn't exist in the database</exception>
        public Texture2D GetTexture(int TextureID)
        {
            if (m_textureDB.ContainsKey(TextureID))
            {
                _Texture tmp = m_textureDB[TextureID];

                if (tmp.loaded)
                    return m_textureDB[TextureID].asset;
                else
                {
                    tmp.Load(m_content);
                    tmp.refCount += 1;
                    m_textureDB[TextureID] = tmp;
                    return tmp.asset;
                }
            }
            else
            {
#if DEBUG_MODE
                throw new Exception("GetTexture(): " + TextureID + " key doesn't exist in the database");
#else
                return GetTexture(m_textureLookup["Invalid"]);
#endif
            }
                
        }

        /// <summary>
        /// Gets the texture identifier.
        /// </summary>
        /// <param name="AssetName">Name of the asset.</param>
        /// <returns>The ID used to reference the texture.</returns>
        /// <remarks>Returns -1 if the asset doesn't exist.</remarks>
        public int GetTextureID(string AssetName)
        {
            if (m_textureLookup.ContainsKey(AssetName))
                return m_textureLookup[AssetName];
            else
                return m_textureLookup["Invalid"];
        }

        /// <summary>
        /// Inserts a texture object into the database.
        /// </summary>
        /// <param name="AssetPath">The path to the texture asset within your content project</param>
        /// <param name="AssetName">The name you want to use to access your texture</param>
        public void AddTexture(string AssetPath, string AssetName)
        {
            if (!m_textureLookup.ContainsKey(AssetName))
            {
                _Texture tmp = new _Texture(AssetPath);
                
                m_textureLookup.Add(AssetName, m_textureIndex);
                m_textureDB.Add(m_textureIndex, tmp);
                m_textureIndex++;
            }
            else
            {
                //the texture already exists, so just increment its reference counter
                _Texture tmp = m_textureDB[m_textureLookup[AssetName]];
                tmp.refCount += 1;
                m_textureDB[m_textureLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Inserts a texture object into the database
        /// </summary>
        /// <param name="AssetPath">The path within your content project to the texture asset. Note: The filename will be the asset name.</param>
        public void AddTexture(string AssetPath)
        {
            string[] tmp = AssetPath.Split('\\');
            string AssetName = tmp[tmp.Length];

            AddTexture(AssetPath, AssetName);
        }

        /// <summary>
        /// Call this whenever an object no longer needs access to this shared asset.
        /// When this texture is no longer used by any objects, the texture data is released from main memory.
        /// However, the meta data still exists. If you need to access the texture again, the texture will be
        /// reloaded from disk.
        /// </summary>
        /// <param name="AssetName">The asset lookup key</param>
        public void ReleaseTexture(string AssetName)
        {
            if (m_textureLookup.ContainsKey(AssetName))
            {
                _Texture tmp = m_textureDB[m_textureLookup[AssetName]];

                if (tmp.refCount <= 1)
                {
                    tmp.asset = null;
                }
                else
                    tmp.refCount -= 1;

                m_textureDB[m_textureLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Completely deletes a texture from the asset database.
        /// If this is run on a shared asset, you're gonna have problems.
        /// </summary>
        /// <param name="AssetName">A handle to the texture name</param>
        public void DeleteTexture(string AssetName)
        {
            if (m_textureLookup.ContainsKey(AssetName))
            {
                m_textureDB.Remove(m_textureLookup[AssetName]);
                m_textureLookup.Remove(AssetName);
            }
        }

        #endregion

        #region Model Interface
        public bool HasModel(string AssetName)
        {
            return m_modelLookup.ContainsKey(AssetName);
        }

        public bool HasModel(int AssetID)
        {
            return m_modelDB.ContainsKey(AssetID);
        }

        /// <summary>
        /// Gets the model.
        /// </summary>
        /// <param name="AssetID">The asset identifier.</param>
        /// <returns>Model.</returns>
        /// <exception cref="System.Exception">Key doesn't exist in the database</exception>
        public Model GetModel(int AssetID)
        {
            if (m_modelDB.ContainsKey(AssetID))
            {
                _Model tmp = m_modelDB[AssetID];

                if (tmp.loaded)
                    return m_modelDB[AssetID].asset;
                else
                {
                    tmp.Load(m_content);
                    tmp.refCount += 1;
                    m_modelDB[AssetID] = tmp;
                    return tmp.asset;
                }
            }
            else
                throw new Exception("Key doesn't exist in the database");
        }

        /// <summary>
        /// Gets the model.
        /// </summary>
        /// <param name="AssetName">Name of the asset.</param>
        /// <returns>Model.</returns>
        /// <exception cref="System.Exception">Model doesn't exist in the database</exception>
        public Model GetModel(string AssetName)
        {
            if (m_modelLookup.ContainsKey(AssetName))
            {
                return GetModel(m_modelLookup[AssetName]);
            }
            else
                throw new Exception("GetModel(): " + AssetName + " Model doesn't exist in the database");
        }

        public Model GetModel(string AssetName, ref BoundingBox boundingBox, ref BoundingSphere boundingSphere)
        {
            if (m_modelLookup.ContainsKey(AssetName))
            {
                int ID = m_modelLookup[AssetName];
                if (m_modelDB.ContainsKey(ID))
                {
                    _Model tmp = m_modelDB[ID];

                    if (tmp.loaded)
                    {
                        boundingBox = m_modelDB[ID].boundingBox;
                        boundingSphere = m_modelDB[ID].boundingSphere;
                        return m_modelDB[ID].asset;
                    }
                    else
                    {
                        tmp.Load(m_content);
                        tmp.refCount += 1;
                        m_modelDB[ID] = tmp;

                        boundingBox = m_modelDB[ID].boundingBox;
                        boundingSphere = m_modelDB[ID].boundingSphere;

                        return tmp.asset;
                    }
                }
                else
                {
                    throw new Exception("GetModel(): " + AssetName + " Model doesn't exist in the database");
                }
            }
            else
                throw new Exception("GetModel(): " + AssetName + " Model doesn't exist in the database");
        }

        public void AddModel(string AssetPath, string AssetName)
        {
            if (!m_modelLookup.ContainsKey(AssetName))
            {
                _Model tmp = new _Model(AssetPath);

                m_modelLookup.Add(AssetName, m_modelIndex);
                m_modelDB.Add(m_modelIndex, tmp);
                m_modelIndex++;
            }
            else
            {
                //the texture already exists, so just increment its reference counter
                _Model tmp = m_modelDB[m_modelLookup[AssetName]];
                tmp.refCount += 1;
                m_modelDB[m_modelLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Changes the model associated with an asset name
        /// </summary>
        /// <param name="AssetName">The name you want to use to reference the asset</param>
        /// <param name="model">The model object you want to change</param>
        public void UpdateModel(string AssetName, Model model)
        {
            if (m_modelLookup.ContainsKey(AssetName))
            {
                _Model tmp = m_modelDB[m_modelLookup[AssetName]];
                tmp.asset = model;
                m_modelDB[m_modelLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Call this whenever an object no longer needs access to this shared asset.
        /// When this asset is no longer used by any objects, it is deleted.
        /// </summary>
        /// <param name="AssetName">The asset lookup key</param>
        public void ReleaseModel(string AssetName)
        {
            if (m_modelLookup.ContainsKey(AssetName))
            {
                _Model tmp = m_modelDB[m_modelLookup[AssetName]];

                if (tmp.refCount <= 1)
                {
                    tmp.asset = null;
                }
                else
                    tmp.refCount -= 1;

                m_modelDB[m_modelLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Completely deletes a model from the asset database.
        /// If this is run on a shared asset, you're gonna have problems.
        /// </summary>
        /// <param name="AssetName">A handle to the model name</param>
        public void DeleteModel(string AssetName)
        {
            if (m_modelLookup.ContainsKey(AssetName))
            {
                m_modelDB.Remove(m_modelLookup[AssetName]);
                m_modelLookup.Remove(AssetName);
            }
        }
        #endregion

        #region Effect Interface

        /// <summary>
        /// Determines whether the effect database has the effect.
        /// </summary>
        /// <param name="AssetID">The asset identifier.</param>
        /// <returns><c>true</c> if the specified asset identifier has effect; otherwise, <c>false</c>.</returns>
        public bool HasEffect(int AssetID)
        {
            return m_effectDB.ContainsKey(AssetID);
        }

        /// <summary>
        /// Determines whether the effect database has the effect.
        /// </summary>
        /// <param name="AssetName">Name of the asset.</param>
        public bool HasEffect(string AssetName)
        {
            return m_effectLookup.ContainsKey(AssetName);
        }

        /// <summary>
        /// Gets an effect by the asset ID
        /// </summary>
        /// <param name="AssetID">The asset identifier.</param>
        /// <returns>Effect.</returns>
        /// <exception cref="System.Exception">Key doesn't exist in the database</exception>
        public Effect GetEffect(int AssetID)
        {
            if (m_effectDB.ContainsKey(AssetID))
            {
                _Effect tmp = m_effectDB[AssetID];

                if (tmp.loaded)
                    return m_effectDB[AssetID].asset;
                else
                {
                    tmp.Load(m_content);
                    tmp.refCount += 1;
                    m_effectDB[AssetID] = tmp;
                    return tmp.asset;
                }
            }
            else
                throw new Exception("Key doesn't exist in the database");
        }

        /// <summary>
        /// Gets the requested asset from the database, provided you've added a asset with the given handle
        /// </summary>
        /// <param name="AssetName">The handle to the asset</param>
        /// <returns>The requested asset</returns>
        /// <remarks>This will load the asset into main memory if it has not been loaded.</remarks>
        public Effect GetEffect(string AssetName)
        {
            if (m_effectLookup.ContainsKey(AssetName))
            {
                return GetEffect(m_effectLookup[AssetName]);
            }
            else
                throw new Exception("Key doesn't exist in the database");
        }

        /// <summary>
        /// Inserts a asset object into the database.
        /// </summary>
        /// <param name="AssetPath">The path to the asset asset within your content project</param>
        /// <param name="AssetName">The name you want to use to access your asset</param>
        public void AddEffect(string AssetPath, string AssetName)
        {
            if (!m_effectLookup.ContainsKey(AssetName))
            {
                _Effect tmp = new _Effect(AssetPath);
                m_effectLookup.Add(AssetName, m_effectIndex);
                m_effectDB.Add(m_effectIndex, tmp);
                m_effectIndex++;
            }
            else
            {
                _Effect tmp = m_effectDB[m_effectLookup[AssetName]];
                tmp.refCount += 1;
                m_effectDB[m_effectLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Call this whenever an object no longer needs access to this shared asset.
        /// When this asset is no longer used by any objects, it is released from main memory.
        /// </summary>
        /// <param name="Handle">The asset lookup key</param>
        public void ReleaseEffect(string AssetName)
        {
            if (m_effectLookup.ContainsKey(AssetName))
            {
                _Effect tmp = m_effectDB[m_effectLookup[AssetName]];

                if (tmp.refCount <= 1)
                {
                    tmp.asset = null;
                }
                else
                {
                    tmp.refCount -= 1;
                }

                m_effectDB[m_effectLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Completely deletes a asset from the asset database.
        /// If this is run on a shared asset, you're gonna have problems.
        /// </summary>
        /// <param name="AssetName">A handle to the asset name</param>
        public void DeleteEffect(string AssetName)
        {
            if (m_effectLookup.ContainsKey(AssetName))
            {
                m_effectDB.Remove(m_effectLookup[AssetName]);
                m_effectLookup.Remove(AssetName);
            }
        }
        #endregion

        #region Font Interface

        public bool HasFont(string AssetName)
        {
            return m_fontLookup.ContainsKey(AssetName);
        }

        public bool HasFont(int FontID)
        {
            return m_fontDB.ContainsKey(FontID);
        }

        public int GetFontID(string AssetName)
        {
            if (m_fontLookup.ContainsKey(AssetName))
                return m_fontLookup[AssetName];
            return -1;
        }

        /// <summary>
        /// Gets the requested asset from the database, provided you've added a asset with the given handle
        /// </summary>
        /// <param name="AssetName">The handle to the asset</param>
        /// <returns>The requested asset</returns>
        /// <remarks>This will load the asset into main memory if it has not been loaded.</remarks>
        public SpriteFont GetFont(string AssetName)
        {
            if (m_fontLookup.ContainsKey(AssetName))
            {
                return GetFont(m_fontLookup[AssetName]);
            }
            else
                throw new Exception("Key doesn't exist in the database");
        }

        public SpriteFont GetFont(int FontID)
        {
            if (m_fontDB.ContainsKey(FontID))
            {
                _Font tmp = m_fontDB[FontID];

                if (tmp.loaded)
                    return m_fontDB[FontID].asset;
                else
                {
                    tmp.Load(m_content);
                    tmp.refCount += 1;
                    m_fontDB[FontID] = tmp;
                    return tmp.asset;
                }
            }
            else
                return null;
        }

        /// <summary>
        /// Inserts a asset object into the database.
        /// </summary>
        /// <param name="AssetPath">The path to the asset asset within your content project</param>
        /// <param name="AssetName">The name you want to use to access your asset</param>
        public void AddFont(string AssetPath, string AssetName)
        {
            if (!m_fontLookup.ContainsKey(AssetName))
            {
                _Font tmp = new _Font(AssetPath);

                m_fontLookup.Add(AssetName, m_fontIndex);
                m_fontDB.Add(m_fontIndex, tmp);
                m_fontIndex++;
            }
            else
            {
                _Font tmp = m_fontDB[m_fontLookup[AssetName]];
                tmp.refCount += 1;
                m_fontDB[m_fontLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Call this whenever an object no longer needs access to this shared asset.
        /// When this asset is no longer used by any objects, it is released from main memory.
        /// </summary>
        /// <param name="AssetName">The asset lookup key</param>
        public void ReleaseFont(string AssetName)
        {
            if (m_fontLookup.ContainsKey(AssetName))
            {
                _Font tmp = m_fontDB[m_fontLookup[AssetName]];

                if (tmp.refCount <= 1)
                {
                    tmp.asset = null;
                }
                else
                    tmp.refCount -= 1;

                m_fontDB[m_fontLookup[AssetName]] = tmp;
            }
        }

        /// <summary>
        /// Completely deletes a asset from the asset database.
        /// If this is run on a shared asset, you're gonna have problems.
        /// </summary>
        /// <param name="AssetName">A handle to the asset name</param>
        public void DeleteFont(string AssetName)
        {
            if (m_fontLookup.ContainsKey(AssetName))
            {

                m_fontDB.Remove(m_fontLookup[AssetName]);
                m_fontLookup.Remove(AssetName);
            }
        }
        #endregion

        /// <summary>
        /// This removes all of the contents of all asset databases.
        /// </summary>
        public void UnloadContent()
        {
            m_effectDB.Clear();
            m_modelDB.Clear();
            m_textureDB.Clear();
            m_fontDB.Clear();

            m_fontLookup.Clear();
            m_textureLookup.Clear();
            m_modelLookup.Clear();
            m_effectLookup.Clear();

            m_textureIndex = 0;
            m_fontIndex = 0;
            m_modelIndex = 0;
            m_effectIndex = 0;
        }
    }
}




#5188957 When to Recruit

Posted by on 24 October 2014 - 12:46 PM

If he's talking about getting people to work on the project for free, though, these things become much more complicated.

Yes, I agree. Free labor is cheap, but you get what you pay for. I think volunteer projects are great for learning new things and getting experience, but it's excruciatingly difficult to seriously build a game which you want to release based on free labor. I personally would never attempt it or join a volunteer project. That's not to say it can't work though. I met a team of developers upstairs in our building who are all working together for free on an HTML5 MMO (top down shooter). Each of them are living off of personal savings from prior jobs and have been slaving away on this project for almost two years. One of them has until next summer until his bank account runs dry, so you can guess what kind of stress and pressure they're under. So, I suppose it's worth noting that "free" labor is never free for everyone -- bills and living expenses don't stop.

Game design needs to be done from day 1.

 
Only as little as possible to avoid severe creative differences.
 
Nobody wants to work for free on somebody else's game design.  It's much more useful to motivate people by giving them input in the design itself, so it's not "my game", it's "our game", which is a kind of creative reward that has value in itself even without pay.
 
You have to narrow the game design down enough to avoid a complete lack of direction, feature creep, or conflicts between team members.  Such as:  one only likes JRPGs, the other only likes FPS - how do you resolve this?  You don't.  You only recruit one of them based on their having similar interests in line with the overall goal.
 
Narrow it down only just enough, but leave it open so contributors can feel like it's their game.  Achieving that balance in itself is something of an art.

I disagree and still stand by my original claim.

Imagine you're brought on as an artist onto a project and are told by someone, who doesn't really know what they want, to make the art for their game. You have no idea what they're trying to build and it could change at a moments notice. A detailed game design is something solid to stand on and something to work off of. It tells you exactly what needs to be built and how it should all work together with other parts of the game. Without it, it's like you're standing on a constantly shifting sand dune which changes form with the winds. When you have to build concrete assets, it's excellent to have as much requirements definition as possible. Naturally, the game designer can't detail out every single nuanced detail, so the *creative* part for an artist is in the actual creative production of the asset. The look, feel, character, style, etc.

If you think the artist is going to be annoyed by a lack of definition, just imagine how much more annoyed a programmer would be (speaking as a programmer myself). I WILL not write up a complete game system if I don't know exactly how it needs to work. There isn't any "figure it out as you go". I also happen to design my own game, but I haven't designed all software I've built. There is nothing more sexy to me as a programmer than an air tight design. There's no thinking required, just implement it to the spec! There is no confusion. You know what needs to be built. It's very refreshing to work on projects with clear definition.

One thing you do allude to, which is critical, is "stakeholder buy-in". You don't need to give everyone on the team creative control / input on the game design. Chances are actually really good that most people are actually not very good game designers. It's actually *really hard* to do correctly. A programmer is an expert at writing code. An artist is an expert at art. A producer is supposed to be an expert at project management. A writer is an expert at writing. Game designers are experts at building game systems. You wouldn't want your artist writing code, or your programmer creating art, so why would you have either of them doing game design? That's not their specialty, and not the only way they have creative input into the production of a game.

Art and style guides needs to be done from day 1.

Where volunteer projects are concerned, that's almost impossible.  People will come and go from week to week, maybe only contribute a couple sketches, or one sprite.  Things are unfortunately very unlikely to match.  
 
And most artists who will work for free are both unwilling and unable to follow a strict style guide.  
 
The rare and magical exception to this is FAN games, which are ripping off a very popular IP that the artists want to copy.
For example, some Zelda fan games have gone pretty far in getting various artists to work together to make consistent assets.  They are also more motivated by fandom.
However, this is also illegal.
 
For programming, it's a little easier for somebody to drop in and contribute a function or two.
 
In the case of artists, you may either have to learn to accept inconsistency, or bite the bullet and pay for art.
 
If you're really lucky, you may find a half decent artist who will contribute to the project in a big way for free, but you'll have to pay them in spades in terms of letting them reign as king over game design and story in order to get that kind of investment.  You'd basically just be finding an artist to work for to make his or her game idea.  And even then, they may still flake off one by one, and have to be replaced, completely gutting all of the game's story and art for a new artist to move in.  
 
Keep it simple, and make sure all the art for the game can be finished in a few weeks by one artist; that will maximize your chances of making it work.

Yes, this is bad. What you describe is exactly what you want to avoid in a serious project. Pick any well produced game and really look at the art style in it. It's consistent. The color palettes are intentionally chosen to create an intended feeling / atmosphere. Think of Skyrim, how they have a bit of a saturated color palette and pretty realistic character models and environments. Now, imagine what Skyrim would have looked like if they had 30+ artists come in, each with their very own unique interpretations on what the game should look like. Some would go for a my stylized approach, others go for hyper-realistic, some go for cartoonish, etc. In a vacuum, each art asset would look good, but when you put them all into the same universe together, you can't convince the player that the game world has consistency and you break the suspension of disbelief, which causes a loss of player immersion (which some mods break).

As for programming, it's equally problematic to have people pop in and write up a function or two and disappear. As a programmer, you *have* to be familiar with the code base / framework you're working within. That costs time for us to get familiar with it (ramp up time). If a programmer doesn't spend time getting familiar with what they're working with, they run a huge risk of breaking something or writing code which has already been done.

Anyways, I guess my whole point here is that people are super important to the success of a game project. In some jobs, people can be treated like interchangeable components -- not in game development! The ramp-up time for a person to really get into a project and become an expert is long, and you can't ever carelessly throw away your most valuable resource (staff) through people mismanagement. If you're going to be serious about building a game and releasing it commercially, you can't afford to screw up the building of your team. If you're just working on a school project or hobby project, recruit away!


#5188799 When to Recruit

Posted by on 23 October 2014 - 01:31 PM

Depends on what you're recruiting for and what the work load is. You'll want to recruit different skill sets at different phases of the project.

 

Game design needs to be done from day 1.

Art and style guides needs to be done from day 1.

Programming can be done when 50% of the design has been figured out, though there's no harm in starting early.

Business planning needs to be done before the project even starts.

Marketing can be done when the project is about 90% complete (keep in mind, the last 10% takes the longest)

Writers can be brought in roughly around 50%-60% production phase (my guess).
Testing needs to be done when you've got something playable, but the testing work load ramps up as the project nears completion. You can probably get away with not having dedicated testers for the first half of a project. Keep in mind though, issues not found through testing snowball in the sheer amount of effort required to fix them. Finding and fixing problems early can save you TONS of time and money -- fixing hypothetical bug A at day of introduction + 2 costs a programmer 2 hours of work, which translates to $40 * 2 = $80. Fixing bug A at day of introduction + 200 costs a programmer 30 hours of work (due to refactoring all dependent systems), which translates to $40 * 30 = $1200.

When do you need to hire someone? When you have too much work built up for one person to handle or when you can't do the work yourself.

IF you have a lot of work, something someone can spend 40 hours/week doing, then you want to hire an employee.

IF you have a bit of piecemeal work, consider contracting it out instead.

Quick note on this: Contractors are generally more expensive per hour than employees, but will save you money if you don't have a lot of consistent work. You don't want to pay employees to sit around doing nothing. Employees on the other hand, give you consistency and continuity which you don't really get with contractors / freelancers. You generally don't want to contract out stuff which has a lot of stylistic variety, such as artwork.

IF you don't want to pay someone to work for you, be prepared to have them quit on you at any moment. Unpaid people have very little incentive other than their own morale / personal interests to stick around. If your making an unpaid person fill a vital role in your project, you're taking on a huge risk in terms of project management.

IF you want to build a geographically remote team of unpaid people, good luck. Not only may members drop off the project at any moment, you will also have huge communication challenges. You've got people all over the world with different time zones, languages, schedules, and cultural backgrounds. Project management and coordination of effort will be a nightmare. You're essentially operating a free open source project, where you should expect people to pop in and tinker a bit and disappear. Don't expect a lot of progress, or for the progress to go in the direction you want, to your level of satisfaction.




#5188393 Starting Slow

Posted by on 21 October 2014 - 02:52 PM

Start with Tic-tac-toe. It's pretty much the game version of "hello world". It'll get you familiar with building for a mobile platform and you won't get stuck in some game design / programming problem BS. If you can't do tic-tac-toe on the phone, you need to increase your mobile dev technical chops -- building anything more complicated than that is just a recipe for failure and disappointment. Once you've got that handled and know how the mobile development workflow works, you can build more complicated projects.




#5187257 what is the correct way to move object along direction

Posted by on 15 October 2014 - 04:46 PM

You can also get a direction vector from an angle:

//theta is a float value between 0->2pi
dirX = speed * cos(theta);
dirY = speed * sin(theta);

So, movement in a direction is pretty simple:

Position.X += dirX;
Position.Y += dirY;

Then you can wire up some input controls to change the direction and speed.




#5186218 Your thoughts on me hiring a game developer/studio

Posted by on 10 October 2014 - 12:16 PM

I avoided the word "hire" because he'll need to feel like this is as much his project he's interested in doing.



So you're not going to pay someone to work for you?!

No, no no. I get what you're trying to say, but this is a really bad move. If you go through the effort and trouble to find that perfect fit for your project and team, you want to lock that person down so that they stay on the project/team! The best way to do this is to take care of them by satisfying their interests, which include getting paid well, regularly, and on time. This is business 101. You need this programmer to be a stakeholder in your project, and if you aren't a stakeholder invested in them, they aren't going to be a stakeholder invested in you. They'll jump ship as soon as something else comes along which satisfies their interests / desires more than you do. This would be a catastrophe and spell doom for your project since its such a large setback. It's hard to bounce back from. So, don't make the foolish mistake of letting it happen in the first place. Hire people.
 

My ideas are just ideas for him to see whether he wants to be interested in doing it and pretty much making it his own, with the input of my ideas as well

I'm a programmer and design my own games. This is a huge red flag. I underestimated the difficulty of good game design, and understand it takes a lot of effort to do it right. If *you* are going to be the game designer, then you need to be beyond stellar and work harder than anyone else on the team, and spell out in precise, exact detail how every minute aspect of the game is going to work together. The fact that you want to do some vague hand waving and essentially tell the programmer to fill in the gaps with their own ideas, screams the fact that you don't know exactly what you want. There's nothing more frustrating than to spend a ton of effort writing code to implement something which ends up changing completely or getting scrapped on the whims of an uncertain and constantly shifting design. If you're expecting the programmer to take control on the direction of this project, you reduce yourself to a niggling background voice which needs to be appeased while the programmer works on his own ideas of what should be built. Warning: Programmers aren't necessarily good designers!!!
 

I tell them to make a site like this site here, and if they cannot, then I regard them as failing to meet client's expectations.


This is not necessarily the right conclusion to make. Just because a developer fails to "build a site" doesn't mean that the developer can't do the job and is thus incompetent. No project exists in a vacuum. The project can be doomed before it even begins due to a failure in any number of things which lead up to the project and its management. I strongly recommend that you familiarize yourself with the software development life cycle. Whether you're building websites, video games, or applications, it's all the same process.
Just to refresh your memory on the lead up to constructing software, you have the following phases:
-1. Visioning step - What would be awesome to do?
0. Feasibility assessment - Can the vision actually be done within the limitations?
1. Requirements gathering - What *must* the software do? Does it meet the vision? Is it feasible?
2. Design - How will the software work to satisfy the requirements? Is it feasible? does it satisfy the vision?
3. Construction - build the damned thing! write the code! create the assets! make it come to life! Does it meet the design? Does it meet the requirements? Can it even work with the technical limitations / constraints?

Notice how each phase of the process depends on the phases preceding it? If any of the steps leading up to the construction phase are shit, it doesn't matter how good the programmer may be, the project is going to fail. The only way a shit project can be saved is if the programmer realizes he got set up for failure and goes through and redoes the work proceeding the work he's supposed to be doing. The right move to do when this happens is to just abandon the project/client and move onto working for/with someone who actually knows what the hell they're doing (some more unscrupulous devs will just string the client along and suck their money dry to get a steady paycheck). Sure, the shit client will bad mouth the programmer for being incompetent/incapable, but what does the programmer care? They've got better people to work for than to concern themselves with what bad clients have to say about them.
 

Yea, maybe that could be more my role, as I'm already an investor for two other companies. I feel maybe being an investor for this one also could be a possibility. But for this one, I have that itch of wanting to have that perfect game I've always wanted to play be realized. Alot of games out there may have 90% of what I'm looking for, and they are all very great games, just that I have that itch to make it 100% so if I can't find it out there already, then only other option is to try to make it. Investing, I'm always going to be doing even after I die.

I'm also an investor (95% stocks). I have also invested in my own indie game studio and put my money where my mouth is. My investment is more than just throwing money at a project/company and hoping for success, it's also a very deeply personal investment of my own time, commitment, and 100% energies. I'm totally invested in myself, and it's a do-or-die situation. With every investment, someone somewhere down the money stream needs to stand up and make use of the financial resources they have been granted to further the goal of the project/organization. The worst way to 'invest' in this sense is to throw money at a new studio/project with a half-assed game design and non-commitaly hiring some shammy programmer to make it happen -- you need to be the leader in the trenches, bringing your troops to victory by being the point man leading the charge. If you aren't/can't, your ROI will be -100%. Even if you have $0 financially invested, you can still be heavily invested in the success of a project. If you aren't 100% invested in a project/company in every way, you can't be the leader who asks others to invest 100%.






PARTNERS