I've been trying to export some data as a binary file which works for the most part the issue comes when I try to load up specific parts of that data if I don't go through the whole file in the exact same order it was written in it causes issues and my whole program depends upon being able to read specific parts of the binary file Instead of reading the whole thing in the exact order that it was created in. Any advice will be greatly appreciated.

I would like to ask if anybody know a good way to create a 3D volumetric fog for an Android game.

I just found this asset, but it seems imposible to use for Android games

Anybody knows a good optimized way to make some kind of volumetric fog that could works well for android games?

The game is a 2,5D horizontal scrolling, but the scenario is full 3D.

Thanks in advance

The discussion that started it all *note* I am not /u/Halfspacer

Fogsight thinks the situation is orchestrated by a bunch of trolls, however, it has grown to become a serious community moderation debacle. Not to mention they are virtue-signaling what kind of content is deemed \"helpful.\" I don't think anyone should be in charge of moderating \"if a solution was not helpful enough.\"

Another unjust ban! I've counted at least 4 bans regarding this situation now none of them justififed in my eyes.

My response to fogsight (I had a friend message and ping them this)

Fogsight's response! Remember all I did was react with 3 emojis expressing my disdain for how /u/Halfspacer was treated when accused of posting LLM code that they claim is NOT LLM.

It's incredible to me that the situation has developed this far in the span of a few hours, I was an avid contributor to the DOTS discussion thread. Although I have been inactive for 7 months (I stopped working on my passion project, and was busy with IRL) Fogsight deemed that I must be a troll and a spammer (3 emojis lol) and decided I deserved a rightful ban (and others who have come to my side to back me up)

I already posted this in Unity Forum. But got no answer, I really don't know where this is coming from.

I created my own Action-Map, but it doesn’t work if I set the preset scheme to mouse and keyboard. But the strange thing is the UI Action Map works perfectly when set to keyboard & mouse. Any idea why this happens?
No Input-event that the player would use, goes though, meaning: If I try something simple like press"L" to send a Log-message, it doesn’t work. But work if is use the Same thing in my gameManager, with the same input. Why? Is the Player-Prefab not connected to the input-Events?

Player Prefab

Player Settings

In Short: No Input Scheme works with the player if he is set to Keyboard, but I works when set to <any> Scheme.

My Code that I test by the Way:

   public void TestInputEvent(InputAction.CallbackContext context) {
    if (context.performed) {
        Debug.LogError("IT WORKED");
    }
   }

Player Move Input

Player Move Input shows with Keyboard scheme

UI Map

im making modular assets in blender so i can put together little houses for a small town in unity. should i model the walls and such as planes or blocks? ive heard that planes can have some issues with lighting, but maybe that was about something else, or a different engine.

regard this image for a moment https://imgur.com/a/y7OeVnN
the squares are 3d modeled pillars that i will use to connect the walls. if the walls are planes, will there be any lighting issues when the player enters the building? (seamless buildings, no load screens) as in, any kind of light bleed coming from outside? or should the walls be fine as planes? or should i make them 3d blocks/rectangles instead?
ive never done modular/architecture before so any other tips are welcome.

I have standard animations for movement and I make use of blend trees. I have idle, walk, backwards walk, sprint, strafe left + right walk & sprint. It took me a lot of learning to get them to work quite well but now I am struggling a bit when it comes to arm specific animations like holding and moving with weapons.

Online there are lots of free animations for this such as "Pistol/Rifle Idle" and "Pistol/Rifle Run", and also for crouching and jumping while holding weapons.

So is inverse kinematics necessary at all for any of this? I am not trying to make my first person animations or movement realistic. The only two uses I can think of here for inverse kinematics is to get a slightly more accurate hand position on the grip of the gun if the animation position isn't perfect by default, and the second would be to make the player head/chest rotate before the whole body does when looking left or right, but I'm not really trying to implement the second one.

