Trajeto linear em linguagem c

Programação C e C++
#1

Ola, sou Lísias e gostaria de saber se alguém poderia me ajudar nessa tarefa tão difícil para finalizar minha biblioteca.

Eu fiz um motor de jogos, e nele já consegui implementar todas as funções básicas para um uso primário. Fazendo a criação de jogos simples através dela.

Mas estou desenvolvendo um rpg, e resolvi fazer com que os personagens atirem a longa distância. Porém, para que isso aconteça, tenho que fazer com que o objeto a ser atirado sempre corra em linha reta.

Criei uma função que faz com que todos os objetos se movam na tela, mas ela não funciona de uma maneira linear. O que posso modificar nessa função para que ela me proporcione isso?

	static STATUS place_user_move(OBJECT_SET * U, BP32 x, BP32 y) {
	if (U == NULL)return (Off);
	if (U->x_route == x) {
		if (U->y_route > y) {
			U->y_route -= U->y_speed;
			U->where_stop_but(U, NORTH);
			if (U->y_route < y) {
				U->y_route = y;
				U->where_stop(U);
				return (On);
			}
		}
		if (U->y_route < y) {
			U->y_route += U->y_speed;
			U->where_stop_but(U, SOUTH);
			if (U->y_route > y) {
				U->where_stop(U);
				U->y_route = y;
				return (On);
			}
		}
		return (Off);
	}
	if (U->y_route == y) {
		if (U->x_route > x) {
			U->x_route -= U->x_speed;
			U->where_stop_but(U, WEST);
			if (U->x_route < x) {
				U->where_stop(U);
				U->x_route = x;
				return (On);
			}
		}
		if (U->x_route < x) {
			U->x_route += U->x_speed;
			U->where_stop_but(U, EAST);
			if (U->x_route > x) {
				U->where_stop(U);
				U->x_route = x;
				return (On);
			}
		}

		return (Off);
	}
	if (U->x_route > x) {
		U->x_route -= U->x_speed;
		if (U->x_route < x)U->x_route = x;
		if (U->y_route > y) {
			U->y_route -= U->y_speed;
			U->where_stop_but_and(U, NORTH, WEST);
			if (U->y_route < y)U->y_route = y;
		}
		if (U->y_route < y) {
			U->where_stop_but_and(U, SOUTH, WEST);
			U->y_route += U->y_speed;
		}
	}
	if (U->x_route < x) {
		U->x_route += U->x_speed;
		if (U->x_route > x)U->x_route = x;
		if (U->y_route < y) {
			U->y_route += U->y_speed;
			U->where_stop_but_and(U, SOUTH, EAST);
			if (U->y_route > y)U->y_route = y;
		}
		if (U->y_route > y) {
			U->y_route -= U->y_speed;
			U->where_stop_but_and(U, NORTH, EAST);
			if (U->y_route < y)U->y_route = y;
		}
	}
	return (Off);
}

PLACE_CALL STATUS PLACE_TYPE place_user_route(CHAINED * user, BP32 x, BP32 y) {
	if (user && USER_C(user->it)->object && bit_is_on(USER_C(user->it)->object->status, OBJECT_VISIBLE)) {
		OBJECT_SET * U = USER_C(user->it)->object;
		if (U->x_route == x && U->y_route == y) {
			obj_where_stop_all(U);
			return (On);
		}
		//printf("xs %f ys %f\n",object->x_speed,object->y_speed);
		return (place_user_move(U, x, y));
	}
	return (Off);
}

#define sign(x) ((x > 0) ? 1 : ((x < 0) ? -1 : 0) )

PLACE_CALL STATUS PLACE_TYPE place_user_straight(CHAINED * user, BP32 x1, BP32 y1) {
	if (user && USER_C(user->it)->object && bit_is_on(USER_C(user->it)->object->status, OBJECT_VISIBLE)) {
		OBJECT_SET * O = USER_C(user->it)->object;
		BP32 dx, dy;

		dx = x1 - O->x_route;
		dy = y1 - O->y_route;

		static BP32 x = -1, y = -1, p = -1;
		if (x == -1)x = O->x_route;
		if (y == -1)y = O->y_route;
		if (p == -1)p = 2 * dy - dx;

		printf("x %lf y %lf\n", x, y);
		if (x < x1) {
			if (p >= 0) {
				y = y + 1;
				p = p + 2 * dy - 2 * dx;
			} else {
				p = p + 2 * dy;
			}
			x = x + 1;
		} else {
			O->x_route = x;
			O->y_route = y;
			x = -1;
			y = -1;
			p = -1;
			return (On);
		}
		O->x_route = x;
		O->y_route = y;
		x = -1;
		y = -1;
		p = -1;
	}
	return (Off);
}

Esses são os códigos que já fiz, tentei adaptar o ultimo com o Bresenham.
Mas até agora não tive sucesso.
Alguém sabe o que alterar para funcionar?

Aqui está meu motor funcionando e uma animação do meu jogo:

#2

Cara to achando meio complexo demais desnecessariamente teu algoritmo ai, pelo menos a primeira vista é o que me parece.

Eu faria algo semelhante a como você já começou a fazer, usando vetores.

void move_objeto(objeto *obj, vetor *direcao, float vel_instantanea) {
  obj->x += direcao->x * vel_instantanea;
  obj->y += direcao->y * vel_instantanea;
}

Simples assim, e isso cobre todos os casos. Ressalva é que o vetor direcao seja normalizado, ou seja, com magnitude 1.0.

Dai pra calcular colisões você confere após o movimento se sobrepõe alguma outra coisa. Caso a velocidade seja alta e começe a pular sobre outros objeto, você pode fazer essa operação 3 ou 4x por frame de movimento, dividindo a velocidade de acordo, e ver se em cada iteração há colisões.

#3

Eu não consegui entender onde seu exemplo faz com que a trajetória fique linear.
Mesmo no exemplo onde a trajetória é não linear não tem como saber a direção que o objeto está indo, sendo assim, não tem como atualizar as animações das imagens.
A função que muda o flag where é justamente para saber qual posição o sprite deve ficar.
NORTH(de costa), SOUTH(de frente), WEST e EAST(lateral) e os outro na diagonal. Talvez você não tenha mostrado como fazer nesses casos. Mesmo assim obrigado por tentar ajudar

#4

A trajetória é linear a partir de que você se baseia em um vetor de direção.

#5

Vetor não passa de espaço em memória para armazenar mais de uma informação ao mesmo tempo como por exemplo:

int vetorInt[3] = {30,80,5}
Esse “vetor” da função parece mais uma estrutura de um tipo genérico, ou algo assim:
typedef struct vetor{
int x,y;
};

Porém as variáveis object da função que eu utilizo já possuem essas características.
Ainda assim, só consigo ver você substituindo as variáveis:
object->x += object->x_speed;
object->y += object->y_speed;
por:
obj->x += direcao->x * vel_instantanea;
obj->y += direcao->y * vel_instantanea;

De onde vem o tipo vetor, já que não o vi como padrão na linguagem c?
E como essa solução faz com que a trajetória ande em linha?
Desde já, muito obrigado

#6

Você ta misturando as bolas ai. Vetor pelo contexto que dei é o conceito matemático / físico:

Você teria que criar. É simples, em C bastaria algo como:

typedef struct tag_vetor {
    float x, y;
} vetor;

A implementação que te mostrei usa uma versão das fórmulas de calculo de posição em relação ao tempo. A derivada dela, na verdade.

Sobre o nome das variáveis, da na mesma, colega, use os que mais se sentir a vontade.