8 TIPS to get MORE WISHLISTS!

1. Take part in the Steam fest
2. Make sure the game is polished
3. Provide a really good tutorial to teach players how to play the game
4. Implement analytics, especially for tutorial to track at which step users drop the game
5. Use Cloud Diagnostics (a Unity service for errors and crashes)
6. Add an in-game feedback form
7. Boost wishlists a week before the fest
8. Do livestreams during the fest

https://www.youtube.com/watch?v=-cnjCyYCxxc

#marketing

noio/games.noio.planter: The plant simulation from Cloud Gardens as a Unity package for level design.

https://github.com/noio/games.noio.planter

#vegetation

Optimize struct performances using StructLayout

I ran a simple benchmark that passes structs as an argument: one uses StructLayout.Sequential and another StructLayout.Auto.
I intentionally ordered fields in a way that makes them have padding.

And result is (the formatting in mobile clients sucks):
| Method | Mean | Ratio |
|------- |---------:|------:|
| Auto | 298.6 us | 1.00 |
| Seq | 359.0 us | 1.20 |

Obviously copying struct that is bigger due to the padding to pass it as an arg is slower. But this operation is so quick that it might be a problem only on a very hot path.
It can be avoided by using 'ref' parameter so no copying occurs. I've also thrown readonly structs to the test.
| Method | Mean | Ratio |
|------------- |---------:|------:|
| Auto | 318.5 us | 1.00 |
| Seq | 398.7 us | 1.25 |
| AutoRef | 254.5 us | 0.80 |
| SeqRef | 299.7 us | 0.94 |
| AutoReadonly | 312.9 us | 0.98 |
| SeqReadonly | 390.5 us | 1.22 |

As you can see passing both structs by ref is definitely faster. But Auto is again faster than Sequential. While readonly structs don't have any performance benefits according to this benchmark. To make sure a defensive copy of a readonly struct is avoided, I've also added 'in' parameter to the arg and now we can see that structs are not copied anymore and performance is on par with the 'ref' parameter
| Method | Mean | Ratio |
|--------------- |---------:|------:|
| Auto | 299.9 us | 1.00 |
| Seq | 369.1 us | 1.23 |
| AutoRef | 245.1 us | 0.82 |
| SeqRef | 305.7 us | 1.02 |
| AutoReadonly | 309.1 us | 1.03 |
| SeqReadonly | 369.6 us | 1.23 |
| AutoReadonlyIn | 255.4 us | 0.86 |
| SeqReadonlyIn | 303.4 us | 1.02 |

I performed all these benchmarks in .NET. It would be very interesting to look at it in Unity using IL2CPP, whether it affects performance in C++ or not.

https://www.meziantou.net/optimize-struct-performances-using-structlayout.htm

#optimization #struct #layout #ref

Designing a Realtime Combat System. This article is about melee combat foremost.

A great list of combat mechanics, how and when each of them should be used or not. Must help a lot when designing combat in your game.

https://howtomakeanrpg.com/a/designing-a-realtime-combat-system.html

#combat #platformer

Speed up the build process of your Unity projects

It's a great post with practical steps based on real experience. I can confirm that these steps are helpful, as I had been working on the same project when these approaches were introduced.
It would be also interesting to read more about splitting the code base into multiple projects and how to properly handle the build process in that case as no references were provided in the post.

https://medium.com/@wondrous_aqua_toad_341/speed-up-the-build-process-of-your-unity-projects-a4e3f048c32f

#build

Dependency injection

The author clearly shows how dependency injection helps make code more maintainable and testable.

https://youtu.be/J1f5b4vcxCQ

#pattern #di

Developing SWIFT, Part 1: Combat & Gameplay Mechanics

The breakdown of combat and gameplay design decisions in a competitive melee combat action game

https://80.lv/articles/developing-swift-part-1-combat-gameplay-mechanics/

#gamedesign #combat

Use string.Equals with StringComparison.OrdinalIgnoreCase parameter instead of manually adding ToLower()/ToUpper() for better performance and cleaner code.

#string #performance

Custom SRP 1.0.0

How to upgrade the old SRP tutorial to Unity 2022. Some of these fixes I had to do myself when I followed this series a long time ago but using Unity 2021. It's great that Jasper supports the series and shared the update.
I personally recommend this series as it not only shows steps how to implement your own rendering pipeline, but gives an idea how some parts of rendering work in general.

https://catlikecoding.com/unity/custom-srp/1-0-0/

#srp

Mesh-Peeling

https://github.com/bunszr/Mesh-Peeling

#mesh #peel

Intro to DOTS animation

No, there is still no solution provided by Unity as part of DOTS.
The author shows how to use a hybrid animator approach, similar to one shown in DOTS character controller samples.
The video also shows the simplest example how to use 2 most popular animation assets from the asset store.

https://youtu.be/KvabbZKrUHk

#dots #animation

Dependency Injection on Unity

Another post why DI might be useful. But it also contains an implementation of a custom DI container, which is a great way to learn how containers work under the hood, especially how injections into MonoBehaviors work

Part 1: https://moderncsharpinunity.github.io/post/dependency-injection-on-unity/

Part 2: https://moderncsharpinunity.github.io/post/dependency-injection-on-unity-part2/

#di

Day Night Cycle using LUT in Fragment Shader of Materials

https://shahriyarshahrabi.medium.com/day-night-cycle-using-lut-in-fragment-shader-of-materials-80edaf26f655

Repo: https://github.com/IRCSS/Day-Night-LUT-Shader

#shader #lut

You can go a long way just by multiplying and adding simple textures in a creative way. ❄ Check out this frozen effect! Adding a few extra particles sells the illusion

https://twitter.com/unitygames/status/1536725196274642944

#vfx #frozen

Particle Effect For UGUI (UI Particle): This plugin provide a component to render particle effect for uGUI in Unity 2018.2 or later.
The particle rendering is maskable and sortable, without Camera, RenderTexture or Canvas.

It also correctly scales particles and provides better performance with mesh sharing feature.

https://github.com/mob-sakai/ParticleEffectForUGUI

#ui #particle

Moving faster

I find this very useful to help structure your development process. In the university I had the Personal Software Process (PSP) course that was also aimed to make each part of software development lifecycle more effecient. This post obviously does not cover what the whole course teaches you about, but it's a good place to start.
I also feel The Pragmatic Programmer vibes in this post. Some advice are directly from this book. So if you liked the post, you may take a look at the book too.

https://www.scattered-thoughts.net/writing/moving-faster/

#psp #productivity

Exarion

This tool makes a greyscale texture that tells each pixel when it should display itself. It helps create these types of textures easier.

https://botsop.itch.io/exarion

#vfx

Vertex Color Baker

An AssetPostprocessor for Unity that can bake ambient occlusion and curvature information into mesh vertex color channels, mainly intended for mid-poly workflows and procedural hard surface shaders.

https://github.com/Fewes/VertexColorBaker

#ao #vertexcolor

How to access worldwide your WebGL build from the local machine

https://medium.com/@wondrous_aqua_toad_341/how-to-access-worldwide-your-webgl-build-from-the-local-machine-b506c24a4dbd

#webgl

C# Journey into struct equality comparison, deep dive

A great post that dives into reasoning behind implementing IEquatable<>: where exactly allocations happen and that default ValueType Equals implementation uses structural comparison only for tightly packed structs, otherwise field-by-field comparison is used which utilizes reflection.
For us it means that we must implement IEquatable<> in our structs in case they are compared, which is common case when used in collections (dictionary, list, array, etc).

https://medium.com/@semuserable/c-journey-into-struct-equality-comparison-deep-dive-9693f74562f1

#performance #equals

Unity HDRP & ShaderGraph: Nodes that Bloat Shaders

It's nothing new that Shader Graph generates less-than-ideal code, but it's still interesting to examine in detail and see which more optimal solutions the author proposes.

https://justlukass.hashnode.dev/shadergraph-can-bloat-your-shaders-and-here-is-when

#performance #shader