settings.java

一个关于沉船的J2ME小游戏

//
// Copyright 2002 Nokia Corporation
//
// THIS SOURCE CODE IS PROVIDED 'AS IS', WITH NO WARRANTIES WHATSOEVER,
// EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF MERCHANTABILITY, FITNESS
// FOR ANY PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE
// OR TRADE PRACTICE, RELATING TO THE SOURCE CODE OR ANY WARRANTY OTHERWISE
// ARISING OUT OF ANY PROPOSAL, SPECIFICATION, OR SAMPLE AND WITH NO
// OBLIGATION OF NOKIA TO PROVIDE THE LICENSEE WITH ANY MAINTENANCE OR
// SUPPORT. FURTHERMORE, NOKIA MAKES NO WARRANTY THAT EXERCISE OF THE
// RIGHTS GRANTED HEREUNDER DOES NOT INFRINGE OR MAY NOT CAUSE INFRINGEMENT
// OF ANY PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OWNED OR CONTROLLED
// BY THIRD PARTIES
//
// Furthermore, information provided in this source code is preliminary,
// and may be changed substantially prior to final release. Nokia Mobile
// Phones Ltd. retains the right to make changes to this source code at
// any time, without notice. This source code is provided for informational
// purposes only.
//
// Third-party brands and names are the property of their respective
// owners. Java(TM) and J2ME(TM) are registered trademarks of
// Sun Microsystems Inc.
//
// A non-exclusive, non-transferable, worldwide, limited license is hereby
// granted to the Licensee to download, print, reproduce and modify the
// source code. The licensee has the right to market, sell, distribute and
// make available the source code in original or modified form only when
// incorporated into the programs developed by the Licensee. No other
// license, express or implied, by estoppel or otherwise, to any other
// intellectual property rights is granted herein.
//


import java.util.*;
import javax.microedition.rms.*;
import java.io.DataOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;


// The 'Game Settings' are kept in the persistent record store,
// so they are remembered when the user exits the game
// and restarts it at a later time.

class Settings
{
    private static short ix = 1;
    final static short USE_VIBRATION 	= ix++;
    final static short USE_SOUND 		= ix++;
    final static short GM_CONTINUE 		= ix++;
    final static short GM_MAIN_DATA		= ix++;
    final static short GM_PLANE_DATA	= ix++;
    final static short GM_BOMB_DATA		= ix++;
    final static short GM_BUILD_DATA	= ix++;

    private final static int TRUE = 0; // bytes[TRUE] = 'T'
    private final static int FALSE = 1; // bytes[FALSE] = 'F'
    private final static byte[] bytes = { 'T', 'F' };

    private static RecordStore rs = null;


    private Settings()
    {
        // no one else may instantiate us
    }


    private static void openRecordStore()
        throws RecordStoreException
    {
        if (rs == null)
        {
          rs = RecordStore.openRecordStore("BLITZED", true);
        }

        if (rs.getNumRecords() == 0)
        {
		// Create some initial data for GM_MAIN_DATA
		byte[] b;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		DataOutputStream outputStream = new DataOutputStream(baos);
		try
		{
			outputStream.writeInt(1);	// HiLevel
			outputStream.writeInt(800);	// HiScore
			outputStream.writeInt(1);	// Game status
			outputStream.writeInt(0);	// Game score
			outputStream.writeInt(1);	// Game Level
			outputStream.writeInt(0);	// Game bonus
		}
		catch (IOException ioe)
		{
			throw new IllegalArgumentException("Error in openRecordStore(1)");
		}
		b = baos.toByteArray();
		try
		{
	            // save a default value for USE_VIBRATION in the record store
      	      rs.addRecord(bytes, TRUE, 1);
            	// save a default value for USE_SOUND in the record store
	            rs.addRecord(bytes, TRUE, 1);
			// save a default value for GM_CONTINUE in the record store
            	rs.addRecord(bytes, FALSE, 1);
			// save a default value for GM_MAIN_DATA in the record store
	            rs.addRecord(b, 0, b.length);
			// save a default value for GM_PLANE_DATA in the record store
	            rs.addRecord(bytes, TRUE, 1);
			// save a default value for GM_BOMB_DATA in the record store
            	rs.addRecord(bytes, TRUE, 1);
			// save a default value for GM_BUILD_DATA in the record store
      	      rs.addRecord(bytes, TRUE, 1);
			
		}
	 	catch (RecordStoreException rse)
	  	{
			throw new IllegalArgumentException("Procedure Settings.openRecordStore has failed: ");
		}
        }
    }


