Thread: beginner w/ text based RPG

Just for fun, I played around with creating a text choosing thingy, with more or less success.

Here is what I made, it extends JScrollPane and accepts a Vector<String> as the text choices. I tried to use a JTextArea as the Component to allow line wrapping, but I haven't gotten that to work. If you figure it out, let me know. The code will have to be worked over considerably to be useful for your implementation, but the framework is there.

import javax.swing.JScrollPane;
import javax.swing.JList;
import java.util.Vector;
import java.awt.Dimension;
import javax.swing.JTextArea;
import javax.swing.DefaultListCellRenderer;
import java.awt.Component;
import java.awt.Color;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
 
public class TextChooser extends JScrollPane
{
	//Create JList to Hold List of Text
	JList textList;
 
	//Vector for JList
	Vector<JTextArea> text;
 
    public TextChooser(Vector<String> textChoices)
    {
    	//Call to Super Constructor
    	super(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
		//Initalize Vector
    	text = new Vector<JTextArea>();
    	//Add Each Text sent to constructor as a JTextArea
    	for(int i=0;i<textChoices.size();i++)
    	{
    		//Create temporary JTextArea
    		JTextArea temp = new JTextArea(textChoices.get(i));
    		//Wrap Lines
    		temp.setLineWrap(true);
    		//Wrap Words
    		temp.setWrapStyleWord(true);
    		//Add temporary JTextArea to JList's data vector
    		text.add(temp);
    	}
		//Initalize JList
    	textList = new JList(text);
    	//Add JList's Cell renderer
    	textList.setCellRenderer(new DefaultListCellRenderer(){
    		public Component getListCellRendererComponent(JList list,Object value,int index,boolean isSelected,boolean cellHasFocus)
    		{
    			setText(((JTextArea)value).getText());
    			if(isSelected)
    			{
    				setBackground(Color.BLUE);
    				setForeground(Color.WHITE);
    			}
    			else
    			{
    				setBackground(Color.white);
    				setForeground(Color.black);
    			}
    			//return (JTextArea)value;
				return this;
    		}
    	});
    	//Add JList's Selection Listener
    	textList.addListSelectionListener(new ListSelectionListener(){
    		public void valueChanged(ListSelectionEvent e)
    		{
    			if(!e.getValueIsAdjusting())
    				System.out.println(textList.getSelectedValue());
    		}
    	});
		//Set Size of JScrollPane
    	super.setPreferredSize(new Dimension(210,60));
		//Add textList to JScrollPane
    	setViewportView(textList);
    }
 
	//Method to send the TextChooser a new Vector of Text Options
    public void setText(Vector<String> in)
    {
    	//Reinitalize text Vector
    	text = new Vector<JTextArea>();
    	//Add each String as JTextArea
    	for(int i=0;i<in.size();i++)
    	{
    		JTextArea temp = new JTextArea(in.get(i));
    		temp.setLineWrap(true);
    		temp.setWrapStyleWord(true);
    		text.add(temp);
    	}
    	//Set JList's new Data Vector
    	textList.setListData(text);
    }
}

As far as having a Backpack, you can create a Backpack Object that extends a DataStructure (such as Vector) and has a Max Weight and Current Weight and create an Item Object that holds a Name and Weight. Then you just change the DataStructure's add method to restrict based on weight.

Here is the code I threw together in the past few minutes that does as I said:
Backpack:

import java.util.Vector;
 
public class Backpack extends Vector<Item>
{
	int maxWeight;
	int currentWeight;
 
    public Backpack(int mw)
    {
		super();
		maxWeight = mw;
		currentWeight = 0;
    }
 
	public boolean add(Item item)
	{
		if(item.weight+currentWeight>maxWeight)
			return false;
		super.add(item);
		currentWeight+=item.weight;
		return true;
	}
}

Item:

public class Item
{
	String name;
	int weight;
 
    public Item(String n,int w)
    {
    	name = n;
    	weight = w;
    }
 
    public String toString()
    {
    	return name;
    }
}

You can figure out a way to show the Backpack Graphically and you will be good.

Ok, well the question that needs to be ask is: where will the jpg files be when the project is finished? The reason I ask is because if you are executing the program from a jar file and the jpg files are packaged in the jar file with the executing class, you must use Buffered Streams instead of the standard File IO in order to read the jpg files. This is a problem that you will most likely not run into while building your project, but you will run into after it has been packaged.

The other question that needs to be asked is how you want to present the jpgs. You can put images on a ton of components, but some require you to read the images differently than others.

Here are some examples of a few standard swing elements with images. Have a look at them and decide what the direction you want to go in is. Once you have a plan, tell us what it is and I will try to help you out better than those tutorials will.
JLabels
JButtons
Text Panels
Paint

It is a good idea to plan from the start. The reason is because, depending on how you make your design, it may be very difficult to add a few pictures at the end.

There are a few things to consider. Mainly, if done correctly, you can deal with any image related issues at runtime. This will require carefully handling possible errors that may occur from failing to read the images and preventing those errors from crashing your program.

Basically, let's imagine you have your program. While developing your program, you access the images using standard File IO and your images are inside the project's root folder (thus no compile or runtime errors will occur while developing). When you package your program, those images will probably be inside the .jar your program is executed from. The problem is that those images are effectively in a .zip folder and cannot be accessed with standard File IO. If this executable jar is located in the same folder as your images, the program will not have an issue when you attempt to run it. If, however, the program is located somewhere other than where your images are or if your images are moved somewhere else, suddenly you will be getting IOExceptions thrown since the images cannot be found. On the flip side, if you intend on having the images inside your executing jar from the beginning, you can preempt the problems and use a Buffered Stream to the location of the executing .class. That means that when you are developing your program, no errors will occur, and when you package your program with the images, no errors will occur (unless something happens that I cannot predict). If that is the route you want to go, I can provide you with some sample code to help you out. It is actually very simple to do.

The same goes for any file reading. ALL files, whether images or text files, that will be packaged with the project must be read using Buffered Streams or the program will have a laundry list of potential issues when packaged. It is an unassuming issue that can cause unimaginable amounts of frustration since you can only debug it after packaging.