gpt4 book ai didi

java - 如何使Java中的多边形对象脉动(例如Atari游戏“冒险”中的 chalice )

转载 作者:行者123 更新时间:2023-11-30 02:09:27 26 4
gpt4 key购买 nike

这就是我在paintComponent中所拥有的(省略了其他大部分内容,只是与一个名为Item的对象对象有关,该对象带有多边形字段,if语句的显式参数对该问题并不重要)
目前,它显示为纯白色,因为我将颜色设置为全部255,但是我想使其逐渐平滑地过渡为不同的颜色,而不是频闪,更像是脉动,但我真的不知道该怎么称呼。我当时正在考虑将Color的显式参数替换为可循环通过该数组中的数字的数组,并以某种方式将其链接到TimerListener,但是我对图形是陌生的,因此我不确定这是否是实现此目的的最佳方法。

public void paintComponent(Graphics g) {
Graphics2D sprite = (Graphics2D) g;

if (chalice.getHolding() == true || roomID == chalice.getRoomDroppedIn()) {
sprite.setColor(new Color(255, 255, 255));
sprite.fill(chalice.getPoly());
}
}

最佳答案

一些基本概念...


脉动效果需要沿两个方向移动,它需要淡入和淡出
为了知道应该应用多少“效果”,需要知道两件事。首先,整个效果要花多长时间(从完全不透明到完全透明再返回),动画要经过多长时间。


这不是一件容易的事情,有很多“状态”信息需要管理和维护,通常,与其他效果或实体分开进行。

在我看来,最简单的解决方案是设计某种“时间线”,该时间线沿时间线管理关键点(关键帧),计算每个点与其表示的值之间的距离。

退后一步。我们知道:


0%我们要完全不透明
50%我们希望完全透明
100%我们想完全不透明


上面考虑了我们要“自动反转”动画的情况。

使用百分比的原因是,它允许我们定义任何给定持续时间的时间轴,该时间轴将处理其余部分。在可能的情况下,始终使用这样的归一化值,这会使整个过程变得更加简单。

TimeLine

以下是一个非常简单的“时间轴”概念。它具有Duration,播放时间线的时间,关键帧和关键帧,这些关键帧在时间线的持续时间内提供关键值,并提供在时间线的整个生命周期中的特定点计算特定值的方法。

此实现还提供“自动”重播功能。也就是说,如果时间轴“结束”播放时指定了Duration,而不是停止播放,它将自动重置并在下一个周期(整整)中考虑“结束”的时间量

public class TimeLine {

private Map<Float, KeyFrame> mapEvents;

private Duration duration;
private LocalDateTime startedAt;

public TimeLine(Duration duration) {
mapEvents = new TreeMap<>();
this.duration = duration;
}

public void start() {
startedAt = LocalDateTime.now();
}

public boolean isRunning() {
return startedAt != null;
}

public float getValue() {
if (startedAt == null) {
return getValueAt(0.0f);
}
Duration runningTime = Duration.between(startedAt, LocalDateTime.now());
if (runningTime.compareTo(duration) > 0) {
runningTime = runningTime.minus(duration);
startedAt = LocalDateTime.now().minus(runningTime);
}
long total = duration.toMillis();
long remaining = duration.minus(runningTime).toMillis();
float progress = remaining / (float) total;
return getValueAt(progress);
}

public void add(float progress, float value) {
mapEvents.put(progress, new KeyFrame(progress, value));
}

public float getValueAt(float progress) {

if (progress < 0) {
progress = 0;
} else if (progress > 1) {
progress = 1;
}

KeyFrame[] keyFrames = getKeyFramesBetween(progress);

float max = keyFrames[1].progress - keyFrames[0].progress;
float value = progress - keyFrames[0].progress;
float weight = value / max;

float blend = blend(keyFrames[0].getValue(), keyFrames[1].getValue(), 1f - weight);
return blend;
}

public KeyFrame[] getKeyFramesBetween(float progress) {

KeyFrame[] frames = new KeyFrame[2];
int startAt = 0;
Float[] keyFrames = mapEvents.keySet().toArray(new Float[mapEvents.size()]);
while (startAt < keyFrames.length && keyFrames[startAt] <= progress) {
startAt++;
}

if (startAt >= keyFrames.length) {
startAt = keyFrames.length - 1;
}

frames[0] = mapEvents.get(keyFrames[startAt - 1]);
frames[1] = mapEvents.get(keyFrames[startAt]);

return frames;

}

protected float blend(float start, float end, float ratio) {
float ir = (float) 1.0 - ratio;
return (float) (start * ratio + end * ir);
}

public class KeyFrame {

private float progress;
private float value;

public KeyFrame(float progress, float value) {
this.progress = progress;
this.value = value;
}

public float getProgress() {
return progress;
}

public float getValue() {
return value;
}

@Override
public String toString() {
return "KeyFrame progress = " + getProgress() + "; value = " + getValue();
}

}

}


