about summary refs log tree commit diff stats
path: root/Archipelago/mypainting.gd
blob: 7aee434ab731cced36b93de2e9a474b22bcdd8f0 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
extends Spatial

var orientation = ""  # north, south, east, west
var move = false
var move_to_x
var move_to_z
var target = null
var key


func _ready():
	var _connected = get_tree().get_root().get_node("Spatial/player").connect(
		"looked_at", self, "_looked_at"
	)
	if move:
		key.get_node("Viewport/GUI/Panel/TextEdit").connect(
			"answer_correct", self, "_answer_correct"
		)


func _answer_correct():
	var apclient = global.get_node("Archipelago")
	if not apclient._door_shuffle or apclient.paintingIsVanilla(self.get_parent().name):
		movePainting()


func movePainting():
	self.get_parent().translation.x = move_to_x
	self.get_parent().translation.z = move_to_z


func _looked_at(body, painting):
	if body.is_in_group("player") and (painting.get_name() == self.get_parent().get_name()):
		var apclient = global.get_node("Archipelago")
		apclient.checkPainting(painting.get_name())

		if target != null:
			var target_dir = _dir_to_int(target.orientation)
			var source_dir = _dir_to_int(orientation)
			var rotate = target_dir - source_dir
			if rotate < 0:
				rotate += 4
			rotate *= 90

			var target_painting = target.get_parent()

			# this is ACW
			if rotate == 0:
				body.translation.x = (
					target_painting.translation.x + (body.translation.x - painting.translation.x)
				)
				body.translation.y = (
					target_painting.translation.y + (body.translation.y - painting.translation.y)
				)
				body.translation.z = (
					target_painting.translation.z + (body.translation.z - painting.translation.z)
				)
			elif rotate == 180:
				body.translation.x = (
					target_painting.translation.x - (body.translation.x - painting.translation.x)
				)
				body.translation.y = (
					target_painting.translation.y + (body.translation.y - painting.translation.y)
				)
				body.translation.z = (
					target_painting.translation.z - (body.translation.z - painting.translation.z)
				)
				body.rotate_y(PI)
				body.velocity = body.velocity.rotated(Vector3(0, 1, 0), PI)
			elif rotate == 90:
				var diff_x = body.translation.x - painting.translation.x
				var diff_y = body.translation.y - painting.translation.y
				var diff_z = body.translation.z - painting.translation.z
				body.translation.x = target_painting.translation.x + diff_z
				body.translation.y = target_painting.translation.y + diff_y
				body.translation.z = target_painting.translation.z - diff_x
				body.rotate_y(PI / 2)
				body.velocity = body.velocity.rotated(Vector3(0, 1, 0), PI / 2)
			elif rotate == 270:
				var diff_x = body.translation.x - painting.translation.x
				var diff_y = body.translation.y - painting.translation.y
				var diff_z = body.translation.z - painting.translation.z
				body.translation.x = target_painting.translation.x - diff_z
				body.translation.y = target_painting.translation.y + diff_y
				body.translation.z = target_painting.translation.z + diff_x
				body.rotate_y(3 * PI / 2)
				body.velocity = body.velocity.rotated(Vector3(0, 1, 0), 3 * PI / 2)

			if !apclient._pilgrimage_allows_paintings:
				global.sunwarp = 1
				body.get_node("pivot/camera/sunwarp_background").visible = false


func _dir_to_int(dir):
	if dir == "north":
		return 0
	elif dir == "west":
		return 1
	elif dir == "south":
		return 2
	elif dir == "east":
		return 3
	return 4
obj.name; if (entrance_it.second["room"]) { door_room = entrance_it.second["room"].as<std::string>(); } exit_obj.door = AddOrGetDoor( door_room, entrance_it.second["door"].as<std::string>()); } if (entrance_it.second["painting"]) { exit_obj.painting = entrance_it.second["painting"].as<bool>(); } from_room_obj.exits.push_back(exit_obj); break; } case YAML::NodeType::Sequence: { for (const auto &option : entrance_it.second) { Exit exit_obj; exit_obj.destination_room = room_id; std::string door_room = room_obj.name; if (option["room"]) { door_room = option["room"].as<std::string>(); } exit_obj.door = AddOrGetDoor(door_room, option["door"].as<std::string>()); if (option["painting"]) { exit_obj.painting = option["painting"].as<bool>(); } from_room_obj.exits.push_back(exit_obj); } break; } default: { // This shouldn't happen. std::cout << "Error reading game data: " << entrance_it << std::endl; break; } } } if (room_it.second["panels"]) { for (const auto &panel_it : room_it.second["panels"]) { int panel_id = AddOrGetPanel(room_obj.name, panel_it.first.as<std::string>()); Panel &panel_obj = panels_[panel_id]; if (panel_it.second["colors"]) { if (panel_it.second["colors"].IsScalar()) { panel_obj.colors.push_back( GetColorForString(panel_it.second["colors"].as<std::string>())); } else { for (const auto &color_node : panel_it.second["colors"]) { panel_obj.colors.push_back( GetColorForString(color_node.as<std::string>())); } } } if (panel_it.second["required_room"]) { if (panel_it.second["required_room"].IsScalar()) { panel_obj.required_rooms.push_back(AddOrGetRoom( panel_it.second["required_room"].as<std::string>())); } else { for (const auto &rr_node : panel_it.second["required_room"]) { panel_obj.required_rooms.push_back( AddOrGetRoom(rr_node.as<std::string>())); } } } if (panel_it.second["required_door"]) { if (panel_it.second["required_door"].IsMap()) { std::string rd_room = room_obj.name; if (panel_it.second["required_door"]["room"]) { rd_room = panel_it.second["required_door"]["room"].as<std::string>(); } panel_obj.required_doors.push_back(AddOrGetDoor( rd_room, panel_it.second["required_door"]["door"].as<std::string>())); } else { for (const auto &rr_node : panel_it.second["required_door"]) { std::string rd_room = room_obj.name; if (rr_node["room"]) { rd_room = rr_node["room"].as<std::string>(); } panel_obj.required_doors.push_back( AddOrGetDoor(rd_room, rr_node["door"].as<std::string>())); } } } if (panel_it.second["check"]) { panel_obj.check = panel_it.second["check"].as<bool>(); } if (panel_it.second["achievement"]) { panel_obj.achievement = panel_it.second["achievement"].as<bool>(); if (panel_obj.achievement) { achievement_panels_.push_back(panel_id); } } if (panel_it.second["exclude_reduce"]) { panel_obj.exclude_reduce = panel_it.second["exclude_reduce"].as<bool>(); } } } if (room_it.second["doors"]) { for (const auto &door_it : room_it.second["doors"]) { int door_id = AddOrGetDoor(room_obj.name, door_it.first.as<std::string>()); Door &door_obj = doors_[door_id]; bool has_external_panels = false; std::vector<std::string> panel_names; for (const auto &panel_node : door_it.second["panels"]) { if (panel_node.IsScalar()) { panel_names.push_back(panel_node.as<std::string>()); door_obj.panels.push_back( AddOrGetPanel(room_obj.name, panel_node.as<std::string>())); } else { has_external_panels = true; panel_names.push_back(panel_node["panel"].as<std::string>()); door_obj.panels.push_back( AddOrGetPanel(panel_node["room"].as<std::string>(), panel_node["panel"].as<std::string>())); } } if (door_it.second["skip_location"]) { door_obj.skip_location = door_it.second["skip_location"].as<bool>(); } if (door_it.second["skip_item"]) { door_obj.skip_item = door_it.second["skip_item"].as<bool>(); } if (door_it.second["event"]) { door_obj.skip_location = door_it.second["event"].as<bool>(); door_obj.skip_item = door_it.second["event"].as<bool>(); } if (door_it.second["item_name"]) { door_obj.item_name = door_it.second["item_name"].as<std::string>(); } else if (!door_it.second["skip_item"] && !door_it.second["event"]) { door_obj.item_name = room_obj.name + " - " + door_obj.name; } if (door_it.second["group"]) { door_obj.group_name = door_it.second["group"].as<std::string>(); } if (door_it.second["location_name"]) { door_obj.location_name = door_it.second["location_name"].as<std::string>(); } else if (!door_it.second["skip_location"] && !door_it.second["event"]) { if (has_external_panels) { std::cout << room_obj.name << " - " << door_obj.name << " has panels from other rooms but does not have an explicit " "location name and is not marked skip_location or event" << std::endl; } door_obj.location_name = room_obj.name + " - " + hatkirby::implode(panel_names, ", "); } if (door_it.second["include_reduce"]) { door_obj.exclude_reduce = !door_it.second["include_reduce"].as<bool>(); } } } if (room_it.second["paintings"]) { for (const auto &painting : room_it.second["paintings"]) { std::string painting_id = painting["id"].as<std::string>(); room_by_painting_[painting_id] = room_id; if (!painting["exit_only"] || !painting["exit_only"].as<bool>()) { PaintingExit painting_exit; painting_exit.id = painting_id; if (painting["required_door"]) { std::string rd_room = room_obj.name; if (painting["required_door"]["room"]) { rd_room = painting["required_door"]["room"].as<std::string>(); } painting_exit.door = AddOrGetDoor( rd_room, painting["required_door"]["door"].as<std::string>()); } room_obj.paintings.push_back(painting_exit); } } } if (room_it.second["progression"]) { for (const auto &progression_it : room_it.second["progression"]) { std::string progressive_item_name = progression_it.first.as<std::string>(); int index = 1; for (const auto &stage : progression_it.second) { int door_id = -1; if (stage.IsScalar()) { door_id = AddOrGetDoor(room_obj.name, stage.as<std::string>()); } else { door_id = AddOrGetDoor(stage["room"].as<std::string>(), stage["door"].as<std::string>()); } doors_[door_id].progressives.push_back( {.item_name = progressive_item_name, .quantity = index}); index++; } } } } map_areas_.reserve(areas_config.size()); std::map<std::string, int> fold_areas; for (const auto &area_it : areas_config) { if (area_it.second["map"]) { int area_id = AddOrGetArea(area_it.first.as<std::string>()); MapArea &area_obj = map_areas_[area_id]; area_obj.map_x = area_it.second["map"][0].as<int>(); area_obj.map_y = area_it.second["map"][1].as<int>(); } else if (area_it.second["fold_into"]) { fold_areas[area_it.first.as<std::string>()] = AddOrGetArea(area_it.second["fold_into"].as<std::string>()); } } for (const Panel &panel : panels_) { if (panel.check) { int room_id = panel.room; std::string room_name = rooms_[room_id].name; std::string area_name = room_name; if (fold_areas.count(room_name)) { int fold_area_id = fold_areas[room_name]; area_name = map_areas_[fold_area_id].name; } int area_id = AddOrGetArea(area_name); MapArea &map_area = map_areas_[area_id]; // room field should be the original room ID map_area.locations.push_back( {.name = panel.name, .ap_location_name = room_name + " - " + panel.name, .room = panel.room, .panels = {panel.id}}); } } for (const Door &door : doors_) { if (!door.skip_location) { int room_id = door.room; std::string area_name = rooms_[room_id].name; std::string section_name; size_t divider_pos = door.location_name.find(" - "); if (divider_pos == std::string::npos) { section_name = door.location_name; } else { area_name = door.location_name.substr(0, divider_pos); section_name = door.location_name.substr(divider_pos + 3); } if (fold_areas.count(area_name)) { int fold_area_id = fold_areas[area_name]; area_name = map_areas_[fold_area_id].name; } int area_id = AddOrGetArea(area_name); MapArea &map_area = map_areas_[area_id]; // room field should be the original room ID map_area.locations.push_back({.name = section_name, .ap_location_name = door.location_name, .room = door.room, .panels = door.panels}); } } } int GameData::AddOrGetRoom(std::string room) { if (!room_by_id_.count(room)) { room_by_id_[room] = rooms_.size(); rooms_.push_back({.name = room}); } return room_by_id_[room]; } int GameData::AddOrGetDoor(std::string room, std::string door) { std::string full_name = room + " - " + door; if (!door_by_id_.count(full_name)) { door_by_id_[full_name] = doors_.size(); doors_.push_back({.room = AddOrGetRoom(room), .name = door}); } return door_by_id_[full_name]; } int GameData::AddOrGetPanel(std::string room, std::string panel) { std::string full_name = room + " - " + panel; if (!panel_by_id_.count(full_name)) { int panel_id = panels_.size(); panel_by_id_[full_name] = panel_id; panels_.push_back( {.id = panel_id, .room = AddOrGetRoom(room), .name = panel}); } return panel_by_id_[full_name]; } int GameData::AddOrGetArea(std::string area) { if (!area_by_id_.count(area)) { int area_id = map_areas_.size(); area_by_id_[area] = area_id; map_areas_.push_back({.id = area_id, .name = area}); } return area_by_id_[area]; } const GameData &GetGameData() { static GameData *instance = new GameData(); return *instance; }