Question

一个数学问题。我正在尝试按顺序为对象设置动画，但是我无法弄清楚可以使我平稳设置延迟的公式。可以说，如果我的数组中有2个对象，我希望它们以i * 0.25的延迟几乎正常地进行动画处理，但是如果我有25个对象，则我希望它们进行快速动画处理。是的，我可以尝试设置手动比例切换.count，但是我认为应该有一个不错的公式？

for (i,object) in objects.enumerated() {
    object.animate(withDelay: (i * 0.25) / objects.count)
}

Answer 1

最好的选择是选择一个动画时间，无论变量多少，该时间都会发生。

let animateTime = 2 // 2 secs
let animateTimePerObject:Double = animateTime/objects.count
for (i,object) in objects.enumerated() {
    object.animate(withDelay: (i * animateTimePerObject) 
}

说有10个对象，并且想要设置动画2秒钟。这将设置animateTimePerObject = 2/10 = .2每个项目都会延迟i (whatever position they are at) * the animatetime per object。因此，依次0, 0.2, 0.4, 0.6, 0.8, 0.1, 0.12, 0.14, 0.16, 0.18, 0.2。

可以用2个对象完成相同的操作。

或者您可以执行log函数，该函数可以实现增长，但速度较慢。这是您可以使用的一些functions。

添加此功能以创建自定义日志功能

func logC(val: Double, forBase base: Double) -> Double {
    return log(val)/log(base)
}

for (i,object) in objects.enumerated() {
    let delay = i == 0 ? .25 : logC(Double(i)*10, forBase: 10) * 0.25
    object.animate(withDelay: delay)
}

This will slow down your 0.25*i rate to a much slower one.

0 -> .25
1 -> Log(20, base: 10) = 1.3 * 0.25 = .325
...
25 -> Log(250, base: 10) = 2.3979 * 0.25 = .6

应该在的地方

0 -> .25
1 -> .25 * 2 = .5
25 -> .25 * 25 = 6.25

您可以随意使用日志功能，但这只是一些想法。您要寻找哪种算法并不精确。

注意：：Double和Int可能只是其中的语法问题，但您可以调整！：）

比较日志和Sqrt：

func logC(val: Double, forBase base: Double) -> Double {
    return log(val)/log(base)
}

for i in 0..<25 {
    let delay = i == 0 ? 0.25 : pow(logC(val: Double(i)*10, forBase: 10) * 0.25, log(1/Double(i))) * 0.45
    let delay2 = i == 0 ? 0.25 : sqrt(Double(i)) * 0.5
    print(delay, delay2)
}

0.25 0.25
0.45 0.5
0.9801911408397829 0.7071067811865476
1.3443747821649137 0.8660254037844386
1.5999258430124579 1.0
1.7853405889097305 1.118033988749895
1.9234257236285595 1.224744871391589
2.0282300761096543 1.3228756555322954
2.1088308307833894 1.4142135623730951
2.1713433790123178 1.5
2.2200343505615683 1.5811388300841898
2.2579686175608598 1.6583123951777
2.2874024254699274 1.7320508075688772
2.3100316733059247 1.8027756377319946
2.32715403828525 1.8708286933869707
2.33977794890637 1.9364916731037085
2.348697701417663 2.0
2.3545463958925756 2.0615528128088303
2.357833976756366 2.1213203435596424
2.358975047645847 2.179449471770337
2.35830952737025 2.23606797749979
2.3561182050020992 2.29128784747792
2.35263460234384 2.345207879911715
2.348054124507179 2.3979157616563596
2.3425411926260447 2.449489742783178

Answer 2

您可以使用下面的函数，该函数取决于您先前指定的对象数，如果数组中有更多的对象，则每个动画的执行延迟都将减少，但第一项的延迟将比后者更长。

for (i,object) in objects.enumerated() {
    object.animate(withDelay: ((1/((i+1)*0.5)) * 0.25) / objects.count)
}

有很多括号，但我希望它能提高可读性，我也应用了i + 1，所以您不会对第一个项除以零的问题。

我希望通过这个公式，当数组中包含大量对象时，延迟会逐渐平滑地减小。

注意：

如果您认为在数组中没有太多元素的情况下延迟太多（这会降低“ objects.count”的数量。请尝试将objects.count替换为(2 * objects.count)
如果您认为当数组中的元素很多时（延迟不大）（这会增加“ objects.count”的数量），请尝试将objects.count替换为(objects.count / 2)

（增加时间延迟）取决于对象数

2 个答案: