A pointer is a value which represents an address. When accessing a pointer, the processor takes the address stored in the pointer and gets the value there. You'd want to have a pointer to, for instance, remove a sprite from a list. You can just pass the sprite's address and have the function handle it like a pointer, setting the value at that address to 0. It's FAR more efficient than telling it to go unset sprite 152 and having a lea instruction calculating an offset into the sprite table and the sprite structure to find the "off" switch for that sprite. Hopefully that clears that up.
The ebp register is used to point to data. Generally, it'll be set to wherever the stack points to (mov ebp,esp) and will have a certain value added or removed from it to move it around according to where it needs to pick data when it reserves memory locally. After the function, the locally-reserved memory is cleared by restoring the old value with a pop instruction.
The addressing mode used here treats ebp as a pointer (that's why there are square brackets around it) but also adds or subtracts from the address stored in it. For instance, if ebp is offset 4856A7 and we add 0x10 to it, we have 4865B7 and since it's a pointer, we check its value.
Indirect addressing occures when you have a structure usually. Your register would hold the base offset of the structure and you'd access the data in it by indirectly referencing it (ie, the 10th byte contains the enemy's health, so, [ebp+0A]) It can also be used to access local memory, which is usually the case when we use ebp. So the things you posted are for locally-stored data.
Games hardly ever hardcode their data in the code directly. So you shouldn't expect to find the size directly stored in the middle of an instruction. In fact, there's no such thing as size - it's very unflexivble and inefficient to have a fixed size. Pixel stored a bounding rect instead. Each rect is 4 sides with 4 bytes each, meaning a frame is 16 bytes. This is pushed into local space in the appropriate function. You will never find 0x10 in relation to Quote's size. You'll have to find the real chunk of code which manages his sprite, and edit that.
Edit: Something I forgot. USUALLY, when you see an operand like [ebp+08] it means it grabs the 32bit value 8 bytes from the start of the stack (so that would be the 2nd parameter, the 1st often being the return address, which you can safely ignore.) When it's subtracted from the register (ie, [ebp-3C]) this is usually stuff in local space. You'll see something like this at the start of most functions...
push ebp ; Back up ebp
mov ebp,esp ; Make ebp point to the top of the stack
sub esp,0x?? ; Allocate ?? bytes above the stack. Bytes which we'll scrap after the function.
...
pop ebp ; Restore ebp. The local data is now lost, as it is useless.
ret ; Return to whatever called the function.
Hopefully that clears up a few things on indirect addressing and the stack (a push instruction will move the stack pointer by 4 bytes after dropping the value on top of the stack, and pop does the opposite, putting the value it just removed from the top of the stack into the operand (such as a register (eax, ecx...) or an offset ([0049ACB9]...), or even an indirect reference ([eax+08]))