XJ发布的Jump bug教程

SiMen.beambean

Jump-bug教程

faker 2007年4月22日

翻译者：就是lz本人啦

大家好：
  我相信大家都听说了很多关于这个疯狂的新技术并且很好奇想学习怎样做到。

在我空闲时我和eDark【（非）正式cs引擎专家 】，谈过一些实情和最好实现jump-bug的方法。

首先，应该是个最重要的问题：什么是jump-bug?它适用于哪方面？

Jump-bug是由tjubby在以前发现的。是从可以从很高的地方落下而不伤血/死亡的另外一种方式。和普通的edgebug类似。


怎样使Jump-bug成功？

为了发现jump bug的构成，我们首先得分析cs引擎。Counter-Strike引擎使用了2种互相抵触得模型。而上层的模型在位于下层模型的下面一点点。只要上层模型没有接触到地面，玩家就不会因落下而受伤。
如果你用+duck下层模型就会下落4个单位的距离。有趣的是，这也正是用于＋Jump的模型。所以如果你在下落的过程中蹲着，并且在离地面上4个单位的距离“跳下来”。对引擎来说你永远也碰不到地面。你得松开+duck键（使得抵触模型回去),并且大约在你落地摔死之前0.01秒内，同时按跳。这样就触发了bug,落地不伤血。

总结：你需要跳，落下，蹲（按着蹲键），然后几乎同时跳和松开蹲键（在你落地的地方）


Jump-bug是个巧合吗？我可以学会吗？

恩，这个就是具体的说就是和正确的时机，还有fps有关
有3种可能的fps情况：
1.  fps稳定在100.0.如果你高度完全正确（见下文），掌握完美的时机，符合所有的要求（见下面的E3方程）。你的成功率是100%.

2.fps不稳定，如果你的fps不稳定，那么是否触发jump-bug就完全是个巧合了。完美的时机不是必要的因素意味着你可以成功的触发jump-bug!但是：在这种情况下jump-bug可以在任何高度实现（高度的不同并不限制jump-bug成功的可能性，如第一种情况).要计算这种情况(不稳定的fps)jump-bug的方法，参见后面的方程E5

3.稳定的fps但是小于100,和第一种情况类似，但是比第一种情况更难触发jump-bug.计算这种可能性也是用E3这个方程，但等级更高[用0,01*(100/fps) 代替 0,01]

另一方面就是高度的不同：下落的距离越高（高度差距越大），越难触发jump-bug.

一些纯数据（给数学天才看的）

下落速度的计算公式：
E1: v(t)=268.25units/s-800units/s^2*t

计算每帧高度的不同：
每帧的不同高度（＝1帧就是引擎用于计算的实体。100fps意味着每秒是100帧）
E2: v(t)/fps

你需要在离地面4个单位以内的区域内行jump命令和松开蹲键。这个动作要在落地前的1帧内完成。(~0,01 seconds @ 100 fps [=1/fps]).

在fps稳定于100的情况下，满足成功触发jump-bug的方程：
E3: h2+4units>h(t)=h1+268.25units/s*t-0.5*800units/s^2*t^2>h2
In frames @ 100 fps: E4: h2+4units>h(f)=h1+2.6825 units/f*f-0.5*8units/f^2*f^2>h2

->注释：h1-=高度（落下的），h2=高度（落地），t=时间，f=帧
->t是在(1/fps) 秒内定性定量分析的大小

如果fps不稳定，用这个方程:
E5: 400/sqrt(71958.0625+1600*hd)

-> 注释：sqrt = square root, hd = height difference
-> E5 must be scaled with the fps of the frame in which you re doing the bug to get the correct probability: E5*(fps/100)

一些连接：
一些jump-bug的demo也许可以帮助你学习：


感谢：
eDark计算并解释这一切，还有所有跳jump-bug的”先锋“，特别感谢tjubby,在很久前就把demo发到论坛上使这个技术得到注意，还有感谢Pulsarl录这个demo的人。
感谢angie帮助我修改这篇文章。


附原文：
Jump-Bug Guide
[email=-]faker[/email] Sunday 22 April 2007


Hey guys,

I’m pretty sure most of you have already heard a lot about this crazy new technique and are very curious to find out more about all this and to learn how it works.

In my spare time I spoke with eDark (the (in)official Counter-Strike engine professor ) about some facts and the best way to master this technique.

First of all, probably the most important question: What is a jump-bug and what is it good for?

The Jump-bug was found by tjubby some time ago and is another way to fall down a pretty long distance without taking any damage and/or dying, pretty similar to the normal edgebug.
Therefore, using this technique gives the jumper a considerable advantage on maps without a health charger. Perhaps the most amazing benefit is the fact that you can use the jump-bug in areas where edge-bugs are impossible.

