#include "Mapper.h"
#include <vector>
#include <math.h>
#ifndef M_PI
#define M_PI (3.14159265358979323846264338327950288419716939937510)
#endif
#include "../sdk/helper/Vec3/Vec3.h"
#include "../../INCLUDES/xorstr/xorstr.hpp"
 

jclass getMinecraftClazz() {
	jclass MinecraftClazz = myc.env->FindClass("com/craftrise/client/S");
	return MinecraftClazz;
}

jobject getMinecraft() {
	jfieldID MinecraftField = myc.env->GetStaticFieldID(getMinecraftClazz(), "cj", "Lcom/craftrise/client/S;");
	jobject Minecraft = myc.env->GetStaticObjectField(getMinecraftClazz(), MinecraftField);

	return Minecraft;
}

jobject getThePlayer() {
	jmethodID getPlayerMethod = myc.env->GetMethodID(getMinecraftClazz(), "a", "()Lcom/craftrise/client/fa;");
	jobject player = myc.env->CallObjectMethod(getMinecraft(), getPlayerMethod);

	return player;
}

jobject getTheWorld() {
	jfieldID theWorldField = myc.env->GetFieldID(getMinecraftClazz(), "bu", "Lcom/craftrise/client/cf;");

	jobject theWorld = myc.env->GetObjectField(getMinecraft(), theWorldField);

	return theWorld;
}

void printVec2(const Vec2& vec) {
	std::cout << "Vec2(x: " << vec.x << ", y: " << vec.y << ", z: " << vec.z << ")" << std::endl;
}

std::vector<jobject> getPlayerEntities() {
	std::vector<jobject> resultVector;

	jobject worldObj = getTheWorld();

	jfieldID hField = myc.env->GetFieldID(myc.env->GetObjectClass(worldObj), "H", "Ljava/util/List;");

	if (hField != NULL) {
		jobject listObj = myc.env->GetObjectField(worldObj, hField);

		jmethodID iteratorMethod = myc.env->GetMethodID(myc.env->GetObjectClass(listObj), "iterator", "()Ljava/util/Iterator;");

		if (iteratorMethod != NULL) {
			jobject iteratorObj = myc.env->CallObjectMethod(listObj, iteratorMethod);

			jmethodID hasNextMethod = myc.env->GetMethodID(myc.env->GetObjectClass(iteratorObj), "hasNext", "()Z");

			jmethodID nextMethod = myc.env->GetMethodID(myc.env->GetObjectClass(iteratorObj), "next", "()Ljava/lang/Object;");

			while (myc.env->CallBooleanMethod(iteratorObj, hasNextMethod)) {
				jobject element = myc.env->CallObjectMethod(iteratorObj, nextMethod);

				resultVector.push_back(element);

				myc.env->DeleteLocalRef(element);
			}

			myc.env->DeleteLocalRef(iteratorObj);
		}
		else {
		}

		myc.env->DeleteLocalRef(listObj);
	}
	else {
	}

	myc.env->DeleteLocalRef(worldObj);

	return resultVector;
}

std::vector<jobject> getLoadedEntityList() {
	std::vector<jobject> resultVector;

	jobject worldObj = getTheWorld();

	jfieldID hField = myc.env->GetFieldID(myc.env->GetObjectClass(worldObj), "g", "Ljava/util/List;");

	if (hField != NULL) {
		jobject listObj = myc.env->GetObjectField(worldObj, hField);

		jmethodID iteratorMethod = myc.env->GetMethodID(myc.env->GetObjectClass(listObj), "iterator", "()Ljava/util/Iterator;");

		if (iteratorMethod != NULL) {
			jobject iteratorObj = myc.env->CallObjectMethod(listObj, iteratorMethod);

			jmethodID hasNextMethod = myc.env->GetMethodID(myc.env->GetObjectClass(iteratorObj), "hasNext", "()Z");

			jmethodID nextMethod = myc.env->GetMethodID(myc.env->GetObjectClass(iteratorObj), "next", "()Ljava/lang/Object;");

			while (myc.env->CallBooleanMethod(iteratorObj, hasNextMethod)) {
				jobject element = myc.env->CallObjectMethod(iteratorObj, nextMethod);

				resultVector.push_back(element);

				myc.env->DeleteLocalRef(element);
			}

			myc.env->DeleteLocalRef(iteratorObj);
		}
		else {
		}

		myc.env->DeleteLocalRef(listObj);
	}
	else {
	}

	myc.env->DeleteLocalRef(worldObj);

	return resultVector;
}

