sfml3-rb 0.2.2 → 0.3.0

data/ext/system/time.c

@@ -12,40 +12,61 @@ typedef struct {
 
 static VALUE rb_cSFTime;
 
-static void Time_free(void *ptr) {
+static void Time_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t Time_data_type = {
     .wrap_struct_name = "SFML::Time",
     .function = {.dmark = NULL, .dfree = Time_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
 static VALUE Time_wrap(sfTime time) {
-    Time *ptr = malloc(sizeof(Time));
+    Time* ptr = malloc(sizeof(Time));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate time");
+    }
 
     ptr->time = time;
 
     return TypedData_Wrap_Struct(rb_cSFTime, &Time_data_type, ptr);
 }
 
-static VALUE Time_new(int argc, VALUE *argv, VALUE klass) {
+/* call-seq:
+ *   Time.new             -> Time(0)
+ *   Time.new(seconds)    -> Time
+ *   Time.new(microseconds_integer) -> Time
+ *   Time.new(other_time) -> copy of +other_time+
+ *
+ * A Float argument is interpreted as seconds; an Integer argument is
+ * interpreted as microseconds. Prefer .seconds/.milliseconds/.microseconds
+ * to be explicit.
+ *
+ * @return [Time]
+ * @raise [ArgumentError] if given more than one argument
+ */
+static VALUE Time_new(int argc, VALUE* argv, VALUE klass) {
     VALUE self;
-    Time *ptr;
+    Time* ptr;
     sfTime time = sfTime_Zero;
 
     if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cSFTime)) {
-        time = ((Time *) Get_Time_Struct(argv[0]))->time;
+        time = ((Time*)Get_Time_Struct(argv[0]))->time;
     } else if (argc == 1 && RB_INTEGER_TYPE_P(argv[0])) {
-        time = sfMicroseconds((int64_t) NUM2LL(argv[0]));
+        time = sfMicroseconds((int64_t)NUM2LL(argv[0]));
     } else if (argc == 1) {
-        time = sfSeconds((float) NUM2DBL(argv[0]));
+        time = sfSeconds((float)NUM2DBL(argv[0]));
     } else if (argc != 0) {
         raise_invalid_arguments_excepted(1, argc);
     }
 
     ptr = malloc(sizeof(Time));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate time");
+    }
+
     ptr->time = time;
 
     self = TypedData_Wrap_Struct(klass, &Time_data_type, ptr);
@@ -53,80 +74,176 @@ static VALUE Time_new(int argc, VALUE *argv, VALUE klass) {
     return self;
 }
 
+/* call-seq:
+ *   Time.seconds(value) -> Time
+ *
+ * Creates a Time of +value+ seconds, where +value+ is any Float-convertible
+ * number.
+ *
+ * @return [Time]
+ */
 static VALUE Time_seconds(VALUE klass, VALUE rb_seconds) {
-    return Time_wrap(sfSeconds((float) NUM2DBL(rb_seconds)));
+    return Time_wrap(sfSeconds((float)NUM2DBL(rb_seconds)));
 }
 
+/* call-seq:
+ *   Time.milliseconds(value) -> Time
+ *
+ * Creates a Time of +value+ milliseconds.
+ *
+ * @return [Time]
+ */
 static VALUE Time_milliseconds(VALUE klass, VALUE rb_milliseconds) {
-    return Time_wrap(sfMilliseconds((int32_t) NUM2INT(rb_milliseconds)));
+    return Time_wrap(sfMilliseconds((int32_t)NUM2INT(rb_milliseconds)));
 }
 
+/* call-seq:
+ *   Time.microseconds(value) -> Time
+ *
+ * Creates a Time of +value+ microseconds.
+ *
+ * @return [Time]
+ */
 static VALUE Time_microseconds(VALUE klass, VALUE rb_microseconds) {
-    return Time_wrap(sfMicroseconds((int64_t) NUM2LL(rb_microseconds)));
+    return Time_wrap(sfMicroseconds((int64_t)NUM2LL(rb_microseconds)));
 }
 
+/* call-seq:
+ *   Time.zero -> Time
+ *
+ * Returns the zero-duration Time.
+ *
+ * @return [Time] a zero-duration Time
+ */
 static VALUE Time_zero(VALUE klass) {
     return Time_wrap(sfTime_Zero);
 }
 
+/* call-seq: as_seconds -> Float
+ *
+ * Returns the duration expressed in seconds.
+ *
+ * @return [Float]
+ */
 static VALUE Time_as_seconds(VALUE self) {
-    return DBL2NUM(sfTime_asSeconds(((Time *) Get_Time_Struct(self))->time));
+    return DBL2NUM(sfTime_asSeconds(((Time*)Get_Time_Struct(self))->time));
 }
 
+/* call-seq: as_milliseconds -> Integer
+ *
+ * Returns the duration expressed in whole milliseconds.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_as_milliseconds(VALUE self) {
-    return INT2NUM(sfTime_asMilliseconds(((Time *) Get_Time_Struct(self))->time));
+    return INT2NUM(sfTime_asMilliseconds(((Time*)Get_Time_Struct(self))->time));
 }
 
+/* call-seq: as_microseconds -> Integer
+ *
+ * Returns the duration expressed in whole microseconds.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_as_microseconds(VALUE self) {
-    return LL2NUM(sfTime_asMicroseconds(((Time *) Get_Time_Struct(self))->time));
+    return LL2NUM(sfTime_asMicroseconds(((Time*)Get_Time_Struct(self))->time));
 }
 
+/* call-seq: to_f -> Float
+ *
+ * Alias for #as_seconds.
+ *
+ * @return [Float]
+ */
 static VALUE Time_to_f(VALUE self) {
     return Time_as_seconds(self);
 }
 
+/* call-seq: to_i -> Integer
+ *
+ * Alias for #as_microseconds.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_to_i(VALUE self) {
     return Time_as_microseconds(self);
 }
 
+/* call-seq:
+ *   self + other -> Time
+ *
+ * Adds +other+ to the duration, returning a new Time.
+ *
+ * @return [Time]
+ */
 static VALUE Time_add(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
     sfTime b = time_from_rb(rb_other);
 
     return Time_wrap(sfMicroseconds(sfTime_asMicroseconds(a) + sfTime_asMicroseconds(b)));
 }
 
+/* call-seq:
+ *   self - other -> Time
+ *
+ * Subtracts +other+ from the duration, returning a new Time.
+ *
+ * @return [Time]
+ */
 static VALUE Time_sub(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
     sfTime b = time_from_rb(rb_other);
 
     return Time_wrap(sfMicroseconds(sfTime_asMicroseconds(a) - sfTime_asMicroseconds(b)));
 }
 
+/* call-seq:
+ *   self * scalar -> Time
+ *
+ * Scales the duration by +scalar+, returning a new Time.
+ *
+ * @return [Time]
+ */
 static VALUE Time_mul(VALUE self, VALUE rb_scalar) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
 
-    return Time_wrap(sfMicroseconds((int64_t) (sfTime_asMicroseconds(a) * NUM2DBL(rb_scalar))));
+    return Time_wrap(sfMicroseconds((int64_t)(sfTime_asMicroseconds(a) * NUM2DBL(rb_scalar))));
 }
 
+/* call-seq:
+ *   self / other -> Time or Float
+ *
+ * Dividing by a Time returns the (unitless) ratio of the two durations as a
+ * Float; dividing by a Number scales the duration.
+ *
+ * @return [Time, Float]
+ * @raise [ZeroDivError] if dividing by a zero Time
+ */
 static VALUE Time_div(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
 
     if (rb_obj_is_kind_of(rb_other, rb_cSFTime)) {
-        int64_t b = sfTime_asMicroseconds(((Time *) Get_Time_Struct(rb_other))->time);
+        int64_t b = sfTime_asMicroseconds(((Time*)Get_Time_Struct(rb_other))->time);
 
         if (b == 0) {
             rb_raise(rb_eZeroDivError, "divided by 0");
         }
 
-        return DBL2NUM((double) sfTime_asMicroseconds(a) / (double) b);
+        return DBL2NUM((double)sfTime_asMicroseconds(a) / (double)b);
     }
 
-    return Time_wrap(sfMicroseconds((int64_t) (sfTime_asMicroseconds(a) / NUM2DBL(rb_other))));
+    return Time_wrap(sfMicroseconds((int64_t)(sfTime_asMicroseconds(a) / NUM2DBL(rb_other))));
 }
 
+/* call-seq:
+ *   self <=> other -> -1, 0 or 1
+ *
+ * Compares the duration with +other+, which may be a Time or a number.
+ *
+ * @return [Integer]
+ */
 static VALUE Time_cmp(VALUE self, VALUE rb_other) {
-    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime a = ((Time*)Get_Time_Struct(self))->time;
     sfTime b = time_from_rb(rb_other);
     int64_t micro_a = sfTime_asMicroseconds(a);
     int64_t micro_b = sfTime_asMicroseconds(b);
@@ -142,25 +259,46 @@ static VALUE Time_cmp(VALUE self, VALUE rb_other) {
     return INT2NUM(0);
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * Returns +true+ if +other+ is a Time holding the same duration.
+ *
+ * @return [Boolean]
+ */
 static VALUE Time_eql(VALUE self, VALUE rb_other) {
     if (!rb_obj_is_kind_of(rb_other, rb_cSFTime)) {
         return Qfalse;
     }
 
-    return BOOL2RB(sfTime_asMicroseconds(((Time *) Get_Time_Struct(self))->time) ==
-                   sfTime_asMicroseconds(((Time *) Get_Time_Struct(rb_other))->time));
+    return BOOL2RB(sfTime_asMicroseconds(((Time*)Get_Time_Struct(self))->time) ==
+                   sfTime_asMicroseconds(((Time*)Get_Time_Struct(rb_other))->time));
 }
 
+/* call-seq: to_s -> String
+ *
+ * Returns the duration formatted as a number of seconds.
+ *
+ * @return [String] +"N s"+, e.g. +"1.5 s"+
+ */
 static VALUE Time_to_s(VALUE self) {
     char buffer[64];
 
-    snprintf(buffer, sizeof(buffer), "%g s", sfTime_asSeconds(((Time *) Get_Time_Struct(self))->time));
+    snprintf(buffer, sizeof(buffer), "%g s",
+             sfTime_asSeconds(((Time*)Get_Time_Struct(self))->time));
 
     return rb_str_new2(buffer);
 }
 
-void Init_Time(VALUE rb_module) {
-    rb_cSFTime = rb_define_class_under(rb_module, "Time", rb_cObject);
+/* Document-class: SFML::Time
+ * A time duration, with microsecond precision internally. Used throughout
+ * the library wherever a duration or timestamp is needed (Clock#elapsed_time,
+ * SoundSource#playing_offset, sleep, animation timers, ...).
+ *
+ * Includes +Comparable+.
+ */
+void Init_Time(VALUE rb_mSFML) {
+    rb_cSFTime = rb_define_class_under(rb_mSFML, "Time", rb_cObject);
 
     rb_include_module(rb_cSFTime, rb_mComparable);
 
@@ -189,23 +327,23 @@ VALUE Get_Klass_Time(void) {
     return rb_cSFTime;
 }
 
-void *Get_Time_Struct(VALUE self) {
-    Time *ptr;
+void* Get_Time_Struct(VALUE self) {
+    Time* ptr;
     TypedData_Get_Struct(self, Time, &Time_data_type, ptr);
     return ptr;
 }
 
 sfTime time_from_rb(VALUE rb_time) {
     if (rb_obj_is_kind_of(rb_time, rb_cSFTime)) {
-        return ((Time *) Get_Time_Struct(rb_time))->time;
+        return ((Time*)Get_Time_Struct(rb_time))->time;
     }
 
     if (RB_INTEGER_TYPE_P(rb_time)) {
-        return sfMicroseconds((int64_t) NUM2LL(rb_time));
+        return sfMicroseconds((int64_t)NUM2LL(rb_time));
     }
 
     if (RB_FLOAT_TYPE_P(rb_time) || RB_TYPE_P(rb_time, T_RATIONAL)) {
-        return sfSeconds((float) NUM2DBL(rb_time));
+        return sfSeconds((float)NUM2DBL(rb_time));
     }
 
     raise_invalid_argument_class(rb_cSFTime);

data/ext/system/vec2.c

@@ -13,19 +13,31 @@ typedef struct {
 
 static VALUE rb_cVector2;
 
-static void Vector2_free(void *ptr) {
+static void Vector2_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t Vector2_data_type = {
     .wrap_struct_name = "SFML::Vector2",
     .function = {.dmark = NULL, .dfree = Vector2_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
-
-static VALUE Vector2_new(int argc, VALUE *argv, VALUE klass) {
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+/* call-seq:
+ *   Vector2.new                -> Vector2(0, 0)
+ *   Vector2.new(x, y)          -> Vector2(x, y)
+ *   Vector2.new([x, y])        -> Vector2(x, y)
+ *   Vector2.new(other_vector2) -> copy of +other_vector2+
+ *
+ * Creates a new 2D vector from two coordinates, a 2-element Array, or
+ * another Vector2.
+ *
+ * @return [Vector2]
+ * @raise [ArgumentError] if given an Array shorter than 2 elements, or an
+ *   argument count other than 0, 1 or 2
+ */
+static VALUE Vector2_new(int argc, VALUE* argv, VALUE klass) {
     VALUE self;
-    Vector2 *ptr;
+    Vector2* ptr;
     float x = 0;
     float y = 0;
 
@@ -48,6 +60,11 @@ static VALUE Vector2_new(int argc, VALUE *argv, VALUE klass) {
     }
 
     ptr = malloc(sizeof(Vector2));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vector");
+    }
+
     ptr->vec.x = x;
     ptr->vec.y = y;
 
@@ -56,32 +73,70 @@ static VALUE Vector2_new(int argc, VALUE *argv, VALUE klass) {
     return self;
 }
 
+/* call-seq: x -> Float
+ *
+ * Returns the X component of the vector.
+ *
+ * @return [Float] the X component
+ */
 static VALUE Vector2_get_x(VALUE self) {
-    return DBL2NUM(((Vector2 *) Get_Vector2_Struct(self))->vec.x);
+    return DBL2NUM(((Vector2*)Get_Vector2_Struct(self))->vec.x);
 }
 
+/* call-seq: y -> Float
+ *
+ * Returns the Y component of the vector.
+ *
+ * @return [Float] the Y component
+ */
 static VALUE Vector2_get_y(VALUE self) {
-    return DBL2NUM(((Vector2 *) Get_Vector2_Struct(self))->vec.y);
+    return DBL2NUM(((Vector2*)Get_Vector2_Struct(self))->vec.y);
 }
 
+/* call-seq:
+ *   x=(value) -> Float
+ *
+ * Sets the X component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector2_set_x(VALUE self, VALUE rb_x) {
-    ((Vector2 *) Get_Vector2_Struct(self))->vec.x = NUM2DBL(rb_x);
+    ((Vector2*)Get_Vector2_Struct(self))->vec.x = NUM2DBL(rb_x);
     return rb_x;
 }
 
+/* call-seq:
+ *   y=(value) -> Float
+ *
+ * Sets the Y component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector2_set_y(VALUE self, VALUE rb_y) {
-    ((Vector2 *) Get_Vector2_Struct(self))->vec.y = NUM2DBL(rb_y);
+    ((Vector2*)Get_Vector2_Struct(self))->vec.y = NUM2DBL(rb_y);
     return rb_y;
 }
 
+/* call-seq: to_a -> [Float, Float]
+ *
+ * Returns the vector's components as a two-element Array.
+ *
+ * @return [Array<Float>] +[x, y]+
+ */
 static VALUE Vector2_to_a(VALUE self) {
-    Vector2 *vec = Get_Vector2_Struct(self);
+    Vector2* vec = Get_Vector2_Struct(self);
 
     return rb_ary_new_from_args(2, DBL2NUM(vec->vec.x), DBL2NUM(vec->vec.y));
 }
 
+/* call-seq: each { |component| ... } -> self
+ *
+ * Yields +x+ then +y+.
+ *
+ * @return [self]
+ */
 static VALUE Vector2_each(VALUE self) {
-    Vector2 *vec = Get_Vector2_Struct(self);
+    Vector2* vec = Get_Vector2_Struct(self);
 
     rb_yield(DBL2NUM(vec->vec.x));
     rb_yield(DBL2NUM(vec->vec.y));
@@ -89,20 +144,40 @@ static VALUE Vector2_each(VALUE self) {
     return self;
 }
 
+/* call-seq:
+ *   [](index) -> Float
+ *
+ * Returns the component stored at +index+.
+ *
+ * @return [Float] +x+ for index 0, +y+ for index 1
+ */
 static VALUE Vector2_aref(VALUE self, VALUE rb_index) {
     return rb_ary_entry(Vector2_to_a(self), NUM2LONG(rb_index));
 }
 
+/* call-seq: size -> Integer
+ *
+ * Returns the number of components, always 2.
+ *
+ * @return [Integer] always 2
+ */
 static VALUE Vector2_size(VALUE self) {
     return INT2NUM(2);
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * +other+ may be a Vector2 or a 2-element Array.
+ *
+ * @return [Boolean]
+ */
 static VALUE Vector2_eql(VALUE self, VALUE rb_other) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     sfVector2f b;
 
     if (rb_obj_is_kind_of(rb_other, rb_cVector2)) {
-        b = ((Vector2 *) Get_Vector2_Struct(rb_other))->vec;
+        b = ((Vector2*)Get_Vector2_Struct(rb_other))->vec;
     } else if (RB_TYPE_P(rb_other, T_ARRAY) && RARRAY_LEN(rb_other) >= 2) {
         b = vec2f_from_rb(rb_other);
     } else {
@@ -112,29 +187,56 @@ static VALUE Vector2_eql(VALUE self, VALUE rb_other) {
     return BOOL2RB(a->vec.x == b.x && a->vec.y == b.y);
 }
 
+/* call-seq:
+ *   self + other -> Vector2
+ *
+ * +other+ may be a Vector2 or a 2-element Array.
+ *
+ * @return [Vector2] componentwise sum
+ */
 static VALUE Vector2_add(VALUE self, VALUE rb_other) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     sfVector2f b = vec2f_from_rb(rb_other);
 
-    return vec2f_to_rb((sfVector2f) {a->vec.x + b.x, a->vec.y + b.y});
+    return vec2f_to_rb((sfVector2f){a->vec.x + b.x, a->vec.y + b.y});
 }
 
+/* call-seq:
+ *   self - other -> Vector2
+ *
+ * +other+ may be a Vector2 or a 2-element Array.
+ *
+ * @return [Vector2] componentwise difference
+ */
 static VALUE Vector2_sub(VALUE self, VALUE rb_other) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     sfVector2f b = vec2f_from_rb(rb_other);
 
-    return vec2f_to_rb((sfVector2f) {a->vec.x - b.x, a->vec.y - b.y});
+    return vec2f_to_rb((sfVector2f){a->vec.x - b.x, a->vec.y - b.y});
 }
 
+/* call-seq:
+ *   self * scalar -> Vector2
+ *
+ * Multiplies both components by +scalar+.
+ *
+ * @return [Vector2]
+ */
 static VALUE Vector2_mul(VALUE self, VALUE rb_scalar) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     float scalar = NUM2DBL(rb_scalar);
 
-    return vec2f_to_rb((sfVector2f) {a->vec.x * scalar, a->vec.y * scalar});
+    return vec2f_to_rb((sfVector2f){a->vec.x * scalar, a->vec.y * scalar});
 }
 
+/* call-seq: to_s -> String
+ *
+ * Returns a human-readable +"(x, y)"+ representation.
+ *
+ * @return [String] +"(x, y)"+
+ */
 static VALUE Vector2_to_s(VALUE self) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     char buffer[64];
 
     snprintf(buffer, sizeof(buffer), "(%g, %g)", a->vec.x, a->vec.y);
@@ -142,8 +244,25 @@ static VALUE Vector2_to_s(VALUE self) {
     return rb_str_new2(buffer);
 }
 
-void Init_Vector2(VALUE rb_module) {
-    rb_cVector2 = rb_define_class_under(rb_module, "Vector2", rb_cObject);
+/* Document-class: SFML::Vector2
+ * A 2D vector of floats, used throughout the library for positions, sizes,
+ * scale factors and directions.
+ *
+ * Includes +Enumerable+ and behaves like a 2-element sequence: it responds to
+ * #each, #to_a and #[], and can be compared or combined with a plain
+ * +[x, y]+ Array anywhere a Vector2 is accepted.
+ *
+ * @!attribute x
+ *   Returns the X component.
+ *
+ *   @return [Float] the X component
+ * @!attribute y
+ *   Returns the Y component.
+ *
+ *   @return [Float] the Y component
+ */
+void Init_Vector2(VALUE rb_mSFML) {
+    rb_cVector2 = rb_define_class_under(rb_mSFML, "Vector2", rb_cObject);
 
     rb_include_module(rb_cVector2, rb_mEnumerable);
 
@@ -171,15 +290,15 @@ VALUE Get_Klass_Vector2(void) {
     return rb_cVector2;
 }
 
-void *Get_Vector2_Struct(VALUE self) {
-    Vector2 *ptr;
+void* Get_Vector2_Struct(VALUE self) {
+    Vector2* ptr;
     TypedData_Get_Struct(self, Vector2, &Vector2_data_type, ptr);
     return ptr;
 }
 
 sfVector2f vec2f_from_rb(VALUE rb_vec) {
     if (rb_obj_is_kind_of(rb_vec, rb_cVector2)) {
-        return ((Vector2 *) Get_Vector2_Struct(rb_vec))->vec;
+        return ((Vector2*)Get_Vector2_Struct(rb_vec))->vec;
     }
 
     if (RB_TYPE_P(rb_vec, T_ARRAY)) {
@@ -187,31 +306,33 @@ sfVector2f vec2f_from_rb(VALUE rb_vec) {
             raise_invalid_array_length(2);
         }
 
-        return (sfVector2f) {
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 0)),
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 1))
-        };
+        return (sfVector2f){(float)NUM2DBL(rb_ary_entry(rb_vec, 0)),
+                            (float)NUM2DBL(rb_ary_entry(rb_vec, 1))};
     }
 
     raise_invalid_argument_class(rb_cVector2);
 
-    return (sfVector2f) {0, 0};
+    return (sfVector2f){0, 0};
 }
 
 sfVector2i vec2i_from_rb(VALUE rb_vec) {
     sfVector2f vec = vec2f_from_rb(rb_vec);
 
-    return (sfVector2i) {(int) vec.x, (int) vec.y};
+    return (sfVector2i){(int)vec.x, (int)vec.y};
 }
 
 sfVector2u vec2u_from_rb(VALUE rb_vec) {
     sfVector2f vec = vec2f_from_rb(rb_vec);
 
-    return (sfVector2u) {(unsigned) vec.x, (unsigned) vec.y};
+    return (sfVector2u){(unsigned)vec.x, (unsigned)vec.y};
 }
 
 VALUE vec2f_to_rb(sfVector2f c_vec) {
-    Vector2 *ptr = malloc(sizeof(Vector2));
+    Vector2* ptr = malloc(sizeof(Vector2));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vector");
+    }
 
     ptr->vec = c_vec;
 
@@ -219,7 +340,7 @@ VALUE vec2f_to_rb(sfVector2f c_vec) {
 }
 
 VALUE vec2_new(float x, float y) {
-    return vec2f_to_rb((sfVector2f) {x, y});
+    return vec2f_to_rb((sfVector2f){x, y});
 }
 
 void vec2_check(VALUE rb_arr) {