Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Ahora que tenemos ya más o menos establecidas las clases de los personajes, podemos pensar en hacer el main del programa.
Por desgracia, me quedo sin tiempo, pero puedo adelantar algo.

Creo que es interesante que al iniciarse el programa, lo primero que se encuentre el usuario es la posibilidad de crear su personaje, decidir la clase, nombre y los niveles de los atributos.
Para los niveles de ataque, defensa y vida he establecido unos límites mínimos y máximos.
Tu ya decides si quieres modificarlos.

Una vez creado el personaje, automáticamente se crea el Caballero que manejará la CPU y se muestra en pantalla las características del este personaje.

A partir de aquí debería comenzar el combate.
Mostrar menú para que el usuario elija atacar, defender o habilidades especiales (distintas según si maneja un Caballero o un Mago).
También habrá que decidir cómo ha de actuar la CPU. Esta deberá elegir al azar entre atacar, defender o Relámpago.

Y bueno, no me da tiempo para más por hoy.
Solo he podido hacer la idea de la creación del personaje:

import java.util.Scanner;

public class Combate {

private static Scanner teclado = new Scanner(System.in);
private static Personaje jugador; //Podrá ser un Mago o un Caballero
private static Caballero CPU; //La CPU siempre es un Caballero

public static void main(String[] args) {

crearPersonaje();

//TODO Combatir...
}


private static void crearPersonaje() {
System.out.println("\t\tCREAR PERSONAJE");
System.out.println("\t\t----- ---------");
System.out.println("Clases disponibles:");
System.out.println("[1] -> Caballero");
System.out.println("[2] -> Mago");

System.out.print("Elige clase: ");
int clase = Integer.parseInt(teclado.nextLine());

System.out.print("\nNombre: ");
String nombre = teclado.nextLine();

System.out.print("Nivel de Ataque(min = 1/max = 10): ");
int ataque = Integer.parseInt(teclado.nextLine());
//Forzamos que el nivel escogido se ciña a los límites
if (ataque < 1)
ataque = 1;
else if (ataque > 10)
ataque = 10;

System.out.print("Nivel de Defensa(min = 1/max = 10): ");
int defensa = Integer.parseInt(teclado.nextLine());
if (defensa < 1)
defensa = 1;
else if (defensa > 10)
defensa = 10;

System.out.print("Nivel de Vida(min = 100/max = 1000): ");
int vida = Integer.parseInt(teclado.nextLine());
if (vida < 100)
vida = 100;
else if (vida > 1000)
vida = 1000;

//Tenemos todos los atributos necesarios, creamos Personaje
if (clase == 1) //Ha elegido Caballero
jugador = new Caballero(nombre, ataque, defensa, vida);
else //Mago
jugador = new Mago(nombre, ataque, defensa, vida);

System.out.println("\nEste es tu personaje:");
System.out.println(jugador);
pausa();

//Ahora creamos el Caballero CPU, con doble de potencia que el Jugador
CPU = new Caballero("Thanos", (ataque*2), (defensa*2), (vida*2));

System.out.println("Y este será tu rival:");
System.out.println(CPU);
System.out.println("Nivel de Ataque: " + CPU.getAtaque()
+ " / Nivel de Defensa: " + CPU.getDefensa());

pausa();
}


private static void pausa() {
System.out.println("\n\t\tPULSA ENTER PARA SEGUIR\n");
teclado.nextLine();
}
}

He combinado los dos temas en uno solo, para que la información no quede dispersa.

A ver, algunas explicaciones.

La clase Pokemon es básicamente la misma, con unos ligeros cambios.
He añadido dos atributos un String llamado mensaje y un boolean llamado suTurno

Antes cuando un Pokemon atacaba, mostraba en consola el daño producido y si era un ataque crítico.
Al pasar a interfaz gráfica ya no usamos la consola, pero esos mensajes nos siguen interesando obtenerlos para mostrarlos en la interfaz.
Así que ahora en lugar de imprimirlos en consola, tras cada ataque se compone un String nuevo que queda guardado en ese atributo.
Así tras la acción de atacar, podemos recuperar ese mensaje y enviarlo al panel superior de la interfaz que funciona como un "display" de mensajes.

El otro atributo, el boolean suTurno, es para que cada objeto Pokemon sepa decirnos si es su turno de ataque o no.
Antes, en modo consola, el turno estaba establecido directamente en el flujo de instrucciones del programa. Cada vez que se repetía el bucle while, atacaba el primer Pokemon y luego el segundo, si es que seguía vivo.
Ahora con la interfaz gráfica, no hay ningún bucle ni flujo de instrucciones que ejecuten los ataques.

Los ataques los produce el usuario pulsando los botones de cada Pokemon. Para garantizar que haya turnos, solo uno de los dos botones está activado. Cuando se pulsa un botón para atacar, este se desactiva y se activa el correspondiente al otro Pokemon para que haya "cambio de turno".