Title lil embarresed to ask but, i tried googling but every guide (not that there'd be many) is either really old. I wonder if there's proper way to do it in Unity over the years, or i gotta go by them?

Hey yall, I’ve used unity way back In like prob 2018 when I was in a game development course. I have since dropped the program and went with IT instead as a career but I want to pick this back up as a hobby. Where should I start? I like learning the programming aspect and I’m trying to make a “slender”-like game. Is there certain readings/books that are useful? Or should I just go thru whatever documentation / program unity has for 3d building? Edit: or any YouTubers that simplify and make relearning the engine simple?

Introduction:

In this post, I’d like to share the concrete steps we took to balance our game, the reasoning behind our choices, and some practical takeaways that other developers might find useful.

When developing a game (in our case a tower defense game), achieving a balanced gameplay experience can be challenging and time-consuming. Each tower’s unique attack patterns, from high-area-of-effect splash damage to precise single-target shots, must feel distinct yet fair. In Tower Alchemist, we spent a significant amount of time designing and refining a balancing methodology that would allow our towers, enemies, and ability systems to scale cohesively and remain engaging across multiple difficulty tiers.

Now as we know the problem... how did we do it?

Establishing a Baseline: Damage per Gold
Our first major balancing question was: How do we ensure that all towers, regardless of their firing style or effect, align with a common baseline metric? We decided to focus on a simple yet powerful metric: Damage per Gold (DPG).

1. Controlled Test Environment: We created a test level where enemy units marched along a straight path. Adjacent to this path, we automatically placed six identical towers, ensuring consistent conditions. By using a fixed number of enemies (30 in our case), we could reduce variance caused by subtle positional differences —like a tower missing out on a shot due to a target stepping out of range by a few pixels or muzzle rotation timings.
2. Measuring Performance: As enemies walked through the gauntlet of these six towers, we recorded the total damage dealt. We then divided this value by the amount of towers and the tower’s construction cost in Gold, yielding a DPG value. For example, if an Arrow Tower dealt a total of 600 damage and cost 100 Gold, it effectively achieved 6 damage per gold coin spent.
3. Normalizing Across Towers: With this standardized metric, we could tune all other tower types—Cannons, Death, Life, Water, Fire, and so forth—such that they landed at a known DPG. Although we set a common baseline (in our case, 6 damage per Gold for mid-tier towers), we still preserved each tower’s unique flavor by adjusting their cost and damage output proportionally. This ensured that more expensive magic towers (like Death and Life) could achieve higher total damage outputs since their cost scaled up, maintaining fairness and consistency.

From Tower Balance to Level Design
Once we had a solid baseline for tower strength and balanced all towers to 6 DPG, we could leverage that data to design our levels more systematically:

1. Predictable Player Damage Output: If we know that 100 starting Gold translates into approximately 600 damage potential (based on our chosen 6 DPG baseline), we can reverse-engineer the enemy stats. For an opening wave, we might use 20 mobs with 30 HP each (20 x 30 = 600 total HP) to ensure it feels challenging but fair. The player who invests their starting Gold efficiently should be able to handle that wave comfortably, while a misallocation of resources might cause leaks.
2. Scaling Difficulty with Economic Progression: As waves progress, players earn more Gold from defeated mobs. By adding the newly acquired Gold to the initial amount, we can predict future player potential damage and scale enemy HP accordingly. For example, after the first wave, players may gain 40 Gold (2 Gold per enemy), pushing their total available resources for the second wave to roughly 140 Gold. With a known DPG of 6, that’s about 840 damage potential—meaning wave two can feature 20 mobs at 42 HP each.
3. Automating Wave Calculation with Spreadsheets: We conducted all these iterative calculations in a Google Sheets document. By applying simple formulas, we could quickly generate stats for up to 30 waves. At wave 30, with a projected 1260 Gold available to players, we might field enemies with around 378 HP. This approach allowed us to reliably scale difficulty and ensure a smooth progression curve without guesswork.

IMAGE: Calculation of the Mob Health via DPG Value

Incorporating Abilities with Diminishing Returns
Difficulty isn’t just about raw hit points; it’s also about the complexity of enemy abilities and how they synergize over time. As the game progresses, we introduce abilities such as Heal and Sprint. To prevent ability spam and maintain incremental complexity, we developed a system that uses an “Ability Strength” (AS) currency per wave:

1. Ability Strength and Cost Scaling: Each wave has a set amount of Ability Strength to allocate. Abilities have a base cost, and placing a mob with that ability consumes some of the AS budget. For example, if a wave has 20 AS:This incremental cost, known as diminishing returns, ensures that stacking many identical abilities in one wave becomes increasingly expensive. This prevents singular strategies like “all Heal” or “all Sprint” mobs and encourages a balanced, diverse set of enemy abilities.
   • Heal might cost 5 AS per use.
   • Sprint might cost 1 AS for the first unit, but the cost increases incrementally (the second Sprint unit costs 2 AS, the third costs 3 AS, etc.).
2. Practical Example: Let’s say we have 20 AS for a wave. The Script now starts "buying" The first Sprint-mob at a costs of 1 AS, the next costs 2 AS, then 3, 4, and finally 5 for the fifth Sprint-mob, Summing these up (1+2+3+4+5=15) leaving us with a rest of 5 AS which can be spend with a 50% chance as another spring mob or a heal mob. This creates interesting, escalating challenges without just inflating HP numbers.
   • 1 Heal-mob
   • 5 Sprint-mobs
   • 14 standard mobs (no ability cost)

IMAGE: Overview how our Ability Strength System calculates the amount of abilities that are "bought" by Mobs.

Dynamic Difficulty Adjustments
To offer multiple difficulty modes—Easy, Medium, Hard—we implemented a dropdown in our spreadsheet. Selecting a difficulty mode applies a multiplier to baseline assumptions like DPG and Ability Strength. For example, switching from Easy to Medium might increase Ability Strength and enemy HP by 30%, while Hard could bump these by 50%. Within seconds, we can generate balanced variants of entire levels at different challenge levels, ready for playtesting.

IMAGE: Increasing Difficulty via a simple Dropdown menu and a percent value.

Takeaways for Other Developers

• Start with a Clear Metric: Using a simple measure like damage per Gold provides a solid anchor point for all subsequent balancing efforts.
• Automate Your Math: Spreadsheets (or simple scripts) can handle a lot of the heavy lifting. They let you experiment quickly and see the cascading effects of a single balance tweak.
• Introduce Systemic Complexity: Add complexity incrementally. Use systems like diminishing returns for abilities to maintain variety and depth without resorting solely to HP inflation.
• Scalable Difficulty: Build a framework that supports quick adjustments. Being able to switch difficulty modes or regenerate stats for multiple waves at a click of a button is a huge time-saver.

Conclusion and Feedback Request
This balancing approach helped us shape Tower Alchemist into a more coherent and strategically rich experience. By starting with a clear baseline, using automated calculations, and layering in complexity like abilities with diminishing returns, we were able to craft a difficulty curve that feels both fair and dynamic.

We’d love to hear your thoughts on our balancing process. What worked well? What would you approach differently? Feel free to check out our demo, try it yourself, and let us know what you think. If you like what you see, consider wishlisting us on Steam. See it as a reward from you to us for sharing our thoughts :D

Check out the Tower Alchemist: Defend Khaldoria demo:
https://store.steampowered.com/app/1866380/Tower_Alchemist_Defend_Khaldoria/

Sorry for any typo errors or misunderstandings, its not my native language ^^

In light of recent drama you can read it here: https://www.reddit.com/r/Unity3D/comments/1hh68ab/unitys_official_discord_is_a_has_a_moderator/

Yep, you read that right “Fogshit” banned me over 3 little emotes.

the reason: SPAM

I did not post any other messages and I did not do anything else. I truly believe this is an abuse of power as I have been a longstanding member of the discord and have contributed to intellectual discussion many times helping out noobs and pros alike.

I’m calling for Fogsight to be removed from the moderation team, this is unacceptable behavior and an active attempt to censor free speech (just because they don’t like what I did)

Im going to make my own system and its going to be a mix of boneworks and pavlov but with a cartoonish style

The guy had a really simple question about coroutines in his tiny code snippet, but instead of answering it, the mod spent a good 10 minutes berating him for not using PasteBin.

So I took the time out of my day to explain how coroutines work and show what his code snippet might look like using it. But then...