Merge remote-tracking branch 'origin/all-in-one-vs2022-wpo' into Scope-fix

Author: Redotix

gamedata/gamedata/configs/patrol_paths.ltx

@@ -0,0 +1 @@
+

gamedata/gamedata/scripts/aaaa_script_fixes_mp.script

@@ -47,6 +47,15 @@ function ui_pda_npc_tab.use_view(obj)
 	end
 end
 
+-- NLTP_ASHES: Fix for ActorMenu_on_item_after_move callback sending nil values
+ui_inventory_UIInventory_Action_Move = ui_inventory.UIInventory.Action_Move
+function ui_inventory.UIInventory:Action_Move(obj, bag)
+  obj = self:CheckItem(obj,"Action_Move")
+  if obj then
+    ui_inventory_UIInventory_Action_Move(self, obj, bag)
+  end
+end
+
 -- Additional params for callbacks
 -- Called on CHudItem Motion Mark
 _G.CHudItem__OnMotionMark = function(state, mark, obj, owner)

gamedata/gamedata/scripts/callbacks_gameobject.script

@@ -273,7 +273,16 @@ function anomaly_on_before_activate(zone, obj, flags)
 	end
 end
 
+-- NLTP_ASHES: Trigger actor_on_item_put_in_box callback when moving item to stash from slot
+function ActorMenu_on_item_after_move(npc_id, obj, mode, bag_from)
+	local box = level.object_by_id(npc_id)
+    if box and IsInvbox(box) and mode == "loot" and bag_from == 1 then
+        SendScriptCallback("actor_on_item_put_in_box", box, obj)
+    end
+end
+
 function on_game_start()
+	RegisterScriptCallback("ActorMenu_on_item_after_move", ActorMenu_on_item_after_move)
 	RegisterScriptCallback("anomaly_on_before_activate", anomaly_on_before_activate)
 	RegisterScriptCallback("game_object_on_net_spawn", game_object_on_net_spawn)
 	RegisterScriptCallback("game_object_on_net_destroy", game_object_on_net_destroy)

src/xrCore/log.cpp

@@ -305,3 +305,15 @@ void CloseLog(void)
 	LogFile->clear();
 	xr_delete(LogFile);
 }
+
+shared_str FormatString(LPCSTR fmt, ...)
+{
+	va_list mark;
+	string2048 buf;
+	va_start(mark, fmt);
+	int sz = _vsnprintf(buf, sizeof(buf) - 1, fmt, mark);
+	buf[sizeof(buf) - 1] = 0;
+	va_end(mark);
+	if (sz) return shared_str(buf);
+	return shared_str(0);
+}

src/xrCore/log.h

@@ -24,4 +24,6 @@ void XRCORE_API FlushLog();
 extern XRCORE_API xr_vector<shared_str>* LogFile;
 extern XRCORE_API BOOL LogExecCB;
 
+shared_str FormatString(LPCSTR fmt, ...);
+
 #endif

src/xrGame/WeaponMagazined.cpp

@@ -103,6 +103,10 @@ void CWeaponMagazined::Load(LPCSTR section)
 		m_sounds.LoadSound(section, "snd_shoot_actor", "sndShotActor", false, m_eSoundShot);
 	//-Alundaio
 
+	// Cyclic fire sounds
+	if (WeaponSoundExist(section, "snd_shoot_actor_first"))
+		m_sounds.LoadSound(section, "snd_shoot_actor_first", "sndShotActorFirst", false, m_eSoundShot);
+
 	//misfire shot
 	if (WeaponSoundExist(section, "snd_shot_misfire"))
 		m_sounds.LoadSound(section, "snd_shot_misfire", "sndShotMisfire", false, m_eSoundShot);
@@ -153,6 +157,10 @@ void CWeaponMagazined::Load(LPCSTR section)
 			m_sounds.LoadSound(section, "snd_silncer_shot_actor", "sndSilencerShotActor", false, m_eSoundShot);
 		//-Alundaio
 
+		// Cyclic fire sounds w/ silencer
+		if (WeaponSoundExist(section, "snd_silncer_shoot_actor_first"))
+			m_sounds.LoadSound(section, "snd_silncer_shoot_actor_first", "sndSilencerShotActorFirst", false, m_eSoundShot);
+
 		//misfire shot
 		if (WeaponSoundExist(section, "snd_silncer_shot_misfire"))
 			m_sounds.LoadSound(section, "snd_silncer_shot_misfire", "sndSilencerShotMisfire", false, m_eSoundShot);
@@ -669,6 +677,8 @@ void CWeaponMagazined::UpdateSounds()
 		m_sounds.SetPosition("sndShotMisfire", P);
 	if (m_sounds.FindSoundItem("sndShotMisfireActor", false))
 		m_sounds.SetPosition("sndShotMisfireActor", P);
+	if (m_sounds.FindSoundItem("sndShotActorFirst", false))
+		m_sounds.SetPosition("sndShotActorFirst", P);
 }
 
 // demonized: check if cycle_down is enabled and shot num below max possible burst. Adds support for arbitrary burst shot at rpm_mode_2 with cycling down to rpm after maxBurstAmount
@@ -819,6 +829,14 @@ void CWeaponMagazined::PlaySoundShot()
 			}
 		}
 
+		string128 sndNameFirst;
+		strconcat(sizeof(sndNameFirst), sndNameFirst, m_sSndShotCurrent.c_str(), "ActorFirst");
+		if (m_iShotNum == 1 && m_sounds.FindSoundItem(sndNameFirst, false))
+		{
+			m_sounds.PlaySound(sndNameFirst, get_LastFP(), H_Root(), !!GetHUDmode(), false, (u8)-1);
+			return;
+		}
+
 		string128 sndName;
 		strconcat(sizeof(sndName), sndName, m_sSndShotCurrent.c_str(), "Actor");
 		if (m_sounds.FindSoundItem(sndName, false))

src/xrGame/ai_space.cpp

@@ -197,6 +197,7 @@ void CAI_Space::patrol_path_storage_raw(IReader& stream)
 	xr_delete(m_patrol_path_storage);
 	m_patrol_path_storage = xr_new<CPatrolPathStorage>();
 	m_patrol_path_storage->load_raw(get_level_graph(), get_cross_table(), get_game_graph(), stream);
+	m_patrol_path_storage->load_from_config();
 }
 
 void CAI_Space::patrol_path_storage(IReader& stream)
@@ -207,6 +208,7 @@ void CAI_Space::patrol_path_storage(IReader& stream)
 	xr_delete(m_patrol_path_storage);
 	m_patrol_path_storage = xr_new<CPatrolPathStorage>();
 	m_patrol_path_storage->load(stream);
+	m_patrol_path_storage->load_from_config();
 }
 
 void CAI_Space::set_alife(CALifeSimulator* alife_simulator)

src/xrGame/patrol_path.cpp

@@ -6,26 +6,29 @@
 //	Description : Patrol path
 ////////////////////////////////////////////////////////////////////////////
 
+#include <regex>
 #include "stdafx.h"
 #include "patrol_path.h"
 #include "levelgamedef.h"
+#include "../xrCore/mezz_stringbuffer.h"
 
 LPCSTR TEST_PATROL_PATH_NAME = "val_dogs_nest4_centre";
 
 CPatrolPath::CPatrolPath(shared_str name)
 {
 #ifdef DEBUG
-	m_name			= name;
+	m_name = name;
 #endif
 }
 
