Archive Assets.npk mod + damage häçk + vip skins v2.0 oct 24, 2018 noban

[azuvivo3]

almost 20 game with this mod

TUTORIAL:
*first back up yung dalawang ASSETS.NPK
*first NPK sa ros folder



*yung ikalawa nasa documents ng ros folder




after backup, paste the downloaded asset.npk sa kung saan kayo kumuha ng back up

paste nyo lang yan may specific folder name yung isa which is sa loob ng ros documents at yung isa sa ros folder

FEATURES:
*damege
*fast parachute
*no/highscope
*antenna
*no recoil 0.0
*VIP skins




OPENLOAD:
You do not have permission to view the full content of this post. Log in or register now.

datafilehost:
You do not have permission to view the full content of this post. Log in or register now.


enjoy the skins thank you!!!

 

[PHC - Fred]

working pa ba ?

 

[PHC - Fred]

ayaw naman ma extract eh

 

[azuvivo3]

working pa ba ?

yep

 

[PeachyPie]

yep

bat ayaw ma extract

 

[katzenjammer]

hindi yan maeextract nka bat. files.

 

[PeachyPie]

hindi yan maeextract nka bat. files.

corrupt pati ung file

 

[LoveMeLikeYouDo]

.bat ung laman. ingats

 

[-Joma]

try nga

 

[azuvivo3]

pc/mobile available na po see may thread

 

[johndick12]

dapat mag update po kayo ng anti Banned para hindi na maka banned..kasi karamihan sa cheat ngayon banned agad tulad ng memoryhäçkers banned agad kc hindi nag update ng anti banned kaya permanent na sila banned pwede po ba ako mag add ng file na anti banned d2 para maka donate ako sa file nyo....salamat

 

[johndick12]

mayroon ako ginawang sotfwer na anti banned kong pwede add ko sa file nyo salamat..

 

[Derpio-Erpio]

Hindi naman nakakabanned yung asset,
pero dpende din kung ano ang feature sa asset like Highscope, underwater car, No recoil at iba pa.
kung hahaluin mo siya nang third party software like Memory, Exiled at iba pa,
Doon ka mabanned

 

[ingicheat]

sa sobrang daming alam naging **** nalang

 

[johndick12]

Hindi naman nakakabanned yung asset,
pero dpende din kung ano ang feature sa asset like Highscope, underwater car, No recoil at iba pa.
kung hahaluin mo siya nang third party software like Memory, Exiled at iba pa,
Doon ka mabanned

oo alam ko kc detected yong softwer nila hehe dapat updated yong illusion nila para gumana na ulit telekill hehe

 

[johndick12]

hirap na ngayon maka pasok sa proxy pag nag gagawa ng cheat

 

[johndick12]

CODING THE SERVER

