elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


  Mostrar Temas
Páginas: 1 2 3 4 [5] 6
41  Foros Generales / Sugerencias y dudas sobre el Foro / Porque lo eliminaron? en: 11 Febrero 2015, 04:03 am
Hace nada había un tema raro, escrito totalmente en ingles, creado por un usuario nuevo. No tenia nada que ver con el foro... y  entiendo la razón por la cual lo eliminaran (yo también lo haría)

Pero que base legal tuvieron?  :-X

Hay una regla de no poder publicar en ingles. Yo leí las reglas completas y no recuerdo ninguna  ;D
42  Foros Generales / Sugerencias y dudas sobre el Foro / Les gusta este header? en: 9 Febrero 2015, 08:01 am
Buenas, con un compañero del foro estamos pensando en hacer video tutoriales en youtube. Pedí el permiso indicado a el-brujo para poder usar elhacker.net como "patrocinador".

Me puse en ello... Y lo primero que hice fue intentar recrear el logo en un gran tamaño para poder utilizarlo en los videotutoriales.

Pues... tuve problemas para extraer una parte del logo, así que simplemente la rehice... y con ello empece a rehacer mas y mas cosas (intentando mantener la escencia, pero modificando un poco el estilo).

Una cosa llevo a la otra, y termine haciendo el mismo header de la pagina, solo que con el nuevo logo, (y algunos detalles distintos).

me gustaría saber su opinión, y quizás ofecerlo de "tributo" al foro.  :xD

(aunque no se si pegue mucho, ya que el foro como tal es bien retro o eso me da a entender a mi)





Este hice para header de foro... no me termina de gustar del todo, pero lo cuelgo igual

43  Foros Generales / Sugerencias y dudas sobre el Foro / Shuriken misterioso de elhacker.net en: 8 Febrero 2015, 17:13 pm
Buenas, me gustaría saber si alguien de este foro por casualidades de la vida tiene el Shuriken del logo de la pagina.

Lo intente extraer manualmente pero me encontré con un dilema... hay unos bordes que por mas que trato no me concuerdan, lo que me hace pensar que hay algo en medio del shuriken.



La circunferencia azul representa el área del shuriken y las lineas rojas representarían el borde del shuriken
44  Foros Generales / Sugerencias y dudas sobre el Foro / Fuente del logo en: 4 Febrero 2015, 13:53 pm
Buenas, alguien sabe cual es la fuente (font) de texto usado en el logo de elhacker.net?  :silbar:
45  Programación / Java / [Aporte] Desarrollo Videojuego Java [Muy Basico] en: 4 Febrero 2015, 02:24 am
Saludos gente, en este aporte busco dar un primer paso para el desarrollo de videojuegos 2D de escritorio en Java.

Quiero dar entender que esta no es la mejor manera para desarrollar un videojuego en java y que tanpoco representa una arquitectura completa. Con esto ultimo me refiero a que el proyecto que mostrare de ejemplo no esta terminado y faltan piezas importantes para ser viable. (La razón por la cual no hice un proyecto completo es porque no busco imponer la forma en la cual programo, y a que no puedo encontrar un patrón ideal para el desarrollo de este tipo de proyectos ya que son muy variados).

Si gustan pondré mas ejemplos y ahondare mas en el tema a futuro, pero como no se cual es el real interés de este foro para este tipo de proyectos no explicare con mucho detalle el presente documento.

Se recomienda saber como funcionan los elementos Thread, JFrame y JPanel de java para poder comprender este documento.

En el presente documento se trataran los siguientes puntos:

  • Como controlar los gráficos (Muy básico, no se hablaran de sprites ni nada por el estilo).
  • Como controlar los FPS. (Intentare detallar en el tema)
  • Como recibir datos del teclado.

Este documento utilizara herramientas de las librerías java.awt y javax.swing (no se utilizara JavaFX).

Lo único que se hará en este proyecto es dibujar un simple cuadrado el cual se moverá por la pantalla utilizando teclado.



Empecemos creando un proyecto (no importa el nombre que le des). crea un paquete (nuevamente no importa el nombre) y posterior crea dos clases:

