<?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 Christopher Graf on Medium]]></title>
        <description><![CDATA[Stories by Christopher Graf on Medium]]></description>
        <link>https://medium.com/@cgraf062491?source=rss-93ec6c95187b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*vQtUY7JJEbdygWtt</url>
            <title>Stories by Christopher Graf on Medium</title>
            <link>https://medium.com/@cgraf062491?source=rss-93ec6c95187b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 03:14:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@cgraf062491/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[Unity Development — Modular Health]]></title>
            <link>https://cgraf062491.medium.com/unity-development-modular-health-b803741ceb45?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/b803741ceb45</guid>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Fri, 01 Oct 2021 20:34:00 GMT</pubDate>
            <atom:updated>2021-10-01T20:34:00.000Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Modular Health</h3><p>In general, when coding the user controlled Player and the computer controlled enemies, they would have very little in common. Sometimes, however, you can still save some time by finding something common and making sure not to code it twice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/1*ck22RVfnJIfZNDtiGes2zA.png" /></figure><p>In this example, both our Player and the Enemy have health and can have some of that health damaged. To keep up with the principals of object oriented programming, we will have a separate class/script specifically for health and damage that will go on both objects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/373/1*xgkU_mf0jmYiq92NWEDJlQ.png" /></figure><p>Right away we declare a max health, min health, and current health. They are serialized, so that they can be given different values to the different objects. At the beginning for the scene, the current health is set to the max health as well. Now we’ll make a public Damage() function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/308/1*fQBnnqj3RfYv9PYIwdt0IQ.png" /></figure><p>Since this function is public, we can call it from anywhere we get a reference to the object and the Health script. The Player has a shooting mechanic with a Raycast. If it hits an Enemy, it can search for the Health script. If it isn’t null, it can perform the Damage function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*gcLn6I067HZ2PbaHKbhIAQ.png" /></figure><p>The same goes for the Enemy. It has a reference to the player and thus can call on the Health script and Damage() as long as it isn’t null, in a completely separate circumstance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/1*VA5ENYu8SHOI8F6YuaPLdQ.png" /></figure><p>And that’s really all there is to it. There are other ways to do this. Interfaces is a good example, but that is one for another day.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b803741ceb45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Raycasting]]></title>
            <link>https://cgraf062491.medium.com/unity-development-raycasting-b6bc4f31c43b?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6bc4f31c43b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Thu, 30 Sep 2021 20:01:31 GMT</pubDate>
            <atom:updated>2021-09-30T20:01:31.755Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Raycasting</h3><p>This may come as a shock to some of you, but most weapons in shooter games don’t actually shoot any bullets (gasp). It’s all behind the scenes magic. A sound effect plays, there are some particle flashes in front of the barrel, and animation of the player and weapon moving with kickback. If all that is true, how does anything get hit? This is where Raycasting comes in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mwgkNQSJjyZ_M7omcMn93g.png" /></figure><p>A Raycast is like an invisible line that goes in a specific direction and can be used to send a message. Think of it like a laser pointer. Previously, we have seen it used in 2D to determine if the player is grounded. The Raycast pointed down for a small distance and if it found something with the layer ‘Ground’, then the player knew it was grounded.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9XUaRf_R11MSAyxLgogdfA.png" /></figure><p>This time we are going to use a Raycast without a distance limit to simulate shooting a weapon. To know where we are aiming, we are first going to need a crosshair or any image in the center of the screen. Create an Image in the Hierarchy and anchor it in the center. This will help as a visual cue of where we are aiming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/486/1*FPbbGRXe_xlta-o5v8bf-Q.png" /></figure><p>Now let’s look at the code. We want to send out a Raycast from the camera’s center, right where the crosshair is, and go straight out. This will happen on a left mouse click. We are going to start with that in Update() and use it to call a function that will do the rest.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/588/1*30VIjKeka6_haBgsum994w.png" /></figure><p>There are many ways to call a Raycast that you can look up. For this example, we are setting up a Vector3 for the center. Then, we are going to use that center and have it be used as the ray’s origin from the camera.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*QcQxnU2BHv5c4W15dkwYvg.png" /></figure><p>We also need to declare a RaycastHit. This stores the information based on what the Raycast actually hits. With that, we can use an IF statement and see whether or not something was hit. Put it all together and you have a Raycast call.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*apZR-ZCwXaTqACLYp-XAIQ.png" /></figure><p>There are many more parameters and ways to set up your Raycast. You can add a specific distance. You can add a layer mask. You can even make Raycasts that are thicker than laser pointers.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FG8jqU8uVnRZEnm7p8W%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FG8jqU8uVnRZEnm7p8W%2Fgiphy.gif&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FG8jqU8uVnRZEnm7p8W%2F200.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="152" frameborder="0" scrolling="no"><a href="https://medium.com/media/d359c036bd5e77cb1099acc267b92931/href">https://medium.com/media/d359c036bd5e77cb1099acc267b92931/href</a></iframe><p>Raycasts add many possibilities to your game design. Go and explore and make great things.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6bc4f31c43b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Camera Mouse]]></title>
            <link>https://cgraf062491.medium.com/unity-development-camera-mouse-a50f64775268?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a50f64775268</guid>
            <category><![CDATA[games]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[cameras]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Tue, 28 Sep 2021 20:43:59 GMT</pubDate>
            <atom:updated>2021-09-28T20:43:59.145Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Camera Mouse</h3><p>We have looked at many ways to move our characters in 2D, 3D, and even 2.5D. In a 3D world, however, we have not yet allowed the player to look around on their own. How about we add that control right now?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*vy-TkFU98_5LsCGg0O3kjQ.png" /></figure><p>To start out with, we should have a Player of some sort ground for them to stand on. While there are other ways to have the Main Camera follow the Player, with the use of Cinemachine, we are going to use a classic method and make it a child of the Player itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/326/1*vbrvSXH07UjRiHHMNulbQw.png" /></figure><p>Afterward, we are going to move the Main Camera, so that it correctly lines up our Player avatar the way we like on the screen. This is determined by your favorite 3rd person games. Zelda, Fortnite, Gears of War. Place it however you feel comfortable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/761/1*vlcQlfYiX7V2StwAjmC8BQ.png" /></figure><p>Now we are going to have the mouse move the camera. This is somewhat similar to moving the Player itself. We are going to grab inputs to represent each axis, but this time, they will be mouse inputs and they will move a rotation of the camera, instead of moving positions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/347/1*qv2RjfZfB7f9AB8zezLATQ.png" /></figure><p>You can also add a global float variable to change the mouse sensitivity. This is common practice for 3rd person shooters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*VgDROuN9KS64yuGtSeRMbA.png" /></figure><p>Like the specific x or y of a transform.position, you cannot simply change the rotation of an axis with transform.rotation.y = 5.0f, or something of that nature. So instead, we are going to make a Vector3 variable, make changes to that, and then assign our new rotation to that Vector3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/559/1*JCnK_rspF_iEFm6DkmHqtA.png" /></figure><p>Notice in the last line, we are changing the localRotation, as opposed to just rotation. This is because the Main Camera is a child of Player and so the global rotation would move many more things and make it a mess, rather than simply moving the localRotation, for the Camera only.</p><p>Also, Quaternion.AngleAxis() takes the rotation value we want (which we have set to currentRotation.y) and sets it to a specific axis (which for us would he around the Y axis, so Vector3.up works just fine). We do the same thing for the X-axis and put it all together for a camera movement function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*6b_0iIk_Cfomnc3FIUW0qA.png" /></figure><p>The last part is to make sure that the cursor does not interrupt the game. In the Start() or Awake() function, we are going to add some built in code, to make sure it is locked in place and invisible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/334/1*uprl51UWsIdYWOKNjz29tA.png" /></figure><p>In the Update(), you may also add input to get out of the locked state.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/325/1*n4UsgsB4pKN03HDX7kX5Nw.png" /></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FrEHYieYsJqRop4i0pJ%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FrEHYieYsJqRop4i0pJ%2Fgiphy.gif%3Fcid%3D790b76110953c05bde763eeeb0ae1bddf2e917f8e7e5499a%26rid%3Dgiphy.gif%26ct%3Dg&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FrEHYieYsJqRop4i0pJ%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="251" frameborder="0" scrolling="no"><a href="https://medium.com/media/d95a64b7efcd238fcb16fdeb31ae442f/href">https://medium.com/media/d95a64b7efcd238fcb16fdeb31ae442f/href</a></iframe><p>Play around with the mouse sensitivity and locks and make your camera movement smooth as silk.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a50f64775268" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Developer — Collision Layers]]></title>
            <link>https://cgraf062491.medium.com/unity-developer-collision-layers-e1ee7087e8cc?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1ee7087e8cc</guid>
            <category><![CDATA[physics]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Wed, 22 Sep 2021 21:11:48 GMT</pubDate>
            <atom:updated>2021-09-22T21:11:48.054Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Developer — Collision Layers</h3><p>When dealing with triggers and collisions, we used the technique of checking tags before performing the required task. This works especially well when there is only one thing that you want to have a trigger for, but there is another method when accounting for multiple objects. That is setting up your collision layers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*X2QaHy49aChXsTzHB3avKg.png" /></figure><p>Collision Layers are a simple and easy way to make sure that objects only interact if desire. We have a player with a hitbox and an enemy with a hitbox. We can set up their layers in their Inspectors. In the top right of any Inspector, go to Layers and Add Layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*HTCMvU0_RXTy2rHlUmBUGQ.png" /></figure><p>Here you can add as many layers as you like. We are going to add a layer for the Player and Enemies. We are also going to add a layer for their attacks, called ‘Sword’ and ‘EnemyAttack.’ You could name these anything that makes sense for you and your project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*fEFiRwqj2JNRmp49lV89AA.png" /></figure><p>After the new layers are set up, assign them on the proper game objects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*1N2rbywUCq44dPMn33uM6A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*Kdgzuaqh9006LOX6OEOiGQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*JEnsRXK8mPBNsmHPmWxlqQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/443/1*TFtCBwpbV06i0oQiIcrOBw.png" /></figure><p>For the final step, go to the Project Settings and Physics2D.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/309/1*KIOPnlvDUbuFbSqUE007lA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/190/1*4JhDANlM4rMZ4wpJxkMzBg.png" /></figure><p>Here you will see a cross section of all the layers. All you have to do is untick any collisions you don’t want to happen. In our case Player/Sword shouldn’t interact, because we don’t want the Player to be hit with their own hitbox. Same goes for the Enemy and EnemyAttack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/333/1*L2kDj4-PY_ksLKRff3AeiQ.png" /></figure><p>And that’s it! With the power of layers, you can fully control what you want to interact and what will pass each other by. You can use this to prevent Players from hitting each other in multiplayer, enemies from hitting each other, or you can even do some interesting layering in the environment. Pass through water, but not ground. Let your creativity run wile.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1ee7087e8cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Hitbox]]></title>
            <link>https://cgraf062491.medium.com/unity-development-hitbox-23208a1114a4?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/23208a1114a4</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Fri, 17 Sep 2021 20:25:49 GMT</pubDate>
            <atom:updated>2021-09-17T20:25:49.217Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Hitbox</h3><p>If you are at all into fighting games, I am sure you have heard people talking about hitboxes before. Maybe even a little too much. Now you are finally going to understand everything they are talking about. Well… maybe not everything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*Zp4eAesl-1hrBNLEMzxBjA.png" /></figure><p>Say we have a Player object and they have an attack animation. We are going to have a hitbox be a child of that object and they will be adjusted in the attack animation itself, simulating the swinging of a sword, a full kick, a punch, or any other attack with movement.</p><p>In my project, the Player’s animations are controlled by a child called ‘Sprite.’ That is just fine. As long as the hitbox is a child of whatever object is holding the Animator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*arqrkfV-cKoYsJDi8WFOJg.png" /></figure><p>Your Hitbox should have a Collider and a Rigidbody to detect collision. Make the Collider a trigger.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/441/1*0hXtKy3mjaxAe0nr9QvMAA.png" /></figure><p>In the Inspector, you should also set the hitboxoff at the top.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/275/1*IY6CtMa8kqGcKo9wPBZwmw.png" /></figure><p>In the Animation window, go to your Attack animation. For every animation you can hit the Record button (red button next to ‘Preview’) and make changes to attributes in the Inspector. Because the hitbox is a child of our object with the Animator, it applies there as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/302/1*78QBEzLUvEb5TW-xy7tBUg.png" /></figure><p>Go to the first frame, hit Record, and set the Hitbox to be enabled on the Inspector. You will see that it sets a new key in the animation window and has recorded. Still in the first frame, move the hitbox’s transform and edit the Collider to properly encompass what you wish to be the area of attack. In our case, it is around the Player’s sword.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*cxJ3TijVOoNizlvjRRP1pQ.png" /></figure><p>It is going to be tedious, depending on how many frames you have, but you must do this for each frame of the animation. And be sure that you are in Record mode the whole time. Make it as precise as you wish, or leave some wiggle room.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2Fz0lSTilQoyZfXvPIzU%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fz0lSTilQoyZfXvPIzU%2Fgiphy.gif%3Fcid%3D790b76111dafadddf655cb2483f854c7ebf0424fd1bf4f63%26rid%3Dgiphy.gif%26ct%3Dg&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2Fz0lSTilQoyZfXvPIzU%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="262" frameborder="0" scrolling="no"><a href="https://medium.com/media/7a07735d437736b912c7f2faaf6c8b05/href">https://medium.com/media/7a07735d437736b912c7f2faaf6c8b05/href</a></iframe><p>Do lots of play testing after setting up your hitboxes. You never know if someone is going to come around and say they are unfair because one reason or the next. Luckily we live in a world with online updates, so even professionals need to readjust sometimes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23208a1114a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Abstract Classes]]></title>
            <link>https://cgraf062491.medium.com/unity-development-abstract-classes-ffa6f6bb7204?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffa6f6bb7204</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Thu, 16 Sep 2021 20:07:32 GMT</pubDate>
            <atom:updated>2021-09-16T20:07:32.560Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Abstract Classes</h3><p>In the Unity Developer Journey, you have already seen the use of the Prefab. A way to make a specific object only once and then be able to Instantiate that same object whenever and wherever you want. With Abstract Classes, we are going to see how to make numerous classes that follow a pattern or category.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*-qEUfacQkd4LZ9Y9hgWOYw.png" /></figure><p>In the example we’re going to look at, we are going to make a few enemies. Each of these enemies are going to share a number of different variables. In our case, they are all going to need a some sort of health, speed, SpriteRenderer, Animator, and an algorithm for them to move around and idle at different waypoints.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*Rq7rnc8mmTwTn9xEVlkHVg.png" /></figure><p>I am just going to quickly go over the initial setup of the enemies’ visual components, as they are not the main focus of this article. Each enemy should have an animation for ‘Walk’ and ‘Idle.’ Their animators should be set up to transition from Idle to Walk when the Idle animation ends. Make a trigger called ‘Idle’ in the parameters. This will be triggered when we want the enemies to go from walking to idling.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/1*HySmDbelDMHdrePMB_dsJg.png" /></figure><p>Our enemies are going to walk back and forth and idle at specific waypoints. In the Hierarchy we have each enemy set up as an empty gameObject, a child object holding the sprite and Animator, and two separate objects to act as their waypoints. These waypoint objects are NOT children as well. This is the end of our initial setup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/293/1*Vr2aDBvJ1mpW5DZT5J6g7A.png" /></figure><p>So now we know that we want a Moss Giant, a Spider, and a Skeleton to all do the same thing. This is true for the most part, but they will not share waypoints, and we want them to have separate speeds and eventually differ in other ways. Instead of writing out three separate scripts doing the same thing, we are going to write one and branch from there.</p><p>Our script is simply going to be called ‘Enemy’ and it will be set up as an abstract class. We want each enemy to have speed, a reference to their SpriteRenderers and Animators, a currentTarget for their movement, and reference to their waypoints.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/1*I4l_8y-VvW8munxDYN5zVA.png" /></figure><p>Make a note that the speed and waypoints are serialized and that all of our variable are protected. Protected means that they are not public for any class to have access, but able to be accessed by those that inherit the Enemy class.</p><p>The chunk of code in this script is going to have the enemies move back and forth between waypoints, go idle at the waypoints, and then continue moving. Again, this is not the main focus of the article, but basically the currentTarget is going to change when reaching a waypoint position, the enemy will stop walk to go idle, then it will flip the sprite and walk to the next waypoint. The code looks like this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/1*PyXpmpqm4KaBm_QM9I84CQ.png" /></figure><p>Likely that top line in Update() is the most confusing. It is function as part of the Animator to say, if we are running the Idle animation, return and do nothing. So it will not go on to the Movement() code. You may also notice that the functions are all called ‘virtual.’ This is the syntax used to make sure they are also run by the inheriting classes.</p><p>Normally when setting up the SpriteRenderer, Animator, and other components, we would do it in Start() or Awake(). Like the Movement() function, we are going to separate it for cleanliness. They will be placed into another function called Init() that is called by Start().</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/434/1*dzMRBRFZ_Hb1g7qwxDCm6g.png" /></figure><p>Now we have the entire Enemy script done, but we are not going to place it on enemy objects. We are now going to very quickly make three more scripts and have them inherit this Enemy script. Just replace ‘MonoBehavior’ with ‘Enemy’ at the top.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/244/1*0ad2CDH3iAbjee5xn0cIyw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ntac1VHy_DJ_JuO82Argtw.png" /></figure><p>Place these scripts on their proper object and you are technically done. I would like to point out one more thing though. You could have simply put the ‘Enemy’ script on each object and it would do the same, but the reason why this is such a powerful tool is that you are now prepared to create their differences later.</p><p>Any one of these scripts can make their own methods or override the methods taken from the parent class. When you override them you can also take the behavior of the original method and add to it. This is done with the ‘base’ call. It looks like this and it is what we are doing for the Init() method.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/281/1*TU2B1wWzYipD37jBOqx3gg.png" /></figure><p>When you add the base to any method you override, it was have the same affect, but then allow you to do more that is specific to this class. It is the ease of only having to write some complicated code once, but then having the freedom to change things around for the specific object.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FpsxK3BcbNP7I4t5Yvm%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FpsxK3BcbNP7I4t5Yvm%2Fgiphy.gif%3Fcid%3D790b7611fabbad52f0c0d5eafd414d33ddca5427b300c937%26rid%3Dgiphy.gif%26ct%3Dg&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FpsxK3BcbNP7I4t5Yvm%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="262" frameborder="0" scrolling="no"><a href="https://medium.com/media/b3971a505265d5972197e78527138dfb/href">https://medium.com/media/b3971a505265d5972197e78527138dfb/href</a></iframe><p>The possibilities here are higher than you’ve seen up to this point. Good luck and make something great.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffa6f6bb7204" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Camera Follow]]></title>
            <link>https://cgraf062491.medium.com/unity-development-camera-follow-e83ad8d7c820?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e83ad8d7c820</guid>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[cameras]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Wed, 15 Sep 2021 20:31:38 GMT</pubDate>
            <atom:updated>2021-09-15T20:31:38.384Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Camera Follow</h3><p>Here’s a tip for Unity that is going to be quick and easy, but one of the most useful things you’ll see for all your future projects. We’re going to follow our player with a virtual camera.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*2BE9XUyv7rtYnpRmemQWjQ.png" /></figure><p>To get access to virtual cameras, we’re going to need to download Cinemachine from the Package Manager. Open it up with from the Window tab and then find Cinemachine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/299/1*08PfdFPjOXulv33QPBBa9w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/793/1*kA_hOI1iuMCdmh_RaBWh8Q.png" /></figure><p>Once this is downloaded and installed, you can add a virtual camera to your scene.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*Wix4jc8VED-hqDeh1_JMdQ.png" /></figure><p>This will automatically give your Main Camera a Cinemachine Brain, which takes care of most of the background work, making your Main Camera and the new virtual camera to be one and the same.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/441/1*ci13cj9-YIUdq2dPWU23zQ.png" /></figure><p>On the actual virtual Inspector, there is an attribute called ‘Follow.’ You are going to click and drag your player object into this spot and now the player will be followed. It is as simple as that.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/453/1*J7jwULnRo1nUllUXo-fugQ.png" /></figure><p>You can play around with some of the other settings, such as dampening and dead zone, but for the most part, that is all there is to it. Your player will now be followed by the camera as they move.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FI9plMzvzWnhDd7Mr0L%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FI9plMzvzWnhDd7Mr0L%2Fgiphy.gif%3Fcid%3D790b76113aa99e4121ad99124b4907ad481da0f31bb040e4%26rid%3Dgiphy.gif%26ct%3Dg&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FI9plMzvzWnhDd7Mr0L%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="248" frameborder="0" scrolling="no"><a href="https://medium.com/media/a1ee5bd95477d78576c849130b1d7119/href">https://medium.com/media/a1ee5bd95477d78576c849130b1d7119/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e83ad8d7c820" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Animated Tiles]]></title>
            <link>https://cgraf062491.medium.com/unity-development-animated-tiles-f88e1d96a7d6?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f88e1d96a7d6</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[tiles]]></category>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[unity]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Tue, 14 Sep 2021 20:02:17 GMT</pubDate>
            <atom:updated>2021-09-14T20:02:17.747Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Animated Tiles</h3><p>If you have been playing with Unity’s Tilemap since it was first introduced to you, bravo. I hope you are enjoying it and have found some new and excellent ways to build your levels. There are two things I would like to add to the basics now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MXJo-VrPxaatvnUHvvkUHw.png" /></figure><p>Creating a level out of tiles does not really serve a purpose if the player cannot walk around. When painted on, the tiles are simply small sprites to create a visual aesthetic. You can grab a specific tilemap and add a tile map collider, allowing objects to have physical interaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/446/1*nQaJGebm4difmEK7rMh10g.png" /></figure><p>There is a bit more too it than that though. If you leave the tilemap as is, it will have a separate collider for each and every tile. There may be some uses for this, but it does not correctly for a tilemap that is meant to be a walkable ground.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*XdKC71Rxatl3F2PYK06ajw.png" /></figure><p>To fix this, add a Composite Collider 2D component to the tilemap. This will automatically add a Rigidbody 2D as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/446/1*ptrlTpa_7UwHYlp9JZyBcw.png" /></figure><p>Set the ‘Body Type’ on the Rigidbody 2D to Static. Saves the engine a lot of processing, knowing the tiles are going to be staying still. Also, no gravity to make them fall.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/437/1*iKDadPesE-30a5P1ryqz0w.png" /></figure><p>Make sure to turn on the ‘Used By Composite’ attribute on the Tilemap Collider.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/201/1*D2N7SUn5sgzaeDG4GH7cvg.png" /></figure><p>Now the tilemap will have a proper collider to cover the area correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*vFr583HoXbhDDa4ZCyUO-g.png" /></figure><p>The second thing we should add to our Tilemap resume are animated tiles. These can create some amazing effects, like waterfalls. Depending on the some Unity updates, this may or may not be already installed and available. You can check with the first step of creating an Animated Tile in the Project Window.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/853/1*iuvDFRLeXkVSIkOJcmK_kg.png" /></figure><p>if this option does not appear, you’ll have to open the Package Manager, make sure it is set to see Preview Packages. Once there, download 2D Tilemap Extras.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/205/1*BbCramNTMoUaO53bw2IG_g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/351/1*SFaKJ4ft-N-ytjaNw60x-A.png" /></figure><p>Once that is all set up, go back to the original step and create an Animated Tile in a proper folder of your choosing. These are very different from other tiles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/163/1*HH4GfeeHhvZPL1e4lW0DPw.png" /></figure><p>In the Inspector for each tile, you’ll be able to set the number of sprites for the animation. If you have a spritesheet, it would help to know this number when creating the animation, just as with a regular animation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/417/1*X3Dunkk6Va7L_odwPKM98w.png" /></figure><p>Unfortunately, unlike making other animations in Unity, you’ll have to individually click and drag each sprite to complete the animation. At the bottom, you can then set the speed at which you want it to run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*mN5yGfhfstc2woQLlIQv1Q.png" /></figure><p>Make a new Tile Palette, if you don’t want to place it anywhere else, and simply drag the animated tiles into the palette window.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/442/1*Z-8SlYM2sF4CVPUC42a4Bw.png" /></figure><p>Now you’ll be able to paint with these tiles like any other. Only difference being, when you play the game, you’ll see the animations come to life.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FLOgIVcGMswaLLR5p0j%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FLOgIVcGMswaLLR5p0j%2Fgiphy.gif%3Fcid%3D790b76115555d7846b0b9c6760d3c2caa9229d5a63251a3f%26rid%3Dgiphy.gif%26ct%3Dg&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FLOgIVcGMswaLLR5p0j%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="446" frameborder="0" scrolling="no"><a href="https://medium.com/media/a0733cd80c877345a54531e8b30aeecf/href">https://medium.com/media/a0733cd80c877345a54531e8b30aeecf/href</a></iframe><p>Your Tilemaps skills have now advanced. Keeping pushing along and see what kind of levels you can make that you never thought of before.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f88e1d96a7d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Tilemap]]></title>
            <link>https://cgraf062491.medium.com/unity-development-tilemap-412abfe61429?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/412abfe61429</guid>
            <category><![CDATA[art]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[unity]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Thu, 09 Sep 2021 19:56:13 GMT</pubDate>
            <atom:updated>2021-09-09T19:56:13.204Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Tilemap</h3><p>When making 2D games and piecing your levels together, it can sometimes be difficult to work with what you have. Making sure all of your prefabs can come together to make something cohesive and proper designed for the player. There is a way, however, to streamline this task and make your level creations much simpler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t0eIF8WbOVT9U5oN2PrbfA.png" /></figure><p>Introducing Unity’s Tilemap. This feature allows you to take mapped out sprites of anything and use it to paint your levels in a grid. In the Hierarchy, go to Create &gt; 2D &gt; Tilemap &gt; Rectangular. This will give you a Grid, where you can place any number of Tilemaps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/238/1*5NQ3lqZuIfNyGRwONZ2leA.png" /></figure><p>Like sprites, these Tilemaps have sorting layers that you can adjust to have some appear in front of or behind others. This can help create a lot of depth in your scene.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/438/1*etEt4oDt5Ao-CQpupNwnwg.png" /></figure><p>Go to Window &gt; 2D &gt; Tile Palette to open the Tile Palette window. Here you can access different Tilemaps to paint on and change your palettes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*0SAcbt_RB1IyvjJIkyeKtw.png" /></figure><p>You may want to create a few new folders in your project. ‘Tilemap’ and inside there ‘Palettes’ and ‘Tiles’ to keep things organized. Click the palettes on the left and go down to Create New Palette. Name the new palette whatever you like and save it where somewhere appropriate. Now you can take sprites and drag them over to the Tile Palette window, with the proper palette open and it will save new tiles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/1*FQVUasR0AKMkeueagXqoGw.png" /></figure><p>On the top of the window, you will see ‘Brush’, ‘Eraser’, and some extra tools to help you. From here is is fairly intuitive. Just click any tiles you want, or a group of tiles, and paint away in the Scene View.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/442/1*MmRYt69o_mIvz2txJbDKBw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*McQ1zNRxIlOJ7BNHwNgYQA.png" /></figure><p>Anything you don’t like, you can simply erase and start over. Remember to double check your Active Tilemap. You wouldn’t want to paint a whole section and have it be on the wrong layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/407/1*szbGgI2hIxI3pITFdvLzmg.png" /></figure><p>Play around with layers, different tiles, and the other tools to see what new heights your level design can get to.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=412abfe61429" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unity Development — Ladder]]></title>
            <link>https://cgraf062491.medium.com/unity-development-ladder-1a7c6c4aeea3?source=rss-93ec6c95187b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a7c6c4aeea3</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[unity]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[animation]]></category>
            <dc:creator><![CDATA[Christopher Graf]]></dc:creator>
            <pubDate>Thu, 02 Sep 2021 20:01:45 GMT</pubDate>
            <atom:updated>2021-09-02T20:01:45.813Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unity Development — Ladder</h3><p>As you most likely have discovered by now, everything that seems very simple in real life becomes a more complicated issue when going to program it into your game. There is even a joke among game programmers on the internet about doors being very difficult to bring to life in a game. Today we’re going to attempt the ladder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*IlXljUR3j1tSvddfS9hgQQ.png" /></figure><p>When it comes to level design and other game development aspect, the ladder is another good tool to have under your repertoire. As usual, you are going to want an animation or sprite of the character climbing a ladder, as well as a ladder model itself. Place this ladder in between two platforms. In the Hierarchy, add two children, representing the bottom and top of the ladder. Each should have their own trigger collider attached.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/194/1*f0f20ADeY1NMpHj41MmYAg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/377/1*B4RsxbjcBTve0eeMvV39kg.png" /></figure><p>Each one of these children will have a ‘Ladder’ script on it to perform the OnTriggerEnter for when the Player gets near one of the ends and enters the triggers. To allow for the ladder to become a prefab to have as many as we want, our variables in script with be serialized, so they can be changed. This include the two Vector3s and two floats. These will represent where the player will grab on to the ladder, where they will stand when getting off and the min and max height on the ladder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*EWwsvXBItMoaSOZzNxlBOw.png" /></figure><p>When the player enters the trigger, these will pass into variables set up on the player in a public function that will be called from the ‘Ladder.’ They will be used as parameters when calling that public function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/506/1*UYTgB54rVrVI5hCtlacW1Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/347/1*YSwWQucT8cOUdgePqB63KQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*LPeRnefaxhjjhPAXLzLqHQ.png" /></figure><p>Once the player’s _nearLadder bool is set to true, they should then be able to hit a key to climb the ladder. Other games have it that you can simply hold up and be on the ladder. What you choose is up to you, but this example will show an input to get on the ladder. Once the player hits ‘E’, it will call another function on the player that sets up the OnLadder animation as well as set up their bottom of the ladder position. If they grab the ladder from the top, it will set up them up on the top section’s grab position.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/569/1*SqPhrpV1G8bp3PgMk-PF4Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/417/1*1YYYzVaRmXjei2V5tH0kJg.png" /></figure><p>The ‘Ladder’ script contains a public function to get the grab position of the active ladder. This is called when getting on the ladder. It is a simple return call.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/249/1*IoxfFakVCSqYgJxfQb8LZg.png" /></figure><p>When at an edge and hitting the ‘E’ button again, it will perform almost the same tasks in reverse. The player will go back to idle and it will call the ‘Ladder’ to get the new standing position.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/1*5BHaz2g49RMQeElovlMHFQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/416/1*w10piK4Dql7U-ut5CnsJUg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/260/1*X8gu7mD7CA7TZbZX7Y5DEA.png" /></figure><p>Since the player’s movement is so different when they are on a ladder, that needs to be setup wherever you are performing the player’s movement. In our case, we use the _OnLadder variable to set this up. Instead of being grounded and using horizontal movement, the player uses vertical inputs to move up and down. Because they are on a ladder, this movement has to be clamped, so as to prevent them from going too high or too low.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*88LFuvtJjynlp1-6uQaloQ.png" /></figure><p>It would also be a good idea to turn off all gravity if they are on the ladder. That way the player isn’t fighting against it going up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/403/1*6hK7Z3qstgtfd-ZpJ0TdJQ.png" /></figure><p>And that should just about do it. You may have to change some rotations on the player, depending on how you set up your ladder, but the bones of the task should all be about the same. If you wanted to design your version of Shoots &amp; Ladders, you now have another key.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FN2swMiWrEGki3Lrdoh%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FN2swMiWrEGki3Lrdoh%2Fgiphy.gif%3Fcid%3D790b76114f4c27c8d2b9dea31e9ba0cf47eaabb5ade8ade4%26rid%3Dgiphy.gif%26ct%3Dg&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FN2swMiWrEGki3Lrdoh%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="257" frameborder="0" scrolling="no"><a href="https://medium.com/media/07623a96173781eb5e50f9bf4052f308/href">https://medium.com/media/07623a96173781eb5e50f9bf4052f308/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a7c6c4aeea3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>