Para que la interfaz sepa en todo momento que botón ha de activar y cuál desactivar, hay que buscar una forma de hacérselo saber. Y se me ocurrió hacer que cada Pokemon tenga un boolean que cambie de true a false cuando ataque y a la inversa cuando reciba daño.
Así cada Pokemon puede decirle a su botón de ataque asociado si ha de estar activo o no.

Y eso es lo único que ha cambiado en la clase Pokemon:

public class Pokemon {

private String nombre;
private int vida;
private Random azar = new Random();

public String mensaje; //Mensaje que se genera tras un ataque
public boolean suTurno; //Indica si es el turno de ataque de este Pokemon

public Pokemon(String nombrePok, int vidaPok, boolean turno) {
nombre = nombrePok;
vida = vidaPok;
mensaje = "";
suTurno = turno;
}

public String getNombre() {
return nombre;
}

public int getVida() {
return vida;
}

public void setVida(int v) {
vida = v;
}

public int atacar() {

mensaje = ""; //Se generará un nuevo mensaje
int ataque = azar.nextInt(11) + 10;

if (esCritico()) {
mensaje += "¡Ataque crítico! ";
ataque =  (int)(ataque * 1.5);
}

mensaje += "Daño: " + ataque + " puntos";
return ataque;
}

public void perderVida(int ataque) {
vida -= ataque;
}

private boolean esCritico() {
int valor = azar.nextInt(100);
/*
* Entre 0 y 100 hay diez valores que son
* múltiplos de 10.
* Es decir, hay un 10% de posibilidades
* de obtener un valor múltiplo de 10.
*/

return valor%10 == 0;
}

@Override
public String toString() {
return "Nombre: " + nombre + "\nVida: " + vida;
}

}
Sobre la interfaz.
Es un JFrame compuesto básicamente de 4 paneles.
Cada panel proviene de una clase que hereda de JPanel (por eso es importante manejar bien POO para sacar partido a Swing)


En la parte superior tenemos un panel de la clase PanelMensajes que simplemente contiene un JLabel (etiqueta) para ir mostrando los mensajes que cada Pokemon genera al atacar.
Se adorna con algunos colores y mayor tamaño de fuente para que los mensajes destaquen más.
La clase tiene un método para recibir y mostrar dichos mensajes.

public class PanelMensajes extends JPanel{

private JLabel mensajes;

public PanelMensajes() {
JPanel display = new JPanel();
mensajes = new JLabel("¡Comienza la batalla!");
mensajes.setFont(new Font("Calibri", Font.PLAIN, 38));
mensajes.setForeground(new Color(243, 81, 55 ));
display.add(mensajes);

setLayout(new GridLayout(1, 1));
add(display);
setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(10, 15, 10, 15),
BorderFactory.createEtchedBorder(EtchedBorder.RAISED)));
display.setBackground(new Color(230, 234, 160 ));
}

/*
* Recibe y muestra los mensajes que los Pokemon generan
* en cada ataque.
*/
public void setMensaje(String mensaje) {
mensajes.setText(mensaje);
}

}
Debajo de este panel superior, tenemos la parte central del JFrame, que es un panel compuesto de tres subpaneles.

Justo en el centro esta un panel de la clase PanelVS, que es tan simple que en realidad no valía la pena escribir una clase separada. Se podría haber compuesto directamente en la clase principal.
Pero bueno, nunca está de más modular el código.
Este panel simplemente muestra una imagen png que descargue de Internet, con las letras vs (versus).
Es tan simple como esto:
public class PanelVS extends JPanel{

public PanelVS() {
ImageIcon imagen = new ImageIcon(PanelVS.class.getClassLoader().getResource("img/vs.png"));
JLabel icono = new JLabel(imagen);
add(icono);
}

}
Como decía, este es el panel que está en medio de los tres paneles centrales.

Los otros dos paneles, uno a cada lado, provienen de la clase PanelPokemon, que ya sí es una clase más elaborada.
Este panel está a su vez compuesto de otros cuatro paneles dispuestos verticalmente.

El primer panel muestra el nombre del Pokemon al que está asociado.

El segundo panel muestra la foto del Pokemon.

El tercer panel contiene la barra de vida, que es un JProgressBar que se va reduciendo según el Pokemon asociado va perdiendo puntos de vida.

El cuarto y último panel contiene el botón para realizar ataques. Este botón es el que antes dijimos que se activa/desactiva según el Pokemon asociado informa de si es su turno de ataque o no.

Para que este botón funcione, hay que añadirle un ActionListener, una clase con el código que decide que ha de ocurrir cuando se pulse el botón.

Este ActionListener va a provenir de la clase principal y se lo haremos llegar mediante el método agregarAccion()