GameEsta contendrá el método de inicio donde se creara la ventana del juego.
GamePanelEsta clase sera el motor principal del videojuego en donde se dibujaran los gráficos y captara los datos del teclado.

Primero trabajaremos con la clase Game la cual contendrá el siguiente código:

Código
  1. package net.elhacker.game;
  2.  
  3. import javax.swing.JFrame; /* Importamos JFrame necesario para crear la ventana */
  4.  
  5. public class Game {
  6.  
  7.    public static void main(String[] args) {
  8.        JFrame window = new JFrame("Title"); /* Creamos la ventana del juego */
  9.        window.setContentPane(new GamePanel()); /* Establecemos el panel del juego */
  10.        window.setResizable(false); /* Bloqueamos el tamaño de la ventana */
  11.        window.pack(); /* Ajustamos el tamaño de la ventana al tamaño del juego */
  12.        window.setLocationRelativeTo(null); /* Colocamos la ventana en el centro */
  13.        window.setVisible(true); /* Hacemos la ventana visible */
  14.        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /* Indicamos que al cerrar la ventana finaliza el proceso */
  15.    }
  16.  
  17. }
  18.  

No te preocupes es normal que de error en este momento el método setContentPane

Bien, explicare los aspectos mas importantes de esta clase:

El método setContentPane nos permite cambiar el panel por defecto de JFrame por nuestro panel en el cual dibujaremos los gráficos del videojuego.

Establecemos en el método setResizable que sea imposible alterar el tamaño del JFrame (A menos que lo hagamos nosotros por código) Este método inhabilita la opción de agrandar la ventana.

El método pack nos permite ajustar el tamaño de la ventana al tamaño del panel. (De esta manera no tendremos que preocuparnos de las medidas del panel)

el método setLocationRelativeTo(null) nos ahorrara mucho trabajo a la hora de posicionar la ventana de nuestro juego en medio. (Con este método nos ahorramos el tener que hacer cálculos para posicionar la ventana en medio de la pantalla)

En este momento window.setContentPane(new GamePanel()) da error debido a que GamePanel no es aun un panel, ahora trabajaremos con GamePanel y arreglaremos esto.

El código de GamePanel es el siguiente (No te preocupes se que es extenso pero intentare explicar cada  una de las partes por separado.)

