Moderators

87

14601

Moderators

74

11031

Members

59

1230

Moderators

50

14118

Popular Content

Showing content with the highest reputation since 11/14/17 in all areas

1. 9 points

2. 7 points

should i use a engine or program everything from scratch?

You've gotten some excellent answers, so let me take a different tack. At the end of the day, it's all about goals. Is your goal to: Develop the game of your dreams and bring your ideas to life? Go professionally into game design or high level programming (AI, game logic, etc)? Use an engine. This is what they are there for. Understand how everything works, and maybe eventually become a professional engine or low level developer? Build everything yourself. Obviously both are legitimate paths to choose, but they're very different.
3. 7 points

4. 6 points

Why I hate fun

http://www.tinker-entertainment.com/sitavriend/psychology-and-games/why-i-hate-fun/ Ever since I decided to specialize in game design I struggled with the word “fun”. It might sound silly to struggle with a term that is so central to the art of making games but it makes sense once you start to research ‘fun’. First of all very limited research has been done and secondly the term ‘fun’ is ambiguous. Fun means something different for everyone. Many other industries envy the games industry for making fun products. They mistakenly think that games are this magical medium that are automatically fun and engaging. As a result, they applied typical game elements such as XP and competition to apps as an attempt to make ‘boring’ tasks more fun. But game designers also struggle to make their games engaging and fun. Not every player enjoys playing every game or genre. I typically don’t enjoy most first person shooters because I suck at them. On the other hand it is not just games that can be fun. Many people think knitting is fun, others think watching a football match is fun or playing a musical instrument. What is considered fun often depends on someone’s expectations and their current context. A player has to be in the right state of mind before considering to play a game, they need to ‘want’ to play the game or do any other activity. This can be fun too. A researcher who attempts to understand fun more thoroughly is Lazzaro (2009). She formed the Four Fun Key model to distinguish between four different types of fun: Hard fun, easy fun, serious fun and people fun. Hard fun is very typical for many hardcore games and is fun that arises from overcoming challenges and obstacles. A key emotion in hard fun is frustration followed by victory. Easy fun can be achieved by engagement through novelty and can be found in many exploration and puzzle games. Emotions that are key to easy fun are curiosity, wonder and surprise. Serious fun is fun people have when they feel better about themselves or being better at something that matters. People fun is concerned with the enjoyment that arises from the interaction between people. You can think about competitive or cooperative games people play because they enjoy playing together rather than the game itself. The Cambridge dictionary defines fun as pleasure, enjoyment, entertainment, or as an activity or behaviour that isn’t serious (http://dictionary.cambridge.org/dictionary/english/fun). While we can measure pleasure and enjoyment objectively by measuring physiological changes in the body, we cannot always say we are having fun when we are enjoying ourselves. Besides that, within casual games mainly, pleasure and enjoyment are supposed to be “easy”. This means that you should be careful with challenging the player. If a player wins (often) they will have fun which is the complete opposite of many hardcore games. Within game design we often use flow theory interchangeably with fun. According to Csikszentmihalyi (1996), flow is a mental state in which a person in fully immersed in an activity. The state of flow can be achieved by matching the most optimal skill with the most optimal difficulty for a person. In the case of games, a player becomes so immersed that they forget about their surroundings and lose track of time. A learning curve is used in most games, both casual and hardcore, to account for player’s changing skill and difficulty level. However flow theory isn’t a definition for fun but can result in a player having fun. This mainly works for hard fun as easy fun doesn’t require the player to be fully immersed. References Lazzaro, N. (2009). Why we play: affect and the fun of games. Human-computer interaction: Designing for diverse users and domains, 155. Csikszentmihalyi, M. (1996). Flow and the psychology of discovery and invention. New York: Harper Collins.
5. 6 points

What do you think can help stop cheating in PUBG

