Screenshot Thread

[Floppixx]

Update :

[tymezz]

Update :
-snip-

Looks like a good health monitor for when you don't have WoW focused :P

[eLaps]

Looks like a good health monitor for when you don't have WoW focused :P

But not so good for the "coordination"

[Robske]

I don't think you're supposed to read coordinates as integers...

[suicidity]

Floppixx, Firstly coordinates are floats not integers. Secondly, what is that absolute horror of ReadProcessMemory!?

[Floppixx]

Floppixx, Firstly coordinates are floats not integers. Secondly, what is that absolute horror of ReadProcessMemory!?

I know but I can´t read it as float xD My result to read it as float are error´s It´s not a horror. It is easy to understand ( i am a beginner) okay .... it is much work

[-Ryuk-]

[COLOR=#EE82EE][B]Heres a little movie I made today!

Includes StopFall/SlowFall/SuperJump/InstantDrop. All 100% safe(At least ive been using them and not banned!)

[namreeb]

Been playing with Heroes of Newerth

[suicidity]

I know but I can´t read it as float xD My result to read it as float are error´s It´s not a horror. It is easy to understand ( i am a beginner) okay .... it is much work

A snippet from my Memory class..

/// <summary>
/// Reads memory of the Initialized Process
/// </summary>
/// <param name="address">Address to read memory from</param>
/// <param name="size">Size to read</param>
/// <param name="ret">Buffer Array</param>
/// <returns>Status of the Read if successful</returns>
public bool ReadMemory(uint address, int size, ref byte[] ret)
{
	if (!Initialized)
		throw new Exception("Memory not initialized.");

	return ReadProcessMemory(Process.Handle, address, ret, size, 0);
}
/// <summary>
/// Reads memory of the Initialized Process to the specified Type
/// </summary>
/// <typeparam name="type">Type to return</typeparam>
/// <param name="address">Address to read memory from</param>
/// <returns>Bytes read returned as Type</returns>
public type Read<type>(uint address) where type : class
{
	// Make sure we're not trying to handle a string
	if (typeof(type) == typeof(string))
		throw new Exception("Cannot read type string, use an Ascii or Unicode handler");

	// Declare our return and HGlobal
	type Return;
	int Size = Marshal.SizeOf(typeof(type));
	IntPtr HGlobal = Marshal.AllocHGlobal(Size);

	// Copy our bytes and free our HGlobal
	Marshal.Copy(ReadMemory(address, Size), 0, HGlobal, Size);
	Return = Marshal.PtrToStructure(HGlobal, typeof(type)) as type;
	Marshal.FreeHGlobal(HGlobal);

	return Return;
}

ReadMemory is just my function to make sure my Memory class is initialized and calls RPM, Read can be called as..

Memory.Read<float>(0xDEADBEEF);

Alternatively you could define it so it doesn't return, but instead sets an out type. Something like..

public void Read<type>(uint address, out type output) where type : class
{
}

...

float ReadFloat;
Memory.Read<float>(0xDEADBEEF, out ReadFloat);

[MaiN]

A snippet from my Memory class..

/// <summary>
/// Reads memory of the Initialized Process
/// </summary>
/// <param name="address">Address to read memory from</param>
/// <param name="size">Size to read</param>
/// <param name="ret">Buffer Array</param>
/// <returns>Status of the Read if successful</returns>
public bool ReadMemory(uint address, int size, ref byte[] ret)
{
    if (!Initialized)
        throw new Exception("Memory not initialized.");

    return ReadProcessMemory(Process.Handle, address, ret, size, 0);
}
/// <summary>
/// Reads memory of the Initialized Process to the specified Type
/// </summary>
/// <typeparam name="type">Type to return</typeparam>
/// <param name="address">Address to read memory from</param>
/// <returns>Bytes read returned as Type</returns>
public type Read<type>(uint address) where type : class
{
    // Make sure we're not trying to handle a string
    if (typeof(type) == typeof(string))
        throw new Exception("Cannot read type string, use an Ascii or Unicode handler");

    // Declare our return and HGlobal
    type Return;
    int Size = Marshal.SizeOf(typeof(type));
    IntPtr HGlobal = Marshal.AllocHGlobal(Size);

    // Copy our bytes and free our HGlobal
    Marshal.Copy(ReadMemory(address, Size), 0, HGlobal, Size);
    Return = Marshal.PtrToStructure(HGlobal, typeof(type)) as type;
    Marshal.FreeHGlobal(HGlobal);

    return Return;
}

You're the kind of person that would code such epic fail! :P

public T Read<T>() where T : struct
{
    Type t = typeof(T);
    int size = Marshal.SizeOf(t);
    byte[] bytes = ReadBytes(size);

    fixed (byte* ptr = bytes)
    {
        return (T)Marshal.PtrToStructure(new IntPtr(ptr), t);
    }
}

This is much faster than allocating new memory, copying the data and freeing the memory again!
EDIT: And just in case you're confused, this is from a stream class.

[suicidity]

One difference, My code is meant to be used in a non-unsafe context. One way to accomplish being non-unsafe is to Allocate memory and free it up when done.

My code is not epic fail, it's restricted by some C# limitations (Talking limitations if I want to stay non-unsafe).

[Cypher]

[MaiN]

One difference, My code is meant to be used in a non-unsafe context. One way to accomplish being non-unsafe is to Allocate memory and free it up when done.

My code is not epic fail, it's restricted by some C# limitations (Talking limitations if I want to stay non-unsafe).

But why do you have to use it in a non-unsafe context? Why do you not just enable unsafe support?

[suicidity]

Just because I felt like having a non-unsafe library of functions. It just so happened that it's the project I pulled up to post some code from.

[MaiN]

Just because I felt like having a non-unsafe library of functions. It just so happened that it's the project I pulled up to post some code from.

I see, like my project where I totally avoid using 'int' and 'uint' datatypes for no reason at all.