Código
  1. package net.elhacker.game;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Dimension;
  5. import java.awt.Graphics;
  6. import java.awt.Rectangle;
  7. import java.awt.event.KeyEvent;
  8. import java.awt.event.KeyListener;
  9. import javax.swing.JPanel;
  10.  
  11. public class GamePanel extends JPanel implements Runnable, KeyListener {
  12.  
  13.    public static final int GAME_WIDTH = 640; /* Ancho sin escala del panel */
  14.    public static final int GAME_HEIGHT = 480; /* Largo sin escala del panel */
  15.  
  16.  
  17.    private int expectedFps = 60; /* FPS esperados */
  18.    private Thread gameThread; /* Thread del juego  */
  19.  
  20.    private final Rectangle rectangle = new Rectangle(0,0,32,32); /* Rectangulo blanco */
  21.                                                                  /* Los primeros dos valores son las cordenadas */
  22.                                                                  /* Los siguientes dos son el ancho y largo */
  23.  
  24.  
  25.    public GamePanel() {
  26.        this.setPreferredSize(new Dimension(
  27.                GamePanel.GAME_WIDTH, GamePanel.GAME_HEIGHT)); /* Se establece el tamaño del juego */
  28.        this.gameThread = new Thread(this); /* inicializamos el thread del juego */
  29.    }
  30.  
  31.    /*
  32.      * Thread que controla los FPS del juego
  33.      */
  34.  
  35.    @Override
  36.    public void run() {
  37.        long start;        
  38.        long elapsed;      
  39.        long wait;
  40.        while(true){
  41.            start = System.nanoTime();  /* Tomamos tiempo de inicio */
  42.            this.repaint();
  43.            elapsed = System.nanoTime(); /* Tomamos tiempo de fin */
  44.            wait = 1000/expectedFps - (elapsed-start)/1000000; /* Utilizamos formula de FPS */
  45.            wait = (wait < 0)? 0 : wait;  /* Prevenimos posibles errores */
  46.            try {
  47.                Thread.sleep(wait); /* Pausamos el thread */
  48.            } catch (InterruptedException ex) { /* Reportar Error */ }
  49.  
  50.        }
  51.    }
  52.  
  53.  
  54.    /*
  55.      * Este metodo inicializa el motor del juego
  56.      */
  57.  
  58.    private void init(){
  59.        this.gameThread.start();    /* iniciamos el motor del juego */
  60.        this.addKeyListener(this);  /* Hacemos que el juego capte las teclas del teclado */
  61.        this.setFocusable(true); /* Hacemos que sea posible hacer un focus a la ventana */
  62.        this.requestFocus();    /* Establecemos el foco al juego */
  63.    }
  64.  
  65.    /*
  66.      * Este metodo se activa al hacer visible el juego
  67.      */
  68.  
  69.    @Override
  70.    public void addNotify() {  
  71.        super.addNotify();
  72.        init(); /* se inicia el motor del juego */
  73.    }
  74.  
  75.    /*
  76.      * Metodo para pintar
  77.      */
  78.  
  79.    @Override
  80.    public void paintComponent(Graphics g) {
  81.        g.setColor(Color.DARK_GRAY); /* Seleccionamos el color gris oscuro */
  82.        g.fillRect(0, 0, GamePanel.GAME_WIDTH,
  83.                GamePanel.GAME_HEIGHT); /* Pintamos el fondo gris oscuro */
  84.  
  85.        g.setColor(Color.WHITE); /* Seleccionamos el color blanco */
  86.        g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height); /* Pintamos el rectangulo */
  87.    }
  88.  
  89.  
  90.  
  91.  
  92.    @Override
  93.    public void keyTyped(KeyEvent e) { }
  94.  
  95.  
  96.    /*
  97.      * Metodo de escucha que nos permite realizar acciones dependiendo de las
  98.      * teclas presionadas
  99.      */
  100.    @Override
  101.    public void keyPressed(KeyEvent e) {
  102.        switch(e.getExtendedKeyCode()){
  103.            case KeyEvent.VK_LEFT:
  104.                rectangle.x-=32;
  105.                break;
  106.            case KeyEvent.VK_RIGHT:
  107.                rectangle.x+=32;
  108.                break;
  109.            case KeyEvent.VK_UP:
  110.                rectangle.y-=32;
  111.                break;
  112.            case KeyEvent.VK_DOWN:
  113.                rectangle.y+=32;
  114.                break;
  115.        }
  116.    }
  117.  
  118.    @Override
  119.    public void keyReleased(KeyEvent e) {
  120.  
  121.    }

Partamos por esta parte:

Código
  1. public class GamePanel extends JPanel implements Runnable, KeyListener

Heredamos de JPanel el cual nos permitirá transformar nuestra clase a una clase tipo Container (GamePanel hereda de container) la cual repara el error de window.setContentPane(new GamePanel()). GamePanel tiene un método de doble buffer el cual nos permitirá controlar mas fácilmente las imágenes.

También implementamos Runnable el cual utilizaremos para crear el Thread que permitirá controlar los FPS de nuestro juego e implementamos KeyListener el cual nos permitirá escuchar datos del teclado.

Bien Ahora veamos los atributos de nuestra clase:

Código
  1. public static final int GAME_WIDTH = 640; /* Ancho sin escala del panel */
  2. public static final int GAME_HEIGHT = 480; /* Largo sin escala del panel */
  3.  
  4. private int expectedFps = 60; /* FPS esperados */
  5. private Thread gameThread; /* Thread del juego  */
  6.  
  7. private final Rectangle rectangle = new Rectangle(0,0,32,32); /* Rectangulo blanco */
  8.                                                              /* Los primeros dos valores son las cordenadas */
  9.                                                              /* Los siguientes dos son el ancho y largo */

GAME_WIDTH y GAME_HEIGHT serán las que indicaran respectivamente el ancho y largo de la ventana.