Why can't it be? What are you basing that on? It sounds like you're just repeating things that you've heard rather than basing this on development experience? It's currently lagging because they don't have a dedicated server, so you're relying on other players on vastly different connections to share game-state instead of having a single reliable connection to a data centre. If 100 players all simultaneously fire a 600RPM rifle at a target that's 3km away, then after three seconds there will be 3000 projectiles in the air. If the server ticks at 20Hz it needs a ray-tracer capable of 60K rays/s, which isn't much - it would only consume a tiny fraction of the server's CPU budget. If every bullet needs to be seen by every client (e.g. To draw tracers) then this would cause a burst of about 72kbit/s in bandwidth, which is fine for anyone on DSL, and a 7mbit/s burst on the server, which is fine for a machine in a gigabit data centre. None of this impacts latency because that's not how that works... And if not every bullet has visible tracers then these numbers go down drastically.  I quickly googled and apparently PUBG does already run on dedicated servers in data centres? Maybe they still do client side hit detection for some reason though...
6. 5 points

Physically Accurate Material Layering

For The Order our compositing system was totally based on parameter blending, much in the same spirit as Disney's material system that was presented at SIGGRAPH 2012. The only exception was when compositing cloth-based materials, in which case we would evaluate lighting with both our cloth BRDF as well as with GGX specular and then perform a simple linear blend of the two results. As far as I know UE4 is generally doing parameter blending as well, but I've never worked with that engine so I'm not very familiar with the specifics. As you've already figured out, you can't really simulate true multi-layer materials with parameter blending alone. To do it "for real", you have to make some attempt at modeling the light transport through the various translucent layers (much like they do in that COD presentation). This generally requires some approximation of volume rendering so that you can compute the amount of light absorbed as it travels through the medium. For something like car paint, at the minimum you'll need to compute your specular twice: one for the light being reflected off of the clear coat layer, and another time for the light being reflected off of the actual metallic paint flecks. I'd probably start out with something like this: Compute the specular reflection off of the clear coat using the roughness and IOR (F0 specular intensity) Compute the amount of light transmitted (refracted) into the clear coat using fresnel equations and IOR Compute the intensity and direction of the view direction as it refracts into the clear cloat using fresnel equations and IOR Compute the specular reflection off of the metallic layer using separate roughness and IOR (and perhaps a separate normal map), and also using the refracted view direction Final result is ClearCoatSpecular + MetallicSpecular * LightTransmitAmt * ViewTransmitAmt This would not account for absorption in the clear coat, but it would give you the characteristic dual specular lobes. If you wanted to account for absorption, you could compute a travel distance through the clear coat by having a "thickness" parameter and computing the intersection of the light/view ray with an imaginary surface located parallel to the outer surface. Using that distance you could evaluate the Beer-Lambert equations and use the result to modulate your transmittance values.
7. 5 points

14. 5 points

November 2017 GameDev Challenge: Pong!

Hi everybody! I decided to use this challenge as an excuse for learning to use Game Maker (or I wanted to learn Game Maker and decided to do it while participating in this challenge; pick one :P). My project is called "Power Word: Pong". It's available for Windows here: https://racso.itch.io/power-word-pong I still want to improve the AI, as it's still quite dumb, and I want to give some variety to the ball (angle and speed changes), but I'm almost done with the game. Still, as always, feedback is appreciated! I hope you like the twist of the game. You may find the game source in this repository. I'll create a post-mortem after I finish working in the project. Regards! O.
15. 4 points

Rip internet 2017-12-14

Because there was no internet before the net neutrality rules, right?
16. 4 points

Pointers and defragmentation

