Updated changelog, added Materal::GetColorIndex(), updated MOSprite bitmap manipulation functions sorry i can't remember all the the changes but they're good i promise

Author: comradeshook

CHANGELOG.md

@@ -79,6 +79,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - New `Attachable` INI and Lua (R/W) properties `InheritsVelWhenDetached` and `InheritsAngularVelWhenDetached`, which determine how much of these velocities an attachable inherits from its parent when detached. Defaults to 1.
 
+- Added Lua-accessible bitmap manipulation functions to `MOSprite`s:	
+	```
+	GetSpritePixelIndex(int x, int y, int whichFrame) - Returns the color index of the pixel at the given coordinate on the given frame of the sprite ((0, 0) is the upper left corner!)
+
+	SetSpritePixelIndex(int x, int y, int whichFrame, int colorIndex, int ignoreIndex, bool invert) - Sets the color of the pixel at the given coordinate on thegiven frame of the sprite, skipping if the pixel has same color index as given in ignoreIndex. If invert is set to true, only pixels of that color index are set.
+
+	GetAllSpritePixelPositions(const Vector& origin, float angle, bool hflipped, int whichFrame, int ignoreIndex, bool invert, bool includeChildren) - Returns a list of vectors pointing to the absolute positions of all pixels in the given frame of the sprite, rotated to match angle, flipped to match hflipped and positioned around origin, providing a full silhouette of the MOSprite. IgnoreIndex and invert are like above, include children denotes whether or not to include all children of the MOSprite (no effect if not at least an MOSRotating).
+
+	GetAllVisibleSpritePixelPositions(bool includeChildren) - Simplified version of the above, returning a list of absolute positions of the visible pixels of the current frame of the sprite as it is currently drawn.
+
+	SetAllSpritePixelIndexes(int whichFrame, int colorIndex, int ignoreIndex, bool invert) - Sets all pixels in the given frame of the sprite to the given color index, ignoring and inverting as above.
+ 
+	SetAllVisibleSpritePixelIndexes(int colorIndex) - Simplified version of the above, sets all visible pixels of the currently visible sprite to the given color index.
+	```
+- Added `Material` Lua function `GetColorIndex()`, which returns the color index of the calling material.
+
 - New `ACraft` INI and Lua (R/W) property `CanEnterOrbit`, which determines whether a craft can enter orbit (and refund gold appropriately) or not. If false, default out-of-bounds deletion logic applies.
 
 </details>
@@ -149,6 +165,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - Fixed an issue where internal Lua functions OriginalDoFile, OriginalLoadFile, and OriginalRequire were polluting the global namespace. They have now been made inaccessible.
 
+- Fixed `MOSprite:UnRotateOffset()` giving the wrong results on HFLipped sprites.
+
 - Various fixes and improvements to inventory management when dual-wielding or carrying a shield, to stop situations where the actor unexpectedly puts their items away.
 
 - Fixed issue where MOSR `Gib`s, `AEmitter` or `PEmitter` `Emission`s, and MetaMan `Player`s were not correctly accessible from script.

Source/Entities/MOSprite.cpp

@@ -353,51 +353,47 @@ Vector MOSprite::RotateOffset(const Vector& offset) const {
 }
 
 Vector MOSprite::UnRotateOffset(const Vector& offset) const {
-	Vector rotOff(offset.GetXFlipped(m_HFlipped));
+	Vector rotOff(offset);
 	rotOff /= const_cast<Matrix&>(m_Rotation);
-	return rotOff;
+	return rotOff.GetXFlipped(m_HFlipped);
 }
 