jfieldID getMotionXField() {
	jfieldID motionXField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "bh", "Lcom/craftrise/dR;");
	
	return motionXField;
}

jfieldID getMotionYField() {
	jfieldID motionYField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "aT", "Lcom/craftrise/dR;");

	return motionYField;
}

jfieldID getMotionZField() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "bf", "Lcom/craftrise/dR;");

	return motionZField;
}

void setMotionX(double motion) {
	jclass MotionContainerClazz = myc.env->FindClass("com/craftrise/dR");
	jmethodID constructor = myc.env->GetMethodID(MotionContainerClazz, "<init>", "(D)V");
	jobject NewMotionValue = myc.env->NewObject(MotionContainerClazz, constructor, motion);

	return myc.env->SetObjectField(getThePlayer(), getMotionXField(), NewMotionValue);
}

void setMotionY(double motion) {
	jclass MotionContainerClazz = myc.env->FindClass("com/craftrise/dR");
	jmethodID constructor = myc.env->GetMethodID(MotionContainerClazz, "<init>", "(D)V");
	jobject NewMotionValue = myc.env->NewObject(MotionContainerClazz, constructor, motion);

	return myc.env->SetObjectField(getThePlayer(), getMotionYField(), NewMotionValue);
}

void setMotionZ(double motion) {
	jclass MotionContainerClazz = myc.env->FindClass("com/craftrise/dR");
	jmethodID constructor = myc.env->GetMethodID(MotionContainerClazz, "<init>", "(D)V");
	jobject NewMotionValue = myc.env->NewObject(MotionContainerClazz, constructor, motion);

	return myc.env->SetObjectField(getThePlayer(), getMotionZField(), NewMotionValue);
}

double getMotionX() {
	jobject MotionContainerObject = myc.env->GetObjectField(getThePlayer(), getMotionXField());

	double Motion = 0;

	if (MotionContainerObject) {
		jclass MotionContainerClazz = myc.env->FindClass("com/craftrise/dR");
		jmethodID MotionContainerMultiplyMethod = myc.env->GetMethodID(MotionContainerClazz, "d", "(D)D");

		if (MotionContainerMultiplyMethod) {
			jdouble MotionValue = myc.env->CallDoubleMethod(MotionContainerObject, MotionContainerMultiplyMethod, 1.0);

			Motion = MotionValue;
			return Motion;
		}
		else {
			return Motion;

		}
	}
	else {
		return Motion;
	}

	return Motion;
}

double getMotionY() {
	jobject MotionContainerObject = myc.env->GetObjectField(getThePlayer(), getMotionYField());

	double Motion = 0;

	if (MotionContainerObject) {
		jclass MotionContainerClazz = myc.env->FindClass("com/craftrise/dR");
		jmethodID MotionContainerMultiplyMethod = myc.env->GetMethodID(MotionContainerClazz, "d", "(D)D");

		if (MotionContainerMultiplyMethod) {
			jdouble MotionValue = myc.env->CallDoubleMethod(MotionContainerObject, MotionContainerMultiplyMethod, 1.0);
			Motion = MotionValue;
			return Motion;
		}
		else {
			return Motion;

		}
	}
	else {
		return Motion;
	}

	return Motion;
}

double getMotionZ() {
	jobject MotionContainerObject = myc.env->GetObjectField(getThePlayer(), getMotionZField());

	double Motion = 0;

	if (MotionContainerObject) {
		jclass MotionContainerClazz = myc.env->FindClass("com/craftrise/dR");
		jmethodID MotionContainerMultiplyMethod = myc.env->GetMethodID(MotionContainerClazz, "d", "(D)D");

		if (MotionContainerMultiplyMethod) {
			jdouble MotionValue = myc.env->CallDoubleMethod(MotionContainerObject, MotionContainerMultiplyMethod, 1.0);
			Motion = MotionValue;
			return Motion;
		}
		else {
			return Motion;
		}
	}
	else {
		return Motion;
	}

	return Motion;
}

jfieldID getPosXField() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "bE", "D");
	return motionZField;
}

jfieldID getPosYField() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "aY", "D");
	return motionZField;
}

jfieldID getPosZField() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "bH", "D");
	return motionZField;
}

jfieldID getPosXFieldForEntityPlayer() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/mg"), "bE", "D");
	return motionZField;
}

