avm2: Implement Math methods in Number

core/src/avm2/globals/Number.as

@@ -36,6 +36,78 @@ package {
         [API("680")]
         public static const LOG10E:Number = 0.4342944819032518;
 
+        [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 = NEGATIVE_INFINITY, y:Number = NEGATIVE_INFINITY, ...rest):Number;
+
+        [API("680")]
+        [Ruffle(FastCall)]
+        public static native function min(x:Number = POSITIVE_INFINITY, y:Number = POSITIVE_INFINITY, ...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,7 +110,9 @@ 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;
         }
     }
@@ -121,8 +126,16 @@ pub fn pow<'gc>(
 ) -> Result<Value<'gc>, Error<'gc>> {
     let n = args[0].as_f64();
     let p = args[1].as_f64();
-
-    Ok(f64::powf(n, p).into())
+    match (n, p) {
+        (_, _) if p.is_nan() => Ok(f64::NAN.into()),
+        // Special case: If p is ±Infinity and n is ±1, the result is NaN.
+        (1.0, _) | (-1.0, _) if p.is_infinite() => Ok(f64::NAN.into()),
+        // Special case: If n is -Infinity and p < 0 and p is a negative even integer, Flash Player returns -0.
+        (f64::NEG_INFINITY, _) if p.to_i64().is_some_and(|i| i % 2 == 0 && i < 0) => {
+            Ok(Value::Number(-0.0))
+        }
+        (_, _) => Ok(f64::powf(n, p).into()),
+    }
 }
 
 pub fn random<'gc>(
@@ -136,3 +149,64 @@ 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].as_f64();
+
+    if input.is_nan() {
+        Ok(Value::Number(f64::NAN))
+    } else if input.is_infinite() {
+        Ok(Value::Number(input))
+    } else {
+        let ceiled = input.ceil();
+        // Special case: if input was negative and ceil result is 0, preserve -0.0
+        if ceiled == 0.0 && input.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/Math/e15_8_2_11_rest/test.toml

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

tests/tests/swfs/from_avmplus/as3/Math/e15_8_2_12_rest/test.toml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tests/tests/swfs/from_avmplus/regress/bug_551587/test.toml

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