I will be frank, the code that I see on your pic is pretty weird.
You first draw the tree sprite onto room-sized surface in original size, then resize the surface... I think that means that not only width and height of the tree will be changed, but its X and Y will also change (final tree image may get shifted away from the position you wanted).
Also, I cannot make any sense out of adding propScale to the surface's sizes. If that's really is a scale factor, then it's wrong, so that's probably not the scale factor, but the final tree size?? or not....
By the way, the Baseline calculation is also wrong. You are using original coordinates propY and Game.SpriteHeight to calculate its position, but they are no longer applicable to the final resized image. You should be multiplying these values by the image scale factor (see below).
If you look for the DrawImage article in the manual, you will see that it has optional width and height parameters. They let you resize an image when you are drawing it.
So the resizing code should probably look like this:
int scale ... // assuming you calculated scale somehow
int orig_width = Game.SpriteWidth[prop[i]];
int orig_height = Game.SpriteHeight[prop[i]];
int final_width = orig_width * scale;
int final_height = orig_height * scale;
EnvPropSurface[i] = EnvProp[i].GetDrawingSurface();
EnvPropSurface[i].DrawImage(propX[i], propY[i], prop[i], 0, final_width, final_height);
EnvPropSurface[i].Release();
In such case there is no need to resize large dynamic sprite, and also prop coordinates stay the same.
Alright, that said, if we still stick to your formulas, then to calculate the "block" object position you need to know following:
1) The size and position of Blocking area relative to the original sprite's size. This you have to define yourself, because only you know it, and you draw these sprites.
Let's call these OrigBlockX, OrigBlockY, OrigBlockWidth and OrigBlockHeight.
2) The size and position of Blocking area relative to the resized sprite. For these you need to multiply previous values by the same factor you are using to resize the sprite.
Since you are resizing whole final image, then every coordinate has to be resized as well:
// The scale factor is a relation between final size of large dynamic sprite and its original size
// (normally I'd suggest to use Room.Width and Room.Height here instead of literal numbers)
float ScaleX = IntToFloat(propScale[i] + EnvProp[i].Width) / 1920.0;
float ScaleY = IntToFloat(propScale[i] + EnvProp[i].Height) / 1080.0;
ScaledBlockX = FloatToInt(IntToFloat(OrigBlockX * ScaleX));
ScaledBlockY = FloatToInt(IntToFloat(OrigBlockY * ScaleY));
ScaledBlockWidth = FloatToInt(IntToFloat(OrigBlockWidth * ScaleX));
ScaledBlockHeight = FloatToInt(IntToFloat(OrigBlockHeight * ScaleY));
Again, these coordinates are positions of the blocking area related to the
resized sprite's local coordinates. This is not final.
How to find the position of the blocking rectangle in the room:
// This is where your resized tree is actually positioned in the room
int RealPropX = object[i].X + FloatToInt(IntToFloat(propX[i] * ScaleX));
int RealPropY = object[i].Y + FloatToInt(IntToFloat(propY[i] * ScaleY));
// So, and the blocking object rectangle will be
int BlockRoomX = RealPropX + ScaledBlockX;
int BlockRoomY = RealPropY + ScaledBlockY;
int BlockRoomWidth = ScaledBlockWidth;
int BlockRoomHeight = ScaledBlockHeight;
Realized a bit later, but we may actually skip ScaledBlockWidth/Height part and do following:
float ScaleX = IntToFloat(propScale[i] + EnvProp[i].Width) / 1920.0;
float ScaleY = IntToFloat(propScale[i] + EnvProp[i].Height) / 1080.0;
int BlockRoomX = object[i].X + FloatToInt(IntToFloat((propX[i] + OrigBlockX) * ScaleX));
int BlockRoomY = object[i].Y + FloatToInt(IntToFloat((propY[i] + OrigBlockY) * ScaleY));
int BlockRoomWidth = FloatToInt(IntToFloat(OrigBlockWidth * ScaleX));
int BlockRoomHeight = FloatToInt(IntToFloat(OrigBlockHeight * ScaleY));
That should give identical results.
NOTE: the actual Baseline formula is also:
int RealPropY = object[i].Y + FloatToInt(IntToFloat(propY[i] * ScaleY));
int RealPropHeight = FloatToInt(IntToFloat(Game.SpriteHeight(prop[i]) * ScaleY));
object[i].Baseline = object[i].Y - Room.Height + RealPropY + RealPropHeight);
Now, I have to admit that I did not test all this, but only figured in my head. So I cannot 100% guarantee that's correct. I'd need to have actual test game on my computer to experiment with.
In any case, I strongly advise to clarify the resizing code you are using. Especially since you say yourself that you do not know the reason behind some formula. Because as you progress further this situation will only worsen...
Recent Posts
