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 {

}

g3

}

var g6 = []

for i in 0..5 {

}

g6

}

var acc = 0

for x in this {

}

for x in this when pred(x) {

yield x

while !good {

var gs = getSix()

print("attribs: \(gs), sum=\(gss), ", terminator: "")

let gl = gss >= 75 ? "good" : "low"

print("(\(gl) sum, high vals=\(hvc))", terminator: "")

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

 

{{out}}

 

=={{header|EasyLang}}==

repeat

.

.

 

<pre>

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

<pre>roll str:13 dex:15 con:14 int:8 wis:17 cha:10 (total:77) ok</pre>

 

 

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

massage=: +/ - <./

generate_attributes=: massage@:roll

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:

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

 

fun main() {

break

}

 

{{output}}

 

=={{header|Ksh}}==

#!/bin/ksh

 

print "Attribute value total: ${total}"

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

{{out}}<pre>

strength: 11

Attribute value total: 81

Attribule count >= 15: 2 </pre>

 

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

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

 

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

{{works with|Bourne Again SHell}}

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

 

var rand = Random.new()

}

}

 

{{out}}

The six values are: [15, 16, 10, 12, 13, 13]

Their total is: 79

</pre>

 

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