|
FULL EDITED POST
Do you feel struggle while aiming? well, not your fault.
This is a factual aspect
For those who have doubts about this command, m_pitch is responsible for the vertical sensitivity speed in the game, as m_yaw is responsible for the horizontal. Both combined determine the sensitivity speed factor.
This command has become protected to prevent abuses in the changing of the values, that caused the servers to crash; And for example in CS:S, If you trigger this on your mouse1 while shooting in, it gives lesser recoil. These are the reasons for the command to be locked.
Taking this into account, these are the following settings m_pitch and m_yaw
"m_yaw" = "0.022"
"m_pitch" = "0.022000" ( def. "0.022" )
People have complained that 0.022000 is different from 0.022
0.022000 which is slightly faster than 0.022
The default value is 0.022, but its locked to 0.022000
Therefore, assuming there is some configuration error
Ok,
Lets convert them:
Decimal Representation - 0.022
Binary Representation - 00111100101101000011100101011000
Hexadecimal Representation - 0x3cb43958
After casting to double precision - 0.02199999988079071
Decimal Representation - 0.022000
Binary Representation - 00111100101101000011100101011000
Hexadecimal Representation - 0x3cb43958
After casting to double precision - 0.02199999988079071
They have equal 32-bit representation values so it is not how they are written in Source Code
So,
where you can find these commands? in a configuration file (a text that game loads) (config.cfg), Wich goes through a different code logic;
Then that means "0.022000" and "0.022" are text that Valve's Code has to read and interpret. It's perfectly possible that Valve's code has a bug in it, when interpreting from the text symbols "0.022000" to the actual number "0.022" ,so the problem might be in fact text-to-float conversion function.
Is this really an issue? Yes, the difference is small but is related to sensitivity which is crucial. This directly affects your ingame performance when it comes to aiming accucary.
brief explanation:
https://i.imgsafe.org/8d2bd74174.png
Console: https://i.imgsafe.org/8d29bc53f9.pn
From 2000 to 2012, CS 1.6
m_pitch 0.022
m_yaw 0.022
From 2004-2012, CS:Source
m_pitch 0.022
m_yaw 0.022
CS:GO
m_pitch 0.022000
m_yaw 0.022
If someone can please check it in runtime, please step foward.
|
What are you saying here? I don't understand the purpose of this thread.
Are you saying not to change these two settings on console?
|
No, I'm saying that the current sensitivity in CS:GO is not being calculated correctly , it means that you can even feel comfortable with your sensitivity but would have better accuracy with it corrected.
The current yaw and pitch values are out of sync;
For this, Valve need to correct the current value of m_pitch which is a protected command, we can not change it, only if sv_cheats 1.
|
France9034 Posts
Source Engine is written in CC++ Language, Depending on compiler and the settings made at compile time (fast float compiling) will determine how precise values are.
If written 0.0220000 then it may be 0.0220096 or something for example.
If written 0.022 then it can only be 0.022.
This is entirely and completely false.
Look for the IEEE754 standard which defines how floating point works (and which is the representation used by all the C++ compilers out there, though the standard specifies that it's up to them), and then come back and show me how the binary representations differ for "0.022" and "0.022000".
Hint: they don't.
Too lazy to check this but I'd bet any sane C++ compiler out there (be it Clang, gcc or even VC++) would just trim the 0 anyway beforehand (when it actually remove space, comments, etc. from a translation unit) in such cases at compile time (and even without aggressive optimization flags set up).
The two values are out of sync visually, but that's it.
EDIT: Here's a working code that shows you that, live on Coliru.
|
|
|
France9034 Posts
I think you missed my example where the code actually outputs the binary representations that are identical.
And saying "they are not necessary the same" shows a profound misunderstanding of floats and the IEEE754, which is determinist. That doesn't mean that 0.022 has an exact representation, but it will always be rounded to the same one (otherwise, we would have a VERY big problem with floats, as if there wasn't already traps with the most used representation).
Just linking one of the most well known guides about floating points doesn't magically make your argument right. There's nothing about extra 0s in there.
|
Yes, they are identical
so you are saying that
0.022 + 0.022000 = 0.022000
and not
0.022 + 0.022000 = 0.0220096 or something
I must explain this
ingame they act different when 0.022000 is set
if both set to 0.022 vertical and horizontal sensitivity is precise
if one set to 0.022 and other to 0.022000 sensitivity is precise but not as much as values above;
0.022 + 0.022000 somehow it is not as accurate as 0.022 + 0.022
checking in earlier versions of the counter-strike m_yaw and m_pitch values it appears that both are 0.022 since all time
It is something related to the engine and the way it handles these settings compile + hardware + outputs
which causes this to happen
I just did the physical testing and research, I have no concrete evidence to show how both are different .
You know somehow it is possible to test both values and prove that work differently ?
|
Unless there is a serious bug in their config parser's floating point value parsing, you are going to have the same representations for 0.022 and 0.022000.
The IEEE754 standard absolutely does not treat those constants any differently. Rounding and precision are (in this case) only going to rely on the underlying float type they chose.
|
France9034 Posts
What I'm actually saying is, if there's a difference, or whatever, this paragraph:
Source Engine is written in CC++ Language, Depending on compiler and the settings made at compile time (fast float compiling) will determine how precise values are.
If written 0.0220000 then it may be 0.0220096 or something for example.
If written 0.022 then it can only be 0.022.
is just dead wrong, whatever the context.
Any actual difference if provably existing must be explained differently, because this is not how it could happen.
It actually makes your title
(This happens because of: Floating-Point Arithmetic Calculations)
completely wrong as well.
|
[B] ingame they act different when 0.022000 is set
if both set to 0.022 vertical and horizontal sensitivity is precise
if one set to 0.022 and other to 0.022000 sensitivity is precise but not as much as values above;
0.022 + 0.022000 somehow it is not as accurate as 0.022
checking in earlier versions of the counter-strike m_yaw and m_pitch values it appears that both are 0.022 since all time
It is something related to the engine and the way it handles these settings compile + hardware + outputs
which causes this to happen
I just did the physical testing and research, I have no concrete evidence to show how both are different .
You know somehow it is possible to test both values and prove that work differently ?
I thinkyou missed my last post, so assuming that this is incorrect , what are the alternatives to this?
which may be the source of
0022 + 0.022000
be diferent from
0.022 + 0.022
in terms of accuracy / sensitivity
memory?
outputs?
|
How do you know there is a demonstrable difference?
Your video doesn't show anything measurable.
It also has a bunch of misleading and/or wrong comments on floating point values and how they are interpreted. (Ex: those two values aren't going to be 16bit vs 32bit floats since the type they get parsed into isn't changing.)
|
France9034 Posts
On July 22 2016 05:53 weqn wrote:Show nested quote +[B] ingame they act different when 0.022000 is set
if both set to 0.022 vertical and horizontal sensitivity is precise
if one set to 0.022 and other to 0.022000 sensitivity is precise but not as much as values above;
0.022 + 0.022000 somehow it is not as accurate as 0.022
checking in earlier versions of the counter-strike m_yaw and m_pitch values it appears that both are 0.022 since all time
It is something related to the engine and the way it handles these settings compile + hardware + outputs
which causes this to happen
I just did the physical testing and research, I have no concrete evidence to show how both are different .
You know somehow it is possible to test both values and prove that work differently ?
I thinkyou missed my last post, so assuming that this is incorrect , what are the alternatives to this? which may be the source of 0022 + 0.022000 be diferent from 0.022 + 0.022 in terms of accuracy / sensitivity memory? outputs?
That you haven't thought of another explanation doesn't make this one valid automatically.
Also, I think this has been too long already, tapping out.
|
On July 22 2016 06:00 PunitiveDamages wrote:
How do you know there is a demonstrable difference?
Because the difference its noticeable ingame, not just me to notice but also many other people wich shared this with
|
On July 22 2016 06:42 weqn wrote:Show nested quote +On July 22 2016 06:00 PunitiveDamages wrote:
How do you know there is a demonstrable difference?
Because the difference its noticeable ingame, not just me to notice but also many other people wich shared this with
Unfortunately without a quantitative difference that you can measure, its going to be impossible to figure out if there is an actual difference in behavior.
And without that you can't find a source for the difference in behavior.
I'll echo again everything Ragnarork said; there is no difference between 0.022 and 0.022000 as far as floating point is concerned. If there is a real effect, it is not being caused by rounding or precision effects of floating point.
|
On July 22 2016 06:25 Ragnarork wrote:Show nested quote +On July 22 2016 05:53 weqn wrote:[B] ingame they act different when 0.022000 is set
if both set to 0.022 vertical and horizontal sensitivity is precise
if one set to 0.022 and other to 0.022000 sensitivity is precise but not as much as values above;
0.022 + 0.022000 somehow it is not as accurate as 0.022
checking in earlier versions of the counter-strike m_yaw and m_pitch values it appears that both are 0.022 since all time
It is something related to the engine and the way it handles these settings compile + hardware + outputs
which causes this to happen
I just did the physical testing and research, I have no concrete evidence to show how both are different .
You know somehow it is possible to test both values and prove that work differently ?
I thinkyou missed my last post, so assuming that this is incorrect , what are the alternatives to this? which may be the source of 0022 + 0.022000 be diferent from 0.022 + 0.022 in terms of accuracy / sensitivity memory? outputs? That you haven't thought of another explanation doesn't make this one valid automatically. Also, I think this has been too long already, tapping out.
please dont take as an offense but you are not helping... i asked if it is possible to test both values and prove that both setups work differently ?
|
On July 22 2016 06:47 PunitiveDamages wrote:Show nested quote +On July 22 2016 06:42 weqn wrote:On July 22 2016 06:00 PunitiveDamages wrote:
How do you know there is a demonstrable difference?
Because the difference its noticeable ingame, not just me to notice but also many other people wich shared this with Unfortunately without a quantitative difference that you can measure, its going to be impossible to figure out if there is an actual difference in behavior. And without that you can't find a source for the difference in behavior. I'll echo again everything Ragnarork said; there is no difference between 0.022 and 0.022000 as far as floating point is concerned. If there is a real effect, it is not being caused by rounding or precision effects of floating point.
Ok there is no difference in floats, numbers, values everything is precise.
both setups are precise
but 0.022
feels so much better to control;
feels so much precise;
looking into previous versions of counter-strike all versions had it 0.022 + 0.022, and not 0.022 + 0.022000 like CS:GO
theres got to be something with the engine/coding some bug i dont know what it can be ( you just made my mind clear about the floats)
i want to prove it, how can i prove both values? any programs or macros that would help figuring this out?
i would lost my time and other people time if i didn't had 100% about what im trying to say
|
On July 22 2016 07:01 weqn wrote:Show nested quote +On July 22 2016 06:47 PunitiveDamages wrote:On July 22 2016 06:42 weqn wrote:On July 22 2016 06:00 PunitiveDamages wrote:
How do you know there is a demonstrable difference?
Because the difference its noticeable ingame, not just me to notice but also many other people wich shared this with Unfortunately without a quantitative difference that you can measure, its going to be impossible to figure out if there is an actual difference in behavior. And without that you can't find a source for the difference in behavior. I'll echo again everything Ragnarork said; there is no difference between 0.022 and 0.022000 as far as floating point is concerned. If there is a real effect, it is not being caused by rounding or precision effects of floating point. Ok there is no difference in floats, numbers, values everything is precise. both setups are precise but 0.022 feels so much better to control; feels so much precise; looking into previous versions of counter-strike all versions had it 0.022 + 0.022, and not 0.022 + 0.022000 like CS:GO theres got to be something with the engine/coding some bug i dont know what it can be ( you just made my mind clear about the floats) i want to prove it, how can i prove both values? any programs ou macros that would help figuring this out? i would lost my time and other people time if i didn't had 100% about what im trying to say
The only option I can think of would be to:
- Hook the CS:GO mouse input (obviously this is possible, since various hacks can spoof mouse inputs)
- Send a specific mouse movement (you can't do this manually or with a physical mouse)
- Record the results with different settings (0.022 and 0.022000) from the same starting point.
Then examine the recordings to see if the ingame crosshair movement is any different. If there isn't a difference then its not a real effect. If there is, then you've found a bug in how CS:GO handles mouse movements.
Good luck.
|
how do i set input mouse?
im not a programmer, is there some sort of program?
|
can you please help me on that?
i have no ideia how to do it, i tryed macros but they dont work i had to move the mouse
please help me
|
|
|
|
|
|
|
|
EPT
