-HttpClient: ’Content-Length’ is added to httprequest if not provided in the headers and a body exists

-expressions in GDScript can take multiple lines if inside parenthesis (python-like)
-Added \ to force linebreaks to GDscript (python-like)
-added exclude objects from raycast
-fixed crashes

core/io/http_client.cpp

@@ -97,8 +97,16 @@ Error HTTPClient::request( Method p_method, const String& p_url, const Vector<St
 
 	String request=String(_methods[p_method])+" "+p_url+" HTTP/1.1\r\n";
 	request+="Host: "+conn_host+":"+itos(conn_port)+"\r\n";
+	bool add_clen=p_body.length()>0;
 	for(int i=0;i<p_headers.size();i++) {
 		request+=p_headers[i]+"\r\n";
+		if (add_clen && p_headers[i].find("Content-Length:")==0) {
+			add_clen=false;
+		}
+	}
+	if (add_clen) {
+		request+="Content-Length: "+itos(p_body.utf8().length())+"\r\n";
+		//should it add utf8 encoding? not sure
 	}
 	request+="\r\n";
 	request+=p_body;

core/variant.cpp

@@ -56,7 +56,7 @@ String Variant::get_type_name(Variant::Type p_type) {
 		} break;
 		case REAL: {
 
-			return "real";
+			return "float";
 
 		} break;
 		case STRING: {

modules/gdscript/gd_parser.cpp

@@ -174,10 +174,19 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 		/* Parse Operand */
 		/*****************/
 
+		if (parenthesis>0) {
+			//remove empty space (only allowed if inside parenthesis
+			while(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+				tokenizer->advance();
+			}
+		}
+
 		if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) {
 			//subexpression ()
 			tokenizer->advance();
+			parenthesis++;
 			Node* subexpr = _parse_expression(p_parent,p_static);
+			parenthesis--;
 			if (!subexpr)
 				return NULL;
 
@@ -629,6 +638,12 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 		/* Parse Operator */
 		/******************/
 
+		if (parenthesis>0) {
+			//remove empty space (only allowed if inside parenthesis
+			while(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+				tokenizer->advance();
+			}
+		}
 
 		Expression e;
 		e.is_op=false;
@@ -2475,6 +2490,7 @@ void GDParser::clear() {
 	tab_level.push_back(0);
 	error_line=0;
 	error_column=0;
+	parenthesis=0;
 	current_export.type=Variant::NIL;
 	error="";
 

modules/gdscript/gd_parser.h

@@ -356,6 +356,7 @@ private:
 	template<class T>
 	T* alloc_node();
 
+	int parenthesis;
 	bool error_set;
 	String error;
 	int error_line;

modules/gdscript/gd_tokenizer.cpp

@@ -242,6 +242,24 @@ void GDTokenizerText::_advance() {
 			case 0:
 				_make_token(TK_EOF);
 				break;
+			case '\\':
+				INCPOS(1);
+				if (GETCHAR(0)=='\r') {
+					INCPOS(1);
+				}
+
+				if (GETCHAR(0)!='\n') {
+					_make_error("Expected newline after '\\'.");
+					return;
+				}
+
+				INCPOS(1);
+
+				while(GETCHAR(0)==' ' || GETCHAR(0)=='\t') {
+					INCPOS(1);
+				}
+
+				continue;
 			case '\t':
 			case '\r':
 			case ' ':

scene/2d/canvas_item.cpp

@@ -350,8 +350,10 @@ void CanvasItem::_notification(int p_what) {
 			if (xform_change.in_list())
 				get_scene()->xform_change_list.remove(&xform_change);
 			_exit_canvas();
-			if (C)
+			if (C) {
 				get_parent()->cast_to<CanvasItem>()->children_items.erase(C);
+				C=NULL;
+			}
 		} break;
 		case NOTIFICATION_DRAW: {
 

scene/2d/ray_cast_2d.cpp

@@ -26,173 +26,217 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#include "ray_cast_2d.h"
+#include "ray_cast_2d.h"
-#include "servers/physics_2d_server.h"
+#include "servers/physics_2d_server.h"
-
+#include "collision_object_2d.h"
-void RayCast2D::set_cast_to(const Vector2& p_point) {
+
-
+void RayCast2D::set_cast_to(const Vector2& p_point) {
-	cast_to=p_point;
+
-	if (is_inside_scene() && get_scene()->is_editor_hint())
+	cast_to=p_point;
-		update();
+	if (is_inside_scene() && get_scene()->is_editor_hint())
-
+		update();
-}
+
-
+}
-Vector2 RayCast2D::get_cast_to() const{
+
-
+Vector2 RayCast2D::get_cast_to() const{
-	return cast_to;
+
-}
+	return cast_to;
-
+}
-bool RayCast2D::is_colliding() const{
+
-
+bool RayCast2D::is_colliding() const{
-	return collided;
+
-}
+	return collided;
-Object *RayCast2D::get_collider() const{
+}
-
+Object *RayCast2D::get_collider() const{
-	if (against==0)
+
-		return NULL;
+	if (against==0)
-
+		return NULL;
-	return ObjectDB::get_instance(against);
+
-}
+	return ObjectDB::get_instance(against);
-
+}
-int RayCast2D::get_collider_shape() const {
+
-
+int RayCast2D::get_collider_shape() const {
-	return against_shape;
+
-}
+	return against_shape;
-Vector2 RayCast2D::get_collision_point() const{
+}
-
+Vector2 RayCast2D::get_collision_point() const{
-	return collision_point;
+
-}
+	return collision_point;
-Vector2 RayCast2D::get_collision_normal() const{
+}
-
+Vector2 RayCast2D::get_collision_normal() const{
-	return collision_normal;
+
-}
+	return collision_normal;
-
+}
-
+
-void RayCast2D::set_enabled(bool p_enabled) {
+
-
+void RayCast2D::set_enabled(bool p_enabled) {
-	enabled=p_enabled;
+
-	if (is_inside_scene() && !get_scene()->is_editor_hint())
+	enabled=p_enabled;
-		set_fixed_process(p_enabled);
+	if (is_inside_scene() && !get_scene()->is_editor_hint())
-	if (!p_enabled)
+		set_fixed_process(p_enabled);
-		collided=false;
+	if (!p_enabled)
-
+		collided=false;
-}
+
-
+}
-
+
-bool RayCast2D::is_enabled() const {
+
-
+bool RayCast2D::is_enabled() const {
-
+
-	return enabled;
+
-}
+	return enabled;
-
+}
-
+
-void RayCast2D::_notification(int p_what) {
+
-
+void RayCast2D::_notification(int p_what) {
-	switch(p_what) {
+
-
+	switch(p_what) {
-		case NOTIFICATION_ENTER_SCENE: {
+
-
+		case NOTIFICATION_ENTER_SCENE: {
-			if (enabled && !get_scene()->is_editor_hint())
+
-				set_fixed_process(true);
+			if (enabled && !get_scene()->is_editor_hint())
-			else
+				set_fixed_process(true);
-				set_fixed_process(false);
+			else
-
+				set_fixed_process(false);
-		} break;
+
-		case NOTIFICATION_EXIT_SCENE: {
+		} break;
-
+		case NOTIFICATION_EXIT_SCENE: {
-			if (enabled)
+
-				set_fixed_process(false);
+			if (enabled)
-
+				set_fixed_process(false);
-		} break;
+
-#ifdef TOOLS_ENABLED
+		} break;
-		case NOTIFICATION_DRAW: {
+#ifdef TOOLS_ENABLED
-
+		case NOTIFICATION_DRAW: {
-			if (!get_scene()->is_editor_hint())
+
-				break;
+			if (!get_scene()->is_editor_hint())
-			Matrix32 xf;
+				break;
-			xf.rotate(cast_to.atan2());
+			Matrix32 xf;
-			xf.translate(Vector2(0,cast_to.length()));
+			xf.rotate(cast_to.atan2());
-
+			xf.translate(Vector2(0,cast_to.length()));
-			//Vector2 tip = Vector2(0,s->get_length());
+
-			Color dcol(0.9,0.2,0.2,0.4);
+			//Vector2 tip = Vector2(0,s->get_length());
-			draw_line(Vector2(),cast_to,dcol,3);
+			Color dcol(0.9,0.2,0.2,0.4);
-			Vector<Vector2> pts;
+			draw_line(Vector2(),cast_to,dcol,3);
-			float tsize=4;
+			Vector<Vector2> pts;
-			pts.push_back(xf.xform(Vector2(0,tsize)));
+			float tsize=4;
-			pts.push_back(xf.xform(Vector2(0.707*tsize,0)));
+			pts.push_back(xf.xform(Vector2(0,tsize)));
-			pts.push_back(xf.xform(Vector2(-0.707*tsize,0)));
+			pts.push_back(xf.xform(Vector2(0.707*tsize,0)));
-			Vector<Color> cols;
+			pts.push_back(xf.xform(Vector2(-0.707*tsize,0)));
-			for(int i=0;i<3;i++)
+			Vector<Color> cols;
-				cols.push_back(dcol);
+			for(int i=0;i<3;i++)
-
+				cols.push_back(dcol);
-			draw_primitive(pts,cols,Vector<Vector2>()); //small arrow
+
-
+			draw_primitive(pts,cols,Vector<Vector2>()); //small arrow
-		} break;
+
-#endif
+		} break;
-
+#endif
-		case NOTIFICATION_FIXED_PROCESS: {
+
-
+		case NOTIFICATION_FIXED_PROCESS: {
-			if (!enabled)
+
-				break;
+			if (!enabled)
-
+				break;
-
+
-
+
-			Ref<World2D> w2d = get_world_2d();
+
-			ERR_BREAK( w2d.is_null() );
+			Ref<World2D> w2d = get_world_2d();
-
+			ERR_BREAK( w2d.is_null() );
-			Physics2DDirectSpaceState *dss = Physics2DServer::get_singleton()->space_get_direct_state(w2d->get_space());
+
-			ERR_BREAK( !dss );
+			Physics2DDirectSpaceState *dss = Physics2DServer::get_singleton()->space_get_direct_state(w2d->get_space());
-
+			ERR_BREAK( !dss );
-			Matrix32 gt = get_global_transform();
+
-
+			Matrix32 gt = get_global_transform();
-			Vector2 to = cast_to;
+
-			if (to==Vector2())
+			Vector2 to = cast_to;
-				to=Vector2(0,0.01);
+			if (to==Vector2())
-
+				to=Vector2(0,0.01);
-			Physics2DDirectSpaceState::RayResult rr;
+
-
+			Physics2DDirectSpaceState::RayResult rr;
-			if (dss->intersect_ray(gt.get_origin(),gt.xform(to),rr)) {
+
-
+			if (dss->intersect_ray(gt.get_origin(),gt.xform(to),rr,exclude)) {
-				collided=true;
+
-				against=rr.collider_id;
+				collided=true;
-				collision_point=rr.position;
+				against=rr.collider_id;
-				collision_normal=rr.normal;
+				collision_point=rr.position;
-				against_shape=rr.shape;
+				collision_normal=rr.normal;
-			} else {
+				against_shape=rr.shape;
-				collided=false;
+			} else {
-			}
+				collided=false;
-
+			}
-
+
-
+
-		} break;
+
-	}
+		} break;
-}
+	}
-
+}
-void RayCast2D::_bind_methods() {
+
-
+void RayCast2D::add_exception_rid(const RID& p_rid) {
-
+
-	ObjectTypeDB::bind_method(_MD("set_enabled","enabled"),&RayCast2D::set_enabled);
+	exclude.insert(p_rid);
-	ObjectTypeDB::bind_method(_MD("is_enabled"),&RayCast2D::is_enabled);
+}
-
+
-	ObjectTypeDB::bind_method(_MD("set_cast_to","local_point"),&RayCast2D::set_cast_to);
+void RayCast2D::add_exception(const Object* p_object){
-	ObjectTypeDB::bind_method(_MD("get_cast_to"),&RayCast2D::get_cast_to);
+
-
+	ERR_FAIL_NULL(p_object);
-	ObjectTypeDB::bind_method(_MD("is_colliding"),&RayCast2D::is_colliding);
+	CollisionObject2D *co=((Object*)p_object)->cast_to<CollisionObject2D>();
-
+	if (!co)
-	ObjectTypeDB::bind_method(_MD("get_collider"),&RayCast2D::get_collider);
+		return;
-	ObjectTypeDB::bind_method(_MD("get_collider_shape"),&RayCast2D::get_collider_shape);
+	add_exception_rid(co->get_rid());
-	ObjectTypeDB::bind_method(_MD("get_collision_point"),&RayCast2D::get_collision_point);
+}
-	ObjectTypeDB::bind_method(_MD("get_collision_normal"),&RayCast2D::get_collision_normal);
+
-
+void RayCast2D::remove_exception_rid(const RID& p_rid) {
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"enabled"),_SCS("set_enabled"),_SCS("is_enabled"));
+
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"cast_to"),_SCS("set_cast_to"),_SCS("get_cast_to"));
+	exclude.erase(p_rid);
-}
+}
-
+
-RayCast2D::RayCast2D() {
+void RayCast2D::remove_exception(const Object* p_object){
-
+
-	enabled=false;
+	ERR_FAIL_NULL(p_object);
-	against=0;
+	CollisionObject2D *co=((Object*)p_object)->cast_to<CollisionObject2D>();
-	collided=false;
+	if (!co)
-	against_shape=0;
+		return;
-	cast_to=Vector2(0,50);
+	remove_exception_rid(co->get_rid());
-}
+}
+
+
+void RayCast2D::clear_exceptions(){
+
+	exclude.clear();
+}
+
+
+void RayCast2D::_bind_methods() {
+
+
+	ObjectTypeDB::bind_method(_MD("set_enabled","enabled"),&RayCast2D::set_enabled);
+	ObjectTypeDB::bind_method(_MD("is_enabled"),&RayCast2D::is_enabled);
+
+	ObjectTypeDB::bind_method(_MD("set_cast_to","local_point"),&RayCast2D::set_cast_to);
+	ObjectTypeDB::bind_method(_MD("get_cast_to"),&RayCast2D::get_cast_to);
+
+	ObjectTypeDB::bind_method(_MD("is_colliding"),&RayCast2D::is_colliding);
+
+	ObjectTypeDB::bind_method(_MD("get_collider"),&RayCast2D::get_collider);
+	ObjectTypeDB::bind_method(_MD("get_collider_shape"),&RayCast2D::get_collider_shape);
+	ObjectTypeDB::bind_method(_MD("get_collision_point"),&RayCast2D::get_collision_point);
+	ObjectTypeDB::bind_method(_MD("get_collision_normal"),&RayCast2D::get_collision_normal);
+
+	ObjectTypeDB::bind_method(_MD("add_exception_rid","rid"),&RayCast2D::add_exception_rid);
+	ObjectTypeDB::bind_method(_MD("add_exception","node"),&RayCast2D::add_exception);
+
+	ObjectTypeDB::bind_method(_MD("remove_exception_rid","rid"),&RayCast2D::remove_exception_rid);
+	ObjectTypeDB::bind_method(_MD("remove_exception","node"),&RayCast2D::remove_exception);
+
+	ObjectTypeDB::bind_method(_MD("clear_exceptions"),&RayCast2D::clear_exceptions);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"enabled"),_SCS("set_enabled"),_SCS("is_enabled"));
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"cast_to"),_SCS("set_cast_to"),_SCS("get_cast_to"));
+}
+
+RayCast2D::RayCast2D() {
+
+	enabled=false;
+	against=0;
+	collided=false;
+	against_shape=0;
+	cast_to=Vector2(0,50);
+}