-void MOSprite::SetPixelIndex(int x, int y, unsigned int whichFrame, int colorIndex, int ignoreIndex, bool invert) {
-	if (!m_SpriteModified) {
-		std::vector<BITMAP*> spriteList;
-
-		for (BITMAP* sprite: m_aSprite) {
-			BITMAP* spriteCopy = create_bitmap_ex(8, sprite->w, sprite->h);
-			rectfill(spriteCopy, 0, 0, spriteCopy->w - 1, spriteCopy->h - 1, 0);
-			draw_sprite(spriteCopy, sprite, 0, 0);
-			spriteList.push_back(spriteCopy);
-		}
-
-		m_aSprite = spriteList;
-		m_SpriteModified = true;
-	}
-
-	BITMAP* targetSprite = m_aSprite[CLAMP(m_FrameCount - 1, 0, whichFrame)];
-	if (ignoreIndex < 0 || (getpixel(targetSprite, x, y) == ignoreIndex) != invert) {
-		putpixel(targetSprite, x, y, colorIndex);
+int MOSprite::GetSpritePixelIndex(int x, int y, int whichFrame) const {
+	unsigned int clampedFrame = std::max(std::min(whichFrame, static_cast<int>(m_FrameCount) - 1), 0);
+	BITMAP* targetSprite = m_aSprite[clampedFrame];
+	if (is_inside_bitmap(targetSprite, x, y, 0)) {
+		return _getpixel(targetSprite, x, y);
 	}
+	return -1;
 }
 
-std::vector<Vector>* MOSprite::GetAllPixelPositions(const Vector& origin, float angle, bool hflipped, unsigned int whichFrame, int ignoreIndex, bool invert) {
+std::vector<Vector>* MOSprite::GetAllSpritePixelPositions(const Vector& origin, float angle, bool hflipped, int whichFrame, int ignoreIndex, bool invert, bool includeChildren) {
 	std::vector<Vector>* posList = new std::vector<Vector>();
-	CLAMP(m_FrameCount - 1, 0, whichFrame);
-	BITMAP* sprite = m_aSprite[whichFrame];
-	BITMAP* temp = create_bitmap_ex(8, m_SpriteDiameter, m_SpriteDiameter);
+	unsigned int clampedFrame = std::max(std::min(whichFrame, static_cast<int>(m_FrameCount) - 1), 0);
+	int spriteSize = m_SpriteDiameter;
+	if (includeChildren && dynamic_cast<MOSRotating*>(this)) {
+		spriteSize = dynamic_cast<MOSRotating*>(this)->GetDiameter();
+	}
+	BITMAP* sprite = m_aSprite[clampedFrame];
+	BITMAP* temp = create_bitmap_ex(8, spriteSize, spriteSize);
 	rectfill(temp, 0, 0, temp->w - 1, temp->h - 1, 0);
 	Vector tempCentre = Vector(temp->w / 2, temp->h / 2);
 	Vector spriteCentre = Vector(sprite->w / 2, sprite->h / 2);
-	Vector offset = (tempCentre + (m_SpriteOffset + spriteCentre).GetXFlipped(m_HFlipped).RadRotate(m_Rotation.GetRadAngle()) - spriteCentre);
 
-	if (!hflipped) {
-		rotate_scaled_sprite(temp, sprite, offset.m_X, offset.m_Y, ftofix(GetAllegroAngle(-m_Rotation.GetDegAngle())), ftofix(m_Scale));
+	if (includeChildren) {
+		Draw(temp, m_Pos - tempCentre);
 	} else {
-		rotate_scaled_sprite_v_flip(temp, sprite, offset.m_X, offset.m_Y, ftofix(GetAllegroAngle(-m_Rotation.GetDegAngle())) + itofix(128), ftofix(m_Scale));
+		Vector offset = (tempCentre + (m_SpriteOffset + spriteCentre).GetXFlipped(m_HFlipped).RadRotate(m_Rotation.GetRadAngle()) - spriteCentre);
+		if (!hflipped) {
+			rotate_scaled_sprite(temp, sprite, offset.m_X, offset.m_Y, ftofix(GetAllegroAngle(-m_Rotation.GetDegAngle())), ftofix(m_Scale));
+		} else {
+			rotate_scaled_sprite_v_flip(temp, sprite, offset.m_X, offset.m_Y, ftofix(GetAllegroAngle(-m_Rotation.GetDegAngle())) + itofix(128), ftofix(m_Scale));
+		}
 	}
 
 	for (int y = 0; y < temp->h; y++) {
 		for (int x = 0; x < temp->w; x++) {
-			int pixelIndex = getpixel(temp, x, y);
+			int pixelIndex = _getpixel(temp, x, y);
 			if (pixelIndex >= 0 && (pixelIndex != ignoreIndex) != invert) {
 				Vector pixelPos = (Vector(x, y) - tempCentre) + origin;
 				posList->push_back(pixelPos);
@@ -409,6 +405,40 @@ std::vector<Vector>* MOSprite::GetAllPixelPositions(const Vector& origin, float
 	return posList;
 }
 
+bool MOSprite::SetSpritePixelIndex(int x, int y, int whichFrame, int colorIndex, int ignoreIndex, bool invert) {
+	if (!m_SpriteModified) {
+		std::vector<BITMAP*> spriteList;
+
+		for (BITMAP* sprite : m_aSprite) {
+			BITMAP* spriteCopy = create_bitmap_ex(8, sprite->w, sprite->h);
+			rectfill(spriteCopy, 0, 0, spriteCopy->w - 1, spriteCopy->h - 1, 0);
+			draw_sprite(spriteCopy, sprite, 0, 0);
+			spriteList.push_back(spriteCopy);
+		}
+
+		m_aSprite = spriteList;
+		m_SpriteModified = true;
+	}
+
+	unsigned int clampedFrame = std::max(std::min(whichFrame, static_cast<int>(m_FrameCount) - 1), 0);
+	BITMAP* targetSprite = m_aSprite[clampedFrame];
+	if (is_inside_bitmap(targetSprite, x, y, 0) && (ignoreIndex < 0 || (_getpixel(targetSprite, x, y) != ignoreIndex) != invert)) {
+		_putpixel(targetSprite, x, y, colorIndex);
+		return true;
+	}
+	return false;
+}
+
+void MOSprite::SetAllSpritePixelIndexes(int whichFrame, int colorIndex, int ignoreIndex, bool invert) {
+	unsigned int clampedFrame = std::max(std::min(whichFrame, static_cast<int>(m_FrameCount) - 1), 0);
+	BITMAP* targetSprite = m_aSprite[clampedFrame];
+	for (int y = 0; y < targetSprite->h; y++) {
+		for (int x = 0; x < targetSprite->w; x++) {
+			SetSpritePixelIndex(x, y, clampedFrame, colorIndex, ignoreIndex, invert);
+		}
+	}
+}
+
 void MOSprite::Update() {
 	MovableObject::Update();
 

Source/Entities/MOSprite.h

@@ -95,30 +95,42 @@ namespace RTE {
 		/// @param y Y coordinate on the bitmap of the pixel to get.
 		/// @param whichFrame Which frame of the sprite sequence to check.
 		/// @return Color index of the indicated pixel.
-		int GetPixelIndex(int x, int y, unsigned int whichFrame = 0) const { return getpixel(m_aSprite[CLAMP(m_FrameCount - 1, 0, whichFrame)], x, y); }
-
-		/// Sets the color index of the pixel at position (X, Y) in the sprite bitmap
-		/// @param x X coordinate on the bitmap of the pixel to set.
-		/// @param y Y coordinate on the bitmap of the pixel to set.
-		/// @param whichFrame Which frame of the sprite sequence to affect.
-		/// @param colorIndex Desired color index of the indicated pixel.
-		/// @param ignoreIndex Avoid setting pixel colour if it has this color index; set below 0 to disable.
-		/// @param invert Whether or not to invert the ignoreIndex so it ONLY colors that index.
-		void SetPixelIndex(int x, int y, unsigned int whichFrame, int colorIndex, int ignoreIndex, bool invert);
+		int GetSpritePixelIndex(int x, int y, int whichFrame = 0) const;
 
 		/// Returns a list of vectors pointing to all matching pixels of the given frame in the sprite, accounting for flipping, rotation and scale.
-		/// @param origin The position around which the vectors are centered.
+		/// @param origin The absolute position around which the vectors are centered.
 		/// @param angle The angle at which the sprite is rotated.
 		/// @param hflipped Whether or not the sprite is flipped horizontally.
 		/// @param whichFrame Which frame of the sprite sequence to check.
 		/// @param ignoreIndex Which color index to ignore when checking; set below 0 to include everything.
 		/// @param invert Whether or not to invert the above check so it ONLY counts that index.
 		/// @return List of vectors pointing to all visible pixels of the given frame in the sprite.
-		std::vector<Vector>* GetAllPixelPositions(const Vector& origin, float angle, bool hflipped, unsigned int whichFrame, int ignoreIndex, bool invert);
+		std::vector<Vector>* GetAllSpritePixelPositions(const Vector& origin, float angle, bool hflipped, int whichFrame, int ignoreIndex, bool invert, bool includeChildren);
 
 		/// Returns a list of vectors pointing to all visible pixels of the given frame in the sprite, accounting for flipping, rotation and scale.
 		/// @return List of vectors pointing to all visible pixels of the given frame in the sprite.
-		std::vector<Vector>* GetAllVisiblePixelPositions() { return GetAllPixelPositions(m_Pos, m_Rotation.GetRadAngle(), m_HFlipped, m_Frame, 0, false); };
+		std::vector<Vector>* GetAllVisibleSpritePixelPositions(bool includeChildren) { return GetAllSpritePixelPositions(m_Pos, m_Rotation.GetRadAngle(), m_HFlipped, m_Frame, 0, false, includeChildren); };
+
+		/// Sets the color index of the pixel at position (X, Y) in the sprite bitmap
+		/// @param x X coordinate on the bitmap of the pixel to set.
+		/// @param y Y coordinate on the bitmap of the pixel to set.
+		/// @param whichFrame Which frame of the sprite sequence to affect.
+		/// @param colorIndex Desired color index of the indicated pixel.
+		/// @param ignoreIndex Avoid setting pixel colour if it has this color index; set below 0 to disable.
+		/// @param invert Whether or not to invert the ignoreIndex so it ONLY colors that index.
+		/// @return Whether or not the pixel index was successfully set.
+		bool SetSpritePixelIndex(int x, int y, int whichFrame, int colorIndex, int ignoreIndex, bool invert);
+
+		/// Sets the color index of all matching pixels in the sprite bitmap.
+		/// @param whichFrame Which frame of the sprite sequence to affect.
+		/// @param colorIndex Desired color index of the pixels.
+		/// @param ignoreIndex Avoid setting pixel colour if it has this color index; set below 0 to disable.
+		/// @param invert Whether or not to invert the ignoreIndex so it ONLY colors that index.
+		void SetAllSpritePixelIndexes(int whichFrame, int colorIndex, int ignoreIndex, bool invert);
+
+		/// Sets the color index of all visible pixels in the sprite bitmap.
+		/// @param colorIndex Desired color index of the pixels.
+		void SetAllVisibleSpritePixelIndexes(int colorIndex) { SetAllSpritePixelIndexes(m_Frame, colorIndex, 0, false); };
 
 		/// Gets the width of the bitmap of this MOSprite
 		/// @return Sprite width if loaded.

Source/Entities/Material.h

@@ -108,6 +108,10 @@ namespace RTE {
 		/// @return The color of this material.
 		Color GetColor() const { return m_Color; }
 
+		/// Gets the color index of this Material.
+		/// @return The color index of this material.
+		int GetColorIndex() const { return m_Color.GetIndex(); }
+
 		/// Indicates whether or not to use the Material's own color when a pixel of this Material is knocked loose from the terrain.
 		/// @return Whether the Material's color, or the terrain pixel's color should be applied.
 		bool UsesOwnColor() const { return m_UseOwnColor; }

Source/Lua/LuaBindingsEntities.cpp

@@ -774,7 +774,9 @@ LuaBindingRegisterFunctionDefinitionForType(EntityLuaBindings, Material) {
 	    .property("SettleMaterial", &Material::GetSettleMaterial)
 	    .property("SpawnMaterial", &Material::GetSpawnMaterial)
 	    .property("TransformsInto", &Material::GetSpawnMaterial)
-	    .property("IsScrap", &Material::IsScrap);
+	    .property("IsScrap", &Material::IsScrap)
+
+	    .def("GetColorIndex", &Material::GetColorIndex);
 }
 
 LuaBindingRegisterFunctionDefinitionForType(EntityLuaBindings, MetaPlayer) {
@@ -836,10 +838,12 @@ LuaBindingRegisterFunctionDefinitionForType(EntityLuaBindings, MOSprite) {
 	    .def("SetExitWound", &MOSprite::SetExitWound)
 	    .def("GetEntryWoundPresetName", &MOSprite::GetEntryWoundPresetName)
 	    .def("GetExitWoundPresetName", &MOSprite::GetExitWoundPresetName)
-	    .def("GetPixelIndex", &MOSprite::GetPixelIndex)
-	    .def("SetPixelIndex", &MOSprite::SetPixelIndex)
-	    .def("GetAllVisiblePixelPositions", &MOSprite::GetAllVisiblePixelPositions, luabind::return_stl_iterator)
-	    .def("GetAllPixelPositions", &MOSprite::GetAllPixelPositions, luabind::return_stl_iterator)
+	    .def("GetSpritePixelIndex", &MOSprite::GetSpritePixelIndex)
+	    .def("SetSpritePixelIndex", &MOSprite::SetSpritePixelIndex)
+	    .def("GetAllSpritePixelPositions", &MOSprite::GetAllSpritePixelPositions, luabind::return_stl_iterator)
+	    .def("GetAllVisibleSpritePixelPositions", &MOSprite::GetAllVisibleSpritePixelPositions, luabind::return_stl_iterator)
+	    .def("SetAllSpritePixelIndexes", &MOSprite::SetAllSpritePixelIndexes)
+	    .def("SetAllVisibleSpritePixelIndexes", &MOSprite::SetAllVisibleSpritePixelIndexes)
 
 	    .enum_("SpriteAnimMode")[luabind::value("NOANIM", SpriteAnimMode::NOANIM),
 	                             luabind::value("ALWAYSLOOP", SpriteAnimMode::ALWAYSLOOP),