public class PanelPokemon extends JPanel{

private Pokemon pokemon; //Referencia al objeto Pokemon asociado a este panel
private JButton btAtacar;
private JProgressBar barraVida;

public PanelPokemon(Pokemon pok, String rutaImagen) {

pokemon = pok;

setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
add(new PanelNombre());
add(new PanelImagen(rutaImagen));
add(new PanelVida());
add(new PanelBoton());

}

private class PanelNombre extends JPanel {

public PanelNombre() {
JLabel nombre = new JLabel(pokemon.getNombre());
nombre.setFont(new Font("Consolas", Font.BOLD, 34));
nombre.setForeground(Color.WHITE);
add(nombre);
setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED, Color.WHITE, Color.BLACK));
setBackground(new Color(23, 151, 238));
}
}

private class PanelImagen extends JPanel {

public PanelImagen(String rutaImagen) {
ImageIcon imagen = new ImageIcon(PanelPokemon.class.getClassLoader().getResource(rutaImagen));
JLabel icono = new JLabel(imagen);
icono.setBorder(BorderFactory.createLoweredSoftBevelBorder());
add(icono);
}
}

private class PanelVida extends JPanel {

public PanelVida() {

barraVida = new JProgressBar();
barraVida.setMaximum(pokemon.getVida());
barraVida.setValue(pokemon.getVida());
barraVida.setPreferredSize(new Dimension(200, 30));
barraVida.setForeground(Color.BLUE);
add(barraVida);
barraVida.setBorder(BorderFactory.createRaisedSoftBevelBorder());

TitledBorder bordeTitulado = new TitledBorder("Nivel de Vida");
bordeTitulado.setTitleFont(new Font("Consolas", Font.ITALIC, 24));
setBorder(bordeTitulado);
}
}

private class PanelBoton extends JPanel {

public PanelBoton() {
btAtacar = new JButton("¡ATACAR!");
btAtacar.setFont(new Font("Consolas", Font.BOLD, 30));
add(btAtacar);
setBorder(BorderFactory.createEmptyBorder(30, 20, 30, 30));
}
}

public void actualizarPanel() {
barraVida.setValue(pokemon.getVida());
btAtacar.setEnabled(pokemon.suTurno);
}

public void agregarAccion(ActionListener accion) {
btAtacar.addActionListener(accion);
}

}

¿Y por qué esa clase ActionListener la vamos a escribir en la clase principal?
Si el botón "ATACAR" está dentro de la clase PanelPokemon, ¿por qué no escribimos ahí su correspondiente código de acción?

Por un problema de "ámbitos". Una de las cosas que quiero que ocurran cuando se ataquen los Pokemon, es que el panel de mensajes reciba y muestre los mensajes que generan los Pokemon.
Pero este panel de mensajes, es una clase llamada PanelMensajes que está escrita separada de la clase PanelPokemon. Esto implica que están en ámbitos distintos, y desde PanelPokemon, no voy a tener visibilidad para actuar sobre PanelMensajes

En cambio, la clase principal, la que va a modelar el JFrame, va a contener dentro de su ámbito a TODAS las otras clases paneles.
Desde ahí si que no voy a tener problemas de visibilidad para hacer que unos paneles interactúen con otros.
Así que puedo escribir ahí la clase ActionListener y luego hacérsela llegar a sendos botones de "ATACAR".


La clase principal, llamada BatallaSwing tiene como atributos los dos Pokemon y referencias a los paneles que componen la interfaz.
Excepto para la clase PanelVS, que como está de puro adorno y no se interactúa con ella durante el programa, no necesita estar referenciada con ningún atributo.

En esta clase podemos ver el código del ActionListener, que viene a ser el "motor" del juego.
Cuando se pulsa un botón de ataque, se pregunta a los Pokemon de quién es el turno (se podría preguntar qué botón ha sido pulsado, pero es más rápido consultar el atributo de los Pokemon).
Entonces el Pokemon que posee el turno ataca al otro.
La interfaz se actualiza con mensaje arriba y las barras de vida.
Y se comprueba si ambos Pokemon siguen con vida.
Si alguno ha muerto, se informa del final del juego con un JOptionPane, que al aceptarlo, se reinicia todo a valores por defecto y el juego comienza de nuevo.

