<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns:yt="http://www.youtube.com/xml/schemas/2015" xmlns:media="http://search.yahoo.com/mrss/" xmlns="http://www.w3.org/2005/Atom">
 <link rel="self" href="http://www.youtube.com/feeds/videos.xml?channel_id=UCy4-zbCBOH4nRbeGCehsgKA"/>
 <id>yt:channel:y4-zbCBOH4nRbeGCehsgKA</id>
 <yt:channelId>y4-zbCBOH4nRbeGCehsgKA</yt:channelId>
 <title>RetroJitsu</title>
 <link rel="alternate" href="https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA"/>
 <author>
  <name>RetroJitsu</name>
  <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
 </author>
 <published>2026-08-30T16:47:01+00:00</published>
 <entry>
  <id>yt:video:5gEWhZJap0w</id>
  <yt:videoId>5gEWhZJap0w</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>The FIRST Antic Magazine! Atari Computing in 1982 | Static From the Attic Episode 2</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=5gEWhZJap0w"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-11-15T22:00:29+00:00</published>
  <updated>2026-11-16T14:47:38+00:00</updated>
  <media:group>
   <media:title>The FIRST Antic Magazine! Atari Computing in 1982 | Static From the Attic Episode 2</media:title>
   <media:content url="https://www.youtube.com/v/5gEWhZJap0w?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/5gEWhZJap0w/hqdefault.jpg" width="480" height="360"/>
   <media:description>It's April 1982, and there's a BRAND-NEW magazine for Atari computer owners... ANTIC!

Welcome to Episode 2 of Static From the Attic, where we're exploring the very FIRST issue of Antic magazine, published in April 1982!

This month we've got a brand-new GTIA graphics chip, a $49.95 programming utility called the Monkey Wrench, a little 6502 assembly language, and a classic Atari BASIC game called CHICKEN!

We'll even learn something new in our BASIC Lesson of the Month: FOR/NEXT loops!

And just wait until you see what happens when our chicken doesn't make it across the road...

In this episode:
- Antic Magazine — Volume 1, Number 1
- The GTIA graphics chip
- A genuine 1982 On-Line Systems advertisement
- Monkey Wrench — the Atari programmer's best friend?
- Assembly Language: A Keyboard Mask
- BASIC Lesson of the Month: FOR/NEXT
- Chicken by Stan Ockers — let's play!

Explore the original magazine:
https://www.atarimania.com/mags/pdf/Antic_Vol_1_No_1.pdf

If you enjoy vintage computers, Atari programming, classic games, and a little 1980s television weirdness, subscribe to RetroJitsu!

#Atari800 #RetroComputing #AnticMagazine</media:description>
   <media:community>
    <media:starRating count="3" average="5.00" min="1" max="5"/>
    <media:statistics views="55"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:v-iwnqZGy38</id>
  <yt:videoId>v-iwnqZGy38</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>This Atari Accessory Was Actually Called THE RAT?!</title>
  <link rel="alternate" href="https://www.youtube.com/shorts/v-iwnqZGy38"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-26T17:00:31+00:00</published>
  <updated>2026-10-30T04:57:52+00:00</updated>
  <media:group>
   <media:title>This Atari Accessory Was Actually Called THE RAT?!</media:title>
   <media:content url="https://www.youtube.com/v/v-iwnqZGy38?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i3.ytimg.com/vi/v-iwnqZGy38/hqdefault.jpg" width="480" height="360"/>
   <media:description>In 1986, your Atari didn't just need a mouse. It could have a RAT!

We found this bizarre $114.95 pointing device advertisement from Zobian Controls in the June 1986 issue of Antic magazine.

It's just one of the strange discoveries from Static From the Attic Episode 1, where we revisit classic Atari magazines, forgotten software, games, and technology.

Watch the full episode using the Related Video link below this Short!

#Atari #RetroComputing #Shorts</media:description>
   <media:community>
    <media:starRating count="0" average="0.00" min="1" max="5"/>
    <media:statistics views="29"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:taqpysNNdtg</id>
  <yt:videoId>taqpysNNdtg</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>What the Heck Is Hexadecimal?! | RetroJitsu Side Quest 1  #retro #atari #retrocomputing</title>
  <link rel="alternate" href="https://www.youtube.com/shorts/taqpysNNdtg"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-22T23:00:34+00:00</published>
  <updated>2026-10-22T23:00:34+00:00</updated>
  <media:group>
   <media:title>What the Heck Is Hexadecimal?! | RetroJitsu Side Quest 1  #retro #atari #retrocomputing</media:title>
   <media:content url="https://www.youtube.com/v/taqpysNNdtg?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i1.ytimg.com/vi/taqpysNNdtg/hqdefault.jpg" width="480" height="360"/>
   <media:description>What the heck is hexadecimal?! 🎮

