.setHandler((action, entity) => {
		// resurrect corpses
		if (action.isArgumentType(entity, 0, ActionArgument.Corpse)) {
			if (ResurrectCorpse(action.executor, entity)) {
				action.setUpdateRender();
			}

			return;
		}

		const health = entity.getStat<IStatMax>(Stat.Health);
		const stamina = entity.getStat<IStatMax>(Stat.Stamina);
		const hunger = entity.getStat<IStatMax>(Stat.Hunger);
		const thirst = entity.getStat<IStatMax>(Stat.Thirst);

		entity.setStat(health, Entity.is(entity, EntityType.Player) ? entity.getMaxHealth() : health.max);
		if (stamina) entity.setStat(stamina, stamina.max);
		if (hunger) entity.setStat(hunger, hunger.max);
		if (thirst) entity.setStat(thirst, thirst.max);

		entity.setStatus(StatusType.Bleeding, false, StatusEffectChangeReason.Passed);
		entity.setStatus(StatusType.Burned, false, StatusEffectChangeReason.Passed);
		entity.setStatus(StatusType.Poisoned, false, StatusEffectChangeReason.Passed);

		if (Entity.is(entity, EntityType.Player)) {
			entity.state = PlayerState.None;
			entity.updateStatsAndAttributes();
		}

		action.setUpdateRender();
		Actions.DEBUG_TOOLS.updateFog();
		newui.getScreen<GameScreen>(ScreenId.Game)!.onGameTickEnd();
	});

/**
 * Clones an entity to another position. Given a player, clones a matching NPC.
 */
export default function (entity: ICreature | INPC | IPlayer, position: IVector3) {
	let clone: ICreature | INPC | IPlayer;

	if (Entity.is(entity, EntityType.Creature)) {
		clone = creatureManager.spawn(entity.type, position.x, position.y, position.z, true, entity.aberrant)!;

		if (entity.isTamed()) clone.tame(entity.getOwner()!);
		clone.renamed = entity.renamed;
		clone.ai = entity.ai;
		clone.enemy = entity.enemy;
		clone.enemyAttempts = entity.enemyAttempts;
		clone.enemyIsPlayer = entity.enemyIsPlayer;

	} else {
		clone = npcManager.spawn(NPCType.Merchant, position.x, position.y, position.z)!;
		clone.customization = { ...entity.customization };
		clone.renamed = entity.getName().getString();
		CloneInventory(entity, clone);
	}

	clone.direction = new Vector2(entity.direction).raw();
	clone.facingDirection = entity.facingDirection;

	CopyStats(entity, clone);

	if (Entity.is(clone, EntityType.NPC)) {
		clone.ai = AiType.Neutral;
	}
}

	.setHandler((action, entity, position?: IVector3) => {

		position = GetPosition(action.executor, position!, () => translation(DebugToolsTranslation.ActionTeleport)
			.get(entity!.getName()));

		if (!entity || !position) return;

		if (Entity.is(entity, EntityType.Creature)) {
			const tile = game.getTile(entity.x, entity.y, entity.z);
			delete tile.creature;
		}

		if (Entity.is(entity, EntityType.NPC)) {
			const tile = game.getTile(entity.x, entity.y, entity.z);
			delete tile.npc;
		}

		if (Entity.is(entity, EntityType.Player)) {
			entity.setPosition(position);

		} else {
			entity.x = entity.fromX = position.x;
			entity.y = entity.fromY = position.y;
			entity.z = position.z;
		}

		if (Entity.is(entity, EntityType.Creature)) {
			const tile = game.getTile(entity.x, entity.y, entity.z);
			tile.creature = entity;
		}

		if (Entity.is(entity, EntityType.NPC)) {
			const tile = game.getTile(entity.x, entity.y, entity.z);
			tile.npc = entity;
		}

		if (entity === localPlayer) {
			newui.getScreen<GameScreen>(ScreenId.Game)!.movementHandler.walkToTileHandler.reset();
		}

		action.setUpdateView(true);
	});

	.setHandler((action, target, item, quality) => {
		if (target instanceof Player) {
			target.createItemInInventory(item, quality);

			if (Entity.is(target, EntityType.Player)) {
				target.updateTablesAndWeight();
			}

		} else {
			itemManager.create(item, target as IContainer, quality);
			action.setUpdateView();
		}

		if (InspectDialog.INSTANCE) InspectDialog.INSTANCE.update();
	});

	public update(entity: ICreature | INPC | IPlayer) {
		if (this.player === entity) return;

		this.player = Entity.is(entity, EntityType.Player) ? entity : undefined;
		this.toggle(!!this.player);

		if (!this.player) return;

		this.emit("change");

		this.refresh();

		this.until([ComponentEvent.Remove, "change"])
			.bind(this.DEBUG_TOOLS, DebugToolsEvent.PlayerDataChange, this.refresh);
	}

export default function (action: IActionApi<IPlayer>, item: IItem) {
	const container = item!.containedWithin;
	itemManager.remove(item!);

	if (container) {
		if ("data" in container) {
			action.setUpdateView(); // we removed the item from a tile

		} else if ("entityType" in container) {
			const entity = container as IEntity;
			if (Entity.is(entity, EntityType.Player)) {
				entity.updateTablesAndWeight();
			}
		}
	}

	if (InspectDialog.INSTANCE) InspectDialog.INSTANCE.update();
}

	public update(entity: ICreature | IPlayer | INPC) {
		this.npc = Entity.is(entity, EntityType.NPC) ? entity : undefined;
		this.toggle(!!this.npc);
	}

	public update(entity: ICreature | INPC | IPlayer) {
		this.creature = Entity.is(entity, EntityType.Creature) ? entity : undefined;
		this.toggle(!!this.creature);
	}