That approach is extremely common in my experience, except typically with as-small-as-possible ID's instead of GUIDs (even u8 if you know you won't instantiate a particular class 256 times!). You typically don't do a search, but a simple lookup into an array that holds the indices. e.g. struct NonMovableComponents { int alloc() { return /*next unused component slot*/; } T& operator[]( int i ) { return component[i]; } T component[SIZE]; }; struct MovableComponents { int alloc() { int slot = /*next unused indices slot*/; int index = /*next unused component slot*/; indices[slot] = index; return slot; } T& operator[]( int i ) { return component[indices[i]]; } T component[SIZE]; int indices[SIZE]; }; However... whether this is an issue depends a lot on how you're using your "components". In some games, the primary way that components are accessed is by iterating over all of them -- for each component, do x... If this case, the cost of a lookup from an entity's handle doesn't matter, because you don't do it very much. In other games, the primary way that components are accessed is from their parent entity -- entity->GetComponent<Transform>()->DoX()... In this case, sure, you want those lookups to be fast... but you've probably also got bad access patterns anyway, so you're not going to get as much benefit from defragging, so you could just, not defrag After the defrag operation, you could go and patch all your component pointers. Entities could listen for an "on defrag" event from systems that they have pointers into.
17. 4 points

18. 4 points

19. 4 points

State of Custom and Commercial Engines as of 2017/2018

At a AAA studio, if they're using a custom / in-house engine, it will likely be just as big and complex as Unreal... If you get a job at a place like that, you'll still be making games on top of a massive engine. Even if you get a job there as an engine developer, it will be much closer to fiddling with the UE4 code-base, than your student-home-made-engine codebase. So, showing that you can actually work with a big, bloated, over-engineered game making toolset is kind of important. Doing fancy tech stuff from scratch is also important, if you want to work in a very technical role... but making a custom renderer from scratch when you're applying for a gameplay role isn't the best use of your time. In that case, a gameplay system built on an existing engine would be a better portfolio piece.
20. 4 points

Where to start… MMO to single player

Forgive the flippant response, but if you make an MMORPG single-player, aren't just left with an RPG? There are literally hundreds of great single-player RPGs. If none of those are to your taste, you'll have to be a little more specific about what elements of the MMORPG genre you think aren't sufficiently represented in single-player RPGs.
21. 4 points

Entity-Component systems

Just because UE4 does it, doesn't mean that it's correct. They can still be trampling all over the rules of OO. Big products made by 100's of programmers are often more likely to do so If your entire code base is designed around the idea of extending classes, then yeah, you get pushed into extending classes in order to add new features to that existing code base. If your code base is designed around the idea of composing new objects from other objects, then you get pushed into writing new composite classes in order to add new features to that code base. Inheritance is only "the only way" if the code is forcing that particular "solution" upon you. Good uses of inheritance are pretty rare...
22. 4 points

23. 4 points

Animation Doubt?

Yes. I did a breakdown for you. By looking at the video we can see there are 5 points where the images are changing. That is why the last image looks so wrong. The character is made of: Head image, Body image, BackPack image, Left arm image, Right arm image, Left leg image, Right leg image. There also is a animated band but it is just attached to the head. The objects are drawn from a top down view so that little change is needed to each. Mostly looks like the artist was using a perspective tool and filling in details. The arms and legs are just rotated. The Head, body and backpack changes. The arms and legs remain the same but are mostly hidden. Hope this helps.
24. 4 points

25. 4 points

November 2017 GameDev Challenge: Pong!

Here is my submission for the challenge. Sadly I don't have the time to work on it again before the end of the month, and the AI is stupid to say the least. The twist is pretty straightforward, the arena is round instead of rectangular. When a player hits the ball it changes its color. When the ball is red if it exit the arena the point will go to the red paddle. Viceversa when it's blue the point will go to the blue paddle. The two paddles can also overlap and both hit the ball. When this happens and the ball exit the arena a point will be subtracted to both player. Here's the blog post: I hope you like it Code reviews are really appreciated! Round Pong.zip Solution.zip
26. 4 points

27. 4 points

Calculating shot hit percentage based on tile distance

In order to see how quickly the value decreases with distance, I divided the value at 10 by the value at 20, and their ratio was exactly 8. So if a factor of 2 increase in distance results in a factor of 8 reduction in the value, it suggests a dependence with 1/(x*x*x). 12800.0 came from fitting a single point at distance 10. Then I saw all the other points match exactly.
28. 4 points