expectedFps representaran a los FPS esperados (FPS = Frames Per Second)

gameThread sera el thread que utilizaremos para repintar nuestro juego cada X milisegundos utilizando.

rectangle sera en este caso nuestro cuadrado blanco que se moverá por la pantalla (representando a un elemento del juego). Los dos primeros valores representan las cordenadas y los dos ultimos el ancho y largo.

Posterior a esto declaramos nuestro constructor en donde define el ancho y largo de nuestra ventana. Ten en cuenta que esto lo hacemos por el método PreferredSize y no por el método setSize (esto es necesario ya que pack() funciona teniendo en cuenta el tamaño preferido, no el real). Y en el mismo contructor crearemos nuestro Thread señalando que se utilizara la misma clase como Thread.

Código
  1. public GamePanel() {
  2.    this.setPreferredSize(new Dimension(
  3.            GamePanel.GAME_WIDTH, GamePanel.GAME_HEIGHT)); /* Se establece el tamaño del juego */
  4.    this.gameThread = new Thread(this); /* inicializamos el thread del juego */
  5. }

Ahora definiremos el método run (el cual implementamos de runnable)

Código
  1. @Override
  2.    public void run() {
  3.        long start;        
  4.        long elapsed;      
  5.        long wait;
  6.        while(true){
  7.            start = System.nanoTime();  /* Tomamos tiempo de inicio */
  8.            this.repaint();
  9.            elapsed = System.nanoTime(); /* Tomamos tiempo de fin */
  10.            wait = 1000/expectedFps - (elapsed-start)/1000000; /* Utilizamos formula de FPS */
  11.            wait = (wait < 0)? 0 : wait;  /* Prevenimos posibles errores */
  12.            try {
  13.                Thread.sleep(wait); /* Pausamos el thread */
  14.            } catch (InterruptedException ex) { /* Reportar Error */ }
  15.  
  16.        }
  17.    }
   
   
Nos detendremos un poco acá para explicar un par de cosas:

Las películas, videojuegos o cualquier animación no son mas que un montón de fotografías pasadas a una gran velocidad. La velocidad por la cual pasan estas fotografías es medida en FPS(Framies Per Second) (Cuadros Por Segundo)  y  la velocidad optima son unos 60 fotografías por segundo en el caso de los videojuegos.

Entonces nuestro thread tiene como objetivo pintar 60 fotografías por segundo, para esto se utiliza un algoritmo que explicare a continuación.

bien te explico, utilizando el metodo repaint() obligamos a nuestro panel volver a pintarse, luego utilizando Thread.sleep() hacemos que nuestro Thread se detenga por una cantidad minúscula de tiempo ya que si no hiciéramos esto el Thread no pararía de pintar a la mayor velocidad posible. Lo cual ocasionaría problemas de rendimiento (Esto tenemos que evitarlo. Claro, porque despues dicen que java es lento) pues bien aqui es cuando entra el concepto de FPS, ¿Cuanto tiempo es necesario que duerma nuestro Thread para lograr que se pinte 60 veces por segundo?

Sabiendo que Thread.sleep() recibe como parámetro milisegundos usaremos la siguiente formula 1000/60. De esta manera cada unos 16.6 milisegundos nuestro programa pintara un nuevo cuadro (esto medido en 1 segundo serán 60 cuadros).

Código
  1. while (true) {
  2. this.repaint();
  3. Thread.sleep(1000/60);
  4. }

Pero si fuera tan fácil porqué a algunos videojuegos le cuesta tanto llegar a los 60 cuadros por segundo?

Pues esto es porque la formula no termina acá. nos ha faltado algo importante. Y es que no tuvimos el cuenta la cantidad de tiempo que se demora en repintar nuestro panel.

Te daré un ejemplo simple. Imagina un pintor. Este pintor tiene por obligación pintar un cuadro todos los días.
Su obligación es empezar a pintar a las 8AM y se puede ir a dormir cuando termine de pintar el cuadro.

Si el primer día se demora 12 horas en pintar el cuadro el hombre podrá dormir 12 horas.
Si el segundo día se demora 10 horas en pintar el cuadro entonces el pintor dormirá 14 horas.
Pero si el tercer día se demora 23 horas en pintar el cuadro, el pobre hombre solo podrá dormir una hora.

