Sync classes with 2.0 branch

classes/class_httpclient.rst

@@ -200,7 +200,11 @@ Stub function
 
 - :ref:`Dictionary<class_dictionary>`  **get_response_headers_as_dictionary**  **(** **)**
 
-Returns all response headers as dictionary where the keys and values are transformed to lower case. A key with more than one value is a simple string with "; " as separator. example: (content-length:12), (content-type:application/json; charset=utf-8)
+Returns all response headers as dictionary where the case-sensitivity of the keys and values is kept like the server delivers it. A value is a simple String, this string can have more than one value where "; " is used as separator.
+
+Structure: ("key":"value1; value2")
+
+Example: (content-length:12), (Content-Type:application/json; charset=UTF-8)
 
 .. _class_HTTPClient_get_response_body_length:
 

classes/class_nodepath.rst

@@ -11,7 +11,7 @@ NodePath
 Brief Description
 -----------------
 
-Built-in type optimized for path traversing.
+Pre-parsed scene tree path.
 
 Member Functions
 ----------------
@@ -37,7 +37,11 @@ Member Functions
 Description
 -----------
 
-Built-in type optimized for path traversing. A Node path is an optimized compiled path used for traversing the scene tree. It references nodes and can reference properties in that node, or even reference properties inside the resources of the node.
+A pre-parsed relative or absolute path in a scene tree, for use with :ref:`Node.get_node<class_Node_get_node>` and similar functions. It can reference a node, a resource within a node, or a property of a node or resource. For instance, ``"Path2D/PathFollow2D/Sprite:texture:size"`` would refer to the size property of the texture resource on the node named "Sprite" which is a child of the other named nodes in the path. Note that if you want to get a resource, you must end the path with a colon, otherwise the last element will be used as a property name.
+
+You will usually just pass a string to :ref:`Node.get_node<class_Node_get_node>` and it will be automatically converted, but you may occasionally want to parse a path ahead of time with :ref:`NodePath<class_nodepath>` or the literal syntax ``@"path"``. Exporting a :ref:`NodePath<class_nodepath>` variable will give you a node selection widget in the properties panel of the editor, which can often be useful.
+
+A :ref:`NodePath<class_nodepath>` is made up of a list of node names, a list of "subnode" (resource) names, and the name of a property in the final node or resource.
 
 Member Function Description
 ---------------------------
@@ -46,31 +50,31 @@ Member Function Description
 
 - :ref:`String<class_string>`  **get_name**  **(** :ref:`int<class_int>` idx  **)**
 
-Return a path level name.
+Get the node name indicated by ``idx`` (0 to :ref:`get_name_count<class_NodePath_get_name_count>`)
 
 .. _class_NodePath_get_name_count:
 
 - :ref:`int<class_int>`  **get_name_count**  **(** **)**
 
-Return the path level count.
+Get the number of node names which make up the path.
 
 .. _class_NodePath_get_property:
 
 - :ref:`String<class_string>`  **get_property**  **(** **)**
 
-Return the property associated (empty if none).
+Get the path's property name, or an empty string if the path doesn't have a property.
 
 .. _class_NodePath_get_subname:
 
 - :ref:`String<class_string>`  **get_subname**  **(** :ref:`int<class_int>` idx  **)**
 
-Return the subname level name.
+Get the resource name indicated by ``idx`` (0 to :ref:`get_subname_count<class_NodePath_get_subname_count>`)
 
 .. _class_NodePath_get_subname_count:
 
 - :ref:`int<class_int>`  **get_subname_count**  **(** **)**
 
-Return the subname count.
+Get the number of resource names in the path.
 
 .. _class_NodePath_is_absolute:
 
@@ -88,4 +92,6 @@ Return true if the node path is empty.
 
 - :ref:`NodePath<class_nodepath>`  **NodePath**  **(** :ref:`String<class_string>` from  **)**
 
+Create a NodePath from a string, e.g. "Path2D/PathFollow2D/Sprite:texture:size". A path is absolute if it starts with a slash. Absolute paths are only valid in the global scene tree, not within individual scenes. In a relative path, ``"."`` and ``".."`` indicate the current node and its parent.
+
 