Why do programmers use letters as numbers? Why does HEX $10 equal 16, and HEX $20 equal 32?

Welcome to RetroJitsu Side Quests — bite-sized adventures into retro computing, vintage technology, and old-school programming!

In this first Side Quest, we're exploring decimal, binary, and hexadecimal, just enough to understand the mysterious numbers in classic computer code.

🕹️ **WATCH THE FULL 6502 ASSEMBLY ADVENTURE:**
https://youtu.be/lf1zbfaNjog

We explore how computers like the Atari 800XL worked, write our first 6502 assembly program, and even watch the processor execute instructions!

Old Computers. New Code. Timeless Tech!

#Hexadecimal #RetroComputing #Programming</media:description>
   <media:community>
    <media:starRating count="1" average="5.00" min="1" max="5"/>
    <media:statistics views="39"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:If1zbfaNjog</id>
  <yt:videoId>If1zbfaNjog</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Programming My Old Computer Like It’s 1983! | My First 6502 Assembly Program</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=If1zbfaNjog"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-20T22:45:01+00:00</published>
  <updated>2026-10-23T23:09:12+00:00</updated>
  <media:group>
   <media:title>Programming My Old Computer Like It’s 1983! | My First 6502 Assembly Program</media:title>
   <media:content url="https://www.youtube.com/v/If1zbfaNjog?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/If1zbfaNjog/hqdefault.jpg" width="480" height="360"/>
   <media:description>What was it like programming a computer back in 1983? After more than 20 years as a professional programmer, I'm going back to my roots to finally learn **6502 assembly language!**

The legendary MOS 6502 processor helped power an entire generation of home computers, including the Apple II, Commodore PET, and Atari 8-bit family. These machines helped introduce millions of people to programming, including me!

I grew up programming in Atari BASIC, but I never really understood what was happening inside that little processor. Today, we're changing that!

We'll explore hexadecimal, memory addresses, the accumulator, the Atari's system clock, and graphics hardware. Then we'll walk through a tiny 6502 assembly program that creates animated rainbow-colored bars on an Atari 800XL using the Altirra emulator!

And stick around for the bonus at the end, when we open Altirra's debugger and actually watch our processor execute instructions one at a time!

Whether you grew up with an Apple, Commodore, Atari, or simply love vintage computers and retro programming, come learn along with me!

**CHAPTERS**

00:00 — My First 6502 Assembly Adventure  
00:45 — A Little 6502 History  
01:33 — SIDE QUEST: What the Heck Is Hexadecimal?  
03:16 — ASM Files, Assemblers &amp; Atari Executables  
04:04 — Let's Explore Our Assembly Program  
05:38 — Labels, START &amp; LOOP  
06:00 — Meet the Accumulator!  
07:20 — Reading the Atari's Graphics Hardware  
08:36 — ASL, CLC &amp; 6502 Math  
09:27 — Using the Atari's System Clock  
10:16 — Changing Colors With GTIA  
11:27 — Our Rainbow Program Comes Alive!  
11:54 — BONUS: Inside Altirra's 6502 Debugger  
14:24 — What We Learned &amp; What's Next

**TOOLS &amp; CREDITS**

Emulator: Altirra  
Computer: Atari 800XL  
Processor: 6502 family  
Programming language: 6502 Assembly

Our animated rainbow program was inspired by Ken Jennings' Atari assembly demonstrations:  
https://github.com/kenjennings/Random-Acts-Of-Asm

**YOUR TURN!**

Did you program on an Atari, Apple II, Commodore 64, PET, or another classic home computer?

Did you use BASIC, assembly language, or something else?

I'd love to hear what you built back in the day! And if you've got ideas for what we should try next with 6502 assembly, leave them in the comments!

Thanks for watching RetroJitsu — Old Computers. New Code. Timeless Tech!

#6502 #RetroComputing #AssemblyLanguage</media:description>
   <media:community>
    <media:starRating count="33" average="5.00" min="1" max="5"/>
    <media:statistics views="1210"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:AyI1Dk_H1PE</id>
  <yt:videoId>AyI1Dk_H1PE</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>The Legendary Atari 800XL Is BACK! ⭐ #atari #retrocomputing</title>
  <link rel="alternate" href="https://www.youtube.com/shorts/AyI1Dk_H1PE"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-08T23:30:07+00:00</published>
  <updated>2026-11-08T14:55:53+00:00</updated>
  <media:group>
   <media:title>The Legendary Atari 800XL Is BACK! ⭐ #atari #retrocomputing</media:title>
   <media:content url="https://www.youtube.com/v/AyI1Dk_H1PE?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/AyI1Dk_H1PE/hqdefault.jpg" width="480" height="360"/>
   <media:description>The legendary Atari 800XL is BACK after more than 40 years! 🕹️

Atari and Retro Games Ltd. are bringing back the classic 1983 home computer with a full-size mechanical keyboard, working cartridge slot, and built-in Atari BASIC!

That's right — you can actually write your own programs again, just like we did back in the '80s!

This is the computer family that helped spark my lifelong love of programming, and I couldn't be more excited!

🎬 **WATCH THE FULL VIDEO!**
Tap the Related Video link below for all the details, including games, features, pricing, and release date!

🤘 Subscribe to RetroJitsu for retro computers, vintage games, and coding adventures!

https://www.youtube.com/@RetroJitsu

#Atari800XL #RetroComputing #Shorts</media:description>
   <media:community>
    <media:starRating count="31" average="5.00" min="1" max="5"/>
    <media:statistics views="1255"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:Ic83_v-gWGY</id>
  <yt:videoId>Ic83_v-gWGY</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>The Atari 800XL Returns! A 1983 Legend Reborn!</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=Ic83_v-gWGY"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-08T20:13:49+00:00</published>
  <updated>2026-10-21T16:57:45+00:00</updated>
  <media:group>
   <media:title>The Atari 800XL Returns! A 1983 Legend Reborn!</media:title>
   <media:content url="https://www.youtube.com/v/Ic83_v-gWGY?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/Ic83_v-gWGY/hqdefault.jpg" width="480" height="360"/>
   <media:description>The Atari 800XL is BACK! Atari and Retro Games Ltd. have officially announced THE 800XL, a full-size recreation of the legendary 1983 Atari home computer — and I am ridiculously excited!

This isn't another miniature retro console. We're getting a full-size mechanical keyboard, a working cartridge slot, built-in Atari BASIC, and the ability to write our own programs again!

In this quick first look, we're covering:

🕹️ Full-size mechanical keyboard and Atari BASIC

🎮 25 built-in games, including M.U.L.E., Boulder Dash, Miner 2049er, and Seven Cities of Gold

👀 TWO hidden games: Castle Crisis and Super Breakout!

💾 Original Atari cartridge support and USB software loading

📺 HDMI output, save states, and rewind

🕹️ Updated Atari joystick

💰 $219.99 preorder price and planned April 23, 2027 release

**For me, Atari computers are where it all began.** These machines introduced me to programming and sparked a lifelong love of computers and writing code.

Here on RetroJitsu, we're revisiting classic Atari games, experimenting with vintage software, and celebrating the computers that started it all!

🎮 **MORE ATARI ADVENTURES FROM RETROJITSU**

Kingdom+ — I Added Orcs to a 46-Year-Old Atari Game:
https://youtu.be/WSP3R430Usk

Micro League Baseball — My Favorite 1984 Atari Baseball Game:
https://youtu.be/1kaIiIx1ygQ

🔗 **OFFICIAL ANNOUNCEMENT &amp; PREORDER**

Atari: https://atari.com/pages/800xl

Retro Games Ltd.: https://retrogames.biz/news/the800xl-announce/

⏱️ **CHAPTERS**

00:00 The Atari 800XL Is BACK!
00:26 Full-Size Keyboard, BASIC &amp; Cartridge Support
00:49 25 Classic Games &amp; Two Hidden Games
01:12 HDMI, USB &amp; Modern Features
01:32 What's Under the Hood?
01:46 How Atari Got Me Into Programming
02:03 Price &amp; Release Date
02:15 Is THE 800XL Worth $220?

**YOUR TURN!**

Would YOU spend $220 to bring a new Atari 800XL into your home? Or are you sticking with original hardware?

Let me know in the comments!

🤘 Subscribe to RetroJitsu for more retro tech, vintage games, and coding adventures!

https://www.youtube.com/@RetroJitsu

Retro Tech • Vintage Games • Code Experiments

#Atari800XL #Atari #RetroComputing</media:description>
   <media:community>
    <media:starRating count="26" average="5.00" min="1" max="5"/>
    <media:statistics views="1239"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:548FfAIXvK0</id>
  <yt:videoId>548FfAIXvK0</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>This 1986 Atari Magazine Had EVERYTHING | Static From the Attic #1</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=548FfAIXvK0"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-07T22:32:51+00:00</published>
  <updated>2026-10-21T23:44:37+00:00</updated>
  <media:group>
   <media:title>This 1986 Atari Magazine Had EVERYTHING | Static From the Attic #1</media:title>
   <media:content url="https://www.youtube.com/v/548FfAIXvK0?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/548FfAIXvK0/hqdefault.jpg" width="480" height="360"/>
   <media:description>June 1986. A new issue of Antic Magazine has arrived — and apparently summer means MORE computer time.

Welcome to the first episode of Static From the Attic, where we dig through classic computer magazines, forgotten software, weird hardware, type-in programs, and all the stuff that made home computing so much fun.

This month we’re opening Antic Magazine — June 1986, Vol. 5 No. 2.
We’re checking out Atari computer camps, using an Atari to predict the weather, discovering why anyone would buy a mouse when they could own THE RAT, and typing in Antic’s Game of the Month: Bomb Squad.

And before we run it, we’ve got our first BASIC Lesson of the Month — DIM, arrays, and how BASIC reserves memory for the data your program needs.

Then we actually fire up Bomb Squad and see whether we can do any better than the Antic staff did.

📖 Read the original June 1986 issue of Antic:
https://www.atarimania.com/mags/pdf/Antic_Vol_5_No_2.pdf

If old-school computers, Atari, BASIC programming, vintage software, computer magazines, and strange forgotten tech are your thing, subscribe to RetroJitsu and let me know if you’d like to see more Static From the Attic.

And remember:
WHO NEEDS A MOUSE WHEN YOU CAN HAVE A RAT?!


Chapters
0:00 Welcome to Static From the Attic
0:38 Summer Computing &amp; Computer Camp
1:43 Weather Wizard
2:26 Meet THE RAT
3:01 Bomb Squad — Game of the Month
3:49 BASIC Lesson of the Month: DIM
4:36 Let’s Run Bomb Squad
5:05 The High Score Problem
5:20 This Month in the Attic  

#Atari #RetroComputing #VintageComputers</media:description>
   <media:community>
    <media:starRating count="1" average="5.00" min="1" max="5"/>
    <media:statistics views="212"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:tZRGF6MLJs0</id>
  <yt:videoId>tZRGF6MLJs0</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Learn C# by Building an Old-School RPG — Part 6: Create Your Hero</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=tZRGF6MLJs0"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-06T15:46:15+00:00</published>
  <updated>2026-11-06T04:48:08+00:00</updated>
  <media:group>
   <media:title>Learn C# by Building an Old-School RPG — Part 6: Create Your Hero</media:title>
   <media:content url="https://www.youtube.com/v/tZRGF6MLJs0?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i1.ytimg.com/vi/tZRGF6MLJs0/hqdefault.jpg" width="480" height="360"/>
   <media:description>Our C# RPG gets its first hero! In Part 6, we put adventure loading behind an interface, then build the Character, Abilities, and Item models. Finally, we create Conan in JSON and load him into the game with CharacterService.

Along the way, we cover inheritance, interfaces, and how the game services fit together.

▶ Part 5 — Git &amp; GitHub: https://youtu.be/ylsv6G55YV4?si=PvBwEgyYdvYkDbwI
▶ Browse RetroJitsu courses: https://www.youtube.com/@RetroJitsu/courses

Chapters
00:00 Welcome to Part 6
00:30 Create a Git branch for this episode
02:51 Recap the RPG so far
03:37 OOP, inheritance, and substitution
06:27 What are C# interfaces?
06:45 Create IAdventureService
09:46 Implement the adventure interface
13:20 Connect it to GameService
17:57 Create the RPG entities
18:57 Build Character and Abilities
21:50 Model items and inventory
25:39 Create Conan in JSON
28:25 Build CharacterService
34:24 Load our first character

#CSharp #LearnToCode #GameDevelopment</media:description>
   <media:community>
    <media:starRating count="1" average="5.00" min="1" max="5"/>
    <media:statistics views="117"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:ylsv6G55YV4</id>
  <yt:videoId>ylsv6G55YV4</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Learn C# by Building an Old-School RPG — Part 5: Git &amp; GitHub</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=ylsv6G55YV4"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-10-06T14:27:47+00:00</published>
  <updated>2026-11-15T11:19:56+00:00</updated>
  <media:group>
   <media:title>Learn C# by Building an Old-School RPG — Part 5: Git &amp; GitHub</media:title>
   <media:content url="https://www.youtube.com/v/ylsv6G55YV4?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/ylsv6G55YV4/hqdefault.jpg" width="480" height="360"/>
   <media:description>Before we add characters to our C# RPG, let’s save our progress. In Part 5 of RetroJitsu Code Lab, I explain commits and branches, create a GitHub repository, and walk through the first add → commit → push cycle. We’ll also create a README and see how Git keeps a history of the project.

