Desafio

Escreva uma função que aceite um parâmetro: um número inteiro t. Sua função precisa interromper o programa por tsegundos antes de continuar, semelhante ao time.sleep(t)Python e WAIT tao BBC BASIC.

Você não deve usar nenhuma função incorporada em espera ou executada para executar código após um certo tempo, e seu programa deve continuar após tsegundos.

Para testar sua função, há tolerância de 0,1 segundos a mais ou a menos do que a fornecida tem sua própria máquina: as variações entre os computadores são boas.

Se a sua resposta é desafiado por qualquer pessoa, você deve fornecer prova fotográfica (screenshotted) que a sua função funciona corretamente para t=1, t=5e t=25. Você também pode fornecer os detalhes do seu computador para que as pessoas possam tentar replicá-lo em sua própria máquina.

Seu programa deve e será executado em um computador cuja velocidade de clock seja de 1,6 GHz ou superior.

Ganhando

O programa mais curto vence.

Recompensa

Uma recompensa vai para o programa mais curto que interrompe o programa sem usar um loop para verificar quanto tempo se passou. Se você está concorrendo a essa recompensa, adicione uma nota de rodapé dizendo que sua resposta é para a recompensa.

Entre os melhores

/* Configuration */

var QUESTION_ID = 55293; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 30525;

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });

    var patt = new RegExp(/[Bb]ounty/);
    var res = patt.test(body);
    var bountyyn = "no";

    if (res) {
      bountyyn = "yes";
    }
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
        bounty: bountyyn
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link)
                   .replace("{{BOUNTY}}", a.bounty);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 400px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td><td>Bounty?</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td>{{BOUNTY}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

código de máquina x86_64, 10 bytes

Hexdump do código:

48 69 c9 ca fc 59 38 e2 fe c3

Código fonte (pode ser montado pelo ml64Visual Studio):

    TITLE   heh

PUBLIC  mywait
_TEXT   SEGMENT
mywait  PROC
    imul rcx, 945421514
myloop:
    loop myloop
    ret
mywait  ENDP
_TEXT   ENDS
END

Executa um loop vazio, iniciando do valor especificado até 0. Escolhi o multiplicador 945421514 empiricamente por tentativa e erro, até que meu programa de teste produza resultados satisfatórios.

Programa de teste (aguarda 10 vezes por cada uma das durações 1, 5 e 25 segundos):

#include <stdio.h>
#include <time.h>

extern "C" void mywait(int);

int main()
{
    int durations[] = {1, 5, 25};
    for (int duration: durations)
    {
        for (int i = 0; i < 10; ++i)
        {
            clock_t before = clock();
            mywait(duration);
            clock_t after = clock();
            printf("%f\n", (after - before) / (double)CLOCKS_PER_SEC);
        }
    }
    getchar(); // now take a screenshot
}

O resultado:

1.003000
1.000000
1.004000
1.006000
1.005000
0.998000
0.995000
1.000000
1.005000
1.004000
4.999000
5.003000
5.035000
5.010000
4.992000
5.003000
5.003000
5.019000
5.026000
4.989000
25.041000
24.993000
25.049000
24.988000
25.038000
24.948000
25.007000
25.014000
25.053000
25.021000

Eu executei este programa em um computador Windows que não tem mais nada para fazer. Se ele executa alguns aplicativos, os tempos de espera são mais irregulares.

A velocidade da CPU é de 3,9 GHz. Parece que esse código é mal bom o suficiente para a tecnologia atual do PC - se a frequência do relógio for de 8,8 GHz, o multiplicador não se ajustará a um int assinado de 32 bits.

PS Como essa resposta não verifica quanto tempo se passou, ela é candidata à recompensa.

Bash, 29 25 24 23 19 bytes

w()(ping -t$1 1.2)

Teste de precisão ( time) em que $1= 1 segundo:

real    0m1.012s
user    0m0.001s
sys     0m0.002s

Obrigado Dennis por reduzir a contagem de bytes para 19 a partir de 23!

EDIT : Eu mudei o IP para evitar pingping no Linux 0.0.0.0, que é o dispositivo de loopback.

Como isso funciona

ping tem um tempo limite padrão de 1 segundo; portanto, ao entrar em contato com um endereço IP que não existe, o ping não pode continuar até que o tempo limite se esgote ou que tenha recebido uma resposta do IP.

-tdiz pingque tentar $1várias vezes sobre este endereço IP falso, forçando pinga tomar $1segundos para completar o ping.

Matlab, 33 bytes

function f(t)
tic;while toc<t,end

Ou você também pode usar isso no Octave: experimente on-line

Matlab, 31 bytes

Como sugerido por @flawr , isso pode ser feito com uma função anônima (deve ser atribuído um nome para usá-lo):

@(t)eval('tic;while toc<t,end')

Exemplo:

>> f=@(t)eval('tic;while toc<t,end');
>> tic, f(2), toc
Elapsed time is 2.000323 seconds.

Java, 63 62 bytes

t->{for(long a=System.nanoTime();System.nanoTime()-a<t*1E9;);}

Nada de surpreendente - basta pegar o número de nanossegundos desde 1/1/1970 várias vezes e verificar se um segundo se passou.

Economizou 1 byte graças a Ypnypn e aditsu.

Lote, 27 bytes

set /a c=%1+1
ping -n %c% 0

Um truque popular de lote, pois o lote não tinha uma função de suspensão.

Nenhum loop, portanto, a recompensa é elegível

Commodore 64 BASIC, 19 16 bytes

1000 FORI=1TO930*N:NEXT:RETURN

Com uma chamada N=<number-of-secods>:GOSUB1000 .

No entanto, não posso fornecer precisão suficiente. Como o C64 tinha cerca de 1 MHz de velocidade da CPU, lembro que era bom o suficiente para fazer um vazioFOR - NEXTciclo 1000 vezes de modo que era sobre 1 segundo.

De fato, havia duas versões principais da máquina: PAL 0,985 MHz e NTSC 1,023 MHz (todos os dados da página C64 da Wikipedia) ). Como eu tinha a versão NTSC, era necessário executar o loop cerca de 930 vezes.

Testes com o seguinte programa ( Nsegundos, fornecidos pelo usuário em INPUT):

10 INPUT N
20 PRINT TI$
30 GOSUB 1000
40 PRINT TI$
50 END
1000 FOR I=1 TO 930*N:NEXT I:RETURN

onde TI$é uma variável do sistema contendo string ( hhmmssformato) com o tempo decorrido desde a última redefinição (precisão de 1 segundo, mas também dependendo da velocidade da CPU, portanto, isso não é muito relevante, porque é o mesmo relógio).

Captura de tela feita com o emulador C64 on-line http://codeazur.com.br/stuff/fc64_final/ .

Este programa ( 1000somente linha ) ocupa 16 19 bytes na memória, conforme testado PRINT FRE(0)+65535antes de digitar o código (38908 bytes) e depois ( 38893 38889 bytes). PRINT FRE(0)retorna memória livre para o programa BASIC (é um valor negativo e uma constante 65535deve ser adicionada, mas na verdade não importa).

Como este programa não testa o tempo decorrido em um loop, ele se qualifica para receber uma recompensa.

JavaScript ES6, 50 45 40 bytes

n=>{for(g=Date.now,z=g();z+n*1e3>g(););}

isso usa funções de execução automática, não sei por que +new Datenão está funcionando.

Uso

Eu testei isso com o Safari Nightly, mas também funcionará no Firefox. Testado com:

(
  n=>{for(g=Date.now,z=g();z+n*1e3>g(););}
)(1); // 1 is the delay is seconds
console.log( 'foo' );

Você pode executá-lo colocando-o entre parênteses:

( n=>{for(g=Date.now,z=g();z+n*1e3>g(););} )(5)

Ou nomeando-o:

const wait=n=>{for(g=Date.now,z=g();z+n*1e3>g(););}
wait(5)

Explicação

Aqui está a principal lógica por trás do programa:

function (n) {
    var start = Date.now();   // Save start time (ms)
    while (                   // while is synchronous, it'll block the code execution until it has finished
           start + (n * 1000) // This is the end time (start + delay)
            > Date.now()      // When the current time is 1 ms past the target end time, stop. resuming the code execution
          );
}

A versão que estou usando usa a mesma lógica:

n=>{ // Function with argument n, { is required if the functions is not just an expression
   for(           // For will also block code execution
                  // This first part is used to define variables
      g=Date.now, // Add an alias for Date.now as "g"
      z=g()       // get current time and store in z
      ;           // Next part, condition
      z + n*1e3   // Target end time, ( start + delay (converted to seconds) ) 1e3 is 1000 but in big e notation
      ;           // Is required for a valid for loop
   );
}

CJam, 15

{e3es+{_es>}g;}

Este é um bloco que pode ser executado ou armazenado em uma variável (tornando-se uma função nomeada). Dennis e Mr Consensus concordam que contar apenas o bloco é aceitável :)

Explicação:

e3       multiply the argument by 1000 (to get milliseconds)
es       get the current timestamp in milliseconds
+        add the values, obtaining the stopping time
{…}g     do…while
  _      duplicate the stopping time
  es>    check if we reached that time yet (loop condition)
;        discard the stopping time

Experimente online

JavaScript, 68 54 51 42

Eu acho que nenhuma captura de tela é necessária. Mas suspeito que você possa jogar golfe ainda mais ...

Nova versão: agora finalmente consegui evitar newe usar Dateduas vezes:

f=t=>{for(x=(d=Date.now)();d()<x+t*1e3;);}

Versões mais antigas:

f=t=>{for(x=new Date();(new Date()|0)<x|0+t*1e3;);}

f=t=>{x=(new Date())|0;while((new Date()|0)<x+t*1e3);}

f=t=>{x=new Date().getSeconds();while(new Date().getSeconds()<x+t);}

PHP, 171 177 84 79 65 64 62 bytes

<?php function a($i){for($f=microtime,$e=$f(1)+$i;$f(1)<$e;);}

Uso:
Chame a função da seguinte maneira:
php -d error_reporting=0 -r "require 'script.php'; a(5);echo 'Hello, World!';"
Onde 5 é o tempo em segundos que o programa deve esperar antes de ecoar "Olá, Mundo!".

Explicação:
Inicialmente, a função obtém o tempo atual em milissegundos. Então a função faz um loop até que o tempo atual seja menor que a primeira vez + a entrada. Depois "Olá Mundo!" recebe eco.

Log:
Economizado 113 bytes graças ao Voitcus
Economizado 2 bytes graças ao axiac

Julia, 33 20 bytes

t->watch_file(".",t)

Só funciona na Julia v0.4 devido a alterações na assinatura da função de watch_file. Define uma função anônima com um único parâmetro tque (ab) usa o parâmetro timeout nowatch_file função.

Este é um candidato à recompensa!

Demonstração usando o Julia REPL:

julia> f=t->watch_file(".",t)
(anonymous function)

julia> @elapsed f(1)
1.002134983

julia> @elapsed f(5)
5.006161965

julia> @elapsed f(25)
25.026096192

Resposta anterior (33 bytes), também trabalhando em Julia stable

t->(b=time();while b+t>time()end)

R, 48 bytes

f=function(t){a={g=Sys.time}();while(g()<a+t){}}

Demonstração:

t0 <- Sys.time();f(1); Sys.time() - t0 
## Time difference of 1.000272 secs

t0 <- Sys.time();f(5); Sys.time() - t0 
## Time difference of 5.011189 secs

t0 <- Sys.time();f(25); Sys.time() - t0 
## Time difference of 25.00848 secs

PHP, 39 bytes

