Spinning rod animation/Text: Difference between revisions

Content added Content deleted

Inline

Revision as of 04:37, 1 March 2019

Task

An animation with the following frames in the following order must animate with a delay of 0.25 seconds between each frame, with the previous frame being cleared before the next frame appears:

|
/
-
\

A version that loops and/or a version that doesn't loop can be made.

Bash

<lang bash>while : ; do

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

done</lang> (Added an indent in the printf to better see the spinning rod).

C Shell

<lang csh>while 1

 foreach rod ('|' '/' '-' '\')
   printf '  %s\r' $rod; sleep 0.25
 end

end</lang> (Added an indent in the printf to better see the spinning rod).

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. <lang glovepie>debug="|" wait 250 ms debug="/" wait 250 ms debug="-" wait 250 ms debug="\" wait 250 ms</lang>

Go

Works with: Ubuntu 16.04

<lang go>package main

import (

   "fmt"
   "time"

)

func main() {

   a := `|/-\`
   fmt.Printf("\033[?25l")  // hide the cursor
   start := time.Now()
   for {
       for i := 0; i < 4; i++ {
           fmt.Print("\033[2J")       // clear terminal
           fmt.Printf("\033[0;0H")    // place cursor at top left corner
           for j := 0; j < 80; j++ {  // 80 character terminal width, say
               fmt.Printf("%c", a[i])
           }
           time.Sleep(250 * time.Millisecond)
       }
       if time.Since(start).Seconds() >= 20.0 { // stop after 20 seconds, say
           break
       }
   }
   fmt.Print("\033[?25h") // restore the cursor

}</lang>

Haskell

Uses the terminfo library to make the cursor invisible, if possible. <lang haskell>import Control.Concurrent (threadDelay) import Control.Exception (bracket_) import Control.Monad (forM_) import System.Console.Terminfo import System.IO (hFlush, stdout)

-- Use the terminfo database to write the terminal-specific characters -- for the given capability. runCapability :: Terminal -> String -> IO () runCapability term cap =

 forM_ (getCapability term (tiGetOutput1 cap)) (runTermOutput term)

-- Control the visibility of the cursor. cursorOff, cursorOn :: Terminal -> IO () cursorOff term = runCapability term "civis" cursorOn term = runCapability term "cnorm"

-- Print the spinning cursor. spin :: IO () spin = forM_ (cycle "|/-\\") $ \c ->

 putChar c >> putChar '\r' >>
 hFlush stdout >> threadDelay 250000

main :: IO () main = do

 putStrLn "Spinning rod demo.  Hit ^C to stop it.\n"
 term <- setupTermFromEnv
 bracket_ (cursorOff term) (cursorOn term) spin</lang>

Java

Translation of: Go

<lang java>public class SpinningRod {

   public static void main(String[] args) throws InterruptedException {
       String a = "|/-\\";
       System.out.print("\033[2J");   // hide the cursor
       long start = System.currentTimeMillis();
       while (true) {
           for (int i = 0; i < 4; i++) {
               System.out.print("\033[2J");     // clear terminal
               System.out.print("\033[0;0H");   // place cursor at top left corner
               for (int j = 0; j < 80; j++) {   // 80 character terminal width, say
                   System.out.print(a.charAt(i));
               }
               Thread.sleep(250);
           }
           long now = System.currentTimeMillis();
           // stop after 20 seconds, say
           if (now - start >= 20000) break;
       }
       System.out.print("\033[?25h"); // restore the cursor
   }

}</lang>

Julia

Translation of: Python

<lang julia>while true

 for rod in "\|/-" # this needs to be a string, a char literal cannot be iterated over
   print(rod,'\r')
   sleep(0.25)
 end

end </lang>

Kotlin

Translation of: Go

<lang scala>// Version 1.2.50

const val ESC = "\u001b"

fun main(args: Array<String>) {

   val a = "|/-\\"
   print("$ESC[?25l") // hide the cursor
   val start = System.currentTimeMillis()
   while (true) {
       for (i in 0..3) {
           print("$ESC[2J")       // clear terminal
           print("$ESC[0;0H")     // place cursor at top left corner
           for (j in 0..79) {     // 80 character terminal width, say
               print(a[i])
           }
           Thread.sleep(250)
       }
       val now = System.currentTimeMillis()
       // stop after 20 seconds, say
       if (now - start >= 20000) break
   }
   print("$ESC[?25h") // restore the cursor

}</lang>

M2000 Interpreter

<lang M2000 Interpreter> Module Checkit {

     n$=lambda$ n=1, a$="|/-\" -> {
           =mid$(a$, n, 1)
           n++
           if n>4 then n=1
     }
     \\ 1000 is 1 second
     Every 250 {
     \\ Print Over: erase line before print. No new line append.
     Print Over  n$()
     }

} CheckIt

</lang>

<lang M2000 Interpreter> Module Checkit {

     n=1
     a$="|/-\"
     Every 250 {
           Print Over mid$(a$, n, 1)
           n++
           if n>4 then n=1      
     }

} CheckIt

</lang>

Microsoft Small Basic

<lang microsoftsmallbasic>a[1]="|" a[2]="/" a[3]="-" a[4]="\" b=0 While b=0

 For c=1 To 4
   TextWindow.Clear()
   TextWindow.WriteLine(a[c])
   Program.Delay(250)
 EndFor

EndWhile</lang>

Perl

The statement $| =1 is required in order to disable output buffering. <lang perl>$|= 1;

while () {

   for (qw[ | / - \ ]) {
       select undef, undef, undef, 0.25;
       printf "\r ($_)";
   }

}</lang>

Perl 6

Works with: Rakudo version 2018.05

Traditionally these are know as throbbers or progress indicators.

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.

<lang perl6>class throbber {

   has @.frames;
   has $.delay is rw = 0;
   has $!index = 0;
   has Bool $.marquee = False;
   method next {
       $!index = ($!index + 1) % +@.frames;
       sleep $.delay if $.delay;
       if $!marquee {
           ("\b" x @.frames) ~ @.frames.rotate($!index).join;
       }
       else {
           "\b" ~ @.frames[$!index];
       }
   }

}

my $rod = throbber.new( :frames(< | / - \ >), :delay(.25) ); print "\e[?25lLong running process... "; print $rod.next for ^20;

my $clock = throbber.new( :frames("🕐" .. "🕛") ); print "\b \nSomething else with a delay... "; until my $done {

   # do something in a loop;
   sleep 1/12;
   print $clock.next;
   $done = True if $++ >= 60;

}

my $scroll = throbber.new( :frames('PLEASE STAND BY... '.comb), :delay(.1), :marquee ); print "\b \nEXPERIENCING TECHNICAL DIFFICULTIES: { $scroll.frames.join }"; print $scroll.next for ^95;

END { print "\e[?25h\n" } # clean up on exit</lang>

Phix

<lang Phix>puts(1,"please_wait... ") cursor(NO_CURSOR) for i=1 to 10 do -- (approx 10 seconds)

   for j=1 to 4 do
       printf(1," \b%c\b",`|/-\`[j])
       sleep(0.25)
   end for

end for puts(1," \ndone") -- clear rod, "done" on next line </lang>

Python

<lang python>from time import sleep while True:

   for rod in r'\|/-':
       print(rod, end='\r')
       sleep(0.25)</lang>

REXX

This REXX program would work for all REXXes if there was a common way to sleep (suspend) execution for fractional seconds.

This REXX version will work for:

Personnal REXX
PC REXX

<lang rexx>/*REXX program displays a "spinning rod" (AKA: trobbers or progress indicators). */ if 4=='f4'x then bs= "16"x /*EBCDIC? Then use this backspace chr.*/

            else bs= "08"x                      /* ASCII?    "   "    "      "      "  */

signal on halt /*jump to HALT when user halts pgm.*/ $= '│/─\' /*the throbbing characters for display.*/

                 do j=1                         /*perform  until  halted by the user.  */
                 call charout ,  bs  ||  substr($, 1 + j//length($), 1)
                 call delay .25                 /*delays a quarter of a second.        */
                 end   /*j*/

halt: say bs ' ' /*stick a fork in it, we're all done. */</lang>

Ring

<lang ring>load "stdlib.ring" rod = ["|", "/", "-", "\"] for n = 1 to len(rod)

    see rod[n] + nl
    sleep(0.25)
    system("cls")

next</lang> Output:

|
/
-
\

Scala

<lang Scala>object SpinningRod extends App {

 val start = System.currentTimeMillis

 def a = "|/-\\"

 print("\033[2J") // hide the cursor

 while (System.currentTimeMillis - start < 20000) {
   for (i <- 0 until 4) {
     print("\033[2J\033[0;0H") // clear terminal, place cursor at top left corner
     for (j <- 0 until 80) print(a(i)) // 80 character terminal width, say
     Thread.sleep(250)
   }
 }
 print("\033[?25h") // restore the cursor

}</lang>

zkl

Translation of: C Shell

<lang zkl>foreach n,rod in ((1).MAX, T("|", "/", "-", "\\")){

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

}</lang> 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. <lang zkl>fcn spin{ // this will be a thread that displays spinner

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

Atomic.sleep(0.25);

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

}</lang> <lang zkl>// main body of code spinner:=spin.launch(); // start spinner thread, returns reference to thread Atomic.sleep(10); // do stuff vm.kick(spinner.value); // stop thread by throwing exception at it</lang>

Spinning rod animation/Text: Difference between revisions

Revision as of 04:37, 1 March 2019

AWK

Bash

C

C Shell

Factor

FreeBASIC

GlovePIE

Go

Haskell

Java

Julia

Kotlin

M2000 Interpreter

Microsoft Small Basic

Perl

Perl 6

Phix

Python

REXX

Ring

Scala

zkl