Pues bien, si nuestro programa se demora 3 milisegundos en pintar el cuadro entonces tendremos que restar esos 3 milisegundos a los 16.6 milisegundos lo que daria un total de 13.6 milisegundos. El problema es que nosotros no sabremos cuanto se demora en pintar el cuadro ya que esto depende de cuantos recursos disponibles hay en el sistema (si la computadora esta ejecutando el antivirus mientras juegan nuestro juego, lo mas natural es que nuestro juego no funcione al 100% de velocidad)

Para saber cuanto se demora en pintar el cuadro necesitaremos tomar el tiempo antes de pintar, y después de pintar el cuadro luego hacer una resta y obtendremos el tiempo. Este tiempo lo restamos a los 1000/60 y obtendremos el tiempo real en que nuestro thread puede dormir.

Si te fijas bien para prevenir errores verifique que el tiempo nunca sea menor a 0.

Código
  1. start = System.nanoTime();  /* Tomamos tiempo de inicio */
  2. this.repaint();
  3. elapsed = System.nanoTime(); /* Tomamos tiempo de fin */
  4. wait = 1000/expectedFps - (elapsed-start)/1000000; /* Utilizamos formula de FPS */
  5. wait = (wait < 0)? 0 : wait;  /* Prevenimos posibles errores */
  6. try {
  7.    Thread.sleep(wait); /* Pausamos el thread */
  8. } catch (InterruptedException ex) { /* Reportar Error */ }
  9.  

sleep puede causar errores, por eso se utiliza un try-catch

Posterior mente declararemos el método init, en el cual pondremos todo lo necesario para que nuestro juego sea funcional y visible, para esto iniciamos el Thread previamente declarado, y hacemos que la ventana pueda escuchar las teclas presionadas en el teclado.

Código
  1. private void init(){
  2.    this.gameThread.start();    /* iniciamos el motor del juego */
  3.    this.addKeyListener(this);  /* Hacemos que el juego capte las teclas del teclado */
  4.    this.setFocusable(true); /* Hacemos que sea posible hacer un focus a la ventana */
  5.    this.requestFocus();    /* Establecemos el foco al juego */
  6. }

(para que el juego capte las teclas del teclado tenemos que hacer que sea posible hacer focus en el panel, si tienes una duda respecto a esto comentalo e intentare responderte a la brevedad.)

La siguiente parte no es nada complicada, solo redefinimos el metodo addNotify (Este método se activa cuando hacemos el juego visible) y agregamos nuestro metodo init() el cual a su vez hará que nuestro Thread se ejecute.

Código
  1. @Override
  2. public void addNotify() {  
  3.    super.addNotify();
  4.    init(); /* se inicia el motor del juego */
  5. }

Ahora redefinimos el método paintComponent que es el encargado de dibujar los gráficos de nuestro juego.

Código
  1. @Override
  2. public void paintComponent(Graphics g) {
  3.    g.setColor(Color.DARK_GRAY); /* Seleccionamos el color gris oscuro */
  4.    g.fillRect(0, 0, GamePanel.GAME_WIDTH,
  5.            GamePanel.GAME_HEIGHT); /* Pintamos el fondo gris oscuro */
  6.  
  7.    g.setColor(Color.WHITE); /* Seleccionamos el color blanco */
  8.    g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height); /* Pintamos el rectangulo */
  9. }

Graphics funciona como si utilizaras paint, primero le indicas el color y luego lo que quieres hacer, en este caso primero indicamos el color gris oscuro y pintamos un cuadrado del mismo tamaño que nuestro panel (de esta manera hacemos un fondo oscuro), luego seleccionamos el color blanco y pintamos nuestro rectángulo.

Ahora solo es necesario redefinir los métodos del teclado (cada vez que se apreté una tecla se hará algo que nosotros queramos). En este caso solo redefiniremos keyPressed (este se activa al presionar una tecla)