Marching cubes

I have had difficulties recently with the Marching Cubes algorithm, mainly because the principal source of information on the subject was kinda vague and incomplete to me. I need a lot of precision to understand something complicated Anyhow, after a lot of struggles, I have been able to code in Java a less hardcoded program than the given source because who doesn't like the cuteness of Java compared to the mean looking C++? Oh and by hardcoding, I mean something like this : cubeindex = 0; if (grid.val[0] < isolevel) cubeindex |= 1; if (grid.val[1] < isolevel) cubeindex |= 2; if (grid.val[2] < isolevel) cubeindex |= 4; if (grid.val[3] < isolevel) cubeindex |= 8; if (grid.val[4] < isolevel) cubeindex |= 16; if (grid.val[5] < isolevel) cubeindex |= 32; if (grid.val[6] < isolevel) cubeindex |= 64; if (grid.val[7] < isolevel) cubeindex |= 128; By no mean I am saying that my code is better or more performant. It's actually ugly. However, I absolutely loathe hardcoding. Here's the result with a scalar field generated using the coherent noise library joise :
29. 4 points

Virtuals hide information on the implementation

Are you sure this matches in your code? You need to store pointers to the objects rather than the base objects themselves. The way the language usually enforces this is for your code make the base class abstract so it cannot be instantiated. They are commonly called an ABC, or Abstract Base Class, because of this. Except in rare cases, only the endmost leaf classes should be concrete, everything below it in the hierarchy should be abstract. In that case, are you certain you are following LSP? Are the sub-objects TRULY able to be substituted for each other? Code should be able to move back up the hierarchy to base class pointers, but should never need to move back out the hierarchy, instead using functions in the interface to do whatever work needs to be done. As a code example: for( BaseThing* theThing : AllTheThings ) { theThing->DoStuff(); } versus: for( BaseThing* theThing : AllTheThings ) { // Might also be a dynamic cast, or RTTI ID, or similar auto thingType = theThing->GetType(); if( thingType == ThingType.Wizard ) { theThing->DoWizardStuff(); } else if( thingType == ThingType.Warrior ) { theThing->DoWarriorStuff(); } else ... ... // Variations for each type of thing } Also, in general it is a bad idea to have public virtual function. Here is some reading on that by one of the most expert among C++ experts. This is different from languages like Java where interface types are created through a virtual public interface. Some people who jump between languages forget this important detail. As the code grows those public virtual functions end up causing breakages as people implement non-substitutable code in leaf classes, as it appears you have done here.
30. 3 points

Any idea on this boss mechanism?

Hi there, I really like the idea of a fog-based enemy but I think that the combination of fog (limited view for the player) and this could result in excessive difficulty (unless you want this) because you are enhancing the enemy's abilities while weakening the player's. Personally, I think it'd be interesting to use the fog as a "hiding" mechanism for the enemy. For example, It could use it if its health drops and take advantage of the limited visual capabilities of the player to regain health. Player-side this results in a situation where you are "weakened" (low visual) but you have the possibility to find the enemy while it is regaining health and possibly deal lots of damage (high difficulty, high reward if you find it).
31. 3 points

Computer Science or Game Development

I believe it would be easier to get a job outside of gamedev with a cs degree, a lot easier then trying to get a job outside with a gamedev degree. A lot of the stuff you learn there aren't useful in many other areas, they are more a specified part of the field. GameDev is an happy dream for many, but does not result in a happy reality for even more. Better to have a job and a hobby, than 'nothing'. So for job security and your future, I'd go with computer science.
32. 3 points

SIGBUS illegal alignment

The X86 family incurs a penalty for doing it, and only the really old types support it. The 64-bit and larger data types typically require proper alignment. C++ is supposed to properly align the values for types supported by the compiler. For tracking it down, usually this comes from improper casts. A common source of those casts is serialization. It can also happen anywhere else you perform unsafe casts, like a reinterpret_cast to convert from one type to another that has stricter alignment requirements. When loading values from disk or network you cannot blindly cast to the right data type or data structure. You need to get the address of a proper variable, then copy the bytes directly into that object. Usually that is done with bitwise manipulations or memcpy(). Once the data is loaded into properly aligned values, C++ should manipulate the data exactly as expected. It adds a performance penalty (if it works at all on the compiler). The compiler adds additional code to ensure the value is suitably aligned, sometimes using temporary objects for member access.
33. 3 points

Handles replacing pointers using indices

I typically have component handles act less like stand-alone pointers and more like indices (which require some external knowledge of the container being indexed). Often if one system of components is referencing another system of components, it can have a pointer to the other system, while the components simply hold index-like handles (instead of pointer-like handles). The system can dereference a component's index-like-handle by combining it with it's own pointer. To catch programming errors, in debug builds, my index-like handles contain an index and a pointer/ID as well, so that the dereference process can be validated (is this handle being used to index the correct container?). Off topic: In this example, that just forces C1/C2/C3 to contain a vtable for absolutely no reason at all. Firstly, inheritance is a code smell, and secondly, A is not being used as an interface for ownership (there's no calls to delete with an A* argument). This feels vaguely like a violation of OO's LSP rule to me for some reason (any algorithm that works on a base type must also work on a derived type).... But yes, Handle<B> could contain a pointer to the std::vector as well as the index into it... This gets complicated beecause the vectors are of different types. One (probably heavy-handed) solution off the top of my head would be for Handle<B> to contain an accessor function like: std::function<B*()> getter = [&c2s, c2index]() { return &c2s[c2index]; } Alternatively, Handle<B> still just contains an index and a templated getter function: template<> struct Handle<B> { int index; template<class T> B& Dereference(std::vector<T>& vec) const { return vec[index]; } } And as above, in debug builds I would store extra data inside the handle to validate that the correct vector is being passed into the Dereference function.
34. 3 points

Issues with creative conflict for small unpaid team

1. Get the vision out of your head and into a document. Anything you won't compromise on needs to be in the document. This document is to be visible to new team members, so that they know exactly what is expected when they join. 2. With the above in mind you need to more carefully vet everyone who joins the team. Ask what their motivation is, and make sure it fits with the project. Make sure you are able to offer what it is that they need to feel that their time is being spent in a worthwhile way, and if that can't be done, don't bring them onto the project. You can't pay them in money so you need to be able to pay them in some other way - e.g. the ability to express certain ideas. But make sure that is compatible with your needs. 3. Accept the fact that some people will leave. They won't like the idea that they do a lot of hard work but you get to make the decisions. Many will want more control over the project than you feel you can offer. That's their right to want it. You can't change it. Just accept, up-front, that there's no one weird trick to compel someone to stay on your project doing your bidding.
35. 3 points

WriteBufferImmediate use-cases

Yep, that's right, and no it doesn't need to be unmapped.
36. 3 points

37. 3 points

Number of triangles is irrelevant to the CPU - how many draw calls do you have? If it's thousands, you may get some benefit from using multiple threads to record the draw commands. In my experience, with less than around a thousand draws, there's not much benefit in threaded draw submission. Most engines these days make a pool of one thread per CPU core, and then split all of their workloads up amongst that pool. So on a quad core, I'd use a max of 4 threads, and as above, also no more than around (draws/1000)+1 threads.
38. 3 points

Fastest detection algorithm?

What you want to do is beyond what any games currently do. The Total War games work with far fewer units and they almost certainly perform hacks to simplify their logic. I will add this: your grid is too small to give you much benefit and I expect the cache coherence is almost zero with rows that long. A more complex spatial database - perhaps even just a large grid of smaller grids - may give you significantly faster lookups much of the time, if it means that the 8 grid squares you're examining are almost always in the same cache line. But what you gain there, you might lose on having the 2 stage lookup, or on having to occasionally search across multiple large grid squares.
39. 3 points

Make my acquaintance

Hi All! I thought it was about time to become more actively engaged in the site and share my aspirations. First off, let me say that I am a senior citizen (I first learned to program using BASIC on a teletype machine using a time-share system at college [I went to Dartmouth and my intro Calculus class was taught by John Kemeny]). I got into game design/development as a hobby after playing around with making websites. I work full-time as a government contractor and have been for the past 13 years. My work hours and work environment has not really allowed me to get too deeply involved in the process. Much of my time has been spent reading about game development; playing around with recommended software (and their tutorials); and having fun in the process with my new hobby. However i am now looking at retiring from full-time work and spending my retirement time making games. Nothing fancy or ambitious, but maybe something that will provide a supplement to my pension. As a start I have taken a more serious approach to making games. I've browsed this forum and noted a lot of advice from vets and I appreciate you taking your time to help us noobs. I will be doing everything myself, so I guess that categorizes me as a solo indie developer. In that respect, any advice for someone like me will be appreciated. Thanks for reading.
40. 3 points

Scalable development methodologies for small teams and one man indies

Try out TDD, but beware that it has a larger learning curve than it initially seems to. You will most likely do things in a cumbersome way for a while as you get used to it, and you'll most likely shoot yourself in the foot a few times with it like I have. Try to avoid dependency injection frameworks. They're just one more thing that can go wrong. It's likely that you will be able to use TDD in a way that does not require dependency injection frameworks at all. If you get to the point where you're methodically using TDD style you will be building your program bottom-up and can avoid unwanted coupling from the start. Make things simple. Single responsibility principle is extremely important. Don't try to make everything an interface to appease the mythical DI gods; usually one function that does exactly what you want to do is the only one that ever needs to fulfill that interface. For Unity, attempt to write as much of your code as possible OUTSIDE of MonoBehaviours. MonoBehaviours have unwanted dependencies and horrid initialization restrictions compared to plain old C# classes. It's easier to test code if it doesn't require MonoBehaviour/GameObject baggage.
41. 3 points

Visual Studio Generating Code/Compiling Multiple Times

As far as I can tell, it batches up a handful of C++ files, then generates code for that batch all at once. But the batch size is limited, so you see more Generating Code the larger the project is. Nothing's going wrong.
42. 3 points

AI Topic for External Blog

There are just too many options. This forum is primarily about game AI. A few big areas (off the top of my head): Locomotion (pathfinding, flocking behaviors, animation controllers) Full-information two-player games (chess, checkers, go) General game playing Tools for game designers to describe behaviors (behavior trees, goal-based architectures, planners, utility systems) Machine learning (reinforcement learning for driving games, AlphaGo) Dialog (select phrases appropriate for the situation) Automatic adjustment of difficulty levels to give the player a good challenge I am probably missing some big ones, but perhaps something in that list piques your interest.
43. 3 points

C# Concepts Useful For JRPGs?

For general code structure, since you're still learning, don't try to get too complex. Do the simplest thing that you think might work, and only make it more complex if you need to. For a turn based game, the simplest things you NEED are a way to keep track of whose turn it is (one variable?), having a way to perform some action(s) during a turn (something which gets input from a player or an NPC), and how/when to go to the next turn. The main suggestion I have for any new programmer is: Try to keep every function very short and simple. If you need to make something complicated, split it up into simpler parts. Turn each simple part into a function, then you can make your more complicated function by just calling the simple ones. There is a tendency to do the same kinds of things in multiple places in a game; you should try to make simple functions so that you can reuse it instead of copy-and-pasting the same code in multiple places. Always make sure to test your code frequently! Even experts make silly mistakes and it's best to catch them early. You can also automate this testing process. If you want to jump right in, look up: "Unit testing" (Unity has built-in support for these as well!) and "Test Driven Development". This stuff is somewhat separate from C#, kind of like how knowing how to use a debugger is separate. Just like knowing how to use a debugger, knowing how to use unit testing can make profound improvements to your development experience.
44. 3 points

Will it cast?

32-bit floating point numbers, called "float" in C, C++, C#, and various other languages, can accurately represent 23 bits of precision, plus another bit for sign. So they should work with any number from +/- 2^23, or about 8.38 million to -8.38 million. Converting from base ten to floating point and back to base ten is only guaranteed for 6 decimal digits precision, although it should work up to that range of 8.38. Beyond that it cannot fit exactly within those 23 bits. That conversion applies just as much to 7654321 as it does to 0.007654321 or 765432100000000. As for the range, there is a must-read article, "What Every Computer Scientist Should Know About Floating-Point Arithmetic" which explains how it works, why it works, how certain calculations are troublesome, catastrophic cancellation where your result is garbage, and more. It requires a bit of math to understand, but it allows you to be far more precise in how much error you've accumulated from various sources, instead of the handwaving answer like "just check within 0.001 or something".
45. 3 points

Debate: Proper Time For Microtransactions?

That is one of the most difficult balancing acts within the business of games. There are some highly vocal, high profile people who will complain about the existence of microtransactions. There are some highly vocal, high profile people who will decry any game that requires people to spend time on games, that everything should be unlocked and available instantly. There are highly vocal, high profile people who will decry any games that use a progression system or story mode to advance, that anything requiring effort by the player is actually grinding and should be removed. There are highly vocal, high profile people who will shout to the world how whenever a player must pay for a game it is extortion. There are highly vocal, high profile people who tell others that the games are a great value. No matter what the company does there are highly vocal, high profile people who will shout it down. The tricky part is to balance them out. You want enough people giving positive feedback and actually paying for the game, but you also want a portion of the people to be offended because otherwise you won't make money and will go out of business. It further hurts the entire industry that many communities are highly toxic, where threats of felony crimes against the developers are commonplace and even encouraged. I've had co-workers get death threats before, including some where FBI agents came to talk to everybody after finding the death threats to their family members were actually credible threats. There are also other developers, even a few amazing indie developers, who have left the industry due to the highly toxic players and repeated threats from so-called fans. There is nothing "just learn how" about it. No matter what developers and publishers do there are people who will be deeply offended and will publish it all over the Internet. A good balancing point is incredibly difficult to find.
46. 3 points

Debate: Proper Time For Microtransactions?

Non-free mobile games don't sell. It's either micro transactions or advertising, or both in that part of the industry. Preferably both in a way that meshes with the game design and doesn't piss off the players. Note that when run as a business, a successful model *will* piss off the perfect percentage of players. Pissing off players loses you money, but obnoxious micro transactions makes you money. The balance is in the middle where you monetise the crap out of it and piss off some people, but not too many. The best way to make money isn't going to be pretty. You can ask individual people to be nice and not try to make the most money possible, but you can't ask a publicly traded corporation not to to that! Pay to win micro transactions in a full priced PC game is always going to piss off your players, and IMHO will completely undermine your gameplay too. I actually don't know how EA thought this would work... Cosmetic micro transactions are pretty much forgiveable in any game though...
47. 3 points

A good way to avoid extermination in RTS?

Most competetive RTSes end in "gg" and one team surrendering rather than playing until every single building is dead. That's the gaming equivalent of this. Whether this happens for an entire match (ala StarCraft) or if there is a higher level 'campaign' or 'war' layer wrapped on top of it doesn't matter.
48. 3 points

Hi, everybody!

Hi! We are Evil Corporation Games, an indie studio, which was founded in 2016. In April 2017 our first game project - Star Story: The Horizon Escape (a text turn-based adventure RPG with 24+ alternative endings) was released on Steam. We are currently working on our next game - TERRORHYTHM. That will be rhythm + beat'em up action in the style of cyberpunk. In this blog we will inform you about our game projects and the latest news about it. First post we would like to dedicate to our first project call "Star Story: The Horizon Escape". It was released on Steam 05.09.2017 (http://store.steampowered.com/app/610310/), then it was published on itch.io, g2a.com and gamersgate.com. Was a work experience with chrono.gg. Soon Star Story will be available on kinguin.net and greenmangaming.com also. It’s a text turn-based adventure game with elements of RPG. The plot is developing in accordance with the actions of the player; there are 24+ alternative endings of an exciting adventure. Trailer: A spaceship of archeologist Van Click crashes, and he finds himself on the last unexplored planet in the whole galaxy called “Horizon”. As the Hero is trying to get out from this planet, he meets various inhabitants of unknown locations; he has to struggle for life encountering extremely aggressive species of Fauna and resolving various puzzles. The end of this eventful flee from the Horizon planet depends only on the player’ choice. In this game we have mixed the mechanics of dialogues, choices, turn-based battles, puzzles, crafting and technology researches. Work on this game lasted 1 year. And before an official release Star Story took the first prize in the nomination «Best PC game» according to Indie Cup 2017 and got the first place in the Deconstruction Workshop at the White Nights St. Petersburg 2017 conference. As it our first post, in honor of it we would like to share 5 STEAM keys to Star Story for our very first readers and friends here: FZGMK-9HVVZ-R6HY4 6RYY4-VBX2Z-67X2B 3VGHH-Q8YY9-LTW73 J4CRJ-ZAZFT-X8FIV HG8RV-IQ8Y4-IEH8A Very soon we will post the early details of our new project making, that will be released Spring 2018.
49. 3 points

Survey regarding which AI 2d pathfinding and what method is easy to use

Wow... a lot of facepalm here. I can't see how you would need to do "research" on a topic that 30 minutes worth of Googling would solve for you. Dijkstra is uninformed and therefore kind of wandery. A* is informed with a heuristic and therefore more directed. It is also guaranteed to find you the shortest path if a path exists provided an admissible heuristic. It also supports arbitrary geometry shapes such as navmesh polys so you don't have to be entirely grid based. You can also arbitrarily change the edge costs between polys to represent something other than distance -- for example terrain type -- so you can bias the results easily to match the world. There are plenty of optimizations as long as the environment fits. e.g. if you are grid based, you can use things like JPS (Jump Point Search) and JPS+. Trying to do a survey and "research" on this is like polling the Math and Physics forum to see what the best way to find the area of a circle is.
50. 3 points

How to reduce data sizes?

Particles might number in the millions, but we don't try to send them across the network. The amount of objects you can send is proportional to the amount of data each one needs. Sorry for such a flippant answer but there's no trick or magic here. You can send as much data as your network bandwidth allows (nothing much to do with packet size, incidentally) and the less data you need per entity, and the less frequently you want to update them, the more entities you can update. To get transmission sizes down, you need to think in terms of information, not in terms of data. You're not trying to copy memory locations across the wire, you're trying to send whatever information is necessary so that the recipient can reconstruct the information you have locally. e.g. If I want to send the Bible or the Koran to another computer, that's hundreds of thousands of letters I need to transmit. But if that computer knows in advance that I will be sending either the Bible or the Koran, it can pre-store copies of those locally and I only have to transmit a single bit to tell it which one to use, as there are only 2 possible values of interest here. Similarly, if I want to send a value that has 8 possible values - i.e. the directions we talked about - that's just 3 bits. I could pack 2 such directions into a single byte, and leave 2 bits spare. Or I could send 8 directions and pack them into 3 bytes (3 bytes at 8 bits per byte is 24 bits to play with). If you're not comfortable with bitpacking, maybe read this: https://gafferongames.com/post/reading_and_writing_packets/

• Member Statistics

• Total Members
240111
• Most Online
6110