Spinning rod animation/Text: Difference between revisions

{{trans|Python}}

 

L(rod) ‘\|/-’

print(rod, end' "\r")

 

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

BYTE RTCLOK=$14

frames==+RTCLOK

CH=$FF

CRSINH=0 ;show cursor

{{out}}

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

=={{header|Ada}}==

{{trans|Go}}

 

procedure Spinning_Rod is

end loop;

Put (ASCII.ESC & "[?25h"); -- Restore the cursor

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Sadly, Algol 68 doesn't have a standard delay/sleep routine, so this sample delays with a busy loop. A loop of 2 000 000 gives a reasonable spinning rod on the machine I tried it on. Increase the outer loop maximum for a longer animation.

FOR d TO 2 000 000 DO SKIP OD; # adjust to change the spin rate #

print( ( CASE 1 + i MOD 4 IN "/", "-", "\", "|" ESAC, REPR 8 ) )

 

=={{header|AWK}}==

# syntax: GAWK -f SPINNING_ROD_ANIMATION_TEXT.AWK

@load "time"

exit(0)

}

 

=={{header|BaCon}}==

PRINT CR$, TOKEN$("🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘", x);

x = IIF(x>7, 1, x+1)

SLEEP 250

 

=={{header|Bash}}==

for rod in \| / - \\ ; do printf ' %s\r' $rod; sleep 0.25; done

(Added an indent in the printf to better see the spinning rod).

 

=={{header|C}}==

{{trans|Go}}

#include <time.h>

 

printf("\033[?25h"); // restore the cursor

return 0;

 

=={{header|C Shell}}==

foreach rod ('|' '/' '-' '\')

printf ' %s\r' $rod; sleep 0.25

end

(Added an indent in the printf to better see the spinning rod).

 

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

; spin 10 times with quarter-second wait

for i = 1:1:10 {

}

}

 

=={{header|Emacs Lisp}}==

(dolist (char (string-to-list "\\|/-"))

(message "%c" char)

 

=={{header|Factor}}==

threads ;

 

[

"\\|/-" [ "%c\r" printf flush 1/4 seconds sleep ] each

 

=={{header|Forth}}==

Tested in gforth 0.7.9

: rod

cr

;

rod

This one is designed to be embedded in a program when the user has to wait for some (silent) task to finish. It is designed as a coroutine, so the state of the spinner is preserved.

{{works with|4tH v3.64.0}}

include lib/yield.4th

 

 

test

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Wend

 

 

=={{header|GlovePIE}}==

Because GlovePIE is a looping programming language, which means the script is ran over and over again in a looping fashion, this code loops again and again until it's stopped.

wait 250 ms

debug="/"

wait 250 ms

debug="\"

 

=={{header|Go}}==

{{works with|Ubuntu 16.04}}

 

import (

}

fmt.Print("\033[?25h") // restore the cursor

 

=={{header|Haskell}}==

Uses the terminfo library to make the cursor invisible, if possible.

import Control.Exception (bracket_)

import Control.Monad (forM_)

putStrLn "Spinning rod demo. Hit ^C to stop it.\n"

term <- setupTermFromEnv

 

=={{header|Java}}==

{{trans|Go}}

{

public static void main(String[] args) throws InterruptedException {

System.out.print("\033[?25h"); // restore the cursor

}

 

=={{header|Javascript}}==

Node JS:

const rod = (function rod() {

const chars = "|/-\\";

})();

setInterval(rod, 250);

 

=={{header|Julia}}==

{{trans|Python}}

for rod in "\|/-" # this needs to be a string, a char literal cannot be iterated over

print(rod,'\r')

end

end

 

=={{header|Kotlin}}==

{{trans|Go}}

 

const val ESC = "\u001b"

}

print("$ESC[?25h") // restore the cursor

 

 

 

=={{header|Lua}}==

--

-- Simple String Animation - semi-hard-coded variant - you can alter the chars table - update the count and run it...

_data.anim, _data.count, _data.index, _data.expiry = _tab, nil, nil, nil;

end

 

Usage:

-- 1 second delay, going backwards.

print( string.BasicAnimation( 1, true ) );

-- 1 second delay going backwards

print( string.BasicAnimation( 1 ) );

 

 

===Extended Modular Variant===

--

-- Simple String Animation - Josh 'Acecool' Moser under modified ACL - Free to use, modify and learn from.

return _char, _has_frame_advanced;

end

 

<br />

<br />

 

--

-- In some HUD element, or where text is output... such as 'Loading' ... try:

-- In this example print would be draw.Text or something along those lines.

print( 'Loading' .. string.SimpleAnimation( STRING_ANIMATION_DOTS ) );

 

<br />

<br />

 

--

-- Example - This is one way it could be used without rendering it every frame... Pseudo code and a task which is a good idea to do - when the map is added, add a function to register the animation and also go through each animation index and see which element is

end

end

 

=={{header|M2000 Interpreter}}==

Module Checkit {

n$=lambda$ n=1, a$="|/-\" -> {

CheckIt

 

 

Module Checkit {

n=1

CheckIt

 

 

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

pos = 1;

Dynamic[c]

c = StringTake[chars, {pos}];

Pause[0.25];

 

=={{header|MelonBasic}}==

Delete:1

Say:/

Wait:0.25

Delete:1

 

=={{header|Microsoft Small Basic}}==

a[2]="/"

a[3]="-"

Program.Delay(250)

EndFor

 

=={{header|MiniScript}}==

Control over the text cursor -- or indeed, whether there ''is'' a text cursor, or even text at all -- depends on the host environment. Here's a version that works with [https://miniscript.org/MiniMicro/ MiniMicro]:

while true

for c in "|/-\"

wait 0.25

end for

 

And here's a version that will work with command-line MiniScript, running on a terminal that interprets standard VT100 escape sequences:

for c in "|/-\"

print c

print char(27) + "[2A" // move cursor up 2 lines

end for

 

=={{header|Nim}}==

{{trans|Kotlin}}

With some modifications.

 

const A = ["|", "/", "—", "\\"]

if (now - start).inSeconds >= 5:

break

 

=={{header|NS-HUBASIC}}==

The 0.25 second delay assumes the program is running at 60 frames per second.

20 A(1)=236

30 A(2)=234

90 PAUSE 15

100 NEXT

 

=={{header|Perl}}==

The statement <code>$| =1</code> is required in order to disable output buffering.

 

while () {

printf "\r ($_)";

}

 

Extending it for moon phases:

 

binmode STDOUT, ":utf8";

 

# (3) `@{}` dereferences the created list.

}

 

=={{header|Phix}}==

=== console version ===

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (cursor, sleep)</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"please_wait... "</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" \ndone"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- clear rod, "done" on next line</span>

=== GUI version ===

{{libheader|Phix/pGUI}}

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/Spinning_rod.htm here] (don't expect too much, improvements welcome).

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Spinning_rod_animation.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

 

=={{header|PicoLisp}}==

(de rod ()

(until ()

(prin R (wait 250) "\r")(flush) ) ) )

(rod)

 

=={{header|Python}}==

while True:

for rod in r'\|/-':

print(rod, end='\r')

 

=={{header|Racket}}==

#lang racket

(define (anim)

(anim))

(anim)

 

=={{header|Raku}}==

This implementation will accept an array of elements to use as its throbber frames, or as a scrolling marquee and optionally a delay before it returns the next element.

 

has @.frames;

has $.delay is rw = 0;

print $scroll.next for ^95;

 

 

=={{header|REXX}}==

::* &nbsp; ROO REXX

::* &nbsp; Regina REXX &nbsp; (see the programming note below.)

 

if 4=='f4'x then bs= "16"x /*EBCDIC? Then use this backspace chr.*/

end /*j*/

 

Programming note: &nbsp; this REXX program makes use of &nbsp; '''DELAY''' &nbsp; BIF which delays (sleeps) for a specified amount of seconds.

<br>Some REXXes don't have a &nbsp; '''DELAY''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[DELAY.REX]].

 

=={{header|Ring}}==

rod = ["|", "/", "-", "\"]

for n = 1 to len(rod)

sleep(0.25)

system("cls")

Output:

|

 

=={{header|Ruby}}==

begin

printf("\033[?25l") # Hide cursor

puts "Ctrl-c to stop."

spinning_rod

 

=={{header|Rust}}==

 

let characters = ['|', '/', '-', '\\'];

let mut current = 0;

std::thread::sleep(std::time::Duration::from_millis(250)); // Sleep 250 ms.

}

 

=={{header|Scala}}==

val start = System.currentTimeMillis

 

print("\033[?25h") // restore the cursor

 

 

=={{header|ScratchScript}}==

delay 0.25

clear

clear

print "\"

 

=={{header|SimpleCode}}==

|

wait

\

wait

 

=={{header|Wee Basic}}==

Since the "|" character isn't built into Wee Basic on the Nintendo DS, and it looks the part in Wee Basic on the Nintendo DS, the character "l" is used as a substitute. Also, since no working delay command has been found yet, a for loop is used to work around this problem.

sub delay:

for i=1 to 10000

gosub delay:

wend

 

=={{header|Wren}}==

{{trans|Kotlin}}

import "timer" for Timer

 

if (now * 1000 + asleep - start * 1000 >= 20000) break

}

 

=={{header|XPL0}}==

[Rod:= "|/-\ ";

loop for I:= 0 to 3 do

if KeyHit then quit;

];

 

=={{header|zkl}}==

{{trans|C Shell}}

print(" %s\r".fmt(rod));

 

Atomic.sleep(0.25);

A loop foreach a,b in (c,d) translates to

foreach a in (c) foreach b in (d). n.MAX is a 64 bit int (9223372036854775807).

A more useful example would be a worker thread showing a "I'm working" display

(in another thread) and turning it off when that work is done.

try{

foreach n,rod in ((1).MAX, "\\|/-"){

}

}catch{} // don't complain about uncaught exception that stops thread

spinner:=spin.launch(); // start spinner thread, returns reference to thread

Atomic.sleep(10); // do stuff

 

=={{header|ZX Spectrum Basic}}==

20 FOR C=1 TO 4

30 PRINT AT 0,0;A$(C)

50 NEXT C

60 GOTO 20