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

Gyrbo

Members
  • Content count

    154
  • Joined

  • Last visited

Community Reputation

187 Neutral

About Gyrbo

  • Rank
    Member
  1. I've been hard at work to improve my automatic AngelScript binding generator. Several new features were added and it now comes with a readme to explain things better. There is both a binary win32 release and a source release. The binary release comes packaged with everything you need to get started. Simply follow the readme instructions and you'll have a .cpp file that you can easily compile into your project. The binder does expect that you've bound std::string as the string type. Any functions using char*'s will automatically be wrapped. As usual, any feedback is greatly appreciated.
  2. I think your problem is using asMETHOD with asCALL_GENERIC. Methods can only be bound using asCALL_THISCALL. If you want to use asCALL_GENERIC, you'll need to make it a static method. The "this pointer" can be retrieved from the asIScriptGeneric paramater.
  3. I don't have a particular reason for it. The reason I asked it is that for some reason TinyXML (which I'm trying to bind with my auto-binder) has it this way. Since I'm generating wrapper functions anyway, it's easy to provide an AS compatible signature. I was just wondering why it was this way, no need to consider this a feature request :). It may be useful to mention it in the documentation, though.
  4. The following code causes an error: // ERROR! r = -10 (INVALID_DECLARATION) r = engine->RegisterObjectBehaviour("Test", asBEHAVE_ASSIGNMENT, "void f(const Test &in)", asMETHOD(Test, operator=), asCALL_THISCALL); // This works //r = engine->RegisterObjectBehaviour("Test", asBEHAVE_ASSIGNMENT, "Test& f(const Test &in)", asMETHOD(Test, operator=), asCALL_THISCALL); Is there any specific reason this is disallowed, or is this a bug?
  5. I've been working on this for a while and I have a very basic first release. You can download it here: http://gyrbo.madoka.be/YAASB/YAASB-20071021.zip. It's called YAASB (Yet Another AngelScript Binder). The zip includes everything to get you started. To use it, you'll have to get your header files processed by doxygen. You can do this by going into their directory and executing doxygen.exe with the supplied Doxyfile as an argument. This will create a folder called "xml" with all the required files for YAASB to work. You pass this folder as an argument to YAASB.exe. It sounds complex, but it's quite easy. The following commands will generate and output.cpp file with all the bindings it can generate doxygen.exe Doxyfile YAASB.exe -y -o output.cpp xml/ It will most likely generate lots of inout references, so you'll need to enable ALLOW_UNSAFE_REFERENCES for it to work. Handles are planned for a later release. If you only want to include specific files, remove the "-y" switch and put the following in each file you want to use: /*! @file @use{recursive} */ If there are any classes/namespaces/methods you don't want includes, you can prepend them with the following comment: //! @use{no} If you already use doxygen for your project, you can add these actions to existing comments. In order for them not to show up in the documentation, add the following to your Doxyfile: ALIASES += use{1}="\xmlonly<yaasb use=\"\1\" />\endxmlonly" Things that aren't included, but planned: - Handles - Inheritance - Downcasting functions - Arrays (using STL containers?) - Templated classes (using typedefs) - Wrappers for const char* to strings - Wrappers so generic calling conventions can be used Any comments are greatly appreciated. I'm also looking for header file to test the code on.
  6. 4e6

    Well, according to wikipedia, "pony" has some other meanings: 1 2 3 (this might be interesting) 4 So I'll repeat the question, how liberal can we be in this? Curious note: all elements are plural. So would having a single accountant make your entry qualify?
  7. That actually seems like a pretty nice idea. From what I gather, custom commands would be a bit of a hack, but workable. I'll have to do some experiments to see if this an actual viable solution, but it seems to best method for now. Thanks for the hint abrken!
  8. The tool itself would only work on windows, but its generated code is potentially portable. That is assuming that other compilers don't default to a different calling convention. I hadn't giving the C++ <-> AS binding difference enough thought, it seems. Handles are probably the most difficult to do automatically since you have to add the refcount to the class. The refcount also needs to be updated appropriately. References need to correct in/out specifier, too. My intention was to make the configuration file as light as possible (only specifying the class/function names and offering to automatically bind all methods of a class). The reason for this is that AS itself is already pretty user friendly. If the configuration file is too complex, there would be no added value over simply calling RegisterXXX manually. Making a validator for the code was one of the things I was planning once this was finished. It might be better to start on that, but if you're going to provide this yourself using inline code, it might not be worth it. I'd try to do it using templates, but I can't really wrap my head around all the required concepts.
  9. I was wondering if there was any interest in an automatic AS binding generator. As a basis for the bindings, I would use the pdb file that MSVC generates (by using the DIA SDK). The tool would read the pdb and output either of these formats: 1. A C++ file that can be compiled into your project would would contain all the required binding code. This would require you to compile your project twice: once for generating the pdb and parsing it and a second time for linking in the generated .cpp file. I'm not sure how well this would integrate with build systems. The advantage would be that this file can easily be used by other operating systems besides windows. 2. A sort of serialized version of the internal AS state. All information that is required is contained in the pdb file. The advantage of this approach would be that you only have simple postprocessing step. On the other hand, this file would probably expose more information that you want about the internals of your program. This file would also only be usable on windows (since it contains function pointers, etc.) A small description file would specify which classes/functions should be included. I haven't started any actual implementations, so I'd like to get some feedback on this idea before I start on this. If I still have some time after this is finished, I might try using an approach based on the actual source (probably using GCC-XML). But since this would probably be harder to do and not be as reliable (calling conventions, ...?), I'd prefer to use the pdb approach first.
  10. For atomic operations, the libatomic_ops library from HP is interesting. It contains implementations for a lot of platforms, including linux and windows. It's licensed under a MIT-style license.
  11. The complexity of find() depends on the container you're using it on. A plain std::map is usually implemented as a binary tree. I couldn't find any Big O for it, though. An alternative would be to use a hash_map, which is usually implemented as a hash table, wich pretty much gives you O(1). The choice depends on how many items are in the map and how fast your hash function is. The best way to determine this is to make two versions of the code in a simple test program and profile. I personally use AMD's CodeAnalyst (it's a free download, probably only works on AMD CPUs). If you need a string hash function, try this: http://www.burtleburtle.net/bob/hash/index.html#lookup
  12. I believe this was changed to a runtime setting in the latest versions.
  13. Not to mention that the posted code doesn't make any sense at all, there isn't really a question. What is it you want to know/ask?
  14. Global functions can't be thiscall. Declare the method as static in c++ and use either cdecl or generic (with a wrapper). In you case though, you probably get an error because you're using non-generic calling conventions on an unsupported platform. Which OS/processor are you using?
  15. You can try running linux in VMWare. Threre is a free Player available, you just have to find a suitable linux image for it. A list of some suitable VMWare images: http://www.vmware.com/vmtn/appliances/directory/cat/45 The player itself can be downloaded here: http://www.vmware.com/download/player/