Initial commit of Go Save the King project

assets/noise/noise2.tres

+[gd_resource type="NoiseTexture2D" load_steps=2 format=3 uid="uid://ceas3dsjeq4ge"]
+
+[sub_resource type="FastNoiseLite" id="FastNoiseLite_e1ki6"]
+noise_type = 0
+frequency = 0.0051
+fractal_type = 3
+fractal_gain = 0.6
+domain_warp_enabled = true
+domain_warp_type = 1
+domain_warp_amplitude = 22.0
+domain_warp_fractal_octaves = 2
+domain_warp_fractal_lacunarity = 1.0
+domain_warp_fractal_gain = 1.0
+
+[resource]
+width = 350
+height = 350
+seamless = true
+seamless_blend_skirt = 1.0
+noise = SubResource("FastNoiseLite_e1ki6")

assets/noise/noise3.tres

+[gd_resource type="NoiseTexture2D" load_steps=2 format=3 uid="uid://m6ki73qfbp2s"]
+
+[sub_resource type="FastNoiseLite" id="FastNoiseLite_7usy6"]
+noise_type = 0
+seed = 1
+frequency = 0.0049
+fractal_type = 3
+fractal_octaves = 4
+domain_warp_enabled = true
+domain_warp_fractal_octaves = 2
+
+[resource]
+width = 350
+height = 350
+seamless = true
+seamless_blend_skirt = 1.0
+noise = SubResource("FastNoiseLite_7usy6")

assets/shaders/bg.gdshader

+shader_type canvas_item;
+
+uniform sampler2D noise : repeat_enable, filter_nearest;
+uniform sampler2D noise2 : repeat_enable, filter_nearest;
+uniform sampler2D noise3 : repeat_enable, filter_nearest;
+uniform vec3 color1;
+uniform vec3 color2;
+uniform vec3 color3;
+
+uniform float speed = 0.1;
+uniform vec2 direction = vec2(1.0, 0.0);
+
+void fragment() {
+	vec2 uv = UV + direction * speed * TIME;
+	float blend_factor = (sin(TIME)+1.0)*0.4;
+	//blend_factor *= cos((TIME*2.0)+2.0);
+	float noise_value1 = texture(noise, uv).r;
+	float noise_value2 = texture(noise2, uv - direction * speed * TIME * 2.0).r;
+	float noise_value3 = texture(noise3, uv - vec2(0.25,0.5) * speed * TIME * 1.5).r;
+
+	float mixed_noise = mix(noise_value1, noise_value2, blend_factor);
+	float final_noise = mix(noise_value3, mixed_noise, blend_factor);
+
+	vec3 mixed_color = mix(color1, color2, mixed_noise);
+	vec3 final_color = mix(mixed_color, color3, final_noise);
+
+    // Set the final fragment color
+	COLOR.rgb = final_color;
+	COLOR.a = 1.0;
+}

assets/shaders/color.gdshader

+shader_type canvas_item;
+
+void vertex() {
+	// Called for every vertex the material is visible on.
+}
+
+uniform float r: hint_range(0.0, 1.0) = 1.0;
+uniform float g: hint_range(0.0, 1.0) = 1.0;
+uniform float b: hint_range(0.0, 1.0) = 1.0;
+uniform float opacity : hint_range(0.0, 1.0) = 1.0;
+
+void fragment() {
+    vec4 sprite_color = texture(TEXTURE, UV);
+    COLOR = vec4(sprite_color.r * r,sprite_color.g * g,sprite_color.b * b, sprite_color.a * opacity )*COLOR;
+}
\ No newline at end of file

assets/shaders/shadow.gdshader

+shader_type canvas_item;
+
+uniform vec4 shadow_color = vec4(0.0, 0.0, 0.0, 0.5); // Shadow color and transparency
+uniform vec2 shadow_offset = vec2(5.0, 5.0); // Offset for the shadow
+
+void fragment() {
+	// Move the texture coordinates by the shadow offset
+	vec2 shadow_uv = UV + shadow_offset / SCREEN_PIXEL_SIZE;
+	vec4 tex_color = texture(TEXTURE, shadow_uv);
+	// Apply the shadow color to the texture
+	COLOR = tex_color * shadow_color;
+}
\ No newline at end of file

assets/sprites/bishop.png.import

+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://b68o4mj7wcwvq"
+path="res://.godot/imported/bishop.png-0a4eeb88803e8373143a355ec2db13ef.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/sprites/bishop.png"
+dest_files=["res://.godot/imported/bishop.png-0a4eeb88803e8373143a355ec2db13ef.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

assets/sprites/knight.png.import

+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://bqrsgofg5ly2i"
+path="res://.godot/imported/knight.png-7c67c83d34932624952797d9e971a644.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/sprites/knight.png"
+dest_files=["res://.godot/imported/knight.png-7c67c83d34932624952797d9e971a644.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

assets/sprites/pawn.png.import

+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://tcrgmk4sxloa"
+path="res://.godot/imported/pawn.png-d212cb186c65ebab605e13f6d0b32094.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/sprites/pawn.png"
+dest_files=["res://.godot/imported/pawn.png-d212cb186c65ebab605e13f6d0b32094.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

assets/sprites/rook.png.import

+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://c30tjv7koff57"
+path="res://.godot/imported/rook.png-3193991601018e9da157f3bba512d9df.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/sprites/rook.png"
+dest_files=["res://.godot/imported/rook.png-3193991601018e9da157f3bba512d9df.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

project.godot

@@ -11,6 +11,7 @@ config_version=5
 [application]
 
 config/name="Go Save The King"
+
 config/features=PackedStringArray("4.3", "GL Compatibility")
 config/icon="res://icon.svg"
 

scenes/game.tscn

+[gd_scene load_steps=7 format=3 uid="uid://duhatjwr2uvue"]
+
+[ext_resource type="Script" path="res://scripts/game.gd" id="1_cbchi"]
+[ext_resource type="Shader" path="res://assets/shaders/bg.gdshader" id="2_rp0o8"]
+[ext_resource type="Texture2D" uid="uid://yeqb8ndri7xp" path="res://assets/noise/noise.tres" id="3_oudqo"]
+[ext_resource type="Texture2D" uid="uid://ceas3dsjeq4ge" path="res://assets/noise/noise2.tres" id="4_n8ady"]
+[ext_resource type="Texture2D" uid="uid://m6ki73qfbp2s" path="res://assets/noise/noise3.tres" id="5_hkjcj"]
+
+[sub_resource type="ShaderMaterial" id="ShaderMaterial_gdbwp"]
+shader = ExtResource("2_rp0o8")
+shader_parameter/color1 = Vector3(0.2, 0.5, 0.5)
+shader_parameter/color2 = Vector3(0, 0.1, 0.1)
+shader_parameter/color3 = Vector3(0.1, 0.1, 0.5)
+shader_parameter/speed = 0.005
+shader_parameter/direction = Vector2(0.25, -0.25)
+shader_parameter/noise = ExtResource("3_oudqo")
+shader_parameter/noise2 = ExtResource("4_n8ady")
+shader_parameter/noise3 = ExtResource("5_hkjcj")
+
+[node name="Game" type="Node"]
+script = ExtResource("1_cbchi")
+X = 8
+Y = 8
+dark = Color(0.055, 0.298, 0.496, 1)
+light = Color(0.82606, 0.82606, 0.82606, 1)
+
+[node name="ShadowContainer" type="Node2D" parent="."]
+
+[node name="TileContainer" type="Node2D" parent="."]
+z_index = 1
+
+[node name="PieceContainer" type="Node2D" parent="."]
+z_index = 3
+texture_filter = 1
+
+[node name="Background" type="ColorRect" parent="."]
+z_index = -1
+material = SubResource("ShaderMaterial_gdbwp")
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2

scripts/game.gd

+extends Node
+class_name game
+
+@export var X : int
+@export var Y : int
+@export var tile_size = 64
+@export var dark = Color(0,0,0)
+@export var light =Color(1,1,1)
+
+@onready var opponent_shader: ShaderMaterial = ShaderMaterial.new()
+
+@onready var background = $Background
+@onready var tile_container = $TileContainer
+@onready var shadow_container = $ShadowContainer
+@onready var piece_container = $PieceContainer
+@onready var board = []
+
+
+var selected_piece
+var selected_piece_value
+var selected_piece_position
+var valid_moves = []
+@onready var selected_shader: ShaderMaterial = ShaderMaterial.new()
+
+
+
+func _ready() -> void:
+	DisplayServer.window_set_min_size(Vector2(1152, 648))  # Set minimum window size
+	
+	#creates 2D array for board, with empty ('0') spaces
+	for x in range(X): 
+		board.append([])
+		for y in range(Y): 
+			board[x].append('0')
+	
+	
+	#hard-coded setup of pieces
+	board[0][7] = 'r'
+	board[1][7] = 'b'
+	board[2][7] = 'kn'
+	board[3][7] = 'p'
+	board[4][7] = 'p'
+	board[5][7] = 'kn'
+	board[6][7] = 'b'
+	board[7][7] = 'r'
+	
+	board[0][0] = 'R'
+	board[1][0] = 'B'
+	board[2][0] = 'KN'
+	board[3][0] = 'P'
+	board[4][0] = 'P'
+	board[5][0] = 'KN'
+	board[6][0] = 'B'
+	board[7][0] = 'R'
+	
+	#potential 'holes', not quite working yet
+	#board[3][3] = '/'
+	
+	draw_board(X,Y)
+	
+	#set up color for opponent's shader, currently set to black
+	opponent_shader.shader = preload("res://assets/shaders/color.gdshader").duplicate()
+	opponent_shader.set_shader_parameter('r', 0.2)
+	opponent_shader.set_shader_parameter('g', 0.2)
+	opponent_shader.set_shader_parameter('b', 0.2)
+	
+	#set up color for selected piece's shader, currently set to red
+	selected_shader.shader = preload("res://assets/shaders/color.gdshader").duplicate()
+	selected_shader.set_shader_parameter('r', 1.0)
+	selected_shader.set_shader_parameter('g', 0.5)
+	selected_shader.set_shader_parameter('b', 0.5)
+	draw_pieces()
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta: float) -> void:
+	#dynamically translates loaction of board and pieces to remain in corrent location
+	tile_container.position = translate()
+	shadow_container.position = translate()
+	piece_container.position = translate()
+	
+	#attempt at linear interpolation for smooth movement of pieces#
+	#if selected_piece != null:
+		#var target_position = selected_piece_position*tile_size
+		#if selected_piece.position != target_position:
+			#selected_piece.position = selected_piece.position.lerp(target_position, 5 * delta)
+
+
+func draw_pieces():
+	#iterate through all tiles, if tile has a piece, 
+	#add corresponding piece with correct sprite to piece_container
+	for x in range(X):
+		for y in range(Y):
+			if !is_empty(x,y):
+				#create new texture rect
+				var piece = TextureRect.new()
+				#translate array index to screen coordinates
+				piece.position = Vector2(x*tile_size, y*tile_size)
+				piece.size = Vector2(64,64)
+				piece.z_index = 3
+				if board[x][y] == 'p' || board[x][y] == 'P':
+					piece.texture = preload("res://assets/sprites/pawn.png")
+				elif board[x][y] == 'r' ||  board[x][y] == 'R':
+					piece.texture = preload("res://assets/sprites/rook.png")
+				elif board[x][y] == 'kn' || board[x][y] == 'KN':
+					piece.texture = preload("res://assets/sprites/knight.png")
+				elif board[x][y] == 'b' || board[x][y] == 'B':
+					piece.texture = preload("res://assets/sprites/bishop.png")
+				elif board[x][y] == 'q' || board[x][y] == 'Q':
+					piece.texture = preload("res://assets/sprites/knight.png")
+				
+				#if piece is opponent add a black shader to piece
+				if is_opponent(x,y):
+					piece.material = opponent_shader
+				piece_container.add_child(piece)
+
+
+#translates 'home' coordinates ((0,0)) to screen location 
+#used to center board, shadow and pieces at 2/3 of x axis and 1/2 of y axis
+func translate() -> Vector2:
+	var screen_size = get_viewport().get_visible_rect().size
+	var board_x_offset = X * tile_size / 2
+	var board_y_offset = Y * tile_size / 2
+	#places top left corner at 2/3 of x axis and 1/2 of y axis, then translates to center 
+	return Vector2(screen_size.x * 2 / 3 - board_x_offset, screen_size.y / 2 - board_y_offset)
+
+
+func draw_board(X, Y):
+	for x in range(X):
+		for y in range(Y):
+			if board[x][y] == '/':
+				pass
+			else:
+				var tile = ColorRect.new()
+				if (x + y)%2 == 0:
+					tile.color = light
+				else:
+					tile.color = dark
+				tile.size = Vector2(tile_size, tile_size)
+				tile.position = Vector2(x * tile_size, y * tile_size)
+				
+				tile_container.add_child(tile)
+				var screen_size = get_viewport().get_visible_rect().size
+				var board_x_offset = X * tile_size / 2
+				var board_y_offset = Y * tile_size / 2
+				#tile_container.position = placement()
+				
+				var shadow_shader = ShaderMaterial.new()
+				shadow_shader.shader = preload("res://assets/shaders/shadow.gdshader")
+				
+				var shadow = ColorRect.new()
+				shadow.size = Vector2(tile_size, tile_size)
+				shadow.position = Vector2(x * tile_size + 15, y * tile_size + 15)
+				
+				shadow.material = shadow_shader
+				shadow_container.add_child(shadow)
+				#shadow_container.position = placement()
+
+
+
+#detects if mouse events occur within the board
+func is_on_board(position : Vector2) -> bool:
+	if position.x < (X * tile_size) && position.x > 0:
+		if position.y < (Y * tile_size) && position.y > 0:
+			return true
+	return false
+
+func _input(event):
+	if event is InputEventMouseButton:
+		#handles only mouse clicks
+		if event.pressed:
+			#translate the mouse click position to 'home' coordinates (start at 0,0)
+			var translated_postition = event.position - translate()
+			#if the click is within the board, proceed
+			if is_on_board(translated_postition):
+				#translates mouse position to array index. 
+				#example: (66.5, 99.9) = (1, 1) , (120.0, 12.0) = (2, 0)
+				var mouse_position = Vector2(int(translated_postition.x / tile_size), int(translated_postition.y / tile_size))
+				
+				var x = mouse_position.x
+				var y = mouse_position.y
+				
+				#if mouse click is a left click, proceed
+				if event.button_index == MOUSE_BUTTON_LEFT:
+					#if the tile is a player's piece, select or deselect it
+					if !is_empty(x,y) && !(is_opponent(x,y)):
+						#if there is a currently selected piece that is on the selected tile, deselect that piece
+						if selected_piece!=null:
+							if board[x][y] == board[selected_piece_position.x][selected_piece_position.y]:
+								unselect_piece(x,y)
+						#otherwise, select the piece
+						else:
+							select_piece(x,y)
+					#if the tile is empty or an opponents piece, move the selected piece to that tile
+					else:
+						move_selected_piece(x,y)
+
+
+func is_opponent(x,y):
+	if board[x][y] == '0':
+		return false
+	else:
+		#if the value of board[x][y] is uppercase, it is an opponent piece
+		return board[x][y] == board[x][y].to_upper()
+
+
+
+func is_empty(x,y):
+	return board[x][y] == '0'
+
+#test funciton to add pieces to board
+#func add_pawn(x, y):
+	#var piece = TextureRect.new()
+	#piece.position = Vector2(x*tile_size, y*tile_size)
+	#piece.size = Vector2(64,64)
+	#piece.z_index = 3
+	#piece.texture = preload("res://pawn.png")
+	#piece_container.add_child(piece)
+
+
+func remove_piece(x,y):
+	#iterate through the pieces in piece_container, if that piece is at location x,y, remove it
+	for child in piece_container.get_children():
+		#translate x,y index values to screen coordinates
+		if child.position == Vector2(x*tile_size, y*tile_size):
+			piece_container.remove_child(child)
+			child.queue_free()
+			break
+			
+func select_piece(x,y):
+	unselect_piece(x,y)
+	
+	#iterate through the pieces in piece_container, if that piece is at location x,y, select it
+	for child in piece_container.get_children():
+		if child.position == Vector2(x*tile_size, y*tile_size):
+			selected_piece_position = Vector2(x,y)
+			selected_piece = child
+			selected_piece_value = board[x][y]
+			#add a red coloured shader to the selected piece
+			child.material = selected_shader
+			
+			#highlight the valid moves the selected piece can make
+			highlight_tiles()
+
+func unselect_piece(x,y):
+	if selected_piece != null:
+		selected_piece.material = null
+		selected_piece = null
+		selected_piece_value = null
+	remove_highlight()
+
+func highlight_tiles():
+	#clear the previously selected valid moves
+	remove_highlight()
+	valid_moves = []
+	
+	var sel_x = selected_piece_position.x
+	var sel_y = selected_piece_position.y
+
+	#valid pawn moves
+	if selected_piece_value == 'p':
+		#one tile up if tile is empty
+		if is_empty(sel_x, sel_y-1):
+			valid_moves.append(Vector2(sel_x, sel_y - 1))
+		#one tile up and one tile right if tile is oponent
+		if is_opponent(sel_x + 1, sel_y - 1):
+			valid_moves.append(Vector2(sel_x + 1, sel_y - 1))
+		#one tile up and one tile left if tile is oponent
+		if is_opponent(sel_x - 1, sel_y - 1):
+			valid_moves.append(Vector2(sel_x - 1, sel_y - 1))
+
+	#valid rook moves
+	elif selected_piece_value == 'r':
+		#valid moves to right of rook
+		#iterate through the amount of X tiles
+		for x in range(1, X + 1):
+			var new_x = sel_x + x 
+			if new_x < X:
+				#if tile is opponent, valid move, end path
+				if !is_empty(new_x, sel_y):
+					if is_opponent(new_x,sel_y):
+						valid_moves.append(Vector2(new_x, selected_piece_position.y))
+						break
+					#if tile is player piece, not valid, end path
+					else:
+						break
+				#if tile is open, valid move, keep searching
+				valid_moves.append(Vector2(new_x, sel_y))
+			else:
+				break
+		
+		#repeat for left
+		for x in range(1, X + 1):
+			var new_x = sel_x - x
+			if new_x >= 0:
+				if !is_empty(new_x, sel_y):
+					if is_opponent(new_x,sel_y):
+						valid_moves.append(Vector2(new_x, selected_piece_position.y))
+						break
+					else:
+						break
+				valid_moves.append(Vector2(new_x, sel_y))
+			else:
+				break
+
+		#repeat for down
+		for y in range(1, Y + 1):
+			var new_y = sel_y + y
+			if new_y < Y:
+				if !is_empty(sel_x, new_y):
+					if is_opponent(sel_x, new_y):
+						valid_moves.append(Vector2(selected_piece_position.x, new_y))
+						break
+					else:
+						break
+				valid_moves.append(Vector2(selected_piece_position.x, new_y))
+			else:
+				break
+		
+		#repeat for up
+		for y in range(1, Y + 1):
+			var new_y = sel_y - y
+			if new_y < Y:
+				if !is_empty(sel_x, new_y):
+					if is_opponent(sel_x, new_y):
+						valid_moves.append(Vector2(selected_piece_position.x, new_y))
+						break
+					else:
+						break
+				valid_moves.append(Vector2(selected_piece_position.x, new_y))
+			else:
+				break
+
+
+	#valid bishop moves
+	elif selected_piece_value == 'b':
+		#valid moves diagonally down and right
+		#iterate through all tiles
+		for x in range(1, X):
+			var new_x = sel_x + x
+			var new_y = sel_y + x
+			#if within board range
+			if new_x < X && new_y < Y:
+				#if tile empty, valid tile, keep searching
+				if is_empty(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+				#if opponent, valid tile, end path
+				elif  is_opponent(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+					break
+				#if player, invalid tile, end path
+				else:
+					break
+			#if outside of range, invalid, end path
+			else:
+				break
+
+		#repeat for diagonaly up and left
+		for x in range(1, X):
+			var new_x = sel_x - x
+			var new_y = sel_y - x
+			if new_x >= 0 && new_y >= 0:
+				if is_empty(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+				elif  is_opponent(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+					break
+				else:
+					break
+			else:
+				break
+		
+		#repeat for diagonaly down and left
+		for x in range(1, X):
+			var new_x = sel_x - x
+			var new_y = sel_y + x
+			if new_x >= 0 && new_y < Y:
+				if is_empty(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+				elif  is_opponent(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+					break
+				else:
+					break
+			else:
+				break
+		
+		#repeat for diagonaly up and right
+		for x in range(1, X):
+			var new_x = sel_x + x
+			var new_y = sel_y - x
+			if new_x < X && new_y >= 0:
+				if is_empty(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+				elif  is_opponent(new_x, new_y):
+					valid_moves.append(Vector2(new_x, new_y))
+					break
+				else:
+					break
+			else:
+				break
+
+
+	#valid knight moves
+	elif selected_piece_value == 'kn':
+		#check if tile in 'L' shape is open or opponent, then valid tile
+		#invalid if tile has player piece or outside of board range
+		#repeat for all 8 directions
+		if (sel_x + 2) < X && (sel_y + 1) < Y:
+			if is_empty(sel_x + 2, sel_y + 1) || is_opponent(sel_x + 2, sel_y + 1):
+				valid_moves.append(Vector2(sel_x + 2, sel_y + 1))
+		if (sel_x - 2) >= 0 && (sel_y + 1) < Y:
+			if is_empty(sel_x - 2, sel_y + 1) || is_opponent(sel_x - 2, sel_y + 1):
+				valid_moves.append(Vector2(sel_x - 2, sel_y + 1))
+		if (sel_x + 2) < X && (sel_y - 1) >= 0:
+			if is_empty(sel_x + 2, sel_y - 1) || is_opponent(sel_x + 2, sel_y - 1):
+				valid_moves.append(Vector2(sel_x + 2, sel_y - 1))
+		if (sel_x - 2) >= 0 && (sel_y - 1) >= 0:
+			if is_empty(sel_x - 2, sel_y - 1) || is_opponent(sel_x - 2, sel_y - 1):
+				valid_moves.append(Vector2(sel_x - 2, sel_y - 1))
+		
+		if (sel_x + 1) < X && (sel_y + 2) < Y:
+			if is_empty(sel_x + 1, sel_y + 2) || is_opponent(sel_x + 1, sel_y + 2):
+				valid_moves.append(Vector2(sel_x + 1, sel_y + 2))
+		if (sel_x - 1) >= 0 && (sel_y + 2) < Y:
+			if is_empty(sel_x - 1, sel_y + 2) || is_opponent(sel_x - 1, sel_y + 2):
+				valid_moves.append(Vector2(sel_x - 1, sel_y + 2))
+		if (sel_x + 1) < X && (sel_y - 2) >= 0:
+			if is_empty(sel_x + 1, sel_y - 2) || is_opponent(sel_x + 1, sel_y - 2):
+				valid_moves.append(Vector2(sel_x + 1, sel_y - 2))
+		if (sel_x - 1) >= 0 && (sel_y - 2) >= 0:
+			if is_empty(sel_x - 1, sel_y - 2) || is_opponent(sel_x - 1, sel_y - 2):
+				valid_moves.append(Vector2(sel_x - 1, sel_y - 2))
+
+	for child in tile_container.get_children():
+		if child.position/tile_size in valid_moves:
+			child.modulate = Color(1,0.5,0.5)
+		else:
+			child.modulate = Color(1,1,1)
+
+
+
+func remove_highlight():
+	#remove all highlights from tiles in tile_container
+	for child in tile_container.get_children():
+		child.modulate = Color(1,1,1)
+	valid_moves = []
+
+
+
+func move_selected_piece(x,y):
+	#can only move a piece if selected_piece exists
+	if selected_piece != null:
+		#can only move to tiles in valid_moves
+		if Vector2(x,y) in valid_moves:
+			#if tile has opponent piece, remove piece
+			if is_opponent(x,y):
+				remove_piece(x,y)
+			#clear the selected_piece's previous position
+			board[selected_piece_position.x][selected_piece_position.y] = '0'
+			#update selected_piece's screen coordinate position
+			selected_piece_position = Vector2(x*tile_size, y*tile_size)
+			#
+			selected_piece.position = selected_piece_position
+			board[x][y] = selected_piece_value
+		
+		#clear selection after move
+		selected_piece.material = null
+		selected_piece = null
+		selected_piece_value = null
+		remove_highlight()
+		
+