pastemyst | Code

Code

Enemy.gd

JavaScriptcopy raw

extends KinematicBody2D

export(int) var SPEED: int = 40
var velocity: Vector2 = Vector2.ZERO

var path: Array = []	# Contains destination positions
var levelNavigation: Navigation2D = null
var player = null
var player_spotted: bool = false
var last_direction = Vector2(0, 1)

onready var line2d = $Line2D
onready var los = $LineOfSight

func _ready():
	yield(get_tree(), "idle_frame")
	var tree = get_tree()
	if tree.has_group("LevelNavigation"):
		levelNavigation = tree.get_nodes_in_group("LevelNavigation")[0]
	if tree.has_group("Player"):
		player = tree.get_nodes_in_group("Player")[0]
		print(player)

func _physics_process(_delta):
	line2d.global_position = Vector2.ZERO
	if player:
		los.look_at(player.global_position)
		check_player_in_detection()
		if player_spotted:
			generate_path()
			navigate()
	move()

func check_player_in_detection() -> bool:
	var collider = los.get_collider()
	if collider and collider.is_in_group("Player"):
		player_spotted = true
		return true
	return false

func navigate():	# Define the next position to go to
	if path.size() > 0:
		velocity = global_position.direction_to(path[1]) * SPEED
		
		# If reached the destination, remove this point from path array
		if global_position == path[0]:
			path.pop_front()

func generate_path():	# It's obvious
	if levelNavigation != null and player != null:
		path = levelNavigation.get_simple_path(global_position, player.global_position, false)
		line2d.points = path

func move():
	velocity = move_and_slide(velocity)

Player.gd

JavaScriptcopy raw

extends KinematicBody2D

var Level0Des = Vector2(-280, -640)

var inarea1 = false
var inarea2 = false
var inarea3 = false
var inarea4 = false
var inarea5 = false
var inarea6 = false
var inarea7 = false

onready var OpenDoor = get_node("../OpenDoor")

# Player stats
var health = 100
var health_max = 100
var health_regeneration = 1
var mana = 100
var mana_max = 100
var mana_regeneration = 2

# Player movement speed
export var speed = 75
var last_direction = Vector2(0, 1)

var one_desired_zoom_out = Vector2(1.1,1.1)
var one_desired_zoom_in = Vector2(0.9,0.9)
var two_desired_zoom_out = Vector2(1.0,1.0)
var two_desired_zoom_in = Vector2(0.8,0.8)

func get_animation_direction(direction: Vector2):
	var norm_direction = direction.normalized()
	if norm_direction.x <= -0.707:
		return "left"
	elif norm_direction.x >= 0.707:
		return "right"
	return "right"

func animates_player(direction: Vector2):
	if direction != Vector2.ZERO:
		# update last_direction
		last_direction = direction
		
		# Choose walk animation based on movement direction
		var animation = get_animation_direction(last_direction) + "_run"
		
		# Play the walk animation
		$Body.play(animation)
	else:
		# Choose idle animation based on last movement direction and play it
		var animation = get_animation_direction(last_direction) + "_idle"
		$Body.play(animation)
		
		$Body.frames.set_animation_speed(animation, 2 + 8 * direction.length())

func _ready():
	$Level0.hide()
	OpenDoor.hide()

func _process(delta):
	# Regenerates mana
	var new_mana = min(mana + mana_regeneration * delta, mana_max)
	if new_mana != mana:
		mana = new_mana
		emit_signal("player_stats_changed", self)

# Regenerates health
	var new_health = min(health + health_regeneration * delta, health_max)
	if new_health != health:
		health = new_health
		emit_signal("player_stats_changed", self)

func _physics_process(delta):
	# Get player input
	var direction: Vector2
	direction.x = Input.get_action_strength("ui_right") - Input.get_action_strength("ui_left")
	direction.y = Input.get_action_strength("ui_down") - Input.get_action_strength("ui_up")
	
	# If input is digital, normalize it for diagonal movement
	if abs(direction.x) == 1 and abs(direction.y) == 1:
		direction = direction.normalized()
	
	# Apply movement
	var movement = speed * direction * delta
	move_and_collide(movement)
	
	# Animate player based on direction
	animates_player(direction)
	
	if inarea1 == true:
		if (Input.is_action_just_pressed("enter_d")):
			position = Vector2(-280, -640)

if inarea2 == true:
		if (Input.is_action_just_pressed("enter_d")):
			position = Vector2(40, -14)
	
	if inarea3 == true:
		position = Vector2(-840, -698)

if inarea4 == true:
		position = Vector2(-392, -761)
		
	if inarea5 == true:
		position = Vector2(-808, -793)
		
	if inarea6 == true:
		position = Vector2(-329, -889)
			
	if inarea7 == true:
		OpenDoor.show()
		if (Input.is_action_just_pressed("enter_d")):
			position = Vector2(40, -14)

func _on_Area2D_body_exited(_body):
	if (_body == self):
		$Level0.hide()
		inarea1 = false
		print("out area1")
func _on_Area2D_body_entered(_body):
	if (_body == self):
		$Level0.show()
		inarea1 = true
		print("in area1")
func _on_Area2D2_body_entered(_body):
	if (_body == self):
		inarea2 = true
		print("in area2")
func _on_Area2D3_body_entered(_body):
	if (_body == self):
		inarea3 = true
		print("in area3")
func _on_Area2D4_body_entered(_body):
	if (_body == self):
		inarea4 = true
		print("in area4")
func _on_Area2D2_body_exited(_body):
	if (_body == self):
		inarea2 = false
		print("out area2")
func _on_Area2D3_body_exited(_body):
	if (_body == self):
		inarea3 = false
		print("out area3")
func _on_Area2D4_body_exited(_body):
	if (_body == self):
		inarea4 = false
		print("out area4")
func _on_Area2D5_body_entered(_body):
	if (_body == self):
		inarea5 = true
		print("in area5")
func _on_Area2D5_body_exited(_body):
	if (_body == self):
		inarea5 = false
		print("out area5")
func _on_Area2D6_body_entered(_body):
	if (_body == self):
		inarea6 = true
		print("in area6")
func _on_Area2D6_body_exited(_body):
	if (_body == self):
		inarea6 = false
		print("out area6")
func _on_Area2D7_body_entered(_body):
	if (_body == self):
		OpenDoor.show()
		inarea7 = true
		print("in area7")
func _on_Area2D7_body_exited(_body):
	if (_body == self):
		OpenDoor.hide()
		inarea7 = false
		print("out area7")

func _on_Layer1_body_entered(_body):
	$Body.scale = Vector2(1.0, 1.0)
	$CollisionShape2D.scale = Vector2(1.0, 1.0)
	
func _on_Layer1_body_exited(_body):
	$Body.scale = Vector2(0.9, 0.9)
	$CollisionShape2D.scale = Vector2(0.9, 0.9)
	
func _on_Layer2_body_entered(_body):
	$Body.scale = Vector2(0.9, 0.9)
	$CollisionShape2D.scale = Vector2(0.9, 0.9)

func _on_Layer2_body_exited(_body):
	$Body.scale = Vector2(0.8, 0.8)
	$CollisionShape2D.scale = Vector2(0.8, 0.8)

TileMap.gd

JavaScriptcopy raw

extends TileMap

# You can only create an AStar node from code, not from the Scene tab
onready var astar_node = AStar.new()
# The Tilemap node doesn't have clear bounds so we're defining the map's limits here
export(Vector2) var map_size = Vector2(16, 16)

# The path start and end variables use setter methods
# You can find them at the bottom of the script
var path_start_position = Vector2() setget _set_path_start_position
var path_end_position = Vector2() setget _set_path_end_position

var _point_path = []

const BASE_LINE_WIDTH = 3.0
const DRAW_COLOR = Color('#fff')

# get_used_cells_by_id is a method from the TileMap node
# here the id 0 corresponds to the grey tile, the obstacles
onready var obstacles = get_used_cells_by_id(0)
onready var _half_cell_size = cell_size / 2

func _ready():
	var walkable_cells_list = astar_add_walkable_cells(obstacles)
	astar_connect_walkable_cells(walkable_cells_list)

# Click and Shift force the start and end position of the path to update
# and the node to redraw everything
#func _input(event):
#	if event.is_action_pressed('click') and Input.is_key_pressed(KEY_SHIFT):
#		# To call the setter method from this script we have to use the explicit self.
#		self.path_start_position = world_to_map(get_global_mouse_position())
#	elif event.is_action_pressed('click'):
#		self.path_end_position = world_to_map(get_global_mouse_position())

# Loops through all cells within the map's bounds and
# adds all points to the astar_node, except the obstacles
func astar_add_walkable_cells(obstacles = []):
	var points_array = []
	for y in range(map_size.y):
		for x in range(map_size.x):
			var point = Vector2(x, y)
			if point in obstacles:
				continue

points_array.append(point)
			# The AStar class references points with indices
			# Using a function to calculate the index from a point's coordinates
			# ensures we always get the same index with the same input point
			var point_index = calculate_point_index(point)
			# AStar works for both 2d and 3d, so we have to convert the point
			# coordinates from and to Vector3s
			astar_node.add_point(point_index, Vector3(point.x, point.y, 0.0))
	return points_array

# Once you added all points to the AStar node, you've got to connect them
# The points don't have to be on a grid: you can use this class
# to create walkable graphs however you'd like
# It's a little harder to code at first, but works for 2d, 3d,
# orthogonal grids, hex grids, tower defense games...
func astar_connect_walkable_cells(points_array):
	for point in points_array:
		var point_index = calculate_point_index(point)
		# For every cell in the map, we check the one to the top, right.
		# left and bottom of it. If it's in the map and not an obstalce,
		# We connect the current point with it
		var points_relative = PoolVector2Array([
			Vector2(point.x + 1, point.y),
			Vector2(point.x - 1, point.y),
			Vector2(point.x, point.y + 1),
			Vector2(point.x, point.y - 1)])
		for point_relative in points_relative:
			var point_relative_index = calculate_point_index(point_relative)

if is_outside_map_bounds(point_relative):
				continue
			if not astar_node.has_point(point_relative_index):
				continue
			# Note the 3rd argument. It tells the astar_node that we want the
			# connection to be bilateral: from point A to B and B to A
			# If you set this value to false, it becomes a one-way path
			# As we loop through all points we can set it to false
			astar_node.connect_points(point_index, point_relative_index, false)

# This is a variation of the method above
# It connects cells horizontally, vertically AND diagonally
func astar_connect_walkable_cells_diagonal(points_array):
	for point in points_array:
		var point_index = calculate_point_index(point)
		for local_y in range(3):
			for local_x in range(3):
				var point_relative = Vector2(point.x + local_x - 1, point.y + local_y - 1)
				var point_relative_index = calculate_point_index(point_relative)

if point_relative == point or is_outside_map_bounds(point_relative):
					continue
				if not astar_node.has_point(point_relative_index):
					continue
				astar_node.connect_points(point_index, point_relative_index, true)

func is_outside_map_bounds(point):
	return point.x < 0 or point.y < 0 or point.x >= map_size.x or point.y >= map_size.y

func calculate_point_index(point):
	return point.x + map_size.x * point.y

func find_path(world_start, world_end):
	self.path_start_position = world_to_map(world_start)
	self.path_end_position = world_to_map(world_end)
	_recalculate_path()
	var path_world = []
	for point in _point_path:
		var point_world = map_to_world(Vector2(point.x, point.y)) + _half_cell_size
		path_world.append(point_world)
	return path_world

func _recalculate_path():
	clear_previous_path_drawing()
	var start_point_index = calculate_point_index(path_start_position)
	var end_point_index = calculate_point_index(path_end_position)
	# This method gives us an array of points. Note you need the start and end
	# points' indices as input
	_point_path = astar_node.get_point_path(start_point_index, end_point_index)
	# Redraw the lines and circles from the start to the end point
	update()

func clear_previous_path_drawing():
	if not _point_path:
		return
	var point_start = _point_path[0]
	var point_end = _point_path[len(_point_path) - 1]
	set_cell(point_start.x, point_start.y, -1)
	set_cell(point_end.x, point_end.y, -1)

func _draw():
	if not _point_path:
		return
	var point_start = _point_path[0]
	var point_end = _point_path[len(_point_path) - 1]

set_cell(point_start.x, point_start.y, 1)
	set_cell(point_end.x, point_end.y, 2)

var last_point = map_to_world(Vector2(point_start.x, point_start.y)) + _half_cell_size
	for index in range(1, len(_point_path)):
		var current_point = map_to_world(Vector2(_point_path[index].x, _point_path[index].y)) + _half_cell_size
		draw_line(last_point, current_point, DRAW_COLOR, BASE_LINE_WIDTH, true)
		draw_circle(current_point, BASE_LINE_WIDTH * 2.0, DRAW_COLOR)
		last_point = current_point

# Setters for the start and end path values.
func _set_path_start_position(value):
	if value in obstacles:
		return
	if is_outside_map_bounds(value):
		return

set_cell(path_start_position.x, path_start_position.y, -1)
	set_cell(value.x, value.y, 1)
	path_start_position = value
	if path_end_position and path_end_position != path_start_position:
		_recalculate_path()

func _set_path_end_position(value):
	if value in obstacles:
		return
	if is_outside_map_bounds(value):
		return

set_cell(path_start_position.x, path_start_position.y, -1)
	set_cell(value.x, value.y, 2)
	path_end_position = value
	if path_start_position != value:
		_recalculate_path()

created at:

stats: 438 lines, 1509 words, 13.04kb