カラーフェーディングアルゴリズムが機能しませんか？

Question

2色とタイマーの間にフェード/トランジションカラーアルゴリズムを作成しようとしています。タイマーは色がどれくらい速くスワップするかを決定します。唯一の問題は、私が追加するフェーディング・トランジション・オブジェクトが多いほど、それらがすべて速く動くことです。たとえば、1つのStandardFade（クラス）オブジェクトを追加すると、それは私が与えるタイマー（アルファ、コード）で実行されます。しかし、画面に「フェード」するオブジェクトが多く表示された場合、タイマーはもはや意味がなくなり、オブジェクトはすべて同じ速度で高速かつ高速に動きます。なぜ誰かが説明できますか？以下は

//Test Game Class, Implements the StandardFades 
import java.awt.Canvas; 
import java.awt.Color; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.image.BufferStrategy; 

public class TestGame extends Canvas implements Runnable{ 

private static final long serialVersionUID = -7267473597604645224L; 

private Thread thread; 
private boolean running = false; 
private boolean consoleFPS = true; 
private boolean titleFPS = true; 

private TestWindow window; 

//Fade objects, two is for a really long timer to test to see if they would transition at different times 
StandardFade one = new StandardFade(Color.RED,Color.BLUE,.005); 
StandardFade two = new StandardFade(Color.RED,Color.GREEN,.00000000000000001); 
StandardFade three = new StandardFade(Color.RED,Color.YELLOW,.000005); 

private int currentFPS; 
private int frames; 

public int levelNum; 

public TestGame(int width, int height, String title){ 
    this.window = new TestWindow(width,height, title, this); 

    this.initFades(); 
    this.start(); 
} 

private synchronized void start(){ 
    if(running) 
     return; 
    else{ 
     this.thread = new Thread(this); 
     this.thread.start(); 
     this.running = true; 
    } 
} 

private synchronized void stop(){ 
    if(!this.running) 
     return; 
    else{ 
     try{ 
      this.thread.join(); 
     }catch(InterruptedException e){ 
      e.printStackTrace(); 
     } 
     this.running = false; 
     System.exit(0); 
    } 
} 
/** 
* This game loop was provided by online sources, though there are many examples 
* of a game loop online. 
* 
* @author RealTutsGML 
*/ 
public void run() { 
    requestFocus(); //Focuses the click/input on the frame/canvas. 
    long lastTime = System.nanoTime(); //The current system's nanotime. 
    double ns = 1000000000.0/60.0; //Retrieves how many nano-seconds are currently in one tick/update. 
    double delta = 0; //How many unprocessed nanoseconds have gone by so far. 
    long timer = System.currentTimeMillis(); 
    int frames = 0; //The frames per second. 
    int updates = 0; //The updates per second. 
    while (running) { 

     boolean renderable = false; //Determines if the game should render the actual graphics. 

     long now = System.nanoTime();//At this point, the current system's nanotime once again. 
     delta += (now - lastTime)/ns; 
     lastTime = now; 
     //If the amount of unprocessed ticks is or goes above one... 
     //Also determines if the game should update or not/render. Approximately sixty frames per second. 
     while (delta >= 1) { 
      tick(); 

      delta--; 
      updates++; 

      renderable = true; 
     } 

     if(renderable){ 
      frames++; 
      render(); 
     } 

     if (System.currentTimeMillis() - timer > 1000) { 
      timer += 1000; 
      System.out.println(frames); 
      updates = 0; 
      frames = 0; 
     } 
    } 

    this.stop(); 
} 

/** 
* This method should tick everything that needs to be updated via positioning, 
* mouse input, etc. 
*/ 
private void tick(){ 
    /********************PUT ALL TICKABLE METHODS IN THIS METHOD; ALL CALCULATIONS, EVERYTHING*********************/ 
    //this.stdFadeHandler.get(0).tick(); 

    //this.stdFadeHandler.tick(); 

    one.tick(); 
    two.tick(); 
    three.tick(); 
    /**********************************END OF TICK METHOD INFORMATION AND METHODS******************************/ 
} 

private void render(){ 
    BufferStrategy bs = this.getBufferStrategy(); 

    if(bs == null){ 
     createBufferStrategy(3); 
     return; 
    } 

    Graphics g = bs.getDrawGraphics(); 
    Graphics2D g2 = (Graphics2D) g; 

    g2.setColor(Color.BLACK);  
    g2.fillRect(0, 0, window.getWidth(), window.getHeight()); 
    /*******************PLACE ALL DRAWING INSTRUCTIONS WITHIN THIS SECTION OF THE RENDER METHOD*************************/ 

    g2.setColor(one.getColor()); 
    g2.fillRect(20, 20, 200, 200); 
    g2.setColor(two.getColor()); 
    g2.fillRect(20, 300, 200, 200); 
    g2.setColor(three.getColor()); 
    g2.fillRect(20, 540, 200, 200); 

    //this.stdFadeHandler 


    /*******************DO NOT PLACE ANY MORE DRAWING INSTRUCTIONS WITHIN THIS SECTION OF THE RENDER METHOD***************/ 

    g.dispose(); 
    g2.dispose(); 

    bs.show(); 
} 

private void initFades(){ 


} 

public static void main(String[] args){ 

    TestGame stdGame = new TestGame(800,800,"Test Standard Game"); 
} 

フレームをMAKES実際のクラスである：StandardFade

import java.awt.Color; 
import java.awt.Graphics2D; 

public class StandardFade { 

private static float time = 0; 
private static boolean firstColor = true; 

private Color color1; 
private Color color2; 
private double alpha; 

private Color fadeColor; 

/** 
* Lines that implement the 
* r,g and b values come from Princeton University; I will author 
* them in at the bottom. 
* 
* Method takes two parameters and fades them into one another according to a 
* timer/clock value: alpha. 
* @param c1 First color to be used. 
* @param c2 Second color to be used. 
* @param alpha How fast colors should shift. 0 <= n <= 1. 
* Closer value is to zero, the longer it will take to shift. 
* ***Important note about alpha: for non-seizure inducing colors, alpha <= .0005*** 
* 
* The issue that is occurring is that, no matter what I do, no matter if I make 
* different StandardFade objects and assign them, they will always render at the 
* same rate, and faster and faster, depending on how many objects are fading. 
* 
* @return new Color based on r, g, and b values calculated. 
* 
* @author (Only code utilized was lines 58-60): 
* http://introcs.cs.princeton.edu/java/31datatype/Fade.java.html 
*/ 
public StandardFade(Color c1, Color c2, double alpha){ 
    this.color1 = c1; 
    this.color2 = c2; 

    this.alpha = alpha; 
} 

public void tick() { 

    if(time <= 1f && firstColor){ 
     time += alpha; 
    } 

    else{ 
     firstColor = false; 
    } 
    if(time >= 0f && !firstColor) 
     time -= alpha; 
    else{ 
     firstColor = true; 
    } 

    //System.out.println(time); 

    short r = (short) (time * color2.getRed() + (1 - time) * color1.getRed()); 
    short g = (short) (time * color2.getGreen() + (1 - time) * color1.getGreen()); 
    short b = (short) (time * color2.getBlue() + (1 - time) * color1.getBlue()); 

    if(r > 255) r = 255; 
    if(g > 255) g = 255; 
    if(b > 255) b = 255; 

    if(r < 0) r = 0; 
    if(g < 0) g = 0; 
    if(b < 0) b = 0; 


    this.fadeColor = new Color(r, g, b); 
} 

public Color getColor(){ 
    return this.fadeColor; 
} 

Answer 1

唯一の問題は次のとおりです。私は追加し、よりフェージング遷移オブジェクト、速く彼らはすべての

を行きます

private static float time = 0; 

時間に対して静的変数を使用しています。この変数は、ColorFadeクラスのすべてのインスタンスで共有されます。したがって、各フェーディングオブジェクトは同じ変数を更新します。

静的変数を使用しないでください（staticキーワードを削除してください）。各フェーディングオブジェクトには、独自の「時間」変数が必要です。

private float time = 0; 

また、firstColor変数が静的である必要があるかどうかは疑問です。

Answer 2

これは非常に多くのコードを処理しています（問題を可能な限り減らすようにしてください）が、問題の説明に基づいています - オブジェクトの数が増えるほど速くなります。問題は次の行です：

private static float time = 0; 

静的フィールドがクラスインスタンス間で共有されていることは承知していると思います。彼らはそれぞれ独自の価値を保存しているわけではありません。

これは、tickメソッドが呼び出されるたびに各インスタンスが時間値をインクリメントするため、問題が発生します。インスタンスが1つだけの場合は問題ありませんが、それ以上の場合は問題あります。

単にstaticキーワードを削除し、それが正常に動作する必要があります

private float time = 0;