EMO Style ForumPro - Hos Geldiniz
Giriş yap

Şifremi unuttum

Istatistikler
Toplam 202 kayıtlı kullanıcımız var
Son kaydolan kullanıcımız: AnthonyFurey3

Kullanıcılarımız toplam 1186 mesaj attılar bunda 862 konu
Tarıyıcı
 Kapı
 Indeks
 Üye Listesi
 Profil
 SSS
 Arama
Arama
 
 

Sonuç :
 


Rechercher çıkıntı araştırma

RSS akısı


Yahoo! 
MSN 
AOL 
Netvibes 
Bloglines 


Kimler hatta?
Toplam 2 kullanıcı online :: 0 Kayıtlı, 0 Gizli ve 2 Misafir

Yok

[ Bütün listeye bak ]


Sitede bugüne kadar en çok 92 kişi Paz Ağus. 28, 2016 6:58 am tarihinde online oldu.
En son konular
» İnternetten Para Kazandıran Oyun ! Ödeme Alt Limiti Yok ! DEV KONU
Cuma Ağus. 29, 2014 8:33 am tarafından Hello EMO

» goldenchase.net maden yaparak para kazanma
Cuma Ağus. 29, 2014 8:18 am tarafından Hello EMO

» etichal hacker görsel egitim seti
Çarş. Ağus. 06, 2014 4:57 am tarafından Hello EMO

» KO TBL Source C#
Ptsi Ara. 09, 2013 6:36 am tarafından Hello EMO

» x86 Registers
C.tesi Ağus. 24, 2013 5:02 am tarafından Hello EMO

» [Tutorial] Pegando Address, Pointers de WYD
Çarş. Tem. 10, 2013 7:25 am tarafından Hello EMO

» [Tutorial] Pegando Address, Pointers de CS Metodo²
Çarş. Tem. 10, 2013 7:23 am tarafından Hello EMO

» [Tutorial] Aprendendo basico deASM OLLYDBG
Çarş. Tem. 10, 2013 7:22 am tarafından Hello EMO

» Basic C# DLL injector
Ptsi Tem. 08, 2013 7:48 am tarafından Hello EMO

Reklam

[Tutorial] Create an in-game console/D3D Textbox

Önceki başlık Sonraki başlık Aşağa gitmek

[Tutorial] Create an in-game console/D3D Textbox

Mesaj tarafından Hello EMO Bir C.tesi Ara. 11, 2010 3:58 am

[quote name='0rbit' timestamp='1288643776' post='31897']
-=[ INTRO ]=-
(Please do not post this tutorial on ANY other website. You may link to it, but not post it elsewhere. If I wish to post it elsewhere, I and only I will.)

Hey everyone. This is a tutorial I made while WOGH was down. Now that it's back, why not post it here? Wink
This is my first DirectX/C++ tutorial so go easy on me

