#include "SAMPFUNCS_API.h"
#include "game_api\game_api.h"
#include 
#include 
#include 
class
Timer
{
struct
TimerInfo
{
std
::
chrono
::
steady_clock
::
time_point start
;
std
::
chrono
::
milliseconds duration
;
std
::
function

callback
;
TimerInfo
(
std
::
chrono
::
steady_clock
::
time_point s
,
std
::
chrono
::
milliseconds dur
,
std
::
function

cb
)
:
start
(
s
)
,
duration
(
dur
)
,
callback
(
cb
)
{
}
}
;
public
:
static
Timer
&
Instance
(
)
{
static
Timer inst
;
return
inst
;
}
void
Update
(
)
{
using
namespace
std
::
chrono
;
for
(
auto
it
=
timers
.
begin
(
)
;
it
!=
timers
.
end
(
)
;
)
{
auto
&
timer
=
*
it
;
if
(
steady_clock
::
now
(
)
-
timer
.
start
>
timer
.
duration
)
{
timer
.
callback
(
)
;
timers
.
erase
(
it
++
)
;
}
else
{
++
it
;
}
}
}
void
AddTimer
(
std
::
function

callback
,
std
::
chrono
::
milliseconds duration
)
{
timers
.
emplace_back
(
std
::
chrono
::
steady_clock
::
now
(
)
,
duration
,
callback
)
;
}
std
::
list

timers
;
}
;
SAMPFUNCS
*
SF
=
new
SAMPFUNCS
(
)
;
void
CALLBACK
k1d
(
std
::
string params
)
{
using
namespace
std
::
chrono_literals
;
SF
->
getSAMP
(
)
->
getChat
(
)
->
AddChatMessage
(
0xFF00FF00
,
"text"
)
;
Timer
::
Instance
(
)
.
AddTimer
(
[
]
{
SF
->
getSAMP
(
)
->
getChat
(
)
->
AddChatMessage
(
0xFFFF0000
,
"text2"
)
;
}
,
3
s
)
;
}
void
CALLBACK
mainloop
(
)
{
Timer
::
Instance
(
)
.
Update
(
)
;
static
bool
init
=
false
;
if
(
!
init
)
{
if
(
GAME
==
nullptr
&&
GAME
->
GetSystemState
(
)
!=
eSystemState
::
GS_PLAYING_GAME
&&
!
SF
->
getSAMP
(
)
->
IsInitialized
(
)
)
return
;
SF
->
getSAMP
(
)
->
registerChatCommand
(
"kr"
,
k1d
)
;
init
=
true
;
}
}
BOOL APIENTRY
DllMain
(
HMODULE hModule
,
DWORD dwReasonForCall
,
LPVOID
)
{
if
(
dwReasonForCall
==
DLL_PROCESS_ATTACH
)
{
SF
->
initPlugin
(
mainloop
,
hModule
)
;
}
return
TRUE
;
}

void
write_memory
(
)
{
DWORD old_prot
;
void
*
ptr
=
reinterpret_cast

(
0x6A3F4D
)
;
char
patch
[
]
=
"\xB0\x05\x90\x90\x90\x90"
;
size_t size
=
sizeof
(
patch
)
-
1
;
VirtualProtect
(
ptr
,
size
,
PAGE_READWRITE
,
&
old_prot
)
;
memcpy
(
ptr
,
patch
,
size
)
;
VirtualProtect
(
ptr
,
size
,
old_prot
,
&
old_prot
)
;
}
BOOL APIENTRY
DllMain
(
HMODULE hModule
,
DWORD ul_reason_for_call
,
LPVOID lpReserved
)
{
if
(
ul_reason_for_call
==
DLL_PROCESS_ATTACH
)
{
write_memory
(
)
;
}
return
TRUE
;
}

#include 
#include 
void
WriteBytes
(
const
unsigned
__int32
&
addr
,
const
std
::
vector

&
bytes
)
{
DWORD prot
;
VirtualProtect
(
(
void
*
)
addr
,
bytes
.
size
(
)
,
PAGE_EXECUTE_READWRITE
,
&
prot
)
;
memcpy
(
(
void
*
)
addr
,
bytes
.
data
(
)
,
bytes
.
size
(
)
)
;
VirtualProtect
(
(
void
*
)
addr
,
bytes
.
size
(
)
,
prot
,
&
prot
)
;
}
class
CPlugin
{
public
:
CPlugin
(
)
{
WriteBytes
(
0x6A3F4D
,
{
0xB0
,
0x05
,
0x90
,
0x90
,
0x90
,
0x90
}
)
;
//install patch
}
~
CPlugin
(
)
{
WriteBytes
(
0x6A3F4D
,
{
0x8A
,
0x86
,
0x8A
,
0x04
,
0x00
,
0x00
}
)
;
//remove patch if plugin unloaded
}
}
Plugin
;