<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dinesh on Medium]]></title>
        <description><![CDATA[Stories by Dinesh on Medium]]></description>
        <link>https://medium.com/@dineshrajasekaran04?source=rss-cc109201715d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*I_18le4dDBbqY-nBvFQA5w.png</url>
            <title>Stories by Dinesh on Medium</title>
            <link>https://medium.com/@dineshrajasekaran04?source=rss-cc109201715d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 09:26:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dineshrajasekaran04/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Plan a Game Vertical Slice in 7 Days with a One-Page GDD]]></title>
            <link>https://medium.com/@dineshrajasekaran04/how-to-plan-a-game-vertical-slice-in-7-days-with-a-one-page-gdd-1d1159385aef?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d1159385aef</guid>
            <category><![CDATA[game-design-document]]></category>
            <category><![CDATA[game-design]]></category>
            <category><![CDATA[video-games-industry]]></category>
            <category><![CDATA[gdd]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 03:18:03 GMT</pubDate>
            <atom:updated>2026-10-30T00:53:01.689Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*39cf0AdXnJrMz-sW.png" /></figure><p>Most solo devs skip the game design document because it feels like homework. Then scope creep eats a month.</p><p>I’m building <strong>Phantom Signal</strong>, a tactical FPS in Unity 6 where you switch your weapon’s frequency (Red, Blue or Green) to break enemy defenses and open the facility around you. Before building anything like it, I write a short GDD. Here is the method, using Phantom Signal as the example.</p><h3>Step 1: Write a one-page pitch</h3><p>If you can’t explain the game on one page, the idea isn’t ready. A simple table is enough:</p><p>Genre: Tactical first-person shooter with puzzle elements</p><p>Platform: WebGL on CrazyGames first, Steam later</p><p>Scope: Vertical slice: Training Facility (5 connected missions)</p><p>Hook: Frequency switching changes how the whole level behaves, not just the weapon</p><p>Audience: Fans of tactical shooters who like short, replayable missions</p><p>The hook line matters most. If you can’t write one, you don’t know why the game is different yet.</p><h3>Step 2: Describe the core loop in five lines</h3><ol><li>Enter a room and scan for what reacts to which frequency</li><li>Switch frequency</li><li>Shoot, hack or open the matching target</li><li>Clear the room and pass the blast door</li><li>Finish the mission, earn a rating, unlock the next one</li></ol><p>Then add one sentence on why that loop is fun. For me it’s fast decisions and clear feedback.</p><h3>Step 3: List your risks before they find you</h3><p>Writing “scope creep: high” in a table makes it much harder to ignore later.</p><h3>Step 4: Put the whole slice on a 7-day schedule</h3><p>This is the example schedule from my GDD template, filled in for Phantom Signal:</p><p>The “Done when” column is the useful part. Every day ends with something you can actually play.</p><h3>Two rules that keep it honest</h3><ul><li><strong>End every day with something playable.</strong> A plan that only works on paper doesn’t count.</li><li><strong>Freeze the feature list early.</strong> Lock it before Day 3 and add nothing new after Day 5. After that, only fix and polish.</li></ul><h3>Want the templates?</h3><p>I turned this into a bundle: a <strong>Lite</strong> GDD template (11 sections) and a <strong>Full</strong> one (pitch, design and production plan), each with a filled-in Phantom Signal example. It works for any engine and any genre.</p><p><a href="https://mardnstudio.gumroad.com/l/gdd-template-bundle"><strong>Get the GDD Bundle on Gumroad</strong></a> (I made it, so this is my own product).</p><p>What do you put in your GDD, and what do you skip? Tell me in the comments.</p><p><em>Originally published at </em><a href="https://dev.to/dinesh_04/how-to-plan-a-game-vertical-slice-in-7-days-with-a-one-page-gdd-e7"><em>https://dev.to</em></a><em> on October 29, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d1159385aef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Switching from Unreal Engine to Unity Felt Surprisingly Difficult]]></title>
            <link>https://medium.com/@dineshrajasekaran04/why-switching-from-unreal-engine-to-unity-felt-surprisingly-difficult-4f097432c103?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f097432c103</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[beginner]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 15:16:11 GMT</pubDate>
            <atom:updated>2026-07-03T15:16:11.550Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Day 105 of my game dev journey — beginner lessons, real confusion, real progress.</em></p><p>I thought learning Unity would be easy after spending months in Unreal Engine.</p><p>Instead, even simple tasks felt strangely difficult.</p><p>That’s when it hit me: I wasn’t learning a new engine. I was trying to force Unreal Engine habits into Unity.</p><p>This post is part of my daily learning journey in game development, where I share the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 105, I explored what it actually feels like to switch from Unreal Engine to Unity.</p><p><strong>What I Used to Think</strong></p><p>Since I already knew Unreal Engine, I assumed Unity would come naturally. Both engines build games, after all. I expected my existing knowledge to transfer almost instantly.</p><p>It didn’t — not the way I expected.</p><p><strong>What I Realized</strong></p><p>The concepts are similar. The workflow isn’t.</p><p>Unity is built around GameObjects and Components. Unreal Engine is built around Actors, Components, and Blueprints. Same destination, different roads.</p><p>Even basic tasks — creating objects, navigating the editor, finding settings — felt unfamiliar, because I kept expecting Unreal’s layout and logic to show up in Unity.</p><p><strong>Why This Was Harder Than Expected</strong></p><p>The real challenge wasn’t relearning game development. It was unlearning how I think about engines.</p><p>I wasn’t struggling with Unity. I was struggling with my Unreal habits. Every time I searched for an “Unreal equivalent” instead of learning Unity’s own approach, I slowed myself down.</p><p><strong>What Finally Clicked</strong></p><p>The problem wasn’t Unity. The problem was my mindset.</p><p>Once I stopped comparing every feature to Unreal and started learning Unity on its own terms, things got easier — fast.</p><p>Instead of asking “Where’s the Unreal version of this?” I started asking “How does Unity solve this problem?”</p><p>That one shift changed everything.</p><p><strong>How to Make the Switch Easier</strong></p><p>Learn Unity’s terminology before comparing it to your old engine. Build one small project start to finish instead of just browsing the editor. Accept that workflows differ, even when concepts overlap. Focus on one engine at a time while you’re learning. And expect menus, tools, and shortcuts to live in completely different places than you’re used to.</p><p><strong>Why This Matters Beyond Unity</strong></p><p>Professional developers often switch between engines throughout their careers. The valuable skill was never memorizing editor layouts — it’s understanding game development fundamentals and adapting that knowledge to whatever workflow you’re in.</p><p>Once I stopped treating Unity like “a different version of Unreal” and started treating it as its own engine, learning got genuinely enjoyable.</p><p><strong>The Takeaway</strong></p><p>Switching engines doesn’t mean starting from zero. You already have the fundamentals. It’s just about learning a new way to apply them.</p><p>Slow progress — but a strong foundation.</p><p>If you’ve switched engines before, what was the first thing that confused you? Drop it below 👇</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f097432c103" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Switching from Unreal Engine to Unity Felt So Difficult]]></title>
            <link>https://medium.com/@dineshrajasekaran04/why-switching-from-unreal-engine-to-unity-felt-so-difficult-54f5d3c3f309?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/54f5d3c3f309</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <category><![CDATA[unity]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Thu, 02 Jul 2026 10:27:39 GMT</pubDate>
            <atom:updated>2026-07-02T10:27:39.509Z</atom:updated>
            <content:encoded><![CDATA[<p>I thought learning Unity would be easy after spending months in Unreal Engine.</p><p>Instead, even simple tasks felt surprisingly difficult.</p><p>That’s when I realized I wasn’t learning a new engine — I was trying to use Unreal Engine inside Unity.</p><p>This post is part of my daily learning journey in game development. I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On <strong>Day 104</strong> of my game development journey, I explored the biggest challenge of switching from Unreal Engine to Unity.</p><h3>What I Used to Think</h3><p>I assumed my Unreal Engine experience would make Unity easy to learn.</p><p>After all, both engines are built to create games.</p><p>So I expected to recognize most of the workflow immediately.</p><h3>What I Realized</h3><p>Both engines solve the same game development problems — but they do it in completely different ways.</p><p><strong>Unity</strong></p><ul><li>Uses <strong>GameObjects</strong> and <strong>Components</strong></li><li>Most functionality is added through Components</li><li>C# scripts control behavior</li></ul><p><strong>Unreal Engine</strong></p><ul><li>Uses <strong>Actors</strong>, <strong>Components</strong>, and <strong>Blueprints</strong></li><li>Gameplay systems are organized differently</li><li>Visual scripting is deeply integrated into the workflow</li></ul><p>The concepts are similar.</p><p>The workflows are completely different.</p><h3>Why This Matters</h3><p>The hardest part wasn’t learning game development concepts.</p><p>It was changing my habits.</p><p>I kept searching for Unreal Engine features inside Unity.</p><p>Even simple tasks like navigating the editor, creating objects, and finding settings took much longer — because I expected Unity to behave like Unreal Engine.</p><p>Game development knowledge transfers.</p><p>Muscle memory doesn’t.</p><h3>What Finally Clicked</h3><p>The problem wasn’t Unity.</p><p>The problem was my mindset.</p><p>I stopped asking:</p><p><em>“Where is the Unreal Engine version of this feature?”</em></p><p>And started asking:</p><p><em>“How does Unity solve this problem?”</em></p><p>That shift made everything click faster.</p><h3>Practical Fix</h3><ul><li>Learn Unity terminology before comparing it to Unreal Engine</li><li>Build one small Unity project from start to finish</li><li>Accept that workflows are different — and that’s okay</li><li>Focus on understanding Unity’s architecture on its own terms</li><li>Avoid searching for Unreal Engine equivalents every time you get stuck</li></ul><h3>One Lesson for Beginners</h3><ul><li>Game development concepts transfer between engines</li><li>Editor workflows do not</li><li>Every engine has its own philosophy</li><li>Small projects help you adapt faster</li><li>Be patient while rebuilding muscle memory</li></ul><h3>Why This Matters in Real Projects</h3><p>Many developers eventually work with more than one game engine.</p><p>The real skill isn’t memorizing menus.</p><p>It’s understanding the underlying concepts and adapting to different workflows.</p><p>Once you stop comparing engines and start learning each one on its own terms, switching becomes much easier.</p><p>Learning a new engine doesn’t mean starting from zero.</p><p>Your knowledge comes with you.</p><p>You just need to learn a different way of applying it.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the biggest surprise when you first switched tools or engines?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54f5d3c3f309" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why 2D Animation Setup in Unity Is Harder Than the Game Logic Itself]]></title>
            <link>https://medium.com/@dineshrajasekaran04/why-2d-animation-setup-in-unity-is-harder-than-the-game-logic-itself-272464dee395?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/272464dee395</guid>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[2d-game-development]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 17:25:35 GMT</pubDate>
            <atom:updated>2026-07-01T17:25:35.488Z</atom:updated>
            <content:encoded><![CDATA[<p>This post is part of my daily learning journey in game development. I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 103 of my game development journey, I worked on 2D animations in Unity — and realized that writing the game logic was the easy part. Setting up the animations was a completely different challenge.</p><h3>What I Used to Think</h3><p>I assumed 2D games were simpler than 3D.</p><p>Less geometry. Less complexity. Less setup.</p><p>So when I started building a basic 2D game in Unity, I expected everything to feel easier — including the animations.</p><p>I was wrong about that last part.</p><h3>What Actually Happened</h3><p>The game logic came together faster than I expected.</p><p>Moving the character. Detecting collisions. Handling jumps. Writing C# scripts for these felt straightforward once I understood Unity’s component system.</p><p>Then I moved to animations.</p><p>I had my sprite sheet ready. I had my frames. I thought it would be a simple drag and drop.</p><p>It wasn’t.</p><h3>Where It Got Complicated</h3><p>Unity’s animation system has multiple layers working together — and as a beginner, I had no idea going in.</p><p>First there’s the <strong>Animation Clip</strong> — the actual recorded movement. Each action like idle, run, and jump is its own clip.</p><p>Then there’s the <strong>Animator Controller</strong> — a state machine that decides which clip plays and when. You build it visually using nodes and transitions inside the Animator window.</p><p>Then there are <strong>Parameters</strong> — boolean, integer, float, or trigger values that your script sends to the Animator to tell it when to switch states.</p><p>And finally there’s the <strong>Animator component</strong> — attached to your GameObject — which connects everything together at runtime.</p><p>Four separate things. All connected. All needing to be set up correctly before a single animation plays.</p><p>The game logic was one script. The animation system was an entire pipeline.</p><h3>What Confused Me</h3><p>I kept asking the same questions.</p><p>Why is my character stuck on the idle animation even though the player is moving?</p><p>Why does the transition not trigger when I press the key?</p><p>Why is the animation playing but the character isn’t moving with it?</p><p>Each problem had a different answer. A wrong parameter name. A missing transition condition. A script referencing the wrong Animator component.</p><p>Small mistakes. Big confusion.</p><h3>Why It Happens</h3><p>Game logic in Unity is mostly linear. Write a script. Attach it. Test it.</p><p>Animation in Unity is a state machine. You’re not just writing logic — you’re building a visual flow of states and rules that the Animator follows at runtime.</p><p>State machines are powerful. But they have their own rules, their own vocabulary, and their own way of breaking when one thing is off.</p><p>For a beginner coming from basic scripting, it’s a real mental shift.</p><h3>What Finally Clicked</h3><p>The Animator Controller isn’t just a tool — it’s a second layer of logic on top of your scripts.</p><p>Your C# script controls the game. The Animator Controller controls the visuals. They talk to each other through parameters.</p><p>Once I started thinking of them as two separate systems that communicate — instead of one thing — the setup started making sense.</p><pre>// Example: telling the Animator the player is running<br>Animator animator = GetComponent&lt;Animator&gt;();<br>animator.SetBool(&quot;isRunning&quot;, true);</pre><p>One side handles the rules. The other side handles what the player sees.</p><h3>Practical Steps That Helped</h3><ul><li>Slice your sprite sheet properly in the <strong>Sprite Editor</strong> before doing anything else</li><li>Create one Animation Clip per action — idle, run, jump, fall</li><li>Open the <strong>Animator Controller</strong> and add each clip as a state</li><li>Set up transitions between states with the right conditions</li><li>Create parameters in the Animator that match exactly what your script sends</li><li>Use SetBool, SetFloat, or SetTrigger in your script to drive the transitions</li><li>Test one animation at a time — don’t wire everything up at once</li></ul><h3>One Lesson for Beginners</h3><ul><li>The Animator Controller is a state machine — understand that concept first</li><li>Parameter names in the Animator must match exactly what your script uses</li><li>Transitions need conditions — they won’t switch automatically without them</li><li>Slice your sprite sheet before creating clips — order matters</li><li>Debug one animation state at a time, not the whole system at once</li></ul><h3>Why This Matters in Real Projects</h3><p>In professional 2D game development, animation is one of the most time-consuming parts of production.</p><p>Even simple characters need multiple states — idle, walk, run, jump, fall, attack, hurt, death. Each state is a clip. Each transition is a rule. The Animator Controller grows fast.</p><p>Understanding how Unity’s animation pipeline works early — the clips, the controller, the parameters, the component — saves a lot of frustration later when the character count and animation count grow.</p><p>Game logic tells the game what to do. Animation tells the player what’s happening.</p><p>Both matter. But animation takes more patience to set up right.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=272464dee395" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Beginners Skip Version Control and Regret It Later]]></title>
            <link>https://medium.com/@dineshrajasekaran04/why-beginners-skip-version-control-and-regret-it-later-926637a8a6a3?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/926637a8a6a3</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[version-control]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 16:46:08 GMT</pubDate>
            <atom:updated>2026-06-30T16:46:08.243Z</atom:updated>
            <content:encoded><![CDATA[<p>This post is part of my daily learning journey in game development. I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 101 of my game development journey, I explored Unity Version Control and Git integration inside Unity Hub — and honestly, I wish I had looked at this sooner.</p><h3>What I Used to Think</h3><p>Version control felt like a professional developer thing.</p><p>Something for big teams. Big projects. Not for a beginner working alone on small games.</p><p>So I skipped it completely.</p><p>My backup system? Duplicate folders. Zip files. Files named like project_final, project_final_v2, project_ACTUALLY_final.</p><p>It worked. Until it didn’t.</p><h3>What I Was Doing Instead</h3><p>Every time I made a big change, I copied the entire project folder and renamed it with a date.</p><p>It felt safe. It wasn’t.</p><p>One wrong save. One bad import. One afternoon of breaking something I couldn’t undo — and I lost hours of work with no way to go back.</p><p>That’s when I started taking version control seriously.</p><h3>What I Found in Unity Hub</h3><p>I expected version control to be complicated.</p><p>Install Git separately. Configure terminal commands. Write commit messages into a black screen.</p><p>But Unity made it much more approachable than I expected.</p><p>Inside Unity Hub, you can link a Git repository directly to your project. Unity also has its own dedicated system called <strong>Unity Version Control</strong> — previously known as Plastic SCM — which goes even further with visual branching, file locking, and full project history.</p><p>Unity Version Control has its own UI built directly into the Unity Editor. I didn’t need to touch a terminal to get started.</p><p>That surprised me.</p><h3>What Unity Version Control Actually Does</h3><p>Unity Version Control tracks every change you make to your project.</p><p>Every scene edit. Every script change. Every asset added or removed.</p><p>If something breaks, you can roll back to a previous version in a few clicks. If you want to try something risky without ruining your current progress, you create a branch — a separate copy of your project — experiment freely, and merge it back if it works.</p><p>Git integration works similarly. You connect your local project to a remote repository — GitHub, GitLab, or Bitbucket — and push your progress as you go.</p><p>Both options give you a safety net that zip files never could.</p><h3>What Finally Clicked</h3><p>Version control isn’t just for teams.</p><p>It’s a safety net for solo developers too.</p><p>Every time you commit your progress, you’re creating a restore point. Like a save state in a game — but for your entire project.</p><p>The moment I understood that, it stopped feeling like extra work.</p><p>It became part of the workflow.</p><h3>Why I Actually Liked Unity’s Approach</h3><p>Unity made this easier than I expected.</p><p>Unity Version Control is built specifically for game projects. It handles large binary files like textures and audio better than raw Git does — because plain Git wasn’t designed for large assets. Unity Version Control was.</p><p>For solo developers and small teams, the free tier covers everything you need to get started.</p><p>It felt designed for people like me — not just experienced developers.</p><h3>Practical Steps to Get Started</h3><ul><li>Install Git from git-scm.com if you want to use Git with a remote repo</li><li>Open Unity Hub → connect a Git repository to your project from the project settings</li><li>Or enable Unity Version Control directly from the Unity Editor under <strong>Edit → Project Settings → Version Control</strong></li><li>Make your first commit after every meaningful change</li><li>Use branches when trying something experimental</li><li>Never rely on folder duplication as a backup again</li></ul><h3>One Lesson for Beginners</h3><ul><li>Version control isn’t just for professionals — solo devs need it too</li><li>Unity Version Control is built for game files, not just code</li><li>It handles large binary assets better than plain Git out of the box</li><li>Commit small and often — don’t wait until a feature is “finished”</li><li>A project without version control is one bad save away from disaster</li></ul><h3>Why This Matters in Real Projects</h3><p>Every professional game studio uses version control. No exceptions.</p><p>Learning it early — even on small solo projects — builds a habit that carries into team environments. You learn how to commit, how to branch, how to roll back. These are skills studios expect you to already have.</p><p>Unity’s built-in tools lower the barrier enough that there’s no good reason to skip it anymore.</p><p>Start now. Your future self will thank you.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=926637a8a6a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blueprint vs Unity Visual Scripting — A Beginner’s Honest Comparison]]></title>
            <link>https://medium.com/@dineshrajasekaran04/blueprint-vs-unity-visual-scripting-a-beginners-honest-comparison-2b7062ad3e32?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b7062ad3e32</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[visual-scripting]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 08:10:31 GMT</pubDate>
            <atom:updated>2026-06-29T08:10:31.649Z</atom:updated>
            <content:encoded><![CDATA[<p>This post is part of my daily learning journey in game development. I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 100 of my game development journey, I explored visual scripting in both Unreal Engine and Unity — and tried to figure out which one actually makes sense for beginners.</p><h3>What I Used to Think</h3><p>I thought visual scripting was just “coding without typing.”</p><p>Same logic. Same power. Just drag and drop.</p><p>So it shouldn’t matter which engine I use — right?</p><p>That was wrong.</p><h3>What I Tried</h3><p>I opened Unreal Engine and created a simple Blueprint to move a cube when I press a key.</p><p>Then I did the same thing in Unity using Visual Scripting (formerly Bolt).</p><p>Same goal. Two completely different experiences.</p><h3>Blueprint (Unreal Engine)</h3><p>Blueprint felt built into the engine from the ground up.</p><p>Everything was connected — the editor, the assets, the events. It didn’t feel like a separate tool layered on top.</p><p>The node graph was large and detailed. A lot of nodes at first. But once I understood the core flow — Event → Condition → Action — things started clicking.</p><p>Blueprint in Unreal Engine is not a workaround. It’s a first-class system. Epic Games has shipped entire games using Blueprint alone.</p><p>The learning curve felt steep early on. But the feedback was immediate — I could see results fast, which kept me going.</p><h3>Unity Visual Scripting</h3><p>Unity Visual Scripting felt like it was added on top of the engine rather than built into it.</p><p>The node graph looked cleaner and simpler — easier to read at first glance.</p><p>But connecting it to GameObjects and components felt less intuitive. I had to understand Unity’s component system first before the visual scripting started making sense.</p><p>It’s genuinely powerful — but it needed more setup before I could see real results.</p><h3>The Real Difference</h3><p>Blueprint is deeply integrated into Unreal Engine. It shares the same event system, the same component references, the same asset pipeline. Everything talks to everything naturally.</p><p>Unity Visual Scripting is more modular. It sits on top of Unity’s existing C# architecture — which makes it flexible, but also means more steps before things connect properly.</p><p>For pure beginner speed — Blueprint wins.</p><p>For long-term flexibility and an easier transition into code later — Unity Visual Scripting has a smoother bridge to C#.</p><h3>What Finally Clicked</h3><p>Visual scripting is not just “no-code.”</p><p>Each engine has its own logic, its own node system, its own rules.</p><p>Learning Blueprint teaches you how Unreal Engine thinks.</p><p>Learning Unity Visual Scripting teaches you how Unity’s component system works.</p><p>They’re not interchangeable. They’re two different ways of understanding two different engines.</p><h3>Which One Should Beginners Start With</h3><p>If you’re starting with Unreal Engine — use Blueprint. It’s the natural entry point. Almost everything in Unreal has a Blueprint equivalent.</p><p>If you’re starting with Unity — get comfortable with GameObjects and components first. Then move into Visual Scripting. It’ll make much more sense once that foundation is there.</p><p>Don’t try to learn both at the same time when you’re just starting out. Pick one engine and go deep.</p><h3>One Lesson for Beginners</h3><ul><li>Blueprint is Unreal Engine’s native language — treat it seriously</li><li>Unity Visual Scripting is built on top of C# — understanding Unity’s component system first helps a lot</li><li>Both systems can build real, complete games — neither is just a toy</li><li>Visual scripting has performance costs compared to native code — keep logic simple while you’re learning</li><li>Pick one engine, learn its visual scripting well, then decide if you need to go deeper</li></ul><h3>Why This Matters in Real Projects</h3><p>In real game development, visual scripting is used for prototyping, gameplay logic, and rapid iteration.</p><p>Blueprint is used professionally in the Unreal Engine ecosystem. Many shipped titles — including AA games — rely on Blueprint for core gameplay systems.</p><p>Unity Visual Scripting is more common in indie and solo projects, especially for teams without strong C# experience.</p><p>Understanding both helps you read other developers’ work, follow tutorials across engines, and make a smarter choice about where to focus your time.</p><p>Choosing the right tool early saves a lot of frustration later.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b7062ad3e32" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why MetaHumans Make Unreal Projects Heavy]]></title>
            <link>https://medium.com/@dineshrajasekaran04/why-metahumans-make-unreal-projects-heavy-26906e3e2459?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/26906e3e2459</guid>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <category><![CDATA[optimization]]></category>
            <category><![CDATA[metahuman-character]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Thu, 14 May 2026 03:35:38 GMT</pubDate>
            <atom:updated>2026-05-14T03:35:38.069Z</atom:updated>
            <content:encoded><![CDATA[<p>I added a MetaHuman to my project. The character looked amazing… but my project suddenly became much heavier.</p><p>This post is part of my daily learning journey in game development.</p><p>I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 99 of my game development journey, I learned why MetaHumans and realistic assets require heavy optimization in Unreal Engine.</p><h4>What I Used to Think</h4><p>If Unreal Engine supports realistic graphics, why not use maximum quality everywhere?</p><p>More quality should always mean better results… right?</p><p>But after importing a MetaHuman, <strong>I noticed:</strong><br>- Bigger project size <br>- Longer loading times <br>- Lower performance</p><p>That’s when optimization finally started making sense.</p><h4>What I Realized</h4><p>Realistic assets are expensive.</p><p><strong>MetaHumans use:</strong><br>- High-resolution textures <br>- Dense meshes <br>- Complex materials <br>- Advanced rigs and shaders</p><p><strong>All of this increases:</strong><br>- Storage usage <br>- Memory usage <br>- Rendering cost</p><p>So games cannot use maximum quality everywhere.</p><h4>Why This Matters</h4><p><strong>Modern games must balance:</strong><br>- Visual quality <br>- Frame rate <br>- Hardware limitations</p><p>Optimization is not about making games look bad.</p><p>It’s about removing details players usually won’t notice during gameplay.</p><h4>What Finally Clicked</h4><p>Good graphics are expensive.</p><p>Optimization = smart compromise.</p><p>Not every object needs ultra quality all the time.</p><p>Background assets, distant objects, and hidden details can often be simplified without ruining the experience.</p><h4>Practical Fix</h4><p>- Use LODs for characters and meshes <br>- Reduce texture resolution where possible <br>- Disable unnecessary material features <br>- Use simpler assets for background objects <br>- Test performance regularly during development</p><h4>One Lesson for Beginners</h4><p>- MetaHumans are heavy by default <br>- Texture size affects storage heavily <br>- LODs improve performance at distance <br>- Optimization should start early <br>- Visual quality must match hardware limits</p><h4>Performance Note</h4><p>Even AAA games sacrifice quality in areas players rarely notice.</p><p><strong>Optimization tricks include:</strong><br>- Lower texture resolution at distance <br>- Simpler meshes in the background <br>- Aggressive LOD switching <br>- Baked lighting in some scenes</p><p>Good optimization is often invisible to players.</p><h4>Why This Matters in Real Projects</h4><p>Professional game development is not about pushing graphics everywhere.</p><p><strong>It’s about deciding:</strong><br>- Where detail matters <br>- Where performance matters more</p><p>Understanding this early changes how environments, characters, and assets are built inside Unreal Engine.</p><p>Realism is not free.</p><p>The real skill is making a game look good while still running smoothly.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26906e3e2459" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Unity Looked So Confusing at First]]></title>
            <link>https://medium.com/@dineshrajasekaran04/why-unity-looked-so-confusing-at-first-053abe87cc43?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/053abe87cc43</guid>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Mon, 11 May 2026 16:18:23 GMT</pubDate>
            <atom:updated>2026-05-11T16:18:23.740Z</atom:updated>
            <content:encoded><![CDATA[<p>I opened Unity for the first time… and immediately got overwhelmed by tabs everywhere. But after writing my first small script, things finally started connecting.</p><p>This post is part of my daily learning journey in game development.</p><p>I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 98 of my game development journey, I explored the **Unity Editor and basic C# scripting workflow.</p><h4>What I Used to Think</h4><p>I thought Unity would work like a simple drag-and-drop tool.</p><p><strong>But after opening the editor, I saw:</strong><br>- Scene <br>- Game <br>- Hierarchy <br>- Inspector <br>- Project</p><p>Everything looked confusing at first.</p><h4>What I Realized</h4><p>Each Unity tab has a specific role.</p><p><strong>Scene</strong><br>Used to build and edit the level.</p><p><strong>Game</strong><br>Shows the final camera output.</p><p><strong>Hierarchy</strong><br>Stores all objects inside the scene.</p><p><strong>Inspector</strong><br>Displays properties of the selected object.</p><p><strong>Project</strong><br>Contains assets, scripts, and project files.</p><p>Then I connected Visual Studio Code and created my first C# script.</p><p>After declaring a simple variable, I finally understood how scripting connects with Unity objects.</p><h4>Why This Matters</h4><p><strong>Unity combines:</strong><br>- Visual editing <br>- Programming</p><p>The editor handles the scene visually, while C# scripts define behavior.</p><p>That’s why Unity uses an external code editor like VS Code.</p><p><strong>Example:</strong></p><p>```csharp public int speed = 5;```</p><p>Public variables appear in the Inspector, allowing values to be changed without editing code.</p><h4>What Finally Clicked</h4><p>Hierarchy = objects <br>Inspector = properties <br>Scripts = behavior</p><p>Unity’s editor and code work together as one system.</p><h4>Practical Fix</h4><p>- Open Unity Hub and create a project <br>- Install Visual Studio Code <br>- Set VS Code as the external editor in Unity Preferences <br>- Create a C# script <br>- Attach the script to a GameObject <br>- Declare simple variables to test behavior</p><h4>One Lesson for Beginners</h4><p>- Don’t try to learn every tab at once <br>- Inspector changes based on the selected object <br>- Public variables appear in the Inspector <br>- Save scripts before returning to Unity <br>- Use the Console tab to debug errors</p><h4>Common Beginner Mistake</h4><p>Thinking Unity scripting works separately from the editor.</p><p><strong>In reality:</strong><br>- The editor handles visuals <br>- Scripts control logic <br>- Both are deeply connected</p><h4>Why This Matters in Real Projects</h4><p>Understanding the editor layout is the foundation of learning any engine.</p><p><strong>Unity’s workflow is designed around:</strong><br>- Fast iteration <br>- Visual editing <br>- Modular scripting</p><p>Learning simple concepts like variables early helps build confidence before moving into larger gameplay systems.</p><p>At first, Unity looked complicated. But once the relationship between the editor and code became clear, the workflow finally started making sense.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=053abe87cc43" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Structure a Beginner Portfolio That Actually Works]]></title>
            <link>https://medium.com/@dineshrajasekaran04/how-to-structure-a-beginner-portfolio-that-actually-works-a2aa32e7171e?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2aa32e7171e</guid>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[carrer]]></category>
            <category><![CDATA[portfolio]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[beginner]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Sat, 02 May 2026 13:28:56 GMT</pubDate>
            <atom:updated>2026-05-02T13:28:56.191Z</atom:updated>
            <content:encoded><![CDATA[<p>I thought a portfolio needed many sections and a perfect design. But the more I added, the more confusing it became. Then I simplified everything — and it finally worked.</p><p>This post is part of my daily learning journey in game development.</p><p>I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 97 of my game development journey, I figured out a simple structure for a beginner portfolio.</p><h4>What I Used to Think</h4><p><strong>A portfolio should:</strong><br>- Look professional <br>- Have many sections <br>- Show advanced skills</p><p>I felt I needed to impress people.</p><h4>What I Realized</h4><p>A beginner portfolio can be simple.</p><p><strong>Just 3 sections are enough:</strong></p><p>1. About<br>- Who I am <br>- What I’m learning</p><p>2. Project Overview<br>- Tools I use <br>- Type of projects I build</p><p>3. Projects<br>- Actual work <br>- Proof (images/videos)</p><h4>Why This Matters</h4><p><strong>Most beginners try to:</strong><br>- Overdesign <br>- Add unnecessary sections <br>- Act like professionals</p><p><strong>But viewers usually want:</strong><br>- Clarity <br>- Honesty <br>- Real work</p><p>A simple structure makes everything easier to understand.</p><h4>What Finally Clicked</h4><p>About = who I am now <br>Overview = what I’m learning <br>Projects = what I built</p><p>No need to fake experience.</p><h4>Practical Fix</h4><p>- Write the About section in simple, honest lines <br>- Add a short overview of tools and skills <br>- Show **2–5 real projects only** <br>- Add images or videos for proof <br>- Keep descriptions short and clear</p><h4>One Lesson for Beginners</h4><p>- Don’t copy complex portfolios <br>- Keep layout simple <br>- Show progress, not perfection <br>- Be honest about your level <br>- Update your portfolio regularly</p><h4>Common Beginner Mistake</h4><p>Trying to look “professional” instead of being clear.</p><p><strong>This leads to:</strong><br>- Confusing structure <br>- Empty sections <br>- Fake or exaggerated content</p><h4>Why This Matters in Real Projects</h4><p>A portfolio is not about impressing with design.</p><p><strong>It’s about:</strong><br>- Showing direction <br>- Showing effort <br>- Showing real work</p><p>Over time, this simple structure can grow into a strong professional portfolio.</p><p>Start simple. Stay honest. Keep building.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2aa32e7171e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Built a Free Portfolio Using GitHub Pages]]></title>
            <link>https://medium.com/@dineshrajasekaran04/how-i-built-a-free-portfolio-using-github-pages-77e456986b85?source=rss-cc109201715d------2</link>
            <guid isPermaLink="false">https://medium.com/p/77e456986b85</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[portfolio]]></category>
            <category><![CDATA[beginner]]></category>
            <dc:creator><![CDATA[Dinesh]]></dc:creator>
            <pubDate>Fri, 01 May 2026 14:14:34 GMT</pubDate>
            <atom:updated>2026-05-01T14:14:34.320Z</atom:updated>
            <content:encoded><![CDATA[<p>I thought I needed money and advanced skills to build a portfolio. <br>Turns out… I just needed to start.</p><p>This post is part of my daily learning journey in game development.</p><p>I’m sharing what I learn each day — the basics, the confusion, and the real progress — from the perspective of a beginner.</p><p>On Day 96 of my game development journey, I built my first portfolio using GitHub Pages for free.</p><h4>What I Used to Think</h4><p><strong>A portfolio meant:</strong><br>- Professional design <br>- Advanced coding <br>- Paid hosting</p><p>It felt like something only experienced developers could do.</p><h4>What I Realized</h4><p>A portfolio is simply a place to show your work.</p><p>That’s it.</p><p><strong>Using GitHub Pages, I was able to:</strong><br>- Create a website for free <br>- Host it online instantly <br>- Share my projects easily</p><p>And the best part — I only needed basic HTML and CSS.</p><h4>Why This Matters</h4><p>Many beginners delay building a portfolio because they think:</p><p>- “I’m not ready yet” <br>- “My work is not good enough”</p><p><strong>But in reality:</strong></p><p>👉 Projects matter more than design <br>👉 Progress matters more than perfection</p><p>A simple portfolio with real work is more valuable than a perfect empty site.</p><h4>What Finally Clicked</h4><p>Portfolio ≠ perfection</p><p>Portfolio = proof of work</p><p><strong>Even a simple site can:</strong><br>- Show skills <br>- Track progress <br>- Help with job or freelance opportunities</p><h4>Practical Fix</h4><p>- Create a GitHub account<br>- Create a new repository <br>- Add a simple HTML/CSS portfolio template <br>- Go to Settings → Enable GitHub Pages <br>- Upload project screenshots or videos <br>- Share your live portfolio link</p><h4>One Lesson for Beginners</h4><p>- You don’t need to be a pro to start <br>- Content is more important than design <br>- Keep layout clean and simple <br>- Update your portfolio regularly <br>- Show real projects, not just ideas</p><h4>Common Beginner Mistake</h4><p>Waiting too long to build a portfolio.</p><p><strong>Your early work may not be perfect, but it shows:</strong><br>- Growth <br>- Consistency <br>- Learning mindset</p><p>That matters more.</p><h4>Why This Matters in Real Projects</h4><p>A portfolio is your digital identity as a game developer.</p><p><strong>It helps you:</strong><br>- Showcase skills <br>- Get freelance work <br>- Apply for jobs <br>- Build credibility</p><p>Free tools like GitHub Pages remove barriers, so you can focus on building and sharing your work.</p><p>Your portfolio doesn’t need to be perfect. It just needs to exist.</p><p>Slow progress — but I’m building a strong foundation.</p><p>If you’re also learning game development, what was the first thing that confused you when you started?</p><p>See you in the next post 🎮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77e456986b85" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>