public class BatallaSwing extends JFrame{

private Pokemon pok1;
private Pokemon pok2;
private PanelMensajes pnMensajes;
private PanelPokemon pnPok1;
private PanelPokemon pnPok2;

public BatallaSwing() {

pok1 = new Pokemon("Pikachu", 100, true);
pok2 = new Pokemon("Bulbasaur", 100, false);
pnMensajes = new PanelMensajes();
pnPok1 = new PanelPokemon(pok1, "img/pikachu.png");
pnPok1.actualizarPanel();
pnPok1.agregarAccion(new AccionAtacar());
pnPok2 = new PanelPokemon(pok2, "img/bulbasaur.png");
pnPok2.actualizarPanel();
pnPok2.agregarAccion(new AccionAtacar());

setLayout(new BorderLayout());

add(pnMensajes, BorderLayout.NORTH);
JPanel pnCentro = new JPanel();
pnCentro.add(pnPok1);
pnCentro.add(new PanelVS()); //PanelVS no requiere referencia, no se interactúa con ella.
pnCentro.add(pnPok2);
add(pnCentro, BorderLayout.CENTER);

setTitle("Batalla Pokemon");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

private class AccionAtacar implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {

if (pok1.suTurno) {
pok2.perderVida(pok1.atacar());
pnMensajes.setMensaje(pok1.mensaje);
pok1.suTurno = false;
pok2.suTurno = true;
}
else {
pok1.perderVida(pok2.atacar());
pnMensajes.setMensaje(pok2.mensaje);
pok1.suTurno = true;
pok2.suTurno = false;
}

pnPok1.actualizarPanel();
pnPok2.actualizarPanel();

if (pok1.getVida() <= 0 || pok2.getVida() <= 0) {
String mensajeFinal = "Juego Terminado\n Ha ganado: ";
mensajeFinal += pok1.getVida()>0?pok1.getNombre():pok2.getNombre();

JOptionPane.showMessageDialog(null, mensajeFinal, "Fin del Juego",
JOptionPane.INFORMATION_MESSAGE);

//Valores por defecto para volver a jugar
pok1.setVida(100);
pok1.suTurno = true;
pok2.setVida(100);
pok2.suTurno = true;
pnPok1.actualizarPanel();
pnPok2.actualizarPanel();
pnMensajes.setMensaje("¡Comienza la batalla!");
}


}
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new BatallaSwing();
}
});
}

}
Y esto es a grandes rasgos el funcionamiento del programa y la composición básica de la interfaz gráfica.
Respecto a esta, no entro a explicar cada detalle ni cada elemento porque sería extenderse mucho y no creo que sirva para aprender. Insisto que solo practicando y experimentando por uno mismo conseguimos familiarizarnos con la librería Swing.

Pero si tienes alguna pregunta concreta, adelante, no te cortes.

Un saludo.

Hola.
Primero quiero destacar que soy un ignorante absoluto del mundo Pokemon, así que he hecho un programa treméndamente simple je je..

He creado una clase Pokemon con dos atributos, nombre (String) y vida (int).
El valor de estos atributos se establece mediante el constructor.

Hay un tercer atributo que es simplemente un objeto Random para generar valores de ataque al azar.

Uno de los métodos que tiene, es el método atacar() que retornará un valor int que representa el daño conseguido en su turno de ataque.

Este método primero genera un valor aleatorio entre 10 y 20.
Luego, le pregunta a otro método de tipo boolean si este ataque es crítico o no.
Si es crítico, informa en pantalla e incrementa el valor de ataque en un 150%.
Por último, informa en pantalla del valor de ataque final (se haya incrementado o no) y retorna este valor.

¿Y cómo decidimos si este ataque es crítico o no?
El enunciado dice que hay un 10% de probabilidades.
Bien, las probabilidades (o las matemáticas en general) no son lo mío así que no se cuál es la forma más óptima de generar esas probabilidades.

A mí lo que se me ha ocurrido es generar un valor int entre 0 y 100. Si el valor generado es múltiplo de 10, pues retorno true, de lo contrario retorno false.
¿Y por qué hacerlo así?
Porque entre 0 y 100 solo hay diez valores que sean múltiplos de 10, es decir, hay un 10% que son múltiplos de 10 y un 90% que no lo son.
Por lo tanto, si hemos obtenido al azar un múltiplo de 10, pues es lo más parecido a generar una probabilidad del 10%....

Hay otro método llamado perderVida(), que simplemente resta al nivel de vida el valor de ataque generador por un Pokemon rival.

Luego hay un par de getters y un método toString(), en fin, como he dicho, es muy simple y no necesita mayores explicaciones.
Esta sería la clase Pokemon:
public class Pokemon {

private String nombre;
private int vida;
private Random azar = new Random();

public Pokemon(String nombrePok, int vidaPok) {
nombre = nombrePok;
vida = vidaPok;
}

public String getNombre() {
return nombre;
}

public int getVida() {
return vida;
}

public int atacar() {

int ataque = azar.nextInt(11) + 10;

if (esCritico()) {
System.out.println("¡" + nombre + " ha conseguido un ataque crítico!");
ataque =  (int)(ataque * 1.5);
}

System.out.println("Daño conseguido: " + ataque + " puntos");
return ataque;
}

public void perderVida(int ataque) {
vida -= ataque;
}

private boolean esCritico() {
int valor = azar.nextInt(100);
/*
* Entre 0 y 100 hay diez valores que son
* múltiplos de 10.
* Es decir, hay un 10% de posibilidades
* de obtener un valor múltiplo de 10.
*/

return valor%10 == 0;
}

@Override
public String toString() {
return "Nombre: " + nombre + "\nVida: " + vida;
}

}

Luego, para el combate, en la clase principal lo que hago es declarar dos objetos Pokemon e inicio un bucle while que se va a repetir mientras ambos contendientes tengan un nivel de vida superior a 0.
Si alguno pierde toda su vida, el bucle se detiene (el combate finaliza)

Dentro del bucle, pues voy informando de los datos de los contendientes y hay dos turnos de ataque, uno para cada Pokemon.

