• Advertisement

Scouting Ninja

  • Content count

  • Joined

  • Last visited

  • Days Won


Scouting Ninja last won the day on April 13

Scouting Ninja had the most liked content!

Community Reputation

4302 Excellent

About Scouting Ninja

  • Rank
    Diamond belt!

Personal Information

  • Interests
  1. Need Coders Existing System

    Instead of down voting this I will explain why I would down vote this. 1.) "Breaking Out" means that the person joining your team would be given a opportunity to break free from constraints. However, all you offer the person is a chance to work on a custom engine; nothing else. "Experience with a custom mod engine" Means nothing to the industry, because it could mean any custom mod engine and chances are you won't vouch for every person who joins your team. So it would be hard to prove. In fact: "Experience using Unity, Unreal and Cryengine" would count for much more, it's also very easy to prove that a person worked with these and they aren't clouded by secrecy (NDA). 2.) The fact that you are keeping things secret is why so few experts would take the risk. Basically you are saying: "The only way working with me is worth something, is if we are successful." Meaning it's a gamble with the odds greatly stacked against them. Especially with no info to decide if they are willing to gamble. It's also a all in type of project, where if a member quits they get nothing for the work done. No one likes wasting time and taking needless risks. 3.) To learn what? And how will you prove that the people who helped you learned it? What people need from a job like this is proper Testimonials and Proof of what they learned working for you. Can they still get this with your NDA in place? Remember you aren't paying them with money, instead you pay them with experience. However experience has no use unless it can be proven. The problem is that in truth you are a freelancer looking for freelancers, the same sales tactics you use is used by the people looking to join your team; this means they are reading between the lines. The result is that each person reading this post, is forming there own opinion , not based on what you wrote but on what wasn't written, the only way for you to counter this is to explain the project and what your "intern" will gain from working for you.
  2. All the time? This is confusing because there is lots of different ways of doing this. Most of the time you program on a 1:1 scale and the camera turns it to a 4:3 scale. In other words, this isn't something you do do unless you also want to make your own render system (API Application Programming Interface, OpenGL and DirectX). If your sprite moves 1 on the X and your screen is 3:4 then it will move 3 pixels on the X axis when rendered. Moving 1 on the Y also moves it 4 on the Y axis when rendered. You don't do this, your rendering API will or engine will. If your sprite is 1024*1024 but it only takes 64*64 pixels on screen then the API will keep down sampling till it has a 64*64 image to fill those pixels. This takes a long time. It can't render 1024*1024 in a 64*64 space no matter how much it wants. So to avoid this Mipmapping is used. Mip maps store do the sampling and keeps it in the "sprite" then instead of sampling the large texture and wasting performance. See this video: https://drive.google.com/file/d/107_vHcHx_wByMARYj-LOgXnQYVyDhQEj/view?usp=sharing This was made using a DDS texture that allows me to make custom mips for special effects. So in other words if you used 10 sprites each of them a 1024*1024 and rendering them on a 1280x720 ratio then each sprite result will be: 1280/10 x 720/10 = 128x72 pixels per sprite meaning that X has to be down sampled 8 times and Y 15 times to scale it to fit on screen. This means you are using 15 times the performance needed to actually display that sprite. Where with a Mipmap and Anisotropic filtering you would be able to render it around 10 times faster and get better results. In other words you will only use a 1024*1024 sprite if the sprite covers 90% of the screen and you know most players will be using a screen +/- 1280x720. Bigger sprites does not mean better quality unless your players have bigger screens. If you used a 4K (4096x4096) sprite it will never display that way on a 1280x720 screen no matter what you do. The screen just doesn't have enough pixels so it has to down sample the sprites. Also 10 of the same C doesn't use 10 texture sheets so you won't need a 10240*1024 texture. You will just render the same sprite more than once. Only 10 unique sprites of 1024*1024 would need a texture of that size and you would pack it better like this: 10240*1024 -> 4096*4096 aka a 4K texture and it will look something like this: From this: To this: Because computers like working with numbers to the power of two, meaning that the image bellow actually loads and renders faster than the image above. This is known as a atlas or tile sheets. What is it you are trying to do? Are you making a rendering API? A engine? A game? The knowledge you need in the moment depends on what you do. The stuff I am telling you took me years of experience as a professional 3D artist and a hobby 2D artist to learn(3D and 2D is the same stuff just have different names). There is a lot of information you need before these things make sense, a lot you don't need to know to make games.
  3. Algorithm Increasing difficulty algorithm

    It is complex but light on resources, remember that Left4Dead was made for computers much slower than modern mobiles. Like all AI the key is turning the behavior into math and doing it as cost effectively as you are willing to compensate for. Just think of how you want the AI to behave when a player does something and turn that to math. Then use lighter equivalent math to get roughly the behavior you wanted with low battery cost.
  4. Algorithm Increasing difficulty algorithm

    Maybe logic would be better here than math. For example Left4Dead used "The Director" and logic based AI. Even today Left4Dead is still one of the most played multiplayer games and a lot of it is because of the AI.
  5. How far are we from component detailed games?

    If you scale it yes. Instead of thousands you only use hundreds, then you will be fine. Game engines today can emulate 1 000 000 - 8 000 000 objects on screen at once if they are kept very-very simple. Unreal can for example emulate 4 000 000 bouncing balls with full physics and materials if they are instances of each other. This should mean +/- 500 000 body parts to use. If it is all you focus your resources on. To emulate a universe you need to use a universe. Voxel systems and the like uses octrees and fake emulating particles, the problem is that the smallest piece of data we can use is a byte a 0 or a 1. A byte is either a small piece of metal or a capacitor or some kind of physical object. Each of these small objects we use for bytes are actually made of trillions of atoms. To be clear, we are using a 1,000,000,000,000 : 1 scale when we try to represent atoms in games. So instead we use much larger objects to fake simulations of smaller objects: The video shows how millions of balls are used to create a water like effect. This takes the same power as most games to do. You can use bigger "atoms" so needing less per emulation and still get convincing results and games use this all the time. It's all about scale.
  6. [UNITY C#] Go through window.

    This is what Inverse Kinematics is for. You would have a walk and climb animation, then play the animation, correcting it with IK. Unity has IK build in and is fairly easy to use if you build your 3D model the way Unity wants. Starting with a window climb is a bit complex, it would be better to start with something small like a button press. Here is a good start: https://www.youtube.com/watch?v=GYfeALySSq8&feature=youtu.be
  7. I made a basic example of how to spawn the grid. It uses a 2D array but I left the 1D array in so you can also see it. It also spawns objects so you can see how to do so. SNBlockBreakerSpawn.zip This part isn't in yet, will add it when I have free time. The concept would be to check if there is a empty row and if there is all rows need to shuffle around.
  8. You are trying to make a game object that doesn't exist. Unity doesn't allow you to use prefabs directly without loading them first. The reason is that engines are bad at dynamic loading and unloading. You can use the resources folder and load from it or you must move the prefab into the scene and link it to your code. The sample I am making for you uses the multi-dimension array. I did try it with a single array first but instead of error out of bounds the blocks spilled into the next row. I will keep it in so you can see some of the basic math for a single array but multi-dimension is much-much easier to use.
  9. Tricount and texture sizes for some middle sized props

    Yes. When you import a texture the engine will make the mips for you. Then while the game is running it will also solve the mips. It's no extra work for you. Texel density is often decided by posting the camera at some angle from the model then mips are checked to see what texture range would be best for the game. When making assets for asset stores this shouldn't bother you much, it is something a developer decides at the start of a project. All you need to do is provide the developer with a good enough texture that they can do these things. A 4-8K texture should allow them to scale as they need. 2K is also good.
  10. Using 2D arrays is to keep things simple, it's not a necessity. The advantage of using a 2D array is that you can then use Linear algebra to solve things. Meaning less if checks and such, but needing math skill. For example in a 2D array I can check how far a block is from a other block by using math. A one dimension array also has it's own advantage, for example if we want to confirm if a object is in the array we can check that it is larger than 0 but smaller than Array length. In a 2D array we have to do it for every array. So both has ups and downs it's just what you like best. For the example I will just use an array. I have to do it when I get home, so it wont be up imitatively. I will comment on each thing I do so you can read how it's used.
  11. Why some games look orange?

    This is why color theory teaches that the eyes is as good as the principle. Because understanding color doesn't give you any better way of letting people see what you want, estimating it is as good as knowing the right color. Mostly it's because no two people see the same color the same way, in fact people don't even see color the same depending on what eye they use. It's also why color theory is not considered worth the effort of learning and there are many great artist who don't know it, going by what they see instead.
  12. A voxel like system, forget about it. For what you need Null objects is actually a good thing. Think of the Null objects as the blocks in the grid that are empty. That way you can check if a block is Null to see if it is open. So step 1 would be to make a grid full of null objects. Null means "nothing" a empty space. Step 2 would be to change the null objects with your own game blocks. That is easy then, just check if the blocks around has at least one block that isn't null. No reason you can't still do this. Lists and arrays have many ways for moving objects around. If the object isn't null you check to see what it is. Basically a array is already exactly what you are describing here, that is how arrays work. If you want I can make a example for you.
  13. Just pointing out that you can use multidimensional lists. Remember that a list is an array, it just has extra code attached to make it dynamic but the way this works is that the array is copied and so it does have impact on performance. I am curious, are you trying to make marching cubes? If you explained what you want it would be easier to help you.
  14. Why some games look orange?

    Most of them have a very light blue, or yellow tint; these two are considered the most natural light. Then they use fog to fill in more blue tint, look into the distance of the images you showed(the first one uses greenish fog). Light and shaddow color is also tinted to change the color. In short they are using more elements to tint the scene instead of just the composing filter. Yes to prevent color from overpowering it should be almost gray. The first image you show here has a white to black gradient, second has a complete yellow gradient and the last one has a aqua to white gradient. Use the brick textures and brown colors when looking at the image, these are the same textures used in all the scenes but because of the color tint you can see them looking different colors, the difference is the tint. Also there are times in Skyrim when the filtering is aggressive: How the tinting is used greatly depends on what kind of feeling and mood the developers want. The rule of thumb for tinting a scene is that if you don't notice the tint with your eyes, then it's probably the right tone. However as the video @Hodgman linked explained, it could still have too many reds. Limitations of the hardware from back then, if you re-made Skyrim in Unreal it would have much better graphics. The biggest mistake, if you can really call anything the best selling game ever does a mistake, is that they used the light to tint things most of the time. A aggressive light color causes things to look plastic, especially with the old shaders from back then.
  15. Why some games look orange?

    I want to point out that the palettes for the last 3 is green. Also Skyrim uses all the palettes, it just depends on where you are in the game.
  • Advertisement