version 1.2

README.md

@@ -11,9 +11,10 @@
 -  you can enable aimbot/esp for your teammates
 -  press mouse4 to disable visible check(Aim at enemies behind smoke)
 -  display legend's name (https://www.unknowncheats.me/forum/3915178-post14046.html)
+-  Spectator List (Display Sepctator's Name and XP level)
 # how to use
 ## guest
--  ctrl+h to replace "changeableplace" to other contents to bypass memory detection.
+-  ctrl+h to replace "placeholder" to other contents to bypass memory detection.
 -  in CustomOverlay: main.cpp
 -  better use VMprotect
 -  build in release x64, use custom overlay for streamproof.
@@ -25,3 +26,11 @@
  - https://github.com/A1exxander/KVM-Spoofing
 
 *If you are concerned with Passthrough/bypass , ask Unknowncheats community for help*
+
+
+### Changelog
+#### 2023/12/20(UTC+8) 
+-  Freecamera will be disable when player is not alive.
+-  Spectator List
+-  Fix some bugs of Legend's name ESP.
+-  Added rcs setting to client

apex_dma/Game.cpp

@@ -299,7 +299,7 @@ float CalculateFov(Entity& from, Entity& target)
 	return Math::GetFov(ViewAngles, Angle);
 }
 
-QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov)
+QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov , float rcs_pitch , float rcs_yaw)
 {
 	Entity target = getEntity(t);
 	if (firing_range)
@@ -382,9 +382,8 @@ QAngle CalculateBestBoneAim(Entity& from, uintptr_t t, float max_fov)
 	//remove sway and recoil
 	if (aim_no_recoil) {
 		QAngle sway = SwayAngles - ViewAngles;
-		sway.x = sway.x * 0.8;   //pitch
+		sway.x = sway.x * rcs_pitch;   //pitch 0.3
-		sway.y = sway.y * 0.75;  //yaw
+		sway.y = sway.y * rcs_yaw;  //yaw 0.5
-		sway.z = sway.z * 0.9;
 		CalculatedAngles -= sway;
 	}
 	Math::NormalizeAngles(CalculatedAngles);

apex_dma/Game.h

@@ -94,7 +94,7 @@ Entity getEntity(uintptr_t ptr);
 Item getItem(uintptr_t ptr);
 bool WorldToScreen(Vector from, float* m_vMatrix, int targetWidth, int targetHeight, Vector& to);
 float CalculateFov(Entity& from, Entity& target);
-QAngle CalculateBestBoneAim(Entity& from, uintptr_t target, float max_fov);
+QAngle CalculateBestBoneAim(Entity& from, uintptr_t target, float max_fov , float rcs_pitch, float rcs_yaw);
 void get_class_name(uint64_t entity_ptr, char* out_str);
 void charge_rifle_hack(uint64_t entity_ptr);
 

apex_dma/apex_dma.cpp

@@ -12,7 +12,7 @@
 Memory apex_mem;
 Memory client_mem;
 
-uint64_t add_off = 0x114514;
+uint64_t add_off = 0x40980;
 
 bool freecam = false;
 bool lockall_enable = false;
@@ -24,6 +24,11 @@ uintptr_t tmp_aimentity = 0;
 uintptr_t lastaimentity = 0;
 float kmax = 999.0f;
 float max_dist = 200.0f * 40.0f;
+
+//rcs setting
+float rcs_pitch = 0.3f;
+float rcs_yaw = 0.4f;
+
 int team_player = 0;
 float max_fov = 15;
 const int toRead = 100;
@@ -66,14 +71,22 @@ typedef struct player
 	int maxshield = 0;
 	int armortype = 0;
 	char name[33] = { 0 };
-	char model_name[33] = { 0 };
+	char model_name[100] = { 0 };
 }player;
 
+typedef struct spectator{
+	bool is_spec = false;
+	int xp_level = 0;
+	char name[33] = { 0 };
+}spectator;
+
 struct Matrix
 {
 	float matrix[16];
 };
 
+spectator spectator_list[toRead];
+
 float lastvis_esp[toRead]; float lastvis_aim[toRead];
 
 int tmp_spec = 0, spectators = 0;
@@ -144,7 +157,7 @@ void DoActions()
 	actions_t = true;
 	while (actions_t)
 	{
-		std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		std::this_thread::sleep_for(std::chrono::milliseconds(10));
 		uint32_t counter = 0;
 
 		while (g_Base != 0 && c_Base != 0)
@@ -179,7 +192,10 @@ void DoActions()
 			tmp_spec = 0;
 			tmp_all_spec = 0;
 
+			memset(spectator_list,0, sizeof(spectator_list));
+
 			int current_obid;
+			if(LPlayer.isAlive()){
 				if (freecam) {
 					apex_mem.Write<int>(LocalPlayer + OFFSET_OBSERVER_MODE, 7);
 				}
@@ -189,6 +205,8 @@ void DoActions()
 						apex_mem.Write<int>(LocalPlayer + OFFSET_OBSERVER_MODE, 0);
 					}
 				}
+			}
+
 			if (firing_range)
 			{
 				int c = 0;
@@ -224,6 +242,20 @@ void DoActions()
 						continue;
 					}
 
+					float localyaw = LPlayer.GetYaw();
+					float targetyaw = Target.GetYaw();
+					if(!Target.isAlive() && localyaw == targetyaw){//if this player a spectator
+						Target.get_name(g_Base,i-1,&spectator_list[i].name[0]);
+						int xp;
+						apex_mem.Read<int>(centity + OFFSET_XP, xp);
+						int xp_level = calc_level(xp);
+						spectator_list[i].xp_level = xp_level;
+						if(spectator_list[i].name[0]){ //detect if this player quit
+							spectator_list[i].is_spec = true;
+						}else{spectator_list[i].is_spec = false;}
+					}else{
+						spectator_list[i].is_spec = false;
+					}
 					ProcessPlayer(LPlayer, Target, entitylist, i);
 
 					int entity_team = Target.getTeamId();
@@ -251,12 +283,13 @@ void DoActions()
 				}
 			}
 
-			if (!klock)
+			if (!klock){
 				aimentity = tmp_aimentity;
-			else
+			}else{
 				aimentity = lastaimentity;
 			}
 		}
+	}
 	actions_t = false;
 }
 
@@ -362,6 +395,7 @@ static void EspLoop()
 							int shield = Target.getShield();
 							int maxshield = Target.getMaxshield();
 							int armortype = Target.getArmortype();
+							//xp
 							int xp;
 							apex_mem.Read<int>(centity + OFFSET_XP, xp);
 							int xp_level = calc_level(xp);
@@ -386,7 +420,7 @@ static void EspLoop()
 							Target.get_name(g_Base, i - 1, &players[c].name[0]);
 							uint64_t model_ptr;
 							apex_mem.Read(centity + OFFSET_MODELNAME, model_ptr);
-							apex_mem.ReadArray(model_ptr,&players[c].model_name[0], 32);
+							apex_mem.ReadArray(model_ptr,&players[c].model_name[0], 99);
 
 							lastvis_esp[c] = Target.lastVisTime();
 							valid = true;
@@ -411,6 +445,7 @@ static void EspLoop()
 						}
 
 						Entity Target = getEntity(centity);
+						Entity Lplayer = getEntity(LocalPlayer);
 
 						if (!Target.isPlayer())
 						{
@@ -456,6 +491,7 @@ static void EspLoop()
 							int shield = Target.getShield();
 							int maxshield = Target.getMaxshield();
 							int armortype = Target.getArmortype();
+							//xp
 							int xp;
 							apex_mem.Read<int>(centity + OFFSET_XP, xp);
 
@@ -482,7 +518,7 @@ static void EspLoop()
 							Target.get_name(g_Base, i - 1, &players[i].name[0]);
 							uint64_t model_ptr;
                                                         apex_mem.Read(centity + OFFSET_MODELNAME, model_ptr);
-                                                        apex_mem.ReadArray(model_ptr,&players[i].model_name[0], 32);
+                                                        apex_mem.ReadArray(model_ptr,&players[i].model_name[0], 99);
 
 							lastvis_esp[i] = Target.lastVisTime();
 							valid = true;
@@ -524,7 +560,7 @@ static void AimbotLoop()
 				apex_mem.Read<uint64_t>(g_Base + OFFSET_LOCAL_ENT, LocalPlayer);
 				if (LocalPlayer == 0) continue;
 				Entity LPlayer = getEntity(LocalPlayer);
-				QAngle Angles = CalculateBestBoneAim(LPlayer, aimentity, max_fov);
+				QAngle Angles = CalculateBestBoneAim(LPlayer, aimentity, max_fov , rcs_pitch , rcs_yaw);
 				if (Angles.x == 0 && Angles.y == 0)
 				{
 					klock = false;
@@ -557,39 +593,44 @@ static void set_vars(uint64_t add_addr)
 	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 5, next_addr);
 	uint64_t player_addr = 0;
 	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 6, player_addr);
+	uint64_t spec_list_addr = 0;
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 7, spec_list_addr);
 	uint64_t valid_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 7, valid_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 8, valid_addr);
 	uint64_t max_dist_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 8, max_dist_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 9, max_dist_addr);
 	uint64_t item_glow_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 9, item_glow_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 10, item_glow_addr);
 	uint64_t player_glow_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 10, player_glow_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 11, player_glow_addr);
 	uint64_t aim_no_recoil_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 11, aim_no_recoil_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 12, aim_no_recoil_addr);
 	uint64_t smooth_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 12, smooth_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 13, smooth_addr);
 	uint64_t max_fov_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 13, max_fov_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 14, max_fov_addr);
 	uint64_t bone_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 14, bone_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 15, bone_addr);
 	uint64_t thirdperson_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 15, thirdperson_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 16, thirdperson_addr);
 	uint64_t spectators_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 16, spectators_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 17, spectators_addr);
 	uint64_t allied_spectators_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 17, allied_spectators_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 18, allied_spectators_addr);
 	uint64_t chargerifle_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 18, chargerifle_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 19, chargerifle_addr);
 	uint64_t shooting_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 19, shooting_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 20, shooting_addr);
 	uint64_t freecam_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 20, freecam_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 21, freecam_addr);
 	uint64_t lockall_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 21, lockall_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 22, lockall_addr);
 	uint64_t firing_range_addr = 0;
-	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 22, firing_range_addr);
+	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 23, firing_range_addr);
-
+    	uint64_t rcs_p_addr = 0;
+    	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 24, rcs_p_addr);
+    	uint64_t rcs_y_addr = 0;
+    	client_mem.Read<uint64_t>(add_addr + sizeof(uint64_t) * 25, rcs_y_addr);
 	uint32_t check = 0;
 	client_mem.Read<uint32_t>(check_addr, check);
 
@@ -615,6 +656,7 @@ static void set_vars(uint64_t add_addr)
 			client_mem.Write<uint64_t>(g_Base_addr, g_Base);
 			client_mem.Write<int>(spectators_addr, spectators);
 			client_mem.Write<int>(allied_spectators_addr, allied_spectators);
+			client_mem.WriteArray<spectator>(spec_list_addr, spectator_list , toRead);
 
 			client_mem.Read<int>(aim_addr, aim);
 			client_mem.Read<bool>(esp_addr, esp);