jfieldID getPosYFieldForEntityPlayer() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/mg"), "aY", "D");
	return motionZField;
}

jfieldID getPosZFieldForEntityPlayer() {
	jfieldID motionZField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/mg"), "bH", "D");
	return motionZField;
}

void setPosX(jdouble posx) {
	jdouble posX = posx;

	myc.env->SetDoubleField(getThePlayer(), getPosXField(), posX);
}

void setPosY(jdouble posy) {
	jdouble posX = posy;

	myc.env->SetDoubleField(getThePlayer(), getPosYField(), posX);
}

void setPosZ(jdouble posz) {
	jdouble posX = posz;

	myc.env->SetDoubleField(getThePlayer(), getPosZField(), posX);
}


jdouble getPosX() {
	jdouble Pos = myc.env->GetDoubleField(getThePlayer(), getPosXField());

	return Pos;
}

jdouble getPosY() {
	jdouble Pos = myc.env->GetDoubleField(getThePlayer(), getPosYField());

	return Pos;
}

jdouble getPosZ() {
	jdouble Pos = myc.env->GetDoubleField(getThePlayer(), getPosZField());

	return Pos;
}


Vec2 getPlayerPos() {
	double x = getPosX();
	double y = getPosY();
	double z = getPosZ();

	Vec2 playerPos;
	playerPos.x = x;
	playerPos.y = y;
	playerPos.z = z;

	return playerPos;
}

Vec2 getEntityPos(jobject entity) {
	Vec2 playerPos;

	playerPos.x = myc.env->GetDoubleField(entity, getPosXField());
	playerPos.y = myc.env->GetDoubleField(entity, getPosYField());
	playerPos.z = myc.env->GetDoubleField(entity, getPosZField());

	return playerPos;
}

double getDifferenceBetweenEntities(Vec2 entityOne, Vec2 entityTwo) {
	double xDifference = entityTwo.x - entityOne.x;
	double yDifference = entityTwo.y - entityOne.y;
	double zDifference = entityTwo.z - entityOne.z;

	double plusses = (xDifference * xDifference) + (yDifference * yDifference) + (zDifference * zDifference);

	return sqrt(plusses);
}

jfieldID getPlayerEntitiesField() {
	return myc.env->GetFieldID(myc.env->FindClass(xorstr_("com/craftrise/iE")), xorstr_("H"), xorstr_("Ljava/util/List;"));
}

jobject getAxisAlignedBB() {
	return myc.env->GetObjectClass(myc.env->FindClass(xorstr_("com/craftrise/ah")));
}
#include <vector>

jobject getPlayerEntitiesObject() {
	jobject world = getTheWorld();
	jfieldID playerEntitiesField = getPlayerEntitiesField();

	if (!world || !playerEntitiesField) {
		std::cerr << "Error: Unable to get world or playerEntitiesField." << std::endl;
		return nullptr;
	}

	try {
		return myc.env->GetObjectField(world, playerEntitiesField);
	}
	catch (const std::exception& e) {
		std::cerr << "Exception while getting player entities object: " << e.what() << std::endl;
		return nullptr;
	}
}


std::string getEntityPlayerName(jobject entityPlayer) {
	jclass entityPlayerClass = myc.env->GetObjectClass(entityPlayer);
	jfieldID nameField = myc.env->GetFieldID(entityPlayerClass, "playerName", "Ljava/lang/String;");

	if (!nameField) {
		std::cerr << "Error: playerName field not found in EntityPlayer class." << std::endl;
		return "";
	}

	jstring playerName = (jstring)myc.env->GetObjectField(entityPlayer, nameField);
	const char* playerNameChars = myc.env->GetStringUTFChars(playerName, nullptr);
	std::string playerNameStr(playerNameChars);
	myc.env->ReleaseStringUTFChars(playerName, playerNameChars);

	return playerNameStr;
}
std::vector<std::string> getAllPlayerNames() {
	std::vector<std::string> playerNames;

	jobject playerEntities = getPlayerEntitiesObject();

	if (playerEntities) {
		jclass listClass = myc.env->GetObjectClass(playerEntities);
		jmethodID sizeMethod = myc.env->GetMethodID(listClass, "size", "()I");
		jmethodID getMethod = myc.env->GetMethodID(listClass, "get", "(I)Ljava/lang/Object;");

		try {
			int size = myc.env->CallIntMethod(playerEntities, sizeMethod);

			for (int i = 0; i < size; ++i) {
				jobject playerEntity = myc.env->CallObjectMethod(playerEntities, getMethod, i);

				if (playerEntity) {
					std::string playerName = getEntityPlayerName(playerEntity);
					playerNames.push_back(playerName);
				}
				else {
					std::cerr << "Error: Player entity at index " << i << " is null." << std::endl;
				}
			}
		}
		catch (const std::exception& e) {
			std::cerr << "Exception while processing player entities: " << e.what() << std::endl;
		}
	}
	else {
		std::cerr << "Error: Player entities object is null." << std::endl;
	}

	return playerNames;
}