classes/class_object.rst

@@ -123,7 +123,7 @@ Objects do not manage memory, if inheriting from one the object will most likely
 
 Some derivates add memory management, such as :ref:`Reference<class_reference>` (which keeps a reference count and deletes itself automatically when no longer referenced) and :ref:`Node<class_node>`, which deletes the children tree when deleted.
 
-Objects export properties, which are mainly useful for storage and editing, but not really so much in programming. Properties are exported in :ref:`_get_property_list<class_Object__get_property_list>` and handled in :ref:`_get<class_Object__get>` and :ref:`_set<class_Object__set>`. However, scripting languages and C++ have simper means to export them.
+Objects export properties, which are mainly useful for storage and editing, but not really so much in programming. Properties are exported in :ref:`_get_property_list<class_Object__get_property_list>` and handled in :ref:`_get<class_Object__get>` and :ref:`_set<class_Object__set>`. However, scripting languages and C++ have simpler means to export them.
 
 Objects also receive notifications (:ref:`_notification<class_Object__notification>`). Notifications are a simple way to notify the object about simple events, so they can all be handled together.
 

classes/class_os.rst

@@ -189,6 +189,8 @@ Member Functions
 +----------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | void                                   | :ref:`native_video_pause<class_OS_native_video_pause>`  **(** **)**                                                                                                                                                        |
 +----------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| void                                   | :ref:`native_video_unpause<class_OS_native_video_unpause>`  **(** **)**                                                                                                                                                    |
++----------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`String<class_string>`            | :ref:`get_scancode_string<class_OS_get_scancode_string>`  **(** :ref:`int<class_int>` code  **)** const                                                                                                                    |
 +----------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`bool<class_bool>`                | :ref:`is_scancode_unicode<class_OS_is_scancode_unicode>`  **(** :ref:`int<class_int>` code  **)** const                                                                                                                    |
@@ -664,6 +666,10 @@ Return the total amount of dynamic memory used (only works in debug).
 
 - void  **native_video_pause**  **(** **)**
 
+.. _class_OS_native_video_unpause:
+
+- void  **native_video_unpause**  **(** **)**
+
 .. _class_OS_get_scancode_string:
 
 - :ref:`String<class_string>`  **get_scancode_string**  **(** :ref:`int<class_int>` code  **)** const

classes/class_rigidbody2d.rst

@@ -133,7 +133,7 @@ Member Function Description
 
 - void  **_integrate_forces**  **(** :ref:`Physics2DDirectBodyState<class_physics2ddirectbodystate>` state  **)** virtual
 
-Override this function to use a custom force integrator. This allows to hook up to the physics processing and alter the simulation state for the object on every frame.
+Called during physics processing, allowing you to read and safely modify the simulation state for the object. By default it works in addition to the usual physics behavior, but :ref:`set_use_custom_integrator<class_RigidBody2D_set_use_custom_integrator>` allows you to disable the default behavior and do fully custom force integration for a body.
 
 .. _class_RigidBody2D_set_mode:
 