Cada vez que uno ataca, compruebo si el otro sigue vivo o no. Si sigue vivo, pasamos al turno en el que a este le toca atacar.
Si ha muerto, entonces no hay más turnos y todo termina.

Para poder ir leyendo en pantalla tranquilamente que ocurre en cada turno, utilizo un método llamado pausa() donde simplemente uso un Scanner para que el programa se detenga hasta que el usuario pulse la tecla enter.

public class Batalla {

private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

Pokemon pok1 = new Pokemon("Bulbasur", 100);
Pokemon pok2 = new Pokemon("Pikachu", 100);


while (pok1.getVida() > 0 && pok2.getVida() > 0) {
System.out.println("\nContendientes:");
System.out.println(pok1);
System.out.println(pok2);
pausa();
System.out.println("Turno de ataque para " + pok1.getNombre());
pok2.perderVida(pok1.atacar());
pausa();
if (pok2.getVida() <= 0) {
System.out.println(pok2.getNombre() + "ha sido derrotado.\n");
}
else {
//Turno del segundo pokemon
System.out.println("\nContendientes:");
System.out.println(pok1);
System.out.println(pok2);
pausa();
System.out.println("Turno de ataque para " + pok2.getNombre());
pok1.perderVida(pok2.atacar());
pausa();
if (pok1.getVida() <= 0)
System.out.println(pok1.getNombre() + " ha sido derrotado.\n");
}
}

System.out.println("\n\n\t\tFIN DEL JUEGO");


}

private static void pausa() {
System.out.println("\n\t\tPULSA ENTER PARA CONTINUAR\n");
teclado.nextLine();
}

}
Si lo ejecutamos, en pantalla podemos ver algo parecido a un combate por turnos:

Contendientes:
Nombre: Bulbasur
Vida: 100
Nombre: Pikachu
Vida: 100

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Bulbasur
Daño conseguido: 10 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 100
Nombre: Pikachu
Vida: 90

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Pikachu
Daño conseguido: 15 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 85
Nombre: Pikachu
Vida: 90

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Bulbasur
Daño conseguido: 17 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 85
Nombre: Pikachu
Vida: 73

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Pikachu
Daño conseguido: 12 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 73
Nombre: Pikachu
Vida: 73

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Bulbasur
¡Bulbasur ha conseguido un ataque crítico!
Daño conseguido: 27 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 73
Nombre: Pikachu
Vida: 46

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Pikachu
Daño conseguido: 15 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 58
Nombre: Pikachu
Vida: 46

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Bulbasur
Daño conseguido: 20 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 58
Nombre: Pikachu
Vida: 26

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Pikachu
Daño conseguido: 15 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 43
Nombre: Pikachu
Vida: 26

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Bulbasur
Daño conseguido: 15 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 43
Nombre: Pikachu
Vida: 11

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Pikachu
Daño conseguido: 14 puntos

      PULSA ENTER PARA CONTINUAR



Contendientes:
Nombre: Bulbasur
Vida: 29
Nombre: Pikachu
Vida: 11

      PULSA ENTER PARA CONTINUAR


Turno de ataque para Bulbasur
Daño conseguido: 12 puntos

      PULSA ENTER PARA CONTINUAR


Pikachu ha sido derrotado.



      FIN DEL JUEGO

Hola. En general me parecen temperaturas adecuadas.

Quizás la del SSD un pelín alta.
A ver, está dentro del rango normal. Un SSD oscila entre 30º y 50º según la carga de trabajo.
A partir de 60º sí que comenzaría a hacer throttling y si alcanzase los 70º las celdas de datos empezarían a estar en peligro.

Así que 41º no es nada preocupante, pero si dices que está en reposo y teniendo un gabinete tan despejado por dentro, quizás lo esperable sería tener una temperatura inferior.

Veo que has puesto un ventilador para el SSD y por la foto creo que ese ventilador estaría "aspirando" el calor.
Sin embargo, los SSD no son muy buenos disipando el calor que generan, así que quizás no haya mucho calor que aspirar alrededor del SSD.

Si te es posible, prueba a girar 180º el ventilador para invertir el flujo de aire y en lugar de aspirar lo que haga sea empujar aire hacia el SSD.
A ver si así notas alguna mejora en la temperatura.

No se si servirá, esto de la refrigeración a veces es una ciencia caprichosa je je.
Pero bueno, por probar...

A ver, para que no caiga esto en el olvido y sirva también de ayuda para futuros visitantes.

Resolvámoslo paso a paso.

Lo primero es conseguir leer el fichero y mostrar sus líneas.
Para esto podemos usar la clase Scanner o la clase BufferedReader.
Yo prefiero esta última.
Para crear un BufferedReader, necesitamos pasarle por constructor un objeto FileReader, quién a su vez necesita un objeto File cuya ruta apunte al fichero que queremos leer. También podemos pasarle directamente un String con esa ruta.

Una vez tenemos el BufferedReader, con el método newLine() le pedimos que nos lea la primera línea y la guardamos en un String
Y cada vez que invoquemos este método, nos devolverá la línea siguiente.

