• Announcements

    • khawk

      Download the Game Design and Indie Game Marketing Freebook   07/19/17

      GameDev.net and CRC Press have teamed up to bring a free ebook of content curated from top titles published by CRC Press. The freebook, Practices of Game Design & Indie Game Marketing, includes chapters from The Art of Game Design: A Book of Lenses, A Practical Guide to Indie Game Marketing, and An Architectural Approach to Level Design. The GameDev.net FreeBook is relevant to game designers, developers, and those interested in learning more about the challenges in game development. We know game development can be a tough discipline and business, so we picked several chapters from CRC Press titles that we thought would be of interest to you, the GameDev.net audience, in your journey to design, develop, and market your next game. The free ebook is available through CRC Press by clicking here. The Curated Books The Art of Game Design: A Book of Lenses, Second Edition, by Jesse Schell Presents 100+ sets of questions, or different lenses, for viewing a game’s design, encompassing diverse fields such as psychology, architecture, music, film, software engineering, theme park design, mathematics, anthropology, and more. Written by one of the world's top game designers, this book describes the deepest and most fundamental principles of game design, demonstrating how tactics used in board, card, and athletic games also work in video games. It provides practical instruction on creating world-class games that will be played again and again. View it here. A Practical Guide to Indie Game Marketing, by Joel Dreskin Marketing is an essential but too frequently overlooked or minimized component of the release plan for indie games. A Practical Guide to Indie Game Marketing provides you with the tools needed to build visibility and sell your indie games. With special focus on those developers with small budgets and limited staff and resources, this book is packed with tangible recommendations and techniques that you can put to use immediately. As a seasoned professional of the indie game arena, author Joel Dreskin gives you insight into practical, real-world experiences of marketing numerous successful games and also provides stories of the failures. View it here. An Architectural Approach to Level Design This is one of the first books to integrate architectural and spatial design theory with the field of level design. The book presents architectural techniques and theories for level designers to use in their own work. It connects architecture and level design in different ways that address the practical elements of how designers construct space and the experiential elements of how and why humans interact with this space. Throughout the text, readers learn skills for spatial layout, evoking emotion through gamespaces, and creating better levels through architectural theory. View it here. Learn more and download the ebook by clicking here. Did you know? GameDev.net and CRC Press also recently teamed up to bring GDNet+ Members up to a 20% discount on all CRC Press books. Learn more about this and other benefits here.

Christopher James Jepson

  • Content count

  • Joined

  • Last visited

Community Reputation

229 Neutral

About Christopher James Jepson

  • Rank

Personal Information

  • Location
    Fairfax, VA
  1. Excellent, thank you. I stand corrected and have removed/edited my previous posts. This information helps me a great deal despite the troll like point bashing and the "you don't know what your talking about" responses. I need more than, "I don't know what I'm talking about". That's just a long way of calling someone stupid. Remember, you can be confident and humble at the same time. This site is about a community, and a community is about helping each other. Being confident and cocky looks belligerent, which is why I prefer humility, especially for something so... correctable.  But then again, I'm not the one correcting someone, so it's not my choice and thus, shame on me. Have a good day.
  2.   To insure that the words "copy" and "introspecting" are not being confused with each other, I pose the following question to you: Could you please clarify this, specifically what Blender is referring to as a "standalone"? No assumptions please. Per blender.org: http://archive.blender.org/education-help/faq/gpl-for-artists/index.html#c2128   I'm assuming you are incorrect. However, if you are indeed correct, you'll be helping me a great deal in the long run. Please provide reliable citations to the answer regarding the question I pose to you. Thank you.
  3. Removed/Edited due to errors found in my statement.
  4. Removed/edited due to errors found in my statement. 
  5.   Correct. This is why almost all internships do diagrams and charts rather then pure coding. Conceptual understanding is critical, or you're just coding blindly. It's also an easy way to spot a very obvious bug that could be over looked in development. What saddens me is when people bash charts and diagrams, claiming it to be useless. For some, such things may be a hindrance. But here's my outlook on it: 1 great programmer can not program nearly as good as a 100 moderately good programmers working as a team. While it's critical to be confident, its crucial to identify when confidence is tainted by belligerence and ignorance. I would much rather work with the person that needs the flow chart and communicates well with me than someone who is too good for anyone else.  So yes, communicating to the point of what is needed (typically in a chart or diagram) can be of a invaluable asset for leadership and direction, which means more man power to complete the larger task at hand.
  6. To answer your question, it is best that you become familiar with the SDLC (Software Design Life Cycle) and the AGILE-Scrum process of this cycle, including what stories, sprints and backlogs are.   There is something called the Technical Design Specification. It is a book, created by the designers and in part, the developers of the SDLC. It encompasses just about every diagram you can think of: Use Case UML, High Level Class Diagram UML, Database Design, ERD, Dataflow Diagram - Flow Charts.   Before a single code is worked on, the Technical Design Specification should be completed. The reason is because of the first page of this book, being the contents regarding its Purpose and Description of the Requirements.  In a nut shell, if either the Purpose or the Requirements are breached or not met, then you either have one really passive and generous client or... you can't adequately define your sprints, which results in project failures (and people start losing their jobs and companies start losing a lot of money). All the pages there after the first page, break down what the program should do.  And that breakdown, allows a sprint log to be created, which allows management for the overall project.   As a one man programmer, yes, you can get away with not using this.  As a two or three man programmer, you might be able to get away with not using this. But as the numbers increase, so does the unlikeliness of succession from not using the Technical Design Specification.     Hope this helps.
  7. To understand OOP (Object Oriented Programming), it's likely best to understand what an Object is when referring to programming.   Consider the following:   Scenario #1 You are a car mechanic.  A car is delivered to you, and it requires a tune up. You find that several nuts and bolts are lose on examination. You search for and acquire an adjustable wrench. Using the adjustable wrench, you tighten the nuts and bolts. The result of using the adjustable wrench returns a task completed. Since there are no other tasks associated with this tune up, the tuneup is completed.   Scenario #2 A second car comes in. The car requires a replacement radiator. On examination of the radiator, you determine that an array of tools are required, including an adjustable wrench. You search for and acquire an adjustable wrench. You use the adjustable wrench to loosen bolts. You use other tools to further allow the removal and replacement of the radiator. A new radiator is installed. You use a combination of tools to again mount the radiator. You again use the adjustable wrench to tighten the bolts. The result of using the adjustable wrench returns a completed task (as with the other tools). Since there are no other tasks associated with this radiator replacement, the replacement is completed.   An object seen in the two examples above would be the adjustable wrench.    In programming, a object is essentially a class that gets instantiated, meets a criteria, and can be reused. For proper object creation, it must meet these four requirements: It must support polymorphism. It must support overloading. It should support overriding (for consistency). It should support encapsulation (for security).   Much like the adjustable wrench in the above example, the adjustable wrench was performed on both a tune up and a radiator replacement. It essentially was used to remove and tighten bolts and nuts in two different scenarios.  The nuts and bolts between the two cars were different, but were classified as the same type of property of which an adjustable wrench be used with. Likewise, two different sets of code may require the use of a class for different reasons, but pass a similar type of peropty and require a similar return value. This is essentially polymorphism, because the same object was used for the same reason with a different set or properties in two different scenarios (you had to adjust the wrench size for different size nuts/bolts two separate jobs, but got the job done with one adjustable wrench).   Polymorphism The biggest challenge in OOP is thinking outside of primitives. As novice programmers, we tend to think int, float, double... and the associated values to such. But OOP is both similar and different. An object is a container of values/properties. The easiest way to truly understand an object is to understand a structure in C. You have an entity, and that entity has properties. When you use that entity, you can call one property, a set of properties, or all properties stored. If you want to get more complicated, you can stored objects within objects, and would have to iterate through the first object to access the nested objects, for the values stored in the desired object. Tricky, huh?   To further understand this, I would highly recommend studying data structures.     Overloading Overload is hard to explain without confusing people.  I would recommend researching it. In simplest definition, overloading is when you call the same function/method of a class, pass a different set of parameters. The parameters define which of the identically named function/methods you are calling.   Overriding Overriding is when you are quite literately calling a method of identical name and parameter, but of a child class, which invokes the use of that method over the identical method of a super class.  A clean example of this is when you define a default constructor which is required in instantiating a class (for Java and C#). Another way to look at this is saying you have two classes, class 1, and class 2. You have a function/method called public int GetMe(int i) in both. To get to class 2, you must first instantiate class 1, then using that object, instantiate class 2. But instead of using GetMe(int i) in class 1, you use it in Class 2. You are overriding the GetMe(int i) method of class 1 with the GetMe(int i) method of class 2.   Encapsulation Encapsulation is when you use access modifiers like private, protected, etc to hide variables from super classes, but give access to change such values through methods like setters/getters.   Again, if you truly want to understand OOP, study polymorphism, overloading, overriding and encapsulation. I would also advise studying further into containers and data structures, and learn how to use iterators. You'll never ask this question again if you know these key aspects. Best of luck to you.
  8. Unity

        To help provide guidance: The only time a GPU becomes essentially important is when you are considering cross platform support or are pushing graphics to the very limit of it's hardware capabilities. For example, when tackling code in a Mac/Linux/UNIX environment, OpenGL will be used, over DirectX, Direct3D which is exclusive for Windows. This fundamental difference would decide whether or not it would be safe to go ATI or nVidia alone. When pushing hard on graphic hardware, that'll narrow the choice of the GPU even further. However, for a lesser hardware critical game, it's better to go toward a middle ground, such as an Intel or nVidia simply for the sake of compatibility. Computer animators on the other hand, have a vigorous requirement, but that's a different subject altogether.   Now, while a GPU can be the most important feature for gamers, and are important for programmers, it is not the most important role for developers. In fact, if we had to talk about hardware at such a low level, I would say, in that low level requirement, a CPU and associated BUS on the mother board would hold a greater importance because of the compatibility needs of the compiler. But frankly, even that's not true for a higher level design paradigm because essentially, the OS takes care of almost all of that for you, even on Linux.   To the point at hand: What I would do is focus on something with a strong processor, that has as many threads as you can get, and has a proven track record for reliability. Games are typically designed to be thread dependent. I would suggest an Intel Processor within the i series for the sake of running fast compilations and executions. You want loads of RAM and a fast hard drive because nothing sucks more than a IDE that crawls and crashes. Don't worry too much about HD space though, as you should get in the habit of backing up your data on portable media, a CVS or SVN regularly, all of which should not be on your system to begin with.   For a GPU, I would highly suggest staying away from anything that is ATI simply due to cross compatibility reasons. While nVidia is a wise choice for a GPU brand, adding a reasonably good nVidia GPU along side with a i series CPU on any laptop usually brings the cost fairly high because the i series CPU's have built in graphics support, essentially having 2 GPU's in one system (a luxury or in your case, a feature as a programmer depending on your role and needs).   For more information on nVidia GPU's, I would suggest visiting this site, and narrowing your search down further to what you need: http://en.wikipedia.org/wiki/GeForce   Remember, you want to cross check the GPU you are interested in with any platform you may be interested in focusing on. A simple Google search for a GPU type and a Linux Distribution can bring up a lot of information for you just for developing on Linux alone.   For CPU, I recommend an Intel iSeries.  However, you can review a list of CPU's and get a genuine idea of which one ideally works for you by going here: http://www.cpubenchmark.net/   I don't do game design, but I do play games, and I do develop code in Java. I wanted a cheap laptop that was a good middle ground for all of this. I found that a AMD A8 Quad Core with a ATI Radeon GPU stood on equal ground for gaming to a i3 and some i5's, met my requirements for coding, and dropped the cost by $300. Plus, I got even more than I could have expected. I honestly thought League of Legends wouldn't run on it, but I was proven horrible wrong when it rocked the game.   As for laptop brands, that could be important as well due to driver support and general reliability. In such cases I would suggest a Lenovo, HP or in some cases a Dell. I personally got a Samsung, but my focus is not game development so I can't suggest that.   Unfortunately, I can not give you any recommendations on sound support, as that is way outside my support and interest scopes. Hope this helps, best of luck.
  9.   That is a seriously good question in my opinion, one of which I would like an answer to as well. My programming experience doesn't fall within games, but I am very much interested in knowing if this does or does not work as a suggestion, and why. Skwee seems to know his stuff, and what he's looking for, as well as why. Getting some feed back from him, if not someone who has worked with Unreal Engine would be nice.   Per wiki comments: The current release is Unreal Engine 3, designed for Microsoft's DirectX 9 (for Windows and Xbox 360), DirectX 10 (for Windows Vista) and DirectX 11 (for Windows 7 and later); OpenGL (for OS X, Linux, PlayStation 3, Wii U, and iOS), Android; Stage 3D (for Adobe Flash Player 11 and later); andJavaScript/WebGL (for HTML5). Source: http://en.wikipedia.org/wiki/Unreal_Engine License Proprietary; UDK free for noncommercial us Written in C++ , UnrealScript   EDIT: Whoops, looks like I didn't see their were 2 additional pages full of comments after Godmil's post. Sorry about that.
  10.   Glad to be of some help.     Best practice is to always put code in a separate object (that meaning not in the main class). That however does not necessarily mean it will provide the best result though; that being speed and only speed. An example of jamming stuff up in the main class is if you were creating a POJO (Plain Old Java Object) to substitute a output only BASH script in Linux/UNIX. Remember, the String[] args of the main parameter refer to the arguments taken in at the command prompt when typing in java someJavaMainClass. If let's say you created a POJO that was designed to run a sequence of Linux/UNIX commands using the getRunTime() method of the Runtime class (http://docs.oracle.com/javase/6/docs/api/), it may be practical to do so only in the main class. However, it is actually more efficient to do this in a language designed to work at a lower level of support, such as PERL, C/C++. as you are taking a unnecessary leap into a higher level language with the use of the JVM, which is developed largely in C++. It's like avoiding C++ to use C++, which simply doesn't make any sense and uses more memory in the process.   The rule of thumb is, if you need to instantiate even one object, then you are using Object Oriented Design, and it is best practice to adhere to it. If you're not, then it's kinda fruitless to use Java unless your environmental situation mandates it.     AWT, Swing or Java FX? You should really jump on Java FX if your not currently using it. Java FX will at some point deprecate Swing, and AWT is mostly deprecated already. You should really learn how to use either Swing or Java FX from the source up, but if you ever needed to cheat: Ever hear of Java FX Scenebuilder (http://www.oracle.com/technetwork/java/javafx/tools/index.html).     This is typically a debate also found in C++. Both in C++ and in Java, the answer is the same; reader's simplicity. The moment you are referring to a part of your code as a separate English subject, that subject should be in a different class. For Example, if I was coding a game about cats, dogs, birds, and fish, I would have 6 classes: Main (instantiates cat, dog and bird through animal) Animal (abstract) Cat (extends animal) Dog (extends animal) Bird (extends animal) Fish (extends animal) Methods (otherwise referred to as functions in C++) would refer to the characteristics of a class. Here is an example:   Cat (extends animal) Sound() (makes a unique sound pertaining to the characteristics of the class defined) Move() (moves in a unique way pertaining to the characteristics of the class defined) Eat() (Eats unique food in a unique way to satisfy its appetite and physical needs)   Dog (extends animal) Sound() (makes a unique sound pertaining to the characteristics of the class defined) Move() (moves in a unique way pertaining to the characteristics of the class defined) Eat() (Eats unique food in a unique way to satisfy its appetite and physical needs)   Bird (extends animal) Sound() (makes a unique sound pertaining to the characteristics of the class defined) Move() (moves in a unique way pertaining to the characteristics of the class defined) Eat() (Eats unique food in a unique way to satisfy its appetite and physical needs)   Fish (extends animal) Sound() (makes a unique sound pertaining to the characteristics of the class defined) Move() (moves in a unique way pertaining to the characteristics of the class defined) Eat() (Eats unique food in a unique way to satisfy its appetite and physical needs)   This is essentially important because, let us say that you now needed to consider which animal was a mammal (Dog, Cat), an aves (bird), and a paraphyletic (fish). This would be done using interface as you can extend only once from an abstract. In a more gamer sense, you could see it this way:   You have a mage (aka, wizard). You create an abstract of their AD&D class (necromancer, conjurer, enchanter, etc). However, their sortie of spells depend on an alignment, so you also create an alignments (evil, natural, good). You would abstract the wizard's AD&D class, and interface their alignment. The sortie of spells they use could then be considered based off of both the abstraction and inclusion of their associations (e.g., David, the Evil Necromancer [spells control the undead and unleash disease on helpless saps], John, the Good Necromancer [spells control the undead and allow him to siphon his own life force to heal a helpless sap], Brian, the Evil Wizard [spells that control the weather and use it to devastate the land because helpless saps should just be vaporized]).   Regardless if the project is large or small, if you don't look at it for a year, or someone else looks at it for you, it becomes extremely difficult to understand it quickly.     You are correct.     Their is a way to compromise between what you're trying to do and what Java is designed to do. I would recommend researching Singleton, and practicing on how to develop it and around it. For a small application, it's possible to get away with using a C++ practice in Java, but as projects get bigger, you will need to consider object management.   A Few Notes: Since we are talking about objects and memory:   Since you are creating a GUI: If you create a program that uses String, you are essentially creating an object. Most people know this. However, what most people do not know is every time you change the value of your String object, you are throwing away an object and creating a new String object. To get around this, you can use either StringBuffer (is thread safe) or StringBuilder (is not thread safe) as the object is unchanged when the value changes.   If you set an object to NULL and then declare System.gc(), you are likely to have that object destroyed much quicker than if it was just simply left as is. This is again, a good reason to use the try/catch/finally exception handling. In finally, you could create a clean up procedure, and later declare a System.gc() to schedule the destruction of that object you cleaned up. An example of where this could be used in your code is as follows:   After the last use of Random rand, use: rand = null; System.gc(); Over all, I see you doing a great job. For the size of your program, I'll assume it's fine enough to remain in the main class. I just don't want to see you get into the bad habit of using object evasion over object management. Hope this helps further. Also, thanks for the feedback.
  11.   I am happy to see you have found a strong interest in learning a new language.     What JTippetts says is true. However, I feel it is still important to learn the C programming language as it gives you an appreciation, if not a better understanding of what goes on in higher level languages like C++ and C#.  Also, by understanding the differences between a low, mid and high level language, you have the needed awareness of what to be cautious about in programming high level applications (such as some games). C++ is, in my opinion, one of the most powerful languages around. This is essentially because C++ can be used in a C like low level paradigms or in a C# like high level paradigm. But with that power, comes the dangerous practice of mixing a low level and high level paradigm in a single application. This should be avoided. Not knowing the difference could get you in a lot of trouble, which recaps why I feel you should learn C.   Also, remember that since C++ is backwards compatible to C, you could simply install a C++ compiler, its libraries, and an IDE to support it while still learn C through use of it.     What Servant of the Lord refers to is also correct and vitally important. As novice programmers, many people tend to not realize the vital importance of understanding the complexity behind copy right laws, and where copy left laws associate. It is important to understand the clear definition of what GNU means, and how it applies to anything you create. For more reading, see here: http://en.wikipedia.org/wiki/GNU_General_Public_License   Now, all methods of setting up your IDE listed from Servant of the Lord and JTippetts are correct and are very useful. But both methods will also come with the proprietary development of Windows programming (some exceptions with Qt and Cygwin). Assuming that you one day wish to expand to other operating systems, another option for you is to use the Eclipse IDE. For right now, I would avoid using it in Windows as it requires some greater knowledge in configuring it with a C++ compiler. However, when you do feel ready, it can be setup to use MinGW, Cygwin, Linux/UNIX or the same compiler used by Visual Studios! And because Eclipse is not GNU licensed, you could also program on a Mac and still sell the game!   If you want to get a feel for how it works in a different OS environment, you could do it by simply following the below steps:   1.Download/Install the Oracle VM here: https://www.virtualbox.org/ 2.Download CentOS here: http://www.centos.org/ 3.Run Oracle VM and install the CentOS in a virtual environment. Here's a tutorial on installing CentOS: http://www.tecmint.com/centos-6-3-step-by-step-installation-guide-with-screenshots/ NOTE: When installing CentOS, choose the prepackage option (step 19 on the tutorial) of a Software Development Workstation. 4.Run the OS, Log in, and start the Eclipse IDE (The Linux C/C++ compiler is already configured for you). 5.Follow the steps normally taken in creating a C++ project, and start coding away.  NOTE: 3D programming may require additional Linux RPMs and may not run properly in a VM environment. Additionally, 3D programming frameworks associating to DirectX and Direct3D will not work on Linux without WINE bindings. Finally, when you develop using Eclipse on a Mac, you'll be using a different compiler, which may require a manual configuration in the Eclipse IDE.   To make full use of my recommendation, learn how to use preprocessor directives, and make your code very efficient for cross-platform execution (an advantage of learning C). The preprocessor directives can judgement whether to use Direct3D or OpenGL based on which compiler is detected. In essence, a solid application will only need to be compiled multiple times between different compilers generating multiple executables. Thus, all you would do is create a script that decides which executable to run based on which operating system is detected and you have a cross-platform package with multiple executable that were compiled with absolutely no coding differences.
  12.   Nice code Mepis. The first thing I see where you could improve on is putting this code in a class, not in a main method.     the mole is correct. But this is also more the reason why it should not be in main though. Their is something called the default constructor, which the JVM (Java Virtual Machine) creates for you when instantiating classes.  It is used to assign all primitives with a 0, 0.0 or null value. However, if you needed to override or overload the default constructor, you can. An example would be like this: File 1. public class Main{ public static void main(String[] args){ ClassExample ce1; = new ClassExample(); // Uses default constructor. int[][] maze = new int[40][40]; ClassExample ce2; = new ClassExample(0, 0, 0, 0, maze); // Overloads default constructor. } } File 2 import java.util.Random; public class ClassExample { // Your variables should look like this. private final int ROWSIZE = 40; private final int COLUMNSIZE = 40; private int[][] maze; private int randX; private int randY; private int choke; private int checkSurroundings; /*If you want to define a default value on creation of the class, you then want to override the default constructor like this. */ public ClassExample() { randX = 0; randY = 0; choke = 0; checkSurroundings = 0; maze = new int[ROWSIZE][COLUMNSIZE]; // Will create instantiate on instantiate. } /*This will allow you to do the same thing as above but also allow you to override the default values assigned in the default constructor for reasons relating to making the code scalable. Remember, if you want to overload the default constructor, you need to override the default constructor first! */ public ClassExample(int x, int y, int choke, int cS, int[][] maze){ this.randX = x; this.randY = y; this.choke = choke; this.checkSurroundings = cS; this.maze = maze; } // <-- Put your logic methods here. // Setters/Getters for all private class primatives. public int[][] getMaze() { return maze; } public void setMaze(int[][] maze) { this.maze = maze; } public int getRandX() { return randX; } public void setRandX(int randX) { this.randX = randX; } public int getRandY() { return randY; } public void setRandY(int randY) { this.randY = randY; } public int getChoke() { return choke; } public void setChoke(int choke) { this.choke = choke; } public int getCheckSurroundings() { return checkSurroundings; } public void setCheckSurroundings(int checkSurroundings) { this.checkSurroundings = checkSurroundings; } // Getters only for final primatives public int getROWSIZE() { return ROWSIZE; } public int getCOLUMNSIZE() { return COLUMNSIZE; } } Also, remember that static means global. You must assign a static value to any variable called outside of a method in the main class because of runtime limitations. This is useful for some reasons, but not in the way you are using it. If you create those variables in a sub class to main, they do not need to be static as seen in the example above.   Additionally, remember that you can use getters for final (constant) variables too, you just can't use setters because they are final.   Another good reason for using a subclass like this for the sake of being able to instantiate it multiple times.  For example, if you had a game with two players, and it was a race to see who could get through the maze faster, but one of the players was very experienced with your game, you may need to create a handicap for the more experienced. In this instance, you may want to overload the default constructor to make the maze size larger, thus creating two maze objects; one for each player with the larger maze going to the experienced player. Additionally, if you have to reuse the values stored in the instantiated objects, the values could remain the same since you could overload the default constructor. Or, if you needed to reset their values, you could also do this by instantiating with the default constructor. And finally, because the primitives are not static, their's less chance of exploitation. The above example are key points of overloading, overriding, encapsulation and polymorphism.   One more note: Try to get in the habit of using try/catch/finally. Here's an example: public boolean Game(){ try { // <-- Put your logic here. // Example if only if(true){ System.out.println(maze[500][500]); // Will create a null exception! } return true; } catch (Exception e) { // Will attempt to catch exception and keep application running. e.printStackTrace(); // Will tell you what happened. return false; } } The key reasons for using try/catch/finally is it keeps the application running even if their is an exception, and it also makes your life easier to track down the bug. This greatly improves on quality assurance. Hope this helps.  Please feel free to add on to this in any way needed, or correct anywhere I am wrong.  Thanks!
  13.   LOL I was curious about that.  It's cool. Thanks much for letting me know. At least you got what you needed, so I'm happy about that.
  14. Hello everyone. Thank you for taking the time and interest in reading this thread. I've broken down the opening topic of this thread for easier reading. Before I get started, let me give you a very brief background about myself.   About me: I'm a Java Application Developer. I focus primarily on the business logic of a multitier (client-server) architecture:   http://en.wikipedia.org/wiki/Multitier_architecture http://en.wikipedia.org/wiki/Business_logic     About what I'm doing which is related to this thread: I'm gearing up to make a cross platform Instant Messenger Client & Server. This is purely for educational reasons. I am confident I have what I need to commit myself for this project on a Windows/Linux/Mac environment.     Where I could use your help: I would like (preferably from someone who's already done it) to give me an idea of what I will need to successfully create a client to server application on an Android mobile device. There are some requirements, so in finer clarity: The APIs must be scalable with JOGL for later projects. The APIs must be easily integrated with Eclipse IDE (no Netbeans IDE please). I want to avoid Game Engines like jMonkey as these remove the education value of what I'm aiming for. I would like something that's standard for businesses, like Java ME for starters. I need to know the business model just like mine listed above for multitier architecture.   Conclusion: If anyone could answer these questions, you would be doing me a great service, and saving me hours if not days of doing the research myself. If I'm going to recreate the wheal, I really want to confine it in the development, and not the designing aspect of SDLC. Many thanks in advance.   Oh, and please... while I have respect for other languages, please do not make comments about using a different language. Thank you!     NOTE: I am not in any rush for an answer. With that said, if someone is trying to research the design aspect of this request, and than implement it to verify and for their own learning before answering this inquiry, than kudos to you.  
  15. Glad I could help. I used to work on voluntary game projects at Hard Light Productions found here: http://www.hard-light.net/. They made ready use of the donated Freespace 2 game engine from Volitation: http://en.wikipedia.org/wiki/Volition,_Inc. I wasn't a programmer back then but what I often saw were really great idea's crush or projects completed but not nearly to the expectation it was set to because of poor control over the project. Management over a project is just as important, if not by far more important than the programmer him/her self.   The one group who really achieved much at Hard Light Productions was the Wing Commander Group backed by Tolwyn. Their game could be found here: http://www.wcsaga.com/. You can quite literately feel the work and professionalism in their product. Tolwyn made full use of project management. He was very organized. He had a bug tracker, a story script, he broken down teams and assigned them small tasks. It may have taken him well over 4 years, but he produced a really top notch game because he was very well disciplined with the development model he was using.