▶ Previous episode — Part 4: Load JSON &amp; Build a Game Service: https://youtu.be/F8T1UM2Mvk0?si=9ShVXeoMIv5XTD3l
▶ All RetroJitsu courses: https://www.youtube.com/@RetroJitsu/courses

CHAPTERS
00:00 Why version control matters
02:00 Branches and merging
03:59 Create a GitHub repository
05:45 Open a command line in the project folder
06:08 Initialize Git and create a README
08:14 Stage the project files
09:04 Make your first commit
10:22 Connect the project to GitHub
11:18 Push the code
12:14 Edit the README
13:03 The everyday add, commit, push workflow
15:15 What’s coming in Part 6

Update for viewers following along today: GitHub Free includes private repositories. New repositories commonly use “main” where this recording uses “master,” so use the branch name in your own project. For Git over HTTPS, use a credential manager or personal access token instead of your GitHub account password.
Current authentication help: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/about-authentication-to-github

#CSharp #Git #GitHub</media:description>
   <media:community>
    <media:starRating count="0" average="0.00" min="1" max="5"/>
    <media:statistics views="48"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:F8T1UM2Mvk0</id>
  <yt:videoId>F8T1UM2Mvk0</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Learn C# by Building an Old-School RPG — Part 4: Load JSON &amp; Build a Game Service</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=F8T1UM2Mvk0"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-09-20T01:40:50+00:00</published>
  <updated>2026-10-22T15:11:50+00:00</updated>
  <media:group>
   <media:title>Learn C# by Building an Old-School RPG — Part 4: Load JSON &amp; Build a Game Service</media:title>
   <media:content url="https://www.youtube.com/v/F8T1UM2Mvk0?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i3.ytimg.com/vi/F8T1UM2Mvk0/hqdefault.jpg" width="480" height="360"/>
   <media:description>Learn C# by continuing to build an old-school RPG console game from scratch.

In Part 4, the adventure data we created in JSON becomes part of the actual game. We locate and open the file using System.IO and StreamReader, install Newtonsoft.Json through NuGet, and deserialize the JSON into a working Adventure object.

🎓 COMPLETE C# RPG COURSE
https://www.youtube.com/playlist?list=PLYBsdGOX4cfk

📚 ALL RETROJITSU COURSES
https://www.youtube.com/@RetroJitsu/courses

⬅️ PREVIOUS LESSON — PART 3
https://youtu.be/G6rHJ7Dcjzk

We’ll expand the Adventure class with experience, gold, GUID, and level properties. Then we’ll introduce the Single Responsibility Principle and move the game logic out of Program and into a dedicated GameService.

By the end of this lesson, your RPG will be able to locate an adventure file, convert its JSON data into a C# object, and start the game through a cleaner service-based structure.

In this episode, you’ll learn:

• Using the System.IO namespace
• Checking whether a file exists
• Building application file paths
• Working with DirectoryInfo and GetFiles()
• Understanding method overloads
• Opening files with StreamReader
• Using statements and resource cleanup
• Arrays and zero-based indexing
• Serialization and deserialization
• Installing NuGet packages
• Using Newtonsoft.Json
• Understanding project dependencies
• Deserializing JSON into a C# object
• Reading and debugging object properties
• Creating and using GUIDs
• Adding properties with the prop code snippet
• The Single Responsibility Principle
• Creating a GameService class
• Moving game logic into a service
• Instantiating and calling the GameService

CHAPTERS

00:00 Preview and checking the adventure file
00:30 Using System.IO
00:44 Building the file path
01:25 Reading the adventure directory
01:59 Understanding method overloads
02:34 Opening a file with StreamReader
03:52 Arrays and zero-based indexing
05:34 Converting JSON into an object
06:27 Installing Newtonsoft.Json
08:29 Understanding project dependencies
09:14 Deserializing the adventure file
10:40 Reading the adventure properties
11:38 Testing the loaded adventure
12:23 Adding XP and gold rewards
12:54 Creating a GUID
14:27 Adding properties to the Adventure class
15:09 Using the prop code snippet
16:33 Confirming the JSON data loaded correctly
16:58 The Single Responsibility Principle
18:17 Creating a game service
19:30 Moving game logic into the service
21:38 Instantiating the GameService
22:23 Calling StartGame() from the service
23:04 What’s coming in Part 5