@@ -271,7 +271,7 @@ Return the maximum contacts that can be reported. See :ref:`set_max_contacts_rep
 
 - void  **set_use_custom_integrator**  **(** :ref:`bool<class_bool>` enable  **)**
 
-Set to true if the body shall not do any internal force integration at all (like gravity or air friction). Only the :ref:`_integrate_forces<class_RigidBody2D__integrate_forces>` will be able to integrate them if overridden.
+Pass true to disable the internal force integration (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the :ref:`_integrate_forces<class_RigidBody2D__integrate_forces>` function, if defined.
 
 .. _class_RigidBody2D_is_using_custom_integrator:
 

classes/class_scenestate.rst

@@ -29,6 +29,10 @@ Member Functions
 +----------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`NodePath<class_nodepath>`        | :ref:`get_node_owner_path<class_SceneState_get_node_owner_path>`  **(** :ref:`int<class_int>` idx  **)** const                                         |
 +----------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`bool<class_bool>`                | :ref:`is_node_instance_placeholder<class_SceneState_is_node_instance_placeholder>`  **(** :ref:`int<class_int>` idx  **)** const                       |
++----------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| :ref:`String<class_string>`            | :ref:`get_node_instance_placeholder<class_SceneState_get_node_instance_placeholder>`  **(** :ref:`int<class_int>` idx  **)** const                     |
++----------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`PackedScene<class_packedscene>`  | :ref:`get_node_instance<class_SceneState_get_node_instance>`  **(** :ref:`int<class_int>` idx  **)** const                                             |
 +----------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
 | :ref:`StringArray<class_stringarray>`  | :ref:`get_node_groups<class_SceneState_get_node_groups>`  **(** :ref:`int<class_int>` idx  **)** const                                                 |
@@ -77,6 +81,14 @@ Member Function Description
 
 - :ref:`NodePath<class_nodepath>`  **get_node_owner_path**  **(** :ref:`int<class_int>` idx  **)** const
 
+.. _class_SceneState_is_node_instance_placeholder:
+
+- :ref:`bool<class_bool>`  **is_node_instance_placeholder**  **(** :ref:`int<class_int>` idx  **)** const
+
+.. _class_SceneState_get_node_instance_placeholder:
+
+- :ref:`String<class_string>`  **get_node_instance_placeholder**  **(** :ref:`int<class_int>` idx  **)** const
+
 .. _class_SceneState_get_node_instance:
 
 - :ref:`PackedScene<class_packedscene>`  **get_node_instance**  **(** :ref:`int<class_int>` idx  **)** const

classes/class_tween.rst

@@ -13,7 +13,7 @@ Tween
 Brief Description
 -----------------
 
-
+Node useful for animations with unknown start and end points.
 
 Member Functions
 ----------------
@@ -86,23 +86,40 @@ Signals
 Numeric Constants
 -----------------
 
-- **TWEEN_PROCESS_FIXED** = **0**
-- **TWEEN_PROCESS_IDLE** = **1**
-- **TRANS_LINEAR** = **0**
-- **TRANS_SINE** = **1**
-- **TRANS_QUINT** = **2**
-- **TRANS_QUART** = **3**
-- **TRANS_QUAD** = **4**
-- **TRANS_EXPO** = **5**
-- **TRANS_ELASTIC** = **6**
-- **TRANS_CUBIC** = **7**
-- **TRANS_CIRC** = **8**
-- **TRANS_BOUNCE** = **9**
-- **TRANS_BACK** = **10**
-- **EASE_IN** = **0**
-- **EASE_OUT** = **1**
-- **EASE_IN_OUT** = **2**
-- **EASE_OUT_IN** = **3**
+- **TWEEN_PROCESS_FIXED** = **0** --- The :ref:`Tween<class_tween>` should use ``_fixed_process`` for timekeeping when this is enabled.
+- **TWEEN_PROCESS_IDLE** = **1** --- The :ref:`Tween<class_tween>` should use ``_process`` for timekeeping when this is enabled (default).
+- **TRANS_LINEAR** = **0** --- Means that the animation is interpolated linearly.
+- **TRANS_SINE** = **1** --- Means that the animation is interpolated using a sine wave.
+- **TRANS_QUINT** = **2** --- Means that the animation is interpolated with a quinary (to the power of 5) function.
+- **TRANS_QUART** = **3** --- Means that the animation is interpolated with a quartic (to the power of 4) function.
+- **TRANS_QUAD** = **4** --- Means that the animation is interpolated with a quadratic (to the power of 2) function.
+- **TRANS_EXPO** = **5** --- Means that the animation is interpolated with a exponential (some number to the power of x) function.
+- **TRANS_ELASTIC** = **6** --- Means that the animation is interpolated with elasticity, wiggling around the edges.
+- **TRANS_CUBIC** = **7** --- Means that the animation is interpolated with a cubic (to the power of 3) function.
+- **TRANS_CIRC** = **8** --- Means that the animation is interpolated with a function using square roots.
+- **TRANS_BOUNCE** = **9** --- Means that the animation is interpolated by bouncing at, but never surpassing, the end.
+- **TRANS_BACK** = **10** --- Means that the animation is interpolated backing out at edges.
+- **EASE_IN** = **0** --- Signifies that the interpolation should be focused in the beginning.
+- **EASE_OUT** = **1** --- Signifies that the interpolation should be focused in the end.
+- **EASE_IN_OUT** = **2** --- Signifies that the interpolation should be focused in both ends.
+- **EASE_OUT_IN** = **3** --- Signifies that the interpolation should be focused in both ends, but they should be switched (a bit hard to explain, try it for yourself to be sure).
+
+Description
+-----------
+
+Node useful for animations with unknown start and end points, procedural animations, making one node follow another, and other simple behavior.
+
+Because it is easy to get it wrong, here is a quick usage example:
+
+::
+
+    var tween = get_node("Tween")
+    tween.interpolate_property(get_node("Node2D_to_move"), "transform/pos", Vector2(0,0), Vector2(100,100), Tween.TRANS_LINEAR, Tween.EASE_IN_OUT)
+    tween.start()
+
+Some of the methods of this class require a property name. You can get the property name by hovering over the property in the inspector of the editor.
+
+Many of the methods accept ``trans_type`` and ``ease_type``. The first accepts an TRANS\_\* constant, and refers to the way the timing of the animation is handled (you might want to see ``http://easings.net/`` for some examples). The second accepts an EASE\_\* constant, and controls the where ``trans_type`` is applied to the interpolation (in the begining, the end, or both). If you don't know which transision and easing to pick, you can try different TRANS\_\* constants with EASE_IN_OUT, and use the one that looks best.
 
 Member Function Description
 ---------------------------
@@ -111,112 +128,180 @@ Member Function Description
 
 - :ref:`bool<class_bool>`  **is_active**  **(** **)** const
 
+Returns true if any tweens are currently running, and false otherwise. Note that this method doesn't consider tweens that have ended.
+
 .. _class_Tween_set_active:
 
 - void  **set_active**  **(** :ref:`bool<class_bool>` active  **)**
 
+Activate/deactivate the tween. You can use this for pausing animations, though :ref:`stop_all<class_Tween_stop_all>` and :ref:`resume_all<class_Tween_resume_all>` might be more fit for this.
+
 .. _class_Tween_is_repeat:
 
 - :ref:`bool<class_bool>`  **is_repeat**  **(** **)** const
 
+Returns true if repeat has been set from editor GUI or :ref:`set_repeat<class_Tween_set_repeat>`.
+
 .. _class_Tween_set_repeat:
 
 - void  **set_repeat**  **(** :ref:`bool<class_bool>` repeat  **)**
 
+Make the tween repeat after all tweens have finished.
+
 .. _class_Tween_set_speed:
 
 - void  **set_speed**  **(** :ref:`float<class_float>` speed  **)**
 
+Set the speed multiplier of the tween. Set it to 1 for normal speed, 2 for two times nromal speed, and 0.5 for half of the normal speed. Setting it to 0 would pause the animation, but you might consider using :ref:`set_active<class_Tween_set_active>` or :ref:`stop_all<class_Tween_stop_all>` and :ref:`resume_all<class_Tween_resume_all>` for this.
+
 .. _class_Tween_get_speed:
 
 - :ref:`float<class_float>`  **get_speed**  **(** **)** const
 
+Returns the speed that has been set from editor GUI or :ref:`set_repeat<class_Tween_set_repeat>`.
+
 .. _class_Tween_set_tween_process_mode:
 
 - void  **set_tween_process_mode**  **(** :ref:`int<class_int>` mode  **)**
 
+Set whether the Tween uses ``_process`` or ``_fixed_process`` (accepts TWEEN_PROCESS_IDLE and TWEEN_PROCESS_FIXED constants, respectively).
+
 .. _class_Tween_get_tween_process_mode:
 
 - :ref:`int<class_int>`  **get_tween_process_mode**  **(** **)** const
 
+Returns the process mode that has been set from editor GUI or :ref:`set_tween_process_mode<class_Tween_set_tween_process_mode>`
+
 .. _class_Tween_start:
 
 - :ref:`bool<class_bool>`  **start**  **(** **)**
 
+Start the tween node. You can define tweens both before and after this.
+
 .. _class_Tween_reset:
 
 - :ref:`bool<class_bool>`  **reset**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` key  **)**
 