-CPatrolPath& CPatrolPath::load_raw(const CLevelGraph* level_graph, const CGameLevelCrossTable* cross,
-                                   const CGameGraph* game_graph, IReader& stream)
+CPatrolPath& CPatrolPath::load_raw(const CLevelGraph* level_graph, const CGameLevelCrossTable* cross, const CGameGraph* game_graph, IReader& stream)
 {
 	R_ASSERT(stream.find_chunk(WAYOBJECT_CHUNK_POINTS));
 	u32 vertex_count = stream.r_u16();
 	for (u32 i = 0; i < vertex_count; ++i)
+	{
 		add_vertex(CPatrolPoint(this).load_raw(level_graph, cross, game_graph, stream), i);
+	}
 
 	R_ASSERT(stream.find_chunk(WAYOBJECT_CHUNK_LINKS));
 	u32 edge_count = stream.r_u16();
@@ -40,17 +43,86 @@ CPatrolPath& CPatrolPath::load_raw(const CLevelGraph* level_graph, const CGameLe
 	return (*this);
 }
 
+CPatrolPath& CPatrolPath::load_from_config(CInifile* ini_paths, LPCSTR patrol_name)
+{
+	R_ASSERT3(ini_paths->line_exist(patrol_name, "points"), "Missing key 'points' in patrol path", patrol_name);
+	LPCSTR points_csv = ini_paths->r_string(patrol_name, "points");
+	std::vector<std::string> points = splitStringMulti(points_csv, ",", false, true);
+
+	// Keep track of name <-> vertex_id association
+	std::map<shared_str, u32> vertex_ids_by_name;
+
+	// Add patrol points
+	for (int idx = 0; idx < points.size(); idx++)
+	{
+		LPCSTR point_name = points[idx].c_str();
+		Msg("[PP] Reading point %s", point_name);
+		add_vertex(CPatrolPoint(this).load_from_config(ini_paths, patrol_name, point_name), idx);
+		vertex_ids_by_name.emplace(point_name, idx);
+	}
+
+	// Link patrol points
+	for (int idx = 0; idx < points.size(); idx++)
+	{
+		LPCSTR point_name = points[idx].c_str();
+
+		Msg("[PP] Linking point for %s", point_name);
+
+		// Verify if point has links (links are optional)
+		shared_str links_csv_key = FormatString("%s:%s", point_name, "links");
+		if (!ini_paths->line_exist(patrol_name, links_csv_key))
+		{
+			continue;
+		}
+
+		// Get list of vertices to link to
+		LPCSTR links_csv = ini_paths->r_string(patrol_name, links_csv_key.c_str());
+		std::vector<std::string> links = splitStringMulti(links_csv, ",", false, true);
+
+		for (std::string link : links)
+		{
+			// Link current point to target points
+			std::pair<u16, float> link_info = parse_point_link(patrol_name, link, vertex_ids_by_name);
+			add_edge(idx, link_info.first, link_info.second);
+			Msg("[PP] Linked %d to %d with a probability of %f", link_info.first, idx, link_info.second);
+		}
+	}
+
+	vertex_ids_by_name.clear();
+
+	return (*this);
+}
+
+std::pair<u32, float> CPatrolPath::parse_point_link(LPCSTR patrol_name, std::string link, std::map<shared_str, u32> vertex_ids_by_name)
+{
+	Msg("[PP] Linking %s", link.c_str());
+
+    std::regex pattern("(\\w+)\\((\\d+)\\)");
+    std::smatch matches;
+
+	bool matched = std::regex_search(link, matches, pattern);
+	R_ASSERT4(matched, "Bad format for patrol path link", patrol_name, link.c_str());
+	
+	std::string target = matches[1].str();
+	float prob = std::stof(matches[2].str());
+
+	auto I = vertex_ids_by_name.find(target.c_str());
+	R_ASSERT4(I != vertex_ids_by_name.end(), "Patrol point link target does not exist", patrol_name, target.c_str());
+
+	return std::make_pair((*I).second, prob);
+}
+
 CPatrolPath::~CPatrolPath()
 {
 }
 
 #ifdef DEBUG
-void CPatrolPath::load		(IReader &stream)
+void CPatrolPath::load(IReader &stream)
 {
 	inherited::load	(stream);
 	vertex_iterator	I = vertices().begin();
 	vertex_iterator	E = vertices().end();
 	for ( ; I != E; ++I)
-		(*I).second->data().path	(this);
+		(*I).second->data().path(this);
 }
 #endif

src/xrGame/patrol_path.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "stdafx.h"
 #include "graph_abstract.h"
 #include "patrol_point.h"
 
@@ -33,13 +34,16 @@ class CPatrolPath : public CGraphAbstractSerialize<CPatrolPoint, float, u32>
 public:
 	CPatrolPath(shared_str name = "");
 	virtual ~CPatrolPath();
-	CPatrolPath& load_raw(const CLevelGraph* level_graph, const CGameLevelCrossTable* cross,
-	                      const CGameGraph* game_graph, IReader& stream);
+	CPatrolPath& load_raw(const CLevelGraph* level_graph, const CGameLevelCrossTable* cross, const CGameGraph* game_graph, IReader& stream);
+	CPatrolPath& load_from_config(CInifile* ini_paths, LPCSTR patrol_name);
 	IC const CVertex* point(shared_str name) const;
 	template <typename T>
 	IC const CVertex* point(const Fvector& position, const T& evaluator) const;
 	IC const CVertex* point(const Fvector& position) const;
 
+private:
+	std::pair<u32, float> CPatrolPath::parse_point_link(LPCSTR patrol_name, std::string link, std::map<shared_str, u32> vertex_ids_by_name);
+
 #ifdef DEBUG
 public:
 	virtual void			load			(IReader &stream);

src/xrGame/patrol_path_storage.cpp

@@ -17,17 +17,15 @@ CPatrolPathStorage::~CPatrolPathStorage()
 	delete_data(m_registry);
 }
 