设置时间表非常简单...

timeLine = new TimeLine(Duration.ofSeconds(5));
timeLine.add(0.0f, 1.0f);
timeLine.add(0.5f, 0.0f);
timeLine.add(1.0f, 1.0f);


我们指定一个 Duration并设置关键帧值。之后,我们只需要“启动”它,并根据播放的时间从 value中获取当前的 TimeLine

对于一个看似简单的问题,这似乎需要大量工作,但请记住,这既动态又可重复使用。

它是动态的,因为您可以提供所需的任何 Duration,从而更改速度,它可以“正常工作”并且可重复使用,因为您可以为多个实体生成多个实例,并且可以对其进行独立管理。

例...

下面的示例仅使用Swing Timer充当动画的“主循环”。在每个循环中,它都会向 TimeLine询问“当前”值,该值仅充当“脉冲”效应的 alpha值。

TimeLine类本身已足够解耦,因此无论您如何建立“主循环”都无关紧要,只需启动它并在可能的情况下从中提取“当前”值即可。

Pulse

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Map;
import java.util.TreeMap;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

public static void main(String[] args) {
new Test();
}

public Test() {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
ex.printStackTrace();
}

JFrame frame = new JFrame("Testing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new TestPane());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
});
}

public class TestPane extends JPanel {

private TimeLine timeLine;
private float alpha = 0;

public TestPane() {
timeLine = new TimeLine(Duration.ofSeconds(5));
timeLine.add(0.0f, 1.0f);
timeLine.add(0.5f, 0.0f);
timeLine.add(1.0f, 1.0f);
Timer timer = new Timer(5, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if (!timeLine.isRunning()) {
timeLine.start();
}
alpha = timeLine.getValue();
repaint();
}
});
timer.start();
}

@Override
public Dimension getPreferredSize() {
return new Dimension(200, 200);
}

protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g.create();
g2d.setComposite(AlphaComposite.SrcOver.derive(alpha));
g2d.setColor(Color.RED);
g2d.fill(new Rectangle(45, 45, 110, 110));
g2d.dispose();

g2d = (Graphics2D) g.create();
g2d.setColor(getBackground());
g2d.fill(new Rectangle(50, 50, 100, 100));
g2d.setColor(Color.BLACK);
g2d.draw(new Rectangle(50, 50, 100, 100));
g2d.dispose();
}

}
}


我会将 TimeLine绑定为指定实体的效果的一部分。这会将 TimeLine绑定到特定实体,这意味着许多实体都可以拥有自己的 TimeLine来计算不同值和效果的验证

“有没有更简单的解决方案?”

这是一个主观的问题。 “可能”会有一种“更简单”的方法来完成相同的工作,但不会像这种方法那样具有可伸缩性或可重用性。

动画是一个复杂的主题,试图使其在复杂的解决方案中工作,运行多种不同的效果和实体只会使问题复杂化

我想出了制作 TimeLine泛型的想法,因此可以将其用于根据所需结果生成不同值的真实性,从而使其成为更加灵活和可重复使用的解决方案。

混色....

我不知道这是否是必要条件,但是如果您要混合使用一系列颜色,则 TimeLine在这里也可以为您提供帮助(您不需要那么长的时间)。您可以设置一系列颜色(用作关键帧),并根据动画的进度计算要使用的颜色。

混合颜色有些麻烦,我花了很多时间试图找到一个对我有用的不错的算法,在 Color fading algorithm?Java: Smooth Color Transition上进行了演示。

关于java - 如何使Java中的多边形对象脉动(例如Atari游戏“冒险”中的 chalice ),我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/50539835/

26 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com