function a($a){while($i++<.4583e8*$a);}

(Observe que, na verdade, posso diminuir isso se um programa completo for necessário, aproveitando os argumentos passados ​​na linha de comando. Abaixo de 35 )

<?php while($i++<.4583e8*$argv[1]);

Programa usado para teste:

<?php function a($a){while($i++<.4583e8*$a);}

record(1);
record(5);
record(25);

function record($t)
{
    $time = microtime_float();
    a($t);
    echo microtime_float() - $time."\n";
}

function microtime_float()
{
    list($usec, $sec) = explode(" ", microtime());
    return ((float)$usec + (float)$sec);
}

Resultados:

JamesWebster:Documents jameswebster$ php A.php
1.0093479156494
4.9945771694183
24.971961975098

Apesar de me qualificar para a recompensa, dificilmente concordo com algumas das outras entradas!

Windows CMD, 22 bytes

ping -w 1000 -n %1 1.1

Isso não usa loop (label e goto), portanto, qualifica-se para a recompensa

Ele envia tpings para 1.0.0.1 (inválido) e aguarda uma resposta por 1000 ms

JavaScript ES6, 40 bytes

t=>{for(t=(d=Date.now)()+t*1e3;d()<t;);}

Testado com o seguinte:

elapsed=(f,t,b=(d=Date.now)())=>(f(t),console.log(d()-b+"ms elapsed")) // accepts func, delay
STOP=t=>{for(t=(d=Date.now)()+t*1e3;d()<t;);}
elapsed(STOP,1)  // prints 1000ms elapsed
elapsed(STOP,5)  // prints 5000ms elapsed
elapsed(STOP,25) // prints 25000ms elapsed

TI-BASIC (84 + SE), 21 bytes

Método de entrada: T:prgmT. Este é o equivalente mais próximo de uma função no TI-BASIC. Programa:

For(A,1,841Ans
End

Toda a precisão é obtida através de tentativa e erro; cronometrando-o com um cronômetro funciona para todos os casos de teste fornecidos dentro de um vigésimo de segundo.

Informação de dispositivo:

RAM FREE   23312
ARC FREE  889802


 TI-84 Plus Silver Edition
          2.55MP
PROD #: 0A-3-02-37
ID: 0A3DC-C3469-FFE8

W00T elegível para uma recompensa!

Python, 57 bytes

import time
b=time.time
def y(i):
 x=b()
 while x+i>b():x

Função de chamada y()

PureBasic, 92 bytes

Procedure z(t)
t=t*1e3+ElapsedMilliseconds()
While t>ElapsedMilliseconds():Wend
EndProcedure

É o mais curto que consigo pensar. Eu suspeito que este será o mais longo aqui também ...

Testar:

OpenConsole()
i=Val(Input())
s=ElapsedMilliseconds()
z(i)
PrintN(Str(ElapsedMilliseconds()-s))
Input()

PowerShell, 75 bytes

Chamadas de procedimento longas e descritivas. Yay para maior clareza em um idioma. :)

function w{param($i);$n=(Get-Date).AddSeconds($i);while($n-gt(Get-Date)){}}

Chamado dentro de um programa com algo como

Get-Date
w(15)
Get-Date

Como alternativa, se for permitido chamar programas externos, podemos reduzir para 59 bytes com o seguinte:

$n=(Get-Date).AddSeconds($args[0]);while($n-lt(Get-Date)){}

Isso seria chamado dentro de um programa da seguinte maneira (presumindo que o acima foi salvo como "wait-function.ps1" e salvo na mesma pasta):

Get-Date
& ((Split-Path $MyInvocation.InvocationName) + "\wait-function.ps1 15")
Get-Date

O que economizamos ao escrever a função / programa é mais do que prejudicado pelo excesso necessário para realmente executá-la. Le suspiro.

Python, 66 bytes

Observe que minha implementação nem chama uma função de tempo embutida nem usa o recurso de agendamento.

