samoan62

Members
  • Content count

    11
  • Joined

  • Last visited

Community Reputation

120 Neutral

About samoan62

  • Rank
    Member

Personal Information

  • Interests
    Art
    Design
    DevOps
    Production
    Programming
    QA
  1. It looks like there's a pretty good description of .sm files here https://github.com/stepmania/stepmania/wiki/sm. Maybe in the actual stepmania repo you could find some code related to parsing them and go from there.
  2. Critique my portfolio

    This is really the only critique I have as well. Your profile looks great, and you are obviously a very talented artist! I would definitely focus more on creating animations like your tiger jump. While static images/backgrounds make up a lot of game assets dynamic sprites are also very important. I worked with an artist who was a local freelancer and had previously never done animations before, and it took her some adjusting before she was able to make nice smooth animated sprites. The tiger looks good, so you're definitely on the right track. I would just try experimenting with more of that and general static game sprites as well.
  3. Resources to get good at math?

    I always have had the same problem when learning something new like this. The lessons tend to drag on and when you skip them you almost always skip important stuff. Alternatively you could always try and fill in gaps of understanding using Google/wikipedia. I majored in math for my undergrad and even did research and I highly reccommend Wikipedia, http://mathworld.wolfram.com/ and math stack exchange. Wolfram has an article on nearly every topic and is really well categorized. In terms of what to focus on the most important subject is definitely linear algebra. Calculus and especially Vector calculus kind of help too but I would really focus hard on linear algebra. In particular try to really understand the following topics. These have definitely gone the longest way for me. What a normal vector to surface is Dot product Cross product Transformation matricies (mostly rotation matricies) Really understand how to use linear transformations hierarchically. (i.e. local position/rotation/scale as opposed to global position/rotation/scale) Bezier curves. Frenet-Serret formulas (useful if you're making wonky paths like roller coasters).
  4. 2.5D Engine?

    Mode7 is a specific case of a perspective projection from 3D to 2D. If you want anything more general you might as well just use a 3D engine. Another useful 2.5D strategy is to create sprite animations in 3D but store their 2D renderings and use the resulting 2D animation in the game. This works well in games like sidescrollers because the animation is independent of the camera's perspective. New Super Mario Bros is one game famous for doing this https://en.wikipedia.org/wiki/New_Super_Mario_Bros.#Development. The game is 2D and uses prerendered animations on sprites to make the game look and feel 3D.
  5. Lost in the Matrix

    Check out this article here https://msdn.microsoft.com/en-us/library/windows/desktop/ff684172(v=vs.85).aspx. The classic clock exercise will give you a good idea as to how rotations work and how to use them in Direct2D. Basically you will need to use the D2D1::Matrix3x2F class (particularly the D2D1::Matrix3x2F::Rotation(angle, center) function) to create a rotation matrix and then apply it to both lineP1 and lineP2 before rendering them.
  6. How to animate the UV correctly?

    I'm not aware of any kind of day-and-night skybox and I don't see one on google, but another option you have is interpolating between a day skybox with moving u and/or v offsets like @iedoc mentioned above and a night skybox. This way the clouds/sun are moving realistically and you still get a nice transition between times of day. You could even interpolate between dusk/dawn skyboxes as well in the transition. I'm not sure a day-and-night skybox would be a good idea since half the skybox would have to be bright and the other half would be dark. I think it would be hard to make that transition look good with one skybox.
  7. Best way to implement wall jump?

    I suppose you're right that OnCollissionEnter being called outside of FixedUpdate() can lead to awkward race condition scenarios. I never really thought of that. I use OnCollissionEnter because OverlapSphere only returns Collider[] and it's very weird to try and get things like distance between the two objects or normal of the closest surface. I have yet to find a good way of doing this. If you look into the dot product, the most meaningful thing to take away is that the dot product of two vectors (normalized vectors in this case) is equal to the cosine of the angle between them. cos(75 degrees) is about .25, so your code would really say: if(0.25f => Mathf.Abs(Vector3.Dot(<surface normal>, <up vector>)))..... If you notice that that number (.25) is too lenient you can always decrease it a little or increase it if you'd like more horizontal walls to be valid.
  8. Best way to implement wall jump?

    I think you're on the right track. You'll have the normal of the surface in OnCollisionEnter(collision) in collision.contacts, in contact.normal. Just use the dot product to determine if this surface isn't right for a wall jump. https://en.wikipedia.org/wiki/Dot_product If 90 to 75 degrees is your range of acceptable walls for jumping than any wall that satisfies the correct conditions will have cos(75 degrees) => Vector3.Dot(<surface normal>, <up vector>).
  9. What is an expression?

    I think the best answer for you if you're just now learning C# is to not get too caught up in the jargon this soon but to instead just be focused on how to code. The technical words and jargon come later. In the meantime try a tutorial site like this http://www.learncs.org/. There's information on everything you'd need to get started and an interactive code terminal that will definitely go a long way in helping you. I find most people learn how to program best when you're just allowed to experiment and play around with stuff. I've been a software developer for several years now and people seem to generally just consider expressions and statements as meaning a line or a few lines of code. I honestly can't even tell you the difference.
  10. Where are you located exactly? The industry definitely varies by location. Also you could try a government job. I've known a lot of people who've worked for my state and I have myself in the past. While the public sector almost always pays less it's typically much more stable than the private sector. Just firing a public employee takes a lot of jumping through hoops and red tape. Unless funding to the program you work for was cut there's almost no chance you'd be taken out of your job.
  11. PN triangle, barycentric lookup

    This paper here: https://pdfs.semanticscholar.org/a9a7/f783efa57d2486612d51e6d78c4a267559eb.pdf details a few useful ideas like how: 1. Given the 3 points and 3 normals of a PN Triangle, to generate the 7 Bezier control points. 2. Using those points we can create a function b(u,v,w) of the curve given where for u,v,w their sum is < 1 and they are all greater than 0. I'm not positive that this u,v,w translates directly into barycentric coordinates, but this paper should hopefully give you some useful info.
  12. Spatial Hashing.

      Yes, your math is correct and setting  42949672.96 = cell_size will make your lookup function work. However given how large your cells are this seems pretty large. I'm not sure how big sprites will be in your game, but the article recommended that the space of a cell be roughly twice as large as an average moving object in your game. Maybe a better course of action would be to determine how big you want your cells and use that equation above to find out how many you will need. Of course if you go for more cells you will have a larger array in memory, so you'll need to determine where the sweet spot is for performance. Larger spacial array and less objects to process per cell or a smaller spacial array with more objects per cell.  Another cool idea for performance tweaks would be to make sure your cell count is a power of 2 (which would make your cell size a power of 2 since your total world size is too) that way instead of dividing you can just right shift the bits of your coordinate (i.e. if cell_size = 2^6 instead of doing (int) (y / cell_size) you could do (int) (y >> 6) which is computationally cheaper than division, although it is less obvious programatically what you're doing).
  13. Am I in the right place?

    I'm willing to bet that most programmers here were web developers at some point or at least have some experience in JSON or REST. A while back when I was a student I made a turn based psychology game that was web based. It was a two player turn based game with a raw php backend. When making a move it would store the move in a MySql database, and each players' front end would continually poll every second for an update from the other player. So it's definitely possible to make a cool multiplayer game with just web based technologies! If you want to make a game with web-based technologies and fast net-working capabilities then I recommend checking out websockets (i.e. something like socket.io) as opposed to AJAX requests. My game on www.eternaldeathmatch.com uses three.js on the front-end (would highly recommend) socket.io for networking and a node.js back-end.
  14.   Yes, i look every sprite. So what you are saying, is to split game objects to two lists and make the loop work something like this: def mainLoop(self): '''staticSprites + movingSprites = all sprites inside the scene.''' for sprite in self.staticSprites: #Run static sprite scripts. #Render static sprite. for moving in self.movingSprites: #Run scripts of moving sprites. #Render moving sprites. #check collision using the quadtree and the moving sprites. please notice that inside the quadtree exists all the gameobjects (static and none static) because the quadtree is a space division Yea something like that would be good although I would avoid nesting the moving sprites loop in the static loop. It didn't look like this was intentional.  An even better idea, in my opintion, for organization purposes is to just have a static property on the sprites that way they can be distinguished but still be in the same list. This way they can still share a lot of the same logic. Kind of like below: [source] def mainLoop(self):          for sprite in self.sprites:         #logic for all sprites         if sprite.onScreen():             sprite.render()         if sprite.static:             #static sprite logic here         else:             #logic for dynamic sprites             if sprite.position.changed():                 self.quadtree.update(sprite)               #collisions will only occur when at least one object is not static             possible_collisions = self.quadtree.get()             for object in possible_collisions:                 sprite.getCollision(object)   [/source]
  15. When you loop through self.sprites are you looking at every sprite in the scene even the ones that don't move? If your bottleneck is the number of sprites, maybe just checking the ones that can move would reduce the iterations of your main loop if done the first way. This way every collision will still have a dynamic sprite attached to it since your static objects don't move. In modern game engines like Unity you can mark non-moving objects as static, and also the scripts on objects always run regardless of proximity to the camera.