+Resets a tween to the initial value (the one given, not the one before the tween), given its object and property/method pair.
+
 .. _class_Tween_reset_all:
 
 - :ref:`bool<class_bool>`  **reset_all**  **(** **)**
 
+Resets all tweens to their initial values (the ones given, not those before the tween).
+
 .. _class_Tween_stop:
 
 - :ref:`bool<class_bool>`  **stop**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` key  **)**
 
+Stop animating a tween, given its object and property/method pair.
+
 .. _class_Tween_stop_all:
 
 - :ref:`bool<class_bool>`  **stop_all**  **(** **)**
 
+Stop animating all tweens.
+
 .. _class_Tween_resume:
 
 - :ref:`bool<class_bool>`  **resume**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` key  **)**
 
+Continue animating a stopped tween, given its object and property/method pair.
+
 .. _class_Tween_resume_all:
 
 - :ref:`bool<class_bool>`  **resume_all**  **(** **)**
 
+Continue animating all stopped tweens.
+
 .. _class_Tween_remove:
 
 - :ref:`bool<class_bool>`  **remove**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` key  **)**
 
+Stop animating and completely remove a tween, given its object and property/method pair.
+
 .. _class_Tween_remove_all:
 
 - :ref:`bool<class_bool>`  **remove_all**  **(** **)**
 
+Stop animating and completely remove all tweens.
+
 .. _class_Tween_seek:
 
 - :ref:`bool<class_bool>`  **seek**  **(** :ref:`float<class_float>` time  **)**
 
+Seek the animation to the given ``time`` in seconds.
+
 .. _class_Tween_tell:
 
 - :ref:`float<class_float>`  **tell**  **(** **)** const
 
+Returns the current time of the tween.
+
 .. _class_Tween_get_runtime:
 
 - :ref:`float<class_float>`  **get_runtime**  **(** **)** const
 
+Returns the time needed for all tweens to end in seconds, measured from the start. Thus, if you have two tweens, one ending 10 seconds after the start and the other - 20 seconds, it would return 20 seconds, as by that time all tweens would have finished.
+
 .. _class_Tween_interpolate_property:
 
 - :ref:`bool<class_bool>`  **interpolate_property**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` property, var initial_val, var final_val, :ref:`float<class_float>` times_in_sec, :ref:`int<class_int>` trans_type, :ref:`int<class_int>` ease_type, :ref:`float<class_float>` delay=0  **)**
 