@@ -630,11 +672,14 @@ static void set_vars(uint64_t add_addr)
 			client_mem.Read<bool>(freecam_addr, freecam);
 			client_mem.Read<bool>(lockall_addr, lockall_enable);
 			client_mem.Read<bool>(firing_range_addr, firing_range);
+			client_mem.Read<float>(rcs_p_addr, rcs_pitch);
+			client_mem.Read<float>(rcs_y_addr, rcs_yaw);
 
 			if (esp && knext)
 			{
 				if (valid)
 				client_mem.WriteArray<player>(player_addr, players, toRead);
+
 				client_mem.Write<bool>(valid_addr, valid);
 				client_mem.Write<bool>(next_addr, true); //next
 

apex_dma/offsets.h

@@ -1,4 +1,3 @@
-//game version: 3.0.51.45 / date:2023/11/21
 #define OFFSET_ARMOR_TYPE           0x4634 //m_armorType
 #define OFFSET_MAXSHIELD            0x01a4 //m_shieldhealthmax
 #define OFFSET_MODELNAME            0x0030 //m_modelname

apex_guest/Client/Client/imgui.ini

@@ -0,0 +1,15 @@
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][##info]
+Pos=0,0
+Size=210,25
+Collapsed=0
+
+[Window][Sepectators]
+Pos=60,60
+Size=84,1074
+Collapsed=0
+

apex_guest/Client/Client/main.cpp

@@ -1,226 +1,261 @@
 #include "main.h"
 
-typedef struct changeableplaceplayer
+typedef struct placeholderplayer
 {
-	float changeableplacedist = 0;
+	float placeholderdist = 0;
-	int changeableplaceentity_team = 0;
+	int placeholderentity_team = 0;
-	float changeableplaceboxMiddle = 0;
+	float placeholderboxMiddle = 0;
-	float changeableplaceh_y = 0;
+	float placeholderh_y = 0;
-	float changeableplacewidth = 0;
+	float placeholderwidth = 0;
-	float changeableplaceheight = 0;
+	float placeholderheight = 0;
-	float changeableplaceb_x = 0;
+	float placeholderb_x = 0;
-	float changeableplaceb_y = 0;
+	float placeholderb_y = 0;
-	bool changeableplaceknocked = false;
+	bool placeholderknocked = false;
-	bool changeableplacevisible = false;
+	bool placeholdervisible = false;
-	int changeableplacehealth = 0;
+	int placeholderhealth = 0;
-	int changeableplaceshield = 0;
+	int placeholdershield = 0;
-	int changeableplacexp_level = 0;
+	int placeholderxp_level = 0;
-	int changeableplacemaxshield = 0;
+	int placeholdermaxshield = 0;
-	int changeableplacearmortype = 0;
+	int placeholderarmortype = 0;
-	char changeableplacename[33] = { 0 };
+	char placeholdername[33] = { 0 };
-	char changeableplacemodel_name[33] = { 0 };
+	char placeholdermodel_name[100] = { 0 };
-}changeableplaceplayer;
+}placeholderplayer;
-
+
-uint32_t changeableplacecheck = 0xABCD;
+typedef struct placeholderspectator {
-int changeableplaceaim_key = VK_XBUTTON2;
+	bool is_placeholderspec = false;
-int changeableplaceaim_key2 = VK_XBUTTON1;
+	int xp_placeholderlevel = 0;
-
+	char nplaceholderame[33] = { 0 };
-int changeableplaceshoot_key = VK_LBUTTON;
+}placeholderspectator;
-
+
-float changeableplacescale = 1.4f;
+uint32_t placeholdercheck = 0xABCD;
-bool changeableplacefiring_range;
+int placeholderaim_key = VK_XBUTTON2;
-int changeableplaceoffset = 0;
+int placeholderaim_key2 = VK_XBUTTON1;
-bool changeableplaceuse_nvidia = false;
+
-bool changeableplaceactive = true;
+int placeholdershoot_key = VK_LBUTTON;
-bool changeableplaceready = false;
+
-extern changeableplacevisuals changeableplacev;
+float placeholderrcs_pitch = 0.3f;
-int changeableplaceaim = 2; //read
+float placeholderrcs_yaw = 0.4f;
-
+
-float changeableplacexp_dist = 200.0f * 40.0f;
+float placeholderscale = 1.4f;
-float changeableplacename_dist = 100.0f * 40.0f;
+bool placeholderfiring_range;
-bool changeableplacefreecam = false;//read
+int placeholderoffset = 0;
-bool changeableplacelockall_mode = false; //read
+bool placeholderuse_nvidia = false;
-
+bool placeholderactive = true;
-bool changeableplaceesp = true; //read
+bool placeholderready = false;
-bool changeableplaceitem_glow = false;
+extern placeholdervisuals placeholderv;
-bool changeableplaceplayer_glow = false;
+int placeholderaim = 2; //read
-bool changeableplaceaim_no_recoil = true;
+
-bool changeableplaceaiming = false; //read
+float placeholderxp_dist = 600.0f * 40.0f;
-uint64_t changeableplaceg_Base = 0; //write
+float placeholdername_dist = 100.0f * 40.0f;
-float changeableplacemax_dist = 650.0f * 40.0f; //read
+bool placeholderfreecam = false;//read
-float changeableplaceseer_dist = 400.0 * 40.0f;
+bool placeholderlockall_mode = false; //read
-float changeableplacesmooth = 82.0f;
+
-float changeableplacemax_fov = 12.0f;
+bool placeholderesp = true; //read
-int changeableplacebone = 3;
+bool placeholderitem_glow = false;
-bool changeableplacethirdperson = false;
+bool placeholderplayer_glow = false;
-int changeableplacespectators = 0; //write
+bool placeholderaim_no_recoil = true;
-int changeableplaceallied_spectators = 0; //write
+bool placeholderaiming = false; //read
-bool changeableplacechargerifle = false;
+uint64_t placeholderg_Base = 0; //write
-bool changeableplaceshooting = false; //read
+float placeholdermax_dist = 650.0f * 40.0f; //read
-
+float placeholderseer_dist = 400.0 * 40.0f;
-
+float placeholdersmooth = 82.0f;
-int changeableplaceindex = 0;
+float placeholdermax_fov = 12.0f;
-bool changeableplacevalid = false; //write
+int placeholderbone = 3;
-bool changeableplacenext = false; //read write
+bool placeholderthirdperson = false;
-
+int placeholderspectators = 0; //write
-uint64_t changeableplaceadd[23];
+int placeholderallied_spectators = 0; //write
-
+bool placeholderchargerifle = false;
-bool changeableplacek_f5 = 0;
+bool placeholdershooting = false; //read
-bool changeableplacek_f6 = 0;
+
-bool changeableplacek_f8 = 0;
+int placeholderindex = 0;
+bool placeholdervalid = false; //write
+bool placeholdernext = false; //read write
+
+uint64_t placeholderadd[26];
+
 
 bool IsKeyDown(int vk)
 {
 	return (GetAsyncKeyState(vk) & 0x8000) != 0;
 }
-changeableplaceplayer changeableplaceplayers[100];
 