Así que para leer todas las líneas, usamos un bucle que se repetirá mientras que el String que nos devuelva el método newLine(), sea distinto de null, lo cuál significa que ya no quedan líneas por leer.

Cada línea obtenida, la mostramos en pantalla.

Importante que para este proceso, el compilador Java nos OBLIGA a usar try catch para capturar posibles excepciones como que el fichero que queremos leer no existe.
O que tal vez sí existe, pero no se puede leer porque está dañado o hay restricciones de acceso por permisos de usuario.
Java considera que trabajar con ficheros de datos es un tema sensible y no permite dejar sin controlar excepciones que pudieran originar pérdida de datos.

public class LeerFichero {

public static void main(String[] args) {
//Ruta donde encontrar el fichero de texto
String rutaTXT = "D:\\Programacion\\FicherosTXT\\restaurante.txt";

try {
//Configuramos lector de ficheros
BufferedReader lector = new BufferedReader(new FileReader(rutaTXT));
//Leemos línea
String linea = lector.readLine();
//Mientras la linea sea distinto de null, es decir, hay líneas para leer
while (linea != null) {
//Mostramos línea en pantalla
System.out.println(linea);
//Leemos siguiente línea, si no es null, se repetirá el bucle
linea = lector.readLine();
}
//Lectura terminada, cerramos lector
lector.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: " + rutaTXT);
} catch (IOException e) {
System.out.println("No se puede acceder a " + rutaTXT);
}

}
}
Con este simple código, en pantalla podremos ver todas las líneas del fichero:

Restaurant,Address,City,State,Zipcode
Vietnam Restaurant,1615 Commerce Parkway,Bloomington,IL,61704
Chops and Ribs,71 S. Wacker Drive Chicago,Chicago,IL,60606
Molinarinari,"1701 River Drive, Suite 306",Moline,IL,61265
Siam Cusine,"3201 W White Oaks Drive, Suite 204",Springfield,IL,62704
Mary's Diner,"4916 S Technopolis Drive, Building 2",Sioux Falls,SD,57106
Bistro Bob,625 32nd Avenue SW,Cedar Rapids,IA,52404
Wiener House,"400 Locust Street, Suite 420 4th Floor",Des Moines,IA,50309
Irifune Place,"Federal Trust Building, 134 South 13th Street, 10th Floor, Suite 1000",Lincoln,NE,68508
Estradanas,"1111 N 102nd Court, Suite 231",Omaha,NE,68114
Fargo,"3310 Fiectner Drive, Suite 108",Fargo,ND,58103
Fangs,650 Third Avenue South,Minneapolis,MN,55402
China Palace,3605 Hwy 52 North,Rochester,MN,55901
Big Daddy Barbeque,"1005 Ikon Drive, Suite G,",Jefferson City,MO,65109
Wolfs,"3315 E. Ridgeview Street, Suite 4000",Springfield,MO,65804
A Cut Above,30501 Agoura Road,Agoura Hills,CA,91301
Ranch House,650 Harry Road,San Jose,CA,95120
Burgers and Fries,5100 California Avenue,Bakersfield,CA,93309
Hofbrau Deluxe,600 Anton Blvd,Costa Mesa,CA,92626
Jean's Place,100 N. Sepulveda Blvd,El Segundo,CA,90245
Nattos,1001 E. Hillsdale Blvd,Foster City,CA,94404

Bien.
Vemos que cada línea contiene 5 datos (restaurante, dirección, ciudad, estado, código postal).
Estos datos están separados unos de otros mediante "comas", así que podemos obtener esos datos por separado "cortando" el String allá donde exista una coma.

La clase String ofrece el método split() que nos ayuda a hacer esto y nos retorna los "trocitos" (los datos) separados, pero agrupados en un array.

public class LeerFichero {

public static void main(String[] args) {
//Ruta donde encontrar el fichero de texto
String rutaTXT = "D:\\Programacion\\FicherosTXT\\restaurante.txt";

try {
//Configuramos lector de ficheros
BufferedReader lector = new BufferedReader(new FileReader(rutaTXT));
//Leemos línea
String linea = lector.readLine();
//Mientras la linea sea distinto de null, es decir, hay líneas para leer
while (linea != null) {
//Separamos los datos en un array
String[] datos = linea.split(",");
//Mostramos el array de datos para comprobar su correcta separacion
System.out.println(Arrays.toString(datos));
//Leemos siguiente línea, si no es null, se repetirá el bucle
linea = lector.readLine();
}
//Lectura terminada, cerramos lector
lector.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: " + rutaTXT);
} catch (IOException e) {
System.out.println("No se puede acceder a " + rutaTXT);
}

}
}
Si mostramos en pantalla el contenido de los arrays que split nos va proporcionando, veremos que tenemos los mismos datos que veíamos en las líneas, pero esta vez contenidos en arrays y como elementos separados.

[Restaurant, Address, City, State, Zipcode]
[Vietnam Restaurant, 1615 Commerce Parkway, Bloomington, IL, 61704]
[Chops and Ribs, 71 S. Wacker Drive Chicago, Chicago, IL, 60606]
[Molinarinari, "1701 River Drive,  Suite 306", Moline, IL, 61265]
[Siam Cusine, "3201 W White Oaks Drive,  Suite 204", Springfield, IL, 62704]
[Mary's Diner, "4916 S Technopolis Drive,  Building 2", Sioux Falls, SD, 57106]
[Bistro Bob, 625 32nd Avenue SW, Cedar Rapids, IA, 52404]
[Wiener House, "400 Locust Street,  Suite 420 4th Floor", Des Moines, IA, 50309]
[Irifune Place, "Federal Trust Building,  134 South 13th Street,  10th Floor,  Suite 1000", Lincoln, NE, 68508]
[Estradanas, "1111 N 102nd Court,  Suite 231", Omaha, NE, 68114]
[Fargo, "3310 Fiectner Drive,  Suite 108", Fargo, ND, 58103]
[Fangs, 650 Third Avenue South, Minneapolis, MN, 55402]
[China Palace, 3605 Hwy 52 North, Rochester, MN, 55901]
[Big Daddy Barbeque, "1005 Ikon Drive,  Suite G, ", Jefferson City, MO, 65109]
[Wolfs, "3315 E. Ridgeview Street,  Suite 4000", Springfield, MO, 65804]
[A Cut Above, 30501 Agoura Road, Agoura Hills, CA, 91301]
[Ranch House, 650 Harry Road, San Jose, CA, 95120]
[Burgers and Fries, 5100 California Avenue, Bakersfield, CA, 93309]
[Hofbrau Deluxe, 600 Anton Blvd, Costa Mesa, CA, 92626]
[Jean's Place, 100 N. Sepulveda Blvd, El Segundo, CA, 90245]
[Nattos, 1001 E. Hillsdale Blvd, Foster City, CA, 94404]

Aquí cabe destacar una cosa. Algunas líneas tienen direcciones compuestas que incorporan una coma, por ejemplo: "3315 E. Ridgeview Street,  Suite 4000"
En estos casos, en lugar de obtener un array de 5 elementos, nos dará un array de 6 elementos, porque esa address compuesta también será "troceada" por el método split().

Para este ejercicio, nos da igual que esto ocurra, porque solo nos va a interesa el último elemento, el zipcode.
Pero si nos pidieran trabajar también con el dato address, habría que tener en cuenta que en ocasiones este dato lo íbamos a obtener separado en dos elementos.

Bueno, dicho esto, el ejercicio nos pide mostrar los datos únicamente de los restaurantes cuyo zipcode comience por 6.
Puesto que ya tenemos los datos separados, para hacer esto nos basta con preguntar si el último elemento de cada array, que es donde se encuentra el código postal, comienza por 6.
Y si esto se cumple, pues mostramos los datos en pantalla.

public class LeerFichero {

public static void main(String[] args) {
//Ruta donde encontrar el fichero de texto
String rutaTXT = "D:\\Programacion\\FicherosTXT\\restaurante.txt";

try {
//Configuramos lector de ficheros
BufferedReader lector = new BufferedReader(new FileReader(rutaTXT));
//Leemos línea
String linea = lector.readLine();
//Mientras la linea sea distinto de null, es decir, hay líneas para leer
while (linea != null) {
//Separamos los datos en un array
String[] datos = linea.split(",");

//Preguntamos si último elemento, el zipcode comienza por 6
if (datos[datos.length - 1].startsWith("6"))
System.out.println(Arrays.toString(datos)); //Mostramos restaurante

//Leemos siguiente línea, si no es null, se repetirá el bucle
linea = lector.readLine();
}
//Lectura terminada, cerramos lector
lector.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: " + rutaTXT);
} catch (IOException e) {
System.out.println("No se puede acceder a " + rutaTXT);
}

}
}
De este modo, ahora en pantalla solo vemos los restaurantes que comienzan por 6:

[Vietnam Restaurant, 1615 Commerce Parkway, Bloomington, IL, 61704]
[Chops and Ribs, 71 S. Wacker Drive Chicago, Chicago, IL, 60606]
[Molinarinari, "1701 River Drive,  Suite 306", Moline, IL, 61265]
[Siam Cusine, "3201 W White Oaks Drive,  Suite 204", Springfield, IL, 62704]
[Irifune Place, "Federal Trust Building,  134 South 13th Street,  10th Floor,  Suite 1000", Lincoln, NE, 68508]
[Estradanas, "1111 N 102nd Court,  Suite 231", Omaha, NE, 68114]
[Big Daddy Barbeque, "1005 Ikon Drive,  Suite G, ", Jefferson City, MO, 65109]
[Wolfs, "3315 E. Ridgeview Street,  Suite 4000", Springfield, MO, 65804]

Hola.
¿En qué tienes dificultades?
No podemos ayudarte si no nos dices que necesitas saber.

Comienza tú un código y cuando te atasques te ayudamos a completarlo.

Intenta hacerlo paso a paso, no pensando en cómo solucionar el TODO, si no buscando objetivos menores.
Si te han pedido este ejercicio, es que como mínimo te han explicado como leer ficheros de texto.
Pues comienza haciendo un programa que lea ese fichero de texto y muestre sus líneas en pantalla.

Cuando tengas eso, modifícalo para que en lugar de mostrar las líneas, separes los datos que contiene cada línea delimitados por las comas.
La clase String ofrece un método llamado split() que trocea una cadena de texto "cortando" donde encuentre el carácter que tu le indiques y te retorna los "trozos" en un array de String.
Así que puedes hacer algo como:
String[] datos = linea.split(",");Así cada línea leída, puedes "trocearla" y consultar esos datos por separado.
Inténtalo y haz que solo se muestre el código postal de cada línea.

Cuando tengas eso, haz que solo se muestren los códigos postales que empiecen por 6.

Y teniendo eso, ya solo es modificarlo un poco para que muestre todos los datos, de las líneas cuyo código postal comience por 6.


Insisto, inténtalo tú. Llega hasta donde puedas, y a partir de ahí te ayudamos.

El tema ha sido movido a Aprender a programar desde cero.

https://aprenderaprogramar.com/foros/index.php?topic=7871.0

No se si responderá porque fue alguien que publicó sin registrarse en el foro.

Pero sí, al decir subprogramas, se refiere a las funciones.
También se les llama (o antaño se les solía llamar..) subrutinas.

Funciones y procedimientos son como pequeños programas, dentro del programa principal, por eso también reciben nombres como los que hemos mencionado.

Si ejecutas tu código, verás que no funciona.
Al margen de unas pequeñas correciones necesarias en la sintaxis, cuando el programa inicia solo conseguimos un bucle infinito.
El for ni siquiera funciona, porque usas la variable n como límite, la cuál no tiene ningún valor inicial, por lo que toma valor 0 así que el for no llega a activarse.

Pero es que de todos modos no necesitas ningún bucle for.

Solo necesitas un bucle do while, que es el que se te repite infinitamente por la condición que has puesto:
while (opcion[0])
¿Qué significa esa condición?
Las condiciones de los bucles han de ser expresiones que den como resultado true o false.
opcion[0] es simplemente el primer char que contiene el array llamado opcion,

Eso no te sirve como condición del while. Y no necesitas ningún array de char para nada.


Fíjate en la condición que puse yo en mi bucle while:
while (calificacion != 0);
"Mientras calificación sea distinto de 0".

¿Por qué esa condición?
Porque eso es lo que pide el enunciado:

programa que lea calificaciones del 5 al 10, hasta que se le capture un 0

Es decir, leemos calificaciones (en una variable llamada calificación) y MIENTRAS lo leído sea distinto de 0, seguiremos pidiendo calificaciones.

Tampoco necesitas ninguna función para calcular el promedio.
Quizás me equivoco, pero parece que hayas encontrado el código de esa función por algún sitio y lo has copiado con la esperanza de que te sirva.

No uses nunca código que no entiendas. Porque viendo el código de esa función es evidente que no es aplicable para este ejercicio.

Mira, añado al código que puse las líneas necesarias para calcular el promedio.
¡¡Solo he necesitado añadir 3 líneas!! (Las resalto en color azul)

#include <iostream>

using namespace std;

int main()
{
    int calificacion = 0; //Para leer calificaciones por teclado
    int contador = 0; //Para contar las calificaciones introducidas
    int suma = 0; //Aquí sumamos calificaciones para luego calcular promedio.

    do {
        cout << "\nIntroduzca calificación: ";
        cin >> calificacion;

        if (calificacion != 0) {
            if (calificacion >= 5 && calificacion <= 10) {
                //Calificación es válida
                contador++; //Contamos la calificación introducida
                suma = suma + calificacion; //Sumamos la calificación
            }
            else
                cout << "Calificación no es válida, solo valores entre 5 y 10\n";
        }
        else //Ha introducido 0, fin del bucle
            cout << "\nFin de lectura de calificaciones\n";
    } while (calificacion != 0);

    //Resultados
    cout << "\nCalificaciones introducidas: " << contador;
    cout << "\nNota promedio: " << (suma/(float)contador);

    cout << "\n\t\tFIN DE PROGRAMA";
}

Puedes verlo y ejecutarlo desde este enlace:
https://www.online-ide.com/9nyPO5lxRG

Fíjate que no ha sido necesario usar ningún array (por ahora), ni ninguna función.

Analiza el código que he compartido. Asegúrate de que entiendes cada línea y que puedes seguir el flujo que sigue el programa.
Te dejo un diagrama de flujo (no se me dan muy bien) para que se entienda mejor la lógica del programa.

Cuando tengas todo claro, podemos pasar a ver como informar en la salida de resultados cuál ha sido la calificación MAYOR introducida.