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


  • Content count

  • Joined

  • Last visited

Community Reputation

118 Neutral

About NathanFR

  • Rank

Personal Information

  • Location
  1.   Thanks for pointing me out those resources. I read about the Q3 network model but i did not find anything specific enough to cover my problem.
  2. I'm prototyping an online fast paced multiplayer game for educational purposes. I use a client-server model with the server being authoritative.   I've already implemented the client side prediction based and it works fine. Now i'm working on the entity interpolation, i'm using a simple algorithm:       interpolationTime = currentTime - INTERP_BACK_TIME //for my game 0.1s for INTERP_BACK_TIME     state1, state2 = getTwoInterpolationStates(interpolationTime) //get two states to interpolate between          length = state2.Time - state1.Time     t = 0.0          if (length > 0.0001) t = (interpolationTime - state1.Time) / length          entityPos = state.pos          entityPos.lerp(state2.pos, t)   This algorithm works fine if the server sends only correct states, which is not the case of my server, let me explain why:   The client sends what i call `Actions` to notify the server about what he is doing. For example, if the client press the right key, it will send a new action to the server, something like `MoveAction(1, 0)` to tell the server he is moving right. If the client keep pressing the right key for 5 seconds, the client will send only two actions, `MoveAction(1, 0)` at t = s and `MoveAction(0, 0)` at t = s + 5. I'm testing the whole thing with a ping of 150ms, so the server receive actions 150ms late.   Here is what happens on the server when the client presses the right key for 5 seconds (there is 150ms ping between client and server):    1. `MoveAction(1, 0)` is received at t = s (s is the time on the client)  2. The action starts being processed on the server (the player starts moving to the right until a new action is received)  3. `MoveAction(0, 0)` is received at t = s + 5  4. The server knows at this point that the action (`MoveAction(1, 0)`) has ended and lasted 5 seconds on the client (but on the server it lasted 5 seconds + 150ms since the `MoveAction(0, 0)` is received 150ms late)  5. The player then need to be snapped back to his correct position   The step 4 is actually the one causing me problems for the interpolation. Since the actions are received 150ms late, the player will keep moving right for 150ms on the server (after the action is completed on the client) before being snapped back to his correct position when the action finally arrives. My server sends game snapshots every 20ms so it will potentially sends 7 game snapshots with incorrect player positions.   How should i deal with this scenario? Should i avoid sending this kind of invalid states or should i handle them client side?      
  3. Just go with the best weapon for fighting a zombie hord, the one everyone should choose: a katana. Disclaimer: no seriously it does not fit your simulation requirement but i'd really enjoy fighting zombies with a authentic katana
  4. In conclusion, go with the language you want, the one you feel the most comfortable with and just write a game. As @jbadams said, when you will get a bit experienced at programming, changing language regarding your requirements would be quite [i]easy[/i]. What you want right now is writing games to get experienced in general programming logic and general game development logic, both are language agnostic. Have fun.
  5. Java is bad language for learning programming? Hum... i don't see why it would less good than C# or Python to learn programming. I'm interested to hear your arguments about that. If you don't care about starting learning programming with low level languages to get a better understanding of how memory and system work, go with Java would totally fine and it would even be better than Python. I love Python, i used it for game development with PyGame during a while when i was getting started but i ran quickly in performance issues. Python/PyGame couple is good to start but i don't think it's a serious choice for more ambitious games. Of course Python is user friendly, you can make games super quickly once you are familiar with it and PyGame but you will end up writing C code each time you will need a bit of performance, and trust me, it's annoying. Today i'm considering PyGame as a really slow library but other tools exist, for example, for 3D games, Panda3D seems to be really nice (i only played a bit with the example codes).
  6. @Elu to know if entities are overlapping a given area (e.g in your case it would be the range of your EMP grenade), you will need to proceed [i]all[/i] the entities and see if they are overlapping the area. I put "all" in italic since you will never check ALL the entities (in an efficient collision-detection system, of course you could check each entity against all entity i.e do a brute force but it's not what you want) and that's the goal of the [i]Broad-Phase, [/i]reduce the number of entity too proceed by grabbing only the entities that wil have a chance to actually overlap with your area. A [i]Broad-Phase [/i]can be implemented using an uniform grid, a quad tree, a BSP tree, it all depends of what you want to achieve. [quote]Doing the standard CollDect that you suggested seem to me a little too inefficient, i am wondering if exist some way to say to a crowd of objects "hey anyone that have a toe in this area should do this" without checking for each one of them[/quote][list] [*][i]i am wondering if exist some way to say to a crowd of objects[/i]: [b]it's the Broad-Phase of your collision-detection process[/b] [*][i]without checking for each one of them: [/i][b]programmation is not magical[/b] [img]http://public.gamedev.net//public/style_emoticons/default/smile.png[/img] [/list]
  7. It seems to be a basic [i]collision-detection[/i] problematic. It's a really wide subject and it's really depends on what are your requirements, what do you want to achieve and what tools are you using? Basically , the first part of a collision-detection process is of couse detect if a pair of entities are actually overlapping. But here again it really depends of what you want to achieve (give us more informations about that), there are dozen of ways/algorithms to do it. Generally, this part of the process is divided in two parts: [list] [*]The [i]Broad-Phase. [/i]Here is a great tutorial that expose a way to go: [url="http://www.metanetsoftware.com/technique/tutorialB.html"]http://www.metanetso.../tutorialB.html[/url]. Basically in this phase, your goal is to [b]quickly [/b]find all the entities that would eventually collide with the entity you are currently proceeding. There is no overlap test here. [*]The [i]Narrow-Phase[/i]: Once you know all the entities that would potentially overlap your current entity, you have to do the actual collision test against the current entity and all the potentially overlapping entities. For this part, refer to the Bacterius post and to this tutorial [url="http://www.metanetsoftware.com/technique/tutorialA.html"]http://www.metanetso.../tutorialA.html[/url]. [/list] The algorithm could be something like: [CODE] function collisionDetection(Entity currentEntity) { collidableEntities = doBroadPhase(currentEntity) //collidableEntities here could be a list of potentially overlapping entities foreach ( ce : collidableEntities) { if (doNarrowPhase(currentEntity, ce)) { //the current entity is overlapping this entity //do something } } //and once per frame in your game loop foreach (e : entities) {//entities is here all your entities collisionDetection(e) } } [/CODE]