Tengo la siguiente situación:
una serie de puntos (creador mediante un ciclo), y quiero que al acercarme a alguno de ellos se active, ilumine, marque, lo que sea.
En el siguiente dibujo muestro lo que quiero aproximadamente:
(http://www.geocities.com/patricio_barros/Dibujo00.jpg)
bueno, y si me acerco a otro punto:
(http://www.geocities.com/patricio_barros/Dibujo01.jpg)
Los puntos, sólo están dibujados, se supone que están dispersos por toda la ventana, así que no sé si deba guardarlos.... quise hacer algo como (suponiendo que el primer punto está en X:100, Y:100):
si mouse.x>=51 y mouse.x<=149 entonces
si mouse.y>=51 y mouse.y<=149 entonces
dibujar_circulo(100,100)
fin si
sin si
...
pero son muchos los puntos... ayuda por favor
¿Estan a una misma distancia todos como en el dibujo?
Si la situación es como la del dibujo, deberías establecer una DISTANCIA predeterminada al momento de crear los puntos, es decir, CONOCER la distancia. A simple vista, los puntos parecen ser equidistantes. Otro paso es FIJAR UN ENTORNO, es decir, a qué distancia debe estar el cursor del mouse del punto para que aparezca el círculo. Luego sería algo así:
// detecto si el cursor del mouse está dentro del entorno admitido (puede ser 0)
if (DISTANCIA_Y - ((mouse.y) % DISTANCIA) <= ENTORNO) && (DISTANCIA_X - ((mouse.x) % DISTANCIA_X) <= ENTORNO)
// si está entonces compenso la diferencia para que el centro del círculo sea justo el punto
drawCircle(mouse.x+(DISTANCIA_X - ((mouse.y) % DISTANCIA_X), mouse.y+(DISTANCIA_Y - ((mouse.y) %
DISTANCIA_Y));
O sea que solo debes conocer la DISTANCIA entre cada punto y, opcional, un entorno, que puede ser 0 en el caso que solo dibujes el círculo si la flecha está sobre el punto.
P/D- No es necesario almacenar nada (ole)
Cita de: "ZüNdFoLGe"Si la situación es como la del dibujo, deberías establecer una DISTANCIA predeterminada al momento de crear los puntos, es decir, CONOCER la distancia. A simple vista, los puntos parecen ser equidistantes. Otro paso es FIJAR UN ENTORNO, es decir, a qué distancia debe estar el cursor del mouse del punto para que aparezca el círculo. Luego sería algo así:
// detecto si el cursor del mouse está dentro del entorno admitido (puede ser 0)
if (DISTANCIA_Y - ((mouse.y) % DISTANCIA) <= ENTORNO) && (DISTANCIA_X - ((mouse.x) % DISTANCIA_X) <= ENTORNO)
// si está entonces compenso la diferencia para que el centro del círculo sea justo el punto
drawCircle(mouse.x+(DISTANCIA_X - ((mouse.y) % DISTANCIA_X), mouse.y+(DISTANCIA_Y - ((mouse.y) %
DISTANCIA_Y));
O sea que solo debes conocer la DISTANCIA entre cada punto y, opcional, un entorno, que puede ser 0 en el caso que solo dibujes el círculo si la flecha está sobre el punto.
P/D- No es necesario almacenar nada (ole)
Si, los puntos están a una distancia fija (ejemplo 20 pixeles) y el entorno al que te refieres, debe ser como la distancia en la que me acerco, no?... si es así, serían unos 5 pixeles....
El símbolo % en C es división, módulo o qué?, ahce mucho que no programo en C y ya se me ha olvidado...
Y gracias por las respuestas...
es el módulo. Los parámetros son, entonces:
DISTANCIA_Y = DISTANCIA_X = 20;
ENTORNO = 5;
Gracias ZüNdFoLGe,
lo hice, corre, pero el único problemilla es que en el if... compara una posición que se encuentra mucho más arriba... osea, como que se le corre el punto hacia arriba y la izquierda, más o menos la misma distancia del entorno... pero cuando dibujo el círculo queda justo en el centro del punto.
------------------------------------------------------------------------------------
(http://www.geocities.com/patricio_barros/Dibujo02.jpg)
(representación del ratón con la posición errónea y dibujando el círculo)
Estoy probando con los valores, pero siguiendo tu ejemplo, es lo más cercano que queda...
Cita de: "pbarros"
El símbolo % en C es división, módulo o qué?, ahce mucho que no programo en C y ya se me ha olvidado...
Hi,
es el modulo. Te devuelve el resto, vamos lo que te sobra... (sorry, no me acuerdo como se llamaba... :rolleyes: :rolleyes: )
Ejemplo:
int a;
int b;
a = 4 % 2 ;
b = 5 % 2;
a vale 0.
b vale 1;
Por cierto, si tienes muchos puntos y quieres buscar el/los mas cercano/s a otro punto lo mas rapido son las estructuras tipo kd-tree. Aunque no tengo ni idea de si sera demasiado complejo para lo que tu quieres, aun asi ahi queda por si te sirve de algo... (ole)
Cita de: "pbarros"lo hice, corre, pero el único problemilla es que en el if... compara una posición que se encuentra mucho más arriba...
El método consiste en buscar coordenadas que sean múltiplos de DISTANCIA, es decir, dados 1000 puntos, esté donde esté, lo único que hago es ver si las coordenadas de la flecha son múltiplos de la distancia, en este caso, significa que estoy sobre un punto (sin saber cual). A la hora de dibujar el círculo, uso las coordenadas de la flecha porque ya se de antemano (se cumple la condicion del if) que está sobre un punto sin importar cual és, al momento de dibujar el círculo el punto será el correcto.
Cita de: "ZüNdFoLGe"lo único que hago es ver si las coordenadas de la flecha son múltiplos de la distancia, en este caso, significa que estoy sobre un punto (sin saber cual). A la hora de dibujar el círculo, uso las coordenadas de la flecha porque ya se de antemano (se cumple la condicion del if) que está sobre un punto sin importar cual és, al momento de dibujar el círculo el punto será el correcto.
Otra vez, gracias ZüNdFoLGe,
pero mira el dibujo que adjunté... éso es lo que pasa... osea, la condición no se está cumpliendo del todo.... porque si me acerco al punto que deseo, desde abajo... me puedo situar hasta en (el punto está en X: 100, Y: 100 por ejemplo) X=X+1 e Y=Y+1, osea justamente bajo el punto un pixel... y no "detecta" que estoy en el rango...
(http://www.geocities.com/patricio_barros/Dibujo03.jpg)
---------------------------------------------------------------------------------------
Dejo el ejemplo ejecutable para que lo veas
Ejemploy el código completo es:
Private Sub Command1_Click()
'Botón Limpiar
'Limpio la ventana y vuelvo a dibujar los puntos
Me.Cls
Call Pinta
End Sub
Private Sub Form_Load()
'Color de fondo Blanco
Me.BackColor = vbWhite
'Para usar las primitivas de dibujo
Me.AutoRedraw = True
Call Pinta
End Sub
Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
If (100 - (X Mod 100) <= 50) And (100 - (Y Mod 100) <= 50) Then
Me.Circle (X + (100 - (X Mod 100)), Y + (100 - (Y Mod 100))), 20, vbRed
End If
End Sub
Private Sub Pinta()
'Dibuja los puntos en la ventana cada 100 pixeles (X e Y)
Dim I As Integer
Dim J As Integer
For I = 0 To Me.ScaleWidth Step 100
For J = 0 To Me.ScaleHeight Step 100
Me.PSet (I, J), vbBlack
Next J
Next I
End Sub
Yo creo seria mucho mas sencillo averiguar a que distancia estan un punto de otro, mas concretos, la posicion de cursor con el punto y comparar dicho valor con uno establecido, como han dicho arriba. Para ello dx_lib32 te proporiciona la funcion MATH_GetDist() de la clase dx_System que calcula la distancia en pixeles de un punto a otro.
Sobre el operador % de C/C++ que he visto mencionado antes en VB su equivalente es Mod:
Resto = A Mod B
Salu2... ;)
// detecto si el cursor del mouse está dentro del entorno admitido (puede ser 0)
if (DISTANCIA_Y - ((mouse.y) % ENTORNO) <= 2*ENTORNO) && (DISTANCIA_X - ((mouse.x) % ENTORNO) <= 2*ENTORNO)
// si está entonces compenso la diferencia para que el centro del círculo sea justo el punto
drawCircle(mouse.x+(DISTANCIA_X - ((mouse.y) % DISTANCIA_X)), mouse.y+(DISTANCIA_Y - ((mouse.y) %
DISTANCIA_Y));
Observa los cambios que he hecho, y aparentemente ahora funciona. Me había olvidado de contemplar el caso "hacia el otro lado" del punto, por ello agregué 2*ENTORNO. Para ver si cae en el entorno del punto uso el entorno mismo para hacer el módulo; recordar que entorno nunca puede ser 0 .
Si no te va a suponer un gran problema de rendimiento, yo calcularía la distancia al punto correctamente, en vez de ver si el puntero esta dentro de un recuadro. Suponiendo que las coordenadas del punto son px y py y que las coordenadas del ratón son mx y my calcularía la distancia de la siguiente forma:
mouse_distance = SQRT( ( px - mx ) * ( px - mx ) + ( py - my ) * ( py - my ) )
Y luego, si mouse_distance es menor de la distancia a la que quieres que se dibuje el círculo, entonces...
IF mouse_distance < distance THEN DibujarCículo ELSE Nada
Puedes optimizar eliminando la raiz cuadrada y comparando los cuadrados de las distancias:
mouse_distance = ( px - mx ) * ( px - mx ) + ( py - my ) * ( py - my )
IF mouse_distance < ( distance * distance ) THEN DibujarCículo ELSE Nada
sync
Si tienes muchos puntos puedes también dividir el espacio en sectores que agrupan puntos, y primero calculas en que espacio estás y después en los puntos del espacio (y como mucho con puntos de espacios adyacentes). Así te ahorras comparar contra muchos puntos.
Un saludo!
Vicente
No he leído todas las respuestas, pero si los puntos están a la misma distancia unos de otros... eh... es un simple mapa de TILES de toda la vida en el que cada punto sería el centro de un tile.
int tilex = ratonx / ANCHO_TILE_X;
int tiley = ratony / ALTO_TILE_Y;
Luego sólo habría que calcular la distancia al centro de ese tile para ver si se sibuja el círculo o no.
Hola a todos,
gracias por todas las respuestas... especialmente a ZüNdFoLGe, que es lo más parecido a la solución que quiero.
A propósito Eduardo, el último código:
Citar// detecto si el cursor del mouse está dentro del entorno admitido (puede ser 0)
if (DISTANCIA_Y - ((mouse.y) % ENTORNO) <= 2*ENTORNO) && (DISTANCIA_X - ((mouse.x) % ENTORNO) <= 2*ENTORNO)
// si está entonces compenso la diferencia para que el centro del círculo sea justo el punto
drawCircle(mouse.x+(DISTANCIA_X - ((mouse.y) % DISTANCIA_X)), mouse.y+(DISTANCIA_Y - ((mouse.y) %
DISTANCIA_Y));
no funcionó... aún cambiando los
(mouse.?) % ENTORNO por
(mouse.?) % DISTANCIA_? como anteriormente lo habías enviado. Sin modificación simplemente no lo hace, lo modifico y hace, lo mismo que te explicaba, sólo que expande el rango mucho más hacia arriba y a la izquierda, osea, si me sitúo por debajo del punto, no lo detecta.
Yo anoche hice una modificación basándome en los resultados del cálculo del módulo que me diste, pero, tiene unas pequeñas fallas...
If (Distancia - (X Mod Distancia) <= Entorno) Or (Distancia - (X Mod Distancia) >= Distancia - Entorno) _
And (Distancia - (Y Mod Distancia) <= Entorno) Or (Distancia - (Y Mod Distancia) >= Distancia - Entorno) Then
Me.Circle (IIf(Distancia - (X Mod Distancia) <= Entorno, X + (Distancia - (X Mod Distancia)), X + (Distancia - (X Mod Distancia)) - Distancia), IIf(Distancia - (Y Mod Distancia) <= Entorno, Y + (Distancia - (Y Mod Distancia)), Y + (Distancia - (Y Mod Distancia)) - Distancia)), Entorno, vbRed
End If
Es mucho más enredado, pero hace el 90% de lo que quiero, si tienes un cálculo más simple... te lo agradecería ;)
synchrnzr, él código que me propones, me sirve, pero tendría q hacer lo que no quería, que es preguntar por cada punto en la ventana, y justamente es lo que no deseaba hacer... de todas formas gracias :D .
Aquí va mi aportación por si te sirve, tenía algo parecido ya hecho, he tenido que apañarlo un poco para que se entienda y lo puedas adaptar.
Primero se haya el número de fila y columna donde está el cursor, que es igual a su posición dividido por la distancia de cada punto.
Pero hay que hacer un par de correcciones al cursor para ajustar el comienzo a la posición del inicio de la matriz de puntos restándole este.
También para que el punto esté en el centro de la celda en lugar de estar en la esquina superior izquierda, sumando la mitad del tamaño de la distancia entre cada punto (creo que es el problema que tenías).
col = ( CursorX - InicioX + DistanciaX/2 ) / DistanciaX;
fil = ( CursorY - InicioY + DistanciaY/2 ) / DistanciaY;
después se obtiene la posición del punto a partir del inicio y de la posición de la fila/columna.
px = InicioX + col * DistanciaX;
py = InicioY + fil * DistanciaY;
si ese punto esta dentro del radio de localización se dibuja o lo que sea
if ( (px-CursorX) * (px-CursorX) + (py-CursorY) * (py-CursorY) < Rango*Rango)
{
Circle( px, py, radio );
}
Este post empieza a rallar y comienza a ser ofensivo :P
Lo mas facil es que trates la pantalla como puntos del tamaño de los puntos que buscas o del rango que quieras, de esta manera lo haces como un mapa de tiles de toda la vida y no tienes que comprobar todos los puntos de pantalla, para saber si se debe de mostrar el circulo o no haces el modulo del tile (lo calculas con la coordenada del raton) contra el numero de tiles que hay de separacion entre ellos, si el modulo te da 0 es que se pinta si te da otro valor no.
(http://img316.imageshack.us/img316/1788/dibujo6vd.jpg)Y lo dicho en mi tutoblog, hecho para una dimension hecho para todas ;)
Ejemplo:
int tilex = mouse.x / tile.width;
int tiley = mouse.y / tile.height;
if( tilex % 4 == 0 && tiley % 4 == 0 )
{
// pintamos circulo
}
Con esto solo ya haces todos los puntos, donde puse 4 pones el numero de puntos invisibles o el rango que veas tu para hacer el efecto que quieras dar y lo mismo para tile.width y tile.height que es el ancho y alto.
Zupervaca, tan simple lo has hecho que te has dejado cosas por resolver.
1. Das por hecho que el origen de la cuadrícula es 0,0
2. El centro de selección no es el punto medio entre un punto y el siguiente (centro de la celda) como lo entiendes tú, si no cada punto (ese es el problema fundamental que creo que tenía).
3. Si la matriz de celdas es menor que la pantalla, cuando se sale el cursor pintas también un círculo fuera o seleccionas puntos que no existen.
4. Y después de hacer todo eso hay que hallar las coordenadas del punto obtenido para dibujar el círculo.
Lo que he puesto antes es más sencillo de lo que parece y no hay que comprobar todos los puntos, échale un vistazo de nuevo, ( pero esta vez sin rallarte ) :P
Bueno, antes de seguir, me gustaría decirles que soy medio novato en esto, y no he programado antes un juego de tiles, sé que se trata de cuadros de tamaño fijo con el que se crean mapas, etc., etc. pero jamás he hecho uno. Así que para los que me han dado solución y se han referido a los tiles... :blink: I'm sorry, pero no entiendo mucho a lo que se refieren.
La verdad es que tengo muy pocos conocimientos en lo que se refiere a juegos, hasta el momento practicamente lo único que he hecho han sido SIA y otros, que no han requerido de gráficos, ni grandes cálculos ni nada de eso, así que les pido paciencia :(
La librería de José ([EX3]), me ha abierto un poco el mundo de la programación al mundo de los video juegos, pero como les mencionaba, estoy recién empezando.
José puede decir con propiedad cuánto lo molestaba cuando recién empecé a entender su librería, tengo su MSN y cada vez que estaba conectado lo invadía con preguntas... y le agradezco su voluntad para conmigo, todos uds. han sido de gran ayuda. Y lo más probable es que llene el foro de preguntas, no creo que sea el único que esté recién empezando y a más de alguien le servirá, aparte de mi.
Y refieriéndome un poco más a lo que quiero hacer... más de alguno habrá jugado o visto DOOM3 (ole), el menú del comienzo, en que aparece una malla de líneas; cuando acercas el ratón al vértice de alguna celda formada por esta malla, se activa la correspondiente linea horizontal y vertical. Sólo que yo no quiero que se dibujen las líneas, sino que se marque el vértice :rolleyes: .
Codigo final:
int tilex = (origen.x + mouse.x) / tile.width;
int tiley = (origen.y + mouse.y) / tile.height;
if( tilex % 4 == 0 && tiley % 4 == 0 )
{
int xcircle = (tilex * tile.width) + (tile.width >> 1);
int ycircle = (tiley * tile.height) + (tile.height >> 1);
circle( xcircle, ycircle, radio );
}
¿Ta mejor asi? tile.width y tile.height no tienen por que ser del tamaño del punto, pueden ser mayor para para que en algunas zonas no se dibuje ningun circulo, ejemplo:
(http://img397.imageshack.us/img397/9067/dibujo6vd9uu.jpg)Los recuadros negros son los tiles o cuadricula invisible y los rojos son los puntos visibles, en la flecha verde se dibuja el ciculo por que su modulo es 0, pero en la flecha gris no ya que su modulo seria 2, como la cuadricula invisible es mayor al tamaño de los puntos la zona donde se indica que se debe de dibujar el circulo es mayor a la zona del punto.
zupervaca,
insisto, no son tiles, no es un mapa de tiles, si lees mi mensaje anterior te darás cuenta de lo que me propongo...
La forma sencilla la que te comente, recorre el array o lista de puntos y realizas la comprobacion que dije:
Si distancia(Cursor, Punto) <= MinDistancia Entonces dibujo tile o lo que sea
Y se podria hacer tambien lo que comento Vicente, puedes dividir en diferentes regiones rectangulares la zona y asignar a cada zona una lista de puntos. Compruebas mediante MATH_PointInRect() de dx_System si la posicion del cursor esta dentro de alguna region que has definido y despues realizar la comprobacion punto a punto de la lista asignada a esa region. De esta forma te ahorrarias tener que recorrer todos los puntos de toda la zona. Es un metodo facil y sencillo en mi opinion.
Salu2...
P.D.: Te digo de usar funcion de la dx_lib32 por que me supongo que la estaras usando en tu proyecto y mas que nada por este hilo esta en el foro de la libreria :P
Cuando la flecha esta sobre un punto es porque las coordenadas son múltiplos de la distancia entre ellos.
Fijando un entorno, si la flecha se encuentra dentro de él, también es válido dibujar el circulo.
mouse_y = k . distancia_y + r ( 0mouse_x = k' . distancia_x + r'
La funcionalidad de r es sumar (hasta 'entorno' cantidad) hasta compensar para que sea múltiplo de distancia. Esto implica la resta.
Si no se cumple que r sea menor que entorno, entonces sin importar en qué lugar esté la flecha va a estar alejada del punto y su entorno.
CONDICION: r <= entorno
ahora,
k = mouse_coord / distancia
despejo r (para el caso de mouse_y) y r' (para el caso de mouse_x) de las ecuaciones anteriores y lo comparo con entorno
if (((mouse_y - ((mouse_y / distancia_y) *distancia_y)) <= entorno) || ( - (mouse_y - ((mouse_y / distancia)+1)*distancia) <= entorno)) && (((mouse_x - ((mouse_x / distancia_x) *distancia_x)) <= entorno) || ( - (mouse_x - ((mouse_x / distancia_x)+1)*distancia_x) <= entorno))
// si está entonces compenso la diferencia para que el centro del círculo sea justo el punto
drawCircle(mouse_x+(distancia_x - ((mouse_x) % distancia_x), mouse_y+(distancia_y- ((mouse_y) %
distancia_y));
considero el caso en que "falte" para llegar a ser múltiplo, por esto sumo 1 en el segundo caso (segunda condicion del OR).
Es decir, si la distancia entre cada punto y es de 20 unidades, entorno 5, y la flecha se encuentra en la posición 17 entonces:
((mouse_y - ((mouse_y / distancia_y) *distancia_y)) = 17 - (0) * 20 = 17 > entorno (NO SE CUMPLE)
pero 17 sí cae en el entorno de uno de los puntos, entonces:
- (mouse_y - ((mouse_y / distancia)+1)*distancia) = - ( 17 - (0 + 1)*20 ) = 3 < entorno (SE CUMPLE)
sumar el 1 implica "pasarse" para el otro lado, para luego ver si puedo sumar un numero no mayor a entorno y llegar al múltiplo.
Y esta vez quedan contemplados ambos casos, y matemáticamente, es correcto. (ole)
Por diox, es un simple mapa de tiles, que rebuscaos <_<
Cita de: "sés"Por diox, es un simple mapa de tiles, que rebuscaos <_<
El codigo espanta, pero el concepto es:
SI (estoy mas arriba del punto y puedo compensar) O (estoy mas abajo y puedo compensar) ENTONCES
DIBUJO CIRCULO;
Hacer el mapa de tiles y andar calculando distancia entre 2 puntos o verificar esta tonta condicion son rebusques por igual :P
Con 2 divisiones sabes el punto más cercano, luego sólo hay que calcular la distancia para ver si estás suficientemente cerca.
:blink: ¿Rebusques?
Joder "sés" qué insistente eres :blink: ; debe ser por eso los ojos de tu avatar.
No voy a seguir en la estúpida discusión de "qué es mejor" . La condición es estúpida y son solo 3 lineas, como ves, tampoco he declarado ninguna variable. En términos de costos basta con ver la función distancia mas las variables...
Math.sqrt(Math.pow((x1-x0),2)+Math.pow((y1-y0),2));
Pero claro...si no tienes ni idea de donde sale o cómo llegar a la condición puede parecerte muy rebuscado o demasiado raro. :ph34r:
ses dejalo, ya hemos dicho que es como un mapa de tiles y no hacen caso, que lo hagan como quieran, no se dan cuenta que la solucion es plantearlo como si fuera un mapa de tiles
Cita de: "ZüNdFoLGe"Joder "sés" qué insistente eres :blink:
Pero si sólo le he dicho una vez...
Cita de: "zupervaca"ses dejalo, ya hemos dicho que es como un mapa de tiles y no hacen caso, que lo hagan como quieran, no se dan cuenta que la solucion es plantearlo como si fuera un mapa de tiles
(uoh) Caballeros, está bien que sea un foro de discusión, pero no es necesario armar una pelea por la solución del problema planteado. Siempre hay más de una solución ;) .
ses y zupervaca, si me explican cómo se hace un mapa de tiles, sin la necesidad de guardar las coordenadas en un vector, ni en ningún otro lado... y a la vez puedo hacer el cálculo... se los agradecería ;).
Y José, si, estoy usando tu librería... voy a probar la solución que me planteas.
Y gracias a todos (ole)
No hay que guardar nada, la solucion es plantear el problema como si fuera un mapa de tiles, es decir, calcular las zonas de colision o zonas calientes de la misma manera que se calcula en que tile estas en un mapas de tiles, con las formulas que te puse antes puedes hacerlo, no obstante dependiendo de uno u otros casos puedes hacer menos calculos.
No tengo interés en discutir como es mejor, ya que para cada caso y para cada programador es mejor de una forma u otra pero voy a explicar un poco mejor mi propuesta anterior a pbarros.
Tienes una matriz de puntos separados a una determinada distancia, donde cada uno se le puede identificar por su fila/columna.
Para saber a que columna pertenece se haría esta operación.
NumColumna = CursorX / AnchoColumna
y para saber la posición (el punto que buscas) de esa columna:
PuntoX = NumColumna * AnchoColumna
Ahora surge el problema que tenías anteriormente cuando la posición aparecía desplazada, y es porque la celda no debe estar entre punto y punto si no que debe estar justo en el centro del punto, ese desplazamiento es igual a la mitad del ancho de la celda, por lo que la corrección se hace al comienzo.
NumColumna = ( CursorX + AnchoColumna/2 )/ AnchoColumna
y ya está, no tiene más, para las filas hay que hacer la misma operación pero usando las Y.
Si por la razón que sea el comienzo de la matriz de puntos no tiene su origen en el la coordenada 0,0 (creo que la tuya empezaba en 100,100) hay que corregir la posición del cursor al obtener la fila/columna.
NumColumna = (CursorX + AnchoColumna/2 - InicioMatrizX)/ AnchoColumna
y por su puesto la posición donde está el punto que corresponde con la columna también lleva el desplazamiento
PuntoX = InicioMatrizX + ( NumColumna * AnchoColumna )
ya conocemos la posición del punto buscado, el más cercano al cursor del ratón, se puede seleccionar directamente, o si se desea se puede comparar su proximidad o selección de la forma que queramos, cuadrada, circular, con una máscara o como sea.
Si quieres saber si el cursor no ha seleccionado una fila/columna válida puedes comprobar que estas no sean menor de cero y que no sea mayor del máximo de filas/columnas.
Si no te interesa el número de columna se puede juntar todo en esta fórmula, es lo único que necesitas.
PuntoX = InicioMatrizX + ( (CursorX + AnchoColumna/2 - InicioMatrizX)/ AnchoColumna * AnchoColumna )
Ahora, si quieres aprender a usar tiles para hacerlo, adelante, pero tampoco está demás saber hacerlo sin usar tiles que por cierto, a mi no me parece que sean tan fáciles.
Cita de: "Guest"Ahora, si quieres aprender a usar tiles para hacerlo, adelante, pero tampoco está demás saber hacerlo sin usar tiles que por cierto, a mi no me parece que sean tan fáciles.
Tu matriz es un mapa de tiles :)
Quiero aclarar que al obtener el punto buscado de esta forma
PuntoX = CursorX / AnchoColumna * AnchoColumna
Hay que hacerlo con número enteros, porque si no, devolvería el mismo punto donde está el cursor.
Cita de: "ZüNdFoLGe"Cita de: "Guest"Ahora, si quieres aprender a usar tiles para hacerlo, adelante, pero tampoco está demás saber hacerlo sin usar tiles que por cierto, a mi no me parece que sean tan fáciles.
Tu matriz es un mapa de tiles :)
Pero no lo trato como tal.
Imagino que cada uno tendrá su forma mejor de hacerlo, a mi lo de hacer comprobaciones sobre celdas imaginarias no me hace mucho.
Se me haría muy difícil el aclararme si la matriz tuviera por ejemplo zoom o rotase, o hacer otros tipos de selección, etc.
Vamos, que no me parece a mi tan fácil el manejar los tiles, pero no voy a discutir si a otro le parece mejor o a pbarros le va a ser más fácil, no lo sé.
Aquí nadie ha dicho que haya que hacer ningún mapa de tiles, sólo que es lo mismo:
Cita de: "sés"No he leído todas las respuestas, pero si los puntos están a la misma distancia unos de otros... eh... es un simple mapa de TILES de toda la vida en el que cada punto sería el centro de un tile.
int tilex = ratonx / ANCHO_TILE_X;
int tiley = ratony / ALTO_TILE_Y;
Luego sólo habría que calcular la distancia al centro de ese tile para ver si se sibuja el círculo o no.
Que es exactamente lo que ha dicho "Guest".
Es un simple mapa de tiles. Estoy con Ses.