void printPlayerEntitiesWithPositions() {
	jobject playerEntities = getPlayerEntitiesObject();

	if (playerEntities) {
		jclass listClass = myc.env->GetObjectClass(playerEntities);
		jmethodID sizeMethod = myc.env->GetMethodID(listClass, xorstr_("size"), xorstr_("()I"));
		jmethodID getMethod = myc.env->GetMethodID(listClass, xorstr_("get"), xorstr_("(I)Ljava/lang/Object;"));

		try {
			int size = myc.env->CallIntMethod(playerEntities, sizeMethod);
			std::cout << "Number of player entities: " << size << std::endl;

			for (int i = 0; i < size; ++i) {
				jobject playerEntity = myc.env->CallObjectMethod(playerEntities, getMethod, i);

				if (playerEntity) {
					if (playerEntity != getThePlayer()) {
						Vec2 playerPos = getEntityPos(playerEntity);
						std::cout << "Player Entity " << i + 1 << " Position: ";
						printVec2(playerPos);
					}
				}
				else {
					std::cerr << "Error: Player entity at index " << i << " is null." << std::endl;
				}
			}
		}
		catch (const std::exception& e) {
			std::cerr << "Exception while processing player entities: " << e.what() << std::endl;
		}
	}
	else {
		std::cerr << "Error: Player entities object is null." << std::endl;
	}
}

jstring getCraftriseKey() {
	jclass CrMainClazzA = myc.env->FindClass("cr/launcher/main/a");
	jfieldID CrMainKeyFieldId = myc.env->GetStaticFieldID(CrMainClazzA, "m", "Ljava/lang/String;");
	jstring CrMainKey = static_cast<jstring>(myc.env->GetStaticObjectField(CrMainClazzA, CrMainKeyFieldId));

	return CrMainKey;
}
jobject getAttackAction() {
	jclass enumClass = myc.env->FindClass("com/craftrise/on$a");
	jfieldID ATTACKField = myc.env->GetStaticFieldID(enumClass, "ATTACK", "Lcom/craftrise/on$a;");

	jobject attackEnum = myc.env->GetStaticObjectField(enumClass, ATTACKField);

	return attackEnum;
}

jobject C02PacketUseEntity(jobject entity, jobject action) {
	jclass C02PacketUseEntityClazz = myc.env->FindClass("com/craftrise/on");
	jmethodID constructor = myc.env->GetMethodID(C02PacketUseEntityClazz, "<init>", "(Lcom/craftrise/m9;Lcom/craftrise/on$a;)V");

	jobject result = myc.env->NewObject(C02PacketUseEntityClazz, constructor, entity, action);

	return result;
}

jobject getPlayerController() {
	jfieldID playerControllerField = myc.env->GetFieldID(getMinecraftClazz(), "b", "Lcom/craftrise/client/ez;");

	jobject PlayerController = myc.env->GetObjectField(getMinecraft(), playerControllerField);

	return PlayerController;
}

jclass getPlayerControllerClazz() {
	jclass PlayerControllerClazz = myc.env->FindClass("com/craftrise/client/ez");
	return PlayerControllerClazz;
}

jobject getNetClientHandler() {
	jfieldID netClientHandlerFieldId = myc.env->GetFieldID(getPlayerControllerClazz(), "a", "Lcom/craftrise/client/c9;");

	jobject NetClientHandler = myc.env->GetObjectField(getPlayerController(), netClientHandlerFieldId);

	return NetClientHandler;
}

jclass getNetClientHandlerClazz() {
	jclass NetClientHandlerClazz = myc.env->FindClass("com/craftrise/client/c9");

	return NetClientHandlerClazz;
}