scene/2d/ray_cast_2d.h

@@ -26,43 +26,51 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#ifndef RAY_CAST_2D_H
+#ifndef RAY_CAST_2D_H
-#define RAY_CAST_2D_H
+#define RAY_CAST_2D_H
-
+
-#include "scene/2d/node_2d.h"
+#include "scene/2d/node_2d.h"
-
+
-class RayCast2D : public Node2D {
+class RayCast2D : public Node2D {
-
+
-	OBJ_TYPE(RayCast2D,Node2D);
+	OBJ_TYPE(RayCast2D,Node2D);
-
+
-
+
-	bool enabled;
+	bool enabled;
-	bool collided;
+	bool collided;
-	ObjectID against;
+	ObjectID against;
-	int against_shape;
+	int against_shape;
-	Vector2 collision_point;
+	Vector2 collision_point;
-	Vector2 collision_normal;
+	Vector2 collision_normal;
-
+	Set<RID> exclude;
-	Vector2 cast_to;
+
-protected:
+
-
+	Vector2 cast_to;
-	void _notification(int p_what);
+protected:
-	static void _bind_methods();
+
-public:
+	void _notification(int p_what);
-
+	static void _bind_methods();
-	void set_enabled(bool p_enabled);
+public:
-	bool is_enabled() const;
+
-
+	void set_enabled(bool p_enabled);
-	void set_cast_to(const Vector2& p_point);
+	bool is_enabled() const;
-	Vector2 get_cast_to() const;
+
-
+	void set_cast_to(const Vector2& p_point);
-	bool is_colliding() const;
+	Vector2 get_cast_to() const;
-	Object *get_collider() const;
+
-	int get_collider_shape() const;
+	bool is_colliding() const;
-	Vector2 get_collision_point() const;
+	Object *get_collider() const;
-	Vector2 get_collision_normal() const;
+	int get_collider_shape() const;
-
+	Vector2 get_collision_point() const;
-	RayCast2D();
+	Vector2 get_collision_normal() const;
-};
+
-
+	void add_exception_rid(const RID& p_rid);
-#endif // RAY_CAST_2D_H
+	void add_exception(const Object* p_object);
+	void remove_exception_rid(const RID& p_rid);
+	void remove_exception(const Object* p_object);
+	void clear_exceptions();
+
+	RayCast2D();
+};
+
+#endif // RAY_CAST_2D_H