Código
  1. /*
  2.  * Metodo de escucha que nos permite realizar acciones dependiendo de las
  3.  * teclas presionadas
  4.  */
  5. @Override
  6. public void keyPressed(KeyEvent e) {
  7.    switch(e.getExtendedKeyCode()){
  8.        case KeyEvent.VK_LEFT:
  9.            rectangle.x-=32;
  10.            break;
  11.        case KeyEvent.VK_RIGHT:
  12.            rectangle.x+=32;
  13.            break;
  14.        case KeyEvent.VK_UP:
  15.            rectangle.y-=32;
  16.            break;
  17.        case KeyEvent.VK_DOWN:
  18.            rectangle.y+=32;
  19.            break;
  20.    }
  21. }
  22.  
  23. @Override
  24. public void keyReleased(KeyEvent e) { }


Con ayuda de un switch y case haremos cada caso posible.

  • Si se aprieta la direccional izquierda nuestro cuadro se mueve 32 pixeles a la izquierda
  • Si se aprieta la direccional derecha nuestro cuadro se mueve 32 pixeles a la derecha
  • Si se aprieta la direccional arriba nuestro cuadro se mueve 32 pixeles a la arriba
  • Si se aprieta la direccional abajo nuestro cuadro se mueve 32 pixeles a la abajo

Ten en cuenta que los pixeles se miden desde el extremo superior izquierdo de la pantalla por esta razón tienes que restar para ir hacia arriba y sumar para ir hacia abajo.

Intentalo tu:

  • Actualmente el cuadrado puede salir de los bordes, intenta evitar que esto sea posible.
  • Intenta crear un segundo cuadra que se mueva con las teclas ASDW
  • Intenta crear una cuadricula amarilla que se se haga visible al apretar la tecla c, y si se apreta nuevamente esta se haga invisible otra vez

Espero la tutorial les haya sido de ayuda. Estoy pensando en hacer un vídeo ya que entiendo que puede ser difícil de entender con tan solo esto. Por otro lado, para los mas experimentados, se que esta tutorial es simple y que no abordo algunos temas importante, pero la verdad es que no se como sera recibido por la comunidad así que no quería hacer algo muy complejo.
46  Foros Generales / Sugerencias y dudas sobre el Foro / ¿Codigo BBC poner bordes a tablas? en: 3 Febrero 2015, 01:15 am
Es posible con código BBC ponerle bordes a tablas?

Quiero hacerlo en un tema que cree (para que sea mas fácil de entender) pero al parecer no se puede. Existe alguien que me lo pueda aclarar?
47  Programación / Java / [Aporte] Operadores de Java en: 3 Febrero 2015, 01:08 am
Con el presente documento planeo hacer una micro guía en partes útil para recordar ciertos aspectos de Java. Detalles simples pero útiles (no planeo enseñar nada nuevo, solo una "chuleta" que permita a los programadores olvidadizos tener un apoyo)

En Java como en todos los lenguajes de programación existen distintos operadores cada uno es útil en distintas circunstancias, y en el presente documento detallare todos los operadores existentes en Java.

Operadores aritméticos:

OperadorDescripción
+Suma
-Resta
*Multiplicación
/División
%Módulo
++Incremento
--Decremento

Operadores relacionales:

OperadorDescripción
==Igual
!=Distinto
>Mayor que
<Menor que
>=Mayor o igual
<=]Menor o igual


Operadores lógicos:

OperadorDescripción
&AND
|OR
^XOR
&&AND en cortocircuito
||OR en cortocircuito
!NOT

Operadores a nivel de bit:

OperadorDescripción
~NOT
&AND
|OR
^XOR
>>Desplazamiento a la derecha
>>>Desplazamiento a la derecha sin signo
<<Desplazamiento a la izquierda

Operadores de asignación:

OperadorDescripción
=Asignación
~NOT
+=Suma y asignación
-=Resta y asignación
*=Multiplcación y asignación
/=División y asignación
%=Módulo y asignación
&=AND y asignación
|=OR y asignación
^=XOR y asignación
<<=Desplazamiento a la izquierda y asignación
>>=Desplazamiento a la derecha y asignación
>>>=Desplazamiento a la derecha sin signo y asignación