By the way, I know there are code tags on this forum, however they automatically colour the text of the code (which is nice).
I need certain parts to be red and certain to..not, so to retain the red text, I have put the code in spoiler tags.
For the sake of consistency, I've put all code in spoiler tags, as opposed to just the red.
(Sorry, I know it loses the indentation, but we can't win 'em all Razz I'm sure if you actually learn from this you can indent your own code to your liking Wink)

Before we start I’d like to get the greetz in:

  • AlexAk92
  • SEGnosis
  • Kiwidog (First DirectX-Hooking source I could actually understand)
And since there is a portion from the QTS, thanks to:

  • bitterbanana - No known site
  • Drunken Cheetah - No known site
  • fatboy88 - No known site
  • Geek4Ever - No known site
  • learn_more - [url="http://www.uc-forum.com/"]www.uc-forum.com[/url]
  • Novocaine - [url="http://ilsken.net/blog/?page_id=64"]http://ilsken.net/blog/?page_id=64[/url]
  • Philly0494 - No known site
  • Roverturbo - [url="http://www.uc-forum.com/"]www.uc-forum.com[/url]
  • SilentKarma - [url="http://www.halocoders.com/"]www.halocoders.com[/url] - offline
  • Strife - [url="http://www.uc-forum.com/"]www.uc-forum.com[/url]
  • Wieter20 - No known site

This tutorial assumes you already know the basics of C++ and DirectX, so I won’t cover these (hooking, drawing, etc). It’s written in a “step-by-step” form, which will hopefully be easier to learn from – though it will be long.

This is what the finished product will (hopefully) look like for you:


Some things are optional – they are geared towards coding an ingame console for Modern Warfare 2. They can be easily adapted for other games, or completely ignored if all you want is a textbox. I will colour these items in red to make them stand out, and be easier to skip if you don’t need/want them.

Anyway, let’s get this started.

-=[ TUTORIAL ]=-
Firstly you’ll need to think logically about what needs to be done for a textbox. What will we need to do to create one? Here I’ve taken a screenshot of one and I’ll explain each thing we need:


Okay! So there are 3 main things that need to be done – the background, the text, and the caret. I’ll explain them in the order they should be done.

  • Background
[indent] The background will be easy – we will simply draw a rectangle, and if you like you can also give it a border. We do this first as everything else will be drawn on top of it.
[/indent]

  • Text
[indent]What is text really? The text is a variable just like any other – we’ll have to store it as such. Nothing overly complicated, just a string variable. Then we simply draw the text over the background. Easy!
[/indent]

  • Caret
[indent] The caret is a simple enough concept, but not as simple to implement fully. A caret basically shows where we will be inserting or removing text from. In this tutorial we’ll use a fixed-width font (Courier), which will make coding our caret MUCH easier. We’ll need 3 variables for this – an integer storing the caret’s position, an integer for a tick count for the caret, and a Boolean whether to show it or not (I’ll explain these later).

[/indent]So in a textbox we have 3 main things to worry about – the background, the text, and the caret.

Well now that we have an idea what’s going to be done, let’s get started coding! I created this as a class so that anything can call, but you can do it however you like.

Firstly, let’s actually create the class. We’ll create a file called “console.h”, in which we’ll store it:
Spoiler:
#ifndef _CONSOLE_H_
#define _CONSOLE_H_

#include "O_Drawing.h"
#include
#include
using namespace std;

#define ADDR_CONSOLE 0x4393E0 // MW2 v1.2.208

class MW2_Console
{
public:
void Render(int x, int y, int width, LPDIRECT3DDEVICE9 pDevice);
void takeInput(WPARAM wParam);
void Init();
void Send(string cmd);

string command;
vector prevCommands;
int caretPos,caretTick,cmdCount,currCmd;
bool showCaret,handled;
}Console;

#endif
Okay, so what’s actually happening here?

Firstly we include “O_Drawing.h” – this is my drawing class. It contains the functions required for drawing things. Since this tutorial assumes you know the basics of DirectX, you should already have your own. Just replace "O_Drawing.h" with your class.

Next we include “string”, and “vector”. String contains classes and functions that make it easier to work with strings, and vector allows us to store data nicely.

Then we define “ADDR_CONSOLE”. ADDR_CONSOLE is the address in Modern Warfare 2 for the SendCommandToConsole() function. This allows us to easily change the address if required, rather than searching through the source for the function to change the address.

The last thing we do here is define the class and its functions/variables.
The Render function will draw everything – the background, the text, and the caret.

The TakeInput function will take the input from the user and input it into the string. This function should be called from a WM_CHAR message hook. See SEGnosis’ Quick Tip Series at [url="http://www.uc-forum.com/forum/c-and-c/64284-qts-quick-tip-series.html"]http://www.uc-forum....tip-series.html[/url] to see how to hook windows messages.
The Init function will reset all the variables, making them easy to use from the get-go.

The Send() function, will send the specified command to the console. It will also split up commands written in the format “command1;command2;command3”, because these need to be sent separately to work.

Lastly we declare our variables:


  • “command” is our string variable. It contains the string that’s shown in our textbox. We use a string rather than a char * or other variable due to the easy to use functions of the string class, for inserting characters, removing them, and editing them.


  • “prevCommands” is a vector variable. It is a vector of string variables, which can be re-used and called later. When we send a command to the console, we add it to prevCommands, allowing the user to cycle through old commands, rather than having to type them out every time.
Next we declare a bunch of integer variables. I’ll explain each of them individually:


  • caretPos stores the position of our caret. This allows us to accurately draw it, and insert/delete text at the specified position.


  • caretTick is for our make-shift timer. If you have ever used a textbox, you’ll know that the caret is not always visible. It “flashes” on and off. We make our own timer for this, and caretTick is the variable used for this.


  • cmdCount is used to store the count of how many commands have been sent/stored. This makes it easy to reference prevCommands without going too far (ie. Out of the size of it, which would likely cause a crash, or at least output pure gobbledygook to the user).


  • currCmd is used to store what our current index in prevCommands is, so that we can show the next, or previous command sent, rather than always just the first one on the list.
And finally we have our two Booleans:


  • showCaret is linked with caretTick. If showCaret is true then the caret will be drawn. Otherwise it won’t be drawn.


  • Handled is a variable which decides whether input has already been handled by the DLL’s main function. If it has, then our console won’t take the input. (For example I have ESC as a key in the main function to close the console. If handled weren’t set to true, the console would also take that input and make a weird character out of it.)


Okay now that we have a class, we can start building up the functions to get this working!

For the sake of easiness I’ll just do these in the order they appear in the class definition, then at the end show how to use them all.

So, firstly we’ll create our Render function:
Spoiler:
void MW2_Console::Render(int x, int y, int width, LPDIRECT3DDEVICE9 pDevice)
{
// Draw box with border
Draw.FullRectBordered(x,y,width,20,2,D3DCOLOR_ARGB( 155, 000, 000, 000 ),D3DCOLOR_ARGB( 255, 000, 000, 000 ),pDevice);
// Draw command
Draw.Text(x+2,y+2,D3DCOLOR_ARGB( 255, 255, 165, 0 ),">",pDevice);
Draw.Text(x+10,y+2,D3DCOLOR_ARGB( 255, 255, 255, 0 ),command.c_str(),pDevice);

caretTick+=1;
if ( caretTick >= 25)
{
caretTick=0;
showCaret=!showCaret;
}
if(showCaret)
Draw.Text(x+6+(caretPos*Cool,y+2,D3DCOLOR_ARGB( 255, 255, 165, 0 ),"|",pDevice);
}
Okay so let’s explain how this is done. In our EndScene function we have a call to this, if the console is supposed to be visible:
Spoiler:
if(console)
Console.Render(10,10,Viewport.Width-20,pDevice);
So that will render our console at (10,10), with a width that is 10px from the right (so it’ll always be 10px from either side of the screen).

So what actually happens in the render function?

Firstly we draw our background – it’s simply a box with a border. The box is semitransparent, and the border is full black. Just so you know what each of the paramaters are, here’s the prototype of my FullRectBordered function:

Spoiler:
void FullRectBordered(float x, float y, int width, int height, int borderThickness, D3DCOLOR fillColor, D3DCOLOR borderColor, LPDIRECT3DDEVICE9 pDevice);
Next, we draw our text. I draw a > character in Orange in front, just for the sake of sexiness, then draw the text in Yellow. We draw command.c_str() rather than command because my Text function takes a char * rather than a string:

Spoiler:
void Text( int x, int y, D3DCOLOR Color, const char *str, LPDIRECT3DDEVICE9 pDevice);
The last thing we do is the caret. Here we have our makeshift timer:
Spoiler:
caretTick+=1;
if ( caretTick >= 25)
{
caretTick=0;
showCaret=!showCaret;
}
Basically what’s done here is caretTick is increased by 1. If it is greater than or equal to 25, then it is reset to 0, and we toggle showCaret. I’ve found 25 looks fairly good, but you can change it around for longer or shorter intervals if you wish – or even remove it altogether to have an always-visible caret.

Then we have
Spoiler:
if(showCaret)
Draw.Text(x+6+(caretPos*Cool,y+2,D3DCOLOR_ARGB( 255, 255, 165, 0 ),"|",pDevice);
This checks is showCaret is true. If it is, then we draw it. The font we are using for all of this is Courier, at 14pt.

For the “x” position of our caret, we have x+6+(caretPos*Cool. Why?
Well we add 6 to the rendering x position due to the sexy > character which is drawn first, then caretPos*8. We multiply caretPos by 8, because (from my calculations), Courier @ 14pt has characters of width about 8px. So the 2nd character of the string would be 16px in, for example.


Next we take our input:
Spoiler:
void MW2_Console::takeInput(WPARAM wParam)
{
if(handled)
{
handled=false;
return;
}

switch(wParam)
{
case '\b': // backspace
{
if(caretPos>0)
{
command.erase(caretPos-1,1);
caretPos-=1;
}
}
break;

case '\r': // return/enter
{
prevCommands.push_back(command);

Send(command);

command="";
caretPos=0;
cmdCount=prevCommands.size();
currCmd=cmdCount;
}
break;

case '\t': // tab
{
if(cmdCount>0)
{
if(currCmd>0)
{
currCmd-=1;
command=prevCommands.at(currCmd);
caretPos=command.length();
}
else
{
currCmd=cmdCount-1;
command=prevCommands.at(currCmd);
caretPos=command.length();
}
}
}
break;


default:
command.insert(caretPos,1,(char)wParam);
caretPos+=1;
break;
} // switch(wParam)
}
Okay this function is much larger than the last and may seem a bit complicated, but it’s simple enough logic once you go through it step by step.

Firstly we check if input has already been handled (See my ESC example in the variable explanations). If it has, then we return, skipping the rest of the function. Otherwise, we continue.

Our first check in the switch is for the character ‘\b’. This character is what is received after the user presses a backspace, so we remove a character.

Spoiler:
if(caretPos>0)
{
command.erase(caretPos-1,1);
caretPos-=1;
}
This is where our nice string functions start to come into play. Firstly we check that caretPos is greater than 0. If it were 0 there would be nothing to delete before the caret!

If it is greater than 0, there will be a character to remove, so we remove it. We erase the character just before caretPos, with a “length” of 1. This means we only delete 1 character. When you backspace, your caret will obviously move back too, so we put the caretPos back 1.

Next we check for ‘\r’. This character is received when the user presses enter/return. Firstly we save the command to our vector prevCommands, allowing it to be called again in the future if you wish. It then calls the Send() function, which will split it up if required, then send to MW2’s console. Then, we reset our variables to their required values – command is emptied, caretPos is reset to 0, cmdCount is set to the size of prevCommands, as is currCmd.

Our next check is ‘\t’, which is what is sent when the user presses the Tab key.
[
spoiler]if(cmdCount>0)
{
if(currCmd>0)
{
currCmd-=1;
command=prevCommands.at(currCmd);
caretPos=command.length();
}
else
{
currCmd=cmdCount-1;
command=prevCommands.at(currCmd);
caretPos=command.length();
}
}[/
spoiler]Firstly we check the cmdCount is greater than 0, ie. There is a stored command to go to. If there is we check what currCmd is. If it’s greater than 0, then we take 1 from it, showing an older command. If however it’s 0 or less than 0, we reset it back to the newest command that was stored, a kind of “wrap around”.
Don’t forget of course to set the new caretPos!



Finally we have our default case. This is called when the sent character has not already been handled, is not return or tab or any other key that is used by other parts of the hack – ie. It is in fact text input!
Spoiler:
default:
command.insert(caretPos,1,(char)wParam);
caretPos+=1;
break;
We insert the character at the position of the caret, and increase the caret position. Don’t forget to use (char)wParam, as this actually converts it to a character properly.

Now back to something quick and easy – the init function:
Spoiler:
void MW2_Console::Init()
{
command="";
caretPos=0;
cmdCount=0;
currCmd=0;
}
This one is pretty basic – all it does is reset all the required variables.


Next, our Send() function:
Spoiler:
// SendCommandToConsole(1,1,"Command");
void (__cdecl *SendCommandToConsole)(int a1,int a2,const char *cvar)=(void (__cdecl *)(int,int,const char *))ADDR_CONSOLE;
void MW2_Console::Send(string cmd)

{
size_t scPos,len; // scPos = semicolon position. Len = length of cmd.
char tmp[50]; // temporary char array for splitting multiple commands
string cmdToSend; // The command to be sent. Used for splitting multiple commands
int i=0;

do
{
cmd.begin();
scPos=cmd.find(';');
if (scPos!=string::npos) // There was an ;. More than one command.
{
len=cmd.copy(tmp,int(scPos),0); // Copy the first command to tmp
tmp[len]='\0'; // End tmp "string"
cmdToSend=tmp; // Assign tmp as the command to be sent
cmdToSend+='\n';
SendCommandToConsole(1,1,cmdToSend.c_str());
cmd.erase(0,int(scPos)+1); // Erase the just-sent command, and the ;
}
else // There was no ;. Just a single command.
{
cmd+='\n';
SendCommandToConsole(1,1,cmd.c_str());
}

}while(scPos!=string::npos); // Only loop again if a ; was found in the last iteration.
}
Firstly we have the declaration of SendCommandToConsole(). This allows us to send a command to the console (no way!) of MW2.

The source is pretty heavily commented here so it’s fairly obvious what’s going on – basically what it does is search for a “;”. If one doesn’t exist, then send the command. Otherwise, split up the command, and send it piece by piece, until it’s all been sent.

We use a do..while loop so that it’s always called at least once, and if required will wrap back around.


So yeah, there you have it, a working textbox class. But are we done?
No.

If you have actually read through this and didn’t scroll to the end to look for full source then lucky you. [url="http://pastebin.com/fCieLTCm"]Here’s[/url] my command.h Razz


Okay, so now we have a class, and the majority of the functions we need to have a pretty nice textbox going, but what more do we need?
Well there are other things than text which are required to have a good textbox. We must also control, for example, the left/right keys to move the caret, escape to quickly close the console, and the DEL key to delete text IN FRONT of the caret.

I coded this function in my main.cpp, but you could easily implement this directly to the console class. I call this from the WM_KEYDOWN message.
Spoiler:
void KeyPressed(WPARAM wParam)
{
Console.handled=false; // in case it's still true


if(wParam==VK_SHIFT) // allows us to use combinations such as Shift+(key)
shift=true;
if(wParam==VK_F1) // F1 is our show/hide hotkey
{
Console.handled=true;
if(console)
{
Console.Send("con_minicon 0"); // This is my lazy way of getting "feedback" from the console
console=false;
}
else
{
Console.Send("con_minicon 1");
console=true;
}
}

if(console) // If the console is visible, take input.
{
switch(wParam)
{
case VK_LEFT:
if(Console.caretPos>0) Console.caretPos-=1; // Left key. Move the caret back 1 if it's not already at 0.
break;
case VK_RIGHT:
if(Console.caretPos<(int)Console.command.length()) Console.caretPos+=1; // Right key. Move the caret forward one if it's not already at the end of the string.
break;
case VK_DELETE:
if(shift) // Shift+DEL are pressed.
{
Console.command=""; // Empty the string
Console.caretPos=0; // Reset Caret
}
else
{
// Delete the character in front of the caret if it's not at the end of the string
// (Note that the caret stays in the same position)
if(Console.caretPos<(int)Console.command.length()) Console.command.erase(Console.caretPos,1);
}
break;
case VK_ESCAPE:
{
Console.handled=true;
console=false; // Hide the console.
}
break;
} // switch(wParam)
} // if(console)
}
Now this is already pretty commented, so it’s pretty self explanatory.

All that you need to know is that console is a boolean for whether to show the console or not, and shift is a boolean for whether the shift key is up or down.

The shift boolean is nice as it allows WM_KEYDOWN to handle Shift+(KEY). Basically, if shift is down, then shift=true. On WM_KEYUP, if the key going up is Shift, then shift = false:
Spoiler:
case WM_KEYUP:
if(wParam==VK_SHIFT)
shift=false;
break;
The con_minicon lines are just plain laziness on my part – rather than actually reading the feedback from the game’s console, I get the game to display it itsself. Pretty nifty.

Just to give you an idea of my Windows Messages handler, here’s the switch statement:
Spoiler:
switch( lpmsg->message )
{
case WM_KEYUP:
if(wParam==VK_SHIFT)
shift=false;
break;
case WM_KEYDOWN:
KeyPressed(wParam);
if(console) return true;
break;
case WM_CHAR:
if(console)
{
Console.takeInput(wParam);
return true;
}
break;
}
As you can see for WM_KEYDOWN and WM_CHAR, if console is true, then I return true. This tells the game that the messages have already been handled, and as such won’t take them (so you won’t run around randomly ingame, or send stupid text messages while the console is showing).


So my last thing to show you is how to call everything and get your wonderful textbox going.

Wherever you init the rest of your hack, where you init your drawing class, etc. Call Console.Init();.

Call the render function in your EndScene hook, eg:
Spoiler:
if(console)
Console.Render(10,10,Viewport.Width-20,pDevice);
Call KeyPressed() and takeInput() from your Windows Messages hook (see above).

That’s it! You now have a beautiful textbox to use for…whatever you want in your DirectX projects

The concepts covered in this tutorial are most certainly not limited to DirectX – the only things in this that rely on DirectX are the drawing functions! Since you’ll be using your own, you could port this to any graphics library or project EXTREMELY easily.


Obviously this textbox is quite basic. There is a lot you could do to expand it if you liked – here are some ideas to get you thinking:

  • Create a multiline textbox
  • Allow users to have text input in your hack, eg have an aimbot focus on “Player X”
  • For a console, have command suggestions
  • For a console, have feedback
  • Instead of Tab, use the up and down keys to cycle through old messages/commands.

  • ..
  • .

The possibilities are…for a textbox at least, endless!

If you’ve physically read through all of this, then I salute you! Well done


Anyway, I hope you enjoyed the tutorial, found it easy to follow and most importantly learned from it! Please comment if you have any suggestions or spot any mistakes or whatnot.

Cheers,
0rbit
[/quote]


Hello Kitty
vs
eMoStyLe




Hello EMO
EMO Team
EMO Team

Cinsiyet : Erkek
Burçlar : Yay
Yılan
Mesaj Sayısı : 935
Puan : 241393
Rep Puanı : 18
Doğum tarihi : 28/11/89
Kayıt tarihi : 21/07/09
Yaş : 27
Nerden : EMO WorlD
İş/Hobiler : RCE Student / Game Hacking / Learn Beginner C#,C++,Delphi
Lakap : EMO

Kullanıcı profilini gör http://emostyle.myforumpro.com

Sayfa başına dön Aşağa gitmek

Önceki başlık Sonraki başlık Sayfa başına dön

- Similar topics

 
Bu forumun müsaadesi var:
Bu forumdaki mesajlara cevap veremezsiniz