include diehammer plan docs
This commit is contained in:
Rory Hinnen
@@ -0,0 +1,294 @@
|
||||
//
|
||||
// Dice.swift
|
||||
// Bunch O' Dice
|
||||
//
|
||||
// Created by Rory Hinnen on 22/2/20.
|
||||
//
|
||||
|
||||
import Foundation
|
||||
|
||||
struct Dice {
|
||||
// MARK: Private
|
||||
private var d6: Int {
|
||||
get {
|
||||
return Int.random(in: 1...6)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Enums
|
||||
enum DiceType: Int, CaseIterable{
|
||||
case one = 1
|
||||
case two = 2
|
||||
case three = 3
|
||||
case four = 4
|
||||
case five = 5
|
||||
case six = 6
|
||||
}
|
||||
|
||||
enum RollModifiers: Int {
|
||||
case negative = -1
|
||||
case none = 0
|
||||
case positive = 1
|
||||
|
||||
func add() -> RollModifiers {
|
||||
switch self {
|
||||
case .negative:
|
||||
return RollModifiers.none
|
||||
case .none:
|
||||
return RollModifiers.positive
|
||||
case .positive:
|
||||
return RollModifiers.positive
|
||||
}
|
||||
}
|
||||
|
||||
func remove() -> RollModifiers {
|
||||
switch self {
|
||||
case .negative:
|
||||
return RollModifiers.negative
|
||||
case .none:
|
||||
return RollModifiers.negative
|
||||
case .positive:
|
||||
return RollModifiers.none
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Variables
|
||||
var one = 0
|
||||
var two = 0
|
||||
var three = 0
|
||||
var four = 0
|
||||
var five = 0
|
||||
var six = 0
|
||||
|
||||
// MARK: Roll controllers
|
||||
// clear and roll the die
|
||||
mutating func roll(howMany: Int) {
|
||||
clear()
|
||||
var y = howMany
|
||||
while y > 0 {
|
||||
switch d6 {
|
||||
case 1:
|
||||
one += 1
|
||||
case 2:
|
||||
two += 1
|
||||
case 3:
|
||||
three += 1
|
||||
case 4:
|
||||
four += 1
|
||||
case 5:
|
||||
five += 1
|
||||
default:
|
||||
six += 1
|
||||
}
|
||||
y -= 1
|
||||
}
|
||||
}
|
||||
|
||||
// calculate basic roll
|
||||
func total(cutoff: Int, modifier: Dice.RollModifiers) -> Int {
|
||||
var total = six
|
||||
|
||||
switch modifier {
|
||||
case .none:
|
||||
switch cutoff {
|
||||
case 5:
|
||||
total += five
|
||||
case 4:
|
||||
total += four + five
|
||||
case 3:
|
||||
total += three + four + five
|
||||
case 2:
|
||||
total += two + three + four + five
|
||||
default:
|
||||
break
|
||||
}
|
||||
case .negative:
|
||||
switch cutoff {
|
||||
case 4:
|
||||
total += five
|
||||
case 3:
|
||||
total += four + five
|
||||
case 2:
|
||||
total += three + four + five
|
||||
case 1:
|
||||
total += two + three + four + five
|
||||
default:
|
||||
break
|
||||
}
|
||||
case .positive:
|
||||
switch cutoff {
|
||||
case 6:
|
||||
total += five
|
||||
case 5:
|
||||
total += four + five
|
||||
case 4:
|
||||
total += three + four + five
|
||||
case 3, 2:
|
||||
total += two + three + four + five
|
||||
default:
|
||||
break
|
||||
}
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
// Calculate different rolls
|
||||
func hit(die: Int, cutoff: Int, modifier: Int) -> Int {
|
||||
return total(cutoff: cutoff, modifier: Dice.RollModifiers(rawValue: modifier) ?? .none)
|
||||
}
|
||||
|
||||
func wound(die: Int, mortal: Bool, cutoff: Int, modifier: Int) -> Int {
|
||||
if mortal {
|
||||
return total(cutoff: 2, modifier: Dice.RollModifiers(rawValue: modifier) ?? .none)
|
||||
} else {
|
||||
return total(cutoff: cutoff, modifier: Dice.RollModifiers(rawValue: modifier) ?? .none)
|
||||
}
|
||||
}
|
||||
|
||||
func armour(die: Int, invulnerable: Bool, save: Int, armourPenetration: Int) -> Int {
|
||||
var total = 0
|
||||
switch invulnerable ? save : (save - armourPenetration) {
|
||||
case 7...:
|
||||
total = six + five + four + three + two + one
|
||||
case 6:
|
||||
total = five + four + three + two + one
|
||||
case 5:
|
||||
total = four + three + two + one
|
||||
case 4:
|
||||
total = three + two + one
|
||||
case 3:
|
||||
total = two + one
|
||||
default:
|
||||
total = one
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
// MARK: roll utilities
|
||||
// Utility functions
|
||||
mutating func clear() {
|
||||
one = 0
|
||||
two = 0
|
||||
three = 0
|
||||
four = 0
|
||||
five = 0
|
||||
six = 0
|
||||
}
|
||||
|
||||
mutating func add(pool: Dice) {
|
||||
one += pool.one
|
||||
two += pool.two
|
||||
three += pool.three
|
||||
four += pool.four
|
||||
five += pool.five
|
||||
six += pool.six
|
||||
}
|
||||
|
||||
func value(which: DiceType) -> Int {
|
||||
switch which {
|
||||
case .one:
|
||||
return one
|
||||
case .two:
|
||||
return two
|
||||
case .three:
|
||||
return three
|
||||
case .four:
|
||||
return four
|
||||
case .five:
|
||||
return five
|
||||
case .six:
|
||||
return six
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Extra
|
||||
mutating func increment(die: DiceType) {
|
||||
switch die {
|
||||
case .one:
|
||||
one += 1
|
||||
case .two:
|
||||
two += 1
|
||||
case .three:
|
||||
three += 1
|
||||
case .four:
|
||||
four += 1
|
||||
case .five:
|
||||
five += 1
|
||||
case .six:
|
||||
six += 1
|
||||
}
|
||||
}
|
||||
|
||||
mutating func decrement(die: DiceType) {
|
||||
switch die {
|
||||
case .one:
|
||||
if one > 0 {
|
||||
one -= 1
|
||||
}
|
||||
case .two:
|
||||
if two > 0 {
|
||||
two -= 1
|
||||
}
|
||||
case .three:
|
||||
if three > 0 {
|
||||
three -= 1
|
||||
}
|
||||
case .four:
|
||||
if four > 0 {
|
||||
four -= 1
|
||||
}
|
||||
case .five:
|
||||
if five > 0 {
|
||||
five -= 1
|
||||
}
|
||||
case .six:
|
||||
if six > 0 {
|
||||
six -= 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mutating func reroll(dice: DiceType) {
|
||||
var rerolls = Dice()
|
||||
switch dice {
|
||||
case .one:
|
||||
rerolls.roll(howMany: one)
|
||||
one = 0
|
||||
self.add(pool: rerolls)
|
||||
case .two:
|
||||
rerolls.roll(howMany: two)
|
||||
two = 0
|
||||
self.add(pool: rerolls)
|
||||
case .three:
|
||||
rerolls.roll(howMany: three)
|
||||
three = 0
|
||||
self.add(pool: rerolls)
|
||||
case .four:
|
||||
rerolls.roll(howMany: four)
|
||||
four = 0
|
||||
self.add(pool: rerolls)
|
||||
case .five:
|
||||
rerolls.roll(howMany: five)
|
||||
five = 0
|
||||
self.add(pool: rerolls)
|
||||
case .six:
|
||||
rerolls.roll(howMany: six)
|
||||
six = 0
|
||||
self.add(pool: rerolls)
|
||||
}
|
||||
}
|
||||
|
||||
mutating func blowup(dice: DiceType) {
|
||||
var rolls = Dice()
|
||||
if dice == .six {
|
||||
rolls.roll(howMany: six)
|
||||
self.add(pool: rolls)
|
||||
} else if dice == .five {
|
||||
rolls.roll(howMany: six + five)
|
||||
self.add(pool: rolls)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user