+Animate ``property`` of ``object`` from ``initial_val`` to ``final_val`` for ``times_in_sec`` seconds, ``delay`` seconds later.
+
+``trans_type`` accepts TRANS\_\* constants, and is the way the animation is interpolated, while ``ease_type`` accepts EASE\_\* constants, and controls the place of the interpolation (the begining, the end, or both). You can read more about them in the class description.
+
 .. _class_Tween_interpolate_method:
 
 - :ref:`bool<class_bool>`  **interpolate_method**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` method, var initial_val, var final_val, :ref:`float<class_float>` times_in_sec, :ref:`int<class_int>` trans_type, :ref:`int<class_int>` ease_type, :ref:`float<class_float>` delay=0  **)**
 
+Animate ``method`` of ``object`` from ``initial_val`` to ``final_val`` for ``times_in_sec`` seconds, ``delay`` seconds later. Methods are animated by calling them with consecuitive values.
+
+``trans_type`` accepts TRANS\_\* constants, and is the way the animation is interpolated, while ``ease_type`` accepts EASE\_\* constants, and controls the place of the interpolation (the begining, the end, or both). You can read more about them in the class description.
+
 .. _class_Tween_interpolate_callback:
 
 - :ref:`bool<class_bool>`  **interpolate_callback**  **(** :ref:`Object<class_object>` object, :ref:`float<class_float>` times_in_sec, :ref:`String<class_string>` callback, var arg1=NULL, var arg2=NULL, var arg3=NULL, var arg4=NULL, var arg5=NULL  **)**
 
+Call ``callback`` of ``object`` after ``times_in_sec``. ``arg1``-``arg5`` are arguments to be passed to the callback.
+
 .. _class_Tween_interpolate_deferred_callback:
 
 - :ref:`bool<class_bool>`  **interpolate_deferred_callback**  **(** :ref:`Object<class_object>` object, :ref:`float<class_float>` times_in_sec, :ref:`String<class_string>` callback, var arg1=NULL, var arg2=NULL, var arg3=NULL, var arg4=NULL, var arg5=NULL  **)**
 
+Call ``callback`` of ``object`` after ``times_in_sec`` on the main thread (similar to :ref:`methog Object.call_deferred). [code<class_methog object.call_deferred). [code>`arg1``-``arg5`` are arguments to be passed to the callback.
+
 .. _class_Tween_follow_property:
 
 - :ref:`bool<class_bool>`  **follow_property**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` property, var initial_val, :ref:`Object<class_object>` target, :ref:`String<class_string>` target_property, :ref:`float<class_float>` times_in_sec, :ref:`int<class_int>` trans_type, :ref:`int<class_int>` ease_type, :ref:`float<class_float>` delay=0  **)**
 