This series is designed for absolute beginners. You do not need any previous C# or programming experience.

The course was originally recorded using Visual Studio 2019, so some screens may look slightly different today, but the core C# concepts remain the same.

In Part 5, we’ll continue building the RPG with character data, additional JSON files, and more game objects.

➡️ NEXT LESSON — PART 5
Coming soon

#CSharp #LearnToCode #GameDevelopment</media:description>
   <media:community>
    <media:starRating count="0" average="0.00" min="1" max="5"/>
    <media:statistics views="264"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:Jt3QA1x1TWk</id>
  <yt:videoId>Jt3QA1x1TWk</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Learn C# by Building an Old-School RPG -- Part 1 : First Program</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=Jt3QA1x1TWk"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-09-19T23:58:41+00:00</published>
  <updated>2026-11-08T15:04:30+00:00</updated>
  <media:group>
   <media:title>Learn C# by Building an Old-School RPG -- Part 1 : First Program</media:title>
   <media:content url="https://www.youtube.com/v/Jt3QA1x1TWk?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i3.ytimg.com/vi/Jt3QA1x1TWk/hqdefault.jpg" width="480" height="360"/>
   <media:description>Learn C# from scratch by building an old-school RPG console game.

In Part 1, we set up the tools needed for the course, create our first C# console application, and examine the basic pieces that make a C# program work.

This is more than a game-development tutorial. The RPG gives us a fun project through which we can learn practical C# syntax, object-oriented programming, good coding habits, and concepts that also apply to professional software development.

By the end of this lesson, you’ll have Visual Studio installed, your first console project running, and a basic understanding of how C# programs are organized.

In this episode, you’ll learn:

• What we’ll build throughout the course
• How the RPG project helps teach C#
• Installing Visual Studio
• Creating a C# console application
• Solutions and projects
• Classes as the building blocks of a program
• Properties and methods
• The Main method and application entry point
• Running your first C# program
• The .NET framework and project dependencies
• Namespaces
• Using statements
• How Visual Studio helps identify and fix errors

Chapters

00:00 The RPG console game we’ll build
00:14 What you’ll learn throughout the series
01:19 What Part 1 covers
01:45 Installing Visual Studio
02:17 Creating a console application
02:48 Exploring Visual Studio
03:17 Solutions and projects
04:20 Classes, properties, and methods
05:33 Understanding the Main method
06:02 Running your first program
06:31 .NET dependencies and the Console class
07:14 Understanding namespaces
07:29 What using statements do
09:40 Reviewing the basic program structure
10:07 What’s coming in Part 2


This course is designed for absolute beginners. You do not need any previous C# experience.

The video was originally recorded using Visual Studio 2019, so some screens may look slightly different in newer editions, but the core C# concepts remain the same.

In Part 2, we begin turning the project into a real RPG by learning about types, variables, methods, debugging, user input, menus, and if/else logic.

🎮 COMPLETE COURSE:
https://www.youtube.com/playlist?list=PLYBsdGOX4cfk

▶ NEXT LESSON — Part 2: Menus &amp; Input
https://youtu.be/kDtWA8OJ9eE</media:description>
   <media:community>
    <media:starRating count="10" average="5.00" min="1" max="5"/>
    <media:statistics views="373"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:G6rHJ7Dcjzk</id>
  <yt:videoId>G6rHJ7Dcjzk</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Learn C# by Building an Old-School RPG — Part 2: Menus &amp; Input</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=G6rHJ7Dcjzk"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-09-19T23:58:27+00:00</published>
  <updated>2026-10-22T00:47:29+00:00</updated>
  <media:group>
   <media:title>Learn C# by Building an Old-School RPG — Part 2: Menus &amp; Input</media:title>
   <media:content url="https://www.youtube.com/v/G6rHJ7Dcjzk?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i4.ytimg.com/vi/G6rHJ7Dcjzk/hqdefault.jpg" width="480" height="360"/>
   <media:description>Learn C# by building an old-school RPG console game from scratch.

In Part 2, we move beyond “Hello World” and begin turning the project into an actual game. Along the way, you’ll learn essential beginner C# concepts including types, variables, methods, arguments, return values, debugging, user input, string interpolation, access modifiers, enums, and if/else logic.

By the end of this lesson, your console RPG will have a title screen, custom colors, ASCII art, a simple main menu, and the ability to read and evaluate player input.

In this episode, you’ll learn:

• Built-in C# types
• Variables and var
• Creating your own methods
• Method arguments and return values
• Method overloading
• Debugging with breakpoints
• Stepping through code
• Reading player input with Console.ReadLine()
• String interpolation
• Access modifiers
• Console colors
• Enums
• if/else statements
• Logical OR conditions
• ToUpper() and ToLower()
• Building a basic RPG main menu

Chapters

00:00 Preview and Part 1 review
00:58 Built-in C# types
01:50 Exploring the Console class
03:09 Method overloading
03:33 Arguments and return values
07:27 Creating variables
08:52 Debugging with breakpoints
11:22 Fixing the AddNumbers method
12:50 Finding and fixing your first bug
15:30 Reading player input
19:09 Starting the RPG
19:26 Creating the title method
19:44 Access modifiers
21:33 Console colors
23:26 Adding ASCII art
24:43 Creating the main menu
27:57 Reading menu choices
28:37 String interpolation
30:18 if/else logic
33:39 Handling uppercase and lowercase input
34:40 What’s coming in Part 3

This series is designed for absolute beginners. You do not need any previous C# experience.

In Part 3, we’ll begin working with loops, files, JSON, and custom classes as the RPG starts becoming a real game.

#CSharp #Programming #gamedevelopment 

🎮 COMPLETE COURSE:
https://www.youtube.com/playlist?list=PLYBsdGOX4cfk

◀ PREVIOUS LESSON — Part 1: First Program
https://youtu.be/Jt3QA1x1TWk

▶ NEXT LESSON — Part 3: Loops, JSON &amp; Custom Classes
https://youtu.be/G6rHJ7Dcjzk</media:description>
   <media:community>
    <media:starRating count="2" average="5.00" min="1" max="5"/>
    <media:statistics views="170"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:kDtWA8OJ9eE</id>
  <yt:videoId>kDtWA8OJ9eE</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>Learn C# by Building an Old-School RPG — Part 3: Loops, JSON &amp; Custom Classes</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=kDtWA8OJ9eE"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-09-19T23:58:16+00:00</published>
  <updated>2026-10-21T22:35:56+00:00</updated>
  <media:group>
   <media:title>Learn C# by Building an Old-School RPG — Part 3: Loops, JSON &amp; Custom Classes</media:title>
   <media:content url="https://www.youtube.com/v/kDtWA8OJ9eE?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i4.ytimg.com/vi/kDtWA8OJ9eE/hqdefault.jpg" width="480" height="360"/>
   <media:description>Learn the basics of C# by continuing to build an old-school RPG console game from scratch.

In Part 3, we make the main menu actually work, introduce loops and switch statements, begin storing adventure data in JSON files, and create our first custom C# class.

This is where the project moves beyond isolated examples and begins developing into a real RPG structure.

By the end of this lesson, your game will repeatedly validate menu input, respond to different player choices, store adventure information in a JSON file, and contain a custom Adventure class with its own properties and constructor.

In this episode, you’ll learn:

• How while loops work
• Using Boolean variables
• Negating a Boolean with !
• Validating player input
• Testing code with breakpoints
• Calling different methods from menu choices
• The DRY principle: Don’t Repeat Yourself
• Extracting repeated code into a method
• Replacing complicated if/else logic with a switch
• Finding and fixing an infinite loop
• What JSON is
• Creating a JSON adventure file
• Working with application file paths
• Organizing files and folders
• Creating your first custom C# class
• Namespaces and using statements
• Instantiating an object
• Constructors
• Auto-implemented properties
• XML documentation comments

Chapters

00:00 Preview and RPG main-menu review
00:23 Starting a new game
01:08 Why we’ll store game data in files
03:42 Fixing the menu with a while loop
04:19 Using a Boolean variable
06:29 Negating a Boolean with !
08:14 Testing the loop
10:01 Connecting the menu choices
11:16 Recognizing repeated code
11:32 The DRY principle
11:49 Extracting the menu options method
13:47 Replacing if/else with a switch
16:32 Finding an infinite-loop bug
17:43 Fixing the menu loop
19:12 What JSON is
19:48 Creating the first adventure file
21:32 Saving JSON in the project structure
23:08 Preparing to load the adventure
24:26 Creating your first custom class
25:30 Namespaces and access modifiers
27:08 Instantiating the Adventure class
27:28 Cleaning up using statements
28:13 Constructors, methods, and properties
29:43 Auto-implemented properties
31:08 XML documentation comments
31:54 What’s coming in Part 4

This series is designed for absolute beginners. You do not need any previous C# experience.

In Part 4, we’ll create a game service, open and read the JSON file, convert that data into an Adventure object, and continue building the RPG’s game engine.