-void CPatrolPathStorage::load_raw(const CLevelGraph* level_graph, const CGameLevelCrossTable* cross,
-                                  const CGameGraph* game_graph, IReader& stream)
+void CPatrolPathStorage::load_raw(const CLevelGraph* level_graph, const CGameLevelCrossTable* cross, const CGameGraph* game_graph, IReader& stream)
 {
 	IReader* chunk = stream.open_chunk(WAY_PATROLPATH_CHUNK);
 
 	if (!chunk)
 		return;
 
 	u32 chunk_iterator;
-	for (IReader* sub_chunk = chunk->open_chunk_iterator(chunk_iterator); sub_chunk; sub_chunk = chunk->
-	     open_chunk_iterator(chunk_iterator, sub_chunk))
+	for (IReader* sub_chunk = chunk->open_chunk_iterator(chunk_iterator); sub_chunk; sub_chunk = chunk->open_chunk_iterator(chunk_iterator, sub_chunk))
 	{
 		R_ASSERT(sub_chunk->find_chunk(WAYOBJECT_CHUNK_VERSION));
 		R_ASSERT(sub_chunk->r_u16() == WAYOBJECT_VERSION);
@@ -40,14 +38,7 @@ void CPatrolPathStorage::load_raw(const CLevelGraph* level_graph, const CGameLev
 		m_registry.insert(
 			std::make_pair(
 				patrol_name,
-				&xr_new<CPatrolPath>(
-					patrol_name
-				)->load_raw(
-					level_graph,
-					cross,
-					game_graph,
-					*sub_chunk
-				)
+				&xr_new<CPatrolPath>(patrol_name)->load_raw(level_graph, cross, game_graph, *sub_chunk)
 			)
 		);
 	}
@@ -88,7 +79,7 @@ void CPatrolPathStorage::load(IReader& stream)
 		VERIFY3(I == m_registry.end(), "Duplicated patrol path found ", *pair.first);
 
 #ifdef DEBUG
-		pair.second->name		(pair.first);
+		pair.second->name(pair.first);
 #endif
 
 		m_registry.insert(pair);
@@ -97,6 +88,41 @@ void CPatrolPathStorage::load(IReader& stream)
 	chunk->close();
 }
 
+void CPatrolPathStorage::load_from_config()
+{
+	// Open patrol_paths.ltx
+	string_path fname;
+	FS.update_path(fname, "$game_config$", "patrol_paths.ltx");
+	CInifile* ini_paths = xr_new<CInifile>(fname, TRUE);
+
+	Msg("[PP] %s initialized", fname);
+
+	// Iterate sections. Each section is a unique patrol path
+	CInifile::Root& paths = ini_paths->sections();
+	for (CInifile::Root::iterator i = paths.begin(), ie = paths.end(); i != ie; ++i)
+	{
+		// Get patrol path name
+		LPCSTR patrol_name = (*i)->Name.c_str();
+
+		Msg("[PP] Reading section %s", patrol_name);
+
+		// Assert unique
+		const_iterator exists = m_registry.find(patrol_name);
+		R_ASSERT3(exists == m_registry.end(), "Duplicated patrol path found", patrol_name);
+
+		// Build CPatrolPath object
+		CPatrolPath* patrol_path = &xr_new<CPatrolPath>(patrol_name)->load_from_config(ini_paths, patrol_name);
+
+		// Insert in registry
+		PATROL_REGISTRY::value_type pair = std::make_pair(patrol_name, patrol_path);
+		m_registry.insert(pair);
+	}
+
+	Msg("[PP] Done reading patrol paths from configs");
+
+	xr_delete(ini_paths);
+}
+
 void CPatrolPathStorage::save(IWriter& stream)
 {
 	stream.open_chunk(0);