    private static void closeRecordStore()
        throws RecordStoreException
    {
        if (rs != null)
        {
            rs.closeRecordStore();
            rs = null;
        }
    }


    static boolean getUseVibration()
    {
        try
        {
            // read the saved value from the record store
            boolean bool = getValue(Settings.USE_VIBRATION);
            return bool;
        }
        catch (Exception e)
        {
            return false;
        }
    }


    static boolean getUseSound()
    {
        try
        {
            // read the saved value from the record store
            boolean bool = getValue(Settings.USE_SOUND);
            return bool;
        }
        catch (Exception e)
        {
            return false;
        }
    }


    static void setUseVibration(boolean bool)
    {
        try
        {
            // save the value persistently in the record store
            setValue(Settings.USE_VIBRATION, bool);
        }
        catch (Exception e)
        {
            // We can not do anything to recover from this error,
            // let the game proceed without using saved settings.
        }
    }


    static void setUseSound(boolean bool)
    {
        try
        {
            // save the value persistently in the record store
            setValue(Settings.USE_SOUND, bool);
        }
        catch (Exception e)
        {
            // We can not do anything to recover from this error,
            // let the game proceed without using saved settings.
        }
    }

    static void setContinue(boolean bool)
    {
        try
        {
            // save the value persistently in the record store
            setValue(Settings.GM_CONTINUE, bool);
        }
        catch (Exception e)
        {
            // We can not do anything to recover from this error,
            // let the game proceed without using saved settings.
        }
    }
    static boolean getContinue()
    {
        try
        {
            // read the saved value from the record store
            boolean bool = getValue(Settings.GM_CONTINUE);
            return bool;
        }
        catch (Exception e)
        {
            return false;
        }
    }

    private static void setValue(int id, boolean bool)
        throws RecordStoreException
    {
        openRecordStore();

        if ((id != USE_VIBRATION) && (id != USE_SOUND) && (id != GM_CONTINUE))
        {
            throw new IllegalArgumentException(
                "Settings.set - invalid id: " + id);
        }
        else
        {
            if (bool)
            {
                rs.setRecord(id, bytes, TRUE, 1);
            }
            else
            {
                rs.setRecord(id, bytes, FALSE, 1);
            }
        }

        closeRecordStore();
    }


    private static boolean getValue(int id)
        throws RecordStoreException
    {
        openRecordStore();

        boolean bool = false; // default value

        if ((id != USE_VIBRATION) && (id != USE_SOUND) && (id != GM_CONTINUE))
        {
            closeRecordStore();
            throw new IllegalArgumentException(
                "Settings.get - invalid id: " + id);
        }
        else
        {
            byte[] barray = rs.getRecord(id);
            if ((barray != null) && (barray.length == 1))
            {
                bool = (barray[0] == bytes[TRUE]);
            }
        }

        closeRecordStore();

        return bool;
    }


    public static void setValue(int id, ByteArrayOutputStream baos)
        throws RecordStoreException
    {
        openRecordStore();

	  byte[] b = baos.toByteArray();
	  try
	  {
		rs.setRecord(id, b, 0, b.length);
        }
 	  catch (RecordStoreException rse)
	  {
		throw new IllegalArgumentException("Procedure Settings.setValue has failed: ");
	  }
        closeRecordStore();
    }

    public static ByteArrayInputStream getArrayValue(int id)
        throws RecordStoreException
    {

        openRecordStore();
	  byte[] b = rs.getRecord(id);
        closeRecordStore();
	  ByteArrayInputStream bais = new ByteArrayInputStream(b);

        return bais;
    }

}