+Follow ``property`` of ``object`` and apply it on ``target_property`` of ``target``, beginning from ``initial_val`` for ``times_in_sec`` seconds, ``delay`` seconds later. Note that ``target:target_property`` would equal ``object:property`` at the end of the tween.
+
+``trans_type`` accepts TRANS\_\* constants, and is the way the animation is interpolated, while ``ease_type`` accepts EASE\_\* constants, and controls the place of the interpolation (the begining, the end, or both). You can read more about them in the class description.
+
 .. _class_Tween_follow_method:
 
 - :ref:`bool<class_bool>`  **follow_method**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` method, var initial_val, :ref:`Object<class_object>` target, :ref:`String<class_string>` target_method, :ref:`float<class_float>` times_in_sec, :ref:`int<class_int>` trans_type, :ref:`int<class_int>` ease_type, :ref:`float<class_float>` delay=0  **)**
 
+Follow ``method`` of ``object`` and apply the returned value on ``target_method`` of ``target``, beginning from ``initial_val`` for ``times_in_sec`` seconds, ``delay`` later. Methods are animated by calling them with consequitive values.
+
+``trans_type`` accepts TRANS\_\* constants, and is the way the animation is interpolated, while ``ease_type`` accepts EASE\_\* constants, and controls the place of the interpolation (the begining, the end, or both). You can read more about them in the class description.
+
 .. _class_Tween_targeting_property:
 
 - :ref:`bool<class_bool>`  **targeting_property**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` property, :ref:`Object<class_object>` initial, :ref:`String<class_string>` initial_val, var final_val, :ref:`float<class_float>` times_in_sec, :ref:`int<class_int>` trans_type, :ref:`int<class_int>` ease_type, :ref:`float<class_float>` delay=0  **)**
 
+Animate ``property`` of ``object`` from the current value of the ``initial_val`` property of ``initial`` to ``final_val`` for ``times_in_sec`` seconds, ``delay`` seconds later.
+
+``trans_type`` accepts TRANS\_\* constants, and is the way the animation is interpolated, while ``ease_type`` accepts EASE\_\* constants, and controls the place of the interpolation (the begining, the end, or both). You can read more about them in the class description.
+
 .. _class_Tween_targeting_method:
 
 - :ref:`bool<class_bool>`  **targeting_method**  **(** :ref:`Object<class_object>` object, :ref:`String<class_string>` method, :ref:`Object<class_object>` initial, :ref:`String<class_string>` initial_method, var final_val, :ref:`float<class_float>` times_in_sec, :ref:`int<class_int>` trans_type, :ref:`int<class_int>` ease_type, :ref:`float<class_float>` delay=0  **)**
 
+Animate ``method`` of ``object`` from the value returned by ``initial.initial_method`` to ``final_val`` for ``times_in_sec`` seconds, ``delay`` seconds later. Methods are animated by calling them with consecuitive values.
+
+``trans_type`` accepts TRANS\_\* constants, and is the way the animation is interpolated, while ``ease_type`` accepts EASE\_\* constants, and controls the place of the interpolation (the begining, the end, or both). You can read more about them in the class description.
+