Blog Posts What am I doing?

Ashton’s Notebook | Part 2: Combat and Charisma

Greetings! Didn’t think I’d return to this, I would assume? Well, I’m back, and I’ve figured out at least a foundation for rules regarding combat and social encounters. There really isn’t much for me to say regarding the world, so this post will just be about the system. Good? Good.

BUT FIRST, I changed some stuff. First, dice in the pool just have to exceed the TN now: meeting the TN is counted as a failure. Why this change? I wanted a TN of 10 to be equivalent to flipping a coin – each d20 would have a 10/20 chance of being a success or a failure. However, with the way things worked previously, a TN of 10 would be an 11/20 chance. Hence the change.

Also, attributes are now a thing! These work similarly to VtM: each level in an attribute adds a certain amount of d20 to your pool (currently 2d20), as does levels in skills (currently 4d20). In addition, you always have 2d20 in your pool. Always. Even if all of your party members screw you over when trying to assist, you will always have 2d20. Even if it means you can only Botch, Mess, or Critical. Also, for any attribute, you must have at least one level in it. Attributes have five levels (again, like VtM attributes), while skills have only three levels to account for the fact that they add more dice. This means that, in theory, you can have a maximum of 24d20 in your pool. Which is a lot, so I might tweak the numbers a bit. Maybe make attributes and skills equal, or change it such that skills are the only thing that affect the dice pool and attributes allow you a certain amount of re-rolls? That remains to be seen, but I kinda like the system as it is so who knows.

As for what the attributes are, they’re literally just the standard D&D attribute set because I can’t think of anything better, but Dexterity is renamed to Reflexes and Constitution is renamed to Endurance. Also, each skill will correspond to one of the attributes. The only exception is Perception, which can be used with any attribute (riffing off of Cogent Roleplaying System a bit here). Besides that, the only other skills I’ve figured out so far are: Melee Weapons (Str), Ranged Weapons (Ref), Throwing Weapons (Ref), Persuasion (Cha), Intimidation (Cha?), and Deception (Cha).

As for stats, I have four right now and they are HP (End), Unarmed Combat Damage Multiplier (Str), Unarmed Combat TN (Str), and Speed (Ref). Guess what all of these do.



When combat begins, turn order is decided. Whoever has the highest Reflexes goes first. If two characters have the same Reflexes, do a competitive check to break the tie.

When a character’s turn comes up, they can perform up to three actions. Moving to a different position takes up one action as long as it’s within the distance determined by the character’s speed. Any more and it may take up multiple actions. Using items may or may not use up an action, depending on the item and how it’s used. Attacking someone will always use up one action. For the purpose of explaining stuff, we’ll say that the person who used an action to attack someone is called the “Attacker”, the person they want to attack being called the “Target”. The target will have two options for how to deal with the attack: they can defend themselves, or they can try to counter-attack. If the attacker is using a ranged or thrown weapon and the target doesn’t have one, they can only defend. Otherwise, the target has a choice. No matter what the target chooses, a competitive check occurs. The TN is dependent on the other character’s armor rating and their reflexes. What happens depends on the outcome and what the target chose. I’ll describe them from the attacker’s perspective (and I’m also assuming the attacker is you), as such:

  • If the target is defending themselves:
    • Botch: You fail to attack. If valid targets other than you and the original target are in range, roll 1d20 to determine who will actually be attacked. Otherwise, the attacker harms themselves no matter what.
    • Fail: You fail to attack.
    • Mess: You attack, but your damage is cut in half.
    • Succeed: You attack.
    • Critical: You attack, and you deal double damage. If the target is using an item to defend themselves directly, the item is damaged. If the item had been damaged twice before and not repaired, it is broken.
  • If the target is counter-attacking:
    • Botch: You fail to attack, and are attacked by the target for double damage.
    • Fail: You fail to attack, and are attacked by the target.
    • Mess: You attack, but are attacked by the target.
    • Succeed: You attack.
    • Critical: You attack for extra damage.

Assuming you landed a hit, you roll again to determine how much damage you deal using the same dice pool, but with a TN determined by the weapon you are using. Then, the success dice should be counted and multiplied by a number which is again determined by the weapon you’re using. The number you get is then doubled if you get a critical or halved if you get a mess while the target is defending.