-std::string changeableplaceprocess_model_name(char changeableplacemodel_name[]) {
+placeholderplayer placeholderplayers[100];
-	if (strstr(changeableplacemodel_name, "dummie")) {
+
+std::string placeholderprocess_model_name(char placeholdermodel_name[]) {
+	if (strstr(placeholdermodel_name, "dummie")) {
 		return u8"人机";
 	}
-	else if (strstr(changeableplacemodel_name, "bangalore")) {
+	else if (strstr(placeholdermodel_name, "bangalore")) {
 		return u8"班加罗尔";
 	}
-	else if (strstr(changeableplacemodel_name, "fuse")) {
+	else if (strstr(placeholdermodel_name, "fuse")) {
 		return u8"暴雷";
 	}
-	else if (strstr(changeableplacemodel_name, "ash")) {
+	else if (strstr(placeholdermodel_name, "ash")) {
 		return u8"艾许";
 	}
-	else if (strstr(changeableplacemodel_name, "madmaggie")) {
+	else if (strstr(placeholdermodel_name, "madmaggie")) {
 		return u8"疯马吉";
 	}
-	else if (strstr(changeableplacemodel_name, "ballistic")) {
+	else if (strstr(placeholdermodel_name, "ballistic")) {
 		return u8"弹道";
 	}
-	else if (strstr(changeableplacemodel_name, "pathfinder")) {
+	else if (strstr(placeholdermodel_name, "pathfinder")) {
 		return u8"探路者";
 	}
-	else if (strstr(changeableplacemodel_name, "stim")) {
+	else if (strstr(placeholdermodel_name, "octane")) {
 		return u8"动力小子";
 	}
-	else if (strstr(changeableplacemodel_name, "revenant")) {
+	else if (strstr(placeholdermodel_name, "stim")) {
+		return u8"动力小子";
+	}
+	else if (strstr(placeholdermodel_name, "revenant")) {
 		return u8"亡灵";
 	}
-	else if (strstr(changeableplacemodel_name, "nova")) {
+	else if (strstr(placeholdermodel_name, "nova")) {
 		return u8"地平线";
 	}
-	else if (strstr(changeableplacemodel_name, "valkyrie")) {
+	else if (strstr(placeholdermodel_name, "horizon")) {
+		return u8"地平线";
+	}
+	else if (strstr(placeholdermodel_name, "valkyrie")) {
 		return u8"瓦尔基里";
 	}
-	else if (strstr(changeableplacemodel_name, "bloodhound")) {
+	else if (strstr(placeholdermodel_name, "bloodhound")) {
 		return u8"寻血猎犬";
 	}
-	else if (strstr(changeableplacemodel_name, "crypto")) {
+	else if (strstr(placeholdermodel_name, "crypto")) {
 		return u8"密客";
 	}
-	else if (strstr(changeableplacemodel_name, "seer")) {
+	else if (strstr(placeholdermodel_name, "seer")) {
 		return u8"希尔";
 	}
-	else if (strstr(changeableplacemodel_name, "wraith")) {
+	else if (strstr(placeholdermodel_name, "wraith")) {
 		return u8"恶灵";
 	}
-	else if (strstr(changeableplacemodel_name, "vantage")) {
+	else if (strstr(placeholdermodel_name, "vantage")) {
 		return u8"万蒂奇";
 	}
-	else if (strstr(changeableplacemodel_name, "gibraltar")) {
+	else if (strstr(placeholdermodel_name, "gibraltar")) {
 		return u8"直布罗陀";
 	}
-	else if (strstr(changeableplacemodel_name, "lifeline")) {
+	else if (strstr(placeholdermodel_name, "lifeline")) {
 		return u8"命脉";
 	}
-	else if (strstr(changeableplacemodel_name, "loba")) {
+	else if (strstr(placeholdermodel_name, "loba")) {
 		return u8"罗芭";
 	}
-	else if (strstr(changeableplacemodel_name, "holo")) {
+	else if (strstr(placeholdermodel_name, "holo")) {
 		return u8"幻象";
 	}
-	else if (strstr(changeableplacemodel_name, "newcastle")) {
+	else if (strstr(placeholdermodel_name, "newcastle")) {
 		return u8"纽卡斯尔";
 	}
-	else if (strstr(changeableplacemodel_name, "conduit")) {
+	else if (strstr(placeholdermodel_name, "conduit")) {
 		return u8"导线管";
 	}
-	else if (strstr(changeableplacemodel_name, "caustic")) {
+	else if (strstr(placeholdermodel_name, "caustic")) {
 		return u8"侵蚀";
 	}
-	else if (strstr(changeableplacemodel_name, "wattson")) {
+	else if (strstr(placeholdermodel_name, "wattson")) {
 		return u8"沃特森";
 	}
-	else if (strstr(changeableplacemodel_name, "rampart")) {
+	else if (strstr(placeholdermodel_name, "rampart")) {
 		return u8"兰伯特";
 	}
-	else if (strstr(changeableplacemodel_name, "catalyst")) {
+	else if (strstr(placeholdermodel_name, "catalyst")) {
 		return u8"催化剂";
 	}
-	else return u8"读取出错";
+	else return placeholdermodel_name;
 }
 
-void Overlay::RenderchangeableplaceEsp()
+placeholderspectator placeholderspectator_list[100];
+
+void Overlay::RenderplaceholderSpectator() {
+	int text_placeholderindex = 0;
+
+	ImGui::SetNextWindowPos(ImVec2(0, 0));
+	ImGui::SetNextWindowSize(ImVec2((float)getplaceholderWidth(), (float)getplaceholderHeight()));
+	ImGui::Begin(XorStr("##spectator_list"), (bool*)true, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoBringToFrontOnFocus);
+
+	for (int i = 0; i < 61; i++) {
+		if (placeholderspectator_list[i].is_placeholderspec) {
+			Stringplaceholder(ImVec2(5, 60 + text_placeholderindex * 20), WHITE, std::to_string(text_placeholderindex + 1).c_str(), 16);
+			Stringplaceholder(ImVec2(25, 60 + text_placeholderindex * 20), WHITE, placeholderspectator_list[i].nplaceholderame , 16);
+			Stringplaceholder(ImVec2(sizeof(placeholderspectator_list[i].nplaceholderame)*5 + 25, 60 + text_placeholderindex * 20), WHITE, std::to_string(placeholderspectator_list[i].xp_placeholderlevel).c_str(), 16);
+			text_placeholderindex++;
+		}
+	}
+	ImGui::End();
+	memset(placeholderspectator_list, 0, sizeof(placeholderspectator_list));
+}
+
+
+void Overlay::RenderplaceholderEsp()
 {
-	changeableplacenext = false;
+	placeholdernext = false;
-	if (changeableplaceg_Base != 0 && changeableplaceesp)
+	if (placeholderg_Base != 0 && placeholderesp)
 	{
-		memset(changeableplaceplayers, 0, sizeof(changeableplaceplayers));
+		memset(placeholderplayers, 0, sizeof(placeholderplayers));
-		while (!changeableplacenext && changeableplaceesp)
+
+		while (!placeholdernext && placeholderesp)
 		{
 			std::this_thread::sleep_for(std::chrono::milliseconds(1));
 		}
 
-		if (changeableplacenext && changeableplacevalid)
+		if (placeholdernext && placeholdervalid)
 		{
 			ImGui::SetNextWindowPos(ImVec2(0, 0));
-			ImGui::SetNextWindowSize(ImVec2((float)getchangeableplaceWidth(), (float)getchangeableplaceHeight()));
+			ImGui::SetNextWindowSize(ImVec2((float)getplaceholderWidth(), (float)getplaceholderHeight()));
 			ImGui::Begin(XorStr("##esp"), (bool*)true, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoBringToFrontOnFocus);
 
 			for (int i = 0; i < 100; i++)
 			{
-				if (changeableplaceplayers[i].changeableplacehealth > 0)
+				if (placeholderplayers[i].placeholderhealth > 0)
 				{
 					//xp+legend
-					std::string changeableplacexpstr = std::to_string(changeableplaceplayers[i].changeableplacexp_level);
+					std::string placeholderxpstr = std::to_string(placeholderplayers[i].placeholderxp_level);
-					changeableplacexpstr = u8"Level:" + changeableplacexpstr.substr(0, changeableplacexpstr.find('.')) + "   Legend:" + changeableplaceprocess_model_name(changeableplaceplayers[i].changeableplacemodel_name);
+					placeholderxpstr = u8"Level:" + placeholderxpstr.substr(0, placeholderxpstr.find('.')) + "   Legend:" + placeholderprocess_model_name(placeholderplayers[i].placeholdermodel_name); // placeholderprocess_model_name(placeholderplayers[i].placeholdermodel_name)
 
 					//DISTENCE + teamnum
-					std::string changeableplacedistance = std::to_string(changeableplaceplayers[i].changeableplacedist / 39.62);
+					std::string placeholderdistance = std::to_string(placeholderplayers[i].placeholderdist / 39.62);
-					changeableplacedistance = changeableplacedistance.substr(0, changeableplacedistance.find('.')) + u8"M( No." + std::to_string(changeableplaceplayers[i].changeableplaceentity_team) + u8")";
+					placeholderdistance = placeholderdistance.substr(0, placeholderdistance.find('.')) + u8"M( No." + std::to_string(placeholderplayers[i].placeholderentity_team) + u8")";
 
-					if (changeableplacev.changeableplacebox)
+					if (placeholderv.placeholderbox)
 					{
-						if (changeableplaceplayers[i].changeableplacevisible)
+						if (placeholderplayers[i].placeholdervisible)
 						{
-							if (changeableplaceplayers[i].changeableplacedist < 1600.0f)
+							if (placeholderplayers[i].placeholderdist < 1600.0f)
-								DrawchangeableplaceBox(RED, changeableplaceplayers[i].changeableplaceboxMiddle, changeableplaceplayers[i].changeableplaceh_y, changeableplaceplayers[i].changeableplacewidth, changeableplaceplayers[i].changeableplaceheight); //BOX
+								DrawplaceholderBox(RED, placeholderplayers[i].placeholderboxMiddle, placeholderplayers[i].placeholderh_y, placeholderplayers[i].placeholderwidth, placeholderplayers[i].placeholderheight); //BOX
 							else
-								DrawchangeableplaceBox(ORANGE, changeableplaceplayers[i].changeableplaceboxMiddle, changeableplaceplayers[i].changeableplaceh_y, changeableplaceplayers[i].changeableplacewidth, changeableplaceplayers[i].changeableplaceheight); //BOX
+								DrawplaceholderBox(ORANGE, placeholderplayers[i].placeholderboxMiddle, placeholderplayers[i].placeholderh_y, placeholderplayers[i].placeholderwidth, placeholderplayers[i].placeholderheight); //BOX
 						}
 						else
 						{
-							DrawchangeableplaceBox(WHITE, changeableplaceplayers[i].changeableplaceboxMiddle, changeableplaceplayers[i].changeableplaceh_y, changeableplaceplayers[i].changeableplacewidth, changeableplaceplayers[i].changeableplaceheight); //white if player not visible
+							DrawplaceholderBox(WHITE, placeholderplayers[i].placeholderboxMiddle, placeholderplayers[i].placeholderh_y, placeholderplayers[i].placeholderwidth, placeholderplayers[i].placeholderheight); //white if player not visible
 						}
 					}
 
-					if (changeableplacev.changeableplaceline)
+					if (placeholderv.placeholderline)
-						DrawchangeableplaceLine(ImVec2((float)(getchangeableplaceWidth() / 2), (float)getchangeableplaceHeight()), ImVec2(changeableplaceplayers[i].changeableplaceb_x, changeableplaceplayers[i].changeableplaceb_y), BLUE, 1); //LINE FROM MIDDLE SCREEN
+						DrawplaceholderLine(ImVec2((float)(getplaceholderWidth() / 2), (float)getplaceholderHeight()), ImVec2(placeholderplayers[i].placeholderb_x, placeholderplayers[i].placeholderb_y), BLUE, 1); //LINE FROM MIDDLE SCREEN
 
-					if (changeableplacev.changeableplacedistance)
+					if (placeholderv.placeholderdistance)
 					{
-						if (changeableplaceplayers[i].changeableplaceknocked)
+						if (placeholderplayers[i].placeholderknocked)
-							Stringchangeableplace(ImVec2(changeableplaceplayers[i].changeableplaceboxMiddle, (changeableplaceplayers[i].changeableplaceb_y + 1)), RED, changeableplacedistance.c_str());  //DISTANCE
+							Stringplaceholder(ImVec2(placeholderplayers[i].placeholderboxMiddle, (placeholderplayers[i].placeholderb_y + 1)), RED, placeholderdistance.c_str());  //DISTANCE
 						else
-							Stringchangeableplace(ImVec2(changeableplaceplayers[i].changeableplaceboxMiddle, (changeableplaceplayers[i].changeableplaceb_y + 1)), WHITE, changeableplacedistance.c_str());  //DISTANCE
+							Stringplaceholder(ImVec2(placeholderplayers[i].placeholderboxMiddle, (placeholderplayers[i].placeholderb_y + 1)), WHITE, placeholderdistance.c_str());  //DISTANCE
 					}
 
 					//esp stuff of shield bar/ bar color
-					if (changeableplacev.changeableplacehealthbar && changeableplaceplayers[i].changeableplacedist <= changeableplaceseer_dist)
+					if (placeholderv.placeholderhealthbar && placeholderplayers[i].placeholderdist <= placeholderseer_dist)
-						DrawchangeableplaceHealth((changeableplaceplayers[i].changeableplaceb_x - (changeableplaceplayers[i].changeableplacewidth / 2.0f) + 5), (changeableplaceplayers[i].changeableplaceb_y - changeableplaceplayers[i].changeableplaceheight - 10), changeableplaceplayers[i].changeableplaceshield, changeableplaceplayers[i].changeableplacemaxshield, changeableplaceplayers[i].changeableplacearmortype, changeableplaceplayers[i].changeableplacehealth);
+						DrawplaceholderHealth((placeholderplayers[i].placeholderb_x - (placeholderplayers[i].placeholderwidth / 2.0f) + 5), (placeholderplayers[i].placeholderb_y - placeholderplayers[i].placeholderheight - 10), placeholderplayers[i].placeholdershield, placeholderplayers[i].placeholdermaxshield, placeholderplayers[i].placeholderarmortype, placeholderplayers[i].placeholderhealth);
 					//name
-					if (changeableplacev.changeableplacename && changeableplaceplayers[i].changeableplacedist <= changeableplacename_dist)
+					if (placeholderv.placeholdername && placeholderplayers[i].placeholderdist <= placeholdername_dist)
-						Stringchangeableplace(ImVec2(changeableplaceplayers[i].changeableplaceboxMiddle, (changeableplaceplayers[i].changeableplaceb_y - changeableplaceplayers[i].changeableplaceheight - 15)), WHITE, changeableplaceplayers[i].changeableplacename);
+						Stringplaceholder(ImVec2(placeholderplayers[i].placeholderboxMiddle, (placeholderplayers[i].placeholderb_y - placeholderplayers[i].placeholderheight - 15)), WHITE, placeholderplayers[i].placeholdername);
 					//xp and legend
-					if (changeableplacev.changeableplacerenderxp && changeableplaceplayers[i].changeableplacedist <= changeableplacexp_dist) {
+					if (placeholderv.placeholderrenderxp && placeholderplayers[i].placeholderdist <= placeholderxp_dist) {
-						Stringchangeableplace(ImVec2(changeableplaceplayers[i].changeableplaceboxMiddle - changeableplaceplayers[i].changeableplacewidth , (changeableplaceplayers[i].changeableplaceb_y - changeableplaceplayers[i].changeableplaceheight - 15)), GREEN , changeableplacexpstr.c_str());
+						Stringplaceholder(ImVec2(placeholderplayers[i].placeholderboxMiddle - placeholderplayers[i].placeholderwidth , (placeholderplayers[i].placeholderb_y - placeholderplayers[i].placeholderheight - 15)), GREEN , placeholderxpstr.c_str());
 					}
 				}
 			}
@@ -233,73 +268,76 @@ void Overlay::RenderchangeableplaceEsp()
 int main(int argc, char** argv)
 {
 	//ShowWindow(GetForegroundWindow(), 0);  // Hide the window
-	changeableplaceadd[0] = (uintptr_t)&changeableplacecheck;
+	placeholderadd[0] = (uintptr_t)&placeholdercheck;
-	changeableplaceadd[1] = (uintptr_t)&changeableplaceaim;
+	placeholderadd[1] = (uintptr_t)&placeholderaim;
-	changeableplaceadd[2] = (uintptr_t)&changeableplaceesp;
+	placeholderadd[2] = (uintptr_t)&placeholderesp;
-	changeableplaceadd[3] = (uintptr_t)&changeableplaceaiming;
+	placeholderadd[3] = (uintptr_t)&placeholderaiming;
-	changeableplaceadd[4] = (uintptr_t)&changeableplaceg_Base;
+	placeholderadd[4] = (uintptr_t)&placeholderg_Base;
-	changeableplaceadd[5] = (uintptr_t)&changeableplacenext;
+	placeholderadd[5] = (uintptr_t)&placeholdernext;
-	changeableplaceadd[6] = (uintptr_t)&changeableplaceplayers[0];
+	placeholderadd[6] = (uintptr_t)&placeholderplayers[0];
-	changeableplaceadd[7] = (uintptr_t)&changeableplacevalid;
+	placeholderadd[7] = (uintptr_t)&placeholderspectator_list[0];
-	changeableplaceadd[8] = (uintptr_t)&changeableplacemax_dist;
+	placeholderadd[8] = (uintptr_t)&placeholdervalid;
-	changeableplaceadd[9] = (uintptr_t)&changeableplaceitem_glow;
+	placeholderadd[9] = (uintptr_t)&placeholdermax_dist;
-	changeableplaceadd[10] = (uintptr_t)&changeableplaceplayer_glow;
+	placeholderadd[10] = (uintptr_t)&placeholderitem_glow;
-	changeableplaceadd[11] = (uintptr_t)&changeableplaceaim_no_recoil;
+	placeholderadd[11] = (uintptr_t)&placeholderplayer_glow;
-	changeableplaceadd[12] = (uintptr_t)&changeableplacesmooth;
+	placeholderadd[12] = (uintptr_t)&placeholderaim_no_recoil;
-	changeableplaceadd[13] = (uintptr_t)&changeableplacemax_fov;
+	placeholderadd[13] = (uintptr_t)&placeholdersmooth;
-	changeableplaceadd[14] = (uintptr_t)&changeableplacebone;
+	placeholderadd[14] = (uintptr_t)&placeholdermax_fov;
-	changeableplaceadd[15] = (uintptr_t)&changeableplacethirdperson;
+	placeholderadd[15] = (uintptr_t)&placeholderbone;
-	changeableplaceadd[16] = (uintptr_t)&changeableplacespectators;
+	placeholderadd[16] = (uintptr_t)&placeholderthirdperson;
-	changeableplaceadd[17] = (uintptr_t)&changeableplaceallied_spectators;
+	placeholderadd[17] = (uintptr_t)&placeholderspectators;
-	changeableplaceadd[18] = (uintptr_t)&changeableplacechargerifle;
+	placeholderadd[18] = (uintptr_t)&placeholderallied_spectators;
-	changeableplaceadd[19] = (uintptr_t)&changeableplaceshooting;
+	placeholderadd[19] = (uintptr_t)&placeholderchargerifle;
-	changeableplaceadd[20] = (uintptr_t)&changeableplacefreecam;
+	placeholderadd[20] = (uintptr_t)&placeholdershooting;
-	changeableplaceadd[21] = (uintptr_t)&changeableplacelockall_mode;
+	placeholderadd[21] = (uintptr_t)&placeholderfreecam;
-	changeableplaceadd[22] = (uintptr_t)&changeableplacefiring_range;
+	placeholderadd[22] = (uintptr_t)&placeholderlockall_mode;
-
+	placeholderadd[23] = (uintptr_t)&placeholderfiring_range;
-	printf(XorStr("offset: 0x%I64x\n"), (uint64_t)&changeableplaceadd[0] - (uint64_t)GetModuleHandle(NULL));
+	placeholderadd[24] = (uintptr_t)&placeholderrcs_pitch;
-	Overlay ov1changeableplace = Overlay();
+	placeholderadd[25] = (uintptr_t)&placeholderrcs_yaw;
-	ov1changeableplace.Startchangeableplace();
+
+	printf(XorStr("offset: 0x%I64x\n"), (uint64_t)&placeholderadd[0] - (uint64_t)GetModuleHandle(NULL));
+	Overlay ov1placeholder = Overlay();
+	ov1placeholder.Startplaceholder();
 	printf(XorStr("Waiting for host/apex...\n"));
-	while (changeableplacecheck == 0xABCD)
+	while (placeholdercheck == 0xABCD)
 	{
 		if (IsKeyDown(VK_F4))
 		{
-			changeableplaceactive = false;
+			placeholderactive = false;
 			break;
 		}
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	}
-	if (changeableplaceactive)
+	if (placeholderactive)
 	{
-		changeableplaceready = true;
+		placeholderready = true;
 		printf(XorStr("Successful\n"));
 	}
 
-	while (changeableplaceactive)
+	while (placeholderactive)
 	{
 		if (IsKeyDown(VK_F4))
 		{
-			changeableplaceactive = false;
+			placeholderactive = false;
 		}
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
-		if (IsKeyDown(changeableplaceaim_key))
+		if (IsKeyDown(placeholderaim_key))
-			changeableplaceaiming = true;
+			placeholderaiming = true;
 		else
-			changeableplaceaiming = false;
+			placeholderaiming = false;
-		if (changeableplaceaim > 0) {
+		if (placeholderaim > 0) {
-			if (IsKeyDown(changeableplaceaim_key2)) {
+			if (IsKeyDown(placeholderaim_key2)) {
-				changeableplaceaim = 1;
+				placeholderaim = 1;
 			}
 			else {
-				changeableplaceaim = 2;
+				placeholderaim = 2;
 			}
 		}
 	}
-	changeableplaceready = false;
+	placeholderready = false;
-	ov1changeableplace.Clearchangeableplace();
+	ov1placeholder.Clearplaceholder();
-	if (!changeableplaceuse_nvidia)
+	if (!placeholderuse_nvidia)
 		system(XorStr("taskkill /F /T /IM ov.exe")); //custom overlay processname
 	return 0;
 }

apex_guest/Client/Client/overlay.cpp

@@ -1,72 +1,73 @@
 #include "overlay.h"
 
-extern int changeableplaceaim;
+extern int placeholderaim;
-extern bool changeableplaceesp;
+extern bool placeholderesp;
-extern bool changeableplaceaim_no_recoil;
+extern bool placeholderaim_no_recoil;
-extern bool changeableplaceready;
+extern bool placeholderready;
-extern bool changeableplaceuse_nvidia;
+extern bool placeholderuse_nvidia;
-extern float changeableplacemax_dist;
+extern float placeholdermax_dist;
-extern float changeableplaceseer_dist;
+extern float placeholderseer_dist;
-extern float changeableplacesmooth;
+extern float placeholdersmooth;
-extern float changeableplacemax_fov;
+extern float placeholdermax_fov;
-extern float changeableplacexp_dist;
+extern float placeholderxp_dist;
-extern float changeableplacescale;
+extern float placeholderscale;
-extern int changeableplacebone;
+extern int placeholderbone;
-extern bool changeableplacethirdperson;
+extern bool placeholderthirdperson;
-extern float changeableplacename_dist;
+extern float placeholdername_dist;
-extern int changeableplacespectators;
+extern int placeholderspectators;
-extern int changeableplaceallied_spectators;
+extern int placeholderallied_spectators;
-extern bool changeableplacechargerifle;
+extern bool placeholderchargerifle;
-extern bool changeableplacefreecam;
+extern bool placeholderfreecam;
-extern bool changeableplacelockall_mode;
+extern bool placeholderlockall_mode;
-extern bool changeableplacedisplay_spec;
+extern bool placeholderfiring_range;
-extern bool changeableplacefiring_range;
+extern int placeholderindex;
-extern int changeableplaceindex;
+extern float placeholderrcs_pitch;
-int changeableplacewidth;
+extern float placeholderrcs_yaw;
-int changeableplaceheight;
+int placeholderwidth;
-bool changeableplacek_leftclick = false;
+int placeholderheight;
-bool changeableplacek_ins = false;
+bool placeholderk_leftclick = false;
-bool changeableplaceshow_menu = false;
+bool placeholderk_ins = false;
-changeableplacevisuals changeableplacev;
+bool placeholdershow_menu = false;
+placeholdervisuals placeholderv;
 
 extern bool IsKeyDown(int vk);
 
-LONG changeableplacenv_default = WS_POPUP | WS_CLIPSIBLINGS;
+LONG placeholdernv_default = WS_POPUP | WS_CLIPSIBLINGS;
-LONG changeableplacenv_default_in_game = changeableplacenv_default | WS_DISABLED;
+LONG placeholdernv_default_in_game = placeholdernv_default | WS_DISABLED;
-LONG changeableplacenv_edit = changeableplacenv_default_in_game | WS_VISIBLE;
+LONG placeholdernv_edit = placeholdernv_default_in_game | WS_VISIBLE;
 
-LONG changeableplacenv_ex_default = WS_EX_TOOLWINDOW;
+LONG placeholdernv_ex_default = WS_EX_TOOLWINDOW;
-LONG changeableplacenv_ex_edit = changeableplacenv_ex_default | WS_EX_LAYERED | WS_EX_TRANSPARENT;
+LONG placeholdernv_ex_edit = placeholdernv_ex_default | WS_EX_LAYERED | WS_EX_TRANSPARENT;
-LONG changeableplacenv_ex_edit_menu = changeableplacenv_ex_default | WS_EX_TRANSPARENT;
+LONG placeholdernv_ex_edit_menu = placeholdernv_ex_default | WS_EX_TRANSPARENT;
 
-static DWORD WINAPI StaticMessageStart(void* changeableplaceParam)
+static DWORD WINAPI StaticMessageStart(void* placeholderParam)
 {
-	Overlay* changeableplaceov = (Overlay*)changeableplaceParam;
+	Overlay* placeholderov = (Overlay*)placeholderParam;
-	changeableplaceov->CreatechangeableplaceOverlay();
+	placeholderov->CreateplaceholderOverlay();
 	return 0;
 }
 
-BOOL CALLBACK EnumWindowsCallback(HWND changeableplacehwnd, LPARAM lParam)
+BOOL CALLBACK EnumWindowsCallback(HWND placeholderhwnd, LPARAM lParam)
 {
-	wchar_t classchangeableplaceName[255] = L"";
+	wchar_t classplaceholderName[255] = L"";
-	GetClassName(changeableplacehwnd, classchangeableplaceName, 255);
+	GetClassName(placeholderhwnd, classplaceholderName, 255);
-	if (changeableplaceuse_nvidia)
+	if (placeholderuse_nvidia)
 	{
-		if (wcscmp(XorStrW(L"CEF-OSC-WIDGET"), classchangeableplaceName) == 0) //Nvidia overlay
+		if (wcscmp(XorStrW(L"CEF-OSC-WIDGET"), classplaceholderName) == 0) //Nvidia overlay
 		{
 			HWND* w = (HWND*)lParam;
-			if (GetWindowLong(changeableplacehwnd, GWL_STYLE) != changeableplacenv_default && GetWindowLong(changeableplacehwnd, GWL_STYLE) != changeableplacenv_default_in_game)
+			if (GetWindowLong(placeholderhwnd, GWL_STYLE) != placeholdernv_default && GetWindowLong(placeholderhwnd, GWL_STYLE) != placeholdernv_default_in_game)
 				return TRUE;
-			*w = changeableplacehwnd;
+			*w = placeholderhwnd;
 			return TRUE;
 		}
 	}
 	else
 	{
-		if (wcscmp(XorStrW(L"changeableplaceoverlay"), classchangeableplaceName) == 0) //Custom overlay
+		if (wcscmp(XorStrW(L"placeholderoverlay"), classplaceholderName) == 0) //Custom overlay
 		{
 			HWND* w = (HWND*)lParam;
-			*w = changeableplacehwnd;
+			*w = placeholderhwnd;
 			return TRUE;
 		}
 	}
@@ -85,29 +86,29 @@ void CleanupDeviceD3D();
 void CreateRenderTarget();
 void CleanupRenderTarget();
 
-void Overlay::RenderchangeableplaceMenu()
+void Overlay::RenderplaceholderMenu()
 {
-	static bool changeableplaceaim_enable = false;
+	static bool placeholderaim_enable = false;
-	static bool changeableplacevis_check = false;
+	static bool placeholdervis_check = false;
-	static bool changeableplacespec_disable = false;
+	static bool placeholderspec_disable = false;
-	static bool changeableplaceall_spec_disable = false;
+	static bool placeholderall_spec_disable = false;
 
-	if (changeableplaceaim > 0)
+	if (placeholderaim > 0)
 	{
-		changeableplaceaim_enable = true;
+		placeholderaim_enable = true;
-		if (changeableplaceaim > 1)
+		if (placeholderaim > 1)
 		{
-			changeableplacevis_check = true;
+			placeholdervis_check = true;
 		}
 		else
 		{
-			changeableplacevis_check = false;
+			placeholdervis_check = false;
 		}
 	}
 	else
 	{
-		changeableplaceaim_enable = false;
+		placeholderaim_enable = false;
-		changeableplacevis_check = false;
+		placeholdervis_check = false;
 	}
 	ImGui::SetNextWindowPos(ImVec2(0, 0));
 	ImGui::SetNextWindowSize(ImVec2(490, 275));
@@ -117,82 +118,88 @@ void Overlay::RenderchangeableplaceMenu()
 	{
 		if (ImGui::BeginTabItem(XorStr(u8"MainMenu")))
 		{
-			ImGui::Checkbox(XorStr(u8"ESP"), &changeableplaceesp);
+			ImGui::Checkbox(XorStr(u8"ESP"), &placeholderesp);
-			ImGui::Checkbox(XorStr(u8"Aimbot"), &changeableplaceaim_enable);
+			ImGui::Checkbox(XorStr(u8"Aimbot"), &placeholderaim_enable);
 
-			if (changeableplaceaim_enable)
+			if (placeholderaim_enable)
 			{
 				ImGui::SameLine();
-				ImGui::Checkbox(XorStr(u8"Visible check"), &changeableplacevis_check);
+				ImGui::Checkbox(XorStr(u8"Visible check"), &placeholdervis_check);
 				ImGui::SameLine();
-				ImGui::Checkbox(XorStr(u8"No recoil"), &changeableplaceaim_no_recoil);
+				ImGui::Checkbox(XorStr(u8"No recoil"), &placeholderaim_no_recoil);
-				if (changeableplacevis_check)
+				if (placeholdervis_check)
 				{
-					changeableplaceaim = 2;
+					placeholderaim = 2;
 				}
 				else
 				{
-					changeableplaceaim = 1;
+					placeholderaim = 1;
 				}
 			}
 			else
 			{
-				changeableplaceaim = 0;
+				placeholderaim = 0;
 			}
 
-			ImGui::Checkbox(XorStr(u8"freecamera"), &changeableplacefreecam);
+			ImGui::Checkbox(XorStr(u8"freecamera"), &placeholderfreecam);
-			ImGui::Checkbox(XorStr(u8"Lock on teammates"), &changeableplacelockall_mode);
+			ImGui::Checkbox(XorStr(u8"Lock on teammates"), &placeholderlockall_mode);
-			ImGui::Checkbox(XorStr(u8"firing_range mode"), &changeableplacefiring_range);//changeableplacefiring_range
+			ImGui::Checkbox(XorStr(u8"firing_range mode"), &placeholderfiring_range);//placeholderfiring_range
-			//ImGui::InputInt(XorStr("index"), &changeableplaceindex);//changeableplaceindex
+			//ImGui::InputInt(XorStr("index"), &placeholderindex);//placeholderindex
 			ImGui::EndTabItem();
 		}
 		if (ImGui::BeginTabItem(XorStr(u8"Aimbot")))
 		{
 			ImGui::Text(XorStr(u8"Max distence:"));
-			ImGui::SliderFloat(XorStr("##1"), &changeableplacemax_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SliderFloat(XorStr("##1"), &placeholdermax_dist, 100.0f * 40, 800.0f * 40, "%.2f");
 			ImGui::SameLine();
-			ImGui::Text(u8"(%d M)", (int)(changeableplacemax_dist / 40));
+			ImGui::Text(u8"(%d M)", (int)(placeholdermax_dist / 40));
-			ImGui::Text(u8"real dist :%d M", (int)(changeableplacemax_dist / 40));
+			ImGui::Text(u8"real dist :%d M", (int)(placeholdermax_dist / 40));
 
 			ImGui::Text(XorStr(u8"Smooth"));
-			ImGui::SliderFloat(XorStr("##2"), &changeableplacesmooth, 76.0f, 100.0f, "%.2f");
+			ImGui::SliderFloat(XorStr("##2"), &placeholdersmooth, 76.0f, 100.0f, "%.2f");
 
 			ImGui::Text(XorStr(u8"FOV:"));
-			ImGui::SliderFloat(XorStr("##3"), &changeableplacemax_fov, 5.0f, 250.0f, "%.2f");
+			ImGui::SliderFloat(XorStr("##3"), &placeholdermax_fov, 5.0f, 250.0f, "%.2f");
 
 			ImGui::Text(XorStr(u8"Bone:"));
-			ImGui::SliderInt(XorStr("##4"), &changeableplacebone, 0, 3);
+			ImGui::SliderInt(XorStr("##4"), &placeholderbone, 0, 3);
+
+			ImGui::Text(XorStr(u8"RCS PITCH:"));
+			ImGui::SliderFloat(XorStr("##5"), &placeholderrcs_pitch, 0, 1);
+
+			ImGui::Text(XorStr(u8"RCS YAW:"));
+			ImGui::SliderFloat(XorStr("##6"), &placeholderrcs_yaw, 0, 1);
 
 			//ImGui::Text(XorStr(u8"FOV Draw scale:"));
-			//ImGui::SliderFloat(XorStr("##5"), &changeableplacescale, 0.0f, 140.0f, "%.2f");
+			//ImGui::SliderFloat(XorStr("##5"), &placeholderscale, 0.0f, 140.0f, "%.2f");
 			ImGui::EndTabItem();
 		}
 		if (ImGui::BeginTabItem(XorStr(u8"ESPHACK")))
 		{
 			ImGui::Text(XorStr(u8"ESP"));
 			//ImGui::Checkbox
-			ImGui::Checkbox(XorStr(u8"BOX"), &changeableplacev.changeableplacebox);
+			ImGui::Checkbox(XorStr(u8"BOX"), &placeholderv.placeholderbox);
 			ImGui::SameLine(0, 70.0f);
-			ImGui::Checkbox(XorStr(u8"Name"), &changeableplacev.changeableplacename);
+			ImGui::Checkbox(XorStr(u8"Name"), &placeholderv.placeholdername);
-			ImGui::Checkbox(XorStr(u8"xp level"), &changeableplacev.changeableplacerenderxp);
+			ImGui::Checkbox(XorStr(u8"xp level"), &placeholderv.placeholderrenderxp);
-			ImGui::Checkbox(XorStr(u8"line"), &changeableplacev.changeableplaceline);
+			ImGui::Checkbox(XorStr(u8"line"), &placeholderv.placeholderline);
-			ImGui::Checkbox(XorStr(u8"dist + teamID"), &changeableplacev.changeableplacedistance);
+			ImGui::Checkbox(XorStr(u8"dist + teamID"), &placeholderv.placeholderdistance);
-			ImGui::Checkbox(XorStr(u8"seer esp"), &changeableplacev.changeableplacehealthbar);
+			ImGui::Checkbox(XorStr(u8"seer esp"), &placeholderv.placeholderhealthbar);
 
 			ImGui::Text(XorStr(u8"seer esp distence:"));
-			ImGui::SliderFloat(XorStr("##1"), &changeableplaceseer_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SliderFloat(XorStr("##1"), &placeholderseer_dist, 100.0f * 40, 800.0f * 40, "%.2f");
 			ImGui::SameLine();
-			ImGui::Text(u8"(%d M)", (int)(changeableplaceseer_dist / 40));
+			ImGui::Text(u8"(%d M)", (int)(placeholderseer_dist / 40));
 
 			ImGui::Text(XorStr(u8"XP level display distence:"));
-			ImGui::SliderFloat(XorStr("##2"), &changeableplacexp_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SliderFloat(XorStr("##2"), &placeholderxp_dist, 100.0f * 40, 800.0f * 40, "%.2f");
 			ImGui::SameLine();
-			ImGui::Text(u8"(%d M)", (int)(changeableplacexp_dist / 40));
+			ImGui::Text(u8"(%d M)", (int)(placeholderxp_dist / 40));
 
 			ImGui::Text(XorStr(u8"name esp distence:"));
-			ImGui::SliderFloat(XorStr("##3"), &changeableplacename_dist, 100.0f * 40, 800.0f * 40, "%.2f");
+			ImGui::SliderFloat(XorStr("##3"), &placeholdername_dist, 100.0f * 40, 800.0f * 40, "%.2f");
 			ImGui::SameLine();
-			ImGui::Text(u8"(%d M)", (int)(changeableplacename_dist / 40));
+			ImGui::Text(u8"(%d M)", (int)(placeholdername_dist / 40));
 			ImGui::EndTabItem();
 		}
 		ImGui::EndTabBar();
@@ -200,44 +207,40 @@ void Overlay::RenderchangeableplaceMenu()
 	ImGui::End();
 }
 
-void Overlay::RenderchangeableplaceInfo()
+void Overlay::RenderplaceholderInfo()
 {
-	//ImGui::Begin("#FOVC'", nullptr, ImGuiWindowFlags_NoMove | ImGuiInputTextFlags_ReadOnly | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar);
-	//auto draw = ImGui::GetBackgroundDrawList();
-	//draw ->AddCircle(ImVec2(1920 / 2, 1080 / 2), changeableplacemax_fov * changeableplacescale ,IM_COL32(255, 0, 0, 255), 100, 0.0f);
-	//ImGui::End();
 	ImGui::SetNextWindowPos(ImVec2(0, 0));
 	ImGui::SetNextWindowSize(ImVec2(210, 25));
 	ImGui::Begin(XorStr("##info"), (bool*)true, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar);
-	ImGui::TextColored(RED, u8"Enemies %d", changeableplacespectators);
+	ImGui::TextColored(RED, u8"Enemies %d", placeholderspectators);
 	ImGui::SameLine();
 	ImGui::Text(" / ");
 	ImGui::SameLine();
-	ImGui::TextColored(GREEN, u8"Team %d", changeableplaceallied_spectators);
+	ImGui::TextColored(GREEN, u8"Team %d", placeholderallied_spectators);
 	ImGui::End();
 }
 
-void Overlay::ClickchangeableplaceThrough(bool changeableplacev)
+void Overlay::ClickplaceholderThrough(bool placeholderv)
 {
-	if (changeableplacev)
+	if (placeholderv)
 	{
-		changeableplacenv_edit = changeableplacenv_default_in_game | WS_VISIBLE;
+		placeholdernv_edit = placeholdernv_default_in_game | WS_VISIBLE;
-		if (GetWindowLong(overlaychangeableplaceHWND, GWL_EXSTYLE) != changeableplacenv_ex_edit)
+		if (GetWindowLong(overlayplaceholderHWND, GWL_EXSTYLE) != placeholdernv_ex_edit)
-			SetWindowLong(overlaychangeableplaceHWND, GWL_EXSTYLE, changeableplacenv_ex_edit);
+			SetWindowLong(overlayplaceholderHWND, GWL_EXSTYLE, placeholdernv_ex_edit);
 	}
 	else
 	{
-		changeableplacenv_edit = changeableplacenv_default | WS_VISIBLE;
+		placeholdernv_edit = placeholdernv_default | WS_VISIBLE;
-		if (GetWindowLong(overlaychangeableplaceHWND, GWL_EXSTYLE) != changeableplacenv_ex_edit_menu)
+		if (GetWindowLong(overlayplaceholderHWND, GWL_EXSTYLE) != placeholdernv_ex_edit_menu)
-			SetWindowLong(overlaychangeableplaceHWND, GWL_EXSTYLE, changeableplacenv_ex_edit_menu);
+			SetWindowLong(overlayplaceholderHWND, GWL_EXSTYLE, placeholdernv_ex_edit_menu);
 	}
 }
 
-DWORD Overlay::CreatechangeableplaceOverlay()
+DWORD Overlay::CreateplaceholderOverlay()
 {
-	EnumWindows(EnumWindowsCallback, (LPARAM)&overlaychangeableplaceHWND);
+	EnumWindows(EnumWindowsCallback, (LPARAM)&overlayplaceholderHWND);
 	Sleep(300);
-	if (overlaychangeableplaceHWND == 0)
+	if (overlayplaceholderHWND == 0)
 	{
 		printf(XorStr("Can't find the overlay\n"));
 		Sleep(1000);
@@ -245,21 +248,21 @@ DWORD Overlay::CreatechangeableplaceOverlay()
 	}
 
 	HDC hDC = ::GetWindowDC(NULL);
-	changeableplacewidth = ::GetDeviceCaps(hDC, HORZRES);
+	placeholderwidth = ::GetDeviceCaps(hDC, HORZRES);
-	changeableplaceheight = ::GetDeviceCaps(hDC, VERTRES);
+	placeholderheight = ::GetDeviceCaps(hDC, VERTRES);
 
-	changeableplacerunning = true;
+	placeholderrunning = true;
 
 	// Initialize Direct3D
-	if (!CreateDeviceD3D(overlaychangeableplaceHWND))
+	if (!CreateDeviceD3D(overlayplaceholderHWND))
 	{
 		CleanupDeviceD3D();
 		return 1;
 	}
 
 	// Show the window
-	::ShowWindow(overlaychangeableplaceHWND, SW_SHOWDEFAULT);
+	::ShowWindow(overlayplaceholderHWND, SW_SHOWDEFAULT);
-	::UpdateWindow(overlaychangeableplaceHWND);
+	::UpdateWindow(overlayplaceholderHWND);
 
 	// Setup Dear ImGui context
 	IMGUI_CHECKVERSION();
@@ -274,7 +277,7 @@ DWORD Overlay::CreatechangeableplaceOverlay()
 	ImGui::GetStyle().WindowMinSize = ImVec2(1, 1);
 
 	// Setup Platform/Renderer bindings
-	ImGui_ImplWin32_Init(overlaychangeableplaceHWND);
+	ImGui_ImplWin32_Init(overlayplaceholderHWND);
 	ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
 
 	ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 0.00f);
@@ -282,14 +285,14 @@ DWORD Overlay::CreatechangeableplaceOverlay()
 	// Main loop
 	MSG msg;
 	ZeroMemory(&msg, sizeof(msg));
-	ClickchangeableplaceThrough(true);
+	ClickplaceholderThrough(true);
-	while (changeableplacerunning)
+	while (placeholderrunning)
 	{
 		HWND wnd = GetWindow(GetForegroundWindow(), GW_HWNDPREV);
-		if (wnd != overlaychangeableplaceHWND)
+		if (wnd != overlayplaceholderHWND)
 		{
-			SetWindowPos(overlaychangeableplaceHWND, wnd, 0, 0, 0, 0, SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE);
+			SetWindowPos(overlayplaceholderHWND, wnd, 0, 0, 0, 0, SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE);
-			::UpdateWindow(overlaychangeableplaceHWND);
+			::UpdateWindow(overlayplaceholderHWND);
 		}
 
 		if (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
@@ -304,35 +307,36 @@ DWORD Overlay::CreatechangeableplaceOverlay()
 		ImGui_ImplWin32_NewFrame();
 		ImGui::NewFrame();
 
-		if (IsKeyDown(VK_LBUTTON) && !changeableplacek_leftclick)
+		if (IsKeyDown(VK_LBUTTON) && !placeholderk_leftclick)
 		{
 			io.MouseDown[0] = true;
-			changeableplacek_leftclick = true;
+			placeholderk_leftclick = true;
 		}
-		else if (!IsKeyDown(VK_LBUTTON) && changeableplacek_leftclick)
+		else if (!IsKeyDown(VK_LBUTTON) && placeholderk_leftclick)
 		{
 			io.MouseDown[0] = false;
-			changeableplacek_leftclick = false;
+			placeholderk_leftclick = false;
 		}
 
-		if (IsKeyDown(VK_INSERT) && !changeableplacek_ins && changeableplaceready)
+		if (IsKeyDown(VK_INSERT) && !placeholderk_ins && placeholderready)
 		{
-			changeableplaceshow_menu = !changeableplaceshow_menu;
+			placeholdershow_menu = !placeholdershow_menu;
-			ClickchangeableplaceThrough(!changeableplaceshow_menu);
+			ClickplaceholderThrough(!placeholdershow_menu);
-			changeableplacek_ins = true;
+			placeholderk_ins = true;
 		}
-		else if (!IsKeyDown(VK_INSERT) && changeableplacek_ins)
+		else if (!IsKeyDown(VK_INSERT) && placeholderk_ins)
 		{
-			changeableplacek_ins = false;
+			placeholderk_ins = false;
 		}
-		if (changeableplaceshow_menu) {
+		if (placeholdershow_menu) {
-			RenderchangeableplaceMenu();
+			RenderplaceholderMenu();
 		}
 		else {
-			RenderchangeableplaceInfo();
+			RenderplaceholderInfo();
+			RenderplaceholderSpectator();
 		}
 
-		RenderchangeableplaceEsp();
+		RenderplaceholderEsp();
 
 		// Rendering
 		ImGui::EndFrame();
@@ -346,33 +350,33 @@ DWORD Overlay::CreatechangeableplaceOverlay()
 
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	}
-	ClickchangeableplaceThrough(true);
+	ClickplaceholderThrough(true);
 
 	CleanupDeviceD3D();
-	::DestroyWindow(overlaychangeableplaceHWND);
+	::DestroyWindow(overlayplaceholderHWND);
 	return 0;
 }
 
-void Overlay::Startchangeableplace()
+void Overlay::Startplaceholder()
 {
 	DWORD ThreadID;
 	CreateThread(NULL, 0, StaticMessageStart, (void*)this, 0, &ThreadID);
 }
 
-void Overlay::Clearchangeableplace()
+void Overlay::Clearplaceholder()
 {
-	changeableplacerunning = 0;
+	placeholderrunning = 0;
 	Sleep(50);
 }
 
-int Overlay::getchangeableplaceWidth()
+int Overlay::getplaceholderWidth()
 {
-	return changeableplacewidth;
+	return placeholderwidth;
 }
 
-int Overlay::getchangeableplaceHeight()
+int Overlay::getplaceholderHeight()
 {
-	return changeableplaceheight;
+	return placeholderheight;
 }
 
 // Helper functions
@@ -431,37 +435,47 @@ void CleanupDeviceD3D()
 	if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
 }
 
-void Overlay::DrawchangeableplaceLine(ImVec2 a, ImVec2 b, ImColor color, float width)
+void Overlay::DrawplaceholderLine(ImVec2 a, ImVec2 b, ImColor color, float width)
 {
 	ImGui::GetWindowDrawList()->AddLine(a, b, color, width);
 }
 
-void Overlay::DrawchangeableplaceBox(ImColor color, float x, float y, float w, float h)
+void Overlay::DrawplaceholderBox(ImColor color, float x, float y, float w, float h)
 {
-	DrawchangeableplaceLine(ImVec2(x, y), ImVec2(x + w, y), color, 1.0f);
+	DrawplaceholderLine(ImVec2(x, y), ImVec2(x + w, y), color, 1.0f);
-	DrawchangeableplaceLine(ImVec2(x, y), ImVec2(x, y + h), color, 1.0f);
+	DrawplaceholderLine(ImVec2(x, y), ImVec2(x, y + h), color, 1.0f);
-	DrawchangeableplaceLine(ImVec2(x + w, y), ImVec2(x + w, y + h), color, 1.0f);
+	DrawplaceholderLine(ImVec2(x + w, y), ImVec2(x + w, y + h), color, 1.0f);
-	DrawchangeableplaceLine(ImVec2(x, y + h), ImVec2(x + w, y + h), color, 1.0f);
+	DrawplaceholderLine(ImVec2(x, y + h), ImVec2(x + w, y + h), color, 1.0f);
 }
 
-void Overlay::changeableplaceText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4 * cpu_fine_clip_rect)
+void Overlay::placeholderText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4 * cpu_fine_clip_rect)
 {
 	ImGui::GetWindowDrawList()->AddText(ImGui::GetFont(), 14, pos, color, text_begin, text_end, wrap_width, cpu_fine_clip_rect);
 }
 
-void Overlay::Stringchangeableplace(ImVec2 pos, ImColor color, const char* text)
+void Overlay::placeholderText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4* cpu_fine_clip_rect , int font)
+{
+	ImGui::GetWindowDrawList()->AddText(ImGui::GetFont(), font, pos, color, text_begin, text_end, wrap_width, cpu_fine_clip_rect);
+}
+
+void Overlay::Stringplaceholder(ImVec2 pos, ImColor color, const char* text)
+{
+	placeholderText(pos, color, text, text + strlen(text), 200, 0);
+}
+
+void Overlay::Stringplaceholder(ImVec2 pos, ImColor color, const char* text,int font)
 {
-	changeableplaceText(pos, color, text, text + strlen(text), 200, 0);
+	placeholderText(pos, color, text, text + strlen(text), 200, 0 , font);
 }
 
-void Overlay::RectchangeableplaceFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags)
+void Overlay::RectplaceholderFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags)
 {
 	ImGui::GetWindowDrawList()->AddRectFilled(ImVec2(x0, y0), ImVec2(x1, y1), color, rounding, rounding_corners_flags);
 }
 
-void Overlay::ProgresschangeableplaceBar(float x, float y, float w, float h, int value, int v_max, ImColor barColor)
+void Overlay::ProgressplaceholderBar(float x, float y, float w, float h, int value, int v_max, ImColor barColor)
 {
-	RectchangeableplaceFilled(x, y, x + w, y + ((h / float(v_max)) * (float)value), barColor, 0.0f, 0);
+	RectplaceholderFilled(x, y, x + w, y + ((h / float(v_max)) * (float)value), barColor, 0.0f, 0);
 }
 
 
@@ -478,36 +492,36 @@ void DrawHexagonFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, con
 	ImGui::GetWindowDrawList()->AddHexagonFilled(p1, p2, p3, p4, p5, p6, col);
 }
 
-void Overlay::DrawchangeableplaceHealth(float changeableplacex, float changeableplacey, int changeableplaceshield, int changeableplacemax_shield, int changeableplacearmorType, int changeableplacehealth) {
+void Overlay::DrawplaceholderHealth(float placeholderx, float placeholdery, int placeholdershield, int placeholdermax_shield, int placeholderarmorType, int placeholderhealth) {
 
-	int changeableplacebg_offset = 3;
+	int placeholderbg_offset = 3;
-	int changeableplacebar_width = 105; //158
+	int placeholderbar_width = 105; //158
 	// 4steps...2*3=6
 	// 38*4=152 152+6 = 158
 	// 5steps...2*4=8
 	// 30*5=150 150+8 = 158
-	float changeableplacemax_health = 100.0f;//100
+	float placeholdermax_health = 100.0f;//100
-	float changeableplaceshield_step = 25.0f; //25
+	float placeholdershield_step = 25.0f; //25
 
-	int changeableplaceshield_25 = 14; //30
+	int placeholdershield_25 = 14; //30
-	int changeableplacesteps = 5;
+	int placeholdersteps = 5;
 
 
-	ImVec2 bg1(changeableplacex - changeableplacebar_width / 2 - changeableplacebg_offset, changeableplacey);
+	ImVec2 bg1(placeholderx - placeholderbar_width / 2 - placeholderbg_offset, placeholdery);
 	ImVec2 bg2(bg1.x - 10, bg1.y - 16);
 	ImVec2 bg3(bg2.x + 5, bg2.y - 7);
-	ImVec2 bg4(bg3.x + changeableplacebar_width + changeableplacebg_offset, bg3.y);
+	ImVec2 bg4(bg3.x + placeholderbar_width + placeholderbg_offset, bg3.y);
 	ImVec2 bg5(bg4.x + 11, bg4.y + 18);
-	ImVec2 bg6(changeableplacex + changeableplacebar_width / 2 + changeableplacebg_offset, changeableplacey);
+	ImVec2 bg6(placeholderx + placeholderbar_width / 2 + placeholderbg_offset, placeholdery);
 	DrawHexagonFilled(bg1, bg2, bg3, bg4, bg5, bg6, ImColor(0, 0, 0, 120));
 
 
 	ImVec2 h1(bg1.x + 3, bg1.y - 4);
 	ImVec2 h2(h1.x - 5, h1.y - 8);
-	ImVec2 h3(h2.x + (float)changeableplacehealth / changeableplacemax_health * changeableplacebar_width, h2.y);
+	ImVec2 h3(h2.x + (float)placeholderhealth / placeholdermax_health * placeholderbar_width, h2.y);
-	ImVec2 h4(h1.x + (float)changeableplacehealth / changeableplacemax_health * changeableplacebar_width, h1.y);
+	ImVec2 h4(h1.x + (float)placeholderhealth / placeholdermax_health * placeholderbar_width, h1.y);
-	ImVec2 h3m(h2.x + changeableplacebar_width, h2.y);
+	ImVec2 h3m(h2.x + placeholderbar_width, h2.y);
-	ImVec2 h4m(h1.x + changeableplacebar_width, h1.y);
+	ImVec2 h4m(h1.x + placeholderbar_width, h1.y);
 	DrawQuadFilled(h1, h2, h3m, h4m, ImColor(10, 10, 30, 60));
 	DrawQuadFilled(h1, h2, h3, h4, WHITE);
 
@@ -517,23 +531,23 @@ void Overlay::DrawchangeableplaceHealth(float changeableplacex, float changeable
 
 	ImColor shieldCol;
 	ImColor shieldColDark; //not used, but the real seer q has shadow inside
-	if (changeableplacemax_shield == 50) { //white
+	if (placeholdermax_shield == 50) { //white
 		shieldCol = ImColor(247, 247, 247);
 		shieldColDark = ImColor(164, 164, 164);
 	}
-	else if (changeableplacemax_shield == 75) { //blue
+	else if (placeholdermax_shield == 75) { //blue
 		shieldCol = ImColor(39, 178, 255);
 		shieldColDark = ImColor(27, 120, 210);
 	}
-	else if (changeableplacemax_shield == 100) { //purple
+	else if (placeholdermax_shield == 100) { //purple
 		shieldCol = ImColor(206, 59, 255);
 		shieldColDark = ImColor(136, 36, 220);
 	}
-	else if (changeableplacemax_shield == 100) { //gold
+	else if (placeholdermax_shield == 100) { //gold
 		shieldCol = ImColor(255, 255, 79);
 		shieldColDark = ImColor(218, 175, 49);
 	}
-	else if (changeableplacemax_shield == 125) { //red
+	else if (placeholdermax_shield == 125) { //red
 		shieldCol = ImColor(219, 2, 2);
 		shieldColDark = ImColor(219, 2, 2);
 	}
@@ -541,7 +555,7 @@ void Overlay::DrawchangeableplaceHealth(float changeableplacex, float changeable
 		shieldCol = ImColor(247, 247, 247);
 		shieldColDark = ImColor(164, 164, 164);
 	}
-	int shield_tmp = changeableplaceshield;
+	int shield_tmp = placeholdershield;
 	int shield1 = 0;
 	int shield2 = 0;
 	int shield3 = 0;
@@ -578,185 +592,185 @@ void Overlay::DrawchangeableplaceHealth(float changeableplacex, float changeable
 	}
 	ImVec2 s1(h2.x - 1, h2.y - 2);
 	ImVec2 s2(s1.x - 3, s1.y - 5);
-	ImVec2 s3(s2.x + shield1 / changeableplaceshield_step * changeableplaceshield_25, s2.y);
+	ImVec2 s3(s2.x + shield1 / placeholdershield_step * placeholdershield_25, s2.y);
-	ImVec2 s4(s1.x + shield1 / changeableplaceshield_step * changeableplaceshield_25, s1.y);
+	ImVec2 s4(s1.x + shield1 / placeholdershield_step * placeholdershield_25, s1.y);
-	ImVec2 s3m(s2.x + changeableplaceshield_25, s2.y);
+	ImVec2 s3m(s2.x + placeholdershield_25, s2.y);
-	ImVec2 s4m(s1.x + changeableplaceshield_25, s1.y);
+	ImVec2 s4m(s1.x + placeholdershield_25, s1.y);
 
 	ImVec2 ss1(s4m.x + 2, s1.y);
 	ImVec2 ss2(s3m.x + 2, s2.y);
-	ImVec2 ss3(ss2.x + shield2 / changeableplaceshield_step * changeableplaceshield_25, s2.y);
+	ImVec2 ss3(ss2.x + shield2 / placeholdershield_step * placeholdershield_25, s2.y);
-	ImVec2 ss4(ss1.x + shield2 / changeableplaceshield_step * changeableplaceshield_25, s1.y);
+	ImVec2 ss4(ss1.x + shield2 / placeholdershield_step * placeholdershield_25, s1.y);
-	ImVec2 ss3m(ss2.x + changeableplaceshield_25, s2.y);
+	ImVec2 ss3m(ss2.x + placeholdershield_25, s2.y);
-	ImVec2 ss4m(ss1.x + changeableplaceshield_25, s1.y);
+	ImVec2 ss4m(ss1.x + placeholdershield_25, s1.y);
 
 	ImVec2 sss1(ss4m.x + 2, s1.y);
 	ImVec2 sss2(ss3m.x + 2, s2.y);
-	ImVec2 sss3(sss2.x + shield3 / changeableplaceshield_step * changeableplaceshield_25, s2.y);
+	ImVec2 sss3(sss2.x + shield3 / placeholdershield_step * placeholdershield_25, s2.y);
-	ImVec2 sss4(sss1.x + shield3 / changeableplaceshield_step * changeableplaceshield_25, s1.y);
+	ImVec2 sss4(sss1.x + shield3 / placeholdershield_step * placeholdershield_25, s1.y);
-	ImVec2 sss3m(sss2.x + changeableplaceshield_25, s2.y);
+	ImVec2 sss3m(sss2.x + placeholdershield_25, s2.y);
-	ImVec2 sss4m(sss1.x + changeableplaceshield_25, s1.y);
+	ImVec2 sss4m(sss1.x + placeholdershield_25, s1.y);
 
 	ImVec2 ssss1(sss4m.x + 2, s1.y);
 	ImVec2 ssss2(sss3m.x + 2, s2.y);
-	ImVec2 ssss3(ssss2.x + shield4 / changeableplaceshield_step * changeableplaceshield_25, s2.y);
+	ImVec2 ssss3(ssss2.x + shield4 / placeholdershield_step * placeholdershield_25, s2.y);
-	ImVec2 ssss4(ssss1.x + shield4 / changeableplaceshield_step * changeableplaceshield_25, s1.y);
+	ImVec2 ssss4(ssss1.x + shield4 / placeholdershield_step * placeholdershield_25, s1.y);
-	ImVec2 ssss3m(ssss2.x + changeableplaceshield_25, s2.y);
+	ImVec2 ssss3m(ssss2.x + placeholdershield_25, s2.y);
-	ImVec2 ssss4m(ssss1.x + changeableplaceshield_25, s1.y);
+	ImVec2 ssss4m(ssss1.x + placeholdershield_25, s1.y);
 
 	ImVec2 sssss1(ssss4m.x + 2, s1.y);
 	ImVec2 sssss2(ssss3m.x + 2, s2.y);
-	ImVec2 sssss3(sssss2.x + shield5 / changeableplaceshield_step * changeableplaceshield_25, s2.y);
+	ImVec2 sssss3(sssss2.x + shield5 / placeholdershield_step * placeholdershield_25, s2.y);
-	ImVec2 sssss4(sssss1.x + shield5 / changeableplaceshield_step * changeableplaceshield_25, s1.y);
+	ImVec2 sssss4(sssss1.x + shield5 / placeholdershield_step * placeholdershield_25, s1.y);
-	ImVec2 sssss3m(sssss2.x + changeableplaceshield_25, s2.y);
+	ImVec2 sssss3m(sssss2.x + placeholdershield_25, s2.y);
-	ImVec2 sssss4m(sssss1.x + changeableplaceshield_25, s1.y);
+	ImVec2 sssss4m(sssss1.x + placeholdershield_25, s1.y);
-	if (changeableplacemax_shield == 50) {
+	if (placeholdermax_shield == 50) {
-		if (changeableplaceshield <= 25) {
+		if (placeholdershield <= 25) {
-			if (changeableplaceshield < 25) {
+			if (placeholdershield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (changeableplaceshield <= 50) {
+		else if (placeholdershield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (changeableplaceshield != 50) {
+			if (placeholdershield != 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
 	}
-	else if (changeableplacemax_shield == 75) {
+	else if (placeholdermax_shield == 75) {
-		if (changeableplaceshield <= 25) {
+		if (placeholdershield <= 25) {
-			if (changeableplaceshield < 25) {
+			if (placeholdershield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (changeableplaceshield <= 50) {
+		else if (placeholdershield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (changeableplaceshield < 50) {
+			if (placeholdershield < 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
-		else if (changeableplaceshield <= 75) {
+		else if (placeholdershield <= 75) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
-			if (changeableplaceshield < 75) {
+			if (placeholdershield < 75) {
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 		}
 	}
-	else if (changeableplacemax_shield == 100) {
+	else if (placeholdermax_shield == 100) {
-		if (changeableplaceshield <= 25) {
+		if (placeholdershield <= 25) {
-			if (changeableplaceshield < 25) {
+			if (placeholdershield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (changeableplaceshield <= 50) {
+		else if (placeholdershield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (changeableplaceshield < 50) {
+			if (placeholdershield < 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
-		else if (changeableplaceshield <= 75) {
+		else if (placeholdershield <= 75) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
-			if (changeableplaceshield < 75) {
+			if (placeholdershield < 75) {
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 		}
-		else if (changeableplaceshield <= 100) {
+		else if (placeholdershield <= 100) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 			DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
-			if (changeableplaceshield < 100) {
+			if (placeholdershield < 100) {
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(ssss1, ssss2, ssss3, ssss4, shieldCol);
 		}
 	}
-	else if (changeableplacemax_shield == 125) {
+	else if (placeholdermax_shield == 125) {
-		if (changeableplaceshield <= 25) {
+		if (placeholdershield <= 25) {
-			if (changeableplaceshield < 25) {
+			if (placeholdershield < 25) {
 				DrawQuadFilled(s1, s2, s3m, s4m, shieldCracked);
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 
 		}
-		else if (changeableplaceshield <= 50) {
+		else if (placeholdershield <= 50) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
-			if (changeableplaceshield < 50) {
+			if (placeholdershield < 50) {
 				DrawQuadFilled(ss1, ss2, ss3m, ss4m, shieldCracked);
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 		}
-		else if (changeableplaceshield <= 75) {
+		else if (placeholdershield <= 75) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
-			if (changeableplaceshield < 75) {
+			if (placeholdershield < 75) {
 				DrawQuadFilled(sss1, sss2, sss3m, sss4m, shieldCracked);
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 		}
-		else if (changeableplaceshield <= 100) {
+		else if (placeholdershield <= 100) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 			DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
-			if (changeableplaceshield < 100) {
+			if (placeholdershield < 100) {
 				DrawQuadFilled(ssss1, ssss2, ssss3m, ssss4m, shieldCracked);
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(ssss1, ssss2, ssss3, ssss4, shieldCol);
 		}
-		else if (changeableplaceshield <= 125) {
+		else if (placeholdershield <= 125) {
 			DrawQuadFilled(s1, s2, s3, s4, shieldCol);
 			DrawQuadFilled(ss1, ss2, ss3, ss4, shieldCol);
 			DrawQuadFilled(sss1, sss2, sss3, sss4, shieldCol);
 			DrawQuadFilled(ssss1, ssss2, ssss3, ssss4, shieldCol);
-			if (changeableplaceshield < 125) {
+			if (placeholdershield < 125) {
 				DrawQuadFilled(sssss1, sssss2, sssss3m, sssss4m, shieldCracked);
 			}
-			if (changeableplaceshield != 0)
+			if (placeholdershield != 0)
 				DrawQuadFilled(sssss1, sssss2, sssss3, sssss4, shieldCol);
 		}
 	}

apex_guest/Client/Client/overlay.h

@@ -24,39 +24,42 @@
 #define WHITE ImColor(255, 255, 255)
 #define PURPLE ImColor(255, 0 , 255)
 
-typedef struct changeableplacevisuals
+typedef struct placeholdervisuals
 {
-	bool changeableplacebox = true;
+	bool placeholderbox = true;
-	bool changeableplaceline = true;
+	bool placeholderline = true;
-	bool changeableplacedistance = true;
+	bool placeholderdistance = true;
-	bool changeableplacehealthbar = true;
+	bool placeholderhealthbar = true;
-	bool changeableplaceshieldbar = true;
+	bool placeholdershieldbar = true;
-	bool changeableplacename = true;
+	bool placeholdername = true;
-	bool changeableplacerenderxp = true;
+	bool placeholderrenderxp = true;
-}changeableplacevisuals;
+}placeholdervisuals;
 
 
 class Overlay
 {
 public:
-	void Startchangeableplace();
+	void Startplaceholder();
-	DWORD CreatechangeableplaceOverlay();
+	DWORD CreateplaceholderOverlay();
-	void Clearchangeableplace();
+	void Clearplaceholder();
-	int getchangeableplaceWidth();
+	int getplaceholderWidth();
-	int getchangeableplaceHeight();
+	int getplaceholderHeight();
-	void RenderchangeableplaceInfo();
+	void RenderplaceholderInfo();
-	void RenderchangeableplaceMenu();
+	void RenderplaceholderMenu();
-	void RenderchangeableplaceEsp();
+	void RenderplaceholderEsp();
-	void ClickchangeableplaceThrough(bool v);
+	void RenderplaceholderSpectator();
-	void DrawchangeableplaceLine(ImVec2 a, ImVec2 b, ImColor color, float width);
+	void ClickplaceholderThrough(bool v);
-	void DrawchangeableplaceBox(ImColor color, float x, float y, float w, float h);
+	void DrawplaceholderLine(ImVec2 a, ImVec2 b, ImColor color, float width);
-	void changeableplaceText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4 * cpu_fine_clip_rect);
+	void DrawplaceholderBox(ImColor color, float x, float y, float w, float h);
-	void RectchangeableplaceFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags);
+	void placeholderText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4 * cpu_fine_clip_rect);
-	void ProgresschangeableplaceBar(float x, float y, float w, float h, int value, int v_max, ImColor barColor);
+	void placeholderText(ImVec2 pos, ImColor color, const char* text_begin, const char* text_end, float wrap_width, const ImVec4* cpu_fine_clip_rect,int font);
-	void Stringchangeableplace(ImVec2 pos, ImColor color, const char* text);
+	void RectplaceholderFilled(float x0, float y0, float x1, float y1, ImColor color, float rounding, int rounding_corners_flags);
+	void ProgressplaceholderBar(float x, float y, float w, float h, int value, int v_max, ImColor barColor);
+	void Stringplaceholder(ImVec2 pos, ImColor color, const char* text);
+	void Stringplaceholder(ImVec2 pos, ImColor color, const char* text, int font);
 	//Seer
-	void DrawchangeableplaceHealth(float changeableplacex, float changeableplacey, int changeableplaceshield, int changeableplacemax_shield, int changeableplacearmorType, int changeableplacehealth);
+	void DrawplaceholderHealth(float placeholderx, float placeholdery, int placeholdershield, int placeholdermax_shield, int placeholderarmorType, int placeholderhealth);
 private:
-	bool changeableplacerunning;
+	bool placeholderrunning;
-	HWND overlaychangeableplaceHWND;
+	HWND overlayplaceholderHWND;
 };

apex_guest/Overlay/Overlay/main.cpp

@@ -5,12 +5,12 @@
 
 #define WDA_EXCLUDEFROMCAPTURE 0x00000011
 const MARGINS margins = { -1 ,-1, -1, -1 };
-const wchar_t g_szClassName[] = L"changeableplaceoverlay";
+const wchar_t g_szClassName[] = L"placeholderoverlay";
 
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 {
 	WNDCLASSEX wc;
-	HWND changeableplacehwnd;
+	HWND placeholderhwnd;
 	MSG Msg;
 
 	wc.cbSize = sizeof(WNDCLASSEX);
@@ -28,7 +28,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	RegisterClassEx(&wc);
 
-	changeableplacehwnd = CreateWindowEx(
+	placeholderhwnd = CreateWindowEx(
 		WS_EX_LAYERED | WS_EX_TRANSPARENT,
 		g_szClassName,
 		g_szClassName,
@@ -36,9 +36,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 		0, 0, 1920, 1080,
 		NULL, NULL, hInstance, NULL);
 
-	SetLayeredWindowAttributes(changeableplacehwnd, RGB(0, 0, 0), 175, LWA_ALPHA);
+	SetLayeredWindowAttributes(placeholderhwnd, RGB(0, 0, 0), 175, LWA_ALPHA);
-	SetWindowDisplayAffinity(changeableplacehwnd, WDA_EXCLUDEFROMCAPTURE);
+	SetWindowDisplayAffinity(placeholderhwnd, WDA_EXCLUDEFROMCAPTURE);
-	DwmExtendFrameIntoClientArea(changeableplacehwnd, &margins);
+	DwmExtendFrameIntoClientArea(placeholderhwnd, &margins);
 
 	while (GetMessage(&Msg, NULL, 0, 0) > 0)
 	{