- Fix arithmetic rules for floats

- Fix float suffixes on integers

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 import static org.openzen.zencode.shared.CodePosition.BUILTIN;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 		inc(builtin, FLOAT_INC, FLOAT);
 		dec(builtin, FLOAT_DEC, FLOAT);
 
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, BYTE, FLOAT, BYTE_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, SBYTE, FLOAT, SBYTE_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, SHORT, FLOAT, SHORT_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, USHORT, FLOAT, USHORT_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, INT, FLOAT, INT_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, UINT, FLOAT, UINT_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, LONG, FLOAT, LONG_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, ULONG, FLOAT, ULONG_TO_FLOAT);
+		addWithCastedOperand(builtin, FLOAT_ADD_FLOAT, USIZE, FLOAT, USIZE_TO_FLOAT);
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT);
 		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE, FLOAT_TO_DOUBLE);
 		
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, BYTE, FLOAT, BYTE_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, SBYTE, FLOAT, SBYTE_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, SHORT, FLOAT, SHORT_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, USHORT, FLOAT, USHORT_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, INT, FLOAT, INT_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, UINT, FLOAT, UINT_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, LONG, FLOAT, LONG_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, ULONG, FLOAT, ULONG_TO_FLOAT);
+		subWithCastedOperand(builtin, FLOAT_SUB_FLOAT, USIZE, FLOAT, USIZE_TO_FLOAT);
 		sub(builtin, FLOAT_SUB_FLOAT, FLOAT, FLOAT);
 		sub(builtin, DOUBLE_SUB_DOUBLE, DOUBLE, DOUBLE, LONG_TO_DOUBLE);
 		
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, BYTE, FLOAT, BYTE_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, SBYTE, FLOAT, SBYTE_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, SHORT, FLOAT, SHORT_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, USHORT, FLOAT, USHORT_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, INT, FLOAT, INT_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, UINT, FLOAT, UINT_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, LONG, FLOAT, LONG_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, ULONG, FLOAT, ULONG_TO_FLOAT);
+		mulWithCastedOperand(builtin, FLOAT_MUL_FLOAT, USIZE, FLOAT, USIZE_TO_FLOAT);
 		mul(builtin, FLOAT_MUL_FLOAT, FLOAT, FLOAT);
 		mul(builtin, DOUBLE_MUL_DOUBLE, DOUBLE, DOUBLE, LONG_TO_DOUBLE);
 		
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, BYTE, FLOAT, BYTE_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, SBYTE, FLOAT, SBYTE_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, SHORT, FLOAT, SHORT_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, USHORT, FLOAT, USHORT_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, INT, FLOAT, INT_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, UINT, FLOAT, UINT_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, LONG, FLOAT, LONG_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, ULONG, FLOAT, ULONG_TO_FLOAT);
+		divWithCastedOperand(builtin, FLOAT_DIV_FLOAT, USIZE, FLOAT, USIZE_TO_FLOAT);
 		div(builtin, FLOAT_DIV_FLOAT, FLOAT, FLOAT);
 		div(builtin, DOUBLE_DIV_DOUBLE, DOUBLE, DOUBLE, LONG_TO_DOUBLE);
 		
 		members.getOrCreateGroup(member.operator).addMethod(method, TypeMemberPriority.SPECIFIED);
 	}
 	
+	private void castedOperandCall(OperatorMember member, StoredType toType, BuiltinID casterBuiltin) {
+		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, toType);
+		TranslatedOperatorMemberRef method = new TranslatedOperatorMemberRef(member, members.type, GenericMapper.EMPTY,
+				call -> member.ref(members.type, null).call(call.position, call.target, new CallArguments(caster.cast(call.position, call.arguments.arguments[0], true)), call.scope));
+		members.getOrCreateGroup(member.operator).addMethod(method, TypeMemberPriority.SPECIFIED);
+	}
+	
 	private void register(IDefinitionMember member) {
 		member.registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 		castedTargetCall(addOp(definition, id, operand.stored, result.stored), result.stored, caster);
 	}
 	
+	private void addWithCastedOperand(HighLevelDefinition definition, BuiltinID id, BasicTypeID operand, BasicTypeID result, BuiltinID caster) {
+		castedOperandCall(addOp(definition, id, operand.stored, result.stored), operand.stored, caster);
+	}
+	
 	private OperatorMember subOp(HighLevelDefinition cls, BuiltinID id, StoredType operand, StoredType result) {
 		return new OperatorMember(
 				BUILTIN,
 		castedTargetCall(subOp(definition, id, operand.stored, result.stored), result.stored, caster);
 	}
 	
+	private void subWithCastedOperand(HighLevelDefinition definition, BuiltinID id, BasicTypeID operand, BasicTypeID result, BuiltinID caster) {
+		castedOperandCall(subOp(definition, id, operand.stored, result.stored), operand.stored, caster);
+	}
+	
 	private OperatorMember mulOp(HighLevelDefinition cls, BuiltinID id, StoredType operand, StoredType result) {
 		return new OperatorMember(
 				BUILTIN,
 		castedTargetCall(mulOp(definition, id, operand.stored, result.stored), result.stored, caster);
 	}
 	
+	private void mulWithCastedOperand(HighLevelDefinition definition, BuiltinID id, BasicTypeID operand, BasicTypeID result, BuiltinID caster) {
+		castedOperandCall(mulOp(definition, id, operand.stored, result.stored), operand.stored, caster);
+	}
+	
 	private OperatorMember divOp(HighLevelDefinition cls, BuiltinID id, StoredType operand, StoredType result) {
 		return new OperatorMember(
 				BUILTIN,
 		castedTargetCall(divOp(definition, id, operand.stored, result.stored), result.stored, caster);
 	}
 	
+	private void divWithCastedOperand(HighLevelDefinition definition, BuiltinID id, BasicTypeID operand, BasicTypeID result, BuiltinID caster) {
+		castedOperandCall(divOp(definition, id, operand.stored, result.stored), operand.stored, caster);
+	}
+	
 	private OperatorMember modOp(HighLevelDefinition cls, BuiltinID id, StoredType operand, StoredType result) {
 		return new OperatorMember(
 				BUILTIN,

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionInt.java

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
 			return new ConstantULongExpression(position, value);
 		if (suffix.equals("U") || suffix.equals("u"))
 			return new ConstantUIntExpression(position, (int)value);
+		if (suffix.equals("D") || suffix.equals("d"))
+			return new ConstantDoubleExpression(position, value);
+		if (suffix.equals("F") || suffix.equals("f"))
+			return new ConstantFloatExpression(position, value);
 		
 		for (StoredType hint : scope.hints) {
 			if (suffix.isEmpty() && (hint.type instanceof BasicTypeID)) {

ScriptingExample/scripts/integration.zs

 
 
 println(<test string>);
-println(<test string>.length);
+println(<test string>.name);
+
+var diamond = <item:minecraft:diamond>;
+var dirt = <item:minecraft:dirt>;
+addShapedRecipe("TestRecipe", diamond, [[dirt, dirt, dirt],[dirt, dirt, dirt],[dirt, dirt, dirt]]);
+
+var count = 10;
+floatMethod(5f * count);

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Globals.java

 			System.out.println("  - " + object.getName());
 	}
 	
-	public static String bracket(String value) {
-		return "BRACKET:" + value;
+	@Global
+    public static void addShapedRecipe(String name, TestClass output, TestClass[][] inputs) {
+		System.out.println("Added " + name);
+	}
+	
+	@Global
+	public static void floatMethod(float argument) {
+		System.out.println(argument);
+	}
+	
+	public static TestClass bracket(String value) {
+		return new TestClass(value);
 	}
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestClass.java

 	public TestClass wrap(String quotes) {
 		return new TestClass(quotes + name + quotes);
 	}
+	
+	@Caster(implicit = true)
+	@Override
+	public String toString() {
+		return name;
+	}
 }

common.gradle

 apply plugin: 'maven'
 
 String mavenGroupId = 'org.openzen.zencode'
-String mavenVersion = '0.3.5'
+String mavenVersion = '0.3.6'
 
 sourceCompatibility = '1.8'
 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'