avm2: Implement Math methods in Number

Author: jarca0123

core/src/avm2/globals/Number.as

@@ -36,6 +36,82 @@ package {
         [API("680")]
         public static const LOG10E:Number = 0.4342944819032518;
 
+        // This is a hacky way to specify `-Infinity` as a default value.
+        private static const NegInfinity: Number = -1 / 0;
+        private static const PosInfinity: Number = 1 / 0;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function abs(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function acos(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function asin(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function atan(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function atan2(y:Number, x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function ceil(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function cos(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function exp(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function floor(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function log(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function max(x:Number = NegInfinity, y:Number = NegInfinity, ...rest):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function min(x:Number = PosInfinity, y:Number = PosInfinity, ...rest):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function pow(x:Number, y:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function random():Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function round(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function sin(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function sqrt(x:Number):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function tan(x:Number):Number;
+
         {
             prototype.toExponential = function(digits:* = 0):String {
                 var self:Number = this;

core/src/avm2/globals/math.rs

@@ -5,6 +5,7 @@ use crate::avm2::error::type_error;
 use crate::avm2::object::Object;
 use crate::avm2::value::Value;
 use crate::avm2::{ClassObject, Error};
+use num_traits::ToPrimitive;
 use rand::Rng;
 
 macro_rules! wrap_std {
@@ -20,14 +21,11 @@ macro_rules! wrap_std {
     };
 }
 
-wrap_std!(abs, f64::abs);
 wrap_std!(acos, f64::acos);
 wrap_std!(asin, f64::asin);
 wrap_std!(atan, f64::atan);
-wrap_std!(ceil, f64::ceil);
 wrap_std!(cos, f64::cos);
 wrap_std!(exp, f64::exp);
-wrap_std!(floor, f64::floor);
 wrap_std!(log, f64::ln);
 wrap_std!(sin, f64::sin);
 wrap_std!(sqrt, f64::sqrt);
@@ -66,7 +64,10 @@ pub fn round<'gc>(
     // Note that Flash Math.round always rounds toward infinity,
     // unlike Rust f32::round which rounds away from zero.
     let ret = (x + 0.5).floor();
-    Ok(ret.into())
+    match ret.to_i32() {
+        Some(num) => Ok(Value::Integer(num)),
+        None => Ok(Value::Number(ret)),
+    }
 }
 
 pub fn atan2<'gc>(
@@ -90,7 +91,9 @@ pub fn max<'gc>(
         let val = arg.coerce_to_number(activation)?;
         if val.is_nan() {
             return Ok(f64::NAN.into());
-        } else if val > cur_max {
+        } else if val > cur_max
+            || (val == cur_max && !val.is_sign_negative() && cur_max.is_sign_negative())
+        {
             cur_max = val;
         };
     }
@@ -107,20 +110,44 @@ pub fn min<'gc>(
         let val = arg.coerce_to_number(activation)?;
         if val.is_nan() {
             return Ok(f64::NAN.into());
-        } else if val < cur_min {
+        } else if val < cur_min
+            || (val == cur_min && val.is_sign_negative() && !cur_min.is_sign_negative())
+        {
             cur_min = val;
         }
     }
     Ok(cur_min.into())
 }
 
 pub fn pow<'gc>(
-    _activation: &mut Activation<'_, 'gc>,
+    activation: &mut Activation<'_, 'gc>,
     _this: Value<'gc>,
     args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error<'gc>> {
-    let n = args[0].as_f64();
-    let p = args[1].as_f64();
+    let n = args[0].coerce_to_number(activation)?;
+    let p = args[1].coerce_to_number(activation)?;
+
+    // If y is NaN, the result is NaN.
+    if p.is_nan() {
+        return Ok(f64::NAN.into());
+    }
+
+    // Special case: If x is ±1 and y is ±Infinity, the result is NaN.
+    if (n == 1.0 || n == -1.0) && p.is_infinite() {
+        return Ok(f64::NAN.into());
+    }
+
+    // Special case: If x is -Infinity and y<0 and y is an even integer, Flash Player returns -0.
+    if n == f64::NEG_INFINITY && p < 0.0 && p.is_finite() {
+        // Check if p is an integer
+        if p.fract() == 0.0 {
+            let p_int = p as i64;
+            if p_int % 2 == 0 {
+                // y is a negative even integer, Flash Player returns -0
+                return Ok(Value::Number(-0.0));
+            }
+        }
+    }
 
     Ok(f64::powf(n, p).into())
 }
@@ -136,3 +163,65 @@ pub fn random<'gc>(
     let rand = activation.context.rng.random_range(0..MAX_VAL);
     Ok(((rand as f64) / (MAX_VAL as f64 + 1f64)).into())
 }
+
+pub fn abs<'gc>(
+    _activation: &mut Activation<'_, 'gc>,
+    _this: Value<'gc>,
+    args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    let input = args[0];
+    match input {
+        Value::Integer(i) => Ok(i.abs().into()),
+        Value::Number(-0.0) => Ok(Value::Integer(0)),
+        _ => Ok(f64::abs(input.as_f64()).into()),
+    }
+}
+
+pub fn ceil<'gc>(
+    _activation: &mut Activation<'_, 'gc>,
+    _this: Value<'gc>,
+    args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    let input = args[0];
+    let num = input.as_f64();
+
+    if num.is_nan() {
+        Ok(Value::Number(f64::NAN))
+    } else if num.is_infinite() {
+        Ok(Value::Number(num))
+    } else {
+        let ceiled = num.ceil();
+        // Special case: if input was negative and ceil result is 0, preserve -0.0
+        if ceiled == 0.0 && num.is_sign_negative() {
+            Ok(Value::Number(-0.0))
+        } else if ceiled >= i32::MIN as f64 && ceiled <= i32::MAX as f64 {
+            Ok(Value::Integer(ceiled as i32))
+        } else {
+            Ok(Value::Number(ceiled))
+        }
+    }
+}
+
+pub fn floor<'gc>(
+    _activation: &mut Activation<'_, 'gc>,
+    _this: Value<'gc>,
+    args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    let input = args[0];
+    let num = input.as_f64();
+
+    if num.is_nan() {
+        Ok(Value::Number(f64::NAN))
+    } else if num.is_infinite() {
+        Ok(Value::Number(num))
+    } else if num == 0.0 && num.is_sign_negative() {
+        Ok(Value::Number(-0.0))
+    } else {
+        let floored = num.floor();
+        if floored >= i32::MIN as f64 && floored <= i32::MAX as f64 {
+            Ok(Value::Integer(floored as i32))
+        } else {
+            Ok(Value::Number(floored))
+        }
+    }
+}

core/src/avm2/globals/number.rs

@@ -7,6 +7,8 @@ use crate::avm2::value::Value;
 use crate::avm2::{AvmString, Error};
 use ruffle_macros::istr;
 
+use crate::avm2::globals::math;
+
 pub fn number_constructor<'gc>(
     activation: &mut Activation<'_, 'gc>,
     args: &[Value<'gc>],
@@ -33,6 +35,25 @@ pub fn call_handler<'gc>(
         .into())
 }
 
+macro_rules! define_math_functions {
+    ($($name:ident),* $(,)?) => {
+        $(
+            pub fn $name<'gc>(
+                activation: &mut Activation<'_, 'gc>,
+                this: Value<'gc>,
+                args: &[Value<'gc>],
+            ) -> Result<Value<'gc>, Error<'gc>> {
+                math::$name(activation, this, args)
+            }
+        )*
+    };
+}
+
+define_math_functions!(
+    abs, acos, asin, atan, atan2, ceil, cos, exp, floor, log, max, min, pow, random, round, sin,
+    sqrt, tan
+);
+
 /// Implements `Number.toExponential`
 pub fn to_exponential<'gc>(
     activation: &mut Activation<'_, 'gc>,

tests/tests/swfs/from_avmplus/as3/Types/Number/abs/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

tests/tests/swfs/from_avmplus/as3/Types/Number/acos/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

tests/tests/swfs/from_avmplus/as3/Types/Number/asin/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

tests/tests/swfs/from_avmplus/as3/Types/Number/atan/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

tests/tests/swfs/from_avmplus/as3/Types/Number/atan2/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

tests/tests/swfs/from_avmplus/as3/Types/Number/ceil/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

tests/tests/swfs/from_avmplus/as3/Types/Number/exp/test.toml

@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true