RPG attributes generator: Difference between revisions

{{trans|Python}}

V total = 0

V count = 0

total = sum(attributes)

{{out}}

=={{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>

=={{header|Action!}}==

BYTE FUNC GenerateAttrib()

BYTE i,v,min,sum

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/RPG_attributes_generator.png Screenshot from Atari 8-bit computer]

=={{header|ALGOL 68}}==

{{Trans|Action!}}

INT attrib count = 6;

OD

{{out}}

<pre>

{{works with|Dyalog APL}}

{{out}}

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

bx lr

=={{header|Arturo}}==

while [or? 75 > sum vals

print ["values:" vals ]

=={{header|Atari BASIC}}==

{{trans|Commodore BASIC}}

110 DIM AT(5)

120 DIM AT$(18)

450 IF K=78 THEN 140

460 POSITION 0,13

{{Out}}

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

if a < b then return a else return b

end function

print "-------"

print "TOT: "; sum

{{out}}

<pre>Igual que la entrada de FreeBASIC.</pre>

=={{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>

=={{header|CLU}}==

% to use the random number generator.

%

stream$putright(po, int$unparse(stat), 4)

end

{{out}}

<pre>$ ./rpg_gen

Except for screen control codes, this is generic enough it could be used for many other 8-bit interpreted BASICs as well. (Applesoft, ZX Spectrum, etc.). Should work on all Commodore models. (Adjustment for screen width may be necessary on VIC-20.)

110 rem rosetta code - commodore basic

120 dim di(3):rem dice

470 if di(x)<di(x+1) then t=di(x):di(x)=di(x+1):di(x+1)=t

480 next x

{{out}}

=={{header|Common Lisp}}==

(defpackage :rpg-generator

(:use :cl)

(format t ">= 15: ~A~%" (count-if (lambda (n) (>= n 15)) scores))

(return scores)))

=={{header|Cowgol}}==

include "argv.coh";

print("\nTotal: ");

print_i8(total);

{{out}}

=={{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:

{{libheader| System.Generics.Collections}}

{{Trans|C#}}

program RPG_Attributes_Generator;

end.

{{out}}

=={{header|Dyalect}}==

{{trans|C#}}

var g3 = []

for i in 0..33 {

good = gs.Sum() >= 75 && hvc > 1

print(" - " + (good ? "success" : "failure"))

{{out}}

=={{header|EasyLang}}==

repeat

vsum = 0

.

print "Attributes: " & " " & v[]

<pre>

=={{header|Factor}}==

{{Works with|Factor|0.98}}

math.statistics qw sequences ;

IN: rosetta-code.rpg-attributes-generator

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

{{out}}

<pre>

=={{header|FreeBASIC}}==

function d6() as integer

next i

print "--------"

{{out}}<pre>STR: 14

CON: 11

=={{header|FOCAL}}==

01.20 F X=1,6;D 4;S AT(X)=S3;S T=T+S3

01.30 I (T-75)1.1

06.01 C--ROLL A D6

06.10 S A=FRAN()*10;S A=A-FITR(A)

{{out}}

{{works with|GNU Forth}}

{{libheader|random.fs}}

: d6 ( -- roll ) 6 random 1 + ;

;

{{Out}}

=={{header|Go}}==

import (

break

}

{{out}}

=={{header|Haskell}}==

import System.Random (randomRIO)

import Data.Bool (bool)

-------------------------- TEST ---------------------------

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.

roll=: 1 + 4 6 ?@:$ 6:

massage=: +/ - <./

NB. use: generate_character 'name'

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

=={{header|Java}}==

import java.util.Random;

import java.util.stream.Stream;

}

}

{{Out}}

<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:

=={{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}}==

fun main() {

break

}

{{output}}

=={{header|Ksh}}==

#!/bin/ksh

print "Attribute value total: ${total}"

print "Attribule count >= 15: ${cnt15}"

{{out}}<pre>

strength: 11

=={{header|Mathematica}} / {{header|Wolfram Language}}==

While[! valid,

try = Map[Total[TakeLargest[#, 3]] &,

]

]

{{out}}

<pre>{78, {13, 15, 9, 13, 12, 16}}</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

=={{header|Nim}}==

# Import "random" to get random numbers and "algorithm" to get sorting functions for arrays.

import random, algorithm

if not twoFifteens(sixAttr) or sumAttr < 75: echo "Not good enough. Rerolling..."

else: break

Sample output: <pre>

=={{header|OCaml}}==

Original version by [http://rosettacode.org/wiki/User:Vanyamil User:Vanyamil]

(* Task : RPG_attributes_generator *)

let s = valid_set () in

List.iter (fun i -> print_int i; print_string ", ") s

{{out}}

<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}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">numbers</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">numbers</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nTheir sum is %d and %d of them are &gt;=15\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|PHP}}==

===Version 1===

$attributesTotal = 0;

}

===Version 2===

​

class CharacterGenerator {

​

print "Attribute Total: $attributesTotal\n";

{{out}}

=={{header|Plain English}}==

Allocate memory for an entry.

Put the attribute into the entry's attribute.

If the entry's next is not nil, write ", " on the console without advancing.

Put the entry's next into the entry.

{{out}}

<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

if __name__ == '__main__':

<pre>A sample of 10:

===Python: One-liner===

Just because you can, doesn't mean you should.

import random; print((lambda attr: f"Attributes: {attr}\nTotal: {sum(attr)}")((lambda func, roll_func: func(func, roll_func, roll_func()))((lambda func, roll_func, rolls: rolls if sum(rolls) >= 75 and rolls.count(15) >= 2 else func(func, roll_func, roll_func())), lambda: [sum(sorted(random.randint(1, 6) for _ in range(4))[1:]) for _ in range(6)])))

<pre>

Attributes: [16, 15, 15, 14, 8, 10]

=={{header|Quackery}}==

[ 0 ]'[ rot witheach

say 'Sum: ' dup sum echo cr

say '# of attributes > 14: '

{{out}}

<pre>

=={{header|Racket}}==

(define (d6 . _)

(module+ main

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

{{out}}

=={{header|R}}==

The base library already has an attributes function, so we avoid using that name. Otherwise, this is R's bread and butter.

{

stats <- c(STR = 0, DEX = 0, CON = 0, INT = 0, WIS = 0, CHA = 0)

if(sum(stats >= 15) < 2 || (stats["TOT"] <- sum(stats)) < 75) Recall() else stats

}

{{out}}

(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>

=={{header|Red}}==

raw-attribute: does [

]

{{out}}

<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]

=={{header|Run BASIC}}==

data "STR", "CON", "DEX", "INT", "WIS", "CHA"

for i = 1 to 6

a = d6() : b = d6() : c = d6() : d = d6()

rollstat = a + b + c + d - min(min(a, b), min(c, d))

=={{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}}

{{trans|FreeBASIC}}

{{works with|QBasic}}

IF a < b THEN LET min = a ELSE LET min = b

END FUNCTION

PRINT "--------"

PRINT "TOT: "; sum

{{out}}

<pre>Igual que la entrada de FreeBASIC.</pre>

=={{header|uBasic/4tH}}==

{{trans|Yabasic}}

@n(0) := "STR"

@n(1) := "CON"

local (4)

a@ = FUNC(_d6) : b@ = FUNC(_d6) : c@ = FUNC(_d6) : d@ = FUNC(_d6)

{{Out}}

<pre>STR: 17

{{works with|Zsh}}

typeset attrs=(str dex con int wis cha)

typeset -A values

main "$@"

{{Out}}

<pre>str: 12

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

repeats until a successful outcome occurs

Dim r As New Random

Loop Until good

End Sub

{{out}}

sample outputs:

=={{header|Wren}}==

{{libheader|Wren-sort}}

import "/sort" for Sort

}

}

{{out}}

=={{header|XPL0}}==

int I, R, Min, SI, Sum, Die(4);

[Min:= 7; Sum:= 0;

[IntOut(0, Value(J)); ChOut(0, ^ )];

CrLf(0);

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

//simulates a marked regular hexahedron coming to rest on a plane

return 1 + int(ran(6))

next i

print "-------\nTOT: ", sum

{{out}}

<pre>Igual que la entrada de FreeBASIC.</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>