jobject getNetworkManager() {
	jfieldID networkManagerField = myc.env->GetFieldID(getNetClientHandlerClazz(), "i", "Lcr/obfuscates/a;");

	jobject networkManager = myc.env->GetObjectField(getNetClientHandler(), networkManagerField);

	return networkManager;
}

void addToSendQueue(jobject packet) {
	jmethodID addToSendQueueMethodId = myc.env->GetMethodID(getNetClientHandlerClazz(), "a", "(Lcom/craftrise/lv;J)V");

	myc.env->CallObjectMethod(getNetClientHandler(), addToSendQueueMethodId, packet, 0);
}

jmethodID getSwingMethodId() {
	jmethodID swingItem_mid = myc.env->GetMethodID(myc.env->FindClass("com/craftrise/mj"), "G", "(J)V");
	return swingItem_mid;
}

void sendSwingPacket() {
	myc.env->CallVoidMethod(getThePlayer(), getSwingMethodId(), 0);
}

void attackEntity(jobject entity) {
	if (myc.env->IsSameObject(getThePlayer(), entity) == false) {
		jobject C02Attack = C02PacketUseEntity(entity, getAttackAction());
		addToSendQueue(C02Attack);
	}
}
void setRotation2(jobject entity, float pitch, float yaw) {
	myc.env->SetFloatField(entity, myc.env->GetFieldID(myc.env->FindClass(xorstr_("com/craftrise/m9")), xorstr_("N"), xorstr_("F")), pitch);
	myc.env->SetFloatField(entity, myc.env->GetFieldID(myc.env->FindClass(xorstr_("com/craftrise/m9")), xorstr_("bL"), xorstr_("F")), yaw);
}




jfieldID getFallDistanceField() {
	jfieldID fallDistanceField = myc.env->GetFieldID(myc.env->FindClass(xorstr_("com/craftrise/m9")), xorstr_("c"), xorstr_("F"));
	return fallDistanceField;
}

void setFallDistance(jobject entity, float fallDistance) {
	myc.env->SetFloatField(entity, getFallDistanceField(), fallDistance);
}

float getFallDistance(jobject entity) {
	return myc.env->GetFloatField(entity, getFallDistanceField());
}


jfieldID getRotationPitchField() {
	return myc.env->GetFieldID(myc.env->FindClass(xorstr_("com/craftrise/m9")), xorstr_("N"), xorstr_("F"));
}

jfieldID getRotationYawField() {
	return myc.env->GetFieldID(myc.env->FindClass(xorstr_("com/craftrise/m9")), xorstr_("bL"), xorstr_("F"));
}

void setRotation(jobject entity, float pitch, float yaw) {
	myc.env->SetFloatField(entity, getRotationPitchField(), pitch);
	myc.env->SetFloatField(entity, getRotationYawField(), yaw);
}

std::pair<float, float> getRotation(jobject entity) {
	float pitch = myc.env->GetFloatField(entity, getRotationPitchField());
	float yaw = myc.env->GetFloatField(entity, getRotationYawField());

	return std::make_pair(pitch, yaw);
}

void setYaw(jobject entity, float yaw) {
	myc.env->SetFloatField(entity, getRotationYawField(), yaw);
}


float getDistance(Vec2 pos1, Vec2 pos2) {
	float dx = pos2.x - pos1.x;
	float dy = pos2.y - pos1.y;
	float dz = pos2.z - pos1.z;

	return std::sqrt(dx * dx + dy * dy + dz * dz);
}

jfieldID getHurtResistantTimeField() {
	jfieldID hurtResistantTimeField = myc.env->GetFieldID(myc.env->FindClass("com/craftrise/m9"), "bK", "I");
	return hurtResistantTimeField;
}

int getHurtResistantTime(jobject entity) {
	return myc.env->GetIntField(entity, getHurtResistantTimeField());
}