#CSharp #Programming #gamedevelopment 

🎮 COMPLETE COURSE:
https://www.youtube.com/playlist?list=PLYBsdGOX4cfk

◀ PREVIOUS LESSON — Part 2: Menus &amp; Input
https://youtu.be/kDtWA8OJ9eE

▶ NEXT LESSON — Part 4: Coming soon</media:description>
   <media:community>
    <media:starRating count="0" average="0.00" min="1" max="5"/>
    <media:statistics views="128"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:BEdURppG5A8</id>
  <yt:videoId>BEdURppG5A8</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>This 1984 Atari Game Made Me Track EVERY STAT</title>
  <link rel="alternate" href="https://www.youtube.com/shorts/BEdURppG5A8"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-09-19T17:00:25+00:00</published>
  <updated>2026-10-21T20:03:58+00:00</updated>
  <media:group>
   <media:title>This 1984 Atari Game Made Me Track EVERY STAT</media:title>
   <media:content url="https://www.youtube.com/v/BEdURppG5A8?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i3.ytimg.com/vi/BEdURppG5A8/hqdefault.jpg" width="480" height="360"/>
   <media:description>MicroLeague Baseball wasn’t just an Atari game to me—it became an entire baseball universe. I tracked full seasons, standings, and player stats in three-ring binders, printed from my Atari 800XL on a loud dot-matrix printer.

Watch the full story through the linked video below.

#Atari #MicroLeagueBaseball #RetroGaming</media:description>
   <media:community>
    <media:starRating count="2" average="5.00" min="1" max="5"/>
    <media:statistics views="114"/>
   </media:community>
  </media:group>
 </entry>
 <entry>
  <id>yt:video:1kaIiIx1ygQ</id>
  <yt:videoId>1kaIiIx1ygQ</yt:videoId>
  <yt:channelId>UCy4-zbCBOH4nRbeGCehsgKA</yt:channelId>
  <title>This 1984 8-Bit Computer Game Took Over My Childhood</title>
  <link rel="alternate" href="https://www.youtube.com/watch?v=1kaIiIx1ygQ"/>
  <author>
   <name>RetroJitsu</name>
   <uri>https://www.youtube.com/channel/UCy4-zbCBOH4nRbeGCehsgKA</uri>
  </author>
  <published>2026-09-17T18:34:12+00:00</published>
  <updated>2026-10-21T15:36:25+00:00</updated>
  <media:group>
   <media:title>This 1984 8-Bit Computer Game Took Over My Childhood</media:title>
   <media:content url="https://www.youtube.com/v/1kaIiIx1ygQ?version=3" type="application/x-shockwave-flash" width="640" height="390"/>
   <media:thumbnail url="https://i2.ytimg.com/vi/1kaIiIx1ygQ/hqdefault.jpg" width="480" height="360"/>
   <media:description>One 1984 Atari game took over my childhood—and filled three-ring binders with box scores, batting averages, pitching records, standings, and entire seasons printed on a loud dot-matrix printer.

That game was MicroLeague Baseball.

This wasn’t a joystick action game. I managed historical teams, built lineups, called bunts and steals, warmed up relievers, made trades, drafted players, and used separate floppy disks to compile statistics across an entire season.

From outside my bedroom, it probably looked like some kid pushing buttons and watching tiny pixel baseball players. To me, it was something much bigger.

More than 40 years later, I returned to MicroLeague Baseball to find out whether it was really as special as I remembered. Along the way, we’ll explore its officially licensed historical teams, player-run leagues, strategy manuals, Stat Compiler, GM/Owner program—and why every pitch became part of a season that belonged to me.

CHAPTERS

0:00 The Atari Game That Took Over My Childhood
0:50 What Was MicroLeague Baseball?
2:28 Baseball Communities Before Online Play
3:00 Building a Universe One Disk at a Time
4:39 Returning After 40 Years
5:51 Back on the Field
6:13 Why Every Game Mattered
7:38 Preserved by the Fans

The complete Altirra setup and step-by-step instructions will be covered in a separate companion video.

If you love forgotten computers, vintage games, and the strange things we built with them, welcome to RetroJitsu:

https://www.youtube.com/@RetroJitsu

Retro Tech • Vintage Games • Code Experiments

#Atari800XL #RetroComputing #MicroLeagueBaseball</media:description>
   <media:community>
    <media:starRating count="3" average="5.00" min="1" max="5"/>
    <media:statistics views="63"/>
   </media:community>
  </media:group>
 </entry>
</feed>
