Star Trap Lvl 1 monster manual

The first half of the first level of Star Trap Dungeon has a whole bunch of OSR style monsters, all now written up with AD&D / Labyrinth Lord style, with brief descriptions and is over five thousand words. I used the 4e format for splitting monster of the same race up into their own entries rather than having notes in the text detailing leaders and special types. It's been a lot of fun, and I'm looking forward to working on the second half of the list, although it probably won't be as extensive as some of the creatures, such as the Pig-Faced Orcs live in the further reaches of the dungeon's upmost level.

1. Angry Owlbear
2. Banshaer Hermit
3. Barghest, Juvenile
4. Beetle, Fire
5. Beetle, Boring
6. Brain In A Jar
7. Centipede, Giant  
8. Crawling Claw/Severed Hand
9. Dimension Shambler
10. Farspawn Returned
11. Farspawn Mind Worm
12. Farspawn Teeth Eel 
13. Fungal Guard
14. Fungal Herder
15. Fungal Priest Of Decay
16. Fungus King
17. Gelatinous Cube
18. Ghoul
19. Goblin Archer
20. Goblin Acolyte
21. Goblin Bully
22. Goblin Hexamancer
23. Goblin King
24. Goblin Runts
25. Goblin Skull Cleavers
26. Goblin Stabbers
27. Goblin Strategist
28. Goblin Warrior
29. Green Slime
30. Grey Ooze
31. Horrible Black Tentacles
32. Iron Hound
33. Killer Bees
34. Lesser Demon, Demonic Two-Headed Warthog
35. Lesser Demon, Grarthrax The Meddler
36. Maggot Wraith
37. Ochre Jelly 
38. Pig-faced Orc Killer 
39. Pig-faced Orc Bannerman
40. Pig-faced Orc Sticker
41. Pig-faced Orc Shieldboy
42. Pig-faced Orc Demon Warriors
43. Pig-faced Orc Murderers
44. Pig-faced Orc Heart Eaters 
45. Pig-faced Orc Champion
46. Pig-faced Orc Warlord
47. Pig-faced Orc Teeth Caster 
48. Rat, Giant
49. Rat, Swarm
50. Rot spider
51. Shrieker
52. Skeleton
53. Skeleton Archer
54. Skeleton Legionnaire
55. Skeleton, Ramshackle 
56. Skeleton, Skullspider
57. Snake, Pit Viper
58. Vile Creeper, Barbed
59. Vile Creeper, Suckered
60. Wolf
61. Wraith
62. Zombie
63. Zombie Rotter
64. Zombie, Famine

Death to the P1, only order matters!

I often hear developers and product owners talk about all the P1 issues on the board or in the backlog. They need to stop it. It is only the order of the backlog that matters. Having stories that appear to equal importance confuses the developers and encourages management to think teams can work on many parallel work streams. Worse, cynical programmers will laughingly say ‘everything is a P1, except for the other stuff which we’ll never do anyway’ and they are often right. If work isn’t worth doing soon, it shouldn’t be at eye level for the teams, so calling a bunch of stories low priority will sound their death knell.

Product owners can steer themselves, and stakeholders towards lean and agile productivity by avoiding talking about buckets of priorities. It’s hard of course, especially with product work that spans multiple teams, instead talk about how stories, features or epics relate to each other. ‘Is getting the biplane flying more or less important right now than the catch the pigeon feature?’

Z80 8-bit microprocessor & Arduino Mega

My first computer was a ZX81, and as child I always wanted to make my own computer. However I always found writing software easier, and moved away from electronics to software. The Arduino rekindled some of that delight in physically making things,
so I started to wonder if an Arduino could help me understand how old 8-bit processors work, and kickstart the process of building one.

I bought two Z80s from RS Components, and after realising I was going to need a lot more digital pins than the Uno provides, an Arduino Mega. The video below shows my set-up running in test mode, which I reset at the beginning. The LEDs in the bottom right are power (green), clock (yellow) and reset (red). The reset blinks 3 times, to clear the Z80 program counter and probably it's registers. I read somewhere that 3 times was better than just once, but I'll play around with that to see if it's true.
The strip of LEDs at the top left are the low bytes of the address bus. The yellow is the 1's and the red the 128. Oddly once I hit 128 in the PC unexpected things start to happen. The LEDs at the top right are memory request (blue), read data (red) and write data (yellow).

When the processor is reset, it's also fed 0's on all of its data lines. This means that when the program counter requests each instruction, it gets a NOP  (no operation). This causes the program counter to increase by one, hence the address bus counts up in binary. Right now all the Arduino Mega is doing is monitoring the address lines and outputting the result to the serial monitor. This works, and proves at least that the Arduino is capable of limited support of the Z80, as well as making me more happy that I probably should be. One thing to love about the Z80 is that the clock signal can be manual, you can literally step through the instruction processing.

I've uploaded the very basic code to GitHub here.

The next step is to make the software recognise the memory request & read data signals to provide instructions, effectively working as a ROM. The after support RAM and IO. I plan to use a small Arduino controlled OLED display to act as an output for now. No idea about input though!