Advertisement Jump to content
  • Advertisement

irreversible

Member
  • Content Count

    1963
  • Joined

  • Last visited

Community Reputation

2878 Excellent

2 Followers

About irreversible

  • Rank
    Crossbones+

Personal Information

  • Role
    Programmer
  • Interests
    Programming

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. irreversible

    How to make Polygon Colliders for Sprites

    For simple cases what you're looking for is convex hull generation. For more complex cases (eg concave/compund hulls) your best bet is to do it manually and/or chop the source image up and generate convex hulls for each section. Splitting an image up like this intelligently is a non-trivial problem and would likely need to be tweaked by hand anyway. If what you want are optimal hulls, then you need to run full analysis on the image, generate simple polygons (including hole/island data), triangulate the result and then merge the triangles to get convex shapes. For this you'll need a good library, which I can't really suggest right off the bat. Writing this stuff is hard. Writing a convex hull generator should be pretty easy, though (just consider each pixel as a point in the cloud) :)
  2. irreversible

    What's is the best story game you've played?

    I wouldn't go so far as to say the gameplay was bad. It was just... there. I personally didn't find it repetitive either (then again I don't really play modern shooters so my bar isn't so much low as it just doesn't really exist). If anything, I would say it was shallow potentially on purpose to avoid you being distracted from the story too much. It's an interesting point of discussion and I haven't read anything any of the devs have said about the production phase, so it could really be either. For me, personally, the "meh"-ness of the gameplay generated a certain urgency of wanting to see more of the story as opposed to overly enjoying the shootouts. Again, I recall most of the shooting actually being okay and there being only a handful of of instances where I felt the game was unfair. Then again, I play Quake on Nightmare and Unreal on Unreal, so punishment isn't new to me (not to say these games are too punishing in the first place). As such, in my case, the sense of urgency to move on only further seems to stem from the fact that the story made me want to not challenge myself as much, but rather just experience it (which is why I suggested not playing it on Hard in my post). Speaking of shooters, I'd like to throw two more titles in here: Deus Ex and The Thing. The latter I REALLY want to replay as it reminded of Carpenter's film to a somewhat uncomfortable degree (even if I don't remember so much about the story). That being said, it's surprisingly non-trivial to come by unless you're willing to pirate it. The prior probably speaks for itself. While I don't think these two titles embody the greatest stories ever told, I do think that they demonstrate that a game is more than the sum of its parts and can be a truly exhilarating experience even if one (or sometimes more) parts are not at their prime.
  3. irreversible

    Documenting efficiently

    Mine's not really capable of handling full-blown C++ at this time. If you're not opposed to sharing yours along with a sample project, I wouldn't mind trying it out
  4. I'm what you might consider a "casual prosumer" when it comes to commenting. I comment important stuff, but only if the code isn't written in a self-explanatory way. Which is why I've also adapted a really simple and descriptive naming scheme and done away with any and all notation systems. That being said, there are occasions where I want to either document a whole system of code or provide a summarized walk-through on a per-function basis. This is where I find myself in a frustrating spot since none of the solutions on the market seem to be quite for what I want. So I figured I'd list things I want to achieve and what I want to avoid in hopes that I'm either not familiar with something or perhaps am simply not configuring stuff properly. I'm willing to pay for a good solution. The dream wish list of things I want and need: full documentation generation, a la Doxygen a non-verbose (lightweight) and non-monolithic style non-XML style markup (eg the way Natural Docs does it, not Doxygen) no block comments in documentation (I use block comments extensively to manage code flow during development) partial documentation (I really don't want to provide an explanation for each and every argument and return type) a concise format with a clear layout, so no \param and \return shenanigans automatically filled in for me no duplication of obvious information (eg the function name) in the comments inline documentation no explicit flow direction (in/out/inout) in documentation, but rather taken directly from code - I already provide this information! proper macro expansion I've tried Atomineer and it doesn't work for me at all. So far the Doxygen style in general is pure bloat in my eyes since it becomes bothersome to maintain as soon as you make something as simple as a name change. Allow me to demonstrate by example: Here's what a typical function in my code might look like: _BASEMETHOD ECBool OnInitialize( IN MODIFY ResourceType& object, IN const char* type, OPTIONAL IN ISignalable* signalable = nullptr, OPTIONAL IN uint32 flags = 0) const { ... } _BASEMETHOD expands to 'virtual'. Atomineer doesn't handle this too well since it is adamant about placing the documentation below that line unless I take care to actually generate it on the word _BASEMETHOD itself. Here's the default "trite" Atomineer generates: /// Executes the initialize action /// /// \author yomama /// \date 12-Dec-18 /// /// \tparam ResourceType Type of the resource type. /// \param [in,out] {IN MODIFY ResourceType&} object The object. /// \param {IN const char*} type The type. /// \param [in,out] {OPTIONAL IN ISignalable*} signalable (Optional) If non-null, the signalable. /// \param {OPTIONAL IN uint32} custHandlerFlags The customer handler flags. /// /// \return {ECBool} An ECBool. This is close to being the least useful way to say what the function actually does. None of the auto-generated stuff makes sense, because it's already obvious from the names. In addition, data flow direction is assumed, not extrapolated from markup that already exists in the code (notice the in/out of signalable while certain conditions might force me to accept a non-const pointer, which is nevertheless never written to). The return type is obvious. Even the general description is obvious to the point of being insulting to the reader. Of course this is all meant to be manually edited. However, the problem is that: 1) on the one hand, writing this stuff from scratch using this style of markup is time consuming and annoyingly verbose. 2) auto-generating the template and editing is also time consuming, because again, it's way too verbose. Here's what an ideal way of commenting the above function looks to me: /// Fill \p object with data and notify \p signalable once the procedure is complete. Runs asynchronously. _BASEMETHOD ECBool OnInitialize( IN MODIFY ResourceType& object, IN const char* type, OPTIONAL IN ISignalable* signalable = nullptr, /// Type-specific flags. See documentation of related resource type for possible values. OPTIONAL IN uint32 flags = 0) const { ... } That's it. This should be enough to generate feature-complete documentation when the docs are finally built. AND it's easy to read inline while writing code. A major hurdle is that while I actually kinda like the Natural Docs style, to the best of my knowledge it's only able to generate documentation for things that have actually been manually documented. Facepalm. So no automatic full documentation of classes, inheritance diagrams, etc. This seemingly forces me into using Doxygen, which is much more feature complete, but suffers from the abovementioned stylistic bloat and for some reason cannot handle relatively simple macro expansions in imo-not-so-complicated cases. I simplified the following from a real world example, but this includes auto-generated class implementations, eg: BEGIN_DEFAULT_HANDLER(foo) _BASEMETHOD const char* bar() const _OVERRIDE { return "yomama"; } END_DEFAULT_HANDLER(foo) which might expand into something like ---------> class foo : public crpt_base<foo> { base_interface* GetInterfaceClass() const _OVERRIDE { _STATIC foo_interface if; return &if; } _BASEMETHOD const char* bar() const _OVERRIDE { return "yomama"; } }; extern "C" _DLLEXPORT base_class* _fooFactory() { return static_cast<base_class*>(new foo); } Doxygen doesn't even recognize foo as a class. The bottom line is it seems to me I shouldn't be asking for too much here. I'd really like the clear coding style I've adopted to pay off in more than just the code. What's your approach? Any suggestions? Ideas or alternative options to explore?
  5. irreversible

    What's is the best story game you've played?

    Oh, no-no. It's a third person shooter that starts out familiar, but then turns into something you don't expect. I had a really hard time putting it down once it got going. It was one of those games that went completely under the radar for most people. In fact, I picked it up by pure chance after discovering it in my library one day (most likely after having gotten it in a bundle of some sort). Just give it a couple of hours before starting to form any judgment. Heck, even Angry Joe stopped playing before he really got into the story and gave it a mediocre review, which is quite sad. I genuinely don't want to ruin the story as it takes the front and center stage. I also suggest you don't read to much about it. The campaign is only around 6-8 hours and I was playing on Hard, which was probably a mistake - just play it on something easier the first time around so you won't get stuck in certain missions and lose a sense of flow. Also - while I think 20€ is quite fair for it, it gets discounted quite often. Here you go:
  6. irreversible

    Simulate The "No Man's Sky Effect"

    Oh, I'm sorry if I left the impression that I have the answer :). It was just an assumption that things went haywire behind the scenes. I don't know what happened or what the reason for this kerfuffle might be.
  7. irreversible

    Video Game Plot Generator

    2d parts hilighed: "Your're are game's title is The Ninja's Dream of Loot . It is an emergent puzzle. The protagonist is a pirate, who out of shear madness needs to retrieve an ancient artifact." "Your're are game's title is The Illusionary King's Adventures for Endless Evil . It is a philosophical action adventure. The protagonist is a japanese schoolgirl, who without any clear motivation needs to retrieve an ancient artifact." "Your're are game's title is The Amazing Ninja's Story of Glory . It is a TCG. The protagonist is a former soldier, who to complete his revenge needs to obtain N items of stale dog feces." This is trolling 101, right?
  8. irreversible

    What's is the best story game you've played?

    Four words: Spec Ops: The Line. On top of that I'm going to say Unreal (the original game), because if you can spell imput with an m in your game and still have me take things seriously, then you doing something right. Followed by Monkey Island 2, System Shock 2 and Mass Effect 1+2.
  9. I didn't read the entire thread in detail, but the key question here is - can't you enable logging on your code? It's kinda like running untested code on your own system - if you encounter a problem, you debug it in one way or another. Having different debug levels in your code will, in the very least, give you a general idea where something is failing. For the the cases where performance tanks on a similar system, can you do remote profiling? Eg create a demo scene and record timings for it manually and then compare them to some ground truth you would expect a system of that magnitude to generate?
  10. irreversible

    How Linux Community Steals Proprietary Assets

    This is not a Russian forum.
  11. irreversible

    Simulate The "No Man's Sky Effect"

    I love this. The game 76-ed the whole of gaming community back when it was released (ultimately the tech being at the forefront of the backlash). And now we're discussing it as an aspirational goal of sorts. That being said, I'm both impressed and glad that they've actually come this far. Despite being conflicted about what really happened behind the veneer.
  12. irreversible

    Simulate The "No Man's Sky Effect"

    I remember them talking about not being able to make it work seamlessly so they have two rendering modes and as you enter the atmosphere they simply crossfade/blend from one to the other. I haven't played the game, but I'm assuming it's masked by a hefty amount of blur, shake and other screenspace effects. You're going to have a framerate spike during the blend, but you can also probably get away with lowering detail.
  13. I would separate logic from the object. So basically you have three "parts": The object (you only have one of these, call it the "template". It contains the geometry and root data for the object) The object's state (stores information about the current animation, transform etc, determines the number of instances of an object you have in the scene, contains a pointer to the base object and a logic handler) The logic handler (this could be a callback, a script or whatever - doesn't really matter) To initialize the game state you load all object data from disk, create states per instance of an object (eg for each monster), attach a logic handler to each instance and then, to update: (eg per frame) for(auto& o : objInstances) o.handler->OnTick(o) (eg when an object receives damage) for(auto& o : objInstances) o.handler->OnDamage(o)
  14. Hey - this works! Like I mentioned in my original post, though - I'd like to understand why this is the case. It would seem the operator defined in the same (in this case global) namespace should, regardless of placement, be preferred by a call from the same namespace. PS - I'm also not quite sure why not to put these specific overloads in global since they get exposed via an early using namespace logging; anyway.
  15. Nope - no warning or anything. The wrong operator just is called blindly. As for it being a compiler bug - it's possible, although it would be nice if I could get some external verification for this since I only have VS set up on my rig. I can't recall if this used to be the case in VS2013 as well or not... As for the code - there isn't much else to show really. This is kinda the minimal example. I might write up a compileable test program when I get back to my computer.
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!