Something important when it comes to combat is what I’ll call the Deck of Wounds. Yes, if you’ve been on r/RPGdesign, you’ll know that this is basically the Deck of Tragedies. Basically, each player gets a deck which contains a bunch of cards (will be 24 assuming I don’t change the number). When a player character’s HP hits 0, the player must draw the top three cards from the deck and give two of them to the game master. The GM must then choose one card, which is handed back to the player while the GM narrates how the wound was gained. Wound cards have at least one effect and a condition that must be met for the wound to be removed/healed. The only exception is death cards. Yes, death cards. When a death card is chosen, it is handed back to the player who then narrates their character’s demise. I have plans for a divine magic ritual that could revive a character, but it would be a slim chance of success. All wound cards which were rejected or healed, as well as death cards, are returned to the bottom of the player’s deck.

Assuming the player avoided character death, the character’s HP returns to their maximum and they are unconscious for the rest of the combat encounter (and will also be safe from further harm) unless they make a 15 TN Strength-only (think of it like a saving throw) check to fight on. Outcomes are as follows:

  • Botch: You go unconscious, but are vulnerable to further harm.
  • Fail: You go unconscious.
  • Mess: You fight on, but your max HP is halved for the rest of the encounter, rounding up if your max HP is odd.
  • Success: You fight on.
  • Critical: You fight on, and your max HP is doubled for the rest of the encounter.


Social encounters are handled in a (hopefully) simple manner. NPCs will have one of three attitudes towards the party: friendly, neutral, and hostile. The attitude determines the TN for the charisma roll. The party may attempt to change an NPC’s attitude through roleplay, but they may only move it one “notch” in either direction during a single encounter. One player should then make a charisma plus persuasion/intimidation/deception check. If any other players helped, they each add 2d20 to that one player’s pool. If any players (accidentally or purposely) hindered the effort, they each remove 2d20 from that one player’s pool. When the check is made, the TN for a friendly NPC is 5, the TN for a neutral NPC is 10, and the TN for a hostile NPC is 15. The outcomes are as follows:

  • Botch: The NPC won’t help you, and will try to hinder the party’s efforts.
    • If the NPC was Friendly, a botch acts like a regular fail.
    • If the NPC was Neutral, they will only accept minor risks.
    • If the NPC was Hostile, they will accept major risks.
  • Fail: The NPC won’t help you.
    • If the NPC was Hostile, they will try to hinder the party’s efforts, accepting minor risks to do so.
  • Mess: The NPC will help you, but they won’t take any risks.
  • Succeed: The NPC will help you, taking minor risks to do so.
  • Critical: The NPC will help you, taking major risks to do so.

Hopefully this all makes sense so far. Again, feedback and questions are appreciated. Have an awesome day!


Ashton’s Notebook: Creating a TTRPG and a world to go with it | Part 1

Greetings! For a good while now, I’ve been working on a TTRPG system and a fictional fantasy world to go along with it, as you could probably tell from the title. It all started with a Moleskin notebook that I started writing details of the world into when I started working on it, hence the name. This is only part one, obviously. The system is nowhere near done, same with the world. But I’ll give you what I’ve figured out now.

The System

Whenever you try to do something in any TTRPG system, you perform some sort of check. This unnamed system has three kinds of checks: normal checks, competitive checks, and assistance checks. Normal checks are performed whenever you’re trying to do something, competitive checks occur when you’re rolling against someone else, and assistance checks occur whenever you’re trying to help someone else do something. All checks are done by rolling a pool of d20, or 20-sided dice. Each individual die (yes, that’s the singular form of “dice”) in the pool must equal or exceed a TN, or target number, in order to be considered a “success die”. Any die that doesn’t is a “failure die”.

In normal and assistance checks, the amount of success and failure dice in your pool determines the outcome. There are five potential outcomes: botches, where all of your dice are failure dice, fails, where most of your dice are failure dice, messes, where your dice are split exactly in half, successes, where most of your dice are success dice, and criticals, where all of your dice are success dice. In the case of a normal check, you succeed at doing whatever you’re trying to do whenever you get a mess, success, or critical, but a mess means something bad happens as well while a critical means that something good happens as well. Failures and botches mean you failed, but botches mean something bad happens as well. If you’re familiar with improv, the outcomes can be summed up as follows:

  • Botch: No, and.
  • Fail: No.
  • Mess: Yes, but.
  • Success: Yes.
  • Critical: Yes, and.

Assistance checks have the same types of outcomes, and they are determined exactly the same way. However, the outcome determines how many dice are added or removed from the pool of whoever you’re assisting. So, a mess means no change, a success means adding 2 more dice, a critical means adding 4 more dice, a fail means removing 2 dice, and a botch means removing 4 dice.

Competitive checks work somewhat differently. Instead, you and your opponent both roll your pools, and whoever’s pool has more success dice succeeds while the other fails. If both pools have the same amount of success dice, that’s a mess. If one of you gets all success dice while the other gets all failure dice, then the first one gets a critical while the other gets a botch.

As for what determines the size of your pool, that would be skills. I don’t know what skills will be in the game just yet, but I know they will have multiple levels (don’t know the level cap yet either) and each level will add dice to your pool (2 dice per level right now). If you don’t have any levels in a skill, you have 4 dice in your pool. Why four? I still want messes to be possible for normal and assist checks, even if you don’t have any levels in a skill. 2 dice to start with, and your only possible outcomes are botch, mess, and critical. 3, and you can’t have a mess. So, 4.

That’s basically all I have figured out right now. I have some ideas for other things, such as how combat would work and whether classes would be a thing, but they aren’t figured out yet.

The World

The world the game would take place in is also somewhat under-developed. I’ve figured out that I want the world to have an axial tilt of 55 degrees (meaning that the equator has arctic temperatures while the poles have tropical temperatures, see Artifexian’s video on axial tilt for more information) and that I want four continents and a bunch of islands. I’ve also figured out how time is going to be. I did not do that mathematically, because last time I tried to worldbuild mathematically/scientifically I broke Universe Sandbox 2. Instead, I pulled numbers out of my rear end. And I got my little sister to do the same. Here’s what we decided on:

  • A local day is 27 Earth hours, or 18 local hours, long.
  • There are two moons, and the moon related stuff is as follows:
    • The inner moon has 5 local day long phases and 20 local day long months.
    • The outer moon has 10 local day long phases and 40 local day long months.
  • A year is 8 and 1/3 outer moon months, or 16 and 2/3 inner moon months, long.
  • So, in total, a normal year is 320 local days long while a leap year is 360 local days long.

I’ve also decided on having three different magic systems of sorts. These can be best described as “divine magic”, “genetic magic”, and “gun magic”. I’ll give you the gist real quick: divine magic is a sort of ritual magic that involves basically asking the gods of this world to do stuff, genetic magic is classic spell casting and is locked behind a genetic trait (like Harry Potter wizards but no squibs), and gun magic is based on the genetic magic but is simpler, doesn’t requite much preparation, and can be used by anyone. That’s about all I’ve really got figured out about them – details are nonexistent right now. But, I can’t really work on the gun magic until I’ve mostly figured out the genetic magic, since it will follow some of the same rules.

That’s all I’ve got for now. Leave feedback and questions in the comments if you want, and have an awesome day!


Neutron PC32 Bill of Materials (for prototype at least)

  • Western Design Center W65C02S6TPG-14 Microprocessor
  • Clock Crystal/Oscillator – 8 MHz Maximum (poss. frequency divider for prototype?)
  • Alliance Memory AS6C62256A-70PCN (warn: EOL, all other THT 70ns 32kB/256kb SRAM are 10x price)
  • Microchip Technology/Atmel AT28C64B-15PU
  • Microchip Technology/Atmel AT27C010-70PU
  • 2 Western Design Center W65C22S6TPG-14 Versatile Interface Adapters
  • Western Design Center W65C51N6TPG-14 Asynchronous Communication Interface Adapter
  • Microchip Technology/Atmel ATMEGA4809-PF
  • Newhaven Display NHD-240128WG-ATFH-VZ#
  • Analog Devices DAC08CPZ
  • Some form of speaker (hooked up to DAC08CPZ)
  • All logic chips required for:
  • All logic chips required for address decode logic (mainly 4-to-16 and 3-to-8 multiplexers/demultiplexers/whatevers + inverters and other gates)
  • Some power supply (planned for finished device: 9V battery or DC power jack, both options present)
  • Connectors: DB25, 8-pin Mini-DIN, 6-pin DIN, some card edge connector, a DC output barrel jack for serial devices

WordPress unborked itself

Self-Explanatory. I can now access my website from my laptop again. Granted, the site is probably going to go down for a few minutes after I post this (because WordPress is WordPress) but whatever.


Finally blogging again.

It’s been a while. WordPress somehow broke itself such that I can’t access it on my laptop, but can still access it anywhere else. I really need to learn web design stuff so I can replace WordPress. Soon.

Anyways, I should probably update you on what’s going on. First, goats. Mainly because they’re shouting in the backyard as I type this out.

Second, I’ve made more changes to Neutron (and created a sister project codenamed Cellia). I’ll save those for a later date (as in, when I get wiki edit access and forum posting access on the RetroBrew Computers website).

Third, I still suck at Calculus and would like to skip to Linear Algebra cause I can understand it better (thanks to 3blue1brown for existing and making math youtube videos).

Fourth, I want to try and Ludum Dare.

Fifth, Bananas.

aight, bye.


Another Neutron Update + A Rant on Annoying 16-bit Microprocessor Things

Let us start off with the rant mentioned in the title. Whenever I think about making a retro computer or device of some sort, I immediately jump to 16-bit because that era is the most interesting one to me. Sadly, the 16-bit processors available on the market (or at least Mouser) are extremely annoying to design around.

Let’s start with the W65C816S, which was originally planned to be used in the Neutron. Annoying thing number #1: multiplexed pins. The 65816 has a 24-bit address bus and an 8-bit data bus, with a 16-bit internal architecture. However, the physical package only has 16 address pins. Where do the other 8 pins go? Why, they’re the data bits! Because for some god dang reason, Western Design Center decided that making the data bus sometimes be part of the address bus was a good idea (IT ISN’T). And that’s not taking into account annoying thing number #2: the interrupt vectors and handlers HAVE to be located in bank $00 (specifically, the vectors must be in the $00FF00 area). The stack is also restricted to bank $00. And this causes a dilemma: unless you’re willing to add a chip (or a feature to an existing chip) that copies the interrupt vectors and handlers from ROM into RAM on reset, you’re going to end up with a crazy memory map like the one in the Super Nintendo if you want to have a stack. So, TL;DR: The 65816 is annoying due to multiplexed address/data pins and the location the interrupt vectors and handlers have to be in.

Up next on the chopping block: The Z8000, or specifically the Z16C02 (being the only version that’s still on the market). For some reason, instead of just having SOME of the data pins act as address pins, THE ENTIRE ADDRESS BUS AND DATA BUS USE THE SAME GOD DANG PINS, WHAT WERE YOU THINKING ZILOG????? WHY DID YOU THINK THAT WAS A GOOD IDEA? AND WHY IS THE ONLY VERSION THAT’S STILL AVAILABLE THE ONE THAT CAN ONLY ACCESS 64K????

Finally we have the Motorola 68000. While Motorola isn’t producing it anymore, the semiconductor company that they spun off during the split, Freescale, does. Or should I say, DID, because NXP ate them. Luckily, NXP does make the chips available. Sadly, they’ve got too many variations. It is seriously confusing. I’d give you an image to demonstrate this, but WordPress is an unstable mess and I fear that trying to add an image will brick the site for another 5 minutes…

Okay… finally got that out of my system. Since there aren’t any easy-to-implement 16-bit processors on the market, I’m just going to start out with an 8-bit processor. The 6502 should do nicely. I do plan on returning to 16-bits once I can get my hands on an easy to implement processor, but for now the 6502 will be good enough.

I’ve also revised what exactly I’m making. I still want to make a retro console, but that doesn’t mean I can’t also make a retro computer. Or multiple of both of those. So, here’s my plan:

  • I’ll make 2 8-bit computers:
    • A Desktop running at 8 MHz, called the Neutron Station (Model N8D)
    • A Handheld running at 2 MHz, called the Neutron Pad (Model N8P)
  • I’ll make 2 8-bit consoles:
    • A stationary console running at 8 MHz, called the Neutron Box (Model N8C)
    • A handheld console running at 2 MHz, called the Neutron Mate (Model N8H)

Yep, 4 models. And 2 of those will need built-in screens. How fun :D. The computers will share one memory map (which will be similar to but not compatible with the Commander X16), while the consoles will use a different memory map (because they have to account for the cartridge). All of them will have the same audio and video chip, which is still called the AVC, or Audio/Video Controller. There will be 64K of Video RAM.

The desktop will have 4 expansion card slots. The handheld computer will have 1 expansion card slot.

As for the consoles, they will need cartridge slots. As for the memory map, it is halved, then halved, then halved again. It starts out with a 16 KiB internal RAM area, followed by 8 KiB MMIO, then a banked 8 KiB area for cartridge RAM (this is the same as High RAM in the computers). This is then followed by the cartridge 16 KiB Low ROM/Flash, which is banked similarly to the cartridge RAM (meaning you can have up to 4 MiB in here!). Finally, at the end of the memory map, is the 16 KiB of cartridge High ROM/Flash.

Okay, I said a lot in this post. And it’s the middle of the night, so I’m tired. I’ll see y’all later, I guess. Have an awesome day!


An Update on the Neutron

So. Remember that old project I made like one or two posts about? The Neutron retro microcomputer? Yeah, it’s not exactly a microcomputer anymore. I have changed my end goal. Now I want to make a 16-bit game console, something similar to a Super Nintendo or a Sega Genesis, but not compatible with either. What does this mean?

  • The Neutron will still be using a W65C816S microprocessor, now with a target clock frequency of 8 MHz instead of the full 14 MHz.
  • There will be one FPGA to handle both audio and video output.
  • There will be one chip, either an FPGA or CPLD, to handle de-multiplexing the processor’s address and data lines (because Western Design Center thought making the data bus act as the most significant byte of the address bus sometimes was a good idea, even though it really isn’t and just complicates things).
  • System RAM and Video RAM will be separated. Amounts are currently unknown.
  • There will be at least one slot for an SD card, so you don’t have to deal with battery-backed Save RAM in the cartridges.
  • There will be 4 controller ports. It is currently unknown what the controller ports will be, or what inputs the controllers will have.
  • There will need to be a cartridge slot mapped to one half of the memory map (8 MB).
  • Half of cartridge space (4 MB) will be banked using the same method (or a similar method) as used in the 8-Bit Guy’s Commander X16 project, for a total of 4 MB * 256 Banks = 1 GB in that one area. The other 4 MB area is static.
  • There will be a parallel expansion port, because who knows what people will want to make.
  • Audio/Video output is indeterminate at this stage. I’m hoping for something capable of both digital and analog output. Perhaps something based on DVI-I Single Link, which would be capable of both VGA and HDMI compatible video out, as well as some pins for analog audio out and (maybe) composite out.

Open Graphics

So today I was thinking about the RISC-V architecture and how it is awesome that an open CPU instruction architecture exists that anyone can implement in FPGA or custom silicon (assuming you can afford to), and then I thought about something – if people have made an open CPU architecture, why not an open GPU architecture to go along with it? Think about it. If you’re making a system-on-a-chip that uses an open processor ISA, wouldn’t it make sense to pair it with an open graphics architecture instead of having to sign some contract to implement someone’s intellectual property just to get graphics?

Luckily, it seems I’m not the first person to think about this – there is something called the Open Graphics Project which aimed to create an open architecture standard for graphics card. Sadly, it seems that project has been defunct for a few years at least, as their website is non-functional as of writing this, and the Wayback Machine’s latest working snapshot appears to be from 2015. Which makes me kind of sad because I think it is a good idea, and I would not be able to do it myself (I think I have made it clear multiple times that when it comes to hardware, I don’t really know what I am doing).

Well, I guess those are my two cents. If anyone has any comments, there’s a comments section. If that’s not enough, there’s a contact form on the about me page. You have an awesome day!


DAM: Decentralized Application Marketplace

Network Architecture DiagramHello! This is an idea I had that I don’t think anyone else has thought of yet, considering I can’t find anything similar through a DuckDuckGo search. Simply put, why not decentralize the app store?

Taking inspiration from how the Matrix protocol works, there are three types of nodes: Clients, who want applications, Merchants, who have applications, and Markets, which facilitate the entire process. In comparison to Matrix, a Merchant is equivalent to a homeserver, and a Market is equivalent to an identity server, but with more responsibilities. I don’t think I need to explain what a client is equivalent to (hint: its the same thing).

How the actual protocol works on a technical level is still up for debate, but only two pieces of software would be absolutely necessary: the Merchant server software and the Market server software. The Market software would handle accounts for Clients, as well as payments. There would probably be options for revenue share – either no share (dev gets all the profit from their app), share what you want (dev chooses how much they want to share with Markets), or fixed share (Market sets their take, limited to 50% and under) – since server hosting is not exactly free. The Merchant software would allow for developers to host applications, as well as multiple versions of the same application (i.e. Linux packages, Mac binaries, Windows binaries, Android APKs / x86 binaries, ARM binaries, RISC-V binaries). For share-what-you-want Markets, the dev chooses how much to share through the Merchant software. There could (and probably will be) client software as well, but it would be possible for the Market to have a web interface (through HTTPS) for Clients to use if they don’t want to use client software.

While this does at least appear to be a complicated system, it has one great benefit: you only need to have one account on one Market and you can access any application on any Merchant, and platform holders don’t need to host all the infrastructure necessary to support a large app store – they just need to host a Market server, add a compatible Client app to their platform, and any developer with compatible binaries on their Merchant server is now on your platform. Easy. Of course, it does mean offloading some of this infrastructure to the developers, but better to spread the burden around and make it easier for everyone than to put everything on one person or group.

That is all I can really say at the moment, as the idea is not fully developed, but I think this could be “very, very, interesting”. But what do you think? There should be comments under this post, but if you wish, I have a contact form on my about page which allows you to email me.

(Oh, and of course the protocol would be open source. Why wouldn’t it be? Just need to decide on a license – MIT, GPL, or something else?)