Okay, so let’s try to find out how this technique is even possible and how it is possible to trigger the bug.


How does the Jump-bug work?

In an attempt to discover how the jump bug functions, we must first break down the CS engine. The Counter-Strike engine uses two different collision models. In this case the upper collision model is located slightly above the lower one, and as long as the upper collision model does not make contact with the ground, then the player will not take fall damage.
If you use +duck the lower collision model will drop down about 4 units. The funny thing is, that this is the exact collision model used for the +jump command too, so if you duck while you are falling down and “jump off” within an area of 4 units above the ground, you’ve never touched the ground for the engine. You have to release the +duck key (to move the collision box back up) and jump at the very same moment, about 0.01 seconds before you would touch the ground and die, to trigger the bug and land without taking any damage.

Summing-Up: You have to jump, fall down, duck (hold the duck key), jump and release duck at the very same moment (at the place you are supposed to “land”).


Is it just coincidence, or can I learn it?

Well, it’s particularly all about the right timing and the fps.

- FPS Issues: There are 3 different possibilities:

1. constant 100,0 fps: If you have the right height difference (see below), perfect timing and all the requirements are met (to see what the requirements are about check the equation E3 below) your chances are 100% to do it.
2. inconstant fps: If your FPS are inconstant it is pure coincidence if you will be able to trigger the jump-bug or not. Perfect timing does not necessarily mean that you will be able to trigger the bug successfully! BUT: Jump-bugs are possible with any height difference in this case (the height difference does not restrict the possibility to be able to do a jump-bug like it did in case 1.). To calculate how likely you will be able to trigger a jump-bug with inconstant fps see the equation below (E5).

3. constantly AND <100 fps: Pretty similar to case 1., but it’s harder (more unlikely) to trigger the bug. To calculate the possibility you have to use the same equation (E3) but with bigger steps (0,01*(100/fps) instead of 0,01)

- Another aspect is the height difference : The higher the jump is (and therefore the bigger the height difference is) the harder it will become to trigger a bug.


Pure facts (for the math geeks )

The falling speed can be calculated with this equation:

E1: v(t)=268.25units/s-800units/s^2*t

This will help you to calculate the height difference per frame.

Height difference per frame (= A frame is an entity used for calculations within the engine. 100 fps means 100 frames per second):

E2: v(t)/fps

You have to hit the jump command and release the duck key within an area of 4 units above the ground in ONE frame before landing (~0,01 seconds @ 100 fps [=1/fps]).

And finally the equation, which needs to be fulfilled to hit the jump-bug successfully with constantly 100,0 fps:

E3: h2+4units>h(t)=h1+268.25units/s*t-0.5*800units/s^2*t^2>h2
In frames @ 100 fps: E4: h2+4units>h(f)=h1+2.6825 units/f*f-0.5*8units/f^2*f^2>h2

-> Illustration: h1 = height (jump off), h2 = height (landing), t = time, f = frames
-> t is quant sized by the engine into (1/fps) seconds

If the fps are not constant you have to use this equation:

E5: 400/sqrt(71958.0625+1600*hd)

-> Illustration: sqrt = square root, hd = height difference
-> E5 must be scaled with the fps of the frame in which you re doing the bug to get the correct probability: E5*(fps/100)


A little attachment

Last but not least: Here is a little demo with a Jump-bug that might help you to understand and learn the technique: Download it


Thanks

Big thanks fly out to:

eDark for calculating and explaining all this.
All the “pioneers” who did the jump-bug in game and especially tjubby, for posting the demo on the forums a long time ago and getting this technique some attention, and Pulsar of course, who recorded the demo for this guide.
And a big big thanks to angie for helping me correcting this article

[ 本帖最后由 SiMen.0027`` 于 2007-11-26 04:01 编辑 ]

whhwkx5988

这么快就翻译好拉?

SiMen.0027``

要命

whhwkx5988

SiMen.0027``
据说我很厚脸皮。。

SiMen.beambean

技术性文章，能不能看明白靠大家悟性了

whhwkx5988

怎么可以这样
我太笨怎么办!!!!!!!

SiMen.Tf.y@Ng

beambean我爱你！

SiMen.0027``

我也看不懂

SiMen.beambean

看不懂？我简单说下，就是落下时按着蹲，在离地面4个单位距离时，同时按跳和松开蹲。

whhwkx5988

在离地面4个单位距离时，同时按跳和松开蹲
4个单位 谁又知道呢..