RPG attributes generator: Difference between revisions

{{task}}

[[Category:Simple]]

You're running a tabletop RPG, and your players are creating characters.

 

However, this can require a lot of manual dice rolling. A programatic solution would be much faster.

 

 

Write a program that:

# Generates 4 random, whole values between 1 and 6.

* At least 2 of the values must be 15 or more.

<p></p>

 

=={{header|8086 Assembly}}==

 

cpu 8086

putch: equ 2h

section .bss

rnddat: resb 4 ; RNG state

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program rpg64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

Total = 83

Values above 15 = 2

</pre>

 

{{works with|Dyalog APL}}

 

 

{{out}}

 

<pre> roll''

roll''

roll''

roll''

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr

 

 

 

 

=={{header|C}}==

{{trans|Go}}

#include <stdlib.h>

#include <time.h>

}

return 0;

 

{{out}}

=={{header|C sharp|C#}}==

{{trans|Visual Basic .NET}}

using System.Collections.Generic;

using System.Linq;

} while (!good);

}

{{out}}

sample outputs:

=={{header|C++}}==

GCC 4.9.2, unoptimised.

#include <ctime>

#include <iostream>

return 0;

{{out}}

Sample run:

 

=={{header|Caché ObjectScript}}==

set attr = $lb("") ; empty list to start

write "Rules:",!,"1.) Total of 6 attributes must be at least 75.",!,"2.) At least two scores must be 15 or more.",!

} while (result '= 3)

{{out}}<pre>

Total 80 and 2 attributes >=15 are sufficient.

</pre>

 

=={{header|Crystal}}==

dices = Array(Int32).new(4) { rand(1..6) }

dices.sum - dices.min

stats = roll_character

puts "stats: #{stats}, sum is #{stats.sum}"

 

sample output:

stats: [17, 13, 11, 10, 14, 16], sum is 81

stats: [11, 16, 11, 13, 15, 16], sum is 82</pre>

 

=={{header|Dyalect}}==

{{trans|C#}}

var g3 = []

for i in 0..33 {

}

g3

}

func getSix() {

var g6 = []

for i in 0..5 {

}

g6

}

var acc = 0

for x in this {

acc

}

for x in this when pred(x) {

yield x

var good = false

while !good {

var gs = getSix()

 

{{out}}

 

=={{header|EasyLang}}==

repeat

.

.

 

<pre>

</pre>

 

=={{header|Factor}}==

{{Works with|Factor|0.98}}

math.statistics qw sequences ;

IN: rosetta-code.rpg-attributes-generator

: generate-valid-stats ( -- seq )

: stats-info ( seq -- )

[ "%s: %d\n" printf ] 2each nl stats-info ;

{{out}}

<pre>

# of attributes >= 15: 2

</pre>

 

=={{header|Go}}==

 

import (

break

}

 

{{out}}

 

=={{header|Haskell}}==

import System.Random (randomRIO)

import Data.List (sort)

 

discardUntil

(((&&) . (75 <) . sum) <*> ((2 <=) . length . filter (15 <=)))

 

discardUntil :: ([Int] -> Bool) -> IO [Int] -> IO [Int]

 

main :: IO ()

{{Out}}

<pre>Sample computation:

=={{header|J}}==

'twould be more efficient to work with index origin 0, then increment the roll once at output.

massage=: +/ - <./

generate_attributes=: massage@:roll

NB. use: generate_character 'name'

generate_character=: (; (+/ ; ])@:([: generate_attributes@:show Until accept 0:))&>@:boxopen

 

 

 

=={{header|Java}}==

}

public static void main(String[] args) {

}

}

}

{{Out}}

<pre>

</pre>

 

=={{header|Javascript}}==

===Imperative===

const stats = {

total: 0,

${rolledCharacter.rolls.join(', ')}

 

 

{{out}}

===Functional===

{{Trans|Python}} (Functional composition version)

'use strict';

 

// MAIN ---

return main();

{{Out}}

A sample of 10 character attribute sets:

79 -> [15,15,11,17,12,9]

76 -> [14,12,9,15,15,11]</pre>

 

=={{header|Julia}}==

 

function rollRPGtoon()

rollRPGtoon()

rollRPGtoon()

New RPG character roll: [15, 16, 15, 11, 9, 15]. Sum is 81, and 4 are >= 15.

New RPG character roll: [12, 14, 15, 12, 10, 16]. Sum is 79, and 2 are >= 15.

 

=={{header|Kotlin}}==

 

while (true) {

}

val vsum = values.sum()

val vcount = values.count { it >= 15 }

if (vsum < 75 || vcount < 2) continue

break

}

 

{{output}}

Sample run:

<pre>

Their sum is 80 and 2 of them are >= 15

</pre>

 

=={{header|min}}==

{{works with|min|0.19.6}}

 

; Implement some general operators we'll need that aren't in the library.

(big (dup special?) () (pop big) () linrec) :stats ; Roll a set of big and special attributes.

 

{{out}}

<pre>

 

=={{header|MiniScript}}==

results = []

for i in range(0,3)

end while

print "Success!"

{{out}}

<pre>Attribute values: 11, 13, 8, 10, 8, 10

Attributes total: 86

Success!</pre>

 

=={{header|Pascal|FreePascal}}==

 

program attributes;

 

writeln(' ---');

end.

{{out}}

<pre>

 

=={{header|Perl}}==

use List::Util 'sum';

 

 

printf "%s = %2d\n", $attr_names[$_], $attr[$_] for 0..$#attr;

{{out}}

<pre>Str = 13

 

=={{header|Phix}}==

{{out}}

<pre>

Their sum is 86 and 3 of them are >=15

</pre>

 

=={{header|PHP}}==

===Version 1===

 

$attributesTotal = 0;

}

 

 

===Version 2===

​

class CharacterGenerator {

​

print "Attribute Total: $attributesTotal\n";

 

{{out}}

<pre>Attribute Total: 80

Attributes: 10, 12, 16, 17, 14, 11</pre>

 

=={{header|PureBasic}}==

#heroicAttributeCountMinimum = 2

#attributeSumMinimum = 75

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>Attributes generated: [13, 17, 17, 11, 9, 17]

=={{header|Python}}==

===Python: Simple===

random.seed()

attributes_total = 0

attributes_total = sum(attributes)

 

{{out}}

 

===Python: Nested Comprehensions #1===

random.seed()

total = 0

total = sum(attributes)

 

{{out}}

===Python: Nested Comprehensions #2===

With comprehensions for checking candidate values in the while expression.

 

def compute():

for i in range(3):

print(*compute())

 

{{out}}

Composing a hero-generator from reusable functions:

{{Works with|Python|3.7}}

 

from itertools import islice

from operator import eq

 

 

def heroes(p):

'''Non-finite list of heroes matching

while True:

 

 

def character(_):

'''A random character with six

return [

sum(sorted(map(

 

 

# main :: IO ()

def main():

def seventyFivePlusIncTwo15s(xs):

'''Sums to 75 or more,

return 75 <= sum(xs) and (

1 < len(list(filter(curry(eq)(15), xs)))

 

 

 

# curry :: ((a, b) -> c) -> a -> b -> c

def curry(f):

'''A curried function derived

 

 

def enumFromTo(m):

 

 

# randomRInt :: Int -> Int -> IO () -> Int

def randomRInt(m):

 

 

def take(n):

'''The prefix of xs of length n,

return lambda xs: (

xs[0:n]

else list(islice(xs, n))

)

# unlines :: [String] -> String

def unlines(xs):

return '\n'.join(xs)

 

def until(p):

'''The result of repeatedly applying f until p holds.

def go(f, x):

v = x

 

if __name__ == '__main__':

<pre>A sample of 10:

 

79 -> (17, 15, 10, 11, 15, 11)

75 -> (15, 13, 7, 11, 14, 15)</pre>

 

=={{header|Racket}}==

 

(define (d6 . _)

(module+ main

(define-values (rolled-stats total) (generate-character))

 

{{out}}

<pre>Rolls: (11 16 10 13 12 15)

Total: 77</pre>

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo Star|2018.04.1}}

my @attr-names = <Str Int Wis Dex Con Cha>;

 

 

say @attr-names Z=> @attr;

{{out}}

<pre>

(Str => 15 Int => 16 Wis => 13 Dex => 11 Con => 15 Cha => 6)

Sum: 76, with 3 attributes >= 15

</pre>

 

=={{header|REXX}}==

===version 1===

Generates 4 random, whole values between 1 and 6.

Saves the sum of the 3 largest values.

swl=swl wa.i

End

{{out}}

<pre>I:\>rexx cast

===version 2===

This REXX version doesn't need a sort to compute the sum of the largest three (of four) values.

do until m>=2 & $$>=75; $$= 0; list= /*do rolls until requirements are met. */

m= 0 /*the number of values ≥ 15 (so far).*/

end /*do 6*/ /* [↑] gen six core attribute values. */

end /*until*/ /*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default (internal) inputs:}}

<pre>

===version 3===

A variation of version 2

Do n=1 By 1 until m>=2 & tot>=75;

slist=''

Say 'the total for' space(slist) 'is -->' tot', 'm' entries are >= 15.'

end

{{out}}

<pre>I:\>rexx rpg

 

=={{header|Ring}}==

# Project : RPG Attributes Generator

 

line = line + "])"

see line + nl

Output:

<pre>

 

=={{header|Ruby}}==

until res.sum >= 75 && res.count{|n| n >= 15} >= 2 do

res = Array.new(6) do

p res

puts "sum: #{res.sum}"

{{out}}

<pre>[12, 14, 17, 12, 16, 9]

sum: 80

</pre>

 

=={{header|Rust}}==

{{libheader|rand}}

{{works with|Rust|2018}}

use rand::distributions::Uniform;

use rand::prelude::{thread_rng, ThreadRng};

}

}

{{out}}

Sample output, running the generator ten times:

 

=={{header|Scala}}==

import scala.util.Random

Random.setSeed(1)

 

println("picked => " + getCharacter.mkString("[", ",", "]"))

 

<pre>

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(" ----");

writeln("Total " <& total lpad 3);

 

{{out}}

Total 76

</pre>

 

=={{header|Visual Basic .NET}}==

repeats until a successful outcome occurs

 

Dim r As New Random

Loop Until good

End Sub

{{out}}

sample outputs:

attribs: 17, 16, 14, 8, 8, 9, sum=72, (low sum, high vals=2) - failure

attribs: 18, 16, 13, 9, 9, 10, sum=75, (good sum, high vals=2) - success</pre>

 

=={{header|zkl}}==

do{

attrs.clear();

}while((S=attrs.sum(0))<75 or (N=attrs.filter('>=(15)).len())<2);

println("Random numbers: %s\nSums to %d, with %d >= 15"

{{out}}

<pre>