def S(t):
 try:__import__("Queue").Queue().get(1,t)
 except:pass

E sim, é elegível para recompensa.

Hassium, 55 Bytes

func w(t){p=time().second;while((p+t)>time().second)0;}

Run and see expanded: http://HassiumLang.com/Hassium/index.php?code=9f4e2bdb292b14b150fba63677a11a79

Pyth, 19 bytes

Late entry but after finding .d0 in the docs last night I decided to give it a go.

DCNK.d0W<-.d0KNJ1))

Defines a function which loops until the time elapsed is N seconds.

Try it here.

RProgN 2, 13 bytes

°°°)*™+]³]™>:

Explained

°°°)*™+]³]™>:
°°°             # Push 3 tens to the stack.
   )*           # Get the product of the entire stack, including the implicit input. This is the shortest way to multiply the input by 1000.
     ™+         # Add it to the current time in miliseconds.
       ]        # Duplicate it to use as a (throwaway) conditional.
        ³   :   # Create a function using the next 3 concepts, and while the top of the stack is truthy, execute it.
         ]      # Duplicate the target time
          ™>    # Is it larger than the current time?

The bounty specifically says "without using a loop checking how much time has elapsed", which this does not do. This sets a target time, and keeps checking if it's passed that target time, thus it's eligible for the bounty.

Try it online!

Tcl, 53 bytes

proc W t {while "\[clock mil]-[clock mil]<$t*1e3" {}}

Try it online!

Explained

Command clock milliseconds can be reduced to clock mil, with escaped 1st bracket, it'll be interpreted at each loop, and w/o just once. As it measures milliseconds, we need to multpily by 1000 or 1e3 which saves 1 Byte.

C# (Visual C# Interactive Compiler) + /u:System.Threading, 36 bytes

x=>new SemaphoreSlim(0).Wait(x*1000)

Try it online!

Creates a semaphore with no capacity and tries to get it for the specified number of seconds.

I realize I am "wait"ing on something here. To me this seems more like the ping/timeout solution as opposed to Thread.Sleep. The code tries to get a resource that it cannot get and stops trying after a limit.

===

Below is a variation that starts a Task with an infinite loop, then waits for it to complete with a timeout. All required namespaces are included by default, but the solution is a few bytes longer than the one above.

C# (Visual C# Interactive Compiler), 40 bytes

x=>Task.Run(()=>{for(;;);}).Wait(x*1000)

Try it online!

05AB1E, 22 bytes

žcžb60*+[Džcžb60*+αIQ#

Try it online.

NOTE: Depending on how many microseconds in the current second have already passed, the tolerance might be slightly larger than 0.1 sec. But since almost halve the answers have similar issues, I figured it's allowed.

Explanation:

05AB1E doesn't have any builtins for the current time. It does however have a builtin for the current year/month/day/hours/minutes/seconds/microseconds as separated builtins. Since only using seconds can potentially wrap around from 59 to 0 causing issues, I need both the minutes and seconds, making the code even longer than most answers in non-codegolfing languages unfortunately.

žc                # Push the current seconds
  žb              # Push the current minutes
    60*           # Multiply it by 60
       +          # Add them together
[                 # Start an infinite loop:
 D                #  Duplicate the initial (minutes*60 + seconds) from before the loop
  žcžb60*+        #  Push the current (minutes*60 + seconds) again
          α       #  And take the absolute difference between the two
           IQ     #  And if this is equal to the input:
             #    #   Stop the infinite loop

SmileBASIC, 20 bytes

INPUT T
DIALOG"",,,T

Opens a dialog box that closes automatically after T seconds. I'm not sure if this counts as a "built in waiting function", but I think this is just as valid as using ping.

An alternative 37-byte program which definitely isn't cheating:

INPUT T
FADE.,T*60WHILE FADECHK()WEND

Causes the screen fade color to change to 0 (alpha=0,red=0,green=0,blue=0) (no effect) gradually over T seconds, then waits for that animation to finish.