• 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.

xenobrain

Members
  • Content count

    42
  • Joined

  • Last visited

Community Reputation

706 Good

About xenobrain

  • Rank
    Member

Personal Information

  • Location
    Pahoa, HI
  1. For a homegrown engine, an interesting option worth considering is basing the rendering layer on BGFX: https://github.com/bkaradzic/bgfx   If it's important to use one of the aforementioned APIs for educational purposes then DirectX 11 certainly has the most learning resources.  The API is lower complexity as well.    Alternatively, if you want to try OpenGL, OpenGL ES 2.0 is not a bad place to start.  There probably more/better resources for that these days than ever were for the desktop version.  Plus it's a much smaller API and useful on every platform, including desktop with some very tiny modifications (or none, if using Angle).
  2. I like [url=https://babelua.codeplex.com/]BabeLua[/url] inside Visual Studio, and Sublime Text for quick edits.
  3. Well, you're not going to find an engine/game with all that stuff already implemented, no.  Your best bet for getting something accomplished is to grab an Unreal subscription, and get a good understanding of Blueprints.  I've seen some pretty incredible things done with them, see [url=http://www.solusthegame.com/]Solus[/url] for example to see some of the environmental effects possible. It has a nice graphical AI editor too.   As for X-Ray, you can take a look at it [url=https://github.com/OpenXRay/xray-16]here[/url] to see how it ticks.  It's a *lot* of code.  No wonder S.T.A.L.K.E.R was so long in development!  High educational value perhaps, but not something I would choose to work with.  It's available under an open source noncommercial license if you want to try modding though.
  4. There's little reason for you to go tile based though, unless you really like using tile editors.    Otherwise I would probably generate the map in something like Photoshop and slice it into power of two sized chunks (maybe 1024x1024) then load/unload those on the fly (ridiculously simple solution: store the sequental image file names in an array, can even be fixed size, async load 2-3 tiles in advance into the resource cache, unload one tile behind. Should only take maybe 14mb of memory for loaded chunks).   Tons more freedom and easier content creation.  You can still make it look retro too, if that what you're after.
  5. OpenGL

    I'll qualify this post first by stating that I know very little of OpenGL NG.  That said, I think investing in OpenGL 4.3+ at this time is still a good move.      First, it sounds like GLSL syntax may not change much, we're getting a new standardized intermediate format which is long overdue but your shaders may require little (if any) modification for the new version.   Second, learning how to reduce OpenGL driver overhead means learning about how the hardware works.  This will serve you well regardless of API, and using these techniques you should be able to get performance pretty close to what a lower level API would get you.  Plus you should have the advantage of wider hardware compatibility.   Third, you know that claiming you would need to learn an 800+ page specification is gross exaggeration, right?  There's a ton of stuff you won't need for your application, even in core profile.  Also, I know it looks like there's a lot of functions but remember a ton of those are OpenGL's version of function overloads.  The "real" API isn't that scary.    For my use I have my GL code wrapped up in a (simplified) D3D11-style device/context interface so they look identical to my renderer.  This helps break the API usage into nice bite-sized chunks that are easy to understand.  I'm also using hard-coded shaders to avoid HLSL/GLSL translation issues at the cost of some flexibility.   Finally, I noticed UE4 is basically wrapping IOS 8's low level Metal API in a higher-level manager that makes it behave a bit of more D3D11, which sits just under the RHI, and they're still getting huge performance gains.
  6. Don't start with MMO.  Just don't.  Don't do it.  Don't.   You can do a multiplayer game with non-persistant state pretty easily if you use one of the common game engines, though.  Then try adding a persistant state through save files later (that alone can get a lot trickier than you may think).  And work up from there.   Go with Unity for now.  It has a gazillion free tutorials, some great books, and you can get some nice stuff in the asset store to help you along.  In particular there is a nice (though slightly dated) hack n' slash RPG tutorial out there that may be a nice starting point over here: http://www.burgzergarcade.com/hack-slash-rpg-unity3d-game-engine-tutorial.   Unreal is very interesting as well, and much more beginner-friendly than it used to be.  I still recommend Unity for beginners at the moment however because UE4 is still quite new and doesn't have the mass of tutorials available (though it's on it's way).
  7.   Right, but the last sound card with hardware EFX/EAX acceleration was the X-Fi.  On Creative's newer SoundCore3D-based cards (Recon3D, Z) those effects are software-based.
  8. In other words, "deterministic" vs "nondeterministic".  ie: Chess is deterministic, Yahtzee is not.  It's a difficult balance to strike.    Too little randomness and once you learn a game, and if hypothetically your brain had the computational ability to process all the choices there is only one optimal choice given a set of conditions.  Where's the fun in that?  It only works so long as it remains beyond your brain's capacity ie: Chess vs Tic-Tac-Toe.   Too much randomness if you start feeling like the randomness is all the matters. Your choices don't matter if the hand you were delt was so bad you can't do anything useful with it.  I get that a bit in Magic: The Gathering.  And Candyland, Snakes [Chutes] and Ladders being pure randomness (a Markov chain, actually) leaves you with no choices whatsoever.  No fun in that either (past the age of five!).
  9. OpenGL

    Qt is too heavy for OpenGL work unless you are building an editor or something otherwise very GUI focused.   As mentioned, GLEW is not a GUI library but as it's name suggests an extension loader.  You'll want to use it (or one of these http://www.opengl.org/wiki/OpenGL_Loading_Library) for any desktop platform (Win/Mac/Linux) work, so keep it around.   GLFW is still IMO a little too GLUT-like, that is to say convenient at first restricting in the long run.  That's fine for experimental or demo code though which seems to be what you're doing?   SDL & SFML are similar beasts with SFML having a nice C++ API, a little higher level abstraction with more features and a little less tested with fewer supported platforms vs SDL having a nice C API, being a little thinner abstraction, having a few less features, being more widely tested and supported on more platforms.   I generally recommend SDL as a platform abstraction layer (if not needing drawing functionality) due to better platform support, testing and it's corporate backing, but SFML has a particularly friendly, helpful and engaged community if that's a consideration.
  10. While I have not created installers with it, as a user I'm always happy to install software that's using http://nixstaller.sourceforge.net/.  Works on every distro and can even create native packages for most of them so it plays well with the native package manager!  Also handles dependencies in a slick way, only installing them if needed and putting them into their own directory to avoid conflicts on the host OS.   IMO it's very slick.  Hopefully it's easy to use too
  11. Notice in Mario ( and to a lesser extent Sonic) that levels are usually broken up into a series of specific challenges. i.e.: a section with moving pipes and a gap in between. Avoid the flying enemies. Jump on the platforms moving in a circle. Avoid the crushing stones falling from the ceiling. Segment length varied considerably, but the segments themselves appeared over and over again in different levels with only minor variation. So that's my recommendation--design your challenges in short segments, test each one, and build your levels out of these solid building blocks, rather than trying to do an entire level all at once. Every once in a while a single idea is strong enough to do an entire level around, the forced scrolling levels for instance, but these should be used sparingly. Oddly enough a design is more cohesive with the series of mini challenges utilizing consistent mechanics rather than an overarching single challenge per level using a single unique mechanic per type.
  12. Well there's not a template for a Win32 window with a Direct3D context, no.  You need to create a new Win32 project, link the directx libraries, include the headers, then create a Win32 window (the Win32 template may have done this for you if you ticked the checkbox) and initialize Direct3D (create a device, swap chain, render target view etc...).   Tutorials here: http://code.msdn.microsoft.com/windowsdesktop/Direct3D-Tutorial-Win32-829979ef (If you're going the Win32 route, this is what you want.  Otherwise see my previous link for the Windows Store DirectX tutorials) Good book here: http://www.amazon.com/Introduction-3D-Game-Programming-DirectX/dp/1936420228/ref=sr_1_1?ie=UTF8&qid=1401414711&sr=8-1&keywords=beginning+game+programming+with+directx   Regarding DirectXApp, DirectXApp XAML vs Win32, the DirectXApp Windows Store template create a Windows Store app and fills in the aforementioned boilerplate for you.  If you create an empty Windows Store app then link the libraries, include the headers, then create a window (IFrameworkView implementation),  create a d3ddevice etc.... you'd end up in the same place.  So you never *need* templates, they're just shortcuts.   As for the difference between the regular DirectXApp and the XAML one, the XAML one layers a GUI on top of the Direct3D content, which you can graphically edit in a designer and hook up to your app with event handlers etc...  The normal template figures you're going to draw the GUI yourself, or hook up another, third-party GUI system.   Also, if going the Windows Store route (which I do recommend for starting) definitely check out Visual Studio 3D Starter kit.  It even includes a content pipeline and shader designer.  Great for learning & experimentation.
  13. So, you saw this stuff, right?   http://msdn.microsoft.com/en-US/library/windows/apps/ff476345  <- Programming Guide for Direct3D 11 http://code.msdn.microsoft.com/DirectX-3D-shooting-game-ed8e56f0  <- DirectX 3D Shooting game sample     As Vexal mentioned, Windows Store apps are going to be easier to start with than Win32.   You say you're 18?  Have you taken Trigonometry yet?  That stuff's 100% required if you want to do 3D.    This book http://www.amazon.com/Math-Primer-Graphics-Development-Edition/dp/1568817231/ref=sr_1_1?ie=UTF8&qid=1401393014&sr=8-1&keywords=3d+math+primer is awesome if you do need some help.   You also mention you're using Visual Studio 2013 Ultimate.  I find it unlikely an 18 year old with 1 year of programming experience acquired it legally.  There's nothing in there you need that's not available in Visual Studio Express, so stop pirating!  Or at the very least don't announce it so blatantly.  <southern drawl>Folks 'round here don't take too kindly to the piratin' kind</southern drawl> so you're limiting the amount of help you might get by doing so.
  14. It is a great book.  But if you're planning to use Java, I guess I would say that while reading the book, work with C++/DirectX for a bit then try implementing in Java/OpenGL a bit later, when your comfortable.  I don't think I'd try to map the code into Java straight away.   The level of C++ used in the book should be no issue for a reasonably experienced Java dev,  and learning DirectX before OpenGL isn't a bad thing at all, in fact in my case I didn't "get" OpenGL until I gave up, went the DirectX route and came back.   One of the book's qualities is the level of detail in the implementation.  Most beginner"books tend to just "tell" you a high level overview or oversimplify it to the point of lacking general utility, this book actually "shows" you a lot of the core engine stuff.   Again though, I wouldn't try mapping it straight away.  If you don't want to get your hands dirty in C++, DirectX, Win32 (yuck!) then there are some quality Java books out there particularly regarding Android, and most of the time their content easily portable to desktop platforms.
  15. Could your question be stated as "free to use FPS engine with strong C++ API and Linux support"?   There's a lot of choices for that, honestly.   If free-to-use isn't a hard requirement, then Unreal Engine 4 excels with it's fantastic C++ API and very helpful game (including AI) framework classes.  Linux export is supported, native Linux compilation (and editor) coming soon.