Caracteres especiales:

OperadorDescripción
\bRetroceso
\tTabulador
\rRetorno de carro
\nNueva línea
\'Comilla simple
\"Comilla doble
\\Barra invertida

Precedencia de operadores:

OperadorAsociatividad
() [] .Izquierda a derecha
++ - ! +(unario) -(unario) () (cast) newDerecha a izquierda
* / %Izquierda a derecha
+ -Izquierda a derecha
>> >>> <<Izquierda a derecha
> >= <= > instanceofIzquierda a derecha
== !=Izquierda a derecha
&Izquierda a derecha
|Izquierda a derecha
&&Izquierda a derecha
||Izquierda a derecha
?:Izquierda a derecha
= += -= *= /= %= &= |= = <<= >>= >>>=Izquierda a derecha

Si omito alguno por favor pido a algún moderador que me permita modificar el presente documento.
48  Foros Generales / Foro Libre / ¿Te consideras un hacker? en: 1 Febrero 2015, 06:51 am
Me gustaría que respondieran esta pregunta con sinceridad: ¿Te consideras un hacker?

Cuando estaba en la escuela recuerdo que con el solo hecho de utilizar linux ya habian algunos que te decían hacker. Y si bueno, si sabias utilizar Airckrack ya eras el mejor informático del mundo.

En lo personal nunca me he considerado hacker (agradezco no haber tenido el ego de decirme a mi mismo hacker cuando recién estaba aprendiendo como usar una computadora)

¿En que punto ya puedes llamarte hacker?
¿Alguien que sabe hacer un ataque DDoS es un hacker?
¿Alguien que crea un programa innovador es un hacker?

¿En que  momento eres un hacker?

Lo he estado pensando mucho... pero creo que el termino hacker depende del ojos de quien lo ve. Si X sabe poco en comparación a Y, entonces a los ojos de X la Y es un hacker, y por esta misma razón nunca te podrás llamar hacker a ti mismo.

Yo no soy un hacker y me faltan AÑOS para siquiera dudar si realmente lo soy. Pero tu..  ¿Te consideras un hacker?
49  Seguridad Informática / Hacking / ¿Como Identificar un ataque DDOS? en: 31 Enero 2015, 05:58 am
Buenas, hoy el foro tuvo problemas durante un tiempo. El error 522 a lo que da entender que el servidor se vio en un momento colapsado.

Para comprobar esto se me ocurrió hacer un ping suponiendo que el servidor al estar colapsado no me respondería satisfactoriamente... pero para mi sorpresa, no tuve ningún problema. Me respondió aun cuando el foro estaba fuera de servicio.

Entonces mi pregunta es ¿porque?, quizás yo no supe interpretar las señales y realmente el servidor no tenia ningún problema... o simplemente el método que utilice no es el correcto.

Alguien me podría explicar de que forma entonces podría saber si realmente una pagina web que frecuento esta bajo un ataque?

simple curiosidad.

PD: lamento si esto no va acá, pero no sabia si ponerlo acá, o en seguridad... ni idea.
50  Comunicaciones / Redes / [Pregunta] Duda sobre recepción paquetes de red/ip en: 30 Enero 2015, 04:00 am
Buenas, la verdad es que esto de las redes es mi punto débil en la informática, así que me gustaría hacer una pregunta pare resolver una duda que se me vino a la cabeza.
<<Lo lamento creo que no busque lo suficiente en Google>>

El tema es que por lo que recuerdo los paquetes de red administrados por el router tienen una cabecera header la cual contiene información relevante para el envió y recepción del paquete en si.

Supongo que es posible modificar esa cabecera, y por esa razón tengo una duda. Que pasa si se envía un conjunto de paquetes aun servidor solicitando descargar un archivo, y  antes de esto modifico la dirección de procedencia. El servidor creerá que la solicitud procede de otro sitio e intentara mandar datos a un lugar en donde no se han solicitado, como controla esto un router?, me refiero que medidas de seguridad se toman?

(no sabia en donde poner esta pregunta, espero que este en el lugar correcto)
Páginas: 1 2 3 4 [5] 6
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines