diff --git a/proto2/autoloads/notifications.gd b/proto2/autoloads/notifications.gd index d9b35c8..0e87852 100644 --- a/proto2/autoloads/notifications.gd +++ b/proto2/autoloads/notifications.gd @@ -6,6 +6,7 @@ extends Node # Called when the node enters the scene tree for the first time. var quest_notification_scene = preload("res://ui/start_quest_notification.tscn") +var quest_complete_notification_scene = preload("res://ui/quest_complete_notification.tscn") var qn: Node func _ready(): pass # Replace with function body. @@ -17,12 +18,15 @@ func _ready(): var queue = [] const cooldown_time: float = 3.0 var time_count: float = 0.0 -enum {N_QUEST, N_OTHER} +enum {N_QUEST, N_QUEST_COMPLETE, N_OTHER} enum {STATE_INIT, STATE_IDLE, STATE_DISPLAY} var state: int = STATE_INIT func quest_notfication(title, desc): queue.push_back({"type": N_QUEST, "title": title, "desc": desc}) +func quest_complete_notfication(title, desc): + queue.push_back({"type": N_QUEST_COMPLETE, "title": title, "desc": desc}) + func _process(delta): match(state): STATE_INIT: @@ -49,6 +53,11 @@ func _process(delta): get_node("/root/main").add_child(qn) qn.display_notification(data.title, data.desc) time_count = 0.0 + N_QUEST_COMPLETE: + qn = quest_complete_notification_scene.instance() + get_node("/root/main").add_child(qn) + qn.display_notification(data.title) + time_count = 0.0 state = STATE_IDLE if time_count < 2000.0: time_count += delta diff --git a/proto2/autoloads/roadmap.gd b/proto2/autoloads/roadmap.gd index 52c69aa..14db64b 100644 --- a/proto2/autoloads/roadmap.gd +++ b/proto2/autoloads/roadmap.gd @@ -1,21 +1,21 @@ extends Node signal complete -var map_width = 768 -var map_height = 768 +var map_width = 1280 +var map_height = 1280 var map_rect = Rect2(0, 0, map_width, map_height) enum {STATE_INIT, STATE_ITERATION, STATE_EDGES1, STATE_EDGES2, STATE_EDGES3, STATE_POLYGONS1, STATE_POLYGONS2, STATE_COMPLETE} var state = STATE_INIT -var min_distance = 3.0 +var min_distance = 12.0 var pgrow = 0.5 var rules = {} var edges = [] var pos2vertex = {} -var points = [] -var triangles = [] +var lot_points = [] +var lot_triangles = [] var pos2edge = {} var road_width: float = 6.0 var pos2id = {} @@ -24,148 +24,278 @@ var maxpos = Vector2() var vertex_queue = [] var vertices = [] var front = [] -var polygons = [] -var extra_points = [] -var polygon_queue = [] -var road_points:PoolVector2Array = PoolVector2Array() +var lots: Lots -class PointDB: - var _points: PoolVector2Array = PoolVector2Array() - var _triangles: PoolIntArray = PoolIntArray() - var _grid: Array = [] - var _grid_size: int = -1 - var grid_w: int - var grid_h: int - var grid_offset: Vector2 - var _edges = {} - var _eid2id = {} - var _id2data = {} - var _id2pos = {} - var _pos2id = {} - var _id2edge = {} - var _edge2data = {} - func build_grid(points: Array, grid_size: int): - _points = points - _triangles = Geometry.triangulate_delaunay_2d(_points) - _grid_size = grid_size - _pos2id.clear() - _id2pos.clear() - _id2data.clear() - _id2edge.clear() - _grid.clear() - _edges.clear() - _edge2data.clear() - var rect: Rect2 = Rect2() - for p in range(_points.size()): - rect = rect.expand(_points[p]) - _pos2id[_points[p]] = p - _id2pos[p] = _points[p] - rect.position.x = floor(rect.position.x / grid_size - 1) * grid_size - rect.position.y = floor(rect.position.x / grid_size - 1) * grid_size - rect.size.x = ceil(rect.size.x / grid_size + 1) * grid_size - rect.size.y = ceil(rect.size.x / grid_size + 1) * grid_size - grid_w = int((rect.size.x + 1)/ grid_size) - grid_h = int((rect.size.x + 1)/ grid_size) - grid_offset = rect.position - _grid.resize((grid_w + 1) * (grid_h + 1)) - for p in range(_points.size()): - var grid_x = int((_points[p].x - grid_offset.x) / grid_size) - var grid_y = int((_points[p].y - grid_offset.y) / grid_size) - if !_grid[grid_w * grid_y + grid_x]: - _grid[grid_w * grid_y + grid_x] = PoolIntArray() - _grid[grid_w * grid_y + grid_x].push_back(p) - for tri in range(0, _triangles.size(), 3): - var p1 = _triangles[tri + 0] - var p2 = _triangles[tri + 1] - var p3 = _triangles[tri + 2] - add_edge_id(p1, p2) - add_edge_id(p2, p3) - add_edge_id(p3, p1) - func add_point_data(p: Vector2, data: Dictionary): - if _pos2id.has(p): - _id2data[_pos2id[p]] = data - else: - breakpoint - print_debug("Bad point added") - func get_point_data(p: Vector2) -> Dictionary: - if _pos2id.has(p): - return _id2data[_pos2id[p]] - else: - return {} - func add_edge_id(a: int, b: int): - var edge_id = hash([a, b]) - _edges[edge_id] = [a, b] - if _id2edge.has(a): - _id2edge[a].push_back(edge_id) - else: - _id2edge[a] = [edge_id] - if _id2edge.has(b): - _id2edge[b].push_back(edge_id) - else: - _id2edge[b] = [edge_id] - func add_edge(a: Vector2, b: Vector2): - if _pos2id.has(a) && _pos2id.has(b): - add_edge_id(_pos2id[a], _pos2id[b]) - else: - breakpoint - print_debug("Bad edge added") - func add_edge_data(a: Vector2, b: Vector2, data: Dictionary): - assert a in _points - assert b in _points - var ai = _pos2id[a] - var bi = _pos2id[b] - var edge_id = hash([ai, bi]) - var edge_id_rev = hash([bi, ai]) - if _edges.has(edge_id): - _edge2data[edge_id] = data - return true - elif _edges.has(edge_id_rev): - _edge2data[edge_id_rev] = data - return true - else: - print_debug("No such edge ", [a, b]) - return false - func get_edge_data(a: Vector2, b: Vector2) -> Dictionary: - var ai = _pos2id[a] - var bi = _pos2id[b] - var edge_id = hash([ai, bi]) - var edge_id_rev = hash([bi, ai]) - if _edge2data.has(edge_id): - return _edge2data[edge_id] - elif _edge2data.has(edge_id_rev): - return _edge2data[edge_id_rev] - else: - return {} - func get_point_edges(a: Vector2) -> Array: - var ret : = [] - var edges = _id2edge[_pos2id[a]] - for e in edges: - var ed = _edges[e] - ret.push_back([_id2pos[ed[0]], _id2pos[ed[1]]]) - return ret - func get_polygons() -> Array: - var ret = [] - for t in range(0, _triangles.size(), 3): - var p1 = _points[_triangles[t + 0]] - var p2 = _points[_triangles[t + 1]] - var p3 = _points[_triangles[t + 2]] - ret.push_back([p1, p2, p3, get_edge_data(p1, p2), get_edge_data(p2, p3), get_edge_data(p3, p1)]) +class Lots: + enum {LOT_FOREST, LOT_AIRPORT, LOT_PARK, LOT_CEMETERY, LOT_RESIDENTAL, LOT_INDUSTRIAL} + var lot_types = { + "forest": { + "w": 500, + "h": 500, + "type": LOT_FOREST, + "center_distance": 400.0 + }, + "airport": { + "w": 500, + "h": 500, + "type": LOT_AIRPORT, + "center_distance": 400.0 + }, + "park": { + "w": 300, + "h": 300, + "type": LOT_PARK, + "center_distance": 0.0 + }, + "cemetery": { + "w": 200, + "h": 200, + "type": LOT_CEMETERY, + "center_distance": 0.0 + }, + "residental1": { + "w": 100, + "h": 100, + "type": LOT_RESIDENTAL, + "center_distance": 0.0 + }, + "residental2": { + "w": 50, + "h": 50, + "type": LOT_RESIDENTAL, + "center_distance": 0.0 + }, + "residental3": { + "w": 20, + "h": 20, + "type": LOT_RESIDENTAL, + "center_distance": 0.0 + }, + "industrial": { + "w": 100, + "h": 100, + "type": LOT_RESIDENTAL, + "center_distance": 200.0 + }, + } + var lots = [] + func make_lot_polygon(lot_name: String): + var lot_type = lot_types[lot_name] + var p1 = Vector2(-lot_type.w * 0.5, -lot_type.h * 0.5) + var p2 = Vector2(lot_type.w * 0.5, -lot_type.h * 0.5) + var p3 = Vector2(lot_type.w * 0.5, lot_type.h * 0.5) + var p4 = Vector2(-lot_type.w * 0.5, lot_type.h * 0.5) + return [p1, p2, p3, p4] +# func get_polygon_center(polygon): +# var ret: Vector2 = Vector2() +# for m in range(polygon.size()): +# ret += polygon[m] +# return ret / 4.0 + func get_lot_transform(p1: Vector2, p2: Vector2, road_width: float, sidewalk_width: float, polygon: Array): + var n = (p2-p1).tangent().normalized() + var offset1 = n * (road_width + sidewalk_width) + var offset2 = Vector2() + for v in range(polygon.size()): + if offset2.x < polygon[v].x: + offset2.x = polygon[v].x + if offset2.y < polygon[v].y: + offset2.y = polygon[v].y + var ret = Transform2D((p2 - p1).angle(), p1.linear_interpolate(p2, 0.5) + offset1 + offset2) return ret + func transformed_polygon(xform: Transform2D, polygon: Array): + return Array(Geometry.transform_points_2d(PoolVector2Array(polygon), xform)) + func polygon_intersects_road(polygon, vertices): + for v in range(vertices.size()): + var p1 = vertices[v].pos + for k in vertices[v]._neighbors: + var p2 = vertices[k].pos + if Geometry.segment_intersects_segment_2d(p1, p2, polygon[0], polygon[1]): + return true + if Geometry.segment_intersects_segment_2d(p1, p2, polygon[1], polygon[2]): + return true + if Geometry.segment_intersects_segment_2d(p1, p2, polygon[2], polygon[3]): + return true + if Geometry.segment_intersects_segment_2d(p1, p2, polygon[3], polygon[0]): + return true + if Geometry.point_is_inside_triangle(p1, polygon[0], polygon[1], polygon[2]): + return true + if Geometry.point_is_inside_triangle(p1, polygon[0], polygon[2], polygon[3]): + return true + if Geometry.point_is_inside_triangle(p2, polygon[0], polygon[1], polygon[2]): + return true + if Geometry.point_is_inside_triangle(p2, polygon[0], polygon[2], polygon[3]): + return true + return false + func generate_lots(vertices, road_width, sidewalk_width, map_width, map_height): + for v in range(vertices.size()): + var p1 = vertices[v].pos + for k in vertices[v]._neighbors: + for d in range(10): + var p2 = vertices[k].pos + var lot_type_name = lot_types.keys()[randi() % lot_types.keys().size()] + var polygon = make_lot_polygon(lot_type_name) + var xform = get_lot_transform(p1, p2, road_width, sidewalk_width, polygon) + if polygon_intersects_road(transformed_polygon(xform, polygon), vertices): + continue + var xfpoly = transformed_polygon(xform, polygon) + var bad = false + for r in lots: + var poly2 = transformed_polygon(r.xform, r.polygon) + if Geometry.intersect_polygons_2d(xfpoly, poly2).size() > 0: + bad = true + break + if xform.origin.distance_to(Vector2(map_width * 0.5, map_height * 0.5)) < lot_types[lot_type_name].center_distance: + bad = true + if bad: + continue + lots.push_back({ + "polygon": polygon, + "xform": xform + }) + break + + +#class PointDB: +# var _points: PoolVector2Array = PoolVector2Array() +# var _triangles: PoolIntArray = PoolIntArray() +# var _grid: Array = [] +# var _grid_size: int = -1 +# var grid_w: int +# var grid_h: int +# var grid_offset: Vector2 +# var _edges = {} +# var _eid2id = {} +# var _id2data = {} +# var _id2pos = {} +# var _pos2id = {} +# var _id2edge = {} +# var _edge2data = {} +# func build_grid(points: Array, grid_size: int): +# _points = points +# _triangles = Geometry.triangulate_delaunay_2d(_points) +# _grid_size = grid_size +# _pos2id.clear() +# _id2pos.clear() +# _id2data.clear() +# _id2edge.clear() +# _grid.clear() +# _edges.clear() +# _edge2data.clear() +# var rect: Rect2 = Rect2() +# for p in range(_points.size()): +# rect = rect.expand(_points[p]) +# _pos2id[_points[p]] = p +# _id2pos[p] = _points[p] +# rect.position.x = floor(rect.position.x / grid_size - 1) * grid_size +# rect.position.y = floor(rect.position.x / grid_size - 1) * grid_size +# rect.size.x = ceil(rect.size.x / grid_size + 1) * grid_size +# rect.size.y = ceil(rect.size.x / grid_size + 1) * grid_size +# grid_w = int((rect.size.x + 1)/ grid_size) +# grid_h = int((rect.size.x + 1)/ grid_size) +# grid_offset = rect.position +# _grid.resize((grid_w + 1) * (grid_h + 1)) +# for p in range(_points.size()): +# var grid_x = int((_points[p].x - grid_offset.x) / grid_size) +# var grid_y = int((_points[p].y - grid_offset.y) / grid_size) +# if !_grid[grid_w * grid_y + grid_x]: +# _grid[grid_w * grid_y + grid_x] = PoolIntArray() +# _grid[grid_w * grid_y + grid_x].push_back(p) +# for tri in range(0, _triangles.size(), 3): +# var p1 = _triangles[tri + 0] +# var p2 = _triangles[tri + 1] +# var p3 = _triangles[tri + 2] +# add_edge_id(p1, p2) +# add_edge_id(p2, p3) +# add_edge_id(p3, p1) +# func add_point_data(p: Vector2, data: Dictionary): +# if _pos2id.has(p): +# _id2data[_pos2id[p]] = data +# else: +# breakpoint +# print_debug("Bad point added") +# func get_point_data(p: Vector2) -> Dictionary: +# if _pos2id.has(p): +# return _id2data[_pos2id[p]] +# else: +# return {} +# func add_edge_id(a: int, b: int): +# var edge_id = hash([a, b]) +# _edges[edge_id] = [a, b] +# if _id2edge.has(a): +# _id2edge[a].push_back(edge_id) +# else: +# _id2edge[a] = [edge_id] +# if _id2edge.has(b): +# _id2edge[b].push_back(edge_id) +# else: +# _id2edge[b] = [edge_id] +# func add_edge(a: Vector2, b: Vector2): +# if _pos2id.has(a) && _pos2id.has(b): +# add_edge_id(_pos2id[a], _pos2id[b]) +# else: +# breakpoint +# print_debug("Bad edge added") +# func add_edge_data(a: Vector2, b: Vector2, data: Dictionary): +# assert a in _points +# assert b in _points +# var ai = _pos2id[a] +# var bi = _pos2id[b] +# var edge_id = hash([ai, bi]) +# var edge_id_rev = hash([bi, ai]) +# if _edges.has(edge_id): +# _edge2data[edge_id] = data +# return true +# elif _edges.has(edge_id_rev): +# _edge2data[edge_id_rev] = data +# return true +# else: +# print_debug("No such edge ", [a, b]) +# return false +# func get_edge_data(a: Vector2, b: Vector2) -> Dictionary: +# var ai = _pos2id[a] +# var bi = _pos2id[b] +# var edge_id = hash([ai, bi]) +# var edge_id_rev = hash([bi, ai]) +# if _edge2data.has(edge_id): +# return _edge2data[edge_id] +# elif _edge2data.has(edge_id_rev): +# return _edge2data[edge_id_rev] +# else: +# return {} +# func get_point_edges(a: Vector2) -> Array: +# var ret : = [] +# var edges = _id2edge[_pos2id[a]] +# for e in edges: +# var ed = _edges[e] +# ret.push_back([_id2pos[ed[0]], _id2pos[ed[1]]]) +# return ret +# func get_polygons() -> Array: +# var ret = [] +# for t in range(0, _triangles.size(), 3): +# var p1 = _points[_triangles[t + 0]] +# var p2 = _points[_triangles[t + 1]] +# var p3 = _points[_triangles[t + 2]] +# ret.push_back([p1, p2, p3, get_edge_data(p1, p2), get_edge_data(p2, p3), get_edge_data(p3, p1)]) +# return ret + var rnd: RandomNumberGenerator var noise: OpenSimplexNoise var complete = false -var db: PointDB +#var db: PointDB var axiom = [ new_vertex(10, 10), - new_vertex(30, 30), - new_vertex(50, 50), - new_vertex(10, 70), - new_vertex(80, 100), - new_vertex(240, 100), - new_vertex(280, 100) + new_vertex(60, 10), + new_vertex(110, 10), + new_vertex(110, 60), + new_vertex(110, 110), + new_vertex(110, 160), + new_vertex(60, 160), + new_vertex(10, 160), + new_vertex(10, 110), + new_vertex(10, 60), ] @@ -176,12 +306,9 @@ func cleanup(): vertices.clear() edges.clear() pos2vertex.clear() - points.clear() - triangles.clear() pos2edge.clear() pos2id.clear() front.clear() - polygons.clear() func new_vertex(x, y): return { @@ -331,6 +458,8 @@ func convert_vertices(): for e in range(vertices.size()): vertices[e]._neighbors = [] for h in vertices[e].neighbors: + assert h +# print(pos2vertex[h.pos]) vertices[e]._neighbors.push_back(pos2vertex[h.pos]._index) func has_neighbor(v, n): var ret = false @@ -577,27 +706,29 @@ func adjacent_edges(e1, e2): return true else: return false -func check_triangles(): - for t in triangles: - if !adjacent_edges(t[0], t[1]): - return false - if !adjacent_edges(t[1], t[2]): - return false - if !adjacent_edges(t[2], t[0]): - return false - return true +#func check_triangles(): +# for t in triangles: +# if !adjacent_edges(t[0], t[1]): +# return false +# if !adjacent_edges(t[1], t[2]): +# return false +# if !adjacent_edges(t[2], t[0]): +# return false +# return true func build(rnd_seed): cleanup() rnd.seed = rnd_seed noise.seed = rnd_seed - for k in axiom: - for l in axiom: - if k == l: - continue - k.neighbors.push_back(l) - k.axiom = true - vertices.push_back(k) + for k in range(axiom.size()): + var cur = k + var next = (k + 1) % axiom.size() + if !axiom[cur] in axiom[next].neighbors: + axiom[next].neighbors.push_back(axiom[cur]) + if !axiom[next] in axiom[cur].neighbors: + axiom[cur].neighbors.push_back(axiom[next]) + axiom[cur].axiom = true + vertices.push_back(axiom[k]) for k in vertices: if minpos.x > k.pos.x: minpos.x = k.pos.x @@ -677,39 +808,39 @@ func get_height(x, y): const sidewalk_width = 1.5 #var potential_edges = [] -func implode_road(): -# for t in range(0, db._triangles.size(), 3): - -# potential_edges.clear() - for v in vertices: - for n in v._neighbors: - var p1 = v.pos - var p2 = vertices[n].pos - var dir = (p2 - p1).normalized() - var t = dir.tangent() - for offset in [-road_width - sidewalk_width, - -road_width, - road_width, - road_width + sidewalk_width]: - var ep1 = p1 + offset - var ep2 = p2 + offset - for p in [ep1, ep2]: - if !p in extra_points && !p in points: - extra_points.push_back(p) - if !p in road_points: - road_points.push_back(p) - for offset in [-road_width - sidewalk_width - 0.1, - road_width + sidewalk_width + 0.1]: - var ep1 = p1 + offset - var ep2 = p2 + offset - for p in [ep1, ep2]: - if !p in extra_points && !p in points: - extra_points.push_back(p) - - if !p1 in road_points: - road_points.push_back(p1) - if !p2 in road_points: - road_points.push_back(p2) +#func implode_road(): +## for t in range(0, db._triangles.size(), 3): +# +## potential_edges.clear() +# for v in vertices: +# for n in v._neighbors: +# var p1 = v.pos +# var p2 = vertices[n].pos +# var dir = (p2 - p1).normalized() +# var t = dir.tangent() +# for offset in [-road_width - sidewalk_width, +# -road_width, +# road_width, +# road_width + sidewalk_width]: +# var ep1 = p1 + offset +# var ep2 = p2 + offset +# for p in [ep1, ep2]: +# if !p in extra_points && !p in points: +# extra_points.push_back(p) +# if !p in road_points: +# road_points.push_back(p) +# for offset in [-road_width - sidewalk_width - 0.1, +# road_width + sidewalk_width + 0.1]: +# var ep1 = p1 + offset +# var ep2 = p2 + offset +# for p in [ep1, ep2]: +# if !p in extra_points && !p in points: +# extra_points.push_back(p) +# +# if !p1 in road_points: +# road_points.push_back(p1) +# if !p2 in road_points: +# road_points.push_back(p2) # potential_edges.push_back([p1, ep1]) # potential_edges.push_back([p1, ep2]) # potential_edges.push_back([p2, ep3]) @@ -738,126 +869,126 @@ func implode_road(): -func build_simple_mesh(): - var arrays = [] - var verts = PoolVector3Array() - var normals = PoolVector3Array() - arrays.resize(ArrayMesh.ARRAY_MAX) - var mesh = ArrayMesh.new() - for p in polygons: - for v in p.vertices: - var v3d = Vector3() - v3d.x = v.x - float(map_width) / 2.0 - v3d.z = v.x - float(map_height) / 2.0 - v3d.y = 0 - verts.push_back(v3d) - normals.push_back(Vector3(1, 1, 1)) - arrays[ArrayMesh.ARRAY_VERTEX] = verts - arrays[ArrayMesh.ARRAY_NORMAL] = normals - mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays) - return mesh +#func build_simple_mesh(): +# var arrays = [] +# var verts = PoolVector3Array() +# var normals = PoolVector3Array() +# arrays.resize(ArrayMesh.ARRAY_MAX) +# var mesh = ArrayMesh.new() +# for p in polygons: +# for v in p.vertices: +# var v3d = Vector3() +# v3d.x = v.x - float(map_width) / 2.0 +# v3d.z = v.x - float(map_height) / 2.0 +# v3d.y = 0 +# verts.push_back(v3d) +# normals.push_back(Vector3(1, 1, 1)) +# arrays[ArrayMesh.ARRAY_VERTEX] = verts +# arrays[ArrayMesh.ARRAY_NORMAL] = normals +# mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays) +# return mesh -func build_d_mesh(): - var arrays = [] - var verts = PoolVector3Array() - var normals = PoolVector3Array() - var indices = PoolIntArray(Geometry.triangulate_delaunay_2d(points)) - arrays.resize(ArrayMesh.ARRAY_MAX) - var mesh = ArrayMesh.new() - for v in points: - var v3d = Vector3() - v3d.x = v.x - float(map_width) / 2.0 - v3d.z = v.x - float(map_height) / 2.0 - v3d.y = 0 - verts.push_back(v3d) - normals.push_back(Vector3(1, 1, 1)) - arrays[ArrayMesh.ARRAY_VERTEX] = verts - arrays[ArrayMesh.ARRAY_NORMAL] = normals - arrays[ArrayMesh.ARRAY_INDEX] = indices - mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays) - return mesh +#func build_d_mesh(): +# var arrays = [] +# var verts = PoolVector3Array() +# var normals = PoolVector3Array() +# var indices = PoolIntArray(Geometry.triangulate_delaunay_2d(points)) +# arrays.resize(ArrayMesh.ARRAY_MAX) +# var mesh = ArrayMesh.new() +# for v in points: +# var v3d = Vector3() +# v3d.x = v.x - float(map_width) / 2.0 +# v3d.z = v.x - float(map_height) / 2.0 +# v3d.y = 0 +# verts.push_back(v3d) +# normals.push_back(Vector3(1, 1, 1)) +# arrays[ArrayMesh.ARRAY_VERTEX] = verts +# arrays[ArrayMesh.ARRAY_NORMAL] = normals +# arrays[ArrayMesh.ARRAY_INDEX] = indices +# mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays) +# return mesh -func build_mesh(aabb: AABB, vn: Node): - var polylist = [] - var mesh_aabb = AABB() - var rect = Rect2(aabb.position.x + map_width / 2.0, - aabb.position.z + map_width / 2.0, aabb.size.x, aabb.size.z) - for p in polygons: - for v in p.vertices: -# print(v) - if rect.has_point(v) || true: - polylist.push_back(p) - break - var verts_road = PoolVector3Array() - var indices_road = PoolIntArray() - var normals_road = PoolVector3Array() - var verts_lot = PoolVector3Array() - var indices_lot = PoolIntArray() - var normals_lot = PoolVector3Array() - var mesh = ArrayMesh.new() - var arrays_roads = [] - var arrays_lots = [] - arrays_roads.resize(ArrayMesh.ARRAY_MAX) - arrays_lots.resize(ArrayMesh.ARRAY_MAX) - var idx_road = 0 - var idx_lot = 0 - for p in polylist: - var vid = 0 - for v in p.vertices: -# var v = p.vertices[e.indices[0]] - var v3d = Vector3() - v3d.x = v.x - float(map_width) / 2.0 - v3d.z = v.x - float(map_height) / 2.0 - v3d.y = get_height(v3d.x, v3d.z) - v3d.y = 0 - v3d *= 0.005 - mesh_aabb = mesh_aabb.expand(v3d) - if p.road: - verts_road.push_back(v3d) - normals_road.push_back(Vector3(0, 1, 0)) - indices_road.push_back(idx_road + vid) - else: - verts_lot.push_back(v3d) - normals_lot.push_back(Vector3(0, 1, 0)) - indices_lot.push_back(idx_lot + vid) - vid += 1 - if p.road: - idx_road += 3 - else: - idx_lot += 3 - print(verts_lot.size()) - print(verts_lot) -# print(indices_lot) -# print(mesh_aabb) - arrays_roads[ArrayMesh.ARRAY_VERTEX] = verts_road -# arrays_roads[ArrayMesh.ARRAY_NORMAL] = normals_road -# arrays_roads[ArrayMesh.ARRAY_INDEX] = indices_road - arrays_lots[ArrayMesh.ARRAY_VERTEX] = verts_lot -# arrays_lots[ArrayMesh.ARRAY_NORMAL] = normals_lot -# arrays_lots[ArrayMesh.ARRAY_INDEX] = indices_lot +#func build_mesh(aabb: AABB, vn: Node): +# var polylist = [] +# var mesh_aabb = AABB() +# var rect = Rect2(aabb.position.x + map_width / 2.0, +# aabb.position.z + map_width / 2.0, aabb.size.x, aabb.size.z) +# for p in polygons: +# for v in p.vertices: +## print(v) +# if rect.has_point(v) || true: +# polylist.push_back(p) +# break +# var verts_road = PoolVector3Array() +# var indices_road = PoolIntArray() +# var normals_road = PoolVector3Array() +# var verts_lot = PoolVector3Array() +# var indices_lot = PoolIntArray() +# var normals_lot = PoolVector3Array() +# var mesh = ArrayMesh.new() +# var arrays_roads = [] +# var arrays_lots = [] +# arrays_roads.resize(ArrayMesh.ARRAY_MAX) +# arrays_lots.resize(ArrayMesh.ARRAY_MAX) +# var idx_road = 0 +# var idx_lot = 0 +# for p in polylist: +# var vid = 0 +# for v in p.vertices: +## var v = p.vertices[e.indices[0]] +# var v3d = Vector3() +# v3d.x = v.x - float(map_width) / 2.0 +# v3d.z = v.x - float(map_height) / 2.0 +# v3d.y = get_height(v3d.x, v3d.z) +# v3d.y = 0 +# v3d *= 0.005 +# mesh_aabb = mesh_aabb.expand(v3d) +# if p.road: +# verts_road.push_back(v3d) +# normals_road.push_back(Vector3(0, 1, 0)) +# indices_road.push_back(idx_road + vid) +# else: +# verts_lot.push_back(v3d) +# normals_lot.push_back(Vector3(0, 1, 0)) +# indices_lot.push_back(idx_lot + vid) +# vid += 1 +# if p.road: +# idx_road += 3 +# else: +# idx_lot += 3 +# print(verts_lot.size()) # print(verts_lot) - mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays_roads) -# arrays_lots[ArrayMesh.ARRAY_VERTEX] = PoolVector3Array([Vector3(-1, -1, -1), Vector3(0, 0, 0), Vector3(0, 0, 1)]) - mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays_lots) -# mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, PlaneMesh.new().get_mesh_arrays()) - var mat = SpatialMaterial.new() - mat.params_cull_mode = SpatialMaterial.CULL_DISABLED - mesh.surface_set_material(0, mat) - mesh.surface_set_material(1, mat) - mesh.custom_aabb = mesh_aabb - var mi = MeshInstance.new() - vn.add_child(mi) - mi.mesh = mesh - - return mesh +## print(indices_lot) +## print(mesh_aabb) +# arrays_roads[ArrayMesh.ARRAY_VERTEX] = verts_road +## arrays_roads[ArrayMesh.ARRAY_NORMAL] = normals_road +## arrays_roads[ArrayMesh.ARRAY_INDEX] = indices_road +# arrays_lots[ArrayMesh.ARRAY_VERTEX] = verts_lot +## arrays_lots[ArrayMesh.ARRAY_NORMAL] = normals_lot +## arrays_lots[ArrayMesh.ARRAY_INDEX] = indices_lot +## print(verts_lot) +# mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays_roads) +## arrays_lots[ArrayMesh.ARRAY_VERTEX] = PoolVector3Array([Vector3(-1, -1, -1), Vector3(0, 0, 0), Vector3(0, 0, 1)]) +# mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays_lots) +## mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, PlaneMesh.new().get_mesh_arrays()) +# var mat = SpatialMaterial.new() +# mat.params_cull_mode = SpatialMaterial.CULL_DISABLED +# mesh.surface_set_material(0, mat) +# mesh.surface_set_material(1, mat) +# mesh.custom_aabb = mesh_aabb +# var mi = MeshInstance.new() +# vn.add_child(mi) +# mi.mesh = mesh +# +# return mesh func _ready(): set_process(false) rules.grid = GridRule.new() rnd = RandomNumberGenerator.new() noise = OpenSimplexNoise.new() - db = PointDB.new() +# db = PointDB.new() func inset_point(v: Dictionary, n:Dictionary, new_pos: Vector2): var nv = new_vertex(new_pos.x, new_pos.y) @@ -1009,36 +1140,40 @@ func _process(delta): print("vertex num: ", vertices.size()) STATE_EDGES1: print_debug("iteration finished") - var ax_verts = [] - for k in vertices: - if k.has("axiom") && k.axiom == true: - for l in vertices: - if l == k: - continue - if k in l.neighbors: - l.neighbors.erase(k) - ax_verts.push_back(k) - for v in ax_verts: - vertices.erase(v) - print_debug("cleanup finished") +# var ax_verts = [] +# for k in vertices: +# if k.has("axiom") && k.axiom == true: +# for l in vertices: +# if l == k: +# continue +# if k in l.neighbors: +# l.neighbors.erase(k) +# ax_verts.push_back(k) +# for v in ax_verts: +# vertices.erase(v) +# print_debug("cleanup finished") convert_vertices() print_debug("conversion finished") state = STATE_EDGES2 STATE_EDGES2: - points = [] - for k in vertices: - points.push_back(k.pos) - db = PointDB.new() - db.build_grid(points, 64) - print_debug("points: ", points.size()) - assert points.size() == db._points.size() - for v in vertices: - assert db._pos2id.has(v.pos) - for v in vertices: - for n in v.neighbors: - assert db._pos2id.has(n.pos) - print_debug("data tests passed") - print(points.size(), " ", db._points.size()) + for v in range(vertices.size()): + var vdata = VertexData.new(roadmap.vertices[v], roadmap.road_width, roadmap.sidewalk_width) + vertices[v]._vdata = vdata + vertices[v]._points = vdata.get_all_road_points(vertices) +# points = [] +# for k in vertices: +# points.push_back(k.pos) +# db = PointDB.new() +# db.build_grid(points, 64) +# print_debug("points: ", points.size()) +# assert points.size() == db._points.size() +# for v in vertices: +# assert db._pos2id.has(v.pos) +# for v in vertices: +# for n in v.neighbors: +# assert db._pos2id.has(n.pos) +# print_debug("data tests passed") +# print(points.size(), " ", db._points.size()) # for e in range(vertices.size()): # for h in vertices[e]._neighbors: @@ -1046,6 +1181,15 @@ func _process(delta): # print_debug("edges added") state = STATE_EDGES3 STATE_EDGES3: + for v in range(vertices.size()): + for entry in range(vertices[v]._points.size()): + var points = vertices[v]._points[entry].points_total + var points_3d = [] + for p in points: + var p3d = Vector3(p.x - map_width * 0.5, get_height(p.x - map_width * 0.5, p.y - map_height * 0.5), p.y - map_height * 0.5) + points_3d.push_back(p3d) + vertices[v]._points[entry].points3d = points_3d + # implode_road() # print(points.size(), " ", extra_points.size()) # adjust_triangles() @@ -1056,23 +1200,23 @@ func _process(delta): # db.build_grid(points,64) # print_debug("edges3") # - var bad_edges = [] - for v in vertices: - for n in v.neighbors: -# print(points.size(), " ", db._points.size()) - assert points.size() == db._points.size() - assert v.pos in points - assert n.pos in points - assert v.pos in db._points - assert n.pos in db._points - if !db.add_edge_data(v.pos, n.pos, {"road": true}): - bad_edges.push_back([v._index, n._index]) - if bad_edges.size() > 0: - print("bad edges: ", bad_edges, " ", bad_edges.size()) - for pe in extra_points: - var e = db.get_point_edges(pe) - for d in e: - db.add_edge_data(d[0], d[1], {"road": true}) +# var bad_edges = [] +# for v in vertices: +# for n in v.neighbors: +## print(points.size(), " ", db._points.size()) +# assert points.size() == db._points.size() +# assert v.pos in points +# assert n.pos in points +# assert v.pos in db._points +# assert n.pos in db._points +# if !db.add_edge_data(v.pos, n.pos, {"road": true}): +# bad_edges.push_back([v._index, n._index]) +# if bad_edges.size() > 0: +# print("bad edges: ", bad_edges, " ", bad_edges.size()) +# for pe in extra_points: +# var e = db.get_point_edges(pe) +# for d in e: +# db.add_edge_data(d[0], d[1], {"road": true}) # for e in bad_edges: # var p1: Vector2 = vertices[e[0]].pos # var p2: Vector2 = vertices[e[1]].pos @@ -1113,6 +1257,9 @@ func _process(delta): # print("bad triangles") # print(triangulation) STATE_POLYGONS1: + lots = Lots.new() + lots.generate_lots(vertices, road_width, sidewalk_width, map_width, map_height) +# db = LotsDB.new(vertices, road_width, sidewalk_width) # polygon_queue = db.get_polygons() # for r in range(polygon_queue.size()): # if polygon_queue[r].size() == 6: diff --git a/proto2/characters/character.gd b/proto2/characters/character.gd index 6d82a49..3ad694f 100644 --- a/proto2/characters/character.gd +++ b/proto2/characters/character.gd @@ -127,6 +127,15 @@ var raycasts : = { "left": {}, "right": {} } +func is_overshooting(): + if _path.size() < 2: + return false + var p = _path[0] + var facing = -global_transform.basis[2] + var dir = (_path[0] - global_transform.origin).normalized() + if facing.dot(dir) <= 0: + return true + return false func _physics_process(delta): var space := get_world().direct_space_state var ray_origin : = global_transform.origin + Vector3(0.0, 0.5, 1.0) @@ -183,7 +192,7 @@ func _physics_process(delta): orientation *= controls.frame_tf controls.frame_tf = Transform() if _path && _path.size() > 0: - while _path.size() > 0 && _path[0].distance_to(global_transform.origin) < 0.5: + while (_path.size() > 0 && _path[0].distance_to(global_transform.origin) < 0.5) || is_overshooting(): _path.pop_front() if _path.size() > 0: var next: Vector3 = _path[0] diff --git a/proto2/main.gd b/proto2/main.gd index cbca41c..0ca9bdd 100644 --- a/proto2/main.gd +++ b/proto2/main.gd @@ -25,6 +25,8 @@ func update_quests(): q.update() func start_quest(quest: Quest): notifications.quest_notfication(quest.get_title(), quest.get_description()) +func complete_quest(quest: Quest): + notifications.quest_complete_notfication(quest.get_title(), quest.get_description()) func start_interaction(obj): print("started interaction") @@ -133,15 +135,20 @@ func _ready(): # cd.scene.set_meta("data", cd) var tut_quest = Quest.new("Tutorial", "This quest shortly introduces to a game") tut_quest.connect("started", self, "start_quest") + tut_quest.connect("complete", self, "complete_quest") world.quests.push_back(tut_quest) var tut1_quest = WalkQuest.new("Walk to closet room", "Walk to closet room designated location", get_node("quest_dst_closet")) tut1_quest.connect("started", self, "start_quest") + tut1_quest.connect("complete", self, "complete_quest") var tut2_quest = StatsQuest.new("Hire 6 team members", "Hire six team members to start with your team", {"player_count": 6}) tut2_quest.connect("started", self, "start_quest") + tut2_quest.connect("complete", self, "complete_quest") var tut3_quest = WalkQuest.new("Walk to gym", "Walk to gym designated location", get_node("quest_dst_gym")) tut3_quest.connect("started", self, "start_quest") + tut3_quest.connect("complete", self, "complete_quest") var tut4_quest = StatsQuest.new("Train your team once", "Complete your team training once", {"team_train_count": 1}) tut4_quest.connect("started", self, "start_quest") + tut4_quest.connect("complete", self, "complete_quest") tut1_quest.set_next_quest(tut2_quest) tut2_quest.set_next_quest(tut3_quest) tut3_quest.set_next_quest(tut4_quest) diff --git a/proto2/ui/quest_complete_notification.gd b/proto2/ui/quest_complete_notification.gd new file mode 100644 index 0000000..befdba9 --- /dev/null +++ b/proto2/ui/quest_complete_notification.gd @@ -0,0 +1,5 @@ +extends Control + +func display_notification(title): + $v/quest_title.text = title + show() diff --git a/proto2/ui/quest_complete_notification.tscn b/proto2/ui/quest_complete_notification.tscn new file mode 100644 index 0000000..b74ab08 --- /dev/null +++ b/proto2/ui/quest_complete_notification.tscn @@ -0,0 +1,48 @@ +[gd_scene load_steps=5 format=2] + +[ext_resource path="res://fonts/DroidSansFallback.ttf" type="DynamicFontData" id=1] +[ext_resource path="res://ui/quest_complete_notification.gd" type="Script" id=2] + +[sub_resource type="DynamicFont" id=1] +size = 35 +font_data = ExtResource( 1 ) + +[sub_resource type="DynamicFont" id=2] +size = 30 +font_data = ExtResource( 1 ) + +[node name="quest_complete_notification" type="Control"] +anchor_right = 1.0 +anchor_bottom = 1.0 +script = ExtResource( 2 ) +__meta__ = { +"_edit_use_anchors_": false +} + +[node name="v" type="VBoxContainer" parent="."] +anchor_left = 0.5 +anchor_top = 0.5 +anchor_right = 0.5 +anchor_bottom = 0.5 +margin_left = -129.5 +margin_top = -45.5 +margin_right = 129.5 +margin_bottom = 45.5 +__meta__ = { +"_edit_use_anchors_": false +} + +[node name="msg" type="Label" parent="v"] +margin_right = 259.0 +margin_bottom = 47.0 +custom_fonts/font = SubResource( 1 ) +text = "Quest complete!" +align = 1 + +[node name="quest_title" type="Label" parent="v"] +margin_top = 51.0 +margin_right = 259.0 +margin_bottom = 91.0 +custom_fonts/font = SubResource( 2 ) +text = "quest title" +align = 1