1. // -----------------------------------------------------------------------
2. // <copyright file="Server.cs" company="">
3. // (c) atom0s 2012 - ExampleTcpProxy
4. // </copyright>
5. // -----------------------------------------------------------------------
6. namespace ExampleTcpProxy.Classes
7. {
8. using System;
9. using System.Net;
10. using System.Net.Sockets;
11. using System.Windows.Forms;
12. /// <summary>
13. /// TCP Proxy Server Implementation
14. ///
15. /// </summary>
16. public class Server
17. {
18. /// <summary>
19. /// Local listening server object.
20. /// </summary>
21. private TcpListener m_vServer;
22. /// <summary>
23. /// Local copy of our connected client.
24. /// </summary>
25. private Client m_vClient;
26. /// <summary>
27. /// Default Constructor
28. /// </summary>
29. public Server()
30. {
31. // Setup class defaults..
32. this.LocalAddress = IPAddress.Loopback.ToString();
33. this.LocalPort = 7776;
34. this.RemoteAddress = IPAddress.Loopback.ToString();
35. this.RemotePort = 7777;
36. }
37. /// <summary>
38. /// Starts our listen server to accept incoming connections.
39. /// </summary>
40. /// <returns></returns>
41. public bool Start()
42. {
43. try
44. {
45. // Cleanup any previous objects..
46. this.Stop();
47. // Create the new TcpListener..
48. this.m_vServer = new TcpListener(IPAddress.Parse(this.LocalAddress), this.LocalPort);
49. this.m_vServer.Start();
50. // Setup the async handler when a client connects..
51. this.m_vServer.BeginAcceptTcpClient(new AsyncCallback(OnAcceptTcpClient), this.m_vServer);
52. return true;
53. }
54. catch (Exception ex)
55. {
56. this.Stop();
57. MessageBox.Show("Exception caught inside of Server::Start\r\n" + ex.Message);
58. return false;
59. }
60. }
61. /// <summary>
62. /// Stops the local listening server if it is started.
63. /// </summary>
64. public void Stop()
65. {
66. // Cleanup the client object..
67. if (this.m_vClient != null)
68. this.m_vClient.Stop();
69. this.m_vClient = null;
70. // Cleanup the server object..
71. if (this.m_vServer != null)
72. this.m_vServer.Stop();
73. this.m_vServer = null;
74. }
75. /// <summary>
76. /// Async callback handler that accepts incoming TcpClient connections.
77. /// NOTE:
78. /// It is important that you use the results server object to
79. /// prevent threading issues and object disposed errors!
80. /// </summary>
81. /// <param name="result"></param>
82. private void OnAcceptTcpClient(IAsyncResult result)
83. {
84. // Ensure this connection is complete and valid..
85. if (result.IsCompleted == false || !(result.AsyncState is TcpListener))
86. {
87. this.Stop();
88. return;
89. }
90. // Obtain our server instance. (YOU NEED TO USE IT LIKE THIS DO NOT USE this.m_vServer here!)
91. TcpListener tcpServer = (result.AsyncState as TcpListener);
92. TcpClient tcpClient = null;
93. try
94. {
95. // End the async connection request..
96. tcpClient = tcpServer.EndAcceptTcpClient(result);
97. // Kill the previous client that was connected (if any)..
98. if (this.m_vClient != null)
99. this.m_vClient.Stop();
100. // Prepare the client and start the proxying..
101. this.m_vClient = new Client(tcpClient.Client);
102. this.m_vClient.Start(this.RemoteAddress, this.RemotePort);
103. }
104. catch
105. {
106. System.Diagnostics.Debug.WriteLine("Error while attempting to complete async connection.");
107. }
108. // Begin listening for the next client..
109. tcpServer.BeginAcceptTcpClient(new AsyncCallback(OnAcceptTcpClient), tcpServer);
110. }
111. /// <summary>
112. /// Gets or sets the local address of this listen server.
113. /// </summary>
114. public String LocalAddress
115. {
116. get;
117. set;
118. }
119. /// <summary>
120. /// Gets or sets the local port of this listen server.
121. /// </summary>
122. public Int32 LocalPort
123. {
124. get;
125. set;
126. }
127. /// <summary>
128. /// Gets or sets the remote address to forward the client to.
129. /// </summary>
130. public String RemoteAddress
131. {
132. get;

Coding The Client

1. // -----------------------------------------------------------------------
2. // <copyright file="Server.cs" company="">
3. // (c) atom0s 2012 - ExampleTcpProxy
4. // </copyright>
5. // -----------------------------------------------------------------------
6. namespace ExampleTcpProxy.Classes
7. {
8. using System;
9. using System.Collections.Generic;
10. using System.Net;
11. using System.Net.Sockets;
12. /// <summary>
13. /// TCP Proxy Client Implementation
14. ///
15. /// </summary>
16. public class Client
17. {
18. /// <summary>
19. /// The maximum amount of data to receive in a single packet.
20. /// </summary>
21. private static Int32 MAX_BUFFER_SIZE = 2048;
22. /// <summary>
23. /// Internal client state to prevent multiple stop calls.
24. /// (Helps reduce the number of unneeded exceptions.)
25. /// </summary>
26. private Boolean m_vIsRunning;
27. /// <summary>
28. /// Client variables.
29. /// </summary>
30. private Socket m_vClientSocket;
31. private Byte[] m_vClientBuffer;
32. private List<Byte> m_vClientBacklog;
33. /// <summary>
34. /// Server variables.
35. /// </summary>
36. private Socket m_vServerSocket;
37. private Byte[] m_vServerBuffer;
38. private List<Byte> m_vServerBacklog;
39. /// <summary>
40. /// Default Constructor
41. /// </summary>
42. /// <param name="sockClient"></param>
43. public Client(Socket sockClient)
44. {
45. // Setup class defaults..
46. this.m_vClientSocket = sockClient;
47. this.m_vClientBuffer = new Byte[MAX_BUFFER_SIZE];
48. this.m_vClientBacklog = new List<Byte>();
49. this.m_vServerSocket = null;
50. this.m_vServerBuffer = new Byte[MAX_BUFFER_SIZE];
51. this.m_vServerBacklog = new List<Byte>();
52. }
53. /// <summary>
54. /// Starts our proxy client.
55. /// </summary>
56. /// <param name="remoteTarget"></param>
57. /// <param name="remotePort"></param>
58. /// <returns></returns>
59. public bool Start(String remoteTarget = "127.0.0.1", Int32 remotePort = 7777)
60. {
61. // Stop this client if it was already started before..
62. if (this.m_vIsRunning == true)
63. this.Stop();
64. this.m_vIsRunning = true;
65. // Attempt to parse the given remote target.
66. // This allows an IP address or domain to be given.
67. // Ex:
68. // 127.0.0.1
69. // derp.no-ip.org
70. IPAddress ipAddress = null;
71. try { ipAddress = IPAddress.Parse(remoteTarget); }
72. catch
73. {
74. try { ipAddress = Dns.GetHostEntry(remoteTarget).AddressList[0]; }
75. catch { throw new SocketException((int)SocketError.HostNotFound); }
76. }
77. try
78. {
79. // Connect to the target machine on a new socket..
80. this.m_vServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
81. this.m_vServerSocket.BeginConnect(new IPEndPoint(ipAddress, remotePort),
82. new AsyncCallback((result) =>
83. {
84. // Ensure the connection was valid..
85. if (result == null || result.IsCompleted == false || !(result.AsyncState is Socket))
86. return;
87. // Obtain our server instance. (YOU NEED TO USE IT LIKE THIS DO NOT USE this.m_vServerSocket here!)
88. Socket serverSocket = (result.AsyncState as Socket);
89. // Stop processing if the server has told us to stop..
90. if (this.m_vIsRunning == false || serverSocket == null)
91. return;
92. // Complete the async connection request..
93. serverSocket.EndConnect(result);
94. // Start monitoring for packets..
95. this.m_vClientSocket.ReceiveBufferSize = MAX_BUFFER_SIZE;
96. serverSocket.ReceiveBufferSize = MAX_BUFFER_SIZE;
97. this.Server_BeginReceive();
98. this.Client_BeginReceive();
99. }), this.m_vServerSocket);
100. return true;
101. }
102. catch (ObjectDisposedException ex)
103. {
104. // Process the exception as you wish here..
105. }
106. catch (SocketException ex)
107. {
108. // Process the exception as you wish here..
109. }
110. catch (Exception ex)
111. {
112. // Process the exception as you wish here..
113. }
114. return false;
115. }
116. /// <summary>
117. /// Stops this client object.
118. /// </summary>
119. public void Stop()
120. {
121. if (this.m_vIsRunning == false)
122. return;
123. // Cleanup the client socket..
124. if (this.m_vClientSocket != null)
125. this.m_vClientSocket.Close();
126. this.m_vClientSocket = null;
127. // Cleanup the server socket..
128. if (this.m_vServerSocket != null)
129. this.m_vServerSocket.Close();
130. this.m_vServerSocket = null;
131. this.m_vIsRunning = false;
132. }
133. /// <summary>
134. /// Begins an async event to receive incoming data.
135. /// </summary>
136. private void Client_BeginReceive()
137. {
138. // Prevent invalid call..
139. if (!this.m_vIsRunning)
140. return;
141. try
142. {
143. this.m_vClientSocket.BeginReceive(this.m_vClientBuffer, 0, MAX_BUFFER_SIZE, SocketFlags.None, new AsyncCallback(OnClientReceiveData), this.m_vClientSocket);
144. }
145. catch (SocketException ex) { this.Stop(); }
146. catch (Exception ex) { this.Stop(); }
147. }
148. /// <summary>
149. /// Begins an async event to receive incoming data.
150. /// </summary>
151. private void Server_BeginReceive()
152. {
153. // Prevent invalid call..
154. if (!this.m_vIsRunning)
155. return;
156. try
157. {
158. this.m_vServerSocket.BeginReceive(this.m_vServerBuffer, 0, MAX_BUFFER_SIZE, SocketFlags.None, new AsyncCallback(OnServerReceiveData), this.m_vServerSocket);
159. }
160. catch (SocketException ex) { this.Stop(); }
161. catch (Exception ex) { this.Stop(); }
162. }
163. /// <summary>
164. /// Completes an async event to receive data.
165. /// </summary>
166. /// <param name="result"></param>
167. private void OnClientReceiveData(IAsyncResult result)
168. {
169. // Prevent invalid calls to this function..
170. if (!this.m_vIsRunning || result.IsCompleted == false || !(result.AsyncState is Socket))
171. {
172. this.Stop();
173. return;
174. }
175. Socket client = (result.AsyncState as Socket);
176. // Attempt to end the async call..
177. Int32 nRecvCount = 0;
178. try
179. {
180. nRecvCount = client.EndReceive(result);
181. if (nRecvCount == 0)
182. {
183. this.Stop();
184. return;
185. }
186. }
187. catch { this.Stop(); return; }
188. // Read the current packet..
189. Byte[] btRecvData = new Byte[nRecvCount];
190. Array.Copy(this.m_vClientBuffer, 0, btRecvData, 0, nRecvCount);
191. // Send the packet to the server..
192. this.SendToServer(btRecvData);
193. // Begin listening for next packet..
194. this.Client_BeginReceive();
195. }
196. /// <summary>
197. /// Completes an async event to receive data.
198. /// </summary>
199. /// <param name="result"></param>
200. private void OnServerReceiveData(IAsyncResult result)
201. {
202. // Prevent invalid calls to this function..
203. if (!this.m_vIsRunning || result.IsCompleted == false || !(result.AsyncState is Socket))
204. {
205. this.Stop();
206. return;
207. }
208. Socket server = (result.AsyncState as Socket);
209. // Attempt to end the async call..
210. Int32 nRecvCount = 0;
211. try
212. {
213. nRecvCount = server.EndReceive(result);
214. if (nRecvCount == 0)
215. {
216. this.Stop();
217. return;
218. }
219. }
220. catch { this.Stop(); return; }
221. // Read the current packet..
222. Byte[] btRecvData = new Byte[nRecvCount];
223. Array.Copy(this.m_vServerBuffer, 0, btRecvData, 0, nRecvCount);
224. // Send the packet to the client..
225. this.SendToClient(btRecvData);
226. // Begin listening for next packet..
227. this.Server_BeginReceive();
228. }
229. /// <summary>
230. /// Sends the given packet data to the client socket.
231. /// </summary>
232. /// <param name="btPacket"></param>
233. public void SendToClient(byte[] btPacket)
234. {
235. if (!this.m_vIsRunning)
236. return;
237. try
238. {
239. this.m_vClientSocket.BeginSend(btPacket, 0, btPacket.Length, SocketFlags.None,
240. new AsyncCallback((x) =>
241. {
242. if (x.IsCompleted == false || !(x.AsyncState is Socket))
243. {
244. this.Stop();
245. return;
246. }
247. (x.AsyncState as Socket).EndSend(x);
248. }), this.m_vClientSocket);
249. }
250. catch (Exception ex) { this.Stop(); }
251. }
252. /// <summary>
253. /// Sends the given packet data to the server socket.
254. /// </summary>
255. /// <param name="btPacket"></param>
256. public void SendToServer(byte[] btPacket)
257. {
258. if (!this.m_vIsRunning)
259. return;
260. try
261. {
262. this.m_vServerSocket.BeginSend(btPacket, 0, btPacket.Length, SocketFlags.None,
263. new AsyncCallback((x) =>
264. {
265. if (x.IsCompleted == false || !(x.AsyncState is Socket))
266. {
267. this.Stop();
268. return;
269. }
270. (x.AsyncState as Socket).EndSend(x);
271. }), this.m_vServerSocket);
272. }
273. catch (Exception ex) { this.Stop(); }
274. }
275. /// <summary>
276. /// Gets the base client socket.
277. /// </summary>
278. public Socket ClientSocket
279. {
280. get
281. {
282. if (this.m_vIsRunning && this.m_vClientSocket != null)
283. return this.m_vClientSocket;
284. return null;
285. }
286. }
287. /// <summary>
288. /// Gets the base server socket.
289. /// </summary>
290. public Socket ServerSocket
291. {
292. get
293. {
294. if (this.m_vIsRunning && this.m_vServerSocket != null)
295. return this.m_vServerSocket;
296. return null;
297. }
298. }
299. }
300. }

Using Our Proxy

1. private void Form1_Load(object sender, EventArgs e)
2. {
3. Server server = new Server();
4. server.RemoteAddress = "your.server.here";
5. server.RemotePort = 7777;
6. server.Start();
7. }

Adjusting The Packet Handlers For A Given Protocol

1. /// <summary>
2. /// Completes an async event to receive data.
3. /// </summary>
4. /// <param name="result"></param>
5. private void OnClientReceiveData(IAsyncResult result)
6. {
7. // Prevent invalid calls to this function..
8. if (!this.m_vIsRunning || result.IsCompleted == false || !(result.AsyncState is Socket))
9. {
10. this.Stop();
11. return;
12. }
13. Socket client = (result.AsyncState as Socket);
14. // Attempt to end the async call..
15. Int32 nRecvCount = 0;
16. try
17. {
18. nRecvCount = client.EndReceive(result);
19. if (nRecvCount == 0)
20. {
21. this.Stop();
22. return;
23. }
24. }
25. catch { this.Stop(); return; }
26. // Copy the obtained data into the backlog..
27. Byte[] btRecvData = new Byte[nRecvCount];
28. Array.Copy(this.m_vClientBuffer, 0, btRecvData, 0, nRecvCount);
29. this.m_vClientBacklog.AddRange(btRecvData);
30. // Process all the packets in the backlog..
31. for (; ; )
32. {
33. if (this.m_vClientBacklog.Count < 5)
34. break;
35. Int32 nPacketSize = BitConverter.ToInt32(this.m_vClientBacklog.ToArray(), 0) + 4;
36. if (this.m_vClientBacklog.Count < nPacketSize)
37. break;
38. Byte[] btPacket = new Byte[nPacketSize];
39. Array.Copy(this.m_vClientBacklog.ToArray(), 0, btPacket, 0, nPacketSize);
40. this.m_vClientBacklog.RemoveRange(0, nPacketSize);
41. // Send this packet to the server..
42. this.SendToServer(btPacket);
43. }
44. // Begin listening for next packet..
45. this.Client_BeginReceive();

1. /// <summary>
2. /// Completes an async event to receive data.
3. /// </summary>
4. /// <param name="result"></param>
5. private void OnServerReceiveData(IAsyncResult result)
6. {
7. // Prevent invalid calls to this function..
8. if (!this.m_vIsRunning || result.IsCompleted == false || !(result.AsyncState is Socket))
9. {
10. this.Stop();
11. return;
12. }
13. Socket server = (result.AsyncState as Socket);
14. // Attempt to end the async call..
15. Int32 nRecvCount = 0;
16. try
17. {
18. nRecvCount = server.EndReceive(result);
19. if (nRecvCount == 0)
20. {
21. this.Stop();
22. return;
23. }
24. }
25. catch { this.Stop(); return; }
26. // Copy the obtained data into the backlog..
27. Byte[] btRecvData = new Byte[nRecvCount];
28. Array.Copy(this.m_vServerBuffer, 0, btRecvData, 0, nRecvCount);
29. this.m_vServerBacklog.AddRange(btRecvData);
30. for (; ; )
31. {
32. if (this.m_vServerBacklog.Count < 5)
33. break;
34. Int32 nPacketSize = BitConverter.ToInt32(this.m_vServerBacklog.ToArray(), 0) + 4;
35. if (this.m_vServerBacklog.Count < nPacketSize)
36. break;
37. Byte[] btPacket = new Byte[nPacketSize];
38. Array.Copy(this.m_vServerBacklog.ToArray(), 0, btPacket, 0, nPacketSize);
39. this.m_vServerBacklog.RemoveRange(0, nPacketSize);
40. // Send this packet to the client..
41. this.SendToClient(btPacket);
42. }
43. // Begin listening for next packet..
44. this.Server_BeginReceive();
45. }

Connecting To Our Proxy

 

[johndick12]

ayan kong sino gusto mag aral mag gawa ng cheat turoan kopo kayo hnd po ako madamot....

 

[justinpontino]

idelete ba ung asset npk ung dati? tapos ilalagay ung bago na asset npk?