jobject GetPlayer(JNIEnv* env) {
	jobject Playerobj = nullptr;
	jclass World2 = env->FindClass("com/craftrise/iE");
	jclass entity = env->FindClass("com/craftrise/m9");
	jfieldID EntityList = env->GetFieldID(World2, "g", "Ljava/util/List;");
	jobject listobject = env->GetObjectField(getTheWorld(), EntityList);

	if (listobject != NULL) {

		jclass ArrayListClass = env->FindClass("java/util/ArrayList");
		jboolean isArrayList = env->IsInstanceOf(listobject, ArrayListClass);

		if (isArrayList) {

			jmethodID toArrayMethod = env->GetMethodID(ArrayListClass, "toArray", "()[Ljava/lang/Object;");
			jobjectArray objArray = (jobjectArray)env->CallObjectMethod(listobject, toArrayMethod);
			jmethodID GetDistanceToEntity = env->GetMethodID(entity, "a", "(Lcom/craftrise/m9;)F");

			for (jsize i = 0; i < 2; i++) {
				jobject element = env->GetObjectArrayElement(objArray, i);
				if (!element)continue;
				if (env->IsSameObject(getThePlayer(), element)) continue;
				jfloat Distance = env->CallFloatMethod(getThePlayer(), GetDistanceToEntity, element);
				if (Distance <= 5.0) {
					Playerobj = element;
				}
			}
		}
	}

	return Playerobj;
}


float getPlayerYaw() {
	return myc.env->GetFloatField(getThePlayer(), getRotationYawField());
}

float getPlayerPitch() {
	return myc.env->GetFloatField(getThePlayer(), getRotationPitchField());
}


void aimAtTarget(jobject target, double maxFov) {
	float playerYaw = getPlayerYaw();
	float playerPitch = getPlayerPitch();

	Vec2 playerPos = getPlayerPos();
	Vec2 targetPos = getEntityPos(target);

	double deltaYaw = std::abs(std::atan2(targetPos.z - playerPos.z, targetPos.x - playerPos.x) * 180.0 / M_PI - 90.0 - playerYaw);
	double deltaPitch = std::abs(-std::atan2(targetPos.y - playerPos.y, std::sqrt((targetPos.x - playerPos.x) * (targetPos.x - playerPos.x) + (targetPos.z - playerPos.z) * (targetPos.z - playerPos.z))) * 180.0 / M_PI - playerPitch);

	if (deltaYaw <= maxFov && deltaPitch <= maxFov) {
		double yaw = std::atan2(targetPos.z - playerPos.z, targetPos.x - playerPos.x) * 180.0 / M_PI - 90.0;
		double pitch = -std::atan2(targetPos.y - playerPos.y, std::sqrt((targetPos.x - playerPos.x) * (targetPos.x - playerPos.x) + (targetPos.z - playerPos.z) * (targetPos.z - playerPos.z))) * 180.0 / M_PI;

		setRotation2(getThePlayer(), static_cast<float>(pitch), static_cast<float>(yaw));
	}
}

bool onGround() {
	jfieldID onGroundField = myc.env->GetFieldID(myc.env->GetObjectClass(getThePlayer()), "s", "Z");

	if (onGroundField != NULL) {
		jboolean isOnGround = myc.env->GetBooleanField(getThePlayer(), onGroundField);
		return (bool)isOnGround;
	}
	else {
		std::cerr << "Error: onGround field not found." << std::endl;
		return false;
	}
}
float GetDistanceToEntity(jobject entity1, jobject entity2) {
	jmethodID getDistanceMethod = myc.env->GetMethodID(myc.env->GetObjectClass(getThePlayer()), "a", "(Lcom/craftrise/m9;)F");
	return myc.env->CallFloatMethod(entity1, getDistanceMethod, entity2);
}

// ticksExisted değerini alma
int getTicksExisted(jobject entity) {
	jclass entityClass = myc.env->GetObjectClass(entity);
	jfieldID ticksExistedField = myc.env->GetFieldID(entityClass, "Z", "I");
	return myc.env->GetIntField(entity, ticksExistedField);
}


void setTicksExisted(jobject entity, int ticks) {
	jclass entityClass = myc.env->GetObjectClass(entity);
	jfieldID ticksExistedField = myc.env->GetFieldID(entityClass, "Z", "I");
	myc.env->SetIntField(entity, ticksExistedField, ticks);
}

float getNextStepDistance(jobject entity) {
	jclass entityClass = myc.env->GetObjectClass(entity);
	jfieldID nextStepDistanceField = myc.env->GetFieldID(entityClass, "bt", "I");
	return myc.env->GetIntField(entity, nextStepDistanceField);
}

// Setter for nextStepDistance
void setNextStepDistance(jobject entity, int value) {
	jclass entityClass = myc.env->GetObjectClass(entity);
	jfieldID nextStepDistanceField = myc.env->GetFieldID(entityClass, "bt", "I");
	myc.env->SetIntField(entity, nextStepDistanceField, value);
}