package utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;

import p.Resettable;
import w.InputStreamSugar;

/**
 * Some utilities that emulate C stlib methods or provide convenient functions
 * to do repetitive system and memory related stuff.
 * 
 * @author Maes
 */

public final class C2JUtils {

    static public final char[] strcpy(char[] s1, final char[] s2) {
        for (int i = 0; i < Math.min(s1.length, s2.length); i++) {
            s1[i] = s2[i];
        }
        return s1;
    }

    static public final char[] strcpy(char[] s1, final char[] s2, int off, int len) {
        for (int i = 0; i < len; i++) {
            s1[i] = s2[i + off];
        }
        return s1;
    }

    static public final char[] strcpy(char[] s1, final char[] s2, int off) {
        for (int i = 0; i < Math.min(s1.length, s2.length - off); i++) {
            s1[i] = s2[i + off];
        }
        return s1;
    }

    static public final char[] strcpy(char[] s1, String s2) {
        for (int i = 0; i < Math.min(s1.length, s2.length()); i++) {
            s1[i] = s2.charAt(i);
        }
        return s1;
    }

    
    /** Return a byte[] array from the string's chars,
     *  ANDed to the lowest 8 bits.
     * 
     * @param str
     * @return
     */
    public static final byte[] toByteArray(String str) {
        byte[] retour = new byte[str.length()];
        for (int i = 0; i < str.length(); i++) {
            retour[i] = (byte) (str.charAt(i) & 0xFF);
        }
        return retour;
    }

    /**
     * Finds index of first element of array matching key. Useful whenever an
     * "indexOf" property is required or you encounter the C-ism [pointer-
     * array_base] used to find array indices in O(1) time. However, since this
     * is just a dumb unsorted search, running time is O(n), so use this method
     * only sparingly and in scenarios where it won't occur very frequently
     * -once per level is probably OK-, but watch out for nested loops, and
     * cache the result whenever possible. Consider adding an index or ID type
     * of field to the searched type if you require to use this property too
     * often.
     * 
     * @param array
     * @param key
     * @return
     */

    public static int indexOf(Object[] array, Object key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return i;
            }
        }

        return -1;
    }

    /**
     * Emulates C-style "string comparison". "Strings" are considered
     * null-terminated, and comparison is performed only up to the smaller of
     * the two.
     * 
     * @param s1
     * @param s2
     * @return
     */

    static public final boolean strcmp(char[] s1, final char[] s2) {
        boolean match = true;
        for (int i = 0; i < Math.min(s1.length, s2.length); i++) {
            if (s1[i] != s2[i]) {
                match = false;
                break;
            }
        }
        return match;
    }

    static public final boolean strcmp(char[] s1, String s2) {
        return strcmp(s1, s2.toCharArray());
    }

    /**
     * C-like string length (null termination).
     * 
     * @param s1
     * @return
     */
    static public final int strlen(char[] s1) {
        if (s1 == null)
            return 0;
        int len = 0;

        while (s1[len++] > 0) {
            if (len >= s1.length)
                break;
        }

        return len - 1;
    }

    /**
     * Return a new String based on C-like null termination.
     * 
     * @param s
     * @return
     */
    static public final String nullTerminatedString(char[] s) {
        if (s == null)
            return "";
        int len = 0;

        while (s[len++] > 0) {
            if (len >= s.length)
                break;
        }

        return new String(s, 0, len - 1);
    }

    /**
     * Automatically "initializes" arrays of objects with their default
     * constuctor. It's better than doing it by hand, IMO. If you have a better
     * way, be my guest.
     * 
     * @param os
     * @param c
     * @throws Exception
     * @throws
     */

    public static final <T> void initArrayOfObjects(T[] os, Class<T> c) {
        try {
            for (int i = 0; i < os.length; i++) {
                os[i] = c.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to allocate " + os.length
                    + " objects of class" + c.getName() + "!");
            System.exit(-1);
        }
    }

    /**
     * Automatically "initializes" arrays of objects with their default
     * constuctor. It's better than doing it by hand, IMO. If you have a better
     * way, be my guest.
     * 
     * @param os
     * @throws Exception
     * @throws
     */

    public static final <T> void initArrayOfObjects(T[] os) {
        Class<T> c = (Class<T>) os.getClass().getComponentType();
        try {
            for (int i = 0; i < os.length; i++) {
                os[i] = (T) c.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to allocate " + os.length
                    + " objects of class " + c.getName() + "!");

            System.exit(-1);
        }
    }

    /**
     * Uses reflection to automatically create and initialize an array of
     * objects of the specified class. Does not require casting on "reception".
     * 
     * @param <T>
     * @param c
     * @param num
     * @return
     * @return
     */

    public static final <T> T[] createArrayOfObjects(Class<T> c, int num) {
        T[] os = null;

        os=getNewArray(c,num);

        try {
            for (int i = 0; i < os.length; i++) {
                os[i] = (T) c.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to instantiate " + os.length
                    + " objects of class " + c.getName() + "!");
            System.exit(-1);
        }

        return os;
    }
    
    /**
     * Uses reflection to automatically create and initialize an array of
     * objects of the specified class. Does not require casting on "reception".
     * Requires an instance of the desired class. This allows getting around
     * determining the runtime type of parametrized types.
     * 
     * 
     * @param <T>
     * @param instance An instance of a particular class. 
     * @param num
     * @return
     * @return
     */

    @SuppressWarnings("unchecked")
    public static final <T> T[] createArrayOfObjects(T instance, int num) {
        T[] os = null;
        
        Class<T> c=(Class<T>) instance.getClass();

        os=getNewArray(c,num);

        try {
            for (int i = 0; i < os.length; i++) {
                os[i] = (T) c.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to instantiate " + os.length
                    + " objects of class " + c.getName() + "!");
            System.exit(-1);
        }

        return os;
    }


    /**
     * Automatically "initializes" arrays of objects with their default
     * constuctor. It's better than doing it by hand, IMO. If you have a better
     * way, be my guest.
     * 
     * @param os
     * @param startpos inclusive
     * @param endpos non-inclusive
     * @throws Exception
     * @throws
     */

    public static final<T> void initArrayOfObjects(T[] os, int startpos,
            int endpos) {
        @SuppressWarnings("unchecked")
		Class<T> c = (Class<T>) os.getClass().getComponentType();
        try {
            for (int i = startpos; i < endpos; i++) {
                os[i] = c.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to allocate " + os.length
                    + " objects of class " + c.getName() + "!");

            System.exit(-1);
        }
    }

    /** This method gets eventually inlined, becoming very fast */

    public static final int toUnsignedByte(byte b) {
        return (0x000000FF & b);
    }

    // Optimized array-fill methods designed to operate like C's memset.

    public static final void memset(boolean[] array, boolean value, int len) {
        if (len > 0)
            array[0] = value;
        for (int i = 1; i < len; i += i) {
            System.arraycopy(array, 0, array, i, ((len - i) < i) ? (len - i)
                    : i);
        }
    }

    public static final void memset(char[] array, char value, int len) {
        if (len > 0)
            array[0] = value;
        for (int i = 1; i < len; i += i) {
            System.arraycopy(array, 0, array, i, ((len - i) < i) ? (len - i)
                    : i);
        }
    }

    public static final void memset(int[] array, int value, int len) {
        if (len > 0)
            array[0] = value;
        for (int i = 1; i < len; i += i) {
            System.arraycopy(array, 0, array, i, ((len - i) < i) ? (len - i)
                    : i);
        }
    }
    
    public static final void memset(short[] array, short value, int len) {
        if (len > 0)
            array[0] = value;
        for (int i = 1; i < len; i += i) {
            System.arraycopy(array, 0, array, i, ((len - i) < i) ? (len - i)
                    : i);
        }
    }

    public static final long unsigned(int num) {
        return 0xFFFFFFFFL & num;
    }

    public static final char unsigned(short num) {
        return (char) num;
    }

    /**
     * Convenient alias for System.arraycopy(src, 0, dest, 0, length);
     * 
     * @param dest
     * @param src
     * @param length
     */
    public static final void memcpy(Object dest, Object src, int length) {
        System.arraycopy(src, 0, dest, 0, length);
    }

    public static final boolean testReadAccess(String URI) {
    	InputStream in=null;
    	
        // This is bullshit.
        if (URI == null)
            return false;
        if (URI.length() == 0)
            return false;

        try {
            in=new FileInputStream(URI);
        } catch (Exception e) {
            // Not a file...
            URL u;
			try {
				u = new URL(URI);
			} catch (MalformedURLException e1) {
				return false;
			}
            try {
				in=u.openConnection().getInputStream();
			} catch (IOException e1) {
				return false;
			}

        }
        
        if (in!=null) {
        	try {
				in.close();
			} catch (IOException e) {

			}
        	return true;
        }
        // All is well. Go on...
        return true;

    }
    
    public static final boolean testWriteAccess(String URI) {
    	OutputStream out=null;
    	
        // This is bullshit.
        if (URI == null)
            return false;
        if (URI.length() == 0)
            return false;

        try {
            out=new FileOutputStream(URI);
        } catch (Exception e) {
            // Not a file...
            URL u;
			try {
				u = new URL(URI);
			} catch (MalformedURLException e1) {
				return false;
			}
            try {
				out=u.openConnection().getOutputStream();
			} catch (IOException e1) {
				return false;
			}

        }

        if (out!=null) {
        	try {
				out.close();
			} catch (IOException e) {

			}
        	return true;
        }
        // All is well. Go on...
        return true;
    }

    /**
     * Returns true if flags are included in arg. Synonymous with (flags &
     * arg)!=0
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final boolean flags(int flags, int arg) {
        return ((flags & arg) != 0);
    }
    
    public static final boolean flags(long flags, long arg) {
        return ((flags & arg) != 0);
    }

    /**
     * Returns 1 for true and 0 for false. Useful, given the amount of
     * "arithmetic" logical functions in legacy code. Synonymous with
     * (expr?1:0);
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final int eval(boolean expr) {
        return (expr ? 1 : 0);
    }

    /**
     * Returns 1 for non-null and 0 for null objects. Useful, given the amount
     * of "existential" logical functions in legacy code. Synonymous with
     * (expr!=null);
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final boolean eval(Object expr) {
        return (expr != null);
    }

    /**
     * Returns true for expr!=0, false otherwise.
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final boolean eval(int expr) {
        return expr != 0;
    }

    /**
     * Returns true for expr!=0, false otherwise.
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final boolean eval(long expr) {
        return expr != 0;
    }

    public static final void resetAll(Resettable[] r) {
        for (int i = 0; i < r.length; i++) {
            r[i].reset();
        }
    }

    /**
     * Useful for unquoting strings, since StringTokenizer won't do it for us.
     * Returns null upon any failure.
     * 
     * @param s
     * @param c
     * @return
     */

    public static final String unquote(String s, char c) {

        int firstq = s.indexOf(c);
        int lastq = s.lastIndexOf(c);
        // Indexes valid?
        if (isQuoted(s,c))
                return s.substring(firstq + 1, lastq);
        
        return null;
    }

    public static final boolean isQuoted(String s, char c) {

        int q1 = s.indexOf(c);
        int q2 = s.lastIndexOf(c);
        char c1,c2;
        
        // Indexes valid?
        if (q1 != -1 && q2 != -1) {
            if (q1 < q2) {
                c1=s.charAt(q1);
                c2=s.charAt(q2);
                return (c1==c2);
            }
        }
        
        return false;
    }
    
    public static final String unquoteIfQuoted(String s, char c) {

        String tmp = unquote(s, c);
        if (tmp != null)
            return tmp;
        return s;
    }

    /** Return either 0 or a hashcode 
     * 
     * @param o 
     */
    public static final int pointer(Object o) {
        if (o == null)
            return 0;
        else
            return o.hashCode();
    }

 
    public static final boolean checkForExtension(String filename, String ext) {
        
        // Null filenames satisfy null extensions.
        if ((filename == null || filename.isEmpty())
                && (ext == null || ext.isEmpty()))
            return true;
        
        String separator = System.getProperty("file.separator");

        // Remove the path upto the filename.
        int lastSeparatorIndex = filename.lastIndexOf(separator);
        if (lastSeparatorIndex != -1) {
            filename = filename.substring(lastSeparatorIndex + 1);
        }

        String realext = null;

        // Get extension separator. It SHOULD be . on all platforms, right?
        int pos = filename.lastIndexOf('.');

        if (pos >= 0 && pos <= filename.length() - 2) { // Extension present
            
            // Null comparator on valid extension
            if (ext == null || ext.isEmpty()) return false;
            
            realext = filename.substring(pos + 1);
            return realext.compareToIgnoreCase(ext) == 0;
        } else // No extension, and null/empty comparator
        if (ext == null || ext.isEmpty())
            return true;

        // No extension, and non-null/nonempty comparator.
        return false;
    }    
    
    /** Return the filename without extension, and stripped
     * of the path.
     * 
     * @param s
     * @return
     */
    
    public static final String removeExtension(String s) {

        String separator = System.getProperty("file.separator");
        String filename;

        // Remove the path upto the filename.
        int lastSeparatorIndex = s.lastIndexOf(separator);
        if (lastSeparatorIndex == -1) {
            filename = s;
        } else {
            filename = s.substring(lastSeparatorIndex + 1);
        }

        // Remove the extension.
        int extensionIndex = filename.lastIndexOf(".");
        if (extensionIndex == -1)
            return filename;

        return filename.substring(0, extensionIndex);
    }

    
    /**
     * This method is supposed to return the "name" part of a filename. It was
     * intended to return length-limited (max 8 chars) strings to use as lump
     * indicators. There's normally no need to enforce this behavior, as there's
     * nothing preventing the engine from INTERNALLY using lump names with >8
     * chars. However, just to be sure...
     * 
     * @param path
     * @param limit  Set to any value >0 to enforce a length limit
     * @param whole keep extension if set to true
     * @return
     */

    public static final String extractFileBase(String path, int limit, boolean whole) {
    	
    	if (path==null) return path;
    	
        int src = path.length() - 1;

        String separator = System.getProperty("file.separator");
        src = path.lastIndexOf(separator)+1;

        if (src < 0) // No separator
            src = 0;

        int len = path.lastIndexOf('.');
        if (whole || len<0 ) len=path.length()-src; // No extension.
        else  len-= src;        

        // copy UP to the specific number of characters, or all        
        if (limit > 0) len = Math.min(limit, len);
        
        return path.substring(src, src + len);
    }

    /** Maes: File intead of "inthandle" */

    public static long filelength(File handle) {
        try {
            return handle.length();
        } catch (Exception e) {
            System.err.println("Error fstating");
            return -1;
        }

    }

	@SuppressWarnings("unchecked")
	public static final <T> T[] resize(T[] oldarray, int newsize) {
		
		if (oldarray[0]!=null) return resize(oldarray[0],oldarray,newsize); 
		
		T cls=null;
		try {
			cls = (T) oldarray.getClass().getComponentType().newInstance();
			return resize(cls,oldarray,newsize);
		} catch (Exception e) {
			System.err.println("Cannot autodetect type in resizeArray.\n");
			return null;
		}


	}
    
	/** Generic array resizing method. Calls Arrays.copyOf but then also
	 *  uses initArrayOfObject for the "abundant" elements.
	 * 
	 * @param <T>
	 * @param instance
	 * @param oldarray
	 * @param newsize
	 * @return
	 */
	
	public static final <T> T[] resize(T instance,T[] oldarray, int newsize) {
		
		//  Hmm... nope.
		if (newsize<=oldarray.length) return oldarray;
		
		// Copy old array with built-in stuff.
		T[] tmp =Arrays.copyOf(oldarray,newsize);
		
		// Init the null portions as well
		C2JUtils.initArrayOfObjects(tmp, oldarray.length,tmp.length);

		System.out.printf("Old array of type %s resized. New capacity: %d\n"
				,instance.getClass(),newsize);
		
		return tmp;

	}
	
	/** Resize an array without autoinitialization. Same as Arrays.copyOf(..), just
	 * prints a message.
	 *  
	 * @param <T>
	 * @param oldarray
	 * @param newsize
	 * @return
	 */
	
	public static final <T> T[] resizeNoAutoInit(T[] oldarray, int newsize) {
		
		// For non-autoinit types, this is enough.
		T[] tmp =Arrays.copyOf(oldarray,newsize);
		
		System.out.printf("Old array of type %s resized without auto-init. New capacity: %d\n"
				,tmp.getClass().getComponentType(),newsize);
		
		return tmp;

	}
	
	@SuppressWarnings("unchecked")
	public final static<T> T[] getNewArray(T instance,int size){
		
		T[] os=null;
		Class<T> c=(Class<T>) instance.getClass();
		
        try {
            os = (T[]) Array.newInstance(c, size);
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to allocate " + size
                    + " objects of class " + c.getName() + "!");
            System.exit(-1);
        }
        
        return os;
	}
	
	public final static<T> T[] getNewArray(int size,T instance){
		@SuppressWarnings("unchecked")
		Class<T> c=(Class<T>) instance.getClass();
		return getNewArray(c,size);
	}
	
	@SuppressWarnings("unchecked")
	public final static<T> T[] getNewArray(Class<T> c,int size){
		T[] os=null;
        try {
            os = (T[]) Array.newInstance(c, size);
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Failure to allocate " + size
                    + " objects of class " + c.getName() + "!");
            System.exit(-1);
        }
        
        return os;
	}

    /**
     * Try to guess whether a URI represents a local file, a network any of the
     * above but zipped. Returns
     * 
     * @param URI
     * @return an int with flags set according to InputStreamSugar
     */

    public static int guessResourceType(String URI) {

        int result = 0;
        InputStream in = null;

        // This is bullshit.
        if (URI == null || URI.length() == 0)
            return InputStreamSugar.BAD_URI;

        try {
            in = new FileInputStream(new File(URI));
            // It's a file
            result |= InputStreamSugar.FILE;
        } catch (Exception e) {
            // Not a file...
            URL u;
            try {
                u = new URL(URI);
            } catch (MalformedURLException e1) {
                return InputStreamSugar.BAD_URI;
            }
            try {
                in = u.openConnection().getInputStream();
                result |= InputStreamSugar.NETWORK_FILE;
            } catch (IOException e1) {
                return InputStreamSugar.BAD_URI;
            }

        }

        // Try guessing if it's a ZIP file. A bit lame, really
        // TODO: add proper validation, and maybe MIME type checking
        // for network streams, for cases that we can't really
        // tell from extension alone.

        if (checkForExtension(URI, "zip")) {
            result |= InputStreamSugar.ZIP_FILE;

        }

        try {
            in.close();
        } catch (IOException e) {

        }

        // All is well. Go on...
        return result;
    }

}

package utils;

/** Half-assed way of finding the OS we're running under, shamelessly 
 * ripped from:
 * 
 *  http://www.mkyong.com/java/how-to-detect-os-in-java-systemgetpropertyosname/
 * .
 * This is required, as some things in AWT don't work exactly consistently cross-OS
 * (AWT frame size is the first thing that goes wrong, but also mouse grabbing
 * behavior).
 * 
 * TODO: replace with Apache Commons library?
 *  
 * @author velktron
 *
 */

public class OSValidator{
 
	public static boolean isWindows(){
 
		String os = System.getProperty("os.name").toLowerCase();
		//windows
	    return (os.indexOf( "win" ) >= 0); 
 
	}
 
	public static boolean isMac(){
 
		String os = System.getProperty("os.name").toLowerCase();
		//Mac
	    return (os.indexOf( "mac" ) >= 0); 
 
	}
 
	public static boolean isUnix(){
 
		String os = System.getProperty("os.name").toLowerCase();
		//linux or unix
	    return (os.indexOf( "nix") >=0 || os.indexOf( "nux") >=0);
 
	}
	
	public static boolean isUnknown(){
		return (!isWindows() && !isUnix() && !isMac());
	}
}

package doom;

import defines.skill_t;

/** Groups functions formerly in d_game, 
 * in case you want to provide a different implementation 
 */

public interface IDoomGame {

	 void ExitLevel ();
	 void WorldDone ();

     boolean CheckDemoStatus();
     
     /** Can be called by the startup code or M_Responder.
     A normal game starts at map 1,
     but a warp test can start elsewhere */
     
     public void DeferedInitNew (skill_t skill, int episode, int map);
     
     /** Can be called by the startup code or M_Responder,
     calls P_SetupLevel or W_EnterWorld. */
   public void LoadGame (String name);

   /** Called by M_Responder. */
   public void SaveGame (int slot, String description);
   
   /** Takes a screenshot *NOW*
    * 
    */
   public void ScreenShot() ;
   
   public void StartTitle();
   
   public gameaction_t getGameAction();

   public void setGameAction(gameaction_t ga);
   
   // public void PlayerReborn(int player);
   
   void DeathMatchSpawnPlayer(int playernum);

}

package doom;

public interface NetConsts {

    public static int    NCMD_EXIT=      0x80000000;
    public static int    NCMD_RETRANSMIT     =0x40000000;
    public static int    NCMD_SETUP      =0x20000000;
    public static int   NCMD_KILL    =   0x10000000; // kill game
    public static int    NCMD_CHECKSUM   =   0x0fffffff;

    public static int  DOOMCOM_ID =     0x12345678;


    //Networking and tick handling related. Moved to DEFINES
    //protected static int    BACKUPTICS     = 12;


    // command_t
    public  static short CMD_SEND    = 1;
    public  static short CMD_GET = 2; 
    
}

package doom;

import n.DoomSystemNetworking;
import f.EndLevel;
import f.Finale;
import f.Wiper;
import hu.HU;
import i.IDiskDrawer;
import i.IDoomSystem;
import i.DoomVideoInterface;
import m.IDoomMenu;
import m.IRandom;
import m.IVariablesManager;
import p.AbstractLevelLoader;
import p.Actions;
import rr.ISpriteManager;
import rr.Renderer;
import rr.TextureManager;
import s.IDoomSound;
import s.IMusic;
import s.ISoundDriver;
import st.AbstractStatusBar;
import timing.ITicker;
import v.DoomVideoRenderer;
import w.IWadLoader;
import automap.IAutoMap;

/** Since a lot of stuff requires shared/global access to 
 *  the WadLoader, the Renderer, the Video system etc. and
 *  we're trying to depart from the global/static mentality,
 *  a common sharing is required. Ideally, this would be a perfect
 *  example of where multiple inheritance could be adopted, since most
 *  stuff needs to share this status anyway. The next best thing is
 *  to have local references of any used fields in the classes that use them.
 * 
 *  About generics: T refers to the type of the graphics resources, and is
 *  currently byte[], as all graphics resources are 8-bit indexed. There are
 *  no plans that this will change anytime soon. Some classes should allow 
 *  different types in theory, but it would be too complex and pointless to 
 *  make everything fully compliant at the moment.
 *  
 *  V refers to the type of DISPLAY, and can be 8-bit (byte[]), 16-bit (short[] 
 *  for HiColor and lesser modes such as ARGB4444, etc.), and, in the future, 
 *  int[] (truecolor).
 * 
 *  The general approach is sharing as much code as possible between different 
 *  implementations (e.g. rendering code), and only specialize methods/classes when
 *  the abstraction of generics isn't enough (typically, when you have to assign
 *  directly to primitive arrays or deal with primitive method signatures).
 *  
 *  Classes that have specialized code for indexed and hicolor modes should be top-level
 *  classes in their package, and contain two nested, static, extending classes called
 *  Indexed and HiColor e.g. new MyClass.Indexed() and new MyClass.HiColor(), while any common 
 *  code should reside in MyClass.
 * 
 * @author velktron
 *
 */

public class DoomContext<T,V>{
	
    public DoomMain<T,V> DM;
    public IDoomGame DG;
    public IWadLoader W;
    public IRandom RND;
    public IDoomSystem I;
    public IDoomSound S;
    public ISoundDriver ISND;
    public IMusic IMUS;
    public DoomVideoInterface<V> VI;
    public AbstractStatusBar ST;
    public DoomVideoRenderer<T,V> V;
    public DoomSystemNetworking DNI;
    public IDoomGameNetworking DGN;
    public AbstractLevelLoader LL;
    public IDoomMenu M;
    public Actions P;
    public Renderer<T,V> R;
    public HU HU;
    public IAutoMap<T,V> AM;
    public Finale<T> F;
    public EndLevel<T,V> WI;
    public Wiper<T,V> WIPE;
    public TextureManager<T> TM;
    public ISpriteManager SM;
    public ICommandLineManager CM;
    public ITicker TICK; 
    public IDiskDrawer DD;
    public IVariablesManager VM;
}

package doom;

import java.util.Hashtable;

import utils.C2JUtils;

import defines.GameMode_t;

public class DoomVersions {

	public final static Hashtable<String,GameMode_t> VersionChecker=new Hashtable<String,GameMode_t>();
	
	static {
		VersionChecker.put("doom.wad",GameMode_t.registered);
		VersionChecker.put("doom2.wad",GameMode_t.commercial);
		VersionChecker.put("udoom.wad",GameMode_t.retail);
		VersionChecker.put("tnt.wad",GameMode_t.pack_tnt);
		VersionChecker.put("plutonia.wad",GameMode_t.pack_plut);
		VersionChecker.put("doom1.wad",GameMode_t.shareware);
		VersionChecker.put("xbla.wad",GameMode_t.pack_xbla);
	}
	
	public DoomVersions(){
		
	}
	
	/** Try all versions in given doommwaddir
	 * 
	 */
	
	public void tryThemAll(String doomwaddir){
		 // Commercial.
        doom2wad = (doomwaddir+ "/doom2.wad");

        // Retail.
        doomuwad = (doomwaddir+ "/doomu.wad");    

        // Registered.
        doomwad = (doomwaddir+ "/doom.wad");

        // Shareware.
        doom1wad = (doomwaddir+ "/doom1.wad");

        // Bug, dear Shawn.
        // Insufficient malloc, caused spurious realloc errors.
        plutoniawad = (doomwaddir+ "/plutonia.wad");

        tntwad = (doomwaddir+ "/tnt.wad");

        xblawad = (doomwaddir+ "/xbla.wad");
        
        // French stuff.
        doom2fwad=(doomwaddir+ "/doom2f.wad");
	}
	
	public String 
	doom1wad,
    doomwad,
    doomuwad,
    doom2wad,
    doom2fwad,
    plutoniawad,    
    tntwad,
    xblawad;
	
	/** Try only one IWAD. 
	 * 
	 * @param iwad
	 * @return
	 */

	public GameMode_t tryOnlyOne(String iwad, String doomwaddir) {
		
		// Is it a known and valid version?
		GameMode_t tmp=VersionChecker.get(iwad.toLowerCase());
		if (tmp!=null) {
		// Can we read it?
		if (C2JUtils.testReadAccess(doomwaddir+iwad))
			return tmp; // Yes, so communicate the gamemode back.
		}
		
		// It's either invalid or we can't read it.
		// Fuck that.
		return null;
	}
	
	
}

package doom;

/** Meant to provide a more lightweight alternative to Java's serialization model,
 *  specifically for the purpose of sending
 *  Objects implementing this can return references to one same byte array, with minimal
 *  overhead. Since it's for send-only purposes, it won't matter if it's  modified.
 *   *  
 *  But don't use it in lieu of CacheableDoomObject! 
 * 
 * @author admin
 *
 */

public interface IDatagramSerializable {
    
        /** Packs object into a byte array suitable to send over 
         * datagram networks. Typically, objects cache this array
         * for later use, and is availabe through cached()
         * 
         * @return
         */
    
        public byte[] pack();
        
        /** Packs object into a byte array suitable to send over 
         * datagram networks. The array is supplied externally 
         * (good for daisy-chaining stuff into a single packet).
         * 
         * @return
         */
    
        public void pack(byte[] buf, int offset);
        
        /** Deserializes an object from a given byte buffer.
         *  Only the first (sizeof) bytes will be used, dependant
         *  on each object's implementation. Will NOT also copy
         *  the byte[] caches. 
         */
        
        public void unpack(byte[] buf);
        
        /** Deserializes an object from a given byte buffer.
         *  Only the first (sizeof) bytes will be used, starting
         *  from a specified offset, dependant on each object's 
         *  implementation.
         */
        public void unpack(byte[] buf, int offset);
        
        /** Only use this if you are 100% sure that the object's content
         *  won't have changed since the last call of pack(). 
         *
         * @return Should return the underlying byte[] array directly.
         */
        public byte[] cached();
       
}

package doom;

// Event structure.

public class event_t {
	
	public event_t(){
	}

	   public event_t(event_t t){
	        this.type = t.type;
	        this.data1 = t.data1;
	        this.data2 = t.data2;
	        this.data3 = t.data3;
	    }

	
    public event_t(evtype_t type, int data) {
        this.type = type;
        this.data1 = data;
    }

    public event_t(char c) {
        this.type = evtype_t.ev_keydown;
        this.data1 = c;
    }

    public event_t(evtype_t type, int data1, int data2, int data3) {
        this.type = type;
        this.data1 = data1;
        this.data2 = data2;
        this.data3 = data3;
    }
    
    public void setFrom(event_t t){
        this.type = t.type;
        this.data1 = t.data1;
        this.data2 = t.data2;
        this.data3 = t.data3;
    }

    public evtype_t type;

    /** keys / mouse/joystick buttons, or wheel rotation amount */
    public int data1;

    /** mouse/joystick x move */
    public int data2;

    /** mouse/joystick y move */
    public int data3;

};

package doom;

import static data.Defines.*;
import static g.Keys.*;
import static data.Limits.*;
import java.io.OutputStreamWriter;

import automap.IAutoMap;
import m.IUseVariables;
import m.IVariablesManager;
import m.Settings;
import p.mobj_t;
import rr.Renderer;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import data.mapthing_t;
import defines.*;
import demo.IDoomDemo;
import f.Finale;
import f.Wiper;

/**
 * We need globally shared data structures, for defining the global state
 * variables. MAES: in pure OO style, this should be a global "Doom state"
 * object to be passed along various modules. No ugly globals here!!! Now, some
 * of the variables that appear here were actually defined in separate modules.
 * Pretty much, whatever needs to be shared with other modules was placed here,
 * either as a local definition, or as an extern share. The very least, I'll
 * document where everything is supposed to come from/reside.
 */

public abstract class DoomStatus<T,V> extends DoomContext<T,V> implements IUseVariables {

	public static final int	BGCOLOR=		7;
	public static final int	FGCOLOR		=8;
	public static int   RESENDCOUNT =10;
	public static int   PL_DRONE    =0x80;  // bit flag in doomdata->player

	public String[]		wadfiles=new String[MAXWADFILES];

	boolean         drone;
	
    /** Command line parametersm, actually defined in d_main.c */
    public boolean nomonsters; // checkparm of -nomonsters

    public boolean respawnparm; // checkparm of -respawn

    public boolean fastparm; // checkparm of -fast

    public boolean devparm; // DEBUG: launched with -devparm

 // MAES: declared as "extern", shared with Menu.java
    public  boolean	inhelpscreens;

    boolean		advancedemo;
    
    /////////// Local to doomstat.c ////////////
    // TODO: hide those behind getters
    
    /** Game Mode - identify IWAD as shareware, retail etc. 
     *  This is now hidden behind getters so some cases like plutonia
     *  etc. can be handled more cleanly.
     * */

    private GameMode_t gamemode;
    
    public void setGameMode(GameMode_t mode){
    	this.gamemode=mode;
    }
    
    public GameMode_t getGameMode(){
    	return gamemode;
    }
    
    public boolean isShareware(){
    	return (gamemode== GameMode_t.shareware);
    }    
    
    /** Commercial means Doom 2, Plutonia, TNT, and possibly others like XBLA.
     * 
     * @return
     */
    public boolean isCommercial(){
    	return (gamemode== GameMode_t.commercial ||
    			gamemode== GameMode_t.pack_plut ||
    			gamemode== GameMode_t.pack_tnt ||
    			gamemode== GameMode_t.pack_xbla);
    }
    
    /** Retail means Ultimate.
     * 
     * @return
     */
    public boolean isRetail(){
    	return (gamemode== GameMode_t.retail );
    }
    
    /** Registered is a subset of Ultimate 
     * 
     * @return
     */

    public boolean isRegistered(){
    	return (gamemode== GameMode_t.registered || gamemode== GameMode_t.retail );
    }
    
    public GameMission_t gamemission;

    /** Set if homebrew PWAD stuff has been added. */
    public boolean modifiedgame;

    /** Language. */
    public Language_t language;

    // /////////// Normally found in d_main.c ///////////////

    // Selected skill type, map etc.

    /** Defaults for menu, methinks. */
    public skill_t startskill;

    public int startepisode;

    public int startmap;

    public boolean autostart;

    /** Selected by user */
    public skill_t gameskill;

    public int gameepisode;

    public int gamemap;

    /** Nightmare mode flag, single player. */
    public boolean respawnmonsters;

    /** Netgame? Only true if >1 player. */
    public boolean netgame;

    /**
     * Flag: true only if started as net deathmatch. An enum might handle
     * altdeath/cooperative better. Use altdeath for the "2" value
     */
    public boolean deathmatch;

    /** Use this instead of "deathmatch=2" which is bullshit. */
    public boolean altdeath;
    
    //////////// STUFF SHARED WITH THE RENDERER ///////////////
    
    // -------------------------
    // Status flags for refresh.
    //

    public boolean nodrawers;

    public boolean noblit;
    
    public boolean viewactive;
    
    // Player taking events, and displaying.
    public int consoleplayer;

    public int displayplayer;
    
    // Depending on view size - no status bar?
    // Note that there is no way to disable the
    // status bar explicitely.
    public boolean statusbaractive;

    public boolean automapactive; // In AutoMap mode?

    public boolean menuactive; // Menu overlayed?

    public boolean paused; // Game Pause?

    // -------------------------
    // Internal parameters for sound rendering.
    // These have been taken from the DOS version,
    // but are not (yet) supported with Linux
    // (e.g. no sound volume adjustment with menu.

    // These are not used, but should be (menu).
    // From m_menu.c:
    // Sound FX volume has default, 0 - 15
    // Music volume has default, 0 - 15
    // These are multiplied by 8.
    /** maximum volume for sound */
    public int snd_SfxVolume;

    /** maximum volume for music */
    public int snd_MusicVolume;

    /** Maximum number of sound channels */
    public int numChannels;

    // Current music/sfx card - index useless
    // w/o a reference LUT in a sound module.
    // Ideally, this would use indices found
    // in: /usr/include/linux/soundcard.h
    public int snd_MusicDevice;

    public int snd_SfxDevice;

    // Config file? Same disclaimer as above.
    public int snd_DesiredMusicDevice;

    public int snd_DesiredSfxDevice;

    
    // -------------------------------------
    // Scores, rating.
    // Statistics on a given map, for intermission.
    //
    public int totalkills;

    public int totalitems;

    public int totalsecret;

    /** TNTHOM "cheat" for flashing HOM-detecting BG */
	public boolean flashing_hom;
    
    // Added for prBoom+ code
    public int totallive;
    
    // Timer, for scores.
    public int levelstarttic; // gametic at level start

    public int leveltime; // tics in game play for par

    // --------------------------------------
    // DEMO playback/recording related stuff.
    // No demo, there is a human player in charge?
    // Disable save/end game?
    public boolean usergame;

    // ?
    public boolean demoplayback;

    public boolean demorecording;

    // Quit after playing a demo from cmdline.
    public boolean singledemo;

    /** Set this to GS_DEMOSCREEN upon init, else it will be null*/
    public gamestate_t gamestate=gamestate_t.GS_DEMOSCREEN;

    // -----------------------------
    // Internal parameters, fixed.
    // These are set by the engine, and not changed
    // according to user inputs. Partly load from
    // WAD, partly set at startup time.

    public int gametic;

    // Bookkeeping on players - state.
    public player_t[] players;

    // Alive? Disconnected?
    public boolean[] playeringame = new boolean[MAXPLAYERS];

    public mapthing_t[] deathmatchstarts = new mapthing_t[MAX_DM_STARTS];

    /** pointer into deathmatchstarts */
    public int deathmatch_p;

    /** Player spawn spots. */
    public mapthing_t[] playerstarts = new mapthing_t[MAXPLAYERS];

    /** Intermission stats.
      Parameters for world map / intermission. */
    public wbstartstruct_t wminfo;

    /** LUT of ammunition limits for each kind.
        This doubles with BackPack powerup item.
        NOTE: this "maxammo" is treated like a global.
         */
    public final static int[] maxammo =  {200, 50, 300, 50};

    // -----------------------------------------
    // Internal parameters, used for engine.
    //

    // File handling stuff.
    
    public OutputStreamWriter debugfile;

    // if true, load all graphics at level load
    public boolean precache;

    // wipegamestate can be set to -1
    // to force a wipe on the next draw
    // wipegamestate can be set to -1 to force a wipe on the next draw
    public gamestate_t     wipegamestate = gamestate_t.GS_DEMOSCREEN;
    
    public int mouseSensitivity=15;
    
    // debug flag to cancel adaptiveness
    // Set to true during timedemos.
    public boolean singletics=false;
    
    /* A "fastdemo" is a demo with a clock that tics as
     * fast as possible, yet it maintains adaptiveness and doesn't
     * try to render everything at all costs.
     */
    protected boolean fastdemo;
    protected boolean normaldemo;
    
    protected String loaddemo;
    
    public int bodyqueslot;

    // Needed to store the number of the dummy sky flat.
    // Used for rendering,
    // as well as tracking projectiles etc.
    //public int skyflatnum;

    // TODO: Netgame stuff (buffers and pointers, i.e. indices).

    // TODO: This is ???
    public doomcom_t doomcom;

    // TODO: This points inside doomcom.
    public doomdata_t netbuffer;

    public ticcmd_t[] localcmds = new ticcmd_t[BACKUPTICS];

    public int rndindex;

    public int maketic;

    public int[] nettics = new int[MAXNETNODES];

    public ticcmd_t[][] netcmds;// [MAXPLAYERS][BACKUPTICS];
      
    /** MAES: this WAS NOT in the original. 
     *  Remember to call it!
     */
    protected void initNetGameStuff() {
        //this.netbuffer = new doomdata_t();
        this.doomcom = new doomcom_t();
        this.netcmds = new ticcmd_t[MAXPLAYERS][BACKUPTICS];

        C2JUtils.initArrayOfObjects(localcmds);
        for (int i=0;i<MAXPLAYERS;i++){
        C2JUtils.initArrayOfObjects(netcmds[i]);
        }
        
    }
    
    public abstract void Init();

    // Fields used for selecting variable BPP implementations.
    
    protected abstract Finale<T> selectFinale();
    
    protected abstract DoomVideoRenderer<T,V> selectVideoRenderer();
    
    protected abstract Renderer<T,V> selectRenderer();
    
    protected abstract Wiper<T,V> selectWiper();
    
    protected abstract IAutoMap<T,V> selectAutoMap();
    
    // MAES: Fields specific to DoomGame. A lot of them were
    // duplicated/externalized
    // in d_game.c and d_game.h, so it makes sense adopting a more unified
    // approach.
    protected gameaction_t gameaction=gameaction_t.ga_nothing;

    public boolean sendpause; // send a pause event next tic

    protected boolean sendsave; // send a save event next tic

    protected int starttime;

    protected boolean timingdemo; // if true, exit with report on completion

    public boolean getPaused() {
        return paused;
    }

    public void setPaused(boolean paused) {
        this.paused = paused;
    }

    // ////////// DEMO SPECIFIC STUFF/////////////

    protected String demoname;

    protected boolean netdemo;

    //protected IDemoTicCmd[] demobuffer;

    protected IDoomDemo demobuffer;
    /** pointers */
    // USELESS protected int demo_p;

   // USELESS protected int demoend;

    protected short[][] consistancy = new short[MAXPLAYERS][BACKUPTICS];

    protected byte[] savebuffer;

    /* TODO Proper reconfigurable controls. Defaults hardcoded for now. T3h h4x, d00d. */

    public int key_right=KEY_RIGHTARROW;

    public int key_left=KEY_LEFTARROW;

    public int key_up='w';

    public int key_down='a';

    public int key_strafeleft='s';

    public int key_straferight='d';

    public int key_fire=KEY_CTRL;

    public int key_use=' ';
    
    public int key_strafe=KEY_ALT;

    public int key_speed=KEY_SHIFT;
    
    // Heretic stuff
    public int		key_lookup=KEY_PGUP;
    public int		key_lookdown=KEY_PGDN;
    public int      key_lookcenter=KEY_END;

    public int mousebfire=0;

    public int mousebstrafe=1;

    public int mousebforward=2;

    public int joybfire;

    public int joybstrafe;

    public int joybuse;

    public int joybspeed;
    
    /** Cancel vertical mouse movement by default */
    protected boolean novert=true;

    protected int MAXPLMOVE() {
        return forwardmove[1];
    }

    protected static final int TURBOTHRESHOLD = 0x32;

    /** fixed_t */
    protected final int[] forwardmove = { 0x19, 0x32 }; // + slow turn

    protected final int[] sidemove = { 0x18, 0x28 };

    protected final int[] angleturn = { 640, 1280, 320 };

    protected static final int SLOWTURNTICS = 6;

    protected static final int NUMKEYS = 256;

    protected boolean[] gamekeydown = new boolean[NUMKEYS];

    protected boolean keysCleared;
    
    public boolean alwaysrun;

    protected int turnheld; // for accelerative turning
    protected int lookheld; // for accelerative looking?

    protected boolean[] mousearray = new boolean[4];

    /** This is an alias for mousearray [1+i] */
    protected boolean mousebuttons(int i) {
        return mousearray[1 + i]; // allow [-1]
    }

    protected void mousebuttons(int i, boolean value) {
        mousearray[1 + i] = value; // allow [-1]
    }

    protected void mousebuttons(int i, int value) {
        mousearray[1 + i] = value != 0; // allow [-1]
    }

    /** mouse values are used once */
    protected int mousex, mousey;

    protected int dclicktime;

    protected int dclickstate;

    protected int dclicks;

    protected int dclicktime2, dclickstate2, dclicks2;

    /** joystick values are repeated */
    protected int joyxmove, joyymove;

    protected boolean[] joyarray = new boolean[5];

    protected boolean joybuttons(int i) {
        return joyarray[1 + i]; // allow [-1]
    }

    protected void joybuttons(int i, boolean value) {
        joyarray[1 + i] = value; // allow [-1]
    }

    protected void joybuttons(int i, int value) {
        joyarray[1 + i] = value != 0; // allow [-1]
    }

    protected int savegameslot;

    protected String savedescription;

    protected static final int BODYQUESIZE = 32;

    protected mobj_t[] bodyque = new mobj_t[BODYQUESIZE];

    public String statcopy; // for statistics driver

    
    
    /** Not documented/used in linuxdoom. I supposed it could be used to
     *  ignore mouse input?
     */
    
    public boolean use_mouse,use_joystick;
    
    
    /** More prBoom+ stuff. Used mostly for code uhm..reuse, rather
     *  than to actually change the way stuff works.
     *   
     */
    
    public static int compatibility_level;
    
    public DoomStatus(){
    	players = new player_t[MAXPLAYERS];
    	C2JUtils.initArrayOfObjects(players);

    	this.wminfo=new wbstartstruct_t();
    	initNetGameStuff();
    }

    @Override
    public void registerVariableManager(IVariablesManager manager) {
        this.VM=manager;        
    }

    @Override
    public void update() {

           this.snd_SfxVolume=VM.getSetting(Settings.sfx_volume).getInteger();
           this.snd_MusicVolume=VM.getSetting(Settings.music_volume).getInteger();
           this.alwaysrun=VM.getSetting(Settings.alwaysrun).getBoolean();
                     
          
           // Keys...
           this.key_right=VM.getSetting(Settings.key_right).getChar();
           this.key_left=VM.getSetting(Settings.key_left).getChar();
           this.key_up=VM.getSetting(Settings.key_up).getChar();
           this.key_down=VM.getSetting(Settings.key_down).getChar();
           this.key_strafeleft=VM.getSetting(Settings.key_strafeleft).getChar();
           this.key_straferight=VM.getSetting(Settings.key_straferight).getChar();
           this.key_fire=VM.getSetting(Settings.key_fire).getChar();
           this.key_use=VM.getSetting(Settings.key_use).getChar();
           this.key_strafe=VM.getSetting(Settings.key_strafe).getChar();
           this.key_speed=VM.getSetting(Settings.key_speed).getChar();
           

           // Mouse buttons
           this.use_mouse=VM.getSetting(Settings.use_mouse).getBoolean();
           this.mousebfire=VM.getSetting(Settings.mouseb_fire).getInteger();
           this.mousebstrafe=VM.getSetting(Settings.mouseb_strafe).getInteger();
           this.mousebforward=VM.getSetting(Settings.mouseb_forward).getInteger();
           
           // Joystick

           this.use_joystick=VM.getSetting(Settings.use_joystick).getBoolean();
           this.joybfire=VM.getSetting(Settings.joyb_fire).getInteger();
           this.joybstrafe=VM.getSetting(Settings.joyb_strafe).getInteger();
           this.joybuse=VM.getSetting(Settings.joyb_use).getInteger();
           this.joybspeed=VM.getSetting(Settings.joyb_speed).getInteger();

           // Sound
           this.numChannels=VM.getSetting(Settings.snd_channels).getInteger();

           // Video...so you should wait until video renderer is active.           
           this.V.setUsegamma(VM.getSetting(Settings.usegamma).getInteger());
           
           // These should really be handled by the menu.
           this.M.setShowMessages(VM.getSetting(Settings.show_messages).getBoolean());
           this.M.setScreenBlocks(VM.getSetting(Settings.screenblocks).getInteger());

           // These should be handled by the HU

           for (int i=0;i<=9;i++){
               
           String chatmacro=String.format("chatmacro%d",i);
           this.HU.setChatMacro(i,VM.getSetting(chatmacro).toString());
           }
        }

    @Override
    public void commit() {
        VM.putSetting(Settings.sfx_volume,this.snd_SfxVolume);
        VM.putSetting(Settings.music_volume,this.snd_MusicVolume);
        VM.putSetting(Settings.alwaysrun, this.alwaysrun);
       
       
        // Keys...
        VM.putSetting(Settings.key_right,this.key_right);
        VM.putSetting(Settings.key_left,this.key_left);
        VM.putSetting(Settings.key_up,this.key_up);
        VM.putSetting(Settings.key_down,this.key_down);
        VM.putSetting(Settings.key_strafeleft,this.key_strafeleft);
        VM.putSetting(Settings.key_straferight,this.key_straferight);
        VM.putSetting(Settings.key_fire,this.key_fire);
        VM.putSetting(Settings.key_use,this.key_use);
        VM.putSetting(Settings.key_strafe,this.key_strafe);
        VM.putSetting(Settings.key_speed,this.key_speed);
        

        // Mouse buttons
        VM.putSetting(Settings.use_mouse,this.use_mouse);
        VM.putSetting(Settings.mouseb_fire,this.mousebfire);
        VM.putSetting(Settings.mouseb_strafe,this.mousebstrafe);
        VM.putSetting(Settings.mouseb_forward,this.mousebforward);
        
        // Joystick

        VM.putSetting(Settings.use_joystick,this.use_joystick);
        VM.putSetting(Settings.joyb_fire,this.joybfire);
        VM.putSetting(Settings.joyb_strafe,this.joybstrafe);
        VM.putSetting(Settings.joyb_use,this.joybuse);
        VM.putSetting(Settings.joyb_speed,this.joybspeed);

        // Sound
        VM.putSetting(Settings.snd_channels,this.numChannels);
        
        // Video...         
        VM.putSetting(Settings.usegamma,V.getUsegamma());
        
        // These should really be handled by the menu.
        VM.putSetting(Settings.show_messages,this.M.getShowMessages());
        VM.putSetting(Settings.screenblocks,this.M.getScreenBlocks());
        
        // These should be handled by the HU

        for (int i=0;i<=9;i++){
            
        String chatmacro=String.format("chatmacro%d",i);
        VM.putSetting(chatmacro,this.HU.chat_macros[i]);
        }
        
    }
    

    

}

// $Log: DoomStatus.java,v $
// Revision 1.36  2012/11/06 16:04:58  velktron
// Variables manager less tightly integrated.
//
// Revision 1.35  2012/09/24 17:16:22  velktron
// Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
// Revision 1.34.2.3  2012/09/24 16:58:06  velktron
// TrueColor, Generics.
//
// Revision 1.34.2.2  2012/09/20 14:25:13  velktron
// Unified DOOM!!!
//
// Revision 1.34.2.1  2012/09/17 16:06:52  velktron
// Now handling updates of all variables, though those specific to some subsystems should probably be moved???
//
// Revision 1.34  2011/11/01 23:48:10  velktron
// Added tnthom stuff.
//
// Revision 1.33  2011/10/24 02:11:27  velktron
// Stream compliancy
//
// Revision 1.32  2011/10/07 16:01:16  velktron
// Added freelook stuff, using Keys.
//
// Revision 1.31  2011/09/27 16:01:41  velktron
// -complevel_t
//
// Revision 1.30  2011/09/27 15:54:51  velktron
// Added some more prBoom+ stuff.
//
// Revision 1.29  2011/07/28 17:07:04  velktron
// Added always run hack.
//
// Revision 1.28  2011/07/16 10:57:50  velktron
// Merged finnw's changes for enabling polling of ?_LOCK keys.
//
// Revision 1.27  2011/06/14 20:59:47  velktron
// Channel settings now read from default.cfg. Changes in sound creation order.
//
// Revision 1.26  2011/06/04 11:04:25  velktron
// Fixed registered/ultimate identification.
//
// Revision 1.25  2011/06/01 17:35:56  velktron
// Techdemo v1.4a level. Default novert and experimental mochaevents interface.
//
// Revision 1.24  2011/06/01 00:37:58  velktron
// Changed default keys to WASD.
//
// Revision 1.23  2011/05/31 21:45:51  velktron
// Added XBLA version as explicitly supported.
//
// Revision 1.22  2011/05/30 15:50:42  velktron
// Changed to work with new Abstract classes
//
// Revision 1.21  2011/05/26 17:52:11  velktron
// Now using ICommandLineManager
//
// Revision 1.20  2011/05/26 13:39:52  velktron
// Now using ICommandLineManager
//
// Revision 1.19  2011/05/25 17:56:52  velktron
// Introduced some fixes for mousebuttons etc.
//
// Revision 1.18  2011/05/24 17:44:37  velktron
// usemouse added for defaults
//
package doom;

import i.DiskDrawer;
import i.DoomStatusAware;
import i.DoomSystem;
import i.DoomVideoInterface;
import i.Strings;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import n.DummyNetworkDriver;
import static data.dstrings.*;
import p.Actions;
import p.BoomLevelLoader;
import p.mobj_t;
import automap.IAutoMap;
import automap.Map;
import awt.AWTDoom;
import f.EndLevel;
import f.Finale;
import f.Wiper;
import hu.HU;
import m.Menu;
import m.MenuMisc;
import m.DoomRandom;
import m.Settings;
import m.VarsManager;
import static doom.NetConsts.*;
import static doom.englsh.*;
import data.Tables;
import data.dstrings;
import data.mapthing_t;
import data.mobjtype_t;
import defines.*;
import demo.IDemoTicCmd;
import demo.IDoomDemo;
import demo.VanillaDoomDemo;
import demo.VanillaTiccmd;
import data.sounds.musicenum_t;
import data.sounds.sfxenum_t;
import static data.Defines.BACKUPTICS;
import static g.Keys.*;
import static data.Defines.NORMALUNIX;
import static data.Defines.PU_STATIC;
import static data.Defines.VERSION;
import rr.Renderer;
import rr.SimpleTextureManager;
import rr.SpriteManager;
import rr.UnifiedRenderer;
import rr.ViewVars;
import rr.subsector_t;
import rr.parallel.ParallelRenderer;
import rr.parallel.ParallelRenderer2;
import s.AbstractDoomAudio;
import s.ClassicDoomSoundDriver;
import s.ClipSFXModule;
import s.DavidMusicModule;
import s.DavidSFXModule;
import s.DummyMusic;
import s.DummySFX;
import s.DummySoundDriver;
import s.SpeakerDoomSoundDriver;
import s.SuperDoomSoundDriver;
//import s.SpeakerDoomSoundDriver;

import savegame.IDoomSaveGame;
import savegame.IDoomSaveGameHeader;
import savegame.VanillaDSG;
import savegame.VanillaDSGHeader;
import st.StatusBar;
import timing.FastTicker;
import timing.ITicker;
import timing.MilliTicker;
import timing.NanoTicker;
import utils.C2JUtils;
import v.BufferedRenderer;
import v.BufferedRenderer16;
import v.BufferedRenderer32;
import v.ColorTint;
import v.DoomVideoRenderer;
import v.GammaTables;
import v.IVideoScale;
import v.IVideoScaleAware;
import v.PaletteGenerator;
//import v.VideoScaleInfo;
import v.VisualSettings;
import w.DoomBuffer;
import w.WadLoader;
import static data.Defines.*;
import static data.Limits.*;
import static data.Tables.*;
import static data.dstrings.SAVEGAMENAME;
import static data.info.mobjinfo;
import static data.info.states;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.MAPFRACUNIT;
import static utils.C2JUtils.*;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: DoomMain.java,v 1.110 2016/06/06 22:21:24 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//	DOOM main program (D_DoomMain) and game loop (D_DoomLoop),
//	plus functions to determine game mode (shareware, registered),
//	parse command line parameters, configure game parameters (turbo),
//	and call the startup functions.
//
//  In Mocha Doom, this was unified with d_game and doomstat.c
//
//-----------------------------------------------------------------------------

public abstract class DoomMain<T,V> extends DoomStatus<T,V> implements IDoomGameNetworking, IDoomGame, IDoom, IVideoScaleAware{

    public static final String rcsid = "$Id: DoomMain.java,v 1.110 2016/06/06 22:21:24 velktron Exp $";

    //
    // EVENT HANDLING
    //
    // Events are asynchronous inputs generally generated by the game user.
    // Events can be discarded if no responder claims them
    //
    public event_t[]         events=new event_t[MAXEVENTS];
    public int             eventhead;
    public int 		eventtail;

    /**
     * D_PostEvent
     * Called by the I/O functions when input is detected
     */

    public void PostEvent (event_t ev)
    {
        // TODO create a pool of reusable messages?
        // NEVERMIND we can use the original system.
        events[eventhead].setFrom(ev);
        eventhead = (++eventhead)&(MAXEVENTS-1);
    }


    /**
     * D_ProcessEvents
     * Send all the events of the given timestamp down the responder chain
     */ 
    public void ProcessEvents ()
    {
        event_t	ev;

        // IF STORE DEMO, DO NOT ACCEPT INPUT

        if ( ( isCommercial() )
                && (W.CheckNumForName("MAP01")<0) )
            return; 

        for ( ; eventtail != eventhead ; eventtail = (++eventtail)&(MAXEVENTS-1) )
        {
            ev = events[eventtail];
            if (M.Responder (ev)){
                //epool.checkIn(ev);
                continue;               // menu ate the event
            }
            Responder (ev);
            // We're done with it, return it to the pool.
            //epool.checkIn(ev);
        }
    }

    // "static" to Display, don't move.
    private  boolean		viewactivestate = false;
    private  boolean		menuactivestate = false;
    private  boolean		inhelpscreensstate = false;
    private  boolean		fullscreen = false;
    private  gamestate_t	oldgamestate = gamestate_t.GS_MINUS_ONE;
    private  int			borderdrawcount;

    /**
     * D_Display
     * draw current display, possibly wiping it from the previous
     * @throws IOException 
     */

    public void Display () throws IOException
    {
        int				nowtime;
        int				tics;
        int				wipestart;
        int				y;
        boolean			done;
        boolean			wipe;
        boolean			redrawsbar;

        if (nodrawers)
            return;                    // for comparative timing / profiling

        redrawsbar = false;

        // change the view size if needed
        if (R.getSetSizeNeeded())
        {
            R.ExecuteSetViewSize ();
            oldgamestate = gamestate_t.GS_MINUS_ONE;                      // force background redraw
            borderdrawcount = 3;
        }

        // save the current screen if about to wipe
        if (wipe=(gamestate != wipegamestate))
        {
            wipe = true;
            WIPE.StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
        }
        else
            wipe = false;

        if (gamestate == gamestate_t.GS_LEVEL && eval(gametic))
            HU.Erase();

        // do buffered drawing
        switch (gamestate)
        {
        case GS_LEVEL:
            if (!eval(gametic))
                break;
            if (automapactive)
                AM.Drawer ();
            if (wipe || (!R.isFullHeight() && fullscreen) ||
            		(inhelpscreensstate && !inhelpscreens)
            		|| (DD.justDoneReading()))
                redrawsbar = true; // just put away the help screen
            ST.Drawer (R.isFullHeight(), redrawsbar );
            fullscreen = R.isFullHeight();
            break;

        case GS_INTERMISSION:
            WI.Drawer ();
            break;

        case GS_FINALE:
            F.Drawer ();
            break;

        case GS_DEMOSCREEN:
            PageDrawer ();
            break;
        }

        // draw the view directly
        if (gamestate == gamestate_t.GS_LEVEL && !automapactive && eval(gametic)){
        	if (flashing_hom){
                V.FillRect(gametic%256,0,view.getViewWindowX(),view.getViewWindowY(),
                    view.getScaledViewWidth(),view.getScaledViewHeight());
        	    }
            R.RenderPlayerView (players[displayplayer]);
        	}

        // Automap was active, update only HU.    
        if (gamestate == gamestate_t.GS_LEVEL && eval(gametic))
            HU.Drawer ();

        // clean up border stuff
        if (gamestate != oldgamestate && gamestate != gamestate_t.GS_LEVEL)
            VI.SetPalette (0);

        // see if the border needs to be initially drawn
        if (gamestate == gamestate_t.GS_LEVEL && oldgamestate != gamestate_t.GS_LEVEL)
        {
            viewactivestate = false;        // view was not active
            R.FillBackScreen ();    // draw the pattern into the back screen
        }

        // see if the border needs to be updated to the screen
        if (gamestate == gamestate_t.GS_LEVEL && !automapactive && !R.isFullScreen())
        {
            if (menuactive || menuactivestate || !viewactivestate)
                borderdrawcount = 3;
            if (eval(borderdrawcount))
            {
                R.DrawViewBorder ();    // erase old menu stuff
                borderdrawcount--;
            }

        }

        menuactivestate = menuactive;
        viewactivestate = viewactive;
        inhelpscreensstate = inhelpscreens;
        oldgamestate = wipegamestate = gamestate;

        // draw pause pic
        if (paused)
        {
            if (automapactive)
                y = 4;
            else
                y = view.getViewWindowY()+4;
            V.DrawPatchDirect(view.getViewWindowX()+(view.getScaledViewWidth()-68)/2,
                y,0,W.CachePatchName ("M_PAUSE", PU_CACHE));
        }


        // menus go directly to the screen
        M.Drawer ();          // menu is drawn even on top of everything
        NetUpdate ();         // send out any new accumulation

        // Disk access goes after everything.
        DD.Drawer();
        
        // normal update
        if (!wipe)
        {
            //System.out.print("Tick "+DM.gametic+"\t");
            //System.out.print(DM.players[0]);
            VI.FinishUpdate ();              // page flip or blit buffer
            return;
        }

        // wipe update. At this point, AT LEAST one frame of the game must have been
        // rendered for this to work. 22/5/2011: Fixed a vexing bug with the wiper.
        // Jesus Christ with a Super Shotgun!
        WIPE.EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);

        wipestart = TICK.GetTime () - 1;

        do
        {
            do
            {
                nowtime = TICK.GetTime ();
                tics = nowtime - wipestart;
            } while (tics==0); // Wait until a single tic has passed.
            wipestart = nowtime;
            done = WIPE.ScreenWipe(Wiper.wipe.Melt.ordinal()
                , 0, 0, SCREENWIDTH, SCREENHEIGHT, tics);
            ISND.UpdateSound();
            ISND.SubmitSound();             // update sounds after one wipe tic.
            VI.UpdateNoBlit ();
            M.Drawer ();                    // menu is drawn even on top of wipes
            VI.FinishUpdate ();             // page flip or blit buffer
        } while (!done);

    }



    /**
     * D-DoomLoop()
     * Not a globally visible function,
     *  just included for source reference,
     *  called by D_DoomMain, never exits.
     * Manages timing and IO,
     *  calls all ?_Responder, ?_Ticker, and ?_Drawer,
     *  calls I_GetTime, I_StartFrame, and I_StartTic
     * @throws IOException 
     */

    public void DoomLoop () throws IOException
    {
        if (demorecording)
            BeginRecording ();

        if (eval(CM.CheckParm ("-debugfile")))
        {
            String    filename="debug"+consoleplayer+".txt";
            System.out.println("debug output to: "+filename);
            try {
                debugfile = new OutputStreamWriter(new FileOutputStream(filename));
            } catch (FileNotFoundException e) {
                System.err.println("Couldn't open debugfile. Now, that sucks some putrid shit out of John Romero's asshole!");
                e.printStackTrace();
            }
        }
        
        view=R.getView();
        
        while (true)
        {
            // frame syncronous IO operations
            VI.StartFrame ();                

            // process one or more tics
            if (singletics)
            {
                VI.StartTic ();
                ProcessEvents ();
                BuildTiccmd (netcmds[consoleplayer][maketic%BACKUPTICS]);
                if (advancedemo)
                    DoAdvanceDemo ();
                M.Ticker ();
                Ticker ();
                gametic++;
                maketic++;
            }
            else
            {
                DGN.TryRunTics (); // will run at least one tic (in NET)

            }

            S.UpdateSounds (players[consoleplayer].mo);// move positional sounds

            // Update display, next frame, with current state.
            Display ();
            
//#ifndef SNDSERV
	// Sound mixing for the buffer is snychronous.
	ISND.UpdateSound();
//#endif	
	// Synchronous sound output is explicitly called.
//#ifndef SNDINTR
	// Update sound output.
	ISND.SubmitSound();
//#endif
             
        }
    }
    
    // To keep an "eye" on the renderer.
    protected ViewVars view;

    //
    //  DEMO LOOP
    //
    int             demosequence;
    int             pagetic;
    String pagename;


    /**
     * D_PageTicker
     * Handles timing for warped projection
     */
    public final void PageTicker ()
    {
        if (--pagetic < 0)
            AdvanceDemo ();
    }



    /**
     * D_PageDrawer
     */

    public final void PageDrawer ()
    {

        // FIXME: this check wasn't necessary in vanilla, since pagename was 
        // guaranteed(?) not to be null or had a safe default value.  
        if (pagename != null)
            V.DrawPatchSolidScaled (0,0, SAFE_SCALE, SAFE_SCALE,0,W.CachePatchName(pagename, PU_CACHE));
    }


    /**
     * D_AdvanceDemo
     * Called after each demo or intro demosequence finishes
     */

    public void AdvanceDemo ()
    {
        advancedemo = true;
    }


    //
    // This cycles through the demo sequences.
    // FIXME - version dependant demo numbers?
    //
    public void DoAdvanceDemo ()
    {
        players[consoleplayer].playerstate = PST_LIVE;  // not reborn
        advancedemo = false;
        usergame = false;               // no save / end game here
        paused = false;
        gameaction = gameaction_t.ga_nothing;
        
        if ( isRetail()) // Allows access to a 4th demo.
            demosequence = (demosequence+1)%7;
        else
            demosequence = (demosequence+1)%6;

        switch (demosequence)
        {
        case 0:
            if ( isCommercial() )
                pagetic = 35 * 11;
            else
                pagetic = 170;
            gamestate = gamestate_t.GS_DEMOSCREEN;
            
            
            if (W.CheckNumForName("TITLEPIC")!=-1){
                pagename = "TITLEPIC";    
            } else {
                if (W.CheckNumForName("DMENUPIC")!=-1){
                    pagename = "DMENUPIC";
                }
            }
            
            if ( isCommercial() )
                S.StartMusic(musicenum_t.mus_dm2ttl);

            else
                S.StartMusic (musicenum_t.mus_intro); 
            break;
        case 1:
            DeferedPlayDemo ("demo1");
            break;
        case 2:
            pagetic = 200;
            gamestate = gamestate_t.GS_DEMOSCREEN;
            pagename = "CREDIT";
            break;
        case 3:
            DeferedPlayDemo ("demo2");
            break;
        case 4:
            gamestate = gamestate_t.GS_DEMOSCREEN;
            if ( isCommercial())
            {
                pagetic = 35 * 11;
                pagename = "TITLEPIC";
                S.StartMusic(musicenum_t.mus_dm2ttl);
            }
            else
            {
                pagetic = 200;

                if ( isRetail() )
                    pagename = "CREDIT";
                else
                    pagename = "HELP1";
            }
            break;
        case 5:
            DeferedPlayDemo ("demo3");
            break;
            // THE DEFINITIVE DOOM Special Edition demo
        case 6:
            DeferedPlayDemo ("demo4");
            break;
        }
    }



    /**
     * D_StartTitle
     */

    public void StartTitle ()
    {
        gameaction = gameaction_t.ga_nothing;
        demosequence = -1;
        AdvanceDemo ();
    }




    //      printtitle for every printed line
    StringBuffer            title=new StringBuffer();



    /**
     * D_AddFile
     * 
     * Adds file to the end of the wadfiles[] list.
     * Quite crude, we could use a listarray instead.
     * 
     * @param file
     */
    void AddFile (String file)
    {
        int     numwadfiles;
        String newfile;

        for (numwadfiles = 0 ; eval(wadfiles[numwadfiles]) ; numwadfiles++)
            ;

        newfile = new String(file);

        wadfiles[numwadfiles] = newfile;
    }
    

    /**
     * IdentifyVersion
     * Checks availability of IWAD files by name,
     * to determine whether registered/commercial features
     * should be executed (notably loading PWAD's).
     */

    public String IdentifyVersion ()
    {

        String home;
        String doomwaddir;
        DoomVersions vcheck=new DoomVersions();
        
        // By default.
        language=Language_t.english;
        
        // First, check for -iwad parameter.
        // If valid, then it trumps all others.
        
        int p;
        p=CM.CheckParm("-iwad");
        if (eval(p))
        {
        	System.out.println("-iwad specified. Will be used with priority\n");
            String test=CM.getArgv(p+1);
            
            // It might be quoted.
            test=C2JUtils.unquoteIfQuoted(test,'"');
            
            String separator=System.getProperty("file.separator");
            doomwaddir=test.substring(0, 1+test.lastIndexOf(separator));
            String iwad=test.substring( 1+test.lastIndexOf(separator));
            GameMode_t attempt=vcheck.tryOnlyOne(iwad,doomwaddir);
            // Note: at this point we can't distinguish between "doom" retail
            // and "doom" ultimate yet.
            if (attempt!=null) {
            	AddFile(doomwaddir+iwad);
            	this.setGameMode(attempt);
            	return (doomwaddir+iwad);
            }
        } else {
        // Unix-like checking. Might come in handy sometimes.   
        // This should ALWAYS be activated, else doomwaddir etc. won't be defined.

        doomwaddir = System.getenv("DOOMWADDIR");
        if (doomwaddir!=null){
                System.out.println("DOOMWADDIR found. Will be used with priority\n");
        }
        
        home = System.getenv("HOME");
        if (NORMALUNIX){
            if (!eval(home))
                I.Error("Please set $HOME to your home directory");
        }
        
        Settings.basedefault=home+"/.doomrc";   

        // None found, using current.
        if (!eval(doomwaddir))
            doomwaddir = ".";
    
        	vcheck.tryThemAll(doomwaddir);
        }

        // MAES: Interesting. I didn't know of that :-o
        if (eval(CM.CheckParm ("-shdev")))
        {
            setGameMode(GameMode_t.shareware);
            devparm = true;
            AddFile (dstrings.DEVDATA+"doom1.wad");
            AddFile (dstrings.DEVMAPS+"data_se/texture1.lmp");
            AddFile (dstrings.DEVMAPS+"data_se/pnames.lmp");
            Settings.basedefault=dstrings.DEVDATA+"default.cfg";
            return (dstrings.DEVDATA+"doom1.wad");
        }

        if (eval(CM.CheckParm ("-regdev")))
        {
            setGameMode(GameMode_t.registered);
            devparm = true;
            AddFile (dstrings.DEVDATA+"doom.wad");
            AddFile (dstrings.DEVMAPS+"data_se/texture1.lmp");
            AddFile (dstrings.DEVMAPS+"data_se/texture2.lmp");
            AddFile (dstrings.DEVMAPS+"data_se/pnames.lmp");
            Settings.basedefault=dstrings.DEVDATA+"default.cfg";
            return (dstrings.DEVDATA+"doom.wad");
        }

        if (eval(CM.CheckParm ("-comdev")))
        {
            setGameMode(GameMode_t.commercial);
            devparm = true;
            /* I don't bother
	if(plutonia)
	    D_AddFile (DEVDATA"plutonia.wad");
	else if(tnt)
	    D_AddFile (DEVDATA"tnt.wad");
	else*/

            AddFile (dstrings.DEVDATA+"doom2.wad");	    
            AddFile (dstrings.DEVMAPS+"cdata/texture1.lmp");
            AddFile (dstrings.DEVMAPS+"cdata/pnames.lmp");
            Settings.basedefault=dstrings.DEVDATA+"default.cfg";
            return (dstrings.DEVDATA+"doom2.wad");
        }


        if ( testReadAccess(vcheck.doom2fwad))
        {
            setGameMode(GameMode_t.commercial);
            // C'est ridicule!
            // Let's handle languages in config files, okay?
            language = Language_t.french;
            System.out.println("French version\n");
            AddFile (vcheck.doom2fwad);
            return vcheck.doom2fwad;
        }


        if ( testReadAccess(vcheck.doom2wad))
        {
            setGameMode(GameMode_t.commercial);
            AddFile (vcheck.doom2wad);
            return vcheck.doom2wad;
        }

        if ( testReadAccess (vcheck.plutoniawad) )
        {
            setGameMode(GameMode_t.pack_plut);
            AddFile (vcheck.plutoniawad);
            return vcheck.plutoniawad;
        }

        if ( testReadAccess ( vcheck.tntwad) )
        {
            setGameMode(GameMode_t.pack_tnt);
            AddFile (vcheck.tntwad);
            return vcheck.tntwad;
        }
        
        if ( testReadAccess ( vcheck.tntwad) )
        {
            setGameMode(GameMode_t.pack_xbla);
            AddFile (vcheck.xblawad);
            return vcheck.xblawad;
        }

        if ( testReadAccess (vcheck.doomuwad) )
        {
            // TODO auto-detect ultimate Doom even from doom.wad
        	// Maes: this is done later on.
            setGameMode(GameMode_t.retail);
            AddFile (vcheck.doomuwad);
            return vcheck.doomuwad;
        }

        if ( testReadAccess (vcheck.doomwad) )
        {
            setGameMode(GameMode_t.registered);
            AddFile (vcheck.doomwad);
            return vcheck.doomwad;
        }

        if ( testReadAccess (vcheck.doom1wad) )
        {
            setGameMode(GameMode_t.shareware);
            AddFile (vcheck.doom1wad);
            return vcheck.doom1wad;
        }

        // MAES: Maybe we should add FreeDoom here later.

        System.out.println("Game mode indeterminate.\n");
        setGameMode(GameMode_t.indetermined);

        return null;
        // We don't abort. Let's see what the PWAD contains.
        //exit(1);
        //I_Error ("Game mode indeterminate\n");
    }




    /**
     * D_DoomMain
     *
     * Completes the job started by Init, which only created the
     * instances of the various stuff and registered the "status aware" 
     * stuff. Here everything priority-critical is 
     * called and created in more detail.
     *
     *
     */

	public void Start() throws IOException
    {
        int             p;
        StringBuffer file=new StringBuffer();

        // TODO: This may modify the command line by appending more stuff
        // from an external file. Since it can affect other stuff too,
        // maybe it should be outside of Start() and into i.Main ?
        CM.FindResponseFile ();

        String iwadfilename=IdentifyVersion ();
        
        // Sets unbuffered output in C. Not needed here. setbuf (stdout, NULL);
        modifiedgame = false;

        nomonsters = eval(CM.CheckParm ("-nomonsters"));
        respawnparm = eval(CM.CheckParm ("-respawn"));
        fastparm = eval(CM.CheckParm ("-fast"));
        devparm = eval(CM.CheckParm ("-devparm"));
        if (eval(CM.CheckParm ("-altdeath")))
            //deathmatch = 2;
            altdeath=true;
        else if (eval(CM.CheckParm ("-deathmatch")))
            deathmatch = true;

        // MAES: Check for Ultimate Doom in "doom.wad" filename.
        WadLoader tmpwad=new WadLoader();
        try {
			tmpwad.InitFile(iwadfilename,true);
		} catch (Exception e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		}
		// Check using a reloadable hack.
        CheckForUltimateDoom(tmpwad);    
       
        // MAES: better extract a method for this.
        GenerateTitle();

        // Print ticker info. It has already been set at Init() though.
        if (eval(CM.CheckParm("-millis"))){
            System.out.println("ITicker: Using millisecond accuracy timer.");
        } else if (eval(CM.CheckParm("-fasttic"))){
                System.out.println("ITicker: Using fastest possible timer.");
            }
        else {
            System.out.println("ITicker: Using nanosecond accuracy timer.");
        }

        System.out.println(title.toString());

        if (devparm)
            System.out.println(D_DEVSTR);

        // Running from CDROM?
        if (eval(CM.CheckParm("-cdrom")))
        {
            System.out.println(D_CDROM);
            //System.get("c:\\doomdata",0);
            System.out.println (Settings.basedefault+"c:/doomdata/default.cfg");
        }	

        // turbo option
        if ( eval(p=CM.CheckParm ("-turbo")) )
        {
            int     scale = 200;
            //int forwardmove[2];
            // int sidemove[2];

            if (p<CM.getArgc()-1)
                scale = Integer.parseInt(CM.getArgv(p+1));
            if (scale < 10)
                scale = 10;
            if (scale > 400)
                scale = 400;
            System.out.println("turbo scale: "+scale);
            forwardmove[0] = forwardmove[0]*scale/100;
            forwardmove[1] = forwardmove[1]*scale/100;
            sidemove[0] = sidemove[0]*scale/100;
            sidemove[1] = sidemove[1]*scale/100;
        }

        // add any files specified on the command line with -file wadfile
        // to the wad list
        //
        // convenience hack to allow -wart e m to add a wad file
        // prepend a tilde to the filename so wadfile will be reloadable
        p = CM.CheckParm ("-wart");
        if (eval(p))
        {
            char[] tmp=CM.getArgv(p).toCharArray();
            tmp[4]= 'p';// big hack, change to -warp
            CM.setArgv(p,new String(tmp));    
            GameMode_t gamemode=getGameMode();
            // Map name handling.
            switch (gamemode )
            {
            case shareware:
            case retail:
            case registered:
                file.append("~");
                file.append(DEVMAPS);
                file.append(String.format("E%cM%c.wad", CM.getArgv(p+1), CM.getArgv(p+2)));
                file.append(String.format("Warping to Episode %s, Map %s.\n",
                    CM.getArgv(p+1),CM.getArgv(p+2)));
                break;

            case commercial:
            default:
                p = Integer.parseInt(CM.getArgv(p+1));
                if (p<10){
                    file.append("~");
                    file.append(DEVMAPS);
                    file.append(String.format("cdata/map0%d.wad", p));
                }
                else
                {
                    file.append("~");
                    file.append(DEVMAPS);
                    file.append(String.format("cdata/map%d.wad", p));
                }
                break;
            }
            AddFile (file.toString());
        }

        p = CM.CheckParm ("-file");
        if (eval(p))
        {
            // the parms after p are wadfile/lump names,
            // until end of parms or another - preceded parm
            modifiedgame = true;            // homebrew levels
            // MAES 1/6/2011: Avoid + to avoid clashing with +map
            while (++p != CM.getArgc() && CM.getArgv(p).charAt(0) != '-' && CM.getArgv(p).charAt(0) != '+')
                AddFile (C2JUtils.unquoteIfQuoted(CM.getArgv(p),'"'));
        }
        
        p = CM.CheckParm ("-playdemo");
                
        if (eval(p)) normaldemo=true;
        else {
            p=CM.CheckParm ("-fastdemo");        
            if (eval(p)){
            System.out.println("Fastdemo mode. Boundless clock!");
            fastdemo=true;
            this.TICK=new FastTicker();            
            }
            else        
                if (!eval(p)) {
                    p = CM.CheckParm ("-timedemo");
                    if (eval(p)) singletics=true;
                }
        }

        // If any of the previous succeeded, try grabbing the filename.
        if ((normaldemo||fastdemo||singletics) && p < CM.getArgc()-1)
        {   
            loaddemo=CM.getArgv(p+1);
            AddFile (loaddemo+".lmp");
            System.out.printf("Playing demo %s.lmp.\n",loaddemo);
            autostart=true;
        }
        
        // Subsequent uses of loaddemo use only the lump name.
        loaddemo=C2JUtils.extractFileBase(loaddemo,0,true);

        // get skill / episode / map from parms
        // FIXME: should get them FROM THE DEMO itself.
        startskill = skill_t.sk_medium;
        startepisode = 1;
        startmap = 1;
        //autostart = false;


        p = CM.CheckParm ("-novert");
        if (eval(p) && p < CM.getArgc()-1)
        {
            novert=!(CM.getArgv(p+1).toLowerCase().compareTo("disable")==0);
            if (!novert) System.out.println("-novert ENABLED (default)");
            else System.out.println("-novert DISABLED. Hope you know what you're doing...");
        }

        p = CM.CheckParm ("-skill");
        if (eval(p) && p < CM.getArgc()-1)
        {
            startskill = skill_t.values()[CM.getArgv(p+1).charAt(0)-'1'];
            autostart = true;
        }

        p = CM.CheckParm ("-episode");
        if (eval(p) && p < CM.getArgc()-1)
        {
            startepisode = CM.getArgv(p+1).charAt(0)-'0';
            startmap = 1;
            autostart = true;
        }

        p = CM.CheckParm ("-timer");
        if (eval(p) && p < CM.getArgc()-1 && deathmatch)
        {
            int     time;
            time = Integer.parseInt(CM.getArgv(p+1));
            System.out.print("Levels will end after "+time+" minute");
            if (time>1)
                System.out.print("s");
            System.out.print(".\n");
        }

        // OK, and exactly how is this enforced?
        p = CM.CheckParm ("-avg");
        if (eval(p) && p < CM.getArgc()-1 && deathmatch)
            System.out.print("Austin Virtual Gaming: Levels will end after 20 minutes\n");

        // MAES 31/5/2011: added support for +map variation.
        p = CM.CheckParm ("-warp");
        if (eval(p) && p < CM.getArgc()-1)
        {
            if (isCommercial())
                startmap = Integer.parseInt(CM.getArgv(p+1));
            else
            {
                int eval=11;
                try {
                    eval=Integer.parseInt(CM.getArgv(p+1));
                } catch (Exception e){
                    // swallow exception. No warp.
                }

                if (eval>99) eval%=100;

                if (eval<10) {
                    startepisode = 1;
                    startmap = 1;
                }
                else {
                    startepisode = eval/10;
                    startmap = eval%10;
                }
            }
            autostart = true;
        }

        // Maes: 1/6/2011 Added +map support
        p = CM.CheckParm ("+map");
        if (eval(p)) 
        {
            if (isCommercial()) {
                startmap = parseAsMapXX(CM.getArgv(p+1));
                if (startmap!=-1){
                	autostart = true;
            	}
            }
            else
            {
                int eval=parseAsExMx(CM.getArgv(p+1));
                if (eval!=-1){

                    startepisode = Math.max(1,eval/10);
                    startmap = Math.max(1,eval%10);
                    autostart = true;
                }
            }
            
        }
        
        // init subsystems
        System.out.print("V_Init: allocate screens.\n");
        V.Init ();
        

        System.out.print("Z_Init: Init zone memory allocation daemon. \n");
        // DUMMY: Z_Init ();

        System.out.print("W_Init: Init WADfiles.\n");
        try {
            W.InitMultipleFiles(wadfiles,true);
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        //
        System.out.print("VI_Init: set colormaps.\n");
        
        // MAES: FIX for incomplete palette lumps such as those in EGADOOM.
        // Generate the palette programmatically _anyway_
        byte[] pal=PaletteGenerator.generatePalette(PaletteGenerator.playpal,
        		256, ColorTint.tints);
        // Copy over the one you read from disk...
        int pallump=W.GetNumForName("PLAYPAL");
        byte[] tmppal=W.CacheLumpNumAsRawBytes(pallump, PU_STATIC);
        if (tmppal!=null)
        System.arraycopy(tmppal, 0, pal, 0, pal.length);
        
        V.createPalettes(pal, GammaTables.gammatables, 14, 256, 3, 5);
        
        W.InjectLumpNum(pallump,new DoomBuffer(ByteBuffer.wrap(pal)));
        // set it, create it, but don't make it visible yet.
        
        VI=selectVideoInterface();

        VI.InitGraphics();

        // MAES: Before we begin calling the various Init() stuff,
        // we need to make sure that objects that support the IVideoScaleAware
        // interface get set and initialized.

        initializeVideoScaleStuff();

        // MAES: The status bar needs this update because it can "force"
        // the video renderer to assign it a scratchpad screen (Screen 4).
        // Since we're at it, let's update everything, it's easy!
        
        this.updateStatusHolders(this);
        
        // Update variables and stuff NOW.
        this.update();

        // Check for -file in shareware
        CheckForPWADSInShareware();
        

        // Iff additonal PWAD files are used, printmodified banner
        
        if (modifiedgame)
        // Generate WAD loading alert. Abort upon denial.
        if (!I.GenerateAlert(Strings.MODIFIED_GAME_TITLE,Strings.MODIFIED_GAME_DIALOG)) {
        	  W.CloseAllHandles();
        	  System.exit(-2);
          }
        
        // Check and printwhich version is executed.
        switch ( getGameMode() )
        {
        case shareware:
        case indetermined:
            System.out.print("===========================================================================\n");
            System.out.print("                                Shareware!\n");
            System.out.print("===========================================================================\n");
            break;
        case registered:
        case retail:
        case commercial:
        case pack_tnt:
        case pack_plut:
        case pack_xbla:
            System.out.print("===========================================================================\n");
            System.out.print("                 Commercial product - do not distribute!\n");
            System.out.print("         Please report software piracy to the SPA: 1-800-388-PIR8\n");
            System.out.print("===========================================================================\n");
            break;

        default:
            // Ouch.
            break;
        }

        System.out.print("Tables.InitTables: Init trigonometric LUTs.\n");
        Tables.InitTables();

        System.out.print("M_Init: Init miscellaneous info.\n");
        M.Init ();

        System.out.print("R_Init: Init DOOM refresh daemon - ");
        R.Init ();
        
        System.out.print("AM_Init: Init Automap colors - ");
        AM.Init (); // Called here to set up configurable colors.

        System.out.print("\nP_Init: Init Playloop state.\n");
        P.Init ();

        System.out.print("I_Init: Setting up machine state.\n");
        I.Init ();

        System.out.print("D_CheckNetGame: Checking network game status.\n");
        CheckNetGame ();

        System.out.print("S_Init: Setting up sound.\n");
        
      // Sound "drivers" before the game sound controller.
        
        if (CM.CheckParmBool("-nomusic") || CM.CheckParmBool("-nosound"))
            this.IMUS=new DummyMusic();
        else
            this.IMUS=new DavidMusicModule();
        
        if (CM.CheckParmBool("-nosfx") ||  CM.CheckParmBool("-nosound"))
            this.ISND=new DummySFX();
        else {
            // Switch between possible sound drivers.
            // Crudish.
            if (CM.CheckParmBool("-audiolines"))
                this.ISND=	new DavidSFXModule(this,numChannels);
            else // PC Speaker emulation 
            if (CM.CheckParmBool("-speakersound"))
                this.ISND=  new SpeakerDoomSoundDriver(this,numChannels);
            else
            if (CM.CheckParmBool("-clipsound"))
                this.ISND=  new ClipSFXModule(this,numChannels);
            else  // This is the default
            if (CM.CheckParmBool("-classicsound"))
                this.ISND=  new ClassicDoomSoundDriver(this,numChannels);
            else  // This is the default
                this.ISND=  new SuperDoomSoundDriver(this,numChannels);

            }
        
        // Check for sound init failure and revert to dummy
        if (!ISND.InitSound()){
        	 System.err.println ("S_InitSound: failed. Reverting to dummy...\n");
        	this.ISND=new DummySFX();
        }
        
        if (!(CM.CheckParmBool("-nosound") || (ISND instanceof DummySFX)))// Obviously, nomusic && nosfx = nosound.
        	this.S=new AbstractDoomAudio(this,numChannels);
        else
        	// Saves a lot of distance calculations, 
        	// if we're not to output any sound at all.
            // TODO: create a Dummy that can handle music alone.
        	this.S=new DummySoundDriver();
        
        IMUS.InitMusic();
        S.Init (snd_SfxVolume *8, snd_MusicVolume *8 );

        // Hook audio to users.
        this.updateStatusHolders(this);
        
        System.out.print("HU_Init: Setting up heads up display.\n");
        HU.Init();

        System.out.print("ST_Init: Init status bar.\n");
        ST.Init ();

        // check for a driver that wants intermission stats
        p = CM.CheckParm ("-statcopy");
        if (eval(p) && p<CM.getArgc()-1)
        {
            // TODO: this should be chained to a logger
            //statcopy = CM.getArgv(p+1);
            System.out.print("External statistics registered.\n");
        }

        // start the apropriate game based on parms
        p = CM.CheckParm ("-record");

        if (eval(p) && p < CM.getArgc()-1)
        {
            RecordDemo (CM.getArgv(p+1));
            autostart = true;
        }
        
        // NOW it's safe to init the disk reader.
        DD.Init();

        // MAES: at this point everything should be set and initialized, so it's
        // time to make the players aware of the general status of Doom.
        //_D_ gonna try to initialize here, because it is needed to play a demo
        for (int i=0;i<MAXPLAYERS;i++){
            players[i].updateStatus(this);
        }

        //p = CM.CheckParm ("-timedemo");
        if (singletics)
        {
            TimeDemo (loaddemo);
            autostart = true;
            DoomLoop ();  // never returns
        }

        p = CM.CheckParm ("-loadgame");
        if (eval(p) && p < CM.getArgc()-1)
        {
            file.delete(0, file.length());
            if (eval(CM.CheckParm("-cdrom"))){
                file.append("c:\\doomdata\\");
                file.append(SAVEGAMENAME);
                file.append("%c.dsg");
                file.append(CM.getArgv(p+1).charAt(0));
            }
            else
            {
                file.append(String.format("%s%c.dsg",SAVEGAMENAME,
                    CM.getArgv(p+1).charAt(0)));

            }
            LoadGame(file.toString());
        }



        if ( gameaction != gameaction_t.ga_loadgame )
        {
            if (autostart || netgame)
                InitNew (startskill, startepisode, startmap);
            else
                StartTitle ();                // start up intro loop

        }


        if (fastdemo||normaldemo)
        {
            singledemo = true;              // quit after one demo
            if (fastdemo) timingdemo=true;
            InitNew (startskill, startepisode, startmap);
            gamestate=gamestate_t.GS_DEMOSCREEN;
            DeferedPlayDemo (loaddemo);
            DoomLoop ();  // never returns
        }

        
        
        DoomLoop ();  // never returns
    }


	protected abstract DoomVideoInterface<V> selectVideoInterface();


    protected int parseAsMapXX(String argv) {
    	
    	if (argv.length()!=5) return -1; // Nah.
    	if (argv.toLowerCase().lastIndexOf("map")!=0) return -1; // Meh.
    	int map;
    	try {
    		map=Integer.parseInt(argv.substring(3));
    	} catch (NumberFormatException e){
    		return -1; // eww
    	}
    	
		return map;
	}

    protected int parseAsExMx(String argv) {
    	
    	if (argv.length()!=4) return -1; // Nah.
    	if (argv.toLowerCase().lastIndexOf("e")!=0) return -1; // Meh.
    	if (argv.toLowerCase().lastIndexOf("m")!=2) return -1; // Meh.
    	int episode,mission;
    	try {
    		episode=Integer.parseInt(argv.substring(1,2));
    		mission=Integer.parseInt(argv.substring(3,4));
    	} catch (NumberFormatException e){
    		return -1; // eww
    	}
    	
		return episode*10+mission;
	}
    
	List<IVideoScaleAware> videoScaleChildren;

    public  void initializeVideoScaleStuff() {

        videoScaleChildren=new ArrayList<IVideoScaleAware>();

        // The automap...
        videoScaleChildren.add(this.AM);
        // The finale...
        videoScaleChildren.add(this.F);
        // The wiper...
        videoScaleChildren.add(this.WIPE);
        // The heads up...
        videoScaleChildren.add(this.HU);
        // The menu...
        videoScaleChildren.add(this.M);
        // The renderer (also has dependent children!)
        videoScaleChildren.add(this.R);
        // The Status Bar
        videoScaleChildren.add(this.ST);
        // Even the video renderer needs some initialization?
        videoScaleChildren.add(this.V);
        // wiper
        videoScaleChildren.add(this.WI);
        // disk drawer
        videoScaleChildren.add(this.DD);
        
        for(IVideoScaleAware i:videoScaleChildren){
            if (i!=null){
                i.setVideoScale(this.vs);
                i.initScaling();
            }
        }


    }


    /**
     * 
     */
    protected void CheckForPWADSInShareware() {
        if (modifiedgame)
        {
            // These are the lumps that will be checked in IWAD,
            // if any one is not present, execution will be aborted.
            String[] name=
            {
                    "e2m1","e2m2","e2m3","e2m4","e2m5","e2m6","e2m7","e2m8","e2m9",
                    "e3m1","e3m3","e3m3","e3m4","e3m5","e3m6","e3m7","e3m8","e3m9",
                    "dphoof","bfgga0","heada1","cybra1","spida1d1"
            };
            int i;

            // Oh yes I can.
            if ( isShareware())
                System.out.println("\nYou cannot -file with the shareware version. Register!");

            // Check for fake IWAD with right name,
            // but w/o all the lumps of the registered version. 
            if (isRegistered())
                for (i = 0;i < 23; i++)
                    if (W.CheckNumForName(name[i].toUpperCase())<0)
                        I.Error("\nThis is not the registered version: "+name[i]);
        }
    }

    /** Check whether the "doom.wad" we actually loaded
     *  is ultimate Doom's, by checking if it contains 
     *  e4m1 - e4m9.
     * 
     */
    protected void CheckForUltimateDoom(WadLoader W) {
        if (isRegistered())
        {
            // These are the lumps that will be checked in IWAD,
            // if any one is not present, execution will be aborted.
            String[] lumps=
            {
                    "e4m1","e4m2","e4m3","e4m4","e4m5","e4m6","e4m7","e4m8","e4m9"
            };

            // Check for fake IWAD with right name,
            // but w/o all the lumps of the registered version. 
            if (!CheckForLumps(lumps,W)) return;
            // Checks passed, so we can set the mode to Ultimate
            setGameMode(GameMode_t.retail);
        }

    }


    /** Check if ALL of the lumps exist.
     * 
     * @param name
     * @return
     */
    protected boolean CheckForLumps(String[] name, WadLoader W) {
        for (int i = 0;i < name.length; i++)
            if (W.CheckNumForName(name[i].toUpperCase())<0) {
                // Even one is missing? Not OK.
                return false; 
            }
        return true;
    }


    /**
     * 
     */
    protected void GenerateTitle() {
        switch ( getGameMode() )
        {
        case retail:
            title.append("                         ");
            title.append("The Ultimate DOOM Startup v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;
        case shareware:
            title.append("                            ");
            title.append("DOOM Shareware Startup v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;
        case registered:
            title.append("                            ");
            title.append("DOOM Registered Startup v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;
        case commercial:
            title.append("                            ");
            title.append("DOOM 2: Hell on Earth v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");

            break;
        case pack_plut:
            title.append("                            ");
            title.append("DOOM 2: Plutonia Experiment v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;
        case pack_tnt:
            title.append("                            ");
            title.append("DOOM 2: TNT - Evilution v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;
        case pack_xbla:
            title.append("                            ");
            title.append("DOOM 2: No Rest for the Living v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;

        default:
            title.append("                            ");
            title.append("Public DOOM - v");
            title.append(VERSION/100);
            title.append(".");
            title.append(VERSION%100);
            title.append("                           ");
            break;
        }
    }

    // Used in BuildTiccmd.
    protected ticcmd_t   base=new ticcmd_t();

    /**
     * G_BuildTiccmd
     * Builds a ticcmd from all of the available inputs
     * or reads it from the demo buffer. 
     * If recording a demo, write it out .
     * 
     * The CURRENT event to process is written to the various 
     * gamekeydown etc. arrays by the Responder method.
     * So look there for any fuckups in constructing them.
     * 
     */ 

    private void BuildTiccmd (ticcmd_t cmd) 
    { 
        int     i; 
        boolean strafe;
        boolean bstrafe; 
        int     speed, tspeed,lspeed; 
        int     forward;
        int     side;
        int look;

        //base = I_BaseTiccmd ();     // empty, or external driver
        // memcpy (cmd,base,sizeof(*cmd));
        base.copyTo(cmd);

        cmd.consistancy =  consistancy[consoleplayer][maketic%BACKUPTICS]; 

        strafe = gamekeydown[key_strafe] || mousebuttons(mousebstrafe) 
        || joybuttons(joybstrafe); 
        speed = ((gamekeydown[key_speed]^alwaysrun) || joybuttons(joybspeed))?1:0;

        forward = side = look= 0;
        
        // use two stage accelerative turning
        // on the keyboard and joystick
        if (joyxmove < 0 || joyxmove > 0 ||
        	gamekeydown[key_right] || gamekeydown[key_left]) 
            turnheld += ticdup; 
        else 
            turnheld = 0; 

        if (turnheld < SLOWTURNTICS) 
            tspeed = 2;             // slow turn 
        else 
            tspeed = speed;

        if(gamekeydown[key_lookdown] || gamekeydown[key_lookup])
    	{
    		lookheld += ticdup;
    	}
    	else
    	{
    		lookheld = 0;
    	}
    	if(lookheld < SLOWTURNTICS)
    	{
    		lspeed = 1;
    	}
    	else
    	{
    		lspeed = 2;
    	}
        
        // let movement keys cancel each other out
        if (strafe) 
        { 
            if (gamekeydown[key_right]) 
            {
                // fprintf(stderr, "strafe right\n");
                side += sidemove[speed]; 
            }
            if (gamekeydown[key_left]) 
            {
                //  fprintf(stderr, "strafe left\n");
                side -= sidemove[speed]; 
            }
            if (joyxmove > 0) 
                side += sidemove[speed]; 
            if (joyxmove < 0) 
                side -= sidemove[speed]; 

        } 
        else 
        { 
            if (gamekeydown[key_right]) 
                cmd.angleturn -= angleturn[tspeed]; 
            if (gamekeydown[key_left]) 
                cmd.angleturn += angleturn[tspeed]; 
            if (joyxmove > 0) 
                cmd.angleturn -= angleturn[tspeed]; 
            if (joyxmove < 0) 
                cmd.angleturn += angleturn[tspeed]; 
        } 

        if (gamekeydown[key_up]) 
        {
            //System.err.print("up\n");
            forward += forwardmove[speed]; 
        }
        if (gamekeydown[key_down]) 
        {
            //System.err.print("down\n");
            forward -= forwardmove[speed]; 
        }        
        
        if (joyymove < 0) 
            forward += forwardmove[speed]; 
        if (joyymove > 0) 
            forward -= forwardmove[speed]; 
        if (gamekeydown[key_straferight]) 
            side += sidemove[speed]; 
        if (gamekeydown[key_strafeleft]) 
            side -= sidemove[speed];

    	// Look up/down/center keys
    	if(gamekeydown[key_lookup])
    	{
    		System.err.print("Look up\n");
    		look = lspeed;
    	}
    	
    	if(gamekeydown[key_lookdown])
    	{
    		System.err.print("Look down\n");
    		look = -lspeed;
    	}
    	
    	if(gamekeydown[key_lookcenter])
    	{
    		System.err.print("Center look\n");
    		look = TOCENTER;
    	}
    	
        // buttons
        cmd.chatchar = HU.dequeueChatChar(); 

        if (gamekeydown[key_fire] || mousebuttons(mousebfire) 
                || joybuttons(joybfire)) 
            cmd.buttons |= BT_ATTACK; 

        if (gamekeydown[key_use] || joybuttons(joybuse) ) 
        { 
            cmd.buttons |= BT_USE;
            // clear double clicks if hit use button 
            dclicks = 0;                   
        } 

        // chainsaw overrides 
        for (i=0 ; i<NUMWEAPONS-1 ; i++)        
            if (gamekeydown['1'+i]) 
            { 
                //System.out.println("Attempting weapon change (building ticcmd)");
                cmd.buttons |= BT_CHANGE; 
                cmd.buttons |= i<<BT_WEAPONSHIFT; 
                break; 
            }

        // mouse
        if (mousebuttons(mousebforward)) 
            forward += forwardmove[speed];

        // forward double click (operator precedence? && over >
        if (mousebuttons(mousebforward) != (dclickstate!=0) && (dclicktime > 1) ) 
        { 
            dclickstate = mousebuttons(mousebforward)?1:0; 
            if (dclickstate!=0) 
                dclicks++; 
            if (dclicks == 2) 
            { 
                cmd.buttons |= BT_USE; 
                dclicks = 0; 
            } 
            else 
                dclicktime = 0; 
        } 
        else 
        { 
            dclicktime += ticdup; 
            if (dclicktime > 20) 
            { 
                dclicks = 0; 
                dclickstate = 0; 
            } 
        }

        // strafe double click
        bstrafe = mousebuttons(mousebstrafe) || joybuttons(joybstrafe); 
        if ((bstrafe != (dclickstate2!=0)) && dclicktime2 > 1 ) 
        { 
            dclickstate2 = bstrafe?1:0; 
            if (dclickstate2!=0) 
                dclicks2++; 
            if (dclicks2 == 2) 
            { 
                cmd.buttons |= BT_USE; 
                dclicks2 = 0; 
            } 
            else 
                dclicktime2 = 0; 
        } 
        else 
        { 
            dclicktime2 += ticdup; 
            if (dclicktime2 > 20) 
            { 
                dclicks2 = 0; 
                dclickstate2 = 0; 
            } 
        } 

        // By default, no vertical mouse movement
        if (!novert) forward += mousey; 

        if (strafe) 
            side += mousex*2; 
        else 
            cmd.angleturn -= mousex*0x8; 

        mousex = mousey = 0; 

        if (forward > MAXPLMOVE()) 
            forward = MAXPLMOVE(); 
        else if (forward < -MAXPLMOVE()) 
            forward = -MAXPLMOVE(); 
        if (side > MAXPLMOVE()) 
            side = MAXPLMOVE(); 
        else if (side < -MAXPLMOVE()) 
            side = -MAXPLMOVE(); 

        cmd.forwardmove += forward; 
        cmd.sidemove += side;

    	if(players[consoleplayer].playerstate == PST_LIVE)
    	{
    		if(look < 0)
    		{
    			look += 16;
    		}
    		
    		cmd.lookfly = (char) look;
    	}
        
        // special buttons
        if (sendpause) 
        { 
            sendpause = false; 
            cmd.buttons = BT_SPECIAL | BTS_PAUSE; 
        } 

        if (sendsave) 
        { 
            sendsave = false; 
            cmd.buttons = (char) (BT_SPECIAL | BTS_SAVEGAME | (savegameslot<<BTS_SAVESHIFT)); 
        } 
    } 


    //
    // G_DoLoadLevel 
    //
    //extern  gamestate_t     wipegamestate; 

    public boolean DoLoadLevel () 
    { 
        int             i; 

        // Set the sky map.
        // First thing, we have a dummy sky texture name,
        //  a flat. The data is in the WAD only because
        //  we look for an actual index, instead of simply
        //  setting one.
        TM.setSkyFlatNum(TM.FlatNumForName ( SKYFLATNAME ));

        // DOOM determines the sky texture to be used
        // depending on the current episode, and the game version.
        if (isCommercial()
                || ( gamemission == GameMission_t.pack_tnt )
                || ( gamemission == GameMission_t.pack_plut ) )
        {
            TM.setSkyTexture(TM.TextureNumForName ("SKY3"));
            if (gamemap < 12)
                TM.setSkyTexture(TM.TextureNumForName ("SKY1"));
            else
                if (gamemap < 21)
                    TM.setSkyTexture(TM.TextureNumForName ("SKY2"));
        }

        levelstarttic = gametic;        // for time calculation

        if (wipegamestate == gamestate_t.GS_LEVEL) 
            wipegamestate = gamestate_t.GS_MINUS_ONE;             // force a wipe 

        gamestate = gamestate_t.GS_LEVEL; 

        for (i=0 ; i<MAXPLAYERS ; i++) 
        { 
            if (playeringame[i] && players[i].playerstate == PST_DEAD) 
                players[i].playerstate = PST_REBORN; 
            // I don't give a shit if it's not super-duper optimal. 
            Arrays.fill(players[i].frags, 0);

        } 

        try {
        LL.SetupLevel (gameepisode, gamemap, 0, gameskill);
        } catch (Exception e){
        	e.printStackTrace();
        	// Failure loading level.
        	return false;
        }
        
        displayplayer = consoleplayer;      // view the guy you are playing    
        gameaction = gameaction_t.ga_nothing; 
        //Z_CheckHeap ();

        // clear cmd building stuff
        Arrays.fill(gamekeydown, false);
        keysCleared = true;
        joyxmove = joyymove = 0; 
        mousex = mousey = 0; 
        sendpause = sendsave = paused = false; 
        Arrays.fill (mousearray, false);
        Arrays.fill(joyarray, false); 
        
        
        // killough 5/13/98: in case netdemo has consoleplayer other than green
        ST.Start();
        HU.Start();
        
        // killough: make -timedemo work on multilevel demos
        // Move to end of function to minimize noise -- killough 2/22/98:

        if (timingdemo)
          {
            if (first)
              {
                starttime = RealTime.GetTime();
                first=false;
              }
          }
        
        // Try reclaiming some memory from limit-expanded buffers.
        R.resetLimits();
        return true;
    } 
    
    protected boolean first=true;
    
    // Maes: needed because a caps lock down signal is issued
    // as soon as the app gains focus. This causes lock keys to respond.
    // With this hack, they are ignored (?) the first time this happens.
    public boolean justfocused=true;

    /**
     * G_Responder  
     * Get info needed to make ticcmd_ts for the players.
     */

    public boolean Responder (event_t ev) 
    { 
        // allow spy mode changes even during the demo
        if (gamestate == gamestate_t.GS_LEVEL && ev.type == evtype_t.ev_keydown 
                && ev.data1 == KEY_F12 && (singledemo || !deathmatch) )
        {
            // spy mode 
            do 
            { 
                displayplayer++; 
                if (displayplayer == MAXPLAYERS) 
                    displayplayer = 0; 
            } while (!playeringame[displayplayer] && displayplayer != consoleplayer); 
            return true; 
        }

        // any other key pops up menu if in demos
        if (gameaction == gameaction_t.ga_nothing && !singledemo && 
                (demoplayback || gamestate == gamestate_t.GS_DEMOSCREEN) 
        ) 
        { 
            if (ev.type == evtype_t.ev_keydown ||  
                    (ev.type == evtype_t.ev_mouse && ev.data1!=0) || 
                    (ev.type == evtype_t.ev_joystick && ev.data1!=0) ) 
            { 
                M.StartControlPanel (); 
                return true; 
            } 
            return false; 
        } 

        if (gamestate == gamestate_t.GS_LEVEL) 
        { 

            if (devparm && ev.type == evtype_t.ev_keydown && ev.data1 == ';') 
            { 
                DeathMatchSpawnPlayer (0); 
                return true; 
            } 

            //automapactive=true;

            if (HU.Responder (ev)) 
                return true;    // chat ate the event 
            if (ST.Responder (ev)) 
                return true;    // status window ate it
            if (AM.Responder (ev)) 
                return true;    // automap ate it 

        } 

        if (gamestate == gamestate_t.GS_FINALE) 
        { 
            if (F.Responder (ev)) 
                return true;    // finale ate the event 
        } 

        switch (ev.type) 
        {
        case ev_clear:
        	// PAINFULLY and FORCEFULLY clear the buttons.
            Arrays.fill(gamekeydown, false);
            keysCleared = true;
            return false; // Nothing more to do here. 
        case ev_keydown: 
            if (ev.data1 == KEY_PAUSE) 
            { 
                sendpause = true; 
                return true; 
            }
            
            /* CAPS lock will only go through as a keyup event
            if (ev.data1 == KEY_CAPSLOCK) 
            { 
                if (justfocused) justfocused=false;
                    else
                // If caps are turned on, turn autorun on anyway.
                if (!alwaysrun) {
                    alwaysrun=true;
                    players[consoleplayer].message=String.format("Always run: %s",alwaysrun);
                    }
                return true; 
            } */
            
            if (ev.data1 <NUMKEYS) 
                gamekeydown[ev.data1] = true;
            return true;    // eat key down events 

        case ev_keyup:
            if (ev.data1 == KEY_CAPSLOCK) 
            { 
                if (justfocused) justfocused=false;
                    else
                    {
                    // Just toggle it. It's too hard to read the state.
                    alwaysrun=!alwaysrun;
                    players[consoleplayer].message=String.format("Always run: %s",alwaysrun);
                    }
            }
            
            if (ev.data1 <NUMKEYS) 
                gamekeydown[ev.data1] = false; 
            return false;   // always let key up events filter down 

        case ev_mouse:
            // Ignore them at the responder level
            if (use_mouse){
            mousebuttons(0, ev.data1 & 1); 
            mousebuttons(1, ev.data1 & 2); 
            mousebuttons(2, ev.data1 & 4);
            mousex = ev.data2*(mouseSensitivity+5)/10; 
            mousey = ev.data3*(mouseSensitivity+5)/10;
            }
            return true;    // eat events 

        case ev_joystick:
            if (use_joystick){
            joybuttons(0, ev.data1 & 1); 
            joybuttons(1, ev.data1 & 2); 
            joybuttons(2,ev.data1 & 4); 
            joybuttons(3,ev.data1 & 8); 
            joyxmove = ev.data2; 
            joyymove = ev.data3; 
            }
            return true;    // eat events 

        default: 
            break; 
        } 

        return false; 
    } 


    private final String turbomessage="is turbo!"; 

    /**
     * G_Ticker
     * Make ticcmd_ts for the players.
     */

    public void Ticker () 
    { 
        int     i;
        int     buf; 
        ticcmd_t   cmd;

        // do player reborns if needed
        for (i=0 ; i<MAXPLAYERS ; i++) 
            if (playeringame[i] && players[i].playerstate == PST_REBORN) 
                DoReborn (i);

        // do things to change the game state
        while (gameaction != gameaction_t.ga_nothing) 
        { 
            switch (gameaction) 
            { 
            case ga_loadlevel: 
                DoLoadLevel ();
                break; 
            case ga_newgame: 
                DoNewGame (); 
                break; 
            case ga_loadgame:
                DoLoadGame (); 
                break; 
            case ga_savegame: 
                DoSaveGame (); 
                break; 
            case ga_playdemo: 
                DoPlayDemo (); 
                break; 
            case ga_completed: 
                DoCompleted (); 
                break; 
            case ga_victory: 
                F.StartFinale (); 
                break; 
            case ga_worlddone: 
                DoWorldDone (); 
                break; 
            case ga_screenshot: 
                ScreenShot (); 
                gameaction = gameaction_t.ga_nothing; 
                break; 
            case ga_nothing: 
                break; 
            } 
        }

        // get commands, check consistancy,
        // and build new consistancy check
        buf = (gametic/ticdup)%BACKUPTICS; 

        for (i=0 ; i<MAXPLAYERS ; i++)
        {
            if (playeringame[i]) 
            { 
                cmd = players[i].cmd; 
                //System.out.println("Current command:"+cmd);

                //memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t));
                netcmds[i][buf].copyTo(cmd);

                // MAES: this is where actual demo commands are being issued or created!
                // Essentially, a demo is a sequence of stored ticcmd_t with a header.
                // Knowing that, it's possible to objectify it.
                if (demoplayback) 
                    ReadDemoTiccmd (cmd); 
                if (demorecording) 
                    WriteDemoTiccmd (cmd);

                // check for turbo cheats
                if (cmd.forwardmove > TURBOTHRESHOLD 
                        && ((gametic&31)==0) && ((gametic>>5)&3) == i )
                {

                    //extern char *player_names[4];
                    //sprintf (turbomessage, "%s is turbo!",player_names[i]);
                    players[consoleplayer].message = hu.HU.player_names[i]+turbomessage;
                }

                if (netgame && !netdemo && (gametic%ticdup)==0 ) 
                { 
                    if (gametic > BACKUPTICS 
                            && consistancy[i][buf] != cmd.consistancy) 
                    { 
                        I.Error ("consistency failure (%d should be %d)",
                            cmd.consistancy, consistancy[i][buf]); 
                    } 
                    if (players[i].mo!=null) 
                        consistancy[i][buf] = (short) players[i].mo.x; 
                    else 
                        consistancy[i][buf] = (short) RND.getIndex(); 
                } 
            }
        }

        // check for special buttons
        for (i=0 ; i<MAXPLAYERS ; i++)
        {
            if (playeringame[i]) 
            { 
                if ((players[i].cmd.buttons & BT_SPECIAL)!=0) 
                { 
                    switch (players[i].cmd.buttons & BT_SPECIALMASK) 
                    { 
                    case BTS_PAUSE:
                        // MAES: fixed stupid ^pause bug.
                        paused = !paused; 
                        if (paused)
                            S.PauseSound ();
                        else
                            S.ResumeSound (); 
                        break; 

                    case BTS_SAVEGAME: 
                        if (savedescription==null) 
                            savedescription=new String( "NET GAME"); 
                        savegameslot =  
                            (players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT; 
        gameaction = gameaction_t.ga_savegame; 
        break; 
                    } 
                } 
            }
        }

        // do main actions
        switch (gamestate) 
        { 
        case GS_LEVEL: 
            P.Ticker (); 
            ST.Ticker (); 
            AM.Ticker (); 
            HU.Ticker ();            
            break; 

        case GS_INTERMISSION: 
            WI.Ticker (); 
            break; 

        case GS_FINALE: 
            F.Ticker (); 
            break; 

        case GS_DEMOSCREEN: 
            PageTicker (); 
            break; 
        }        
    } 


    //
    // PLAYER STRUCTURE FUNCTIONS
    // also see P_SpawnPlayer in P_Things
    //

    /**
     * G_InitPlayer
     * Called at the start.
     * Called by the game initialization functions.
     *
     * MAES: looks like dead code. It's never called.
     *
     */

    protected void InitPlayer (int player) 
    { 
        player_t   p; 

        // set up the saved info         
        p = players[player]; 

        // clear everything else to defaults 
        p.PlayerReborn (); 

    } 
    
    //
    // G_CheckSpot  
    // Returns false if the player cannot be respawned
    // at the given mapthing_t spot  
    // because something is occupying it 
    //
    //void P_SpawnPlayer (mapthing_t* mthing); 

    private boolean
    CheckSpot
    ( int       playernum,
            mapthing_t   mthing ) 
    { 
        int     x,y; // fixed_t 
        subsector_t    ss; 
        int        an; // angle 
        mobj_t     mo; 


        if (players[playernum].mo==null)
        {
            // first spawn of level, before corpses
            for (int i=0 ; i<playernum ; i++)
                if (players[i].mo.x == mthing.x << FRACBITS
                        && players[i].mo.y == mthing.y << FRACBITS)
                    return false;   
            return true;
        }

        x = mthing.x << FRACBITS; 
        y = mthing.y << FRACBITS; 

        if (!P.CheckPosition (players[playernum].mo, x, y) )
            return false;

        // flush an old corpse if needed 
        if (bodyqueslot >= BODYQUESIZE) 
            P.RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]); 
        bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo; 
        bodyqueslot++; 

        // spawn a teleport fog 
        ss = LL.PointInSubsector (x,y); 
        // Angles stored in things are supposed to be "sanitized" against rollovers.
        an = (int) (( ANG45 * (mthing.angle/45) ) >>> ANGLETOFINESHIFT); 

        mo = P.SpawnMobj (x+20*finecosine[an], y+20*finesine[an] 
                                                             , ss.sector.floorheight 
                                                             , mobjtype_t.MT_TFOG); 

        if (players[consoleplayer].viewz != 1) ; 
        S.StartSound (mo, sfxenum_t.sfx_telept);  // don't start sound on first frame 

        return true; 
    } 


    //
    // G_DeathMatchSpawnPlayer 
    // Spawns a player at one of the random death match spots 
    // called at level load and each death 
    //
    @Override
    public void DeathMatchSpawnPlayer (int playernum) 
    { 
        int             i,j; 
        int             selections; 

        selections = deathmatch_p; 
        if (selections < 4) 
            I.Error ("Only %d deathmatch spots, 4 required", selections); 

        for (j=0 ; j<20 ; j++) 
        { 
            i = RND.P_Random() % selections; 
            if (CheckSpot (playernum, deathmatchstarts[i]) ) 
            { 
                deathmatchstarts[i].type = (short) (playernum+1); 
                P.SpawnPlayer (deathmatchstarts[i]); 
                return; 
            } 
        } 

        // no good spot, so the player will probably get stuck
        // MAES: seriously, fuck him.
        P.SpawnPlayer (playerstarts[playernum]); 
    } 

    //
    // G_DoReborn 
    // 

    public void DoReborn (int playernum) 
    { 
        int                             i; 

        if (!netgame)
        {
            // reload the level from scratch
            gameaction = gameaction_t.ga_loadlevel;  
        }
        else 
        {
            // respawn at the start

            // first dissasociate the corpse 
            players[playernum].mo.player = null;   

            // spawn at random spot if in death match 
            if (deathmatch) 
            { 
                DeathMatchSpawnPlayer (playernum); 
                return; 
            } 

            if (CheckSpot (playernum, playerstarts[playernum]) ) 
            { 
                P.SpawnPlayer (playerstarts[playernum]); 
                return; 
            }

            // try to spawn at one of the other players spots 
            for (i=0 ; i<MAXPLAYERS ; i++)
            {
                if (CheckSpot (playernum, playerstarts[i]) ) 
                { 
                    playerstarts[i].type = (short) (playernum+1); // fake as other player 
                    P.SpawnPlayer (playerstarts[i]); 
                    playerstarts[i].type = (short) (i+1);     // restore 
                    return; 
                }       
                // he's going to be inside something.  Too bad.
                // MAES: Yeah, they're like, fuck him.
            }
            P.SpawnPlayer (playerstarts[playernum]); 
        } 
    } 

    /** DOOM Par Times [4][10] */
    final int[][] pars = 
    { 
            {0}, 
            {0,30,75,120,90,165,180,180,30,165}, 
            {0,90,90,90,120,90,360,240,30,170}, 
            {0,90,45,90,150,90,90,165,30,135} 
    }; 

    /** DOOM II Par Times */
    final int[] cpars =
    {
            30,90,120,120,90,150,120,120,270,90,    //  1-10
            210,150,150,150,210,150,420,150,210,150,    // 11-20
            240,150,180,150,150,300,330,420,300,180,    // 21-30
            120,30                  // 31-32
    };


    //
    // G_DoCompleted 
    //
    boolean     secretexit; 

    public final void ExitLevel () 
    { 
        secretexit = false; 
        gameaction = gameaction_t.ga_completed; 
    } 

    // Here's for the german edition.
    public void SecretExitLevel () 
    { 
        // IF NO WOLF3D LEVELS, NO SECRET EXIT!
        if ( isCommercial()
                && (W.CheckNumForName("MAP31")<0))
            secretexit = false;
        else
            secretexit = true; 
        gameaction =  gameaction_t.ga_completed; 
    } 

    protected void DoCompleted () 
    { 
        int             i; 

        gameaction =  gameaction_t.ga_nothing; 

        for (i=0 ; i<MAXPLAYERS ; i++) 
            if (playeringame[i]) 
                players[i].PlayerFinishLevel ();        // take away cards and stuff 

        if (automapactive) 
            AM.Stop (); 

        if ( !isCommercial())
            switch(gamemap)
            {
            case 8:
                // MAES: end of episode
                gameaction =  gameaction_t.ga_victory;
                return;
            case 9:
                // MAES: end of secret level
                for (i=0 ; i<MAXPLAYERS ; i++) 
                    players[i].didsecret = true; 
                break;
            }

        /*  Hmmm - why? MAES: Clearly redundant.
        if ( (gamemap == 8)
                && (!isCommercial()) ) 
        {
            // victory 
            gameaction =  gameaction_t.ga_victory; 
            return; 
        } 

        if ( (gamemap == 9)
                && !isCommercial() ) 
        {
            // exit secret level 
            for (i=0 ; i<MAXPLAYERS ; i++) 
                players[i].didsecret = true; 
        } 
         */


        wminfo.didsecret = players[consoleplayer].didsecret; 
        wminfo.epsd = gameepisode -1; 
        wminfo.last = gamemap -1;

        // wminfo.next is 0 biased, unlike gamemap
        if ( isCommercial())
        {
            if (secretexit)
                switch(gamemap)
                {
                case 15: wminfo.next = 30; break;
                case 31: wminfo.next = 31; break;
                }
            else
                switch(gamemap)
                {
                case 31:
                case 32: wminfo.next = 15; break;
                default: wminfo.next = gamemap;
                }
        }
        else
        {
            if (secretexit) 
                wminfo.next = 8;    // go to secret level 
            else if (gamemap == 9) 
            {
                // returning from secret level 
                switch (gameepisode) 
                { 
                case 1: 
                    wminfo.next = 3; 
                    break; 
                case 2: 
                    wminfo.next = 5; 
                    break; 
                case 3: 
                    wminfo.next = 6; 
                    break; 
                case 4:
                    wminfo.next = 2;
                    break;
                }                
            } 
            else 
                wminfo.next = gamemap;          // go to next level 
        }

        wminfo.maxkills = totalkills; 
        wminfo.maxitems = totalitems; 
        wminfo.maxsecret = totalsecret; 
        wminfo.maxfrags = 0; 
        if ( isCommercial() )
            wminfo.partime = 35*cpars[gamemap-1]; 
        else if (gameepisode >= pars.length)
            wminfo.partime = 0;
        else
            wminfo.partime = 35*pars[gameepisode][gamemap]; 
        wminfo.pnum = consoleplayer; 

        for (i=0 ; i<MAXPLAYERS ; i++) 
        { 
            wminfo.plyr[i].in = playeringame[i]; 
            wminfo.plyr[i].skills = players[i].killcount; 
            wminfo.plyr[i].sitems = players[i].itemcount; 
            wminfo.plyr[i].ssecret = players[i].secretcount; 
            wminfo.plyr[i].stime = leveltime;
            C2JUtils.memcpy (wminfo.plyr[i].frags, players[i].frags 
                , wminfo.plyr[i].frags.length); 
        } 

        gamestate = gamestate_t.GS_INTERMISSION; 
        viewactive = false; 
        automapactive = false; 

        if (statcopy!=null)
            C2JUtils.memcpy (statcopy, wminfo,1);

        WI.Start (wminfo); 
    } 


    /**
     * G_WorldDone 
     */

    public void WorldDone () 
    { 
        gameaction = gameaction_t.ga_worlddone; 

        if (secretexit) 
            players[consoleplayer].didsecret = true; 

        if ( isCommercial() )
        {
            switch (gamemap)
            {
            case 15:
            case 31:
                if (!secretexit)
                    break;
            case 6:
            case 11:
            case 20:
            case 30:
                F.StartFinale ();
                break;
            }
        }
    } 

    public void DoWorldDone () 
    {        
        gamestate = gamestate_t.GS_LEVEL; 
        gamemap = wminfo.next+1; 
        DoLoadLevel (); 
        gameaction = gameaction_t.ga_nothing; 
        viewactive = true; 
    } 



    //
    // G_InitFromSavegame
    // Can be called by the startup code or the menu task. 
    //
    //extern boolean setsizeneeded;
    //void R_ExecuteSetViewSize (void);

    String    savename;

    public void LoadGame (String name) 
    { 
        savename=new String(name); 
        gameaction = gameaction_t.ga_loadgame; 
    } 



    /** This is fugly. Making a "savegame object" will make at least certain comparisons
     *  easier, and avoid writing code twice.
     */

    protected void DoLoadGame () 
    { 
        try{ 
            int     i;  
            StringBuffer vcheck=new StringBuffer();
            VanillaDSGHeader header=new VanillaDSGHeader();
            IDoomSaveGame dsg=new VanillaDSG();
            dsg.updateStatus(this.DM);
            
            gameaction = gameaction_t.ga_nothing; 

            DataInputStream f=new DataInputStream(new BufferedInputStream(new FileInputStream(savename))); 

            header.read(f);
            f.close();
    
            // skip the description field 
            vcheck.append("version ");
            vcheck.append(VERSION);

            if (vcheck.toString().compareTo(header.getVersion())!=0) {
            	f.close();
            	return; // bad version
            }

            // Ok so far, reopen stream.
            f=new DataInputStream(new BufferedInputStream(new FileInputStream(savename)));        
            gameskill = header.getGameskill(); 
            gameepisode = header.getGameepisode(); 
            gamemap = header.getGamemap(); 
            for (i=0 ; i<MAXPLAYERS ; i++) 
                playeringame[i] = header.getPlayeringame()[i]; 

            // load a base level 
            InitNew (gameskill, gameepisode, gamemap); 
            
            if (gameaction == gameaction_t.ga_failure) {
            	// failure to load. Abort.
            	f.close();
            	return;
            }

            gameaction = gameaction_t.ga_nothing;
            
            // get the times 
            leveltime = header.getLeveltime(); 

            // dearchive all the modifications
            boolean ok=dsg.doLoad(f);
            f.close();

            // MAES: this will cause a forced exit.
            // The problem is that the status will have already been altered 
            // (perhaps VERY badly) so it makes no sense to progress.
            // If you want it bullet-proof, you could implement
            // a "tentative loading" subsystem, which will only alter the game
            // if everything works out without errors. But who cares :-p
            if (!ok) 
                I.Error("Bad savegame");

            // done 
            //Z_Free (savebuffer); 

            if (R.getSetSizeNeeded())
                R.ExecuteSetViewSize ();

            // draw the pattern into the back screen
            R.FillBackScreen ();   
        } catch (Exception e){
            e.printStackTrace();
        }
    } 


    //
    // G_SaveGame
    // Called by the menu task.
    // Description is a 24 byte text string 
    //
    public void
    SaveGame
    ( int   slot,
            String description ) 
    { 
        savegameslot = slot; 
        savedescription=new String(description); 
        sendsave = true; 
    } 

    protected void DoSaveGame () 
    { 
     
        try{
     String    name; 
     //char[]    name2=new char[VERSIONSIZE]; 
     String   description;
     StringBuffer build=new StringBuffer();
     IDoomSaveGameHeader header=new VanillaDSGHeader();
     IDoomSaveGame dsg=new VanillaDSG();
     dsg.updateStatus(this.DM);
     
     if (eval(CM.CheckParm("-cdrom"))) {
         build.append("c:\\doomdata\\");
         build.append(SAVEGAMENAME);
         build.append("%d.dsg");
     } else {         
      build.append(SAVEGAMENAME);
      build.append("%d.dsg"); 
     }
     
     name=String.format(build.toString(), savegameslot);
     
     description = savedescription; 

     header.setName(description);
     header.setVersion(String.format("version %d",VERSION));
     header.setGameskill(gameskill);
     header.setGameepisode(gameepisode);
     header.setGamemap(gamemap);
     header.setPlayeringame(playeringame);
     header.setLeveltime(leveltime);
     dsg.setHeader(header);
     
     // Try opening a save file. No intermediate buffer (performance?)
     DataOutputStream f=new DataOutputStream(new FileOutputStream(name));
     boolean ok=dsg.doSave(f);
     f.close();
        } catch (Exception e){
            e.printStackTrace();
        }
     // Saving is not as destructive as loading.
     
     gameaction = gameaction_t.ga_nothing; 
        savedescription = "";      

        players[consoleplayer].message = GGSAVED; 

        // draw the pattern into the back screen
        R.FillBackScreen ();
     

    } 



    skill_t d_skill; 
    int     d_episode; 
    int     d_map; 

    public void
    DeferedInitNew
    ( skill_t   skill,
            int       episode,
            int       map) 
    { 
        d_skill = skill; 
        d_episode = episode; 
        d_map = map; 
        gameaction = gameaction_t.ga_newgame; 
    } 


    public void DoNewGame () 
    {
        demoplayback = false; 
        netdemo = false;
        netgame = false;
        deathmatch = false;
        playeringame[1] = playeringame[2] = playeringame[3] = false;
        respawnparm = false;
        fastparm = false;
        nomonsters = false;
        consoleplayer = 0;
        InitNew (d_skill, d_episode, d_map); 
        gameaction = gameaction_t.ga_nothing; 
    } 


    /**
     * G_InitNew
     * Can be called by the startup code or the menu task,
     * consoleplayer, displayplayer, playeringame[] should be set. 
     */

    public void InitNew
    ( skill_t   skill,
            int       episode,
            int       map ) 
    { 
        int             i; 

        if (paused) 
        { 
            paused = false; 
            S.ResumeSound (); 
        } 


        if (skill.ordinal() > skill_t.sk_nightmare.ordinal()) 
            skill = skill_t.sk_nightmare;


        // This was quite messy with SPECIAL and commented parts.
        // Supposedly hacks to make the latest edition work.
        // It might not work properly.
        if (episode < 1)
            episode = 1; 

        if ( isRetail() )
        {
            if (episode > 4)
                episode = 4;
        }
        else if ( isShareware() )
        {
            if (episode > 1) 
                episode = 1; // only start episode 1 on shareware
        }  
        else
        {
            if (episode > 3)
                episode = 3;
        }



        if (map < 1) 
            map = 1;

        if ( (map > 9)
                && ( !isCommercial()))
            map = 9; 

        RND.ClearRandom (); 

        if (skill == skill_t.sk_nightmare || respawnparm )
            respawnmonsters = true;
        else
            respawnmonsters = false;

        // If on nightmare/fast monsters make everything MOAR pimp.

        if (fastparm || (skill == skill_t.sk_nightmare && gameskill != skill_t.sk_nightmare) )
        { 
            for (i=statenum_t.S_SARG_RUN1.ordinal() ; i<=statenum_t.S_SARG_PAIN2.ordinal() ; i++) 
                states[i].tics >>= 1; 
            mobjinfo[mobjtype_t.MT_BRUISERSHOT.ordinal()].speed = 20*MAPFRACUNIT; 
            mobjinfo[mobjtype_t.MT_HEADSHOT.ordinal()].speed = 20*MAPFRACUNIT; 
            mobjinfo[mobjtype_t.MT_TROOPSHOT.ordinal()].speed = 20*MAPFRACUNIT; 
        } 
        else if (skill != skill_t.sk_nightmare && gameskill == skill_t.sk_nightmare) 
        { 
            for (i=statenum_t.S_SARG_RUN1.ordinal() ; i<=statenum_t.S_SARG_PAIN2.ordinal() ; i++) 
                states[i].tics <<= 1; 
            mobjinfo[mobjtype_t.MT_BRUISERSHOT.ordinal()].speed = 15*MAPFRACUNIT; 
            mobjinfo[mobjtype_t.MT_HEADSHOT.ordinal()].speed = 10*MAPFRACUNIT; 
            mobjinfo[mobjtype_t.MT_TROOPSHOT.ordinal()].speed = 10*MAPFRACUNIT; 
        } 


        // force players to be initialized upon first level load         
        for (i=0 ; i<MAXPLAYERS ; i++) 
            players[i].playerstate = PST_REBORN; 

        usergame = true;                // will be set false if a demo 
        paused = false; 
        demoplayback = false; 
        automapactive = false; 
        viewactive = true; 
        gameepisode = episode; 
        gamemap = map; 
        gameskill = skill; 

        viewactive = true;

        // set the sky map for the episode
        if ( isCommercial())
        {
            TM.setSkyTexture(TM.TextureNumForName ("SKY3"));
            if (gamemap < 12)
                TM.setSkyTexture(TM.TextureNumForName ("SKY1"));
            else
                if (gamemap < 21)
                    TM.setSkyTexture(TM.TextureNumForName ("SKY2"));
        }
        else
            switch (episode) 
            { 
            case 1: 
                TM.setSkyTexture(TM.TextureNumForName ("SKY1")); 
                break; 
            case 2: 
                TM.setSkyTexture(TM.TextureNumForName ("SKY2"));
                break; 
            case 3: 
                TM.setSkyTexture(TM.TextureNumForName ("SKY3")); 
                break; 
            case 4:   // Special Edition sky
                TM.setSkyTexture(TM.TextureNumForName ("SKY4"));
                break;
            } 

        if (!DoLoadLevel ()) levelLoadFailure();
    } 

    protected void levelLoadFailure(){
    	boolean endgame=I.GenerateAlert(Strings.LEVEL_FAILURE_TITLE, Strings.LEVEL_FAILURE_CAUSE);
    	
    	if (endgame){         	// Initiate endgame
    	gameaction=gameaction_t.ga_failure;
    	gamestate = gamestate_t.GS_DEMOSCREEN; 
    	M.ClearMenus();
    	StartTitle();
    	} else {
    	// Shutdown immediately.
    	I.Quit();	
    	}
    }

    //
    // DEMO RECORDING 
    // 
    public  void ReadDemoTiccmd (ticcmd_t cmd) 
    { 
        IDemoTicCmd democmd=demobuffer.getNextTic();
        if (democmd == null) 
        {
            // end of demo data stream 
            CheckDemoStatus ();

            // Force status resetting
            this.demobuffer.resetDemo();
            return; 
        }

        democmd.decode(cmd); 
    } 

    public void WriteDemoTiccmd (ticcmd_t cmd) 
    { 
        if (gamekeydown['q'])           // press q to end demo recording 
            CheckDemoStatus ();
        IDemoTicCmd reccmd=new VanillaTiccmd();
        reccmd.encode(cmd);     
        demobuffer.putTic(reccmd);

        // MAES: Useless, we can't run out of space anymore (at least not in theory).

        /*   demobuffer[demo_p++] = cmd.forwardmove; 
     demobuffer[demo_p++] = cmd.sidemove; 
     demobuffer[demo_p++] = (byte) ((cmd.angleturn+128)>>8); 
     demobuffer[demo_p++] = (byte) cmd.buttons; 
     demo_p -= 4; 
     if (demo_p > demoend - 16)
     {
     // no more space 
     CheckDemoStatus (); 
     return; 
     } */ 

        //ReadDemoTiccmd (cmd);         // make SURE it is exactly the same
        // MAES: this is NOT the way to do in Mocha, because we are not manipulating
        // the demo index directly anymore. Instead, decode what we have just saved.     
        reccmd.decode(cmd);

    } 



    /**
     * G_RecordDemo 
     */ 
    public void RecordDemo (String name) 
    { 

        StringBuffer buf=new StringBuffer();
        usergame = false; 
        buf.append(name); 
        buf.append(".lmp");
        demoname=buf.toString();
        demobuffer = new VanillaDoomDemo(); 
        demorecording = true; 
    } 


    public void BeginRecording () 
    {         
        demobuffer.setVersion(VERSION);
        demobuffer.setSkill(gameskill); 
        demobuffer.setEpisode(gameepisode);
        demobuffer.setMap(gamemap);
        demobuffer.setDeathmatch(deathmatch);
        demobuffer.setRespawnparm(respawnparm);
        demobuffer.setFastparm(fastparm);
        demobuffer.setNomonsters(nomonsters);
        demobuffer.setConsoleplayer(consoleplayer);
        demobuffer.setPlayeringame(playeringame);
    }
    
    String   defdemoname;
    
    /**
     * G_PlayDemo 
     */

    public void DeferedPlayDemo (String name) 
    { 
        defdemoname = name; 
        gameaction = gameaction_t.ga_playdemo; 
    } 

    public void DoPlayDemo () 
    { 

        skill_t skill;
        boolean fail=false;
        int             i, episode, map; 

        gameaction = gameaction_t.ga_nothing;
        // MAES: Yeah, it's OO all the way now, baby ;-)
        try {
        demobuffer = (IDoomDemo) W.CacheLumpName(defdemoname.toUpperCase(), PU_STATIC,VanillaDoomDemo.class);
        } catch (Exception e){
            fail=true;
        }
        
        fail=(demobuffer.getSkill()==null);

        if (fail || demobuffer.getVersion()!= VERSION)
        {
            System.err.println("Demo is from a different game version!\n");
            System.err.println("Version code read: "+demobuffer.getVersion());
            gameaction = gameaction_t.ga_nothing;
            return;
        }

        skill = demobuffer.getSkill(); 
        episode = demobuffer.getEpisode(); 
        map = demobuffer.getMap(); 
        deathmatch = demobuffer.isDeathmatch();
        respawnparm = demobuffer.isRespawnparm();
        fastparm = demobuffer.isFastparm();
        nomonsters = demobuffer.isNomonsters();
        consoleplayer = demobuffer.getConsoleplayer();
        // Do this, otherwise previously loaded demos will be stuck at their end.
        demobuffer.resetDemo();
        
        boolean[] pigs=demobuffer.getPlayeringame();
        for (i=0 ; i<MAXPLAYERS ; i++) 
            playeringame[i] = pigs[i]; 
        if (playeringame[1]) 
        {
            netgame = true; 
            netdemo = true; 
        }

        // don't spend a lot of time in loadlevel 
        precache = false;
        InitNew (skill, episode, map); 
        precache = true;

        usergame = false; 
        demoplayback = true; 

    }

    //
    // G_TimeDemo 
    //
    public void TimeDemo (String name) 
    {    
        nodrawers = CM.CheckParm ("-nodraw")!=0; 
        noblit = CM.CheckParm ("-noblit")!=0; 
        timingdemo = true; 
        singletics = true;
        defdemoname = name;
        gameaction = gameaction_t.ga_playdemo; 
    } 

    
    /** G_CheckDemoStatus
     * 
     * Called after a death or level completion to allow demos to be cleaned up
     * Returns true if a new demo loop action will take place
     *  
     */ 

    public boolean CheckDemoStatus () 
    { 
        int endtime; 
        
        if (timingdemo) 
        {
            endtime = RealTime.GetTime ();
            // killough -- added fps information and made it work for longer demos:
            long realtics=endtime-starttime;    
            
            this.commit();
            VM.SaveDefaults(VM.getDefaultFile());
            I.Error ("timed %d gametics in %d realtics = %f frames per second",gametic 
                , realtics, gametic*(double)(TICRATE)/realtics); 
        }

        if (demoplayback) 
        {
            if (singledemo) 
                I.Quit ();

            // Z_ChangeTag (demobuffer, PU_CACHE); 
            demoplayback = false; 
            netdemo = false;
            netgame = false;
            deathmatch = false;
            playeringame[1] = playeringame[2] = playeringame[3] = false;
            respawnparm = false;
            fastparm = false;
            nomonsters = false;
            consoleplayer = 0;
            AdvanceDemo (); 
            return true; 
        } 

        if (demorecording) 
        { 
            //demobuffer[demo_p++] = (byte) DEMOMARKER; 

            MenuMisc.WriteFile(demoname, demobuffer); 
            //Z_Free (demobuffer); 
            demorecording = false; 
            I.Error ("Demo %s recorded",demoname); 
        } 

        return false; 
    } 

    /** This should always be available for real timing */
    protected ITicker RealTime;
    
    public DoomMain(){
        // Init game status...
        super();
        C2JUtils.initArrayOfObjects(events,event_t.class);
        this.I=new DoomSystem();
        gamestate=gamestate_t.GS_DEMOSCREEN;        
        
        this.RealTime=new MilliTicker();
    }

   
    
    protected void updateStatusHolders(DoomStatus<T,V> DS){
        for (DoomStatusAware dsa : status_holders){
            dsa.updateStatus(DS);
        }
    }

    /** A list with objects that do hold status and need to be aware of 
     *  it.
     */
    protected List<DoomStatusAware> status_holders;

 


    /* Since it's so intimately tied, it's less troublesome to merge the "main" and "network"
     *  code. 
     * 
     */


    /** To be initialized by the DoomNetworkingInterface via a setter */
    //private  doomcom_t   doomcom;   
    //private  doomdata_t  netbuffer;      // points inside doomcom
    protected StringBuilder sb=new StringBuilder();


    //
    // NETWORKING
    //
    // gametic is the tic about to (or currently being) run
    // maketic is the tick that hasn't had control made for it yet
    // nettics[] has the maketics for all players 
    //
    // a gametic cannot be run until nettics[] > gametic for all players
    //

    //ticcmd_t[]  localcmds= new ticcmd_t[BACKUPTICS];

    //ticcmd_t [][]       netcmds=new ticcmd_t [MAXPLAYERS][BACKUPTICS];
    int[]           nettics=new int[MAXNETNODES];
    boolean[]       nodeingame=new boolean[MAXNETNODES];        // set false as nodes leave game
    boolean[]       remoteresend=new boolean[MAXNETNODES];      // set when local needs tics
    int[]       resendto=new int[MAXNETNODES];          // set when remote needs tics
    int[]       resendcount=new int[MAXNETNODES];

    int[]       nodeforplayer=new int[MAXPLAYERS];

    int             maketic;
    int     lastnettic;
    int     skiptics;
    protected int     ticdup;


    public int getTicdup() {
        return ticdup;
    }


    public void setTicdup(int ticdup) {
        this.ticdup = ticdup;
    }






    int     maxsend; // BACKUPTICS/(2*ticdup)-1;


    //void D_ProcessEvents (void); 
    //void G_BuildTiccmd (ticcmd_t *cmd); 
    //void D_DoAdvanceDemo (void);

    // _D_
    boolean     reboundpacket = false;
    doomdata_t  reboundstore = new doomdata_t();


    // 
    //
    //123

    /** MAES: interesting. After testing it was found to return the following size:
     *  (8*(netbuffer.numtics+1));
     */

    int NetbufferSize ()
    {
        //    return (int)(((doomdata_t)0).cmds[netbuffer.numtics]);
        return (8*(netbuffer.numtics+1));
    }


    protected long NetbufferChecksum ()
    {
        long        c;
        int     i,l;

        c = 0x1234567L;

        // FIXME -endianess?
        if (NORMALUNIX)
            return 0;           // byte order problems


        /* Here it was trying to get the length of a doomdata_t struct up to retransmit from.
         * l = (NetbufferSize () - (int)&(((doomdata_t *)0)->retransmitfrom))/4;
         * (int)&(((doomdata_t *)0)->retransmitfrom) evaluates to "4"
         * Therefore, l= (netbuffersize - 4)/4
         * 
         */
        l = (NetbufferSize () - 4)/4;
        for (i=0 ; i<l ; i++)
            // TODO: checksum would be better computer in the netbuffer itself.
            // The C code actually takes all fields into account.
            c += 0;// TODO: (netbuffer->retransmitfrom)[i] * (i+1);

        return c & NCMD_CHECKSUM;
    }
    //
    //
    //
    protected int ExpandTics (int low)
    {
        int delta;

        delta = low - (maketic&0xff);

        if (delta >= -64 && delta <= 64)
            return (maketic&~0xff) + low;
        if (delta > 64)
            return (maketic&~0xff) - 256 + low;
        if (delta < -64)
            return (maketic&~0xff) + 256 + low;

        I.Error ("ExpandTics: strange value %d at maketic %d",low,maketic);
        return 0;
    }



    /**
     * HSendPacket
     *
     * Will send out a packet to all involved parties. A special
     * case is the rebound storage, which acts as a local "echo"
     * which is then picked up by the host itself. This is
     * necessary to simulate a 1-node network.
     * @throws IOException 
     *
     */
    void
    HSendPacket
    (int   node,
            int   flags )
    {
        netbuffer.checksum = (int) (NetbufferChecksum () | flags);

        // Local node's comms are sent to rebound packet, which is 
        // then picked up again. THIS IS VITAL FOR SINGLE-PLAYER
        // SPEED THROTTLING TOO, AS IT RELIES ON NETWORK ACKS/BUSY
        // WAITING.
        if (node==0)
        {
            // _D_
            reboundstore.copyFrom(netbuffer);
            reboundpacket = true;
            return;
        }

        if (DM.demoplayback)
            return;

        if (!DM.netgame)
            I.Error ("Tried to transmit to another node");

        doomcom.command = CMD_SEND;
        doomcom.remotenode = (short) node;
        doomcom.datalength = (short) NetbufferSize ();

        if (DM.debugfile!=null)
        {
            int     i;
            int     realretrans;
            if (flags(netbuffer.checksum , NCMD_RETRANSMIT))
                realretrans = ExpandTics (netbuffer.retransmitfrom);
            else
                realretrans = -1;

            logger(debugfile,"send ("+ExpandTics(netbuffer.starttic)+", "+netbuffer.numtics + ", R "+
                realretrans+ "["+ doomcom.datalength+"]");

            for (i=0 ; i<doomcom.datalength ; i++)

                // TODO: get a serialized string representation.
            	logger(debugfile,netbuffer.toString()+"\n");
        }

        // This should execute a "send" command for the current stuff in doomcom.
        DNI.NetCmd ();
    }

    //
    // HGetPacket
    // Returns false if no packet is waiting
    //
    private boolean HGetPacket () 
    {   
        // Fugly way of "clearing" the buffer.
        sb.setLength(0);
        if (reboundpacket)
        {
            // FIXME: MAES: this looks like a struct copy 
            netbuffer.copyFrom(reboundstore);
            doomcom.remotenode = 0;
            reboundpacket = false;
            return true;
        }

        // If not actually a netgame (e.g. single player, demo) return.
        if (!DM.netgame)
            return false;

        if (DM.demoplayback)
            return false;

        doomcom.command = CMD_GET;
        DNI.NetCmd ();

        // Invalid node?
        if (doomcom.remotenode == -1)
            return false;

        if (doomcom.datalength != NetbufferSize ())
        {
            if (eval(debugfile))
            	logger(debugfile,"bad packet length "+doomcom.datalength+"\n");
            return false;
        }

        if (NetbufferChecksum () != (netbuffer.checksum&NCMD_CHECKSUM) )
        {
            if (eval(debugfile))
            	logger(debugfile,"bad packet checksum\n");
            return false;
        }

        if (eval(debugfile))
        {
            int     realretrans;
            int i;

            if (flags(netbuffer.checksum , NCMD_SETUP))
            	logger(debugfile,"setup packet\n");
            else
            {
                if (flags(netbuffer.checksum , NCMD_RETRANSMIT))
                    realretrans = ExpandTics (netbuffer.retransmitfrom);
                else
                    realretrans = -1;

                sb.append("get ");
                sb.append(doomcom.remotenode);
                sb.append(" = (");
                sb.append(ExpandTics(netbuffer.starttic));
                sb.append(" + ");
                sb.append(netbuffer.numtics);
                sb.append(", R ");
                sb.append(realretrans);
                sb.append(")[");
                sb.append(doomcom.datalength);
                sb.append("]");

                logger(debugfile,sb.toString());

                // Trick: force update of internal buffer.
                netbuffer.pack();

                /* TODO: Could it be actually writing stuff beyond the boundaries of a single doomdata object?
                 * A doomcom object has a lot of header info, and a single "raw" data placeholder, which by now
                 * should be inside netbuffer....right?
                 * 
                 * 
                 */

                try{
                    for (i=0 ; i<doomcom.datalength ; i++) {
                    	debugfile.write(Integer.toHexString(netbuffer.cached()[i]));
                    	debugfile.write('\n');
                    }
                }
                catch( IOException e){
                    // "Drown" IOExceptions here.
                }
            }
        }
        return true;    
    }


    ////    GetPackets

    StringBuilder exitmsg=new StringBuilder(80);

    public void GetPackets () 
    {
        int     netconsole;
        int     netnode;
        ticcmd_t    src, dest;
        int     realend;
        int     realstart;

        while ( HGetPacket() )
        {
            if (flags(netbuffer.checksum , NCMD_SETUP))
                continue;       // extra setup packet

            netconsole = netbuffer.player & ~PL_DRONE;
            netnode = doomcom.remotenode;

            // to save bytes, only the low byte of tic numbers are sent
            // Figure out what the rest of the bytes are
            realstart = ExpandTics (netbuffer.starttic);        
            realend = (realstart+netbuffer.numtics);

            // check for exiting the game
            if (flags(netbuffer.checksum , NCMD_EXIT))
            {
                if (!nodeingame[netnode])
                    continue;
                nodeingame[netnode] = false;
                playeringame[netconsole] = false;
                exitmsg.insert(0, "Player 1 left the game");
                exitmsg.setCharAt(7,(char) (exitmsg.charAt(7)+netconsole));
                players[consoleplayer].message = exitmsg.toString();
                if (demorecording)
                    DM.CheckDemoStatus ();
                continue;
            }

            // check for a remote game kill
            if (flags(netbuffer.checksum , NCMD_KILL))
                I.Error ("Killed by network driver");

            nodeforplayer[netconsole] = netnode;

            // check for retransmit request
            if ( resendcount[netnode] <= 0 
                    && flags(netbuffer.checksum , NCMD_RETRANSMIT) )
            {
                resendto[netnode] = ExpandTics(netbuffer.retransmitfrom);
                if (eval(debugfile)){
                    sb.setLength(0);
                    sb.append("retransmit from ");
                    sb.append(resendto[netnode]);
                    sb.append('\n');
                    logger(debugfile,sb.toString());
                    resendcount[netnode] = RESENDCOUNT;
                }
            }
            else
                resendcount[netnode]--;

            // check for out of order / duplicated packet       
            if (realend == nettics[netnode])
                continue;

            if (realend < nettics[netnode])
            {
                if (eval(debugfile)){
                    sb.setLength(0);
                    sb.append("out of order packet (");
                    sb.append(realstart);
                    sb.append(" + ");
                    sb.append(netbuffer.numtics);
                    sb.append(")\n");
                    logger(debugfile,sb.toString());
                }
                continue;
            }

            // check for a missed packet
            if (realstart > nettics[netnode])
            {
                // stop processing until the other system resends the missed tics
                if (eval(debugfile)) {
                    sb.setLength(0);
                    sb.append("missed tics from ");
                    sb.append(netnode);
                    sb.append(" (");
                    sb.append(realstart);
                    sb.append(" - ");
                    sb.append(nettics[netnode]);
                    sb.append(")\n");
                    logger(debugfile,sb.toString());
                }
                remoteresend[netnode] = true;
                continue;
            }

            // update command store from the packet
            {
                int     start;

                remoteresend[netnode] = false;

                start = nettics[netnode] - realstart;       
                src = netbuffer.cmds[start];

                while (nettics[netnode] < realend)
                {
                    dest = netcmds[netconsole][nettics[netnode]%BACKUPTICS];
                    nettics[netnode]++;
                    // MAES: this is a struct copy.
                    src.copyTo(dest);
                    // Advance src
                    start++;

                    //_D_: had to add this (see linuxdoom source). That fixed that damn consistency failure!!!
                    if (start < netbuffer.cmds.length)
                        src = netbuffer.cmds[start];

                }
            }
        }
    }

    protected void logger(OutputStreamWriter debugfile, String string) {
    		try {
				debugfile.write(string);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
	}

	int      gametime;

    @Override
    public void NetUpdate ()
    {
        int             nowtime;
        int             newtics;
        int             i,j;
        int             realstart;
        int             gameticdiv;

        // check time
        nowtime = TICK.GetTime ()/ticdup;
        newtics = nowtime - gametime;
        gametime = nowtime;

        if (newtics <= 0)   // nothing new to update
        {
            // listen for other packets
            GetPackets ();
            return;
        } else {


            if (skiptics <= newtics)
            {
                newtics -= skiptics;
                skiptics = 0;
            }
            else
            {
                skiptics -= newtics;
                newtics = 0;
            }

            netbuffer.player = (byte) consoleplayer;

            // build new ticcmds for console player
            gameticdiv = gametic/ticdup;
            for (i=0 ; i<newtics ; i++)
            {
                VI.StartTic ();
                ProcessEvents ();
                if (maketic - gameticdiv >= BACKUPTICS/2-1)
                    break;          // can't hold any more

                //System.out.printf ("mk:%d ",maketic);
                BuildTiccmd (localcmds[maketic%BACKUPTICS]);
                maketic++;
            }


            if (singletics)
                return;         // singletic update is syncronous

            // send the packet to the other nodes
            for (i=0 ; i<doomcom.numnodes ; i++)
                if (nodeingame[i])
                {
                    netbuffer.starttic = (byte) (realstart = resendto[i]);
                    netbuffer.numtics = (byte) (maketic - realstart);
                    if (netbuffer.numtics > BACKUPTICS)
                        I.Error ("NetUpdate: netbuffer.numtics > BACKUPTICS");

                    resendto[i] = maketic - doomcom.extratics;

                    for (j=0 ; j< netbuffer.numtics ; j++)
                        localcmds[(realstart+j)%BACKUPTICS].copyTo(netbuffer.cmds[j]);
                    // MAES: one of _D_ fixes.
                    //netbuffer.cmds[j] = localcmds[(realstart+j)%BACKUPTICS];

                    if (remoteresend[i])
                    {
                        netbuffer.retransmitfrom = (byte) nettics[i];
                        HSendPacket (i, NCMD_RETRANSMIT);
                    }
                    else
                    {
                        netbuffer.retransmitfrom = 0;
                        HSendPacket (i, 0);
                    }
                }
            GetPackets();
        }

    }



    //
    // CheckAbort
    //
    private void CheckAbort ()
    {
        event_t ev;
        int     stoptic;

        stoptic = TICK.GetTime () + 2; 
        while (TICK.GetTime() < stoptic) 
            VI.StartTic (); 

        VI.StartTic ();
        for ( ; eventtail != eventhead 
        ; eventtail = (++eventtail)&(MAXEVENTS-1) ) 
        { 
            ev = events[eventtail]; 
            if (ev.type == evtype_t.ev_keydown && ev.data1 == KEY_ESCAPE)
                I.Error ("Network game synchronization aborted.");
        } 
    }

    boolean[] gotinfo=new boolean[MAXNETNODES];

    /**
     * D_ArbitrateNetStart
     * @throws IOException 
     *
     * 
     */
    public void ArbitrateNetStart () throws IOException
    {
        int     i;
        autostart = true;

        // Clear it up...
        Arrays.fill(gotinfo,false);

        if (doomcom.consoleplayer!=0)
        {
            // listen for setup info from key player
            System.out.println("listening for network start info...\n");
            while (true)
            {
                CheckAbort ();
                if (!HGetPacket ())
                    continue;
                if (flags(netbuffer.checksum , NCMD_SETUP))
                {
                    if (netbuffer.player != VERSION)
                        I.Error ("Different DOOM versions cannot play a net game!");
                    startskill = skill_t.values()[netbuffer.retransmitfrom & 15];

                    // Deathmatch
                    if (((netbuffer.retransmitfrom & 0xc0) >> 6)==1) 
                        deathmatch = true;
                    else
                        // Cooperative
                        if (((netbuffer.retransmitfrom & 0xc0) >> 6)==2) 
                            altdeath = true;

                    nomonsters = (netbuffer.retransmitfrom & 0x20) > 0;
                    respawnparm = (netbuffer.retransmitfrom & 0x10) > 0;
                    startmap = netbuffer.starttic & 0x3f;
                    startepisode = netbuffer.starttic >> 6;
            return;
                }
            }
        }
        else
        {
            // key player, send the setup info
            System.out.println("sending network start info...\n");
            do
            {
                CheckAbort ();
                for (i=0 ; i<doomcom.numnodes ; i++)
                {
                    netbuffer.retransmitfrom = (byte) startskill.ordinal();
                    if (deathmatch)
                        netbuffer.retransmitfrom |= (1<<6);
                    else
                        if (altdeath)
                            netbuffer.retransmitfrom |= (2<<6);
                    if (nomonsters)
                        netbuffer.retransmitfrom |= 0x20;
                    if (respawnparm)
                        netbuffer.retransmitfrom |= 0x10;
                    netbuffer.starttic = (byte) (startepisode * 64 + startmap);
                    netbuffer.player = VERSION;
                    netbuffer.numtics = 0;
                    HSendPacket (i, NCMD_SETUP);
                }

                //#if 1
                for(i = 10 ; (i>0)  &&  HGetPacket(); --i)
                {
                    if((netbuffer.player&0x7f) < MAXNETNODES)
                        gotinfo[netbuffer.player&0x7f] = true;
                }
                /*
        while (HGetPacket ())
        {
        gotinfo[netbuffer.player&0x7f] = true;
        }
                 */

                for (i=1 ; i<doomcom.numnodes ; i++)
                    if (!gotinfo[i])
                        break;
            } while (i < doomcom.numnodes);
        }
    }

    //
    // D_CheckNetGame
    // Works out player numbers among the net participants
    //

    private void CheckNetGame () throws IOException
    {
        int             i;

        for (i=0 ; i<MAXNETNODES ; i++)
        {
            nodeingame[i] = false;
            nettics[i] = 0;
            remoteresend[i] = false;    // set when local needs tics
            resendto[i] = 0;        // which tic to start sending
        }

        // I_InitNetwork sets doomcom and netgame
        DNI.InitNetwork ();
        if (doomcom.id != DOOMCOM_ID)
            I.Error ("Doomcom buffer invalid!");

        // Maes: This is the only place where netbuffer is definitively set to something
        netbuffer = doomcom.data;
        consoleplayer = displayplayer = doomcom.consoleplayer;
        if (netgame)
            ArbitrateNetStart ();

        System.out.printf ("startskill %s  deathmatch: %s  startmap: %d  startepisode: %d\n",
            startskill.toString(), Boolean.toString(deathmatch), startmap, startepisode);

        // read values out of doomcom
        ticdup = doomcom.ticdup;
        // MAES: ticdup must not be zero at this point. Obvious, no?
        maxsend = BACKUPTICS/(2*ticdup)-1;
        if (maxsend<1)
            maxsend = 1;

        for (i=0 ; i<doomcom.numplayers ; i++)
            playeringame[i] = true;
        for (i=0 ; i<doomcom.numnodes ; i++)
            nodeingame[i] = true;

        System.out.printf ("player %d of %d (%d nodes)\n",(consoleplayer+1), doomcom.numplayers, doomcom.numnodes);

    }


    //
    // D_QuitNetGame
    // Called before quitting to leave a net game
    // without hanging the other players
    //
    @Override
    public void QuitNetGame () throws IOException
    {
        int             i, j;

        if (eval(debugfile))
            try {
                debugfile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
                return;

            // send a bunch of packets for security
            netbuffer.player = (byte) consoleplayer;
            netbuffer.numtics = 0;
            for (i=0 ; i<4 ; i++)
            {
                for (j=1 ; j<doomcom.numnodes ; j++)
                    if (nodeingame[j])
                        HSendPacket (j, NCMD_EXIT);
                I.WaitVBL (1);
            }
    }



    //
    // TryRunTics
    //
    int[] frametics=new int[4];
    int frameon;
    boolean[] frameskip=new boolean[4];
    int oldnettics;
    int  oldentertics;


    @Override
    public void TryRunTics () throws IOException
    {
        int     i;
        int     lowtic;
        int     entertic;

        int     realtics;
        int     availabletics;
        int     counts;
        int     numplaying;


        // get real tics        
        entertic = TICK.GetTime ()/ticdup;
        realtics = entertic - oldentertics;
        oldentertics = entertic;

        //System.out.printf("Entertic %d, realtics %d, oldentertics %d\n",entertic,realtics,oldentertics);

        // get available tics
        NetUpdate ();

        lowtic = MAXINT;
        numplaying = 0;
        for (i=0 ; i<doomcom.numnodes ; i++)
        {
            if (nodeingame[i])
            {
                numplaying++;
                if (nettics[i] < lowtic)
                    lowtic = nettics[i];
            }
        }
        availabletics = lowtic - gametic/ticdup;

        // decide how many tics to run
        if (realtics < availabletics-1)
            counts = realtics+1;
        else if (realtics < availabletics)
            counts = realtics;
        else
            counts = availabletics;

        if (counts < 1)
            counts = 1;

        frameon++;

        if (eval(debugfile)){
            sb.setLength(0);
            sb.append( "=======real: ");
            sb.append(realtics);
            sb.append("  avail: ");
            sb.append(availabletics);
            sb.append("  game: ");
            sb.append(counts);
            sb.append("\n");
            debugfile.write(sb.toString());
        }

        if (!demoplayback)
        {   
            // ideally nettics[0] should be 1 - 3 tics above lowtic
            // if we are consistantly slower, speed up time
            for (i=0 ; i<MAXPLAYERS ; i++)
                if (playeringame[i])
                    break;
            if (consoleplayer == i)
            {
                // the key player does not adapt
            }
            else
            {
                if (nettics[0] <= nettics[nodeforplayer[i]])
                {
                    gametime--;
                    System.out.print("-");
                }
                frameskip[frameon&3] = oldnettics > nettics[nodeforplayer[i]];
                oldnettics = nettics[0];
                if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
                {
                    skiptics = 1;
                    System.out.print("+");
                }
            }
        }// demoplayback

        // wait for new tics if needed
        while (lowtic < gametic/ticdup + counts)    
        {
            NetUpdate ();   
            lowtic = MAXINT;

            // Finds the node with the lowest number of tics.
            for (i=0 ; i<doomcom.numnodes ; i++)
                if (nodeingame[i] && nettics[i] < lowtic)
                    lowtic = nettics[i];

            if (lowtic < gametic/ticdup)
                I.Error ("TryRunTics: lowtic < gametic");

            // don't stay in here forever -- give the menu a chance to work
            int time=TICK.GetTime();
            if (time/ticdup - entertic >= 20)
            {
                M.Ticker ();
                return;
            }
        }

        // run the count * ticdup dics
        while (counts-->0)
        {
            for (i=0 ; i<ticdup ; i++)
            {
                if (gametic/ticdup > lowtic)
                    I.Error ("gametic>lowtic");
                if (advancedemo)
                    DM.DoAdvanceDemo ();
                M.Ticker ();
                Ticker ();
                gametic++;

                // modify command for duplicated tics
                if (i != ticdup-1)
                {
                    ticcmd_t    cmd;
                    int         buf;
                    int         j;

                    buf = (gametic/ticdup)%BACKUPTICS; 
                    for (j=0 ; j<MAXPLAYERS ; j++)
                    {
                        cmd = netcmds[j][buf];
                        cmd.chatchar = 0;
                        if (flags(cmd.buttons , BT_SPECIAL))
                            cmd.buttons = 0;
                    }
                }
            }
            NetUpdate ();   // check for new console commands
        }
    }


    @Override
    public doomcom_t getDoomCom() {
        return this.doomcom;
    }


    @Override
    public void setDoomCom(doomcom_t doomcom) {
        this.doomcom=doomcom;
    }


    @Override
    public void setGameAction(gameaction_t action) {
        this.gameaction=action;
    }


    @Override
    public gameaction_t getGameAction() {       
        return this.gameaction;
    }

    ////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

    protected int SCREENWIDTH;
    protected int SCREENHEIGHT;
    protected int SAFE_SCALE;
    protected IVideoScale vs;



    @Override
    public void setVideoScale(IVideoScale vs) {
        this.vs=vs;
    }

    @Override
    public void initScaling() {
        this.SCREENHEIGHT=vs.getScreenHeight();
        this.SCREENWIDTH=vs.getScreenWidth();
        this.SAFE_SCALE=vs.getSafeScaling();
    }


    public void setCommandLineArgs(ICommandLineManager cM) {
        this.CM=cM;

    }


    public boolean shouldPollLockingKeys() {
        if (keysCleared) {
            keysCleared = false;
            return true;
        }
        return false;
    }
    
    /**
     * Since this is a fully OO implementation, we need a way to create
     * the instances of the Refresh daemon, the Playloop, the Wadloader 
     * etc. which however are now completely independent of each other
     * (well, ALMOST), and are typically only passed context when 
     * instantiated.
     * 
     *  If you instantiate one too early, it will have null context.
     *  
     *  The trick is to construct objects in the correct order. Some of
     *  them have Init() methods which are NOT yet safe to call.
     * 
     */

    public void Init(){
       
        // The various objects that need to "sense" the global status
        // end up here. This allows one-call updates.
        status_holders=new ArrayList<DoomStatusAware>();
        
        // Doommain is both "main" and handles most of the game status.
        this.DM=this;
        this.DG = this;
        this.DGN=this; // DoomMain also handles its own Game Networking.
             
        // Set ticker. It is a shared status object, but not a holder itself.
        if (eval(CM.CheckParm("-millis"))){

            TICK=new MilliTicker();
        }
        else if (eval(CM.CheckParm("-fasttic"))){
            TICK=new FastTicker();
        } else {
            TICK=new NanoTicker();
        }
        
        // Network "driver"
        status_holders.add((DoomStatusAware) (this.DNI=new DummyNetworkDriver(this)));
        
        // Random number generator, but we can have others too.
        this.RND=new DoomRandom();
        
        // Sound can be left until later, in Start

        this.W=new WadLoader(this.I); // The wadloader is a "weak" status holder.
        status_holders.add(this.WIPE=selectWiper());   

        // Then the menu...
        status_holders.add(this.HU=new HU(this));
        status_holders.add(this.M=new Menu(this));
        status_holders.add(this.LL=new BoomLevelLoader(this));
        
        // This will set R.
        this.R= selectRenderer();
        status_holders.add(this.R);
        status_holders.add((this.P=new Actions(this)));
        status_holders.add(this.ST=new StatusBar(this));
        status_holders.add(this.AM=selectAutoMap()); // Call Init later.
        // Let the renderer pick its own. It makes linking easier.
        this.TM=R.getTextureManager();
        this.SM=R.getSpriteManager();        

        //_D_: well, for EndLevel and Finale to work, they need to be instanciated somewhere!
        // it seems to fit perfectly here
        status_holders.add(this.WI = new EndLevel(this));    
        status_holders.add(this.F = selectFinale());
        
        // TODO: find out if we have requests for a specific resolution,
        // and try honouring them as closely as possible.       

        // 23/5/2011: Experimental dynamic resolution subsystem
        vs=VisualSettings.parse(CM);
        
        // Initializing actually sets drawing positions, constants,
        // etc. for main. Children will be set later in Start().
        this.initScaling();
        
        this.V=selectVideoRenderer();

        status_holders.add((DoomStatusAware) this.I);
        status_holders.add((DoomStatusAware) this.V);
        
        // Disk access visualizer
        
        status_holders.add((DoomStatusAware) (this.DD=new DiskDrawer(this,DiskDrawer.STDISK)));
        
        updateStatusHolders(this);


    }
    


    public static final class HiColor extends DoomMain<byte[], short[]>{
    
        public HiColor(){
            super();
        }
        
        protected IAutoMap<byte[], short[]> selectAutoMap() {
            return new Map.HiColor(this);
        }
        
        protected final Finale<byte[]> selectFinale(){
            return new Finale<byte[]>(this);
        }
        
        protected final DoomVideoRenderer<byte[],short[]> selectVideoRenderer(){
            return new BufferedRenderer16(SCREENWIDTH,SCREENHEIGHT);
        }
        
        protected final DoomVideoInterface<short[]> selectVideoInterface(){
            return new AWTDoom.HiColor(this,V);
        }
        
        protected final Wiper<byte[],short[]> selectWiper(){
            return new Wiper.HiColor(this);
        }
        
        protected final Renderer<byte[],short[]> selectRenderer() {
            // Serial or parallel renderer (serial is default, but can be forced)
            if (eval(CM.CheckParm("-serialrenderer"))){
                return new UnifiedRenderer.HiColor(this);    
            } else 
                // Parallel. Either with default values (2,1) or user-specified.
                if (CM.CheckParmBool("-parallelrenderer")||CM.CheckParmBool("-parallelrenderer2")){        
                    int p = CM.CheckParm ("-parallelrenderer");
                    if (p<1) p=CM.CheckParm("-parallelrenderer2");
                    
                    if (p < CM.getArgc()-1)
                    {
                        // Next THREE args must be numbers.
                        int walls=1, floors=1,masked=2;
                        startmap = Integer.parseInt(CM.getArgv(p+1));
                        // Try parsing walls.
                        try {
                            walls=Integer.parseInt(CM.getArgv(p+1));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }

                        // Try parsing floors. If wall succeeded, but floors
                        // not, it will default to 1.
                        try {
                            floors=Integer.parseInt(CM.getArgv(p+2));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }
                        
                        try {
                            masked=Integer.parseInt(CM.getArgv(p+3));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }

                        // In the worst case, we will use the defaults.
                        if  (CM.CheckParmBool("-parallelrenderer"))
                            // TODO: temporarily disabled
                        	return new ParallelRenderer.HiColor(this,walls,floors,masked);  
                       //     return (Renderer<byte[], short[]>) new ParallelRenderer(this,walls,floors,masked);
                       // else
                       //     return (Renderer<byte[], short[]>) new ParallelRenderer2(this,walls,floors,masked);
                    }
                } else {
                    // Force serial
                    return new UnifiedRenderer.HiColor(this);   
                }
            
            return null;
        }

        /**
        *  M_Screenshot
        *  
        *  Currently saves PCX screenshots, and only in devparm.
        *  Very oldschool ;-)
        *  
        *  TODO: add non-devparm hotkey for screenshots, sequential screenshot
        *  messages, option to save as either PCX or PNG. Also, request
        *  current palette from VI (otherwise gamma settings and palette effects
        *  don't show up).
        *  
        */

       public void ScreenShot ()
       {
           int     i;
           short[]  linear;
           String format=new String("DOOM%d%d%d%d.png");
           String lbmname = null;
           
           // munge planar buffer to linear
           linear = (short[]) V.getScreen(DoomVideoRenderer.SCREEN_WS);
           VI.ReadScreen (linear);

           // find a file name to save it to
           
           int[] digit=new int[4];
           
           for (i=0 ; i<=9999 ; i++)
           {
           digit[0] = ((i/1000 )%10);
           digit[1] =  ((i/100)%10);
           digit[2] =  ((i/10)%10);
           digit[3] =  (i%10);
           lbmname=String.format(format, digit[0],digit[1],digit[2],digit[3]);
           if (!C2JUtils.testReadAccess(lbmname))
               break;  // file doesn't exist
           }
           if (i==10000)
           I.Error ("M_ScreenShot: Couldn't create a PNG");

           // save the pcx file
           MenuMisc.WritePNGfile (lbmname, linear,
                 SCREENWIDTH, SCREENHEIGHT);

           players[consoleplayer].message = "screen shot";
       }

    }
    
    public static final class Indexed extends DoomMain<byte[], byte[]>{
        
        public Indexed(){
            super();
        }
        
        protected IAutoMap<byte[], byte[]> selectAutoMap() {
            return new Map.Indexed(this);
        }
        
        protected final Finale<byte[]> selectFinale(){
            return new Finale<byte[]>(this);
        }
        
        protected final DoomVideoRenderer<byte[],byte[]> selectVideoRenderer(){
            return new BufferedRenderer(SCREENWIDTH,SCREENHEIGHT);
        }
        
        protected final DoomVideoInterface<byte[]> selectVideoInterface(){
            return new AWTDoom.Indexed(this,V);
        }
        
        protected final Wiper<byte[],byte[]> selectWiper(){
            return new Wiper.Indexed(this);
        }        
        protected final Renderer<byte[],byte[]> selectRenderer() {
            // Serial or parallel renderer (serial is default, but can be forced)
            if (eval(CM.CheckParm("-serialrenderer"))){
                return new UnifiedRenderer.Indexed(this);    
            } else 
                // Parallel. Either with default values (2,1) or user-specified.
                if (CM.CheckParmBool("-parallelrenderer")||CM.CheckParmBool("-parallelrenderer2")){        
                    int p = CM.CheckParm ("-parallelrenderer");
                    if (p<1) p=CM.CheckParm("-parallelrenderer2");
                    
                    if (p < CM.getArgc()-1)
                    {
                        // Next THREE args must be numbers.
                        int walls=1, floors=1,masked=2;
                        startmap = Integer.parseInt(CM.getArgv(p+1));
                        // Try parsing walls.
                        try {
                            walls=Integer.parseInt(CM.getArgv(p+1));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }

                        // Try parsing floors. If wall succeeded, but floors
                        // not, it will default to 1.
                        try {
                            floors=Integer.parseInt(CM.getArgv(p+2));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }
                        
                        try {
                            masked=Integer.parseInt(CM.getArgv(p+3));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }

                        // In the worst case, we will use the defaults.
                        if  (CM.CheckParmBool("-parallelrenderer"))                            
                            // TODO: temporarily disabled
                            //return new UnifiedRenderer.Indexed(this);   
                            return new ParallelRenderer.Indexed(this,walls,floors,masked);
                        //else
                          //  return new ParallelRenderer2(this,walls,floors,masked);
                    }
                } else {
                    // Force serial
                    return new UnifiedRenderer.Indexed(this);   
                }
            
            return null;
        }

        /**
        *  M_Screenshot
        *  
        *  Currently saves PCX screenshots, and only in devparm.
        *  Very oldschool ;-)
        *  
        *  TODO: add non-devparm hotkey for screenshots, sequential screenshot
        *  messages, option to save as either PCX or PNG. Also, request
        *  current palette from VI (otherwise gamma settings and palette effects
        *  don't show up).
        *  
        */

       public void ScreenShot ()
       {
           int     i;
           byte[]  linear;
           String format=new String("DOOM%d%d%d%d.png");
           String lbmname = null;
           
           // munge planar buffer to linear
           linear = (byte[]) V.getScreen(DoomVideoRenderer.SCREEN_WS);
           VI.ReadScreen (linear);

           // find a file name to save it to
           
           int[] digit=new int[4];
           
           for (i=0 ; i<=9999 ; i++)
           {
           digit[0] = ((i/1000 )%10);
           digit[1] =  ((i/100)%10);
           digit[2] =  ((i/10)%10);
           digit[3] =  (i%10);
           lbmname=String.format(format, digit[0],digit[1],digit[2],digit[3]);
           if (!C2JUtils.testReadAccess(lbmname))
               break;  // file doesn't exist
           }
           if (i==10000)
           I.Error ("M_ScreenShot: Couldn't create a PNG");

           // save the pcx file
           MenuMisc.WritePNGfile(lbmname, linear,
                 SCREENWIDTH, SCREENHEIGHT,V.getPalette());

           players[consoleplayer].message = "screen shot";
       }
        
    }
 
    public static final class TrueColor extends DoomMain<byte[], int[]>{
        
        public TrueColor(){
            super();
        }
        
        protected IAutoMap<byte[], int[]> selectAutoMap() {
            return new Map.TrueColor(this);
        }
        
        protected final Finale<byte[]> selectFinale(){
            return new Finale<byte[]>(this);
        }
        
        protected final DoomVideoRenderer<byte[],int[]> selectVideoRenderer(){
            return new BufferedRenderer32(SCREENWIDTH,SCREENHEIGHT);
        }
        
        protected final DoomVideoInterface<int[]> selectVideoInterface(){
            return new AWTDoom.TrueColor(this,V);
        }
        
        protected final Wiper<byte[],int[]> selectWiper(){
            return new Wiper.TrueColor(this);
        }
        
        protected final Renderer<byte[],int[]> selectRenderer() {
            // Serial or parallel renderer (serial is default, but can be forced)
            if (eval(CM.CheckParm("-serialrenderer"))){
                return new UnifiedRenderer.TrueColor(this);    
            } else 
                // Parallel. Either with default values (2,1) or user-specified.
                if (CM.CheckParmBool("-parallelrenderer")||CM.CheckParmBool("-parallelrenderer2")){        
                    int p = CM.CheckParm ("-parallelrenderer");
                    if (p<1) p=CM.CheckParm("-parallelrenderer2");
                    
                    if (p < CM.getArgc()-1)
                    {
                        // Next THREE args must be numbers.
                        int walls=1, floors=1,masked=2;
                        startmap = Integer.parseInt(CM.getArgv(p+1));
                        // Try parsing walls.
                        try {
                            walls=Integer.parseInt(CM.getArgv(p+1));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }

                        // Try parsing floors. If wall succeeded, but floors
                        // not, it will default to 1.
                        try {
                            floors=Integer.parseInt(CM.getArgv(p+2));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }
                        
                        try {
                            masked=Integer.parseInt(CM.getArgv(p+3));
                        } catch (Exception e){
                            // OK, move on anyway.
                        }

                        // In the worst case, we will use the defaults.
                        if  (CM.CheckParmBool("-parallelrenderer"))
                            // TODO: temporarily disabled
                        	return new ParallelRenderer.TrueColor(this,walls,floors,masked);   
                       //     return (Renderer<byte[], short[]>) new ParallelRenderer(this,walls,floors,masked);
                       // else
                       //     return (Renderer<byte[], short[]>) new ParallelRenderer2(this,walls,floors,masked);
                    }
                } else {
                    // Force serial
                    return new UnifiedRenderer.TrueColor(this);   
                }
            
            return null;
        }

        /**
        *  M_Screenshot
        *  
        *  Currently saves PCX screenshots, and only in devparm.
        *  Very oldschool ;-)
        *  
        *  TODO: add non-devparm hotkey for screenshots, sequential screenshot
        *  messages, option to save as either PCX or PNG. Also, request
        *  current palette from VI (otherwise gamma settings and palette effects
        *  don't show up).
        *  
        */

       public void ScreenShot ()
       {
           int     i;
           int[]  linear;
           String format=new String("DOOM%d%d%d%d.png");
           String lbmname = null;
           
           // munge planar buffer to linear
           linear = (int[]) V.getScreen(DoomVideoRenderer.SCREEN_WS);
           VI.ReadScreen (linear);

           // find a file name to save it to
           
           int[] digit=new int[4];
           
           for (i=0 ; i<=9999 ; i++)
           {
           digit[0] = ((i/1000 )%10);
           digit[1] =  ((i/100)%10);
           digit[2] =  ((i/10)%10);
           digit[3] =  (i%10);
           lbmname=String.format(format, digit[0],digit[1],digit[2],digit[3]);
           if (!C2JUtils.testReadAccess(lbmname))
               break;  // file doesn't exist
           }
           if (i==10000)
           I.Error ("M_ScreenShot: Couldn't create a PNG");

           // save the pcx file
           MenuMisc.WritePNGfile (lbmname, linear,
                 SCREENWIDTH, SCREENHEIGHT);

           players[consoleplayer].message = "screen shot";
       }

    }
    
}

//$Log: DoomMain.java,v $
//Revision 1.110  2016/06/06 22:21:24  velktron
//Use coalescing
//
//Revision 1.109  2012/11/06 16:04:58  velktron
//Variables manager less tightly integrated.
//
//Revision 1.108  2012/11/05 17:25:29  velktron
//Fixed tinting system according to SodaHolic's advice.
//
//Revision 1.107  2012/09/27 16:53:46  velktron
//Stupid brokeness prevented -loadgame from working.
//
//Revision 1.106  2012/09/26 23:15:20  velktron
//Parallel renderer restored...sort of.
//
//Revision 1.105  2012/09/26 15:54:22  velktron
//Spritemanager is set up by renderer.
//
//Revision 1.104  2012/09/24 22:36:49  velktron
//Fixed HOM detection.
//
//Revision 1.103  2012/09/24 17:16:22  velktron
//Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
//Revision 1.101.2.11  2012/09/24 16:58:06  velktron
//TrueColor, Generics.
//
//Revision 1.101.2.10  2012/09/21 16:17:25  velktron
//More generic.
//
//Revision 1.101.2.9  2012/09/20 14:25:13  velktron
//Unified DOOM!!!
//

package doom;

/** A shiny new and enterprisey (yeah right) interface for
 *  command-line handling. No more argv/argc nastiness!
 *  
 * @author velktron
 *
 */

public interface ICommandLineManager {

    public abstract String getArgv(int index);

    public abstract int getArgc();

    /**
     * M_CheckParm Checks for the given parameter in the program's command line
     * arguments. Returns the argument number (1 to argc-1) or 0 if not present
     * 
     * OK, now WHY ON EARTH was this be defined in m_menu.c?
     * 
     * MAES: this needs to be modified for Java, or else bump myargc one element up.
     * 
     */

    public abstract int CheckParm(String check);

    void FindResponseFile();

    public abstract void setArgv(int index, String string);

	boolean CheckParmBool(String check);

}
package doom;
import defines.*;

//
// PSPRITE ACTIONS for waepons.
// This struct controls the weapon animations.
//
// Each entry is:
//   ammo/amunition type
//  upstate
//  downstate
// readystate
// atkstate, i.e. attack/fire/hit frame
// flashstate, muzzle flash
//

public class weaponinfo_t {

    /*    
    public weaponinfo_t(ammotype_t ammo, int upstate, int downstate,
            int readystate, int atkstate, int flashstate) {
        super();
        this.ammo = ammo;
        this.upstate = upstate;
        this.downstate = downstate;
        this.readystate = readystate;
        this.atkstate = atkstate;
        this.flashstate = flashstate;
    }*/
        public ammotype_t  ammo;
             
        
        public weaponinfo_t(ammotype_t ammo, statenum_t upstate,
                statenum_t downstate, statenum_t readystate,
                statenum_t atkstate, statenum_t flashstate) {
            super();
            this.ammo = ammo;
            this.upstate = upstate;
            this.downstate = downstate;
            this.readystate = readystate;
            this.atkstate = atkstate;
            this.flashstate = flashstate;
        }
        
        public statenum_t     upstate;
        public statenum_t     downstate;
        public statenum_t     readystate;
        public statenum_t     atkstate;
        public statenum_t     flashstate;
        
        
        /*
        public int     upstate;
        public int     downstate;
        public int     readystate;
        public int     atkstate;
        public int     flashstate;
        */
    
}

package doom;

/** The possible events according to Doom */

public enum evtype_t {
        ev_null,
        ev_keydown,
        ev_keyup,
        ev_mouse,
        ev_joystick,
        ev_mousewheel, // extension
        ev_clear // Forcibly clear all button input (e.g. when losing focus)
    };

package doom;

/** Mocha Doom uses the think_t type as an ENUM for available action functions. This
 * makes enumerations etc. easy to keep track of.
 * 
 * @author velktron
 *
 */

public enum think_t {
    /** Here's your "decent NOP" function */
	NOP,
	A_Light0(2),
    A_WeaponReady(2),
    A_Lower(2),
    A_Raise(2),
    A_Punch(2),
    A_ReFire(2),
    A_FirePistol(2),
    A_Light1(2),
    A_FireShotgun(2),
    A_Light2(2),
    A_FireShotgun2(2),
    A_CheckReload(2),
    A_OpenShotgun2(2),
    A_LoadShotgun2(2),
    A_CloseShotgun2(2),
    A_FireCGun(2),
    A_GunFlash(2),
    A_FireMissile(2),
    A_Saw(2),
    A_FirePlasma(2),
    A_BFGsound(2),
    A_FireBFG(2),
    A_BFGSpray(1),
    A_Explode(1),
    A_Pain(1),
    A_PlayerScream(1),
    A_Fall(1),
    A_XScream(1),
    A_Look(1),
    A_Chase(1),
    A_FaceTarget(1),
    A_PosAttack(1),
    A_Scream(1),
    A_SPosAttack(1),
    A_VileChase(1),
    A_VileStart(1),
    A_VileTarget(1),
    A_VileAttack(1),
    A_StartFire(1),
    A_Fire(1),
    A_FireCrackle(1),
    A_Tracer(1),
    A_SkelWhoosh(1),
  //Historically, "think_t" is yet another
  //function pointer to a routine to handle
  //an actor.

  //
  //Experimental stuff.
  //To compile this as "ANSI C with classes"
  //we will need to handle the various
  //action functions cleanly.
  //
  //typedef  void (*actionf_v)();
  //typedef  void (*actionf_p1)( void* );
  //typedef  void (*actionf_p2)( void*, void* );

  /*typedef union
  {
  actionf_p1  acp1;
  actionf_v   acv;
  actionf_p2  acp2;

  } actionf_t;

  */

    A_SkelFist(1),
    A_SkelMissile(1),
    A_FatRaise(1),
    A_FatAttack1(1),
    A_FatAttack2(1),
    A_FatAttack3(1),
    A_BossDeath(1),
    A_CPosAttack(1),
    A_CPosRefire(1),
    A_TroopAttack(1),
    A_SargAttack(1),
    A_HeadAttack(1),
    A_BruisAttack(1),
    A_SkullAttack(1),
    A_Metal(1),
    A_SpidRefire(1),
    A_BabyMetal(1),
    A_BspiAttack(1),
    A_Hoof(1),
    A_CyberAttack(1),
    A_PainAttack(1),
    A_PainDie(1),
    A_KeenDie(1),
    A_BrainPain(1),
    A_BrainScream(1),
    A_BrainDie(1),
    A_BrainAwake(1),
    A_BrainSpit(1),
    A_SpawnSound(1),
    A_SpawnFly(1),
    A_BrainExplode(1),
    P_MobjThinker(1),
    T_FireFlicker(1),
	T_LightFlash(1),
	T_StrobeFlash(1),
	T_Glow(1),
	T_MoveCeiling(1),
	T_MoveFloor(1),
	T_VerticalDoor(1),
	T_PlatRaise(1), 
	T_SlidingDoor(1),
	// The following are dummies that exist only for demo sync debugging
	DeathMatchSpawnPlayer,
	PlayerInSpecialSector, 
	SpawnLightFlash, 
	SpawnStrobeFlash, 
	ExplodeMissile,
	CheckMissileRange,
	DoPlat,
	CheckMissileSpawn,
	DamageMobj, 
	KillMobj, 
	NewChaseDir, 
	P_GunShot, 
	PIT_ChangeSector, 
	PIT_CheckThing, 
	TryWalk, 
	SpawnBlood, 
	SpawnMapThing, 
	SpawnMobj, 
	SpawnMissile,
	SpawnPuff;
    
	
	think_t(){
	    type=0; // Default, but Doom has no "type 0" functions!
	}
	
    think_t(int type){
        this.type=type;
    }

    /** 0 for void, 1 for acp1, 2 for acp2 */
    public int getType() {
        return type;
    }

    private int type;
    
    public String ToString(){
        return this.name()+" Type: "+type;
    }
    
    public static final int acpv=0;
    public static final int acp1=1;
    public static final int acp2=2;
	
}

package doom;

import java.io.IOException;

/** Doom is actually tied to its networking module.
 *  Therefore, no matter where and how you implement it, these functions
 *  need to be callable from within many modules.
 *  
 *  This is the so called "game networking" which is internal and game-specific,
 *  and not system networking which deals with the low level sockets and packet 
 *  stuff. You'll need DoomSystemNetworking for that one.
 *  
 * @author Velktron
 *
 */

public interface IDoomGameNetworking {
	
	public void TryRunTics() throws IOException;
	
	/**
	 * NetUpdate
	 * Builds ticcmds for console player,
	 * sends out a packet
	 * @throws IOException 
	 */

	public void NetUpdate ();
	
	public doomcom_t getDoomCom();
	
	public void setDoomCom(doomcom_t doomcom);
	
	public int getTicdup();

	public void setTicdup(int ticdup);

}

package doom;

import i.DoomStatusAware;
import i.IDoomSystem;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;

import m.IRandom;

import data.Tables;
import data.state_t;
import defines.*;
import data.sounds.sfxenum_t;
import static data.Defines.*;
import static data.Tables.*;
import static m.fixed_t.*;
import static data.info.*;
import static p.mobj_t.*;
import p.Actions;
import p.mobj_t;
import p.pspdef_t;
import rr.LightsAndColors;
import rr.Renderer;
import rr.sector_t;
import s.IDoomSound;
import utils.C2JUtils;
import w.DoomBuffer;
import w.DoomIO;
import w.IPackableDoomObject;
import w.IReadableDoomObject;
import static utils.C2JUtils.*;
import static data.Limits.*;
import static doom.items.weaponinfo;
import static p.mobj_t.MF_SHADOW;

/**
 * Extended player object info: player_t The player data structure depends on a
 * number of other structs: items (internal inventory), animation states
 * (closely tied to the sprites used to represent them, unfortunately). 
 * 
 * #include "d_items.h" 
 * #include "p_pspr.h" 
 * 
 * In addition, the player is just a special
 * case of the generic moving object/actor. 
 * NOTE: this doesn't mean it needs to extend it, although it would be
 * possible.
 * 
 * #include "p_mobj.h" 
 * 
 * Finally, for odd reasons, the player input is buffered within 
 * the player data struct, as  commands per game tick. 
 * 
 * #include "d_ticcmd.h"
 */

public class player_t /*extends mobj_t */
        implements Cloneable ,DoomStatusAware, IReadableDoomObject, IPackableDoomObject
        {
	
    /** Probably doomguy needs to know what the fuck is going on */
    private DoomStatus DS;
    private IDoomGame DG;
    private Actions P;
    private Renderer<?,?> R;
    private IRandom RND;
    private IDoomSystem I;
    private IDoomSound S;
	
    /* Fugly hack to "reset" the player. Not worth the fugliness.
    public static player_t nullplayer;
    static {
        nullplayer = new player_t();
    }
    */

    public player_t() {
        powers = new int[NUMPOWERS];
        frags = new int[MAXPLAYERS];
        ammo = new int[NUMAMMO];
        //maxammo = new int[NUMAMMO];
        maxammo= new int[NUMAMMO];
        cards = new boolean[card_t.NUMCARDS.ordinal()];
        weaponowned = new boolean[NUMWEAPONS];
        psprites = new pspdef_t[NUMPSPRITES];
        C2JUtils.initArrayOfObjects(psprites);
        this.mo=new mobj_t();
        // If a player doesn't reference himself through his object, he will have an existential crisis.
        this.mo.player=this;
        readyweapon=weapontype_t.wp_fist;
        this.cmd=new ticcmd_t();
        //weaponinfo=new weaponinfo_t();
    }

    public final static int CF_NOCLIP = 1; // No damage, no health loss.

    public final static int CF_GODMODE = 2;

    public final static int CF_NOMOMENTUM = 4; // Not really a cheat, just a debug aid.

    
    /** The "mobj state" of the player is stored here, even though he "inherits"
     *  all mobj_t properties (except being a thinker). However, for good or bad,
     *  his mobj properties are modified by accessing player.mo
     */
    public mobj_t mo;

    /** playerstate_t */
    public int playerstate;

    public ticcmd_t cmd;

    /**
     * Determine POV, including viewpoint bobbing during movement. (fixed_t)
     * Focal origin above r.z
     */
    public int viewz;
    
    /** (fixed_t) Base height above floor for viewz. */
    public int viewheight;

    /** (fixed_t) Bob/squat speed. */
    public int deltaviewheight;

    /** (fixed_t) bounded/scaled total momentum. */
    public int bob;

    // Heretic stuff
	public int			flyheight;
	public int			lookdir;
	public boolean		centering;
    
    /**
     * This is only used between levels, mo->health is used during levels.
     * CORRECTION: this is also used by the automap widget.
     * MAES: fugly hax, as even passing "Integers" won't work, as they are immutable.
     * Fuck that, I'm doing it the fugly MPI Java way!
     */
    public int[] health = new int[1];

    /** has to be passed around :-( */
    public int[] armorpoints = new int[1];

    /** Armor type is 0-2. */
    public int armortype;

    /** Power ups. invinc and invis are tic counters. */
    public int[] powers;

    public boolean[] cards;

    public boolean backpack;

    // Frags, kills of other players.
    public int[] frags;

    public weapontype_t readyweapon;

    // Is wp_nochange if not changing.
    public weapontype_t pendingweapon;

    public boolean[] weaponowned;

    public int[] ammo;

    public int[] maxammo;

    /** True if button down last tic. */
    public boolean attackdown;

    public boolean usedown;

    // Bit flags, for cheats and debug.
    // See cheat_t, above.
    public int cheats;

    // Refired shots are less accurate.
    public int refire;

    // For intermission stats.
    public int killcount;

    public int itemcount;

    public int secretcount;

    // Hint messages.
    public String message;

    // For screen flashing (red or bright).
    public int damagecount;

    public int bonuscount;

    // Who did damage (NULL for floors/ceilings).
    public mobj_t attacker;

    // So gun flashes light up areas.
    public int extralight;

    /**
     * Current PLAYPAL, ??? can be set to REDCOLORMAP for pain, etc. MAES: "int"
     * my ass. It's yet another pointer alias into colormaps. Ergo, array and
     * pointer.
     */

    // public byte[] fixedcolormap;
    public int fixedcolormap;

    // Player skin colorshift,
    // 0-3 for which color to draw player.
    public int colormap;

    // TODO: Overlay view sprites (gun, etc).
    public pspdef_t[] psprites;

    // True if secret level has been done.
    public boolean didsecret;

    /** It's probably faster to clone the null player */

    public void reset() {

        Arrays.fill(this.ammo, 0);
        Arrays.fill(this.armorpoints, 0);
        Arrays.fill(this.cards, false);
        Arrays.fill(this.frags, 0);
        Arrays.fill(this.health, 0);
        Arrays.fill(this.maxammo, 0);
        Arrays.fill(this.powers, 0);
        Arrays.fill(this.weaponowned, false);
        //Arrays.fill(this.psprites, null);
        this.cheats=0; // Forgot to clear up cheats flag...
        this.armortype = 0;
        this.attackdown = false;
        this.attacker = null;
        this.backpack = false;
        this.bob = 0;

    }

    @Override
    public player_t clone()
            throws CloneNotSupportedException {
        return (player_t) super.clone();
    }
        
    /** 16 pixels of bob */
    private static int MAXBOB = 0x100000;

    /**
     * P_Thrust Moves the given origin along a given angle.
     * 
     * @param angle
     *        (angle_t)
     * @param move
     *        (fixed_t)
     */

    public void Thrust(long angle, int move) {
        mo.momx += FixedMul(move, finecosine(angle));
        mo.momy += FixedMul(move, finesine( angle));
    }

    protected final static int PLAYERTHRUST=2048/TIC_MUL;
    
    /**
     * P_MovePlayer
     */
    public void MovePlayer() {
        ticcmd_t cmd = this.cmd;

        mo.angle += (cmd.angleturn << 16);
        mo.angle&=BITS32;
        
        // Do not let the player control movement
        // if not onground.
        onground = (mo.z <= mo.floorz);

        if (cmd.forwardmove != 0 && onground)
            Thrust(mo.angle, cmd.forwardmove * PLAYERTHRUST);

        if (cmd.sidemove != 0 && onground)
            Thrust((mo.angle - ANG90)&BITS32, cmd.sidemove * PLAYERTHRUST);

        if ((cmd.forwardmove != 0 || cmd.sidemove != 0)
                && mo.state == states[statenum_t.S_PLAY.ordinal()]) {
            this.mo.SetMobjState(statenum_t.S_PLAY_RUN1);
        }
        
        // Freelook code ripped off Heretic. Sieg heil!
        
        int look = cmd.lookfly&15;
        
    	if(look > 7)
    	{
    		look -= 16;
    	}
    	if(look!=0)
    	{
    		if(look == TOCENTER)
    		{
    			centering = true;
    		}
    		else
    		{
    			lookdir += 5*look;
    			if(lookdir > 90 || lookdir < -110)
    			{
    				lookdir -= 5*look;
    			}
    		}
    	}
    	
    	// Centering is done over several tics
    	if(centering)
    	{
    		if(lookdir > 0)
    		{
    			lookdir -= 8;
    		}
    		else if(lookdir < 0)
    		{
    			lookdir += 8;
    		}
    		if(Math.abs(lookdir) < 8)
    		{
    			lookdir = 0;
    			centering = false;
    		}
    	}
    	/* Flight stuff from Heretic
    	fly = cmd.lookfly>>4;
    		
    	if(fly > 7)
    	{
    		fly -= 16;
    	}
    	if(fly && player->powers[pw_flight])
    	{
    		if(fly != TOCENTER)
    		{
    			player->flyheight = fly*2;
    			if(!(player->mo->flags2&MF2_FLY))
    			{
    				player->mo->flags2 |= MF2_FLY;
    				player->mo->flags |= MF_NOGRAVITY;
    			}
    		}
    		else
    		{
    			player->mo->flags2 &= ~MF2_FLY;
    			player->mo->flags &= ~MF_NOGRAVITY;
    		}
    	}
    	else if(fly > 0)
    	{
    		P_PlayerUseArtifact(player, arti_fly);
    	}
    	if(player->mo->flags2&MF2_FLY)
    	{
    		player->mo->momz = player->flyheight*FRACUNIT;
    		if(player->flyheight)
    		{
    			player->flyheight /= 2;
    		}
    	} */
    }


    //
    // GET STUFF
    //

    
    // a weapon is found with two clip loads,
    // a big item has five clip loads
    
    public static final int[] clipammo = { 10, 4, 20, 1 };

    /**
     * P_GiveAmmo Num is the number of clip loads, not the individual count (0=
     * 1/2 clip).
     * 
     * @return false if the ammo can't be picked up at all
     * @param ammo
     *        intended to be ammotype_t.
     */
        
    public boolean GiveAmmo(ammotype_t amm, int num) {
        int oldammo;
        int ammo = amm.ordinal();
        if (ammo == ammotype_t.am_noammo.ordinal())
            return false;

        if (ammo < 0 || ammo > NUMAMMO)
            I.Error("P_GiveAmmo: bad type %i", ammo);

        if (this.ammo[ammo] == maxammo[ammo])
            return false;

        if (num != 0)
            num *= clipammo[ammo];
        else
            num = clipammo[ammo] / 2;

        if (DS.gameskill == skill_t.sk_baby
                ||DS.gameskill == skill_t.sk_nightmare) {
            // give double ammo in trainer mode,
            // you'll need in nightmare
            num <<= 1;
        }

        oldammo = this.ammo[ammo];
        this.ammo[ammo] += num;

        if (this.ammo[ammo] > maxammo[ammo])
            this.ammo[ammo] = maxammo[ammo];

        // If non zero ammo,
        // don't change up weapons,
        // player was lower on purpose.
        if (oldammo != 0)
            return true;

        // We were down to zero,
        // so select a new weapon.
        // Preferences are not user selectable.
        switch (ammotype_t.values()[ammo]) {
        case am_clip:
            if (readyweapon == weapontype_t.wp_fist) {
                if (weaponowned[weapontype_t.wp_chaingun.ordinal()])
                    pendingweapon = weapontype_t.wp_chaingun;
                else
                    pendingweapon = weapontype_t.wp_pistol;
            }
            break;

        case am_shell:
            if (readyweapon == weapontype_t.wp_fist
                    || readyweapon == weapontype_t.wp_pistol) {
                if (weaponowned[weapontype_t.wp_shotgun.ordinal()])
                    pendingweapon = weapontype_t.wp_shotgun;
            }
            break;

        case am_cell:
            if (readyweapon == weapontype_t.wp_fist
                    || readyweapon == weapontype_t.wp_pistol) {
                if (weaponowned[weapontype_t.wp_plasma.ordinal()])
                    pendingweapon = weapontype_t.wp_plasma;
            }
            break;

        case am_misl:
            if (readyweapon == weapontype_t.wp_fist) {
                if (weaponowned[weapontype_t.wp_missile.ordinal()])
                    pendingweapon = weapontype_t.wp_missile;
            }
        default:
            break;
        }

        return true;
    }

    public static final int BONUSADD = 6;

    /**
     * P_GiveWeapon
     * The weapon name may have a MF_DROPPED flag ored in.
     */
    
    public boolean GiveWeapon(weapontype_t weapn, boolean dropped) {
        boolean gaveammo;
        boolean gaveweapon;
        int weapon = weapn.ordinal();

        if (DS.netgame && (DS.deathmatch != true) // ???? was "2"
                && !dropped) {
            // leave placed weapons forever on net games
            if (weaponowned[weapon])
                return false;

            bonuscount += BONUSADD;
            weaponowned[weapon] = true;

            if (DS.deathmatch)
                GiveAmmo(weaponinfo[weapon].ammo, 5);
            else
                GiveAmmo(weaponinfo[weapon].ammo, 2);
            pendingweapon = weapn;

            if (this ==DS.players[DS.consoleplayer])
                S.StartSound (null, sfxenum_t.sfx_wpnup);
                return false;
        }

        if (weaponinfo[weapon].ammo != ammotype_t.am_noammo) {
            // give one clip with a dropped weapon,
            // two clips with a found weapon
            if (dropped)
                gaveammo = GiveAmmo(weaponinfo[weapon].ammo, 1);
            else
                gaveammo = GiveAmmo(weaponinfo[weapon].ammo, 2);
        } else
            gaveammo = false;

        if (weaponowned[weapon])
            gaveweapon = false;
        else {
            gaveweapon = true;
            weaponowned[weapon] = true;
            pendingweapon = weapn;
        }

        return (gaveweapon || gaveammo);
    }

    /**
     * P_GiveBody Returns false if the body isn't needed at all
     */

    public boolean GiveBody(int num) {
        if (this.health[0] >= MAXHEALTH)
            return false;

        health[0] += num;
        if (health[0] > MAXHEALTH)
            health[0] = MAXHEALTH;
        mo.health = health[0];

        return true;
    }

    /**
     * P_GiveArmor Returns false if the armor is worse than the current armor.
     */

    public boolean GiveArmor(int armortype) {
        int hits;

        hits = armortype * 100;
        if (armorpoints[0] >= hits)
            return false; // don't pick up

        this.armortype = armortype;
        armorpoints[0] = hits;

        return true;
    }

    /**
     * P_GiveCard
     */
    
    public void GiveCard(card_t crd) {
        int card = crd.ordinal();
        if (cards[card])
            return;

        bonuscount = BONUSADD;
        cards[card] = true;
    }

    //
    // P_GivePower
    //
    public boolean GivePower( int /* powertype_t */power) // MAES:
                                                                          // I
                                                                          // didn't
                                                                          // change
                                                                          // this!
    {
        if (power == pw_invulnerability) {
            powers[power] = INVULNTICS;
            return true;
        }

        if (power == pw_invisibility) {
            powers[power] = INVISTICS;
            mo.flags |= MF_SHADOW;
            return true;
        }

        if (power == pw_infrared) {
            powers[power] = INFRATICS;
            return true;
        }

        if (power == pw_ironfeet) {
            powers[power] = IRONTICS;
            return true;
        }

        if (power == pw_strength) {
            GiveBody(100);
            powers[power] = 1;
            return true;
        }

        if (powers[power] != 0)
            return false; // already got it

        powers[power] = 1;
        return true;
    }
 
    /**
     * G_PlayerFinishLevel
     * Called when a player completes a level.
     */

    public final void PlayerFinishLevel () 
    { 
        Arrays.fill(powers, 0);
        Arrays.fill(cards,false);       
        mo.flags &= ~mobj_t.MF_SHADOW;     // cancel invisibility 
        extralight = 0;          // cancel gun flashes 
        fixedcolormap = 0;       // cancel ir gogles 
        damagecount = 0;         // no palette changes 
        bonuscount = 0;
        lookdir = 0; // From heretic
    } 
    

    /**
     * P_PlayerInSpecialSector
     * Called every tic frame
     *  that the player origin is in a special sector
     */
    
    protected void PlayerInSpecialSector ()
    {
        sector_t   sector;
        
        sector = mo.subsector.sector;

        // Falling, not all the way down yet?
        if (mo.z != sector.floorheight)
        return; 

        // Has hitten ground.
        switch (sector.special)
        {
          case 5:
        // HELLSLIME DAMAGE
        if (powers[pw_ironfeet]==0)
            if (!flags(DS.leveltime,0x1f))
                P.DamageMobj (mo,null, null, 10);
        break;
        
          case 7:
        // NUKAGE DAMAGE
        if (powers[pw_ironfeet]==0)
            if (!flags(DS.leveltime,0x1f))
                P.DamageMobj (mo, null, null, 5);
        break;
        
          case 16:
        // SUPER HELLSLIME DAMAGE
          case 4:
        // STROBE HURT
        if (!eval(powers[pw_ironfeet])
            || (RND.P_Random()<5) )
        {
            if (!flags(DS.leveltime,0x1f))
            P.DamageMobj (mo, null, null, 20);
        }
        break;
                
          case 9:
        // SECRET SECTOR
        secretcount++;
        sector.special = 0;
        break;
                
          case 11:
        // EXIT SUPER DAMAGE! (for E1M8 finale)
        cheats &= ~CF_GODMODE;

        if (!flags(DS.leveltime,0x1f))
            P.DamageMobj (mo, null, null, 20);

        if (health[0] <= 10)
            DG.ExitLevel();
        break;
                
          default:
        I.Error ("P_PlayerInSpecialSector: unknown special %d", sector.special);
        break;
        };
    }    
   
 // Index of the special effects (INVUL inverse) map.
public static final int INVERSECOLORMAP		=LightsAndColors.LIGHTLEVELS;
    

 
 //
//P_CalcHeight
//Calculate the walking / running height adjustment
//
public void CalcHeight () 
{
  int     angle;
  int bob; // fixed
  
  // Regular movement bobbing
  // (needs to be calculated for gun swing
  // even if not on ground)
  // OPTIMIZE: tablify angle
  // Note: a LUT allows for effects
  //  like a ramp with low health.
  this.bob =
  FixedMul (mo.momx, mo.momx)
  + FixedMul (mo.momy,mo.momy);
  
  this.bob >>= 2;

        
  if (this.bob>MAXBOB)
	  this.bob = MAXBOB;

  
  
  if (flags(cheats ,CF_NOMOMENTUM) || !onground)
  {
  viewz = mo.z + VIEWHEIGHT;

  if (viewz > mo.ceilingz-4*FRACUNIT)
      viewz = mo.ceilingz-4*FRACUNIT;

  viewz = mo.z + viewheight;
  return;
  }
      
  angle = (FINEANGLES/20*DS.leveltime)&FINEMASK;
  bob = FixedMul ( this.bob/2, finesine[angle]);

  
  // move viewheight
  if (playerstate == PST_LIVE)
  {
  viewheight += deltaviewheight;

  if (viewheight > VIEWHEIGHT)
  {
      viewheight = VIEWHEIGHT;
      deltaviewheight = 0;
  }

  if (viewheight < VIEWHEIGHT/2)
  {
      viewheight = VIEWHEIGHT/2;
      if (deltaviewheight <= 0)
      deltaviewheight = 1;
  }
  
  if (deltaviewheight!=0)    
  {
      deltaviewheight += FRACUNIT/4;
      if (deltaviewheight==0)
      deltaviewheight = 1;
  }
  }
  viewz = mo.z + viewheight + bob;

  if (viewz > mo.ceilingz-4*FRACUNIT)
  viewz = mo.ceilingz-4*FRACUNIT;
} 
 
 private static final long ANG5   = (ANG90/18);

 /**
  * P_DeathThink
  * Fall on your face when dying.
  * Decrease POV height to floor height.
  * 
  * DOOMGUY IS SO AWESOME THAT HE THINKS EVEN WHEN DEAD!!!
  * 
  */

 
public void DeathThink ()
{
  long     angle; //angle_t
  long     delta;

  MovePsprites ();
  
  // fall to the ground
  if (viewheight > 6*FRACUNIT)
  viewheight -= FRACUNIT;

  if (viewheight < 6*FRACUNIT)
  viewheight = 6*FRACUNIT;

  deltaviewheight = 0;
  onground = (mo.z <= mo.floorz);
  CalcHeight ();
  
  if (attacker!=null && attacker != mo)
  {
  angle = R.PointToAngle2 (mo.x,
               mo.y,
               attacker.x,
               attacker.y);
  
  delta = Tables.addAngles(angle, - mo.angle);
  
  if (delta < ANG5 || delta > -ANG5)
  {
      // Looking at killer,
      //  so fade damage flash down.
      mo.angle = angle;

      if (damagecount!=0)
      damagecount--;
  }
  else if (delta < ANG180)
      mo.angle += ANG5;
  else
      mo.angle -= ANG5;
  }
  else if (damagecount!=0)
  damagecount--;
  

  if (flags(cmd.buttons ,BT_USE))
  playerstate = PST_REBORN;
}
 
//
// P_MovePsprites
// Called every tic by player thinking routine.
//
public void MovePsprites () 
{

    pspdef_t    psp;
    @SuppressWarnings("unused") // Shut up compiler
	state_t state=null;    
 
    for (int i=0 ; i<NUMPSPRITES ; i++)
    {
    	   psp = psprites[i];
    // a null state means not active
    if ( (state = psp.state)!=null )  
    {
        // drop tic count and possibly change state

        // a -1 tic count never changes
        if (psp.tics != -1) 
        {
        psp.tics--;
        if (!eval(psp.tics))
            this.SetPsprite (i, psp.state.nextstate);
        }               
    }
    }
    
    psprites[ps_flash].sx = psprites[ps_weapon].sx;
    psprites[ps_flash].sy = psprites[ps_weapon].sy;
}

/**
/* P_SetPsprite
*/

public void
SetPsprite
( int       position,
  statenum_t    newstate ) 
{
    pspdef_t    psp;
    state_t state;
    
    psp = psprites[position];
    
    do
    {
    if (newstate==null)
    {
        // object removed itself
        psp.state = null;
        break;  
    }
    
    state = states[newstate.ordinal()];
    psp.state = state;
    psp.tics = (int) state.tics;    // could be 0

    if (state.misc1!=0)
    {
        // coordinate set
        psp.sx = (int) (state.misc1 << FRACBITS);
        psp.sy = (int) (state.misc2 << FRACBITS);
    }
    
    // Call action routine.
    // Modified handling.
    if (state.acp2!=null)
    {
        state.acp2.invoke(this, psp);
        if (psp.state==null)
        break;
    }
    
    newstate = psp.state.nextstate;
    
    } while (psp.tics==0);
    // an initial state of 0 could cycle through
}


    /** Accessory method to identify which "doomguy" we are.
     *  Because we can't use the [target.player-players] syntax
     *  in order to get an array index, in Java.
     *  
     *  If -1 is returned, then we have existential problems.
     *
     */    
    
    public int identify(){
        
        
        if (id>=0) return id;
        int i;    
        // Let's assume that we know jack.
            for (i=0;i<DS.players.length;i++)
                if (this==DS.players[i]) break;
            
            return id=i;
        
    }
    
    private int id=-1;
    
    private boolean onground;


        	
    /* psprnum_t enum */
    public static int ps_weapon=0,
        ps_flash=1,
        NUMPSPRITES=2;  
    
    public static int  LOWERSPEED  =   MAPFRACUNIT*6;
    public static int  RAISESPEED  =   MAPFRACUNIT*6;

    public static int  WEAPONBOTTOM    =128*FRACUNIT;
    public static int  WEAPONTOP       =32*FRACUNIT;


    // plasma cells for a bfg attack
    private static int  BFGCELLS        =40;        


    /*
     P_SetPsprite
    
    
    public void
    SetPsprite
    ( player_t  player,
      int       position,
      statenum_t    newstate ) 
    {
        pspdef_t    psp;
        state_t state;
        
        psp = psprites[position];
        
        do
        {
        if (newstate==null)
        {
            // object removed itself
            psp.state = null;
            break;  
        }
        
        state = states[newstate.ordinal()];
        psp.state = state;
        psp.tics = (int) state.tics;    // could be 0

        if (state.misc1!=0)
        {
            // coordinate set
            psp.sx = (int) (state.misc1 << FRACBITS);
            psp.sy = (int) (state.misc2 << FRACBITS);
        }
        
        // Call action routine.
        // Modified handling.
        if (state.action.getType()==acp2)
        {
            P.A.dispatch(state.action,this, psp);
            if (psp.state==null)
            break;
        }
        
        newstate = psp.state.nextstate;
        
        } while (psp.tics==0);
        // an initial state of 0 could cycle through
    }
    */
    
    /** fixed_t */
    int     swingx, swingy;

    /**P_CalcSwing
     * 
     * @param player
     */
    public void CalcSwing (player_t   player)
    {
        int swing; // fixed_t
        int     angle;
        
        // OPTIMIZE: tablify this.
        // A LUT would allow for different modes,
        //  and add flexibility.

        swing = this.bob;

        angle = (FINEANGLES/70*DS.leveltime)&FINEMASK;
        swingx = FixedMul ( swing, finesine[angle]);

        angle = (FINEANGLES/70*DS.leveltime+FINEANGLES/2)&FINEMASK;
        swingy = -FixedMul ( swingx, finesine[angle]);
    }



    //
    // P_BringUpWeapon
    // Starts bringing the pending weapon up
    // from the bottom of the screen.
    // Uses player
    //
    public void BringUpWeapon ()
    {
        statenum_t  newstate=statenum_t.S_NULL;
        
        if (pendingweapon == weapontype_t.wp_nochange)
        pendingweapon = readyweapon;
            
        if (pendingweapon == weapontype_t.wp_chainsaw)
        S.StartSound (mo, sfxenum_t.sfx_sawup);
            
        newstate = weaponinfo[pendingweapon.ordinal()].upstate;

        pendingweapon = weapontype_t.wp_nochange;
        psprites[ps_weapon].sy = WEAPONBOTTOM;

        this.SetPsprite ( ps_weapon, newstate);
    }

    /**
     * P_CheckAmmo
     * Returns true if there is enough ammo to shoot.
     * If not, selects the next weapon to use.
     */
    
    public boolean CheckAmmo ()
    {
        ammotype_t      ammo;
        int         count;

        ammo = weaponinfo[readyweapon.ordinal()].ammo;

        // Minimal amount for one shot varies.
        if (readyweapon == weapontype_t.wp_bfg)
        count = BFGCELLS;
        else if (readyweapon == weapontype_t.wp_supershotgun)
        count = 2;  // Double barrel.
        else
        count = 1;  // Regular.

        // Some do not need ammunition anyway.
        // Return if current ammunition sufficient.
        if (ammo == ammotype_t.am_noammo || this.ammo[ammo.ordinal()] >= count)
        return true;
            
        // Out of ammo, pick a weapon to change to.
        // Preferences are set here.
        do
        {
        if (weaponowned[weapontype_t.wp_plasma.ordinal()]
            && (this.ammo[ammotype_t.am_cell.ordinal()]!=0)
            && !DS.isShareware() )
        {
            pendingweapon = weapontype_t.wp_plasma;
        }
        else if (weaponowned[weapontype_t.wp_supershotgun.ordinal()] 
             && this.ammo[ammotype_t.am_shell.ordinal()]>2
             && DS.isCommercial() )
        {
            pendingweapon = weapontype_t.wp_supershotgun;
        }
        else if (weaponowned[weapontype_t.wp_chaingun.ordinal()]
             && this.ammo[ammotype_t.am_clip.ordinal()]!=0)
        {
            pendingweapon = weapontype_t.wp_chaingun;
        }
        else if (weaponowned[weapontype_t.wp_shotgun.ordinal()]
             && this.ammo[ammotype_t.am_shell.ordinal()]!=0)
        {
            pendingweapon = weapontype_t.wp_shotgun;
        }
        else if (this.ammo[ammotype_t.am_clip.ordinal()]!=0)
        {
            pendingweapon = weapontype_t.wp_pistol;
        }
        else if (weaponowned[weapontype_t.wp_chainsaw.ordinal()])
        {
            pendingweapon = weapontype_t.wp_chainsaw;
        }
        else if (weaponowned[weapontype_t.wp_missile.ordinal()]
             && this.ammo[ammotype_t.am_misl.ordinal()]!=0)
        {
            pendingweapon = weapontype_t.wp_missile;
        }
        else if (weaponowned[weapontype_t.wp_bfg.ordinal()]
             && this.ammo[ammotype_t.am_cell.ordinal()]>40
             && !DS.isShareware() )
        {
            pendingweapon = weapontype_t.wp_bfg;
        }
        else
        {
            // If everything fails.
            pendingweapon = weapontype_t.wp_fist;
        }
        
        } while (pendingweapon == weapontype_t.wp_nochange);

        // Now set appropriate weapon overlay.
        this.SetPsprite (
              ps_weapon,
              weaponinfo[readyweapon.ordinal()].downstate);

        return false;   
    }


    /**
     * P_DropWeapon
     * Player died, so put the weapon away.
     */
    
    public void DropWeapon ()
    {
        this.SetPsprite (
              ps_weapon,
              weaponinfo[readyweapon.ordinal()].downstate);
    }

    /**
     * P_SetupPsprites
     * Called at start of level for each 
     */
    
    public void SetupPsprites () 
    {
        int i;
        
        // remove all psprites
        for (i=0 ; i<NUMPSPRITES ; i++)
        psprites[i].state = null;
            
        // spawn the gun
        pendingweapon = readyweapon;
        BringUpWeapon ();
    }
    
    /**
     *  P_PlayerThink
     */
    public void PlayerThink (player_t player)
    {
     ticcmd_t       cmd;
     weapontype_t    newweapon;
     
     // fixme: do this in the cheat code
     if (flags(player.cheats , player_t.CF_NOCLIP))
     player.mo.flags |= MF_NOCLIP;
     else
     player.mo.flags &= ~MF_NOCLIP;
     
     // chain saw run forward
     cmd = player.cmd;
     if (flags(player.mo.flags , MF_JUSTATTACKED))
     {
     cmd.angleturn = 0;
     cmd.forwardmove = (0xc800/512);
     cmd.sidemove = 0;
     player.mo.flags &= ~MF_JUSTATTACKED;
     }
             
     
     if (player.playerstate == PST_DEAD)
     {
     player.DeathThink ();
     return;
     }
     
     // Move around.
     // Reactiontime is used to prevent movement
     //  for a bit after a teleport.
     if (eval(player.mo.reactiontime))
     player.mo.reactiontime--;
     else
         player.MovePlayer ();
     
         player.CalcHeight ();

     if (eval(player.mo.subsector.sector.special))
         player.PlayerInSpecialSector ();
     
     // Check for weapon change.

     // A special event has no other buttons.
     if (flags(cmd.buttons , BT_SPECIAL))
     cmd.buttons = 0;           
         
     if (flags(cmd.buttons , BT_CHANGE))
     {
     // The actual changing of the weapon is done
     //  when the weapon psprite can do it
     //  (read: not in the middle of an attack).
    // System.out.println("Weapon change detected, attempting to perform");
         
     newweapon = weapontype_t.values()[(cmd.buttons&BT_WEAPONMASK)>>BT_WEAPONSHIFT];

     // If chainsaw is available, it won't change back to the fist 
     // unless player also has berserk.
     if (newweapon == weapontype_t.wp_fist
         && player.weaponowned[weapontype_t.wp_chainsaw.ordinal()]
         && !(player.readyweapon == weapontype_t.wp_chainsaw
          && eval(player.powers[pw_strength])))
     {
         newweapon = weapontype_t.wp_chainsaw;
     }
     
     // Will switch between SG and SSG in Doom 2.
     
     if ( DS.isCommercial()
         && newweapon == weapontype_t.wp_shotgun 
         && player.weaponowned[weapontype_t.wp_supershotgun.ordinal()]
         && player.readyweapon != weapontype_t.wp_supershotgun)
     {
         newweapon = weapontype_t.wp_supershotgun;
     }
     

     if (player.weaponowned[newweapon.ordinal()]
         && newweapon != player.readyweapon)
     {
         // Do not go to plasma or BFG in shareware,
         //  even if cheated.
         if ((newweapon != weapontype_t.wp_plasma
          && newweapon != weapontype_t.wp_bfg)
         || !DS.isShareware() )
         {
         player.pendingweapon = newweapon;
         }
     }
     }
     
     // check for use
     if (flags(cmd.buttons , BT_USE))
     {
     if (!player.usedown)
     {
         P.UseLines (player);
         player.usedown = true;
     }
     }
     else
     player.usedown = false;
     
     // cycle psprites
     player.MovePsprites ();
     
     // Counters, time dependent power ups.

     // Strength counts up to diminish fade.
     if (eval(player.powers[pw_strength]))
     player.powers[pw_strength]++;  
         
     if (eval(player.powers[pw_invulnerability]))
     player.powers[pw_invulnerability]--;

     if (eval(player.powers[pw_invisibility]))
     if (! eval(--player.powers[pw_invisibility]) )
         player.mo.flags &= ~MF_SHADOW;
             
     if (eval(player.powers[pw_infrared]))
     player.powers[pw_infrared]--;
         
     if (eval(player.powers[pw_ironfeet]))
     player.powers[pw_ironfeet]--;
         
     if (eval(player.damagecount))
     player.damagecount--;
         
     if (eval(player.bonuscount))
     player.bonuscount--;

     
     // Handling colormaps.
     if (eval(player.powers[pw_invulnerability]))
     {
     if (player.powers[pw_invulnerability] > 4*32
         || flags(player.powers[pw_invulnerability],8) )
         player.fixedcolormap = player_t.INVERSECOLORMAP;
     else
         player.fixedcolormap = 0;
     }
     else if (eval(player.powers[pw_infrared]))
     {
     if (player.powers[pw_infrared] > 4*32
         || flags(player.powers[pw_infrared],8) )
     {
         // almost full bright
         player.fixedcolormap = 1;
     }
     else
         player.fixedcolormap = 0;
     }
     else
     player.fixedcolormap = 0;
    }

    /**
     * G_PlayerReborn
     * Called after a player dies 
     * almost everything is cleared and initialized 
     *
     *
     */

    public void PlayerReborn () 
    { 
        int     i; 
        int[]     frags=new int [MAXPLAYERS]; 
        int     killcount;
        int     itemcount;
        int     secretcount; 

        // System.arraycopy(players[player].frags, 0, frags, 0, frags.length);
        // We save the player's frags here...
        C2JUtils.memcpy (frags,this.frags,frags.length); 
        killcount = this.killcount; 
        itemcount = this.itemcount; 
        secretcount = this.secretcount; 

        //MAES: we need to simulate an erasure, possibly without making
        // a new object.memset (p, 0, sizeof(*p));
        //players[player]=(player_t) player_t.nullplayer.clone();
        // players[player]=new player_t();
        this.reset();

        // And we copy the old frags into the "new" player. 
        C2JUtils.memcpy(this.frags, frags, this.frags.length); 

        this.killcount = killcount; 
        this.itemcount = itemcount; 
        this.secretcount = secretcount; 

        usedown = attackdown = true;  // don't do anything immediately 
        playerstate = PST_LIVE;       
        health[0] = MAXHEALTH; 
        readyweapon = pendingweapon = weapontype_t.wp_pistol; 
        weaponowned[weapontype_t.wp_fist.ordinal()] = true; 
        weaponowned[weapontype_t.wp_pistol.ordinal()] = true;        
        ammo[ammotype_t.am_clip.ordinal()] = 50; 
        lookdir = 0; // From Heretic

        for (i=0 ; i<NUMAMMO ; i++) 
        	this.maxammo[i] = DoomStatus.maxammo[i]; 

    }

    
    /** Called by Actions ticker */
    public void PlayerThink() {
        PlayerThink(this);       
    }

	@Override
	public void updateStatus(DoomStatus DS) {
	    this.DS=DS;
	    this.DG=DS.DG;
	    this.P=DS.P;
	    this.R=DS.R;
	    this.RND=DS.RND;
	    this.I=DS.I;
	    this.S=DS.S;
	}

	public String toString(){
		sb.setLength(0);
		sb.append("player");
		sb.append(" momx ");
		sb.append(this.mo.momx);
		sb.append(" momy ");
		sb.append(this.mo.momy);
		sb.append(" x ");
		sb.append(this.mo.x);
		sb.append(" y ");
		sb.append(this.mo.y);
		return sb.toString();
	}

	private static StringBuilder sb=new StringBuilder();

    public void read(DataInputStream f) throws IOException{

            // Careful when loading/saving:
            // A player only carries a pointer to a mobj, which is "saved"
            // but later discarded at load time, at least in vanilla. In any case,
           // it has the size of a 32-bit integer, so make sure you skip it.
           // TODO: OK, so vanilla's monsters lost "state" when saved, including non-Doomguy
            //  infighting. Did they "remember" Doomguy too?
            // ANSWER: they didn't.
        
            // The player is special in that it unambigously allows identifying
            // its own map object in an absolute way. Once we identify
            // at least one (e.g. object #45 is pointer 0x43545345) then, since
            // map objects are stored in a nice serialized order.
            this.p_mobj= DoomIO.readLEInt(f); // player mobj pointer
            
            this.playerstate=DoomIO.readLEInt(f);
            this.cmd.read(f);
            this.viewz=DoomIO.readLEInt(f);
            this.viewheight= DoomIO.readLEInt(f);
            this.deltaviewheight= DoomIO.readLEInt(f);
            this.bob=DoomIO.readLEInt(f);
            this.health[0]=DoomIO.readLEInt(f);
            this.armorpoints[0]=DoomIO.readLEInt(f); 
            this.armortype=DoomIO.readLEInt(f); 
            DoomIO.readIntArray(f,this.powers, ByteOrder.LITTLE_ENDIAN); 
            DoomIO.readBooleanIntArray(f,this.cards);
            this.backpack=DoomIO.readIntBoolean(f);
            DoomIO.readIntArray(f,frags, ByteOrder.LITTLE_ENDIAN);
            this.readyweapon=weapontype_t.values()[DoomIO.readLEInt(f)];
            this.pendingweapon=weapontype_t.values()[DoomIO.readLEInt(f)];
            DoomIO.readBooleanIntArray(f,this.weaponowned);
            DoomIO.readIntArray(f,ammo,ByteOrder.LITTLE_ENDIAN);
            DoomIO.readIntArray(f,maxammo,ByteOrder.LITTLE_ENDIAN);
            // Read these as "int booleans"
            this.attackdown=DoomIO.readIntBoolean(f);
            this.usedown=DoomIO.readIntBoolean(f);
            this.cheats=DoomIO.readLEInt(f);
            this.refire=DoomIO.readLEInt(f);
            // For intermission stats.
            this.killcount=DoomIO.readLEInt(f);
            this.itemcount=DoomIO.readLEInt(f);
            this.secretcount=DoomIO.readLEInt(f);
            // Hint messages.
            f.skipBytes(4);
            // For screen flashing (red or bright).
            this.damagecount=DoomIO.readLEInt(f);
            this.bonuscount=DoomIO.readLEInt(f);
            // Who did damage (NULL for floors/ceilings).
            // TODO: must be properly denormalized before saving/loading
            f.skipBytes(4); // TODO: waste a read for attacker mobj.
            // So gun flashes light up areas.
            this.extralight=DoomIO.readLEInt(f);
            // Current PLAYPAL, ???
            //  can be set to REDCOLORMAP for pain, etc.
            this.fixedcolormap=DoomIO.readLEInt(f);
            this.colormap=DoomIO.readLEInt(f);
            // PSPDEF _is_ readable.
            for (pspdef_t p: this.psprites)
                p.read(f);
            this.didsecret=DoomIO.readIntBoolean(f);
            // Total size should be 280 bytes.
        }
    
    public void write(DataOutputStream f) throws IOException{

        // It's much more convenient to pre-buffer, since
        // we'll be writing all Little Endian stuff.
        ByteBuffer b=ByteBuffer.allocate(280);
        this.pack(b);
        // Total size should be 280 bytes.
        // Write everything nicely and at once.        
        f.write(b.array());
    }
    
    // Used to disambiguate between objects
    public int p_mobj;

    @Override
    public void pack(ByteBuffer buf)
            throws IOException {
        
        ByteOrder bo=ByteOrder.LITTLE_ENDIAN;
        buf.order(bo);
        // The player is special in that it unambiguously allows identifying
        // its own map object in an absolute way. Once we identify
        // at least one (e.g. object #45 is pointer 0x43545345) then, since
        // map objects are stored in a nice serialized order by using
        // their next/prev pointers, you can reconstruct their
        // relationships a posteriori.
        // Store our own hashcode or "pointer" if you wish.
        buf.putInt(pointer(mo));
        buf.putInt(playerstate);
        cmd.pack(buf);
        buf.putInt(viewz);        
        buf.putInt(viewheight);
        buf.putInt(deltaviewheight);
        buf.putInt(bob);
        buf.putInt(health[0]);
        buf.putInt(armorpoints[0]); 
        buf.putInt(armortype);
        DoomBuffer.putIntArray(buf,this.powers,this.powers.length,bo); 
        DoomBuffer.putBooleanIntArray(buf,this.cards,this.cards.length, bo);
        DoomBuffer.putBooleanInt(buf,backpack,bo);
        DoomBuffer.putIntArray(buf,this.frags,this.frags.length,bo);
        buf.putInt(readyweapon.ordinal());
        buf.putInt(pendingweapon.ordinal());
        DoomBuffer.putBooleanIntArray(buf,this.weaponowned,this.weaponowned.length, bo);
        DoomBuffer.putIntArray(buf,this.ammo,this.ammo.length, bo);
        DoomBuffer.putIntArray(buf,this.maxammo,this.maxammo.length, bo);
        // Read these as "int booleans"
        DoomBuffer.putBooleanInt(buf,attackdown,bo);
        DoomBuffer.putBooleanInt(buf,usedown,bo);        
        buf.putInt(cheats);
        buf.putInt(refire);
        // For intermission stats.
        buf.putInt(this.killcount);
        buf.putInt(this.itemcount);
        buf.putInt(this.secretcount);
        // Hint messages.
        buf.putInt(0);
        // For screen flashing (red or bright).
        buf.putInt(this.damagecount);
        buf.putInt(this.bonuscount);
        // Who did damage (NULL for floors/ceilings).
        // TODO: must be properly denormalized before saving/loading
        buf.putInt(pointer(attacker));
        // So gun flashes light up areas.
        buf.putInt(this.extralight);
        // Current PLAYPAL, ???
        //  can be set to REDCOLORMAP for pain, etc.
        buf.putInt(this.fixedcolormap);
        buf.putInt(this.colormap);
        // PSPDEF _is_ readable.
        for (pspdef_t p: this.psprites)
            p.pack(buf);
        buf.putInt(this.didsecret?1:0);
        
    }
        
    }
package doom;

/** killough 8/29/98: threads of thinkers, for more efficient searches
 * cph 2002/01/13: for consistency with the main thinker list, keep objects
 * pending deletion on a class list too
 */


public enum th_class {
      th_delete,
      th_misc,
      th_friends,
      th_enemies,
      th_all;
      
      public static final int NUMTHCLASS=th_class.values().length;
}

package doom;

import java.nio.ByteBuffer;

import utils.C2JUtils;
import w.DoomBuffer;

public class doomdata_t implements IDatagramSerializable {

    public static final int DOOMDATALEN=8+data.Defines.BACKUPTICS*ticcmd_t.TICCMDLEN;
    
     // High bit is retransmit request.
     /** MAES: was "unsigned" */
     public int        checksum; 
     
     /* CAREFUL!!! Those "bytes" are actually unsigned
      * 
      */
     
     /** Only valid if NCMD_RETRANSMIT. */     
     public byte        retransmitfrom;
     
     public byte        starttic;
     public byte        player;
     public byte        numtics;
     public ticcmd_t[]        cmds;
     
    public doomdata_t(){
        cmds=new ticcmd_t[data.Defines.BACKUPTICS];
        C2JUtils.initArrayOfObjects(cmds);
        // Enough space for its own header + the ticcmds;
        buffer=new byte[DOOMDATALEN];
        // This "pegs" the ByteBuffer to this particular array.
        // Separate updates are not necessary.
        bbuf=ByteBuffer.wrap(buffer);
    }
    
    // Used for datagram serialization.
    private byte[] buffer;
    private ByteBuffer bbuf;

    
    
    @Override
    public byte[] pack() {        
        
        bbuf.rewind();
        
        // Why making it harder?
        bbuf.putInt(checksum);
        bbuf.put(retransmitfrom);
        bbuf.put(starttic);
        bbuf.put(player);
        bbuf.put(numtics);
        
        // FIXME: it's probably more efficient to use System.arraycopy ? 
        // Or are the packets too small anyway? At most we'll be sending "doomdata_t's"
        
        for (int i=0;i<cmds.length;i++){
            bbuf.put(cmds[i].pack());
        }
        
        return bbuf.array();
    
    }

    @Override
    public void pack(byte[] buf, int offset) {
        
        // No need to make it harder...just pack it and slap it in.
        byte[] tmp=this.pack();
        System.arraycopy(tmp, 0, buf, offset, tmp.length);        
    }

    @Override
    public void unpack(byte[] buf) {
        unpack(buf,0);
    }

    @Override
    public void unpack(byte[] buf, int offset) {
        checksum=DoomBuffer.getBEInt(buf);
        offset=+4;
        retransmitfrom=buf[offset++];
        starttic=buf[offset++];
        player=buf[offset++];
        numtics=buf[offset++];
        
        for (int i=0;i<cmds.length;i++){
            cmds[i].unpack(buf,offset);
            offset+=ticcmd_t.TICCMDLEN;
            }
        
    }
    
    public void selfUnpack(){
        unpack(this.buffer);
    }
    
    public void copyFrom(doomdata_t source) {        
        this.checksum=source.checksum;
        this.numtics=source.numtics;
        this.player=source.player;
        this.retransmitfrom=source.retransmitfrom;
        this.starttic=source.starttic;
        
        // MAES: this was buggy as hell, and didn't work at all, which
        // in turn prevented other subsystems such as speed throttling and
        // networking to work.
        // 
        // This should be enough to alter the ByteBuffer too.
        //System.arraycopy(source.cached(), 0, this.buffer, 0, DOOMDATALEN);
        // This should set all fields
        //selfUnpack();        
        }
    
    @Override
     public byte[] cached(){
         return this.buffer;
     }
    
    StringBuilder sb=new StringBuilder();
    public String toString(){
        sb.setLength(0);
        sb.append("doomdata_t ");
        sb.append(retransmitfrom);
        sb.append(" starttic ");
        sb.append(starttic);
        sb.append(" player ");
        sb.append(player);
        sb.append(" numtics ");
        sb.append(numtics);
        return sb.toString();
        
    }

 }

package doom;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: net.java,v 1.5 2011/02/11 00:11:13 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: net.java,v $
// Revision 1.5  2011/02/11 00:11:13  velktron
// A MUCH needed update to v1.3.
//
// Revision 1.1  2010/06/30 08:58:50  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//	DOOM Network game communication and protocol,
//	all OS independend parts.
//
//-----------------------------------------------------------------------------


//static const char rcsid[] = "$Id: net.java,v 1.5 2011/02/11 00:11:13 velktron Exp $";


//#include "m_menu.h"
//#include "i_system.h"
//#include "i_video.h"
//#include "i_net.h"
//#include "g_game.h"
import static data.Defines.*;
import data.doomstat.*;

//
//Network play related stuff.
//There is a data struct that stores network
//communication related stuff, and another
//one that defines the actual packets to
//be transmitted.
//


public class net{

protected static int	NCMD_EXIT=		0x80000000;
protected static int   	NCMD_RETRANSMIT		=0x40000000;
protected static int   	NCMD_SETUP		=0x20000000;
protected static int   NCMD_KILL	=	0x10000000;	// kill game
protected static int   	NCMD_CHECKSUM	= 	0x0fffffff;

protected static int  DOOMCOM_ID =     0x12345678;

//Max computers/players in a game.
protected static int    MAXNETNODES   =  8;


//Networking and tick handling related.
protected static int    BACKUPTICS     = 12;


// commant_t
protected  static int CMD_SEND    = 1;
protected  static int CMD_GET = 2; 

doomcom_t	doomcom;	
doomdata_t	netbuffer;		// points inside doomcom


//
// NETWORKING
//
// gametic is the tic about to (or currently being) run
// maketic is the tick that hasn't had control made for it yet
// nettics[] has the maketics for all players 
//
// a gametic cannot be run until nettics[] > gametic for all players
//
public static int	RESENDCOUNT	=10;
public static int	PL_DRONE	=0x80;	// bit flag in doomdata->player

ticcmd_t[]	localcmds= new ticcmd_t[BACKUPTICS];

ticcmd_t [][]       netcmds=new ticcmd_t [MAXPLAYERS][BACKUPTICS];
int[]         	nettics=new int[MAXNETNODES];
boolean[]		nodeingame=new boolean[MAXNETNODES];		// set false as nodes leave game
boolean[]		remoteresend=new boolean[MAXNETNODES];		// set when local needs tics
int[]		resendto=new int[MAXNETNODES];			// set when remote needs tics
int[]		resendcount=new int[MAXNETNODES];

int[]		nodeforplayer=new int[MAXPLAYERS];

int             maketic;
int		lastnettic;
int		skiptics;
int		ticdup;		
int		maxsend;	// BACKUPTICS/(2*ticdup)-1


//void D_ProcessEvents (void); 
//void G_BuildTiccmd (ticcmd_t *cmd); 
//void D_DoAdvanceDemo (void);
 
boolean		reboundpacket;
doomdata_t	reboundstore;



// 
//
//123

/** MAES: interesting. After testing it was found to return the following size:
 * 
 */

int NetbufferSize ()
{
//    return (int)(((doomdata_t)0).cmds[netbuffer.numtics]);
    return (8*(netbuffer.numtics+1));
}

}
/*

//1
// Checksum 
//
unsigned NetbufferChecksum (void)
{
    unsigned		c;
    int		i,l;

    c = 0x1234567;

    // FIXME -endianess?
#ifdef NORMALUNIX
    return 0;			// byte order problems
#endif

    l = (NetbufferSize () - (int)&(((doomdata_t *)0)->retransmitfrom))/4;
    for (i=0 ; i<l ; i++)
	c += ((unsigned *)&netbuffer->retransmitfrom)[i] * (i+1);

    return c & NCMD_CHECKSUM;
}

//
//
//
int ExpandTics (int low)
{
    int	delta;
	
    delta = low - (maketic&0xff);
	
    if (delta >= -64 && delta <= 64)
	return (maketic&~0xff) + low;
    if (delta > 64)
	return (maketic&~0xff) - 256 + low;
    if (delta < -64)
	return (maketic&~0xff) + 256 + low;
		
    I_Error ("ExpandTics: strange value %i at maketic %i",low,maketic);
    return 0;
}



//
// HSendPacket
//
void
HSendPacket
 (int	node,
  int	flags )
{
    netbuffer->checksum = NetbufferChecksum () | flags;

    if (!node)
    {
	reboundstore = *netbuffer;
	reboundpacket = true;
	return;
    }

    if (demoplayback)
	return;

    if (!netgame)
	I_Error ("Tried to transmit to another node");
		
    doomcom->command = CMD_SEND;
    doomcom->remotenode = node;
    doomcom->datalength = NetbufferSize ();
	
    if (debugfile)
    {
	int		i;
	int		realretrans;
	if (netbuffer->checksum & NCMD_RETRANSMIT)
	    realretrans = ExpandTics (netbuffer->retransmitfrom);
	else
	    realretrans = -1;

	fprintf (debugfile,"send (%i + %i, R %i) [%i] ",
		 ExpandTics(netbuffer->starttic),
		 netbuffer->numtics, realretrans, doomcom->datalength);
	
	for (i=0 ; i<doomcom->datalength ; i++)
	    fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);

	fprintf (debugfile,"\n");
    }

    I_NetCmd ();
}

//
// HGetPacket
// Returns false if no packet is waiting
//
boolean HGetPacket (void)
{	
    if (reboundpacket)
    {
	*netbuffer = reboundstore;
	doomcom->remotenode = 0;
	reboundpacket = false;
	return true;
    }

    if (!netgame)
	return false;

    if (demoplayback)
	return false;
		
    doomcom->command = CMD_GET;
    I_NetCmd ();
    
    if (doomcom->remotenode == -1)
	return false;

    if (doomcom->datalength != NetbufferSize ())
    {
	if (debugfile)
	    fprintf (debugfile,"bad packet length %i\n",doomcom->datalength);
	return false;
    }
	
    if (NetbufferChecksum () != (netbuffer->checksum&NCMD_CHECKSUM) )
    {
	if (debugfile)
	    fprintf (debugfile,"bad packet checksum\n");
	return false;
    }

    if (debugfile)
    {
	int		realretrans;
	int	i;
			
	if (netbuffer->checksum & NCMD_SETUP)
	    fprintf (debugfile,"setup packet\n");
	else
	{
	    if (netbuffer->checksum & NCMD_RETRANSMIT)
		realretrans = ExpandTics (netbuffer->retransmitfrom);
	    else
		realretrans = -1;
	    
	    fprintf (debugfile,"get %i = (%i + %i, R %i)[%i] ",
		     doomcom->remotenode,
		     ExpandTics(netbuffer->starttic),
		     netbuffer->numtics, realretrans, doomcom->datalength);

	    for (i=0 ; i<doomcom->datalength ; i++)
		fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
	    fprintf (debugfile,"\n");
	}
    }
    return true;	
}


//
// GetPackets
//
char    exitmsg[80];

void GetPackets (void)
{
    int		netconsole;
    int		netnode;
    ticcmd_t	*src, *dest;
    int		realend;
    int		realstart;
				 
    while ( HGetPacket() )
    {
	if (netbuffer->checksum & NCMD_SETUP)
	    continue;		// extra setup packet
			
	netconsole = netbuffer->player & ~PL_DRONE;
	netnode = doomcom->remotenode;
	
	// to save bytes, only the low byte of tic numbers are sent
	// Figure out what the rest of the bytes are
	realstart = ExpandTics (netbuffer->starttic);		
	realend = (realstart+netbuffer->numtics);
	
	// check for exiting the game
	if (netbuffer->checksum & NCMD_EXIT)
	{
	    if (!nodeingame[netnode])
		continue;
	    nodeingame[netnode] = false;
	    playeringame[netconsole] = false;
	    strcpy (exitmsg, "Player 1 left the game");
	    exitmsg[7] += netconsole;
	    players[consoleplayer].message = exitmsg;
	    if (demorecording)
		G_CheckDemoStatus ();
	    continue;
	}
	
	// check for a remote game kill
	if (netbuffer->checksum & NCMD_KILL)
	    I_Error ("Killed by network driver");

	nodeforplayer[netconsole] = netnode;
	
	// check for retransmit request
	if ( resendcount[netnode] <= 0 
	     && (netbuffer->checksum & NCMD_RETRANSMIT) )
	{
	    resendto[netnode] = ExpandTics(netbuffer->retransmitfrom);
	    if (debugfile)
		fprintf (debugfile,"retransmit from %i\n", resendto[netnode]);
	    resendcount[netnode] = RESENDCOUNT;
	}
	else
	    resendcount[netnode]--;
	
	// check for out of order / duplicated packet		
	if (realend == nettics[netnode])
	    continue;
			
	if (realend < nettics[netnode])
	{
	    if (debugfile)
		fprintf (debugfile,
			 "out of order packet (%i + %i)\n" ,
			 realstart,netbuffer->numtics);
	    continue;
	}
	
	// check for a missed packet
	if (realstart > nettics[netnode])
	{
	    // stop processing until the other system resends the missed tics
	    if (debugfile)
		fprintf (debugfile,
			 "missed tics from %i (%i - %i)\n",
			 netnode, realstart, nettics[netnode]);
	    remoteresend[netnode] = true;
	    continue;
	}

	// update command store from the packet
        {
	    int		start;

	    remoteresend[netnode] = false;
		
	    start = nettics[netnode] - realstart;		
	    src = &netbuffer->cmds[start];

	    while (nettics[netnode] < realend)
	    {
		dest = &netcmds[netconsole][nettics[netnode]%BACKUPTICS];
		nettics[netnode]++;
		*dest = *src;
		src++;
	    }
	}
    }
}


//
// NetUpdate
// Builds ticcmds for console player,
// sends out a packet
//
int      gametime;

void NetUpdate (void)
{
    int             nowtime;
    int             newtics;
    int				i,j;
    int				realstart;
    int				gameticdiv;
    
    // check time
    nowtime = I_GetTime ()/ticdup;
    newtics = nowtime - gametime;
    gametime = nowtime;
	
    if (newtics <= 0) 	// nothing new to update
	goto listen; 

    if (skiptics <= newtics)
    {
	newtics -= skiptics;
	skiptics = 0;
    }
    else
    {
	skiptics -= newtics;
	newtics = 0;
    }
	
		
    netbuffer->player = consoleplayer;
    
    // build new ticcmds for console player
    gameticdiv = gametic/ticdup;
    for (i=0 ; i<newtics ; i++)
    {
	I_StartTic ();
	D_ProcessEvents ();
	if (maketic - gameticdiv >= BACKUPTICS/2-1)
	    break;          // can't hold any more
	
	//printf ("mk:%i ",maketic);
	G_BuildTiccmd (&localcmds[maketic%BACKUPTICS]);
	maketic++;
    }


    if (singletics)
	return;         // singletic update is syncronous
    
    // send the packet to the other nodes
    for (i=0 ; i<doomcom->numnodes ; i++)
	if (nodeingame[i])
	{
	    netbuffer->starttic = realstart = resendto[i];
	    netbuffer->numtics = maketic - realstart;
	    if (netbuffer->numtics > BACKUPTICS)
		I_Error ("NetUpdate: netbuffer->numtics > BACKUPTICS");

	    resendto[i] = maketic - doomcom->extratics;

	    for (j=0 ; j< netbuffer->numtics ; j++)
		netbuffer->cmds[j] = 
		    localcmds[(realstart+j)%BACKUPTICS];
					
	    if (remoteresend[i])
	    {
		netbuffer->retransmitfrom = nettics[i];
		HSendPacket (i, NCMD_RETRANSMIT);
	    }
	    else
	    {
		netbuffer->retransmitfrom = 0;
		HSendPacket (i, 0);
	    }
	}
    
    // listen for other packets
  listen:
    GetPackets ();
}



//
// CheckAbort
//
void CheckAbort (void)
{
    event_t *ev;
    int		stoptic;
	
    stoptic = I_GetTime () + 2; 
    while (I_GetTime() < stoptic) 
	I_StartTic (); 
	
    I_StartTic ();
    for ( ; eventtail != eventhead 
	      ; eventtail = (++eventtail)&(MAXEVENTS-1) ) 
    { 
	ev = &events[eventtail]; 
	if (ev->type == ev_keydown && ev->data1 == KEY_ESCAPE)
	    I_Error ("Network game synchronization aborted.");
    } 
}


//
// D_ArbitrateNetStart
//
void D_ArbitrateNetStart (void)
{
    int		i;
    boolean	gotinfo[MAXNETNODES];
	
    autostart = true;
    memset (gotinfo,0,sizeof(gotinfo));
	
    if (doomcom->consoleplayer)
    {
	// listen for setup info from key player
	printf ("listening for network start info...\n");
	while (1)
	{
	    CheckAbort ();
	    if (!HGetPacket ())
		continue;
	    if (netbuffer->checksum & NCMD_SETUP)
	    {
		if (netbuffer->player != VERSION)
		    I_Error ("Different DOOM versions cannot play a net game!");
		startskill = netbuffer->retransmitfrom & 15;
		deathmatch = (netbuffer->retransmitfrom & 0xc0) >> 6;
		nomonsters = (netbuffer->retransmitfrom & 0x20) > 0;
		respawnparm = (netbuffer->retransmitfrom & 0x10) > 0;
		startmap = netbuffer->starttic & 0x3f;
		startepisode = netbuffer->starttic >> 6;
		return;
	    }
	}
    }
    else
    {
	// key player, send the setup info
	printf ("sending network start info...\n");
	do
	{
	    CheckAbort ();
	    for (i=0 ; i<doomcom->numnodes ; i++)
	    {
		netbuffer->retransmitfrom = startskill;
		if (deathmatch)
		    netbuffer->retransmitfrom |= (deathmatch<<6);
		if (nomonsters)
		    netbuffer->retransmitfrom |= 0x20;
		if (respawnparm)
		    netbuffer->retransmitfrom |= 0x10;
		netbuffer->starttic = startepisode * 64 + startmap;
		netbuffer->player = VERSION;
		netbuffer->numtics = 0;
		HSendPacket (i, NCMD_SETUP);
	    }

#if 1
	    for(i = 10 ; i  &&  HGetPacket(); --i)
	    {
		if((netbuffer->player&0x7f) < MAXNETNODES)
		    gotinfo[netbuffer->player&0x7f] = true;
	    }
#else
	    while (HGetPacket ())
	    {
		gotinfo[netbuffer->player&0x7f] = true;
	    }
#endif

	    for (i=1 ; i<doomcom->numnodes ; i++)
		if (!gotinfo[i])
		    break;
	} while (i < doomcom->numnodes);
    }
}

//
// D_CheckNetGame
// Works out player numbers among the net participants
//
extern	int			viewangleoffset;

void D_CheckNetGame (void)
{
    int             i;
	
    for (i=0 ; i<MAXNETNODES ; i++)
    {
	nodeingame[i] = false;
       	nettics[i] = 0;
	remoteresend[i] = false;	// set when local needs tics
	resendto[i] = 0;		// which tic to start sending
    }
	
    // I_InitNetwork sets doomcom and netgame
    I_InitNetwork ();
    if (doomcom->id != DOOMCOM_ID)
	I_Error ("Doomcom buffer invalid!");
    
    netbuffer = &doomcom->data;
    consoleplayer = displayplayer = doomcom->consoleplayer;
    if (netgame)
	D_ArbitrateNetStart ();

    printf ("startskill %i  deathmatch: %i  startmap: %i  startepisode: %i\n",
	    startskill, deathmatch, startmap, startepisode);
	
    // read values out of doomcom
    ticdup = doomcom->ticdup;
    maxsend = BACKUPTICS/(2*ticdup)-1;
    if (maxsend<1)
	maxsend = 1;
			
    for (i=0 ; i<doomcom->numplayers ; i++)
	playeringame[i] = true;
    for (i=0 ; i<doomcom->numnodes ; i++)
	nodeingame[i] = true;
	
    printf ("player %i of %i (%i nodes)\n",
	    consoleplayer+1, doomcom->numplayers, doomcom->numnodes);

}


//
// D_QuitNetGame
// Called before quitting to leave a net game
// without hanging the other players
//
void D_QuitNetGame (void)
{
    int             i, j;
	
    if (debugfile)
	fclose (debugfile);
		
    if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
	return;
	
    // send a bunch of packets for security
    netbuffer->player = consoleplayer;
    netbuffer->numtics = 0;
    for (i=0 ; i<4 ; i++)
    {
	for (j=1 ; j<doomcom->numnodes ; j++)
	    if (nodeingame[j])
		HSendPacket (j, NCMD_EXIT);
	I_WaitVBL (1);
    }
}



//
// TryRunTics
//
int	frametics[4];
int	frameon;
int	frameskip[4];
int	oldnettics;

extern	boolean	advancedemo;

public static void TryRunTics ()
{
    int		i;
    int		lowtic;
    int		entertic;
    static int	oldentertics;
    int		realtics;
    int		availabletics;
    int		counts;
    int		numplaying;
    
    // get real tics		
    entertic = I_GetTime ()/ticdup;
    realtics = entertic - oldentertics;
    oldentertics = entertic;
    
    // get available tics
    NetUpdate ();
	
    lowtic = MAXINT;
    numplaying = 0;
    for (i=0 ; i<doomcom->numnodes ; i++)
    {
	if (nodeingame[i])
	{
	    numplaying++;
	    if (nettics[i] < lowtic)
		lowtic = nettics[i];
	}
    }
    availabletics = lowtic - gametic/ticdup;
    
    // decide how many tics to run
    if (realtics < availabletics-1)
	counts = realtics+1;
    else if (realtics < availabletics)
	counts = realtics;
    else
	counts = availabletics;
    
    if (counts < 1)
	counts = 1;
		
    frameon++;

    if (debugfile)
	fprintf (debugfile,
		 "=======real: %i  avail: %i  game: %i\n",
		 realtics, availabletics,counts);

    if (!demoplayback)
    {	
	// ideally nettics[0] should be 1 - 3 tics above lowtic
	// if we are consistantly slower, speed up time
	for (i=0 ; i<MAXPLAYERS ; i++)
	    if (playeringame[i])
		break;
	if (consoleplayer == i)
	{
	    // the key player does not adapt
	}
	else
	{
	    if (nettics[0] <= nettics[nodeforplayer[i]])
	    {
		gametime--;
		// printf ("-");
	    }
	    frameskip[frameon&3] = (oldnettics > nettics[nodeforplayer[i]]);
	    oldnettics = nettics[0];
	    if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
	    {
		skiptics = 1;
		// printf ("+");
	    }
	}
    }// demoplayback
	
    // wait for new tics if needed
    while (lowtic < gametic/ticdup + counts)	
    {
	NetUpdate ();   
	lowtic = MAXINT;
	
	for (i=0 ; i<doomcom->numnodes ; i++)
	    if (nodeingame[i] && nettics[i] < lowtic)
		lowtic = nettics[i];
	
	if (lowtic < gametic/ticdup)
	    I_Error ("TryRunTics: lowtic < gametic");
				
	// don't stay in here forever -- give the menu a chance to work
	if (I_GetTime ()/ticdup - entertic >= 20)
	{
	    M_Ticker ();
	    return;
	} 
    }
    
    // run the count * ticdup dics
    while (counts--)
    {
	for (i=0 ; i<ticdup ; i++)
	{
	    if (gametic/ticdup > lowtic)
		I_Error ("gametic>lowtic");
	    if (advancedemo)
		D_DoAdvanceDemo ();
	    M_Ticker ();
	    G_Ticker ();
	    gametic++;
	    
	    // modify command for duplicated tics
	    if (i != ticdup-1)
	    {
		ticcmd_t	*cmd;
		int			buf;
		int			j;
				
		buf = (gametic/ticdup)%BACKUPTICS; 
		for (j=0 ; j<MAXPLAYERS ; j++)
		{
		    cmd = &netcmds[j][buf];
		    cmd->chatchar = 0;
		    if (cmd->buttons & BT_SPECIAL)
			cmd->buttons = 0;
		}
	    }
	}
	NetUpdate ();	// check for new console commands
    }
}
}*/
package doom;

public class doomcom_t {
	
		public doomcom_t(){
			this.data=new doomdata_t();
			
		}

        // Supposed to be DOOMCOM_ID?
        // Maes: was "long", but they intend 32-bit "int" here. Hurray for C's consistency!
        public int        id;
        
        // DOOM executes an int to execute commands.
        public short       intnum;     
        // Communication between DOOM and the driver.
        // Is CMD_SEND or CMD_GET.
        public short       command;
        // Is dest for send, set by get (-1 = no packet).
        public short       remotenode;
        
        // Number of bytes in doomdata to be sent
        public short       datalength;

        // Info common to all nodes.
        // Console is allways node 0.
        public short       numnodes;
        // Flag: 1 = no duplication, 2-5 = dup for slow nets.
        public short       ticdup;
        // Flag: 1 = send a backup tic in every packet.
        public short       extratics;
        // Flag: 1 = deathmatch.
        public short       deathmatch;
        // Flag: -1 = new game, 0-5 = load savegame
        public short       savegame;
        public short       episode;    // 1-3
        public short       map;        // 1-9
        public short       skill;      // 1-5

        // Info specific to this node.
        public short       consoleplayer;
        public short       numplayers;
        
        // These are related to the 3-display mode,
        //  in which two drones looking left and right
        //  were used to render two additional views
        //  on two additional computers.
        // Probably not operational anymore.
        // 1 = left, 0 = center, -1 = right
        public short       angleoffset;
        // 1 = drone
        public short       drone;      

        // The packet data to be sent.
        public doomdata_t      data;
        
    }

package doom;

public class pic_t {
    
    public pic_t(byte width, byte height, byte data) {
        super();
        this.width = width;
        this.height = height;
        this.data = data;
    }
    
    public byte        width;
    public byte        height;
    public byte        data;
}


package doom;

/** The defined weapons,
 * including a marker indicating
 *  user has not changed weapon.
 */
public enum weapontype_t
{
    wp_fist,
    wp_pistol,
    wp_shotgun,
    wp_chaingun,
    wp_missile,
    wp_plasma,
    wp_bfg,
    wp_chainsaw,
    wp_supershotgun,

    NUMWEAPONS,
    
    // No pending weapon change.
    wp_nochange;
    
    public String toString(){
        return this.name();
    }
    
}

package doom;

import static utils.C2JUtils.eval;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.StringTokenizer;

import w.DoomIO;

/**
 * A class to handle the command-line args in an unified manner, and without
 * them being tied to DoomMain or DoomStatus.
 * 
 * 
 * @author velktron
 *
 */

public class CommandLine implements ICommandLineManager {

    
    /* What bullshit, those are supposed to carry over from the very first main */
    protected int myargc;
    protected String[] myargv;
    
    public CommandLine(String[] argv){

        // Bump argcount up by 1 to maintain CheckParm behavior
        // In C, argument 0 is the executable itself, and most
        // of Doom's code is tailored to reflect that, with 0
        // meaning "not found" with regards to a parameter.
        // It's easier to change this here.
    	// TODO: this is really bad practice, eliminate once a 
    	// cvar system is in place.

        myargv=new String[argv.length+1];
        System.arraycopy(argv, 0, myargv, 1, argv.length);        
        myargc=argv.length+1;
        cvars=new HashMap<String, Object>();
    }
    
    /* (non-Javadoc)
     * @see doom.ICommandLineManager#getArgv(int)
     */
    @Override
    public String getArgv(int index){
        if (index>myargc) return null;
        else return myargv[index];
    }
    
    /* (non-Javadoc)
     * @see doom.ICommandLineManager#getArgc()
     */
    @Override
    public int getArgc(){
        return myargc;
    }
    

    /* (non-Javadoc)
     * @see doom.ICommandLineManager#CheckParm(java.lang.String)
     */

    @Override
    public int CheckParm(String check) {
        int i;

        for (i = 1; i < myargc; i++) {
            if (check.compareToIgnoreCase(myargv[i]) == 0)
                return i;
        }

        return 0;
    }
    
    @Override
    public boolean CheckParmBool(String check) {
        int i;

        for (i = 1; i < myargc; i++) {
            if (check.compareToIgnoreCase(myargv[i]) == 0)
                return true;
        }

        return false;
    }
    
    /**
     * Find a Response File
     * 
     * Not very well documented, but Doom apparently could use a sort of 
     * script file with command line arguments inside, if you prepend @ to
     * the command-like argument itself. The arguments themselves could
     * be separated by any sort of whitespace or ASCII characters exceeding "z"
     * in value.
     * 
     * E.g. doom @crap
     * 
     * would load a file named "crap".
     * 
     * Now, the original function is crap for several reasons: for one,
     * it will bomb if more than 100 arguments <i>total</i> are formed.
     * Memory allocation will also fail because the tokenizer used only
     * stops at file size limit, not at maximum parsed arguments limit
     * (MACARGVS = 100).
     * 
     * This is the wiki's entry:
     * 
     * doom @<response>
     * This parameter tells the Doom engine to read from a response file, 
     * a text file that may store additional command line parameters. 
     * The file may have any name that is valid to the system, optionally 
     * with an extension. The parameters are typed as in the command line 
     * (-episode 2, for example), but one per line, where up to 100 lines
     *  may be used. The additional parameters may be disabled for later 
     *  use by placing a vertical bar (the | character) between the 
     *  prefixing dash (-) and the rest of the parameter name.
     * 
     * 
     */
    @Override
    public void FindResponseFile ()
    {
        try{

            for (int i = 1;i < getArgc();i++)
                if (getArgv(i).charAt(0)=='@')
                {
                    DataInputStream handle;
                    // save o       
                    int             size;
                    int             indexinfile;
                    char[]   infile=null;
                    char[]    file=null;
                    // Fuck that, we're doing it properly.
                    ArrayList<String>  parsedargs=new ArrayList<String>();
                    ArrayList<String>    moreargs=new ArrayList<String>();
                    String    firstargv;

                    // READ THE RESPONSE FILE INTO MEMORY
                    handle = new DataInputStream(new BufferedInputStream(new FileInputStream(myargv[i].substring(1))));
                    if (!eval(handle))
                    {
                        System.out.print ("\nNo such response file!");
                        System.exit(1);
                    }
                    System.out.println("Found response file "+myargv[i].substring(1));
                    size = (int) handle.available();
                    file=new char[size];
                    
                    DoomIO.readNonUnicodeCharArray(handle, file,size);
                    handle.close();

                    // Save first argument.
                    firstargv = myargv[0];

                    // KEEP ALL CMDLINE ARGS FOLLOWING @RESPONSEFILE ARG
                    // This saves the old references.
                    for (int k = i+1; k < myargc; k++)
                        moreargs.add(myargv[k]);

                    infile = file;
                    indexinfile = 0;
                    indexinfile++;  // SKIP PAST ARGV[0] (KEEP IT)
                    // HMM? StringBuffer build=new StringBuffer();

                    /* MAES: the code here looked like some primitive tokenizer.
           that assigned C-strings to memory locations.
           Instead, we'll tokenize the file input correctly here.
                     */

                    StringTokenizer tk=new StringTokenizer(String.copyValueOf(infile));



                    //myargv = new String[tk.countTokens()+argc];
                    parsedargs.add(firstargv);

                    while(tk.hasMoreTokens())
                    {
                        parsedargs.add(tk.nextToken());
                    }

                    // Append the other args to the end.
                    parsedargs.addAll(moreargs);

                    /* NOW the original myargv is reset, but the old values still survive in 
                     * the listarray.*/

                    myargv= new String[parsedargs.size()];
                    myargv=parsedargs.toArray(myargv);
                    myargc = myargv.length;

                    // DISPLAY ARGS
                    System.out.println(myargc+" command-line args:");
                    for (int k=0;k<myargc;k++)
                        System.out.println(myargv[k]);

                    // Stops at the first one. Pity, because we could do funky recursive stuff with that :-p
                    break;
                }
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public void setArgv(int index, String string) {
        this.myargv[index]=string;
        
    }
    
    private HashMap<String, Object> cvars;
    
    public boolean cvarExists(String name){
    	return cvars.containsKey(name);
    	}
    
    public Object removeCvar(String name){
    	return cvars.remove(name);
    	}
    
    public void putCvar(String name, int value){
    	cvars.put(name, value);
    	}

    public void putCvar(String name, double value){
    	cvars.put(name, value);
    	}
    
    public void putCvar(String name, String value){
    	cvars.put(name, value);
    	}

    public void putCvar(String name, boolean value){
    	cvars.put(name, value);
    	}

    public void putCvar(String name, String[] value){
    	cvars.put(name, value);
    	}
    
    public Integer getInt(String name){
    	Object stuff=cvars.get(name);
    	if (stuff !=null){
    		if (stuff instanceof Integer){
    			return (Integer) stuff;
    		}
    	}    	
    	return null;
    }
    
    public Double getFloat(String name){
    	Object stuff=cvars.get(name);
    	if (stuff !=null){
    		if (stuff instanceof Double){
    			return (Double) stuff;
    		}
    	}    	
    	return null;
    }
    
    public String getString(String name){
    	Object stuff=cvars.get(name);
    	if (stuff !=null){
    		if (stuff instanceof String){
    			return (String) stuff;
    		}
    	}    	
    	return null;
    }
    
    public String[] getStringArray(String name){
    	Object stuff=cvars.get(name);
    	if (stuff !=null){
    		if (stuff instanceof String[]){
    			return (String[]) stuff;
    		}
    	}    	
    	return null;
    }
    
    public Boolean getBoolean(String name){
    	Object stuff=cvars.get(name);
    	if (stuff !=null){
    		if (stuff instanceof Boolean){
    			return (Boolean) stuff;
    		}
    	}    	
    	return null;
    }
    
    public <K> void setCvar(String name, K value){
    	if (cvars.containsKey(name)){
    		cvars.put(name, value);
    	}
    }

    public static String checkParameterCouple(String check, String[] myargv) {
        int found=-1;

        for (int i = 0; i < myargv.length; i++) {
            if (check.compareToIgnoreCase(myargv[i]) == 0){
                found=i; // found. Break on first.
                break;
            }
        }
        
        // Found, and there's room to spare for one more?
        if ((found>=0)&&(found<myargv.length-1)){
            if (myargv[found+1]!=null){
                // Not null, not empty and not a parameter switch
                if ((myargv[found+1].length()>=1) &&
                    (myargv[found+1].charAt(0)!='-'))                        
                        return myargv[found+1];
            }
        }

        // Well duh.
        return null;
    }
 
    /** Is a parameter based on an prefix identifier e.g. '-'
     * 
     * @param what
     * @param identifier
     * @return
     */
    public static boolean isParameter(String what, char identifier){
        if (what!=null && what.length()>-0){
        	return (what.charAt(0)!=identifier); 
        }
        
        return false;        
    }
    
    public static int parameterMultipleValues(String check, String[] myargv) {
        int found=-1;

        // It's not even a valid parameter name
        if (!isParameter(check,'-')) return -1;
        
        // Does it exist?
        if ((found=checkParm(check,myargv))==-1) return found;
        
        // Found, and there are still some to spare
        int rest=myargv.length-found-1;
        int count=0;
        
        for (int i=found+1;i<myargv.length;i++){
        	if (isParameter(myargv[i],'-')) break;
        		else
        	count++; // not a parameter, count up        	
        }
        
        // Well duh.
        return count;
    }
    
    
    public static int checkParm(String check, String[] params) {
        int i;

        for (i = 0; i < params.length; i++) {
            if (check.compareToIgnoreCase(params[i]) == 0)
                return i;
        }

        return -1;
    }
    
}

package doom;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import static utils.C2JUtils.pointer;
import w.CacheableDoomObject;
import w.IPackableDoomObject;
import w.IReadableDoomObject;
import p.ActionType1;
import p.ActionType2;
import p.ActionTypeSS;

public class thinker_t implements CacheableDoomObject,IReadableDoomObject,IPackableDoomObject{
   
   public thinker_t prev;
   public thinker_t next;
   public think_t     function;

   /* killough 8/29/98: we maintain thinkers in several equivalence classes,
    * according to various criteria, so as to allow quicker searches.
    */

   /** Next, previous thinkers in same class */
   
   public thinker_t cnext, cprev;

   
   // Thinkers can either have one parameter of type (mobj_t),
   // Or otherwise be sector specials, flickering lights etc.
   // Those are atypical and need special handling.
   public ActionType1     acp1;
   public ActionType2     acp2;
   public ActionTypeSS     acpss;
   
   /** extra fields, to use when archiving/unarchiving for
    * identification. Also in blocklinks, etc.
    */
   public int id,previd, nextid,functionid;
   
   
   
@Override
public void read(DataInputStream f)
        throws IOException {
	readbuffer.position(0);
	readbuffer.order(ByteOrder.LITTLE_ENDIAN);
	f.read(readbuffer.array());
	unpack(readbuffer);
	}

/** This adds 12 bytes */

@Override
public void pack(ByteBuffer b)
        throws IOException {
    // It's possible to reconstruct even by hashcodes.
    // As for the function, that should be implied by the mobj_t type.
	b.order(ByteOrder.LITTLE_ENDIAN);
	b.putInt(pointer(prev));
    b.putInt(pointer(next));
    b.putInt(pointer(function));
    //System.out.printf("Packed thinker %d %d %d\n",pointer(prev),pointer(next),pointer(function));
	}

@Override
public void unpack(ByteBuffer b)
        throws IOException {
    // We are supposed to archive pointers to other thinkers,
    // but they are rather useless once on disk.
	b.order(ByteOrder.LITTLE_ENDIAN);
    previd=b.getInt();
    nextid=b.getInt();
    functionid=b.getInt();
    //System.out.printf("Unpacked thinker %d %d %d\n",pointer(previd),pointer(nextid),pointer(functionid));
	}

 private static ByteBuffer readbuffer=ByteBuffer.allocate(12);

}
package doom;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: items.java,v 1.3 2010/12/20 17:15:08 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: items.java,v $
// Revision 1.3  2010/12/20 17:15:08  velktron
// Made the renderer more OO -> TextureManager and other changes as well.
//
// Revision 1.2  2010/08/19 23:14:49  velktron
// Automap
//
// Revision 1.1  2010/06/30 08:58:50  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//
//-----------------------------------------------------------------------------

import defines.*;

public class items{

public static weaponinfo_t[]	weaponinfo=
{
    new weaponinfo_t(
	// fist
	ammotype_t.am_noammo,
	statenum_t.S_PUNCHUP,
	statenum_t.S_PUNCHDOWN,
	statenum_t.S_PUNCH,
	statenum_t.S_PUNCH1,
	statenum_t.S_NULL
    ),	
    new weaponinfo_t(
	// pistol
    ammotype_t.am_clip,
	statenum_t.S_PISTOLUP,
	statenum_t.S_PISTOLDOWN,
	statenum_t.S_PISTOL,
	statenum_t.S_PISTOL1,
	statenum_t.S_PISTOLFLASH
	), new weaponinfo_t(
	// shotgun
    ammotype_t.am_shell,
    statenum_t.S_SGUNUP,
    statenum_t.S_SGUNDOWN,
    statenum_t.S_SGUN,
    statenum_t.S_SGUN1,
    statenum_t.S_SGUNFLASH1
    ),
    new weaponinfo_t(
	// chaingun
    ammotype_t.am_clip,
	statenum_t.S_CHAINUP,
	statenum_t.S_CHAINDOWN,
	statenum_t.S_CHAIN,
	statenum_t.S_CHAIN1,
	statenum_t.S_CHAINFLASH1
    ),
    new weaponinfo_t(
	// missile launcher
        ammotype_t.am_misl,
	statenum_t.S_MISSILEUP,
	statenum_t.S_MISSILEDOWN,
	statenum_t.S_MISSILE,
	statenum_t.S_MISSILE1,
	statenum_t.S_MISSILEFLASH1
    ),
    new weaponinfo_t(
	// plasma rifle
        ammotype_t.am_cell,
	statenum_t.S_PLASMAUP,
	statenum_t.S_PLASMADOWN,
	statenum_t.S_PLASMA,
	statenum_t.S_PLASMA1,
	statenum_t.S_PLASMAFLASH1
    ),
    new weaponinfo_t(
	// bfg 9000
        ammotype_t.am_cell,
	statenum_t.S_BFGUP,
	statenum_t.S_BFGDOWN,
	statenum_t.S_BFG,
	statenum_t.S_BFG1,
	statenum_t.S_BFGFLASH1
    ),
    new weaponinfo_t(
	// chainsaw
        ammotype_t.am_noammo,
	statenum_t.S_SAWUP,
	statenum_t.S_SAWDOWN,
	statenum_t.S_SAW,
	statenum_t.S_SAW1,
	statenum_t.S_NULL
    ),
    new weaponinfo_t(
	// super shotgun
    ammotype_t.am_shell,
    statenum_t.S_DSGUNUP,
	statenum_t.S_DSGUNDOWN,
	statenum_t.S_DSGUN,
	statenum_t.S_DSGUN1,
	statenum_t.S_DSGUNFLASH1
    )
    };
}









package doom;

public enum gameaction_t {
        ga_nothing,
        ga_loadlevel,
        ga_newgame,
        ga_loadgame,
        ga_savegame,
        ga_playdemo,
        ga_completed,
        ga_victory,
        ga_worlddone,
        ga_screenshot,
        ga_failure // HACK: communicate failures silently
    }

package doom;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: englsh.java,v 1.5 2011/05/31 21:46:20 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//  Printed strings for translation.
//  English language support (default).
//
//-----------------------------------------------------------------------------

//
//  Printed strings for translation
//

//
// D_Main.C
//

public class englsh{
public final static String  D_DEVSTR="Development mode ON.\n";
public final static String  D_CDROM="CD-ROM Version: default.cfg from c:\\doomdata\n";

//
//  M_Menu.C
//
public final static String  PRESSKEY ="press a key.";
public final static String  PRESSYN ="press y or n.";
public final static String  QUITMSG="are you sure you want to\nquit this great game?";
public final static String  LOADNET ="you can't do load while in a net game!\n\n"+PRESSKEY;
public final static String  QLOADNET="you can't quickload during a netgame!\n\n"+PRESSKEY;
public final static String  QSAVESPOT="you haven't picked a quicksave slot yet!\n\n"+PRESSKEY;
public final static String  SAVEDEAD ="you can't save if you aren't playing!\n\n"+PRESSKEY;
public final static String  QSPROMPT ="quicksave over your game named\n\n'%s'?\n\n"+PRESSYN;
public final static String  QLPROMPT="do you want to quickload the game named\n\n'%s'?\n\n"+PRESSYN;

public final static String  NEWGAME = "you can't start a new game\nwhile in a network game.\n\n"+PRESSKEY;

public final static String  NIGHTMARE ="are you sure? this skill level\nisn't even remotely fair.\n\n"+PRESSYN;

public final static String  SWSTRING = "this is the shareware version of doom.\n\nyou need to order the entire trilogy.\n\n"+PRESSKEY;

public final static String  MSGOFF="Messages OFF";
public final static String  MSGON   ="Messages ON";
public final static String  NETEND="you can't end a netgame!\n\n"+PRESSKEY;
public final static String  ENDGAME="are you sure you want to end the game?\n\n"+PRESSYN;

public final static String  DOSY    ="(press y to quit)";

public final static String  DETAILHI="High detail";
public final static String  DETAILLO="Low detail";
public final static String  GAMMALVL0="Gamma correction OFF";
public final static String  GAMMALVL1="Gamma correction level 1";
public final static String  GAMMALVL2="Gamma correction level 2";
public final static String  GAMMALVL3="Gamma correction level 3";
public final static String  GAMMALVL4="Gamma correction level 4";
public final static String  EMPTYSTRING="empty slot";

//
//  P_inter.C
//
public final static String  GOTARMOR="Picked up the armor.";
public final static String  GOTMEGA="Picked up the MegaArmor!";
public final static String  GOTHTHBONUS="Picked up a health bonus.";
public final static String  GOTARMBONUS="Picked up an armor bonus.";
public final static String  GOTSTIM="Picked up a stimpack.";
public final static String  GOTMEDINEED="Picked up a medikit that you REALLY need!";
public final static String  GOTMEDIKIT="Picked up a medikit.";
public final static String  GOTSUPER="Supercharge!";

public final static String  GOTBLUECARD="Picked up a blue keycard.";
public final static String  GOTYELWCARD="Picked up a yellow keycard.";
public final static String  GOTREDCARD="Picked up a red keycard.";
public final static String  GOTBLUESKUL="Picked up a blue skull key.";
public final static String  GOTYELWSKUL="Picked up a yellow skull key.";
public final static String  GOTREDSKULL="Picked up a red skull key.";

public final static String  GOTINVUL="Invulnerability!";
public final static String  GOTBERSERK="Berserk!";
public final static String  GOTINVIS="Partial Invisibility";
public final static String  GOTSUIT="Radiation Shielding Suit";
public final static String  GOTMAP="Computer Area Map";
public final static String  GOTVISOR="Light Amplification Visor";
public final static String  GOTMSPHERE="MegaSphere!";

public final static String  GOTCLIP="Picked up a clip.";
public final static String  GOTCLIPBOX="Picked up a box of bullets.";
public final static String  GOTROCKET="Picked up a rocket.";
public final static String  GOTROCKBOX="Picked up a box of rockets.";
public final static String  GOTCELL="Picked up an energy cell.";
public final static String  GOTCELLBOX="Picked up an energy cell pack.";
public final static String  GOTSHELLS="Picked up 4 shotgun shells.";
public final static String  GOTSHELLBOX="Picked up a box of shotgun shells.";
public final static String  GOTBACKPACK="Picked up a backpack full of ammo!";

public final static String  GOTBFG9000="You got the BFG9000!  Oh, yes.";
public final static String  GOTCHAINGUN="You got the chaingun!";
public final static String  GOTCHAINSAW="A chainsaw!  Find some meat!";
public final static String  GOTLAUNCHER="You got the rocket launcher!";
public final static String  GOTPLASMA="You got the plasma gun!";
public final static String  GOTSHOTGUN="You got the shotgun!";
public final static String  GOTSHOTGUN2="You got the super shotgun!";

//
// P_Doors.C
//
public final static String  PD_BLUEO="You need a blue key to activate this object";
public final static String  PD_REDO="You need a red key to activate this object";
public final static String  PD_YELLOWO="You need a yellow key to activate this object";
public final static String  PD_BLUEK="You need a blue key to open this door";
public final static String  PD_REDK="You need a red key to open this door";
public final static String  PD_YELLOWK="You need a yellow key to open this door";

//
//  G_game.C
//
public final static String  GGSAVED="game saved.";

//
//  HU_stuff.C
//
public final static String  HUSTR_MSGU="[Message unsent]";

public final static String  HUSTR_E1M1="E1M1: Hangar";
public final static String  HUSTR_E1M2="E1M2: Nuclear Plant";
public final static String  HUSTR_E1M3="E1M3: Toxin Refinery";
public final static String  HUSTR_E1M4="E1M4: Command Control";
public final static String  HUSTR_E1M5="E1M5: Phobos Lab";
public final static String  HUSTR_E1M6="E1M6: Central Processing";
public final static String  HUSTR_E1M7="E1M7: Computer Station";
public final static String  HUSTR_E1M8="E1M8: Phobos Anomaly";
public final static String  HUSTR_E1M9="E1M9: Military Base";

public final static String  HUSTR_E2M1="E2M1: Deimos Anomaly";
public final static String  HUSTR_E2M2="E2M2: Containment Area";
public final static String  HUSTR_E2M3="E2M3: Refinery";
public final static String  HUSTR_E2M4="E2M4: Deimos Lab";
public final static String  HUSTR_E2M5="E2M5: Command Center";
public final static String  HUSTR_E2M6="E2M6: Halls of the Damned";
public final static String  HUSTR_E2M7="E2M7: Spawning Vats";
public final static String  HUSTR_E2M8="E2M8: Tower of Babel";
public final static String  HUSTR_E2M9="E2M9: Fortress of Mystery";

public final static String  HUSTR_E3M1="E3M1: Hell Keep";
public final static String  HUSTR_E3M2="E3M2: Slough of Despair";
public final static String  HUSTR_E3M3="E3M3: Pandemonium";
public final static String  HUSTR_E3M4="E3M4: House of Pain";
public final static String  HUSTR_E3M5="E3M5: Unholy Cathedral";
public final static String  HUSTR_E3M6="E3M6: Mt. Erebus";
public final static String  HUSTR_E3M7="E3M7: Limbo";
public final static String  HUSTR_E3M8="E3M8: Dis";
public final static String  HUSTR_E3M9="E3M9: Warrens";

public final static String  HUSTR_E4M1="E4M1: Hell Beneath";
public final static String  HUSTR_E4M2="E4M2: Perfect Hatred";
public final static String  HUSTR_E4M3="E4M3: Sever The Wicked";
public final static String  HUSTR_E4M4="E4M4: Unruly Evil";
public final static String  HUSTR_E4M5="E4M5: They Will Repent";
public final static String  HUSTR_E4M6="E4M6: Against Thee Wickedly";
public final static String  HUSTR_E4M7="E4M7: And Hell Followed";
public final static String  HUSTR_E4M8="E4M8: Unto The Cruel";
public final static String  HUSTR_E4M9="E4M9: Fear";

public final static String  HUSTR_1="level 1: entryway";
public final static String  HUSTR_2="level 2: underhalls";
public final static String  HUSTR_3="level 3: the gantlet";
public final static String  HUSTR_4="level 4: the focus";
public final static String  HUSTR_5="level 5: the waste tunnels";
public final static String  HUSTR_6="level 6: the crusher";
public final static String  HUSTR_7="level 7: dead simple";
public final static String  HUSTR_8="level 8: tricks and traps";
public final static String  HUSTR_9="level 9: the pit";
public final static String  HUSTR_10="level 10: refueling base";
public final static String  HUSTR_11="level 11: 'o' of destruction!";

public final static String  HUSTR_12="level 12: the factory";
public final static String  HUSTR_13="level 13: downtown";
public final static String  HUSTR_14="level 14: the inmost dens";
public final static String  HUSTR_15="level 15: industrial zone";
public final static String  HUSTR_16="level 16: suburbs";
public final static String  HUSTR_17="level 17: tenements";
public final static String  HUSTR_18="level 18: the courtyard";
public final static String  HUSTR_19="level 19: the citadel";
public final static String  HUSTR_20="level 20: gotcha!";

public final static String  HUSTR_21="level 21: nirvana";
public final static String  HUSTR_22="level 22: the catacombs";
public final static String  HUSTR_23="level 23: barrels o' fun";
public final static String  HUSTR_24="level 24: the chasm";
public final static String  HUSTR_25="level 25: bloodfalls";
public final static String  HUSTR_26="level 26: the abandoned mines";
public final static String  HUSTR_27="level 27: monster condo";
public final static String  HUSTR_28="level 28: the spirit world";
public final static String  HUSTR_29="level 29: the living end";
public final static String  HUSTR_30="level 30: icon of sin";

public final static String  HUSTR_31="level 31: wolfenstein";
public final static String  HUSTR_32="level 32: grosse";
public final static String  HUSTR_33="level 33: betray";

public final static String  PHUSTR_1="level 1: congo";
public final static String  PHUSTR_2="level 2: well of souls";
public final static String  PHUSTR_3="level 3: aztec";
public final static String  PHUSTR_4="level 4: caged";
public final static String  PHUSTR_5="level 5: ghost town";
public final static String  PHUSTR_6="level 6: baron's lair";
public final static String  PHUSTR_7="level 7: caughtyard";
public final static String  PHUSTR_8="level 8: realm";
public final static String  PHUSTR_9="level 9: abattoire";
public final static String  PHUSTR_10="level 10: onslaught";
public final static String  PHUSTR_11="level 11: hunted";

public final static String  PHUSTR_12="level 12: speed";
public final static String  PHUSTR_13="level 13: the crypt";
public final static String  PHUSTR_14="level 14: genesis";
public final static String  PHUSTR_15="level 15: the twilight";
public final static String  PHUSTR_16="level 16: the omen";
public final static String  PHUSTR_17="level 17: compound";
public final static String  PHUSTR_18="level 18: neurosphere";
public final static String  PHUSTR_19="level 19: nme";
public final static String  PHUSTR_20="level 20: the death domain";

public final static String  PHUSTR_21="level 21: slayer";
public final static String  PHUSTR_22="level 22: impossible mission";
public final static String  PHUSTR_23="level 23: tombstone";
public final static String  PHUSTR_24="level 24: the final frontier";
public final static String  PHUSTR_25="level 25: the temple of darkness";
public final static String  PHUSTR_26="level 26: bunker";
public final static String  PHUSTR_27="level 27: anti-christ";
public final static String  PHUSTR_28="level 28: the sewers";
public final static String  PHUSTR_29="level 29: odyssey of noises";
public final static String  PHUSTR_30="level 30: the gateway of hell";

public final static String  PHUSTR_31="level 31: cyberden";
public final static String  PHUSTR_32="level 32: go 2 it";

public final static String  THUSTR_1="level 1: system control";
public final static String  THUSTR_2="level 2: human bbq";
public final static String  THUSTR_3="level 3: power control";
public final static String  THUSTR_4="level 4: wormhole";
public final static String  THUSTR_5="level 5: hanger";
public final static String  THUSTR_6="level 6: open season";
public final static String  THUSTR_7="level 7: prison";
public final static String  THUSTR_8="level 8: metal";
public final static String  THUSTR_9="level 9: stronghold";
public final static String  THUSTR_10="level 10: redemption";
public final static String  THUSTR_11="level 11: storage facility";

public final static String  THUSTR_12="level 12: crater";
public final static String  THUSTR_13="level 13: nukage processing";
public final static String  THUSTR_14="level 14: steel works";
public final static String  THUSTR_15="level 15: dead zone";
public final static String  THUSTR_16="level 16: deepest reaches";
public final static String  THUSTR_17="level 17: processing area";
public final static String  THUSTR_18="level 18: mill";
public final static String  THUSTR_19="level 19: shipping/respawning";
public final static String  THUSTR_20="level 20: central processing";

public final static String  THUSTR_21="level 21: administration center";
public final static String  THUSTR_22="level 22: habitat";
public final static String  THUSTR_23="level 23: lunar mining project";
public final static String  THUSTR_24="level 24: quarry";
public final static String  THUSTR_25="level 25: baron's den";
public final static String  THUSTR_26="level 26: ballistyx";
public final static String  THUSTR_27="level 27: mount pain";
public final static String  THUSTR_28="level 28: heck";
public final static String  THUSTR_29="level 29: river styx";
public final static String  THUSTR_30="level 30: last call";

public final static String  THUSTR_31="level 31: pharaoh";
public final static String  THUSTR_32="level 32: caribbean";

public final static String  HUSTR_CHATMACRO1="I'm ready to kick butt!";
public final static String  HUSTR_CHATMACRO2="I'm OK.";
public final static String  HUSTR_CHATMACRO3="I'm not looking too good!";
public final static String  HUSTR_CHATMACRO4="Help!";
public final static String  HUSTR_CHATMACRO5="You suck!";
public final static String  HUSTR_CHATMACRO6="Next time, scumbag...";
public final static String  HUSTR_CHATMACRO7="Come here!";
public final static String  HUSTR_CHATMACRO8="I'll take care of it.";
public final static String  HUSTR_CHATMACRO9="Yes";
public final static String  HUSTR_CHATMACRO0="No";

public final static String  HUSTR_TALKTOSELF1="You mumble to yourself";
public final static String  HUSTR_TALKTOSELF2="Who's there?";
public final static String  HUSTR_TALKTOSELF3="You scare yourself";
public final static String  HUSTR_TALKTOSELF4="You start to rave";
public final static String  HUSTR_TALKTOSELF5="You've lost it...";

public final static String  HUSTR_MESSAGESENT="[Message Sent]";

// The following should NOT be changed unless it seems
// just AWFULLY necessary

public final static String  HUSTR_PLRGREEN="Green: ";
public final static String  HUSTR_PLRINDIGO="Indigo: ";
public final static String  HUSTR_PLRBROWN="Brown: ";
public final static String  HUSTR_PLRRED    ="Red: ";

public final static char  HUSTR_KEYGREEN = 'g';
public final static char  HUSTR_KEYINDIGO ='i';
public final static char  HUSTR_KEYBROWN = 'b';
public final static char  HUSTR_KEYRED   = 'r';

//
//  AM_map.C
//

public final static String  AMSTR_FOLLOWON="Follow Mode ON";
public final static String  AMSTR_FOLLOWOFF="Follow Mode OFF";

public final static String  AMSTR_GRIDON="Grid ON";
public final static String  AMSTR_GRIDOFF="Grid OFF";

public final static String  AMSTR_MARKEDSPOT="Marked Spot";
public final static String  AMSTR_MARKSCLEARED="All Marks Cleared";

//
//  ST_stuff.C
//

public final static String  STSTR_MUS   ="Music Change";
public final static String  STSTR_NOMUS ="IMPOSSIBLE SELECTION";
public final static String  STSTR_DQDON ="Degreelessness Mode On";
public final static String  STSTR_DQDOFF="Degreelessness Mode Off";

public final static String  STSTR_KFAADDED="Very Happy Ammo Added";
public final static String  STSTR_FAADDED="Ammo (no keys) Added";

public final static String  STSTR_NCON  ="No Clipping Mode ON";
public final static String  STSTR_NCOFF ="No Clipping Mode OFF";

public final static String  STSTR_BEHOLD="inVuln, Str, Inviso, Rad, Allmap, or Lite-amp";
public final static String  STSTR_BEHOLDX="Power-up Toggled";

public final static String  STSTR_CHOPPERS="... doesn't suck - GM";
public final static String  STSTR_CLEV  ="Changing Level...";

//
//  F_Finale.C
//
public final static String  E1TEXT =(
"Once you beat the big badasses and\n"+
"clean out the moon base you're supposed\n"+
"to win, aren't you? Aren't you? Where's\n"+
"your fat reward and ticket home? What\n"+
"the hell is this? It's not supposed to\n"+
"end this way!\n"+
"\n" +
"It stinks like rotten meat, but looks\n"+
"like the lost Deimos base.  Looks like\n"+
"you're stuck on The Shores of Hell.\n"+
"The only way out is through.\n"+
"\n"+
"To continue the DOOM experience, play\n"+
"The Shores of Hell and its amazing\n"+
"sequel, Inferno!\n");


public final static String  E2TEXT =(
"You've done it! The hideous cyber-\n"+
"demon lord that ruled the lost Deimos\n"+
"moon base has been slain and you\n"+
"are triumphant! But ... where are\n"+
"you? You clamber to the edge of the\n"+
"moon and look down to see the awful\n"+
"truth.\n" +
"\n"+
"Deimos floats above Hell itself!\n"+
"You've never heard of anyone escaping\n"+
"from Hell, but you'll make the bastards\n"+
"sorry they ever heard of you! Quickly,\n"+
"you rappel down to  the surface of\n"+
"Hell.\n"+
"\n" +
"Now, it's on to the final chapter of\n"+
"DOOM! -- Inferno.");


public final static String  E3TEXT =(
"The loathsome spiderdemon that\n"+
"masterminded the invasion of the moon\n"+
"bases and caused so much death has had\n"+
"its ass kicked for all time.\n"+
"\n"+
"A hidden doorway opens and you enter.\n"+
"You've proven too tough for Hell to\n"+
"contain, and now Hell at last plays\n"+
"fair -- for you emerge from the door\n"+
"to see the green fields of Earth!\n"+
"Home at last.\n" +
"\n"+
"You wonder what's been happening on\n"+
"Earth while you were battling evil\n"+
"unleashed. It's good that no Hell-\n"+
"spawn could have come through that\n"+
"door with you ...");


public final static String  E4TEXT =(
"the spider mastermind must have sent forth\n"+
"its legions of hellspawn before your\n"+
"final confrontation with that terrible\n"+
"beast from hell.  but you stepped forward\n"+
"and brought forth eternal damnation and\n"+
"suffering upon the horde as a true hero\n"+
"would in the face of something so evil.\n"+
"\n"+
"besides, someone was gonna pay for what\n"+
"happened to daisy, your pet rabbit.\n"+
"\n"+
"but now, you see spread before you more\n"+
"potential pain and gibbitude as a nation\n"+
"of demons run amok among our cities.\n"+
"\n"+
"next stop, hell on earth!");


// after level 6, put this:

public final static String  C1TEXT =(
"YOU HAVE ENTERED DEEPLY INTO THE INFESTED\n" +
"STARPORT. BUT SOMETHING IS WRONG. THE\n" +
"MONSTERS HAVE BROUGHT THEIR OWN REALITY\n" +
"WITH THEM, AND THE STARPORT'S TECHNOLOGY\n" +
"IS BEING SUBVERTED BY THEIR PRESENCE.\n" +
"\n"+
"AHEAD, YOU SEE AN OUTPOST OF HELL, A\n" +
"FORTIFIED ZONE. IF YOU CAN GET PAST IT,\n" +
"YOU CAN PENETRATE INTO THE HAUNTED HEART\n" +
"OF THE STARBASE AND FIND THE CONTROLLING\n" +
"SWITCH WHICH HOLDS EARTH'S POPULATION\n" +
"HOSTAGE.");

// After level 11, put this:

public final static String  C2TEXT =(
"YOU HAVE WON! YOUR VICTORY HAS ENABLED\n" +
"HUMANKIND TO EVACUATE EARTH AND ESCAPE\n"+
"THE NIGHTMARE.  NOW YOU ARE THE ONLY\n"+
"HUMAN LEFT ON THE FACE OF THE PLANET.\n"+
"CANNIBAL MUTATIONS, CARNIVOROUS ALIENS,\n"+
"AND EVIL SPIRITS ARE YOUR ONLY NEIGHBORS.\n"+
"YOU SIT BACK AND WAIT FOR DEATH, CONTENT\n"+
"THAT YOU HAVE SAVED YOUR SPECIES.\n"+
"\n"+
"BUT THEN, EARTH CONTROL BEAMS DOWN A\n"+
"MESSAGE FROM SPACE: \"SENSORS HAVE LOCATED\n"+
"THE SOURCE OF THE ALIEN INVASION. IF YOU\n"+
"GO THERE, YOU MAY BE ABLE TO BLOCK THEIR\n"+
"ENTRY.  THE ALIEN BASE IS IN THE HEART OF\n"+
"YOUR OWN HOME CITY, NOT FAR FROM THE\n"+
"STARPORT.\" SLOWLY AND PAINFULLY YOU GET\n"+
"UP AND RETURN TO THE FRAY.");


// After level 20, put this:

public final static String  C3TEXT =(
"YOU ARE AT THE CORRUPT HEART OF THE CITY,\n"+
"SURROUNDED BY THE CORPSES OF YOUR ENEMIES.\n"+
"YOU SEE NO WAY TO DESTROY THE CREATURES'\n"+
"ENTRYWAY ON THIS SIDE, SO YOU CLENCH YOUR\n"+
"TEETH AND PLUNGE THROUGH IT.\n"+
"\n"+
"THERE MUST BE A WAY TO CLOSE IT ON THE\n"+
"OTHER SIDE. WHAT DO YOU CARE IF YOU'VE\n"+
"GOT TO GO THROUGH HELL TO GET TO IT?");


// After level 29, put this:

public final static String  C4TEXT =(
"THE HORRENDOUS VISAGE OF THE BIGGEST\n"+
"DEMON YOU'VE EVER SEEN CRUMBLES BEFORE\n"+
"YOU, AFTER YOU PUMP YOUR ROCKETS INTO\n"+
"HIS EXPOSED BRAIN. THE MONSTER SHRIVELS\n"+
"UP AND DIES, ITS THRASHING LIMBS\n"+
"DEVASTATING UNTOLD MILES OF HELL'S\n"+
"SURFACE.\n"+
"\n"+
"YOU'VE DONE IT. THE INVASION IS OVER.\n"+
"EARTH IS SAVED. HELL IS A WRECK. YOU\n"+
"WONDER WHERE BAD FOLKS WILL GO WHEN THEY\n"+
"DIE, NOW. WIPING THE SWEAT FROM YOUR\n"+
"FOREHEAD YOU BEGIN THE LONG TREK BACK\n"+
"HOME. REBUILDING EARTH OUGHT TO BE A\n"+
"LOT MORE FUN THAN RUINING IT WAS.\n");



// Before level 31, put this:

public final static String  C5TEXT =(
"CONGRATULATIONS, YOU'VE FOUND THE SECRET\n"+
"LEVEL! LOOKS LIKE IT'S BEEN BUILT BY\n"+
"HUMANS, RATHER THAN DEMONS. YOU WONDER\n"+
"WHO THE INMATES OF THIS CORNER OF HELL\n"+
"WILL BE.");


// Before level 32, put this:

public final static String  C6TEXT =(
"CONGRATULATIONS, YOU'VE FOUND THE\n"+
"SUPER SECRET LEVEL!  YOU'D BETTER\n"+
"BLAZE THROUGH THIS ONE!\n");


// after map 06 

public final static String  P1TEXT  =(
"You gloat over the steaming carcass of the\n"+
"Guardian.  With its death, you've wrested\n"+
"the Accelerator from the stinking claws\n"+
"of Hell.  You relax and glance around the\n"+
"room.  Damn!  There was supposed to be at\n"+
"least one working prototype, but you can't\n"+
"see it. The demons must have taken it.\n"+
"\n"+
"You must find the prototype, or all your\n"+
"struggles will have been wasted. Keep\n"+
"moving, keep fighting, keep killing.\n"+
"Oh yes, keep living, too.");


// after map 11

public final static String  P2TEXT =(
"Even the deadly Arch-Vile labyrinth could\n"+
"not stop you, and you've gotten to the\n"+
"prototype Accelerator which is soon\n"+
"efficiently and permanently deactivated.\n"+
"\n"+
"You're good at that kind of thing.");


// after map 20

public final static String  P3TEXT =(
"You've bashed and battered your way into\n"+
"the heart of the devil-hive.  Time for a\n"+
"Search-and-Destroy mission, aimed at the\n"+
"Gatekeeper, whose foul offspring is\n"+
"cascading to Earth.  Yeah, he's bad. But\n"+
"you know who's worse!\n"+
"\n"+
"Grinning evilly, you check your gear, and\n"+
"get ready to give the bastard a little Hell\n"+
"of your own making!");

// after map 30

public final static String  P4TEXT =(
"The Gatekeeper's evil face is splattered\n"+
"all over the place.  As its tattered corpse\n"+
"collapses, an inverted Gate forms and\n"+
"sucks down the shards of the last\n"+
"prototype Accelerator, not to mention the\n"+
"few remaining demons.  You're done. Hell\n"+
"has gone back to pounding bad dead folks \n"+
"instead of good live ones.  Remember to\n"+
"tell your grandkids to put a rocket\n"+
"launcher in your coffin. If you go to Hell\n"+
"when you die, you'll need it for some\n"+
"final cleaning-up ...");

// before map 31

public final static String  P5TEXT =(
"You've found the second-hardest level we\n"+
"got. Hope you have a saved game a level or\n"+
"two previous.  If not, be prepared to die\n"+
"aplenty. For master marines only.");

// before map 32

public final static String  P6TEXT =(
"Betcha wondered just what WAS the hardest\n"+
"level we had ready for ya?  Now you know.\n"+
"No one gets out alive.");


public final static String  T1TEXT =(
"You've fought your way out of the infested\n"+
"experimental labs.   It seems that UAC has\n"+
"once again gulped it down.  With their\n"+
"high turnover, it must be hard for poor\n"+
"old UAC to buy corporate health insurance\n"+
"nowadays..\n"+
"\n"+
"Ahead lies the military complex, now\n"+
"swarming with diseased horrors hot to get\n"+
"their teeth into you. With luck, the\n"+
"complex still has some warlike ordnance\n"+
"laying around.");


public final static String  T2TEXT =(
"You hear the grinding of heavy machinery\n"+
"ahead.  You sure hope they're not stamping\n"+
"out new hellspawn, but you're ready to\n"+
"ream out a whole herd if you have to.\n"+
"They might be planning a blood feast, but\n"+
"you feel about as mean as two thousand\n"+
"maniacs packed into one mad killer.\n"+
"\n"+
"You don't plan to go down easy.");


public final static String  T3TEXT =(
"The vista opening ahead looks real damn\n"+
"familiar. Smells familiar, too -- like\n"+
"fried excrement. You didn't like this\n"+
"place before, and you sure as hell ain't\n"+
"planning to like it now. The more you\n"+
"brood on it, the madder you get.\n"+
"Hefting your gun, an evil grin trickles\n"+
"onto your face. Time to take some names.");

public final static String  T4TEXT =(
"Suddenly, all is silent, from one horizon\n"+
"to the other. The agonizing echo of Hell\n"+
"fades away, the nightmare sky turns to\n"+
"blue, the heaps of monster corpses start \n"+
"to evaporate along with the evil stench \n"+
"that filled the air. Jeeze, maybe you've\n"+
"done it. Have you really won?\n"+
"\n"+
"Something rumbles in the distance.\n"+
"A blue light begins to glow inside the\n"+
"ruined skull of the demon-spitter.");


public final static String  T5TEXT =(
"What now? Looks totally different. Kind\n"+
"of like King Tut's condo. Well,\n"+
"whatever's here can't be any worse\n"+
"than usual. Can it?  Or maybe it's best\n"+
"to let sleeping gods lie..");


public final static String  T6TEXT =(
"Time for a vacation. You've burst the\n"+
"bowels of hell and by golly you're ready\n"+
"for a break. You mutter to yourself,\n"+
"Maybe someone else can kick Hell's ass\n"+
"next time around. Ahead lies a quiet town,\n"+
"with peaceful flowing water, quaint\n"+
"buildings, and presumably no Hellspawn.\n"+
"\n"+
"As you step off the transport, you hear\n"+
"the stomp of a cyberdemon's iron shoe.");



//
// Character cast strings F_FINALE.C
//
public final static String  CC_ZOMBIE="ZOMBIEMAN";
public final static String  CC_SHOTGUN="SHOTGUN GUY";
public final static String  CC_HEAVY="HEAVY WEAPON DUDE";
public final static String  CC_IMP="IMP";
public final static String  CC_DEMON="DEMON";
public final static String  CC_LOST="LOST SOUL";
public final static String  CC_CACO="CACODEMON";
public final static String  CC_HELL="HELL KNIGHT";
public final static String  CC_BARON="BARON OF HELL";
public final static String  CC_ARACH="ARACHNOTRON";
public final static String  CC_PAIN="PAIN ELEMENTAL";
public final static String  CC_REVEN="REVENANT";
public final static String  CC_MANCU="MANCUBUS";
public final static String  CC_ARCH="ARCH-VILE";
public final static String  CC_SPIDER="THE SPIDER MASTERMIND";
public final static String  CC_CYBER="THE CYBERDEMON";
public final static String  CC_NAZI="WAFFEN SS. SIEG HEIL!";
public final static String  CC_KEEN="COMMANDER KEEN";
public final static String  CC_BARREL="EXPLODING BARREL";
public final static String  CC_HERO="OUR HERO";

}
package doom;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.IReadableDoomObject;

public class ticcmd_t implements IDatagramSerializable, IReadableDoomObject,CacheableDoomObject{
    
    // The length datagrams are supposed to have, for full compatibility.
    
    public static final int TICCMDLEN=8;
    
    // Initializes ticcmd buffer, too.
    
    public ticcmd_t(){
        this.buffer=new byte[TICCMDLEN];
    }
    
    /** *2048 for move */
    public byte forwardmove;

    /** *2048 for move */
    public byte sidemove;

    /** <<16 for angle delta */
    public short angleturn;

    /** checks for net game */
    public short consistancy;
    
    /** MAES: these are unsigned bytes :-( 
     *  However over networks, if we wish for vanilla compatibility,
     *  these must be reduced to 8-bit "chars"
     * */

    public char chatchar, buttons; 
    
    /** HERETIC look/fly up/down/centering */    
    public char		lookfly; 
    
    // TODO: will be ignored during vanilla demos. Consider using specialized
    // per-demotype readers instead of Cacheable/Unpackage.

    /** replaces G_CmdChecksum (ticcmd_t cmd) */

    /////////////////////////////////////////////
    
    // For datagram serialization
    private byte[] buffer;
    
    public int getChecksum(ticcmd_t cmd) {
        int sum = 0;
        sum += forwardmove;
        sum += sidemove;
        sum += angleturn;
        sum += consistancy;
        sum += chatchar;
        sum += buttons;
        return sum;
        }

    /** because Cloneable is bullshit */
    
     public void copyTo(ticcmd_t dest){
         dest.forwardmove = forwardmove;
         dest.sidemove = sidemove;
         dest.angleturn= angleturn;
         dest.consistancy= consistancy;
         dest.chatchar= chatchar;
         dest.buttons= buttons;
         dest.lookfly=lookfly;
     }
     
     private static StringBuilder sb=new StringBuilder();
     
     public String toString(){
         sb.setLength(0);
         sb.append(" forwardmove ");
         sb.append(Integer.toHexString(this.forwardmove)); 
         sb.append(" sidemove ");
         sb.append(Integer.toHexString(this.sidemove)); 
         sb.append(" angleturn ");
         sb.append(Integer.toHexString(this.angleturn)); 
         sb.append(" consistancy ");
         sb.append(Integer.toHexString(this.consistancy));      
         sb.append(" chatchar ");
         sb.append(chatchar);         
        sb.append(" buttons ");
         sb.append(Integer.toHexString(this.buttons));
         return sb.toString();
     }

    @Override
    public byte[] pack() {
        buffer[0]=forwardmove;
        buffer[1]=sidemove;        
        buffer[2]=(byte) (angleturn>>>8);
        buffer[3]=(byte) (angleturn&0x00FF);
        buffer[4]=(byte) (consistancy>>>8);
        buffer[5]=(byte) (consistancy&0x00FF);

        // We only send 8 bytes because the original length was 8 bytes.
        buffer[6]=(byte) (chatchar&0x00FF);
        buffer[7]=(byte) (buttons&0x00FF);
        
        return buffer;
    }

    @Override
    public void pack(byte[] buf, int offset) {
        buf[0+offset]=forwardmove;
        buf[1+offset]=sidemove;        
        buf[2+offset]=(byte) (angleturn>>>8);
        buf[3+offset]=(byte) (angleturn&0x00FF);
        buf[4+offset]=(byte) (consistancy>>>8);
        buf[5+offset]=(byte) (consistancy&0x00FF);

        // We only send 8 bytes because the original length was 8 bytes.
        buf[6+offset]=(byte) (chatchar&0x00FF);
        buf[7+offset]=(byte) (buttons&0x00FF);
        
    }

    @Override
    public void unpack(byte[] buf) {
        unpack(buf,0);        
        }

    @Override
    public void unpack(byte[] buf, int offset) {
        forwardmove=buf[0+offset];
        sidemove=   buf[1+offset];        
        angleturn=(short)(buf[2+offset]<<8|buf[3+offset]);
        consistancy=(short)(buf[4+offset]<<8|buf[5+offset]);
        // We blow these up to full chars.
        chatchar=(char)(0x00FF& buf[6+offset]);
        buttons=(char) (0x00FF& buf[7+offset]);
        
    }

    @Override
    public byte[] cached() {
        return this.buffer;
    }

    @Override
    public void read(DataInputStream f)
            throws IOException {
    	iobuffer.position(0);
    	iobuffer.order(ByteOrder.LITTLE_ENDIAN);
    	f.read(iobuffer.array());
    	unpack(iobuffer);
    }
    
    /** This is useful only when loading/saving players from savegames.
     *  It's NOT interchangeable with datagram methods, because it
     *  does not use the network byte order.
     */

    @Override
    public void unpack(ByteBuffer f)
            throws IOException {
        f.order(ByteOrder.LITTLE_ENDIAN);
        forwardmove=f.get();
        sidemove=   f.get();        
        // Even if they use the "unsigned char" syntax, angleturn is signed.
        angleturn=f.getShort();
        consistancy=f.getShort();
        // We blow these up to full chars.
        chatchar=(char) f.get();
        buttons=(char) f.get();
        
    }
    
    /** Ditto, we only pack some of the fields.
     * 
     * @param f
     * @throws IOException
     */
    public void pack(ByteBuffer f)
            throws IOException {
        f.order(ByteOrder.LITTLE_ENDIAN);
        f.put(forwardmove);
        f.put(sidemove);        
        // LE order on disk for vanilla compatibility.
        f.putShort(angleturn);
        f.putShort(consistancy);
        // We crimp these to bytes :-(
        f.put((byte) chatchar);
        f.put((byte) buttons);     
    }
    
    private static ByteBuffer iobuffer=ByteBuffer.allocate(8);
    
};

package doom;


//
// INTERMISSION
// Structure passed e.g. to WI_Start(wb)
//

public class wbplayerstruct_t implements Cloneable{
    
    public wbplayerstruct_t(){
        frags=new int[4];
    }
     public boolean in; // whether the player is in game
     
     /** Player stats, kills, collected items etc. */
     public int     skills;
     public int     sitems;
     public int     ssecret;
     public int     stime; 
     public int[]   frags;
     /** current score on entry, modified on return */
     public int     score;
   
     public wbplayerstruct_t clone(){
         wbplayerstruct_t r=null;
        try {
            r = (wbplayerstruct_t)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
         /*r.in=this.in;
         r.skills=this.skills;
         r.sitems=this.sitems;
         r.ssecret=this.ssecret;
         r.stime=this.stime; */
         System.arraycopy(this.frags, 0, r.frags,0,r.frags.length);
         // r.score=this.score;
         
         
        return r;
         
     }
     
 }

package doom;

import static data.Limits.MAXPLAYERS;
import utils.C2JUtils;

public class wbstartstruct_t implements Cloneable{

        public wbstartstruct_t(){
            plyr=new wbplayerstruct_t[MAXPLAYERS];
            C2JUtils.initArrayOfObjects(plyr, wbplayerstruct_t.class);
        }
    
        public int      epsd;   // episode # (0-2)

        // if true, splash the secret level
        public boolean  didsecret;
        
        // previous and next levels, origin 0
        public int      last;
        public int      next;   
        
        public int      maxkills;
        public int      maxitems;
        public int      maxsecret;
        public int      maxfrags;

        /** the par time */
        public int      partime;
        
        /** index of this player in game */
        public int      pnum;   
        /** meant to be treated as a "struct", therefore assignments should be deep copies */
        public wbplayerstruct_t[]   plyr;
        
        public wbstartstruct_t clone(){
            wbstartstruct_t cl=null;
            try {
                cl=(wbstartstruct_t)super.clone();
            } catch (CloneNotSupportedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            /*cl.epsd=this.epsd;
            cl.didsecret=this.didsecret;
            cl.last=this.last;
            cl.next=this.next;
            cl.maxfrags=this.maxfrags;
            cl.maxitems=this.maxitems;
            cl.maxsecret=this.maxsecret;
            cl.maxkills=this.maxkills;
            cl.partime=this.partime;
            cl.pnum=this.pnum;*/
            for (int i=0;i<cl.plyr.length;i++){
                cl.plyr[i]=this.plyr[i].clone();    
            }
            //cl.plyr=this.plyr.clone();
            
            return cl;
            
        }
        
    } 

package doom;

import java.io.IOException;

/** Stuff that the "main" is supposed to do. DoomMain implements those.
 * 
 * @author Maes
 *
 */


public interface IDoom {


	/** Called by IO functions when input is detected. */
	void PostEvent (event_t ev);
	void PageTicker ();
	void PageDrawer ();
	void AdvanceDemo ();
	void StartTitle ();
    void QuitNetGame() throws IOException; 

}
package doom;

 // Player states.
 //
 public enum  playerstate_t
 {
     // Playing or camping.
     PST_LIVE,
     // Dead on the ground, view follows killer.
     PST_DEAD,
     // Ready to restart/respawn???
     PST_REBORN      

 };
package n;

import i.DoomStatusAware;
import i.IDoomSystem;
import doom.DoomMain;
import doom.DoomStatus;
import doom.IDoomGameNetworking;
import doom.NetConsts;
import doom.doomcom_t;

/** Does nothing.
 *  Allows running single-player games without an actual network.
 *  Hopefully, it will be replaced by a real UDP-based driver one day.
 *  
 * @author Velktron
 *
 */

public class DummyNetworkDriver implements NetConsts,DoomSystemNetworking, DoomStatusAware{

	////////////// STATUS ///////////

	IDoomSystem I;
	DoomMain DM;
	IDoomGameNetworking DGN;

	public DummyNetworkDriver(DoomStatus DC){
		updateStatus(DC);
	}

	@Override
	public void InitNetwork() {
		doomcom_t doomcom =new doomcom_t();
		doomcom.id=DOOMCOM_ID;
		doomcom.ticdup=1;

		// single player game
		DM.netgame = false;
		doomcom.id = DOOMCOM_ID;
		doomcom.numplayers = doomcom.numnodes = 1;
		doomcom.deathmatch = 0;
		doomcom.consoleplayer = 0;
		DGN.setDoomCom(doomcom);
	}

	@Override
	public void NetCmd() {
		// TODO Auto-generated method stub

	}

	@Override
	public void updateStatus(DoomStatus DC) {
		this.DM=DC.DM;
		this.DGN=DC.DM;
	}

}

package n;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: DoomSystemNetworking.java,v 1.1 2010/11/17 23:55:06 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//  System specific network interface stuff.
//
//-----------------------------------------------------------------------------

public interface DoomSystemNetworking{


// Called by D_DoomMain.

public void InitNetwork ();
public void NetCmd ();


}

//-----------------------------------------------------------------------------
//
// $Log: DoomSystemNetworking.java,v $
// Revision 1.1  2010/11/17 23:55:06  velktron
// Kind of playable/controllable.
//
// Revision 1.1  2010/10/22 16:22:43  velktron
// Renderer works stably enough but a ton of bleeding. Started working on netcode.
//
//
//-----------------------------------------------------------------------------


package n;

import doom.IDoomGameNetworking;
import doom.doomcom_t;

public class DummyNetworkHandler implements IDoomGameNetworking{

    @Override
    public void NetUpdate() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void TryRunTics() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public doomcom_t getDoomCom() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void setDoomCom(doomcom_t doomcom) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public int getTicdup() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void setTicdup(int ticdup) {
        // TODO Auto-generated method stub
        
    }

}

package n;

import static data.Limits.MAXNETNODES;
import static doom.NetConsts.CMD_GET;
import static doom.NetConsts.CMD_SEND;
import static doom.NetConsts.DOOMCOM_ID;
import i.DoomStatusAware;
import i.IDoomSystem;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.net.SocketTimeoutException;

import w.DoomBuffer;
import doom.DoomContext;
import doom.DoomMain;
import doom.DoomStatus;
import doom.doomcom_t;
import doom.doomdata_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: BasicNetworkInterface.java,v 1.5 2011/05/26 13:39:06 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: BasicNetworkInterface.java,v $
// Revision 1.5  2011/05/26 13:39:06  velktron
// Now using ICommandLineManager
//
// Revision 1.4  2011/05/18 16:54:31  velktron
// Changed to DoomStatus
//
// Revision 1.3  2011/05/17 16:53:42  velktron
// _D_'s version.
//
// Revision 1.2  2010/12/20 17:15:08  velktron
// Made the renderer more OO -> TextureManager and other changes as well.
//
// Revision 1.1  2010/11/17 23:55:06  velktron
// Kind of playable/controllable.
//
// Revision 1.2  2010/11/11 15:31:28  velktron
// Fixed "warped floor" error.
//
// Revision 1.1  2010/10/22 16:22:43  velktron
// Renderer works stably enough but a ton of bleeding. Started working on netcode.
//
//
// DESCRIPTION:
//
//-----------------------------------------------------------------------------

public class BasicNetworkInterface
        implements DoomSystemNetworking, DoomStatusAware {


  public static final String rcsid = "$Id: BasicNetworkInterface.java,v 1.5 2011/05/26 13:39:06 velktron Exp $";

  ////////////// STATUS ///////////
  
  IDoomSystem I;
  protected DoomMain DM;
  
  public BasicNetworkInterface(DoomContext DC){
      this.DM=DC.DM;
      //this.myargv=DM.myargv;
      //this.myargc=DM.myargc;
      sendData=new doomdata_t();
      recvData=new doomdata_t();
      // We can do that since the buffer is reused.
      // Note: this will effectively tie doomdata and the datapacket.
      recvPacket=new DatagramPacket(recvData.cached(),recvData.cached().length);
      sendPacket=new DatagramPacket(sendData.cached(),sendData.cached().length);
      
      
  }
  
  // Bind it to the ones inside DN and DM;  
  //doomdata_t netbuffer;
  doomcom_t doomcom;
  
  
  // For some odd reason...
  
  /** Changes endianness of a number */
  
  public static int ntohl(int x) {      
   return       ((((x & 0x000000ff) << 24) | 
                               ((x & 0x0000ff00) <<  8) | 
                               ((x & 0x00ff0000) >>>  8) | 
                               ((x & 0xff000000) >>> 24)));
      }

  public static short ntohs(short x) {
      return (short) (((x & 0x00ff) << 8) | ((x & 0xff00) >>> 8));
      }
        
  public static int htonl(int x) {
      return ntohl(x);
      }
  
  public static short htons(short x){
      return ntohs(x);
  }

  //void    NetSend ();
  //boolean NetListen ();


  //
  // NETWORKING
  //

  // Maes: come on, we all know it's 666.
  int DOOMPORT =  666;//(IPPORT_USERRESERVED +0x1d );
  
  //_D_: for testing purposes. If testing on the same machine, we can't have two UDP servers on the same port
  int RECVPORT = DOOMPORT;
  int SENDPORT = DOOMPORT;

  //DatagramSocket         sendsocket;
  DatagramSocket         insocket;

    
  // MAES: closest java equivalent
  DatagramSocket /*InetAddress*/ sendaddress[]=new DatagramSocket/*InetAddress*/[MAXNETNODES];

  
  interface NetFunction {
      public void invoke();
  }
  

  // To use inside packetsend. Declare once and reuse to save on heap costs.
  private doomdata_t  sendData;
  private doomdata_t  recvData;
  
  // We also reuse always the same DatagramPacket, "peged" to sw's byte buffer.
  private DatagramPacket recvPacket;
  private DatagramPacket sendPacket;
  
  public void sendSocketPacket(DatagramSocket ds, DatagramPacket dp) throws IOException {
      ds.send(dp);
  }

  public PacketSend packetSend = new PacketSend();

  public class PacketSend implements NetFunction {

      @Override
      public void invoke() {
          int     c;

          doomdata_t netbuffer = DM.netbuffer;

          // byte swap: so this is transferred as little endian? Ugh
          /*sendData.checksum = htonl(netbuffer.checksum);
          sendData.player = netbuffer.player;
          sendData.retransmitfrom = netbuffer.retransmitfrom;
          sendData.starttic = netbuffer.starttic;
          sendData.numtics = netbuffer.numtics;
          for (c=0 ; c< netbuffer.numtics ; c++)
          {
              sendData.cmds[c].forwardmove = netbuffer.cmds[c].forwardmove;
              sendData.cmds[c].sidemove = netbuffer.cmds[c].sidemove;
              sendData.cmds[c].angleturn = htons(netbuffer.cmds[c].angleturn);
              sendData.cmds[c].consistancy = htons(netbuffer.cmds[c].consistancy);
              sendData.cmds[c].chatchar = netbuffer.cmds[c].chatchar;
              sendData.cmds[c].buttons = netbuffer.cmds[c].buttons;
          }
*/
          //printf ("sending %i\n",gametic);      
          
          sendData.copyFrom(netbuffer);
          // MAES: This will force the buffer to be refreshed.
          byte[] bytes = sendData.pack();

          /*System.out.print("SEND >> Thisplayer: "+DM.consoleplayer+" numtics: "+sendData.numtics+" consistency: ");
          for (doom.ticcmd_t t: sendData.cmds)
              System.out.print(t.consistancy+",");
          System.out.println();*/

          // The socket already contains the address it needs,
          // and the packet's buffer is already modified. Send away.
          sendPacket.setData(bytes, 0, doomcom.datalength);
          DatagramSocket sendsocket;
          try {
              sendsocket = sendaddress[doomcom.remotenode];
              sendPacket.setSocketAddress(sendsocket.getRemoteSocketAddress());
              sendSocketPacket(sendsocket, sendPacket);
          } catch (Exception e) {
              e.printStackTrace();
              I.Error ("SendPacket error: %s",e.getMessage());
          }

          //  if (c == -1)
          //      I_Error ("SendPacket error: %s",strerror(errno));
      }

  }


  public void socketGetPacket(DatagramSocket ds, DatagramPacket dp) throws IOException {
      ds.receive(dp);
  }
  
  // Used inside PacketGet
  private boolean first=true;

  public PacketGet packetGet = new PacketGet();
  public class PacketGet implements NetFunction {

      @Override
      public void invoke() {
          int         i;
          int         c;

          // Receive back into swp.
          try {
              //recvPacket.setSocketAddress(insocket.getLocalSocketAddress());
              socketGetPacket(insocket, recvPacket);
          } 
          catch (SocketTimeoutException e) {
              doomcom.remotenode = -1;       // no packet
              return;
          }
          catch (Exception e)
          { if (e.getClass()!=java.nio.channels.IllegalBlockingModeException.class){
              I.Error ("GetPacket: %s",e.getStackTrace());
          }
          }

          recvData.unpack(recvPacket.getData());
          InetAddress fromaddress = recvPacket.getAddress();

          /*System.out.print("RECV << Thisplayer: "+DM.consoleplayer+" numtics: "+recvData.numtics+" consistency: ");
          for (doom.ticcmd_t t: recvData.cmds)
              System.out.print(t.consistancy+",");
          System.out.println();*/
          
          {
              //static int first=1;
              if (first){
                  sb.setLength(0);
                  sb.append("("+DM.consoleplayer+") PacketRECV len=");
                  sb.append(recvPacket.getLength());
                  sb.append(":p=[0x");
                  sb.append(Integer.toHexString(recvData.checksum));
                  sb.append(" 0x");
                  sb.append(DoomBuffer.getBEInt(recvData.retransmitfrom,recvData.starttic,recvData.player,recvData.numtics));
                  sb.append("numtics: "+recvData.numtics);
                  System.out.println(sb.toString());
                  first = false;
              }
          }

          // find remote node number
          for (i=0 ; i<doomcom.numnodes ; i++) {
              if (sendaddress[i] != null) {
                  if (fromaddress.equals(sendaddress[i].getInetAddress()))
                      break;
              }
          }

          if (i == doomcom.numnodes)
          {
              // packet is not from one of the players (new game broadcast)
              doomcom.remotenode = -1;       // no packet
              return;
          }

          doomcom.remotenode = (short) i;            // good packet from a game player
          doomcom.datalength = (short) recvPacket.getLength();

          //_D_: temporary hack to test two player on single machine
          //doomcom.remotenode = (short)(RECVPORT-DOOMPORT);
          

          
          // byte swap
          /*doomdata_t netbuffer = DM.netbuffer;
          netbuffer.checksum = ntohl(recvData.checksum);
          netbuffer.player = recvData.player;
          netbuffer.retransmitfrom = recvData.retransmitfrom;
          netbuffer.starttic = recvData.starttic;
          netbuffer.numtics = recvData.numtics;

          for (c=0 ; c< netbuffer.numtics ; c++)
          {
              netbuffer.cmds[c].forwardmove = recvData.cmds[c].forwardmove;
              netbuffer.cmds[c].sidemove = recvData.cmds[c].sidemove;
              netbuffer.cmds[c].angleturn = ntohs(recvData.cmds[c].angleturn);
              netbuffer.cmds[c].consistancy = ntohs(recvData.cmds[c].consistancy);
              netbuffer.cmds[c].chatchar = recvData.cmds[c].chatchar;
              netbuffer.cmds[c].buttons = recvData.cmds[c].buttons;
          } */
          DM.netbuffer.copyFrom(recvData);

      }

  };

  // Maes: oh great. More function pointer "fun".
  NetFunction netget = packetGet;
  NetFunction netsend = packetSend;


  //
  // I_InitNetwork
  //
    
  @Override
  public void InitNetwork() {
      boolean     trueval = true;
      int         i;
      int         p;
      //struct hostent* hostentry;  // host information entry

      doomcom = new doomcom_t();
      //netbuffer = new doomdata_t();
      DM.setDoomCom(doomcom);
      //DM.netbuffer = netbuffer;

      // set up for network
      i = DM.CM.CheckParm ("-dup");
      if ((i!=0) && i< DM.CM.getArgc()-1)
      {
          doomcom.ticdup = (short) (DM.CM.getArgv(i+1).charAt(0)-'0');
          if (doomcom.ticdup < 1)
              doomcom.ticdup = 1;
          if (doomcom.ticdup > 9)
              doomcom.ticdup = 9;
      }
      else
          doomcom. ticdup = 1;

      if (DM.CM.CheckParm ("-extratic")!=0)
          doomcom. extratics = 1;
      else
          doomcom. extratics = 0;

      p = DM.CM.CheckParm ("-port");
      if ((p!=0) && (p<DM.CM.getArgc()-1))
      {
          DOOMPORT = Integer.parseInt(DM.CM.getArgv(p+1));
          System.out.println ("using alternate port "+DOOMPORT);
      }

      // parse network game options,
      //  -net <consoleplayer> <host> <host> ...
      i = DM.CM.CheckParm ("-net");
      if (i==0)
      {
          // single player game
          DM.netgame = false;
          doomcom.id = DOOMCOM_ID;
          doomcom.numplayers = doomcom.numnodes = 1;
          doomcom.deathmatch = 0; // false
          doomcom.consoleplayer = 0;
          return;
      }

      DM.netgame = true;

      // parse player number and host list
      doomcom.consoleplayer = (short) (DM.CM.getArgv(i+1).charAt(0)-'1');
      
      RECVPORT = SENDPORT = DOOMPORT;
      if (doomcom.consoleplayer == 0)
          SENDPORT++;
      else
          RECVPORT++;

      doomcom.numnodes = 1;  // this node for sure

      i++;
      while (++i < DM.CM.getArgc() && DM.CM.getArgv(i).charAt(0) != '-')
      {
          try {
          InetAddress addr = InetAddress.getByName(DM.CM.getArgv(i));
          DatagramSocket ds = new DatagramSocket(null);
          ds.setReuseAddress(true);
          ds.connect(addr, SENDPORT);

          sendaddress[doomcom.numnodes] = ds;
          }catch (Exception e) {
              e.printStackTrace();
          }
          
          doomcom.numnodes++;
      }

      doomcom.id = DOOMCOM_ID;
      doomcom.numplayers = doomcom.numnodes;

      // build message to receive
      try {
          insocket = new DatagramSocket(null);
          insocket.setReuseAddress(true);
          insocket.setSoTimeout(1);
          insocket.bind(new InetSocketAddress(RECVPORT));
      } catch (SocketException e1) {
          // TODO Auto-generated catch block
          e1.printStackTrace();
      }
  }

    @Override
    public void NetCmd() {
          if (insocket == null) //HACK in case "netgame" is due to "addbot"
              return;

        if (DM.doomcom.command == CMD_SEND)
        {
        netsend.invoke ();
        }
        else if (doomcom.command == CMD_GET)
        {
        netget.invoke ();
        }
        else
        I.Error ("Bad net cmd: %i\n",doomcom.command);

    }

    // Instance StringBuilder
    private StringBuilder sb=new StringBuilder();

    @Override
    public void updateStatus(DoomStatus DC) {
        // TODO Auto-generated method stub
        
    }
    
}

package n;

public interface IDoomNet {
    public void NetUpdate();
}

package f;

/* Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: EndLevel.java,v 1.12 2016/07/04 07:52:26 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: EndLevel.java,v $
// Revision 1.12  2016/07/04 07:52:26  velktron
// GPL license header, and cleanup for files that are not in direct correspondence with original ones.
//
// Revision 1.11  2012/09/24 17:16:23  velktron
// Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
// Revision 1.8.2.2  2012/09/24 16:57:43  velktron
// Addressed generics warnings.
//
// Revision 1.8.2.1  2011/11/27 18:18:34  velktron
// Use cacheClear() on deactivation.
//
// Revision 1.8  2011/11/01 19:02:57  velktron
// Using screen number constants
//
// Revision 1.7  2011/10/23 18:11:32  velktron
// Generic compliance for DoomVideoInterface
//
// Revision 1.6  2011/08/23 16:13:53  velktron
// Got rid of Z remnants.
//
// Revision 1.5  2011/07/31 21:49:38  velktron
// Changed endlevel drawer's behavior to be closer to prBoom+'s. Allows using 1994TU.WAD while backwards compatible.
//
// Revision 1.4  2011/06/02 14:56:48  velktron
// imports
//
// Revision 1.3  2011/06/02 14:53:21  velktron
// Moved Endlevel constants to AbstractEndLevel
//
// Revision 1.2  2011/06/02 14:14:28  velktron
// Implemented endlevel unloading of graphics, changed state enum.
//
// Revision 1.1  2011/06/02 14:00:48  velktron
// Moved Endlevel stuff  to f, where it makes more sense.
//
// Revision 1.18  2011/05/31 12:25:14  velktron
// Endlevel -mostly- scaled correctly.
//
// Revision 1.17  2011/05/29 22:15:32  velktron
// Introduced IRandom interface.
//
// Revision 1.16  2011/05/24 17:54:02  velktron
// Defaults tester
//
// Revision 1.15  2011/05/23 17:00:39  velktron
// Got rid of verbosity
//
// Revision 1.14  2011/05/21 16:53:24  velktron
// Adapted to use new gamemode system.
//
// Revision 1.13  2011/05/18 16:58:04  velktron
// Changed to DoomStatus
//
// Revision 1.12  2011/05/17 16:52:19  velktron
// Switched to DoomStatus
//
// Revision 1.11  2011/05/11 14:12:08  velktron
// Interfaced with DoomGame
//
// Revision 1.10  2011/05/10 10:39:18  velktron
// Semi-playable Techdemo v1.3 milestone
//
// Revision 1.9  2011/05/06 14:00:54  velktron
// More of _D_'s changes committed.
//
// Revision 1.8  2011/02/11 00:11:13  velktron
// A MUCH needed update to v1.3.
//
// Revision 1.7  2010/12/20 17:15:08  velktron
// Made the renderer more OO -> TextureManager and other changes as well.
//
// Revision 1.6  2010/11/12 13:37:25  velktron
// Rationalized the LUT system - now it's 100% procedurally generated.
//
// Revision 1.5  2010/09/23 07:31:11  velktron
// fuck
//
// Revision 1.4  2010/09/02 15:56:54  velktron
// Bulk of unified renderer copyediting done.
//
// Some changes like e.g. global separate limits class and instance methods for seg_t and node_t introduced.
//
// Revision 1.3  2010/08/23 14:36:08  velktron
// Menu mostly working, implemented Killough's fast hash-based GetNumForName, although it can probably be finetuned even more.
//
// Revision 1.2  2010/08/13 14:06:36  velktron
// Endlevel screen fully functional!
//
// Revision 1.1  2010/07/06 16:32:38  velktron
// Threw some work in WI, now EndLevel. YEAH THERE'S GONNA BE A SEPARATE EndLevel OBJECT THAT'S HOW PIMP THE PROJECT IS!!!!11!!!
//
// Revision 1.1  2010/06/30 08:58:51  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//	Intermission screens.
//
//-----------------------------------------------------------------------------*/


import static data.Defines.*;
import static data.Limits.*;
import static v.DoomVideoRenderer.*;
import defines.*;
import data.sounds.musicenum_t;
import data.sounds.sfxenum_t;
import doom.DoomMain;
import doom.DoomStatus;
import doom.IDoomGame;
import doom.event_t;
import doom.player_t;
import doom.wbplayerstruct_t;
import doom.wbstartstruct_t;
import m.IRandom;
import rr.*;
import s.IDoomSound;
import st.IDoomStatusBar;
import v.DoomVideoRenderer;
import v.IVideoScale;
import w.IWadLoader;
import w.animenum_t;

/** This class (stuff.c) seems to implement the endlevel screens.
 * 
 * @author Maes
 *
 */

public class EndLevel<T,V> extends AbstractEndLevel {

    ////////////////// STATUS ///////////////////
    private DoomMain<?,?> DS;
    private IDoomGame DG;
    private DoomVideoRenderer<?,?> V;
    private IDoomSound S;
    private IWadLoader W;
    private IDoomStatusBar ST;
    private IRandom RND;
    
    private static int COUNT_KILLS=2;
    private static int COUNT_ITEMS=4;
    private static int COUNT_SECRETS=6;
    private static int COUNT_TIME=8;
    private static int COUNT_DONE=10;
    
    static enum endlevel_state{
    	NoState,
    	StatCount,
    	ShowNextLoc, 
    	JustShutOff
    }
    
  //GLOBAL LOCATIONS
    private static final int WI_TITLEY       =2;
    private static final int WI_SPACINGY         =3;
    
    
//
// GENERAL DATA
//

//
// Locally used stuff.
//
public static final int FB= 0;
private static final boolean RANGECHECKING = true;

// Where to draw some stuff. To be scaled up, so they
// are not final.

public static int SP_STATSX;
public static int SP_STATSY;

public static int SP_TIMEX;
public static int SP_TIMEY;

// States for single-player
protected static int SP_KILLS	=	0;
protected static int SP_ITEMS	=	2;
protected static int SP_SECRET	=	4;
protected static int SP_FRAGS	=	6 ;
protected static int SP_TIME		=	8 ;
protected static int SP_PAR		=	SP_TIME;

protected int SP_PAUSE	=	1;

// in seconds
protected  int SHOWNEXTLOCDELAY	=4;
protected  int SHOWLASTLOCDELAY	=SHOWNEXTLOCDELAY;

// used to accelerate or skip a stage
int		acceleratestage;

// wbs->pnum
int		me;

 // specifies current state )
endlevel_state	state;

// contains information passed into intermission
public wbstartstruct_t	wbs;

wbplayerstruct_t[] plrs;  // wbs->plyr[]

// used for general timing
int 		cnt;  

// used for timing of background animation
int 		bcnt;

// signals to refresh everything for one frame
int 		firstrefresh; 

int[]		cnt_kills=new int[MAXPLAYERS];
int[]		cnt_items=new int[MAXPLAYERS];
int[]		cnt_secret=new int[MAXPLAYERS];
int		cnt_time;
int		cnt_par;
int		cnt_pause;

// # of commercial levels
int		NUMCMAPS; 


//
//	GRAPHICS
//

// background (map of levels).
patch_t		bg;

// You Are Here graphic
patch_t[]		yah=new patch_t[2]; 

// splat
patch_t		splat;

/** %, : graphics */
patch_t		percent,colon;

/** 0-9 graphic */
patch_t[]		num=new patch_t[10];

/** minus sign */
 patch_t	wiminus;

// "Finished!" graphics
 patch_t		finished;

// "Entering" graphic
 patch_t		entering; 

// "secret"
 patch_t		sp_secret;

 /** "Kills", "Scrt", "Items", "Frags" */
 patch_t		kills,	secret,items,frags;

/** Time sucks. */
 patch_t		time,	par,sucks;

/** "killers", "victims" */
 patch_t		killers,victims; 

/** "Total", your face, your dead face */
 patch_t		total,	star, bstar;

/** "red P[1..MAXPLAYERS]"*/
 patch_t[]		p=new patch_t[MAXPLAYERS];

/** "gray P[1..MAXPLAYERS]" */
 patch_t[] bp=new patch_t[MAXPLAYERS];

 /** Name graphics of each level (centered) */
 patch_t[]	lnames;

//
// CODE
//

// slam background
// UNUSED  unsigned char *background=0;


public EndLevel(DoomStatus<T,V> DC) {
    this.updateStatus(DC);
   
    // _D_: commented this, otherwise something didn't work
    //this.Start(DS.wminfo);
}

protected void slamBackground()
{
    //    memcpy(screens[0], screens[1], SCREENWIDTH * SCREENHEIGHT);
    // Remember, the second arg is the source!
    System.arraycopy(V.getScreen(SCREEN_BG), 0 ,V.getScreen(SCREEN_FG),0, SCREENWIDTH * SCREENHEIGHT);
    V.MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
}

// The ticker is used to detect keys
//  because of timing issues in netgames.
public boolean Responder(event_t ev)
{
    return false;
}


/** Draws "<Levelname> Finished!" */	
protected void drawLF()
{
    int y = WI_TITLEY;

    // draw <LevelName> 
    V.DrawScaledPatch((320 - lnames[wbs.last].width)/2,
        y, FB,vs, lnames[wbs.last]);

    // draw "Finished!"
    y += (5*lnames[wbs.last].height)/4;
    
    V.DrawScaledPatch((320 - finished.width)/2,
        y, FB,vs, finished);
}



/** Draws "Entering <LevelName>" */
protected void drawEL()
{
    int y = WI_TITLEY; // This is in 320 x 200 coords!

    // draw "Entering"
    V.DrawScaledPatch((320 - entering.width)/2, y, FB,vs, entering);
    
    // HACK: if lnames[wbs.next] DOES have a defined nonzero topoffset, use it.
    // implicitly in DrawScaledPatch, and trump the normal behavior.
    // FIXME: this is only useful in a handful of prBoom+ maps, which use
    // a modified endlevel screen. The reason it works there is the behavior of the 
    // unified patch drawing function, which is approximated with this hack.
    
    
    	if (lnames[wbs.next].topoffset==0) 
    	y += (5*lnames[wbs.next].height)/4;
    // draw level.
        
    V.DrawScaledPatch((320 - lnames[wbs.next].width)/2,
        y, FB,vs, lnames[wbs.next]);
 
}

/** For whatever fucked-up reason, it expects c to be an array of patches, 
 *  and may choose to draw from alternative ones...which however are never loaded,
 *  or are supposed to be "next" in memory or whatever. I kept this behavior, however 
 *  in Java it will NOT work as intended, if ever.
 * 
 * @param n
 * @param c
 */

protected void
drawOnLnode
( int		n,
  patch_t[]	c )
{

    int		i;
    int		left;
    int		top;
    int		right;
    int		bottom;
    boolean	fits = false;

    i = 0;
    do
    {
	left = lnodes[wbs.epsd][n].x - c[i].leftoffset;
	top = lnodes[wbs.epsd][n].y - c[i].topoffset;
	right = left + c[i].width;
	bottom = top + c[i].height;

	if (left >= 0
	    && right < SCREENWIDTH
	    && top >= 0
	    && bottom < SCREENHEIGHT)
	{
	    fits = true;
	}
	else
	{
	    i++;
	}
    } while (!fits && i!=2);

    if (fits && i<2)
    {
	//V.DrawPatch(lnodes[wbs.epsd][n].x, lnodes[wbs.epsd][n].y,
	//	    FB, c[i]);
        V./*DrawPatchDirect*/DrawScaledPatch(lnodes[wbs.epsd][n].x, lnodes[wbs.epsd][n].y,
            FB, vs,c[i]);
    }
    else
    {
	// DEBUG
	System.out.println("Could not place patch on level "+ n+1); 
    }
}



protected void initAnimatedBack()
{
    int		i;
    anim_t	a;

    if (DS.isCommercial())
	return;

    if (wbs.epsd > 2)
	return;

    for (i=0;i<NUMANIMS[wbs.epsd];i++)
    {
	a = anims[wbs.epsd][i];

	// init variables
	a.ctr = -1;

	// specify the next time to draw it
	if (a.type == animenum_t.ANIM_ALWAYS)
	    a.nexttic = bcnt + 1 + (RND.M_Random()%a.period);
	else if (a.type == animenum_t.ANIM_RANDOM)
	    a.nexttic = bcnt + 1 + a.data2+(RND.M_Random()%a.data1);
	else if (a.type == animenum_t.ANIM_LEVEL)
	    a.nexttic = bcnt + 1;
    }

}

protected void updateAnimatedBack()
{
    int		i;
    anim_t	a;

    if (DS.isCommercial())
	return;

    if (wbs.epsd > 2)
	return;

    int aaptr=wbs.epsd;
    
    for (i=0;i<NUMANIMS[wbs.epsd];i++)
    {
	a = anims[aaptr][i];
	
	if (bcnt == a.nexttic)
	{
	    switch (a.type)
	    {
	      case ANIM_ALWAYS:
		if (++anims[aaptr][i].ctr >= a.nanims) a.ctr = 0;
		a.nexttic = bcnt + a.period;
		break;

	      case ANIM_RANDOM:
		a.ctr++;
		if (a.ctr == a.nanims)
		{
		    a.ctr = -1;
		    a.nexttic = bcnt+a.data2+(RND.M_Random()%a.data1);
		}
		else a.nexttic = bcnt + a.period;
		break;
		
	      case ANIM_LEVEL:
		// gawd-awful hack for level anims
		if (!(state == endlevel_state.StatCount && i == 7)
		    && wbs.next == a.data1)
		{
		    a.ctr++;
		    if (a.ctr == a.nanims) a.ctr--;
		    a.nexttic = bcnt + a.period;
		}
		break;
	    }
	}

    }

}

protected void drawAnimatedBack()
{
    int			i;
    anim_t		a;

    if (DS.isCommercial())
	return;

    if (wbs.epsd > 2)
	return;

    for (i=0 ; i<NUMANIMS[wbs.epsd] ; i++)
    {
	a = anims[wbs.epsd][i];

	if (a.ctr >= 0)
	    V.DrawScaledPatch(a.loc.x, a.loc.y, FB,vs, a.p[a.ctr]);
    }

}

/**
 * Draws a number.
 * If digits > 0, then use that many digits minimum,
 *  otherwise only use as many as necessary.
 * Returns new x position.
 */

protected int
drawNum
( int		x,
  int		y,
  int		n,
  int		digits )
{

    int		fontwidth = num[0].width;
    boolean		neg;
    int		temp;

    if (digits < 0)
    {
	if (n==0)
	{
	    // make variable-length zeros 1 digit long
	    digits = 1;
	}
	else
	{
	    // figure out # of digits in #
	    digits = 0;
	    temp = n;

	    while (temp!=0)
	    {
		temp /= 10;
		digits++;
	    }
	}
    }

    neg = (n < 0);
    if (neg)
	n = -n;

    // if non-number, do not draw it
    if (n == 1994)
	return 0;

    // draw the new number
    while ((digits--)!=0)
    {
	x -= fontwidth*BEST_X_SCALE;
	V.DrawScaledPatch(x, y, V_NOSCALESTART|FB,vs, num[ n % 10 ]);
	n /= 10;
    }

    // draw a minus sign if necessary
    if (neg)
	V.DrawScaledPatch(x-=8*BEST_X_SCALE, y, V_NOSCALESTART|FB,vs, wiminus);

    return x;

}

protected 

void
drawPercent
( int		x,
  int		y,
  int		p )
{
    if (p < 0)
	return;

    V.DrawScaledPatch(x, y, V_NOSCALESTART|FB,vs, percent);
    drawNum(x, y, p, -1);
}



//
// Display level completion time and par,
//  or "sucks" message if overflow.
//
protected void drawTime
( int		x,
  int		y,
  int		t )
{

    int		div;
    int		n;

    if (t<0)
	return;

    if (t <= 61*59)
    {
	div = 1;

	do
	{
	    n = (t / div) % 60;
	    x = drawNum(x, y, n, 2) - colon.width*BEST_X_SCALE;
	    div *= 60;

	    // draw
	    if ((div==60) || (t / div)>0)
		V.DrawScaledPatch(x, y, V_NOSCALESTART|FB, vs,colon);
	    
	} while ((t / div)>0);
    }
    else
    {
	// "sucks"
	V.DrawScaledPatch(x - sucks.width*BEST_X_SCALE, y, V_NOSCALESTART|FB, vs,sucks); 
    }
}


protected void End()
{
	state=endlevel_state.JustShutOff;
	V.clearCaches();
    unloadData();
}

protected void unloadData()
{
  int   i;
  int   j;

  W.UnlockLumpNum(wiminus); wiminus=null;

  for (i=0 ; i<10 ; i++) {
    W.UnlockLumpNum(num[i]); num[i]=null;
  	}
    
  if (DS.isCommercial())
    {
      for (i=0 ; i<NUMCMAPS ; i++){
        W.UnlockLumpNum(lnames[i]); lnames[i]=null;
      }
    }
  else
    {
      W.UnlockLumpNum(yah[0]); yah[0]=null;
      W.UnlockLumpNum(yah[1]); yah[1]=null;

      W.UnlockLumpNum(splat); splat=null;

      for (i=0 ; i<NUMMAPS ; i++) {
        W.UnlockLumpNum(lnames[i]); lnames[i]=null;
  
      }
      if (wbs.epsd < 3)
        {
          for (j=0;j<NUMANIMS[wbs.epsd];j++)
            {
              if (wbs.epsd != 1 || j != 8)
                for (i=0;i<anims[wbs.epsd][j].nanims;i++){
                  W.UnlockLumpNum(anims[wbs.epsd][j].p[i]);
                  anims[wbs.epsd][j].p[i]=null;
                }
            }
        }
    }
  W.UnlockLumpNum(percent); percent=null;
  W.UnlockLumpNum(colon); colon=null;
  W.UnlockLumpNum(finished); finished=null;
  W.UnlockLumpNum(entering); entering=null;
  W.UnlockLumpNum(kills); kills=null;
  W.UnlockLumpNum(secret); secret=null;
  W.UnlockLumpNum(sp_secret); sp_secret=null;
  W.UnlockLumpNum(items); items=null;
  W.UnlockLumpNum(frags); frags=null;
  W.UnlockLumpNum(time); time=null;
  W.UnlockLumpNum(sucks); sucks=null;
  W.UnlockLumpNum(par); par=null;
  W.UnlockLumpNum(victims); victims=null;
  W.UnlockLumpNum(killers); killers=null;
  W.UnlockLumpNum(total); total=null;
  for (i=0 ; i<MAXPLAYERS ; i++) {
    W.UnlockLumpNum(p[i]);
    W.UnlockLumpNum(bp[i]);
    p[i]=null;
    bp[i]=null;
  }
}


protected void initNoState()
{
    state = endlevel_state.NoState;
    acceleratestage = 0;
    cnt = 10;
}

protected void updateNoState() {

    updateAnimatedBack();

    if (--cnt==00)
    {
	End();
	DG.WorldDone();
    }

}

boolean		snl_pointeron = false;


protected void initShowNextLoc()
{
    state = endlevel_state.ShowNextLoc;
    acceleratestage = 0;
    cnt = SHOWNEXTLOCDELAY * TICRATE;

    initAnimatedBack();
}

protected void updateShowNextLoc()
{
    updateAnimatedBack();

    if ((--cnt==0) || (acceleratestage!=0))
	initNoState();
    else
	snl_pointeron = (cnt & 31) < 20;
}

protected void drawShowNextLoc()
{

    int		i;
    int		last;

    slamBackground();

    // draw animated background
    drawAnimatedBack(); 

    if ( !DS.isCommercial())
    {
  	if (wbs.epsd > 2)
	{
	    drawEL();
	    return;
	}
	
	last = (wbs.last == 8) ? wbs.next - 1 : wbs.last;

	// draw a splat on taken cities.
	for (i=0 ; i<=last ; i++)
	    drawOnLnode(i, new patch_t[]{splat});

	// splat the secret level?
	if (wbs.didsecret)
	    drawOnLnode(8, new patch_t[]{splat});

	// draw flashing ptr
	if (snl_pointeron)
	    drawOnLnode(wbs.next, yah); 
    }

    // draws which level you are entering..
    if ( (!DS.isCommercial())
	 || wbs.next != 30)
	drawEL();  

}

protected void drawNoState()
{
    snl_pointeron = true;
    drawShowNextLoc();
}

protected int fragSum(int playernum)
{
    int		i;
    int		frags = 0;
    
    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (DS.playeringame[i]
	    && i!=playernum)
	{
	    frags += plrs[playernum].frags[i];
	}
    }

	
    // JDC hack - negative frags.
    frags -= plrs[playernum].frags[playernum];
    // UNUSED if (frags < 0)
    // 	frags = 0;

    return frags;
}



int		dm_state;
int[][]		dm_frags=new int[MAXPLAYERS][MAXPLAYERS];
int	[]	dm_totals=new int[MAXPLAYERS];



protected void initDeathmatchStats()
{

    int		i;
    int		j;

    state = endlevel_state.StatCount;
    acceleratestage = 0;
    dm_state = 1;

    cnt_pause = TICRATE;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (DS.playeringame[i])
	{
	    for (j=0 ; j<MAXPLAYERS ; j++)
		if (DS.playeringame[j])
		    dm_frags[i][j] = 0;

	    dm_totals[i] = 0;
	}
    }
    
    initAnimatedBack();
}



protected void updateDeathmatchStats()
{

    int		i;
    int		j;
    
    boolean	stillticking;

    updateAnimatedBack();

    if ((acceleratestage!=0) && (dm_state != 4))
    {
	acceleratestage = 0;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (DS.playeringame[i])
	    {
		for (j=0 ; j<MAXPLAYERS ; j++)
		    if (DS.playeringame[j])
			dm_frags[i][j] = plrs[i].frags[j];

		dm_totals[i] = fragSum(i);
	    }
	}
	

	S.StartSound(null, sfxenum_t.sfx_barexp);
	dm_state = 4;
    }

    
    if (dm_state == 2)
    {
	if ((bcnt&3)==0)
	     S.StartSound(null, sfxenum_t.sfx_pistol);
	
	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (DS.playeringame[i])
	    {
		for (j=0 ; j<MAXPLAYERS ; j++)
		{
		    if (DS.playeringame[j]
			&& dm_frags[i][j] != plrs[i].frags[j])
		    {
			if (plrs[i].frags[j] < 0)
			    dm_frags[i][j]--;
			else
			    dm_frags[i][j]++;

			if (dm_frags[i][j] > 99)
			    dm_frags[i][j] = 99;

			if (dm_frags[i][j] < -99)
			    dm_frags[i][j] = -99;
			
			stillticking = true;
		    }
		}
		dm_totals[i] = fragSum(i);

		if (dm_totals[i] > 99)
		    dm_totals[i] = 99;
		
		if (dm_totals[i] < -99)
		    dm_totals[i] = -99;
	    }
	    
	}
	if (!stillticking)
	{
	    S.StartSound(null,sfxenum_t.sfx_barexp);
	    dm_state++;
	}

    }
    else if (dm_state == 4)
    {
	if (acceleratestage!=0)
	{
	    S.StartSound(null, sfxenum_t.sfx_slop);

	    if ( DS.isCommercial())
		initNoState();
	    else
		initShowNextLoc();
	}
    }
    else if ((dm_state & 1)!=0)
    {
	if (--cnt_pause==0)
	{
	    dm_state++;
	    cnt_pause = TICRATE;
	}
    }
}



protected void drawDeathmatchStats()
{

    int		i;
    int		j;
    int		x;
    int		y;
    int		w;
    
    int		lh = WI_SPACINGY; // line height

    slamBackground();
    
    // draw animated background
    drawAnimatedBack(); 
    drawLF();

    // draw stat titles (top line)
    V.DrawPatch(DM_TOTALSX-total.width/2,
		DM_MATRIXY-WI_SPACINGY+10,
		FB,
		total);
    
    V.DrawPatch(DM_KILLERSX, DM_KILLERSY, FB, killers);
    V.DrawPatch(DM_VICTIMSX, DM_VICTIMSY, FB, victims);

    // draw P?
    x = DM_MATRIXX + DM_SPACINGX;
    y = DM_MATRIXY;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (DS.playeringame[i])
	{
	    V.DrawPatch(x-p[i].width/2,
			DM_MATRIXY - WI_SPACINGY,
			FB,
			p[i]);
	    
	    V.DrawPatch(DM_MATRIXX-p[i].width/2,
			y,
			FB,
			p[i]);

	    if (i == me)
	    {
		V.DrawPatch(x-p[i].width/2,
			    DM_MATRIXY - WI_SPACINGY,
			    FB,
			    bstar);

		V.DrawPatch(DM_MATRIXX-p[i].width/2,
			    y,
			    FB,
			    star);
	    }
	}
	else
	{
	    // V_DrawPatch(x-SHORT(bp[i].width)/2,
	    //   DM_MATRIXY - WI_SPACINGY, FB, bp[i]);
	    // V_DrawPatch(DM_MATRIXX-SHORT(bp[i].width)/2,
	    //   y, FB, bp[i]);
	}
	x += DM_SPACINGX;
	y += WI_SPACINGY;
    }

    // draw stats
    y = DM_MATRIXY+10;
    w = num[0].width;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	x = DM_MATRIXX + DM_SPACINGX;

	if (DS.playeringame[i])
	{
	    for (j=0 ; j<MAXPLAYERS ; j++)
	    {
		if (DS.playeringame[j])
		    drawNum(x+w, y, dm_frags[i][j], 2);

		x += DM_SPACINGX;
	    }
	    drawNum(DM_TOTALSX+w, y, dm_totals[i], 2);
	}
	y += WI_SPACINGY;
    }
}

 int[]	cnt_frags=new int[MAXPLAYERS];
 int	dofrags;
 int	ng_state;

 protected void initNetgameStats()
{

    int i;

    state = endlevel_state.StatCount;
    acceleratestage = 0;
    ng_state = 1;

    cnt_pause = TICRATE;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (!DS.playeringame[i])
	    continue;

	cnt_kills[i] = cnt_items[i] = cnt_secret[i] = cnt_frags[i] = 0;

	dofrags += fragSum(i);
    }

    dofrags = ~~dofrags;

    initAnimatedBack();
}



protected void updateNetgameStats()
{

    int		i;
    int		fsum;
    
    boolean	stillticking;

    updateAnimatedBack();

    if (acceleratestage!=0 && ng_state != 10)
    {
	acceleratestage = 0;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!DS.playeringame[i])
		continue;

	    cnt_kills[i] = (plrs[i].skills * 100) / wbs.maxkills;
	    cnt_items[i] = (plrs[i].sitems * 100) / wbs.maxitems;
	    cnt_secret[i] = (plrs[i].ssecret * 100) / wbs.maxsecret;

	    if (dofrags!=0)
		cnt_frags[i] = fragSum(i);
	}
	S.StartSound(null, sfxenum_t.sfx_barexp);
	ng_state = 10;
    }

    if (ng_state == 2)
    {
	if ((bcnt&3)==0)
	    S.StartSound(null,  sfxenum_t.sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!DS.playeringame[i])
		continue;

	    cnt_kills[i] += 2;

	    if (cnt_kills[i] >= (plrs[i].skills * 100) / wbs.maxkills)
		cnt_kills[i] = (plrs[i].skills * 100) / wbs.maxkills;
	    else
		stillticking = true;
	}
	
	if (!stillticking)
	{
	    S.StartSound(null,  sfxenum_t.sfx_barexp);
	    ng_state++;
	}
    }
    else if (ng_state == 4)
    {
	if ((bcnt&3)==0)
	   S.StartSound(null,  sfxenum_t.sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!DS.playeringame[i])
		continue;

	    cnt_items[i] += 2;
	    if (cnt_items[i] >= (plrs[i].sitems * 100) / wbs.maxitems)
		cnt_items[i] = (plrs[i].sitems * 100) / wbs.maxitems;
	    else
		stillticking = true;
	}
	if (!stillticking)
	{
	   S.StartSound(null,  sfxenum_t.sfx_barexp);
	    ng_state++;
	}
    }
    else if (ng_state == 6)
    {
	if ((bcnt&3)==0)
	   S.StartSound(null,  sfxenum_t.sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!DS.playeringame[i])
		continue;

	    cnt_secret[i] += 2;

	    if (cnt_secret[i] >= (plrs[i].ssecret * 100) / wbs.maxsecret)
		cnt_secret[i] = (plrs[i].ssecret * 100) / wbs.maxsecret;
	    else
		stillticking = true;
	}
	
	if (!stillticking)
	{
	    S.StartSound(null, sfxenum_t.sfx_barexp);
	    ng_state += 1 + 2*~dofrags;
	}
    }
    else if (ng_state == 8)
    {
	if ((bcnt&3)==0)
	  S.StartSound(null,  sfxenum_t.sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!DS.playeringame[i])
		continue;

	    cnt_frags[i] += 1;

	    if (cnt_frags[i] >= (fsum = fragSum(i)))
		cnt_frags[i] = fsum;
	    else
		stillticking = true;
	}
	
	if (!stillticking)
	{
	    S.StartSound(null,  sfxenum_t.sfx_pldeth);
	    ng_state++;
	}
    }
    else if (ng_state == 10)
    {
	if (acceleratestage!=0)
	{
	   S.StartSound(null,  sfxenum_t.sfx_sgcock);
	    if ( DS.isCommercial() )
		initNoState();
	    else
		initShowNextLoc();
	}
    }
    else if ((ng_state & 1)!=0)
    {
	if (--cnt_pause==0)
	{
	    ng_state++;
	    cnt_pause = TICRATE;
	}
    }
}

protected void drawNetgameStats()
{
    int		i;
    int		x;
    int		y;
    int		pwidth = percent.width;

    slamBackground();
    
    // draw animated background
    drawAnimatedBack(); 

    drawLF();

    // draw stat titles (top line)
    V.DrawPatch(NG_STATSX()+NG_SPACINGX-kills.width,
		NG_STATSY, FB, kills);

    V.DrawPatch(NG_STATSX()+2*NG_SPACINGX-items.width,
		NG_STATSY, FB, items);

    V.DrawPatch(NG_STATSX()+3*NG_SPACINGX-secret.width,
		NG_STATSY, FB, secret);
    
    if (dofrags!=0)
	V.DrawPatch(NG_STATSX()+4*NG_SPACINGX-frags.width,
		    NG_STATSY, FB, frags);

    // draw stats
    y = NG_STATSY + kills.height;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (!DS.playeringame[i])
	    continue;

	x = NG_STATSX();
	V.DrawPatch(x-p[i].width, y, FB, p[i]);

	if (i == me)
	    V.DrawPatch(x-p[i].width, y, FB, star);

	x += NG_SPACINGX;
	drawPercent(x-pwidth, y+10, cnt_kills[i]);	x += NG_SPACINGX;
	drawPercent(x-pwidth, y+10, cnt_items[i]);	x += NG_SPACINGX;
	drawPercent(x-pwidth, y+10, cnt_secret[i]);	x += NG_SPACINGX;

	if (dofrags!=0)
	    drawNum(x, y+10, cnt_frags[i], -1);

	y += WI_SPACINGY;
    }

}


 int	sp_state;

 protected void initStats()
{
    state = endlevel_state.StatCount;
    acceleratestage = 0;
    sp_state = 1;
    cnt_kills[0] = cnt_items[0] = cnt_secret[0] = -1;
    cnt_time = cnt_par = -1;
    cnt_pause = TICRATE;

    initAnimatedBack();
}

protected void updateStats()
{

    updateAnimatedBack();
    
    //System.out.println("SP_State "+sp_state);

    if ((acceleratestage !=0) && sp_state != COUNT_DONE)
    {
	acceleratestage = 0;
	cnt_kills[0] = (plrs[me].skills * 100) / wbs.maxkills;
	cnt_items[0] = (plrs[me].sitems * 100) / wbs.maxitems;
	cnt_secret[0] = (plrs[me].ssecret * 100) / wbs.maxsecret;
	cnt_time = plrs[me].stime / TICRATE;
	cnt_par = wbs.partime / TICRATE;
	S.StartSound(null,  sfxenum_t.sfx_barexp);
	sp_state = 10;
    }

    if (sp_state == COUNT_KILLS)
    {
	cnt_kills[0] += 2;

	if ((bcnt&3)==0)
	     S.StartSound(null,  sfxenum_t.sfx_pistol);

	if (cnt_kills[0] >= (plrs[me].skills * 100) / wbs.maxkills)
	{
	    cnt_kills[0] = (plrs[me].skills * 100) / wbs.maxkills;
	    S.StartSound(null, sfxenum_t.sfx_barexp);
	    sp_state++;
	}
    }
    else if (sp_state == COUNT_ITEMS)
    {
	cnt_items[0] += 2;

	if ((bcnt&3)==0)
	     S.StartSound(null, sfxenum_t.sfx_pistol);

	if (cnt_items[0] >= (plrs[me].sitems * 100) / wbs.maxitems)
	{
	    cnt_items[0] = (plrs[me].sitems * 100) / wbs.maxitems;
	     S.StartSound(null, sfxenum_t.sfx_barexp);
	    sp_state++;
	}
    }
    else if (sp_state == COUNT_SECRETS)
    {
	cnt_secret[0] += 2;

	if ((bcnt&3)==0)
	     S.StartSound(null, sfxenum_t.sfx_pistol);

	if (cnt_secret[0] >= (plrs[me].ssecret * 100) / wbs.maxsecret)
	{
	    cnt_secret[0] = (plrs[me].ssecret * 100) / wbs.maxsecret;
	     S.StartSound(null, sfxenum_t.sfx_barexp);
	    sp_state++;
	}
    }

    else if (sp_state == COUNT_TIME)
    {
	if ((bcnt&3)==0)
	    S.StartSound(null, sfxenum_t.sfx_pistol);

	cnt_time += 3;

	if (cnt_time >= plrs[me].stime / TICRATE)
	    cnt_time = plrs[me].stime / TICRATE;

	cnt_par += 3;

	if (cnt_par >= wbs.partime / TICRATE)
	{
	    cnt_par = wbs.partime / TICRATE;

	    if (cnt_time >= plrs[me].stime / TICRATE)
	    {
		 S.StartSound(null, sfxenum_t.sfx_barexp);
		sp_state++;
	    }
	}
    }
    else if (sp_state == COUNT_DONE)
    {
	if (acceleratestage!=0)
	{
	     S.StartSound(null, sfxenum_t.sfx_sgcock);

	    if (DS.isCommercial())
		initNoState();
	    else
		initShowNextLoc();
	}
    }
    // Non-drawing, pausing state. Any odd value introduces a 35 tic pause.
    else if ((sp_state & 1)>0)
    {
	if (--cnt_pause==0)
	{
	    sp_state++;
	    cnt_pause = TICRATE;
	}
    }

}

protected void drawStats()
{
    // line height
    int lh;	

    lh = (3*num[0].height*BEST_Y_SCALE)/2;

    slamBackground();

    // draw animated background
    drawAnimatedBack();
    
    drawLF();

    V.DrawScaledPatch(SP_STATSX, SP_STATSY, V_NOSCALESTART|FB,vs, kills);
    drawPercent(SCREENWIDTH - SP_STATSX, SP_STATSY, cnt_kills[0]);

    V.DrawScaledPatch(SP_STATSX, SP_STATSY+lh, V_NOSCALESTART|FB,vs, items);
    drawPercent(SCREENWIDTH - SP_STATSX, SP_STATSY+lh, cnt_items[0]);

    V.DrawScaledPatch(SP_STATSX, SP_STATSY+2*lh, V_NOSCALESTART|FB,vs, sp_secret);
    drawPercent(SCREENWIDTH - SP_STATSX, SP_STATSY+2*lh, cnt_secret[0]);

    V.DrawScaledPatch(SP_TIMEX, SP_TIMEY, V_NOSCALESTART|FB,vs, time);
    drawTime(SCREENWIDTH/2 - SP_TIMEX, SP_TIMEY, cnt_time);

    if (wbs.epsd < 3)
    {
	V.DrawScaledPatch(SCREENWIDTH/2 + SP_TIMEX, SP_TIMEY, V_NOSCALESTART|FB,vs, par);
	drawTime(SCREENWIDTH - SP_TIMEX, SP_TIMEY, cnt_par);
    }

}

protected void checkForAccelerate()
{

    // check for button presses to skip delays
    for (int i=0 ; i<MAXPLAYERS ; i++)
    {
        player_t player = DS.players[i];
	if (DS.playeringame[i])
	{
	    if ((player.cmd.buttons & BT_ATTACK)!=0)
	    {
		if (!player.attackdown)
		    acceleratestage = 1;
		player.attackdown = true;
	    }
	    else
		player.attackdown = false;
	    if ((player.cmd.buttons & BT_USE)!=0)
	    {
		if (!player.usedown)
		    acceleratestage = 1;
		player.usedown = true;
	    }
	    else
		player.usedown = false;
	}
    }
}



/** Updates stuff each tick */
public void Ticker()
{
    // counter for general background animation
    bcnt++;  

    if (bcnt == 1)
    {
	// intermission music
  	if ( DS.isCommercial())
  	
  	    S.ChangeMusic(musicenum_t.mus_dm2int.ordinal(), true);
	else
	    S.ChangeMusic(musicenum_t.mus_inter.ordinal(), true); 
    }

    checkForAccelerate();
//System.out.println("State "+state);
    
    switch (state)
    {
      case StatCount:
	if (DS.deathmatch) updateDeathmatchStats();
	else if (DS.netgame) updateNetgameStats();
	else updateStats();
	break;
	
      case ShowNextLoc:
	updateShowNextLoc();
	break;
	
      case NoState:
	updateNoState();
	 break;
      case JustShutOff:
    	  // We just finished, and graphics have been unloaded.
    	  // If we don't consume a tick in this way, Doom
    	  // will try to draw unloaded graphics.
    	  state=endlevel_state.NoState;
    	  break;
    }

}

protected void loadData()
{
    int		i;
    int		j;
    String	name;
    anim_t	a;

    if (DS.isCommercial())
	name= "INTERPIC";
    else 
	//sprintf(name, "WIMAP%d", wbs.epsd);
        name=("WIMAP"+Integer.toString(wbs.epsd));
    
    // MAES: For Ultimate Doom
    if ( DS.isRetail())
    {
      if (wbs.epsd == 3)
          name= "INTERPIC";
    }

    // background - draw it to screen 1 for quick redraw.
    bg = (patch_t) W.CacheLumpName(name, PU_CACHE,patch_t.class);    
    V.DrawPatchSolidScaled(0, 0, BEST_X_SCALE, BEST_Y_SCALE,1, bg);


    // UNUSED unsigned char *pic = screens[1];
    // if (gamemode == commercial)
    // {
    // darken the background image
    // while (pic != screens[1] + SCREENHEIGHT*SCREENWIDTH)
    // {
    //   *pic = colormaps[256*25 + *pic];
    //   pic++;
    // }
    //}

    if (DS.isCommercial())
    {
	NUMCMAPS = 32;								
//	lnames = (patch_t **) Z_Malloc(sizeof(patch_t*) * NUMCMAPS,
//				       PU_, 0);
	
	lnames=new patch_t[NUMCMAPS];
    String xxx=new String("CWILV%02d");
    //String buffer;
	for (i=0 ; i<NUMCMAPS ; i++)
	{								
	    name=String.format(xxx,i);
	    lnames[i] = (patch_t) W.CacheLumpName(name, PU_STATIC,patch_t.class);
	}					
    }
    else
    {
	lnames = new patch_t[NUMMAPS];
	String xxx=new String("WILV%d%d");

	for (i=0 ; i<NUMMAPS ; i++)
	{
	    name=String.format(xxx,wbs.epsd, i);
	    lnames[i] = (patch_t) W.CacheLumpName(name, PU_STATIC,patch_t.class);
	}

	// you are here
	yah[0] = (patch_t) W.CacheLumpName("WIURH0", PU_STATIC,patch_t.class);

	// you are here (alt.)
	yah[1] = (patch_t) W.CacheLumpName("WIURH1", PU_STATIC,patch_t.class);

	// splat
	splat = (patch_t) W.CacheLumpName("WISPLAT", PU_STATIC,patch_t.class); 
	
	if (wbs.epsd < 3)
	{
	    xxx=new String("WIA%d%02d%02d");
	    //xxx=new PrintfFormat("WIA%d%.2d%.2d");
	    for (j=0;j<NUMANIMS[wbs.epsd];j++)
	    {
		a = anims[wbs.epsd][j];
		for (i=0;i<a.nanims;i++)
		{
		    // MONDO HACK!
		    if (wbs.epsd != 1 || j != 8) 
		    {
			// animations
			name=String.format(xxx,wbs.epsd, j, i);  
			a.p[i] = (patch_t)W.CacheLumpName(name, PU_STATIC,patch_t.class);
		    }
		    else
		    {
			// HACK ALERT!
			a.p[i] = anims[1][4].p[i]; 
		    }
		}
	    }
	}
    }

    // More hacks on minus sign.
    wiminus = (patch_t)W.CacheLumpName("WIMINUS", PU_STATIC,patch_t.class); 

    String xxx=new String("WINUM%d");
    for (i=0;i<10;i++)
    {
	 // numbers 0-9
	name=String.format(xxx,i);     
	num[i] = (patch_t)W.CacheLumpName(name, PU_STATIC,patch_t.class);
    }

    // percent sign
    percent = (patch_t)W.CacheLumpName("WIPCNT", PU_STATIC,patch_t.class);

    // "finished"
    finished = (patch_t)W.CacheLumpName("WIF", PU_STATIC,patch_t.class);

    // "entering"
    entering = (patch_t)W.CacheLumpName("WIENTER", PU_STATIC,patch_t.class);

    // "kills"
    kills = (patch_t)W.CacheLumpName("WIOSTK", PU_STATIC,patch_t.class);   

    // "scrt"
    secret = (patch_t)W.CacheLumpName("WIOSTS", PU_STATIC,patch_t.class);

     // "secret"
    sp_secret =(patch_t)W.CacheLumpName("WISCRT2", PU_STATIC,patch_t.class);

    // Yuck. 
    if (DS.language==Language_t.french)
    {
	// "items"
	if (DS.netgame && !DS.deathmatch)
	    items = (patch_t)W.CacheLumpName("WIOBJ", PU_STATIC,patch_t.class);    
  	else
	    items = (patch_t)W.CacheLumpName("WIOSTI", PU_STATIC,patch_t.class);
    } else
	items = (patch_t)W.CacheLumpName("WIOSTI", PU_STATIC,patch_t.class);

    // "frgs"
    frags = (patch_t)W.CacheLumpName("WIFRGS", PU_STATIC,patch_t.class);    

    // ":"
    colon = (patch_t)W.CacheLumpName("WICOLON", PU_STATIC,patch_t.class); 

    // "time"
    time = (patch_t)W.CacheLumpName("WITIME", PU_STATIC,patch_t.class);  

    // "sucks"
    sucks = (patch_t)W.CacheLumpName("WISUCKS", PU_STATIC,patch_t.class);  

    // "par"
    par = (patch_t)W.CacheLumpName("WIPAR", PU_STATIC,patch_t.class);   

    // "killers" (vertical)
    killers = (patch_t)W.CacheLumpName("WIKILRS", PU_STATIC,patch_t.class);

    // "victims" (horiz)
    victims = (patch_t)W.CacheLumpName("WIVCTMS", PU_STATIC,patch_t.class);

    // "total"
    total = (patch_t)W.CacheLumpName("WIMSTT", PU_STATIC,patch_t.class);   

    // your face
    star = (patch_t)W.CacheLumpName("STFST01", PU_STATIC,patch_t.class);

    // dead face
    bstar = (patch_t)W.CacheLumpName("STFDEAD0", PU_STATIC,patch_t.class);    

    String xx1=new String("STPB%d");
    String xx2=new String("WIBP%d");
    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	// "1,2,3,4"
    name= String.format(xx1,i);
	p[i] = (patch_t)W.CacheLumpName(name, PU_STATIC,patch_t.class);;

	// "1,2,3,4"
	name= String.format(xx2,i+1);
	bp[i] = (patch_t)W.CacheLumpName(name, PU_STATIC,patch_t.class);;
    }

}

/*

public void WI_unloadData()
{
    int		i;
    int		j;

    W.UnlockLumpNum(wiminus, PU_CACHE);

    for (i=0 ; i<10 ; i++)
	W.UnlockLumpNum(num[i], PU_CACHE);
    
    if (gamemode == commercial)
    {
  	for (i=0 ; i<NUMCMAPS ; i++)
	    W.UnlockLumpNum(lnames[i], PU_CACHE);
    }
    else
    {
	W.UnlockLumpNum(yah[0], PU_CACHE);
	W.UnlockLumpNum(yah[1], PU_CACHE);

	W.UnlockLumpNum(splat, PU_CACHE);

	for (i=0 ; i<NUMMAPS ; i++)
	    W.UnlockLumpNum(lnames[i], PU_CACHE);
	
	if (wbs.epsd < 3)
	{
	    for (j=0;j<NUMANIMS[wbs.epsd];j++)
	    {
		if (wbs.epsd != 1 || j != 8)
		    for (i=0;i<anims[wbs.epsd][j].nanims;i++)
			W.UnlockLumpNum(anims[wbs.epsd][j].p[i], PU_CACHE);
	    }
	}
    }
    
    Z_Free(lnames);

    W.UnlockLumpNum(percent, PU_CACHE);
    W.UnlockLumpNum(colon, PU_CACHE);
    W.UnlockLumpNum(finished, PU_CACHE);
    W.UnlockLumpNum(entering, PU_CACHE);
    W.UnlockLumpNum(kills, PU_CACHE);
    W.UnlockLumpNum(secret, PU_CACHE);
    W.UnlockLumpNum(sp_secret, PU_CACHE);
    W.UnlockLumpNum(items, PU_CACHE);
    W.UnlockLumpNum(frags, PU_CACHE);
    W.UnlockLumpNum(time, PU_CACHE);
    W.UnlockLumpNum(sucks, PU_CACHE);
    W.UnlockLumpNum(par, PU_CACHE);

    W.UnlockLumpNum(victims, PU_CACHE);
    W.UnlockLumpNum(killers, PU_CACHE);
    W.UnlockLumpNum(total, PU_CACHE);
    //  W.UnlockLumpNum(star, PU_CACHE);
    //  W.UnlockLumpNum(bstar, PU_CACHE);
    
    for (i=0 ; i<MAXPLAYERS ; i++)
	W.UnlockLumpNum(p[i], PU_CACHE);

    for (i=0 ; i<MAXPLAYERS ; i++)
	W.UnlockLumpNum(bp[i], PU_CACHE);
}
*/


public void Drawer ()
{
    switch (state)
    {
      case StatCount:
	if (DS.deathmatch)
	    drawDeathmatchStats();
	else if (DS.netgame)
	    drawNetgameStats();
	else
	    drawStats();
	break;
	
      case ShowNextLoc:
	drawShowNextLoc();
	break;
	
      case NoState:
	drawNoState();
	break;
    }
}


protected void initVariables(wbstartstruct_t wbstartstruct)
{

    wbs = wbstartstruct.clone();

if (RANGECHECKING){
    if (!DS.isCommercial())
    {
      if ( DS.isRetail())
	RNGCHECK(wbs.epsd, 0, 3);
      else
	RNGCHECK(wbs.epsd, 0, 2);
    }
    else
    {
	RNGCHECK(wbs.last, 0, 8);
	RNGCHECK(wbs.next, 0, 8);
    }
    RNGCHECK(wbs.pnum, 0, MAXPLAYERS);
    RNGCHECK(wbs.pnum, 0, MAXPLAYERS);
}

    acceleratestage = 0;
    cnt = bcnt = 0;
    firstrefresh = 1;
    me = wbs.pnum;
    plrs = wbs.plyr.clone();

    if (wbs.maxkills==0)
	wbs.maxkills = 1;

    if (wbs.maxitems==0)
	wbs.maxitems = 1;

    if (wbs.maxsecret==0)
	wbs.maxsecret = 1;

    // Sanity check for Ultimate.
    if ( !DS.isRetail())
      if (wbs.epsd > 2)
	wbs.epsd -= 3;
}

public void Start(wbstartstruct_t wbstartstruct)
{

    initVariables(wbstartstruct);
    loadData();

    if (DS.deathmatch)
	initDeathmatchStats();
    else if (DS.netgame)
	initNetgameStats();
    else
	initStats();
}


protected int NG_STATSX(){
    return 32 + star.width/2 + 32*~dofrags;
}

protected static boolean RNGCHECK(int what, int min, int max){
    return (what>=min && what <=max)?true:false;
}

@Override
public void updateStatus(DoomStatus DS) {
    this.DG=DS.DG;
    this.DS=DS.DM;
    this.V=DS.V;
    this.W=DS.W;
    this.RND=DS.RND;
    this.S=DS.S;
    this.ST=DS.ST;

    
}


//////////////////////////// VIDEO SCALE STUFF ////////////////////////////////

protected int SCREENWIDTH;
protected int SCREENHEIGHT;
protected IVideoScale vs;
protected int BEST_X_SCALE;
protected int BEST_Y_SCALE;


@Override
public void setVideoScale(IVideoScale vs) {
    this.vs=vs;
}

@Override
public void initScaling() {
    this.SCREENHEIGHT=vs.getScreenHeight();
    this.SCREENWIDTH=vs.getScreenWidth();
    this.BEST_X_SCALE=vs.getScalingX();
    this.BEST_Y_SCALE=vs.getScalingY();
    
    // Pre-scale stuff.
    SP_STATSX       =50*vs.getSafeScaling();
    SP_STATSY      = 50*vs.getSafeScaling();;

    SP_TIMEX      =  16*vs.getSafeScaling();
    SP_TIMEY      =  (SCREENHEIGHT-ST.getHeight());   
}

}
package f;

import static data.Defines.HU_FONTSIZE;
import static data.Defines.HU_FONTSTART;
import static data.Defines.PU_CACHE;
import static data.Defines.PU_LEVEL;
import static data.Defines.FF_FRAMEMASK;
import static data.Limits.MAXPLAYERS;
import static data.info.mobjinfo;
import static data.info.states;
import static doom.englsh.*;
import static utils.C2JUtils.*;
import hu.HU;
import i.DoomStatusAware;

import java.io.IOException;
import java.util.ArrayList;

import rr.ISpriteManager;
import rr.flat_t;
import rr.patch_t;
import rr.spritedef_t;
import rr.spriteframe_t;
import s.IDoomSound;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import v.IVideoScale;
import v.IVideoScaleAware;
import w.IWadLoader;
import data.mobjtype_t;
import data.sounds.musicenum_t;
import data.state_t;
import defines.*;
import data.sounds.sfxenum_t;
import doom.DoomStatus;
import doom.IDoomGame;
import doom.event_t;
import doom.evtype_t;
import doom.gameaction_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: Finale.java,v 1.28 2012/09/24 17:16:23 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// DESCRIPTION:
//  Game completion, final screen animation.
//
//-----------------------------------------------------------------------------

public class Finale<T> implements DoomStatusAware, IVideoScaleAware {

	public static final String rcsid = "$Id: Finale.java,v 1.28 2012/09/24 17:16:23 velktron Exp $";

	IDoomGame DG;
	DoomStatus<?,?> DS;
	DoomVideoRenderer<T,?> V;
	IDoomSound S;
	HU HU;
	IWadLoader W;
	ISpriteManager SM;

	int finalestage;

	int finalecount;

	private static int TEXTSPEED = 3;
	private static int TEXTWAIT = 250;

	String[] doom_text = { E1TEXT, E2TEXT, E3TEXT, E4TEXT };

	String[] doom2_text = { C1TEXT, C2TEXT, C3TEXT, C4TEXT, C5TEXT, C6TEXT };

	String[] plut_text = { P1TEXT, P2TEXT, P3TEXT, P4TEXT, P5TEXT, P6TEXT };
	String[] tnt_text = { T1TEXT, T2TEXT, T3TEXT, T4TEXT, T5TEXT, T6TEXT };

	String finaletext;
	String finaleflat;

	/**
	 * F_StartFinale
	 */
	public void StartFinale() {
		DG.setGameAction(gameaction_t.ga_nothing);
		DS.gamestate = gamestate_t.GS_FINALE;
		DS.viewactive = false;
		DS.automapactive = false;
		String[] texts = null;

		// Pick proper text.
		switch (DS.getGameMode()) {
		case commercial:
		case pack_xbla:
			texts = doom2_text;
			break;
		case pack_tnt:
			texts = tnt_text;
			break;
		case pack_plut:
			texts = plut_text;
			break;
		case shareware:
		case registered:
		case retail:
			texts = doom_text;
			break;
		}

		// Okay - IWAD dependend stuff.
		// This has been changed severly, and
		// some stuff might have changed in the process.
		switch (DS.getGameMode()) {

		// DOOM 1 - E1, E3 or E4, but each nine missions
		case shareware:
		case registered:
		case retail: {
			S.ChangeMusic(musicenum_t.mus_victor, true);

			switch (DS.gameepisode) {
			case 1:
				finaleflat = "FLOOR4_8";
				finaletext = texts[0];
				break;
			case 2:
				finaleflat = "SFLR6_1";
				finaletext = texts[1];
				break;
			case 3:
				finaleflat = "MFLR8_4";
				finaletext = texts[2];
				break;
			case 4:
				finaleflat = "MFLR8_3";
				finaletext = texts[3];
				break;
			default:
				// Ouch.
				break;
			}
			break;
		}

			// DOOM II and missions packs with E1, M34
		case commercial:
		case pack_xbla:
		case pack_tnt:
		case pack_plut: {
			S.ChangeMusic(musicenum_t.mus_read_m, true);

			switch (DS.gamemap) {
			case 6:
				finaleflat = "SLIME16";
				finaletext = texts[0];
				break;
			case 11:
				finaleflat = "RROCK14";
				finaletext = texts[1];
				break;
			case 20:
				finaleflat = "RROCK07";
				finaleflat = texts[2];
				break;
			case 30:
				finaleflat = "RROCK17";
				finaletext = texts[3];
				break;
			case 15:
				finaleflat = "RROCK13";
				finaletext = texts[4];
				break;
			case 31:
				finaleflat = "RROCK19";
				finaletext = texts[5];
				break;
			default:
				// Ouch.
				break;
			}
			break;
		}

			// Indeterminate.
		default:
			S.ChangeMusic(musicenum_t.mus_read_m, true);
			finaleflat = "F_SKY1"; // Not used anywhere else.
			finaletext = doom2_text[1];
			; // FIXME - other text, music?
			break;
		}

		finalestage = 0;
		finalecount = 0;

	}

	public boolean Responder(event_t event) {
		if (finalestage == 2)
			return CastResponder(event);

		return false;
	}

	/**
	 * F_Ticker
	 */

	public void Ticker() {
		int i;

		// check for skipping
		if ((DS.isCommercial()) && (finalecount > 50)) {
			// go on to the next level
			for (i = 0; i < MAXPLAYERS; i++)
				if (DS.players[i].cmd.buttons != 0)
					break;

			if (i < MAXPLAYERS) {
				if (DS.gamemap == 30)
					StartCast();
				else
					DG.setGameAction(gameaction_t.ga_worlddone);
			}
		}

		// advance animation
		finalecount++;

		if (finalestage == 2) {
			CastTicker();
			return;
		}

		if (DS.isCommercial())
			return;
		// MAES: this is when we can transition to bunny.
		if ((finalestage == 0)
				&& finalecount > finaletext.length() * TEXTSPEED + TEXTWAIT) {
			finalecount = 0;
			finalestage = 1;
			DS.wipegamestate = gamestate_t.GS_MINUS_ONE; // force a wipe
			if (DS.gameepisode == 3)

				S.StartMusic(musicenum_t.mus_bunny);
		}
	}

	//
	// F_TextWrite
	//

	// #include "hu_stuff.h"
	patch_t[] hu_font;

	@SuppressWarnings("unchecked")
    public void TextWrite() {
		T src;
		//V dest;
		int w;
		int count;
		char[] ch;
		int c;
		int cx;
		int cy;

		// erase the entire screen to a tiled background
		src = (T)((flat_t) W.CacheLumpName(finaleflat, PU_CACHE, flat_t.class)).data;
		//dest = V.getScreen(DoomVideoRenderer.SCREEN_FG);

		for (int y = 0; y < SCREENHEIGHT; y+=64) {
			
			int y_maxdraw=Math.min(SCREENHEIGHT-y, 64);
			
			// Draw whole blocks.
			for (int x = 0; x < SCREENWIDTH; x+=64) {
				int x_maxdraw=Math.min(SCREENWIDTH-x, 64);
				V.DrawBlock(x, y, DoomVideoRenderer.SCREEN_FG, x_maxdraw,y_maxdraw,
						src);
			}
		}

		V.MarkRect(0, 0, SCREENWIDTH, SCREENHEIGHT);

		// draw some of the text onto the screen
		cx = 10;
		cy = 10;
		ch = finaletext.toCharArray();

		count = (finalecount - 10) / TEXTSPEED;
		if (count < 0)
			count = 0;

		// _D_: added min between count and ch.length, so that the text is not
		// written all at once
		for (int i = 0; i < Math.min(ch.length, count); i++)

		{
			c = ch[i];
			if (c == 0)
				break;
			if (c == '\n') {
				cx = 10;
				cy += 11;
				continue;
			}

			c = Character.toUpperCase(c) - HU_FONTSTART;
			if (c < 0 || c > HU_FONTSIZE) {
				cx += 4;
				continue;
			}

			w = hu_font[c].width;
			if (cx + w > SCREENWIDTH)
				break;
			V.DrawScaledPatch(cx, cy, 0, vs, hu_font[c]);
			cx += w;
		}

	}

	private final castinfo_t[] castorder;

	int castnum;
	int casttics;
	state_t caststate;
	boolean castdeath;
	int castframes;
	int castonmelee;
	boolean castattacking;

	//
	// F_StartCast
	//
	// extern gamestate_t wipegamestate;

	public void StartCast() {
		DS.wipegamestate = gamestate_t.GS_MINUS_ONE; // force a screen wipe
		castnum = 0;
		caststate = states[mobjinfo[castorder[castnum].type.ordinal()].seestate
				.ordinal()];
		casttics = (int) caststate.tics;
		castdeath = false;
		finalestage = 2;
		castframes = 0;
		castonmelee = 0;
		castattacking = false;
		S.ChangeMusic(musicenum_t.mus_evil, true);
	}

	//
	// F_CastTicker
	//
	public void CastTicker() {
		statenum_t st;
		sfxenum_t sfx;

		if (--casttics > 0)
			return; // not time to change state yet

		if (caststate.tics == -1 || caststate.nextstate == statenum_t.S_NULL
				|| caststate.nextstate == null) {
			// switch from deathstate to next monster
			castnum++;
			castdeath = false;
			if (castorder[castnum].name == null)
				castnum = 0;
			if (mobjinfo[castorder[castnum].type.ordinal()].seesound.ordinal() != 0)
				;
			S.StartSound(null,
					mobjinfo[castorder[castnum].type.ordinal()].seesound);
			caststate = states[mobjinfo[castorder[castnum].type.ordinal()].seestate
					.ordinal()];
			castframes = 0;
		} else {
			// just advance to next state in animation
			if (caststate == states[statenum_t.S_PLAY_ATK1.ordinal()]) {
				stopattack(); // Oh, gross hack!
				afterstopattack();
				return; // bye ...
			}

			st = caststate.nextstate;
			caststate = states[st.ordinal()];
			castframes++;

			// sound hacks....
			switch (st) {
			case S_PLAY_ATK1:
				sfx = sfxenum_t.sfx_dshtgn;
				break;
			case S_POSS_ATK2:
				sfx = sfxenum_t.sfx_pistol;
				break;
			case S_SPOS_ATK2:
				sfx = sfxenum_t.sfx_shotgn;
				break;
			case S_VILE_ATK2:
				sfx = sfxenum_t.sfx_vilatk;
				break;
			case S_SKEL_FIST2:
				sfx = sfxenum_t.sfx_skeswg;
				break;
			case S_SKEL_FIST4:
				sfx = sfxenum_t.sfx_skepch;
				break;
			case S_SKEL_MISS2:
				sfx = sfxenum_t.sfx_skeatk;
				break;
			case S_FATT_ATK8:
			case S_FATT_ATK5:
			case S_FATT_ATK2:
				sfx = sfxenum_t.sfx_firsht;
				break;
			case S_CPOS_ATK2:
			case S_CPOS_ATK3:
			case S_CPOS_ATK4:
				sfx = sfxenum_t.sfx_shotgn;
				break;
			case S_TROO_ATK3:
				sfx = sfxenum_t.sfx_claw;
				break;
			case S_SARG_ATK2:
				sfx = sfxenum_t.sfx_sgtatk;
				break;
			case S_BOSS_ATK2:
			case S_BOS2_ATK2:
			case S_HEAD_ATK2:
				sfx = sfxenum_t.sfx_firsht;
				break;
			case S_SKULL_ATK2:
				sfx = sfxenum_t.sfx_sklatk;
				break;
			case S_SPID_ATK2:
			case S_SPID_ATK3:
				sfx = sfxenum_t.sfx_shotgn;
				break;
			case S_BSPI_ATK2:
				sfx = sfxenum_t.sfx_plasma;
				break;
			case S_CYBER_ATK2:
			case S_CYBER_ATK4:
			case S_CYBER_ATK6:
				sfx = sfxenum_t.sfx_rlaunc;
				break;
			case S_PAIN_ATK3:
				sfx = sfxenum_t.sfx_sklatk;
				break;
			default:
				sfx = null;
				break;
			}

			if (sfx != null) // Fixed mute thanks to _D_ 8/6/2011
				S.StartSound(null, sfx);
		}

		if (castframes == 12) {
			// go into attack frame
			castattacking = true;
			if (castonmelee != 0)
				caststate = states[mobjinfo[castorder[castnum].type.ordinal()].meleestate
						.ordinal()];
			else
				caststate = states[mobjinfo[castorder[castnum].type.ordinal()].missilestate
						.ordinal()];
			castonmelee ^= 1;
			if (caststate == states[statenum_t.S_NULL.ordinal()]) {
				if (castonmelee != 0)
					caststate = states[mobjinfo[castorder[castnum].type
							.ordinal()].meleestate.ordinal()];
				else
					caststate = states[mobjinfo[castorder[castnum].type
							.ordinal()].missilestate.ordinal()];
			}
		}

		if (castattacking) {
			if (castframes == 24
					|| caststate == states[mobjinfo[castorder[castnum].type
							.ordinal()].seestate.ordinal()])

				stopattack();
		}

		afterstopattack();
	}

	protected void stopattack() {
		castattacking = false;
		castframes = 0;
		caststate = states[mobjinfo[castorder[castnum].type.ordinal()].seestate
				.ordinal()];
	}

	protected void afterstopattack() {
		casttics = (int) caststate.tics;
		if (casttics == -1)
			casttics = 15;
	}

	/**
	 * CastResponder
	 */

	public boolean CastResponder(event_t ev) {
		if (ev.type != evtype_t.ev_keydown)
			return false;

		if (castdeath)
			return true; // already in dying frames

		// go into death frame
		castdeath = true;
		caststate = states[mobjinfo[castorder[castnum].type.ordinal()].deathstate
				.ordinal()];
		casttics = (int) caststate.tics;
		castframes = 0;
		castattacking = false;
		if (mobjinfo[castorder[castnum].type.ordinal()].deathsound != null)
			S.StartSound(null,
					mobjinfo[castorder[castnum].type.ordinal()].deathsound);

		return true;
	}

	public void CastPrint(String text) {
		char[] ch;
		int c;
		int cx;
		int w;
		int width;

		// find width
		ch = text.toCharArray();
		width = 0;

		for (int i = 0; i < ch.length; i++) {
			c = ch[i];
			if (c == 0)
				break;
			c = Character.toUpperCase(c) - HU_FONTSTART;
			if (c < 0 || c > HU_FONTSIZE) {
				width += 4;
				continue;
			}

			w = hu_font[c].width;
			width += w;
		}

		// draw it
		cx = 160 - width / 2;
		// ch = text;
		for (int i = 0; i < ch.length; i++) {
			c = ch[i];
			if (c == 0)
				break;
			c = Character.toUpperCase(c) - HU_FONTSTART;
			if (c < 0 || c > HU_FONTSIZE) {
				cx += 4;
				continue;
			}

			w = hu_font[c].width;
			V.DrawScaledPatch(cx, 180, 0, vs, hu_font[c]);
			cx += w;
		}

	}

	/**
	 * F_CastDrawer
	 * 
	 * @throws IOException
	 */

	// public void V_DrawPatchFlipped (int x, int y, int scrn, patch_t patch);

	public void CastDrawer() {
		spritedef_t sprdef;
		spriteframe_t sprframe;
		int lump;
		boolean flip;
		patch_t patch = null;

		// erase the entire screen to a background
		V.DrawPatchSolidScaled(0, 0, SAFE_SCALE, SAFE_SCALE, 0,
				W.CachePatchName("BOSSBACK", PU_CACHE));

		this.CastPrint(castorder[castnum].name);

		// draw the current frame in the middle of the screen
		sprdef = SM.getSprite(caststate.sprite.ordinal());
		sprframe = sprdef.spriteframes[caststate.frame & FF_FRAMEMASK];
		lump = sprframe.lump[0];
		flip = eval(sprframe.flip[0]);
		// flip=false;
		// lump=0;

		patch = W.CachePatchNum(lump + SM.getFirstSpriteLump());

		if (flip)
			V.DrawScaledPatch(160, 170, 0 | DoomVideoRenderer.V_FLIPPEDPATCH,
					vs, patch);
		else
			V.DrawScaledPatch(160, 170, 0, vs, patch);
	}

	protected int laststage;

	/**
	 * F_BunnyScroll
	 */
	public void BunnyScroll() {
		int scrolled;
		int x;
		patch_t p1;
		patch_t p2;
		String name;
		int stage;

		p1 = W.CachePatchName("PFUB2", PU_LEVEL);
		p2 = W.CachePatchName("PFUB1", PU_LEVEL);

		V.MarkRect(0, 0, SCREENWIDTH, SCREENHEIGHT);

		scrolled = 320 - (finalecount - 230) / 2;
		if (scrolled > 320)
			scrolled = 320;
		if (scrolled < 0)
			scrolled = 0;

		for (x = 0; x < 320; x++) {
			if (x + scrolled < 320)
				V.DrawPatchColScaled(x, p1, x + scrolled, vs, 0);
			else
				V.DrawPatchColScaled(x, p2, x + scrolled - 320, vs, 0);
		}

		if (finalecount < 1130)
			return;
		if (finalecount < 1180) {
			V.DrawScaledPatch((320 - 13 * 8) / 2, (320 - 8 * 8) / 2, 0, vs,
					W.CachePatchName("END0", PU_CACHE));
			laststage = 0;
			return;
		}

		stage = (finalecount - 1180) / 5;
		if (stage > 6)
			stage = 6;
		if (stage > laststage) {
			S.StartSound(null, sfxenum_t.sfx_pistol);
			laststage = stage;
		}

		name = ("END" + stage);
		V.DrawScaledPatch((320 - 13 * 8) / 2, (320 - 8 * 8) / 2, 0, vs,
				W.CachePatchName(name, PU_CACHE));
	}

	//
	// F_Drawer
	//
	public void Drawer() {
		if (finalestage == 2) {
			CastDrawer();
			return;
		}

		if (finalestage == 0)
			TextWrite();
		else {
			switch (DS.gameepisode) {
			case 1:
				if (DS.isCommercial() || DS.isRegistered())
					V.DrawPatchSolidScaled(0, 0, this.SAFE_SCALE,
							this.SAFE_SCALE, 0,
							W.CachePatchName("CREDIT", PU_CACHE));
				else
					// Fun fact: Registered/Ultimate Doom has no "HELP2" lump.
					V.DrawPatchSolidScaled(0, 0, this.SAFE_SCALE,
							this.SAFE_SCALE, 0,
							W.CachePatchName("HELP2", PU_CACHE));
				break;
			case 2:
				V.DrawPatchSolidScaled(0, 0, this.SAFE_SCALE, this.SAFE_SCALE,
						0, W.CachePatchName("VICTORY2", PU_CACHE));
				break;
			case 3:
				BunnyScroll();
				break;
			case 4:
				V.DrawPatchSolidScaled(0, 0, this.SAFE_SCALE, this.SAFE_SCALE,
						0, W.CachePatchName("ENDPIC", PU_CACHE));
				break;
			}
		}

	}

	@SuppressWarnings("unchecked")
	public Finale(DoomStatus DC) {
		this.updateStatus(DC);
		hu_font = HU.getHUFonts();

		castinfo_t shit = new castinfo_t(CC_ZOMBIE, mobjtype_t.MT_POSSESSED);

		ArrayList<castinfo_t> crap = new ArrayList<castinfo_t>();
		crap.add(new castinfo_t(CC_ZOMBIE, mobjtype_t.MT_POSSESSED));
		crap.add(new castinfo_t(CC_SHOTGUN, mobjtype_t.MT_SHOTGUY));
		crap.add(new castinfo_t(CC_HEAVY, mobjtype_t.MT_CHAINGUY));
		crap.add(new castinfo_t(CC_IMP, mobjtype_t.MT_TROOP));
		crap.add(new castinfo_t(CC_DEMON, mobjtype_t.MT_SERGEANT));
		crap.add(new castinfo_t(CC_LOST, mobjtype_t.MT_SKULL));
		crap.add(new castinfo_t(CC_CACO, mobjtype_t.MT_HEAD));
		crap.add(new castinfo_t(CC_HELL, mobjtype_t.MT_KNIGHT));
		crap.add(new castinfo_t(CC_BARON, mobjtype_t.MT_BRUISER));
		crap.add(new castinfo_t(CC_ARACH, mobjtype_t.MT_BABY));
		crap.add(new castinfo_t(CC_PAIN, mobjtype_t.MT_PAIN));
		crap.add(new castinfo_t(CC_REVEN, mobjtype_t.MT_UNDEAD));
		crap.add(new castinfo_t(CC_MANCU, mobjtype_t.MT_FATSO));
		crap.add(new castinfo_t(CC_ARCH, mobjtype_t.MT_VILE));
		crap.add(new castinfo_t(CC_SPIDER, mobjtype_t.MT_SPIDER));
		crap.add(new castinfo_t(CC_CYBER, mobjtype_t.MT_CYBORG));
		crap.add(new castinfo_t(CC_HERO, mobjtype_t.MT_PLAYER));
		crap.add(new castinfo_t(null, null));

		castorder = C2JUtils
				.createArrayOfObjects(castinfo_t.class, crap.size());
		crap.toArray(castorder);

	}

	@Override
	public void updateStatus(DoomStatus<?,?> DC) {
		this.DG = DC.DG;
		this.DS = DC.DM;
		V = (DoomVideoRenderer<T,?>) DC.V;
		S = DC.S;
		HU = DC.HU;
		W = DC.W;
		SM = DC.SM;
	}

	// //////////////////////////VIDEO SCALE STUFF
	// ////////////////////////////////

	protected int SCREENWIDTH;
	protected int SCREENHEIGHT;
	protected int SAFE_SCALE;
	protected IVideoScale vs;

	@Override
	public void setVideoScale(IVideoScale vs) {
		this.vs = vs;
	}

	@Override
	public void initScaling() {
		this.SCREENHEIGHT = vs.getScreenHeight();
		this.SCREENWIDTH = vs.getScreenWidth();
		this.SAFE_SCALE = vs.getSafeScaling();

		// Pre-scale stuff.

	}

}

// /$Log
package f;

import data.mobjtype_t;

/**
 * Final DOOM 2 animation Casting by id Software. in order of appearance
 */

public class castinfo_t {
	String name;
	mobjtype_t type;

	public castinfo_t() {

	}

	public castinfo_t(String name, mobjtype_t type) {
		this.name = name;
		this.type = type;
	}

}

package f;

public interface IWiper {

    boolean ScreenWipe(int wipeno, int x, int y, int width, int height,
            int ticks);

    boolean EndScreen(int x, int y, int width, int height);

    boolean StartScreen(int x, int y, int width, int height);

}

package f;

public class point_t {
     public point_t(int x, int y) {
        this.x=x;
        this.y=y;
    }
     public   int     x;
     public  int     y;
        
    }

package f;

import doom.DoomStatus;
import m.IRandom;
import v.DoomVideoRenderer;
import v.IVideoScale;
import v.IVideoScaleAware;
import i.DoomStatusAware;
import i.DoomVideoInterface;

public abstract class AbstractWiper<T,V> implements IWiper, DoomStatusAware, IVideoScaleAware{
    
    //
    //                           SCREEN WIPE PACKAGE
    //

    /** These don't seem to be used anywhere */
    
    public static enum wipe
    {
        // simple gradual pixel change for 8-bit only
        // MAES: this transition isn't guaranteed to always terminate
        // see Chocolate Strife develpment. Unused in Doom anyway.
        ColorXForm,
        
        // weird screen melt
        Melt,  

        NUMWIPES
    };
    
    /** when false, stop the wipe */
    protected volatile boolean  go = false;

    protected V    wipe_scr_start;
    protected V    wipe_scr_end;
    protected V    wipe_scr;
    
////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

    protected int SCREENWIDTH;
    protected int SCREENHEIGHT;
    protected int Y_SCALE;
    protected IVideoScale vs;


    @Override
    public void setVideoScale(IVideoScale vs) {
        this.vs=vs;
    }

    @Override
    public void initScaling() {
        this.SCREENHEIGHT=vs.getScreenHeight();
        this.SCREENWIDTH=vs.getScreenWidth();
        this.Y_SCALE=vs.getScalingY();

        // Pre-scale stuff.
    }

    ///////////////////// STATUS /////////////////////

    @SuppressWarnings("unchecked")
    @Override
    public void updateStatus(DoomStatus<?,?> DS){
    this.RND=DS.RND;
    this.V=(DoomVideoRenderer<T, V>) DS.V;
    this.VI=(DoomVideoInterface<V>) DS.VI;
    }
    
    IRandom RND;
    DoomVideoRenderer<T,V> V;
    DoomVideoInterface<V> VI;

    
}

package f;

import w.animenum_t;
import rr.patch_t;

//
//Animation.
//There is another anim_t used in p_spec.
//

public class anim_t {

        public anim_t(animenum_t type, int period, int nanims, point_t loc,
            int data1, int data2, patch_t[] p, int nexttic, int lastdrawn,
            int ctr, int state) {
        this.type = type;
        this.period = period;
        this.nanims = nanims;
        this.loc = loc;
        this.data1 = data1;
        this.data2 = data2;
        this.p = p;
        this.nexttic = nexttic;
        this.lastdrawn = lastdrawn;
        this.ctr = ctr;
        this.state = state;
    }
        // Partial constructor, only 4 first fields.
        public anim_t(animenum_t animAlways, int period, int nanims, point_t loc
               ) {
            this.type = animAlways;
            this.period = period;
            this.nanims = nanims;
            this.loc = loc;
        }
        
        // Partial constructor, only 5 first fields.
        public anim_t(animenum_t type, int period, int nanims, point_t loc, int data1
               ) {
            this.type = type;
            this.period = period;
            this.nanims = nanims;
            this.loc = loc;
            this.data1=data1;
        }
        
        public animenum_t  type;

        // period in tics between animations
        public int     period;

        // number of animation frames
        public int     nanims;

        // location of animation
        point_t loc;

        // ALWAYS: n/a,
        // RANDOM: period deviation (<256),
        // LEVEL: level
        public int     data1;

        // ALWAYS: n/a,
        // RANDOM: random base period,
        // LEVEL: n/a
        public int     data2; 

        // actual graphics for frames of animations
        //Maes: was pointer to array
        public patch_t[] p= new patch_t[3];

        // following must be initialized to zero before use!

        // next value of bcnt (used in conjunction with period)
        public int     nexttic;

        // last drawn animation frame
        public int     lastdrawn;

        // next frame number to animate
        public int     ctr;
        
        // used by RANDOM and LEVEL when animating
        public int     state;  

    } 

package f;

import i.DoomStatusAware;
import v.IVideoScaleAware;
import w.animenum_t;
import static data.Defines.TICRATE;

public abstract class AbstractEndLevel implements DoomStatusAware, IVideoScaleAware{
	
	//NET GAME STUFF

	public static final int NG_STATSY       =50;
	public static final int NG_SPACINGX        = 64;

	//DEATHMATCH STUFF
	public static final int DM_MATRIXX = 42;
	public static final int DM_MATRIXY =     68;

	public static final int DM_SPACINGX =    40;

	public static final int DM_TOTALSX =     269;

	public static final int DM_KILLERSX  =   10;
	public static final int DM_KILLERSY   =  100;
	public static final int DM_VICTIMSX    =     5;
	public static final int DM_VICTIMSY    = 50;

	// static point_t lnodes[NUMEPISODES][NUMMAPS] 
	final static public point_t[][] lnodes =
	{
	    // Episode 0 World Map
	    {
	    new point_t( 185, 164 ),   // location of level 0 (CJ)
	    new point_t( 148, 143 ),   // location of level 1 new point_t(CJ)
	    new point_t( 69, 122 ),    // location of level 2 new point_t(CJ)
	    new point_t( 209, 102 ),   // location of level 3 new point_t(CJ)
	    new point_t( 116, 89 ),    // location of level 4 new point_t(CJ)
	    new point_t( 166, 55 ),    // location of level 5 new point_t(CJ)
	    new point_t( 71, 56 ), // location of level 6 new point_t(CJ)
	    new point_t( 135, 29 ),    // location of level 7 new point_t(CJ)
	    new point_t( 71, 24 )  // location of level 8 new point_t(CJ)
	    },

	    // Episode 1 World Map should go here
	    {
	    new point_t( 254, 25 ),    // location of level 0 new point_t(CJ)
	    new point_t( 97, 50 ), // location of level 1 new point_t(CJ)
	    new point_t( 188, 64 ),    // location of level 2 new point_t(CJ)
	    new point_t( 128, 78 ),    // location of level 3 new point_t(CJ)
	    new point_t( 214, 92 ),    // location of level 4 new point_t(CJ)
	    new point_t( 133, 130 ),   // location of level 5 new point_t(CJ)
	    new point_t( 208, 136 ),   // location of level 6 new point_t(CJ)
	    new point_t( 148, 140 ),   // location of level 7 new point_t(CJ)
	    new point_t( 235, 158 )    // location of level 8 new point_t(CJ)
	    },

	    // Episode 2 World Map should go here
	    {
	    new point_t( 156, 168 ),   // location of level 0 new point_t(CJ)
	    new point_t( 48, 154 ),    // location of level 1 new point_t(CJ)
	    new point_t( 174, 95 ),    // location of level 2 new point_t(CJ)
	    new point_t( 265, 75 ),    // location of level 3 new point_t(CJ)
	    new point_t( 130, 48 ),    // location of level 4 new point_t(CJ)
	    new point_t( 279, 23 ),    // location of level 5 new point_t(CJ)
	    new point_t( 198, 48 ),    // location of level 6 new point_t(CJ)
	    new point_t( 140, 25 ),    // location of level 7 new point_t(CJ)
	    new point_t( 281, 136 )    // location of level 8 new point_t(CJ)
	    }

	};

	//
	//Animation locations for episode 0 (1).
	//Using patches saves a lot of space,
	//as they replace 320x200 full screen frames.
	//
	
	public static  final anim_t[] epsd0animinfo =
	{
	 new anim_t(animenum_t.ANIM_ALWAYS, TICRATE/3, 3, new point_t( 224, 104 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 184, 160 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 112, 136 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 72, 112 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3, new point_t( 88, 96 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 64, 48 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 192, 40 ) ),
	  new anim_t(animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 136, 16 ) ),
	  new anim_t(animenum_t. ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 80, 16 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 64, 24 ) )
	};

	public static final anim_t[] epsd1animinfo =
	{
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t( 128, 136 ), 1 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t( 128, 136 ), 2 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t( 128, 136 ), 3 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1, new point_t( 128, 136 ), 4 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t(128, 136 ), 5 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t( 128, 136 ), 6 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t( 128, 136 ), 7 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 3, new point_t( 192, 144 ), 8 ),
	  new anim_t( animenum_t.ANIM_LEVEL, TICRATE/3, 1,  new point_t( 128, 136 ), 8 )
	};

	public static final anim_t[] epsd2animinfo =
	{
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 104, 168 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 40, 136 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t( 160, 96 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3,  new point_t(104, 80 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/3, 3, new point_t( 120, 32 ) ),
	  new anim_t( animenum_t.ANIM_ALWAYS, TICRATE/4, 3,  new point_t( 40, 0 ) )
	};

	/*static int NUMANIMS[NUMEPISODES] =
	{
	 sizeof(epsd0animinfo)/sizeof(anim_t),
	 sizeof(epsd1animinfo)/sizeof(anim_t),
	 sizeof(epsd2animinfo)/sizeof(anim_t)
	};*/

	// MAES: cute, but we can do it in a more Java-friendly way :-p

	public static final int[] NUMANIMS={epsd0animinfo.length,epsd1animinfo.length,epsd2animinfo.length};

	/** ATTENTION: there's a difference between these "anims" and those used in p_spec.c */

	public static final anim_t[][] anims =
	{
	 epsd0animinfo,
	 epsd1animinfo,
	 epsd2animinfo
	};

}

package f;

import v.DoomVideoRenderer;
import doom.DoomMain;

public abstract class Wiper<T,V> extends AbstractWiper<T,V> {

    static final String rcsid = "$Id: Wiper.java,v 1.18 2012/09/24 17:16:23 velktron Exp $";
    
    protected wipefun[] wipes;
    
    public Wiper(DoomMain<T,V> DC){
        this.updateStatus(DC);
    }
    
    public static final class HiColor extends Wiper<byte[],short[]>{

        public HiColor(DoomMain<byte[], short[]> DC) {
            super(DC);
            wipes=new wipefun[]{
                    new wipe_initColorXForm(), new wipe_doColorXForm(), new wipe_exitColorXForm(),
                    new wipe_initMelt(), new wipe_doMelt(), new wipe_exitMelt()
                    };
        }
        
        /** Those guys sure have an obsession with shit...this is supposed to do some
         * lame-ass transpose.
         * 
         * @param array
         * @param width
         * @param height
         */
        
        protected final void
        shittyColMajorXform
        ( short[]    array,
          int       width,
          int       height )
        {
            int     x;
            int     y;
            short[]  dest;

            dest = new short[width*height];

            for(y=0;y<height;y++)
            for(x=0;x<width;x++){
                dest[x*height+y] = array[y*width+x];
                //dest[(1+x)*height+y] = array[y*width+(1+x)];
            }
            System.arraycopy(dest, 0, array, 0, width*height);

            //Z_Free(dest);

        }
        
        class wipe_doColorXForm implements wipefun{
            
            public boolean
        invoke
        ( int   width,
          int   height,
          int   ticks )
        {
            boolean changed;
            short[]   w=wipe_scr;
            short[]   e=wipe_scr_end;
            int     newval;

            changed = false;
            int pw =0;// wipe_scr;
            int pe = 0; //wipe_scr_end;
            
            while (pw!=width*height)
            {
            if (w[pw] != e[pe])
            {
                if (w[pw] > e[pe])
                {
                newval = w[pw] - ticks;
                if (newval < e[pe])
                    w[pw] = e[pe];
                else
                    w[pw] = (byte) newval;
                changed = true;
                }
                else if (w[pw] < e[pe])
                {
                newval = w[pw] + ticks;
                if (newval > e[pe])
                    w[pw] = e[pe];
                else
                    w[pw] = (byte) newval;
                changed = true;
                }
            }
            pw++;
            pe++;
            }

            return !changed;

        }
        }
    
        class wipe_doMelt implements wipefun{
            public boolean
            invoke
        ( int   width,
          int   height,
          int   ticks )
        {
                
            //   int w2=2*width;
            //    int w3=3*width;
            //    int w4=4*width;

            int     dy;
            int     idx;
            
            // Indexex to short* ?! WTF... 
            int  ps;
            int  pd;
            
            short[] s;//=wipe_scr_end;
            short[] d=wipe_scr;
            
            boolean done = true;

            //width=2;

            while (ticks-->0)
            {
            for (int i=0;i<width;i++)
            {
                // Column won't start yet.
                if (y[i]<0)
                {
                y[i]++; done = false;
                }
                else if (y[i] < height)
                {
                    
                    
                dy = (y[i] < 16*Y_SCALE) ? y[i]+Y_SCALE : 8*Y_SCALE;
                if (y[i]+dy >= height) dy = height - y[i];
                ps = i*height+y[i];// &((short *)wipe_scr_end)[i*height+y[i]];
                pd = y[i]*width+i;//&((short *)wipe_scr)[y[i]*width+i];
                idx = 0;

                s=wipe_scr_end;
                

                
                // MAES: this part should draw the END SCREEN "behind" the melt.
                for (int j=dy;j>0;j--)
                {
                    d[pd+idx] = s[ps++];
                    idx += width;
                }
                y[i] += dy;
                s=wipe_scr_start;
                ps = i*height; //&((short *)wipe_scr_start)[i*height];
                pd = y[i]*width+i; //&((short *)wipe_scr)[y[i]*width+i];
                idx = 0;

                // This draws a column shifted by y[i]
                
                for (int j=height-y[i];j>0;j--)
                {
                    d[pd+idx] = s[ps++];
                    idx+=width;
                }
                done = false;
                }
            }
            }

            return done;

        }
        }
    }
    
    public static final class Indexed extends Wiper<byte[],byte[]>{

        public Indexed(DoomMain<byte[], byte[]> DC) {
            super(DC);
            wipes=new wipefun[]{
                    new wipe_initColorXForm(), new wipe_doColorXForm(), new wipe_exitColorXForm(),
                    new wipe_initMelt(), new wipe_doMelt(), new wipe_exitMelt()
                    };
        }
        
        /** Those guys sure have an obsession with shit...this is supposed to do some
         * lame-ass transpose.
         * 
         * @param array
         * @param width
         * @param height
         */
        
        protected final void
        shittyColMajorXform
        ( byte[]    array,
          int       width,
          int       height )
        {
            int     x;
            int     y;
            byte[]  dest;

            dest = new byte[width*height];

            for(y=0;y<height;y++)
            for(x=0;x<width;x++){
                dest[x*height+y] = array[y*width+x];
                //dest[(1+x)*height+y] = array[y*width+(1+x)];
            }
            System.arraycopy(dest, 0, array, 0, width*height);

            //Z_Free(dest);

        }
        
        class wipe_doColorXForm implements wipefun{
            
            public boolean
        invoke
        ( int   width,
          int   height,
          int   ticks )
        {
            boolean changed;
            byte[]   w=wipe_scr;
            byte[]   e=wipe_scr_end;
            int     newval;

            changed = false;
            int pw =0;// wipe_scr;
            int pe = 0; //wipe_scr_end;
            
            while (pw!=width*height)
            {
            if (w[pw] != e[pe])
            {
                if (w[pw] > e[pe])
                {
                newval = w[pw] - ticks;
                if (newval < e[pe])
                    w[pw] = e[pe];
                else
                    w[pw] = (byte) newval;
                changed = true;
                }
                else if (w[pw] < e[pe])
                {
                newval = w[pw] + ticks;
                if (newval > e[pe])
                    w[pw] = e[pe];
                else
                    w[pw] = (byte) newval;
                changed = true;
                }
            }
            pw++;
            pe++;
            }

            return !changed;

        }
        }
    
        class wipe_doMelt implements wipefun{
            public boolean
            invoke
        ( int   width,
          int   height,
          int   ticks )
        {
                
            //   int w2=2*width;
            //    int w3=3*width;
            //    int w4=4*width;

            int     dy;
            int     idx;
            
            // Indexex to short* ?! WTF... 
            int  ps;
            int  pd;
            
            byte[] s;//=wipe_scr_end;
            byte[] d=wipe_scr;
            
            boolean done = true;

            //width=2;

            while (ticks-->0)
            {
            for (int i=0;i<width;i++)
            {
                // Column won't start yet.
                if (y[i]<0)
                {
                y[i]++; done = false;
                }
                else if (y[i] < height)
                {
                    
                    
                dy = (y[i] < 16*Y_SCALE) ? y[i]+Y_SCALE : 8*Y_SCALE;
                if (y[i]+dy >= height) dy = height - y[i];
                ps = i*height+y[i];// &((short *)wipe_scr_end)[i*height+y[i]];
                pd = y[i]*width+i;//&((short *)wipe_scr)[y[i]*width+i];
                idx = 0;

                s=wipe_scr_end;
                

                
                // MAES: this part should draw the END SCREEN "behind" the melt.
                for (int j=dy;j>0;j--)
                {
                    d[pd+idx] = s[ps++];
                    idx += width;
                }
                y[i] += dy;
                s=wipe_scr_start;
                ps = i*height; //&((short *)wipe_scr_start)[i*height];
                pd = y[i]*width+i; //&((short *)wipe_scr)[y[i]*width+i];
                idx = 0;

                // This draws a column shifted by y[i]
                
                for (int j=height-y[i];j>0;j--)
                {
                    d[pd+idx] = s[ps++];
                    idx+=width;
                }
                done = false;
                }
            }
            }

            return done;

        }
        }
    }
    
    public static final class TrueColor extends Wiper<byte[],int[]>{

        public TrueColor(DoomMain<byte[], int[]> DC) {
            super(DC);
            wipes=new wipefun[]{
                    new wipe_initColorXForm(), new wipe_doColorXForm(), new wipe_exitColorXForm(),
                    new wipe_initMelt(), new wipe_doMelt(), new wipe_exitMelt()
                    };
        }
        
        /** Those guys sure have an obsession with shit...this is supposed to do some
         * lame-ass transpose.
         * 
         * @param array
         * @param width
         * @param height
         */
        
        protected final void
        shittyColMajorXform
        ( int[]    array,
          int       width,
          int       height )
        {
            int     x;
            int     y;
            int[]  dest;

            dest = new int[width*height];

            for(y=0;y<height;y++)
            for(x=0;x<width;x++){
                dest[x*height+y] = array[y*width+x];
                //dest[(1+x)*height+y] = array[y*width+(1+x)];
            }
            System.arraycopy(dest, 0, array, 0, width*height);

            //Z_Free(dest);

        }
        
        class wipe_doColorXForm implements wipefun{
            
            public boolean
        invoke
        ( int   width,
          int   height,
          int   ticks )
        {
            boolean changed;
            int[]   w=wipe_scr;
            int[]   e=wipe_scr_end;
            int     newval;

            changed = false;
            int pw =0;// wipe_scr;
            int pe = 0; //wipe_scr_end;
            
            while (pw!=width*height)
            {
            if (w[pw] != e[pe])
            {
                if (w[pw] > e[pe])
                {
                newval = w[pw] - ticks;
                if (newval < e[pe])
                    w[pw] = e[pe];
                else
                    w[pw] = (byte) newval;
                changed = true;
                }
                else if (w[pw] < e[pe])
                {
                newval = w[pw] + ticks;
                if (newval > e[pe])
                    w[pw] = e[pe];
                else
                    w[pw] = (byte) newval;
                changed = true;
                }
            }
            pw++;
            pe++;
            }

            return !changed;

        }
        }
    
        class wipe_doMelt implements wipefun{
            public boolean
            invoke
        ( int   width,
          int   height,
          int   ticks )
        {
                
            //   int w2=2*width;
            //    int w3=3*width;
            //    int w4=4*width;

            int     dy;
            int     idx;
            
            // Indexex to short* ?! WTF... 
            int  ps;
            int  pd;
            
            int[] s;//=wipe_scr_end;
            int[] d=wipe_scr;
            
            boolean done = true;

            //width=2;

            while (ticks-->0)
            {
            for (int i=0;i<width;i++)
            {
                // Column won't start yet.
                if (y[i]<0)
                {
                y[i]++; done = false;
                }
                else if (y[i] < height)
                {
                    
                    
                dy = (y[i] < 16*Y_SCALE) ? y[i]+Y_SCALE : 8*Y_SCALE;
                if (y[i]+dy >= height) dy = height - y[i];
                ps = i*height+y[i];// &((short *)wipe_scr_end)[i*height+y[i]];
                pd = y[i]*width+i;//&((short *)wipe_scr)[y[i]*width+i];
                idx = 0;

                s=wipe_scr_end;
                

                
                // MAES: this part should draw the END SCREEN "behind" the melt.
                for (int j=dy;j>0;j--)
                {
                    d[pd+idx] = s[ps++];
                    idx += width;
                }
                y[i] += dy;
                s=wipe_scr_start;
                ps = i*height; //&((short *)wipe_scr_start)[i*height];
                pd = y[i]*width+i; //&((short *)wipe_scr)[y[i]*width+i];
                idx = 0;

                // This draws a column shifted by y[i]
                
                for (int j=height-y[i];j>0;j--)
                {
                    d[pd+idx] = s[ps++];
                    idx+=width;
                }
                done = false;
                }
            }
            }

            return done;

        }
        }
    }
    
    protected abstract void shittyColMajorXform( V array, int       width,  int       height );
    
    class wipe_initColorXForm implements wipefun{
        public boolean
        invoke
    ( int   width,
      int   height,
      int   ticks )
    {
        System.arraycopy(wipe_scr_start,0 ,wipe_scr, 0,width*height);
        return false;
    }
    
    }
   
    
    
    class wipe_exitColorXForm implements wipefun{
    public boolean
    invoke
    ( int   width,
      int   height,
      int   ticks )
    {
        return false;
    }
    }


    protected int[] y;

    class wipe_initMelt implements wipefun{
        public boolean
        invoke
    ( int   width,
      int   height,
      int   ticks )
    {
        int i, r;
        
        // copy start screen to main screen
        System.arraycopy(wipe_scr_start, 0,wipe_scr, 0,width*height);
        
        // makes this wipe faster (in theory)
        // to have stuff in column-major format
        shittyColMajorXform(wipe_scr_start, width, height);
        shittyColMajorXform(wipe_scr_end, width, height);
        
        // setup initial column positions
        // (y<0 => not ready to scroll yet)
        y = new int[width];
        
        y[0] = -(RND.M_Random()%16);
        
        for (int j=1;j<Y_SCALE;j++){
        	y[j]=y[j-1];
        }
        
        for (i=Y_SCALE;i<width;i+=Y_SCALE)
        {
            r = (RND.M_Random()%3) - 1;
            y[i] = y[i-1] + r;
            if (y[i] > 0) y[i] = 0;
            else if (y[i] == -16) y[i] = -15;
            
        	for (int j=1;j<Y_SCALE;j++){
        		y[i+j]=y[i];
        	}
        
        }

        return false;
    }
    }

    
    
    class wipe_exitMelt implements wipefun{
        public boolean
        invoke
    ( int   width,
      int   height,
      int   ticks )

    {
        y=null; //Z_Free(y);
        return false;
    }
    }

    /** Sets "from" screen and stores it in "screen 2"*/
    
    @Override
    public boolean
    StartScreen
    ( int   x,
      int   y,
      int   width,
      int   height )
    {
        wipe_scr_start = V.getScreen(DoomVideoRenderer.SCREEN_WS);
        //  byte[] screen_zero=V.getScreen(0);
        VI.ReadScreen(wipe_scr_start);
        
        //System.arraycopy(screen_zero,0,wipe_scr_start, 0, SCREENWIDTH*SCREENHEIGHT);
        return false;
    }

    /** Sets "to" screen and stores it to "screen 3" */

    @Override
    public boolean
    EndScreen
    ( int   x,
      int   y,
      int   width,
      int   height )
    {
        // Set end screen to "screen 3" and copy visible screen to it.
        wipe_scr_end = V.getScreen(DoomVideoRenderer.SCREEN_WE);
        VI.ReadScreen(wipe_scr_end);
        
        // Restore starting screen.
        V screen_zero= V.getScreen(DoomVideoRenderer.SCREEN_FG);        
        System.arraycopy(wipe_scr_start,0,screen_zero, 0, SCREENWIDTH*SCREENHEIGHT);
        return false;
    }
    @Override
    public boolean
    ScreenWipe
    ( int   wipeno,
      int   x,
      int   y,
      int   width,
      int   height,
      int   ticks )
    {
        boolean rc;
  
        //System.out.println("Ticks do "+ticks);

        // initial stuff
        if (!go)
        {
        go = true;
        //wipe_scr = new byte[width*height]; // DEBUG
        wipe_scr = V.getScreen(DoomVideoRenderer.SCREEN_FG);
        // HOW'S THAT FOR A FUNCTION POINTER, BIATCH?!
        (wipes[wipeno*3]).invoke(width, height, ticks);
        }

        // do a piece of wipe-in
        V.MarkRect(0, 0, width, height);
        rc = (wipes[wipeno*3+1]).invoke(width, height, ticks);
        // V.DrawBlock(x, y, 0, width, height, wipe_scr); // DEBUG

        // final stuff
        if (rc)
        {
        go = false;
        (wipes[wipeno*3+2]).invoke(width, height, ticks);
        }

        return !go;

    }

    
    /** Interface for ASS-WIPING functions */
    
    interface wipefun{
        public boolean invoke(int   width,
                int   height,
                int   ticks );
    }
    
}

package data;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: dstrings.java,v 1.4 2010/10/01 16:47:51 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: dstrings.java,v $
// Revision 1.4  2010/10/01 16:47:51  velktron
// Fixed tab interception.
//
// Revision 1.3  2010/09/22 16:40:02  velktron
// MASSIVE changes in the status passing model.
// DoomMain and DoomGame unified.
// Doomstat merged into DoomMain (now status and game functions are one).
//
// Most of DoomMain implemented. Possible to attempt a "classic type" start but will stop when reading sprites.
//
// Revision 1.2  2010/07/22 15:37:53  velktron
// MAJOR changes in Menu system.
//
// Revision 1.1  2010/06/30 08:58:51  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//	Globally defined strings.
// 
//-----------------------------------------------------------------------------

import static doom.englsh.*;

public class dstrings{

//public static const char rcsid[] = "$Id: dstrings.java,v 1.4 2010/10/01 16:47:51 velktron Exp $";


    // Misc. other strings.
    public static final String SAVEGAMENAME=    "doomsav";
    
    /** File locations,  relative to current position.
     * Path names are OS-sensitive. 
     * Only really used with the -shdev command line parameter.
     * 
     * MAES: shouldn't those need path separator characters? :-S
     */
    
    
    public static final String DEVMAPS= "devmaps", DEVDATA ="devdata";


    // Not done in french?

    // QuitDOOM messages
    public static final int NUM_QUITMESSAGES= 22;


public static final String[] endmsg=
{
  // DOOM1
  QUITMSG,
  "please don't leave, there's more\ndemons to toast!",
  "let's beat it -- this is turning\ninto a bloodbath!",
  "i wouldn't leave if i were you.\ndos is much worse.",
  "you're trying to say you like dos\nbetter than me, right?",
  "don't leave yet -- there's a\ndemon around that corner!",
  "ya know, next time you come in here\ni'm gonna toast ya.",
  "go ahead and leave. see if i care.",

  // QuitDOOM II messages
  "you want to quit?\nthen, thou hast lost an eighth!",
  "don't go now, there's a \ndimensional shambler waiting\nat the dos prompt!",
  "get outta here and go back\nto your boring programs.",
  "if i were your boss, i'd \n deathmatch ya in a minute!",
  "look, bud. you leave now\nand you forfeit your body count!",
  "just leave. when you come\nback, i'll be waiting with a bat.",
  "you're lucky i don't smack\nyou for thinking about leaving.",

  // FinalDOOM?
  "fuck you, pussy!\nget the fuck out!",
  "you quit and i'll jizz\nin your cystholes!",
  "if you leave, i'll make\nthe lord drink my jizz.",
  "hey, ron! can we say\n'fuck' in the game?",
  "i'd leave: this is just\nmore monsters and levels.\nwhat a load.",
  "suck it down, asshole!\nyou're a fucking wimp!",
  "don't quit now! we're \nstill spending your money!",

  // Internal debug. Different style, too.
  "THIS IS NO MESSAGE!\nPage intentionally left blank."
};
}


  



package data;

/**
 *   SoundFX struct.
 *    
 *   
 *
 */

public class sfxinfo_t {
	
		public sfxinfo_t(){
			
		}
	
        /** up to 6-character name */
        public String   name;

        /** Sfx singularity (only one at a time) */
        public boolean     singularity;

        /** Sfx priority */
        public int     priority;

        // referenced sound if a link
        // MAES: since in pure hackish C style, a "0" value would be used as a boolean, we'll need to distinguish more
        // unambiguously. So for querying, look at the "linked" boolean or a getter.
        public boolean linked;
        
        public sfxinfo_t  link;

        public sfxinfo_t getLink() {
            if (linked) return link;
            else return null;
        }

        public void setLink(sfxinfo_t link) {
            this.link=link;
        }
        
        // pitch if a link
        public int     pitch;

        // volume if a link
        public int     volume;

        /** sound data (used to be void*) */
        public byte[]  data;

        // this is checked every second to see if sound
        // can be thrown out (if 0, then decrement, if -1,
        // then throw out, if > 0, then it is in use)
        public int     usefulness;

        // lump number of sfx
        public int     lumpnum;

        public sfxinfo_t(String name, boolean singularity, int priority,
                sfxinfo_t link, int pitch, int volume, byte[] data,
                int usefulness, int lumpnum) {
            this.name = name;
            this.singularity = singularity;
            this.priority = priority;
            this.link = link;
            this.pitch = pitch;
            this.volume = volume;
            this.data = data;
            this.usefulness = usefulness;
            this.lumpnum = lumpnum;
        }
        
        /** MAES: Call this constructor if you don't want a cross-linked sound.
         * 
         * @param name
         * @param singularity
         * @param priority
         * @param pitch
         * @param volume
         * @param usefulness
         */
        
        public sfxinfo_t(String name, boolean singularity, int priority,
                int pitch, int volume, int usefulness) {
            this.name = name;
            this.singularity = singularity;
            this.priority = priority;
            this.linked = false;
            this.pitch = pitch;
            this.volume = volume;
            this.usefulness = usefulness;
        }
        
        public sfxinfo_t(String name, boolean singularity, int priority, boolean linked,
                int pitch, int volume, int usefulness) {
            this.name = name;
            this.singularity = singularity;
            this.priority = priority;
            this.linked = linked;
            this.pitch = pitch;
            this.volume = volume;
            this.usefulness = usefulness;
        }
        
        public int identify(sfxinfo_t[] array){
        	for (int i=0;i<array.length;i++){
        		if (array[i]==this){
        			return i;
        		}
        	}
        	// Duh
        	return 0;
        }
        
    };

package data;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: doomtype.java,v 1.3 2011/02/11 00:11:13 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//	Simple basic typedefs, isolated here to make it easier
//	 separating modules.
//    
//-----------------------------------------------------------------------------


public class doomtype {

// C's "chars" are actually Java signed bytes.
public static byte MAXCHAR =((byte)0x7f);
public static short MAXSHORT=	((short)0x7fff);

// Max pos 32-bit int.
public static int MAXINT=((int)0x7fffffff);	
public static long MAXLONG=((long)0x7fffffff);
public static byte MINCHAR=((byte)0x80);
public static short MINSHORT=((short)0x8000);

// Max negative 32-bit integer.
public static int MININT=((int)0x80000000);
public static long MINLONG=((long)0x80000000);
}
package data;

//import m.define;
import static data.Limits.MAXINT;
import static data.Limits.MININT;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.MAPFRACUNIT;
import g.Keys;
import defines.ammotype_t;
import defines.card_t;
import doom.weapontype_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: Defines.java,v 1.48 2012/09/24 17:16:22 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//  Internally used data structures for virtually everything,
//   key definitions, lots of other stuff.
//
//-----------------------------------------------------------------------------

//#ifndef __DOOMDEF__
//#define __DOOMDEF__

//#include <stdio.h>
//#include <string.h>

//
// Global parameters/defines.
//
// DOOM version
public final class Defines{
    
    /** Seems to be 109 for shareware 1.9, wtf is this*/
public static final int VERSION =  109 ;

/** Some parts of the code may actually be better used as if in a UNIX environment */

public static final boolean NORMALUNIX =false;


/** If rangecheck is undefined,  ost parameter validation debugging code will not be compiled */
public static final boolean RANGECHECK=false;

// Do or do not use external soundserver.
// The sndserver binary to be run separately
//  has been introduced by Dave Taylor.
// The integrated sound support is experimental,
//  and unfinished. Default is synchronous.
// Experimental asynchronous timer based is
//  handled by SNDINTR. 
//#define SNDSERV  1
//#define SNDINTR  1

// Defines suck. C sucks.
// C++ might sucks for OOP, but it sure is a better C.
// So there.

// MAES: moved static defines out of here and into VideoScaleInfo.

// State updates, number of tics / second.
public static final int BASETICRATE = 35;
public static final int TIC_MUL = 1;
public static final int TICRATE = BASETICRATE*TIC_MUL;

//
// Difficulty/skill settings/filters.
//

// Skill flags.
public static int MTF_EASY =       1;
public static int MTF_NORMAL =     2;
public static int MTF_HARD =       4;

// Deaf monsters/do not react to sound.
public static int MTF_AMBUSH =8;

//Maes: this makes it a bit less retarded.
public static final int NUMCARDS=card_t.NUMCARDS.ordinal();


//Maes: this makes it a bit less retarded.
public static final int NUMWEAPONS=weapontype_t.NUMWEAPONS.ordinal();

//Maes: this makes it a bit less retarded.
public static final int NUMAMMO=ammotype_t.NUMAMMO.ordinal();

// Power up artifacts.
public static final int pw_invulnerability=0;
public static final int    pw_strength=1;
public static final int    pw_invisibility=2;
public static final int    pw_ironfeet=3;
public static final int    pw_allmap=4;
public static final int    pw_infrared=5;
public static final int    NUMPOWERS=6;


/** Power up durations,
 *  how many seconds till expiration,
 *  assuming TICRATE is 35 ticks/second.
 */
    public static final int INVULNTICS=(30*TICRATE),
    INVISTICS=(60*TICRATE),
    INFRATICS=(120*TICRATE),
    IRONTICS =(60*TICRATE);

// Center command from Heretic
public final static int TOCENTER=-8;

// from r_defs.h:



//Silhouette, needed for clipping Segs (mainly)
//and sprites representing things.
public static final int SIL_NONE =0;
public static final int SIL_BOTTOM     =1;
public static final int SIL_TOP  =       2;
public static final int SIL_BOTH    =    3;

//SKY, store the number for name.
static public final String SKYFLATNAME  ="F_SKY1";

// The sky map is 256*128*4 maps.
public static final int ANGLETOSKYSHIFT   = 22;

// From r_draw.c

// status bar height at bottom of screen
public static final int  SBARHEIGHT     = 32;


//
//Different vetween registered DOOM (1994) and
//Ultimate DOOM - Final edition (retail, 1995?).
//This is supposedly ignored for commercial
//release (aka DOOM II), which had 34 maps
//in one episode. So there.
public static final int NUMEPISODES=4;
public static final int NUMMAPS     =9;


//in tics
//U #define PAUSELEN        (TICRATE*2) 
//U #define SCORESTEP       100
//U #define ANIMPERIOD      32
//pixel distance from "(YOU)" to "PLAYER N"
//U #define STARDIST        10 
//U #define WK 1


// MAES 23/5/2011: moved SP_... stuff to EndLevel

public static final int    BACKUPTICS     = 12;




// From Zone:

//
//ZONE MEMORY
//PU - purge tags.
//Tags < 100 are not overwritten until freed.
public static final int PU_STATIC   =    1;   // static entire execution time
public static final int PU_SOUND    =    2;   // static while playing
public static final int PU_MUSIC   =     3;   // static while playing
public static final int PU_DAVE   =  4;   // anything else Dave wants static
public static final int PU_LEVEL   =     50;  // static until level exited
public static final int PU_LEVSPEC  =    51;    // a special thinker in a level
//Tags >= 100 are purgable whenever needed.
public static final int PU_PURGELEVEL =  100;
public static final int PU_CACHE     =   101;


// From hu_lib.h:

//background and foreground screen numbers
//different from other modules.
public static final int BG     =     1;
public static final int FG     =     0;

//font stuff
static public final char HU_CHARERASE  =  Keys.KEY_BACKSPACE;

public static final int HU_MAXLINES  =   4;
public static final int HU_MAXLINELENGTH  =  80;

// From hu_stuff.h

//
//Globally visible constants.
//
static public final byte HU_FONTSTART  =  '!'; // the first font characters
static public final byte HU_FONTEND  ='_'; // the last font characters

//Calculate # of glyphs in font.
public static final int HU_FONTSIZE = (HU_FONTEND - HU_FONTSTART + 1); 

static public final char HU_BROADCAST   = 5;

static public final char HU_MSGREFRESH =  Keys.KEY_ENTER;
static public final char HU_MSGX     =0;
static public final char HU_MSGY     =0;
static public final char HU_MSGWIDTH =64;  // in characters
static public final char HU_MSGHEIGHT  =  1;   // in lines

public static final int HU_MSGTIMEOUT =  (4*TICRATE);

public static final int SAVESTRINGSIZE = 24;

//
// Button/action code definitions.
// From d_event.h

     // Press "Fire".
    public static final int BT_ATTACK       = 1;
     // Use button, to open doors, activate switches.
    public static final int BT_USE      = 2;

     // Flag: game events, not really buttons.
    public static final int BT_SPECIAL      = 128;
    public static final int BT_SPECIALMASK  = 3;
     
     // Flag, weapon change pending.
     // If true, the next 3 bits hold weapon num.
    public static final int  BT_CHANGE       = 4;
     // The 3bit weapon mask and shift, convenience.
    public static final int  BT_WEAPONMASK   = (8+16+32);
    public static final int   BT_WEAPONSHIFT  = 3;

     // Pause the game.
    public static final int  BTS_PAUSE       = 1;
     // Save the game at each console.
    public static final int  BTS_SAVEGAME    = 2;

     // Savegame slot numbers
     //  occupy the second byte of buttons.    
    public static final int BTS_SAVEMASK    = (4+8+16);
    public static final int BTS_SAVESHIFT   = 2;
   

    
    
    //==================== Stuff from r_local.c =========================================

    
    public static final int FLOATSPEED        =(FRACUNIT*4);

    public static final int VIEWHEIGHT    =   (41*FRACUNIT);

    // mapblocks are used to check movement
    // against lines and things
    public static final int MAPBLOCKUNITS=    128;
    public static final int MAPBLOCKSIZE  =(MAPBLOCKUNITS*FRACUNIT);
    public static final int MAPBLOCKSHIFT =(FRACBITS+7);
    public static final int MAPBMASK      =(MAPBLOCKSIZE-1);
    public static final int MAPBTOFRAC=       (MAPBLOCKSHIFT-FRACBITS);
    public static final int BLOCKMAPPADDING=       8*FRACUNIT;

    // player radius for movement checking
    public static final int PLAYERRADIUS  =16*FRACUNIT;
    public static final int GRAVITY   =   MAPFRACUNIT;
    public static int USERANGE      =(64*FRACUNIT);
    public static int MELEERANGE    =   (64*FRACUNIT);
    public static int MISSILERANGE=(32*64*FRACUNIT);

    // follow a player exlusively for 3 seconds
    public static int   BASETHRESHOLD=      100;


    
    public static int PT_ADDLINES     =1;
    public static int PT_ADDTHINGS    =2;
    public static int PT_EARLYOUT     =4;
    
 //
 // P_MOBJ
 //
 public static int ONFLOORZ  =   MININT;
 public static int ONCEILINGZ    =   MAXINT;

 // Time interval for item respawning.
 public static int ITEMQUESIZE       =128;
 

    /** Indicate a leaf. e6y: support for extended nodes */
    public static final int NF_SUBSECTOR = 0x80000000;

    /** This is the regular leaf indicator. Use for reference/conversions */
    public static final int NF_SUBSECTOR_CLASSIC = 0x8000;

    
    
    /** Player states. */
    
    public static final int   PST_LIVE=0,     // Playing or camping.    
        PST_DEAD=1,        // Dead on the ground, view follows killer.

        PST_REBORN=2;            // Ready to restart/respawn???
 
    public static final int  FF_FULLBRIGHT =  0x8000;  // flag in thing->frame
    public static final int  FF_FRAMEMASK =   0x7fff;


 
static final String
rcsid = "$Id: Defines.java,v 1.48 2012/09/24 17:16:22 velktron Exp $";
}


package data;

import defines.statenum_t;
import data.sounds.sfxenum_t;

public class mobjinfo_t {
   
        public mobjinfo_t(int doomednum, statenum_t spawnstate, int spawnhealth,
                statenum_t seestate, sfxenum_t seesound, int reactiontime,
                sfxenum_t attacksound, statenum_t painstate,
                int painchance, sfxenum_t painsound,
                statenum_t meleestate, statenum_t missilestate,
                statenum_t deathstate, statenum_t xdeathstate,
                sfxenum_t deathsound, int speed, int radius, int height,
                int mass, int damage, sfxenum_t activesound, long flags,
                statenum_t raisestate) {
            super();
            this.doomednum = doomednum;
            this.spawnstate = spawnstate;
            this.spawnhealth = spawnhealth;
            this.seestate = seestate;
            this.seesound = seesound;
            this.reactiontime = reactiontime;
            this.attacksound = attacksound;
            this.painstate = painstate;
            this.painchance = painchance;
            this.painsound = painsound;
            this.meleestate = meleestate;
            this.missilestate = missilestate;
            this.deathstate = deathstate;
            this.xdeathstate = xdeathstate;
            this.deathsound = deathsound;
            this.speed = speed;
            this.radius = radius;
            this.height = height;
            this.mass = mass;
            this.damage = damage;
            this.activesound = activesound;
            this.flags = flags;
            this.raisestate = raisestate;
        }
        
        public int doomednum;
        public statenum_t spawnstate;
        public int spawnhealth;
        public statenum_t seestate;
        public sfxenum_t seesound;
        public int reactiontime;
        public sfxenum_t attacksound;
        public statenum_t painstate;
        public int painchance;
        public sfxenum_t painsound;
        public statenum_t meleestate;
        public statenum_t missilestate;
        public statenum_t deathstate;
        public statenum_t xdeathstate;
        public sfxenum_t deathsound;
        public int speed;
        public int radius;
        public int height;
        public int mass;
        public int damage;
        public sfxenum_t activesound;
        public long flags;
        public statenum_t raisestate;
    }

package data;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import w.CacheableDoomObject;

/**
 *  LineSeg, generated by splitting LineDefs
 * using partition lines selected by BSP builder.
 * MAES: this is the ON-DISK structure. The corresponding memory structure, 
 * segs_t, has fixed_t members. 
 */

public class mapseg_t implements CacheableDoomObject{
    
    public mapseg_t(){
        
    }

   public char     v1;
   public char     v2;
   public char     angle;      
   public char     linedef;
   public char     side;
   public char     offset;
   
   public static int sizeOf(){
       return 12;
   }
   
   @Override
   public void unpack(ByteBuffer buf)
           throws IOException {
       buf.order(ByteOrder.LITTLE_ENDIAN);
       this.v1 = buf.getChar();
       this.v2 = buf.getChar();
       this.angle=buf.getChar();       
       this.linedef=buf.getChar();
       this.side=buf.getChar();
       this.offset=buf.getChar();
      
   }
   
   public String toString(){
       return String.format("mapseg_t v1,2: %d %d ang: %d ld: %d sd: %d off: %d",
           (int)v1,(int)v2,(int)angle,(int)linedef,(int)side,(int)offset);
   }
   
 };

package data;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: doomdata.java,v 1.4 2011/02/11 00:11:13 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//  all external data is defined here
//  most of the data is loaded into different structures at run time
//  some internal structures shared by many modules are here
//
//-----------------------------------------------------------------------------



    
// The most basic types we use, portability.
//#include "doomtype.h"

// Some global defines, that configure the game.


public class doomdata{
//
// Map level types.
// The following data structures define the persistent format
// used in the lumps of the WAD files.
//

// Lump order in a map WAD: each map needs a couple of lumps
// to provide a complete scene geometry description.
// Maes: this was defined as a typeless enum, probably intended to be used as cardinality?
// Turning it into "ML" enum or int consts.
public static enum ML
{
  ML_LABEL,		// A separator, name, ExMx or MAPxx
  ML_THINGS,		// Monsters, items..
  ML_LINEDEFS,		// LineDefs, from editing
  ML_SIDEDEFS,		// SideDefs, from editing
  ML_VERTEXES,		// Vertices, edited and BSP splits generated
  ML_SEGS,		// LineSegs, from LineDefs split by BSP
  ML_SSECTORS,		// SubSectors, list of LineSegs
  ML_NODES,		// BSP nodes
  ML_SECTORS,		// Sectors, from editing
  ML_REJECT,		// LUT, sector-sector visibility	
  ML_BLOCKMAP		// LUT, motion clipping, walls/grid element
};


// A single Vertex.
static class mapvertex_t
{
  short		x;
  short		y;
};


// A SideDef, defining the visual appearance of a wall,
// by setting textures and offsets.
static class  mapsidedef_t
{
  short		textureoffset;
  short		rowoffset;
  char[]		toptexture=new char[8];
  char[]		bottomtexture=new char[8];
  char[]		midtexture=new char[8];
  // Front sector, towards viewer.
  short		sector;
}



// A LineDef, as used for editing, and as input
// to the BSP builder.
static class maplinedef_t
{
  short		v1;
  short		v2;
  short		flags;
  short		special;
  short		tag;
  // sidenum[1] will be -1 if one sided
  int[]		sidenum=new int[2];		
} 


//
// LineDef attributes.
//

// Solid, is an obstacle.
public static final int ML_BLOCKING		=1;

// Blocks monsters only.
public static final int ML_BLOCKMONSTERS=	2;

// Backside will not be present at all
//  if not two sided.
public static final int ML_TWOSIDED		=4;

// If a texture is pegged, the texture will have
// the end exposed to air held constant at the
// top or bottom of the texture (stairs or pulled
// down things) and will move with a height change
// of one of the neighbor sectors.
// Unpegged textures allways have the first row of
// the texture at the top pixel of the line for both
// top and bottom textures (use next to windows).

// upper texture unpegged
public static final int ML_DONTPEGTOP=8;

// lower texture unpegged
public static final int ML_DONTPEGBOTTOM=	16	;

// In AutoMap: don't map as two sided: IT'S A SECRET!
public static final int ML_SECRET=		32;

// Sound rendering: don't let sound cross two of these.
public static final int ML_SOUNDBLOCK=		64;

// Don't draw on the automap at all.
public static final int ML_DONTDRAW=		128;

// Set if already seen, thus drawn in automap.
public static final int ML_MAPPED		=256;




// Sector definition, from editing.
class mapsector_t
{
  short		floorheight;
  short		ceilingheight;
  char[] floorpic=new char[8];
  char[]		ceilingpic=new char[8];
  short		lightlevel;
  short		special;
  short		tag;
};

// SubSector, as generated by BSP.
class mapsubsector_t
{
  short		numsegs;
  // Index of first one, segs are stored sequentially.
  short		firstseg;	
};


// LineSeg, generated by splitting LineDefs
// using partition lines selected by BSP builder.
class mapseg_t
{
  short		v1;
  short		v2;
  short		angle;		
  short		linedef;
  short		side;
  short		offset;
};



// BSP node structure.

// Indicate a leaf.
public static int	NF_SUBSECTOR	=0x8000;

class mapnode_t
{
  // Partition line from (x,y) to x+dx,y+dy)
  short		x;
  short		y;
  short		dx;
  short		dy;

  // Bounding box for each child,
  // clip against view frustum.
  short[][]		bbox=new short[2][4];

  // If NF_SUBSECTOR its a subsector,
  // else it's a node of another subtree.
  //Maes: used to be unsigned short
  int[] children=new int[2];

} ;

}
package data;

import static data.sounds.*;
import static m.fixed_t.*;
import static p.MobjFlags.*;
import defines.statenum_t;
import doom.think_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: info.java,v 1.13 2013/06/03 12:36:42 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

//
//-----------------------------------------------------------------------------

/** 
 * DESCRIPTION:
 *  Thing frame/state LUT, generated by multigen utilitiy.
 *  This one is the original DOOM version, preserved.
 * 
 * @author velktron
 *
 */

public class info{

public static final state_t[]	states = {
    // MAES: ATTENTION! The "null" state looks just like an imp. If you see it, then something's
    // wrong. When you check for "null" state, you should actually check whether something 
    // is set to S_NULL!
    new state_t(spritenum_t.SPR_TROO,0,-1,null,statenum_t.S_NULL,0,0),	// S_NULL
    // _D_: replaced "null" by "think_t.A_Light0" (see linuxdoom source)
    // I was trying to make the red fire around the gun apprear when we shoot
    // but I didn't succeed. This modification below is minor as I didn't see
    // any change in the game
    new state_t(spritenum_t.SPR_SHTG,4,0,think_t.A_Light0,statenum_t.S_NULL,0,0),	// S_LIGHTDONE
    new state_t(spritenum_t.SPR_PUNG,0,1,think_t.A_WeaponReady,statenum_t.S_PUNCH,0,0),	// S_PUNCH
    new state_t(spritenum_t.SPR_PUNG,0,1,think_t.A_Lower,statenum_t.S_PUNCHDOWN,0,0),	// S_PUNCHDOWN
    new state_t(spritenum_t.SPR_PUNG,0,1,think_t.A_Raise,statenum_t.S_PUNCHUP,0,0),	// S_PUNCHUP
    new state_t(spritenum_t.SPR_PUNG,1,4,null,statenum_t.S_PUNCH2,0,0),		// S_PUNCH1
    new state_t(spritenum_t.SPR_PUNG,2,4,think_t.A_Punch,statenum_t.S_PUNCH3,0,0),	// S_PUNCH2
    new state_t(spritenum_t.SPR_PUNG,3,5,null,statenum_t.S_PUNCH4,0,0),		// S_PUNCH3
    new state_t(spritenum_t.SPR_PUNG,2,4,null,statenum_t.S_PUNCH5,0,0),		// S_PUNCH4
    new state_t(spritenum_t.SPR_PUNG,1,5,think_t.A_ReFire,statenum_t.S_PUNCH,0,0),	// S_PUNCH5
    new state_t(spritenum_t.SPR_PISG,0,1,think_t.A_WeaponReady,statenum_t.S_PISTOL,0,0),// S_PISTOL
    new state_t(spritenum_t.SPR_PISG,0,1,think_t.A_Lower,statenum_t.S_PISTOLDOWN,0,0),	// S_PISTOLDOWN
    new state_t(spritenum_t.SPR_PISG,0,1,think_t.A_Raise,statenum_t.S_PISTOLUP,0,0),	// S_PISTOLUP
    new state_t(spritenum_t.SPR_PISG,0,4,null,statenum_t.S_PISTOL2,0,0),	// S_PISTOL1
    new state_t(spritenum_t.SPR_PISG,1,6,think_t.A_FirePistol,statenum_t.S_PISTOL3,0,0),// S_PISTOL2
    new state_t(spritenum_t.SPR_PISG,2,4,null,statenum_t.S_PISTOL4,0,0),	// S_PISTOL3
    new state_t(spritenum_t.SPR_PISG,1,5,think_t.A_ReFire,statenum_t.S_PISTOL,0,0),	// S_PISTOL4
    new state_t(spritenum_t.SPR_PISF,32768,7,think_t.A_Light1,statenum_t.S_LIGHTDONE,0,0),	// S_PISTOLFLASH
    new state_t(spritenum_t.SPR_SHTG,0,1,think_t.A_WeaponReady,statenum_t.S_SGUN,0,0),	// S_SGUN
    new state_t(spritenum_t.SPR_SHTG,0,1,think_t.A_Lower,statenum_t.S_SGUNDOWN,0,0),	// S_SGUNDOWN
    new state_t(spritenum_t.SPR_SHTG,0,1,think_t.A_Raise,statenum_t.S_SGUNUP,0,0),	// S_SGUNUP
    new state_t(spritenum_t.SPR_SHTG,0,3,null,statenum_t.S_SGUN2,0,0),	// S_SGUN1
    new state_t(spritenum_t.SPR_SHTG,0,7,think_t.A_FireShotgun,statenum_t.S_SGUN3,0,0),	// S_SGUN2
    new state_t(spritenum_t.SPR_SHTG,1,5,null,statenum_t.S_SGUN4,0,0),	// S_SGUN3
    new state_t(spritenum_t.SPR_SHTG,2,5,null,statenum_t.S_SGUN5,0,0),	// S_SGUN4
    new state_t(spritenum_t.SPR_SHTG,3,4,null,statenum_t.S_SGUN6,0,0),	// S_SGUN5
    new state_t(spritenum_t.SPR_SHTG,2,5,null,statenum_t.S_SGUN7,0,0),	// S_SGUN6
    new state_t(spritenum_t.SPR_SHTG,1,5,null,statenum_t.S_SGUN8,0,0),	// S_SGUN7
    new state_t(spritenum_t.SPR_SHTG,0,3,null,statenum_t.S_SGUN9,0,0),	// S_SGUN8
    new state_t(spritenum_t.SPR_SHTG,0,7,think_t.A_ReFire,statenum_t.S_SGUN,0,0),	// S_SGUN9
    new state_t(spritenum_t.SPR_SHTF,32768,4,think_t.A_Light1,statenum_t.S_SGUNFLASH2,0,0),	// S_SGUNFLASH1
    new state_t(spritenum_t.SPR_SHTF,32769,3,think_t.A_Light2,statenum_t.S_LIGHTDONE,0,0),	// S_SGUNFLASH2
    new state_t(spritenum_t.SPR_SHT2,0,1,think_t.A_WeaponReady,statenum_t.S_DSGUN,0,0),	// S_DSGUN
    new state_t(spritenum_t.SPR_SHT2,0,1,think_t.A_Lower,statenum_t.S_DSGUNDOWN,0,0),	// S_DSGUNDOWN
    new state_t(spritenum_t.SPR_SHT2,0,1,think_t.A_Raise,statenum_t.S_DSGUNUP,0,0),	// S_DSGUNUP
    new state_t(spritenum_t.SPR_SHT2,0,3,null,statenum_t.S_DSGUN2,0,0),	// S_DSGUN1
    new state_t(spritenum_t.SPR_SHT2,0,7,think_t.A_FireShotgun2,statenum_t.S_DSGUN3,0,0),	// S_DSGUN2
    new state_t(spritenum_t.SPR_SHT2,1,7,null,statenum_t.S_DSGUN4,0,0),	// S_DSGUN3
    new state_t(spritenum_t.SPR_SHT2,2,7,think_t.A_CheckReload,statenum_t.S_DSGUN5,0,0),	// S_DSGUN4
    new state_t(spritenum_t.SPR_SHT2,3,7,think_t.A_OpenShotgun2,statenum_t.S_DSGUN6,0,0),	// S_DSGUN5
    new state_t(spritenum_t.SPR_SHT2,4,7,null,statenum_t.S_DSGUN7,0,0),	// S_DSGUN6
    new state_t(spritenum_t.SPR_SHT2,5,7,think_t.A_LoadShotgun2,statenum_t.S_DSGUN8,0,0),	// S_DSGUN7
    new state_t(spritenum_t.SPR_SHT2,6,6,null,statenum_t.S_DSGUN9,0,0),	// S_DSGUN8
    new state_t(spritenum_t.SPR_SHT2,7,6,think_t.A_CloseShotgun2,statenum_t.S_DSGUN10,0,0),	// S_DSGUN9
    new state_t(spritenum_t.SPR_SHT2,0,5,think_t.A_ReFire,statenum_t.S_DSGUN,0,0),	// S_DSGUN10
    new state_t(spritenum_t.SPR_SHT2,1,7,null,statenum_t.S_DSNR2,0,0),	// S_DSNR1
    new state_t(spritenum_t.SPR_SHT2,0,3,null,statenum_t.S_DSGUNDOWN,0,0),	// S_DSNR2
    new state_t(spritenum_t.SPR_SHT2,32776,5,think_t.A_Light1,statenum_t.S_DSGUNFLASH2,0,0),	// S_DSGUNFLASH1
    new state_t(spritenum_t.SPR_SHT2,32777,4,think_t.A_Light2,statenum_t.S_LIGHTDONE,0,0),	// S_DSGUNFLASH2
    new state_t(spritenum_t.SPR_CHGG,0,1,think_t.A_WeaponReady,statenum_t.S_CHAIN,0,0),	// S_CHAIN
    new state_t(spritenum_t.SPR_CHGG,0,1,think_t.A_Lower,statenum_t.S_CHAINDOWN,0,0),	// S_CHAINDOWN
    new state_t(spritenum_t.SPR_CHGG,0,1,think_t.A_Raise,statenum_t.S_CHAINUP,0,0),	// S_CHAINUP
    new state_t(spritenum_t.SPR_CHGG,0,4,think_t.A_FireCGun,statenum_t.S_CHAIN2,0,0),	// S_CHAIN1
    new state_t(spritenum_t.SPR_CHGG,1,4,think_t.A_FireCGun,statenum_t.S_CHAIN3,0,0),	// S_CHAIN2
    new state_t(spritenum_t.SPR_CHGG,1,0,think_t.A_ReFire,statenum_t.S_CHAIN,0,0),	// S_CHAIN3
    new state_t(spritenum_t.SPR_CHGF,32768,5,think_t.A_Light1,statenum_t.S_LIGHTDONE,0,0),	// S_CHAINFLASH1
    new state_t(spritenum_t.SPR_CHGF,32769,5,think_t.A_Light2,statenum_t.S_LIGHTDONE,0,0),	// S_CHAINFLASH2
    new state_t(spritenum_t.SPR_MISG,0,1,think_t.A_WeaponReady,statenum_t.S_MISSILE,0,0),	// S_MISSILE
    new state_t(spritenum_t.SPR_MISG,0,1,think_t.A_Lower,statenum_t.S_MISSILEDOWN,0,0),	// S_MISSILEDOWN
    new state_t(spritenum_t.SPR_MISG,0,1,think_t.A_Raise,statenum_t.S_MISSILEUP,0,0),	// S_MISSILEUP
    new state_t(spritenum_t.SPR_MISG,1,8,think_t.A_GunFlash,statenum_t.S_MISSILE2,0,0),	// S_MISSILE1
    new state_t(spritenum_t.SPR_MISG,1,12,think_t.A_FireMissile,statenum_t.S_MISSILE3,0,0),	// S_MISSILE2
    new state_t(spritenum_t.SPR_MISG,1,0,think_t.A_ReFire,statenum_t.S_MISSILE,0,0),	// S_MISSILE3
    new state_t(spritenum_t.SPR_MISF,32768,3,think_t.A_Light1,statenum_t.S_MISSILEFLASH2,0,0),	// S_MISSILEFLASH1
    new state_t(spritenum_t.SPR_MISF,32769,4,null,statenum_t.S_MISSILEFLASH3,0,0),	// S_MISSILEFLASH2
    new state_t(spritenum_t.SPR_MISF,32770,4,think_t.A_Light2,statenum_t.S_MISSILEFLASH4,0,0),	// S_MISSILEFLASH3
    new state_t(spritenum_t.SPR_MISF,32771,4,think_t.A_Light2,statenum_t.S_LIGHTDONE,0,0),	// S_MISSILEFLASH4
    new state_t(spritenum_t.SPR_SAWG,2,4,think_t.A_WeaponReady,statenum_t.S_SAWB,0,0),	// S_SAW
    new state_t(spritenum_t.SPR_SAWG,3,4,think_t.A_WeaponReady,statenum_t.S_SAW,0,0),	// S_SAWB
    new state_t(spritenum_t.SPR_SAWG,2,1,think_t.A_Lower,statenum_t.S_SAWDOWN,0,0),	// S_SAWDOWN
    new state_t(spritenum_t.SPR_SAWG,2,1,think_t.A_Raise,statenum_t.S_SAWUP,0,0),	// S_SAWUP
    new state_t(spritenum_t.SPR_SAWG,0,4,think_t.A_Saw,statenum_t.S_SAW2,0,0),	// S_SAW1
    new state_t(spritenum_t.SPR_SAWG,1,4,think_t.A_Saw,statenum_t.S_SAW3,0,0),	// S_SAW2
    new state_t(spritenum_t.SPR_SAWG,1,0,think_t.A_ReFire,statenum_t.S_SAW,0,0),	// S_SAW3
    new state_t(spritenum_t.SPR_PLSG,0,1,think_t.A_WeaponReady,statenum_t.S_PLASMA,0,0),	// S_PLASMA
    new state_t(spritenum_t.SPR_PLSG,0,1,think_t.A_Lower,statenum_t.S_PLASMADOWN,0,0),	// S_PLASMADOWN
    new state_t(spritenum_t.SPR_PLSG,0,1,think_t.A_Raise,statenum_t.S_PLASMAUP,0,0),	// S_PLASMAUP
    new state_t(spritenum_t.SPR_PLSG,0,3,think_t.A_FirePlasma,statenum_t.S_PLASMA2,0,0),	// S_PLASMA1
    new state_t(spritenum_t.SPR_PLSG,1,20,think_t.A_ReFire,statenum_t.S_PLASMA,0,0),	// S_PLASMA2
    new state_t(spritenum_t.SPR_PLSF,32768,4,think_t.A_Light1,statenum_t.S_LIGHTDONE,0,0),	// S_PLASMAFLASH1
    new state_t(spritenum_t.SPR_PLSF,32769,4,think_t.A_Light1,statenum_t.S_LIGHTDONE,0,0),	// S_PLASMAFLASH2
    new state_t(spritenum_t.SPR_BFGG,0,1,think_t.A_WeaponReady,statenum_t.S_BFG,0,0),	// S_BFG
    new state_t(spritenum_t.SPR_BFGG,0,1,think_t.A_Lower,statenum_t.S_BFGDOWN,0,0),	// S_BFGDOWN
    new state_t(spritenum_t.SPR_BFGG,0,1,think_t.A_Raise,statenum_t.S_BFGUP,0,0),	// S_BFGUP
    new state_t(spritenum_t.SPR_BFGG,0,20,think_t.A_BFGsound,statenum_t.S_BFG2,0,0),	// S_BFG1
    new state_t(spritenum_t.SPR_BFGG,1,10,think_t.A_GunFlash,statenum_t.S_BFG3,0,0),	// S_BFG2
    new state_t(spritenum_t.SPR_BFGG,1,10,think_t.A_FireBFG,statenum_t.S_BFG4,0,0),	// S_BFG3
    new state_t(spritenum_t.SPR_BFGG,1,20,think_t.A_ReFire,statenum_t.S_BFG,0,0),	// S_BFG4
    new state_t(spritenum_t.SPR_BFGF,32768,11,think_t.A_Light1,statenum_t.S_BFGFLASH2,0,0),	// S_BFGFLASH1
    new state_t(spritenum_t.SPR_BFGF,32769,6,think_t.A_Light2,statenum_t.S_LIGHTDONE,0,0),	// S_BFGFLASH2
    new state_t(spritenum_t.SPR_BLUD,2,8,null,statenum_t.S_BLOOD2,0,0),	// S_BLOOD1
    new state_t(spritenum_t.SPR_BLUD,1,8,null,statenum_t.S_BLOOD3,0,0),	// S_BLOOD2
    new state_t(spritenum_t.SPR_BLUD,0,8,null,statenum_t.S_NULL,0,0),	// S_BLOOD3
    new state_t(spritenum_t.SPR_PUFF,32768,4,null,statenum_t.S_PUFF2,0,0),	// S_PUFF1
    new state_t(spritenum_t.SPR_PUFF,1,4,null,statenum_t.S_PUFF3,0,0),	// S_PUFF2
    new state_t(spritenum_t.SPR_PUFF,2,4,null,statenum_t.S_PUFF4,0,0),	// S_PUFF3
    new state_t(spritenum_t.SPR_PUFF,3,4,null,statenum_t.S_NULL,0,0),	// S_PUFF4
    new state_t(spritenum_t.SPR_BAL1,32768,4,null,statenum_t.S_TBALL2,0,0),	// S_TBALL1
    new state_t(spritenum_t.SPR_BAL1,32769,4,null,statenum_t.S_TBALL1,0,0),	// S_TBALL2
    new state_t(spritenum_t.SPR_BAL1,32770,6,null,statenum_t.S_TBALLX2,0,0),	// S_TBALLX1
    new state_t(spritenum_t.SPR_BAL1,32771,6,null,statenum_t.S_TBALLX3,0,0),	// S_TBALLX2
    new state_t(spritenum_t.SPR_BAL1,32772,6,null,statenum_t.S_NULL,0,0),	// S_TBALLX3
    new state_t(spritenum_t.SPR_BAL2,32768,4,null,statenum_t.S_RBALL2,0,0),	// S_RBALL1
    new state_t(spritenum_t.SPR_BAL2,32769,4,null,statenum_t.S_RBALL1,0,0),	// S_RBALL2
    new state_t(spritenum_t.SPR_BAL2,32770,6,null,statenum_t.S_RBALLX2,0,0),	// S_RBALLX1
    new state_t(spritenum_t.SPR_BAL2,32771,6,null,statenum_t.S_RBALLX3,0,0),	// S_RBALLX2
    new state_t(spritenum_t.SPR_BAL2,32772,6,null,statenum_t.S_NULL,0,0),	// S_RBALLX3
    new state_t(spritenum_t.SPR_PLSS,32768,6,null,statenum_t.S_PLASBALL2,0,0),	// S_PLASBALL
    new state_t(spritenum_t.SPR_PLSS,32769,6,null,statenum_t.S_PLASBALL,0,0),	// S_PLASBALL2
    new state_t(spritenum_t.SPR_PLSE,32768,4,null,statenum_t.S_PLASEXP2,0,0),	// S_PLASEXP
    new state_t(spritenum_t.SPR_PLSE,32769,4,null,statenum_t.S_PLASEXP3,0,0),	// S_PLASEXP2
    new state_t(spritenum_t.SPR_PLSE,32770,4,null,statenum_t.S_PLASEXP4,0,0),	// S_PLASEXP3
    new state_t(spritenum_t.SPR_PLSE,32771,4,null,statenum_t.S_PLASEXP5,0,0),	// S_PLASEXP4
    new state_t(spritenum_t.SPR_PLSE,32772,4,null,statenum_t.S_NULL,0,0),	// S_PLASEXP5
    new state_t(spritenum_t.SPR_MISL,32768,1,null,statenum_t.S_ROCKET,0,0),	// S_ROCKET
    new state_t(spritenum_t.SPR_BFS1,32768,4,null,statenum_t.S_BFGSHOT2,0,0),	// S_BFGSHOT
    new state_t(spritenum_t.SPR_BFS1,32769,4,null,statenum_t.S_BFGSHOT,0,0),	// S_BFGSHOT2
    new state_t(spritenum_t.SPR_BFE1,32768,8,null,statenum_t.S_BFGLAND2,0,0),	// S_BFGLAND
    new state_t(spritenum_t.SPR_BFE1,32769,8,null,statenum_t.S_BFGLAND3,0,0),	// S_BFGLAND2
    new state_t(spritenum_t.SPR_BFE1,32770,8,think_t.A_BFGSpray,statenum_t.S_BFGLAND4,0,0),	// S_BFGLAND3
    new state_t(spritenum_t.SPR_BFE1,32771,8,null,statenum_t.S_BFGLAND5,0,0),	// S_BFGLAND4
    new state_t(spritenum_t.SPR_BFE1,32772,8,null,statenum_t.S_BFGLAND6,0,0),	// S_BFGLAND5
    new state_t(spritenum_t.SPR_BFE1,32773,8,null,statenum_t.S_NULL,0,0),	// S_BFGLAND6
    new state_t(spritenum_t.SPR_BFE2,32768,8,null,statenum_t.S_BFGEXP2,0,0),	// S_BFGEXP
    new state_t(spritenum_t.SPR_BFE2,32769,8,null,statenum_t.S_BFGEXP3,0,0),	// S_BFGEXP2
    new state_t(spritenum_t.SPR_BFE2,32770,8,null,statenum_t.S_BFGEXP4,0,0),	// S_BFGEXP3
    new state_t(spritenum_t.SPR_BFE2,32771,8,null,statenum_t.S_NULL,0,0),	// S_BFGEXP4
    new state_t(spritenum_t.SPR_MISL,32769,8,think_t.A_Explode,statenum_t.S_EXPLODE2,0,0),	// S_EXPLODE1
    new state_t(spritenum_t.SPR_MISL,32770,6,null,statenum_t.S_EXPLODE3,0,0),	// S_EXPLODE2
    new state_t(spritenum_t.SPR_MISL,32771,4,null,statenum_t.S_NULL,0,0),	// S_EXPLODE3
    new state_t(spritenum_t.SPR_TFOG,32768,6,null,statenum_t.S_TFOG01,0,0),	// S_TFOG
    new state_t(spritenum_t.SPR_TFOG,32769,6,null,statenum_t.S_TFOG02,0,0),	// S_TFOG01
    new state_t(spritenum_t.SPR_TFOG,32768,6,null,statenum_t.S_TFOG2,0,0),	// S_TFOG02
    new state_t(spritenum_t.SPR_TFOG,32769,6,null,statenum_t.S_TFOG3,0,0),	// S_TFOG2
    new state_t(spritenum_t.SPR_TFOG,32770,6,null,statenum_t.S_TFOG4,0,0),	// S_TFOG3
    new state_t(spritenum_t.SPR_TFOG,32771,6,null,statenum_t.S_TFOG5,0,0),	// S_TFOG4
    new state_t(spritenum_t.SPR_TFOG,32772,6,null,statenum_t.S_TFOG6,0,0),	// S_TFOG5
    new state_t(spritenum_t.SPR_TFOG,32773,6,null,statenum_t.S_TFOG7,0,0),	// S_TFOG6
    new state_t(spritenum_t.SPR_TFOG,32774,6,null,statenum_t.S_TFOG8,0,0),	// S_TFOG7
    new state_t(spritenum_t.SPR_TFOG,32775,6,null,statenum_t.S_TFOG9,0,0),	// S_TFOG8
    new state_t(spritenum_t.SPR_TFOG,32776,6,null,statenum_t.S_TFOG10,0,0),	// S_TFOG9
    new state_t(spritenum_t.SPR_TFOG,32777,6,null,statenum_t.S_NULL,0,0),	// S_TFOG10
    new state_t(spritenum_t.SPR_IFOG,32768,6,null,statenum_t.S_IFOG01,0,0),	// S_IFOG
    new state_t(spritenum_t.SPR_IFOG,32769,6,null,statenum_t.S_IFOG02,0,0),	// S_IFOG01
    new state_t(spritenum_t.SPR_IFOG,32768,6,null,statenum_t.S_IFOG2,0,0),	// S_IFOG02
    new state_t(spritenum_t.SPR_IFOG,32769,6,null,statenum_t.S_IFOG3,0,0),	// S_IFOG2
    new state_t(spritenum_t.SPR_IFOG,32770,6,null,statenum_t.S_IFOG4,0,0),	// S_IFOG3
    new state_t(spritenum_t.SPR_IFOG,32771,6,null,statenum_t.S_IFOG5,0,0),	// S_IFOG4
    new state_t(spritenum_t.SPR_IFOG,32772,6,null,statenum_t.S_NULL,0,0),	// S_IFOG5
    new state_t(spritenum_t.SPR_PLAY,0,-1,null,statenum_t.S_NULL,0,0),	// S_PLAY
    new state_t(spritenum_t.SPR_PLAY,0,4,null,statenum_t.S_PLAY_RUN2,0,0),	// S_PLAY_RUN1
    new state_t(spritenum_t.SPR_PLAY,1,4,null,statenum_t.S_PLAY_RUN3,0,0),	// S_PLAY_RUN2
    new state_t(spritenum_t.SPR_PLAY,2,4,null,statenum_t.S_PLAY_RUN4,0,0),	// S_PLAY_RUN3
    new state_t(spritenum_t.SPR_PLAY,3,4,null,statenum_t.S_PLAY_RUN1,0,0),	// S_PLAY_RUN4
    new state_t(spritenum_t.SPR_PLAY,4,12,null,statenum_t.S_PLAY,0,0),	// S_PLAY_ATK1
    new state_t(spritenum_t.SPR_PLAY,32773,6,null,statenum_t.S_PLAY_ATK1,0,0),	// S_PLAY_ATK2
    new state_t(spritenum_t.SPR_PLAY,6,4,null,statenum_t.S_PLAY_PAIN2,0,0),	// S_PLAY_PAIN
    new state_t(spritenum_t.SPR_PLAY,6,4,think_t.A_Pain,statenum_t.S_PLAY,0,0),	// S_PLAY_PAIN2
    new state_t(spritenum_t.SPR_PLAY,7,10,null,statenum_t.S_PLAY_DIE2,0,0),	// S_PLAY_DIE1
    new state_t(spritenum_t.SPR_PLAY,8,10,think_t.A_PlayerScream,statenum_t.S_PLAY_DIE3,0,0),	// S_PLAY_DIE2
    new state_t(spritenum_t.SPR_PLAY,9,10,think_t.A_Fall,statenum_t.S_PLAY_DIE4,0,0),	// S_PLAY_DIE3
    new state_t(spritenum_t.SPR_PLAY,10,10,null,statenum_t.S_PLAY_DIE5,0,0),	// S_PLAY_DIE4
    new state_t(spritenum_t.SPR_PLAY,11,10,null,statenum_t.S_PLAY_DIE6,0,0),	// S_PLAY_DIE5
    new state_t(spritenum_t.SPR_PLAY,12,10,null,statenum_t.S_PLAY_DIE7,0,0),	// S_PLAY_DIE6
    new state_t(spritenum_t.SPR_PLAY,13,-1,null,statenum_t.S_NULL,0,0),	// S_PLAY_DIE7
    new state_t(spritenum_t.SPR_PLAY,14,5,null,statenum_t.S_PLAY_XDIE2,0,0),	// S_PLAY_XDIE1
    new state_t(spritenum_t.SPR_PLAY,15,5,think_t.A_XScream,statenum_t.S_PLAY_XDIE3,0,0),	// S_PLAY_XDIE2
    new state_t(spritenum_t.SPR_PLAY,16,5,think_t.A_Fall,statenum_t.S_PLAY_XDIE4,0,0),	// S_PLAY_XDIE3
    new state_t(spritenum_t.SPR_PLAY,17,5,null,statenum_t.S_PLAY_XDIE5,0,0),	// S_PLAY_XDIE4
    new state_t(spritenum_t.SPR_PLAY,18,5,null,statenum_t.S_PLAY_XDIE6,0,0),	// S_PLAY_XDIE5
    new state_t(spritenum_t.SPR_PLAY,19,5,null,statenum_t.S_PLAY_XDIE7,0,0),	// S_PLAY_XDIE6
    new state_t(spritenum_t.SPR_PLAY,20,5,null,statenum_t.S_PLAY_XDIE8,0,0),	// S_PLAY_XDIE7
    new state_t(spritenum_t.SPR_PLAY,21,5,null,statenum_t.S_PLAY_XDIE9,0,0),	// S_PLAY_XDIE8
    new state_t(spritenum_t.SPR_PLAY,22,-1,null,statenum_t.S_NULL,0,0),	// S_PLAY_XDIE9
    new state_t(spritenum_t.SPR_POSS,0,10,think_t.A_Look,statenum_t.S_POSS_STND2,0,0),	// S_POSS_STND
    new state_t(spritenum_t.SPR_POSS,1,10,think_t.A_Look,statenum_t.S_POSS_STND,0,0),	// S_POSS_STND2
    new state_t(spritenum_t.SPR_POSS,0,4,think_t.A_Chase,statenum_t.S_POSS_RUN2,0,0),	// S_POSS_RUN1
    new state_t(spritenum_t.SPR_POSS,0,4,think_t.A_Chase,statenum_t.S_POSS_RUN3,0,0),	// S_POSS_RUN2
    new state_t(spritenum_t.SPR_POSS,1,4,think_t.A_Chase,statenum_t.S_POSS_RUN4,0,0),	// S_POSS_RUN3
    new state_t(spritenum_t.SPR_POSS,1,4,think_t.A_Chase,statenum_t.S_POSS_RUN5,0,0),	// S_POSS_RUN4
    new state_t(spritenum_t.SPR_POSS,2,4,think_t.A_Chase,statenum_t.S_POSS_RUN6,0,0),	// S_POSS_RUN5
    new state_t(spritenum_t.SPR_POSS,2,4,think_t.A_Chase,statenum_t.S_POSS_RUN7,0,0),	// S_POSS_RUN6
    new state_t(spritenum_t.SPR_POSS,3,4,think_t.A_Chase,statenum_t.S_POSS_RUN8,0,0),	// S_POSS_RUN7
    new state_t(spritenum_t.SPR_POSS,3,4,think_t.A_Chase,statenum_t.S_POSS_RUN1,0,0),	// S_POSS_RUN8
    new state_t(spritenum_t.SPR_POSS,4,10,think_t.A_FaceTarget,statenum_t.S_POSS_ATK2,0,0),	// S_POSS_ATK1
    new state_t(spritenum_t.SPR_POSS,5,8,think_t.A_PosAttack,statenum_t.S_POSS_ATK3,0,0),	// S_POSS_ATK2
    new state_t(spritenum_t.SPR_POSS,4,8,null,statenum_t.S_POSS_RUN1,0,0),	// S_POSS_ATK3
    new state_t(spritenum_t.SPR_POSS,6,3,null,statenum_t.S_POSS_PAIN2,0,0),	// S_POSS_PAIN
    new state_t(spritenum_t.SPR_POSS,6,3,think_t.A_Pain,statenum_t.S_POSS_RUN1,0,0),	// S_POSS_PAIN2
    new state_t(spritenum_t.SPR_POSS,7,5,null,statenum_t.S_POSS_DIE2,0,0),	// S_POSS_DIE1
    new state_t(spritenum_t.SPR_POSS,8,5,think_t.A_Scream,statenum_t.S_POSS_DIE3,0,0),	// S_POSS_DIE2
    new state_t(spritenum_t.SPR_POSS,9,5,think_t.A_Fall,statenum_t.S_POSS_DIE4,0,0),	// S_POSS_DIE3
    new state_t(spritenum_t.SPR_POSS,10,5,null,statenum_t.S_POSS_DIE5,0,0),	// S_POSS_DIE4
    new state_t(spritenum_t.SPR_POSS,11,-1,null,statenum_t.S_NULL,0,0),	// S_POSS_DIE5
    new state_t(spritenum_t.SPR_POSS,12,5,null,statenum_t.S_POSS_XDIE2,0,0),	// S_POSS_XDIE1
    new state_t(spritenum_t.SPR_POSS,13,5,think_t.A_XScream,statenum_t.S_POSS_XDIE3,0,0),	// S_POSS_XDIE2
    new state_t(spritenum_t.SPR_POSS,14,5,think_t.A_Fall,statenum_t.S_POSS_XDIE4,0,0),	// S_POSS_XDIE3
    new state_t(spritenum_t.SPR_POSS,15,5,null,statenum_t.S_POSS_XDIE5,0,0),	// S_POSS_XDIE4
    new state_t(spritenum_t.SPR_POSS,16,5,null,statenum_t.S_POSS_XDIE6,0,0),	// S_POSS_XDIE5
    new state_t(spritenum_t.SPR_POSS,17,5,null,statenum_t.S_POSS_XDIE7,0,0),	// S_POSS_XDIE6
    new state_t(spritenum_t.SPR_POSS,18,5,null,statenum_t.S_POSS_XDIE8,0,0),	// S_POSS_XDIE7
    new state_t(spritenum_t.SPR_POSS,19,5,null,statenum_t.S_POSS_XDIE9,0,0),	// S_POSS_XDIE8
    new state_t(spritenum_t.SPR_POSS,20,-1,null,statenum_t.S_NULL,0,0),	// S_POSS_XDIE9
    new state_t(spritenum_t.SPR_POSS,10,5,null,statenum_t.S_POSS_RAISE2,0,0),	// S_POSS_RAISE1
    new state_t(spritenum_t.SPR_POSS,9,5,null,statenum_t.S_POSS_RAISE3,0,0),	// S_POSS_RAISE2
    new state_t(spritenum_t.SPR_POSS,8,5,null,statenum_t.S_POSS_RAISE4,0,0),	// S_POSS_RAISE3
    new state_t(spritenum_t.SPR_POSS,7,5,null,statenum_t.S_POSS_RUN1,0,0),	// S_POSS_RAISE4
    new state_t(spritenum_t.SPR_SPOS,0,10,think_t.A_Look,statenum_t.S_SPOS_STND2,0,0),	// S_SPOS_STND
    new state_t(spritenum_t.SPR_SPOS,1,10,think_t.A_Look,statenum_t.S_SPOS_STND,0,0),	// S_SPOS_STND2
    new state_t(spritenum_t.SPR_SPOS,0,3,think_t.A_Chase,statenum_t.S_SPOS_RUN2,0,0),	// S_SPOS_RUN1
    new state_t(spritenum_t.SPR_SPOS,0,3,think_t.A_Chase,statenum_t.S_SPOS_RUN3,0,0),	// S_SPOS_RUN2
    new state_t(spritenum_t.SPR_SPOS,1,3,think_t.A_Chase,statenum_t.S_SPOS_RUN4,0,0),	// S_SPOS_RUN3
    new state_t(spritenum_t.SPR_SPOS,1,3,think_t.A_Chase,statenum_t.S_SPOS_RUN5,0,0),	// S_SPOS_RUN4
    new state_t(spritenum_t.SPR_SPOS,2,3,think_t.A_Chase,statenum_t.S_SPOS_RUN6,0,0),	// S_SPOS_RUN5
    new state_t(spritenum_t.SPR_SPOS,2,3,think_t.A_Chase,statenum_t.S_SPOS_RUN7,0,0),	// S_SPOS_RUN6
    new state_t(spritenum_t.SPR_SPOS,3,3,think_t.A_Chase,statenum_t.S_SPOS_RUN8,0,0),	// S_SPOS_RUN7
    new state_t(spritenum_t.SPR_SPOS,3,3,think_t.A_Chase,statenum_t.S_SPOS_RUN1,0,0),	// S_SPOS_RUN8
    new state_t(spritenum_t.SPR_SPOS,4,10,think_t.A_FaceTarget,statenum_t.S_SPOS_ATK2,0,0),	// S_SPOS_ATK1
    new state_t(spritenum_t.SPR_SPOS,32773,10,think_t.A_SPosAttack,statenum_t.S_SPOS_ATK3,0,0),	// S_SPOS_ATK2
    new state_t(spritenum_t.SPR_SPOS,4,10,null,statenum_t.S_SPOS_RUN1,0,0),	// S_SPOS_ATK3
    new state_t(spritenum_t.SPR_SPOS,6,3,null,statenum_t.S_SPOS_PAIN2,0,0),	// S_SPOS_PAIN
    new state_t(spritenum_t.SPR_SPOS,6,3,think_t.A_Pain,statenum_t.S_SPOS_RUN1,0,0),	// S_SPOS_PAIN2
    new state_t(spritenum_t.SPR_SPOS,7,5,null,statenum_t.S_SPOS_DIE2,0,0),	// S_SPOS_DIE1
    new state_t(spritenum_t.SPR_SPOS,8,5,think_t.A_Scream,statenum_t.S_SPOS_DIE3,0,0),	// S_SPOS_DIE2
    new state_t(spritenum_t.SPR_SPOS,9,5,think_t.A_Fall,statenum_t.S_SPOS_DIE4,0,0),	// S_SPOS_DIE3
    new state_t(spritenum_t.SPR_SPOS,10,5,null,statenum_t.S_SPOS_DIE5,0,0),	// S_SPOS_DIE4
    new state_t(spritenum_t.SPR_SPOS,11,-1,null,statenum_t.S_NULL,0,0),	// S_SPOS_DIE5
    new state_t(spritenum_t.SPR_SPOS,12,5,null,statenum_t.S_SPOS_XDIE2,0,0),	// S_SPOS_XDIE1
    new state_t(spritenum_t.SPR_SPOS,13,5,think_t.A_XScream,statenum_t.S_SPOS_XDIE3,0,0),	// S_SPOS_XDIE2
    new state_t(spritenum_t.SPR_SPOS,14,5,think_t.A_Fall,statenum_t.S_SPOS_XDIE4,0,0),	// S_SPOS_XDIE3
    new state_t(spritenum_t.SPR_SPOS,15,5,null,statenum_t.S_SPOS_XDIE5,0,0),	// S_SPOS_XDIE4
    new state_t(spritenum_t.SPR_SPOS,16,5,null,statenum_t.S_SPOS_XDIE6,0,0),	// S_SPOS_XDIE5
    new state_t(spritenum_t.SPR_SPOS,17,5,null,statenum_t.S_SPOS_XDIE7,0,0),	// S_SPOS_XDIE6
    new state_t(spritenum_t.SPR_SPOS,18,5,null,statenum_t.S_SPOS_XDIE8,0,0),	// S_SPOS_XDIE7
    new state_t(spritenum_t.SPR_SPOS,19,5,null,statenum_t.S_SPOS_XDIE9,0,0),	// S_SPOS_XDIE8
    new state_t(spritenum_t.SPR_SPOS,20,-1,null,statenum_t.S_NULL,0,0),	// S_SPOS_XDIE9
    new state_t(spritenum_t.SPR_SPOS,11,5,null,statenum_t.S_SPOS_RAISE2,0,0),	// S_SPOS_RAISE1
    new state_t(spritenum_t.SPR_SPOS,10,5,null,statenum_t.S_SPOS_RAISE3,0,0),	// S_SPOS_RAISE2
    new state_t(spritenum_t.SPR_SPOS,9,5,null,statenum_t.S_SPOS_RAISE4,0,0),	// S_SPOS_RAISE3
    new state_t(spritenum_t.SPR_SPOS,8,5,null,statenum_t.S_SPOS_RAISE5,0,0),	// S_SPOS_RAISE4
    new state_t(spritenum_t.SPR_SPOS,7,5,null,statenum_t.S_SPOS_RUN1,0,0),	// S_SPOS_RAISE5
    new state_t(spritenum_t.SPR_VILE,0,10,think_t.A_Look,statenum_t.S_VILE_STND2,0,0),	// S_VILE_STND
    new state_t(spritenum_t.SPR_VILE,1,10,think_t.A_Look,statenum_t.S_VILE_STND,0,0),	// S_VILE_STND2
    new state_t(spritenum_t.SPR_VILE,0,2,think_t.A_VileChase,statenum_t.S_VILE_RUN2,0,0),	// S_VILE_RUN1
    new state_t(spritenum_t.SPR_VILE,0,2,think_t.A_VileChase,statenum_t.S_VILE_RUN3,0,0),	// S_VILE_RUN2
    new state_t(spritenum_t.SPR_VILE,1,2,think_t.A_VileChase,statenum_t.S_VILE_RUN4,0,0),	// S_VILE_RUN3
    new state_t(spritenum_t.SPR_VILE,1,2,think_t.A_VileChase,statenum_t.S_VILE_RUN5,0,0),	// S_VILE_RUN4
    new state_t(spritenum_t.SPR_VILE,2,2,think_t.A_VileChase,statenum_t.S_VILE_RUN6,0,0),	// S_VILE_RUN5
    new state_t(spritenum_t.SPR_VILE,2,2,think_t.A_VileChase,statenum_t.S_VILE_RUN7,0,0),	// S_VILE_RUN6
    new state_t(spritenum_t.SPR_VILE,3,2,think_t.A_VileChase,statenum_t.S_VILE_RUN8,0,0),	// S_VILE_RUN7
    new state_t(spritenum_t.SPR_VILE,3,2,think_t.A_VileChase,statenum_t.S_VILE_RUN9,0,0),	// S_VILE_RUN8
    new state_t(spritenum_t.SPR_VILE,4,2,think_t.A_VileChase,statenum_t.S_VILE_RUN10,0,0),	// S_VILE_RUN9
    new state_t(spritenum_t.SPR_VILE,4,2,think_t.A_VileChase,statenum_t.S_VILE_RUN11,0,0),	// S_VILE_RUN10
    new state_t(spritenum_t.SPR_VILE,5,2,think_t.A_VileChase,statenum_t.S_VILE_RUN12,0,0),	// S_VILE_RUN11
    new state_t(spritenum_t.SPR_VILE,5,2,think_t.A_VileChase,statenum_t.S_VILE_RUN1,0,0),	// S_VILE_RUN12
    new state_t(spritenum_t.SPR_VILE,32774,0,think_t.A_VileStart,statenum_t.S_VILE_ATK2,0,0),	// S_VILE_ATK1
    new state_t(spritenum_t.SPR_VILE,32774,10,think_t.A_FaceTarget,statenum_t.S_VILE_ATK3,0,0),	// S_VILE_ATK2
    new state_t(spritenum_t.SPR_VILE,32775,8,think_t.A_VileTarget,statenum_t.S_VILE_ATK4,0,0),	// S_VILE_ATK3
    new state_t(spritenum_t.SPR_VILE,32776,8,think_t.A_FaceTarget,statenum_t.S_VILE_ATK5,0,0),	// S_VILE_ATK4
    new state_t(spritenum_t.SPR_VILE,32777,8,think_t.A_FaceTarget,statenum_t.S_VILE_ATK6,0,0),	// S_VILE_ATK5
    new state_t(spritenum_t.SPR_VILE,32778,8,think_t.A_FaceTarget,statenum_t.S_VILE_ATK7,0,0),	// S_VILE_ATK6
    new state_t(spritenum_t.SPR_VILE,32779,8,think_t.A_FaceTarget,statenum_t.S_VILE_ATK8,0,0),	// S_VILE_ATK7
    new state_t(spritenum_t.SPR_VILE,32780,8,think_t.A_FaceTarget,statenum_t.S_VILE_ATK9,0,0),	// S_VILE_ATK8
    new state_t(spritenum_t.SPR_VILE,32781,8,think_t.A_FaceTarget,statenum_t.S_VILE_ATK10,0,0),	// S_VILE_ATK9
    new state_t(spritenum_t.SPR_VILE,32782,8,think_t.A_VileAttack,statenum_t.S_VILE_ATK11,0,0),	// S_VILE_ATK10
    new state_t(spritenum_t.SPR_VILE,32783,20,null,statenum_t.S_VILE_RUN1,0,0),	// S_VILE_ATK11
    new state_t(spritenum_t.SPR_VILE,32794,10,null,statenum_t.S_VILE_HEAL2,0,0),	// S_VILE_HEAL1
    new state_t(spritenum_t.SPR_VILE,32795,10,null,statenum_t.S_VILE_HEAL3,0,0),	// S_VILE_HEAL2
    new state_t(spritenum_t.SPR_VILE,32796,10,null,statenum_t.S_VILE_RUN1,0,0),	// S_VILE_HEAL3
    new state_t(spritenum_t.SPR_VILE,16,5,null,statenum_t.S_VILE_PAIN2,0,0),	// S_VILE_PAIN
    new state_t(spritenum_t.SPR_VILE,16,5,think_t.A_Pain,statenum_t.S_VILE_RUN1,0,0),	// S_VILE_PAIN2
    new state_t(spritenum_t.SPR_VILE,16,7,null,statenum_t.S_VILE_DIE2,0,0),	// S_VILE_DIE1
    new state_t(spritenum_t.SPR_VILE,17,7,think_t.A_Scream,statenum_t.S_VILE_DIE3,0,0),	// S_VILE_DIE2
    new state_t(spritenum_t.SPR_VILE,18,7,think_t.A_Fall,statenum_t.S_VILE_DIE4,0,0),	// S_VILE_DIE3
    new state_t(spritenum_t.SPR_VILE,19,7,null,statenum_t.S_VILE_DIE5,0,0),	// S_VILE_DIE4
    new state_t(spritenum_t.SPR_VILE,20,7,null,statenum_t.S_VILE_DIE6,0,0),	// S_VILE_DIE5
    new state_t(spritenum_t.SPR_VILE,21,7,null,statenum_t.S_VILE_DIE7,0,0),	// S_VILE_DIE6
    new state_t(spritenum_t.SPR_VILE,22,7,null,statenum_t.S_VILE_DIE8,0,0),	// S_VILE_DIE7
    new state_t(spritenum_t.SPR_VILE,23,5,null,statenum_t.S_VILE_DIE9,0,0),	// S_VILE_DIE8
    new state_t(spritenum_t.SPR_VILE,24,5,null,statenum_t.S_VILE_DIE10,0,0),	// S_VILE_DIE9
    new state_t(spritenum_t.SPR_VILE,25,-1,null,statenum_t.S_NULL,0,0),	// S_VILE_DIE10
    new state_t(spritenum_t.SPR_FIRE,32768,2,think_t.A_StartFire,statenum_t.S_FIRE2,0,0),	// S_FIRE1
    new state_t(spritenum_t.SPR_FIRE,32769,2,think_t.A_Fire,statenum_t.S_FIRE3,0,0),	// S_FIRE2
    new state_t(spritenum_t.SPR_FIRE,32768,2,think_t.A_Fire,statenum_t.S_FIRE4,0,0),	// S_FIRE3
    new state_t(spritenum_t.SPR_FIRE,32769,2,think_t.A_Fire,statenum_t.S_FIRE5,0,0),	// S_FIRE4
    new state_t(spritenum_t.SPR_FIRE,32770,2,think_t.A_FireCrackle,statenum_t.S_FIRE6,0,0),	// S_FIRE5
    new state_t(spritenum_t.SPR_FIRE,32769,2,think_t.A_Fire,statenum_t.S_FIRE7,0,0),	// S_FIRE6
    new state_t(spritenum_t.SPR_FIRE,32770,2,think_t.A_Fire,statenum_t.S_FIRE8,0,0),	// S_FIRE7
    new state_t(spritenum_t.SPR_FIRE,32769,2,think_t.A_Fire,statenum_t.S_FIRE9,0,0),	// S_FIRE8
    new state_t(spritenum_t.SPR_FIRE,32770,2,think_t.A_Fire,statenum_t.S_FIRE10,0,0),	// S_FIRE9
    new state_t(spritenum_t.SPR_FIRE,32771,2,think_t.A_Fire,statenum_t.S_FIRE11,0,0),	// S_FIRE10
    new state_t(spritenum_t.SPR_FIRE,32770,2,think_t.A_Fire,statenum_t.S_FIRE12,0,0),	// S_FIRE11
    new state_t(spritenum_t.SPR_FIRE,32771,2,think_t.A_Fire,statenum_t.S_FIRE13,0,0),	// S_FIRE12
    new state_t(spritenum_t.SPR_FIRE,32770,2,think_t.A_Fire,statenum_t.S_FIRE14,0,0),	// S_FIRE13
    new state_t(spritenum_t.SPR_FIRE,32771,2,think_t.A_Fire,statenum_t.S_FIRE15,0,0),	// S_FIRE14
    new state_t(spritenum_t.SPR_FIRE,32772,2,think_t.A_Fire,statenum_t.S_FIRE16,0,0),	// S_FIRE15
    new state_t(spritenum_t.SPR_FIRE,32771,2,think_t.A_Fire,statenum_t.S_FIRE17,0,0),	// S_FIRE16
    new state_t(spritenum_t.SPR_FIRE,32772,2,think_t.A_Fire,statenum_t.S_FIRE18,0,0),	// S_FIRE17
    new state_t(spritenum_t.SPR_FIRE,32771,2,think_t.A_Fire,statenum_t.S_FIRE19,0,0),	// S_FIRE18
    new state_t(spritenum_t.SPR_FIRE,32772,2,think_t.A_FireCrackle,statenum_t.S_FIRE20,0,0),	// S_FIRE19
    new state_t(spritenum_t.SPR_FIRE,32773,2,think_t.A_Fire,statenum_t.S_FIRE21,0,0),	// S_FIRE20
    new state_t(spritenum_t.SPR_FIRE,32772,2,think_t.A_Fire,statenum_t.S_FIRE22,0,0),	// S_FIRE21
    new state_t(spritenum_t.SPR_FIRE,32773,2,think_t.A_Fire,statenum_t.S_FIRE23,0,0),	// S_FIRE22
    new state_t(spritenum_t.SPR_FIRE,32772,2,think_t.A_Fire,statenum_t.S_FIRE24,0,0),	// S_FIRE23
    new state_t(spritenum_t.SPR_FIRE,32773,2,think_t.A_Fire,statenum_t.S_FIRE25,0,0),	// S_FIRE24
    new state_t(spritenum_t.SPR_FIRE,32774,2,think_t.A_Fire,statenum_t.S_FIRE26,0,0),	// S_FIRE25
    new state_t(spritenum_t.SPR_FIRE,32775,2,think_t.A_Fire,statenum_t.S_FIRE27,0,0),	// S_FIRE26
    new state_t(spritenum_t.SPR_FIRE,32774,2,think_t.A_Fire,statenum_t.S_FIRE28,0,0),	// S_FIRE27
    new state_t(spritenum_t.SPR_FIRE,32775,2,think_t.A_Fire,statenum_t.S_FIRE29,0,0),	// S_FIRE28
    new state_t(spritenum_t.SPR_FIRE,32774,2,think_t.A_Fire,statenum_t.S_FIRE30,0,0),	// S_FIRE29
    new state_t(spritenum_t.SPR_FIRE,32775,2,think_t.A_Fire,statenum_t.S_NULL,0,0),	// S_FIRE30
    new state_t(spritenum_t.SPR_PUFF,1,4,null,statenum_t.S_SMOKE2,0,0),	// S_SMOKE1
    new state_t(spritenum_t.SPR_PUFF,2,4,null,statenum_t.S_SMOKE3,0,0),	// S_SMOKE2
    new state_t(spritenum_t.SPR_PUFF,1,4,null,statenum_t.S_SMOKE4,0,0),	// S_SMOKE3
    new state_t(spritenum_t.SPR_PUFF,2,4,null,statenum_t.S_SMOKE5,0,0),	// S_SMOKE4
    new state_t(spritenum_t.SPR_PUFF,3,4,null,statenum_t.S_NULL,0,0),	// S_SMOKE5
    new state_t(spritenum_t.SPR_FATB,32768,2,think_t.A_Tracer,statenum_t.S_TRACER2,0,0),	// S_TRACER
    new state_t(spritenum_t.SPR_FATB,32769,2,think_t.A_Tracer,statenum_t.S_TRACER,0,0),	// S_TRACER2
    new state_t(spritenum_t.SPR_FBXP,32768,8,null,statenum_t.S_TRACEEXP2,0,0),	// S_TRACEEXP1
    new state_t(spritenum_t.SPR_FBXP,32769,6,null,statenum_t.S_TRACEEXP3,0,0),	// S_TRACEEXP2
    new state_t(spritenum_t.SPR_FBXP,32770,4,null,statenum_t.S_NULL,0,0),	// S_TRACEEXP3
    new state_t(spritenum_t.SPR_SKEL,0,10,think_t.A_Look,statenum_t.S_SKEL_STND2,0,0),	// S_SKEL_STND
    new state_t(spritenum_t.SPR_SKEL,1,10,think_t.A_Look,statenum_t.S_SKEL_STND,0,0),	// S_SKEL_STND2
    new state_t(spritenum_t.SPR_SKEL,0,2,think_t.A_Chase,statenum_t.S_SKEL_RUN2,0,0),	// S_SKEL_RUN1
    new state_t(spritenum_t.SPR_SKEL,0,2,think_t.A_Chase,statenum_t.S_SKEL_RUN3,0,0),	// S_SKEL_RUN2
    new state_t(spritenum_t.SPR_SKEL,1,2,think_t.A_Chase,statenum_t.S_SKEL_RUN4,0,0),	// S_SKEL_RUN3
    new state_t(spritenum_t.SPR_SKEL,1,2,think_t.A_Chase,statenum_t.S_SKEL_RUN5,0,0),	// S_SKEL_RUN4
    new state_t(spritenum_t.SPR_SKEL,2,2,think_t.A_Chase,statenum_t.S_SKEL_RUN6,0,0),	// S_SKEL_RUN5
    new state_t(spritenum_t.SPR_SKEL,2,2,think_t.A_Chase,statenum_t.S_SKEL_RUN7,0,0),	// S_SKEL_RUN6
    new state_t(spritenum_t.SPR_SKEL,3,2,think_t.A_Chase,statenum_t.S_SKEL_RUN8,0,0),	// S_SKEL_RUN7
    new state_t(spritenum_t.SPR_SKEL,3,2,think_t.A_Chase,statenum_t.S_SKEL_RUN9,0,0),	// S_SKEL_RUN8
    new state_t(spritenum_t.SPR_SKEL,4,2,think_t.A_Chase,statenum_t.S_SKEL_RUN10,0,0),	// S_SKEL_RUN9
    new state_t(spritenum_t.SPR_SKEL,4,2,think_t.A_Chase,statenum_t.S_SKEL_RUN11,0,0),	// S_SKEL_RUN10
    new state_t(spritenum_t.SPR_SKEL,5,2,think_t.A_Chase,statenum_t.S_SKEL_RUN12,0,0),	// S_SKEL_RUN11
    new state_t(spritenum_t.SPR_SKEL,5,2,think_t.A_Chase,statenum_t.S_SKEL_RUN1,0,0),	// S_SKEL_RUN12
    new state_t(spritenum_t.SPR_SKEL,6,0,think_t.A_FaceTarget,statenum_t.S_SKEL_FIST2,0,0),	// S_SKEL_FIST1
    new state_t(spritenum_t.SPR_SKEL,6,6,think_t.A_SkelWhoosh,statenum_t.S_SKEL_FIST3,0,0),	// S_SKEL_FIST2
    new state_t(spritenum_t.SPR_SKEL,7,6,think_t.A_FaceTarget,statenum_t.S_SKEL_FIST4,0,0),	// S_SKEL_FIST3
    new state_t(spritenum_t.SPR_SKEL,8,6,think_t.A_SkelFist,statenum_t.S_SKEL_RUN1,0,0),	// S_SKEL_FIST4
    new state_t(spritenum_t.SPR_SKEL,32777,0,think_t.A_FaceTarget,statenum_t.S_SKEL_MISS2,0,0),	// S_SKEL_MISS1
    new state_t(spritenum_t.SPR_SKEL,32777,10,think_t.A_FaceTarget,statenum_t.S_SKEL_MISS3,0,0),	// S_SKEL_MISS2
    new state_t(spritenum_t.SPR_SKEL,10,10,think_t.A_SkelMissile,statenum_t.S_SKEL_MISS4,0,0),	// S_SKEL_MISS3
    new state_t(spritenum_t.SPR_SKEL,10,10,think_t.A_FaceTarget,statenum_t.S_SKEL_RUN1,0,0),	// S_SKEL_MISS4
    new state_t(spritenum_t.SPR_SKEL,11,5,null,statenum_t.S_SKEL_PAIN2,0,0),	// S_SKEL_PAIN
    new state_t(spritenum_t.SPR_SKEL,11,5,think_t.A_Pain,statenum_t.S_SKEL_RUN1,0,0),	// S_SKEL_PAIN2
    new state_t(spritenum_t.SPR_SKEL,11,7,null,statenum_t.S_SKEL_DIE2,0,0),	// S_SKEL_DIE1
    new state_t(spritenum_t.SPR_SKEL,12,7,null,statenum_t.S_SKEL_DIE3,0,0),	// S_SKEL_DIE2
    new state_t(spritenum_t.SPR_SKEL,13,7,think_t.A_Scream,statenum_t.S_SKEL_DIE4,0,0),	// S_SKEL_DIE3
    new state_t(spritenum_t.SPR_SKEL,14,7,think_t.A_Fall,statenum_t.S_SKEL_DIE5,0,0),	// S_SKEL_DIE4
    new state_t(spritenum_t.SPR_SKEL,15,7,null,statenum_t.S_SKEL_DIE6,0,0),	// S_SKEL_DIE5
    new state_t(spritenum_t.SPR_SKEL,16,-1,null,statenum_t.S_NULL,0,0),	// S_SKEL_DIE6
    new state_t(spritenum_t.SPR_SKEL,16,5,null,statenum_t.S_SKEL_RAISE2,0,0),	// S_SKEL_RAISE1
    new state_t(spritenum_t.SPR_SKEL,15,5,null,statenum_t.S_SKEL_RAISE3,0,0),	// S_SKEL_RAISE2
    new state_t(spritenum_t.SPR_SKEL,14,5,null,statenum_t.S_SKEL_RAISE4,0,0),	// S_SKEL_RAISE3
    new state_t(spritenum_t.SPR_SKEL,13,5,null,statenum_t.S_SKEL_RAISE5,0,0),	// S_SKEL_RAISE4
    new state_t(spritenum_t.SPR_SKEL,12,5,null,statenum_t.S_SKEL_RAISE6,0,0),	// S_SKEL_RAISE5
    new state_t(spritenum_t.SPR_SKEL,11,5,null,statenum_t.S_SKEL_RUN1,0,0),	// S_SKEL_RAISE6
    new state_t(spritenum_t.SPR_MANF,32768,4,null,statenum_t.S_FATSHOT2,0,0),	// S_FATSHOT1
    new state_t(spritenum_t.SPR_MANF,32769,4,null,statenum_t.S_FATSHOT1,0,0),	// S_FATSHOT2
    new state_t(spritenum_t.SPR_MISL,32769,8,null,statenum_t.S_FATSHOTX2,0,0),	// S_FATSHOTX1
    new state_t(spritenum_t.SPR_MISL,32770,6,null,statenum_t.S_FATSHOTX3,0,0),	// S_FATSHOTX2
    new state_t(spritenum_t.SPR_MISL,32771,4,null,statenum_t.S_NULL,0,0),	// S_FATSHOTX3
    new state_t(spritenum_t.SPR_FATT,0,15,think_t.A_Look,statenum_t.S_FATT_STND2,0,0),	// S_FATT_STND
    new state_t(spritenum_t.SPR_FATT,1,15,think_t.A_Look,statenum_t.S_FATT_STND,0,0),	// S_FATT_STND2
    new state_t(spritenum_t.SPR_FATT,0,4,think_t.A_Chase,statenum_t.S_FATT_RUN2,0,0),	// S_FATT_RUN1
    new state_t(spritenum_t.SPR_FATT,0,4,think_t.A_Chase,statenum_t.S_FATT_RUN3,0,0),	// S_FATT_RUN2
    new state_t(spritenum_t.SPR_FATT,1,4,think_t.A_Chase,statenum_t.S_FATT_RUN4,0,0),	// S_FATT_RUN3
    new state_t(spritenum_t.SPR_FATT,1,4,think_t.A_Chase,statenum_t.S_FATT_RUN5,0,0),	// S_FATT_RUN4
    new state_t(spritenum_t.SPR_FATT,2,4,think_t.A_Chase,statenum_t.S_FATT_RUN6,0,0),	// S_FATT_RUN5
    new state_t(spritenum_t.SPR_FATT,2,4,think_t.A_Chase,statenum_t.S_FATT_RUN7,0,0),	// S_FATT_RUN6
    new state_t(spritenum_t.SPR_FATT,3,4,think_t.A_Chase,statenum_t.S_FATT_RUN8,0,0),	// S_FATT_RUN7
    new state_t(spritenum_t.SPR_FATT,3,4,think_t.A_Chase,statenum_t.S_FATT_RUN9,0,0),	// S_FATT_RUN8
    new state_t(spritenum_t.SPR_FATT,4,4,think_t.A_Chase,statenum_t.S_FATT_RUN10,0,0),	// S_FATT_RUN9
    new state_t(spritenum_t.SPR_FATT,4,4,think_t.A_Chase,statenum_t.S_FATT_RUN11,0,0),	// S_FATT_RUN10
    new state_t(spritenum_t.SPR_FATT,5,4,think_t.A_Chase,statenum_t.S_FATT_RUN12,0,0),	// S_FATT_RUN11
    new state_t(spritenum_t.SPR_FATT,5,4,think_t.A_Chase,statenum_t.S_FATT_RUN1,0,0),	// S_FATT_RUN12
    new state_t(spritenum_t.SPR_FATT,6,20,think_t.A_FatRaise,statenum_t.S_FATT_ATK2,0,0),	// S_FATT_ATK1
    new state_t(spritenum_t.SPR_FATT,32775,10,think_t.A_FatAttack1,statenum_t.S_FATT_ATK3,0,0),	// S_FATT_ATK2
    new state_t(spritenum_t.SPR_FATT,8,5,think_t.A_FaceTarget,statenum_t.S_FATT_ATK4,0,0),	// S_FATT_ATK3
    new state_t(spritenum_t.SPR_FATT,6,5,think_t.A_FaceTarget,statenum_t.S_FATT_ATK5,0,0),	// S_FATT_ATK4
    new state_t(spritenum_t.SPR_FATT,32775,10,think_t.A_FatAttack2,statenum_t.S_FATT_ATK6,0,0),	// S_FATT_ATK5
    new state_t(spritenum_t.SPR_FATT,8,5,think_t.A_FaceTarget,statenum_t.S_FATT_ATK7,0,0),	// S_FATT_ATK6
    new state_t(spritenum_t.SPR_FATT,6,5,think_t.A_FaceTarget,statenum_t.S_FATT_ATK8,0,0),	// S_FATT_ATK7
    new state_t(spritenum_t.SPR_FATT,32775,10,think_t.A_FatAttack3,statenum_t.S_FATT_ATK9,0,0),	// S_FATT_ATK8
    new state_t(spritenum_t.SPR_FATT,8,5,think_t.A_FaceTarget,statenum_t.S_FATT_ATK10,0,0),	// S_FATT_ATK9
    new state_t(spritenum_t.SPR_FATT,6,5,think_t.A_FaceTarget,statenum_t.S_FATT_RUN1,0,0),	// S_FATT_ATK10
    new state_t(spritenum_t.SPR_FATT,9,3,null,statenum_t.S_FATT_PAIN2,0,0),	// S_FATT_PAIN
    new state_t(spritenum_t.SPR_FATT,9,3,think_t.A_Pain,statenum_t.S_FATT_RUN1,0,0),	// S_FATT_PAIN2
    new state_t(spritenum_t.SPR_FATT,10,6,null,statenum_t.S_FATT_DIE2,0,0),	// S_FATT_DIE1
    new state_t(spritenum_t.SPR_FATT,11,6,think_t.A_Scream,statenum_t.S_FATT_DIE3,0,0),	// S_FATT_DIE2
    new state_t(spritenum_t.SPR_FATT,12,6,think_t.A_Fall,statenum_t.S_FATT_DIE4,0,0),	// S_FATT_DIE3
    new state_t(spritenum_t.SPR_FATT,13,6,null,statenum_t.S_FATT_DIE5,0,0),	// S_FATT_DIE4
    new state_t(spritenum_t.SPR_FATT,14,6,null,statenum_t.S_FATT_DIE6,0,0),	// S_FATT_DIE5
    new state_t(spritenum_t.SPR_FATT,15,6,null,statenum_t.S_FATT_DIE7,0,0),	// S_FATT_DIE6
    new state_t(spritenum_t.SPR_FATT,16,6,null,statenum_t.S_FATT_DIE8,0,0),	// S_FATT_DIE7
    new state_t(spritenum_t.SPR_FATT,17,6,null,statenum_t.S_FATT_DIE9,0,0),	// S_FATT_DIE8
    new state_t(spritenum_t.SPR_FATT,18,6,null,statenum_t.S_FATT_DIE10,0,0),	// S_FATT_DIE9
    new state_t(spritenum_t.SPR_FATT,19,-1,think_t.A_BossDeath,statenum_t.S_NULL,0,0),	// S_FATT_DIE10
    new state_t(spritenum_t.SPR_FATT,17,5,null,statenum_t.S_FATT_RAISE2,0,0),	// S_FATT_RAISE1
    new state_t(spritenum_t.SPR_FATT,16,5,null,statenum_t.S_FATT_RAISE3,0,0),	// S_FATT_RAISE2
    new state_t(spritenum_t.SPR_FATT,15,5,null,statenum_t.S_FATT_RAISE4,0,0),	// S_FATT_RAISE3
    new state_t(spritenum_t.SPR_FATT,14,5,null,statenum_t.S_FATT_RAISE5,0,0),	// S_FATT_RAISE4
    new state_t(spritenum_t.SPR_FATT,13,5,null,statenum_t.S_FATT_RAISE6,0,0),	// S_FATT_RAISE5
    new state_t(spritenum_t.SPR_FATT,12,5,null,statenum_t.S_FATT_RAISE7,0,0),	// S_FATT_RAISE6
    new state_t(spritenum_t.SPR_FATT,11,5,null,statenum_t.S_FATT_RAISE8,0,0),	// S_FATT_RAISE7
    new state_t(spritenum_t.SPR_FATT,10,5,null,statenum_t.S_FATT_RUN1,0,0),	// S_FATT_RAISE8
    new state_t(spritenum_t.SPR_CPOS,0,10,think_t.A_Look,statenum_t.S_CPOS_STND2,0,0),	// S_CPOS_STND
    new state_t(spritenum_t.SPR_CPOS,1,10,think_t.A_Look,statenum_t.S_CPOS_STND,0,0),	// S_CPOS_STND2
    new state_t(spritenum_t.SPR_CPOS,0,3,think_t.A_Chase,statenum_t.S_CPOS_RUN2,0,0),	// S_CPOS_RUN1
    new state_t(spritenum_t.SPR_CPOS,0,3,think_t.A_Chase,statenum_t.S_CPOS_RUN3,0,0),	// S_CPOS_RUN2
    new state_t(spritenum_t.SPR_CPOS,1,3,think_t.A_Chase,statenum_t.S_CPOS_RUN4,0,0),	// S_CPOS_RUN3
    new state_t(spritenum_t.SPR_CPOS,1,3,think_t.A_Chase,statenum_t.S_CPOS_RUN5,0,0),	// S_CPOS_RUN4
    new state_t(spritenum_t.SPR_CPOS,2,3,think_t.A_Chase,statenum_t.S_CPOS_RUN6,0,0),	// S_CPOS_RUN5
    new state_t(spritenum_t.SPR_CPOS,2,3,think_t.A_Chase,statenum_t.S_CPOS_RUN7,0,0),	// S_CPOS_RUN6
    new state_t(spritenum_t.SPR_CPOS,3,3,think_t.A_Chase,statenum_t.S_CPOS_RUN8,0,0),	// S_CPOS_RUN7
    new state_t(spritenum_t.SPR_CPOS,3,3,think_t.A_Chase,statenum_t.S_CPOS_RUN1,0,0),	// S_CPOS_RUN8
    new state_t(spritenum_t.SPR_CPOS,4,10,think_t.A_FaceTarget,statenum_t.S_CPOS_ATK2,0,0),	// S_CPOS_ATK1
    new state_t(spritenum_t.SPR_CPOS,32773,4,think_t.A_CPosAttack,statenum_t.S_CPOS_ATK3,0,0),	// S_CPOS_ATK2
    new state_t(spritenum_t.SPR_CPOS,32772,4,think_t.A_CPosAttack,statenum_t.S_CPOS_ATK4,0,0),	// S_CPOS_ATK3
    new state_t(spritenum_t.SPR_CPOS,5,1,think_t.A_CPosRefire,statenum_t.S_CPOS_ATK2,0,0),	// S_CPOS_ATK4
    new state_t(spritenum_t.SPR_CPOS,6,3,null,statenum_t.S_CPOS_PAIN2,0,0),	// S_CPOS_PAIN
    new state_t(spritenum_t.SPR_CPOS,6,3,think_t.A_Pain,statenum_t.S_CPOS_RUN1,0,0),	// S_CPOS_PAIN2
    new state_t(spritenum_t.SPR_CPOS,7,5,null,statenum_t.S_CPOS_DIE2,0,0),	// S_CPOS_DIE1
    new state_t(spritenum_t.SPR_CPOS,8,5,think_t.A_Scream,statenum_t.S_CPOS_DIE3,0,0),	// S_CPOS_DIE2
    new state_t(spritenum_t.SPR_CPOS,9,5,think_t.A_Fall,statenum_t.S_CPOS_DIE4,0,0),	// S_CPOS_DIE3
    new state_t(spritenum_t.SPR_CPOS,10,5,null,statenum_t.S_CPOS_DIE5,0,0),	// S_CPOS_DIE4
    new state_t(spritenum_t.SPR_CPOS,11,5,null,statenum_t.S_CPOS_DIE6,0,0),	// S_CPOS_DIE5
    new state_t(spritenum_t.SPR_CPOS,12,5,null,statenum_t.S_CPOS_DIE7,0,0),	// S_CPOS_DIE6
    new state_t(spritenum_t.SPR_CPOS,13,-1,null,statenum_t.S_NULL,0,0),	// S_CPOS_DIE7
    new state_t(spritenum_t.SPR_CPOS,14,5,null,statenum_t.S_CPOS_XDIE2,0,0),	// S_CPOS_XDIE1
    new state_t(spritenum_t.SPR_CPOS,15,5,think_t.A_XScream,statenum_t.S_CPOS_XDIE3,0,0),	// S_CPOS_XDIE2
    new state_t(spritenum_t.SPR_CPOS,16,5,think_t.A_Fall,statenum_t.S_CPOS_XDIE4,0,0),	// S_CPOS_XDIE3
    new state_t(spritenum_t.SPR_CPOS,17,5,null,statenum_t.S_CPOS_XDIE5,0,0),	// S_CPOS_XDIE4
    new state_t(spritenum_t.SPR_CPOS,18,5,null,statenum_t.S_CPOS_XDIE6,0,0),	// S_CPOS_XDIE5
    new state_t(spritenum_t.SPR_CPOS,19,-1,null,statenum_t.S_NULL,0,0),	// S_CPOS_XDIE6
    new state_t(spritenum_t.SPR_CPOS,13,5,null,statenum_t.S_CPOS_RAISE2,0,0),	// S_CPOS_RAISE1
    new state_t(spritenum_t.SPR_CPOS,12,5,null,statenum_t.S_CPOS_RAISE3,0,0),	// S_CPOS_RAISE2
    new state_t(spritenum_t.SPR_CPOS,11,5,null,statenum_t.S_CPOS_RAISE4,0,0),	// S_CPOS_RAISE3
    new state_t(spritenum_t.SPR_CPOS,10,5,null,statenum_t.S_CPOS_RAISE5,0,0),	// S_CPOS_RAISE4
    new state_t(spritenum_t.SPR_CPOS,9,5,null,statenum_t.S_CPOS_RAISE6,0,0),	// S_CPOS_RAISE5
    new state_t(spritenum_t.SPR_CPOS,8,5,null,statenum_t.S_CPOS_RAISE7,0,0),	// S_CPOS_RAISE6
    new state_t(spritenum_t.SPR_CPOS,7,5,null,statenum_t.S_CPOS_RUN1,0,0),	// S_CPOS_RAISE7
    new state_t(spritenum_t.SPR_TROO,0,10,think_t.A_Look,statenum_t.S_TROO_STND2,0,0),	// S_TROO_STND
    new state_t(spritenum_t.SPR_TROO,1,10,think_t.A_Look,statenum_t.S_TROO_STND,0,0),	// S_TROO_STND2
    new state_t(spritenum_t.SPR_TROO,0,3,think_t.A_Chase,statenum_t.S_TROO_RUN2,0,0),	// S_TROO_RUN1
    new state_t(spritenum_t.SPR_TROO,0,3,think_t.A_Chase,statenum_t.S_TROO_RUN3,0,0),	// S_TROO_RUN2
    new state_t(spritenum_t.SPR_TROO,1,3,think_t.A_Chase,statenum_t.S_TROO_RUN4,0,0),	// S_TROO_RUN3
    new state_t(spritenum_t.SPR_TROO,1,3,think_t.A_Chase,statenum_t.S_TROO_RUN5,0,0),	// S_TROO_RUN4
    new state_t(spritenum_t.SPR_TROO,2,3,think_t.A_Chase,statenum_t.S_TROO_RUN6,0,0),	// S_TROO_RUN5
    new state_t(spritenum_t.SPR_TROO,2,3,think_t.A_Chase,statenum_t.S_TROO_RUN7,0,0),	// S_TROO_RUN6
    new state_t(spritenum_t.SPR_TROO,3,3,think_t.A_Chase,statenum_t.S_TROO_RUN8,0,0),	// S_TROO_RUN7
    new state_t(spritenum_t.SPR_TROO,3,3,think_t.A_Chase,statenum_t.S_TROO_RUN1,0,0),	// S_TROO_RUN8
    new state_t(spritenum_t.SPR_TROO,4,8,think_t.A_FaceTarget,statenum_t.S_TROO_ATK2,0,0),	// S_TROO_ATK1
    new state_t(spritenum_t.SPR_TROO,5,8,think_t.A_FaceTarget,statenum_t.S_TROO_ATK3,0,0),	// S_TROO_ATK2
    new state_t(spritenum_t.SPR_TROO,6,6,think_t.A_TroopAttack,statenum_t.S_TROO_RUN1,0,0),	// S_TROO_ATK3
    new state_t(spritenum_t.SPR_TROO,7,2,null,statenum_t.S_TROO_PAIN2,0,0),	// S_TROO_PAIN
    new state_t(spritenum_t.SPR_TROO,7,2,think_t.A_Pain,statenum_t.S_TROO_RUN1,0,0),	// S_TROO_PAIN2
    new state_t(spritenum_t.SPR_TROO,8,8,null,statenum_t.S_TROO_DIE2,0,0),	// S_TROO_DIE1
    new state_t(spritenum_t.SPR_TROO,9,8,think_t.A_Scream,statenum_t.S_TROO_DIE3,0,0),	// S_TROO_DIE2
    new state_t(spritenum_t.SPR_TROO,10,6,null,statenum_t.S_TROO_DIE4,0,0),	// S_TROO_DIE3
    new state_t(spritenum_t.SPR_TROO,11,6,think_t.A_Fall,statenum_t.S_TROO_DIE5,0,0),	// S_TROO_DIE4
    new state_t(spritenum_t.SPR_TROO,12,-1,null,statenum_t.S_NULL,0,0),	// S_TROO_DIE5
    new state_t(spritenum_t.SPR_TROO,13,5,null,statenum_t.S_TROO_XDIE2,0,0),	// S_TROO_XDIE1
    new state_t(spritenum_t.SPR_TROO,14,5,think_t.A_XScream,statenum_t.S_TROO_XDIE3,0,0),	// S_TROO_XDIE2
    new state_t(spritenum_t.SPR_TROO,15,5,null,statenum_t.S_TROO_XDIE4,0,0),	// S_TROO_XDIE3
    new state_t(spritenum_t.SPR_TROO,16,5,think_t.A_Fall,statenum_t.S_TROO_XDIE5,0,0),	// S_TROO_XDIE4
    new state_t(spritenum_t.SPR_TROO,17,5,null,statenum_t.S_TROO_XDIE6,0,0),	// S_TROO_XDIE5
    new state_t(spritenum_t.SPR_TROO,18,5,null,statenum_t.S_TROO_XDIE7,0,0),	// S_TROO_XDIE6
    new state_t(spritenum_t.SPR_TROO,19,5,null,statenum_t.S_TROO_XDIE8,0,0),	// S_TROO_XDIE7
    new state_t(spritenum_t.SPR_TROO,20,-1,null,statenum_t.S_NULL,0,0),	// S_TROO_XDIE8
    new state_t(spritenum_t.SPR_TROO,12,8,null,statenum_t.S_TROO_RAISE2,0,0),	// S_TROO_RAISE1
    new state_t(spritenum_t.SPR_TROO,11,8,null,statenum_t.S_TROO_RAISE3,0,0),	// S_TROO_RAISE2
    new state_t(spritenum_t.SPR_TROO,10,6,null,statenum_t.S_TROO_RAISE4,0,0),	// S_TROO_RAISE3
    new state_t(spritenum_t.SPR_TROO,9,6,null,statenum_t.S_TROO_RAISE5,0,0),	// S_TROO_RAISE4
    new state_t(spritenum_t.SPR_TROO,8,6,null,statenum_t.S_TROO_RUN1,0,0),	// S_TROO_RAISE5
    new state_t(spritenum_t.SPR_SARG,0,10,think_t.A_Look,statenum_t.S_SARG_STND2,0,0),	// S_SARG_STND
    new state_t(spritenum_t.SPR_SARG,1,10,think_t.A_Look,statenum_t.S_SARG_STND,0,0),	// S_SARG_STND2
    new state_t(spritenum_t.SPR_SARG,0,2,think_t.A_Chase,statenum_t.S_SARG_RUN2,0,0),	// S_SARG_RUN1
    new state_t(spritenum_t.SPR_SARG,0,2,think_t.A_Chase,statenum_t.S_SARG_RUN3,0,0),	// S_SARG_RUN2
    new state_t(spritenum_t.SPR_SARG,1,2,think_t.A_Chase,statenum_t.S_SARG_RUN4,0,0),	// S_SARG_RUN3
    new state_t(spritenum_t.SPR_SARG,1,2,think_t.A_Chase,statenum_t.S_SARG_RUN5,0,0),	// S_SARG_RUN4
    new state_t(spritenum_t.SPR_SARG,2,2,think_t.A_Chase,statenum_t.S_SARG_RUN6,0,0),	// S_SARG_RUN5
    new state_t(spritenum_t.SPR_SARG,2,2,think_t.A_Chase,statenum_t.S_SARG_RUN7,0,0),	// S_SARG_RUN6
    new state_t(spritenum_t.SPR_SARG,3,2,think_t.A_Chase,statenum_t.S_SARG_RUN8,0,0),	// S_SARG_RUN7
    new state_t(spritenum_t.SPR_SARG,3,2,think_t.A_Chase,statenum_t.S_SARG_RUN1,0,0),	// S_SARG_RUN8
    new state_t(spritenum_t.SPR_SARG,4,8,think_t.A_FaceTarget,statenum_t.S_SARG_ATK2,0,0),	// S_SARG_ATK1
    new state_t(spritenum_t.SPR_SARG,5,8,think_t.A_FaceTarget,statenum_t.S_SARG_ATK3,0,0),	// S_SARG_ATK2
    new state_t(spritenum_t.SPR_SARG,6,8,think_t.A_SargAttack,statenum_t.S_SARG_RUN1,0,0),	// S_SARG_ATK3
    new state_t(spritenum_t.SPR_SARG,7,2,null,statenum_t.S_SARG_PAIN2,0,0),	// S_SARG_PAIN
    new state_t(spritenum_t.SPR_SARG,7,2,think_t.A_Pain,statenum_t.S_SARG_RUN1,0,0),	// S_SARG_PAIN2
    new state_t(spritenum_t.SPR_SARG,8,8,null,statenum_t.S_SARG_DIE2,0,0),	// S_SARG_DIE1
    new state_t(spritenum_t.SPR_SARG,9,8,think_t.A_Scream,statenum_t.S_SARG_DIE3,0,0),	// S_SARG_DIE2
    new state_t(spritenum_t.SPR_SARG,10,4,null,statenum_t.S_SARG_DIE4,0,0),	// S_SARG_DIE3
    new state_t(spritenum_t.SPR_SARG,11,4,think_t.A_Fall,statenum_t.S_SARG_DIE5,0,0),	// S_SARG_DIE4
    new state_t(spritenum_t.SPR_SARG,12,4,null,statenum_t.S_SARG_DIE6,0,0),	// S_SARG_DIE5
    new state_t(spritenum_t.SPR_SARG,13,-1,null,statenum_t.S_NULL,0,0),	// S_SARG_DIE6
    new state_t(spritenum_t.SPR_SARG,13,5,null,statenum_t.S_SARG_RAISE2,0,0),	// S_SARG_RAISE1
    new state_t(spritenum_t.SPR_SARG,12,5,null,statenum_t.S_SARG_RAISE3,0,0),	// S_SARG_RAISE2
    new state_t(spritenum_t.SPR_SARG,11,5,null,statenum_t.S_SARG_RAISE4,0,0),	// S_SARG_RAISE3
    new state_t(spritenum_t.SPR_SARG,10,5,null,statenum_t.S_SARG_RAISE5,0,0),	// S_SARG_RAISE4
    new state_t(spritenum_t.SPR_SARG,9,5,null,statenum_t.S_SARG_RAISE6,0,0),	// S_SARG_RAISE5
    new state_t(spritenum_t.SPR_SARG,8,5,null,statenum_t.S_SARG_RUN1,0,0),	// S_SARG_RAISE6
    new state_t(spritenum_t.SPR_HEAD,0,10,think_t.A_Look,statenum_t.S_HEAD_STND,0,0),	// S_HEAD_STND
    new state_t(spritenum_t.SPR_HEAD,0,3,think_t.A_Chase,statenum_t.S_HEAD_RUN1,0,0),	// S_HEAD_RUN1
    new state_t(spritenum_t.SPR_HEAD,1,5,think_t.A_FaceTarget,statenum_t.S_HEAD_ATK2,0,0),	// S_HEAD_ATK1
    new state_t(spritenum_t.SPR_HEAD,2,5,think_t.A_FaceTarget,statenum_t.S_HEAD_ATK3,0,0),	// S_HEAD_ATK2
    new state_t(spritenum_t.SPR_HEAD,32771,5,think_t.A_HeadAttack,statenum_t.S_HEAD_RUN1,0,0),	// S_HEAD_ATK3
    new state_t(spritenum_t.SPR_HEAD,4,3,null,statenum_t.S_HEAD_PAIN2,0,0),	// S_HEAD_PAIN
    new state_t(spritenum_t.SPR_HEAD,4,3,think_t.A_Pain,statenum_t.S_HEAD_PAIN3,0,0),	// S_HEAD_PAIN2
    new state_t(spritenum_t.SPR_HEAD,5,6,null,statenum_t.S_HEAD_RUN1,0,0),	// S_HEAD_PAIN3
    new state_t(spritenum_t.SPR_HEAD,6,8,null,statenum_t.S_HEAD_DIE2,0,0),	// S_HEAD_DIE1
    new state_t(spritenum_t.SPR_HEAD,7,8,think_t.A_Scream,statenum_t.S_HEAD_DIE3,0,0),	// S_HEAD_DIE2
    new state_t(spritenum_t.SPR_HEAD,8,8,null,statenum_t.S_HEAD_DIE4,0,0),	// S_HEAD_DIE3
    new state_t(spritenum_t.SPR_HEAD,9,8,null,statenum_t.S_HEAD_DIE5,0,0),	// S_HEAD_DIE4
    new state_t(spritenum_t.SPR_HEAD,10,8,think_t.A_Fall,statenum_t.S_HEAD_DIE6,0,0),	// S_HEAD_DIE5
    new state_t(spritenum_t.SPR_HEAD,11,-1,null,statenum_t.S_NULL,0,0),	// S_HEAD_DIE6
    new state_t(spritenum_t.SPR_HEAD,11,8,null,statenum_t.S_HEAD_RAISE2,0,0),	// S_HEAD_RAISE1
    new state_t(spritenum_t.SPR_HEAD,10,8,null,statenum_t.S_HEAD_RAISE3,0,0),	// S_HEAD_RAISE2
    new state_t(spritenum_t.SPR_HEAD,9,8,null,statenum_t.S_HEAD_RAISE4,0,0),	// S_HEAD_RAISE3
    new state_t(spritenum_t.SPR_HEAD,8,8,null,statenum_t.S_HEAD_RAISE5,0,0),	// S_HEAD_RAISE4
    new state_t(spritenum_t.SPR_HEAD,7,8,null,statenum_t.S_HEAD_RAISE6,0,0),	// S_HEAD_RAISE5
    new state_t(spritenum_t.SPR_HEAD,6,8,null,statenum_t.S_HEAD_RUN1,0,0),	// S_HEAD_RAISE6
    new state_t(spritenum_t.SPR_BAL7,32768,4,null,statenum_t.S_BRBALL2,0,0),	// S_BRBALL1
    new state_t(spritenum_t.SPR_BAL7,32769,4,null,statenum_t.S_BRBALL1,0,0),	// S_BRBALL2
    new state_t(spritenum_t.SPR_BAL7,32770,6,null,statenum_t.S_BRBALLX2,0,0),	// S_BRBALLX1
    new state_t(spritenum_t.SPR_BAL7,32771,6,null,statenum_t.S_BRBALLX3,0,0),	// S_BRBALLX2
    new state_t(spritenum_t.SPR_BAL7,32772,6,null,statenum_t.S_NULL,0,0),	// S_BRBALLX3
    new state_t(spritenum_t.SPR_BOSS,0,10,think_t.A_Look,statenum_t.S_BOSS_STND2,0,0),	// S_BOSS_STND
    new state_t(spritenum_t.SPR_BOSS,1,10,think_t.A_Look,statenum_t.S_BOSS_STND,0,0),	// S_BOSS_STND2
    new state_t(spritenum_t.SPR_BOSS,0,3,think_t.A_Chase,statenum_t.S_BOSS_RUN2,0,0),	// S_BOSS_RUN1
    new state_t(spritenum_t.SPR_BOSS,0,3,think_t.A_Chase,statenum_t.S_BOSS_RUN3,0,0),	// S_BOSS_RUN2
    new state_t(spritenum_t.SPR_BOSS,1,3,think_t.A_Chase,statenum_t.S_BOSS_RUN4,0,0),	// S_BOSS_RUN3
    new state_t(spritenum_t.SPR_BOSS,1,3,think_t.A_Chase,statenum_t.S_BOSS_RUN5,0,0),	// S_BOSS_RUN4
    new state_t(spritenum_t.SPR_BOSS,2,3,think_t.A_Chase,statenum_t.S_BOSS_RUN6,0,0),	// S_BOSS_RUN5
    new state_t(spritenum_t.SPR_BOSS,2,3,think_t.A_Chase,statenum_t.S_BOSS_RUN7,0,0),	// S_BOSS_RUN6
    new state_t(spritenum_t.SPR_BOSS,3,3,think_t.A_Chase,statenum_t.S_BOSS_RUN8,0,0),	// S_BOSS_RUN7
    new state_t(spritenum_t.SPR_BOSS,3,3,think_t.A_Chase,statenum_t.S_BOSS_RUN1,0,0),	// S_BOSS_RUN8
    new state_t(spritenum_t.SPR_BOSS,4,8,think_t.A_FaceTarget,statenum_t.S_BOSS_ATK2,0,0),	// S_BOSS_ATK1
    new state_t(spritenum_t.SPR_BOSS,5,8,think_t.A_FaceTarget,statenum_t.S_BOSS_ATK3,0,0),	// S_BOSS_ATK2
    new state_t(spritenum_t.SPR_BOSS,6,8,think_t.A_BruisAttack,statenum_t.S_BOSS_RUN1,0,0),	// S_BOSS_ATK3
    new state_t(spritenum_t.SPR_BOSS,7,2,null,statenum_t.S_BOSS_PAIN2,0,0),	// S_BOSS_PAIN
    new state_t(spritenum_t.SPR_BOSS,7,2,think_t.A_Pain,statenum_t.S_BOSS_RUN1,0,0),	// S_BOSS_PAIN2
    new state_t(spritenum_t.SPR_BOSS,8,8,null,statenum_t.S_BOSS_DIE2,0,0),	// S_BOSS_DIE1
    new state_t(spritenum_t.SPR_BOSS,9,8,think_t.A_Scream,statenum_t.S_BOSS_DIE3,0,0),	// S_BOSS_DIE2
    new state_t(spritenum_t.SPR_BOSS,10,8,null,statenum_t.S_BOSS_DIE4,0,0),	// S_BOSS_DIE3
    new state_t(spritenum_t.SPR_BOSS,11,8,think_t.A_Fall,statenum_t.S_BOSS_DIE5,0,0),	// S_BOSS_DIE4
    new state_t(spritenum_t.SPR_BOSS,12,8,null,statenum_t.S_BOSS_DIE6,0,0),	// S_BOSS_DIE5
    new state_t(spritenum_t.SPR_BOSS,13,8,null,statenum_t.S_BOSS_DIE7,0,0),	// S_BOSS_DIE6
    new state_t(spritenum_t.SPR_BOSS,14,-1,think_t.A_BossDeath,statenum_t.S_NULL,0,0),	// S_BOSS_DIE7
    new state_t(spritenum_t.SPR_BOSS,14,8,null,statenum_t.S_BOSS_RAISE2,0,0),	// S_BOSS_RAISE1
    new state_t(spritenum_t.SPR_BOSS,13,8,null,statenum_t.S_BOSS_RAISE3,0,0),	// S_BOSS_RAISE2
    new state_t(spritenum_t.SPR_BOSS,12,8,null,statenum_t.S_BOSS_RAISE4,0,0),	// S_BOSS_RAISE3
    new state_t(spritenum_t.SPR_BOSS,11,8,null,statenum_t.S_BOSS_RAISE5,0,0),	// S_BOSS_RAISE4
    new state_t(spritenum_t.SPR_BOSS,10,8,null,statenum_t.S_BOSS_RAISE6,0,0),	// S_BOSS_RAISE5
    new state_t(spritenum_t.SPR_BOSS,9,8,null,statenum_t.S_BOSS_RAISE7,0,0),	// S_BOSS_RAISE6
    new state_t(spritenum_t.SPR_BOSS,8,8,null,statenum_t.S_BOSS_RUN1,0,0),	// S_BOSS_RAISE7
    new state_t(spritenum_t.SPR_BOS2,0,10,think_t.A_Look,statenum_t.S_BOS2_STND2,0,0),	// S_BOS2_STND
    new state_t(spritenum_t.SPR_BOS2,1,10,think_t.A_Look,statenum_t.S_BOS2_STND,0,0),	// S_BOS2_STND2
    new state_t(spritenum_t.SPR_BOS2,0,3,think_t.A_Chase,statenum_t.S_BOS2_RUN2,0,0),	// S_BOS2_RUN1
    new state_t(spritenum_t.SPR_BOS2,0,3,think_t.A_Chase,statenum_t.S_BOS2_RUN3,0,0),	// S_BOS2_RUN2
    new state_t(spritenum_t.SPR_BOS2,1,3,think_t.A_Chase,statenum_t.S_BOS2_RUN4,0,0),	// S_BOS2_RUN3
    new state_t(spritenum_t.SPR_BOS2,1,3,think_t.A_Chase,statenum_t.S_BOS2_RUN5,0,0),	// S_BOS2_RUN4
    new state_t(spritenum_t.SPR_BOS2,2,3,think_t.A_Chase,statenum_t.S_BOS2_RUN6,0,0),	// S_BOS2_RUN5
    new state_t(spritenum_t.SPR_BOS2,2,3,think_t.A_Chase,statenum_t.S_BOS2_RUN7,0,0),	// S_BOS2_RUN6
    new state_t(spritenum_t.SPR_BOS2,3,3,think_t.A_Chase,statenum_t.S_BOS2_RUN8,0,0),	// S_BOS2_RUN7
    new state_t(spritenum_t.SPR_BOS2,3,3,think_t.A_Chase,statenum_t.S_BOS2_RUN1,0,0),	// S_BOS2_RUN8
    new state_t(spritenum_t.SPR_BOS2,4,8,think_t.A_FaceTarget,statenum_t.S_BOS2_ATK2,0,0),	// S_BOS2_ATK1
    new state_t(spritenum_t.SPR_BOS2,5,8,think_t.A_FaceTarget,statenum_t.S_BOS2_ATK3,0,0),	// S_BOS2_ATK2
    new state_t(spritenum_t.SPR_BOS2,6,8,think_t.A_BruisAttack,statenum_t.S_BOS2_RUN1,0,0),	// S_BOS2_ATK3
    new state_t(spritenum_t.SPR_BOS2,7,2,null,statenum_t.S_BOS2_PAIN2,0,0),	// S_BOS2_PAIN
    new state_t(spritenum_t.SPR_BOS2,7,2,think_t.A_Pain,statenum_t.S_BOS2_RUN1,0,0),	// S_BOS2_PAIN2
    new state_t(spritenum_t.SPR_BOS2,8,8,null,statenum_t.S_BOS2_DIE2,0,0),	// S_BOS2_DIE1
    new state_t(spritenum_t.SPR_BOS2,9,8,think_t.A_Scream,statenum_t.S_BOS2_DIE3,0,0),	// S_BOS2_DIE2
    new state_t(spritenum_t.SPR_BOS2,10,8,null,statenum_t.S_BOS2_DIE4,0,0),	// S_BOS2_DIE3
    new state_t(spritenum_t.SPR_BOS2,11,8,think_t.A_Fall,statenum_t.S_BOS2_DIE5,0,0),	// S_BOS2_DIE4
    new state_t(spritenum_t.SPR_BOS2,12,8,null,statenum_t.S_BOS2_DIE6,0,0),	// S_BOS2_DIE5
    new state_t(spritenum_t.SPR_BOS2,13,8,null,statenum_t.S_BOS2_DIE7,0,0),	// S_BOS2_DIE6
    new state_t(spritenum_t.SPR_BOS2,14,-1,null,statenum_t.S_NULL,0,0),	// S_BOS2_DIE7
    new state_t(spritenum_t.SPR_BOS2,14,8,null,statenum_t.S_BOS2_RAISE2,0,0),	// S_BOS2_RAISE1
    new state_t(spritenum_t.SPR_BOS2,13,8,null,statenum_t.S_BOS2_RAISE3,0,0),	// S_BOS2_RAISE2
    new state_t(spritenum_t.SPR_BOS2,12,8,null,statenum_t.S_BOS2_RAISE4,0,0),	// S_BOS2_RAISE3
    new state_t(spritenum_t.SPR_BOS2,11,8,null,statenum_t.S_BOS2_RAISE5,0,0),	// S_BOS2_RAISE4
    new state_t(spritenum_t.SPR_BOS2,10,8,null,statenum_t.S_BOS2_RAISE6,0,0),	// S_BOS2_RAISE5
    new state_t(spritenum_t.SPR_BOS2,9,8,null,statenum_t.S_BOS2_RAISE7,0,0),	// S_BOS2_RAISE6
    new state_t(spritenum_t.SPR_BOS2,8,8,null,statenum_t.S_BOS2_RUN1,0,0),	// S_BOS2_RAISE7
    new state_t(spritenum_t.SPR_SKUL,32768,10,think_t.A_Look,statenum_t.S_SKULL_STND2,0,0),	// S_SKULL_STND
    new state_t(spritenum_t.SPR_SKUL,32769,10,think_t.A_Look,statenum_t.S_SKULL_STND,0,0),	// S_SKULL_STND2
    new state_t(spritenum_t.SPR_SKUL,32768,6,think_t.A_Chase,statenum_t.S_SKULL_RUN2,0,0),	// S_SKULL_RUN1
    new state_t(spritenum_t.SPR_SKUL,32769,6,think_t.A_Chase,statenum_t.S_SKULL_RUN1,0,0),	// S_SKULL_RUN2
    new state_t(spritenum_t.SPR_SKUL,32770,10,think_t.A_FaceTarget,statenum_t.S_SKULL_ATK2,0,0),	// S_SKULL_ATK1
    new state_t(spritenum_t.SPR_SKUL,32771,4,think_t.A_SkullAttack,statenum_t.S_SKULL_ATK3,0,0),	// S_SKULL_ATK2
    new state_t(spritenum_t.SPR_SKUL,32770,4,null,statenum_t.S_SKULL_ATK4,0,0),	// S_SKULL_ATK3
    new state_t(spritenum_t.SPR_SKUL,32771,4,null,statenum_t.S_SKULL_ATK3,0,0),	// S_SKULL_ATK4
    new state_t(spritenum_t.SPR_SKUL,32772,3,null,statenum_t.S_SKULL_PAIN2,0,0),	// S_SKULL_PAIN
    new state_t(spritenum_t.SPR_SKUL,32772,3,think_t.A_Pain,statenum_t.S_SKULL_RUN1,0,0),	// S_SKULL_PAIN2
    new state_t(spritenum_t.SPR_SKUL,32773,6,null,statenum_t.S_SKULL_DIE2,0,0),	// S_SKULL_DIE1
    new state_t(spritenum_t.SPR_SKUL,32774,6,think_t.A_Scream,statenum_t.S_SKULL_DIE3,0,0),	// S_SKULL_DIE2
    new state_t(spritenum_t.SPR_SKUL,32775,6,null,statenum_t.S_SKULL_DIE4,0,0),	// S_SKULL_DIE3
    new state_t(spritenum_t.SPR_SKUL,32776,6,think_t.A_Fall,statenum_t.S_SKULL_DIE5,0,0),	// S_SKULL_DIE4
    new state_t(spritenum_t.SPR_SKUL,9,6,null,statenum_t.S_SKULL_DIE6,0,0),	// S_SKULL_DIE5
    new state_t(spritenum_t.SPR_SKUL,10,6,null,statenum_t.S_NULL,0,0),	// S_SKULL_DIE6
    new state_t(spritenum_t.SPR_SPID,0,10,think_t.A_Look,statenum_t.S_SPID_STND2,0,0),	// S_SPID_STND
    new state_t(spritenum_t.SPR_SPID,1,10,think_t.A_Look,statenum_t.S_SPID_STND,0,0),	// S_SPID_STND2
    new state_t(spritenum_t.SPR_SPID,0,3,think_t.A_Metal,statenum_t.S_SPID_RUN2,0,0),	// S_SPID_RUN1
    new state_t(spritenum_t.SPR_SPID,0,3,think_t.A_Chase,statenum_t.S_SPID_RUN3,0,0),	// S_SPID_RUN2
    new state_t(spritenum_t.SPR_SPID,1,3,think_t.A_Chase,statenum_t.S_SPID_RUN4,0,0),	// S_SPID_RUN3
    new state_t(spritenum_t.SPR_SPID,1,3,think_t.A_Chase,statenum_t.S_SPID_RUN5,0,0),	// S_SPID_RUN4
    new state_t(spritenum_t.SPR_SPID,2,3,think_t.A_Metal,statenum_t.S_SPID_RUN6,0,0),	// S_SPID_RUN5
    new state_t(spritenum_t.SPR_SPID,2,3,think_t.A_Chase,statenum_t.S_SPID_RUN7,0,0),	// S_SPID_RUN6
    new state_t(spritenum_t.SPR_SPID,3,3,think_t.A_Chase,statenum_t.S_SPID_RUN8,0,0),	// S_SPID_RUN7
    new state_t(spritenum_t.SPR_SPID,3,3,think_t.A_Chase,statenum_t.S_SPID_RUN9,0,0),	// S_SPID_RUN8
    new state_t(spritenum_t.SPR_SPID,4,3,think_t.A_Metal,statenum_t.S_SPID_RUN10,0,0),	// S_SPID_RUN9
    new state_t(spritenum_t.SPR_SPID,4,3,think_t.A_Chase,statenum_t.S_SPID_RUN11,0,0),	// S_SPID_RUN10
    new state_t(spritenum_t.SPR_SPID,5,3,think_t.A_Chase,statenum_t.S_SPID_RUN12,0,0),	// S_SPID_RUN11
    new state_t(spritenum_t.SPR_SPID,5,3,think_t.A_Chase,statenum_t.S_SPID_RUN1,0,0),	// S_SPID_RUN12
    new state_t(spritenum_t.SPR_SPID,32768,20,think_t.A_FaceTarget,statenum_t.S_SPID_ATK2,0,0),	// S_SPID_ATK1
    new state_t(spritenum_t.SPR_SPID,32774,4,think_t.A_SPosAttack,statenum_t.S_SPID_ATK3,0,0),	// S_SPID_ATK2
    new state_t(spritenum_t.SPR_SPID,32775,4,think_t.A_SPosAttack,statenum_t.S_SPID_ATK4,0,0),	// S_SPID_ATK3
    new state_t(spritenum_t.SPR_SPID,32775,1,think_t.A_SpidRefire,statenum_t.S_SPID_ATK2,0,0),	// S_SPID_ATK4
    new state_t(spritenum_t.SPR_SPID,8,3,null,statenum_t.S_SPID_PAIN2,0,0),	// S_SPID_PAIN
    new state_t(spritenum_t.SPR_SPID,8,3,think_t.A_Pain,statenum_t.S_SPID_RUN1,0,0),	// S_SPID_PAIN2
    new state_t(spritenum_t.SPR_SPID,9,20,think_t.A_Scream,statenum_t.S_SPID_DIE2,0,0),	// S_SPID_DIE1
    new state_t(spritenum_t.SPR_SPID,10,10,think_t.A_Fall,statenum_t.S_SPID_DIE3,0,0),	// S_SPID_DIE2
    new state_t(spritenum_t.SPR_SPID,11,10,null,statenum_t.S_SPID_DIE4,0,0),	// S_SPID_DIE3
    new state_t(spritenum_t.SPR_SPID,12,10,null,statenum_t.S_SPID_DIE5,0,0),	// S_SPID_DIE4
    new state_t(spritenum_t.SPR_SPID,13,10,null,statenum_t.S_SPID_DIE6,0,0),	// S_SPID_DIE5
    new state_t(spritenum_t.SPR_SPID,14,10,null,statenum_t.S_SPID_DIE7,0,0),	// S_SPID_DIE6
    new state_t(spritenum_t.SPR_SPID,15,10,null,statenum_t.S_SPID_DIE8,0,0),	// S_SPID_DIE7
    new state_t(spritenum_t.SPR_SPID,16,10,null,statenum_t.S_SPID_DIE9,0,0),	// S_SPID_DIE8
    new state_t(spritenum_t.SPR_SPID,17,10,null,statenum_t.S_SPID_DIE10,0,0),	// S_SPID_DIE9
    new state_t(spritenum_t.SPR_SPID,18,30,null,statenum_t.S_SPID_DIE11,0,0),	// S_SPID_DIE10
    new state_t(spritenum_t.SPR_SPID,18,-1,think_t.A_BossDeath,statenum_t.S_NULL,0,0),	// S_SPID_DIE11
    new state_t(spritenum_t.SPR_BSPI,0,10,think_t.A_Look,statenum_t.S_BSPI_STND2,0,0),	// S_BSPI_STND
    new state_t(spritenum_t.SPR_BSPI,1,10,think_t.A_Look,statenum_t.S_BSPI_STND,0,0),	// S_BSPI_STND2
    new state_t(spritenum_t.SPR_BSPI,0,20,null,statenum_t.S_BSPI_RUN1,0,0),	// S_BSPI_SIGHT
    new state_t(spritenum_t.SPR_BSPI,0,3,think_t.A_BabyMetal,statenum_t.S_BSPI_RUN2,0,0),	// S_BSPI_RUN1
    new state_t(spritenum_t.SPR_BSPI,0,3,think_t.A_Chase,statenum_t.S_BSPI_RUN3,0,0),	// S_BSPI_RUN2
    new state_t(spritenum_t.SPR_BSPI,1,3,think_t.A_Chase,statenum_t.S_BSPI_RUN4,0,0),	// S_BSPI_RUN3
    new state_t(spritenum_t.SPR_BSPI,1,3,think_t.A_Chase,statenum_t.S_BSPI_RUN5,0,0),	// S_BSPI_RUN4
    new state_t(spritenum_t.SPR_BSPI,2,3,think_t.A_Chase,statenum_t.S_BSPI_RUN6,0,0),	// S_BSPI_RUN5
    new state_t(spritenum_t.SPR_BSPI,2,3,think_t.A_Chase,statenum_t.S_BSPI_RUN7,0,0),	// S_BSPI_RUN6
    new state_t(spritenum_t.SPR_BSPI,3,3,think_t.A_BabyMetal,statenum_t.S_BSPI_RUN8,0,0),	// S_BSPI_RUN7
    new state_t(spritenum_t.SPR_BSPI,3,3,think_t.A_Chase,statenum_t.S_BSPI_RUN9,0,0),	// S_BSPI_RUN8
    new state_t(spritenum_t.SPR_BSPI,4,3,think_t.A_Chase,statenum_t.S_BSPI_RUN10,0,0),	// S_BSPI_RUN9
    new state_t(spritenum_t.SPR_BSPI,4,3,think_t.A_Chase,statenum_t.S_BSPI_RUN11,0,0),	// S_BSPI_RUN10
    new state_t(spritenum_t.SPR_BSPI,5,3,think_t.A_Chase,statenum_t.S_BSPI_RUN12,0,0),	// S_BSPI_RUN11
    new state_t(spritenum_t.SPR_BSPI,5,3,think_t.A_Chase,statenum_t.S_BSPI_RUN1,0,0),	// S_BSPI_RUN12
    new state_t(spritenum_t.SPR_BSPI,32768,20,think_t.A_FaceTarget,statenum_t.S_BSPI_ATK2,0,0),	// S_BSPI_ATK1
    new state_t(spritenum_t.SPR_BSPI,32774,4,think_t.A_BspiAttack,statenum_t.S_BSPI_ATK3,0,0),	// S_BSPI_ATK2
    new state_t(spritenum_t.SPR_BSPI,32775,4,null,statenum_t.S_BSPI_ATK4,0,0),	// S_BSPI_ATK3
    new state_t(spritenum_t.SPR_BSPI,32775,1,think_t.A_SpidRefire,statenum_t.S_BSPI_ATK2,0,0),	// S_BSPI_ATK4
    new state_t(spritenum_t.SPR_BSPI,8,3,null,statenum_t.S_BSPI_PAIN2,0,0),	// S_BSPI_PAIN
    new state_t(spritenum_t.SPR_BSPI,8,3,think_t.A_Pain,statenum_t.S_BSPI_RUN1,0,0),	// S_BSPI_PAIN2
    new state_t(spritenum_t.SPR_BSPI,9,20,think_t.A_Scream,statenum_t.S_BSPI_DIE2,0,0),	// S_BSPI_DIE1
    new state_t(spritenum_t.SPR_BSPI,10,7,think_t.A_Fall,statenum_t.S_BSPI_DIE3,0,0),	// S_BSPI_DIE2
    new state_t(spritenum_t.SPR_BSPI,11,7,null,statenum_t.S_BSPI_DIE4,0,0),	// S_BSPI_DIE3
    new state_t(spritenum_t.SPR_BSPI,12,7,null,statenum_t.S_BSPI_DIE5,0,0),	// S_BSPI_DIE4
    new state_t(spritenum_t.SPR_BSPI,13,7,null,statenum_t.S_BSPI_DIE6,0,0),	// S_BSPI_DIE5
    new state_t(spritenum_t.SPR_BSPI,14,7,null,statenum_t.S_BSPI_DIE7,0,0),	// S_BSPI_DIE6
    new state_t(spritenum_t.SPR_BSPI,15,-1,think_t.A_BossDeath,statenum_t.S_NULL,0,0),	// S_BSPI_DIE7
    new state_t(spritenum_t.SPR_BSPI,15,5,null,statenum_t.S_BSPI_RAISE2,0,0),	// S_BSPI_RAISE1
    new state_t(spritenum_t.SPR_BSPI,14,5,null,statenum_t.S_BSPI_RAISE3,0,0),	// S_BSPI_RAISE2
    new state_t(spritenum_t.SPR_BSPI,13,5,null,statenum_t.S_BSPI_RAISE4,0,0),	// S_BSPI_RAISE3
    new state_t(spritenum_t.SPR_BSPI,12,5,null,statenum_t.S_BSPI_RAISE5,0,0),	// S_BSPI_RAISE4
    new state_t(spritenum_t.SPR_BSPI,11,5,null,statenum_t.S_BSPI_RAISE6,0,0),	// S_BSPI_RAISE5
    new state_t(spritenum_t.SPR_BSPI,10,5,null,statenum_t.S_BSPI_RAISE7,0,0),	// S_BSPI_RAISE6
    new state_t(spritenum_t.SPR_BSPI,9,5,null,statenum_t.S_BSPI_RUN1,0,0),	// S_BSPI_RAISE7
    new state_t(spritenum_t.SPR_APLS,32768,5,null,statenum_t.S_ARACH_PLAZ2,0,0),	// S_ARACH_PLAZ
    new state_t(spritenum_t.SPR_APLS,32769,5,null,statenum_t.S_ARACH_PLAZ,0,0),	// S_ARACH_PLAZ2
    new state_t(spritenum_t.SPR_APBX,32768,5,null,statenum_t.S_ARACH_PLEX2,0,0),	// S_ARACH_PLEX
    new state_t(spritenum_t.SPR_APBX,32769,5,null,statenum_t.S_ARACH_PLEX3,0,0),	// S_ARACH_PLEX2
    new state_t(spritenum_t.SPR_APBX,32770,5,null,statenum_t.S_ARACH_PLEX4,0,0),	// S_ARACH_PLEX3
    new state_t(spritenum_t.SPR_APBX,32771,5,null,statenum_t.S_ARACH_PLEX5,0,0),	// S_ARACH_PLEX4
    new state_t(spritenum_t.SPR_APBX,32772,5,null,statenum_t.S_NULL,0,0),	// S_ARACH_PLEX5
    new state_t(spritenum_t.SPR_CYBR,0,10,think_t.A_Look,statenum_t.S_CYBER_STND2,0,0),	// S_CYBER_STND
    new state_t(spritenum_t.SPR_CYBR,1,10,think_t.A_Look,statenum_t.S_CYBER_STND,0,0),	// S_CYBER_STND2
    new state_t(spritenum_t.SPR_CYBR,0,3,think_t.A_Hoof,statenum_t.S_CYBER_RUN2,0,0),	// S_CYBER_RUN1
    new state_t(spritenum_t.SPR_CYBR,0,3,think_t.A_Chase,statenum_t.S_CYBER_RUN3,0,0),	// S_CYBER_RUN2
    new state_t(spritenum_t.SPR_CYBR,1,3,think_t.A_Chase,statenum_t.S_CYBER_RUN4,0,0),	// S_CYBER_RUN3
    new state_t(spritenum_t.SPR_CYBR,1,3,think_t.A_Chase,statenum_t.S_CYBER_RUN5,0,0),	// S_CYBER_RUN4
    new state_t(spritenum_t.SPR_CYBR,2,3,think_t.A_Chase,statenum_t.S_CYBER_RUN6,0,0),	// S_CYBER_RUN5
    new state_t(spritenum_t.SPR_CYBR,2,3,think_t.A_Chase,statenum_t.S_CYBER_RUN7,0,0),	// S_CYBER_RUN6
    new state_t(spritenum_t.SPR_CYBR,3,3,think_t.A_Metal,statenum_t.S_CYBER_RUN8,0,0),	// S_CYBER_RUN7
    new state_t(spritenum_t.SPR_CYBR,3,3,think_t.A_Chase,statenum_t.S_CYBER_RUN1,0,0),	// S_CYBER_RUN8
    new state_t(spritenum_t.SPR_CYBR,4,6,think_t.A_FaceTarget,statenum_t.S_CYBER_ATK2,0,0),	// S_CYBER_ATK1
    new state_t(spritenum_t.SPR_CYBR,5,12,think_t.A_CyberAttack,statenum_t.S_CYBER_ATK3,0,0),	// S_CYBER_ATK2
    new state_t(spritenum_t.SPR_CYBR,4,12,think_t.A_FaceTarget,statenum_t.S_CYBER_ATK4,0,0),	// S_CYBER_ATK3
    new state_t(spritenum_t.SPR_CYBR,5,12,think_t.A_CyberAttack,statenum_t.S_CYBER_ATK5,0,0),	// S_CYBER_ATK4
    new state_t(spritenum_t.SPR_CYBR,4,12,think_t.A_FaceTarget,statenum_t.S_CYBER_ATK6,0,0),	// S_CYBER_ATK5
    new state_t(spritenum_t.SPR_CYBR,5,12,think_t.A_CyberAttack,statenum_t.S_CYBER_RUN1,0,0),	// S_CYBER_ATK6
    new state_t(spritenum_t.SPR_CYBR,6,10,think_t.A_Pain,statenum_t.S_CYBER_RUN1,0,0),	// S_CYBER_PAIN
    new state_t(spritenum_t.SPR_CYBR,7,10,null,statenum_t.S_CYBER_DIE2,0,0),	// S_CYBER_DIE1
    new state_t(spritenum_t.SPR_CYBR,8,10,think_t.A_Scream,statenum_t.S_CYBER_DIE3,0,0),	// S_CYBER_DIE2
    new state_t(spritenum_t.SPR_CYBR,9,10,null,statenum_t.S_CYBER_DIE4,0,0),	// S_CYBER_DIE3
    new state_t(spritenum_t.SPR_CYBR,10,10,null,statenum_t.S_CYBER_DIE5,0,0),	// S_CYBER_DIE4
    new state_t(spritenum_t.SPR_CYBR,11,10,null,statenum_t.S_CYBER_DIE6,0,0),	// S_CYBER_DIE5
    new state_t(spritenum_t.SPR_CYBR,12,10,think_t.A_Fall,statenum_t.S_CYBER_DIE7,0,0),	// S_CYBER_DIE6
    new state_t(spritenum_t.SPR_CYBR,13,10,null,statenum_t.S_CYBER_DIE8,0,0),	// S_CYBER_DIE7
    new state_t(spritenum_t.SPR_CYBR,14,10,null,statenum_t.S_CYBER_DIE9,0,0),	// S_CYBER_DIE8
    new state_t(spritenum_t.SPR_CYBR,15,30,null,statenum_t.S_CYBER_DIE10,0,0),	// S_CYBER_DIE9
    new state_t(spritenum_t.SPR_CYBR,15,-1,think_t.A_BossDeath,statenum_t.S_NULL,0,0),	// S_CYBER_DIE10
    new state_t(spritenum_t.SPR_PAIN,0,10,think_t.A_Look,statenum_t.S_PAIN_STND,0,0),	// S_PAIN_STND
    new state_t(spritenum_t.SPR_PAIN,0,3,think_t.A_Chase,statenum_t.S_PAIN_RUN2,0,0),	// S_PAIN_RUN1
    new state_t(spritenum_t.SPR_PAIN,0,3,think_t.A_Chase,statenum_t.S_PAIN_RUN3,0,0),	// S_PAIN_RUN2
    new state_t(spritenum_t.SPR_PAIN,1,3,think_t.A_Chase,statenum_t.S_PAIN_RUN4,0,0),	// S_PAIN_RUN3
    new state_t(spritenum_t.SPR_PAIN,1,3,think_t.A_Chase,statenum_t.S_PAIN_RUN5,0,0),	// S_PAIN_RUN4
    new state_t(spritenum_t.SPR_PAIN,2,3,think_t.A_Chase,statenum_t.S_PAIN_RUN6,0,0),	// S_PAIN_RUN5
    new state_t(spritenum_t.SPR_PAIN,2,3,think_t.A_Chase,statenum_t.S_PAIN_RUN1,0,0),	// S_PAIN_RUN6
    new state_t(spritenum_t.SPR_PAIN,3,5,think_t.A_FaceTarget,statenum_t.S_PAIN_ATK2,0,0),	// S_PAIN_ATK1
    new state_t(spritenum_t.SPR_PAIN,4,5,think_t.A_FaceTarget,statenum_t.S_PAIN_ATK3,0,0),	// S_PAIN_ATK2
    new state_t(spritenum_t.SPR_PAIN,32773,5,think_t.A_FaceTarget,statenum_t.S_PAIN_ATK4,0,0),	// S_PAIN_ATK3
    new state_t(spritenum_t.SPR_PAIN,32773,0,think_t.A_PainAttack,statenum_t.S_PAIN_RUN1,0,0),	// S_PAIN_ATK4
    new state_t(spritenum_t.SPR_PAIN,6,6,null,statenum_t.S_PAIN_PAIN2,0,0),	// S_PAIN_PAIN
    new state_t(spritenum_t.SPR_PAIN,6,6,think_t.A_Pain,statenum_t.S_PAIN_RUN1,0,0),	// S_PAIN_PAIN2
    new state_t(spritenum_t.SPR_PAIN,32775,8,null,statenum_t.S_PAIN_DIE2,0,0),	// S_PAIN_DIE1
    new state_t(spritenum_t.SPR_PAIN,32776,8,think_t.A_Scream,statenum_t.S_PAIN_DIE3,0,0),	// S_PAIN_DIE2
    new state_t(spritenum_t.SPR_PAIN,32777,8,null,statenum_t.S_PAIN_DIE4,0,0),	// S_PAIN_DIE3
    new state_t(spritenum_t.SPR_PAIN,32778,8,null,statenum_t.S_PAIN_DIE5,0,0),	// S_PAIN_DIE4
    new state_t(spritenum_t.SPR_PAIN,32779,8,think_t.A_PainDie,statenum_t.S_PAIN_DIE6,0,0),	// S_PAIN_DIE5
    new state_t(spritenum_t.SPR_PAIN,32780,8,null,statenum_t.S_NULL,0,0),	// S_PAIN_DIE6
    new state_t(spritenum_t.SPR_PAIN,12,8,null,statenum_t.S_PAIN_RAISE2,0,0),	// S_PAIN_RAISE1
    new state_t(spritenum_t.SPR_PAIN,11,8,null,statenum_t.S_PAIN_RAISE3,0,0),	// S_PAIN_RAISE2
    new state_t(spritenum_t.SPR_PAIN,10,8,null,statenum_t.S_PAIN_RAISE4,0,0),	// S_PAIN_RAISE3
    new state_t(spritenum_t.SPR_PAIN,9,8,null,statenum_t.S_PAIN_RAISE5,0,0),	// S_PAIN_RAISE4
    new state_t(spritenum_t.SPR_PAIN,8,8,null,statenum_t.S_PAIN_RAISE6,0,0),	// S_PAIN_RAISE5
    new state_t(spritenum_t.SPR_PAIN,7,8,null,statenum_t.S_PAIN_RUN1,0,0),	// S_PAIN_RAISE6
    new state_t(spritenum_t.SPR_SSWV,0,10,think_t.A_Look,statenum_t.S_SSWV_STND2,0,0),	// S_SSWV_STND
    new state_t(spritenum_t.SPR_SSWV,1,10,think_t.A_Look,statenum_t.S_SSWV_STND,0,0),	// S_SSWV_STND2
    new state_t(spritenum_t.SPR_SSWV,0,3,think_t.A_Chase,statenum_t.S_SSWV_RUN2,0,0),	// S_SSWV_RUN1
    new state_t(spritenum_t.SPR_SSWV,0,3,think_t.A_Chase,statenum_t.S_SSWV_RUN3,0,0),	// S_SSWV_RUN2
    new state_t(spritenum_t.SPR_SSWV,1,3,think_t.A_Chase,statenum_t.S_SSWV_RUN4,0,0),	// S_SSWV_RUN3
    new state_t(spritenum_t.SPR_SSWV,1,3,think_t.A_Chase,statenum_t.S_SSWV_RUN5,0,0),	// S_SSWV_RUN4
    new state_t(spritenum_t.SPR_SSWV,2,3,think_t.A_Chase,statenum_t.S_SSWV_RUN6,0,0),	// S_SSWV_RUN5
    new state_t(spritenum_t.SPR_SSWV,2,3,think_t.A_Chase,statenum_t.S_SSWV_RUN7,0,0),	// S_SSWV_RUN6
    new state_t(spritenum_t.SPR_SSWV,3,3,think_t.A_Chase,statenum_t.S_SSWV_RUN8,0,0),	// S_SSWV_RUN7
    new state_t(spritenum_t.SPR_SSWV,3,3,think_t.A_Chase,statenum_t.S_SSWV_RUN1,0,0),	// S_SSWV_RUN8
    new state_t(spritenum_t.SPR_SSWV,4,10,think_t.A_FaceTarget,statenum_t.S_SSWV_ATK2,0,0),	// S_SSWV_ATK1
    new state_t(spritenum_t.SPR_SSWV,5,10,think_t.A_FaceTarget,statenum_t.S_SSWV_ATK3,0,0),	// S_SSWV_ATK2
    new state_t(spritenum_t.SPR_SSWV,32774,4,think_t.A_CPosAttack,statenum_t.S_SSWV_ATK4,0,0),	// S_SSWV_ATK3
    new state_t(spritenum_t.SPR_SSWV,5,6,think_t.A_FaceTarget,statenum_t.S_SSWV_ATK5,0,0),	// S_SSWV_ATK4
    new state_t(spritenum_t.SPR_SSWV,32774,4,think_t.A_CPosAttack,statenum_t.S_SSWV_ATK6,0,0),	// S_SSWV_ATK5
    new state_t(spritenum_t.SPR_SSWV,5,1,think_t.A_CPosRefire,statenum_t.S_SSWV_ATK2,0,0),	// S_SSWV_ATK6
    new state_t(spritenum_t.SPR_SSWV,7,3,null,statenum_t.S_SSWV_PAIN2,0,0),	// S_SSWV_PAIN
    new state_t(spritenum_t.SPR_SSWV,7,3,think_t.A_Pain,statenum_t.S_SSWV_RUN1,0,0),	// S_SSWV_PAIN2
    new state_t(spritenum_t.SPR_SSWV,8,5,null,statenum_t.S_SSWV_DIE2,0,0),	// S_SSWV_DIE1
    new state_t(spritenum_t.SPR_SSWV,9,5,think_t.A_Scream,statenum_t.S_SSWV_DIE3,0,0),	// S_SSWV_DIE2
    new state_t(spritenum_t.SPR_SSWV,10,5,think_t.A_Fall,statenum_t.S_SSWV_DIE4,0,0),	// S_SSWV_DIE3
    new state_t(spritenum_t.SPR_SSWV,11,5,null,statenum_t.S_SSWV_DIE5,0,0),	// S_SSWV_DIE4
    new state_t(spritenum_t.SPR_SSWV,12,-1,null,statenum_t.S_NULL,0,0),	// S_SSWV_DIE5
    new state_t(spritenum_t.SPR_SSWV,13,5,null,statenum_t.S_SSWV_XDIE2,0,0),	// S_SSWV_XDIE1
    new state_t(spritenum_t.SPR_SSWV,14,5,think_t.A_XScream,statenum_t.S_SSWV_XDIE3,0,0),	// S_SSWV_XDIE2
    new state_t(spritenum_t.SPR_SSWV,15,5,think_t.A_Fall,statenum_t.S_SSWV_XDIE4,0,0),	// S_SSWV_XDIE3
    new state_t(spritenum_t.SPR_SSWV,16,5,null,statenum_t.S_SSWV_XDIE5,0,0),	// S_SSWV_XDIE4
    new state_t(spritenum_t.SPR_SSWV,17,5,null,statenum_t.S_SSWV_XDIE6,0,0),	// S_SSWV_XDIE5
    new state_t(spritenum_t.SPR_SSWV,18,5,null,statenum_t.S_SSWV_XDIE7,0,0),	// S_SSWV_XDIE6
    new state_t(spritenum_t.SPR_SSWV,19,5,null,statenum_t.S_SSWV_XDIE8,0,0),	// S_SSWV_XDIE7
    new state_t(spritenum_t.SPR_SSWV,20,5,null,statenum_t.S_SSWV_XDIE9,0,0),	// S_SSWV_XDIE8
    new state_t(spritenum_t.SPR_SSWV,21,-1,null,statenum_t.S_NULL,0,0),	// S_SSWV_XDIE9
    new state_t(spritenum_t.SPR_SSWV,12,5,null,statenum_t.S_SSWV_RAISE2,0,0),	// S_SSWV_RAISE1
    new state_t(spritenum_t.SPR_SSWV,11,5,null,statenum_t.S_SSWV_RAISE3,0,0),	// S_SSWV_RAISE2
    new state_t(spritenum_t.SPR_SSWV,10,5,null,statenum_t.S_SSWV_RAISE4,0,0),	// S_SSWV_RAISE3
    new state_t(spritenum_t.SPR_SSWV,9,5,null,statenum_t.S_SSWV_RAISE5,0,0),	// S_SSWV_RAISE4
    new state_t(spritenum_t.SPR_SSWV,8,5,null,statenum_t.S_SSWV_RUN1,0,0),	// S_SSWV_RAISE5
    new state_t(spritenum_t.SPR_KEEN,0,-1,null,statenum_t.S_KEENSTND,0,0),	// S_KEENSTND
    new state_t(spritenum_t.SPR_KEEN,0,6,null,statenum_t.S_COMMKEEN2,0,0),	// S_COMMKEEN
    new state_t(spritenum_t.SPR_KEEN,1,6,null,statenum_t.S_COMMKEEN3,0,0),	// S_COMMKEEN2
    new state_t(spritenum_t.SPR_KEEN,2,6,think_t.A_Scream,statenum_t.S_COMMKEEN4,0,0),	// S_COMMKEEN3
    new state_t(spritenum_t.SPR_KEEN,3,6,null,statenum_t.S_COMMKEEN5,0,0),	// S_COMMKEEN4
    new state_t(spritenum_t.SPR_KEEN,4,6,null,statenum_t.S_COMMKEEN6,0,0),	// S_COMMKEEN5
    new state_t(spritenum_t.SPR_KEEN,5,6,null,statenum_t.S_COMMKEEN7,0,0),	// S_COMMKEEN6
    new state_t(spritenum_t.SPR_KEEN,6,6,null,statenum_t.S_COMMKEEN8,0,0),	// S_COMMKEEN7
    new state_t(spritenum_t.SPR_KEEN,7,6,null,statenum_t.S_COMMKEEN9,0,0),	// S_COMMKEEN8
    new state_t(spritenum_t.SPR_KEEN,8,6,null,statenum_t.S_COMMKEEN10,0,0),	// S_COMMKEEN9
    new state_t(spritenum_t.SPR_KEEN,9,6,null,statenum_t.S_COMMKEEN11,0,0),	// S_COMMKEEN10
    new state_t(spritenum_t.SPR_KEEN,10,6,think_t.A_KeenDie,statenum_t.S_COMMKEEN12,0,0),// S_COMMKEEN11
    new state_t(spritenum_t.SPR_KEEN,11,-1,null,statenum_t.S_NULL,0,0),		// S_COMMKEEN12
    new state_t(spritenum_t.SPR_KEEN,12,4,null,statenum_t.S_KEENPAIN2,0,0),	// S_KEENPAIN
    new state_t(spritenum_t.SPR_KEEN,12,8,think_t.A_Pain,statenum_t.S_KEENSTND,0,0),	// S_KEENPAIN2
    new state_t(spritenum_t.SPR_BBRN,0,-1,null,statenum_t.S_NULL,0,0),		// S_BRAIN
    new state_t(spritenum_t.SPR_BBRN,1,36,think_t.A_BrainPain,statenum_t.S_BRAIN,0,0),	// S_BRAIN_PAIN
    new state_t(spritenum_t.SPR_BBRN,0,100,think_t.A_BrainScream,statenum_t.S_BRAIN_DIE2,0,0),	// S_BRAIN_DIE1
    new state_t(spritenum_t.SPR_BBRN,0,10,null,statenum_t.S_BRAIN_DIE3,0,0),	// S_BRAIN_DIE2
    new state_t(spritenum_t.SPR_BBRN,0,10,null,statenum_t.S_BRAIN_DIE4,0,0),	// S_BRAIN_DIE3
    new state_t(spritenum_t.SPR_BBRN,0,-1,think_t.A_BrainDie,statenum_t.S_NULL,0,0),	// S_BRAIN_DIE4
    new state_t(spritenum_t.SPR_SSWV,0,10,think_t.A_Look,statenum_t.S_BRAINEYE,0,0),	// S_BRAINEYE
    new state_t(spritenum_t.SPR_SSWV,0,181,think_t.A_BrainAwake,statenum_t.S_BRAINEYE1,0,0),	// S_BRAINEYESEE
    new state_t(spritenum_t.SPR_SSWV,0,150,think_t.A_BrainSpit,statenum_t.S_BRAINEYE1,0,0),	// S_BRAINEYE1
    new state_t(spritenum_t.SPR_BOSF,32768,3,think_t.A_SpawnSound,statenum_t.S_SPAWN2,0,0),	// S_SPAWN1
    new state_t(spritenum_t.SPR_BOSF,32769,3,think_t.A_SpawnFly,statenum_t.S_SPAWN3,0,0),	// S_SPAWN2
    new state_t(spritenum_t.SPR_BOSF,32770,3,think_t.A_SpawnFly,statenum_t.S_SPAWN4,0,0),	// S_SPAWN3
    new state_t(spritenum_t.SPR_BOSF,32771,3,think_t.A_SpawnFly,statenum_t.S_SPAWN1,0,0),	// S_SPAWN4
    new state_t(spritenum_t.SPR_FIRE,32768,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE2,0,0),	// S_SPAWNFIRE1
    new state_t(spritenum_t.SPR_FIRE,32769,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE3,0,0),	// S_SPAWNFIRE2
    new state_t(spritenum_t.SPR_FIRE,32770,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE4,0,0),	// S_SPAWNFIRE3
    new state_t(spritenum_t.SPR_FIRE,32771,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE5,0,0),	// S_SPAWNFIRE4
    new state_t(spritenum_t.SPR_FIRE,32772,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE6,0,0),	// S_SPAWNFIRE5
    new state_t(spritenum_t.SPR_FIRE,32773,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE7,0,0),	// S_SPAWNFIRE6
    new state_t(spritenum_t.SPR_FIRE,32774,4,think_t.A_Fire,statenum_t.S_SPAWNFIRE8,0,0),	// S_SPAWNFIRE7
    new state_t(spritenum_t.SPR_FIRE,32775,4,think_t.A_Fire,statenum_t.S_NULL,0,0),		// S_SPAWNFIRE8
    new state_t(spritenum_t.SPR_MISL,32769,10,null,statenum_t.S_BRAINEXPLODE2,0,0),	// S_BRAINEXPLODE1
    new state_t(spritenum_t.SPR_MISL,32770,10,null,statenum_t.S_BRAINEXPLODE3,0,0),	// S_BRAINEXPLODE2
    new state_t(spritenum_t.SPR_MISL,32771,10,think_t.A_BrainExplode,statenum_t.S_NULL,0,0),	// S_BRAINEXPLODE3
    new state_t(spritenum_t.SPR_ARM1,0,6,null,statenum_t.S_ARM1A,0,0),	// S_ARM1
    new state_t(spritenum_t.SPR_ARM1,32769,7,null,statenum_t.S_ARM1,0,0),	// S_ARM1A
    new state_t(spritenum_t.SPR_ARM2,0,6,null,statenum_t.S_ARM2A,0,0),	// S_ARM2
    new state_t(spritenum_t.SPR_ARM2,32769,6,null,statenum_t.S_ARM2,0,0),	// S_ARM2A
    new state_t(spritenum_t.SPR_BAR1,0,6,null,statenum_t.S_BAR2,0,0),	// S_BAR1
    new state_t(spritenum_t.SPR_BAR1,1,6,null,statenum_t.S_BAR1,0,0),	// S_BAR2
    new state_t(spritenum_t.SPR_BEXP,32768,5,null,statenum_t.S_BEXP2,0,0),	// S_BEXP
    new state_t(spritenum_t.SPR_BEXP,32769,5,think_t.A_Scream,statenum_t.S_BEXP3,0,0),	// S_BEXP2
    new state_t(spritenum_t.SPR_BEXP,32770,5,null,statenum_t.S_BEXP4,0,0),	// S_BEXP3
    new state_t(spritenum_t.SPR_BEXP,32771,10,think_t.A_Explode,statenum_t.S_BEXP5,0,0),	// S_BEXP4
    new state_t(spritenum_t.SPR_BEXP,32772,10,null,statenum_t.S_NULL,0,0),	// S_BEXP5
    new state_t(spritenum_t.SPR_FCAN,32768,4,null,statenum_t.S_BBAR2,0,0),	// S_BBAR1
    new state_t(spritenum_t.SPR_FCAN,32769,4,null,statenum_t.S_BBAR3,0,0),	// S_BBAR2
    new state_t(spritenum_t.SPR_FCAN,32770,4,null,statenum_t.S_BBAR1,0,0),	// S_BBAR3
    new state_t(spritenum_t.SPR_BON1,0,6,null,statenum_t.S_BON1A,0,0),	// S_BON1
    new state_t(spritenum_t.SPR_BON1,1,6,null,statenum_t.S_BON1B,0,0),	// S_BON1A
    new state_t(spritenum_t.SPR_BON1,2,6,null,statenum_t.S_BON1C,0,0),	// S_BON1B
    new state_t(spritenum_t.SPR_BON1,3,6,null,statenum_t.S_BON1D,0,0),	// S_BON1C
    new state_t(spritenum_t.SPR_BON1,2,6,null,statenum_t.S_BON1E,0,0),	// S_BON1D
    new state_t(spritenum_t.SPR_BON1,1,6,null,statenum_t.S_BON1,0,0),	// S_BON1E
    new state_t(spritenum_t.SPR_BON2,0,6,null,statenum_t.S_BON2A,0,0),	// S_BON2
    new state_t(spritenum_t.SPR_BON2,1,6,null,statenum_t.S_BON2B,0,0),	// S_BON2A
    new state_t(spritenum_t.SPR_BON2,2,6,null,statenum_t.S_BON2C,0,0),	// S_BON2B
    new state_t(spritenum_t.SPR_BON2,3,6,null,statenum_t.S_BON2D,0,0),	// S_BON2C
    new state_t(spritenum_t.SPR_BON2,2,6,null,statenum_t.S_BON2E,0,0),	// S_BON2D
    new state_t(spritenum_t.SPR_BON2,1,6,null,statenum_t.S_BON2,0,0),	// S_BON2E
    new state_t(spritenum_t.SPR_BKEY,0,10,null,statenum_t.S_BKEY2,0,0),	// S_BKEY
    new state_t(spritenum_t.SPR_BKEY,32769,10,null,statenum_t.S_BKEY,0,0),	// S_BKEY2
    new state_t(spritenum_t.SPR_RKEY,0,10,null,statenum_t.S_RKEY2,0,0),	// S_RKEY
    new state_t(spritenum_t.SPR_RKEY,32769,10,null,statenum_t.S_RKEY,0,0),	// S_RKEY2
    new state_t(spritenum_t.SPR_YKEY,0,10,null,statenum_t.S_YKEY2,0,0),	// S_YKEY
    new state_t(spritenum_t.SPR_YKEY,32769,10,null,statenum_t.S_YKEY,0,0),	// S_YKEY2
    new state_t(spritenum_t.SPR_BSKU,0,10,null,statenum_t.S_BSKULL2,0,0),	// S_BSKULL
    new state_t(spritenum_t.SPR_BSKU,32769,10,null,statenum_t.S_BSKULL,0,0),	// S_BSKULL2
    new state_t(spritenum_t.SPR_RSKU,0,10,null,statenum_t.S_RSKULL2,0,0),	// S_RSKULL
    new state_t(spritenum_t.SPR_RSKU,32769,10,null,statenum_t.S_RSKULL,0,0),	// S_RSKULL2
    new state_t(spritenum_t.SPR_YSKU,0,10,null,statenum_t.S_YSKULL2,0,0),	// S_YSKULL
    new state_t(spritenum_t.SPR_YSKU,32769,10,null,statenum_t.S_YSKULL,0,0),	// S_YSKULL2
    new state_t(spritenum_t.SPR_STIM,0,-1,null,statenum_t.S_NULL,0,0),	// S_STIM
    new state_t(spritenum_t.SPR_MEDI,0,-1,null,statenum_t.S_NULL,0,0),	// S_MEDI
    new state_t(spritenum_t.SPR_SOUL,32768,6,null,statenum_t.S_SOUL2,0,0),	// S_SOUL
    new state_t(spritenum_t.SPR_SOUL,32769,6,null,statenum_t.S_SOUL3,0,0),	// S_SOUL2
    new state_t(spritenum_t.SPR_SOUL,32770,6,null,statenum_t.S_SOUL4,0,0),	// S_SOUL3
    new state_t(spritenum_t.SPR_SOUL,32771,6,null,statenum_t.S_SOUL5,0,0),	// S_SOUL4
    new state_t(spritenum_t.SPR_SOUL,32770,6,null,statenum_t.S_SOUL6,0,0),	// S_SOUL5
    new state_t(spritenum_t.SPR_SOUL,32769,6,null,statenum_t.S_SOUL,0,0),	// S_SOUL6
    new state_t(spritenum_t.SPR_PINV,32768,6,null,statenum_t.S_PINV2,0,0),	// S_PINV
    new state_t(spritenum_t.SPR_PINV,32769,6,null,statenum_t.S_PINV3,0,0),	// S_PINV2
    new state_t(spritenum_t.SPR_PINV,32770,6,null,statenum_t.S_PINV4,0,0),	// S_PINV3
    new state_t(spritenum_t.SPR_PINV,32771,6,null,statenum_t.S_PINV,0,0),	// S_PINV4
    new state_t(spritenum_t.SPR_PSTR,32768,-1,null,statenum_t.S_NULL,0,0),	// S_PSTR
    new state_t(spritenum_t.SPR_PINS,32768,6,null,statenum_t.S_PINS2,0,0),	// S_PINS
    new state_t(spritenum_t.SPR_PINS,32769,6,null,statenum_t.S_PINS3,0,0),	// S_PINS2
    new state_t(spritenum_t.SPR_PINS,32770,6,null,statenum_t.S_PINS4,0,0),	// S_PINS3
    new state_t(spritenum_t.SPR_PINS,32771,6,null,statenum_t.S_PINS,0,0),	// S_PINS4
    new state_t(spritenum_t.SPR_MEGA,32768,6,null,statenum_t.S_MEGA2,0,0),	// S_MEGA
    new state_t(spritenum_t.SPR_MEGA,32769,6,null,statenum_t.S_MEGA3,0,0),	// S_MEGA2
    new state_t(spritenum_t.SPR_MEGA,32770,6,null,statenum_t.S_MEGA4,0,0),	// S_MEGA3
    new state_t(spritenum_t.SPR_MEGA,32771,6,null,statenum_t.S_MEGA,0,0),	// S_MEGA4
    new state_t(spritenum_t.SPR_SUIT,32768,-1,null,statenum_t.S_NULL,0,0),	// S_SUIT
    new state_t(spritenum_t.SPR_PMAP,32768,6,null,statenum_t.S_PMAP2,0,0),	// S_PMAP
    new state_t(spritenum_t.SPR_PMAP,32769,6,null,statenum_t.S_PMAP3,0,0),	// S_PMAP2
    new state_t(spritenum_t.SPR_PMAP,32770,6,null,statenum_t.S_PMAP4,0,0),	// S_PMAP3
    new state_t(spritenum_t.SPR_PMAP,32771,6,null,statenum_t.S_PMAP5,0,0),	// S_PMAP4
    new state_t(spritenum_t.SPR_PMAP,32770,6,null,statenum_t.S_PMAP6,0,0),	// S_PMAP5
    new state_t(spritenum_t.SPR_PMAP,32769,6,null,statenum_t.S_PMAP,0,0),	// S_PMAP6
    new state_t(spritenum_t.SPR_PVIS,32768,6,null,statenum_t.S_PVIS2,0,0),	// S_PVIS
    new state_t(spritenum_t.SPR_PVIS,1,6,null,statenum_t.S_PVIS,0,0),	// S_PVIS2
    new state_t(spritenum_t.SPR_CLIP,0,-1,null,statenum_t.S_NULL,0,0),	// S_CLIP
    new state_t(spritenum_t.SPR_AMMO,0,-1,null,statenum_t.S_NULL,0,0),	// S_AMMO
    new state_t(spritenum_t.SPR_ROCK,0,-1,null,statenum_t.S_NULL,0,0),	// S_ROCK
    new state_t(spritenum_t.SPR_BROK,0,-1,null,statenum_t.S_NULL,0,0),	// S_BROK
    new state_t(spritenum_t.SPR_CELL,0,-1,null,statenum_t.S_NULL,0,0),	// S_CELL
    new state_t(spritenum_t.SPR_CELP,0,-1,null,statenum_t.S_NULL,0,0),	// S_CELP
    new state_t(spritenum_t.SPR_SHEL,0,-1,null,statenum_t.S_NULL,0,0),	// S_SHEL
    new state_t(spritenum_t.SPR_SBOX,0,-1,null,statenum_t.S_NULL,0,0),	// S_SBOX
    new state_t(spritenum_t.SPR_BPAK,0,-1,null,statenum_t.S_NULL,0,0),	// S_BPAK
    new state_t(spritenum_t.SPR_BFUG,0,-1,null,statenum_t.S_NULL,0,0),	// S_BFUG
    new state_t(spritenum_t.SPR_MGUN,0,-1,null,statenum_t.S_NULL,0,0),	// S_MGUN
    new state_t(spritenum_t.SPR_CSAW,0,-1,null,statenum_t.S_NULL,0,0),	// S_CSAW
    new state_t(spritenum_t.SPR_LAUN,0,-1,null,statenum_t.S_NULL,0,0),	// S_LAUN
    new state_t(spritenum_t.SPR_PLAS,0,-1,null,statenum_t.S_NULL,0,0),	// S_PLAS
    new state_t(spritenum_t.SPR_SHOT,0,-1,null,statenum_t.S_NULL,0,0),	// S_SHOT
    new state_t(spritenum_t.SPR_SGN2,0,-1,null,statenum_t.S_NULL,0,0),	// S_SHOT2
    new state_t(spritenum_t.SPR_COLU,32768,-1,null,statenum_t.S_NULL,0,0),	// S_COLU
    new state_t(spritenum_t.SPR_SMT2,0,-1,null,statenum_t.S_NULL,0,0),	// S_STALAG
    new state_t(spritenum_t.SPR_GOR1,0,10,null,statenum_t.S_BLOODYTWITCH2,0,0),	// S_BLOODYTWITCH
    new state_t(spritenum_t.SPR_GOR1,1,15,null,statenum_t.S_BLOODYTWITCH3,0,0),	// S_BLOODYTWITCH2
    new state_t(spritenum_t.SPR_GOR1,2,8,null,statenum_t.S_BLOODYTWITCH4,0,0),	// S_BLOODYTWITCH3
    new state_t(spritenum_t.SPR_GOR1,1,6,null,statenum_t.S_BLOODYTWITCH,0,0),	// S_BLOODYTWITCH4
    new state_t(spritenum_t.SPR_PLAY,13,-1,null,statenum_t.S_NULL,0,0),	// S_DEADTORSO
    new state_t(spritenum_t.SPR_PLAY,18,-1,null,statenum_t.S_NULL,0,0),	// S_DEADBOTTOM
    new state_t(spritenum_t.SPR_POL2,0,-1,null,statenum_t.S_NULL,0,0),	// S_HEADSONSTICK
    new state_t(spritenum_t.SPR_POL5,0,-1,null,statenum_t.S_NULL,0,0),	// S_GIBS
    new state_t(spritenum_t.SPR_POL4,0,-1,null,statenum_t.S_NULL,0,0),	// S_HEADONASTICK
    new state_t(spritenum_t.SPR_POL3,32768,6,null,statenum_t.S_HEADCANDLES2,0,0),	// S_HEADCANDLES
    new state_t(spritenum_t.SPR_POL3,32769,6,null,statenum_t.S_HEADCANDLES,0,0),	// S_HEADCANDLES2
    new state_t(spritenum_t.SPR_POL1,0,-1,null,statenum_t.S_NULL,0,0),	// S_DEADSTICK
    new state_t(spritenum_t.SPR_POL6,0,6,null,statenum_t.S_LIVESTICK2,0,0),	// S_LIVESTICK
    new state_t(spritenum_t.SPR_POL6,1,8,null,statenum_t.S_LIVESTICK,0,0),	// S_LIVESTICK2
    new state_t(spritenum_t.SPR_GOR2,0,-1,null,statenum_t.S_NULL,0,0),	// S_MEAT2
    new state_t(spritenum_t.SPR_GOR3,0,-1,null,statenum_t.S_NULL,0,0),	// S_MEAT3
    new state_t(spritenum_t.SPR_GOR4,0,-1,null,statenum_t.S_NULL,0,0),	// S_MEAT4
    new state_t(spritenum_t.SPR_GOR5,0,-1,null,statenum_t.S_NULL,0,0),	// S_MEAT5
    new state_t(spritenum_t.SPR_SMIT,0,-1,null,statenum_t.S_NULL,0,0),	// S_STALAGTITE
    new state_t(spritenum_t.SPR_COL1,0,-1,null,statenum_t.S_NULL,0,0),	// S_TALLGRNCOL
    new state_t(spritenum_t.SPR_COL2,0,-1,null,statenum_t.S_NULL,0,0),	// S_SHRTGRNCOL
    new state_t(spritenum_t.SPR_COL3,0,-1,null,statenum_t.S_NULL,0,0),	// S_TALLREDCOL
    new state_t(spritenum_t.SPR_COL4,0,-1,null,statenum_t.S_NULL,0,0),	// S_SHRTREDCOL
    new state_t(spritenum_t.SPR_CAND,32768,-1,null,statenum_t.S_NULL,0,0),	// S_CANDLESTIK
    new state_t(spritenum_t.SPR_CBRA,32768,-1,null,statenum_t.S_NULL,0,0),	// S_CANDELABRA
    new state_t(spritenum_t.SPR_COL6,0,-1,null,statenum_t.S_NULL,0,0),	// S_SKULLCOL
    new state_t(spritenum_t.SPR_TRE1,0,-1,null,statenum_t.S_NULL,0,0),	// S_TORCHTREE
    new state_t(spritenum_t.SPR_TRE2,0,-1,null,statenum_t.S_NULL,0,0),	// S_BIGTREE
    new state_t(spritenum_t.SPR_ELEC,0,-1,null,statenum_t.S_NULL,0,0),	// S_TECHPILLAR
    new state_t(spritenum_t.SPR_CEYE,32768,6,null,statenum_t.S_EVILEYE2,0,0),	// S_EVILEYE
    new state_t(spritenum_t.SPR_CEYE,32769,6,null,statenum_t.S_EVILEYE3,0,0),	// S_EVILEYE2
    new state_t(spritenum_t.SPR_CEYE,32770,6,null,statenum_t.S_EVILEYE4,0,0),	// S_EVILEYE3
    new state_t(spritenum_t.SPR_CEYE,32769,6,null,statenum_t.S_EVILEYE,0,0),	// S_EVILEYE4
    new state_t(spritenum_t.SPR_FSKU,32768,6,null,statenum_t.S_FLOATSKULL2,0,0),	// S_FLOATSKULL
    new state_t(spritenum_t.SPR_FSKU,32769,6,null,statenum_t.S_FLOATSKULL3,0,0),	// S_FLOATSKULL2
    new state_t(spritenum_t.SPR_FSKU,32770,6,null,statenum_t.S_FLOATSKULL,0,0),	// S_FLOATSKULL3
    new state_t(spritenum_t.SPR_COL5,0,14,null,statenum_t.S_HEARTCOL2,0,0),	// S_HEARTCOL
    new state_t(spritenum_t.SPR_COL5,1,14,null,statenum_t.S_HEARTCOL,0,0),	// S_HEARTCOL2
    new state_t(spritenum_t.SPR_TBLU,32768,4,null,statenum_t.S_BLUETORCH2,0,0),	// S_BLUETORCH
    new state_t(spritenum_t.SPR_TBLU,32769,4,null,statenum_t.S_BLUETORCH3,0,0),	// S_BLUETORCH2
    new state_t(spritenum_t.SPR_TBLU,32770,4,null,statenum_t.S_BLUETORCH4,0,0),	// S_BLUETORCH3
    new state_t(spritenum_t.SPR_TBLU,32771,4,null,statenum_t.S_BLUETORCH,0,0),	// S_BLUETORCH4
    new state_t(spritenum_t.SPR_TGRN,32768,4,null,statenum_t.S_GREENTORCH2,0,0),	// S_GREENTORCH
    new state_t(spritenum_t.SPR_TGRN,32769,4,null,statenum_t.S_GREENTORCH3,0,0),	// S_GREENTORCH2
    new state_t(spritenum_t.SPR_TGRN,32770,4,null,statenum_t.S_GREENTORCH4,0,0),	// S_GREENTORCH3
    new state_t(spritenum_t.SPR_TGRN,32771,4,null,statenum_t.S_GREENTORCH,0,0),	// S_GREENTORCH4
    new state_t(spritenum_t.SPR_TRED,32768,4,null,statenum_t.S_REDTORCH2,0,0),	// S_REDTORCH
    new state_t(spritenum_t.SPR_TRED,32769,4,null,statenum_t.S_REDTORCH3,0,0),	// S_REDTORCH2
    new state_t(spritenum_t.SPR_TRED,32770,4,null,statenum_t.S_REDTORCH4,0,0),	// S_REDTORCH3
    new state_t(spritenum_t.SPR_TRED,32771,4,null,statenum_t.S_REDTORCH,0,0),	// S_REDTORCH4
    new state_t(spritenum_t.SPR_SMBT,32768,4,null,statenum_t.S_BTORCHSHRT2,0,0),	// S_BTORCHSHRT
    new state_t(spritenum_t.SPR_SMBT,32769,4,null,statenum_t.S_BTORCHSHRT3,0,0),	// S_BTORCHSHRT2
    new state_t(spritenum_t.SPR_SMBT,32770,4,null,statenum_t.S_BTORCHSHRT4,0,0),	// S_BTORCHSHRT3
    new state_t(spritenum_t.SPR_SMBT,32771,4,null,statenum_t.S_BTORCHSHRT,0,0),	// S_BTORCHSHRT4
    new state_t(spritenum_t.SPR_SMGT,32768,4,null,statenum_t.S_GTORCHSHRT2,0,0),	// S_GTORCHSHRT
    new state_t(spritenum_t.SPR_SMGT,32769,4,null,statenum_t.S_GTORCHSHRT3,0,0),	// S_GTORCHSHRT2
    new state_t(spritenum_t.SPR_SMGT,32770,4,null,statenum_t.S_GTORCHSHRT4,0,0),	// S_GTORCHSHRT3
    new state_t(spritenum_t.SPR_SMGT,32771,4,null,statenum_t.S_GTORCHSHRT,0,0),	// S_GTORCHSHRT4
    new state_t(spritenum_t.SPR_SMRT,32768,4,null,statenum_t.S_RTORCHSHRT2,0,0),	// S_RTORCHSHRT
    new state_t(spritenum_t.SPR_SMRT,32769,4,null,statenum_t.S_RTORCHSHRT3,0,0),	// S_RTORCHSHRT2
    new state_t(spritenum_t.SPR_SMRT,32770,4,null,statenum_t.S_RTORCHSHRT4,0,0),	// S_RTORCHSHRT3
    new state_t(spritenum_t.SPR_SMRT,32771,4,null,statenum_t.S_RTORCHSHRT,0,0),	// S_RTORCHSHRT4
    new state_t(spritenum_t.SPR_HDB1,0,-1,null,statenum_t.S_NULL,0,0),	// S_HANGNOGUTS
    new state_t(spritenum_t.SPR_HDB2,0,-1,null,statenum_t.S_NULL,0,0),	// S_HANGBNOBRAIN
    new state_t(spritenum_t.SPR_HDB3,0,-1,null,statenum_t.S_NULL,0,0),	// S_HANGTLOOKDN
    new state_t(spritenum_t.SPR_HDB4,0,-1,null,statenum_t.S_NULL,0,0),	// S_HANGTSKULL
    new state_t(spritenum_t.SPR_HDB5,0,-1,null,statenum_t.S_NULL,0,0),	// S_HANGTLOOKUP
    new state_t(spritenum_t.SPR_HDB6,0,-1,null,statenum_t.S_NULL,0,0),	// S_HANGTNOBRAIN
    new state_t(spritenum_t.SPR_POB1,0,-1,null,statenum_t.S_NULL,0,0),	// S_COLONGIBS
    new state_t(spritenum_t.SPR_POB2,0,-1,null,statenum_t.S_NULL,0,0),	// S_SMALLPOOL
    new state_t(spritenum_t.SPR_BRS1,0,-1,null,statenum_t.S_NULL,0,0),		// S_BRAINSTEM
    new state_t(spritenum_t.SPR_TLMP,32768,4,null,statenum_t.S_TECHLAMP2,0,0),	// S_TECHLAMP
    new state_t(spritenum_t.SPR_TLMP,32769,4,null,statenum_t.S_TECHLAMP3,0,0),	// S_TECHLAMP2
    new state_t(spritenum_t.SPR_TLMP,32770,4,null,statenum_t.S_TECHLAMP4,0,0),	// S_TECHLAMP3
    new state_t(spritenum_t.SPR_TLMP,32771,4,null,statenum_t.S_TECHLAMP,0,0),	// S_TECHLAMP4
    new state_t(spritenum_t.SPR_TLP2,32768,4,null,statenum_t.S_TECH2LAMP2,0,0),	// S_TECH2LAMP
    new state_t(spritenum_t.SPR_TLP2,32769,4,null,statenum_t.S_TECH2LAMP3,0,0),	// S_TECH2LAMP2
    new state_t(spritenum_t.SPR_TLP2,32770,4,null,statenum_t.S_TECH2LAMP4,0,0),	// S_TECH2LAMP3
    new state_t(spritenum_t.SPR_TLP2,32771,4,null,statenum_t.S_TECH2LAMP,0,0)	// S_TECH2LAMP4
};

public static mobjinfo_t[] mobjinfo = {
    new mobjinfo_t(		// MT_PLAYER
	-1,		// doomednum
	statenum_t.S_PLAY,		// spawnstate
	100,		// spawnhealth
	statenum_t.S_PLAY_RUN1,		// seestate
	sfxenum_t.sfx_None,		// seesound
	0,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_PLAY_PAIN,		// painstate
	255,		// painchance
	sfxenum_t.sfx_plpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_PLAY_ATK1,		// missilestate
	statenum_t.S_PLAY_DIE1,		// deathstate
	statenum_t.S_PLAY_XDIE1,		// xdeathstate
	sfxenum_t.sfx_pldeth,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_DROPOFF|MF_PICKUP|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_POSSESSED
	3004,		// doomednum
	statenum_t.S_POSS_STND,		// spawnstate
	20,		// spawnhealth
	statenum_t.S_POSS_RUN1,		// seestate
	sfxenum_t.sfx_posit1,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_pistol,		// attacksound
	statenum_t.S_POSS_PAIN,		// painstate
	200,		// painchance
	sfxenum_t.sfx_popain,		// painsound
	statenum_t.S_NULL,		// meleestate MAES: BE careful with "0 - null" states!
	statenum_t.S_POSS_ATK1,		// missilestate
	statenum_t.S_POSS_DIE1,		// deathstate
	statenum_t.S_POSS_XDIE1,		// xdeathstate
	sfxenum_t.sfx_podth1,		// deathsound
	8,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_posact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_POSS_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_SHOTGUY
	9,		// doomednum
	statenum_t.S_SPOS_STND,		// spawnstate
	30,		// spawnhealth
	statenum_t.S_SPOS_RUN1,		// seestate
	sfxenum_t.sfx_posit2,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_shotgn,		// attacksound MAES: Weird, this was 0 :-S
	statenum_t.S_SPOS_PAIN,		// painstate
	170,		// painchance
	sfxenum_t.sfx_popain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_SPOS_ATK1,		// missilestate
	statenum_t.S_SPOS_DIE1,		// deathstate
	statenum_t.S_SPOS_XDIE1,		// xdeathstate
	sfxenum_t.sfx_podth2,		// deathsound
	8,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_posact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_SPOS_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_VILE
	64,		// doomednum
	statenum_t.S_VILE_STND,		// spawnstate
	700,		// spawnhealth
	statenum_t.S_VILE_RUN1,		// seestate
	sfxenum_t.sfx_vilsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_VILE_PAIN,		// painstate
	10,		// painchance
	sfxenum_t.sfx_vipain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_VILE_ATK1,		// missilestate
	statenum_t.S_VILE_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_vildth,		// deathsound
	15,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	500,		// mass
	0,		// damage
	sfxenum_t.sfx_vilact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_FIRE
	-1,		// doomednum
	statenum_t.S_FIRE1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_UNDEAD
	66,		// doomednum
	statenum_t.S_SKEL_STND,		// spawnstate
	300,		// spawnhealth
	statenum_t.S_SKEL_RUN1,		// seestate
	sfxenum_t.sfx_skesit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_SKEL_PAIN,		// painstate
	100,		// painchance
	sfxenum_t.sfx_popain,		// painsound
	statenum_t.S_SKEL_FIST1,		// meleestate
	statenum_t.S_SKEL_MISS1,		// missilestate
	statenum_t.S_SKEL_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_skedth,		// deathsound
	10,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	500,		// mass
	0,		// damage
	sfxenum_t.sfx_skeact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_SKEL_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_TRACER
	-1,		// doomednum
	statenum_t.S_TRACER,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_skeatk,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_TRACEEXP1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_barexp,		// deathsound
	10*FRACUNIT,		// speed
	11*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	10,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_SMOKE
	-1,		// doomednum
	statenum_t.S_SMOKE1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_FATSO
	67,		// doomednum
	statenum_t.S_FATT_STND,		// spawnstate
	600,		// spawnhealth
	statenum_t.S_FATT_RUN1,		// seestate
	sfxenum_t.sfx_mansit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_FATT_PAIN,		// painstate
	80,		// painchance
	sfxenum_t.sfx_mnpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_FATT_ATK1,		// missilestate
	statenum_t.S_FATT_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_mandth,		// deathsound
	8,		// speed
	48*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	1000,		// mass
	0,		// damage
	sfxenum_t.sfx_posact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_FATT_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_FATSHOT
	-1,		// doomednum
	statenum_t.S_FATSHOT1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_firsht,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_FATSHOTX1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	20*FRACUNIT,		// speed
	6*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	8,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_CHAINGUY
	65,		// doomednum
	statenum_t.S_CPOS_STND,		// spawnstate
	70,		// spawnhealth
	statenum_t.S_CPOS_RUN1,		// seestate
	sfxenum_t.sfx_posit2,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_CPOS_PAIN,		// painstate
	170,		// painchance
	sfxenum_t.sfx_popain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_CPOS_ATK1,		// missilestate
	statenum_t.S_CPOS_DIE1,		// deathstate
	statenum_t.S_CPOS_XDIE1,		// xdeathstate
	sfxenum_t.sfx_podth2,		// deathsound
	8,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_posact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_CPOS_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_TROOP
	3001,		// doomednum
	statenum_t.S_TROO_STND,		// spawnstate
	60,		// spawnhealth
	statenum_t.S_TROO_RUN1,		// seestate
	sfxenum_t.sfx_bgsit1,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_TROO_PAIN,		// painstate
	200,		// painchance
	sfxenum_t.sfx_popain,		// painsound
	statenum_t.S_TROO_ATK1,		// meleestate
	statenum_t.S_TROO_ATK1,		// missilestate
	statenum_t.S_TROO_DIE1,		// deathstate
	statenum_t.S_TROO_XDIE1,		// xdeathstate
	sfxenum_t.sfx_bgdth1,		// deathsound
	8,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_bgact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_TROO_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_SERGEANT
	3002,		// doomednum
	statenum_t.S_SARG_STND,		// spawnstate
	150,		// spawnhealth
	statenum_t.S_SARG_RUN1,		// seestate
	sfxenum_t.sfx_sgtsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_sgtatk,		// attacksound
	statenum_t.S_SARG_PAIN,		// painstate
	180,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_SARG_ATK1,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_SARG_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_sgtdth,		// deathsound
	10,		// speed
	30*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	400,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_SARG_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_SHADOWS
	58,		// doomednum
	statenum_t.S_SARG_STND,		// spawnstate
	150,		// spawnhealth
	statenum_t.S_SARG_RUN1,		// seestate
	sfxenum_t.sfx_sgtsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_sgtatk,		// attacksound
	statenum_t.S_SARG_PAIN,		// painstate
	180,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_SARG_ATK1,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_SARG_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_sgtdth,		// deathsound
	10,		// speed
	30*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	400,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_SHADOW|MF_COUNTKILL,		// flags
	statenum_t.S_SARG_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_HEAD
	3005,		// doomednum
	statenum_t.S_HEAD_STND,		// spawnstate
	400,		// spawnhealth
	statenum_t.S_HEAD_RUN1,		// seestate
	sfxenum_t.sfx_cacsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_HEAD_PAIN,		// painstate
	128,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_HEAD_ATK1,		// missilestate
	statenum_t.S_HEAD_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_cacdth,		// deathsound
	8,		// speed
	31*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	400,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_FLOAT|MF_NOGRAVITY|MF_COUNTKILL,		// flags
	statenum_t.S_HEAD_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_BRUISER
	3003,		// doomednum
	statenum_t.S_BOSS_STND,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_BOSS_RUN1,		// seestate
	sfxenum_t.sfx_brssit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_BOSS_PAIN,		// painstate
	50,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_BOSS_ATK1,		// meleestate
	statenum_t.S_BOSS_ATK1,		// missilestate
	statenum_t.S_BOSS_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_brsdth,		// deathsound
	8,		// speed
	24*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	1000,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_BOSS_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_BRUISERSHOT
	-1,		// doomednum
	statenum_t.S_BRBALL1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_firsht,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_BRBALLX1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	15*FRACUNIT,		// speed
	6*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	8,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_KNIGHT
	69,		// doomednum
	statenum_t.S_BOS2_STND,		// spawnstate
	500,		// spawnhealth
	statenum_t.S_BOS2_RUN1,		// seestate
	sfxenum_t.sfx_kntsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_BOS2_PAIN,		// painstate
	50,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_BOS2_ATK1,		// meleestate
	statenum_t.S_BOS2_ATK1,		// missilestate
	statenum_t.S_BOS2_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_kntdth,		// deathsound
	8,		// speed
	24*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	1000,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_BOS2_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_SKULL
	3006,		// doomednum
	statenum_t.S_SKULL_STND,		// spawnstate
	100,		// spawnhealth
	statenum_t.S_SKULL_RUN1,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_sklatk,		// attacksound
	statenum_t.S_SKULL_PAIN,		// painstate
	256,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_SKULL_ATK1,		// missilestate
	statenum_t.S_SKULL_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	8,		// speed
	16*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	50,		// mass
	3,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_FLOAT|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_SPIDER
	7,		// doomednum
	statenum_t.S_SPID_STND,		// spawnstate
	3000,		// spawnhealth
	statenum_t.S_SPID_RUN1,		// seestate
	sfxenum_t.sfx_spisit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_shotgn,		// attacksound
	statenum_t.S_SPID_PAIN,		// painstate
	40,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_SPID_ATK1,		// missilestate
	statenum_t.S_SPID_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_spidth,		// deathsound
	12,		// speed
	128*FRACUNIT,		// radius
	100*FRACUNIT,		// height
	1000,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BABY
	68,		// doomednum
	statenum_t.S_BSPI_STND,		// spawnstate
	500,		// spawnhealth
	statenum_t.S_BSPI_SIGHT,		// seestate
	sfxenum_t.sfx_bspsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_BSPI_PAIN,		// painstate
	128,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_BSPI_ATK1,		// missilestate
	statenum_t.S_BSPI_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_bspdth,		// deathsound
	12,		// speed
	64*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	600,		// mass
	0,		// damage
	sfxenum_t.sfx_bspact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_BSPI_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_CYBORG
	16,		// doomednum
	statenum_t.S_CYBER_STND,		// spawnstate
	4000,		// spawnhealth
	statenum_t.S_CYBER_RUN1,		// seestate
	sfxenum_t.sfx_cybsit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_CYBER_PAIN,		// painstate
	20,		// painchance
	sfxenum_t.sfx_dmpain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_CYBER_ATK1,		// missilestate
	statenum_t.S_CYBER_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_cybdth,		// deathsound
	16,		// speed
	40*FRACUNIT,		// radius
	110*FRACUNIT,		// height
	1000,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_PAIN
	71,		// doomednum
	statenum_t.S_PAIN_STND,		// spawnstate
	400,		// spawnhealth
	statenum_t.S_PAIN_RUN1,		// seestate
	sfxenum_t.sfx_pesit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_PAIN_PAIN,		// painstate
	128,		// painchance
	sfxenum_t.sfx_pepain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_PAIN_ATK1,		// missilestate
	statenum_t.S_PAIN_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_pedth,		// deathsound
	8,		// speed
	31*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	400,		// mass
	0,		// damage
	sfxenum_t.sfx_dmact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_FLOAT|MF_NOGRAVITY|MF_COUNTKILL,		// flags
	statenum_t.S_PAIN_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_WOLFSS
	84,		// doomednum
	statenum_t.S_SSWV_STND,		// spawnstate
	50,		// spawnhealth
	statenum_t.S_SSWV_RUN1,		// seestate
	sfxenum_t.sfx_sssit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_SSWV_PAIN,		// painstate
	170,		// painchance
	sfxenum_t.sfx_popain,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_SSWV_ATK1,		// missilestate
	statenum_t.S_SSWV_DIE1,		// deathstate
	statenum_t.S_SSWV_XDIE1,		// xdeathstate
	sfxenum_t.sfx_ssdth,		// deathsound
	8,		// speed
	20*FRACUNIT,		// radius
	56*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_posact,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_SSWV_RAISE1		// raisestate
    ),

    new mobjinfo_t(		// MT_KEEN
	72,		// doomednum
	statenum_t.S_KEENSTND,		// spawnstate
	100,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_KEENPAIN,		// painstate
	256,		// painchance
	sfxenum_t.sfx_keenpn,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_COMMKEEN,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_keendt,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	72*FRACUNIT,		// height
	10000000,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY|MF_SHOOTABLE|MF_COUNTKILL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BOSSBRAIN
	88,		// doomednum
	statenum_t.S_BRAIN,		// spawnstate
	250,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_BRAIN_PAIN,		// painstate
	255,		// painchance
	sfxenum_t.sfx_bospn,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_BRAIN_DIE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_bosdth,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	10000000,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SHOOTABLE,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BOSSSPIT
	89,		// doomednum
	statenum_t.S_BRAINEYE,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_BRAINEYESEE,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	32*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOSECTOR,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BOSSTARGET
	87,		// doomednum
	statenum_t.S_NULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	32*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOSECTOR,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_SPAWNSHOT
	-1,		// doomednum
	statenum_t.S_SPAWN1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_bospit,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	10*FRACUNIT,		// speed
	6*FRACUNIT,		// radius
	32*FRACUNIT,		// height
	100,		// mass
	3,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY|MF_NOCLIP,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_SPAWNFIRE
	-1,		// doomednum
	statenum_t.S_SPAWNFIRE1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BARREL
	2035,		// doomednum
	statenum_t.S_BAR1,		// spawnstate
	20,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_BEXP,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_barexp,		// deathsound
	0,		// speed
	10*FRACUNIT,		// radius
	42*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SHOOTABLE|MF_NOBLOOD,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_TROOPSHOT
	-1,		// doomednum
	statenum_t.S_TBALL1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_firsht,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_TBALLX1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	10*FRACUNIT,		// speed
	6*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	3,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_HEADSHOT
	-1,		// doomednum
	statenum_t.S_RBALL1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_firsht,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_RBALLX1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	10*FRACUNIT,		// speed
	6*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	5,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_ROCKET
	-1,		// doomednum
	statenum_t.S_ROCKET,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_rlaunc,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_EXPLODE1,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_barexp,		// deathsound
	20*FRACUNIT,		// speed
	11*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	20,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_PLASMA
	-1,		// doomednum
	statenum_t.S_PLASBALL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_plasma,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_PLASEXP,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	25*FRACUNIT,		// speed
	13*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	5,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BFG
	-1,		// doomednum
	statenum_t.S_BFGSHOT,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_BFGLAND,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_rxplod,		// deathsound
	25*FRACUNIT,		// speed
	13*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	100,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_ARACHPLAZ
	-1,		// doomednum
	statenum_t.S_ARACH_PLAZ,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_plasma,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_ARACH_PLEX,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_firxpl,		// deathsound
	25*FRACUNIT,		// speed
	13*FRACUNIT,		// radius
	8*FRACUNIT,		// height
	100,		// mass
	5,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_PUFF
	-1,		// doomednum
	statenum_t.S_PUFF1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_BLOOD
	-1,		// doomednum
	statenum_t.S_BLOOD1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_TFOG
	-1,		// doomednum
	statenum_t.S_TFOG,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_IFOG
	-1,		// doomednum
	statenum_t.S_IFOG,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_TELEPORTMAN
	14,		// doomednum
	statenum_t.S_NULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOSECTOR,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_EXTRABFG
	-1,		// doomednum
	statenum_t.S_BFGEXP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC0
	2018,		// doomednum
	statenum_t.S_ARM1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC1
	2019,		// doomednum
	statenum_t.S_ARM2,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC2
	2014,		// doomednum
	statenum_t.S_BON1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC3
	2015,		// doomednum
	statenum_t.S_BON2,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC4
	5,		// doomednum
	statenum_t.S_BKEY,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC5
	13,		// doomednum
	statenum_t.S_RKEY,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC6
	6,		// doomednum
	statenum_t.S_YKEY,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC7
	39,		// doomednum
	statenum_t.S_YSKULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC8
	38,		// doomednum
	statenum_t.S_RSKULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC9
	40,		// doomednum
	statenum_t.S_BSKULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_NOTDMATCH,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC10
	2011,		// doomednum
	statenum_t.S_STIM,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC11
	2012,		// doomednum
	statenum_t.S_MEDI,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC12
	2013,		// doomednum
	statenum_t.S_SOUL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_INV
	2022,		// doomednum
	statenum_t.S_PINV,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC13
	2023,		// doomednum
	statenum_t.S_PSTR,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_INS
	2024,		// doomednum
	statenum_t.S_PINS,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC14
	2025,		// doomednum
	statenum_t.S_SUIT,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC15
	2026,		// doomednum
	statenum_t.S_PMAP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC16
	2045,		// doomednum
	statenum_t.S_PVIS,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MEGA
	83,		// doomednum
	statenum_t.S_MEGA,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL|MF_COUNTITEM,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_CLIP
	2007,		// doomednum
	statenum_t.S_CLIP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC17
	2048,		// doomednum
	statenum_t.S_AMMO,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC18
	2010,		// doomednum
	statenum_t.S_ROCK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC19
	2046,		// doomednum
	statenum_t.S_BROK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC20
	2047,		// doomednum
	statenum_t.S_CELL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC21
	17,		// doomednum
	statenum_t.S_CELP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC22
	2008,		// doomednum
	statenum_t.S_SHEL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC23
	2049,		// doomednum
	statenum_t.S_SBOX,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC24
	8,		// doomednum
	statenum_t.S_BPAK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC25
	2006,		// doomednum
	statenum_t.S_BFUG,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_CHAINGUN
	2002,		// doomednum
	statenum_t.S_MGUN,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC26
	2005,		// doomednum
	statenum_t.S_CSAW,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC27
	2003,		// doomednum
	statenum_t.S_LAUN,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC28
	2004,		// doomednum
	statenum_t.S_PLAS,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_SHOTGUN
	2001,		// doomednum
	statenum_t.S_SHOT,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_SUPERSHOTGUN
	82,		// doomednum
	statenum_t.S_SHOT2,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPECIAL,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC29
	85,		// doomednum
	statenum_t.S_TECHLAMP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC30
	86,		// doomednum
	statenum_t.S_TECH2LAMP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC31
	2028,		// doomednum
	statenum_t.S_COLU,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC32
	30,		// doomednum
	statenum_t.S_TALLGRNCOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC33
	31,		// doomednum
	statenum_t.S_SHRTGRNCOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC34
	32,		// doomednum
	statenum_t.S_TALLREDCOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC35
	33,		// doomednum
	statenum_t.S_SHRTREDCOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC36
	37,		// doomednum
	statenum_t.S_SKULLCOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC37
	36,		// doomednum
	statenum_t.S_HEARTCOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC38
	41,		// doomednum
	statenum_t.S_EVILEYE,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC39
	42,		// doomednum
	statenum_t.S_FLOATSKULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC40
	43,		// doomednum
	statenum_t.S_TORCHTREE,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC41
	44,		// doomednum
	statenum_t.S_BLUETORCH,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC42
	45,		// doomednum
	statenum_t.S_GREENTORCH,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC43
	46,		// doomednum
	statenum_t.S_REDTORCH,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC44
	55,		// doomednum
	statenum_t.S_BTORCHSHRT,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC45
	56,		// doomednum
	statenum_t.S_GTORCHSHRT,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC46
	57,		// doomednum
	statenum_t.S_RTORCHSHRT,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC47
	47,		// doomednum
	statenum_t.S_STALAGTITE,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC48
	48,		// doomednum
	statenum_t.S_TECHPILLAR,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC49
	34,		// doomednum
	statenum_t.S_CANDLESTIK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC50
	35,		// doomednum
	statenum_t.S_CANDELABRA,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC51
	49,		// doomednum
	statenum_t.S_BLOODYTWITCH,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	68*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC52
	50,		// doomednum
	statenum_t.S_MEAT2,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	84*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC53
	51,		// doomednum
	statenum_t.S_MEAT3,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	84*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC54
	52,		// doomednum
	statenum_t.S_MEAT4,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	68*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC55
	53,		// doomednum
	statenum_t.S_MEAT5,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	52*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC56
	59,		// doomednum
	statenum_t.S_MEAT2,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	84*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC57
	60,		// doomednum
	statenum_t.S_MEAT4,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	68*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC58
	61,		// doomednum
	statenum_t.S_MEAT3,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	52*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC59
	62,		// doomednum
	statenum_t.S_MEAT5,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	52*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC60
	63,		// doomednum
	statenum_t.S_BLOODYTWITCH,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	68*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC61
	22,		// doomednum
	statenum_t.S_HEAD_DIE6,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC62
	15,		// doomednum
	statenum_t.S_PLAY_DIE7,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC63
	18,		// doomednum
	statenum_t.S_POSS_DIE5,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC64
	21,		// doomednum
	statenum_t.S_SARG_DIE6,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC65
	23,		// doomednum
	statenum_t.S_SKULL_DIE6,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC66
	20,		// doomednum
	statenum_t.S_TROO_DIE5,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC67
	19,		// doomednum
	statenum_t.S_SPOS_DIE5,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC68
	10,		// doomednum
	statenum_t.S_PLAY_XDIE9,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC69
	12,		// doomednum
	statenum_t.S_PLAY_XDIE9,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC70
	28,		// doomednum
	statenum_t.S_HEADSONSTICK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC71
	24,		// doomednum
	statenum_t.S_GIBS,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	0,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC72
	27,		// doomednum
	statenum_t.S_HEADONASTICK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC73
	29,		// doomednum
	statenum_t.S_HEADCANDLES,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC74
	25,		// doomednum
	statenum_t.S_DEADSTICK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC75
	26,		// doomednum
	statenum_t.S_LIVESTICK,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC76
	54,		// doomednum
	statenum_t.S_BIGTREE,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	32*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC77
	70,		// doomednum
	statenum_t.S_BBAR1,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC78
	73,		// doomednum
	statenum_t.S_HANGNOGUTS,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	88*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC79
	74,		// doomednum
	statenum_t.S_HANGBNOBRAIN,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	88*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC80
	75,		// doomednum
	statenum_t.S_HANGTLOOKDN,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC81
	76,		// doomednum
	statenum_t.S_HANGTSKULL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC82
	77,		// doomednum
	statenum_t.S_HANGTLOOKUP,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC83
	78,		// doomednum
	statenum_t.S_HANGTNOBRAIN,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	16*FRACUNIT,		// radius
	64*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC84
	79,		// doomednum
	statenum_t.S_COLONGIBS,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC85
	80,		// doomednum
	statenum_t.S_SMALLPOOL,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP,		// flags
	statenum_t.S_NULL		// raisestate
    ),

    new mobjinfo_t(		// MT_MISC86
	81,		// doomednum
	statenum_t.S_BRAINSTEM,		// spawnstate
	1000,		// spawnhealth
	statenum_t.S_NULL,		// seestate
	sfxenum_t.sfx_None,		// seesound
	8,		// reactiontime
	sfxenum_t.sfx_None,		// attacksound
	statenum_t.S_NULL,		// painstate
	0,		// painchance
	sfxenum_t.sfx_None,		// painsound
	statenum_t.S_NULL,		// meleestate
	statenum_t.S_NULL,		// missilestate
	statenum_t.S_NULL,		// deathstate
	statenum_t.S_NULL,		// xdeathstate
	sfxenum_t.sfx_None,		// deathsound
	0,		// speed
	20*FRACUNIT,		// radius
	16*FRACUNIT,		// height
	100,		// mass
	0,		// damage
	sfxenum_t.sfx_None,		// activesound
	MF_NOBLOCKMAP,		// flags
	statenum_t.S_NULL		// raisestate
    )
};

static {
// Need to set them to simulate pointer-like operations.
	for (int i=0;i<states.length;i++){
		states[i].id=i;
		
		//states[0]=null;
}
}
}


package data;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;

/** BSP Node structure on-disk */
public class mapnode_t
        implements CacheableDoomObject {

    public mapnode_t() {
        this.bbox = new short[2][4];
        this.children = new char[2];
    }

    /** Partition line from (x,y) to x+dx,y+dy) */
    public short x, y, dx, dy;

    /** Bounding box for each child, clip against view frustum. */
    public short[][] bbox;

    /** If NF_SUBSECTOR its a subsector, else it's a node of another subtree. 
     *  In simpler words: if the first bit is set, strip it and use the rest
     *  as a subtree index. Else it's a node index.
     * */
    public char[] children = new char[2]; // MAES: used to be unsigned short.

    public static int sizeOf() {
        return (8 + 16 + 4);
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.x = buf.getShort();
        this.y = buf.getShort();
        this.dx = buf.getShort();
        this.dy = buf.getShort();
        DoomBuffer.readShortArray(buf, this.bbox[0], 4);
        DoomBuffer.readShortArray(buf, this.bbox[1], 4);
        DoomBuffer.readCharArray(buf, this.children, 2);
    }

}

package data;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;
import w.IPackableDoomObject;
import w.IWritableDoomObject;

/**
 * A LineDef, as used for editing, and as input to the BSP builder.
 */
public class maplinedef_t implements CacheableDoomObject,IPackableDoomObject,IWritableDoomObject{

    public maplinedef_t() {
        this.sidenum = new char[2];
    }

    public char v1;

    public char v2;

    public short flags;

    public short special;

    public short tag;

    /** sidenum[1] will be 0xFFFF if one sided */
    public char[] sidenum;

    public static int sizeOf() {
        return 14;
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
    buf.order(ByteOrder.LITTLE_ENDIAN);
    this.v1 = buf.getChar();
    this.v2 = buf.getChar();
    this.flags = buf.getShort();
    this.special = buf.getShort();
    this.tag = buf.getShort();
    DoomBuffer.readCharArray(buf, this.sidenum, 2);
    }

	@Override
	public void write(DataOutputStream dos) throws IOException {
        // More efficient, avoids duplicating code and
        // handles little endian better.
        iobuffer.position(0);
        iobuffer.order(ByteOrder.LITTLE_ENDIAN);
        this.pack(iobuffer);
        dos.write(iobuffer.array());		
	}

	@Override
	public void pack(ByteBuffer buf) throws IOException {
	    buf.order(ByteOrder.LITTLE_ENDIAN);
	    buf.putChar(v1);
	    buf.putChar(v2);
	    buf.putShort(flags);
	    buf.putShort(special);
	    buf.putShort(tag);
	    buf.putChar(sidenum[0]);
	    buf.putChar(sidenum[1]);		
	}
	
	private static ByteBuffer iobuffer=ByteBuffer.allocate(maplinedef_t.sizeOf());
}

package data;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.IPackableDoomObject;
import w.IWritableDoomObject;

/**
 * This is the structure of a map vertex ON DISK: in memory it gets shifted and
 * expanded to fixed_t. Also, on disk it only exists as part of the VERTEXES
 * lump: it is not individually cacheable, even though it implements
 * CacheableDoomObject.
 */

public class mapvertex_t implements CacheableDoomObject,IWritableDoomObject,IPackableDoomObject {

    public mapvertex_t(short x, short y) {
        this.x = x;
        this.y = y;
    }

    public mapvertex_t() {
        this((short) 0, (short) 0);
    }

    public short x;

    public short y;

    public static int sizeOf() {
        return 4;
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        x = buf.getShort();
        y = buf.getShort();
    }

	@Override
	public void pack(ByteBuffer buf) throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        buf.putShort(x);
        buf.putShort(y);		
	}

	@Override
	public void write(DataOutputStream dos) throws IOException {
        // More efficient, avoids duplicating code and
        // handles little endian better.
        iobuffer.position(0);
        iobuffer.order(ByteOrder.LITTLE_ENDIAN);
        this.pack(iobuffer);
        dos.write(iobuffer.array());		
	}
	
	private static final ByteBuffer iobuffer=ByteBuffer.allocate(mapvertex_t.sizeOf());

}

package data;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import rr.sector_t;
import w.CacheableDoomObject;
import w.DoomBuffer;
import w.IPackableDoomObject;
import w.IWritableDoomObject;

/** Sector definition, from editing. */ 
public class mapsector_t implements CacheableDoomObject,IWritableDoomObject, IPackableDoomObject {
    
        public mapsector_t(){

        }
    
      public short     floorheight;
      public  short     ceilingheight;
      public  String floorpic;
      public  String        ceilingpic;
      public  short     lightlevel;
      public  short     special;
      public  short     tag;
      
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.floorheight = buf.getShort();
        this.ceilingheight = buf.getShort();
        this.floorpic=DoomBuffer.getNullTerminatedString(buf,8).toUpperCase();
        this.ceilingpic=DoomBuffer.getNullTerminatedString(buf,8).toUpperCase();
        this.lightlevel= buf.getShort();
        this.special= buf.getShort();
        this.tag= buf.getShort();
    }
    
    public static int sizeOf() {
        return 26;
    }
    
    @Override
    public void write(DataOutputStream dos)
            throws IOException {    	
    	
        // More efficient, avoids duplicating code and
        // handles little endian better.
        iobuffer.position(0);
        iobuffer.order(ByteOrder.LITTLE_ENDIAN);
        this.pack(iobuffer);
        dos.write(iobuffer.array());
        
    }

    public void pack(ByteBuffer b) throws IOException {
        b.order(ByteOrder.LITTLE_ENDIAN);
        b.putShort(this.floorheight);
        b.putShort(this.ceilingheight);
        DoomBuffer.putNullTerminatedString(b, this.floorpic,8);
        DoomBuffer.putNullTerminatedString(b, this.ceilingpic,8);
        b.putShort(this.lightlevel);
        b.putShort(this.special);
        b.putShort(this.tag);
    }
    
    private static final ByteBuffer iobuffer=ByteBuffer.allocate(mapsector_t.sizeOf());
      
}

package data;

public class musicinfo_t {

    public musicinfo_t() {
    }

    
    public musicinfo_t(String name) {
        this.name = name;
    }
    
    public musicinfo_t(String name, int lumpnum) {
        this.name = name;
        this.lumpnum = lumpnum;
    }

    // up to 6-character name
    public String   name;

    // lump number of music
    public int     lumpnum;
    
    // music data
    public byte[] data;

    // music handle once registered
    public int handle;
}

package data;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

/** SubSector, as generated by BSP. */

public class mapsubsector_t implements CacheableDoomObject{
    
        public mapsubsector_t(){
            
        }
        
      public char     numsegs;
      /** Index of first one, segs are stored sequentially. */
      public char     firstseg;
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.numsegs = buf.getChar();
        this.firstseg = buf.getChar();
        
    } 
    
    public static int sizeOf(){
        return 4;
    }
}

package data;

/** This is actually used as a data type */

public enum spritenum_t {
	    SPR_TROO,
	    SPR_SHTG,
	    SPR_PUNG,
	    SPR_PISG,
	    SPR_PISF,
	    SPR_SHTF,
	    SPR_SHT2,
	    SPR_CHGG,
	    SPR_CHGF,
	    SPR_MISG,
	    SPR_MISF,
	    SPR_SAWG,
	    SPR_PLSG,
	    SPR_PLSF,
	    SPR_BFGG,
	    SPR_BFGF,
	    SPR_BLUD,
	    SPR_PUFF,
	    SPR_BAL1,
	    SPR_BAL2,
	    SPR_PLSS,
	    SPR_PLSE,
	    SPR_MISL,
	    SPR_BFS1,
	    SPR_BFE1,
	    SPR_BFE2,
	    SPR_TFOG,
	    SPR_IFOG,
	    SPR_PLAY,
	    SPR_POSS,
	    SPR_SPOS,
	    SPR_VILE,
	    SPR_FIRE,
	    SPR_FATB,
	    SPR_FBXP,
	    SPR_SKEL,
	    SPR_MANF,
	    SPR_FATT,
	    SPR_CPOS,
	    SPR_SARG,
	    SPR_HEAD,
	    SPR_BAL7,
	    SPR_BOSS,
	    SPR_BOS2,
	    SPR_SKUL,
	    SPR_SPID,
	    SPR_BSPI,
	    SPR_APLS,
	    SPR_APBX,
	    SPR_CYBR,
	    SPR_PAIN,
	    SPR_SSWV,
	    SPR_KEEN,
	    SPR_BBRN,
	    SPR_BOSF,
	    SPR_ARM1,
	    SPR_ARM2,
	    SPR_BAR1,
	    SPR_BEXP,
	    SPR_FCAN,
	    SPR_BON1,
	    SPR_BON2,
	    SPR_BKEY,
	    SPR_RKEY,
	    SPR_YKEY,
	    SPR_BSKU,
	    SPR_RSKU,
	    SPR_YSKU,
	    SPR_STIM,
	    SPR_MEDI,
	    SPR_SOUL,
	    SPR_PINV,
	    SPR_PSTR,
	    SPR_PINS,
	    SPR_MEGA,
	    SPR_SUIT,
	    SPR_PMAP,
	    SPR_PVIS,
	    SPR_CLIP,
	    SPR_AMMO,
	    SPR_ROCK,
	    SPR_BROK,
	    SPR_CELL,
	    SPR_CELP,
	    SPR_SHEL,
	    SPR_SBOX,
	    SPR_BPAK,
	    SPR_BFUG,
	    SPR_MGUN,
	    SPR_CSAW,
	    SPR_LAUN,
	    SPR_PLAS,
	    SPR_SHOT,
	    SPR_SGN2,
	    SPR_COLU,
	    SPR_SMT2,
	    SPR_GOR1,
	    SPR_POL2,
	    SPR_POL5,
	    SPR_POL4,
	    SPR_POL3,
	    SPR_POL1,
	    SPR_POL6,
	    SPR_GOR2,
	    SPR_GOR3,
	    SPR_GOR4,
	    SPR_GOR5,
	    SPR_SMIT,
	    SPR_COL1,
	    SPR_COL2,
	    SPR_COL3,
	    SPR_COL4,
	    SPR_CAND,
	    SPR_CBRA,
	    SPR_COL6,
	    SPR_TRE1,
	    SPR_TRE2,
	    SPR_ELEC,
	    SPR_CEYE,
	    SPR_FSKU,
	    SPR_COL5,
	    SPR_TBLU,
	    SPR_TGRN,
	    SPR_TRED,
	    SPR_SMBT,
	    SPR_SMGT,
	    SPR_SMRT,
	    SPR_HDB1,
	    SPR_HDB2,
	    SPR_HDB3,
	    SPR_HDB4,
	    SPR_HDB5,
	    SPR_HDB6,
	    SPR_POB1,
	    SPR_POB2,
	    SPR_BRS1,
	    SPR_TLMP,
	    SPR_TLP2,
	    NUMSPRITES
	};


package data;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.IPackableDoomObject;
import w.IWritableDoomObject;

/** mapthing_t ... same on disk AND in memory, wow?! */

public class mapthing_t implements CacheableDoomObject,IPackableDoomObject,IWritableDoomObject,Cloneable{
    public short x;

    public short y;

    public short angle;

    public short type;

    public short options;

    public mapthing_t() {
    }

    public mapthing_t(mapthing_t source) {
        this.copyFrom(source);
    }

    public static int sizeOf() {
        return 10;
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.x = buf.getShort();
        this.y = buf.getShort();
        this.angle = buf.getShort();
        this.type = buf.getShort();
        this.options = buf.getShort();
        
    }
    
    public void copyFrom(mapthing_t source){

        this.x=source.x;
        this.y=source.y;
        this.angle=source.angle;
        this.options=source.options;
        this.type=source.type;
    }

    @Override
    public void write(DataOutputStream f)
            throws IOException {
        
        // More efficient, avoids duplicating code and
        // handles little endian better.
        iobuffer.position(0);
        iobuffer.order(ByteOrder.LITTLE_ENDIAN);
        this.pack(iobuffer);
        f.write(iobuffer.array());
        
    }

    public void pack(ByteBuffer b) {
        b.order(ByteOrder.LITTLE_ENDIAN);
        b.putShort(x);
        b.putShort(y);
        b.putShort(angle);
        b.putShort(type);
        b.putShort(options);
    }
    
    private static ByteBuffer iobuffer=ByteBuffer.allocate(mapthing_t.sizeOf());
}
package data;

import static m.fixed_t.FRACUNIT;
import static m.fixed_t.MAPFRACUNIT;

/** Everything that constitutes a removable limit should go here */

public final class Limits {

	// Obvious rendering limits
	public static final int MAXVISPLANES = 128;
	public static final int MAXSEGS = 32;
	public static final int MAXVISSPRITES = 128;
	public static final int MAXDRAWSEGS = 256;
	// MAES: Moved MAXOPENINGS to renderer state, it's scale dependant.
	public static final int CEILSPEED = MAPFRACUNIT;
	public static final int CEILWAIT = 150;
	public static final int MAXCEILINGS = 30;

	public static final int MAXANIMS = 32;

	/** Animating line specials */
	public static final int MAXLINEANIMS = 64;

	// These are only used in the renderer, effectively putting
	// a limit to the size of lookup tables for screen buffers.
	public static final int MAXWIDTH = 1600;
	public static final int MAXHEIGHT = 1200;

	// Command line/file limits
	public static final int MAXWADFILES = 20;
	public static final int MAXARGVS = 100;

	// The maximum number of players, multiplayer/networking.
	// Max computers/players in a game. AFFECTS SAVEGAMES.
	public static final int MAXPLAYERS = 4;
	public final static int MAXNETNODES = 8;

	/** Some quirky engine limits */
	public static final int MAXEVENTS = 64;
	
	/** max # of wall switch TYPES in a level */
	public static final int MAXSWITCHES = 50;

	/** 20 adjoining sectors max! */
	public static final int MAX_ADJOINING_SECTORS = 20;

	// 4 players, 4 buttons each at once, max.
	public static final int MAXBUTTONS = 16;

	// 1 second, in ticks.
	public static final int BUTTONTIME = 35;

	/**
	 * keep track of special lines as they are hit, but don't process them until
	 * the move is proven valid
	 */
	public static final int MAXSPECIALCROSS = 8;
	public static final int MAXHEALTH = 100;

	/**
	 * MAXRADIUS is for precalculated sector block boxes the spider demon is
	 * larger, but we do not have any moving sectors nearby
	 */
	public static final int MAXRADIUS = 32 * FRACUNIT;

	public static final int MAXINTERCEPTS = 128;
	public static final int MAXMOVE = (30 * MAPFRACUNIT);

	/** Player spawn spots for deathmatch. */
	public static final int MAX_DM_STARTS = 10;

	// C's "chars" are actually Java signed bytes.
	public static final byte MAXCHAR = ((byte) 0x7f);
	public static final byte MINCHAR = ((byte) 0x80);

	// 16-bit integers...
	public static final short MAXSHORT = ((short) 0x7fff);
	public static final short MINSHORT = ((short) 0x8000);

	// Max pos 32-bit int.
	public static final int MAXINT = ((int) 0x7fffffff);
	public static final long MAXLONG = ((long) 0x7fffffff);

	// Max negative 32-bit integer. These are considered to be the same.
	public static final int MININT = ((int) 0x80000000);
	public static final long MINLONG = ((long) 0x80000000);

	// Buffering/memory limits.
	public static final int SAVEGAMESIZE = 0x2c000;

	public static final int SAVESTRINGSIZE = 24;
	public static final int VERSIONSIZE = 16;

	public static final int PLATWAIT = 3;
	public static final int PLATSPEED = MAPFRACUNIT;
	public static final int MAXPLATS = 30;
	public static final int MAXSKULLS = 20;
	public static final int NUMBRAINTARGETS=32;
	public static final int NUMMOBJTYPES=mobjtype_t.NUMMOBJTYPES.ordinal();
	
}

package data;

import static data.Tables.FINEANGLES;

/** Sine and Cosine.
 *  Java can't have that mush initialization data in one file, so I had to separate it.
 * 
 * @author Maes
 *
 */

public class SineCosine {

 // MAES: original size was 10240, but includes 5PI/4 periods.
 // We can get away with ints on this one because of the small range.
 // MAES: WTF? -64 ~ 64K range... so 17-bit accuracy? heh.

    /**
     * Original size was 10240, but includes 5PI/4 periods.
     * We can get away with ints on this one because of the small range.
     * MAES: WTF? -64 ~ 64K range... so 17-bit accuracy? heh.
     */
    
    public static int[] finesine=
    {
        25,75,125,175,226,276,326,376,
        427,477,527,578,628,678,728,779,
        829,879,929,980,1030,1080,1130,1181,
        1231,1281,1331,1382,1432,1482,1532,1583,
        1633,1683,1733,1784,1834,1884,1934,1985,
        2035,2085,2135,2186,2236,2286,2336,2387,
        2437,2487,2537,2587,2638,2688,2738,2788,
        2839,2889,2939,2989,3039,3090,3140,3190,
        3240,3291,3341,3391,3441,3491,3541,3592,
        3642,3692,3742,3792,3843,3893,3943,3993,
        4043,4093,4144,4194,4244,4294,4344,4394,
        4445,4495,4545,4595,4645,4695,4745,4796,
        4846,4896,4946,4996,5046,5096,5146,5197,
        5247,5297,5347,5397,5447,5497,5547,5597,
        5647,5697,5748,5798,5848,5898,5948,5998,
        6048,6098,6148,6198,6248,6298,6348,6398,
        6448,6498,6548,6598,6648,6698,6748,6798,
        6848,6898,6948,6998,7048,7098,7148,7198,
        7248,7298,7348,7398,7448,7498,7548,7598,
        7648,7697,7747,7797,7847,7897,7947,7997,
        8047,8097,8147,8196,8246,8296,8346,8396,
        8446,8496,8545,8595,8645,8695,8745,8794,
        8844,8894,8944,8994,9043,9093,9143,9193,
        9243,9292,9342,9392,9442,9491,9541,9591,
        9640,9690,9740,9790,9839,9889,9939,9988,
        10038,10088,10137,10187,10237,10286,10336,10386,
        10435,10485,10534,10584,10634,10683,10733,10782,
        10832,10882,10931,10981,11030,11080,11129,11179,
        11228,11278,11327,11377,11426,11476,11525,11575,
        11624,11674,11723,11773,11822,11872,11921,11970,
        12020,12069,12119,12168,12218,12267,12316,12366,
        12415,12464,12514,12563,12612,12662,12711,12760,
        12810,12859,12908,12957,13007,13056,13105,13154,
        13204,13253,13302,13351,13401,13450,13499,13548,
        13597,13647,13696,13745,13794,13843,13892,13941,
        13990,14040,14089,14138,14187,14236,14285,14334,
        14383,14432,14481,14530,14579,14628,14677,14726,
        14775,14824,14873,14922,14971,15020,15069,15118,
        15167,15215,15264,15313,15362,15411,15460,15509,
        15557,15606,15655,15704,15753,15802,15850,15899,
        15948,15997,16045,16094,16143,16191,16240,16289,
        16338,16386,16435,16484,16532,16581,16629,16678,
        16727,16775,16824,16872,16921,16970,17018,17067,
        17115,17164,17212,17261,17309,17358,17406,17455,
        17503,17551,17600,17648,17697,17745,17793,17842,
        17890,17939,17987,18035,18084,18132,18180,18228,
        18277,18325,18373,18421,18470,18518,18566,18614,
        18663,18711,18759,18807,18855,18903,18951,19000,
        19048,19096,19144,19192,19240,19288,19336,19384,
        19432,19480,19528,19576,19624,19672,19720,19768,
        19816,19864,19912,19959,20007,20055,20103,20151,
        20199,20246,20294,20342,20390,20438,20485,20533,
        20581,20629,20676,20724,20772,20819,20867,20915,
        20962,21010,21057,21105,21153,21200,21248,21295,
        21343,21390,21438,21485,21533,21580,21628,21675,
        21723,21770,21817,21865,21912,21960,22007,22054,
        22102,22149,22196,22243,22291,22338,22385,22433,
        22480,22527,22574,22621,22668,22716,22763,22810,
        22857,22904,22951,22998,23045,23092,23139,23186,
        23233,23280,23327,23374,23421,23468,23515,23562,
        23609,23656,23703,23750,23796,23843,23890,23937,
        23984,24030,24077,24124,24171,24217,24264,24311,
        24357,24404,24451,24497,24544,24591,24637,24684,
        24730,24777,24823,24870,24916,24963,25009,25056,
        25102,25149,25195,25241,25288,25334,25381,25427,
        25473,25520,25566,25612,25658,25705,25751,25797,
        25843,25889,25936,25982,26028,26074,26120,26166,
        26212,26258,26304,26350,26396,26442,26488,26534,
        26580,26626,26672,26718,26764,26810,26856,26902,
        26947,26993,27039,27085,27131,27176,27222,27268,
        27313,27359,27405,27450,27496,27542,27587,27633,
        27678,27724,27770,27815,27861,27906,27952,27997,
        28042,28088,28133,28179,28224,28269,28315,28360,
        28405,28451,28496,28541,28586,28632,28677,28722,
        28767,28812,28858,28903,28948,28993,29038,29083,
        29128,29173,29218,29263,29308,29353,29398,29443,
        29488,29533,29577,29622,29667,29712,29757,29801,
        29846,29891,29936,29980,30025,30070,30114,30159,
        30204,30248,30293,30337,30382,30426,30471,30515,
        30560,30604,30649,30693,30738,30782,30826,30871,
        30915,30959,31004,31048,31092,31136,31181,31225,
        31269,31313,31357,31402,31446,31490,31534,31578,
        31622,31666,31710,31754,31798,31842,31886,31930,
        31974,32017,32061,32105,32149,32193,32236,32280,
        32324,32368,32411,32455,32499,32542,32586,32630,
        32673,32717,32760,32804,32847,32891,32934,32978,
        33021,33065,33108,33151,33195,33238,33281,33325,
        33368,33411,33454,33498,33541,33584,33627,33670,
        33713,33756,33799,33843,33886,33929,33972,34015,
        34057,34100,34143,34186,34229,34272,34315,34358,
        34400,34443,34486,34529,34571,34614,34657,34699,
        34742,34785,34827,34870,34912,34955,34997,35040,
        35082,35125,35167,35210,35252,35294,35337,35379,
        35421,35464,35506,35548,35590,35633,35675,35717,
        35759,35801,35843,35885,35927,35969,36011,36053,
        36095,36137,36179,36221,36263,36305,36347,36388,
        36430,36472,36514,36555,36597,36639,36681,36722,
        36764,36805,36847,36889,36930,36972,37013,37055,
        37096,37137,37179,37220,37262,37303,37344,37386,
        37427,37468,37509,37551,37592,37633,37674,37715,
        37756,37797,37838,37879,37920,37961,38002,38043,
        38084,38125,38166,38207,38248,38288,38329,38370,
        38411,38451,38492,38533,38573,38614,38655,38695,
        38736,38776,38817,38857,38898,38938,38979,39019,
        39059,39100,39140,39180,39221,39261,39301,39341,
        39382,39422,39462,39502,39542,39582,39622,39662,
        39702,39742,39782,39822,39862,39902,39942,39982,
        40021,40061,40101,40141,40180,40220,40260,40300,
        40339,40379,40418,40458,40497,40537,40576,40616,
        40655,40695,40734,40773,40813,40852,40891,40931,
        40970,41009,41048,41087,41127,41166,41205,41244,
        41283,41322,41361,41400,41439,41478,41517,41556,
        41595,41633,41672,41711,41750,41788,41827,41866,
        41904,41943,41982,42020,42059,42097,42136,42174,
        42213,42251,42290,42328,42366,42405,42443,42481,
        42520,42558,42596,42634,42672,42711,42749,42787,
        42825,42863,42901,42939,42977,43015,43053,43091,
        43128,43166,43204,43242,43280,43317,43355,43393,
        43430,43468,43506,43543,43581,43618,43656,43693,
        43731,43768,43806,43843,43880,43918,43955,43992,
        44029,44067,44104,44141,44178,44215,44252,44289,
        44326,44363,44400,44437,44474,44511,44548,44585,
        44622,44659,44695,44732,44769,44806,44842,44879,
        44915,44952,44989,45025,45062,45098,45135,45171,
        45207,45244,45280,45316,45353,45389,45425,45462,
        45498,45534,45570,45606,45642,45678,45714,45750,
        45786,45822,45858,45894,45930,45966,46002,46037,
        46073,46109,46145,46180,46216,46252,46287,46323,
        46358,46394,46429,46465,46500,46536,46571,46606,
        46642,46677,46712,46747,46783,46818,46853,46888,
        46923,46958,46993,47028,47063,47098,47133,47168,
        47203,47238,47273,47308,47342,47377,47412,47446,
        47481,47516,47550,47585,47619,47654,47688,47723,
        47757,47792,47826,47860,47895,47929,47963,47998,
        48032,48066,48100,48134,48168,48202,48237,48271,
        48305,48338,48372,48406,48440,48474,48508,48542,
        48575,48609,48643,48676,48710,48744,48777,48811,
        48844,48878,48911,48945,48978,49012,49045,49078,
        49112,49145,49178,49211,49244,49278,49311,49344,
        49377,49410,49443,49476,49509,49542,49575,49608,
        49640,49673,49706,49739,49771,49804,49837,49869,
        49902,49935,49967,50000,50032,50065,50097,50129,
        50162,50194,50226,50259,50291,50323,50355,50387,
        50420,50452,50484,50516,50548,50580,50612,50644,
        50675,50707,50739,50771,50803,50834,50866,50898,
        50929,50961,50993,51024,51056,51087,51119,51150,
        51182,51213,51244,51276,51307,51338,51369,51401,
        51432,51463,51494,51525,51556,51587,51618,51649,
        51680,51711,51742,51773,51803,51834,51865,51896,
        51926,51957,51988,52018,52049,52079,52110,52140,
        52171,52201,52231,52262,52292,52322,52353,52383,
        52413,52443,52473,52503,52534,52564,52594,52624,
        52653,52683,52713,52743,52773,52803,52832,52862,
        52892,52922,52951,52981,53010,53040,53069,53099,
        53128,53158,53187,53216,53246,53275,53304,53334,
        53363,53392,53421,53450,53479,53508,53537,53566,
        53595,53624,53653,53682,53711,53739,53768,53797,
        53826,53854,53883,53911,53940,53969,53997,54026,
        54054,54082,54111,54139,54167,54196,54224,54252,
        54280,54308,54337,54365,54393,54421,54449,54477,
        54505,54533,54560,54588,54616,54644,54672,54699,
        54727,54755,54782,54810,54837,54865,54892,54920,
        54947,54974,55002,55029,55056,55084,55111,55138,
        55165,55192,55219,55246,55274,55300,55327,55354,
        55381,55408,55435,55462,55489,55515,55542,55569,
        55595,55622,55648,55675,55701,55728,55754,55781,
        55807,55833,55860,55886,55912,55938,55965,55991,
        56017,56043,56069,56095,56121,56147,56173,56199,
        56225,56250,56276,56302,56328,56353,56379,56404,
        56430,56456,56481,56507,56532,56557,56583,56608,
        56633,56659,56684,56709,56734,56760,56785,56810,
        56835,56860,56885,56910,56935,56959,56984,57009,
        57034,57059,57083,57108,57133,57157,57182,57206,
        57231,57255,57280,57304,57329,57353,57377,57402,
        57426,57450,57474,57498,57522,57546,57570,57594,
        57618,57642,57666,57690,57714,57738,57762,57785,
        57809,57833,57856,57880,57903,57927,57950,57974,
        57997,58021,58044,58067,58091,58114,58137,58160,
        58183,58207,58230,58253,58276,58299,58322,58345,
        58367,58390,58413,58436,58459,58481,58504,58527,
        58549,58572,58594,58617,58639,58662,58684,58706,
        58729,58751,58773,58795,58818,58840,58862,58884,
        58906,58928,58950,58972,58994,59016,59038,59059,
        59081,59103,59125,59146,59168,59190,59211,59233,
        59254,59276,59297,59318,59340,59361,59382,59404,
        59425,59446,59467,59488,59509,59530,59551,59572,
        59593,59614,59635,59656,59677,59697,59718,59739,
        59759,59780,59801,59821,59842,59862,59883,59903,
        59923,59944,59964,59984,60004,60025,60045,60065,
        60085,60105,60125,60145,60165,60185,60205,60225,
        60244,60264,60284,60304,60323,60343,60363,60382,
        60402,60421,60441,60460,60479,60499,60518,60537,
        60556,60576,60595,60614,60633,60652,60671,60690,
        60709,60728,60747,60766,60785,60803,60822,60841,
        60859,60878,60897,60915,60934,60952,60971,60989,
        61007,61026,61044,61062,61081,61099,61117,61135,
        61153,61171,61189,61207,61225,61243,61261,61279,
        61297,61314,61332,61350,61367,61385,61403,61420,
        61438,61455,61473,61490,61507,61525,61542,61559,
        61577,61594,61611,61628,61645,61662,61679,61696,
        61713,61730,61747,61764,61780,61797,61814,61831,
        61847,61864,61880,61897,61913,61930,61946,61963,
        61979,61995,62012,62028,62044,62060,62076,62092,
        62108,62125,62141,62156,62172,62188,62204,62220,
        62236,62251,62267,62283,62298,62314,62329,62345,
        62360,62376,62391,62407,62422,62437,62453,62468,
        62483,62498,62513,62528,62543,62558,62573,62588,
        62603,62618,62633,62648,62662,62677,62692,62706,
        62721,62735,62750,62764,62779,62793,62808,62822,
        62836,62850,62865,62879,62893,62907,62921,62935,
        62949,62963,62977,62991,63005,63019,63032,63046,
        63060,63074,63087,63101,63114,63128,63141,63155,
        63168,63182,63195,63208,63221,63235,63248,63261,
        63274,63287,63300,63313,63326,63339,63352,63365,
        63378,63390,63403,63416,63429,63441,63454,63466,
        63479,63491,63504,63516,63528,63541,63553,63565,
        63578,63590,63602,63614,63626,63638,63650,63662,
        63674,63686,63698,63709,63721,63733,63745,63756,
        63768,63779,63791,63803,63814,63825,63837,63848,
        63859,63871,63882,63893,63904,63915,63927,63938,
        63949,63960,63971,63981,63992,64003,64014,64025,
        64035,64046,64057,64067,64078,64088,64099,64109,
        64120,64130,64140,64151,64161,64171,64181,64192,
        64202,64212,64222,64232,64242,64252,64261,64271,
        64281,64291,64301,64310,64320,64330,64339,64349,
        64358,64368,64377,64387,64396,64405,64414,64424,
        64433,64442,64451,64460,64469,64478,64487,64496,
        64505,64514,64523,64532,64540,64549,64558,64566,
        64575,64584,64592,64601,64609,64617,64626,64634,
        64642,64651,64659,64667,64675,64683,64691,64699,
        64707,64715,64723,64731,64739,64747,64754,64762,
        64770,64777,64785,64793,64800,64808,64815,64822,
        64830,64837,64844,64852,64859,64866,64873,64880,
        64887,64895,64902,64908,64915,64922,64929,64936,
        64943,64949,64956,64963,64969,64976,64982,64989,
        64995,65002,65008,65015,65021,65027,65033,65040,
        65046,65052,65058,65064,65070,65076,65082,65088,
        65094,65099,65105,65111,65117,65122,65128,65133,
        65139,65144,65150,65155,65161,65166,65171,65177,
        65182,65187,65192,65197,65202,65207,65212,65217,
        65222,65227,65232,65237,65242,65246,65251,65256,
        65260,65265,65270,65274,65279,65283,65287,65292,
        65296,65300,65305,65309,65313,65317,65321,65325,
        65329,65333,65337,65341,65345,65349,65352,65356,
        65360,65363,65367,65371,65374,65378,65381,65385,
        65388,65391,65395,65398,65401,65404,65408,65411,
        65414,65417,65420,65423,65426,65429,65431,65434,
        65437,65440,65442,65445,65448,65450,65453,65455,
        65458,65460,65463,65465,65467,65470,65472,65474,
        65476,65478,65480,65482,65484,65486,65488,65490,
        65492,65494,65496,65497,65499,65501,65502,65504,
        65505,65507,65508,65510,65511,65513,65514,65515,
        65516,65518,65519,65520,65521,65522,65523,65524,
        65525,65526,65527,65527,65528,65529,65530,65530,
        65531,65531,65532,65532,65533,65533,65534,65534,
        65534,65535,65535,65535,65535,65535,65535,65535,
        65535,65535,65535,65535,65535,65535,65535,65534,
        65534,65534,65533,65533,65532,65532,65531,65531,
        65530,65530,65529,65528,65527,65527,65526,65525,
        65524,65523,65522,65521,65520,65519,65518,65516,
        65515,65514,65513,65511,65510,65508,65507,65505,
        65504,65502,65501,65499,65497,65496,65494,65492,
        65490,65488,65486,65484,65482,65480,65478,65476,
        65474,65472,65470,65467,65465,65463,65460,65458,
        65455,65453,65450,65448,65445,65442,65440,65437,
        65434,65431,65429,65426,65423,65420,65417,65414,
        65411,65408,65404,65401,65398,65395,65391,65388,
        65385,65381,65378,65374,65371,65367,65363,65360,
        65356,65352,65349,65345,65341,65337,65333,65329,
        65325,65321,65317,65313,65309,65305,65300,65296,
        65292,65287,65283,65279,65274,65270,65265,65260,
        65256,65251,65246,65242,65237,65232,65227,65222,
        65217,65212,65207,65202,65197,65192,65187,65182,
        65177,65171,65166,65161,65155,65150,65144,65139,
        65133,65128,65122,65117,65111,65105,65099,65094,
        65088,65082,65076,65070,65064,65058,65052,65046,
        65040,65033,65027,65021,65015,65008,65002,64995,
        64989,64982,64976,64969,64963,64956,64949,64943,
        64936,64929,64922,64915,64908,64902,64895,64887,
        64880,64873,64866,64859,64852,64844,64837,64830,
        64822,64815,64808,64800,64793,64785,64777,64770,
        64762,64754,64747,64739,64731,64723,64715,64707,
        64699,64691,64683,64675,64667,64659,64651,64642,
        64634,64626,64617,64609,64600,64592,64584,64575,
        64566,64558,64549,64540,64532,64523,64514,64505,
        64496,64487,64478,64469,64460,64451,64442,64433,
        64424,64414,64405,64396,64387,64377,64368,64358,
        64349,64339,64330,64320,64310,64301,64291,64281,
        64271,64261,64252,64242,64232,64222,64212,64202,
        64192,64181,64171,64161,64151,64140,64130,64120,
        64109,64099,64088,64078,64067,64057,64046,64035,
        64025,64014,64003,63992,63981,63971,63960,63949,
        63938,63927,63915,63904,63893,63882,63871,63859,
        63848,63837,63825,63814,63803,63791,63779,63768,
        63756,63745,63733,63721,63709,63698,63686,63674,
        63662,63650,63638,63626,63614,63602,63590,63578,
        63565,63553,63541,63528,63516,63504,63491,63479,
        63466,63454,63441,63429,63416,63403,63390,63378,
        63365,63352,63339,63326,63313,63300,63287,63274,
        63261,63248,63235,63221,63208,63195,63182,63168,
        63155,63141,63128,63114,63101,63087,63074,63060,
        63046,63032,63019,63005,62991,62977,62963,62949,
        62935,62921,62907,62893,62879,62865,62850,62836,
        62822,62808,62793,62779,62764,62750,62735,62721,
        62706,62692,62677,62662,62648,62633,62618,62603,
        62588,62573,62558,62543,62528,62513,62498,62483,
        62468,62453,62437,62422,62407,62391,62376,62360,
        62345,62329,62314,62298,62283,62267,62251,62236,
        62220,62204,62188,62172,62156,62141,62125,62108,
        62092,62076,62060,62044,62028,62012,61995,61979,
        61963,61946,61930,61913,61897,61880,61864,61847,
        61831,61814,61797,61780,61764,61747,61730,61713,
        61696,61679,61662,61645,61628,61611,61594,61577,
        61559,61542,61525,61507,61490,61473,61455,61438,
        61420,61403,61385,61367,61350,61332,61314,61297,
        61279,61261,61243,61225,61207,61189,61171,61153,
        61135,61117,61099,61081,61062,61044,61026,61007,
        60989,60971,60952,60934,60915,60897,60878,60859,
        60841,60822,60803,60785,60766,60747,60728,60709,
        60690,60671,60652,60633,60614,60595,60576,60556,
        60537,60518,60499,60479,60460,60441,60421,60402,
        60382,60363,60343,60323,60304,60284,60264,60244,
        60225,60205,60185,60165,60145,60125,60105,60085,
        60065,60045,60025,60004,59984,59964,59944,59923,
        59903,59883,59862,59842,59821,59801,59780,59759,
        59739,59718,59697,59677,59656,59635,59614,59593,
        59572,59551,59530,59509,59488,59467,59446,59425,
        59404,59382,59361,59340,59318,59297,59276,59254,
        59233,59211,59190,59168,59146,59125,59103,59081,
        59059,59038,59016,58994,58972,58950,58928,58906,
        58884,58862,58840,58818,58795,58773,58751,58729,
        58706,58684,58662,58639,58617,58594,58572,58549,
        58527,58504,58481,58459,58436,58413,58390,58367,
        58345,58322,58299,58276,58253,58230,58207,58183,
        58160,58137,58114,58091,58067,58044,58021,57997,
        57974,57950,57927,57903,57880,57856,57833,57809,
        57785,57762,57738,57714,57690,57666,57642,57618,
        57594,57570,57546,57522,57498,57474,57450,57426,
        57402,57377,57353,57329,57304,57280,57255,57231,
        57206,57182,57157,57133,57108,57083,57059,57034,
        57009,56984,56959,56935,56910,56885,56860,56835,
        56810,56785,56760,56734,56709,56684,56659,56633,
        56608,56583,56557,56532,56507,56481,56456,56430,
        56404,56379,56353,56328,56302,56276,56250,56225,
        56199,56173,56147,56121,56095,56069,56043,56017,
        55991,55965,55938,55912,55886,55860,55833,55807,
        55781,55754,55728,55701,55675,55648,55622,55595,
        55569,55542,55515,55489,55462,55435,55408,55381,
        55354,55327,55300,55274,55246,55219,55192,55165,
        55138,55111,55084,55056,55029,55002,54974,54947,
        54920,54892,54865,54837,54810,54782,54755,54727,
        54699,54672,54644,54616,54588,54560,54533,54505,
        54477,54449,54421,54393,54365,54337,54308,54280,
        54252,54224,54196,54167,54139,54111,54082,54054,
        54026,53997,53969,53940,53911,53883,53854,53826,
        53797,53768,53739,53711,53682,53653,53624,53595,
        53566,53537,53508,53479,53450,53421,53392,53363,
        53334,53304,53275,53246,53216,53187,53158,53128,
        53099,53069,53040,53010,52981,52951,52922,52892,
        52862,52832,52803,52773,52743,52713,52683,52653,
        52624,52594,52564,52534,52503,52473,52443,52413,
        52383,52353,52322,52292,52262,52231,52201,52171,
        52140,52110,52079,52049,52018,51988,51957,51926,
        51896,51865,51834,51803,51773,51742,51711,51680,
        51649,51618,51587,51556,51525,51494,51463,51432,
        51401,51369,51338,51307,51276,51244,51213,51182,
        51150,51119,51087,51056,51024,50993,50961,50929,
        50898,50866,50834,50803,50771,50739,50707,50675,
        50644,50612,50580,50548,50516,50484,50452,50420,
        50387,50355,50323,50291,50259,50226,50194,50162,
        50129,50097,50065,50032,50000,49967,49935,49902,
        49869,49837,49804,49771,49739,49706,49673,49640,
        49608,49575,49542,49509,49476,49443,49410,49377,
        49344,49311,49278,49244,49211,49178,49145,49112,
        49078,49045,49012,48978,48945,48911,48878,48844,
        48811,48777,48744,48710,48676,48643,48609,48575,
        48542,48508,48474,48440,48406,48372,48338,48304,
        48271,48237,48202,48168,48134,48100,48066,48032,
        47998,47963,47929,47895,47860,47826,47792,47757,
        47723,47688,47654,47619,47585,47550,47516,47481,
        47446,47412,47377,47342,47308,47273,47238,47203,
        47168,47133,47098,47063,47028,46993,46958,46923,
        46888,46853,46818,46783,46747,46712,46677,46642,
        46606,46571,46536,46500,46465,46429,46394,46358,
        46323,46287,46252,46216,46180,46145,46109,46073,
        46037,46002,45966,45930,45894,45858,45822,45786,
        45750,45714,45678,45642,45606,45570,45534,45498,
        45462,45425,45389,45353,45316,45280,45244,45207,
        45171,45135,45098,45062,45025,44989,44952,44915,
        44879,44842,44806,44769,44732,44695,44659,44622,
        44585,44548,44511,44474,44437,44400,44363,44326,
        44289,44252,44215,44178,44141,44104,44067,44029,
        43992,43955,43918,43880,43843,43806,43768,43731,
        43693,43656,43618,43581,43543,43506,43468,43430,
        43393,43355,43317,43280,43242,43204,43166,43128,
        43091,43053,43015,42977,42939,42901,42863,42825,
        42787,42749,42711,42672,42634,42596,42558,42520,
        42481,42443,42405,42366,42328,42290,42251,42213,
        42174,42136,42097,42059,42020,41982,41943,41904,
        41866,41827,41788,41750,41711,41672,41633,41595,
        41556,41517,41478,41439,41400,41361,41322,41283,
        41244,41205,41166,41127,41088,41048,41009,40970,
        40931,40891,40852,40813,40773,40734,40695,40655,
        40616,40576,40537,40497,40458,40418,40379,40339,
        40300,40260,40220,40180,40141,40101,40061,40021,
        39982,39942,39902,39862,39822,39782,39742,39702,
        39662,39622,39582,39542,39502,39462,39422,39382,
        39341,39301,39261,39221,39180,39140,39100,39059,
        39019,38979,38938,38898,38857,38817,38776,38736,
        38695,38655,38614,38573,38533,38492,38451,38411,
        38370,38329,38288,38248,38207,38166,38125,38084,
        38043,38002,37961,37920,37879,37838,37797,37756,
        37715,37674,37633,37592,37551,37509,37468,37427,
        37386,37344,37303,37262,37220,37179,37137,37096,
        37055,37013,36972,36930,36889,36847,36805,36764,
        36722,36681,36639,36597,36556,36514,36472,36430,
        36388,36347,36305,36263,36221,36179,36137,36095,
        36053,36011,35969,35927,35885,35843,35801,35759,
        35717,35675,35633,35590,35548,35506,35464,35421,
        35379,35337,35294,35252,35210,35167,35125,35082,
        35040,34997,34955,34912,34870,34827,34785,34742,
        34699,34657,34614,34571,34529,34486,34443,34400,
        34358,34315,34272,34229,34186,34143,34100,34057,
        34015,33972,33929,33886,33843,33799,33756,33713,
        33670,33627,33584,33541,33498,33454,33411,33368,
        33325,33281,33238,33195,33151,33108,33065,33021,
        32978,32934,32891,32847,32804,32760,32717,32673,
        32630,32586,32542,32499,32455,32411,32368,32324,
        32280,32236,32193,32149,32105,32061,32017,31974,
        31930,31886,31842,31798,31754,31710,31666,31622,
        31578,31534,31490,31446,31402,31357,31313,31269,
        31225,31181,31136,31092,31048,31004,30959,30915,
        30871,30826,30782,30738,30693,30649,30604,30560,
        30515,30471,30426,30382,30337,30293,30248,30204,
        30159,30114,30070,30025,29980,29936,29891,29846,
        29801,29757,29712,29667,29622,29577,29533,29488,
        29443,29398,29353,29308,29263,29218,29173,29128,
        29083,29038,28993,28948,28903,28858,28812,28767,
        28722,28677,28632,28586,28541,28496,28451,28405,
        28360,28315,28269,28224,28179,28133,28088,28042,
        27997,27952,27906,27861,27815,27770,27724,27678,
        27633,27587,27542,27496,27450,27405,27359,27313,
        27268,27222,27176,27131,27085,27039,26993,26947,
        26902,26856,26810,26764,26718,26672,26626,26580,
        26534,26488,26442,26396,26350,26304,26258,26212,
        26166,26120,26074,26028,25982,25936,25889,25843,
        25797,25751,25705,25658,25612,25566,25520,25473,
        25427,25381,25334,25288,25241,25195,25149,25102,
        25056,25009,24963,24916,24870,24823,24777,24730,
        24684,24637,24591,24544,24497,24451,24404,24357,
        24311,24264,24217,24171,24124,24077,24030,23984,
        23937,23890,23843,23796,23750,23703,23656,23609,
        23562,23515,23468,23421,23374,23327,23280,23233,
        23186,23139,23092,23045,22998,22951,22904,22857,
        22810,22763,22716,22668,22621,22574,22527,22480,
        22433,22385,22338,22291,22243,22196,22149,22102,
        22054,22007,21960,21912,21865,21817,21770,21723,
        21675,21628,21580,21533,21485,21438,21390,21343,
        21295,21248,21200,21153,21105,21057,21010,20962,
        20915,20867,20819,20772,20724,20676,20629,20581,
        20533,20485,20438,20390,20342,20294,20246,20199,
        20151,20103,20055,20007,19959,19912,19864,19816,
        19768,19720,19672,19624,19576,19528,19480,19432,
        19384,19336,19288,19240,19192,19144,19096,19048,
        19000,18951,18903,18855,18807,18759,18711,18663,
        18614,18566,18518,18470,18421,18373,18325,18277,
        18228,18180,18132,18084,18035,17987,17939,17890,
        17842,17793,17745,17697,17648,17600,17551,17503,
        17455,17406,17358,17309,17261,17212,17164,17115,
        17067,17018,16970,16921,16872,16824,16775,16727,
        16678,16629,16581,16532,16484,16435,16386,16338,
        16289,16240,16191,16143,16094,16045,15997,15948,
        15899,15850,15802,15753,15704,15655,15606,15557,
        15509,15460,15411,15362,15313,15264,15215,15167,
        15118,15069,15020,14971,14922,14873,14824,14775,
        14726,14677,14628,14579,14530,14481,14432,14383,
        14334,14285,14236,14187,14138,14089,14040,13990,
        13941,13892,13843,13794,13745,13696,13646,13597,
        13548,13499,13450,13401,13351,13302,13253,13204,
        13154,13105,13056,13007,12957,12908,12859,12810,
        12760,12711,12662,12612,12563,12514,12464,12415,
        12366,12316,12267,12218,12168,12119,12069,12020,
        11970,11921,11872,11822,11773,11723,11674,11624,
        11575,11525,11476,11426,11377,11327,11278,11228,
        11179,11129,11080,11030,10981,10931,10882,10832,
        10782,10733,10683,10634,10584,10534,10485,10435,
        10386,10336,10286,10237,10187,10137,10088,10038,
        9988,9939,9889,9839,9790,9740,9690,9640,
        9591,9541,9491,9442,9392,9342,9292,9243,
        9193,9143,9093,9043,8994,8944,8894,8844,
        8794,8745,8695,8645,8595,8545,8496,8446,
        8396,8346,8296,8246,8196,8147,8097,8047,
        7997,7947,7897,7847,7797,7747,7697,7648,
        7598,7548,7498,7448,7398,7348,7298,7248,
        7198,7148,7098,7048,6998,6948,6898,6848,
        6798,6748,6698,6648,6598,6548,6498,6448,
        6398,6348,6298,6248,6198,6148,6098,6048,
        5998,5948,5898,5848,5798,5748,5697,5647,
        5597,5547,5497,5447,5397,5347,5297,5247,
        5197,5146,5096,5046,4996,4946,4896,4846,
        4796,4745,4695,4645,4595,4545,4495,4445,
        4394,4344,4294,4244,4194,4144,4093,4043,
        3993,3943,3893,3843,3792,3742,3692,3642,
        3592,3541,3491,3441,3391,3341,3291,3240,
        3190,3140,3090,3039,2989,2939,2889,2839,
        2788,2738,2688,2638,2587,2537,2487,2437,
        2387,2336,2286,2236,2186,2135,2085,2035,
        1985,1934,1884,1834,1784,1733,1683,1633,
        1583,1532,1482,1432,1382,1331,1281,1231,
        1181,1130,1080,1030,980,929,879,829,
        779,728,678,628,578,527,477,427,
        376,326,276,226,175,125,75,25,
        -25,-75,-125,-175,-226,-276,-326,-376,
        -427,-477,-527,-578,-628,-678,-728,-779,
        -829,-879,-929,-980,-1030,-1080,-1130,-1181,
        -1231,-1281,-1331,-1382,-1432,-1482,-1532,-1583,
        -1633,-1683,-1733,-1784,-1834,-1884,-1934,-1985,
        -2035,-2085,-2135,-2186,-2236,-2286,-2336,-2387,
        -2437,-2487,-2537,-2588,-2638,-2688,-2738,-2788,
        -2839,-2889,-2939,-2989,-3039,-3090,-3140,-3190,
        -3240,-3291,-3341,-3391,-3441,-3491,-3541,-3592,
        -3642,-3692,-3742,-3792,-3843,-3893,-3943,-3993,
        -4043,-4093,-4144,-4194,-4244,-4294,-4344,-4394,
        -4445,-4495,-4545,-4595,-4645,-4695,-4745,-4796,
        -4846,-4896,-4946,-4996,-5046,-5096,-5146,-5197,
        -5247,-5297,-5347,-5397,-5447,-5497,-5547,-5597,
        -5647,-5697,-5748,-5798,-5848,-5898,-5948,-5998,
        -6048,-6098,-6148,-6198,-6248,-6298,-6348,-6398,
        -6448,-6498,-6548,-6598,-6648,-6698,-6748,-6798,
        -6848,-6898,-6948,-6998,-7048,-7098,-7148,-7198,
        -7248,-7298,-7348,-7398,-7448,-7498,-7548,-7598,
        -7648,-7697,-7747,-7797,-7847,-7897,-7947,-7997,
        -8047,-8097,-8147,-8196,-8246,-8296,-8346,-8396,
        -8446,-8496,-8545,-8595,-8645,-8695,-8745,-8794,
        -8844,-8894,-8944,-8994,-9043,-9093,-9143,-9193,
        -9243,-9292,-9342,-9392,-9442,-9491,-9541,-9591,
        -9640,-9690,-9740,-9790,-9839,-9889,-9939,-9988,
        -10038,-10088,-10137,-10187,-10237,-10286,-10336,-10386,
        -10435,-10485,-10534,-10584,-10634,-10683,-10733,-10782,
        -10832,-10882,-10931,-10981,-11030,-11080,-11129,-11179,
        -11228,-11278,-11327,-11377,-11426,-11476,-11525,-11575,
        -11624,-11674,-11723,-11773,-11822,-11872,-11921,-11970,
        -12020,-12069,-12119,-12168,-12218,-12267,-12316,-12366,
        -12415,-12464,-12514,-12563,-12612,-12662,-12711,-12760,
        -12810,-12859,-12908,-12957,-13007,-13056,-13105,-13154,
        -13204,-13253,-13302,-13351,-13401,-13450,-13499,-13548,
        -13597,-13647,-13696,-13745,-13794,-13843,-13892,-13941,
        -13990,-14040,-14089,-14138,-14187,-14236,-14285,-14334,
        -14383,-14432,-14481,-14530,-14579,-14628,-14677,-14726,
        -14775,-14824,-14873,-14922,-14971,-15020,-15069,-15118,
        -15167,-15215,-15264,-15313,-15362,-15411,-15460,-15509,
        -15557,-15606,-15655,-15704,-15753,-15802,-15850,-15899,
        -15948,-15997,-16045,-16094,-16143,-16191,-16240,-16289,
        -16338,-16386,-16435,-16484,-16532,-16581,-16629,-16678,
        -16727,-16775,-16824,-16872,-16921,-16970,-17018,-17067,
        -17115,-17164,-17212,-17261,-17309,-17358,-17406,-17455,
        -17503,-17551,-17600,-17648,-17697,-17745,-17793,-17842,
        -17890,-17939,-17987,-18035,-18084,-18132,-18180,-18228,
        -18277,-18325,-18373,-18421,-18470,-18518,-18566,-18614,
        -18663,-18711,-18759,-18807,-18855,-18903,-18951,-19000,
        -19048,-19096,-19144,-19192,-19240,-19288,-19336,-19384,
        -19432,-19480,-19528,-19576,-19624,-19672,-19720,-19768,
        -19816,-19864,-19912,-19959,-20007,-20055,-20103,-20151,
        -20199,-20246,-20294,-20342,-20390,-20438,-20485,-20533,
        -20581,-20629,-20676,-20724,-20772,-20819,-20867,-20915,
        -20962,-21010,-21057,-21105,-21153,-21200,-21248,-21295,
        -21343,-21390,-21438,-21485,-21533,-21580,-21628,-21675,
        -21723,-21770,-21817,-21865,-21912,-21960,-22007,-22054,
        -22102,-22149,-22196,-22243,-22291,-22338,-22385,-22433,
        -22480,-22527,-22574,-22621,-22668,-22716,-22763,-22810,
        -22857,-22904,-22951,-22998,-23045,-23092,-23139,-23186,
        -23233,-23280,-23327,-23374,-23421,-23468,-23515,-23562,
        -23609,-23656,-23703,-23750,-23796,-23843,-23890,-23937,
        -23984,-24030,-24077,-24124,-24171,-24217,-24264,-24311,
        -24357,-24404,-24451,-24497,-24544,-24591,-24637,-24684,
        -24730,-24777,-24823,-24870,-24916,-24963,-25009,-25056,
        -25102,-25149,-25195,-25241,-25288,-25334,-25381,-25427,
        -25473,-25520,-25566,-25612,-25658,-25705,-25751,-25797,
        -25843,-25889,-25936,-25982,-26028,-26074,-26120,-26166,
        -26212,-26258,-26304,-26350,-26396,-26442,-26488,-26534,
        -26580,-26626,-26672,-26718,-26764,-26810,-26856,-26902,
        -26947,-26993,-27039,-27085,-27131,-27176,-27222,-27268,
        -27313,-27359,-27405,-27450,-27496,-27542,-27587,-27633,
        -27678,-27724,-27770,-27815,-27861,-27906,-27952,-27997,
        -28042,-28088,-28133,-28179,-28224,-28269,-28315,-28360,
        -28405,-28451,-28496,-28541,-28586,-28632,-28677,-28722,
        -28767,-28812,-28858,-28903,-28948,-28993,-29038,-29083,
        -29128,-29173,-29218,-29263,-29308,-29353,-29398,-29443,
        -29488,-29533,-29577,-29622,-29667,-29712,-29757,-29801,
        -29846,-29891,-29936,-29980,-30025,-30070,-30114,-30159,
        -30204,-30248,-30293,-30337,-30382,-30426,-30471,-30515,
        -30560,-30604,-30649,-30693,-30738,-30782,-30826,-30871,
        -30915,-30959,-31004,-31048,-31092,-31136,-31181,-31225,
        -31269,-31313,-31357,-31402,-31446,-31490,-31534,-31578,
        -31622,-31666,-31710,-31754,-31798,-31842,-31886,-31930,
        -31974,-32017,-32061,-32105,-32149,-32193,-32236,-32280,
        -32324,-32368,-32411,-32455,-32499,-32542,-32586,-32630,
        -32673,-32717,-32760,-32804,-32847,-32891,-32934,-32978,
        -33021,-33065,-33108,-33151,-33195,-33238,-33281,-33325,
        -33368,-33411,-33454,-33498,-33541,-33584,-33627,-33670,
        -33713,-33756,-33799,-33843,-33886,-33929,-33972,-34015,
        -34057,-34100,-34143,-34186,-34229,-34272,-34315,-34358,
        -34400,-34443,-34486,-34529,-34571,-34614,-34657,-34699,
        -34742,-34785,-34827,-34870,-34912,-34955,-34997,-35040,
        -35082,-35125,-35167,-35210,-35252,-35294,-35337,-35379,
        -35421,-35464,-35506,-35548,-35590,-35633,-35675,-35717,
        -35759,-35801,-35843,-35885,-35927,-35969,-36011,-36053,
        -36095,-36137,-36179,-36221,-36263,-36305,-36347,-36388,
        -36430,-36472,-36514,-36555,-36597,-36639,-36681,-36722,
        -36764,-36805,-36847,-36889,-36930,-36972,-37013,-37055,
        -37096,-37137,-37179,-37220,-37262,-37303,-37344,-37386,
        -37427,-37468,-37509,-37551,-37592,-37633,-37674,-37715,
        -37756,-37797,-37838,-37879,-37920,-37961,-38002,-38043,
        -38084,-38125,-38166,-38207,-38248,-38288,-38329,-38370,
        -38411,-38451,-38492,-38533,-38573,-38614,-38655,-38695,
        -38736,-38776,-38817,-38857,-38898,-38938,-38979,-39019,
        -39059,-39100,-39140,-39180,-39221,-39261,-39301,-39341,
        -39382,-39422,-39462,-39502,-39542,-39582,-39622,-39662,
        -39702,-39742,-39782,-39822,-39862,-39902,-39942,-39982,
        -40021,-40061,-40101,-40141,-40180,-40220,-40260,-40299,
        -40339,-40379,-40418,-40458,-40497,-40537,-40576,-40616,
        -40655,-40695,-40734,-40773,-40813,-40852,-40891,-40931,
        -40970,-41009,-41048,-41087,-41127,-41166,-41205,-41244,
        -41283,-41322,-41361,-41400,-41439,-41478,-41517,-41556,
        -41595,-41633,-41672,-41711,-41750,-41788,-41827,-41866,
        -41904,-41943,-41982,-42020,-42059,-42097,-42136,-42174,
        -42213,-42251,-42290,-42328,-42366,-42405,-42443,-42481,
        -42520,-42558,-42596,-42634,-42672,-42711,-42749,-42787,
        -42825,-42863,-42901,-42939,-42977,-43015,-43053,-43091,
        -43128,-43166,-43204,-43242,-43280,-43317,-43355,-43393,
        -43430,-43468,-43506,-43543,-43581,-43618,-43656,-43693,
        -43731,-43768,-43806,-43843,-43880,-43918,-43955,-43992,
        -44029,-44067,-44104,-44141,-44178,-44215,-44252,-44289,
        -44326,-44363,-44400,-44437,-44474,-44511,-44548,-44585,
        -44622,-44659,-44695,-44732,-44769,-44806,-44842,-44879,
        -44915,-44952,-44989,-45025,-45062,-45098,-45135,-45171,
        -45207,-45244,-45280,-45316,-45353,-45389,-45425,-45462,
        -45498,-45534,-45570,-45606,-45642,-45678,-45714,-45750,
        -45786,-45822,-45858,-45894,-45930,-45966,-46002,-46037,
        -46073,-46109,-46145,-46180,-46216,-46252,-46287,-46323,
        -46358,-46394,-46429,-46465,-46500,-46536,-46571,-46606,
        -46642,-46677,-46712,-46747,-46783,-46818,-46853,-46888,
        -46923,-46958,-46993,-47028,-47063,-47098,-47133,-47168,
        -47203,-47238,-47273,-47308,-47342,-47377,-47412,-47446,
        -47481,-47516,-47550,-47585,-47619,-47654,-47688,-47723,
        -47757,-47792,-47826,-47860,-47895,-47929,-47963,-47998,
        -48032,-48066,-48100,-48134,-48168,-48202,-48236,-48271,
        -48304,-48338,-48372,-48406,-48440,-48474,-48508,-48542,
        -48575,-48609,-48643,-48676,-48710,-48744,-48777,-48811,
        -48844,-48878,-48911,-48945,-48978,-49012,-49045,-49078,
        -49112,-49145,-49178,-49211,-49244,-49278,-49311,-49344,
        -49377,-49410,-49443,-49476,-49509,-49542,-49575,-49608,
        -49640,-49673,-49706,-49739,-49771,-49804,-49837,-49869,
        -49902,-49935,-49967,-50000,-50032,-50065,-50097,-50129,
        -50162,-50194,-50226,-50259,-50291,-50323,-50355,-50387,
        -50420,-50452,-50484,-50516,-50548,-50580,-50612,-50644,
        -50675,-50707,-50739,-50771,-50803,-50834,-50866,-50898,
        -50929,-50961,-50993,-51024,-51056,-51087,-51119,-51150,
        -51182,-51213,-51244,-51276,-51307,-51338,-51369,-51401,
        -51432,-51463,-51494,-51525,-51556,-51587,-51618,-51649,
        -51680,-51711,-51742,-51773,-51803,-51834,-51865,-51896,
        -51926,-51957,-51988,-52018,-52049,-52079,-52110,-52140,
        -52171,-52201,-52231,-52262,-52292,-52322,-52353,-52383,
        -52413,-52443,-52473,-52503,-52534,-52564,-52594,-52624,
        -52653,-52683,-52713,-52743,-52773,-52803,-52832,-52862,
        -52892,-52922,-52951,-52981,-53010,-53040,-53069,-53099,
        -53128,-53158,-53187,-53216,-53246,-53275,-53304,-53334,
        -53363,-53392,-53421,-53450,-53479,-53508,-53537,-53566,
        -53595,-53624,-53653,-53682,-53711,-53739,-53768,-53797,
        -53826,-53854,-53883,-53911,-53940,-53969,-53997,-54026,
        -54054,-54082,-54111,-54139,-54167,-54196,-54224,-54252,
        -54280,-54308,-54337,-54365,-54393,-54421,-54449,-54477,
        -54505,-54533,-54560,-54588,-54616,-54644,-54672,-54699,
        -54727,-54755,-54782,-54810,-54837,-54865,-54892,-54920,
        -54947,-54974,-55002,-55029,-55056,-55084,-55111,-55138,
        -55165,-55192,-55219,-55246,-55274,-55300,-55327,-55354,
        -55381,-55408,-55435,-55462,-55489,-55515,-55542,-55569,
        -55595,-55622,-55648,-55675,-55701,-55728,-55754,-55781,
        -55807,-55833,-55860,-55886,-55912,-55938,-55965,-55991,
        -56017,-56043,-56069,-56095,-56121,-56147,-56173,-56199,
        -56225,-56250,-56276,-56302,-56328,-56353,-56379,-56404,
        -56430,-56456,-56481,-56507,-56532,-56557,-56583,-56608,
        -56633,-56659,-56684,-56709,-56734,-56760,-56785,-56810,
        -56835,-56860,-56885,-56910,-56935,-56959,-56984,-57009,
        -57034,-57059,-57083,-57108,-57133,-57157,-57182,-57206,
        -57231,-57255,-57280,-57304,-57329,-57353,-57377,-57402,
        -57426,-57450,-57474,-57498,-57522,-57546,-57570,-57594,
        -57618,-57642,-57666,-57690,-57714,-57738,-57762,-57785,
        -57809,-57833,-57856,-57880,-57903,-57927,-57950,-57974,
        -57997,-58021,-58044,-58067,-58091,-58114,-58137,-58160,
        -58183,-58207,-58230,-58253,-58276,-58299,-58322,-58345,
        -58367,-58390,-58413,-58436,-58459,-58481,-58504,-58527,
        -58549,-58572,-58594,-58617,-58639,-58662,-58684,-58706,
        -58729,-58751,-58773,-58795,-58818,-58840,-58862,-58884,
        -58906,-58928,-58950,-58972,-58994,-59016,-59038,-59059,
        -59081,-59103,-59125,-59146,-59168,-59190,-59211,-59233,
        -59254,-59276,-59297,-59318,-59340,-59361,-59382,-59404,
        -59425,-59446,-59467,-59488,-59509,-59530,-59551,-59572,
        -59593,-59614,-59635,-59656,-59677,-59697,-59718,-59739,
        -59759,-59780,-59801,-59821,-59842,-59862,-59883,-59903,
        -59923,-59944,-59964,-59984,-60004,-60025,-60045,-60065,
        -60085,-60105,-60125,-60145,-60165,-60185,-60205,-60225,
        -60244,-60264,-60284,-60304,-60323,-60343,-60363,-60382,
        -60402,-60421,-60441,-60460,-60479,-60499,-60518,-60537,
        -60556,-60576,-60595,-60614,-60633,-60652,-60671,-60690,
        -60709,-60728,-60747,-60766,-60785,-60803,-60822,-60841,
        -60859,-60878,-60897,-60915,-60934,-60952,-60971,-60989,
        -61007,-61026,-61044,-61062,-61081,-61099,-61117,-61135,
        -61153,-61171,-61189,-61207,-61225,-61243,-61261,-61279,
        -61297,-61314,-61332,-61350,-61367,-61385,-61403,-61420,
        -61438,-61455,-61473,-61490,-61507,-61525,-61542,-61559,
        -61577,-61594,-61611,-61628,-61645,-61662,-61679,-61696,
        -61713,-61730,-61747,-61764,-61780,-61797,-61814,-61831,
        -61847,-61864,-61880,-61897,-61913,-61930,-61946,-61963,
        -61979,-61995,-62012,-62028,-62044,-62060,-62076,-62092,
        -62108,-62125,-62141,-62156,-62172,-62188,-62204,-62220,
        -62236,-62251,-62267,-62283,-62298,-62314,-62329,-62345,
        -62360,-62376,-62391,-62407,-62422,-62437,-62453,-62468,
        -62483,-62498,-62513,-62528,-62543,-62558,-62573,-62588,
        -62603,-62618,-62633,-62648,-62662,-62677,-62692,-62706,
        -62721,-62735,-62750,-62764,-62779,-62793,-62808,-62822,
        -62836,-62850,-62865,-62879,-62893,-62907,-62921,-62935,
        -62949,-62963,-62977,-62991,-63005,-63019,-63032,-63046,
        -63060,-63074,-63087,-63101,-63114,-63128,-63141,-63155,
        -63168,-63182,-63195,-63208,-63221,-63235,-63248,-63261,
        -63274,-63287,-63300,-63313,-63326,-63339,-63352,-63365,
        -63378,-63390,-63403,-63416,-63429,-63441,-63454,-63466,
        -63479,-63491,-63504,-63516,-63528,-63541,-63553,-63565,
        -63578,-63590,-63602,-63614,-63626,-63638,-63650,-63662,
        -63674,-63686,-63698,-63709,-63721,-63733,-63745,-63756,
        -63768,-63779,-63791,-63803,-63814,-63825,-63837,-63848,
        -63859,-63871,-63882,-63893,-63904,-63915,-63927,-63938,
        -63949,-63960,-63971,-63981,-63992,-64003,-64014,-64025,
        -64035,-64046,-64057,-64067,-64078,-64088,-64099,-64109,
        -64120,-64130,-64140,-64151,-64161,-64171,-64181,-64192,
        -64202,-64212,-64222,-64232,-64242,-64252,-64261,-64271,
        -64281,-64291,-64301,-64310,-64320,-64330,-64339,-64349,
        -64358,-64368,-64377,-64387,-64396,-64405,-64414,-64424,
        -64433,-64442,-64451,-64460,-64469,-64478,-64487,-64496,
        -64505,-64514,-64523,-64532,-64540,-64549,-64558,-64566,
        -64575,-64584,-64592,-64601,-64609,-64617,-64626,-64634,
        -64642,-64651,-64659,-64667,-64675,-64683,-64691,-64699,
        -64707,-64715,-64723,-64731,-64739,-64747,-64754,-64762,
        -64770,-64777,-64785,-64793,-64800,-64808,-64815,-64822,
        -64830,-64837,-64844,-64852,-64859,-64866,-64873,-64880,
        -64887,-64895,-64902,-64908,-64915,-64922,-64929,-64936,
        -64943,-64949,-64956,-64963,-64969,-64976,-64982,-64989,
        -64995,-65002,-65008,-65015,-65021,-65027,-65033,-65040,
        -65046,-65052,-65058,-65064,-65070,-65076,-65082,-65088,
        -65094,-65099,-65105,-65111,-65117,-65122,-65128,-65133,
        -65139,-65144,-65150,-65155,-65161,-65166,-65171,-65177,
        -65182,-65187,-65192,-65197,-65202,-65207,-65212,-65217,
        -65222,-65227,-65232,-65237,-65242,-65246,-65251,-65256,
        -65260,-65265,-65270,-65274,-65279,-65283,-65287,-65292,
        -65296,-65300,-65305,-65309,-65313,-65317,-65321,-65325,
        -65329,-65333,-65337,-65341,-65345,-65349,-65352,-65356,
        -65360,-65363,-65367,-65371,-65374,-65378,-65381,-65385,
        -65388,-65391,-65395,-65398,-65401,-65404,-65408,-65411,
        -65414,-65417,-65420,-65423,-65426,-65429,-65431,-65434,
        -65437,-65440,-65442,-65445,-65448,-65450,-65453,-65455,
        -65458,-65460,-65463,-65465,-65467,-65470,-65472,-65474,
        -65476,-65478,-65480,-65482,-65484,-65486,-65488,-65490,
        -65492,-65494,-65496,-65497,-65499,-65501,-65502,-65504,
        -65505,-65507,-65508,-65510,-65511,-65513,-65514,-65515,
        -65516,-65518,-65519,-65520,-65521,-65522,-65523,-65524,
        -65525,-65526,-65527,-65527,-65528,-65529,-65530,-65530,
        -65531,-65531,-65532,-65532,-65533,-65533,-65534,-65534,
        -65534,-65535,-65535,-65535,-65535,-65535,-65535,-65535,
        -65535,-65535,-65535,-65535,-65535,-65535,-65535,-65534,
        -65534,-65534,-65533,-65533,-65532,-65532,-65531,-65531,
        -65530,-65530,-65529,-65528,-65527,-65527,-65526,-65525,
        -65524,-65523,-65522,-65521,-65520,-65519,-65518,-65516,
        -65515,-65514,-65513,-65511,-65510,-65508,-65507,-65505,
        -65504,-65502,-65501,-65499,-65497,-65496,-65494,-65492,
        -65490,-65488,-65486,-65484,-65482,-65480,-65478,-65476,
        -65474,-65472,-65470,-65467,-65465,-65463,-65460,-65458,
        -65455,-65453,-65450,-65448,-65445,-65442,-65440,-65437,
        -65434,-65431,-65429,-65426,-65423,-65420,-65417,-65414,
        -65411,-65408,-65404,-65401,-65398,-65395,-65391,-65388,
        -65385,-65381,-65378,-65374,-65371,-65367,-65363,-65360,
        -65356,-65352,-65349,-65345,-65341,-65337,-65333,-65329,
        -65325,-65321,-65317,-65313,-65309,-65305,-65300,-65296,
        -65292,-65287,-65283,-65279,-65274,-65270,-65265,-65260,
        -65256,-65251,-65246,-65242,-65237,-65232,-65227,-65222,
        -65217,-65212,-65207,-65202,-65197,-65192,-65187,-65182,
        -65177,-65171,-65166,-65161,-65155,-65150,-65144,-65139,
        -65133,-65128,-65122,-65117,-65111,-65105,-65099,-65094,
        -65088,-65082,-65076,-65070,-65064,-65058,-65052,-65046,
        -65040,-65033,-65027,-65021,-65015,-65008,-65002,-64995,
        -64989,-64982,-64976,-64969,-64963,-64956,-64949,-64943,
        -64936,-64929,-64922,-64915,-64908,-64902,-64895,-64887,
        -64880,-64873,-64866,-64859,-64852,-64844,-64837,-64830,
        -64822,-64815,-64808,-64800,-64793,-64785,-64777,-64770,
        -64762,-64754,-64747,-64739,-64731,-64723,-64715,-64707,
        -64699,-64691,-64683,-64675,-64667,-64659,-64651,-64642,
        -64634,-64626,-64617,-64609,-64601,-64592,-64584,-64575,
        -64566,-64558,-64549,-64540,-64532,-64523,-64514,-64505,
        -64496,-64487,-64478,-64469,-64460,-64451,-64442,-64433,
        -64424,-64414,-64405,-64396,-64387,-64377,-64368,-64358,
        -64349,-64339,-64330,-64320,-64310,-64301,-64291,-64281,
        -64271,-64261,-64252,-64242,-64232,-64222,-64212,-64202,
        -64192,-64181,-64171,-64161,-64151,-64140,-64130,-64120,
        -64109,-64099,-64088,-64078,-64067,-64057,-64046,-64035,
        -64025,-64014,-64003,-63992,-63981,-63971,-63960,-63949,
        -63938,-63927,-63915,-63904,-63893,-63882,-63871,-63859,
        -63848,-63837,-63825,-63814,-63803,-63791,-63779,-63768,
        -63756,-63745,-63733,-63721,-63709,-63698,-63686,-63674,
        -63662,-63650,-63638,-63626,-63614,-63602,-63590,-63578,
        -63565,-63553,-63541,-63528,-63516,-63504,-63491,-63479,
        -63466,-63454,-63441,-63429,-63416,-63403,-63390,-63378,
        -63365,-63352,-63339,-63326,-63313,-63300,-63287,-63274,
        -63261,-63248,-63235,-63221,-63208,-63195,-63182,-63168,
        -63155,-63141,-63128,-63114,-63101,-63087,-63074,-63060,
        -63046,-63032,-63019,-63005,-62991,-62977,-62963,-62949,
        -62935,-62921,-62907,-62893,-62879,-62865,-62850,-62836,
        -62822,-62808,-62793,-62779,-62764,-62750,-62735,-62721,
        -62706,-62692,-62677,-62662,-62648,-62633,-62618,-62603,
        -62588,-62573,-62558,-62543,-62528,-62513,-62498,-62483,
        -62468,-62453,-62437,-62422,-62407,-62391,-62376,-62360,
        -62345,-62329,-62314,-62298,-62283,-62267,-62251,-62236,
        -62220,-62204,-62188,-62172,-62156,-62141,-62125,-62108,
        -62092,-62076,-62060,-62044,-62028,-62012,-61995,-61979,
        -61963,-61946,-61930,-61913,-61897,-61880,-61864,-61847,
        -61831,-61814,-61797,-61780,-61764,-61747,-61730,-61713,
        -61696,-61679,-61662,-61645,-61628,-61611,-61594,-61577,
        -61559,-61542,-61525,-61507,-61490,-61473,-61455,-61438,
        -61420,-61403,-61385,-61367,-61350,-61332,-61314,-61297,
        -61279,-61261,-61243,-61225,-61207,-61189,-61171,-61153,
        -61135,-61117,-61099,-61081,-61062,-61044,-61026,-61007,
        -60989,-60971,-60952,-60934,-60915,-60897,-60878,-60859,
        -60841,-60822,-60803,-60785,-60766,-60747,-60728,-60709,
        -60690,-60671,-60652,-60633,-60614,-60595,-60576,-60556,
        -60537,-60518,-60499,-60479,-60460,-60441,-60421,-60402,
        -60382,-60363,-60343,-60323,-60304,-60284,-60264,-60244,
        -60225,-60205,-60185,-60165,-60145,-60125,-60105,-60085,
        -60065,-60045,-60025,-60004,-59984,-59964,-59944,-59923,
        -59903,-59883,-59862,-59842,-59821,-59801,-59780,-59759,
        -59739,-59718,-59697,-59677,-59656,-59635,-59614,-59593,
        -59572,-59551,-59530,-59509,-59488,-59467,-59446,-59425,
        -59404,-59382,-59361,-59340,-59318,-59297,-59276,-59254,
        -59233,-59211,-59189,-59168,-59146,-59125,-59103,-59081,
        -59059,-59038,-59016,-58994,-58972,-58950,-58928,-58906,
        -58884,-58862,-58840,-58818,-58795,-58773,-58751,-58729,
        -58706,-58684,-58662,-58639,-58617,-58594,-58572,-58549,
        -58527,-58504,-58481,-58459,-58436,-58413,-58390,-58367,
        -58345,-58322,-58299,-58276,-58253,-58230,-58207,-58183,
        -58160,-58137,-58114,-58091,-58067,-58044,-58021,-57997,
        -57974,-57950,-57927,-57903,-57880,-57856,-57833,-57809,
        -57785,-57762,-57738,-57714,-57690,-57666,-57642,-57618,
        -57594,-57570,-57546,-57522,-57498,-57474,-57450,-57426,
        -57402,-57377,-57353,-57329,-57304,-57280,-57255,-57231,
        -57206,-57182,-57157,-57133,-57108,-57083,-57059,-57034,
        -57009,-56984,-56959,-56935,-56910,-56885,-56860,-56835,
        -56810,-56785,-56760,-56734,-56709,-56684,-56659,-56633,
        -56608,-56583,-56557,-56532,-56507,-56481,-56456,-56430,
        -56404,-56379,-56353,-56328,-56302,-56276,-56250,-56225,
        -56199,-56173,-56147,-56121,-56095,-56069,-56043,-56017,
        -55991,-55965,-55938,-55912,-55886,-55860,-55833,-55807,
        -55781,-55754,-55728,-55701,-55675,-55648,-55622,-55595,
        -55569,-55542,-55515,-55489,-55462,-55435,-55408,-55381,
        -55354,-55327,-55300,-55274,-55246,-55219,-55192,-55165,
        -55138,-55111,-55084,-55056,-55029,-55002,-54974,-54947,
        -54920,-54892,-54865,-54837,-54810,-54782,-54755,-54727,
        -54699,-54672,-54644,-54616,-54588,-54560,-54533,-54505,
        -54477,-54449,-54421,-54393,-54365,-54337,-54308,-54280,
        -54252,-54224,-54196,-54167,-54139,-54111,-54082,-54054,
        -54026,-53997,-53969,-53940,-53911,-53883,-53854,-53826,
        -53797,-53768,-53739,-53711,-53682,-53653,-53624,-53595,
        -53566,-53537,-53508,-53479,-53450,-53421,-53392,-53363,
        -53334,-53304,-53275,-53246,-53216,-53187,-53158,-53128,
        -53099,-53069,-53040,-53010,-52981,-52951,-52922,-52892,
        -52862,-52832,-52803,-52773,-52743,-52713,-52683,-52653,
        -52624,-52594,-52564,-52534,-52503,-52473,-52443,-52413,
        -52383,-52353,-52322,-52292,-52262,-52231,-52201,-52171,
        -52140,-52110,-52079,-52049,-52018,-51988,-51957,-51926,
        -51896,-51865,-51834,-51803,-51773,-51742,-51711,-51680,
        -51649,-51618,-51587,-51556,-51525,-51494,-51463,-51432,
        -51401,-51369,-51338,-51307,-51276,-51244,-51213,-51182,
        -51150,-51119,-51087,-51056,-51024,-50993,-50961,-50929,
        -50898,-50866,-50834,-50803,-50771,-50739,-50707,-50675,
        -50644,-50612,-50580,-50548,-50516,-50484,-50452,-50420,
        -50387,-50355,-50323,-50291,-50259,-50226,-50194,-50162,
        -50129,-50097,-50065,-50032,-50000,-49967,-49935,-49902,
        -49869,-49837,-49804,-49771,-49739,-49706,-49673,-49640,
        -49608,-49575,-49542,-49509,-49476,-49443,-49410,-49377,
        -49344,-49311,-49278,-49244,-49211,-49178,-49145,-49112,
        -49078,-49045,-49012,-48978,-48945,-48911,-48878,-48844,
        -48811,-48777,-48744,-48710,-48676,-48643,-48609,-48575,
        -48542,-48508,-48474,-48440,-48406,-48372,-48338,-48305,
        -48271,-48237,-48202,-48168,-48134,-48100,-48066,-48032,
        -47998,-47963,-47929,-47895,-47860,-47826,-47792,-47757,
        -47723,-47688,-47654,-47619,-47585,-47550,-47516,-47481,
        -47446,-47412,-47377,-47342,-47307,-47273,-47238,-47203,
        -47168,-47133,-47098,-47063,-47028,-46993,-46958,-46923,
        -46888,-46853,-46818,-46783,-46747,-46712,-46677,-46642,
        -46606,-46571,-46536,-46500,-46465,-46429,-46394,-46358,
        -46323,-46287,-46251,-46216,-46180,-46145,-46109,-46073,
        -46037,-46002,-45966,-45930,-45894,-45858,-45822,-45786,
        -45750,-45714,-45678,-45642,-45606,-45570,-45534,-45498,
        -45462,-45425,-45389,-45353,-45316,-45280,-45244,-45207,
        -45171,-45135,-45098,-45062,-45025,-44989,-44952,-44915,
        -44879,-44842,-44806,-44769,-44732,-44695,-44659,-44622,
        -44585,-44548,-44511,-44474,-44437,-44400,-44363,-44326,
        -44289,-44252,-44215,-44178,-44141,-44104,-44067,-44029,
        -43992,-43955,-43918,-43880,-43843,-43806,-43768,-43731,
        -43693,-43656,-43618,-43581,-43543,-43506,-43468,-43430,
        -43393,-43355,-43317,-43280,-43242,-43204,-43166,-43128,
        -43091,-43053,-43015,-42977,-42939,-42901,-42863,-42825,
        -42787,-42749,-42711,-42672,-42634,-42596,-42558,-42520,
        -42481,-42443,-42405,-42366,-42328,-42290,-42251,-42213,
        -42174,-42136,-42097,-42059,-42020,-41982,-41943,-41904,
        -41866,-41827,-41788,-41750,-41711,-41672,-41633,-41595,
        -41556,-41517,-41478,-41439,-41400,-41361,-41322,-41283,
        -41244,-41205,-41166,-41127,-41087,-41048,-41009,-40970,
        -40931,-40891,-40852,-40813,-40773,-40734,-40695,-40655,
        -40616,-40576,-40537,-40497,-40458,-40418,-40379,-40339,
        -40299,-40260,-40220,-40180,-40141,-40101,-40061,-40021,
        -39982,-39942,-39902,-39862,-39822,-39782,-39742,-39702,
        -39662,-39622,-39582,-39542,-39502,-39462,-39422,-39382,
        -39341,-39301,-39261,-39221,-39180,-39140,-39100,-39059,
        -39019,-38979,-38938,-38898,-38857,-38817,-38776,-38736,
        -38695,-38655,-38614,-38573,-38533,-38492,-38451,-38411,
        -38370,-38329,-38288,-38248,-38207,-38166,-38125,-38084,
        -38043,-38002,-37961,-37920,-37879,-37838,-37797,-37756,
        -37715,-37674,-37633,-37592,-37550,-37509,-37468,-37427,
        -37386,-37344,-37303,-37262,-37220,-37179,-37137,-37096,
        -37055,-37013,-36972,-36930,-36889,-36847,-36805,-36764,
        -36722,-36681,-36639,-36597,-36556,-36514,-36472,-36430,
        -36388,-36347,-36305,-36263,-36221,-36179,-36137,-36095,
        -36053,-36011,-35969,-35927,-35885,-35843,-35801,-35759,
        -35717,-35675,-35633,-35590,-35548,-35506,-35464,-35421,
        -35379,-35337,-35294,-35252,-35210,-35167,-35125,-35082,
        -35040,-34997,-34955,-34912,-34870,-34827,-34785,-34742,
        -34699,-34657,-34614,-34571,-34529,-34486,-34443,-34400,
        -34358,-34315,-34272,-34229,-34186,-34143,-34100,-34057,
        -34015,-33972,-33929,-33886,-33843,-33799,-33756,-33713,
        -33670,-33627,-33584,-33541,-33498,-33454,-33411,-33368,
        -33325,-33281,-33238,-33195,-33151,-33108,-33065,-33021,
        -32978,-32934,-32891,-32847,-32804,-32760,-32717,-32673,
        -32630,-32586,-32542,-32499,-32455,-32411,-32368,-32324,
        -32280,-32236,-32193,-32149,-32105,-32061,-32017,-31974,
        -31930,-31886,-31842,-31798,-31754,-31710,-31666,-31622,
        -31578,-31534,-31490,-31446,-31402,-31357,-31313,-31269,
        -31225,-31181,-31136,-31092,-31048,-31004,-30959,-30915,
        -30871,-30826,-30782,-30738,-30693,-30649,-30604,-30560,
        -30515,-30471,-30426,-30382,-30337,-30293,-30248,-30204,
        -30159,-30114,-30070,-30025,-29980,-29936,-29891,-29846,
        -29801,-29757,-29712,-29667,-29622,-29577,-29533,-29488,
        -29443,-29398,-29353,-29308,-29263,-29218,-29173,-29128,
        -29083,-29038,-28993,-28948,-28903,-28858,-28812,-28767,
        -28722,-28677,-28632,-28586,-28541,-28496,-28451,-28405,
        -28360,-28315,-28269,-28224,-28179,-28133,-28088,-28042,
        -27997,-27952,-27906,-27861,-27815,-27770,-27724,-27678,
        -27633,-27587,-27542,-27496,-27450,-27405,-27359,-27313,
        -27268,-27222,-27176,-27131,-27085,-27039,-26993,-26947,
        -26902,-26856,-26810,-26764,-26718,-26672,-26626,-26580,
        -26534,-26488,-26442,-26396,-26350,-26304,-26258,-26212,
        -26166,-26120,-26074,-26028,-25982,-25936,-25889,-25843,
        -25797,-25751,-25705,-25658,-25612,-25566,-25520,-25473,
        -25427,-25381,-25334,-25288,-25241,-25195,-25149,-25102,
        -25056,-25009,-24963,-24916,-24870,-24823,-24777,-24730,
        -24684,-24637,-24591,-24544,-24497,-24451,-24404,-24357,
        -24311,-24264,-24217,-24171,-24124,-24077,-24030,-23984,
        -23937,-23890,-23843,-23796,-23750,-23703,-23656,-23609,
        -23562,-23515,-23468,-23421,-23374,-23327,-23280,-23233,
        -23186,-23139,-23092,-23045,-22998,-22951,-22904,-22857,
        -22810,-22763,-22716,-22668,-22621,-22574,-22527,-22480,
        -22432,-22385,-22338,-22291,-22243,-22196,-22149,-22102,
        -22054,-22007,-21960,-21912,-21865,-21817,-21770,-21723,
        -21675,-21628,-21580,-21533,-21485,-21438,-21390,-21343,
        -21295,-21248,-21200,-21153,-21105,-21057,-21010,-20962,
        -20915,-20867,-20819,-20772,-20724,-20676,-20629,-20581,
        -20533,-20485,-20438,-20390,-20342,-20294,-20246,-20199,
        -20151,-20103,-20055,-20007,-19959,-19912,-19864,-19816,
        -19768,-19720,-19672,-19624,-19576,-19528,-19480,-19432,
        -19384,-19336,-19288,-19240,-19192,-19144,-19096,-19048,
        -19000,-18951,-18903,-18855,-18807,-18759,-18711,-18663,
        -18614,-18566,-18518,-18470,-18421,-18373,-18325,-18277,
        -18228,-18180,-18132,-18084,-18035,-17987,-17939,-17890,
        -17842,-17793,-17745,-17697,-17648,-17600,-17551,-17503,
        -17455,-17406,-17358,-17309,-17261,-17212,-17164,-17115,
        -17067,-17018,-16970,-16921,-16872,-16824,-16775,-16727,
        -16678,-16629,-16581,-16532,-16484,-16435,-16386,-16338,
        -16289,-16240,-16191,-16143,-16094,-16045,-15997,-15948,
        -15899,-15850,-15802,-15753,-15704,-15655,-15606,-15557,
        -15509,-15460,-15411,-15362,-15313,-15264,-15215,-15167,
        -15118,-15069,-15020,-14971,-14922,-14873,-14824,-14775,
        -14726,-14677,-14628,-14579,-14530,-14481,-14432,-14383,
        -14334,-14285,-14236,-14187,-14138,-14089,-14040,-13990,
        -13941,-13892,-13843,-13794,-13745,-13696,-13647,-13597,
        -13548,-13499,-13450,-13401,-13351,-13302,-13253,-13204,
        -13154,-13105,-13056,-13007,-12957,-12908,-12859,-12810,
        -12760,-12711,-12662,-12612,-12563,-12514,-12464,-12415,
        -12366,-12316,-12267,-12217,-12168,-12119,-12069,-12020,
        -11970,-11921,-11872,-11822,-11773,-11723,-11674,-11624,
        -11575,-11525,-11476,-11426,-11377,-11327,-11278,-11228,
        -11179,-11129,-11080,-11030,-10981,-10931,-10882,-10832,
        -10782,-10733,-10683,-10634,-10584,-10534,-10485,-10435,
        -10386,-10336,-10286,-10237,-10187,-10137,-10088,-10038,
        -9988,-9939,-9889,-9839,-9790,-9740,-9690,-9640,
        -9591,-9541,-9491,-9442,-9392,-9342,-9292,-9243,
        -9193,-9143,-9093,-9043,-8994,-8944,-8894,-8844,
        -8794,-8745,-8695,-8645,-8595,-8545,-8496,-8446,
        -8396,-8346,-8296,-8246,-8196,-8147,-8097,-8047,
        -7997,-7947,-7897,-7847,-7797,-7747,-7697,-7648,
        -7598,-7548,-7498,-7448,-7398,-7348,-7298,-7248,
        -7198,-7148,-7098,-7048,-6998,-6948,-6898,-6848,
        -6798,-6748,-6698,-6648,-6598,-6548,-6498,-6448,
        -6398,-6348,-6298,-6248,-6198,-6148,-6098,-6048,
        -5998,-5948,-5898,-5848,-5798,-5747,-5697,-5647,
        -5597,-5547,-5497,-5447,-5397,-5347,-5297,-5247,
        -5197,-5146,-5096,-5046,-4996,-4946,-4896,-4846,
        -4796,-4745,-4695,-4645,-4595,-4545,-4495,-4445,
        -4394,-4344,-4294,-4244,-4194,-4144,-4093,-4043,
        -3993,-3943,-3893,-3843,-3792,-3742,-3692,-3642,
        -3592,-3541,-3491,-3441,-3391,-3341,-3291,-3240,
        -3190,-3140,-3090,-3039,-2989,-2939,-2889,-2839,
        -2788,-2738,-2688,-2638,-2588,-2537,-2487,-2437,
        -2387,-2336,-2286,-2236,-2186,-2135,-2085,-2035,
        -1985,-1934,-1884,-1834,-1784,-1733,-1683,-1633,
        -1583,-1532,-1482,-1432,-1382,-1331,-1281,-1231,
        -1181,-1130,-1080,-1030,-980,-929,-879,-829,
        -779,-728,-678,-628,-578,-527,-477,-427,
        -376,-326,-276,-226,-175,-125,-75,-25    
    };
    
    /* MAES: Java can't use that much direct init data in a single class (finesine alone is well beyond that)
     * so a first workaround is to generate the data procedurally.
     * If this proves to cause accuracy problems, an external data file could be used.
     * Another workaround is to define the int table in its own file and then import or "implement" it.
     */
    
 // Re-use data, is just PI/2 phase shift.
  public static final int[] finecosine=new int[FINEANGLES];

  /* MAES: Java can't use that much direct init data in a single class so a first workaround 
   * s to generate the data procedurally.
   * If this proves to cause accuracy problems, an external data file could be used.
   * Another workaround is to define the int table in its own file and then import 
   * or "implement" it.
   */

  static{
  System.arraycopy(finesine, FINEANGLES/4,finecosine, 0, FINEANGLES);
  }

  private SineCosine(){
      
  }
    
}

package data;

public enum mobjtype_t {
	    MT_PLAYER,
	    MT_POSSESSED,
	    MT_SHOTGUY,
	    MT_VILE,
	    MT_FIRE,
	    MT_UNDEAD,
	    MT_TRACER,
	    MT_SMOKE,
	    MT_FATSO,
	    MT_FATSHOT,
	    MT_CHAINGUY,
	    MT_TROOP,
	    MT_SERGEANT,
	    MT_SHADOWS,
	    MT_HEAD,
	    MT_BRUISER,
	    MT_BRUISERSHOT,
	    MT_KNIGHT,
	    MT_SKULL,
	    MT_SPIDER,
	    MT_BABY,
	    MT_CYBORG,
	    MT_PAIN,
	    MT_WOLFSS,
	    MT_KEEN,
	    MT_BOSSBRAIN,
	    MT_BOSSSPIT,
	    MT_BOSSTARGET,
	    MT_SPAWNSHOT,
	    MT_SPAWNFIRE,
	    MT_BARREL,
	    MT_TROOPSHOT,
	    MT_HEADSHOT,
	    MT_ROCKET,
	    MT_PLASMA,
	    MT_BFG,
	    MT_ARACHPLAZ,
	    MT_PUFF,
	    MT_BLOOD,
	    MT_TFOG,
	    MT_IFOG,
	    MT_TELEPORTMAN,
	    MT_EXTRABFG,
	    MT_MISC0,
	    MT_MISC1,
	    MT_MISC2,
	    MT_MISC3,
	    MT_MISC4,
	    MT_MISC5,
	    MT_MISC6,
	    MT_MISC7,
	    MT_MISC8,
	    MT_MISC9,
	    MT_MISC10,
	    MT_MISC11,
	    MT_MISC12,
	    MT_INV,
	    MT_MISC13,
	    MT_INS,
	    MT_MISC14,
	    MT_MISC15,
	    MT_MISC16,
	    MT_MEGA,
	    MT_CLIP,
	    MT_MISC17,
	    MT_MISC18,
	    MT_MISC19,
	    MT_MISC20,
	    MT_MISC21,
	    MT_MISC22,
	    MT_MISC23,
	    MT_MISC24,
	    MT_MISC25,
	    MT_CHAINGUN,
	    MT_MISC26,
	    MT_MISC27,
	    MT_MISC28,
	    MT_SHOTGUN,
	    MT_SUPERSHOTGUN,
	    MT_MISC29,
	    MT_MISC30,
	    MT_MISC31,
	    MT_MISC32,
	    MT_MISC33,
	    MT_MISC34,
	    MT_MISC35,
	    MT_MISC36,
	    MT_MISC37,
	    MT_MISC38,
	    MT_MISC39,
	    MT_MISC40,
	    MT_MISC41,
	    MT_MISC42,
	    MT_MISC43,
	    MT_MISC44,
	    MT_MISC45,
	    MT_MISC46,
	    MT_MISC47,
	    MT_MISC48,
	    MT_MISC49,
	    MT_MISC50,
	    MT_MISC51,
	    MT_MISC52,
	    MT_MISC53,
	    MT_MISC54,
	    MT_MISC55,
	    MT_MISC56,
	    MT_MISC57,
	    MT_MISC58,
	    MT_MISC59,
	    MT_MISC60,
	    MT_MISC61,
	    MT_MISC62,
	    MT_MISC63,
	    MT_MISC64,
	    MT_MISC65,
	    MT_MISC66,
	    MT_MISC67,
	    MT_MISC68,
	    MT_MISC69,
	    MT_MISC70,
	    MT_MISC71,
	    MT_MISC72,
	    MT_MISC73,
	    MT_MISC74,
	    MT_MISC75,
	    MT_MISC76,
	    MT_MISC77,
	    MT_MISC78,
	    MT_MISC79,
	    MT_MISC80,
	    MT_MISC81,
	    MT_MISC82,
	    MT_MISC83,
	    MT_MISC84,
	    MT_MISC85,
	    MT_MISC86,
	    NUMMOBJTYPES
	    };


package data;

import p.ActionType1;
import p.ActionType2;
import p.ActionTypeSS;
import doom.think_t;
import defines.statenum_t;
import static data.Defines.TIC_MUL;

public class state_t {

	public state_t(){
		
	}
       
        public state_t(spritenum_t sprite, int frame, int tics, think_t action,
            statenum_t nextstate, int misc1, int misc2) {
        this.sprite = sprite;
        this.frame = frame;
        this.tics = tics*TIC_MUL;
        this.action = action;
        this.nextstate = nextstate;
        this.misc1 = misc1;
        this.misc2 = misc2;
        }
        
        public spritenum_t   sprite;
        /** The frame should indicate which one of the frames available in the 
         *  available spritenum should be used. This can also be flagged with
         *  0x8000 indicating bright sprites.
         */
 
        public int          frame;
        public int          tics;
        //TODO: proper implementation of (*action)
        // MAES: was actionp_t... which is typedeffed to think_t anyway,
        // and this is the only place it's invoked explicitly.
        /** OK...this is the most infamous part of Doom to implement in Java.
         *  We can't have proper "function pointers" in java without either losing a LOT
         *  of speed (through reflection) or cluttering syntax and heap significantly
         *  (callback objects, which also need to be aware of context).
         *  Therefore, I decided to implement an "action dispatcher".
         *  This a
         *  
         */
        public think_t         action;
        public ActionType1 acp1;
        public ActionType2 acp2;
        public ActionTypeSS acpss;
        
        public statenum_t            nextstate;
        public int misc1, misc2;
        /** relative index in state array. Needed sometimes. */
        public int id;
		
        
        public String toString(){
            sb.setLength(0);
            sb.append(this.getClass().getName());
            sb.append(" sprite ");
            sb.append(this.sprite.name());
            sb.append(" frame ");
            sb.append(this.frame);

            return sb.toString();
            
        }
        
        protected static StringBuilder sb=new StringBuilder();

        /*@Override
        public void read(DoomFile f)
                throws IOException {
            this.sprite = spritenum_t.values()[f.readLEInt()];
            this.frame = f.readLEInt();
            this.tics = f.readLong();
            this.action = think_t.values()[f.readInt()];
            this.nextstate = statenum_t.values()[f.readInt()];
            this.misc1 = f.readInt();
            this.misc2 = f.readInt();
            
        } */
}

package data;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: sounds.java,v 1.1 2010/06/30 08:58:51 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: sounds.java,v $
// Revision 1.1  2010/06/30 08:58:51  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//	Created by a sound utility.
//	Kept as a sample, DOOM2 sounds.
//
//-----------------------------------------------------------------------------

public class sounds{

//
// Information about all the music
//

public static musicinfo_t[] S_music= 
{
    new musicinfo_t(null),
    new musicinfo_t( "e1m1", 0 ),
    new musicinfo_t( "e1m2", 0 ),
    new musicinfo_t( "e1m3", 0 ),
    new musicinfo_t( "e1m4", 0 ),
    new musicinfo_t( "e1m5", 0 ),
    new musicinfo_t( "e1m6", 0 ),
    new musicinfo_t( "e1m7", 0 ),
    new musicinfo_t( "e1m8", 0 ),
    new musicinfo_t( "e1m9", 0 ),
    new musicinfo_t( "e2m1", 0 ),
    new musicinfo_t( "e2m2", 0 ),
    new musicinfo_t( "e2m3", 0 ),
    new musicinfo_t( "e2m4", 0 ),
    new musicinfo_t( "e2m5", 0 ),
    new musicinfo_t( "e2m6", 0 ),
    new musicinfo_t( "e2m7", 0 ),
    new musicinfo_t( "e2m8", 0 ),
    new musicinfo_t( "e2m9", 0 ),
    new musicinfo_t( "e3m1", 0 ),
    new musicinfo_t( "e3m2", 0 ),
    new musicinfo_t( "e3m3", 0 ),
    new musicinfo_t( "e3m4", 0 ),
    new musicinfo_t( "e3m5", 0 ),
    new musicinfo_t( "e3m6", 0 ),
    new musicinfo_t( "e3m7", 0 ),
    new musicinfo_t( "e3m8", 0 ),
    new musicinfo_t( "e3m9", 0 ),
    new musicinfo_t( "inter", 0 ),
    new musicinfo_t( "intro", 0 ),
    new musicinfo_t( "bunny", 0 ),
    new musicinfo_t( "victor", 0 ),
    new musicinfo_t( "introa", 0 ),
    new musicinfo_t( "runnin", 0 ),
    new musicinfo_t( "stalks", 0 ),
    new musicinfo_t( "countd", 0 ),
    new musicinfo_t( "betwee", 0 ),
    new musicinfo_t( "doom", 0 ),
    new musicinfo_t( "the_da", 0 ),
    new musicinfo_t( "shawn", 0 ),
    new musicinfo_t( "ddtblu", 0 ),
    new musicinfo_t( "in_cit", 0 ),
    new musicinfo_t( "dead", 0 ),
    new musicinfo_t( "stlks2", 0 ),
    new musicinfo_t( "theda2", 0 ),
    new musicinfo_t( "doom2", 0 ),
    new musicinfo_t( "ddtbl2", 0 ),
    new musicinfo_t( "runni2", 0 ),
    new musicinfo_t( "dead2", 0 ),
    new musicinfo_t( "stlks3", 0 ),
    new musicinfo_t( "romero", 0 ),
    new musicinfo_t( "shawn2", 0 ),
    new musicinfo_t( "messag", 0 ),
    new musicinfo_t( "count2", 0 ),
    new musicinfo_t( "ddtbl3", 0 ),
    new musicinfo_t( "ampie", 0 ),
    new musicinfo_t( "theda3", 0 ),
    new musicinfo_t( "adrian", 0 ),
    new musicinfo_t( "messg2", 0 ),
    new musicinfo_t( "romer2", 0 ),
    new musicinfo_t( "tense", 0 ),
    new musicinfo_t( "shawn3", 0 ),
    new musicinfo_t( "openin", 0 ),
    new musicinfo_t( "evil", 0 ),
    new musicinfo_t( "ultima", 0 ),
    new musicinfo_t( "read_m", 0 ),
    new musicinfo_t( "dm2ttl", 0 ),
    new musicinfo_t( "dm2int", 0 ) 
};


//
// Information about all the sfx
//

public static sfxinfo_t nullSfxLink;

public static sfxinfo_t[] S_sfx =
{
  // S_sfx[0] needs to be a dummy for odd reasons.
  new sfxinfo_t( "none", false,  0, -1, -1, 0 ),

  new sfxinfo_t( "pistol", false, 64, -1, -1, 0 ),
  new sfxinfo_t( "shotgn", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "sgcock", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "dshtgn", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "dbopn", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "dbcls", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "dbload", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "plasma", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "bfg", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "sawup", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "sawidl", false, 118,  -1, -1, 0 ),
  new sfxinfo_t( "sawful", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "sawhit", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "rlaunc", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "rxplod", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "firsht", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "firxpl", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "pstart", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "pstop", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "doropn", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "dorcls", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "stnmov", false, 119,  -1, -1, 0 ),
  new sfxinfo_t( "swtchn", false, 78,  -1, -1, 0 ),
  new sfxinfo_t( "swtchx", false, 78,  -1, -1, 0 ),
  new sfxinfo_t( "plpain", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "dmpain", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "popain", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "vipain", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "mnpain", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "pepain", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "slop", false, 78,  -1, -1, 0 ),
  new sfxinfo_t( "itemup", true, 78,  -1, -1, 0 ),
  new sfxinfo_t( "wpnup", true, 78,  -1, -1, 0 ),
  new sfxinfo_t( "oof", false, 96,  -1, -1, 0 ),
  new sfxinfo_t( "telept", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "posit1", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "posit2", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "posit3", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "bgsit1", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "bgsit2", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "sgtsit", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "cacsit", true, 98,  -1, -1, 0 ),
  new sfxinfo_t( "brssit", true, 94,  -1, -1, 0 ),
  new sfxinfo_t( "cybsit", true, 92,  -1, -1, 0 ),
  new sfxinfo_t( "spisit", true, 90,  -1, -1, 0 ),
  new sfxinfo_t( "bspsit", true, 90,  -1, -1, 0 ),
  new sfxinfo_t( "kntsit", true, 90,  -1, -1, 0 ),
  new sfxinfo_t( "vilsit", true, 90,  -1, -1, 0 ),
  new sfxinfo_t( "mansit", true, 90,  -1, -1, 0 ),
  new sfxinfo_t( "pesit", true, 90,  -1, -1, 0 ),
  new sfxinfo_t( "sklatk", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "sgtatk", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "skepch", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "vilatk", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "claw", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "skeswg", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "pldeth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "pdiehi", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "podth1", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "podth2", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "podth3", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "bgdth1", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "bgdth2", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "sgtdth", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "cacdth", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "skldth", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "brsdth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "cybdth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "spidth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "bspdth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "vildth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "kntdth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "pedth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "skedth", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "posact", true, 120,  -1, -1, 0 ),
  new sfxinfo_t( "bgact", true, 120,  -1, -1, 0 ),
  new sfxinfo_t( "dmact", true, 120,  -1, -1, 0 ),
  new sfxinfo_t( "bspact", true, 100,  -1, -1, 0 ),
  new sfxinfo_t( "bspwlk", true, 100,  -1, -1, 0 ),
  new sfxinfo_t( "vilact", true, 100,  -1, -1, 0 ),
  new sfxinfo_t( "noway", false, 78,  -1, -1, 0 ),
  new sfxinfo_t( "barexp", false, 60,  -1, -1, 0 ),
  new sfxinfo_t( "punch", false, 64,  -1, -1, 0 ),
  new sfxinfo_t( "hoof", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "metal", false, 70,  -1, -1, 0 ),
  // MAES: here C referenced a field before it was defined. 
  // We'll make do by defining a new "linked" boolean field, and
  // handling special cases in a separate initializer.
  new sfxinfo_t( "chgun", false, 64, true, 150, 0, 0 ),
  new sfxinfo_t( "tink", false, 60,  -1, -1, 0 ),
  new sfxinfo_t( "bdopn", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "bdcls", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "itmbk", false, 100,  -1, -1, 0 ),
  new sfxinfo_t( "flame", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "flamst", false, 32,  -1, -1, 0 ),
  new sfxinfo_t( "getpow", false, 60,  -1, -1, 0 ),
  new sfxinfo_t( "bospit", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "boscub", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "bossit", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "bospn", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "bosdth", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "manatk", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "mandth", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "sssit", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "ssdth", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "keenpn", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "keendt", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "skeact", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "skesit", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "skeatk", false, 70,  -1, -1, 0 ),
  new sfxinfo_t( "radio", false, 60, -1, -1, 0 )
};

/** MAES: This method is here to handle exceptions in definitions of static sfx.
 *  Only the chaingun sound needs to be cross-linked to the pistol sound, but in 
 *  Java you can't do that until the array is actually created. So remember to run
 *  this explicitly, and add any further rules you want!
 *  
 */

public static void init(){
    for (int i=0;i<S_sfx.length;i++){
        if (S_sfx[i].linked){
            // MAES: Rule for chgun
            if (S_sfx[i].name.compareToIgnoreCase("chgun")==0) {
                S_sfx[i].link=S_sfx[sfxenum_t.sfx_pistol.ordinal()];
            }
        }
    }
    
}

public static enum  musicenum_t
{
    mus_None,
    mus_e1m1,
    mus_e1m2,
    mus_e1m3,
    mus_e1m4,
    mus_e1m5,
    mus_e1m6,
    mus_e1m7,
    mus_e1m8,
    mus_e1m9,
    mus_e2m1,
    mus_e2m2,
    mus_e2m3,
    mus_e2m4,
    mus_e2m5,
    mus_e2m6,
    mus_e2m7,
    mus_e2m8,
    mus_e2m9,
    mus_e3m1,
    mus_e3m2,
    mus_e3m3,
    mus_e3m4,
    mus_e3m5,
    mus_e3m6,
    mus_e3m7,
    mus_e3m8,
    mus_e3m9,
    mus_inter,
    mus_intro,
    mus_bunny,
    mus_victor,
    mus_introa,
    mus_runnin,
    mus_stalks,
    mus_countd,
    mus_betwee,
    mus_doom,
    mus_the_da,
    mus_shawn,
    mus_ddtblu,
    mus_in_cit,
    mus_dead,
    mus_stlks2,
    mus_theda2,
    mus_doom2,
    mus_ddtbl2,
    mus_runni2,
    mus_dead2,
    mus_stlks3,
    mus_romero,
    mus_shawn2,
    mus_messag,
    mus_count2,
    mus_ddtbl3,
    mus_ampie,
    mus_theda3,
    mus_adrian,
    mus_messg2,
    mus_romer2,
    mus_tense,
    mus_shawn3,
    mus_openin,
    mus_evil,
    mus_ultima,
    mus_read_m,
    mus_dm2ttl,
    mus_dm2int,
    NUMMUSIC
};

public static enum  sfxenum_t
{
    sfx_None,
    sfx_pistol,
    sfx_shotgn,
    sfx_sgcock,
    sfx_dshtgn,
    sfx_dbopn,
    sfx_dbcls,
    sfx_dbload,
    sfx_plasma,
    sfx_bfg,
    sfx_sawup,
    sfx_sawidl,
    sfx_sawful,
    sfx_sawhit,
    sfx_rlaunc,
    sfx_rxplod,
    sfx_firsht,
    sfx_firxpl,
    sfx_pstart,
    sfx_pstop,
    sfx_doropn,
    sfx_dorcls,
    sfx_stnmov,
    sfx_swtchn,
    sfx_swtchx,
    sfx_plpain,
    sfx_dmpain,
    sfx_popain,
    sfx_vipain,
    sfx_mnpain,
    sfx_pepain,
    sfx_slop,
    sfx_itemup,
    sfx_wpnup,
    sfx_oof,
    sfx_telept,
    sfx_posit1,
    sfx_posit2,
    sfx_posit3,
    sfx_bgsit1,
    sfx_bgsit2,
    sfx_sgtsit,
    sfx_cacsit,
    sfx_brssit,
    sfx_cybsit,
    sfx_spisit,
    sfx_bspsit,
    sfx_kntsit,
    sfx_vilsit,
    sfx_mansit,
    sfx_pesit,
    sfx_sklatk,
    sfx_sgtatk,
    sfx_skepch,
    sfx_vilatk,
    sfx_claw,
    sfx_skeswg,
    sfx_pldeth,
    sfx_pdiehi,
    sfx_podth1,
    sfx_podth2,
    sfx_podth3,
    sfx_bgdth1,
    sfx_bgdth2,
    sfx_sgtdth,
    sfx_cacdth,
    sfx_skldth,
    sfx_brsdth,
    sfx_cybdth,
    sfx_spidth,
    sfx_bspdth,
    sfx_vildth,
    sfx_kntdth,
    sfx_pedth,
    sfx_skedth,
    sfx_posact,
    sfx_bgact,
    sfx_dmact,
    sfx_bspact,
    sfx_bspwlk,
    sfx_vilact,
    sfx_noway,
    sfx_barexp,
    sfx_punch,
    sfx_hoof,
    sfx_metal,
    sfx_chgun,
    sfx_tink,
    sfx_bdopn,
    sfx_bdcls,
    sfx_itmbk,
    sfx_flame,
    sfx_flamst,
    sfx_getpow,
    sfx_bospit,
    sfx_boscub,
    sfx_bossit,
    sfx_bospn,
    sfx_bosdth,
    sfx_manatk,
    sfx_mandth,
    sfx_sssit,
    sfx_ssdth,
    sfx_keenpn,
    sfx_keendt,
    sfx_skeact,
    sfx_skesit,
    sfx_skeatk,
    sfx_radio,
    NUMSFX
};



}


package data;

import static data.Tables.FINEANGLES;
import static data.Tables.SLOPERANGE;
import static data.Tables.tantoangle;
import static m.fixed_t.*;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: Tables.java,v 1.22 2011/05/06 09:21:59 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: Tables.java,v $
// Revision 1.22  2011/05/06 09:21:59  velktron
// Cleaned up and reorganized common renderer code.
//
// Revision 1.21  2011/02/11 00:11:13  velktron
// A MUCH needed update to v1.3.
//
// Revision 1.20  2010/12/20 17:15:08  velktron
// Made the renderer more OO -> TextureManager and other changes as well.
//
// Revision 1.19  2010/12/10 17:38:56  velktron
// pspritescale fixed, weapon actions won't crash (but not work either).
//
// Revision 1.18  2010/11/25 20:12:44  velktron
// Fixed blockmap bug and viewangletox overflow bug.
//
// Revision 1.17  2010/11/22 01:17:16  velktron
// Fixed blockmap (for the most part), some actions implemented and functional, ambient animation/lighting functional.
//
// Revision 1.16  2010/11/17 23:55:06  velktron
// Kind of playable/controllable.
//
// Revision 1.15  2010/11/15 17:15:54  velktron
// Fixed masked columns rendering, introduced unrolled span and column functions from Boom (thanks, Lee Killough :-)
//
// Revision 1.14  2010/11/14 20:00:21  velktron
// Bleeding floor bug fixed!
//
// Revision 1.13  2010/11/12 13:37:25  velktron
// Rationalized the LUT system - now it's 100% procedurally generated.
//
// Revision 1.12  2010/11/03 16:48:04  velktron
// "Bling" view angles fixed (perhaps related to the "bleeding line bug"?)
//
// Revision 1.11  2010/10/14 18:37:14  velktron
// Rendering kinda works. Wow.
//
// Revision 1.10  2010/10/08 16:55:50  velktron
// Duh
//
// Revision 1.9  2010/10/01 16:47:51  velktron
// Fixed tab interception.
//
// Revision 1.8  2010/09/27 15:07:44  velktron
// meh
//
// Revision 1.7  2010/09/27 02:27:29  velktron
// BEASTLY update
//
// Revision 1.6  2010/09/22 16:40:02  velktron
// MASSIVE changes in the status passing model.
// DoomMain and DoomGame unified.
// Doomstat merged into DoomMain (now status and game functions are one).
//
// Most of DoomMain implemented. Possible to attempt a "classic type" start but will stop when reading sprites.
//
// Revision 1.5  2010/09/21 15:53:37  velktron
// Split the Map ...somewhat...
//
// Revision 1.4  2010/09/16 00:16:27  velktron
// Velvet FM 96.8
//
// Revision 1.3  2010/09/15 16:17:38  velktron
// Arithmetic
//
// Revision 1.2  2010/09/09 16:09:09  velktron
// Yer more enhancements to the display system...
//
// Revision 1.1  2010/07/05 16:18:40  velktron
// YOU DON'T WANNA KNOW
//
// Revision 1.1  2010/06/30 08:58:51  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//	Lookup tables.
//	Do not try to look them up :-).
//	In the order of appearance: 
//
//	int finetangent[4096]	- Tangens LUT.
//	 Should work with BAM fairly well (12 of 16bit,
//      effectively, by shifting).
//
//	int finesine[10240]		- Sine lookup.
//	 Guess what, serves as cosine, too.
//	 Remarkable thing is, how to use BAMs with this?
//
//	int tantoangle[2049]	- ArcTan LUT,
//	  maps tan(angle) to angle fast. Gotta search.
//	
//    
//-----------------------------------------------------------------------------

public final class Tables {

    public static final String rcsid="$Id:";

   public static final double PI =             3.141592657;

   /** Normally set to 12, and this sets the value of other constants too.
    *  Howevever changing it will also distort the view, resulting in a 
    *  nightmare-like vision. There are some practical minimum and 
    *  maximums as well.
    *  
    * 
    */
   
  public static final int BITSPRECISION = 12;
  public static final int FINEANGLES  =    2<<BITSPRECISION;
  public static final int FINETANS = FINEANGLES/2; // 4096 for normal precision.
  public static final int QUARTERMARK = 2<<BITSPRECISION-2;
  public static final int FINEMASK =       (FINEANGLES-1);
  /** Mod long angle_t's with this value to cut off rollover */
  public static final long ANGLEMODULE = 0x100000000L;
  
  /** AND with this to remove unwanted sign extensions */
  public static final long BITS32 = 0x00000000FFFFFFFFL;
  
  /** Sign elimination */
  public static final int BITS31 = 0x7FFFFFFF;

  
  // Maes: we have to procedurally generate finesine/finecosine, else we run into a Java static limit.
  // Either that, or I split the files. Guess what I did.
 // public static int PRECISION = 10240 ;

  /** 0x100000000 to 0x2000 */
  public static final int ANGLETOFINESHIFT =   31-BITSPRECISION;
    
/* Binary Angle Measurement.
 * Some maths: their definition means that a range of 2pi is actually
 * mapped to 2^32 values!!! But the lookup tables are only 8K (2^13)
 * long (for sine/cosine), which means that we're 19 bits too precise
 * -> ergo, >>ANGLETOFINESHIFT must be applied.
 * 
 * Also, the original angle_t type was "unsigned int", so we should be
 * using longs here. However, as BAM is used only after shifting, so 
 * using ints doesn't cause a problem for LUT access.
 *  
 * However, some problems may arise with comparisons and ordinary arithmetic: 
 * e.g. ANG270 is supposed to be larger not only than ANG180, but also from 
 * ANG45, which does not hold true if those constants were stored as ints.
 * 
 * As a rule of thumb, whenever you need to store JUST a BAM index, then 
 * ints are ok (actually, you'll have to cast down to int anyway).
 * 
 * Whenever you need to add or compare angles directly however, you need 
 * longs. Furthermore, you must account for possible rollovers by modding
 * with 0x100000000 or else long ints will store angles exceeding 360 degrees!
 * Under no circumstances the value actually stored in the "long angles" should
 * exceed 0xFFFFFFFF.
 * 
 * An example: comparing any two long angles directly is OK, provided they were
 * constructed correctly.
 * 
 * Adding, subtracting, multiplying etc. with two or more angles however requires
 * rollover compensation (e.g. result=(a+b+c) is wrong, result=(a+b+c)%0xFFFFFFFF
 * is correct and will produce an angle you can "trust".
 * 
 * 
 */
  
  /** Doom angle constants. */
  
public static final long ANG45 =  0x20000000L,
                        ANG90  =     0x40000000L,
                        ANG180 =     0x80000000L,
                        ANG270 =     0xc0000000L;

public static final int SLOPERANGE =    (2<<(BITSPRECISION-2)); // Normally 2048.
public static final int SLOPEBITS  =     BITSPRECISION-1;
public static final int DBITS=FRACBITS-SLOPEBITS;

//  typedef unsigned angle_t;


  // Effective size is 2049;
  // The +1 size is to handle the case when x==y
  //  without additional checking.
  //extern angle_t      tantoangle[SLOPERANGE+1];

/**
 * Original size was 10240, but includes 5PI/4 periods. We can get away with
 * ints on this one because of the small range. MAES: WTF? -64 ~ 64K
 * range... so 17-bit accuracy? heh.
 */

public static final int[] finesine=new int[FINEANGLES+QUARTERMARK];
public static final int[] finecosine=new int[FINEANGLES];

/** Any denominator smaller than 512 will result in 
 *  maximum slope (45 degrees, or an index into tantoangle of 2048)
 *  The original method used unsigned args. So if this returns NEGATIVES
 *  in any way, it means you fucked up. Another "consistency" for Doom.
 *  Even though it was called upon fixed_t signed numbers.
 * 
 */
public static final int SlopeDiv ( long	num, long den)
{
    int 	ans;
    
    if (den < 512)
	return SLOPERANGE;

    ans = (int) ((num<<3)/(den>>>8));

    return ans <= SLOPERANGE ? ans : SLOPERANGE;
}

/** Finetangent table. It only has 4096 values corresponding roughly
 * to -90/+90 angles, with values between are -/+ 2607 for "infinity".
 * 
 * Since in vanilla accesses to the table can overflow way beyond 4096
 * indexes, the access index must be clipped to 4K tops via an accessor,
 * or, in order to simulate some aspects of vanilla overflowing, replicate
 * 4K of finesine's values AFTER the 4K index. This removes the need
 * for access checking, at the cost of some extra memory. It also allows
 * a small degree of "vanilla like" compatibility.
 * 
 * 
 */

public final static int[] finetangent=new int[2*FINETANS];


// MAES: original range 2049
// This obviously 
// Range goes from 0x00000000 to 0x20000000, so in theory plain ints should be enough...

/** This maps a value 0-2048 to a BAM unsigned integer angle, ranging from 0x0 to 0x2000000:
 * 
 * In practice, this means there are only tangent values for angles up to 45 degrees. 
 *  
 * These values are valid BAM measurements in the first quadrant
 * 
 * 
 */

public static final int[] tantoangle=new int[SLOPERANGE+1];

/** Use this to get a value from the finesine table. It will be automatically shifte, 
 *  Equivalent to finesine[angle>>>ANGLETOFINESHIFT]
 * 
 * @param angle in BAM units
 * @return
 */
public static final int finesine(int angle){
    return finesine[angle>>>ANGLETOFINESHIFT];
}

/** Use this to get a value from the finesine table using a long argument.
 * It will automatically shift, apply rollover module and cast.
 * 
 * Equivalent to finesine[(int) ((angle>>ANGLETOFINESHIFT)%ANGLEMODULE)];
 * 
 * @param angle in BAM units
 * @return
 */
public static final int finesine(long angle){
    return finesine[(int) ((angle&BITS32)>>>ANGLETOFINESHIFT)];
}

/** Use this to get a value from the finecosine table. It will be automatically shifted, 
 * Equivalent to finecosine[angle>>>ANGLETOFINESHIFT]
 * @param angle in BAM units
 * @return
 */
public static final int finecosine(int angle){
    return finecosine[angle>>>ANGLETOFINESHIFT];
}

/** Use this to get a value from the finecosine table. 
 * It will automatically shift, apply rollover module and cast.
 *  
 * Equivalent to finecosine[(int) ((angle&BITS32)>>>ANGLETOFINESHIFT)]
 * @param angle in BAM units
 * @return
 */
public static final int finecosine(long angle){
    return finecosine[(int) ((angle&BITS32)>>>ANGLETOFINESHIFT)];
}

/** Compare BAM angles in 32-bit format 
 *  "Greater or Equal" bam0>bam1
 * */

public static final boolean GE(int bam0, int bam1){
    // Handle easy case.
    if (bam0==bam1) return true;
    
    // bam0 is greater than 180 degrees.
    if (bam0<0 && bam1>=0) return true;
    // bam1 is greater than 180 degrees.
    if (bam0>=0 && bam1<0) return false;
    
    // Both "greater than 180", No other way to compare.
    bam0&=BITS31;
    bam1&=BITS31;        
    return bam0>bam1;
}

public static final boolean GT(int bam0, int bam1){       
    // bam0 is greater than 180 degrees.
    if (bam0<0 && bam1>=0) return true;
    // bam1 is greater than 180 degrees.
    if (bam0>=0 && bam1<0) return false;
    
    // Both "greater than 180", No other way to compare.
    bam0&=BITS31;
    bam1&=BITS31;        
    return bam0>bam1;
}

public static final int BAMDiv(int bam0, int bam1){       
    // bam0 is greater than 180 degrees.
    if (bam0>=0) return bam0/bam1;
    // bam0 is greater than 180 degrees.
    // We have to make is so that ANG270 0xC0000000 becomes ANG135, aka 60000000
    if (bam1>=0)
    return (int) ((long)(0x0FFFFFFFFL&bam0)/bam1);
    
    return (int) ((long)(0x0FFFFFFFFL&bam0)/(0x0FFFFFFFFL&bam1));
}

/** Converts a long angle to a BAM LUT-ready angle (13 bits, between 0-8191). 
 *  Cuts away rollover. 
 *  
 * @param angle
 * @return
 */

public static final int toBAMIndex(long angle){
    return (int) ((angle&BITS32)>>>ANGLETOFINESHIFT);
}

/** Converts a long angle to a TAN BAM  LUT-ready angle (12 bits, between 0-4195). 
 *  Cuts away rollover. 
 *  
 * @param angle
 * @return
 */

public static final int toFineTanIndex(long angle){
    return (int) ((angle&BITS31)>>>ANGLETOFINESHIFT);
}

/** Converts an 32-bit int angle to a BAM LUT-ready angle (13 bits, between 0-8192). 
 * 
 * @param angle
 * @return
 */

public static final int toBAMIndex(int angle){
    return angle>>>ANGLETOFINESHIFT;
}

/** Add two long angles and correct for overflow */

public static final long addAngles(long a, long b) {
    return ((a+b)&BITS32);
}

/** MAES: I brought this function "back from the dead" since
 *  Java has some pretty low static limits for statically defined LUTs.
 *  In order to keep the codebase clutter and static allocation to a minimum,
 *  I decided to procedurally generate the tables during runtime, 
 *  using the original functions.
 *    
 *  The code has been thoroughly checked in both Sun's JDK and GCC and was
 *  found to, indeed, produce the same values found in the finesine/finecosine
 *  and finetangent tables, at least on Intel.
 *  
 *  The "tantoangle" table is also generated procedurally, but since there 
 *  was no "dead code" to build upon, it was recreated through reverse
 *  engineering and also found to be 100% faithful to the original data.  
 * 
 * 
 */

public static void InitTables(){
    int     i;
    float   a;
    float   fv;
    int     t;
    
    // viewangle tangent table
    for (i=0 ; i<FINEANGLES/2 ; i++)
    {
    a = (float)((i-FINEANGLES/4+0.5)*PI*2)/FINEANGLES;
    fv = (float)(FRACUNIT*Math.tan (a));
    t = (int)fv;
    finetangent[i] = t;
    } 
    
    // finesine table
    for (i=0 ; i<FINEANGLES+QUARTERMARK ; i++)
    {
    // OPTIMIZE: mirror...
    a = (float)((i+0.5)*PI*2)/FINEANGLES;
    t = (int)(FRACUNIT*Math.sin (a));
    finesine[i] = t;
    if (i>=QUARTERMARK){
        finecosine[i-QUARTERMARK] = t;
        }
    }
    
    // HACK: replicate part of finesine after finetangent, to
    // simulate overflow behavior and remove need for capping
    // indexes
    // viewangle tangent table
    for (i=FINEANGLES/2 ; i<FINEANGLES ; i++)
    {
    finetangent[i] = finesine[i-FINEANGLES/2];
    } 
    
    /* tantoangle table
     * There was actually no dead code for that one, so this is a close recreation.
     * Since there are 2049 values, and the maximum angle considered is 536870912 (0x20000000)
     * which is 45 degrees in BAM, we have to fill in the atan for values up to 45 degrees.
     * Since the argument is a slope ranging from 0...2048, we have 2049 equally spaced (?)
     *  values, with 2048 being being the unitary slope (0x10000 in fixed_t). That value is only
     *  accessed in special cases (overflow) so we only need to consider 0..2047 aka 11 bits.
     *  So: we take "minislopes" 0-2048, we blow them up to a full fixed_t unit with <<5.
     *  We make this into a float (?), then use trigonometric ATAN, and then go to BAM.
     *  
     *  Any questions?
     *  
     */    
    
    /* This is the recreated code 
    for (i=0 ; i<SLOPERANGE+1 ; i++)
    {
    
    a=(float)((i<<DBITS)/65536.0);
    t=(int)((float)(2*Math.atan(a)/PI)*0x40000000); 
    tantoangle[i] = t;
    } 
    */
    
    // This is the original R_InitPointToAngle code that created this table.
    for (i=0 ; i<=SLOPERANGE ; i++)
    {
 a = (float) (Math.atan( (double)i/SLOPERANGE )/(3.141592657*2));
 t = (int) (0xffffffffL*a);
 tantoangle[i] = (int) t;
    }
    
    }

private Tables(){
    
}

}


package data;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;
import w.IPackableDoomObject;
import w.IWritableDoomObject;

/**
 * A SideDef, defining the visual appearance of a wall, by setting textures and
 * offsets. ON-DISK.
 */

public class mapsidedef_t implements CacheableDoomObject,IWritableDoomObject,IPackableDoomObject{

    public mapsidedef_t() {

    }

    public short textureoffset;

    public short rowoffset;

    // 8-char strings.
    public String toptexture;

    public String bottomtexture;

    public String midtexture;

    /** Front sector, towards viewer. */
    public short sector;

    public static int sizeOf() {
        return 30;
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.textureoffset = buf.getShort();
        this.rowoffset = buf.getShort();
        this.toptexture=DoomBuffer.getNullTerminatedString(buf,8).toUpperCase();
        this.bottomtexture=DoomBuffer.getNullTerminatedString(buf,8).toUpperCase();
        this.midtexture=DoomBuffer.getNullTerminatedString(buf,8).toUpperCase();
        this.sector = buf.getShort();
        
    }

	@Override
	public void pack(ByteBuffer buf) throws IOException {
	    buf.order(ByteOrder.LITTLE_ENDIAN);
	    buf.putShort(textureoffset);
	    buf.putShort(rowoffset);
	    DoomBuffer.putNullTerminatedString(buf,toptexture,8);
	    DoomBuffer.putNullTerminatedString(buf,bottomtexture,8);
	    DoomBuffer.putNullTerminatedString(buf,midtexture,8);
	    buf.putShort(sector);		
	}

	@Override
	public void write(DataOutputStream dos) throws IOException {
        // More efficient, avoids duplicating code and
        // handles little endian better.
        iobuffer.position(0);
        iobuffer.order(ByteOrder.LITTLE_ENDIAN);
        this.pack(iobuffer);
        dos.write(iobuffer.array());				
	}
	
	private static ByteBuffer iobuffer=ByteBuffer.allocate(mapsidedef_t.sizeOf());
}

package i;

import doom.ticcmd_t;

public interface IDoomSystem {

	public void AllocLow(int length);

	public void BeginRead();

	public void EndRead();

	public void WaitVBL(int count);

	public byte[] ZoneBase(int size);

	public int GetHeapSize();

	public void Tactile(int on, int off, int total);

	public void Quit();

	public ticcmd_t BaseTiccmd();

	public void Error(String error, Object ... args);

	void Error(String error);
	
	void Init();
	
	/** Generate a blocking alert with the intention of continuing or aborting
	 * a certain game-altering action. E.g. loading PWADs, or upon critical 
	 * level loading failures. This can be either a popup panel or console 
	 * message.
	 *  
	 * @param cause Provide a clear string explaining why the alert was generated
	 * @return true if we should continue, false if an alternate action should be taken.
	 */
	boolean GenerateAlert(String title,String cause);


}

package i;

import doom.DoomStatus;
import rr.patch_t;
import v.DoomVideoRenderer;
import v.IVideoScale;
import w.IWadLoader;

public class DiskDrawer implements IDiskDrawer,DoomStatusAware {

	private patch_t disk;
	private IWadLoader W;
	private DoomVideoRenderer<?,?> V;
	private IVideoScale VS;
	private int timer=0;
	private String diskname;
	
	public static final String STDISK="STDISK";
	public static final String STCDROM="STCDROM";
	
	public DiskDrawer(DoomStatus<?,?> DM,String icon){		
		this.updateStatus(DM);
		this.diskname=icon;
	}

	@Override
	public void Init(){
		this.disk=W.CachePatchName(diskname);
	}
	
	@Override
	public void Drawer() {
		if (timer>0){
			if (timer%2==0)
		V.DrawScaledPatch(304,184,DoomVideoRenderer.SCREEN_FG,VS, disk);
		}
		if (timer>=0)
			timer--;
	}

	@Override
	public void updateStatus(DoomStatus<?,?> DC) {
		this.W=DC.W;
		this.V=DC.V;		
	    }

	@Override
	public void setVideoScale(IVideoScale vs) {
		this.VS = vs;
	}

	@Override
	public void initScaling() {

	}

	@Override
	public void setReading(int reading) {
		timer=reading;
	}

	@Override
	public boolean isReading() {
		return timer>0;
	}

	@Override
	public boolean justDoneReading() {
		return timer==0;
	}
	
}

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: system.java,v 1.5 2011/02/11 00:11:13 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: system.java,v $
// Revision 1.5  2011/02/11 00:11:13  velktron
// A MUCH needed update to v1.3.
//
// Revision 1.1  2010/06/30 08:58:50  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//
//-----------------------------------------------------------------------------

package i;

public class system{
    
/*
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <stdarg.h>
#include <sys/time.h>
#include <unistd.h>

#include "doomdef.h"
#include "m_misc.h"
#include "i_video.h"
#include "i_sound.h"

#include "d_net.h"
#include "g_game.h"

#ifdef __GNUG__
#pragma implementation "i_system.h"
#endif
#include "i_system.h"

*/


static int	mb_used = 6;


public void
Tactile
( int	on,
  int	off,
  int	total )
{
  // UNUSED.
  on = off = total = 0;
}

/*
ticcmd_t	emptycmd;
ticcmd_t*	I_BaseTiccmd(void)
{
    return &emptycmd;
}

*/

public static int  GetHeapSize ()
{
    return mb_used*1024*1024;
}

/*
byte* I_ZoneBase (int*	size)
{
    *size = mb_used*1024*1024;
    return (byte *) malloc (*size);
}
*/


//
// I_GetTime
// returns time in 1/70th second tics
//
/*
int  I_GetTime ()
{
    struct timeval	tp;
    struct timezone	tzp;
    int			newtics;
    static int		basetime=0;
  
    gettimeofday(&tp, &tzp);
    if (!basetime)
	basetime = tp.tv_sec;
    newtics = (tp.tv_sec-basetime)*TICRATE + tp.tv_usec*TICRATE/1000000;
    return newtics;
}
*/


//
// I_Init
//
/*
void I_Init (void)
{
    I_InitSound();
    //  I_InitGraphics();
}

//
// I_Quit
//
void I_Quit (void)
{
    D_QuitNetGame ();
    I_ShutdownSound();
    I_ShutdownMusic();
    M_SaveDefaults ();
    I_ShutdownGraphics();
    exit(0);
}

void I_WaitVBL(int count)
{
#ifdef SGI
    sginap(1);                                           
#else
#ifdef SUN
    sleep(0);
#else
    usleep (count * (1000000/70) );                                
#endif
#endif
}

void I_BeginRead(void)
{
}

void I_EndRead(void)
{
}

byte*	I_AllocLow(int length)
{
    byte*	mem;
        
    mem = (byte *)malloc (length);
    memset (mem,0,length);
    return mem;
}

*/

//
// I_Error
//
public static boolean demorecording;

public static void Error (String error, Object ... args)
{
    //va_list	argptr;

    // Message first.
    //va_start (argptr,error);
    System.err.print("Error: ");
    System.err.printf(error,args);
    System.err.print("\n");
    //va_end (argptr);

    //fflush( stderr );

    // Shutdown. Here might be other errors.
    //if (demorecording)
	//G_CheckDemoStatus();

    //D_QuitNetGame ();
    //I_ShutdownGraphics();
    
    System.exit(-1);
}
}

package i;

/** Interface for Doom-to-System event handling methods
 * 
 * @author Velktron
 *
 */


public interface DoomEventInterface {

	/** The implementation is windowing subsystem-specific 
	 *  e.g. DOS, XServer, AWT or Swing or whatever.
	 * 
	 */
	public void GetEvent();


}

package i;

import v.IVideoScaleAware;

public interface IDiskDrawer extends IDrawer,IVideoScaleAware{
	
	/** Set a timeout (in tics) for displaying the disk icon 
	 * 
	 * @param timeout
	 */
	
	void setReading(int reading);
	
	/** Disk displayer is currently active
	 * 
	 * @return
	 */
	boolean isReading();
	
	/** Only call after the Wadloader is instantiated and
	 *  initialized itself.
	 * 
	 */
	void Init();
	
	/**Status only valid after the last tic has been drawn.
	 * Use to know when to redraw status bar.
	 * 
	 * @return
	 */
	boolean justDoneReading();
    	
}

package i;

public final class Strings {
	public static final String MOCHA_DOOM_TITLE="Mocha Doom Alpha 1.6";	
	
	public static final String MODIFIED_GAME=
		("===========================================================================\n"+
		 "ATTENTION:  This version of DOOM has been modified.  If you would like to\n"+
         "get a copy of the original game, call 1-800-IDGAMES or see the readme file.\n"+
         "        You will not receive technical support for modified games.\n"+
         "                      press enter to continue\n"+
         "===========================================================================\n");
	
	public static final String MODIFIED_GAME_TITLE="Modified game alert";
	
	public static final String MODIFIED_GAME_DIALOG=
		
		("<html><center>"+
		"===========================================================================<br>"+
		 "ATTENTION:  This version of DOOM has been modified.  If you would like to<br>"+
         "get a copy of the original game, call 1-800-IDGAMES or see the readme file.<br>"+
         "        You will not receive technical support for modified games.<br>"+
         "                      press OK to continue<br>"+
         "===========================================================================<br>"+
         "</center></html>");
	
	public static final String LEVEL_FAILURE_TITLE="Level loading failure";
	
	public static final String LEVEL_FAILURE_CAUSE=
		
		("<html><center>"+
		"Level loading failed!<br>"+
		 "Press OK to end this game without exiting, or cancel to quit Doom."+
         "</center></html>");
	
}

package i;

import doom.ticcmd_t;

public class DummySystem implements IDoomSystem{

    @Override
    public void AllocLow(int length) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void BeginRead() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void EndRead() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void WaitVBL(int count) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public byte[] ZoneBase(int size) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public int GetHeapSize() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void Tactile(int on, int off, int total) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void Quit() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public ticcmd_t BaseTiccmd() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void Error(String error, Object... args) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void Error(String error) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void Init() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public boolean GenerateAlert(String title, String cause) {
        // TODO Auto-generated method stub
        return false;
    }

}

package i;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: DoomSoundInterface.java,v 1.3 2011/02/11 00:11:13 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// DESCRIPTION:
//	System interface, sound.
//
//-----------------------------------------------------------------------------



import data.sfxinfo_t;


/*
// UNIX hack, to be removed.
#ifdef SNDSERV
#include <stdio.h>
extern FILE* sndserver;
extern char* sndserver_filename;
#endif*/


public interface DoomSoundInterface{


// Init at program start...
public void I_InitSound();

// ... update sound buffer and audio device at runtime...
public void I_UpdateSound();
public void I_SubmitSound();

// ... shut down and relase at program termination.
public void I_ShutdownSound();


//
//  SFX I/O
//

// Initialize channels?
void I_SetChannels();

// Get raw data lump index for sound descriptor.
public int I_GetSfxLumpNum (sfxinfo_t sfxinfo );


// Starts a sound in a particular sound channel.
public int
I_StartSound
( int		id,
  int		vol,
  int		sep,
  int		pitch,
  int		priority );


// Stops a sound channel.
public void I_StopSound(int handle);

// Called by S_*() functions
//  to see if a channel is still playing.
// Returns 0 if no longer playing, 1 if playing.
public boolean I_SoundIsPlaying(int handle);

// Updates the volume, separation,
//  and pitch of a sound channel.
public void
I_UpdateSoundParams
( int		handle,
  int		vol,
  int		sep,
  int		pitch );


//
//  MUSIC I/O
//
public void I_InitMusic();
public void I_ShutdownMusic();
// Volume.
public void I_SetMusicVolume(int volume);
// PAUSE game handling.
public void I_PauseSong(int handle);
public void I_ResumeSong(int handle);
// Registers a song handle to song data.
public int I_RegisterSong(byte[] data);
// Called by anything that wishes to start music.
//  plays a song, and when the song is done,
//  starts playing it again in an endless loop.
// Horrible thing to do, considering.
public void
I_PlaySong
( int		handle,
  int		looping );
// Stops a song over 3 seconds.
public void I_StopSong(int handle);
// See above (register), then think backwards
public void I_UnRegisterSong(int handle);
}
package i;

public enum BppMode {
    HiColor,
    Indexed,
    TrueColor,
    TrueColor32
}

package i;

public interface IDrawer {

	public void Drawer();
	
}

package i;

import doom.DoomStatus;

public interface DoomStatusAware {
	  public void updateStatus(DoomStatus<?,?> DC);
}

package i;

/** Methods specific to Doom-System video interfacing. 
 *  In essence, whatever you are using as a final system-specific way to display
 *  the screens, should be able to respond to these commands. In particular,
 *  screen update requests must be honored, and palette/gamma request changes
 *  must be intercepted before they are forwarded to the renderers (in case they
 *  are system-specific, rather than renderer-specific).
 *  
 *  The idea is that the final screen rendering module sees/handles as less as
 *  possible, and only gets a screen to render, no matter what depth it is.
 * 
 *  
 */

public interface DoomVideoInterface<K> {

	public void StartFrame();

	public void StartTic();

	public void SetPalette(int palette);

	public void InitGraphics();

	public void FinishUpdate();

	public void UpdateNoBlit();

	public void ShutdownGraphics();

	public void SetGamma(int gammalevel);
	
	public void ReadScreen(K linear);

}

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: DoomSystem.java,v 1.18 2013/06/04 11:29:39 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: DoomSystem.java,v $
// Revision 1.18  2013/06/04 11:29:39  velktron
// Shut up logger
//
// Revision 1.17  2013/06/03 10:54:11  velktron
// System interface allows for a logging subsystem, but implementation details may very well vary.
//
// Revision 1.16.2.1  2012/11/19 22:14:35  velktron
// Sync tooling shutdown.
//
// Revision 1.16  2012/11/06 16:05:29  velktron
// Variables manager now part of Main.
//
// Revision 1.15  2012/09/24 17:16:22  velktron
// Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
// Revision 1.14.2.2  2012/09/17 15:57:53  velktron
// Aware of IVariablesManager
//
// Revision 1.14.2.1  2012/06/14 22:38:06  velktron
// Update to handle new disk flasher
//
// Revision 1.14  2011/10/24 02:11:27  velktron
// Stream compliancy
//
// Revision 1.13  2011/09/29 15:16:04  velktron
// Modal popup generation moved here.
//
// Revision 1.12  2011/06/12 21:54:31  velktron
// Separate music + sound closing.
//
// Revision 1.11  2011/06/05 22:52:28  velktron
// Proper audio subsystem shutdown.
//
// Revision 1.10  2011/05/29 22:15:32  velktron
// Introduced IRandom interface.
//
// Revision 1.9  2011/05/26 17:56:32  velktron
// Removed ticker functionality, moved to ITicker interface.
//
// Revision 1.8  2011/05/18 16:53:29  velktron
// Implements IDoomSystem now.
//
// Revision 1.7  2011/05/17 16:54:09  velktron
// Switched to DoomStatus
//
// Revision 1.6  2011/05/13 17:44:24  velktron
// Global error function, shutdown on demos.
//
// Revision 1.5  2011/02/11 00:11:13  velktron
// A MUCH needed update to v1.3.
//
// Revision 1.4  2010/12/15 16:12:19  velktron
// Changes in Wiper code and alternate timing method, hoping to fix the Athlon X2
//
// Revision 1.3  2010/09/24 17:58:39  velktron
// Menus and HU  functional -mostly.
//
// Revision 1.2  2010/09/23 20:36:45  velktron
// *** empty log message ***
//
// Revision 1.1  2010/09/23 15:11:57  velktron
// A bit closer...
//
// Revision 1.3  2010/09/07 16:23:00  velktron
// *** empty log message ***
//
// Revision 1.2  2010/08/30 15:53:19  velktron
// Screen wipes work...Finale coded but untested.
// GRID.WAD included for testing.
//
// Revision 1.1  2010/06/30 08:58:50  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//
//-----------------------------------------------------------------------------

package i;

import java.io.IOException;

import sun.misc.VM;

import awt.MsgBox;
import m.MenuMisc;
import doom.DoomMain;
import doom.DoomStatus;
import doom.ticcmd_t;
import static data.Defines.TICRATE;

public class DoomSystem implements IDoomSystem, DoomStatusAware{
 


static int	mb_used = 6;

// Even the SYSTEM needs to know about DOOM!!!!
protected DoomMain<?,?> DM;

@Override
public void
Tactile
( int	on,
  int	off,
  int	total )
{
  // UNUSED.
  on = off = total = 0;
}


public ticcmd_t	emptycmd;

@Override
public ticcmd_t	BaseTiccmd()
{
    return emptycmd;
}


@Override
public int  GetHeapSize ()
{
    return mb_used*1024*1024;
}

@Override
public byte[] ZoneBase (int	size)
{
    return (new byte[mb_used*1024*1024]);
}

//
//I_Quit
//
@Override
public void Quit ()
{

 //DM.CheckDemoStatus();
 try {
	DM.QuitNetGame ();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}
 //DM.debugEnd();
 DM.ISND.ShutdownSound();
 DM.IMUS.ShutdownMusic();
 DM.commit();
 DM.VM.SaveDefaults(DM.VM.getDefaultFile());
 DM.VI.ShutdownGraphics();
 System.exit(0);
}


/**
 * I_Init
 */
@Override
public void Init ()
{
    //TODO: InitSound();
    //TODO: InitGraphics();
}


@Override
public void WaitVBL(int count)
{
    try {
        Thread.sleep(count*1000/70);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }                                
}
@Override
public void BeginRead()
{
	if (DM.DD!=null)
	   if (!DM.DD.isReading()) {
		   // Set 8 tick reading time
		   DM.DD.setReading(8);
	   }
	   	
}

@Override
public void EndRead()
{
}

@Override
public void	AllocLow(int length)
{
 ; // Dummy
}

//
// I_Error
//
@Override
public void Error (String error, Object ... args)
{

    System.err.print("Error: ");
    System.err.printf(error,args);
    System.err.print("\n");
    //va_end (argptr);

    //fflush( stderr );

    // Shutdown. Here might be other errors.
    if (DM.demorecording)
	DM.DG.CheckDemoStatus();
    if (DM.VI!=null)
    	DM.VI.ShutdownGraphics();    
    
    try {
		DM.QuitNetGame ();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
   // DM.VI.ShutdownGraphics();
    
    System.exit(-1);
}

@Override
public void Error (String error)
{
    //va_list	argptr;

    // Message first.
    //va_start (argptr,error);
    System.err.print("Error: ");
    System.err.printf(error);
    System.err.print("\n");
    //va_end (argptr);

    //fflush( stderr );

    // Shutdown. Here might be other errors.
    //if (demorecording)
	//G_CheckDemoStatus();

    //D_QuitNetGame ();
    //I_ShutdownGraphics();
    
    System.exit(-1);
}

public DoomSystem(){
emptycmd=new ticcmd_t();
}

public static void MiscError(String error, Object ... args) {
    System.err.print("Error: ");
    System.err.printf(error);
    System.err.print("\n");    
}


@Override
public void updateStatus(DoomStatus DS) {
    this.DM=DS.DM;
    
}


// This particular implementation will generate a popup box.// 
@Override
public boolean GenerateAlert(String title,String cause) {
    MsgBox alert=new MsgBox(null, title, cause, true);
      return alert.isOk();
}

}

package i;

import java.io.IOException;

import m.IVariablesManager;
import m.VarsManager;

import rr.LightsAndColors;

import v.VideoScaleInfo;
import doom.CommandLine;
import doom.DoomMain;
import doom.ICommandLineManager;

//Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
//$Id: Main.java,v 1.14 2016/06/06 14:22:17 velktron Exp $
//
//Copyright (C) 1993-1996 by id Software, Inc.
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//
//DESCRIPTION:
//Main program, simply calls D_DoomMain high level loop after loading 
//some essential settings and determining what "flavor" we're going to run.
//
//-----------------------------------------------------------------------------



public class Main {
    static final String rcsid = "$Id: Main.java,v 1.14 2016/06/06 14:22:17 velktron Exp $";

    /** Global setting for initializing the renderer's bitplane mode */
    public static BppMode bpp;
    /** Global setting for initializing the renderer's light levels */
    public static int lightlevels;
    
    public static void main(String[] argv) throws IOException{

    	  //First, get the command line parameters.
          ICommandLineManager CLM=new CommandLine(argv);
            
          // Handles variables and settings from default.cfg
          IVariablesManager VM=new VarsManager(CLM);
          
          // load before initting other systems, but don't apply them yet.          
          System.out.print ("M_LoadDefaults: Load system defaults.\n");
          VM.LoadDefaults (VM.getDefaultFile());
        
          bpp= BppMode.Indexed;
          lightlevels=5;
          
          //if (VM.getSetting(name), value))
          
            
          if (VM.isSettingLiteral("color_depth","hicolor"))
              bpp=BppMode.HiColor;
          if (VM.isSettingLiteral("color_depth","truecolor"))
              bpp=BppMode.TrueColor;
          
          if (CLM.CheckParmBool("-hicolor")) bpp=BppMode.HiColor;
              else
          if (CLM.CheckParmBool("-truecolor")) bpp=BppMode.TrueColor;
          
          
          
          // Here we create DOOM
          DoomMain<?, ?> DM=null;
          // Create a dummy. This will force static init to run.
          
          switch(bpp){
          case Indexed:
              System.out.println("Indexed 8-bit mode selected...");
              DM=new DoomMain.Indexed();
              break;
          case HiColor:
              System.out.println("HiColor (Alpha) 16-bit mode selected...");
              DM=new DoomMain.HiColor();
              break;
          case TrueColor:
          case TrueColor32:
              System.out.println("TrueColor (extended colormaps) 24-bit mode selected...");
              DM=new DoomMain.TrueColor();
              break;

          }    

          DM.setCommandLineArgs(CLM);
          DM.registerVariableManager(VM);
          DM.Init();
          DM.Start();

          return;
        } 
    }

package i;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: SystemSoundInterface.java,v 1.2 2011/05/17 16:51:20 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// DESCRIPTION:
//	System interface, sound.
//
//-----------------------------------------------------------------------------



import data.sfxinfo_t;


/*
// UNIX hack, to be removed.
#ifdef SNDSERV
#include <stdio.h>
extern FILE* sndserver;
extern char* sndserver_filename;
#endif*/


public interface SystemSoundInterface{


// Init at program start...
public void InitSound();

// ... update sound buffer and audio device at runtime...
public void UpdateSound();
public void SubmitSound();

// ... shut down and relase at program termination.
public void ShutdownSound();


//
//  SFX I/O
//

// Initialize channels?
void SetChannels();

// Get raw data lump index for sound descriptor.
public int GetSfxLumpNum (sfxinfo_t sfxinfo );


// Starts a sound in a particular sound channel.
public int
StartSound
( int		id,
  int		vol,
  int		sep,
  int		pitch,
  int		priority );


// Stops a sound channel.
public void StopSound(int handle);

// Called by S_*() functions
//  to see if a channel is still playing.
// Returns 0 if no longer playing, 1 if playing.
public boolean SoundIsPlaying(int handle);

// Updates the volume, separation,
//  and pitch of a sound channel.
public void
UpdateSoundParams
( int		handle,
  int		vol,
  int		sep,
  int		pitch );


//
//  MUSIC I/O
//
public void InitMusic();
public void ShutdownMusic();
// Volume.
public void SetMusicVolume(int volume);
// PAUSE game handling.
public void PauseSong(int handle);
public void ResumeSong(int handle);
// Registers a song handle to song data.
public int RegisterSong(byte[] data);
// Called by anything that wishes to start music.
//  plays a song, and when the song is done,
//  starts playing it again in an endless loop.
// Horrible thing to do, considering.
public void
PlaySong
( int		handle,
  int		looping );
// Stops a song over 3 seconds.
public void StopSong(int handle);
// See above (register), then think backwards
public void UnRegisterSong(int handle);
}

/** Blatantly ripped off Jake 2. Sieg heil! */

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
package i;

import java.awt.event.*;
import java.util.LinkedList;

import doom.event_t;
import doom.evtype_t;

/**
 * InputListener
 */
public final class InputListener implements KeyListener, MouseListener, 
        MouseMotionListener, ComponentListener, MouseWheelListener {

    // modifications of eventQueue must be thread safe!
    private static LinkedList<event_t> eventQueue = new LinkedList<event_t>();

    static void addEvent(event_t ev) {
        synchronized (eventQueue) {
            eventQueue.addLast(ev);
        }
    }

    public static event_t nextEvent() {
        event_t ev;
        synchronized (eventQueue) {
            ev = (!eventQueue.isEmpty())?(event_t)eventQueue.removeFirst():null;
        }
        return ev;
    }

    public void keyPressed(KeyEvent e) {
        if (!((e.getModifiersEx() & InputEvent.ALT_GRAPH_DOWN_MASK) != 0)) {
            addEvent(new event_t(evtype_t.ev_keydown, e.getKeyCode()));
        }
    }

    public void keyReleased(KeyEvent e) {
        addEvent(new event_t(evtype_t.ev_keyup, e.getKeyCode()));
    }

    public void keyTyped(KeyEvent e) {
        if ((e.getModifiersEx() & InputEvent.ALT_GRAPH_DOWN_MASK) != 0) {
            addEvent(new event_t(evtype_t.ev_keydown, e.getKeyCode()));
            addEvent(new event_t(evtype_t.ev_keyup, e.getKeyCode()));
        }       
    }

    public void mouseClicked(MouseEvent e) {
    }

    public void mouseEntered(MouseEvent e) {
    }

    public void mouseExited(MouseEvent e) {
    }

    public void mousePressed(MouseEvent e) {
        addEvent(new event_t(evtype_t.ev_mouse, e.getButton()));
    }

    public void mouseReleased(MouseEvent e) {
        addEvent(new event_t(evtype_t.ev_mouse, e.getButton()));
    }

    public void mouseDragged(MouseEvent e) {
        addEvent(new event_t(evtype_t.ev_mouse, e.getButton(),e.getX(),e.getY()));
    }

    public void mouseMoved(MouseEvent e) {
        addEvent(new event_t(evtype_t.ev_mouse, e.getButton(),e.getX(),e.getY()));
    }
    
    public void mouseWheelMoved(MouseWheelEvent e) {
        addEvent(new event_t(evtype_t.ev_mousewheel, e.getWheelRotation()));
    }   

   // Don't listen?
    public void componentHidden(ComponentEvent e) {
    }

    public void componentMoved(ComponentEvent e) {
       // addEvent(new event_t(event_t.ConfigureNotify, e));
    }

    public void componentResized(ComponentEvent e) {
      //  addEvent(new event_t(event_t.ConfigureNotify, e));
    }

    public void componentShown(ComponentEvent e) {
    //    JOGLKBD.c = e.getComponent();
    //    addEvent(new event_t(event_t.CreateNotify, e));
    }

}


package rr;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import p.Resettable;

import static m.fixed_t.FRACBITS;
import w.DoomIO;
import w.IPackableDoomObject;
import w.IReadableDoomObject;

/**
 * The SideDef.
 * 
 * @author admin
 */
public class side_t
        implements IReadableDoomObject, IPackableDoomObject, Resettable {
    /** (fixed_t) add this to the calculated texture column */
    public int textureoffset;

    /** (fixed_t) add this to the calculated texture top */
    public int rowoffset;

    /**
     * Texture indices. We do not maintain names here.
     */
    public short toptexture;

    public short bottomtexture;

    public short midtexture;

    /** Sector the SideDef is facing. MAES: pointer */
    public sector_t sector;

    public int sectorid;

    public int special;

    public side_t() {
    }

    public side_t(int textureoffset, int rowoffset, short toptexture,
            short bottomtexture, short midtexture, sector_t sector) {
        super();
        this.textureoffset = textureoffset;
        this.rowoffset = rowoffset;
        this.toptexture = toptexture;
        this.bottomtexture = bottomtexture;
        this.midtexture = midtexture;
        this.sector = sector;
    }

    @Override
    public void read(DataInputStream f)
            throws IOException {
        this.textureoffset = DoomIO.readLEShort(f) << FRACBITS;
        this.rowoffset = DoomIO.readLEShort(f) << FRACBITS;
        this.toptexture = DoomIO.readLEShort(f);
        this.bottomtexture = DoomIO.readLEShort(f);
        this.midtexture = DoomIO.readLEShort(f);
        // this.sectorid=f.readLEInt();

    }

    @Override
    public void pack(ByteBuffer buffer) {
        buffer.putShort((short) (textureoffset >> FRACBITS));
        buffer.putShort((short) (rowoffset >> FRACBITS));
        buffer.putShort(toptexture);
        buffer.putShort(bottomtexture);
        buffer.putShort(midtexture);
    }

    @Override
    public void reset() {
        textureoffset = 0;
        rowoffset = 0;
        toptexture = 0;
        bottomtexture = 0;
        midtexture = 0;
        sector = null;
        sectorid = 0;
        special = 0;

    }

}

package rr;

public interface IDetailAware {

    public static int HIGH_DETAIL=0;
    public static int LOW_DETAIL=1;
    void setDetail(int detailshift);
}

package rr;

import static data.Tables.ANG180;
import static data.Tables.ANG270;
import static data.Tables.ANG90;
import static data.Tables.SlopeDiv;
import static data.Tables.tantoangle;
import utils.C2JUtils;
import doom.player_t;

public class ViewVars {
    
    // Found in draw_c. Only ever used in renderer.
    public int windowx;
    public int windowy;
    public int width;
    public int height;
    
    // MAES: outsiders have no business peeking into this.
    // Or...well..maybe they do. It's only used to center the "pause" X
    // position.
    // TODO: get rid of this?
    public int scaledwidth;
    public int centerx;
    public int centery;
    
    /** Used to determine the view center and projection in view units fixed_t */
    public int centerxfrac, centeryfrac, projection;

    /** fixed_t */
    public int x, y, z;

    // MAES: an exception to strict type safety. These are used only in here,
    // anyway (?) and have no special functions.
    // Plus I must use them as indexes. angle_t
    public long angle;

    /** fixed */
    public int cos, sin;

    public player_t player;

    /** Heretic/freeview stuff? */

    public int lookdir;
    
    // 0 = high, 1 = low. Normally only the menu and the interface can change
    // that.
    public int detailshift;
    
    public int WEAPONADJUST;
    public int BOBADJUST;
	
	/**
	 * constant arrays used for psprite clipping and initializing clipping
	 */
    public short[] negonearray; // MAES: in scaling
    public short[] screenheightarray;// MAES: in scaling
    
    /** Mirrors the one in renderer... */
    public long[] xtoviewangle;
	
    public final void initNegOneArray(int screenwidth){
	       C2JUtils.memset(negonearray, (short)-1,screenwidth);
		}
    
    public final long PointToAngle(int x, int y) {
        // MAES: note how we don't use &BITS32 here. That is because
        // we know that the maximum possible value of tantoangle is angle
        // This way, we are actually working with vectors emanating
        // from our current position.
        x -= this.x;
        y -= this.y;

        if ((x == 0) && (y == 0))
            return 0;

        if (x >= 0) {
            // x >=0
            if (y >= 0) {
                // y>= 0

                if (x > y) {
                    // octant 0
                    return tantoangle[SlopeDiv(y, x)];
                } else {
                    // octant 1
                    return (ANG90 - 1 - tantoangle[SlopeDiv(x, y)]);
                }
            } else {
                // y<0
                y = -y;

                if (x > y) {
                    // octant 8
                    return (-tantoangle[SlopeDiv(y, x)]);
                } else {
                    // octant 7
                    return (ANG270 + tantoangle[SlopeDiv(x, y)]);
                }
            }
        } else {
            // x<0
            x = -x;

            if (y >= 0) {
                // y>= 0
                if (x > y) {
                    // octant 3
                    return (ANG180 - 1 - tantoangle[SlopeDiv(y, x)]);
                } else {
                    // octant 2
                    return (ANG90 + tantoangle[SlopeDiv(x, y)]);
                }
            } else {
                // y<0
                y = -y;

                if (x > y) {
                    // octant 4
                    return (ANG180 + tantoangle[SlopeDiv(y, x)]);
                } else {
                    // octant 5
                    return (ANG270 - 1 - tantoangle[SlopeDiv(x, y)]);
                }
            }
        }
        // This is actually unreachable.
        // return 0;
    }
    
    public final int getViewWindowX(){
        return windowx;
    }

    public final int getViewWindowY(){
        return windowy;
    }
        
    public final int getScaledViewWidth(){
        return scaledwidth;
    }

    public final int getScaledViewHeight() {
        return height;
    }

}

package rr;

public interface planefunction_t {

}

package rr;

import java.io.IOException;

import rr.parallel.IGetSmpColumn;

/** All texture, flat and sprite management operations should be handled
 *  by an implementing class. As of now, the renderer does both, though it's
 *  not really the most ideal.
 *  
 * @author Velktron
 *
 */

public interface TextureManager<T> extends IGetColumn<T>, IGetCachedColumn<T>,IGetSmpColumn{

    public final static String[] texturelumps={"TEXTURE1","TEXTURE2"};
    public final static int NUMTEXLUMPS=texturelumps.length;
    public final static int TEXTURE1=0;
    public final static int TEXTURE2=1;
    
	int TextureNumForName(String texname);
	
	
	/**The "num" expected here is the internal flat number,
	 * not the absolute lump number. So impement accordingly.
	 * 
	 * @param flatname
	 * @return
	 */
	int FlatNumForName(String flatname);
	
	void PrecacheLevel() throws IOException;
	
	void GenerateComposite(int tex);
	
	int getTextureheight(int texnum);	
		
	int getTextureTranslation(int texnum);
	
	int getFlatTranslation(int flatnum);
	
	void setTextureTranslation(int texnum, int amount);
	
	void setFlatTranslation(int flatnum,int amount);

	int CheckTextureNumForName(String texnamem);

	String CheckTextureNameForNum(int texnum);
	
    int getTexturewidthmask(int tex);
   
    int getTextureColumnLump(int tex, int col);
   
    char getTextureColumnOfs(int tex, int col);

    T[] getTextureComposite(int tex);

    T getTextureComposite(int tex, int col);

    void InitFlats();

    void InitTextures() throws IOException;

    //int getFirstFlat();

    int getSkyTextureMid();

    int getSkyFlatNum();

    int getSkyTexture();

    void setSkyTexture(int skytexture);

    int InitSkyMap();

    void setSkyFlatNum(int skyflatnum);

    void GenerateLookup(int texnum)
            throws IOException;
    
    int getFlatLumpNum(int flatnum);


	T getRogueColumn(int lump, int column);

    patch_t getMaskedComposite(int tex);


    void GenerateMaskedComposite(int texnum);
    
    /** Return a "sanitized" patch. If data is insufficient, return
     *  a default patch or attempt a partial draw.
     * 
     * @param patchnum
     * @return
     */
    
    public T getSafeFlat(int flatnum);


    column_t GetColumnStruct(int tex, int col);


    void setSMPVars(int nUMMASKEDTHREADS);
    
    }

package rr;

import static rr.line_t.*;
import static data.Defines.ANGLETOSKYSHIFT;
import static data.Defines.NF_SUBSECTOR;
import static data.Defines.PU_CACHE;
import static data.Defines.SIL_BOTH;
import static data.Defines.SIL_BOTTOM;
import static data.Defines.SIL_TOP;
import static data.Limits.MAXHEIGHT;
import static data.Limits.MAXSEGS;
import static data.Limits.MAXWIDTH;
import static data.Tables.ANG180;
import static data.Tables.ANG270;
import static data.Tables.ANG90;
import static data.Tables.ANGLETOFINESHIFT;
import static data.Tables.BITS32;
import static data.Tables.DBITS;
import static data.Tables.FINEANGLES;
import static data.Tables.QUARTERMARK;
import static data.Tables.SlopeDiv;
import static data.Tables.addAngles;
import static data.Tables.finecosine;
import static data.Tables.finesine;
import static data.Tables.finetangent;
import static data.Tables.tantoangle;
import static m.BBox.BOXBOTTOM;
import static m.BBox.BOXLEFT;
import static m.BBox.BOXRIGHT;
import static m.BBox.BOXTOP;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.FixedDiv;
import static m.fixed_t.FixedMul;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import m.IDoomMenu;
import m.MenuMisc;
import p.AbstractLevelLoader;
import p.UnifiedGameMap;
import p.mobj_t;
import rr.UnifiedRenderer.Segs;
import rr.drawfuns.ColFuncs;
import rr.drawfuns.ColVars;
import rr.drawfuns.DoomColumnFunction;
import rr.drawfuns.DoomSpanFunction;
import rr.drawfuns.R_DrawColumnBoom;
import rr.drawfuns.R_DrawColumnBoomLow;
import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;
import rr.drawfuns.R_DrawFuzzColumn;
import rr.drawfuns.R_DrawFuzzColumnLow;
import rr.drawfuns.R_DrawSpanLow;
import rr.drawfuns.R_DrawSpanUnrolled;
import rr.drawfuns.R_DrawTLColumn;
import rr.drawfuns.R_DrawTranslatedColumn;
import rr.drawfuns.R_DrawTranslatedColumnLow;
import rr.drawfuns.SpanVars;
import i.IDoomSystem;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import v.IVideoScale;
import v.IVideoScaleAware;
import w.IWadLoader;
import data.Defines;
import data.Tables;
import doom.DoomMain;
import doom.DoomStatus;
import doom.IDoomGameNetworking;
import doom.player_t;
import doom.think_t;
import doom.thinker_t;
import static rr.LightsAndColors.*;

/**
 * Most shared -essential- status information, methods and classes related to
 * the software rendering subsystem are found here, shared between the various
 * implementations of the Doom's renderer. Not the cleanest or more OO way
 * possible, but still a good way to avoid duplicating common code. Some stuff
 * like Texture, Flat and Sprite management are also found -or at least
 * implemented temporarily- here, until a cleaner split can be made. This is a
 * kind of "Jack of all trades" class, but hopefully not for long.
 * 
 * @author velktron
 */

public abstract class RendererState<T, V>
        implements Renderer<T, V>, ILimitResettable {

    protected static final boolean DEBUG = false;

    protected static final boolean DEBUG2 = false;

    // ///////////////////// STATUS ////////////////////////

    protected DoomMain<T, V> DM;

    protected IDoomGameNetworking DGN;

    protected AbstractLevelLoader LL;

    protected ISegDrawer MySegs;

    protected IDoomMenu Menu;

    protected BSP MyBSP;

    protected PlaneDrawer<T, V> MyPlanes;

    protected IMaskedDrawer<T, V> MyThings;

    protected DoomVideoRenderer<T, V> V;

    protected UnifiedGameMap P;

    public IWadLoader W;

    public ISpriteManager SM;

    public IVisSpriteManagement<V> VIS;

    public IDoomSystem I;

    protected TextureManager<T> TexMan;

    public ViewVars view;

    public LightsAndColors<V> colormaps;

    public SegVars seg_vars;

    public Visplanes vp_vars;

    // Rendering subsystems that are detailshift-aware

    protected List<IDetailAware> detailaware;

    // The only reason to query scaledviewwidth from outside the renderer, is
    // this.
    public boolean isFullHeight() {
        return (view.height == SCREENHEIGHT);
    }

    public boolean isFullWidth() {
        return (view.scaledwidth == SCREENWIDTH);
    }

    public boolean isFullScreen() {
        return isFullWidth() && isFullHeight();
    }

    /**
     * Increment every time a check is made For some reason, this needs to be
     * visible even by enemies thinking :-S
     */
    protected int validcount = 1;

    /** Who can set this? A: The Menu. */
    protected boolean setsizeneeded;

    protected int setblocks;

    protected int setdetail;

    // private BSPVars bspvars;

    /**
     * R_SetViewSize Do not really change anything here, because it might be in
     * the middle of a refresh. The change will take effect next refresh.
     * 
     * @param blocks
     *        11 is full screen, 9 default.
     * @param detail
     *        0= high, 1 =low.
     */

    public void SetViewSize(int blocks, int detail) {
        // System.out.println("SetViewSize");
        setsizeneeded = true;
        setblocks = blocks;
        setdetail = detail;

        for (IDetailAware d : detailaware) {
            d.setDetail(setdetail);
        }
    }

    /**
     * R_SetupFrame
     */
    public void SetupFrame(player_t player) {
        int i;

        view.player = player;
        view.x = player.mo.x;
        view.y = player.mo.y;
        // viewangle = addAngles(player.mo.angle , viewangleoffset);
        view.angle = player.mo.angle & BITS32;
        // With 32 colormaps, a bump of 1 or 2 is normal.
        // With more than 32, it should be obviously higher.

        int bumplight = Math.max(LBITS - 5, 0);
        // Be a bit more generous, otherwise the effect is not
        // as evident with truecolor maps.
        bumplight += (bumplight > 0) ? 1 : 0;

        colormaps.extralight = player.extralight << bumplight;

        view.z = player.viewz;
        view.lookdir = (int) player.lookdir;
        int tempCentery;

        // MAES: hacks based on Heretic. Weapon movement needs to be compensated
        if (setblocks == 11)
            tempCentery =
                (view.height / 2)
                        + (int) (view.lookdir * SCREEN_MUL * setblocks) / 11;
        else
            tempCentery =
                (view.height / 2)
                        + (int) (view.lookdir * SCREEN_MUL * setblocks) / 10;

        if (view.centery != tempCentery) {
            view.centery = tempCentery;
            view.centeryfrac = view.centery << FRACBITS;
            int yslope[] = vp_vars.yslope;
            for (i = 0; i < view.height; i++) {
                yslope[i] =
                    FixedDiv(
                        (view.width << view.detailshift) / 2 * FRACUNIT,
                        Math.abs(((i - view.centery) << FRACBITS) + FRACUNIT
                                / 2));
            }

            skydcvars.centery =
                maskedcvars.centery = dcvars.centery = view.centery;
        }

        view.sin = Tables.finesine(view.angle);
        view.cos = Tables.finecosine(view.angle);

        sscount = 0;

        if (player.fixedcolormap != 0) {
            colormaps.fixedcolormap = colormaps.colormaps[player.fixedcolormap];
            // Offset by fixedcolomap
            // pfixedcolormap =player.fixedcolormap*256;

            colormaps.walllights = colormaps.scalelightfixed;

            for (i = 0; i < MAXLIGHTSCALE; i++)
                colormaps.scalelightfixed[i] = colormaps.fixedcolormap;
        } else
            colormaps.fixedcolormap = null;

        framecount++;
        validcount++;
    }

    /**
     * R_SetupFrame for a particular actor.
     */
    public void SetupFrame(mobj_t actor) {

        // viewplayer = player;
        view.x = actor.x;
        view.y = actor.y;
        // viewangle = addAngles(player.mo.angle , viewangleoffset);
        view.angle = actor.angle & BITS32;
        // extralight = actor.extralight;

        view.z = actor.z + actor.height;

        view.sin = finesine(view.angle);
        view.cos = finecosine(view.angle);

        sscount = 0;

        framecount++;
        validcount++;
    }

    public RendererState(DoomStatus<T, V> DS) {
        this.updateStatus(DS);

        // These don't change between implementations, yet.
        this.MyBSP = new BSP();

        this.view = new ViewVars();
        this.seg_vars = new SegVars();
        this.dcvars=new ColVars<T,V>();
        this.dsvars=new SpanVars<T,V>();        
        this.maskedcvars=new ColVars<T,V>();
        this.skydcvars=new ColVars<T,V>();
        this.colfunclow=new ColFuncs<T,V>();
        this.colfunchi=new ColFuncs<T,V>();

        this.detailaware = new ArrayList<IDetailAware>();
        this.colormaps=new LightsAndColors<V>();
        // It's better to construct this here
        this.TexMan = (TextureManager<T>) new SimpleTextureManager(DS);
        this.SM=new SpriteManager(DS);

        // Visplane variables
        this.vp_vars = new Visplanes(view, TexMan);
        // Initialize array of minus ones for sprite clipping
        view.initNegOneArray(SCREENWIDTH);

        // Set rendering functions only after screen sizes
        // and stuff have been set.
        
        this.MyPlanes = new Planes(this);
        this.VIS=new VisSprites<V>(this);
        this.MyThings = new SimpleThings<T,V>(this);
        
    }

    @SuppressWarnings("unchecked")
    @Override
    public void updateStatus(DoomStatus<?, ?> DC) {
        this.DM = (DoomMain<T, V>) DC.DM;
        this.DGN = DC.DGN;
        this.LL = DC.LL;
        this.W = DC.W;
        this.P = DC.P;
        // We must also connect screen to V. Don't forget it. Do it in Init(),
        // OK?
        this.V = (DoomVideoRenderer<T, V>) DC.V;
        this.SM = DC.SM;
        this.I = DC.I;
        if (VIS != null)
            this.VIS.updateStatus(this);
    }

    // ////////////////////////////// THINGS ////////////////////////////////

    protected final class BSP
            extends BSPVars {

        /** newend is one past the last valid seg (cliprange_t) */
        int newend;

        cliprange_t[] solidsegs;

        public BSP() {
            solidsegs = new cliprange_t[MAXSEGS + 1];
            C2JUtils.initArrayOfObjects(solidsegs);

        }

        /**
         * R_ClipSolidWallSegment Does handle solid walls, single sided LineDefs
         * (middle texture) that entirely block the view VERTICALLY. Handles
         * "clipranges" for a solid wall, aka where it blocks the view.
         * 
         * @param first
         *        starting y coord?
         * @param last
         *        ending y coord?
         */

        private void ClipSolidWallSegment(int first, int last) {

            int next;
            int start;
            // int maxlast=Integer.MIN_VALUE;

            start = 0; // within solidsegs

            // Find the first cliprange that touches the range.
            // Actually, the first one not completely hiding it (its last must
            // be lower than first.

            while (solidsegs[start].last < first - 1)
                start++;

            // If the post begins above the lastly found cliprange...
            if (first < solidsegs[start].first) {
                // ..and ends above it, too (no overlapping)
                if (last < solidsegs[start].first - 1) {
                    // ... then the post is entirely visible (above start),
                    // so insert a new clippost. Calling this function
                    // tells the renderer that there is an obstruction.
                    MySegs.StoreWallRange(first, last);

                    // Newend should have a value of 2 if we are at the
                    // beginning of a new frame.
                    next = newend;
                    newend++;

                    if (next >= solidsegs.length)
                        ResizeSolidSegs();
                    while (next != start) {
                        // *next=*(next-1);
                        /*
                         * MAES: I think this is supposed to copy the structs
                         * solidsegs[next] = solidsegs[next-1].clone(); OK, so
                         * basically the last solidseg copies its previous, and
                         * so on until we reach the start. This means that at
                         * some point, the value of the start solidseg is
                         * duplicated.
                         */

                        solidsegs[next].copy(solidsegs[next - 1]);

                        next--;
                    }

                    // At this point, next points at start.
                    // Therefore, start
                    solidsegs[next].first = first;
                    solidsegs[next].last = last;
                    return;
                }

                // There is a fragment above *start. This can occur if it a
                // post does start before another, but its lower edge overlaps
                // (partial, upper occlusion)
                MySegs.StoreWallRange(first, solidsegs[start].first - 1);
                // Now adjust the clip size.
                solidsegs[start].first = first;
            }

            // We can reach this only if a post starts AFTER another

            // Bottom contained in start? Obviously it won't be visible.
            if (last <= solidsegs[start].last)
                return;

            next = start;
            while (last >= solidsegs[(next + 1)].first - 1) {
                // There is a fragment between two posts.
                MySegs.StoreWallRange(solidsegs[next].last + 1,
                    solidsegs[next + 1].first - 1);
                next++;

                if (last <= solidsegs[next].last) {
                    // Bottom is contained in next.
                    // Adjust the clip size.
                    solidsegs[start].last = solidsegs[next].last;
                    // goto crunch;

                    { // crunch code
                        if (next == start) {
                            // Post just extended past the bottom of one post.
                            return;
                        }

                        while (next++ != newend) {
                            // Remove a post.
                            // MAES: this is a struct copy.
                            if (next >= solidsegs.length)
                                ResizeSolidSegs();
                            solidsegs[++start].copy(solidsegs[next]);
                        }

                        newend = start + 1;
                        return;
                    }
                }
            }

            // There is a fragment after *next.
            MySegs.StoreWallRange(solidsegs[next].last + 1, last);
            // Adjust the clip size.
            solidsegs[start].last = last;

            // Remove start+1 to next from the clip list,
            // because start now covers their area.

            { // crunch code
                if (next == start) {
                    // Post just extended past the bottom of one post.
                    return;
                }

                while (next++ != newend) {
                    // Remove a post.
                    // MAES: this is a struct copy.
                    // MAES: this can overflow, breaking e.g. MAP30 of Final
                    // Doom.
                    if (next >= solidsegs.length)
                        ResizeSolidSegs();
                    solidsegs[++start].copy(solidsegs[next]);
                }

                newend = start + 1;
                return;
            }
        }

        protected final void ResizeSolidSegs() {
            solidsegs = C2JUtils.resize(solidsegs, solidsegs.length * 2);
        }

        //
        // R_ClipPassWallSegment
        // Clips the given range of columns,
        // but does not includes it in the clip list.
        // Does handle windows,
        // e.g. LineDefs with upper and lower texture.
        //
        private void ClipPassWallSegment(int first, int last) {

            // Find the first range that touches the range
            // (adjacent pixels are touching).
            int start = 0;

            while (solidsegs[start].last < first - 1)
                start++;

            if (first < solidsegs[start].first) {
                if (last < solidsegs[start].first - 1) {
                    // Post is entirely visible (above start).
                    MySegs.StoreWallRange(first, last);
                    return;
                }

                // There is a fragment above *start.
                MySegs.StoreWallRange(first, solidsegs[start].first - 1);
            }

            // Bottom contained in start?
            if (last <= solidsegs[start].last)
                return;

            // MAES: Java absolutely can't do without a sanity check here.
            // if (startptr>=MAXSEGS-2) return;

            while (last >= solidsegs[start + 1].first - 1) {
                // There is a fragment between two posts.
                MySegs.StoreWallRange(solidsegs[start].last + 1,
                    solidsegs[start + 1].first - 1);
                start++;
                // if (startptr>=MAXSEGS-2) return;
                // start=solidsegs[startptr];

                if (last <= solidsegs[start].last)
                    return;
            }

            // There is a fragment after *next.
            MySegs.StoreWallRange(solidsegs[start].last + 1, last);
        }

        /**
         * R_ClearClipSegs Clears the clipping segs list. The list is actually
         * fixed size for efficiency reasons, so it just tells Doom to use the
         * first two solidsegs, which are "neutered". It's interesting to note
         * how the solidsegs begin and end just "outside" the visible borders of
         * the screen.
         */

        public void ClearClipSegs() {
            solidsegs[0].first = -0x7fffffff;
            solidsegs[0].last = -1;
            solidsegs[1].first = view.width;
            solidsegs[1].last = 0x7fffffff;
            newend = 2; // point so solidsegs[2];
        }

        /**
         * R_AddLine Called after a SubSector BSP trasversal ends up in a
         * "final" subsector. Clips the given segment and adds any visible
         * pieces to the line list. It also determines what kind of boundary
         * (line) visplane clipping should be performed. E.g. window, final
         * 1-sided line, closed door etc.) CAREFUL: was the source of much
         * frustration with visplanes...
         */
        private void AddLine(seg_t line) {
            if (DEBUG)
                System.out.println("Entered AddLine for " + line);
            int x1;
            int x2;
            long angle1;
            long angle2;
            long span;
            long tspan;

            curline = line;

            // OPTIMIZE: quickly reject orthogonal back sides.
            angle1 = view.PointToAngle(line.v1x, line.v1y);
            angle2 = view.PointToAngle(line.v2x, line.v2y);

            // Clip to view edges.
            // OPTIMIZE: make constant out of 2*clipangle (FIELDOFVIEW).

            span = addAngles(angle1, -angle2);

            // Back side? I.e. backface culling?
            if (span >= ANG180)
                return;

            // Global angle needed by segcalc.
            MySegs.setGlobalAngle(angle1);
            angle1 -= view.angle;
            angle2 -= view.angle;

            angle1 &= BITS32;
            angle2 &= BITS32;

            tspan = addAngles(angle1, clipangle);

            if (tspan > CLIPANGLE2) {
                tspan -= CLIPANGLE2;
                tspan &= BITS32;

                // Totally off the left edge?
                if (tspan >= span)
                    return;

                angle1 = clipangle;
            }
            tspan = addAngles(clipangle, -angle2);

            if (tspan > CLIPANGLE2) {
                tspan -= CLIPANGLE2;
                tspan &= BITS32;

                // Totally off the left edge?
                if (tspan >= span)
                    return;
                angle2 = -clipangle;
                angle2 &= BITS32;
            }

            // The seg is in the view range,
            // but not necessarily visible.

            angle1 = ((angle1 + ANG90) & BITS32) >>> ANGLETOFINESHIFT;
            angle2 = ((angle2 + ANG90) & BITS32) >>> ANGLETOFINESHIFT;
            x1 = viewangletox[(int) angle1];
            x2 = viewangletox[(int) angle2];

            // Does not cross a pixel?
            if (x1 == x2)
                return;

            backsector = line.backsector;

            // Single sided line?

            if (backsector == null) {
                if (DEBUG)
                    System.out
                            .println("Entering ClipSolidWallSegment SS with params "
                                    + x1 + " " + (x2 - 1));
                ClipSolidWallSegment(x1, x2 - 1); // to clipsolid
                if (DEBUG)
                    System.out.println("Exiting ClipSolidWallSegment");
                return;
            }

            // Closed door.
            if (backsector.ceilingheight <= frontsector.floorheight
                    || backsector.floorheight >= frontsector.ceilingheight) {
                if (DEBUG)
                    System.out
                            .println("Entering ClipSolidWallSegment Closed door with params "
                                    + x1 + " " + (x2 - 1));
                ClipSolidWallSegment(x1, x2 - 1);
                ; // to clipsolid
                return;
            }

            // Window. This includes same-level floors with different textures
            if (backsector.ceilingheight != frontsector.ceilingheight
                    || backsector.floorheight != frontsector.floorheight) {
                if (DEBUG)
                    System.out
                            .println("Entering ClipSolidWallSegment window with params "
                                    + x1 + " " + (x2 - 1));
                ClipPassWallSegment(x1, x2 - 1); // to clippass
                return;
            }

            // Reject empty lines used for triggers
            // and special events.
            // Identical floor and ceiling on both sides,
            // identical light levels on both sides,
            // and no middle texture.
            if (backsector.ceilingpic == frontsector.ceilingpic
                    && backsector.floorpic == frontsector.floorpic
                    && backsector.lightlevel == frontsector.lightlevel
                    && curline.sidedef.midtexture == 0) {
                return;
            }

            // If nothing of the previous holds, then we are
            // treating the case of same-level, differently
            // textured floors. ACHTUNG, this caused the "bleeding floor"
            // bug, which is now fixed.
            // Fucking GOTOs....
            ClipPassWallSegment(x1, x2 - 1); // to clippass
            if (DEBUG)
                System.out.println("Exiting AddLine for " + line);
        }

        //
        // R_CheckBBox
        // Checks BSP node/subtree bounding box.
        // Returns true
        // if some part of the bbox might be visible.
        //
        private int[][] checkcoord = { { 3, 0, 2, 1 }, { 3, 0, 2, 0 },
                { 3, 1, 2, 0 }, { 0 }, { 2, 0, 2, 1 }, { 0, 0, 0, 0 },
                { 3, 1, 3, 0 }, { 0 }, { 2, 0, 3, 1 }, { 2, 1, 3, 1 },
                { 2, 1, 3, 0 } };

        /**
         * @param bspcoord
         *        (fixed_t* as bbox)
         * @return
         */
        public boolean CheckBBox(int[] bspcoord) {
            int boxx;
            int boxy;
            int boxpos;

            // fixed_t
            int x1;
            int y1;
            int x2;
            int y2;

            // angle_t
            long angle1;
            long angle2;
            long span;
            long tspan;

            cliprange_t start;

            int sx1;
            int sx2;

            // Find the corners of the box
            // that define the edges from current viewpoint.
            if (view.x <= bspcoord[BOXLEFT])
                boxx = 0;
            else if (view.x < bspcoord[BOXRIGHT])
                boxx = 1;
            else
                boxx = 2;

            if (view.y >= bspcoord[BOXTOP])
                boxy = 0;
            else if (view.y > bspcoord[BOXBOTTOM])
                boxy = 1;
            else
                boxy = 2;

            boxpos = (boxy << 2) + boxx;
            if (boxpos == 5)
                return true;

            x1 = bspcoord[checkcoord[boxpos][0]];
            y1 = bspcoord[checkcoord[boxpos][1]];
            x2 = bspcoord[checkcoord[boxpos][2]];
            y2 = bspcoord[checkcoord[boxpos][3]];

            // check clip list for an open space
            angle1 = view.PointToAngle(x1, y1) - view.angle;
            angle2 = view.PointToAngle(x2, y2) - view.angle;

            angle1 &= BITS32;
            angle2 &= BITS32;

            span = angle1 - angle2;

            span &= BITS32;

            // Sitting on a line?
            if (span >= ANG180)
                return true;

            tspan = angle1 + clipangle;
            tspan &= BITS32;

            if (tspan > CLIPANGLE2) {
                tspan -= CLIPANGLE2;
                tspan &= BITS32;
                // Totally off the left edge?
                if (tspan >= span)
                    return false;

                angle1 = clipangle;
            }
            tspan = (clipangle - angle2) & BITS32;
            ;
            if (tspan > CLIPANGLE2) {
                tspan -= CLIPANGLE2;
                tspan &= BITS32;

                // Totally off the left edge?
                if (tspan >= span)
                    return false;

                angle2 = -clipangle;
                angle2 &= BITS32;
            }

            // Find the first clippost
            // that touches the source post
            // (adjacent pixels are touching).
            angle1 = ((angle1 + ANG90) & BITS32) >>> ANGLETOFINESHIFT;
            angle2 = ((angle2 + ANG90) & BITS32) >>> ANGLETOFINESHIFT;
            sx1 = viewangletox[(int) angle1];
            sx2 = viewangletox[(int) angle2];

            // Does not cross a pixel.
            if (sx1 == sx2)
                return false;
            sx2--;

            int pstart = 0;
            start = solidsegs[pstart];
            // FIXME: possible solidseg overflow here overflows
            while (start.last < sx2 && pstart < MAXSEGS)
                start = solidsegs[pstart++];

            if (sx1 >= start.first && sx2 <= start.last) {
                // The clippost contains the new span.
                return false;
            }

            return true;
        }

        /**
         * R_Subsector Determine floor/ceiling planes. Add sprites of things in
         * sector. Draw one or more line segments. It also alters the visplane
         * list!
         * 
         * @param num
         *        Subsector from subsector_t list in Lever Loader.
         */

        private void Subsector(int num) {
            if (DEBUG)
                System.out.println("\t\tSubSector " + num + " to render");
            int count;
            int line; // pointer into a list of segs instead of seg_t
            subsector_t sub;

            if (RANGECHECK) {
                if (num >= LL.numsubsectors)
                    I.Error("R_Subsector: ss %d with numss = %d", num,
                        LL.numsubsectors);
            }

            sscount++;
            sub = LL.subsectors[num];

            frontsector = sub.sector;
            if (DEBUG)
                System.out.println("Frontsector to render :" + frontsector);
            count = sub.numlines;
            // line = LL.segs[sub.firstline];
            line = sub.firstline;

            if (DEBUG)
                System.out
                        .println("Trying to find an existing FLOOR visplane...");
            if (frontsector.floorheight < view.z) {
                vp_vars.floorplane =
                    vp_vars.FindPlane(frontsector.floorheight,
                        frontsector.floorpic, frontsector.lightlevel);
            } else
                // FIXME: unclear what would happen with a null visplane used
                // It's never checked explicitly for either condition, just
                // called straight.
                vp_vars.floorplane = -1; // in lieu of NULL

            // System.out.println("Trying to find an existing CEILING visplane...");

            if (frontsector.ceilingheight > view.z
                    || frontsector.ceilingpic == TexMan.getSkyFlatNum()) {
                vp_vars.ceilingplane =
                    vp_vars.FindPlane(frontsector.ceilingheight,
                        frontsector.ceilingpic, frontsector.lightlevel);
            } else
                vp_vars.ceilingplane = -1; // In lieu of NULL. Will bomb if
                                           // actually
            // used.

            VIS.AddSprites(frontsector);

            if (DEBUG)
                System.out.println("Enter Addline for SubSector " + num
                        + " count " + count);
            while (count-- > 0) {
                AddLine(LL.segs[line]);
                line++;
            }
            if (DEBUG)
                System.out.println("Exit Addline for SubSector " + num);
        }

        /**
         * RenderBSPNode Renders all subsectors below a given node, traversing
         * subtree recursively. Just call with BSP root.
         */
        public void RenderBSPNode(int bspnum) {
            if (DEBUG)
                System.out.println("Processing BSP Node " + bspnum);

            node_t bsp;
            int side;

            // Found a subsector? Then further decisions are taken, in, well,
            // SubSector.
            if (C2JUtils.flags(bspnum, NF_SUBSECTOR)) {
                if (DEBUG)
                    System.out.println("Subsector found.");
                if (bspnum == -1)
                    Subsector(0);
                else
                    Subsector(bspnum & (~NF_SUBSECTOR));
                return;
            }

            bsp = LL.nodes[bspnum];

            // Decide which side the view point is on.
            side = bsp.PointOnSide(view.x, view.y);
            if (DEBUG)
                System.out.println("\tView side: " + side);

            // Recursively divide front space.
            if (DEBUG)
                System.out.println("\tEnter Front space of " + bspnum);
            RenderBSPNode(bsp.children[side]);
            if (DEBUG)
                System.out.println("\tReturn Front space of " + bspnum);

            // Possibly divide back space.

            if (CheckBBox(bsp.bbox[side ^ 1].bbox)) {
                if (DEBUG)
                    System.out.println("\tEnter Back space of " + bspnum);
                RenderBSPNode(bsp.children[side ^ 1]);
                if (DEBUG)
                    System.out.println("\tReturn Back space of " + bspnum);
            }
        }

    }

    protected abstract class SegDrawer
            implements ISegDrawer {

        protected static final int HEIGHTBITS = 12;

        protected static final int HEIGHTUNIT = (1 << HEIGHTBITS);

        protected final Visplanes vp_vars;

        protected final SegVars seg_vars;

        // Fast blanking buffers.
        protected short[] BLANKFLOORCLIP;

        protected short[] BLANKCEILINGCLIP;

        @Override
        public short[] getBLANKFLOORCLIP() {
            return BLANKFLOORCLIP;
        }

        @Override
        public short[] getBLANKCEILINGCLIP() {
            return BLANKCEILINGCLIP;
        }

        /** fixed_t */
        protected int pixhigh, pixlow, pixhighstep, pixlowstep, topfrac,
                topstep, bottomfrac, bottomstep;

        protected int worldtop, worldbottom, worldhigh, worldlow;

        /** True if any of the segs textures might be visible. */
        protected boolean segtextured;

        /**
         * Clip values are the solid pixel bounding the range. floorclip starts
         * out SCREENHEIGHT ceilingclip starts out -1
         */
        protected short[] floorclip, ceilingclip;

        public final short[] getFloorClip() {
            return floorclip;
        }

        public final short[] getCeilingClip() {
            return ceilingclip;
        }

        /** False if the back side is the same plane. */
        protected boolean markfloor, markceiling;

        protected boolean maskedtexture;

        protected int toptexture;

        protected int bottomtexture;

        protected int midtexture;

        /** angle_t, used after adding ANG90 in StoreWallRange */
        protected long rw_normalangle;

        /** angle to line origin */
        protected long rw_angle1;

        //
        // regular wall
        //
        protected int rw_x;

        protected int rw_stopx;

        protected long rw_centerangle; // angle_t

        /** fixed_t */
        protected int rw_offset, rw_distance, rw_scale, rw_scalestep,
                rw_midtexturemid, rw_toptexturemid, rw_bottomtexturemid;

        public void resetLimits() {
            drawseg_t[] tmp = new drawseg_t[seg_vars.MAXDRAWSEGS];
            System.arraycopy(seg_vars.drawsegs, 0, tmp, 0, seg_vars.MAXDRAWSEGS);

            // Now, that was quite a haircut!.
            seg_vars.drawsegs = tmp;

            // System.out.println("Drawseg buffer cut back to original limit of "+MAXDRAWSEGS);
        }
        
        public void sync(){
            // Nothing required if serial.
        }

        /**
         * R_StoreWallRange A wall segment will be drawn between start and stop
         * pixels (inclusive). This is the only place where
         * markceiling/markfloor can be set. Can only be called from
         * ClipSolidWallSegment and ClipPassWallSegment.
         * 
         * @throws IOException
         */

        public void StoreWallRange(int start, int stop) {

            if (DEBUG2)
                System.out.println("\t\t\t\tStorewallrange called between "
                        + start + " and " + stop);

            int hyp; // fixed_t
            int sineval; // fixed_t
            int distangle;
            long offsetangle; // angle_t
            int vtop; // fixed_t
            int lightnum;
            drawseg_t seg;

            // don't overflow and crash
            if (seg_vars.ds_p == seg_vars.drawsegs.length)
                seg_vars.ResizeDrawsegs();

            if (RANGECHECK) {
                if (start >= view.width || start > stop)
                    I.Error("Bad R_RenderWallRange: %d to %d", start, stop);
            }

            seg = seg_vars.drawsegs[seg_vars.ds_p];

            MyBSP.sidedef = MyBSP.curline.sidedef;
            MyBSP.linedef = MyBSP.curline.linedef;

            // mark the segment as visible for auto map
            MyBSP.linedef.flags |= ML_MAPPED;

            // calculate rw_distance for scale calculation
            rw_normalangle = addAngles(MyBSP.curline.angle, ANG90);

            /*
             * MAES: ok, this is a tricky spot. angle_t's are supposed to be
             * always positive 32-bit unsigned integers, so a subtraction should
             * be always positive by definition, right? WRONG: this fucking spot
             * caused "blind spots" at certain angles because ONLY HERE angles
             * are supposed to be treated as SIGNED and result in differences
             * <180 degrees -_- The only way to coerce this behavior is to cast
             * both as signed ints.
             */
            offsetangle = Math.abs((int) rw_normalangle - (int) rw_angle1);

            if (offsetangle > ANG90)
                offsetangle = ANG90;

            // It should fit even in a signed int, by now.
            distangle = (int) (ANG90 - offsetangle);
            hyp = PointToDist(MyBSP.curline.v1x, MyBSP.curline.v1y);
            sineval = finesine(distangle);
            rw_distance = FixedMul(hyp, sineval);

            seg.x1 = rw_x = start;
            seg.x2 = stop;
            seg.curline = MyBSP.curline;
            /*
             * This is the only place it's ever explicitly assigned. Therefore
             * it always starts at stop+1.
             */
            rw_stopx = stop + 1;

            // calculate scale at both ends and step
            // this is the ONLY place where rw_scale is set.
            seg.scale1 =
                rw_scale =
                    ScaleFromGlobalAngle((view.angle + xtoviewangle[start]));

            if (stop > start) {
                seg.scale2 =
                    ScaleFromGlobalAngle(view.angle + xtoviewangle[stop]);
                seg.scalestep =
                    rw_scalestep = (seg.scale2 - rw_scale) / (stop - start);
            } else {
                // UNUSED: try to fix the stretched line bug
                /*
                 * #if 0 if (rw_distance < FRACUNIT/2) { fixed_t trx,try;
                 * fixed_t gxt,gyt; trx = curline.v1.x - viewx; try =
                 * curline.v1.y - viewy; gxt = FixedMul(trx,viewcos); gyt =
                 * -FixedMul(try,viewsin); seg.scale1 = FixedDiv(projection,
                 * gxt-gyt)<<detailshift; } #endif
                 */
                seg.scale2 = seg.scale1;
            }

            // calculate texture boundaries
            // and decide if floor / ceiling marks are needed
            worldtop = MyBSP.frontsector.ceilingheight - view.z;
            worldbottom = MyBSP.frontsector.floorheight - view.z;

            midtexture = toptexture = bottomtexture = 0;
            maskedtexture = false;
            seg.setMaskedTextureCol(null, 0);
            // seg.maskedtexturecol = null;

            if (MyBSP.backsector == null) {
                // single sided line
                midtexture =
                    TexMan.getTextureTranslation(MyBSP.sidedef.midtexture);
                // a single sided line is terminal, so it must mark ends
                markfloor = markceiling = true;
                if ((MyBSP.linedef.flags & ML_DONTPEGBOTTOM) != 0) {
                    vtop =
                        MyBSP.frontsector.floorheight
                                + TexMan.getTextureheight(MyBSP.sidedef.midtexture);
                    // bottom of texture at bottom
                    rw_midtexturemid = vtop - view.z;
                } else {
                    // top of texture at top
                    rw_midtexturemid = worldtop;
                }
                rw_midtexturemid += MyBSP.sidedef.rowoffset;

                seg.silhouette = SIL_BOTH;
                seg.setSprTopClip(view.screenheightarray, 0);
                seg.setSprBottomClip(view.negonearray, 0);
                seg.bsilheight = Integer.MAX_VALUE;
                seg.tsilheight = Integer.MIN_VALUE;
            } else {
                // two sided line
                seg.setSprTopClip(null, 0);
                seg.setSprBottomClip(null, 0);
                seg.silhouette = 0;

                if (MyBSP.frontsector.floorheight > MyBSP.backsector.floorheight) {
                    seg.silhouette = SIL_BOTTOM;
                    seg.bsilheight = MyBSP.frontsector.floorheight;
                } else if (MyBSP.backsector.floorheight > view.z) {
                    seg.silhouette = SIL_BOTTOM;
                    seg.bsilheight = Integer.MAX_VALUE;
                    // seg.sprbottomclip = negonearray;
                }

                if (MyBSP.frontsector.ceilingheight < MyBSP.backsector.ceilingheight) {
                    seg.silhouette |= SIL_TOP;
                    seg.tsilheight = MyBSP.frontsector.ceilingheight;
                } else if (MyBSP.backsector.ceilingheight < view.z) {
                    seg.silhouette |= SIL_TOP;
                    seg.tsilheight = Integer.MIN_VALUE;
                    // seg.sprtopclip = screenheightarray;
                }

                if (MyBSP.backsector.ceilingheight <= MyBSP.frontsector.floorheight) {
                    seg.setSprBottomClip(view.negonearray, 0);
                    seg.bsilheight = Integer.MAX_VALUE;
                    seg.silhouette |= SIL_BOTTOM;
                }

                if (MyBSP.backsector.floorheight >= MyBSP.frontsector.ceilingheight) {
                    seg.setSprTopClip(view.screenheightarray, 0);
                    seg.tsilheight = Integer.MIN_VALUE;
                    seg.silhouette |= SIL_TOP;
                }

                worldhigh = MyBSP.backsector.ceilingheight - view.z;
                worldlow = MyBSP.backsector.floorheight - view.z;

                // hack to allow height changes in outdoor areas
                if (MyBSP.frontsector.ceilingpic == TexMan.getSkyFlatNum()
                        && MyBSP.backsector.ceilingpic == TexMan
                                .getSkyFlatNum()) {
                    worldtop = worldhigh;
                }

                if (worldlow != worldbottom
                        || MyBSP.backsector.floorpic != MyBSP.frontsector.floorpic
                        || MyBSP.backsector.lightlevel != MyBSP.frontsector.lightlevel) {
                    markfloor = true;
                } else {
                    // same plane on both sides
                    markfloor = false;
                }

                if (worldhigh != worldtop
                        || MyBSP.backsector.ceilingpic != MyBSP.frontsector.ceilingpic
                        || MyBSP.backsector.lightlevel != MyBSP.frontsector.lightlevel) {
                    markceiling = true;
                } else {
                    // same plane on both sides
                    markceiling = false;
                }

                if (MyBSP.backsector.ceilingheight <= MyBSP.frontsector.floorheight
                        || MyBSP.backsector.floorheight >= MyBSP.frontsector.ceilingheight) {
                    // closed door
                    markceiling = markfloor = true;
                }

                if (worldhigh < worldtop) {
                    // top texture
                    toptexture =
                        TexMan.getTextureTranslation(MyBSP.sidedef.toptexture);
                    if ((MyBSP.linedef.flags & ML_DONTPEGTOP) != 0) {
                        // top of texture at top
                        rw_toptexturemid = worldtop;
                    } else {
                        vtop =
                            MyBSP.backsector.ceilingheight
                                    + TexMan.getTextureheight(MyBSP.sidedef.toptexture);

                        // bottom of texture
                        rw_toptexturemid = vtop - view.z;
                    }
                }
                if (worldlow > worldbottom) {
                    // bottom texture
                    bottomtexture =
                        TexMan.getTextureTranslation(MyBSP.sidedef.bottomtexture);

                    if ((MyBSP.linedef.flags & ML_DONTPEGBOTTOM) != 0) {
                        // bottom of texture at bottom
                        // top of texture at top
                        rw_bottomtexturemid = worldtop;
                    } else
                        // top of texture at top
                        rw_bottomtexturemid = worldlow;
                }
                rw_toptexturemid += MyBSP.sidedef.rowoffset;
                rw_bottomtexturemid += MyBSP.sidedef.rowoffset;

                // allocate space for masked texture tables
                if (MyBSP.sidedef.midtexture != 0) {
                    // masked midtexture
                    maskedtexture = true;
                    seg_vars.maskedtexturecol = vp_vars.openings;
                    seg_vars.pmaskedtexturecol = vp_vars.lastopening - rw_x;
                    seg.setMaskedTextureCol(seg_vars.maskedtexturecol,
                        seg_vars.pmaskedtexturecol);
                    vp_vars.lastopening += rw_stopx - rw_x;
                }
            }

            // calculate rw_offset (only needed for textured lines)
            segtextured =
                (((midtexture | toptexture | bottomtexture) != 0) | maskedtexture);

            if (segtextured) {
                offsetangle = addAngles(rw_normalangle, -rw_angle1);

                // Another "tricky spot": negative of an unsigned number?
                if (offsetangle > ANG180)
                    offsetangle = (-(int) offsetangle) & BITS32;

                if (offsetangle > ANG90)
                    offsetangle = ANG90;

                sineval = finesine(offsetangle);
                rw_offset = FixedMul(hyp, sineval);

                // Another bug: we CAN'T assume that the result won't wrap
                // around.
                // If that assumption is made, then texture alignment issues
                // appear
                if (((rw_normalangle - rw_angle1) & BITS32) < ANG180)
                    rw_offset = -rw_offset;

                rw_offset += MyBSP.sidedef.textureoffset + MyBSP.curline.offset;
                // This is OK, however: we can add as much shit as we want,
                // as long as we trim it to the 32 LSB. Proof as to why
                // this is always true is left as an exercise to the reader.
                rw_centerangle = (ANG90 + view.angle - rw_normalangle) & BITS32;

                // calculate light table
                // use different light tables
                // for horizontal / vertical / diagonal
                // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
                if (colormaps.fixedcolormap == null) {
                    lightnum =
                        (MyBSP.frontsector.lightlevel >> LIGHTSEGSHIFT)
                                + colormaps.extralight;

                    if (MyBSP.curline.v1y == MyBSP.curline.v2y)
                        lightnum--;
                    else if (MyBSP.curline.v1x == MyBSP.curline.v2x)
                        lightnum++;

                    if (lightnum < 0)
                        colormaps.walllights = colormaps.scalelight[0];
                    else if (lightnum >= LIGHTLEVELS)
                        colormaps.walllights =
                            colormaps.scalelight[LIGHTLEVELS - 1];
                    else
                        colormaps.walllights = colormaps.scalelight[lightnum];
                }
            }

            // if a floor / ceiling plane is on the wrong side
            // of the view plane, it is definitely invisible
            // and doesn't need to be marked.

            if (MyBSP.frontsector.floorheight >= view.z) {
                // above view plane
                markfloor = false;
            }

            if (MyBSP.frontsector.ceilingheight <= view.z
                    && MyBSP.frontsector.ceilingpic != TexMan.getSkyFlatNum()) {
                // below view plane
                markceiling = false;
            }

            // calculate incremental stepping values for texture edges
            worldtop >>= 4;
            worldbottom >>= 4;

            topstep = -FixedMul(rw_scalestep, worldtop);
            topfrac = (view.centeryfrac >> 4) - FixedMul(worldtop, rw_scale);

            bottomstep = -FixedMul(rw_scalestep, worldbottom);
            bottomfrac =
                (view.centeryfrac >> 4) - FixedMul(worldbottom, rw_scale);

            if (MyBSP.backsector != null) {
                worldhigh >>= 4;
                worldlow >>= 4;

                if (worldhigh < worldtop) {
                    pixhigh =
                        (view.centeryfrac >> 4) - FixedMul(worldhigh, rw_scale);
                    pixhighstep = -FixedMul(rw_scalestep, worldhigh);
                }

                if (worldlow > worldbottom) {
                    pixlow =
                        (view.centeryfrac >> 4) - FixedMul(worldlow, rw_scale);
                    pixlowstep = -FixedMul(rw_scalestep, worldlow);
                }
            }

            // render it
            if (markceiling) {
                // System.out.println("Markceiling");
                vp_vars.ceilingplane =
                    vp_vars.CheckPlane(vp_vars.ceilingplane, rw_x, rw_stopx - 1);
            }

            if (markfloor) {
                // System.out.println("Markfloor");
                vp_vars.floorplane =
                    vp_vars.CheckPlane(vp_vars.floorplane, rw_x, rw_stopx - 1);
            }

            RenderSegLoop();

            // After rendering is actually performed, clipping is set.

            // save sprite clipping info ... no top clipping?
            if ((C2JUtils.flags(seg.silhouette, SIL_TOP) || maskedtexture)
                    && seg.nullSprTopClip()) {

                // memcpy (lastopening, ceilingclip+start, 2*(rw_stopx-start));
                System.arraycopy(ceilingclip, start, vp_vars.openings,
                    vp_vars.lastopening, rw_stopx - start);

                seg.setSprTopClip(vp_vars.openings, vp_vars.lastopening - start);
                // seg.setSprTopClipPointer();
                vp_vars.lastopening += rw_stopx - start;
            }
            // no floor clipping?
            if ((C2JUtils.flags(seg.silhouette, SIL_BOTTOM) || maskedtexture)
                    && seg.nullSprBottomClip()) {
                // memcpy (lastopening, floorclip+start, 2*(rw_stopx-start));
                System.arraycopy(floorclip, start, vp_vars.openings,
                    vp_vars.lastopening, rw_stopx - start);
                seg.setSprBottomClip(vp_vars.openings, vp_vars.lastopening
                        - start);
                vp_vars.lastopening += rw_stopx - start;
            }

            if (maskedtexture && C2JUtils.flags(seg.silhouette, SIL_TOP)) {
                seg.silhouette |= SIL_TOP;
                seg.tsilheight = Integer.MIN_VALUE;
            }
            if (maskedtexture && (seg.silhouette & SIL_BOTTOM) == 0) {
                seg.silhouette |= SIL_BOTTOM;
                seg.bsilheight = Integer.MAX_VALUE;
            }
            seg_vars.ds_p++;
        }

        /**
         * R_RenderSegLoop Draws zero, one, or two textures (and possibly a
         * masked texture) for walls. Can draw or mark the starting pixel of
         * floor and ceiling textures. Also sets the actual sprite clipping info
         * (where sprites should be cut) Since rw_x ranges are non-overlapping,
         * rendering all walls means completing the clipping list as well. The
         * only difference between the parallel and the non-parallel version is
         * that the parallel doesn't draw immediately but rather, generates
         * RWIs. This can surely be unified to avoid replicating code. CALLED:
         * CORE LOOPING ROUTINE.
         */

        protected void RenderSegLoop() {
            int angle; // angle_t
            int index;
            int yl; // low
            int yh; // hight
            int mid;
            int texturecolumn = 0; // fixed_t
            int top;
            int bottom;

            for (; rw_x < rw_stopx; rw_x++) {
                // mark floor / ceiling areas
                yl = (topfrac + HEIGHTUNIT - 1) >> HEIGHTBITS;

                // no space above wall?
                if (yl < ceilingclip[rw_x] + 1)
                    yl = ceilingclip[rw_x] + 1;

                if (markceiling) {
                    top = ceilingclip[rw_x] + 1;
                    bottom = yl - 1;

                    if (bottom >= floorclip[rw_x])
                        bottom = floorclip[rw_x] - 1;

                    if (top <= bottom) {
                        vp_vars.visplanes[vp_vars.ceilingplane].setTop(rw_x,
                            (char) top);
                        vp_vars.visplanes[vp_vars.ceilingplane].setBottom(rw_x,
                            (char) bottom);
                    }
                }

                yh = bottomfrac >> HEIGHTBITS;

                if (yh >= floorclip[rw_x])
                    yh = floorclip[rw_x] - 1;

                // A particular seg has been identified as a floor marker.

                if (markfloor) {
                    top = yh + 1;
                    bottom = floorclip[rw_x] - 1;
                    if (top <= ceilingclip[rw_x])
                        top = ceilingclip[rw_x] + 1;
                    if (top <= bottom) {
                        vp_vars.visplanes[vp_vars.floorplane].setTop(rw_x,
                            (char) top);
                        vp_vars.visplanes[vp_vars.floorplane].setBottom(rw_x,
                            (char) bottom);
                    }
                }

                // texturecolumn and lighting are independent of wall tiers
                if (segtextured) {
                    // calculate texture offset

                    // CAREFUL: a VERY anomalous point in the code. Their sum is
                    // supposed
                    // to give an angle not exceeding 45 degrees (or an index of
                    // 0x0FFF after
                    // shifting). If added with pure unsigned rules, this
                    // doesn't hold anymore,
                    // not even if accounting for overflow.
                    angle =
                        Tables.toBAMIndex(rw_centerangle
                                + (int) xtoviewangle[rw_x]);

                    // FIXME: We are accessing finetangent here, the code seems
                    // pretty confident in that angle won't exceed 4K no matter
                    // what.
                    // But xtoviewangle alone can yield 8K when shifted.
                    // This usually only overflows if we idclip and look at
                    // certain directions (probably angles get fucked up),
                    // however it seems rare
                    // enough to just "swallow" the exception. You can eliminate
                    // it by anding
                    // with 0x1FFF if you're so inclined.
                    // FIXED by allowing overflow. See Tables for details.

                    texturecolumn =
                        rw_offset - FixedMul(finetangent[angle], rw_distance);
                    texturecolumn >>= FRACBITS;
                    // calculate lighting
                    index = rw_scale >> LIGHTSCALESHIFT;

                    if (index >= MAXLIGHTSCALE)
                        index = MAXLIGHTSCALE - 1;

                    dcvars.dc_colormap = colormaps.walllights[index];
                    dcvars.dc_x = rw_x;
                    dcvars.dc_iscale = (int) (0xffffffffL / rw_scale);
                }

                // draw the wall tiers
                if (midtexture != 0) {
                    // single sided line
                    dcvars.dc_yl = yl;
                    dcvars.dc_yh = yh;
                    dcvars.dc_texheight =
                        TexMan.getTextureheight(midtexture) >> FRACBITS; // killough
                    dcvars.dc_texturemid = rw_midtexturemid;
                    dcvars.dc_source_ofs = 0;
                    dcvars.dc_source =
                        TexMan.GetCachedColumn(midtexture, texturecolumn);
                    CompleteColumn();
                    ceilingclip[rw_x] = (short) view.height;
                    floorclip[rw_x] = -1;
                } else {
                    // two sided line
                    if (toptexture != 0) {
                        // top wall
                        mid = pixhigh >> HEIGHTBITS;
                        pixhigh += pixhighstep;

                        if (mid >= floorclip[rw_x])
                            mid = floorclip[rw_x] - 1;

                        if (mid >= yl) {
                            dcvars.dc_yl = yl;
                            dcvars.dc_yh = mid;
                            dcvars.dc_texturemid = rw_toptexturemid;
                            dcvars.dc_texheight =
                                TexMan.getTextureheight(toptexture) >> FRACBITS;
                            dcvars.dc_source =
                                (T) TexMan.GetCachedColumn(toptexture,
                                    texturecolumn);
                            dcvars.dc_source_ofs = 0;
                            if (dcvars.dc_colormap == null)
                                System.out.println("Two-sided");
                            CompleteColumn();
                            ceilingclip[rw_x] = (short) mid;
                        } else
                            ceilingclip[rw_x] = (short) (yl - 1);
                    } else {
                        // no top wall
                        if (markceiling)
                            ceilingclip[rw_x] = (short) (yl - 1);
                    }

                    if (bottomtexture != 0) {
                        // bottom wall
                        mid = (pixlow + HEIGHTUNIT - 1) >> HEIGHTBITS;
                        pixlow += pixlowstep;

                        // no space above wall?
                        if (mid <= ceilingclip[rw_x])
                            mid = ceilingclip[rw_x] + 1;

                        if (mid <= yh) {
                            dcvars.dc_yl = mid;
                            dcvars.dc_yh = yh;
                            dcvars.dc_texturemid = rw_bottomtexturemid;
                            dcvars.dc_texheight =
                                TexMan.getTextureheight(bottomtexture) >> FRACBITS;
                            dcvars.dc_source =
                                (T) TexMan.GetCachedColumn(bottomtexture,
                                    texturecolumn);
                            dcvars.dc_source_ofs = 0;
                            CompleteColumn();

                            floorclip[rw_x] = (short) mid;
                        } else
                            floorclip[rw_x] = (short) (yh + 1);
                    } else {
                        // no bottom wall
                        if (markfloor)
                            floorclip[rw_x] = (short) (yh + 1);
                    }

                    if (maskedtexture) {
                        // save texturecol
                        // for backdrawing of masked mid texture
                        seg_vars.maskedtexturecol[seg_vars.pmaskedtexturecol
                                + rw_x] = (short) texturecolumn;
                    }
                }

                rw_scale += rw_scalestep;
                topfrac += topstep;
                bottomfrac += bottomstep;
            }
        }

        @Override
        public void ClearClips() {
            System.arraycopy(BLANKFLOORCLIP, 0, floorclip, 0, view.width);
            System.arraycopy(BLANKCEILINGCLIP, 0, ceilingclip, 0, view.width);
        }

        /**
         * Called from RenderSegLoop. This should either invoke the column
         * function, or store a wall rendering instruction in the parallel
         * version. It's the only difference between the parallel and serial
         * renderer, BTW. So override and implement accordingly.
         */
        protected abstract void CompleteColumn();

        @Override
        public void ExecuteSetViewSize(int viewwidth) {
            for (int i = 0; i < viewwidth; i++) {
                BLANKFLOORCLIP[i] = (short) view.height;
                BLANKCEILINGCLIP[i] = -1;
            }
        }
        
        public void CompleteRendering(){
            // Nothing to do for serial. 
        }

        protected column_t col;

        public SegDrawer(Renderer<?, ?> R) {
            this.vp_vars = R.getVPVars();
            this.seg_vars = R.getSegVars();
            col = new column_t();
            seg_vars.drawsegs = new drawseg_t[seg_vars.MAXDRAWSEGS];
            C2JUtils.initArrayOfObjects(seg_vars.drawsegs);
        }

        /**
         * R_ScaleFromGlobalAngle Returns the texture mapping scale for the
         * current line (horizontal span) at the given angle. rw_distance must
         * be calculated first.
         */

        protected final int ScaleFromGlobalAngle(long visangle) {
            int scale; // fixed_t
            long anglea;
            long angleb;
            int sinea;
            int sineb;
            int num; // fixed_t
            int den;

            // UNUSED
            /*
             * { fixed_t dist; fixed_t z; fixed_t sinv; fixed_t cosv; sinv =
             * finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT]; dist =
             * FixedDiv (rw_distance, sinv); cosv =
             * finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT]; z =
             * abs(FixedMul (dist, cosv)); scale = FixedDiv(projection, z);
             * return scale; }
             */

            anglea = (ANG90 + visangle - view.angle) & BITS32;
            angleb = (ANG90 + visangle - rw_normalangle) & BITS32;

            // both sines are allways positive
            sinea = finesine(anglea);
            sineb = finesine(angleb);
            num = FixedMul(view.projection, sineb) << view.detailshift;
            den = FixedMul(rw_distance, sinea);

            if (den > num >> 16) {
                scale = FixedDiv(num, den);

                if (scale > 64 * FRACUNIT)
                    scale = 64 * FRACUNIT;
                else if (scale < 256)
                    scale = 256;
            } else
                scale = 64 * FRACUNIT;

            return scale;
        }

        public void setGlobalAngle(long angle) {
            this.rw_angle1 = angle;
        }
        
        public void initScaling() {
            this.floorclip = new short[vs.getScreenWidth()];
            this.ceilingclip = new short[vs.getScreenWidth()];
            BLANKFLOORCLIP = new short[vs.getScreenWidth()];
            BLANKCEILINGCLIP = new short[vs.getScreenWidth()];
        }

        @Override
        public void setVideoScale(IVideoScale vs) {
            this.vs = vs;
        }

        IVideoScale vs;
    }

    protected interface IPlaneDrawer
            extends IVideoScaleAware {

        void InitPlanes();

        void MapPlane(int y, int x1, int x2);

        void DrawPlanes();

        int[] getDistScale();
        
        /** Sync up in case there's concurrent planes/walls rendering */
        public void sync();

    }

    protected interface ISegDrawer
            extends IVideoScaleAware, ILimitResettable {
        public void ClearClips();

        short[] getBLANKCEILINGCLIP();

        short[] getBLANKFLOORCLIP();

        short[] getFloorClip();

        short[] getCeilingClip();

        void ExecuteSetViewSize(int viewwidth);

        public void setGlobalAngle(long angle1);

        public void StoreWallRange(int first, int last);

        /** If there is anything to do beyond the BPS traversal,
         * e.g. parallel rendering
         */
        public void CompleteRendering();

        /** Sync up in case there's concurrent planes/walls rendering */
        public void sync();
    }

    protected final class Planes
            extends PlaneDrawer<T, V> {

        public Planes(RendererState<T, V> R) {
            super(R);
        }

        /**
         * R_DrawPlanes At the end of each frame. This also means that visplanes
         * must have been set BEFORE we called this function. Therefore, look
         * for errors behind.
         * 
         * @throws IOException
         */

        @Override
        public final void DrawPlanes() {
            if (DEBUG)
                System.out.println(" >>>>>>>>>>>>>>>>>>>>>   DrawPlanes: "
                        + vp_vars.lastvisplane);
            visplane_t pln = null; // visplane_t
            int light;
            int x;
            int stop;
            int angle;

            if (RANGECHECK) {
                rangeCheckErrors();
            }

            for (int pl = 0; pl < vp_vars.lastvisplane; pl++) {
                pln = vp_vars.visplanes[pl];
                if (DEBUG2)
                    System.out.println(pln);

                if (pln.minx > pln.maxx)
                    continue;
                // sky flat
                if (pln.picnum == TexMan.getSkyFlatNum()) {
                    // Cache skytexture stuff here. They aren't going to change
                    // while
                    // being drawn, after all, are they?
                    int skytexture = TexMan.getSkyTexture();
                    skydcvars.dc_texheight =
                        TexMan.getTextureheight(skytexture) >> FRACBITS;
                    skydcvars.dc_iscale =
                        vpvars.getSkyScale() >> view.detailshift;

                    /*
                     * Sky is allways drawn full bright, i.e. colormaps[0] is
                     * used. Because of this hack, sky is not affected by INVUL
                     * inverse mapping.
                     */
                    skydcvars.dc_colormap = colormap.colormaps[0];
                    skydcvars.dc_texturemid = TexMan.getSkyTextureMid();
                    for (x = pln.minx; x <= pln.maxx; x++) {

                        skydcvars.dc_yl = pln.getTop(x);
                        skydcvars.dc_yh = pln.getBottom(x);

                        if (skydcvars.dc_yl <= skydcvars.dc_yh) {
                            angle =
                                (int) (addAngles(view.angle, xtoviewangle[x]) >>> ANGLETOSKYSHIFT);
                            skydcvars.dc_x = x;
                            // Optimized: texheight is going to be the same
                            // during normal skies drawing...right?
                            skydcvars.dc_source =
                                TexMan.GetCachedColumn(skytexture, angle);
                            colfunc.sky.invoke();
                        }
                    }
                    continue;
                }

                // regular flat
                dsvars.ds_source = TexMan.getSafeFlat(pln.picnum);

                planeheight = Math.abs(pln.height - view.z);
                light = (pln.lightlevel >> LIGHTSEGSHIFT) + colormap.extralight;

                if (light >= LIGHTLEVELS)
                    light = LIGHTLEVELS - 1;

                if (light < 0)
                    light = 0;

                planezlight = colormap.zlight[light];

                // We set those values at the border of a plane's top to a
                // "sentinel" value...ok.
                pln.setTop(pln.maxx + 1, visplane_t.SENTINEL);
                pln.setTop(pln.minx - 1, visplane_t.SENTINEL);

                stop = pln.maxx + 1;

                for (x = pln.minx; x <= stop; x++) {
                    MakeSpans(x, pln.getTop(x - 1), pln.getBottom(x - 1),
                        pln.getTop(x), pln.getBottom(x));
                }

                // Z_ChangeTag (ds_source, PU_CACHE);
            }
        }

    } // End Plane class

    // /////////////////////// LIGHTS, POINTERS, COLORMAPS ETC. ////////////////

    // /// FROM R_DATA, R_MAIN , R_DRAW //////////

    /**
     * OK< this is supposed to "peg" into screen buffer 0. It will work AS LONG
     * AS SOMEONE FUCKING ACTUALLY SETS IT !!!!
     */
    protected V screen;

    protected static final boolean RANGECHECK = false;

    /**
     * These are actually offsets inside screen 0 (or any screen). Therefore
     * anything using them should "draw" inside screen 0
     */
    protected int[] ylookup = new int[MAXHEIGHT];

    /** Columns offset to set where?! */
    protected int[] columnofs = new int[MAXWIDTH];

    /**
     * General purpose. Used for solid walls and as an intermediary for
     * threading
     */

    protected ColVars<T, V> dcvars;

    /** Used for spans */

    protected SpanVars<T, V> dsvars;

    // Used for sky drawer, to avoid clashing with shared dcvars
    protected ColVars<T, V> skydcvars;

    /**
     * Masked drawing functions get "pegged" to this set of dcvars, passed upon
     * initialization. However, multi-threaded vars are better off carrying each
     * their own ones.
     */
    protected ColVars<T, V> maskedcvars;

    /**
     * e6y: wide-res Borrowed from PrBoom+;
     */

    /*
     * protected int wide_centerx, wide_ratio, wide_offsetx, wide_offset2x,
     * wide_offsety, wide_offset2y; protected final base_ratio_t[]
     * BaseRatioSizes = { new base_ratio_t(960, 600, 0, 48, 1.333333f), // 4:3
     * new base_ratio_t(1280, 450, 0, 48 * 3 / 4, 1.777777f), // 16:9 new
     * base_ratio_t(1152, 500, 0, 48 * 5 / 6, 1.6f), // 16:10 new
     * base_ratio_t(960, 600, 0, 48, 1.333333f), new base_ratio_t(960, 640,
     * (int) (6.5 * FRACUNIT), 48 * 15 / 16, 1.25f) // 5:4 };
     */

    /** just for profiling purposes */
    protected int framecount;

    protected int sscount;

    protected int linecount;

    protected int loopcount;

    //
    // precalculated math tables
    //
    protected long clipangle;

    // Set to 2*clipangle later.
    protected long CLIPANGLE2;

    // The viewangletox[viewangle + FINEANGLES/4] lookup
    // maps the visible view angles to screen X coordinates,
    // flattening the arc to a flat projection plane.
    // There will be many angles mapped to the same X.

    protected final int[] viewangletox = new int[FINEANGLES / 2];

    /**
     * The xtoviewangle[] table maps a screen pixel to the lowest viewangle that
     * maps back to x ranges from clipangle to -clipangle.
     */
    protected long[] xtoviewangle;// MAES: to resize

    // UNUSED.
    // The finetangentgent[angle+FINEANGLES/4] table
    // holds the fixed_t tangent values for view angles,
    // ranging from MININT to 0 to MAXINT.
    // fixed_t finetangent[FINEANGLES/2];

    // fixed_t finesine[5*FINEANGLES/4];
    // MAES: uh oh. So now all these ints must become finesines? fuck that.
    // Also wtf @ this hack....this points to approx 1/4th of the finesine
    // table, but what happens if I read past it?
    // int[] finecosine = finesine[FINEANGLES/4];

    /*
     * MAES: what's going on with light tables here. OK...so these should be
     * "unsigned bytes", since, after all, they'll be used as pointers inside an
     * array to finally pick a color, so they should be expanded to shorts.
     */

    // //////////// SOME UTILITY METHODS /////////////

    /**
     * Assigns a point of view before calling PointToAngle CAREFUL: this isn't a
     * pure function, as it alters the renderer's state!
     */

    public final long PointToAngle2(int x1, int y1, int x2, int y2) {
        // Careful with assignments...
        view.x = x1;
        view.y = y1;

        return view.PointToAngle(x2, y2);
    }

    //
    // R_InitPointToAngle
    //
    /*
     * protected final void InitPointToAngle () { // UNUSED - now getting from
     * tables.c if (false){ int i; long t; float f; // // slope (tangent) to
     * angle lookup // for (i=0 ; i<=SLOPERANGE ; i++) { f = (float) Math.atan(
     * (double)(i/SLOPERANGE )/(3.141592657*2)); t = (long) (0xffffffffL*f);
     * tantoangle[i] = (int) t; } } }
     */

    /**
     * Public, static, stateless version of PointToAngle2. Call this one when
     * "renderless" use of PointToAngle2 is required.
     */

    public final static long PointToAngle(int viewx, int viewy, int x, int y) {
        // MAES: note how we don't use &BITS32 here. That is because
        // we know that the maximum possible value of tantoangle is angle
        // This way, we are actually working with vectors emanating
        // from our current position.
        x -= viewx;
        y -= viewy;

        if ((x == 0) && (y == 0))
            return 0;

        if (x >= 0) {
            // x >=0
            if (y >= 0) {
                // y>= 0

                if (x > y) {
                    // octant 0
                    return tantoangle[SlopeDiv(y, x)];
                } else {
                    // octant 1
                    return (ANG90 - 1 - tantoangle[SlopeDiv(x, y)]);
                }
            } else {
                // y<0
                y = -y;

                if (x > y) {
                    // octant 8
                    return (-tantoangle[SlopeDiv(y, x)]);
                } else {
                    // octant 7
                    return (ANG270 + tantoangle[SlopeDiv(x, y)]);
                }
            }
        } else {
            // x<0
            x = -x;

            if (y >= 0) {
                // y>= 0
                if (x > y) {
                    // octant 3
                    return (ANG180 - 1 - tantoangle[SlopeDiv(y, x)]);
                } else {
                    // octant 2
                    return (ANG90 + tantoangle[SlopeDiv(x, y)]);
                }
            } else {
                // y<0
                y = -y;

                if (x > y) {
                    // octant 4
                    return (ANG180 + tantoangle[SlopeDiv(y, x)]);
                } else {
                    // octant 5
                    return (ANG270 - 1 - tantoangle[SlopeDiv(x, y)]);
                }
            }
        }
        // This is actually unreachable.
        // return 0;
    }

    //
    // R_InitTables
    //
    protected final void InitTables() {
        // UNUSED: now getting from tables.c
        /*
         * int i; float a; float fv; int t; // viewangle tangent table for (i=0
         * ; i<FINEANGLES/2 ; i++) { a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES;
         * fv = FRACUNIT*tan (a); t = fv; finetangent[i] = t; } // finesine
         * table for (i=0 ; i<5*FINEANGLES/4 ; i++) { // OPTIMIZE: mirro.. a =
         * (i+0.5)*PI*2/FINEANGLES; t = FRACUNIT*sin (a); finesine[i] = t; }
         */

    }

    /**
     * R_PointToDist
     * 
     * @param x
     *        fixed_t
     * @param y
     *        fixed_t
     * @return
     */

    protected final int PointToDist(int x, int y) {
        int angle;
        int dx;
        int dy;
        int temp;
        int dist;

        dx = Math.abs(x - view.x);
        dy = Math.abs(y - view.y);

        // If something is farther north/south than west/east, it gets swapped.
        // Probably as a crude way to avoid divisions by zero. This divides
        // the field into octants, rather than quadrants, where the biggest
        // angle to
        // consider is 45...right? So dy/dx can never exceed 1.0, in theory.

        if (dy > dx) {
            temp = dx;
            dx = dy;
            dy = temp;
        }

        // If one or both of the distances are *exactly* zero at this point,
        // then this means that the wall is in your face anyway, plus we want to
        // avoid a division by zero. So you get zero.
        if (dx == 0)
            return 0;

        /*
         * If dx is zero, this is going to bomb. Fixeddiv will return MAXINT aka
         * 7FFFFFFF, >> DBITS will make it 3FFFFFF, which is more than enough to
         * break tantoangle[]. In the original C code, this probably didn't
         * matter: there would probably be garbage orientations thrown all
         * around. However this is unacceptable in Java. OK, so the safeguard
         * above prevents that. Still... this method is only called once per
         * visible wall per frame, so one check more or less at this point won't
         * change much. It's better to be safe than sorry.
         */

        // This effectively limits the angle to
        // angle = Math.max(FixedDiv(dy, dx), 2048) >> DBITS;
        angle = (FixedDiv(dy, dx) & 0x1FFFF) >> DBITS;

        // Since the division will be 0xFFFF at most, DBITS will restrict
        // the maximum angle index to 7FF, about 45, so adding ANG90 with
        // no other safeguards is OK.
        angle = (int) ((tantoangle[angle] + ANG90) >> ANGLETOFINESHIFT);

        // use as cosine
        dist = FixedDiv(dx, finesine[angle]);

        return dist;
    }

    // //////////// COMMON RENDERING GLOBALS ////////////////

    // //////////////// COLUMN AND SPAN FUNCTIONS //////////////

    protected ColFuncs<T, V> colfunc;

    // Keep two sets of functions.
    protected ColFuncs<T, V> colfunchi;

    protected ColFuncs<T, V> colfunclow;

    protected final void setHiColFuns() {
        colfunchi.main = colfunchi.base = DrawColumn;
        colfunchi.masked = DrawColumnMasked;
        colfunchi.fuzz = DrawFuzzColumn;
        colfunchi.trans = DrawTranslatedColumn;
        colfunchi.glass = DrawTLColumn;
        colfunchi.player = DrawColumnPlayer;
        colfunchi.sky = DrawColumnSkies;
    }

    protected final void setLowColFuns() {
        colfunclow.main = colfunclow.base = DrawColumnLow;
        colfunclow.masked = DrawColumnMaskedLow;
        colfunclow.fuzz = DrawFuzzColumnLow;
        colfunclow.trans = DrawTranslatedColumnLow;
        colfunclow.glass = DrawTLColumn;
        colfunclow.player = DrawColumnMaskedLow;
        colfunclow.sky = DrawColumnSkiesLow;
    }
    
    public ColFuncs<T,V> getColFuncsHi(){
        return this.colfunchi;
    }
   
    public ColFuncs<T,V> getColFuncsLow(){
        return this.colfunclow;
    }
    
    public ColVars<T, V> getMaskedDCVars(){
        return this.maskedcvars;
    }
    
    
    // These column functions are "fixed" for a given renderer, and are
    // not used directly, but only after passing them to colfuncs

    protected DoomColumnFunction<T, V> DrawTranslatedColumn;

    protected DoomColumnFunction<T, V> DrawTranslatedColumnLow;

    protected DoomColumnFunction<T, V> DrawColumnPlayer;

    protected DoomColumnFunction<T, V> DrawColumnSkies;

    protected DoomColumnFunction<T, V> DrawColumnSkiesLow;

    protected DoomColumnFunction<T, V> DrawFuzzColumn;

    protected DoomColumnFunction<T, V> DrawFuzzColumnLow;

    protected DoomColumnFunction<T, V> DrawColumn;

    protected DoomColumnFunction<T, V> DrawColumnLow;

    protected DoomColumnFunction<T, V> DrawColumnMasked;

    protected DoomColumnFunction<T, V> DrawColumnMaskedLow;

    protected DoomColumnFunction<T, V> DrawTLColumn;

    /** to be set in UnifiedRenderer */
    protected DoomSpanFunction<T, V> DrawSpan, DrawSpanLow;

    // ////////////// r_draw methods //////////////

    /**
     * Copy a screen buffer. Actually, it's hardcoded to copy stuff from screen
     * 1 to screen 0. Used to overlay stuff like beveled edges that don't need
     * to be updated that often. * LFB copy. This might not be a good idea if
     * memcpy is not optiomal, e.g. byte by byte on a 32bit CPU, as GNU
     * GCC/Linux libc did at one point.
     */
    public void VideoErase(int ofs, int count) {

        // memcpy (screens[0]+ofs, screens[1]+ofs, count);
        System.arraycopy(V.getScreen(DoomVideoRenderer.SCREEN_BG), ofs,
            V.getScreen(DoomVideoRenderer.SCREEN_FG), ofs, count);

    }

    /*
     * R_DrawViewBorder Draws the border around the view for different size
     * windows?
     */

    public void DrawViewBorder() {
        int top;
        int side;
        int ofs;
        int i;

        if (view.scaledwidth == SCREENWIDTH)
            return;

        top = ((SCREENHEIGHT - DM.ST.getHeight()) - view.height) / 2;
        side = (SCREENWIDTH - view.scaledwidth) / 2;

        // copy top and one line of left side
        this.VideoErase(0, top * SCREENWIDTH + side);

        // copy one line of right side and bottom
        ofs = (view.height + top) * SCREENWIDTH - side;
        this.VideoErase(ofs, top * SCREENWIDTH + side);

        // copy sides using wraparound
        ofs = top * SCREENWIDTH + SCREENWIDTH - side;
        side <<= 1;

        for (i = 1; i < view.height; i++) {
            this.VideoErase(ofs, side);
            ofs += SCREENWIDTH;
        }

        // ?
        V.MarkRect(0, 0, SCREENWIDTH, SCREENHEIGHT - DM.ST.getHeight());
    }

    public void ExecuteSetViewSize() {
        int cosadj;
        int dy;
        int i;
        int j;
        int level;
        int startmap;

        setsizeneeded = false;

        // 11 Blocks means "full screen"

        if (setblocks == 11) {
            view.scaledwidth = SCREENWIDTH;
            view.height = SCREENHEIGHT;
        } else {
            view.scaledwidth = setblocks * (SCREENWIDTH / 10);
            // Height can only be a multiple of 8.
            view.height =
                (short) ((setblocks * (SCREENHEIGHT - DM.ST.getHeight()) / 10) & ~7);
        }

        skydcvars.viewheight =
            maskedcvars.viewheight = dcvars.viewheight = view.height;

        view.detailshift = setdetail;
        view.width = view.scaledwidth >> view.detailshift;

        view.centery = view.height / 2;
        view.centerx = view.width / 2;
        view.centerxfrac = (view.centerx << FRACBITS);
        view.centeryfrac = (view.centery << FRACBITS);
        view.projection = view.centerxfrac;

        skydcvars.centery = maskedcvars.centery = dcvars.centery = view.centery;

        // High detail
        if (view.detailshift == 0) {

            colfunc = colfunchi;
            dsvars.spanfunc = DrawSpan;
        } else {
            // Low detail
            colfunc = colfunclow;
            dsvars.spanfunc = DrawSpanLow;

        }

        InitBuffer(view.scaledwidth, view.height);

        InitTextureMapping();

        // psprite scales
        // pspritescale = FRACUNIT*viewwidth/SCREENWIDTH;
        // pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;

        MyThings.setPspriteScale((int) (FRACUNIT
                * ((float) SCREEN_MUL * view.width) / SCREENWIDTH));
        MyThings.setPspriteIscale((int) (FRACUNIT * (SCREENWIDTH / (view.width * (float) SCREEN_MUL))));
        vp_vars.setSkyScale((int) (FRACUNIT * (SCREENWIDTH / (view.width * (float) SCREEN_MUL))));

        view.BOBADJUST = (int) (this.vs.getSafeScaling() << 15);
        view.WEAPONADJUST = (int) ((SCREENWIDTH / (2 * SCREEN_MUL)) * FRACUNIT);

        // thing clipping
        for (i = 0; i < view.width; i++)
            view.screenheightarray[i] = (short) view.height;

        // planes
        for (i = 0; i < view.height; i++) {
            dy = ((i - view.height / 2) << FRACBITS) + FRACUNIT / 2;
            dy = Math.abs(dy);
            vp_vars.yslope[i] =
                FixedDiv((view.width << view.detailshift) / 2 * FRACUNIT, dy);
            // MyPlanes.yslopef[i] = ((viewwidth<<detailshift)/2)/ dy;
        }

        // double cosadjf;
        for (i = 0; i < view.width; i++) {
            // MAES: In this spot we must interpet it as SIGNED, else it's
            // pointless, right?
            // MAES: this spot caused the "warped floor bug", now fixed. Don't
            // forget xtoviewangle[i]!
            cosadj = Math.abs(finecosine(xtoviewangle[i]));
            // cosadjf =
            // Math.abs(Math.cos((double)xtoviewangle[i]/(double)0xFFFFFFFFL));
            MyPlanes.getDistScale()[i] = FixedDiv(FRACUNIT, cosadj);
            // MyPlanes.distscalef[i] = (float) (1.0/cosadjf);
        }

        // Calculate the light levels to use
        // for each level / scale combination.
        for (i = 0; i < LIGHTLEVELS; i++) {
            startmap = ((LIGHTLEVELS-LIGHTBRIGHT-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
            for (j = 0; j < MAXLIGHTSCALE; j++) {
                level =
                    startmap - j/ DISTMAP;
                if (level < 0)
                    level = 0;
                if (level >= NUMCOLORMAPS)
                    level = NUMCOLORMAPS - 1;
                colormaps.scalelight[i][j] = colormaps.colormaps[level];
            }
        }

        MySegs.ExecuteSetViewSize(view.width);

    }

    /**
     * R_FillBackScreen Fills the back screen with a pattern for variable screen
     * sizes Also draws a beveled edge. This is actually stored in screen 1, and
     * is only OCCASIONALLY written to screen 0 (the visible one) by calling
     * R_VideoErase.
     */

    public void FillBackScreen() {
        flat_t src;
        int x;
        int y;
        patch_t patch;

        // DOOM border patch.
        String name1 = "FLOOR7_2";

        // DOOM II border patch.
        String name2 = "GRNROCK";

        String name;

        if (view.scaledwidth == SCREENWIDTH)
            return;

        if (DM.isCommercial())
            name = name2;
        else
            name = name1;

        /* This is a flat we're reading here */
        src = (flat_t) (W.CacheLumpName(name, PU_CACHE, flat_t.class));

        /*
         * This part actually draws the border itself, without bevels MAES:
         * improved drawing routine for extended bit-depth compatibility.
         */

        for (y = 0; y < SCREENHEIGHT - DM.ST.getHeight(); y += 64) {

            int y_maxdraw = Math.min(SCREENHEIGHT - DM.ST.getHeight() - y, 64);

            // Draw whole blocks.
            for (x = 0; x < SCREENWIDTH; x += 64) {
                int x_maxdraw = Math.min(SCREENWIDTH - x, 64);
                V.DrawBlock(x, y, DoomVideoRenderer.SCREEN_BG, x_maxdraw,
                    y_maxdraw, (T) src.data);
            }
        }

        patch = (patch_t) W.CachePatchName("BRDR_T", PU_CACHE);

        for (x = 0; x < view.scaledwidth; x += 8)
            V.DrawPatch(view.windowx + x, view.windowy - 8, 1, patch);
        patch = (patch_t) W.CachePatchName("BRDR_B", PU_CACHE);

        for (x = 0; x < view.scaledwidth; x += 8)
            V.DrawPatch(view.windowx + x, view.windowy + view.height, 1, patch);
        patch = (patch_t) W.CachePatchName("BRDR_L", PU_CACHE);

        for (y = 0; y < view.height; y += 8)
            V.DrawPatch(view.windowx - 8, view.windowy + y, 1, patch);
        patch = (patch_t) W.CachePatchName("BRDR_R", PU_CACHE);

        for (y = 0; y < view.height; y += 8)
            V.DrawPatch(view.windowx + view.scaledwidth, view.windowy + y, 1,
                patch);

        // Draw beveled edge. Top-left
        V.DrawPatch(view.windowx - 8, view.windowy - 8, 1,
            (patch_t) W.CachePatchName("BRDR_TL", PU_CACHE));

        // Top-right.
        V.DrawPatch(view.windowx + view.scaledwidth, view.windowy - 8, 1,
            (patch_t) W.CachePatchName("BRDR_TR", PU_CACHE));

        // Bottom-left
        V.DrawPatch(view.windowx - 8, view.windowy + view.height, 1,
            (patch_t) W.CachePatchName("BRDR_BL", PU_CACHE));
        // Bottom-right.
        V.DrawPatch(view.windowx + view.width, view.windowy + view.height, 1,
            (patch_t) W.CachePatchName("BRDR_BR", PU_CACHE));
    }

    /**
     * R_Init
     */

    public void Init()

    {
        // Any good reason for this to be here?
        // drawsegs=new drawseg_t[MAXDRAWSEGS];
        // C2JUtils.initArrayOfObjects(drawsegs);

        // DON'T FORGET ABOUT MEEEEEE!!!11!!!
        this.screen = this.V.getScreen(DoomVideoRenderer.SCREEN_FG);

        System.out.print("\nR_InitData");
        InitData();
        // InitPointToAngle ();
        System.out.print("\nR_InitPointToAngle");

        // ds.DM.viewwidth / ds.viewheight / detailLevel are set by the defaults
        System.out.print("\nR_InitTables");
        InitTables();

        SetViewSize(DM.M.getScreenBlocks(), DM.M.getDetailLevel());

        System.out.print("\nR_InitPlanes");
        MyPlanes.InitPlanes();

        System.out.print("\nR_InitLightTables");
        InitLightTables();

        System.out.print("\nR_InitSkyMap: " + TexMan.InitSkyMap());

        System.out.print("\nR_InitTranslationsTables");
        InitTranslationTables();

        System.out.print("\nR_InitTranMap: ");
        R_InitTranMap(0);

        System.out.print("\nR_InitDrawingFunctions: ");
        R_InitDrawingFunctions();
        
        framecount = 0;
    }        
    
    /**
     * R_InitBuffer Creates lookup tables that avoid multiplies and other
     * hazzles for getting the framebuffer address of a pixel to draw. MAES:
     * this is "pinned" to screen[0] of a Video Renderer. We will handle this
     * differently elsewhere...
     */

    protected final void InitBuffer(int width, int height) {
        int i;

        // Handle resize,
        // e.g. smaller view windows
        // with border and/or status bar.
        view.windowx = (SCREENWIDTH - width) >> 1;

        // Column offset. For windows.
        for (i = 0; i < width; i++)
            columnofs[i] = view.windowx + i;

        // SamE with base row offset.
        if (width == SCREENWIDTH)
            view.windowy = 0;
        else
            view.windowy = (SCREENHEIGHT - DM.ST.getHeight() - height) >> 1;

        // Preclaculate all row offsets.
        for (i = 0; i < height; i++)
            ylookup[i] = /* screens[0] + */(i + view.windowy) * SCREENWIDTH;
    }

    /**
     * R_InitTextureMapping Not moved into the TextureManager because it's
     * tighly coupled to the visuals, rather than textures. Perhaps the name is
     * not the most appropriate.
     */
    protected final void InitTextureMapping() {
        int i, x, t;
        int focallength; // fixed_t
        int fov = FIELDOFVIEW;

        // For widescreen displays, increase the FOV so that the middle part of
        // the
        // screen that would be visible on a 4:3 display has the requested FOV.
        /*
         * UNUSED if (wide_centerx != centerx) { // wide_centerx is what centerx
         * would be // if the display was not widescreen fov = (int)
         * (Math.atan((double) centerx Math.tan((double) fov * Math.PI /
         * FINEANGLES) / (double) wide_centerx) FINEANGLES / Math.PI); if (fov >
         * 130 * FINEANGLES / 360) fov = 130 * FINEANGLES / 360; }
         */

        // Use tangent table to generate viewangletox:
        // viewangletox will give the next greatest x
        // after the view angle.
        //
        // Calc focallength
        // so FIELDOFVIEW angles covers SCREENWIDTH.
        focallength =
            FixedDiv(view.centerxfrac, finetangent[QUARTERMARK + FIELDOFVIEW
                    / 2]);

        for (i = 0; i < FINEANGLES / 2; i++) {
            if (finetangent[i] > FRACUNIT * 2)
                t = -1;
            else if (finetangent[i] < -FRACUNIT * 2)
                t = view.width + 1;
            else {
                t = FixedMul(finetangent[i], focallength);
                t = (view.centerxfrac - t + FRACUNIT - 1) >> FRACBITS;

                if (t < -1)
                    t = -1;
                else if (t > view.width + 1)
                    t = view.width + 1;
            }
            viewangletox[i] = t;
        }

        // Scan viewangletox[] to generate xtoviewangle[]:
        // xtoviewangle will give the smallest view angle
        // that maps to x.
        for (x = 0; x <= view.width; x++) {
            i = 0;
            while (viewangletox[i] > x)
                i++;
            xtoviewangle[x] = addAngles((i << ANGLETOFINESHIFT), -ANG90);
        }

        // Take out the fencepost cases from viewangletox.
        for (i = 0; i < FINEANGLES / 2; i++) {
            t = FixedMul(finetangent[i], focallength);
            t = view.centerx - t;

            if (viewangletox[i] == -1)
                viewangletox[i] = 0;
            else if (viewangletox[i] == view.width + 1)
                viewangletox[i] = view.width;
        }

        clipangle = xtoviewangle[0];
        // OPTIMIZE: assign constant for optimization.
        CLIPANGLE2 = (2 * clipangle) & BITS32;
    }

    //
    // R_InitLightTables
    // Only inits the zlight table,
    // because the scalelight table changes with view size.
    //
    protected final static int DISTMAP = 2;

    protected final void InitLightTables() {
        int i;
        int j;
        int startmap;
        int scale;

        // Calculate the light levels to use
        // for each level / distance combination.
        for (i = 0; i < LIGHTLEVELS; i++) {
            startmap = ((LIGHTLEVELS - LIGHTBRIGHT - i) * 2) * NUMCOLORMAPS / LIGHTLEVELS;
            for (j = 0; j < MAXLIGHTZ; j++) {
                // CPhipps - use 320 here instead of SCREENWIDTH, otherwise hires is
                //           brighter than normal res
                
                scale = FixedDiv((320 / 2 * FRACUNIT), (j + 1) << LIGHTZSHIFT);
                int t, level = startmap - (scale >>= LIGHTSCALESHIFT)/DISTMAP;

                if (level < 0)
                    level = 0;

                if (level >= NUMCOLORMAPS)
                    level = NUMCOLORMAPS - 1;

                // zlight[i][j] = colormaps + level*256;
                colormaps.zlight[i][j] = colormaps.colormaps[level];
            }
        }
    }

    protected static final int TSC = 12; /*
                                          * number of fixed point digits in
                                          * filter percent
                                          */

    byte[] main_tranmap;

    /**
     * A faster implementation of the tranmap calculations. Almost 10x faster
     * than the old one!
     * 
     * @param progress
     */

    protected void R_InitTranMap(int progress) {
        int lump = W.CheckNumForName("TRANMAP");

        long ta = System.nanoTime();
        int p;
        String tranmap;

        // PRIORITY: a map file has been specified from commandline. Try to read
        // it. If OK, this trumps even those specified in lumps.

        if ((p = DM.CM.CheckParm("-tranmap")) != 0) {
            if ((tranmap = DM.CM.getArgv(p + 1)) != null) {
                if (C2JUtils.testReadAccess(tranmap)) {
                    System.out
                            .printf(
                                "Translucency map file %s specified in -tranmap arg. Attempting to use...\n",
                                tranmap);
                    main_tranmap = new byte[256 * 256]; // killough 4/11/98
                    int result = MenuMisc.ReadFile(tranmap, main_tranmap);
                    if (result > 0)
                        return;
                    System.out.print("...failure.\n");
                }
            }
        }

        // Next, if a tranlucency filter map lump is present, use it
        if (lump != -1) { // Set a pointer to the translucency filter maps.
            System.out
                    .print("Translucency map found in lump. Attempting to use...");
            // main_tranmap=new byte[256*256]; // killough 4/11/98
            main_tranmap = W.CacheLumpNumAsRawBytes(lump, Defines.PU_STATIC); // killough
                                                                              // 4/11/98
            // Tolerate 64K or more.
            if (main_tranmap.length >= 0x10000)
                return;
            System.out.print("...failure.\n"); // Not good, try something else.
        }

        // A default map file already exists. Try to read it.
        if (C2JUtils.testReadAccess("tranmap.dat")) {
            System.out
                    .print("Translucency map found in default tranmap.dat file. Attempting to use...");
            main_tranmap = new byte[256 * 256]; // killough 4/11/98
            int result = MenuMisc.ReadFile("tranmap.dat", main_tranmap);
            if (result > 0)
                return; // Something went wrong, so fuck that.
        }

        // Nothing to do, so we must synthesize it from scratch. And, boy, is it
        // slooow.
        { // Compose a default transparent filter map based on PLAYPAL.
            System.out
                    .print("Computing translucency map from scratch...that's gonna be SLOW...");
            byte[] playpal =
                W.CacheLumpNameAsRawBytes("PLAYPAL", Defines.PU_STATIC);
            main_tranmap = new byte[256 * 256]; // killough 4/11/98
            int[] basepal = new int[3 * 256];
            int[] mixedpal = new int[3 * 256 * 256];

            main_tranmap = new byte[256 * 256];

            // Init array of base colors.
            for (int i = 0; i < 256; i++) {
                basepal[3 * i] = 0Xff & playpal[i * 3];
                basepal[1 + 3 * i] = 0Xff & playpal[1 + i * 3];
                basepal[2 + 3 * i] = 0Xff & playpal[2 + i * 3];
            }

            // Init array of mixed colors. These are true RGB.
            // The diagonal of this array will be the original colors.

            for (int i = 0; i < 256 * 3; i += 3) {
                for (int j = 0; j < 256 * 3; j += 3) {
                    mixColors(basepal, basepal, mixedpal, i, j, j * 256 + i);

                }
            }

            // Init distance map. Every original palette colour has a
            // certain distance from all the others. The diagonal is zero.
            // The interpretation is that e.g. the mixture of color 2 and 8 will
            // have a RGB value, which is closest to euclidean distance to
            // e.g. original color 9. Therefore we should put "9" in the (2,8)
            // and (8,2) cells of the tranmap.

            final float[] tmpdist = new float[256];

            for (int a = 0; a < 256; a++) {
                for (int b = a; b < 256; b++) {
                    // We evaluate the mixture of a and b
                    // Construct distance table vs all of the ORIGINAL colors.
                    for (int k = 0; k < 256; k++) {
                        tmpdist[k] =
                            colorDistance(mixedpal, basepal, 3 * (a + b * 256),
                                k * 3);
                    }

                    main_tranmap[(a << 8) | b] = (byte) findMin(tmpdist);
                    main_tranmap[(b << 8) | a] = main_tranmap[(a << 8) | b];
                }
            }
            System.out.print("...done\n");
            if (MenuMisc.WriteFile("tranmap.dat", main_tranmap,
                main_tranmap.length))
                System.out
                        .print("TRANMAP.DAT saved to disk for your convenience! Next time will be faster.\n");
        }
        long b = System.nanoTime();

        System.out.printf("Tranmap %d\n", (b - ta) / 1000000);
    }

    /** Mixes two RGB colors. Nuff said */

    protected final void mixColors(int[] a, int[] b, int[] c, int pa, int pb,
            int pc) {
        c[pc] = (a[pa] + b[pb]) / 2;
        c[pc + 1] = (a[pa + 1] + b[pb + 1]) / 2;
        c[pc + 2] = (a[pa + 2] + b[pb + 2]) / 2;

    }

    /** Returns the euclidean distance of two RGB colors. Nuff said */

    protected final float colorDistance(int[] a, int[] b, int pa, int pb) {
        return (float) Math.sqrt((a[pa] - b[pb]) * (a[pa] - b[pb])
                + (a[pa + 1] - b[pb + 1]) * (a[pa + 1] - b[pb + 1])
                + (a[pa + 2] - b[pb + 2]) * (a[pa + 2] - b[pb + 2]));
    }

    
    /** Stuff that is trivially initializable, even with generics,
     *  but is only safe to do after all constructors have completed.
     */
    
    protected final void completeInit(){
        this.detailaware.add(MyThings);        
    }
    
    protected final int findMin(float[] a) {
        int minindex = 0;
        float min = Float.POSITIVE_INFINITY;

        for (int i = 0; i < a.length; i++)
            if (a[i] < min) {
                min = a[i];
                minindex = i;
            }

        return minindex;

    }

    /**
     * R_DrawMaskedColumnSinglePost. Used to handle some special cases where
     * cached columns get used as "masked" middle textures. Will be treated as a
     * single-run post of capped length.
     */

    /*
     * protected final void DrawCompositeColumnPost(byte[] column) { int
     * topscreen; int bottomscreen; int basetexturemid; // fixed_t int
     * topdelta=0; // Fixed value int length; basetexturemid = dc_texturemid; //
     * That's true for the whole column. dc_source = column; // for each post...
     * while (topdelta==0) { // calculate unclipped screen coordinates // for
     * post topscreen = sprtopscreen + spryscale * 0; length = column.length;
     * bottomscreen = topscreen + spryscale * length; dc_yl = (topscreen +
     * FRACUNIT - 1) >> FRACBITS; dc_yh = (bottomscreen - 1) >> FRACBITS; if
     * (dc_yh >= mfloorclip[p_mfloorclip + dc_x]) dc_yh =
     * mfloorclip[p_mfloorclip + dc_x] - 1; if (dc_yl <=
     * mceilingclip[p_mceilingclip + dc_x]) dc_yl = mceilingclip[p_mceilingclip
     * + dc_x] + 1; // killough 3/2/98, 3/27/98: Failsafe against
     * overflow/crash: if (dc_yl <= dc_yh && dc_yh < viewheight) { // Set
     * pointer inside column to current post's data // Rremember, it goes
     * {postlen}{postdelta}{pad}[data]{pad} dc_source_ofs = 0; // pointer + 3;
     * dc_texturemid = basetexturemid - (topdelta << FRACBITS); // Drawn by
     * either R_DrawColumn // or (SHADOW) R_DrawFuzzColumn. dc_texheight=0; //
     * Killough try { maskedcolfunc.invoke(); } catch (Exception e){
     * System.err.printf("Error rendering %d %d %d\n", dc_yl,dc_yh,dc_yh-dc_yl);
     * } } topdelta--; } dc_texturemid = basetexturemid; }
     */

    protected abstract void InitColormaps()
            throws IOException;

    // Only used b
    protected byte[] BLURRY_MAP;

    /**
     * R_InitData Locates all the lumps that will be used by all views Must be
     * called after W_Init.
     */

    public void InitData() {
        try {
            System.out.print("\nInit Texture and Flat Manager");
            TexMan = this.DM.TM;
            System.out.print("\nInitTextures");
            TexMan.InitTextures();
            System.out.print("\nInitFlats");
            TexMan.InitFlats();
            System.out.print("\nInitSprites");
            SM.InitSpriteLumps();
            MyThings.cacheSpriteManager(SM);
            VIS.cacheSpriteManager(SM);
            System.out.print("\nInitColormaps");
            InitColormaps();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    protected int spritememory;

    /**
     * To be called right after PrecacheLevel from SetupLevel in LevelLoader.
     * It's an ugly hack, in that it must communicate with the "Game map" class
     * and determine what kinds of monsters are actually in the level and
     * whether it should load their graphics or not. Whenever we implement it,
     * it's going to be ugly and not neatly separated anyway.
     * 
     * @return
     */
    public void PreCacheThinkers() {

        boolean[] spritepresent;
        thinker_t th;
        spriteframe_t sf;
        int i, j, k;
        int lump;

        final spritedef_t[] sprites = SM.getSprites();
        final int numsprites = SM.getNumSprites();

        spritepresent = new boolean[numsprites];

        for (th = P.getThinkerCap().next; th != P.getThinkerCap(); th = th.next) {
            if (th.function == think_t.P_MobjThinker)
                spritepresent[((mobj_t) th).sprite.ordinal()] = true;
        }

        spritememory = 0;
        for (i = 0; i < numsprites; i++) {
            if (!spritepresent[i])
                continue;

            for (j = 0; j < sprites[i].numframes; j++) {
                sf = sprites[i].spriteframes[j];
                for (k = 0; k < 8; k++) {
                    lump = SM.getFirstSpriteLump() + sf.lump[k];
                    spritememory += W.GetLumpInfo(lump).size;
                    W.CacheLumpNum(lump, PU_CACHE, patch_t.class);
                }
            }
        }
    }

    /**
     * R_InitTranslationTables Creates the translation tables to map the green
     * color ramp to gray, brown, red. Assumes a given structure of the PLAYPAL.
     * Could be read from a lump instead.
     */

    protected final void InitTranslationTables() {
        int i;

        final int TR_COLORS = 28;

        // translationtables = Z_Malloc (256*3+255, PU_STATIC, 0);
        // translationtables = (byte *)(( (int)translationtables + 255 )& ~255);
        byte[][] translationtables =
            colormaps.translationtables = new byte[TR_COLORS][256];

        // translate just the 16 green colors
        for (i = 0; i < 256; i++) {
            translationtables[0][i] = (byte) i;

            if (i >= 0x70 && i <= 0x7f) {
                // Remap green range to other ranges.
                translationtables[1][i] = (byte) (0x60 + (i & 0xf)); // gray
                translationtables[2][i] = (byte) (0x40 + (i & 0xf)); // brown
                translationtables[3][i] = (byte) (0x20 + (i & 0xf)); // red
                translationtables[4][i] = (byte) (0x10 + (i & 0xf)); // pink
                translationtables[5][i] = (byte) (0x30 + (i & 0xf)); // skin
                translationtables[6][i] = (byte) (0x50 + (i & 0xf)); // metal
                translationtables[7][i] = (byte) (0x80 + (i & 0xf)); // copper
                translationtables[8][i] = (byte) (0xB0 + (i & 0xf)); // b.red
                translationtables[9][i] = (byte) (0xC0 + (i & 0xf)); // electric
                                                                     // blue
                translationtables[10][i] = (byte) (0xD0 + (i & 0xf)); // guantanamo
                // "Halfhue" colors for which there are only 8 distinct hues
                translationtables[11][i] = (byte) (0x90 + (i & 0xf) / 2); // brown2
                translationtables[12][i] = (byte) (0x98 + (i & 0xf) / 2); // gray2
                translationtables[13][i] = (byte) (0xA0 + (i & 0xf) / 2); // piss
                translationtables[14][i] = (byte) (0xA8 + (i & 0xf) / 2); // gay
                translationtables[15][i] = (byte) (0xE0 + (i & 0xf) / 2); // yellow
                translationtables[16][i] = (byte) (0xE8 + (i & 0xf) / 2); // turd
                translationtables[17][i] = (byte) (0xF0 + (i & 0xf) / 2); // compblue
                translationtables[18][i] = (byte) (0xF8 + (i & 0xf) / 2); // whore
                translationtables[19][i] = (byte) (0x05 + (i & 0xf) / 2); // nigga
                // "Pimped up" colors, using mixed hues.
                translationtables[20][i] = (byte) (0x90 + (i & 0xf)); // soldier
                translationtables[21][i] = (byte) (0xA0 + (i & 0xf)); // drag
                                                                      // queen
                translationtables[22][i] = (byte) (0xE0 + (i & 0xf)); // shit &
                                                                      // piss
                translationtables[23][i] = (byte) (0xF0 + (i & 0xf)); // raver
                translationtables[24][i] = (byte) (0x70 + (0xf - i & 0xf)); // inv.marine
                translationtables[25][i] = (byte) (0xF0 + (0xf - i & 0xf)); // inv.raver
                translationtables[26][i] = (byte) (0xE0 + (0xf - i & 0xf)); // piss
                                                                            // &
                                                                            // shit
                translationtables[27][i] = (byte) (0xA0 + (i & 0xf)); // shitty
                                                                      // gay
            } else {
                for (int j = 1; j < TR_COLORS; j++)
                    // Keep all other colors as is.
                    translationtables[j][i] = (byte) i;
            }
        }
    }

    // ///////////////// Generic rendering methods /////////////////////

    public IMaskedDrawer<T, V> getThings() {
        return this.MyThings;        
    }

    /**
     * e6y: this is a precalculated value for more precise flats drawing (see
     * R_MapPlane) "Borrowed" from PrBoom+
     */
    protected float viewfocratio;

    protected int projectiony;

    // Some more isolation methods....

    public final int getValidCount() {
        return validcount;
    }

    public final void increaseValidCount(int amount) {
        validcount += amount;
    }

    public boolean getSetSizeNeeded() {
        return setsizeneeded;
    }

    @Override
    public TextureManager<T> getTextureManager() {
        return TexMan;
    }

    public PlaneDrawer<T, V> getPlaneDrawer() {
        return this.MyPlanes;
    }

    public ViewVars getView() {
        return this.view;
    }

    public SpanVars<T, V> getDSVars() {
        return this.dsvars;
    }

    public LightsAndColors<V> getColorMap() {
        return this.colormaps;
    }

    public IDoomSystem getDoomSystem() {
        return this.I;
    }

    public Visplanes getVPVars() {
        return this.vp_vars;
    }

    @Override
    public SegVars getSegVars() {
        return this.seg_vars;
    }

    public IWadLoader getWadLoader() {
        return this.W;
    }
    
    public ISpriteManager getSpriteManager(){
        return this.SM;
    }

    public BSPVars getBSPVars(){
        return this.MyBSP;
    }

    public IVisSpriteManagement<V> getVisSpriteManager(){
        return this.VIS;
    }

    // //////////////VIDEO SCALE STUFF ///////////////////////

    protected int SCREENWIDTH;

    protected int SCREENHEIGHT;

    protected float SCREEN_MUL;

    protected IVideoScale vs;

    @Override
    public void setVideoScale(IVideoScale vs) {
        this.vs = vs;
    }

    @Override
    public void initScaling() {
        this.SCREENHEIGHT = vs.getScreenHeight();
        this.SCREENWIDTH = vs.getScreenWidth();
        this.SCREEN_MUL = vs.getScreenMul();

        // Pre-scale stuff.

        view.negonearray = new short[SCREENWIDTH]; // MAES: in scaling
        view.screenheightarray = new short[SCREENWIDTH];// MAES: in scaling
        // Mirror in view
        view.xtoviewangle = xtoviewangle = new long[SCREENWIDTH + 1];

        // Initialize children objects\
        MySegs.setVideoScale(vs);
        MyPlanes.setVideoScale(vs);
        vp_vars.setVideoScale(vs);
        MyThings.setVideoScale(vs);

        MySegs.initScaling();
        MyPlanes.initScaling();
        vp_vars.initScaling();
        MyThings.initScaling();

    }

    /**
     * Initializes the various drawing functions. They are all "pegged" to the
     * same dcvars/dsvars object. Any initializations of e.g. parallel renderers
     * and their supporting subsystems should occur here.
     */

    protected void R_InitDrawingFunctions(){
        this.setHiColFuns();
        this.setLowColFuns();
    }

    // //////////////////////////// LIMIT RESETTING //////////////////
    @Override
    public void resetLimits() {
        // Call it only at the beginning of new levels.
        VIS.resetLimits();
        MySegs.resetLimits();
    }

    /**
     * R_RenderView As you can guess, this renders the player view of a
     * particular player object. In practice, it could render the view of any
     * mobj too, provided you adapt the SetupFrame method (where the viewing
     * variables are set). This is the "vanilla" implementation which just works
     * for most cases.
     */

    public void RenderPlayerView(player_t player) {

        // Viewing variables are set according to the player's mobj. Interesting
        // hacks like
        // free cameras or monster views can be done.

		/* Uncommenting this will result in a very existential experience.
		 * Basically, the player's view will randomly switch between different mobj_t's in the map, 
		 * "possessing" them at the same time and turning them into (partial) Doomguys. Limited
		 * control is possible (e.g. moving) but trying to use things or shoot while in this state will
		 * result in a NPE.
		 */
    	
    /*
  	if (Math.random()>0.99){
	  thinker_t shit=P.getRandomThinker();
	  try {		  
	  mobj_t crap=(mobj_t)shit; // It works, because practically all thinkers are also mobj_t's. There are no "bodyless" thinkers
	  player.mo=crap;
	  SetupFrame(crap);
	  } catch (ClassCastException e){

	  }
  	} else{
    
        SetupFrame(player);
  	}
  	*/
  	

        // Clear buffers.
        MyBSP.ClearClipSegs();
        seg_vars.ClearDrawSegs();
        vp_vars.ClearPlanes();
        MySegs.ClearClips();
        VIS.ClearSprites();

        // Check for new console commands.
        DGN.NetUpdate();

        // The head node is the last node output.
        MyBSP.RenderBSPNode(LL.numnodes - 1);

        // Check for new console commands.
        DGN.NetUpdate();

        // FIXME: "Warped floor" fixed, now to fix same-height visplane
        // bleeding.
        MyPlanes.DrawPlanes();

        // Check for new console commands.
        DGN.NetUpdate();

        MyThings.DrawMasked();

        colfunc.main = colfunc.base;

        // Check for new console commands.
        DGN.NetUpdate();
    }

}

package rr;

import static m.fixed_t.FRACBITS;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import p.Resettable;

import w.CacheableDoomObject;

/** This is the vertex structure used IN MEMORY with fixed-point arithmetic.
 *  It's DIFFERENT than the one used on disk, which has 16-bit signed shorts.
 *  However, it must be parsed. 
 *
 */

public class vertex_t  implements CacheableDoomObject, Resettable{

    public vertex_t(){
        
    }
    /** treat as (fixed_t) */
    public  int x,y;
    
    
    /** Notice how we auto-expand to fixed_t */
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.x=buf.getShort()<<FRACBITS;
        this.y=buf.getShort()<<FRACBITS;
        
    }

    @Override
    public void reset() {
        x=0; y=0;        
    }


    public static int sizeOf() {
        return 4;
    }
    
}
package rr;

import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Utilities to synthesize patch_t format images from multiple patches
 * (with transparency).
 * 
 * 
 * @author velktron
 *
 */

public class MultiPatchSynthesizer {

    
    static class PixelRange {
        public PixelRange(int start, int end) {
            this.start=start;
            this.end=end;
        }
        
        public int getLength(){
            return (end-start+1);
        }
        
        public int start;
        public int end;
    }
    
    public static patch_t synthesizePatchFromFlat(String name,byte[] flat, int width, int height){
        
        byte[] expected=new byte[width *height];        
        byte[][] pixels=new byte[width][height];
        boolean[][] solid=new boolean[width][height];
        
        // Copy as much data as possible.
        System.arraycopy(flat,0,expected,0,Math.min(flat.length,expected.length));

        for (int i=0;i<width;i++){           
            Arrays.fill(solid[i],true);
            for (int j=0;j<height;j++){
                pixels[i][j]=expected[i+j*width];
            }
        }
        
        patch_t result=new patch_t(name,width,height,0,0);
        column_t[] columns=new column_t[width];
        
        for (int x=0;x<width;x++)
            columns[x]=getColumnStream(pixels[x],solid[x],height);
        
       result.columns=columns;
        return result;
    }
    
    public static patch_t synthesize(String name,byte[][] pixels, boolean[][] solid, int width, int height){
        
        patch_t result=new patch_t(name,width,height,0,0);
        column_t[] columns=new column_t[width];
        
        for (int x=0;x<width;x++)
            columns[x]=getColumnStream(pixels[x],solid[x],height);
        
       result.columns=columns;
        return result;
    }

    public static column_t getColumnStream(byte[] pixels, boolean[] solid, int height){
    
        column_t result=new column_t();
        int start=-1;
        int end=-1;
        
        List<PixelRange> ranges=new ArrayList<PixelRange>();
        
        // Scan column for continuous pixel ranges                
        for (int i=0;i<height;i++){
            
            // Encountered solid start.
            if (solid[i] && start==-1){
                start=i; // mark start
            }
                
            // Last solid pixel
            if (solid[i] && i==height-1 && start!=-1 ){
                end=i;
                ranges.add(new PixelRange(start,end));
                start=end=-1; // reset start/end
            }
               
            // Start defined and ending not yet detected
            if (!solid[i] && start!=-1 && end ==-1){
                end=i-1; // Single-pixel runs would be e.g. 1-2 -> 1-1
            }            

            if (start!=-1 && end!=-1){
                // Range complete.
                ranges.add(new PixelRange(start,end));
                start=end=-1; // reset start/end
            }
        }
        
        // There should be at least an empty post
        if (ranges.size()==0){
            ranges.add(new PixelRange(0,-1));
        }
        
        // Ideal for this use, since we don't know how big the patch is going to be a-priori
        ByteArrayOutputStream file=new ByteArrayOutputStream();
        int topdelta=0;
        int n=ranges.size();
        short topdeltas[]=new short[n];
        int postofs[]=new int[n];
        short postlens[]=new short[n];
        

        
        for (int i=0;i<n;i++){
            PixelRange pr=ranges.get(i);
            topdelta=pr.start; // cumulative top delta  
            
            // Precomputed column data
            postofs[i]=(short) file.size()+3; // Last written post +3, pointing at first pixel of data.
            topdeltas[i]=(short) topdelta;
            postlens[i]=(short) (pr.getLength()); // Post lengths are at net of padding  
                      
            file.write(topdeltas[i]);
            file.write(postlens[i]);
            file.write(0); // padding
            file.write(pixels,pr.start,pr.getLength()); // data
            file.write(0); // padding
            }
    
        file.write(0xFF); // Terminator
        
        result.data=file.toByteArray();
        result.postdeltas=topdeltas;
        result.postlen=postlens;
        result.postofs=postofs;
        result.posts=ranges.size();
        
        // The ranges tell us where continuous posts
        
        return result;
    }
    
    /*
    public static patch_t synthesize(byte[][] pixels, boolean[][] solid, int width, int height, int picture_top, int picture_left){
        // Ideal for this use, since we don't know how big the patch is going to be a-priori
        ByteArrayOutputStream file=new ByteArrayOutputStream();
        
        int offset;
        
        int[] columnofs=new int[width];
        
        // Patch header
        file.write(width);
        file.write(height);
        file.write(picture_top);
        file.write(picture_left);

        int column_array=0;
        int x=0,y;
        byte dummy_value;
        while (x<width){

            //write memory buffer position to end of column_array
            columnofs[column_array]=file.size();
            column_array++;

            y = 0;

            boolean operator = true;
            int pixel_count = 0;
            
            while (y < height){
                byte val=pixels[x][y];
                boolean transparent=!solid[x][y];
                
                
                // Pixel is transparent
                if (transparent && !operator ) {
                    dummy_value = 0;                    
                    file.write(dummy_value);
                    operator = true;
                    }
                else //Pixel not transparent, and operator condition set.
                    if (!transparent && operator){
                    int row_start = y;                    
                    pixel_count = 0;
                    dummy_value = 0;
                    // write above post data to memory buffer

                    offset = file.size(); //current post position in memory buffer

                    operator = false;
                    } else 
                   if (!transparent && !operator){
                       pixel_count++; // increment current post pixel_count
                   }

                    if (offset > 0 && pixel_count > 0){
                        previous_offset = current post position

                        seek back in memory buffer by offset - 2

                        write pixel_count to memory buffer

                        seek back to previous_offset
                    end block
                    
                    write pixel to memory buffer
                end block

                increment y by 1

            end block

            if operator = true or y = height then
                Pixel = 0

                write Pixel to memory buffer

                rowstart = 255
                
                write rowstart to memory buffer
            end block

            increment x by 1

        end block

        seek memory buffer position to 0

        block_size = picture_width * size of dword

        allocate block_memory, filled with 0's, with block_size

        write block_memory to file, using block_size as size

        offset = current file_position

        free block_memory

        seek to position 8 in file from start

        for loop, count = 0, break on count = number of elements in column_array
            column_offset = column_array[count] + offset

            write column_offset to file
        end block

        write memory buffer to file
    }
    } */
    
}

package rr;

/** Interface for sprite managers. Handles loading sprites, fixing
 *  rotations etc. and helping retrieving spritedefs when required.
 * 
 * @author velktron.
 *
 */

public interface ISpriteManager {
    
    /** Default known sprite names for DOOM */
    public final static String[] doomsprnames = {
        "TROO","SHTG","PUNG","PISG","PISF","SHTF","SHT2","CHGG","CHGF","MISG",
        "MISF","SAWG","PLSG","PLSF","BFGG","BFGF","BLUD","PUFF","BAL1","BAL2",
        "PLSS","PLSE","MISL","BFS1","BFE1","BFE2","TFOG","IFOG","PLAY","POSS",
        "SPOS","VILE","FIRE","FATB","FBXP","SKEL","MANF","FATT","CPOS","SARG",
        "HEAD","BAL7","BOSS","BOS2","SKUL","SPID","BSPI","APLS","APBX","CYBR",
        "PAIN","SSWV","KEEN","BBRN","BOSF","ARM1","ARM2","BAR1","BEXP","FCAN",
        "BON1","BON2","BKEY","RKEY","YKEY","BSKU","RSKU","YSKU","STIM","MEDI",
        "SOUL","PINV","PSTR","PINS","MEGA","SUIT","PMAP","PVIS","CLIP","AMMO",
        "ROCK","BROK","CELL","CELP","SHEL","SBOX","BPAK","BFUG","MGUN","CSAW",
        "LAUN","PLAS","SHOT","SGN2","COLU","SMT2","GOR1","POL2","POL5","POL4",
        "POL3","POL1","POL6","GOR2","GOR3","GOR4","GOR5","SMIT","COL1","COL2",
        "COL3","COL4","CAND","CBRA","COL6","TRE1","TRE2","ELEC","CEYE","FSKU",
        "COL5","TBLU","TGRN","TRED","SMBT","SMGT","SMRT","HDB1","HDB2","HDB3",
        "HDB4","HDB5","HDB6","POB1","POB2","BRS1","TLMP","TLP2"
    };
    
    void InitSpriteLumps();
    
    int getNumSprites();

    int getFirstSpriteLump();
    
    spritedef_t[] getSprites();
    
    spritedef_t getSprite(int index);
    
    int[] getSpriteWidth();
    int[] getSpriteOffset();
    int[] getSpriteTopOffset();

    int getSpriteWidth(int index);
    int getSpriteOffset(int index);
    int getSpriteTopOffset(int index);

    void InitSprites(String[] namelist);

    
}
package rr;

import p.Resettable;

/**
 * 
 * A SubSector. References a Sector. Basically, this is a list of LineSegs,
 * indicating the visible walls that define (all or some) sides of a convex BSP
 * leaf.
 * 
 * @author admin
 */
public class subsector_t implements Resettable{

	public subsector_t() {
		this(null,  0,  0);
	} 

	public subsector_t(sector_t sector, int numlines, int firstline) {
		this.sector = sector;
		this.numlines = numlines;
		this.firstline = firstline;
	}

	// Maes: single pointer
	public sector_t sector;
	// e6y: support for extended nodes
	// 'int' instead of 'short'
	public int numlines;
	public int firstline;
	
	public String toString(){
		sb.setLength(0);
		sb.append("Subsector");
		sb.append('\t');
		sb.append("Sector: ");
		sb.append(sector);
		sb.append('\t');
		sb.append("numlines ");
		sb.append(numlines);
		sb.append('\t');
		sb.append("firstline ");
		sb.append(firstline);
		return sb.toString();
		
		
	}
	
	private static StringBuilder sb=new StringBuilder();

    @Override
    public void reset() {
        sector=null;
        firstline=numlines=0;        
    }
	

}

package rr;

/**
 * A single patch from a texture definition,
 * basically a rectangular area within
 * the texture rectangle.
 * @author admin
 *
 */
public class texpatch_t {
// Block origin (allways UL),
// which has allready accounted
// for the internal origin of the patch.
int     originx;    
int     originy;
int     patch;

public void copyFromMapPatch(mappatch_t mpp) {
   this.originx=mpp.originx;
   this.originy=mpp.originy;
   this.patch=mpp.patch;
    }
}
package rr;

import static data.Defines.FF_FRAMEMASK;
import static data.Defines.FF_FULLBRIGHT;
import static data.Limits.MAXVISSPRITES;
import static data.Tables.ANG45;
import static data.Tables.BITS32;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.FixedDiv;
import static m.fixed_t.FixedMul;
import static p.mobj_t.MF_SHADOW;
import static rr.LightsAndColors.*;
import static rr.Renderer.MINZ;

import i.IDoomSystem;

import java.util.Arrays;

import p.mobj_t;
import utils.C2JUtils;

/** Visualized sprite manager. Depends on: SpriteManager, DoomSystem,
 *  Colormaps, Current View.
 *  
 * @author velktron
 *
 * @param <V>
 */

public final class VisSprites<V>
        implements IVisSpriteManagement<V> {

    private final static boolean DEBUG = false;

    private final static boolean RANGECHECK = false;

    protected IDoomSystem I;

    protected ISpriteManager SM;

    protected ViewVars view;

    protected LightsAndColors<V> colormaps;

    protected RendererState<?, V> R;

    public VisSprites(RendererState<?, V> R) {
        updateStatus(R);
        vissprite_t<V> tmp = new vissprite_t<V>();
        vissprites = C2JUtils.createArrayOfObjects(tmp, MAXVISSPRITES);
    }

    public void updateStatus(RendererState<?, V> R) {
        this.R = R;
        this.view = R.view;
        this.I = R.I;
        this.SM = R.SM;
        this.colormaps = R.colormaps;

    }

    protected vissprite_t<V>[] vissprites;

    protected int vissprite_p;

    protected int newvissprite;

    // UNUSED
    // private final vissprite_t unsorted;
    // private final vissprite_t vsprsortedhead;

    // Cache those you get from the sprite manager
    protected int[] spritewidth, spriteoffset, spritetopoffset;

    /**
     * R_AddSprites During BSP traversal, this adds sprites by sector.
     */

    @Override
    public void AddSprites(sector_t sec) {
        if (DEBUG)
            System.out.println("AddSprites");
        mobj_t thing;
        int lightnum;

        // BSP is traversed by subsector.
        // A sector might have been split into several
        // subsectors during BSP building.
        // Thus we check whether its already added.
        if (sec.validcount == R.getValidCount())
            return;

        // Well, now it will be done.
        sec.validcount = R.getValidCount();

        lightnum = (sec.lightlevel >> LIGHTSEGSHIFT) + colormaps.extralight;

        if (lightnum < 0)
            colormaps.spritelights = colormaps.scalelight[0];
        else if (lightnum >= LIGHTLEVELS)
            colormaps.spritelights = colormaps.scalelight[LIGHTLEVELS - 1];
        else
            colormaps.spritelights = colormaps.scalelight[lightnum];

        // Handle all things in sector.
        for (thing = sec.thinglist; thing != null; thing = (mobj_t) thing.snext)
            ProjectSprite(thing);
    }

    /**
     * R_ProjectSprite Generates a vissprite for a thing if it might be visible.
     * 
     * @param thing
     */
    protected final void ProjectSprite(mobj_t thing) {
        int tr_x, tr_y;
        int gxt, gyt;
        int tx, tz;

        int xscale, x1, x2;

        spritedef_t sprdef;
        spriteframe_t sprframe;
        int lump;

        int rot;
        boolean flip;

        int index;

        vissprite_t<V> vis;

        long ang;
        int iscale;

        // transform the origin point
        tr_x = thing.x - view.x;
        tr_y = thing.y - view.y;

        gxt = FixedMul(tr_x, view.cos);
        gyt = -FixedMul(tr_y, view.sin);

        tz = gxt - gyt;

        // thing is behind view plane?
        if (tz < MINZ)
            return;
        /* MAES: so projection/tz gives horizontal scale */
        xscale = FixedDiv(view.projection, tz);

        gxt = -FixedMul(tr_x, view.sin);
        gyt = FixedMul(tr_y, view.cos);
        tx = -(gyt + gxt);

        // too far off the side?
        if (Math.abs(tx) > (tz << 2))
            return;

        // decide which patch to use for sprite relative to player
        if (RANGECHECK) {
            if (thing.sprite.ordinal() >= SM.getNumSprites())
                I.Error("R_ProjectSprite: invalid sprite number %d ",
                    thing.sprite);
        }
        sprdef = SM.getSprite(thing.sprite.ordinal());
        if (RANGECHECK) {
            if ((thing.frame & FF_FRAMEMASK) >= sprdef.numframes)
                I.Error("R_ProjectSprite: invalid sprite frame %d : %d ",
                    thing.sprite, thing.frame);
        }
        sprframe = sprdef.spriteframes[thing.frame & FF_FRAMEMASK];

        if (sprframe.rotate != 0) {
            // choose a different rotation based on player view
            ang = view.PointToAngle(thing.x, thing.y);
            rot = (int) ((ang - thing.angle + (ANG45 * 9) / 2) & BITS32) >>> 29;
            lump = sprframe.lump[rot];
            flip = (boolean) (sprframe.flip[rot] != 0);
        } else {
            // use single rotation for all views
            lump = sprframe.lump[0];
            flip = (boolean) (sprframe.flip[0] != 0);
        }

        // calculate edges of the shape
        tx -= spriteoffset[lump];
        x1 = (view.centerxfrac + FixedMul(tx, xscale)) >> FRACBITS;

        // off the right side?
        if (x1 > view.width)
            return;

        tx += spritewidth[lump];
        x2 = ((view.centerxfrac + FixedMul(tx, xscale)) >> FRACBITS) - 1;

        // off the left side
        if (x2 < 0)
            return;

        // store information in a vissprite
        vis = NewVisSprite();
        vis.mobjflags = thing.flags;
        vis.scale = xscale << view.detailshift;
        vis.gx = thing.x;
        vis.gy = thing.y;
        vis.gz = thing.z;
        vis.gzt = thing.z + spritetopoffset[lump];
        vis.texturemid = vis.gzt - view.z;
        vis.x1 = x1 < 0 ? 0 : x1;
        vis.x2 = x2 >= view.width ? view.width - 1 : x2;
        /*
         * This actually determines the general sprite scale) iscale = 1/xscale,
         * if this was floating point.
         */
        iscale = FixedDiv(FRACUNIT, xscale);

        if (flip) {
            vis.startfrac = spritewidth[lump] - 1;
            vis.xiscale = -iscale;
        } else {
            vis.startfrac = 0;
            vis.xiscale = iscale;
        }

        if (vis.x1 > x1)
            vis.startfrac += vis.xiscale * (vis.x1 - x1);
        vis.patch = lump;

        // get light level
        if ((thing.flags & MF_SHADOW) != 0) {
            // shadow draw
            vis.colormap = null;
        } else if (colormaps.fixedcolormap != null) {
            // fixed map
            vis.colormap = (V) colormaps.fixedcolormap;
            // vis.pcolormap=0;
        } else if ((thing.frame & FF_FULLBRIGHT) != 0) {
            // full bright
            vis.colormap = (V) colormaps.colormaps[0];
            // vis.pcolormap=0;
        }

        else {
            // diminished light
            index = xscale >> (LIGHTSCALESHIFT - view.detailshift);

            if (index >= MAXLIGHTSCALE)
                index = MAXLIGHTSCALE - 1;

            vis.colormap = colormaps.spritelights[index];
            // vis.pcolormap=index;
        }
    }

    /**
     * R_NewVisSprite Returns either a "new" sprite (actually, reuses a pool),
     * or a special "overflow sprite" which just gets overwritten with bogus
     * data. It's a bit of dumb thing to do, since the overflow sprite is never
     * rendered but we have to copy data over it anyway. Would make more sense
     * to check for it specifically and avoiding copying data, which should be
     * more time consuming. Fixed by making this fully limit-removing.
     * 
     * @return
     */
    protected final vissprite_t<V> NewVisSprite() {
        if (vissprite_p == (vissprites.length - 1)) {
            ResizeSprites();
        }
        // return overflowsprite;

        vissprite_p++;
        return vissprites[vissprite_p - 1];
    }

    @Override
    public void cacheSpriteManager(ISpriteManager SM) {
        this.spritewidth = SM.getSpriteWidth();
        this.spriteoffset = SM.getSpriteOffset();
        this.spritetopoffset = SM.getSpriteTopOffset();
    }

    /**
     * R_ClearSprites Called at frame start.
     */

    @Override
    public void ClearSprites() {
        // vissprite_p = vissprites;
        vissprite_p = 0;
    }

    // UNUSED private final vissprite_t overflowsprite = new vissprite_t();

    protected final void ResizeSprites() {
        vissprites =
            C2JUtils.resize(vissprites[0], vissprites, vissprites.length * 2); // Bye
                                                                               // bye,
                                                                               // old
                                                                               // vissprites.
    }

    /**
     * R_SortVisSprites UNUSED more efficient Comparable sorting + built-in
     * Arrays.sort function used.
     */

    @Override
    public final void SortVisSprites() {
        Arrays.sort(vissprites, 0, vissprite_p);

        // Maes: got rid of old vissprite sorting code. Java's is better
        // Hell, almost anything was better than that.

    }

    @Override
    public int getNumVisSprites() {
        return vissprite_p;
    }

    @Override
    public vissprite_t<V>[] getVisSprites() {
        return vissprites;
    }

    public void resetLimits() {
        vissprite_t<V>[] tmp =
            C2JUtils.createArrayOfObjects(vissprites[0], MAXVISSPRITES);
        System.arraycopy(vissprites, 0, tmp, 0, MAXVISSPRITES);

        // Now, that was quite a haircut!.
        vissprites = tmp;    }
}
package rr;

import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedMul;

import p.Resettable;

/**
 * The LineSeg. Must be built from on-disk mapsegs_t, which are much simpler.
 * 
 * @author Maes
 */

public class seg_t
        implements Resettable {

    /** To be used as references */
    public vertex_t v1, v2;

    /** Local caching. Spares us using one extra reference level */
    public int v1x, v1y, v2x, v2y;

    /** (fixed_t) */
    public int offset;

    /** (angle_t) */
    public long angle;

    // MAES: all were single pointers.

    public side_t sidedef;

    public line_t linedef;

    /**
     * Sector references. Could be retrieved from linedef, too. backsector is
     * NULL for one sided lines
     */
    public sector_t frontsector, backsector;

    // Boom stuff
    public boolean miniseg;

    public float length;

    /** proff 11/05/2000: needed for OpenGL */
    public int iSegID;

    public void assignVertexValues() {
        this.v1x = v1.x;
        this.v1y = v1.y;
        this.v2x = v2.x;
        this.v2y = v2.y;

    }

    /**
     * R_PointOnSegSide
     * 
     * @param x
     * @param y
     * @param line
     * @return
     */
    public static int PointOnSegSide(int x, int y, seg_t line) {
        int lx;
        int ly;
        int ldx;
        int ldy;
        int dx;
        int dy;
        int left;
        int right;

        lx = line.v1x;
        ly = line.v1y;

        ldx = line.v2x - lx;
        ldy = line.v2y - ly;

        if (ldx == 0) {
            if (x <= lx)
                return (ldy > 0) ? 1 : 0;

            return (ldy < 0) ? 1 : 0;
        }
        if (ldy == 0) {
            if (y <= ly)
                return (ldx < 0) ? 1 : 0;

            return (ldx > 0) ? 1 : 0;
        }

        dx = x - lx;
        dy = y - ly;

        // Try to quickly decide by looking at sign bits.
        if (((ldy ^ ldx ^ dx ^ dy) & 0x80000000) != 0) {
            if (((ldy ^ dx) & 0x80000000) != 0) {
                // (left is negative)
                return 1;
            }
            return 0;
        }

        left = FixedMul(ldy >> FRACBITS, dx);
        right = FixedMul(dy, ldx >> FRACBITS);

        if (right < left) {
            // front side
            return 0;
        }
        // back side
        return 1;
    }

    /**
     * R_PointOnSegSide
     * 
     * @param x
     * @param y
     * @param line
     * @return
     */
    public int PointOnSegSide(int x, int y) {
        int lx;
        int ly;
        int ldx;
        int ldy;
        int dx;
        int dy;
        int left;
        int right;

        lx = this.v1x;
        ly = this.v1y;

        ldx = this.v2x - lx;
        ldy = this.v2y - ly;

        if (ldx == 0) {
            if (x <= lx)
                return (ldy > 0) ? 1 : 0;

            return (ldy < 0) ? 1 : 0;
        }
        if (ldy == 0) {
            if (y <= ly)
                return (ldx < 0) ? 1 : 0;

            return (ldx > 0) ? 1 : 0;
        }

        dx = x - lx;
        dy = y - ly;

        // Try to quickly decide by looking at sign bits.
        if (((ldy ^ ldx ^ dx ^ dy) & 0x80000000) != 0) {
            if (((ldy ^ dx) & 0x80000000) != 0) {
                // (left is negative)
                return 1;
            }
            return 0;
        }

        left = FixedMul(ldy >> FRACBITS, dx);
        right = FixedMul(dy, ldx >> FRACBITS);

        if (right < left) {
            // front side
            return 0;
        }
        // back side
        return 1;
    }

    public String toString() {
        return String
                .format(
                    "Seg %d\n\tFrontsector: %s\n\tBacksector: %s\n\tVertexes: %x %x %x %x",
                    iSegID, frontsector, backsector, v1x, v1y, v2x, v2y);
    }

    @Override
    public void reset() {
        v1 = v2 = null;
        v1x = v1y = v2x = v2y = 0;
        angle = 0;
        frontsector = backsector = null;
        iSegID = 0;
        linedef = null;
        miniseg = false;
        offset = 0;
        length = 0;
    }

}

package rr;

import static data.Tables.ANGLETOFINESHIFT;
import static data.Tables.BITS32;
import static data.Tables.finecosine;
import static data.Tables.finesine;
import static m.fixed_t.FixedMul;
import static rr.LightsAndColors.*;

import i.IDoomSystem;

import rr.RendererState.IPlaneDrawer;
import rr.drawfuns.SpanVars;
import v.IVideoScale;

public abstract class PlaneDrawer<T,V> implements IPlaneDrawer{

    private static final boolean DEBUG2=false;


    protected final boolean RANGECHECK = false;
    
    //
    // spanstart holds the start of a plane span
    // initialized to 0 at start
    //
    protected int[] spanstart, spanstop;

    //
    // texture mapping
    //
    protected V[] planezlight; // The distance lighting effect you see
    /** To treat as fixed_t */
    protected int planeheight;
    /** To treat as fixed_t */
    protected int[] distscale;

    /** To treat as fixed_t */
    protected int[] cacheddistance, cachedxstep, cachedystep;

    protected final ViewVars view;    

    protected final SegVars seg_vars;
    protected final SpanVars<T,V> dsvars;
    /** The visplane data. Set separately. For threads, use the same for
     *  everyone.
     */
    protected Visplanes vpvars;
    protected final LightsAndColors<V> colormap;
    protected final TextureManager<T> TexMan;
    protected final IDoomSystem I;
    
    
    protected PlaneDrawer(Renderer<T,V> R){
        this.view=R.getView();
        this.vpvars=R.getVPVars();
        this.dsvars=R.getDSVars();
        this.seg_vars=R.getSegVars();
        this.colormap=R.getColorMap();
        this.TexMan=R.getTextureManager();
        this.I=R.getDoomSystem();
    }

    /**
     * R_MapPlane
     * 
     * Called only by R_MakeSpans.
     * 
     * This is where the actual span drawing function is called.
     * 
     * Uses global vars: planeheight ds_source -> flat data has already been
     * set. basexscale -> actual drawing angle and position is computed from
     * these baseyscale viewx viewy
     * 
     * BASIC PRIMITIVE
     */

    public void MapPlane(int y, int x1, int x2) {
        // MAES: angle_t
        int angle;
        // fixed_t
        int distance;
        int length;
        int index;

        if (RANGECHECK) {
            rangeCheck(x1,x2,y);
        }

        if (planeheight != vpvars.cachedheight[y]) {
            vpvars.cachedheight[y] = planeheight;
            distance = cacheddistance[y] = FixedMul(planeheight, vpvars.yslope[y]);
            dsvars.ds_xstep = cachedxstep[y] = FixedMul(distance, vpvars.basexscale);
            dsvars.ds_ystep = cachedystep[y] = FixedMul(distance, vpvars.baseyscale);
        } else {
            distance = cacheddistance[y];
            dsvars.ds_xstep = cachedxstep[y];
            dsvars.ds_ystep = cachedystep[y];
        }

        length = FixedMul(distance, distscale[x1]);
        angle = (int) (((view.angle + view.xtoviewangle[x1]) & BITS32) >>> ANGLETOFINESHIFT);
        dsvars.ds_xfrac = view.x + FixedMul(finecosine[angle], length);
        dsvars.ds_yfrac = -view.y - FixedMul(finesine[angle], length);

        if (colormap.fixedcolormap != null)
            dsvars.ds_colormap = colormap.fixedcolormap;
        else {
            index = distance >>> LIGHTZSHIFT;

            if (index >= MAXLIGHTZ)
                index = MAXLIGHTZ - 1;

            dsvars.ds_colormap = planezlight[index];
        }

        dsvars.ds_y = y;
        dsvars.ds_x1 = x1;
        dsvars.ds_x2 = x2;

        // high or low detail
        dsvars.spanfunc.invoke();
    }

    protected final void rangeCheck(int x1,int x2,int y) {
        if (x2 < x1 || x1 < 0 || x2 >= view.width || y > view.height)
            I.Error("%s: %d, %d at %d",this.getClass().getName(), x1, x2, y);
        }
  
        
    /**
     * R_MakeSpans
     * 
     * Called only by DrawPlanes. If you wondered where the actual
     * boundaries for the visplane flood-fill are laid out, this is it.
     * 
     * The system of coords seems to be defining a sort of cone.
     * 
     * 
     * @param x
     *            Horizontal position
     * @param t1
     *            Top-left y coord?
     * @param b1
     *            Bottom-left y coord?
     * @param t2
     *            Top-right y coord ?
     * @param b2
     *            Bottom-right y coord ?
     * 
     */

    protected void MakeSpans(int x, int t1, int b1, int t2, int b2) {

        // If t1 = [sentinel value] then this part won't be executed.
        while (t1 < t2 && t1 <= b1) {
            this.MapPlane(t1, spanstart[t1], x - 1);
            t1++;
        }
        while (b1 > b2 && b1 >= t1) {
            this.MapPlane(b1, spanstart[b1], x - 1);
            b1--;
        }

        // So...if t1 for some reason is < t2, we increase t2 AND store the
        // current x
        // at spanstart [t2] :-S
        while (t2 < t1 && t2 <= b2) {
            // System.out.println("Increasing t2");
            spanstart[t2] = x;
            t2++;
        }

        // So...if t1 for some reason b2 > b1, we decrease b2 AND store the
        // current x
        // at spanstart [t2] :-S

        while (b2 > b1 && b2 >= t2) {
            // System.out.println("Decreasing b2");
            spanstart[b2] = x;
            b2--;
        }
    }

    /**
     * R_InitPlanes Only at game startup.
     */

    public void InitPlanes() {
        // Doh!
    }

   /////////// VIDEO SCALE STUFF ///////////

    protected int SCREENWIDTH;
    protected int SCREENHEIGHT;
    protected IVideoScale vs;

    @Override
    public void setVideoScale(IVideoScale vs) {
        this.vs = vs;
    }

    @Override
    public void initScaling() {
        this.SCREENHEIGHT = vs.getScreenHeight();
        this.SCREENWIDTH = vs.getScreenWidth();

        // Pre-scale stuff.

        spanstart = new int[SCREENHEIGHT];
        spanstop = new int[SCREENHEIGHT];
        distscale = new int[SCREENWIDTH];        
        cacheddistance = new int[SCREENHEIGHT];
        cachedxstep = new int[SCREENHEIGHT];
        cachedystep = new int[SCREENHEIGHT];

        // HACK: visplanes are initialized globally.
        visplane_t.setVideoScale(vs);
        visplane_t.initScaling();
        vpvars.initVisplanes();

    }
    
    protected final void rangeCheckErrors(){
        if (seg_vars.ds_p > seg_vars.MAXDRAWSEGS)
            I.Error("R_DrawPlanes: drawsegs overflow (%d)", seg_vars.ds_p);

        if (vpvars.lastvisplane > vpvars.MAXVISPLANES)
            I.Error(" R_DrawPlanes: visplane overflow (%d)",
                vpvars.lastvisplane);

        if (vpvars.lastopening > vpvars.MAXOPENINGS)
            I.Error("R_DrawPlanes: opening overflow (%d)", vpvars.lastopening);
    }

    /** Default implementation which DOES NOTHING. MUST OVERRIDE */
    
    public void DrawPlanes(){
        
    }
    
    public void sync(){
        // Nothing required if serial.
    }
    
    /////////////// VARIOUS BORING GETTERS ////////////////////


    @Override
    public int[] getDistScale() {
        return distscale;
    }
    
}

package rr;

import static data.Defines.PU_CACHE;
import static data.Defines.PU_STATIC;
import static data.Defines.SKYFLATNAME;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FRACUNIT;

import i.IDoomSystem;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import p.AbstractLevelLoader;
import doom.DoomStatus;
import w.DoomBuffer;
import w.IWadLoader;
import w.li_namespace;
import w.lumpinfo_t;

/** An attempt to separate texture mapping functionality from
 *  the rest of the rendering. Seems to work like a charm, and
 *  it makes it clearer what needs and what doesn't need to be 
 *  exposed.
 * 
 * @author Maes
 *
 */

public class SimpleTextureManager
        implements TextureManager<byte[]> {
    
    IWadLoader W;
    IDoomSystem I;
    AbstractLevelLoader LL;
    DoomStatus<?,?> DM;
    
    //
    // Graphics.
    // DOOM graphics for walls and sprites
    // is stored in vertical runs of opaque pixels (posts).
    // A column is composed of zero or more posts,
    // a patch or sprite is composed of zero or more columns.
    // 

    protected int     firstflat;
    protected int     lastflat;
    protected int     numflats;
    /** HACK */
    protected flat_t[] flats;
    
    //protected int     firstpatch;
    //protected int     lastpatch;
    protected int     numpatches;


    protected int     numtextures;
    
    /** The unchached textures themselves, stored just as patch lists and various properties */
    protected texture_t[] textures;

    /** Width per texture? */
    protected int[]            texturewidthmask;
    /** fixed_t[] needed for texture pegging */
    
    /** How tall each composite texture is supposed to be */
    protected int[]        textureheight;    
    
    /** How large each composite texture is supposed to be */
    protected int[]            texturecompositesize;
    /** Tells us which patch lump covers which column of which texture */
    protected short[][]         texturecolumnlump;
    
    /** This is supposed to store indexes into a patch_t lump which point to the columns themselves 
     *  Instead, we're going to return indexes to columns inside a particular patch.
     *  In the case of patches inside a non-cached multi-patch texture (e.g. those made of non-overlapping
     *  patches), we're storing indexes INSIDE A PARTICULAR PATCH. E.g. for STARTAN1, which is made of two
     *  32-px wide patches, it should go something like 0, 1,2 ,3...31, 0,1,2,....31.
     *  
     * */
    protected char[][]    texturecolumnofs;
    
    /** couple with texturecomposite */
    protected char texturecoloffset;
    //short[][]    texturecolumnindexes;
    /** Stores [textures][columns][data]. */
    protected byte[][][] texturecomposite;
    
    /** HACK to store "composite masked textures", a Boomism. */ 
    protected patch_t[] patchcomposite;

    /** for global animation. Storage stores actual lumps, translation is a relative -> relative map */
    protected int[]        flattranslation, flatstorage,texturetranslation;
    
    // This is also in DM, but one is enough, really.
    protected int skytexture,skytexturemid,skyflatnum;
    
    public SimpleTextureManager(DoomStatus<?,?> DC) {
        this.DM=DC;
        this.W=DM.W;
        this.I=DM.I;
        this.LL=DM.LL;
        FlatPatchCache=new Hashtable<Integer, patch_t>();
    }
  
    /** Hash table used for matching flat <i>lump</i> to flat <i>num</i> */

    Hashtable<Integer, Integer> FlatCache;
    
    Hashtable<Integer, patch_t> FlatPatchCache;

      /**
       * R_CheckTextureNumForName Check whether texture is available. Filter out
       * NoTexture indicator. Can be sped up with a hash table, but it's pointless.
       */
    
        @Override
       public int CheckTextureNumForName(String name) {
          Integer i;
          // "NoTexture" marker.
          if (name.charAt(0) == '-')  return 0;
          
          i=TextureCache.get(name);
          if (i==null) return -1;
          else return i;

          /* for (i = 0; i < numtextures; i++)
              if (textures[i].name.compareToIgnoreCase(name) == 0)
                  return i;

          return -1; */
      }
    
        /** Hash table used for fast texture lookup */

        Hashtable<String, Integer> TextureCache;
        
        /**
         * R_TextureNumForName
         * Calls R_CheckTextureNumForName,
         * aborts with error message.
         */
      
        public int TextureNumForName(String name) {
            int i;

            i = CheckTextureNumForName(name);

            if (i == -1) {
                I.Error("R_TextureNumForName: %s not found", name);
            }
            return i;
        }

    /**
     * R_InitTextures
     * Initializes the texture list
     *  with the textures from the world map.
     */
    
    public void InitTextures () throws IOException
    {
        // This drives the rest
        maptexture_t mtexture = new maptexture_t();
        texture_t texture;
        mappatch_t[] mpatch;
        texpatch_t[] patch;
        ByteBuffer[] maptex = new ByteBuffer[texturelumps.length];
        int[] patchlookup;
        int totalwidth;
        int offset;
        int[] maxoff = new int[texturelumps.length];
        int[] _numtextures = new int[texturelumps.length];
        int directory = 1;
        int texset=TEXTURE1;
        // Load the patch names from pnames.lmp.
        //name[8] = 0;    
        patchlookup=loadPatchNames("PNAMES");
        
        // Load the map texture definitions from textures.lmp.
        // The data is contained in one or two lumps,
        //  TEXTURE1 for shareware, plus TEXTURE2 for commercial.
        
        for (int i=0;i<texturelumps.length;i++){
            String TEXTUREx=texturelumps[i];
            if (W.CheckNumForName (TEXTUREx) != -1){
            maptex[i] = W.CacheLumpName (TEXTUREx, PU_STATIC).getBuffer();
            maptex[i].rewind();
            maptex[i].order(ByteOrder.LITTLE_ENDIAN);
            _numtextures[i] = maptex[i].getInt();
            maxoff[i] = W.LumpLength (W.GetNumForName (TEXTUREx));
            if (_numtextures[i]!= (maxoff[i]-4)/8) {
            	System.err.printf("Warning! Possibly malformed TEXTURE%d lump. Stated number of textures: %d Possible: %d\n",i, _numtextures[i] , (maxoff[i]-4)/8);
            }
           
            }
        }
        
        // Total number of textures.
        numtextures = _numtextures[0] + _numtextures[1];
        
        textures = new texture_t[numtextures];
        // MAES: Texture hashtable.          
        TextureCache=new Hashtable<String, Integer>(numtextures);
        
        texturecolumnlump = new short[numtextures][];
        texturecolumnofs = new char[numtextures][];
        patchcomposite=new patch_t[numtextures];
        texturecomposite = new byte[numtextures][][];
        texturecompositesize = new int[numtextures];
        texturewidthmask = new int[numtextures];
        textureheight = new int[numtextures];

        totalwidth = 0;
        
        //  Really complex printing shit...
        System.out.print("[");
        for (int i=0 ; i<numtextures ; i++,directory++)
        {
        
        if ((i&63)==0)
            System.out.print ('.');

        if (i == _numtextures[TEXTURE1])
        {
            // Start looking in second texture file.
            texset=TEXTURE2;
            directory = 1; // offset "1" inside maptex buffer
            //System.err.print("Starting looking into TEXTURE2\n");
        }
        
        offset = maptex[texset].getInt(directory<<2);
        
        if (offset > maxoff[texset])
            I.Error("R_InitTextures: bad texture directory");
        
        maptex[texset].position(offset);
        // Read "maptexture", which is the on-disk form.
        mtexture.unpack(maptex[texset]);

        // MAES: the HashTable only needs to know the correct names.
        TextureCache.put(mtexture.name.toUpperCase(), new Integer(i));
        
        // We don't need to manually copy trivial fields.
        textures[i]=new texture_t();
        textures[i].copyFromMapTexture(mtexture);
        texture = textures[i];
        
        // However we do need to correct the "patch.patch" field through the patchlookup
        mpatch = mtexture.patches;
        patch = texture.patches;
        
        for (int j=0 ; j<texture.patchcount ; j++)
        {
            //System.err.printf("Texture %d name %s patch %d lookup %d\n",i,mtexture.name,j,mpatch[j].patch);
            patch[j].patch = patchlookup[mpatch[j].patch%patchlookup.length];
            if (patch[j].patch == -1)
            {
            I.Error ("R_InitTextures: Missing patch in texture %s",
                 texture.name);
            }
        }       
        
        // Columns and offsets of taxture = textures[i]
        texturecolumnlump[i] = new short[texture.width];
        //C2JUtils.initArrayOfObjects( texturecolumnlump[i], column_t.class);
        texturecolumnofs[i] = new char[texture.width];
        
        int j = 1;
        while (j*2 <= texture.width)
            j<<=1;

        texturewidthmask[i] = j-1;
        textureheight[i] = texture.height<<FRACBITS;
            
        totalwidth += texture.width;
        }
        
        // Precalculate whatever possible.  
        for (int i=0 ; i<numtextures ; i++)
        GenerateLookup (i);
        
        // Create translation table for global animation.
        texturetranslation = new int[numtextures];
        
        for (int i=0 ; i<numtextures ; i++)
            texturetranslation[i] = i;
    }
    
    /** Assigns proper lumpnum to patch names. Check whether flats and patches of the same name coexist.
     *  If yes, priority should go to patches. Otherwise, it's a "flats on walls" case.
     * 
     * @param pnames
     * @return
     * @throws IOException
     */
    
    private int[] loadPatchNames(String pnames) throws IOException {
        int[] patchlookup;
        int nummappatches;
        String name;
        
        ByteBuffer names = W.CacheLumpName (pnames, PU_STATIC).getBuffer();        
        names.order(ByteOrder.LITTLE_ENDIAN);
        
        // Number of patches.
        names.rewind();
        nummappatches = names.getInt();        
        patchlookup = new int[nummappatches];
        
        for (int i=0 ; i<nummappatches ; i++)
        {
        // Get a size limited string;
        name=DoomBuffer.getNullTerminatedString(names, 8).toUpperCase();
        
        // Resolve clashes
        int[] stuff= W.CheckNumsForName (name);
        
        // Move backwards.
        for (int k=0;k<stuff.length;k++){
            
            // Prefer non-flat, with priority
            if (W.GetLumpInfo(stuff[k]).namespace != li_namespace.ns_flats) {
                patchlookup[i]=stuff[k];
                break;            
            }            
             
            // Suck it down :-/
            patchlookup[i]=stuff[k];
        }
        }
        
        return patchlookup;
    }

    private patch_t retrievePatchSafe(int lump){
        
        // If this is a known troublesome lump, get it from the cache.
        if (FlatPatchCache.containsKey(lump)){
            return FlatPatchCache.get(lump);
            }
        
        lumpinfo_t info = W.GetLumpInfo(lump);
        patch_t realpatch;
        
        // Patch is actually a flat or something equally nasty. Ouch.
        if (info.namespace==li_namespace.ns_flats) {
                byte[] flat=W.CacheLumpNumAsRawBytes(lump, PU_CACHE);
                realpatch= MultiPatchSynthesizer.synthesizePatchFromFlat(info.name,flat,64, 64);
                this.FlatPatchCache.put(lump, realpatch);
                W.UnlockLumpNum(lump);
        }
        else
            // It's probably safe, at this point.
            realpatch = (patch_t) W.CacheLumpNum (lump, PU_CACHE,patch_t.class);
        
        return realpatch;
    }
    
    /**
     * R_GenerateLookup
     * 
     * Creates the lookup tables for a given texture (aka, where inside the texture cache
     * is the offset for particular column... I think.
     * 
     * @throws IOException 
     */
    @Override
    public void GenerateLookup (int texnum) throws IOException
    {
        texture_t      texture;
        short[]       patchcount; //Keeps track of how many patches overlap a column.
        texpatch_t[]     patch;  
        patch_t        realpatch = null;
        int         x;
        int         x1;
        int         x2;

        short[]      collump;
         char[] colofs;
        
        texture = textures[texnum];

        // Composited texture not created yet.
        texturecomposite[texnum] = null;
        
        // We don't know ho large the texture will be, yet, but it will be a multiple of its height.
        texturecompositesize[texnum] = 0;

        // This is the only place where those can be actually modified.
        // They are still null at this point.
        collump = texturecolumnlump[texnum];
        colofs = texturecolumnofs[texnum];
        
        /* Now count the number of columns  that are covered by more 
         * than one patch. Fill in the lump / offset, so columns
         * with only a single patch are all done.
         */

        patchcount = new short[texture.width];
        patch = texture.patches;
            
        // for each patch in a texture...
        for (int i=0; i<texture.patchcount;i++)
        {
        // Retrieve patch...if it IS a patch.
        realpatch=this.retrievePatchSafe(patch[i].patch);

        x1 = patch[i].originx;
        x2 = x1 + realpatch.width;
        
        // Where does the patch start, inside the compositetexture?
        if (x1 < 0)
            x = 0;
        else
            x = x1;

        // Correct, starts at originx. Where does it end?
        
        if (x2 > texture.width)
            x2 = texture.width;
        for ( ; x<x2 ; x++)
        {
            /* Obviously, if a patch starts at x it does cover the x-th column
             *  of a texture, even if transparent. 
             */
            patchcount[x]++;
            // Column "x" of composite texture "texnum" is covered by this patch.
            collump[x] = (short) patch[i].patch;
            
            /* This is supposed to be a raw pointer to the beginning of the column
             * data, as it appears inside the PATCH.
             * 
             * Instead, we can return the actual column index (x-x1)
             * As an example, the second patch of STARTAN1 (width 64) starts
             * at column 32. Therefore colofs should be something like
             * 0,1,2,...,31,0,1,....31, indicating that the 32-th column of
             * STARTAN1 is the 0-th column of the patch that is assigned to that column
             * (the latter can be looked up in texturecolumnlump[texnum].
             * 
             * Any questions?
             * 
             */
            colofs[x] = (char) (x-x1);
            // This implies that colofs[x] is 0 for a void column?
                
        } // end column of patch.
        } // end patch
        
        // Now check all columns again.
        for ( x=0 ; x<texture.width ; x++)
        {
        // Can only occur if a column isn't covered by a patch at all, not even a transparent one.
        if (patchcount[x]==0)
        {
            // TODO: somehow handle this. 
            System.err.print (realpatch.width);
            System.err.print ("R_GenerateLookup: column without a patch ("+texture.name+")\n");
            //return;
        }
        // I_Error ("R_GenerateLookup: column without a patch");
        
        
        // Columns where more than one patch overlaps.
        if (patchcount[x] > 1)
        {
            // Use the cached block. This column won't be read from the wad system.
            collump[x] = -1;    
            colofs[x] = (char) texturecompositesize[texnum];
            
            /* Do we really mind?
            if (texturecompositesize[texnum] > 0x10000-texture.height)
            {
            I.Error ("R_GenerateLookup: texture no %d (%s) is >64k",
                 texnum,textures[texnum].name);
            } */
            
            texturecompositesize[texnum] += texture.height;
        }
        }   
    }

    /**
     * R_GenerateComposite
     * Using the texture definition, the composite texture is created 
     * from the patches and each column is cached. This method is "lazy"
     * aka it's only called when a cached/composite texture is needed.
     * 
     * @param texnum
     * 
     */
    
    public void GenerateComposite (int texnum) 
    {
        byte[][]       block;
        texture_t      texture;
        texpatch_t[]     patch;  
        patch_t        realpatch=null;
        int         x;
        int         x1;
        int         x2;
        column_t       patchcol;
        short[]      collump;
        char[] colofs; // unsigned short
       // short[] colidxs; // unsigned short
        
        texture = textures[texnum];

        // BOth allocate the composite texture, and assign it to block.
        // texturecompositesize indicates a size in BYTES. We need a number of columns, though.
        // Now block is divided into columns. We need to allocate enough data for each column
     
        block = texturecomposite[texnum]=new byte[texture.width][texture.height];
        
        // Lump where a certain column will be read from (actually, a patch)
        collump = texturecolumnlump[texnum];
        
        // Offset of said column into the patch.
        colofs = texturecolumnofs[texnum];
        
       // colidxs = texturecolumnindexes[texnum];
        
        // Composite the columns together.
        patch = texture.patches;
        
        // For each patch in the texture...
        for (int i=0 ;i<texture.patchcount; i++)
        {
        // Retrieve patch...if it IS a patch.
        realpatch=this.retrievePatchSafe(patch[i].patch);
            
        x1 = patch[i].originx;
        x2 = x1 + realpatch.width;

        if (x1<0)
            x = 0;
        else
            x = x1;
        
        if (x2 > texture.width)
            x2 = texture.width;

        for ( ; x<x2 ; x++)
        {
            // Column does not have multiple patches?
            if (collump[x] >= 0)
            continue;
            
           // patchcol = (column_t *)((byte *)realpatch
            //            + LONG(realpatch.columnofs[x-x1]));
            
            
            // We can look this up cleanly in Java. Ha!
            patchcol=realpatch.columns[x-x1];
            DrawColumnInCache (patchcol,
                     block[x], colofs[x],
                     patch[i].originy,
                     texture.height);
        }
                            
        }
    }
    
    /**
     * R_GenerateMaskedComposite
     * 
     * Generates a "masked composite texture": the result is a MASKED texture
     * (with see-thru holes), but this time  multiple patches can be used to 
     * assemble it, unlike standard Doom where this is not allowed.
     *  
     * Called only if a request for a texture in the general purpose GetColumn 
     * method (used only for masked renders) turns out not to be pointing to a standard 
     * cached texture, nor to a disk lump(which is the standard Doom way of indicating a 
     * composite single patch texture) but to a cached one which, however, is composite.
     * 
     * Confusing, huh?
     * 
     * Normally, this results in a disaster, as the masked rendering methods 
     * don't expect cached/composite textures at all, and you get all sorts of nasty
     * tutti frutti and medusa effects. Not anymore ;-) 
     * 
     * @param texnum
     * 
     */
    
    @Override
    public void GenerateMaskedComposite(int texnum) {
        byte[][] block;
        boolean[][] pixmap; // Solidity map
        texture_t texture;
        texpatch_t[] patch;
        patch_t realpatch = null;
        int x;
        int x1;
        int x2;
        column_t patchcol;
        short[] collump;
        char[] colofs; // unsigned short

        texture = textures[texnum];

        // MAES: we don't want to save a solid block this time. Will only use
        // it for synthesis.

        block = new byte[texture.width][texture.height];
        pixmap = new boolean[texture.width][texture.height]; // True values = solid

        // Lump where a certain column will be read from (actually, a patch)
        collump = texturecolumnlump[texnum];

        // Offset of said column into the patch.
        colofs = texturecolumnofs[texnum];

        // Composite the columns together.
        patch = texture.patches;

        // For each patch in the texture...
        for (int i = 0; i < texture.patchcount; i++) {

            realpatch = W.CachePatchNum(patch[i].patch);
            x1 = patch[i].originx;
            x2 = x1 + realpatch.width;

            if (x1 < 0)
                x = 0;
            else
                x = x1;

            if (x2 > texture.width)
                x2 = texture.width;

            for (; x < x2; x++) {
                // Column does not have multiple patches?
                if (collump[x] >= 0)
                    continue;

                // patchcol = (column_t *)((byte *)realpatch
                // + LONG(realpatch.columnofs[x-x1]));

                // We can look this up cleanly in Java. Ha!
                patchcol = realpatch.columns[x - x1];
                DrawColumnInCache(patchcol, block[x], pixmap[x], colofs[x],
                    patch[i].originy, texture.height);
            }

        }
        
        // Patch drawn on cache, synthesize patch_t using it. 
        this.patchcomposite[texnum]=MultiPatchSynthesizer.synthesize(this.CheckTextureNameForNum(texnum),block, pixmap,texture.width,texture.height);
    }
    
    /**
     *  R_DrawColumnInCache
     *  Clip and draw a column from a patch into a cached post.
     *  
     *  This means that columns are effectively "uncompressed" into cache, here,
     *  and that composite textures are generally uncompressed...right?
     *  
     *  Actually: "compressed" or "masked" textures are retrieved in the same way.
     *  There are both "masked" and "unmasked" drawing methods. If a masked
     *  column is passed to a method that expects a full, dense column...well,
     *  it will look fugly/overflow/crash. Vanilla Doom tolerated this, 
     *  we're probably going to have more problems.
     *  
     *  @param patch Actually it's a single column to be drawn. May overdraw existing ones or void space.
     *  @param cache the column cache itself. Actually it's the third level [texture][column]->data.
     *  @param offset an offset inside the column cache (UNUSED)
     *  @param originy vertical offset. Caution with masked stuff!
     *  @param cacheheight the maximum height it's supposed to reach when drawing?
     *  
     */
    
    public void DrawColumnInCache(column_t patch, byte[] cache, int offset,
            int originy, int cacheheight) {
        int count;
        int position;
        int source = 0; // treat as pointers

        /*
         * Iterate inside column. This is starkly different from the C code,
         * because post positions AND offsets are already precomputed at load
         * time
         */

        for (int i = 0; i < patch.posts; i++) {

            // This should position us at the beginning of the next post
            source = patch.postofs[i];

            count = patch.postlen[i]; // length of this particular post
            position = originy + patch.postdeltas[i]; // Position to draw inside
                                                      // cache.

            // Post starts outside of texture's bounds. Adjust offset.

            if (position < 0) {
                count += position; // Consider that we have a "drawing debt".
                position = 0;
            }

            // Post will go too far outside.
            if (position + count > cacheheight)
                count = cacheheight - position;

            if (count > 0) // Draw this post. Won't draw posts that start
                           // "outside"
                // Will start at post's start, but will only draw enough pixels
                // not to overdraw.
                System.arraycopy(patch.data, source, cache, position, count);

        }
    }
    
    
    // Version also drawing on a supplied transparency map
    public void DrawColumnInCache(column_t patch, byte[] cache,
            boolean[] pixmap, int offset, int originy, int cacheheight) {
        int count;
        int position;
        int source = 0; // treat as pointers

        /*
         * Iterate inside column. This is starkly different from the C code,
         * because post positions AND offsets are already precomputed at load
         * time
         */

        for (int i = 0; i < patch.posts; i++) {

            // This should position us at the beginning of the next post
            source = patch.postofs[i];

            count = patch.postlen[i]; // length of this particular post
            position = originy + patch.postdeltas[i]; // Position to draw inside
                                                      // cache.

            // Post starts outside of texture's bounds. Adjust offset.

            if (position < 0) {
                count += position; // Consider that we have a "drawing debt".
                position = 0;
            }

            // Post will go too far outside.
            if (position + count > cacheheight)
                count = cacheheight - position;

            if (count > 0) {
                // Draw post, AND fill solidity map
                System.arraycopy(patch.data, source, cache, position, count);
                Arrays.fill(pixmap, position, position+count, true);
            }
            // Repeat for next post(s), if any.
        }
    }

    /**
     * R_InitFlats
     *
     * Scans WADs for F_START/F_END lumps, and also any additional
     * F1_ and F2_ pairs.
     * 
     * Correct behavior would be to detect F_START/F_END lumps, 
     * and skip any marker lumps sandwiched in between. If F_START and F_END are external, 
     * use external override.
     * 
     * Also, in the presence of external FF_START lumps, merge their contents 
     * with those previously read.
     * 
     * The method is COMPATIBLE with resource pre-coalesing, however it's not 
     * trivial to change back to the naive code because of the "translationless"
     * system used (all flats are assumed to lie in a linear space). This 
     * speeds up lookups.
     *
     */
    
    @Override
    public final void InitFlats ()
    {
        numflats=0;
        int extendedflatstart=-1;
        firstflat=W.GetNumForName(LUMPSTART); // This is the start of normal lumps.
        if (FlatCache==null) FlatCache=new Hashtable<Integer,Integer>(); 
        else FlatCache.clear();
        Hashtable<String,Integer> FlatNames=new Hashtable<String,Integer> (); // Store names here.
        
        // Normally, if we don't use Boom features, we could look for F_END and that's it.
        // However we want to avoid using flat translation and instead store absolute lump numbers.
        // So we need to do a clean parse.
        
        // The rule is: we scan from the very first F_START to the very first F_END.
        // We discard markers, and only assign sequential numbers to valid lumps.
        // These are the vanilla flats, and will work with fully merged PWADs too.
        
        // Normally, this marks the end of regular lumps. However, if DEUTEX extension
        // are present, it will actually mark the end of the extensions due to lump
        // priority, so its usefulness as an absolute end-index for regular flats
        // is dodgy at best. Gotta love the inconsistent mundo hacks!
        
        //int lastflatlump=W.GetNumForName(LUMPEND);
        
		// 
        int lump=firstflat;
        int seq=0;
        String name;
        while (!(name=W.GetNameForNum(lump)).equalsIgnoreCase(LUMPEND)){
            if (!W.isLumpMarker(lump)){
                // Not a marker. Put in cache.
                FlatCache.put(lump, seq);
                // Save its name too.
                FlatNames.put(name, lump);
                seq++; // Advance sequence
                numflats++; // Total flats do increase
            }     
            lump++; // Advance lump.
        }

        
        extendedflatstart=W.CheckNumForName(DEUTEX_START); // This is the start of DEUTEX flats.
        if (extendedflatstart>-1){
       	// If extended ones are present, then Advance slowly.
        lump=extendedflatstart;
        
        // Safeguard: FF_START without corresponding F_END (e.g. in helltest.wad)
    
        name=W.GetNameForNum(lump);
            
        // The end of those extended flats is also marked by F_END or FF_END, as noted above.
        // It can also be non-existent in some broken maps like helltest.wad. Jesus.
        while (!(name==null || name.equalsIgnoreCase(LUMPEND)||name.equalsIgnoreCase(DEUTEX_END))){
            if (!W.isLumpMarker(lump)){
                // Not a marker. Check if it's supposed to replace something.
                if (FlatNames.containsKey(name)){
                    // Well, it is. Off with its name, save the lump number though.
                    int removed=FlatNames.remove(name);
                    // Put new name in list
                    FlatNames.put(name, lump);
                    // Remove old lump, but keep sequence.
                    int oldseq=FlatCache.remove(removed);
                    // Put new lump number with old sequence. 
                    FlatCache.put(lump, oldseq);
                    } else {  // Add normally
                        FlatCache.put(lump, seq);
                        // Save its name too.
                        FlatNames.put(name, lump);
                        seq++; // Advance sequence
                        numflats++; // Total flats do increase
                    }
            }
            lump++; // Advance lump.
            name=W.GetNameForNum(lump);
        }
        }
        
        // So now we have a lump -> sequence number mapping.

            // Create translation table for global animation.
            flattranslation = new int[numflats];
            flatstorage = new int[numflats];
            
            // MAJOR CHANGE: flattranslation stores absolute lump numbers. Adding
            // firstlump is not necessary anymore.      
            // Now, we're pretty sure that we have a progressive value mapping.
   
            Enumeration<Integer> stuff= FlatCache.keys();
            while (stuff.hasMoreElements()){
                int nextlump=stuff.nextElement();
                flatstorage[FlatCache.get(nextlump)]=nextlump;
                // Lump is used as the key, while the relative lump number is the value.
                //FlatCache.put(j, k-1);
                
                }
            
              for (int i=0;i<numflats;i++){
                  flattranslation[i]=i;
                //  System.out.printf("Verification: flat[%d] is %s in lump %d\n",i,W.GetNameForNum(flattranslation[i]),flatstorage[i]);  
              }
            }
    
    private final static String LUMPSTART="F_START";
    private final static String LUMPEND="F_END";
    private final static String DEUTEX_END="FF_END";
    private final static String DEUTEX_START="FF_START";
    
    /**
     * R_PrecacheLevel
     * Preloads all relevant graphics for the level.
     * 
     * MAES: Everything except sprites.
     * A Texturemanager != sprite manager.
     * So the relevant functionality has been split into
     * PrecacheThinkers (found in common rendering code).
     * 
     * 
     */
    
    
    int     flatmemory;
    int     texturememory;    

    public void PrecacheLevel () throws IOException
    {
        
        this.preCacheFlats();
        this.preCacheTextures();
        
        // recache sprites.
        
        /* MAES: this code into PrecacheThinkers
        spritepresent = new boolean[numsprites];
        
        
        for (th = P.thinkercap.next ; th != P.thinkercap ; th=th.next)
        {
        if (th.function==think_t.P_MobjThinker)
            spritepresent[((mobj_t )th).sprite.ordinal()] = true;
        }
        
        spritememory = 0;
        for (i=0 ; i<numsprites ; i++)
        {
        if (!spritepresent[i])
            continue;

        for (j=0 ; j<sprites[i].numframes ; j++)
        {
            sf = sprites[i].spriteframes[j];
            for (k=0 ; k<8 ; k++)
            {
            lump = firstspritelump + sf.lump[k];
            spritememory += W.lumpinfo[lump].size;
            W.CacheLumpNum(lump , PU_CACHE,patch_t.class);
            }
        }
        }
        */
    }
    
    protected final void preCacheFlats(){
    	boolean[]       flatpresent;
        int         lump;
        
        
        if (DM.demoplayback)
        return;
        
        // Precache flats.
        flatpresent = new boolean[numflats];
        flats=new flat_t[numflats];
        
        for (int i=0 ; i<LL.numsectors ; i++)
        {
        flatpresent[LL.sectors[i].floorpic] = true;
        flatpresent[LL.sectors[i].ceilingpic] = true;
        }
        
        flatmemory = 0;

        for (int i=0 ; i<numflats ; i++)
        {
        if (flatpresent[i])
        {
            lump = firstflat + i;
            flatmemory += W.GetLumpInfo(lump).size;
            flats[i]=(flat_t) W.CacheLumpNum(lump, PU_CACHE,flat_t.class);
        }
        }
    }
    
    protected final void preCacheTextures(){
    	boolean []      texturepresent;
        texture_t      texture;
        int lump;

    	
    	// Precache textures.
        texturepresent = new boolean[numtextures];
        
        for (int i=0 ; i<LL.numsides ; i++)
        {
        texturepresent[LL.sides[i].toptexture] = true;
        texturepresent[LL.sides[i].midtexture] = true;
        texturepresent[LL.sides[i].bottomtexture] = true;
        }

        // Sky texture is always present.
        // Note that F_SKY1 is the name used to
        //  indicate a sky floor/ceiling as a flat,
        //  while the sky texture is stored like
        //  a wall texture, with an episode dependend
        //  name.
        texturepresent[skytexture] = true;
        
        texturememory = 0;
        for (int i=0 ; i<numtextures ; i++)
        {
        if (!texturepresent[i])
            continue;

        texture = textures[i];
        
        for (int j=0 ; j<texture.patchcount ; j++)
        {
            lump = texture.patches[j].patch;
            texturememory += W.GetLumpInfo(lump).size;
            W.CacheLumpNum(lump , PU_CACHE,patch_t.class);
        }
        }
    }
    
    /**
     * R_FlatNumForName
     * Retrieval, get a flat number for a flat name.
     * 
     * Unlike the texture one, this one is not used frequently. Go figure.
     */
     
    @Override
    public final int FlatNumForName(String name) {
        int i;
        
        //System.out.println("Checking for "+name);

        i = W.CheckNumForName(name);

        //System.out.printf("R_FlatNumForName retrieved lump %d for name %s picnum %d\n",i,name,FlatCache.get(i));
        if (i == -1) {
            I.Error("R_FlatNumForName: %s not found", name);
        }

        return FlatCache.get(i);

    }

    @Override
    public final int getTextureColumnLump(int tex, int col) {
        return texturecolumnlump[tex][col];
    }


    @Override
    public final char getTextureColumnOfs(int tex, int col) {
        return texturecolumnofs[tex][col];
    }

    @Override
    public final int getTexturewidthmask(int tex) {
        return texturewidthmask[tex];
    }

    @Override
    public final byte[][] getTextureComposite(int tex) {       
        return texturecomposite[tex];
    }

    @Override
    public final byte[] getTextureComposite(int tex, int col) {
        return texturecomposite[tex][col];
    }
    
    @Override
    public final patch_t getMaskedComposite(int tex) {       
        return this.patchcomposite[tex];
    }
    
    @Override
    public final int getTextureheight(int texnum) {
            return textureheight[texnum];
    }

    @Override
    public final int getTextureTranslation(int texnum) {
        return texturetranslation[texnum];
    }
    
    /** Returns a flat after it has been modified by the translation table e.g. by animations */
    @Override
    public int getFlatTranslation(int flatnum) {
        return flatstorage[flattranslation[flatnum]];
    }

    @Override
    public final void setTextureTranslation(int texnum, int amount) {
        texturetranslation[texnum]=amount;
    }
    
    /** This affects ONLY THE TRANSLATION TABLE, not the lump storage.
     * 
     */
    
    @Override
    public final void setFlatTranslation(int flatnum, int amount) {
        flattranslation[flatnum]=amount;
    }
    

    
    //////////////////////////////////From r_sky.c /////////////////////////////////////

//////////////////////////////////From r_sky.c /////////////////////////////////////

    /**
     * R_InitSkyMap
     * Called whenever the view size changes.
     */

    public int InitSkyMap ()
    {
        skyflatnum = FlatNumForName ( SKYFLATNAME );
        skytexturemid = 100*FRACUNIT;
        return skyflatnum;
    }

    @Override
    public int getSkyFlatNum() {
        return skyflatnum;
    }

    @Override
    public void setSkyFlatNum(int skyflatnum) {
        this.skyflatnum = skyflatnum;
    }



    @Override
    public int getSkyTexture() {
        return skytexture;
    }

    @Override
    public void setSkyTexture(int skytexture) {
        this.skytexture = skytexture;
    }

    /*@Override
    public int getFirstFlat() {
        return firstflat;
    } */

    @Override
    public int getSkyTextureMid() {
        return skytexturemid;
    }

    @Override
    public String CheckTextureNameForNum(int texnum) {       
        return textures[texnum].name;
    }

    @Override
    public int getFlatLumpNum(int flatnum) {
        // TODO Auto-generated method stub
        return 0;
    }
    
    /** Generates a "cached" masked column against a black background.
     *  Synchronized so concurrency issues won't cause random glitching and
     *  errors.
     * 
     * @param lump
     * @param column
     * @return raw, 0-pointed column data.
     */    
    public synchronized byte[] getRogueColumn(int lump, int column) {
		
		// If previously requested, speed up gathering.
		//if (lastrogue==lump)
        //	return rogue[column];
		
		// Not contained? Generate.
		if (!roguePatches.containsKey(lump))
			roguePatches.put(lump,generateRoguePatch(lump));
		
		lastrogue=lump;		
		rogue=roguePatches.get(lump);
		
		return rogue[column];
	}
	
	
	/** Actually generates a tutti-frutti-safe cached patch out of
	 * a masked or unmasked single-patch lump.
	 * 
	 * @param lump
	 * @return
	 */
	
	private byte[][] generateRoguePatch(int lump) {
        // Retrieve patch...if it IS a patch.
        patch_t p=this.retrievePatchSafe(lump);		

		// Allocate space for a cached block.
		byte[][] block=new byte[p.width][p.height];
		
		
		for (int i=0;i<p.width;i++)
			DrawColumnInCache(p.columns[i], block[i], i, 0, p.height);
		
		// Don't keep this twice in memory.
		W.UnlockLumpNum(lump);
		return block;
	}

	int lastrogue=-1;
	byte[][] rogue;
	
	
	HashMap<Integer,byte[][]> roguePatches= new HashMap<Integer,byte[][]> ();
    
	class TextureDirectoryEntry implements Comparable<TextureDirectoryEntry>{
	    /** Where an entry starts within the TEXTUREx lump */
	    int offset;
	    /** Its implicit position as indicated by the directory's ordering */
	    int entry;
	    /** Its MAXIMUM possible length, depending on what follows it. 
	     *  Not trivial to compute without thoroughtly examining the entire lump */
	    int length;
	    
	    /** Entries are ranked according to actual offset */
        @Override
        public int compareTo(TextureDirectoryEntry o) {
            if (this.offset<o.offset) return -1;
            if (this.offset==o.offset) return 0;
            return 1;
        }
	 }

    @Override
    public byte[] getSafeFlat(int flatnum) {
        byte[] flat= ((flat_t)W.CacheLumpNum(getFlatTranslation(flatnum),
            PU_STATIC,flat_t.class)).data;

        if (flat.length<4096){
            System.arraycopy(flat, 0,safepatch,0,flat.length);
            return safepatch;
        }
        
        return flat;
    }
	
    private final byte[] safepatch=new byte[4096];
    
    // COLUMN GETTING METHODS. No idea why those had to be in the renderer...
    
    /**
     * Special version of GetColumn meant to be called concurrently by different
     * (MASKED) seg rendering threads, identfiex by index. This serves to avoid stomping
     * on mutual cached textures and causing crashes.
     * 
     * Returns column_t, so in theory it could be made data-agnostic.
     * 
     */

    public column_t GetSmpColumn(int tex, int col, int id) {
        int lump,ofs;

        col &= getTexturewidthmask(tex);
        lump = getTextureColumnLump(tex, col);
        ofs = getTextureColumnOfs(tex, col);

        // It's always 0 for this kind of access.

        // Speed-increasing trick: speed up repeated accesses to the same
        // texture or patch, if they come from the same lump
        
        if (tex == smp_lasttex[id] && lump == smp_lastlump[id]) {
            if (composite)
                return smp_lastpatch[id].columns[col];
            else
                return smp_lastpatch[id].columns[ofs];
            }

        // If pointing inside a non-zero, positive lump, then it's not a
        // composite texture. Read it from disk.
        if (lump > 0) {
            // This will actually return a pointer to a patch's columns.
            // That is, to the ONE column exactly.{
            // If the caller needs access to a raw column, we must point 3 bytes
            // "ahead".
            smp_lastpatch[id] = W.CachePatchNum(lump);
            smp_lasttex[id] = tex;
            smp_lastlump[id]=lump;
            smp_composite[id]=false;
            // If the column was a disk lump, use ofs.
            return smp_lastpatch[id].columns[ofs];
        }
        
        // Problem. Composite texture requested as if it was masked
        // but it doesn't yet exist. Create it.
        if (getMaskedComposite(tex) == null){
            System.err.printf("Forced generation of composite %s\n",CheckTextureNameForNum(tex),smp_composite[id],col,ofs);
            GenerateMaskedComposite(tex);
            System.err.printf("Composite patch %s %d\n",getMaskedComposite(tex).name,getMaskedComposite(tex).columns.length);
        }
        
        // Last resort. 
        smp_lastpatch[id] = getMaskedComposite(tex);
        smp_lasttex[id]=tex;
        smp_composite[id]=true;
        smp_lastlump[id]=0;
        
        return lastpatch.columns[col];
    }

    // False: disk-mirrored patch. True: improper "transparent composite".
    protected boolean[] smp_composite;// = false;
    protected int[] smp_lasttex;// = -1;
    protected int[] smp_lastlump;// = -1;
    protected patch_t[] smp_lastpatch;// = null;
    
///////////////////////// TEXTURE MANAGEMENT /////////////////////////

    /**
     * R_GetColumn original version: returns raw pointers to byte-based column
     * data. Works for both masked and unmasked columns, but is not
     * tutti-frutti-safe.
     * 
     * Use GetCachedColumn instead, if rendering non-masked stuff, which is also
     * faster.
     * 
     * @throws IOException
     * 
     * 
     */

    public byte[] GetColumn(int tex, int col) {
        int lump,ofs;

        col &= getTexturewidthmask(tex);
        lump = getTextureColumnLump(tex, col);
        ofs = getTextureColumnOfs(tex, col);

        // It's always 0 for this kind of access.

        // Speed-increasing trick: speed up repeated accesses to the same
        // texture or patch, if they come from the same lump
        
        if (tex == lasttex && lump == lastlump) {
            if (composite)
                return lastpatch.columns[col].data;
            else
                return lastpatch.columns[ofs].data;
            }

        // If pointing inside a non-zero, positive lump, then it's not a
        // composite texture. Read it from disk.
        if (lump > 0) {
            // This will actually return a pointer to a patch's columns.
            // That is, to the ONE column exactly.{
            // If the caller needs access to a raw column, we must point 3 bytes
            // "ahead".
            lastpatch = W.CachePatchNum(lump);
            lasttex = tex;
            lastlump=lump;
            composite=false;
            // If the column was a disk lump, use ofs.
            return lastpatch.columns[ofs].data;
        }
        
        // Problem. Composite texture requested as if it was masked
        // but it doesn't yet exist. Create it.
        if (getMaskedComposite(tex) == null){
            System.err.printf("Forced generation of composite %s\n",CheckTextureNameForNum(tex),composite,col,ofs);
            GenerateMaskedComposite(tex);
            System.err.printf("Composite patch %s %d\n",getMaskedComposite(tex).name,getMaskedComposite(tex).columns.length);
        }
        
        // Last resort. 
        lastpatch = getMaskedComposite(tex);
        lasttex=tex;
        composite=true;
        lastlump=0;
        
        return lastpatch.columns[col].data;
    }
    
    /**
     * R_GetColumnStruct: returns actual pointers to columns.
     * Agnostic of the underlying type. 
     * 
     * Works for both masked and unmasked columns, but is not
     * tutti-frutti-safe.
     * 
     * Use GetCachedColumn instead, if rendering non-masked stuff, which is also
     * faster.
     * 
     * @throws IOException
     * 
     * 
     */

    @Override
    public column_t GetColumnStruct(int tex, int col) {
        int lump,ofs;

        col &= getTexturewidthmask(tex);
        lump = getTextureColumnLump(tex, col);
        ofs = getTextureColumnOfs(tex, col);

        // Speed-increasing trick: speed up repeated accesses to the same
        // texture or patch, if they come from the same lump
        
        if (tex == lasttex && lump == lastlump) {
            if (composite)
                return lastpatch.columns[col];
            else
                return lastpatch.columns[ofs];
            }

        // If pointing inside a non-zero, positive lump, then it's not a
        // composite texture. Read it from disk.
        if (lump > 0) {
            // This will actually return a pointer to a patch's columns.
            // That is, to the ONE column exactly.{
            // If the caller needs access to a raw column, we must point 3 bytes
            // "ahead".
            lastpatch = W.CachePatchNum(lump);
            lasttex = tex;
            lastlump=lump;
            composite=false;
            // If the column was a disk lump, use ofs.
            return lastpatch.columns[ofs];
        }
        
        // Problem. Composite texture requested as if it was masked
        // but it doesn't yet exist. Create it.
        if (getMaskedComposite(tex) == null){
            System.err.printf("Forced generation of composite %s\n",CheckTextureNameForNum(tex),composite,col,ofs);
            GenerateMaskedComposite(tex);
            System.err.printf("Composite patch %s %d\n",getMaskedComposite(tex).name,getMaskedComposite(tex).columns.length);
        }
        
        // Last resort. 
        lastpatch = getMaskedComposite(tex);
        lasttex=tex;
        composite=true;
        lastlump=0;
        
        return lastpatch.columns[col];
    }

    // False: disk-mirrored patch. True: improper "transparent composite".
    private boolean composite = false;
    private int lasttex = -1;
    private int lastlump = -1;
    private patch_t lastpatch = null;

    
    
    /**
     * R_GetColumn variation which is tutti-frutti proof. It only returns cached
     * columns, and even pre-caches single-patch textures intead of trashing the
     * WAD manager (should be faster, in theory).
     * 
     * Cannot be used for drawing masked textures, use classic GetColumn
     * instead.
     * 
     * 
     * @throws IOException
     */
    @Override
    public final byte[] GetCachedColumn(int tex, int col) {
        int lump, ofs;

        col &= getTexturewidthmask(tex);
        lump = getTextureColumnLump(tex, col);
        ofs = getTextureColumnOfs(tex, col);

        // In the case of cached columns, this is always 0.
        // Done externally, for now.
        //dcvars.dc_source_ofs = 0;

        // If pointing inside a non-zero, positive lump, then it's not a
        // composite texture.
        // Read from disk, and safeguard vs tutti frutti.
        if (lump > 0) {
            // This will actually return a pointer to a patch's columns.
            return getRogueColumn(lump, ofs);
        }

        // Texture should be composite, but it doesn't yet exist. Create it.
        if (getTextureComposite(tex) == null)
            GenerateComposite(tex);

        return getTextureComposite(tex, col);
    }

    @Override
    public void setSMPVars(int num_threads) {
        smp_composite=new boolean[num_threads];// = false;
        smp_lasttex=new int[num_threads];// = -1;
        smp_lastlump=new int[num_threads];// = -1;
        smp_lastpatch=new patch_t[num_threads];// = null;        
    }

    
}

package rr;

/** Purpose unknown, probably unused.
 *  On a closer examination, it could have been part of a system to
 *  "enqueue" masked draws, not much unlike the current parallel
 *  rendering subsystem, but discarded because of simplifications.
 *  In theory it could be brought back one day if parallel sprite
 *  drawing comes back.. just a thought ;-)
 * 
 * 
 * @author Maes
 *
 */

public class maskdraw_t {
        public int     x1;
        public  int     x2;
        
        public  int     column;
        public  int     topclip;
        public  int     bottomclip;

    }
package rr;
import v.IVideoScaleAware;

/** Draws any masked stuff -sprites, textures, or special 3D floors */

public interface IMaskedDrawer<T,V>
        extends IVideoScaleAware,IDetailAware {

    public static final int BASEYCENTER = 100;
    
    /** Cache the sprite manager, if possible */

    void cacheSpriteManager(ISpriteManager SM);

    void DrawMasked();

    void setPspriteIscale(int i);

    void setPspriteScale(int i);

    /**
     * For serial masked drawer, just complete the column function. For
     * parallel version, store rendering instructions and execute later on.
     * HINT: you need to discern between masked and non-masked draws.
     */

    void completeColumn();
}

package rr;

     
/** Stuff used to pass information between the BSP and the SegDrawer */

public class BSPVars{
/** The sectors of the line currently being considered */
public sector_t frontsector, backsector;
public seg_t curline;
public side_t sidedef;
public line_t linedef;
}

package rr;

import static data.Defines.PU_CACHE;
import static m.fixed_t.FRACBITS;

import i.DoomStatusAware;
import i.IDoomSystem;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.List;

import doom.DoomStatus;

import utils.C2JUtils;
import w.IWadLoader;
import w.lumpinfo_t;

/** An stand-alone sprite loader. Surprisingly, it is quite a 
 *  separate concern from the renderer, and only needs to communicate 
 *  occasionally through its getters with the rest of the stuff.
 *  
 *  Helped lighten up the rendering code a lot, too.
 * 
 * @author Maes
 *
 */

public class SpriteManager implements ISpriteManager, DoomStatusAware{
	    
	    /** There seems to be an arbitrary limit of 29 distinct frames per THING */
	    public static final int MAX_SPRITE_FRAMES = 29;
	    
        private SpriteManager(){
            sprtemp = new spriteframe_t[MAX_SPRITE_FRAMES];
            C2JUtils.initArrayOfObjects(sprtemp);
        }
	    
        public SpriteManager(DoomStatus DC) {
            this();
            this.updateStatus(DC);
        }

        // Temporarily contains the frames of a given sprite before they are
        // registered with the rendering system. Apparently, a maximum of 29 frames
        // per sprite is allowed.
        protected spriteframe_t[] sprtemp = new spriteframe_t[29];
        protected int maxframe;
        protected String spritename;
        
        // MAES: Shit taken from things

        protected int firstspritelump;
        protected int lastspritelump;
        protected int numspritelumps;
	    
        // variables used to look up and range check thing_t sprites patches
        //
        protected spritedef_t[] sprites;
        
        protected int numsprites;
        
        /** needed for pre rendering (fixed_t[]) */
        protected int[] spritewidth, spriteoffset, spritetopoffset;

        
	    //
        // R_InitSpriteDefs
        // Pass a null terminated list of sprite names
        // (4 chars exactly) to be used.
        //
        // Builds the sprite rotation matrixes to account
        // for horizontally flipped sprites.
        //
        // Will report an error if the lumps are inconsistent.
        // Only called at startup.
        //
        // Sprite lump names are 4 characters for the actor,
        // a letter for the frame, and a number for the rotation.
        //
        // A sprite that is flippable will have an additional
        // letter/number appended.
        //
        // The rotation character can be 0 to signify no rotations.
        //
        // 1/25/98, 1/31/98 killough : Rewritten for performance
        //
        // Empirically verified to have excellent hash
        // properties across standard Doom sprites:

        protected final void InitSpriteDefs(String[] namelist) {
            int numentries = lastspritelump - firstspritelump + 1;
            Hashtable<Integer, List<Integer>> hash;
            int i;

            if (numentries == 0 || namelist == null)
                return;

            // count the number of sprite names
            i = namelist.length;

            numsprites = i;

            sprites = new spritedef_t[numsprites];
            C2JUtils.initArrayOfObjects(sprites);

            // Create hash table based on just the first four letters of each
            // sprite
            // killough 1/31/98
            // Maes: the idea is to have a chained hastable which can handle
            // multiple entries (sprites) on the same primary key (the 4 first chars of
            // the sprite name)

            hash = new Hashtable<Integer, List<Integer>>(numentries); // allocate
                                                                        // hash
                                                                        // table

            // We have to trasverse this in the opposite order, so that later
            // lumps
            // trump previous ones in order.
            for (i = numentries - 1; i >= 0; i--) {
                int hashcode = SpriteNameHash(W.GetLumpInfo(i + firstspritelump).name);
                // Create chain list for each sprite class (e.g. TROO, POSS,
                // etc.)
                //
                if (!hash.containsKey(hashcode)) {
                    hash.put(hashcode, new ArrayList<Integer>());
                }

                // Store (yet another) lump index for this sprite.
                hash.get(hashcode).add(i);
            }

            // scan all the lump names for each of the names,
            // noting the highest frame letter.

            for (i = 0; i < numsprites; i++) {

                // We only look for entries that are known to be sprites.
                // The hashtable may contain a lot of other shit, at this point
                // which will be hopefully ignored.
                String spritename = namelist[i];
                List<Integer> list = hash.get(SpriteNameHash(spritename));

                // Well, it may have been something else. Fuck it.
                if (list != null && !list.isEmpty()) {

                    // Maes: the original code actually set everything to "-1"
                    // here, including the
                    // "boolean" rotate value. The idea was to create a
                    // "tristate" of sorts, where -1
                    // means a sprite of uncertain status. Goto
                    // InstallSpriteLumps for more.
                    for (int k = 0; k < sprtemp.length; k++) {
                        Arrays.fill(sprtemp[k].flip, (byte) -1);
                        Arrays.fill(sprtemp[k].lump, (short) -1);
                        // This should be INDETERMINATE at this point.
                        sprtemp[k].rotate = -1;
                    }
                    maxframe = -1;

                    // What is stored in the lists are all actual lump numbers
                    // relative
                    // to e.g. TROO. In coalesced lumps, there will be overlap.
                    // This procedure should, in theory, trump older ones.

                    for (Integer j : list) {

                        lumpinfo_t lump = W.GetLumpInfo(j + firstspritelump);

                        // We don't know a-priori which frames exist.
                        // However, we do know how to interpret existing ones,
                        // and have an implicit maximum sequence of 29 Frames.
                        // A frame can also hame multiple rotations.

                        if (lump.name.substring(0, 4).equalsIgnoreCase(
                                spritename.substring(0, 4))) {

                            int frame = lump.name.charAt(4) - 'A';
                            int rotation = lump.name.charAt(5) - '0';

                            if (sprtemp[frame].rotate != -1) {
                                // We already encountered this sprite, but we
                                // may need to trump it with something else

                            }

                            InstallSpriteLump(j + firstspritelump, frame,
                                    rotation, false);
                            if (lump.name.length() >= 7) {
                                frame = lump.name.charAt(6) - 'A';
                                rotation = lump.name.charAt(7) - '0';
                                InstallSpriteLump(j + firstspritelump, frame,
                                        rotation, true);
                            }
                        }
                    }

                    // check the frames that were found for completeness
                    if ((sprites[i].numframes = ++maxframe) != 0) // killough
                                                                    // 1/31/98
                    {
                        int frame;
                        for (frame = 0; frame < maxframe; frame++)
                            switch ((int) sprtemp[frame].rotate) {
                            case -1:
                                // no rotations were found for that frame at all
                                I.Error("R_InitSprites: No patches found for %s frame %c",
                                        namelist[i], frame + 'A');
                                break;

                            case 0:
                                // only the first rotation is needed
                                break;

                            case 1:
                                // must have all 8 frames
                            {
                                int rotation;
                                for (rotation = 0; rotation < 8; rotation++)
                                    if (sprtemp[frame].lump[rotation] == -1)
                                        I.Error("R_InitSprites: Sprite %s frame %c is missing rotations",
                                                namelist[i], frame + 'A');
                                break;
                            }
                            }
                        // allocate space for the frames present and copy
                        // sprtemp to it
                        // MAES: we can do that elegantly in one line.

                        sprites[i].copy(sprtemp, maxframe);
                    }

                }
            }

        }
        
        /**
         * R_InitSpriteLumps Finds the width and hoffset of all sprites in the wad,
         * so the sprite does not need to be cached completely just for having the
         * header info ready during rendering.
         */

        public void InitSpriteLumps() {
            int i;
            patch_t patch;

            firstspritelump = W.GetNumForName("S_START") + 1;
            lastspritelump = W.GetNumForName("S_END") - 1;

            numspritelumps = lastspritelump - firstspritelump + 1;
            spritewidth = new int[numspritelumps];
            spriteoffset = new int[numspritelumps];
            spritetopoffset = new int[numspritelumps];

            for (i = 0; i < numspritelumps; i++) {
                if ((i & 63) == 0)
                    System.out.print(".");

                patch = (patch_t) W.CacheLumpNum(firstspritelump + i, PU_CACHE,
                        patch_t.class);
                spritewidth[i] = patch.width << FRACBITS;
                spriteoffset[i] = patch.leftoffset << FRACBITS;
                spritetopoffset[i] = patch.topoffset << FRACBITS;
            }
        }
        
        /**
         * R_InstallSpriteLump Local function for R_InitSprites.
         * 
         * Boom function, more suited to resource coalescing.
         * 
         */

        public final void InstallSpriteLump(int lump, int frame,
                int rotation, boolean flipped) {
            if (frame >= MAX_SPRITE_FRAMES || rotation > 8)
                I.Error("R_InstallSpriteLump: Bad frame characters in lump %d",
                        lump);

            if ((int) frame > maxframe)
                maxframe = frame;

            if (rotation == 0) { // the lump should be used for all rotations
                int r;
                for (r = 0; r < 8; r++)
                    if (sprtemp[frame].lump[r] == -1) {
                        sprtemp[frame].lump[r] = lump - firstspritelump;
                        sprtemp[frame].flip[r] = (byte) (flipped ? 1 : 0);
                        sprtemp[frame].rotate = 0; // jff 4/24/98 if any subbed,
                                                    // rotless
                    }
                return;
            }

            // the lump is only used for one rotation

            if (sprtemp[frame].lump[--rotation] == -1) {
                sprtemp[frame].lump[rotation] = lump - firstspritelump;
                sprtemp[frame].flip[rotation] = (byte) (flipped ? 1 : 0);
                sprtemp[frame].rotate = 1; // jff 4/24/98 only change if rot
                                            // used
            }
        }

        /**
         * R_InitSprites Called at program start.
         * 
         */

        @Override
        public void InitSprites(String[] namelist) {
            InitSpriteDefs(namelist);
        }
        
        
        protected final int SpriteNameHash(String ss) {
            return ss.substring(0, 4).hashCode();
        }
        
        // GETTERS
        
        @Override
        public final int getFirstSpriteLump(){
            return firstspritelump;
        }
        
        @Override
        public final int getNumSprites(){
            return numsprites;
        }

        @Override
        public final spritedef_t[] getSprites() {
            return sprites;
        }
        
        @Override
        public final spritedef_t getSprite(int index) {
            return sprites[index];
        }
        
        @Override
        public final int[] getSpriteWidth() {
            return spritewidth;
        }

        @Override
        public final int[] getSpriteOffset() {
            return spriteoffset;
        }

        @Override
        public final int[] getSpriteTopOffset() {
            return spritetopoffset;
        }

        @Override
        public final int getSpriteWidth(int index) {
            return spritewidth[index];
        }

        @Override
        public final int getSpriteOffset(int index) {
            return spriteoffset[index];
        }

        @Override
        public final int getSpriteTopOffset(int index) {
            return spritetopoffset[index];
        }

        /////////// STATUS ///////////
        
        @Override
        public void updateStatus(DoomStatus DC) {
            this.W=DC.W;
            this.I=DC.I;
            }
        
        protected IWadLoader W;
        protected IDoomSystem I;




        // Some unused shit
         
         /*
         * R_InstallSpriteLump Local function for R_InitSprites.
         * 
         * Older function, closer to linuxdoom. Using Boom-derived one instead.
         */ 
        
          /*
        protected final void InstallSpriteLump(int lump, int frame,
                int rotation, boolean flipped) {

            // System.out.println("Trying to install "+spritename+" Frame "+
            // (char)('A'+frame)+" rot "+(rotation)
            // +" . Should have rotations: "+sprtemp[frame].rotate);
            int r;

            if (frame >= 29 || rotation > 8)
                I.Error("R_InstallSpriteLump: Bad frame characters in lump %i",
                        lump);

            if ((int) frame > maxframe)
                maxframe = frame;

            // A rotation value of 0 means that we are either checking the first
            // frame of a sprite that HAS rotations, or something that has no
            // rotations at all. The value of rotate doesn't really help us
            // discern here, unless set to "false" a-priori...which can't happen
            // ?!

            if (rotation == 0) {
                
                 // MAES: notice how comparisons are done with strict literals
                 // (true and false) which are actually defined to be 0 and 1,
                 // rather than assuming that true is "any nonzero value". This
                 // happens because rotate's value could be -1 at this point (!),
                 // if a series of circumstances occur. Therefore it's actually a
                 // "tri-state", and the comparison 0==false and
                 // "anything else"==true was not good enough in this case. A
                 // value of -1 doesn't yield either true or false here.
                
                // the lump should be used for all rotations
                if (sprtemp[frame].rotate == 0) {
                    
                     // MAES: Explanation: we stumbled upon this lump before, and
                     // decided that this frame should have no more rotations,
                     // hence we found an error and we bomb everything.
                    
                    I.Error("R_InitSprites: Sprite %s frame %c has multiple rot=0 lump",
                            spritename, 'A' + frame);
                }

                // This should NEVER happen!
                if (sprtemp[frame].rotate == 1) {
                    
                     // MAES: This can only happen if we decided that a sprite's
                     // frame was already decided to have rotations, but now we
                     // stumble upon another occurence of "rotation 0". Or if you
                     // use naive true/false evaluation for .rotate ( -1 is also
                     // an admissible value).

                    I.Error("R_InitSprites: Sprite %s frame %c has rotations and a rot=0 lump",
                            spritename, 'A' + frame);
                }

                // Rotation is acknowledged to be totally false at this point.
                sprtemp[frame].rotate = 0;
                for (r = 0; r < 8; r++) {
                    sprtemp[frame].lump[r] = (short) (lump - firstspritelump);
                    sprtemp[frame].flip[r] = (byte) (flipped ? 1 : 0);
                }
                return;
            }

            // the lump is only used for one rotation
            if (sprtemp[frame].rotate == 0)
                I.Error("R_InitSprites: Sprite %s frame %c has rotations and a rot=0 lump",
                        spritename, 'A' + frame);

            sprtemp[frame].rotate = 1;

            // make 0 based
            rotation--;
            if (sprtemp[frame].lump[rotation] == -1) {
                // FUN FACT: with resource coalesing, this is no longer an
                // error.
                // I.Error
                // ("R_InitSprites: Sprite %s : %c : %c has two lumps mapped to it",
                // spritename, 'A'+frame, '1'+rotation);

                // Everything is OK, we can bless the temporary sprite's frame's
                // rotation.
                sprtemp[frame].lump[rotation] = (short) (lump - firstspritelump);
                sprtemp[frame].flip[rotation] = (byte) (flipped ? 1 : 0);
                sprtemp[frame].rotate = 1; // jff 4/24/98 only change if rot
                                            // used
            }
        }
        */

        

        /*
         * OLDER, UNUSED VERSION
         * 
         * R_InitSpriteDefs Pass a null terminated list of sprite names (4 chars
         * exactly) to be used. Builds the sprite rotation matrixes to account
         * for horizontally flipped sprites. Will report an error if the lumps
         * are inconsistent. Only called at startup.
         * 
         * Sprite lump names are 4 characters for the actor, a letter for the
         * frame, and a number for the rotation. A sprite that is flippable will
         * have an additional letter/number appended. The rotation character can
         * be 0 to signify no rotations.
         */

    /*  public void InitSpriteDefs2(String[] namelist) {

            int intname;
            int frame;
            int rotation;
            int start;
            int end;
            int patched;

            if (namelist == null)
                return;
            numsprites = namelist.length;

            if (numsprites == 0)
                return;

            sprites = new spritedef_t[numsprites];
            C2JUtils.initArrayOfObjects(sprites);

            start = firstspritelump - 1;
            end = lastspritelump + 1;

            // scan all the lump names for each of the names,
            // noting the highest frame letter.
            // Just compare 4 characters as ints
            for (int i = 0; i < numsprites; i++) {
                // System.out.println("Preparing sprite "+i);
                spritename = namelist[i];

                // The original code actually set everything to "-1"
                // here, including the "boolean" rotate value. The idea was 
                // to create a "tristate" of sorts, where -1 means a 
                // sprite of uncertain status. Goto InstallSpriteLumps
                // for more.
                for (int j = 0; j < sprtemp.length; j++) {
                    Arrays.fill(sprtemp[j].flip, (byte) -1);
                    Arrays.fill(sprtemp[j].lump, (short) -1);
                    // This should be INDETERMINATE at this point.
                    sprtemp[j].rotate = -1;
                }

                maxframe = -1;
                intname = name8.getIntName(namelist[i].toUpperCase());

                // scan the lumps,
                // filling in the frames for whatever is found
                for (int l = start + 1; l < end; l++) {
                    // We HOPE it has 8 characters.
                    char[] cname = W.GetLumpInfo(l).name.toCharArray();
                    if (cname.length == 6 || cname.length == 8) // Sprite names
                                                                // must be this
                                                                // way

                        // If the check is successful, we keep looking for more
                        // frames
                        // for a particular sprite e.g. TROOAx, TROOHxHy etc.
                        //
                        if (W.GetLumpInfo(l).intname == intname) {
                            frame = cname[4] - 'A';
                            rotation = cname[5] - '0';

                            if (DM.modifiedgame)
                                patched = W
                                        .GetNumForName(W.GetLumpInfo(l).name);
                            else
                                patched = l;

                            InstallSpriteLump2(patched, frame, rotation, false);

                            // Second set of rotations?
                            if (cname.length > 6 && cname[6] != 0) {
                                frame = cname[6] - 'A';
                                rotation = cname[7] - '0';
                                InstallSpriteLump2(l, frame, rotation, true);
                            }
                        }
                }

                // check the frames that were found for completeness
                // This can only be -1 at this point if we didn't install
                // a single frame successfuly.
                //
                if (maxframe == -1) {
                    // System.out.println("Sprite "+spritename+" has no frames!");
                    getSprites()[i].numframes = 0;
                    // We move on to the next sprite with this one.
                    continue;
                }

                maxframe++;

                for (frame = 0; frame < maxframe; frame++) {
                    switch ((int) sprtemp[frame].rotate) {
                    case -1:
                        // no rotations were found for that frame at all
                        I.Error("R_InitSprites: No patches found for %s frame %c",
                                namelist[i], frame + 'A');
                        break;

                    case 0:
                        // only the first rotation is needed
                        break;

                    case 1:
                        // must have all 8 frames
                        for (rotation = 0; rotation < 8; rotation++)
                            if (sprtemp[frame].lump[rotation] == -1)
                                I.Error("R_InitSprites: Sprite %s frame %c is missing rotations",
                                        namelist[i], frame + 'A');
                        break;
                    }
                }

                // allocate space for the frames present and copy sprtemp to it
                // MAES: we can do that elegantly in one line.

                sprites[i].copy(sprtemp, maxframe);

                // sprites[i].numframes = maxframe;
                // sprites[i].spriteframes = new spriteframe_t[maxframe];
                // C2JUtils.initArrayOfObjects(sprites[i].spriteframes,spriteframe_t.class);

                // for (int j=0;j<)
                // System.arraycopy(src, srcPos, dest, destPos, length)
                // memcpy (sprites[i].spriteframes, sprtemp,
                // maxframe*sizeof(spriteframe_t));
            }

        }
        */
        
	}


package rr;

import java.io.IOException;
import java.nio.ByteBuffer;

import w.CacheableDoomObject;

public class flat_t
        implements CacheableDoomObject {

    public static final int FLAT_SIZE=4096;
    
    public byte[] data;

    public flat_t(){
        this.data=new byte[FLAT_SIZE];
    }

    public flat_t(int size){
        this.data=new byte[size];
    }

    
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        
            //buf.get(this.data);
            this.data=buf.array();

    }

}

package rr;

import static data.Tables.FINEANGLES;
import static m.fixed_t.FRACUNIT;
import rr.drawfuns.ColFuncs;
import rr.drawfuns.ColVars;
import rr.drawfuns.SpanVars;
import i.DoomStatusAware;
import i.IDoomSystem;
import v.IVideoScaleAware;
import w.IWadLoader;
import doom.player_t;

public interface Renderer<T,V> extends IVideoScaleAware,DoomStatusAware{
	


	/** Fineangles in the SCREENWIDTH wide window. */
	public static final int FIELDOFVIEW = FINEANGLES / 4;
	
	public static final int MINZ = (FRACUNIT * 4);

	
	public static final int FUZZTABLE = 50;
	
	/**
	 * killough: viewangleoffset is a legacy from the pre-v1.2 days, when Doom
	 * had Left/Mid/Right viewing. +/-ANG90 offsets were placed here on each
	 * node, by d_net.c, to set up a L/M/R session.
	 */

	public static final long viewangleoffset = 0;
	
	
	public void Init();
	
	public void RenderPlayerView(player_t player);
	
	public void ExecuteSetViewSize();
	
	public void FillBackScreen();
	
	public void DrawViewBorder();
	
	public void SetViewSize(int size, int detaillevel);
	
	public void VideoErase(int offset, int width);
	
	public long PointToAngle2(int x1, int y1, int x2, int y2);
	
	public void PreCacheThinkers();
	
	public int getValidCount();
	
	public void increaseValidCount(int amount);

	public boolean isFullHeight();

	public void resetLimits();

	public boolean getSetSizeNeeded();
	
	public boolean isFullScreen();

	// Isolation methods
	
	public TextureManager<T> getTextureManager();
	
	public PlaneDrawer<T,V> getPlaneDrawer();

    public ViewVars getView();

    public SpanVars<T, V> getDSVars();

    public LightsAndColors<V> getColorMap();

    public IDoomSystem getDoomSystem();
    
    public IWadLoader getWadLoader();

    /** Use this to "peg" visplane drawers (even parallel ones) to
     *  the same set of visplane variables.
     *  
     * @return
     */
    
    public Visplanes getVPVars();

    public SegVars getSegVars();

    public ISpriteManager getSpriteManager();

    public BSPVars getBSPVars();

    public IVisSpriteManagement<V> getVisSpriteManager();

    public ColFuncs<T,V> getColFuncsHi();
    public ColFuncs<T,V> getColFuncsLow();

    public ColVars<T, V> getMaskedDCVars();
    
	
	//public subsector_t PointInSubsector(int x, int y);

}

package rr;

public class cliprange_t {

    public cliprange_t(int first, int last) {
        this.first = first;
        this.last = last;
    }

    public cliprange_t(){
        
    }
    
    public int first;
    public int last;
    
    public void copy(cliprange_t from){
        this.first=from.first;
        this.last=from.last;
    }
}

package rr;

/**
 * A sprite definition:
 * a number of animation frames.
 */

public class spritedef_t {

    /** the very least, primitive fields won't bomb,
     *  and copy constructors can do their job.
     */
    public spritedef_t(){        
    }
    
    public spritedef_t(int numframes){
        this.numframes=numframes;
        this.spriteframes=new spriteframe_t[numframes];        
    }
    
    public spritedef_t(spriteframe_t[] frames){
        this.numframes=frames.length;
        this.spriteframes=new spriteframe_t[numframes];
        // copy shit over...
        for (int i=0;i<numframes;i++){
            spriteframes[i]=frames[i].clone();
        }
    }
    
    /** Use this constructor, as we usually need less than 30 frames 
     *  It will actually clone the frames.
     */
    
    public void copy(spriteframe_t[] from, int maxframes){
        this.numframes=maxframes;
        this.spriteframes=new spriteframe_t[maxframes];
        // copy shit over...
        for (int i=0;i<maxframes;i++){
            spriteframes[i]=from[i].clone();
        }
    }
    
    
 public int         numframes;
 public spriteframe_t[]  spriteframes;

};
package rr;

/** A sprite manager does everything but drawing the sprites. It creates lists
 *  of sprites-per-sector, sorts them, and stuff like that.
 *  that gory visibiliy
 *  
 * @author velkton
 *
 * @param <V>
 */


public interface IVisSpriteManagement<V> extends ILimitResettable {
    
    void AddSprites(sector_t sec);
    
    /** Cache the sprite manager, if possible */
    
    void cacheSpriteManager(ISpriteManager SM);
    
    void SortVisSprites();

    int getNumVisSprites();

    vissprite_t<V>[] getVisSprites();

    void ClearSprites();
    
    void updateStatus(RendererState<?,V> R);
    
}

package rr;

import static rr.LightsAndColors.*;
import java.io.IOException;
import java.util.ArrayList;

import rr.drawfuns.ColVars;
import rr.drawfuns.R_DrawColumnBoom;
import rr.drawfuns.R_DrawColumnBoomLow;
import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;
import rr.drawfuns.R_DrawFuzzColumn;
import rr.drawfuns.R_DrawFuzzColumnLow;
import rr.drawfuns.R_DrawSpanLow;
import rr.drawfuns.R_DrawSpanUnrolled;
import rr.drawfuns.R_DrawTLColumn;
import rr.drawfuns.R_DrawTranslatedColumn;
import rr.drawfuns.R_DrawTranslatedColumnLow;
import rr.drawfuns.SpanVars;

import v.DoomVideoRenderer;
import doom.DoomMain;
import doom.DoomStatus;

public abstract class UnifiedRenderer<T, V>
        extends RendererState<T,V> {

    public UnifiedRenderer(DoomStatus<T,V> DS) {
        super(DS);
        this.MySegs=new Segs(this);
    }


    /** A very simple Seg (Wall) drawer, which just completes abstract SegDrawer
     *  by calling the final column functions.
     *  
     *  TODO: move out of RendererState.
     *  
     * @author velktron
     *
     */
    
    protected final class Segs
            extends SegDrawer {

        public Segs(Renderer<?, ?> R) {
            super(R);
        }

        /** For serial version, just complete the call */
        @Override
        protected final void CompleteColumn() {
            colfunc.main.invoke();
        }

    }

    ////////////////// The actual rendering calls ///////////////////////

   

    public static final class HiColor
            extends UnifiedRenderer<byte[],short[]> {

        public HiColor(DoomStatus<byte[],short[]> DM) {            
            super(DM);
            
            // Init any video-output dependant stuff            
            

            
            // Init light levels
            colormaps.scalelight = new short[LIGHTLEVELS][MAXLIGHTSCALE][];
            colormaps.scalelightfixed = new short[MAXLIGHTSCALE][];
            colormaps.zlight = new short[LIGHTLEVELS][MAXLIGHTZ][];
            
            completeInit();
        }

        /**
         * R_InitColormaps This is VERY different for hicolor.
         * 
         * @throws IOException
         */
        protected void InitColormaps()
                throws IOException {

            colormaps.colormaps = V.getColorMaps();
            System.out.println("COLORS15 Colormaps: " + colormaps.colormaps.length);

            // MAES: blurry effect is hardcoded to this colormap.
            // Pointless, since we don't use indexes. Instead, a half-brite
            // processing works just fine.
            BLURRY_MAP = null;// colormaps[0];
        }
        
        /** Initializes the various drawing functions. They are all "pegged" to the
         *  same dcvars/dsvars object. Any initializations of e.g. parallel renderers
         *  and their supporting subsystems should occur here. 
         */
        @Override
        protected void R_InitDrawingFunctions(){
            
            
            // Span functions. Common to all renderers unless overriden
            // or unused e.g. parallel renderers ignore them.
            DrawSpan=new R_DrawSpanUnrolled.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            DrawSpanLow=new R_DrawSpanLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            
            
            // Translated columns are usually sprites-only.
            DrawTranslatedColumn=new R_DrawTranslatedColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTranslatedColumnLow=new R_DrawTranslatedColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTLColumn=new R_DrawTLColumn(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Fuzzy columns. These are also masked.
            DrawFuzzColumn=new R_DrawFuzzColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawFuzzColumnLow=new R_DrawFuzzColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Regular draw for solid columns/walls. Full optimizations.
            DrawColumn=new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            DrawColumnLow=new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            
            // Non-optimized stuff for masked.
            DrawColumnMasked=new R_DrawColumnBoom.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawColumnMaskedLow=new R_DrawColumnBoomLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Player uses masked
            DrawColumnPlayer=DrawColumnMasked; // Player normally uses masked.
            
            // Skies use their own. This is done in order not to stomp parallel threads.
            
            DrawColumnSkies=new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            DrawColumnSkiesLow=new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            
            super.R_InitDrawingFunctions();
        }

    }       
                       
            public static final class Indexed
            extends UnifiedRenderer<byte[],byte[]> {

        public Indexed(DoomStatus<byte[],byte[]> DM) {            
            super(DM);
            
            // Init light levels
            colormaps.scalelight = new byte[LIGHTLEVELS][MAXLIGHTSCALE][];
            colormaps.scalelightfixed = new byte[MAXLIGHTSCALE][];
            colormaps.zlight = new byte[LIGHTLEVELS][MAXLIGHTZ][];
            
            completeInit();
        }

        /**
         * R_InitColormaps
         * 
         * @throws IOException
         */
        protected void InitColormaps() throws IOException {
            int lump, length;

            // Load in the light tables,
            // 256 byte align tables.
            lump = W.GetNumForName("COLORMAP");
            length = W.LumpLength(lump) + 256;
            colormaps.colormaps = new byte[(length / 256)][256];
            System.out.println("Colormaps: " + colormaps.colormaps.length);

            byte[] tmp = new byte[length];
            W.ReadLump(lump,tmp);

            for (int i = 0; i < colormaps.colormaps.length; i++) {
                System.arraycopy(tmp, i * 256, colormaps.colormaps[i], 0, 256);
            }
            
            // MAES: blurry effect is hardcoded to this colormap.
            BLURRY_MAP=colormaps.colormaps[6];
            // colormaps = (byte *)( ((int)colormaps + 255)&~0xff);     

            
        }
        
        /** Initializes the various drawing functions. They are all "pegged" to the
         *  same dcvars/dsvars object. Any initializations of e.g. parallel renderers
         *  and their supporting subsystems should occur here. 
         */
        
        @Override
        protected void R_InitDrawingFunctions(){
            
            // Span functions. Common to all renderers unless overriden
            // or unused e.g. parallel renderers ignore them.
            DrawSpan=new R_DrawSpanUnrolled.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            DrawSpanLow=new R_DrawSpanLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            
            
            // Translated columns are usually sprites-only.
            DrawTranslatedColumn=new R_DrawTranslatedColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTranslatedColumnLow=new R_DrawTranslatedColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            //DrawTLColumn=new R_DrawTLColumn(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Fuzzy columns. These are also masked.
            DrawFuzzColumn=new R_DrawFuzzColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I,BLURRY_MAP);
            DrawFuzzColumnLow=new R_DrawFuzzColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I,BLURRY_MAP);
            
            // Regular draw for solid columns/walls. Full optimizations.
            DrawColumn=new R_DrawColumnBoomOpt.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            DrawColumnLow=new R_DrawColumnBoomOptLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            
            // Non-optimized stuff for masked.
            DrawColumnMasked=new R_DrawColumnBoom.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawColumnMaskedLow=new R_DrawColumnBoomLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Player uses masked
            DrawColumnPlayer=DrawColumnMasked; // Player normally uses masked.
            
            // Skies use their own. This is done in order not to stomp parallel threads.
            
            DrawColumnSkies=new R_DrawColumnBoomOpt.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            DrawColumnSkiesLow=new R_DrawColumnBoomOptLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            super.R_InitDrawingFunctions();
        }

    }       
          
            public static final class TrueColor
            extends UnifiedRenderer<byte[],int[]> {

        public TrueColor(DoomStatus<byte[],int[]> DM) {            
            super(DM);
            
            // Init light levels
            colormaps.scalelight = new int[LIGHTLEVELS][MAXLIGHTSCALE][];
            colormaps.scalelightfixed = new int[MAXLIGHTSCALE][];
            colormaps.zlight = new int[LIGHTLEVELS][MAXLIGHTZ][];
            
            completeInit();
        }

        /**
         * R_InitColormaps This is VERY different for hicolor.
         * 
         * @throws IOException
         */
        protected void InitColormaps()
                throws IOException {

            colormaps.colormaps = V.getColorMaps();
            System.out.println("COLORS32 Colormaps: " + colormaps.colormaps.length);
            BLURRY_MAP = null;

        }
        
        /** Initializes the various drawing functions. They are all "pegged" to the
         *  same dcvars/dsvars object. Any initializations of e.g. parallel renderers
         *  and their supporting subsystems should occur here. 
         */
        
        @Override
        protected void R_InitDrawingFunctions(){
            
            // Span functions. Common to all renderers unless overriden
            // or unused e.g. parallel renderers ignore them.
            DrawSpan=new R_DrawSpanUnrolled.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            DrawSpanLow=new R_DrawSpanLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            
            
            // Translated columns are usually sprites-only.
            DrawTranslatedColumn=new R_DrawTranslatedColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTranslatedColumnLow=new R_DrawTranslatedColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            //DrawTLColumn=new R_DrawTLColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Fuzzy columns. These are also masked.
            DrawFuzzColumn=new R_DrawFuzzColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawFuzzColumnLow=new R_DrawFuzzColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Regular draw for solid columns/walls. Full optimizations.
            DrawColumn=new R_DrawColumnBoomOpt.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            DrawColumnLow=new R_DrawColumnBoomOptLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            
            // Non-optimized stuff for masked.
            DrawColumnMasked=new R_DrawColumnBoom.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawColumnMaskedLow=new R_DrawColumnBoomLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Player uses masked
            DrawColumnPlayer=DrawColumnMasked; // Player normally uses masked.
            
            // Skies use their own. This is done in order not to stomp parallel threads.
            
            DrawColumnSkies=new R_DrawColumnBoomOpt.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            DrawColumnSkiesLow=new R_DrawColumnBoomOptLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            super.R_InitDrawingFunctions();
        }

    }       

}

package rr;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Hashtable;

import utils.C2JUtils;
import w.CacheableDoomObject;
import w.DoomBuffer;

//Patches.
//A patch holds one or more columns.
//Patches are used for sprites and all masked pictures,
//and we compose textures from the TEXTURE1/2 lists
//of patches.

public class patch_t implements /*IReadableDoomObject,*/CacheableDoomObject{

    /** bounding box size */ 
    public short       width,   height;  
    /** pixels to the left of origin */
    public short       leftoffset;  
    /** pixels below the origin */
    public short       topoffset;   
    /** This used to be an implicit array pointing to raw posts of data. 
     * TODO: get rid of it? It's never used
     * only [width] used the [0] is &columnofs[width] */
    public int[]         columnofs;     
    /** The ACTUAL data is here, nicely deserialized (well, almost) */
    public column_t[] columns;
    
    /** Added for debug aid purposes */
    public String name;
    
    /** Synthesizing constructor.
     * You have to provide the columns yourself, a-posteriori.
     * 
     * @param name
     * @param width
     * @param height
     * @param leftoffset
     * @param topoffset
     */
    public patch_t(String name, int width, int height, int leftoffset, int topoffset){
        this.name=name;
        this.width=(short) width;
        this.height=(short) height;
        this.leftoffset=(short) leftoffset;
        this.columns=new column_t[width];
    }
    
    public patch_t(){
        
    }
    
  /*  @Override
    public void read(DoomFile f) throws IOException{

        long pos=f.getFilePointer();
        this.width=f.readLEShort();
        this.height=f.readLEShort();
        this.leftoffset=f.readLEShort();
        this.topoffset=f.readLEShort();
        // As many columns as width...right???
        this.columnofs=new int[this.width];
        this.columns=new column_t[this.width];
        C2JUtils.initArrayOfObjects( this.columns, column_t.class);
        
        // Read the column offsets.
        f.readIntArray(this.columnofs, this.columnofs.length, ByteOrder.LITTLE_ENDIAN);
        for (int i=0;i<this.width;i++){
            // Go to offset.
            //f.seek(pos+this.columnofs[i]);
            this.columns[i].read(f);
        }
        
    }*/
    
    /** In the C code, reading is "aided", aka they know how long the header + all
     *  posts/columns actually are on disk, and only "deserialize" them when using them.
     *  Here, we strive to keep stuff as elegant and OO as possible, so each column will get 
     *  deserialized one by one. I thought about reading ALL column data as raw data, but
     *  IMO that's shit in the C code, and would be utter shite here too. Ergo, I cleanly 
     *  separate columns at the patch level (an advantage is that it's now easy to address
     *  individual columns). However, column data is still read "raw".
     */
    
    @Override
    public void unpack(ByteBuffer b)
            throws IOException {
        // Remember to reset the ByteBuffer position each time.
        b.position(0);
        // In ByteBuffers, the order can be conveniently set beforehand :-o
        b.order(ByteOrder.LITTLE_ENDIAN);
        
        this.width=b.getShort();
        
        this.height=b.getShort();
        this.leftoffset=b.getShort();
        this.topoffset=b.getShort();
        // As many columns as width...right???
        this.columnofs=new int[this.width];
        this.columns=new column_t[this.width];
        C2JUtils.initArrayOfObjects( this.columns, column_t.class);
        
        // Compute the ACTUAL full-column sizes.
        int[] actualsizes=new int[columns.length];
        
        for (int i=0;i<actualsizes.length-1;i++){
            actualsizes[i]=columnofs[i+1]-columnofs[i];
        }
        
        // The offsets.
        DoomBuffer.readIntArray(b, this.columnofs, this.columnofs.length);
        for (int i=0;i<this.width;i++){
        	// Go to offset.
        	b.position(this.columnofs[i]);
        	
        	try {
        	this.columns[i].unpack(b);
        	} catch (Exception e){
        		// Error during loading of column.
        		// If first column (too bad..) set to special error column.
        		if (i==0)
        			this.columns[i]=getBadColumn(this.height);
        		// Else duplicate previous column. Saves memory, too!
        		else this.columns[i]=this.columns[i-1];
        	}
        }

    }
    
    
    // Special safeguard against badly computed columns. Now they can be any size.
    private static Hashtable<Integer,column_t> badColumns=new Hashtable<Integer,column_t>();

    private static column_t getBadColumn(int size){
    	
    	if (badColumns.get(size)==null){
            column_t tmp=new column_t();
            tmp.data=new byte[size+5];
        for (int i=3;i<size+3;i++){
        	tmp.data[i]=(byte) (i-3);
        }
        
        tmp.data[size+4]=(byte) 0xFF;
        tmp.posts=1;
        //tmp.length=(short) size;
        //tmp.topdelta=0;
        tmp.postofs=new int[]{3};        
        tmp.postdeltas=new short[]{0};
        tmp.postlen=new short[]{(short) (size%256)};
        //tmp.setData();
        badColumns.put(size, tmp);
    	}
    	
    	return badColumns.get(size);
    	
    }
    
}
package rr;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import utils.C2JUtils;
import w.CacheableDoomObject;
import w.DoomBuffer;

/** Texture definition.
 *  A DOOM wall texture is a list of patches which are to be combined in a predefined order.
 *  This is the ON-DISK structure, to be read from the TEXTURES1 and TEXTURES2 lumps.
 *  In memory, this becomes texture_t.
 *    
 *  @author MAES
 *
 */

public class maptexture_t implements CacheableDoomObject{
    public String        name; /* Fixed, 8-char width */
    public boolean     masked; 
    public short       width; // was signed byte
    public short       height; // was 
    //void**t        columndirectory;  // OBSOLETE (yeah, but we must read a dummy integer here)
    public short       patchcount;
    public mappatch_t[]  patches;
    
    
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        name=DoomBuffer.getNullTerminatedString(buf,8);
        masked=(buf.getInt()!=0);
        width=buf.getShort();
        height=buf.getShort();
        buf.getInt(); // read a dummy integer for obsolete columndirectory.
        patchcount=buf.getShort();        
        
        // Simple sanity check. Do not attempt reading more patches than there
        // are left in the TEXTURE lump.
        patchcount=(short) Math.min(patchcount,(buf.capacity()-buf.position())/mappatch_t.size());
        
        patches=new mappatch_t[patchcount];
        C2JUtils.initArrayOfObjects(patches,mappatch_t.class);
        DoomBuffer.readObjectArray(buf, patches, patchcount);
        
    }
    
};
package rr;

import static data.Limits.MAXINT;
import static data.Limits.MAX_ADJOINING_SECTORS;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.FRACBITS;
import static p.DoorDefines.*;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;

import m.IRandom;
import doom.think_t;
import doom.thinker_t;
import p.Resettable;
import p.ThinkerList;
import p.fireflicker_t;
import p.glow_t;
import p.lightflash_t;
import p.mobj_t;
import p.strobe_t;
import p.vldoor_e;
import p.vldoor_t;
import s.degenmobj_t;
import w.DoomIO;
import w.IPackableDoomObject;
import w.IReadableDoomObject;

/**
 * The SECTORS record, at runtime. Stores things/mobjs. Can be
 * archived/unarchived during savegames.
 * 
 * @author Maes
 */
public class sector_t
        implements IReadableDoomObject, IPackableDoomObject, Resettable {

    public ThinkerList TL;

    public IRandom RND;

    public sector_t() {
        blockbox = new int[4];
        id = -1;
    }

    /** (fixed_t) */
    public int floorheight, ceilingheight;

    public short floorpic;

    public short ceilingpic;

    public short lightlevel;

    public short special;

    public short tag;

    /** 0 = untraversed, 1,2 = sndlines -1 */
    public int soundtraversed;

    /** thing that made a sound (or null) (MAES: single pointer) */
    public mobj_t soundtarget;

    /** mapblock bounding box for height changes */
    public int[] blockbox;

    /**
     * origin for any sounds played by the sector. Used to be degenmobj_t, but
     * that's really a futile distinction.
     */
    public degenmobj_t soundorg;

    /** if == validcount, already checked */
    public int validcount;

    /** list of mobjs in sector (MAES: it's used as a linked list) */
    public mobj_t thinglist;

    /**
     * thinker_t for reversable actions. This actually was a void*, and in
     * practice it could store doors, plats, floors and ceiling objects.
     */
    public SectorAction specialdata;

    public int linecount;

    // struct line_s** lines; // [linecount] size
    // MAES: make this line_t[] for now?
    public line_t[] lines;

    /** Use for internal identification */
    public int id;

    /** killough 1/30/98: improves searches for tags. */
    public int nexttag,firsttag;  

    public String toString() {
        String str =
            String.format("Sector: %d %x %x %d %d %d %d %d", id, floorheight,
                ceilingheight, floorpic, ceilingpic, lightlevel, special, // needed?
                tag); // needed?

        return str;

    }

    //
    // Find minimum light from an adjacent sector
    //
    public int FindMinSurroundingLight(int max) {
        int i;
        int min;
        line_t line;
        sector_t check;

        min = max;
        for (i = 0; i < this.linecount; i++) {
            line = this.lines[i];
            check = line.getNextSector(this);

            if (check == null)
                continue;

            if (check.lightlevel < min)
                min = check.lightlevel;
        }
        return min;
    }

    //
    // P_FindLowestFloorSurrounding()
    // FIND LOWEST FLOOR HEIGHT IN SURROUNDING SECTORS
    //
    public int FindLowestFloorSurrounding() {
        int i;
        line_t check;
        sector_t other;
        int floor = this.floorheight;

        for (i = 0; i < this.linecount; i++) {
            check = this.lines[i];
            other = check.getNextSector(this);

            if (other == null)
                continue;

            if (other.floorheight < floor)
                floor = other.floorheight;
        }
        return floor;
    }

    /**
     * P_FindHighestFloorSurrounding() FIND HIGHEST FLOOR HEIGHT IN SURROUNDING
     * SECTORS Compatibility problem: apparently this is hardcoded for vanilla
     * compatibility (instead of Integer.MIN_VALUE), but it will cause some
     * "semi-Boom" maps not to work, since it won't be able to lower stuff below
     * -500 units. The correct fix here would be to allow for -compatlevel style
     * options. Maybe later.
     * 
     * @param sec
     */

    public int FindHighestFloorSurrounding() {
        int i;
        line_t check;
        sector_t other;

        int floor = -500 * FRACUNIT;

        for (i = 0; i < this.linecount; i++) {
            check = this.lines[i];
            other = check.getNextSector(this);

            // The compiler nagged about this being unreachable, with
            // some older 1.6 JDKs, but that's obviously not true.
            if (other == null)
                continue;

            if (other.floorheight > floor)
                floor = other.floorheight;
        }
        return floor;
    }

    /**
     * P_FindNextHighestFloor FIND NEXT HIGHEST FLOOR IN SURROUNDING SECTORS
     * Note: this should be doable w/o a fixed array.
     * 
     * @param sec
     * @param currentheight
     * @return fixed
     */

    public int FindNextHighestFloor(int currentheight) {
        int i;
        int h;
        int min;
        line_t check;
        sector_t other;
        int height = currentheight;

        int heightlist[] = new int[MAX_ADJOINING_SECTORS];

        for (i = 0, h = 0; i < this.linecount; i++) {
            check = this.lines[i];
            other = check.getNextSector(this);

            if (other == null)
                continue;

            if (other.floorheight > height)
                heightlist[h++] = other.floorheight;

            // Check for overflow. Exit.
            if (h >= MAX_ADJOINING_SECTORS) {
                System.err
                        .print("Sector with more than 20 adjoining sectors\n");
                break;
            }
        }

        // Find lowest height in list
        if (h == 0)
            return currentheight;

        min = heightlist[0];

        // Range checking?
        for (i = 1; i < h; i++)
            if (heightlist[i] < min)
                min = heightlist[i];

        return min;
    }

    //
    // FIND LOWEST CEILING IN THE SURROUNDING SECTORS
    //
    public int FindLowestCeilingSurrounding() {
        int i;
        line_t check;
        sector_t other;
        int height = MAXINT;

        for (i = 0; i < this.linecount; i++) {
            check = this.lines[i];
            other = check.getNextSector(this);

            if (other == null)
                continue;

            if (other.ceilingheight < height)
                height = other.ceilingheight;
        }
        return height;
    }

    //
    // FIND HIGHEST CEILING IN THE SURROUNDING SECTORS
    //
    public int FindHighestCeilingSurrounding() {
        int i;
        line_t check;
        sector_t other;
        int height = 0;

        for (i = 0; i < this.linecount; i++) {
            check = this.lines[i];
            other = check.getNextSector(this);

            if (other == null)
                continue;

            if (other.ceilingheight > height)
                height = other.ceilingheight;
        }
        return height;
    }

    //
    // P_SpawnFireFlicker
    //
    public void SpawnFireFlicker() {
        fireflicker_t flick;

        // Note that we are resetting sector attributes.
        // Nothing special about it during gameplay.
        this.special = 0;

        flick = new fireflicker_t(RND);
        flick.function = think_t.T_FireFlicker;
        TL.AddThinker(flick);
        flick.sector = this;
        flick.maxlight = this.lightlevel;
        flick.minlight = this.FindMinSurroundingLight(this.lightlevel) + 16;
        flick.count = 4;
    }

    /**
     * Spawn a door that opens after 5 minutes
     */

    public void SpawnDoorRaiseIn5Mins(int secnum) {
        vldoor_t door;

        door = new vldoor_t();

        this.specialdata = door;
        this.special = 0;
        door.function = think_t.T_VerticalDoor;
        TL.AddThinker(door);
        door.sector = this;
        door.direction = 2;
        door.type = vldoor_e.raiseIn5Mins;
        door.speed = VDOORSPEED;
        door.topheight = this.FindLowestCeilingSurrounding();
        door.topheight -= 4 * FRACUNIT;
        door.topwait = VDOORWAIT;
        door.topcountdown = 5 * 60 * 35;
    }

    //
    // Spawn a door that closes after 30 seconds
    //
    public void SpawnDoorCloseIn30() {
        vldoor_t door;

        door = new vldoor_t();

        this.specialdata = door;
        this.special = 0;

        door.function = think_t.T_VerticalDoor;
        TL.AddThinker(door);
        door.sector = this;
        door.direction = 0;
        door.type = vldoor_e.normal;
        door.speed = VDOORSPEED;
        door.topcountdown = 30 * 35;
    }

    //
    // P_SpawnStrobeFlash
    // After the map has been loaded, scan each sector
    // for specials that spawn thinkers
    //
    public void SpawnStrobeFlash(int fastOrSlow, int inSync) {
        strobe_t flash;

        flash = new strobe_t();
        flash.sector = this;
        flash.darktime = fastOrSlow;
        flash.brighttime = STROBEBRIGHT;
        flash.function = think_t.T_StrobeFlash;
        TL.AddThinker(flash);
        flash.maxlight = this.lightlevel;
        flash.minlight = this.FindMinSurroundingLight(this.lightlevel);

        if (flash.minlight == flash.maxlight)
            flash.minlight = 0;

        // nothing special about it during gameplay
        this.special = 0;

        if (inSync == 0)
            flash.count = (RND.P_Random() & 7) + 1;
        else
            flash.count = 1;
    }

    /**
     * P_SpawnLightFlash After the map has been loaded, scan each sector for
     * specials that spawn thinkers
     */

    public void SpawnLightFlash() {
        lightflash_t flash;

        // nothing special about it during gameplay
        special = 0;

        flash = new lightflash_t(RND);
        flash.function = think_t.T_LightFlash;
        TL.AddThinker((thinker_t) flash);
        flash.sector = this;
        flash.maxlight = lightlevel;

        flash.minlight = FindMinSurroundingLight(lightlevel);
        flash.maxtime = 64;
        flash.mintime = 7;
        flash.count = (RND.P_Random() & flash.maxtime) + 1;
    }

    public void SpawnGlowingLight() {
        glow_t g;

        g = new glow_t();
        g.sector = this;
        g.minlight = FindMinSurroundingLight(this.lightlevel);
        g.maxlight = lightlevel;
        g.function = think_t.T_Glow;
        TL.AddThinker(g);
        g.direction = -1;

        this.special = 0;
    }

    @Override
    public void read(DataInputStream f)
            throws IOException {

        // ACHTUNG: the only situation where we'd
        // like to read memory-format sector_t's is from
        // savegames, and in vanilla savegames, not all info
        // is saved (or read) from disk.

        this.floorheight = DoomIO.readLEShort(f) << FRACBITS;
        this.ceilingheight = DoomIO.readLEShort(f) << FRACBITS;
        // MAES: it may be necessary to apply a hack in order to
        // read vanilla savegames.
        this.floorpic = (short) DoomIO.readLEShort(f);
        this.ceilingpic = (short) DoomIO.readLEShort(f);
        // f.skipBytes(4);
        this.lightlevel = DoomIO.readLEShort(f);
        this.special = DoomIO.readLEShort(f); // needed?
        this.tag = DoomIO.readLEShort(f); // needed?
    }

    @Override
    public void pack(ByteBuffer b) {

        b.putShort((short) (floorheight >> FRACBITS));
        b.putShort((short) (ceilingheight >> FRACBITS));
        // MAES: it may be necessary to apply a hack in order to
        // read vanilla savegames.
        b.putShort(floorpic);
        b.putShort(ceilingpic);
        // f.skipBytes(4);
        b.putShort(lightlevel);
        b.putShort(special);
        b.putShort(tag);
    }

    @Override
    public void reset() {
        floorheight = 0;
        ceilingheight = 0;
        floorpic = 0;
        ceilingpic = 0;
        lightlevel = 0;
        special = 0;
        tag = 0;
        soundtraversed = 0;
        soundtarget = null;
        Arrays.fill(blockbox, 0);
        soundorg = null;
        validcount = 0;
        thinglist = null;
        specialdata = null;
        linecount = 0;
        lines = null;
        id = -1;

    }
}

package rr.drawfuns;

public class ColFuncs<T,V> {
    
    public DoomColumnFunction<T, V> main;

    public DoomColumnFunction<T, V> base;

    public DoomColumnFunction<T, V> masked;

    public DoomColumnFunction<T, V> fuzz;

    public DoomColumnFunction<T, V> trans;

    public DoomColumnFunction<T, V> glass;

    public DoomColumnFunction<T, V> player;

    public DoomColumnFunction<T, V> sky;
}

package rr.drawfuns;
import static m.fixed_t.FRACBITS;
import i.IDoomSystem;


public final class R_DrawTLColumn extends DoomColumnFunction<byte[],short[]> {

		public R_DrawTLColumn(int SCREENWIDTH, int SCREENHEIGHT,
	            int[] ylookup, int[] columnofs, ColVars<byte[],short[]> dcvars,
	            short[] screen, IDoomSystem I) {
	        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	        this.flags=DcFlags.TRANSPARENT;
	    }

        public void invoke() {
			int count;
			int dest; // killough
			int frac; // killough
			final int fracstep;
			final int dc_source_ofs=dcvars.dc_source_ofs;
			final byte[] tranmap=dcvars.tranmap;

			count = dcvars.dc_yh - dcvars.dc_yl + 1;

			if (count <= 0) // Zero length, column does not exceed a pixel.
				return;

			if (RANGECHECK) {
				performRangeCheck();
			}

			// Framebuffer destination address.
			// Use ylookup LUT to avoid multiply with ScreenWidth.
			// Use columnofs LUT for subwindows?

			dest = computeScreenDest();

			// Determine scaling, which is the only mapping to be done.

			fracstep = dcvars.dc_iscale;
			frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;

			// Inner loop that does the actual texture mapping,
			// e.g. a DDA-lile scaling.
			// This is as fast as it gets. (Yeah, right!!! -- killough)
			//
			// killough 2/1/98: more performance tuning

			{
				final byte[] source = dcvars.dc_source;
				final short[] colormap = dcvars.dc_colormap;
				int heightmask = dcvars.dc_texheight - 1;
				if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2 --
														// killough
				{
					heightmask++;
					heightmask <<= FRACBITS;

					if (frac < 0)
						while ((frac += heightmask) < 0)
							;
					else
						while (frac >= heightmask)
							frac -= heightmask;

					do {
						// Re-map color indices from wall texture column
						// using a lighting/special effects LUT.
						// heightmask is the Tutti-Frutti fix -- killough

						screen[dest] = tranmap[0xFF00
								& (screen[dest] << 8)
								| (0x00FF & colormap[0x00FF & source[dc_source_ofs
										+ ((frac >> FRACBITS) & heightmask)]])];
						dest += SCREENWIDTH;
						if ((frac += fracstep) >= heightmask)
							frac -= heightmask;
					} while (--count > 0);
				} else {
					while ((count -= 4) >= 0) // texture height is a power of 2
												// -- killough
					{
						// screen[dest] =
						// main_tranmap[0xFF00&(screen[dest]<<8)|(0x00FF&colormap[0x00FF&source[dc_source_ofs+((frac>>FRACBITS)
						// & heightmask)]])];
						screen[dest] = tranmap[0xFF00
								& (screen[dest] << 8)
								| (0x00FF & colormap[0x00FF & source[dc_source_ofs
										+ ((frac >> FRACBITS) & heightmask)]])];
						dest += SCREENWIDTH;
						frac += fracstep;
						screen[dest] = tranmap[0xFF00
								& (screen[dest] << 8)
								| (0x00FF & colormap[0x00FF & source[dc_source_ofs
										+ ((frac >> FRACBITS) & heightmask)]])];
						dest += SCREENWIDTH;
						frac += fracstep;
						screen[dest] = tranmap[0xFF00
								& (screen[dest] << 8)
								| (0x00FF & colormap[0x00FF & source[dc_source_ofs
										+ ((frac >> FRACBITS) & heightmask)]])];
						dest += SCREENWIDTH;
						frac += fracstep;
						screen[dest] = tranmap[0xFF00
								& (screen[dest] << 8)
								| (0x00FF & colormap[0x00FF & source[dc_source_ofs
										+ ((frac >> FRACBITS) & heightmask)]])];
						dest += SCREENWIDTH;
						frac += fracstep;
					}
					if ((count & 1) != 0)
						screen[dest] = tranmap[0xFF00
								& (screen[dest] << 8)
								| (0x00FF & colormap[0x00FF & source[dc_source_ofs
										+ ((frac >> FRACBITS) & heightmask)]])];
				}
			}
		}
	}
package rr.drawfuns;

import i.IDoomSystem;

/**
	 * Framebuffer postprocessing. Creates a fuzzy image by copying pixels from
	 * adjacent ones to left and right. Used with an all black colormap, this
	 * could create the SHADOW effect, i.e. spectres and invisible players.
	 */

	public abstract class R_DrawFuzzColumn<T,V> extends DoomColumnFunction<T,V>  {
		
	    public R_DrawFuzzColumn(int SCREENWIDTH, int SCREENHEIGHT,
                int[] ylookup, int[] columnofs, ColVars<T,V> dcvars,
                V screen, IDoomSystem I,T BLURRY_MAP) {
	    	this(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	    	this.BLURRY_MAP=BLURRY_MAP;
	    }
		
	    public R_DrawFuzzColumn(int SCREENWIDTH, int SCREENHEIGHT,
                int[] ylookup, int[] columnofs, ColVars<T,V> dcvars,
                V screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
        
            this.flags=DcFlags.FUZZY;
        
        FUZZOFF = SCREENWIDTH;
        
        // Recompute fuzz table
        
        fuzzoffset= new int[]{ FUZZOFF, -FUZZOFF, FUZZOFF, -FUZZOFF,
                FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF,
                FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF,
                -FUZZOFF, -FUZZOFF, -FUZZOFF, FUZZOFF, -FUZZOFF, -FUZZOFF, FUZZOFF,
                FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF,
                FUZZOFF, -FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF, -FUZZOFF,
                -FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF,
                FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF };
        
        FUZZTABLE=fuzzoffset.length;
		}
		
		protected int fuzzpos;
		
		protected final int FUZZTABLE;
		

        //
        // Spectre/Invisibility.
        //

		protected final int FUZZOFF;

		protected final int[] fuzzoffset;

        public static final class HiColor extends R_DrawFuzzColumn<byte[],short[]>{
        	
        	public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
					int[] columnofs, ColVars<byte[], short[]> dcvars,
					short[] screen, IDoomSystem I) {
				super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
				// TODO Auto-generated constructor stub
			}

			public void invoke() {
    			int count;
    			int dest;

    			// Adjust borders. Low...
    			if (dcvars.dc_yl == 0)
    			    dcvars.dc_yl = 1;

    			// .. and high.
    			if (dcvars.dc_yh == dcvars.viewheight - 1)
    			    dcvars.dc_yh = dcvars.viewheight - 2;

    			count = dcvars.dc_yh - dcvars.dc_yl;

    			// Zero length.
    			if (count < 0)
    				return;

    			if (RANGECHECK) {
    				    super.performRangeCheck();
    			}

    			// Does not work with blocky mode.
    			dest = computeScreenDest();

    			// Looks like an attempt at dithering,
    			// using the colormap #6 (of 0-31, a bit
    			// brighter than average).
    			if (count>4) // MAES: unroll by 4
    			do {
    				// Lookup framebuffer, and retrieve
    				// a pixel that is either one column
    				// left or right of the current one.
    				// Add index from colormap to index.

    				screen[dest] = fuzzMix(screen[dest
    										+ fuzzoffset[fuzzpos]]);

    				// Clamp table lookup index.
    				if (++fuzzpos == FUZZTABLE)
    					fuzzpos = 0;

    				dest += SCREENWIDTH;				
                    
    				screen[dest] = fuzzMix(screen[dest
    										+ fuzzoffset[fuzzpos]]);
                    if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                    dest += SCREENWIDTH;

    				screen[dest] = fuzzMix(screen[dest
    										+ fuzzoffset[fuzzpos]]);
                    if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                    dest += SCREENWIDTH;

    				screen[dest] = fuzzMix(screen[dest
    										+ fuzzoffset[fuzzpos]]);
                    if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                    dest += SCREENWIDTH;
    				
    			} while ((count-=4) > 4);
    			
    			if (count>0)
    	         do {
    	                screen[dest] = fuzzMix(screen[dest
    	                                              + fuzzoffset[fuzzpos]]);

    	                // Clamp table lookup index.
    	                if (++fuzzpos == FUZZTABLE)
    	                    fuzzpos = 0;

    	                dest += SCREENWIDTH;
    	            } while (count-- > 0);
    			
    		}
            
            private final short fuzzMix(short rgb){
                // super-fast half-brite trick
                // 3DEF and >> 1: ok hue, but too dark
                // 7BDE, no shift:  good compromise
                // 739C, no shift: results in too obvious tinting.         
                return (short) (rgb&0x7BDE);        	
            }
        }
        
        public static final class Indexed extends R_DrawFuzzColumn<byte[],byte[]>{
        
        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
					int[] columnofs, ColVars<byte[], byte[]> dcvars,
					byte[] screen, IDoomSystem I,byte[] BLURRY_MAP) {
				super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I,BLURRY_MAP);
			}

		public void invoke() {
			int count;
			int dest;

			// Adjust borders. Low...
			if (dcvars.dc_yl == 0)
			    dcvars.dc_yl = 1;

			// .. and high.
			if (dcvars.dc_yh == dcvars.viewheight - 1)
			    dcvars.dc_yh = dcvars.viewheight - 2;

			count = dcvars.dc_yh - dcvars.dc_yl;

			// Zero length.
			if (count < 0)
				return;

			if (RANGECHECK) {
				    super.performRangeCheck();
			}

			// Does not work with blocky mode.
			dest = computeScreenDest();

			// Looks like an attempt at dithering,
			// using the colormap #6 (of 0-31, a bit
			// brighter than average).
			if (count>4) // MAES: unroll by 4
			do {
				// Lookup framebuffer, and retrieve
				// a pixel that is either one column
				// left or right of the current one.
				// Add index from colormap to index.
				screen[dest] = BLURRY_MAP[0x00FF & screen[dest
						+ fuzzoffset[fuzzpos]]];

				// Clamp table lookup index.
				if (++fuzzpos == FUZZTABLE)
					fuzzpos = 0;

				dest += SCREENWIDTH;				
                
				screen[dest] = 
                        BLURRY_MAP[0x00FF & screen[dest+ fuzzoffset[fuzzpos]]];
                if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                dest += SCREENWIDTH;
                
                screen[dest] = 
                        BLURRY_MAP[0x00FF & screen[dest+ fuzzoffset[fuzzpos]]];
                if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                dest += SCREENWIDTH;
                
                screen[dest] = 
                        BLURRY_MAP[0x00FF & screen[dest+ fuzzoffset[fuzzpos]]];
                if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                dest += SCREENWIDTH;
				
			} while ((count-=4) > 4);
			
			if (count>0)
	         do {
	                // Lookup framebuffer, and retrieve
	                // a pixel that is either one column
	                // left or right of the current one.
	                // Add index from colormap to index.
	                screen[dest] = BLURRY_MAP[0x00FF & screen[dest
	                        + fuzzoffset[fuzzpos]]];

	                // Clamp table lookup index.
	                if (++fuzzpos == FUZZTABLE)
	                    fuzzpos = 0;

	                dest += SCREENWIDTH;
	            } while (count-- > 0);
			
		}
        }

public static final class TrueColor extends R_DrawFuzzColumn<byte[],int[]>{
            
            public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                    int[] columnofs, ColVars<byte[], int[]> dcvars,
                    int[] screen, IDoomSystem I) {
                super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
            }

            public void invoke() {
                int count;
                int dest;

                // Adjust borders. Low...
                if (dcvars.dc_yl == 0)
                    dcvars.dc_yl = 1;

                // .. and high.
                if (dcvars.dc_yh == dcvars.viewheight - 1)
                    dcvars.dc_yh = dcvars.viewheight - 2;

                count = dcvars.dc_yh - dcvars.dc_yl;

                // Zero length.
                if (count < 0)
                    return;

                if (RANGECHECK) {
                        super.performRangeCheck();
                }

                // Does not work with blocky mode.
                dest = computeScreenDest();

                // Looks like an attempt at dithering,
                // using the colormap #6 (of 0-31, a bit
                // brighter than average).
                if (count>4) // MAES: unroll by 4
                do {
                    // Lookup framebuffer, and retrieve
                    // a pixel that is either one column
                    // left or right of the current one.
                    // Add index from colormap to index.

                    screen[dest] = fuzzMix(screen[dest
                                            + fuzzoffset[fuzzpos]]);

                    // Clamp table lookup index.
                    if (++fuzzpos == FUZZTABLE)
                        fuzzpos = 0;

                    dest += SCREENWIDTH;                
                    
                    screen[dest] = fuzzMix(screen[dest
                                            + fuzzoffset[fuzzpos]]);
                    if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                    dest += SCREENWIDTH;

                    screen[dest] = fuzzMix(screen[dest
                                            + fuzzoffset[fuzzpos]]);
                    if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                    dest += SCREENWIDTH;

                    screen[dest] = fuzzMix(screen[dest
                                            + fuzzoffset[fuzzpos]]);
                    if (++fuzzpos == FUZZTABLE) fuzzpos = 0;
                    dest += SCREENWIDTH;
                    
                } while ((count-=4) > 4);
                
                if (count>0)
                 do {
                        screen[dest] = fuzzMix(screen[dest
                                                      + fuzzoffset[fuzzpos]]);

                        // Clamp table lookup index.
                        if (++fuzzpos == FUZZTABLE)
                            fuzzpos = 0;

                        dest += SCREENWIDTH;
                    } while (count-- > 0);
                
            }
            
            private final int fuzzMix(int rgb){
                // Proper half-brite alpha!
                return rgb&0x10FFFFFF;
            }
        }
        
	}
package rr.drawfuns;

import i.IDoomSystem;

/** Prototype for 
 * 
 * @author velktron
 *
 * @param <T>
 */

public abstract class DoomColumnFunction<T,V> implements ColumnFunction<T,V>{
    
    protected final boolean RANGECHECK=false;
    protected final int SCREENWIDTH;
    protected final int SCREENHEIGHT;
    protected ColVars<T,V> dcvars;
    protected final V screen;
    protected final IDoomSystem I;
    protected final int[] ylookup;
    protected final int[] columnofs;
    protected T BLURRY_MAP;
    protected int flags;
    
    public DoomColumnFunction(int sCREENWIDTH, int sCREENHEIGHT,int[] ylookup,
            int[] columnofs, ColVars<T,V> dcvars, V screen,IDoomSystem I) {
        SCREENWIDTH = sCREENWIDTH;
        SCREENHEIGHT = sCREENHEIGHT;
        this.ylookup=ylookup;
        this.columnofs=columnofs;
        this.dcvars = dcvars;
        this.screen = screen;
        this.I=I;
        this.BLURRY_MAP=null;
    }
    
    public DoomColumnFunction(int sCREENWIDTH, int sCREENHEIGHT,int[] ylookup,
            int[] columnofs, ColVars<T,V> dcvars, V screen,IDoomSystem I,T BLURRY_MAP) {
        SCREENWIDTH = sCREENWIDTH;
        SCREENHEIGHT = sCREENHEIGHT;
        this.ylookup=ylookup;
        this.columnofs=columnofs;
        this.dcvars = dcvars;
        this.screen = screen;
        this.I=I;
        this.BLURRY_MAP=BLURRY_MAP;
    }

    protected final void performRangeCheck(){
        if (dcvars.dc_x >= SCREENWIDTH || dcvars.dc_yl < 0 || dcvars.dc_yh >= SCREENHEIGHT)
            I.Error("R_DrawColumn: %d to %d at %d", dcvars.dc_yl, dcvars.dc_yh, dcvars.dc_x);
    }
    
    /**
     * 
     * Use ylookup LUT to avoid multiply with ScreenWidth.
     * Use columnofs LUT for subwindows?
     * 
     * @return Framebuffer destination address.
     */
    
    protected final int computeScreenDest() {
        return ylookup[dcvars.dc_yl] + columnofs[dcvars.dc_x];
    }

    protected final int blockyDest1() {
        return ylookup[dcvars.dc_yl] + columnofs[dcvars.dc_x<<1];
    }

    protected final int blockyDest2() {
        return  ylookup[dcvars.dc_yl] + columnofs[(dcvars.dc_x<<1)+1];
    }

    @Override
    public final void invoke(ColVars<T,V> dcvars) {
        this.dcvars=dcvars;
        invoke();
    }
    
    public final int getFlags(){
        return this.flags;
    }
    
}

package rr.drawfuns;
import i.IDoomSystem;

/**
	 * EI VITTU, this gives a clean 25% boost. Da fack...
	 * 
	 * 
	 * @author admin
	 * 
	 */

	public final class R_DrawColumnUnrolled extends DoomColumnFunction<byte[],short[]> {

		/*
		 * That's shit, doesn't help. private final int
		 * SCREENWIDTH2=SCREENWIDTH*2; private final int
		 * SCREENWIDTH3=SCREENWIDTH*3; private final int
		 * SCREENWIDTH4=SCREENWIDTH*4; private final int
		 * SCREENWIDTH5=SCREENWIDTH*5; private final int
		 * SCREENWIDTH6=SCREENWIDTH*6; private final int
		 * SCREENWIDTH7=SCREENWIDTH*7; private final int
		 * SCREENWIDTH8=SCREENWIDTH*8;
		 */

		public R_DrawColumnUnrolled(int SCREENWIDTH, int SCREENHEIGHT,
	            int[] ylookup, int[] columnofs, ColVars<byte[],short[]> dcvars,
	            short[] screen, IDoomSystem I) {
	        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	    }

        public void invoke() {
			int count,dest;
			final byte[] source;			
			final short[] colormap;
			final int dc_source_ofs=dcvars.dc_source_ofs;

			// These are all "unsigned". Watch out for bit shifts!
			int frac;
			final int fracstep, fracstep2, fracstep3, fracstep4;

			count = dcvars.dc_yh - dcvars.dc_yl + 1;

			source = dcvars.dc_source;
			// dc_source_ofs+=15; // ???? WHY
			colormap = dcvars.dc_colormap;
			dest = computeScreenDest();

			fracstep = dcvars.dc_iscale << 9;
			frac = (dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * dcvars.dc_iscale) << 9;

			fracstep2 = fracstep + fracstep;
			fracstep3 = fracstep2 + fracstep;
			fracstep4 = fracstep3 + fracstep;

			while (count > 8) {
				screen[dest] = colormap[0x00FF & source[dc_source_ofs + frac >>> 25]];
				screen[dest + SCREENWIDTH] = colormap[0x00FF & source[dc_source_ofs
						+ (frac + fracstep) >>> 25]];
				screen[dest + SCREENWIDTH * 2] = colormap[0x00FF & source[dc_source_ofs
						+ (frac + fracstep2) >>> 25]];
				screen[dest + SCREENWIDTH * 3] = colormap[0x00FF & source[dc_source_ofs
						+ (frac + fracstep3) >>> 25]];

				frac += fracstep4;

				screen[dest + SCREENWIDTH * 4] = colormap[0x00FF & source[dc_source_ofs
						+ frac >>> 25]];
				screen[dest + SCREENWIDTH * 5] = colormap[0x00FF & source[dc_source_ofs
						+ (frac + fracstep) >>> 25]];
				screen[dest + SCREENWIDTH * 6] = colormap[0x00FF & source[dc_source_ofs
						+ (frac + fracstep2) >>> 25]];
				screen[dest + SCREENWIDTH * 7] = colormap[0x00FF & source[dc_source_ofs
						+ (frac + fracstep3) >>> 25]];

				frac += fracstep4;
				dest += SCREENWIDTH * 8;
				count -= 8;
			}

			while (count > 0) {
				screen[dest] = colormap[0x00FF & source[dc_source_ofs + frac >>> 25]];
				dest += SCREENWIDTH;
				frac += fracstep;
				count--;
			}
		}
	}
package rr.drawfuns;

import i.IDoomSystem;

/** An unrolled (4x) rendering loop with full quality */
// public final int dumb=63 * 64;

public final class R_DrawSpanUnrolled2 extends DoomSpanFunction<byte[],short[]> {
    
    
	public R_DrawSpanUnrolled2(int sCREENWIDTH, int sCREENHEIGHT,
            int[] ylookup, int[] columnofs, SpanVars<byte[],short[]> dsvars,
            short[] screen, IDoomSystem I) {
        super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
        // TODO Auto-generated constructor stub
    }

    public void invoke() {
	    final byte[] ds_source= dsvars.ds_source;
	    final short[] ds_colormap= dsvars.ds_colormap;
	    final int ds_xstep=dsvars.ds_xstep;
	    final int ds_ystep=dsvars.ds_ystep;
		int f_xfrac; // fixed_t
		int f_yfrac; // fixed_t
		int dest;
		int count;
		int spot;

		// System.out.println("R_DrawSpan: "+ds_x1+" to "+ds_x2+" at "+
		// ds_y);

		if (RANGECHECK) {
		    doRangeCheck();
			// dscount++;
		}

		f_xfrac = dsvars.ds_xfrac;
		f_yfrac = dsvars.ds_yfrac;

		dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];

		count = dsvars.ds_x2 - dsvars.ds_x1;
		while (count >= 4) {
			// Current texture index in u,v.
			spot = ((f_yfrac >> (16 - 6)) & (63 * 64))
					+ ((f_xfrac >> 16) & 63);

			// Lookup pixel from flat texture tile,
			// re-index using light/colormap.
			screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];

			// Next step in u,v.
			f_xfrac += ds_xstep;
			f_yfrac += ds_ystep;

			// UNROLL 2
			spot = ((f_yfrac >> (16 - 6)) & (63 * 64))
					+ ((f_xfrac >> 16) & 63);
			screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];
			f_xfrac += ds_xstep;
			f_yfrac += ds_ystep;

			// UNROLL 3
			spot = ((f_yfrac >> (16 - 6)) & (63 * 64))
					+ ((f_xfrac >> 16) & 63);
			screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];
			f_xfrac += ds_xstep;
			f_yfrac += ds_ystep;

			// UNROLL 4
			spot = ((f_yfrac >> (16 - 6)) & (63 * 64))
					+ ((f_xfrac >> 16) & 63);
			screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];
			f_xfrac += ds_xstep;
			f_yfrac += ds_ystep;

			count -= 4;
		}

		while (count > 0) {
			// Current texture index in u,v.
			spot = ((f_yfrac >> (16 - 6)) & (63 * 64))
					+ ((f_xfrac >> 16) & 63);

			// Lookup pixel from flat texture tile,
			// re-index using light/colormap.
			screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];

			// Next step in u,v.
			f_xfrac += ds_xstep;
			f_yfrac += ds_ystep;
			count--;
		}

	}
}

package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;

/**
 * Adapted from Killough's Boom code. Low-detail variation, no DC_SOURCE
 * optimization.
 * 
 * @author admin
 */

public abstract class R_DrawColumnBoomLow<T, V>
        extends DoomColumnFunction<T, V> {

    public R_DrawColumnBoomLow(int SCREENWIDTH, int SCREENHEIGHT,
            int[] ylookup, int[] columnofs, ColVars<T, V> dcvars, V screen,
            IDoomSystem I) {
        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
        this.flags = DcFlags.LOW_DETAIL;
    }

    public static final class HiColor
            extends R_DrawColumnBoomLow<byte[], short[]> {

        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], short[]> dcvars,
                short[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest, dest2; // killough
            int frac; // killough
            final int fracstep, dc_source_ofs;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;
            dc_source_ofs = dcvars.dc_source_ofs;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final short[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {

                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }

    public static final class Indexed
            extends R_DrawColumnBoomLow<byte[], byte[]> {

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], byte[]> dcvars, byte[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest, dest2; // killough
            int frac; // killough
            final int fracstep, dc_source_ofs;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;
            dc_source_ofs = dcvars.dc_source_ofs;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final byte[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {

                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }

    }

            
            public static final class TrueColor
            extends R_DrawColumnBoomLow<byte[], int[]> {

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], int[]> dcvars,
                int[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest, dest2; // killough
            int frac; // killough
            final int fracstep, dc_source_ofs;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;
            dc_source_ofs = dcvars.dc_source_ofs;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final int[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {

                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] =
                            screen[dest2] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }
            
}
package rr.drawfuns;

import i.IDoomSystem;

/**
	 * Draws the actual span.
	 * 
	 * ds_frac, ds_yfrac, ds_x2, ds_x1, ds_xstep and ds_ystep must be set.
	 * 
	 */

	public final class R_DrawSpan extends DoomSpanFunction<byte[],short[]> {

        public R_DrawSpan(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
            int[] columnofs, SpanVars<byte[],short[]> dsvars,short[] screen,
            IDoomSystem I) {
        super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
        }

        public void invoke() {

			int f_xfrac; // fixed_t
			int f_yfrac; // fixed_t
			int dest,count,spot;
			final short[] ds_colormap=dsvars.ds_colormap;
			final byte[] ds_source=dsvars.ds_source;

			// System.out.println("R_DrawSpan: "+ds_x1+" to "+ds_x2+" at "+
			// ds_y);

			if (RANGECHECK) {
			    doRangeCheck();
				// dscount++;
			}

			f_xfrac = dsvars.ds_xfrac;
			f_yfrac = dsvars.ds_yfrac;

			dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];

			// We do not check for zero spans here?
			count = dsvars.ds_x2 - dsvars.ds_x1;

			do {
				// Current texture index in u,v.
				spot = ((f_yfrac >> (16 - 6)) & (63 * 64))
						+ ((f_xfrac >> 16) & 63);

				// Lookup pixel from flat texture tile,
				// re-index using light/colormap.
				screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];

				// Next step in u,v.
				f_xfrac += dsvars.ds_xstep;
				f_yfrac += dsvars.ds_ystep;

			} while (count-- > 0);
		}
	}
package rr.drawfuns;

import static m.fixed_t.FRACBITS;
import i.IDoomSystem;

     /**
	 * Adapted from Killough's Boom code. There are optimized as well as
	 * low-detail versions of it.
	 * 
	 * @author admin
	 * 
	 */

/**
 * A column is a vertical slice/span from a wall texture that, given the
 * DOOM style restrictions on the view orientation, will always have
 * constant z depth. Thus a special case loop for very fast rendering can be
 * used. It has also been used with Wolfenstein 3D. MAES: this is called
 * mostly from inside Draw and from an external "Renderer"
 */

public final class R_DrawColumn extends DoomColumnFunction<byte[],short[]> {
    
    public R_DrawColumn(int SCREENWIDTH, int SCREENHEIGHT,
            int[] ylookup, int[] columnofs, ColVars<byte[],short[]> dcvars,
            short[] screen, IDoomSystem I) {
        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
    }
    
    public void invoke() {
        int count;
        // byte* dest;
        int dest; // As pointer
        // fixed_t
        int frac, fracstep;
        byte colmask = 127;
        count = dcvars.dc_yh - dcvars.dc_yl;
        // How much we should draw
        // count = Math.min(dc_yh - dc_yl,dc_source.length-dc_source_ofs-1);
        // colmask = (byte) Math.min(dc_source.length-dc_source_ofs-1,127);

        // Zero length, column does not exceed a pixel.
        if (count <= 0)
            return;

        if (RANGECHECK) {
            if (dcvars.dc_x >= SCREENWIDTH || dcvars.dc_yl < 0 || dcvars.dc_yh >= SCREENHEIGHT)
                I.Error("R_DrawColumn: %i to %i at %i", dcvars.dc_yl, dcvars.dc_yh, dcvars.dc_x);
        }

        // Trying to draw a masked column? Then something gross will happen.
        /*
         * if (count>=dc_source.length-dc_source_ofs) { int
         * diff=count-(dc_source.length-dc_source_ofs);
         * count=dc_source.length-dc_source_ofs-1; dc_source_ofs=0;
         * //dc_yl=dc_yh-count; gross=true; }
         */
        
        dest = computeScreenDest();

        // Determine scaling,
        // which is the only mapping to be done.
        fracstep = dcvars.dc_iscale;
        frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;

        // Inner loop that does the actual texture mapping,
        // e.g. a DDA-lile scaling.
        // This is as fast as it gets.
        do {
            /*
             * Re-map color indices from wall texture column using a
             * lighting/special effects LUT. 
             * Q: Where is "*dest"supposed to be pointing?
             * A: it's pointing inside screen[0] (set long before we came here)
             * dc_source is a pointer to a decompressed column's data.
             * Oh Woe if it points at non-pixel data.
             */
            // if (gross) System.out.println(frac >> FRACBITS);
            screen[dest] = dcvars.dc_colormap[0x00FF & dcvars.dc_source[(dcvars.dc_source_ofs + (frac >> FRACBITS))
                    & colmask]];

            /*
             * MAES: ok, so we have (from inside out):
             * 
             * frac is a fixed-point number representing a pointer inside a
             * column. It gets shifted to an integer, and AND-ed with 128
             * (this causes vertical column tiling).
             */
            dest += SCREENWIDTH;
            frac += fracstep;

        } while (count-- > 0);
    }
}
package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;


/**
 * Adapted from Killough's Boom code. Specially super-optimized version assuming
 * that dc_source_ofs is always 0, AND that frac>>FRACBITS can be eliminated by
 * doing fracstep>>FRACBITS a-priori. Experimental/untested.
 * 
 * @author admin
 * 
 */

public final class R_DrawColumnBoomSuperOpt extends DoomColumnFunction<byte[],short[]> {

		public R_DrawColumnBoomSuperOpt(int SCREENWIDTH, int SCREENHEIGHT,
	            int[] ylookup, int[] columnofs, ColVars<byte[],short[]> dcvars,
	            short[] screen, IDoomSystem I) {
	        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	    }

        public void invoke() {
			int count;
			int dest; // killough
			int frac; // killough
			final int fracstep;

			count = dcvars.dc_yh - dcvars.dc_yl + 1;

			if (count <= 0) // Zero length, column does not exceed a pixel.
				return;

			if (RANGECHECK) {
				performRangeCheck();
			}

			// Framebuffer destination address.
			// Use ylookup LUT to avoid multiply with ScreenWidth.
			// Use columnofs LUT for subwindows?

			dest = computeScreenDest();

			// Determine scaling, which is the only mapping to be done.

			fracstep = dcvars.dc_iscale>>FRACBITS;
			frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;
			frac>>=FRACBITS;

			// Inner loop that does the actual texture mapping,
			// e.g. a DDA-lile scaling.
			// This is as fast as it gets. (Yeah, right!!! -- killough)
			//
			// killough 2/1/98: more performance tuning

			{
				final byte[] source = dcvars.dc_source;
				final short[] colormap = dcvars.dc_colormap;
				int heightmask = dcvars.dc_texheight - 1;
				if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2 --
														// killough
				{
					heightmask++;
					heightmask <<= FRACBITS;

					if (frac < 0)
						while ((frac += heightmask) < 0)
							;
					else
						while (frac >= heightmask)
							frac -= heightmask;

					do {
						// Re-map color indices from wall texture column
						// using a lighting/special effects LUT.

						// heightmask is the Tutti-Frutti fix -- killough

						screen[dest] = colormap[0x00FF & source[frac]];
						dest += SCREENWIDTH;
						if ((frac += fracstep) >= heightmask)
							frac -= heightmask;
					} while (--count > 0);
				} else {
					while (count >= 4) // texture height is a power of 2 --
										// killough
					{
						// System.err.println(dest);
						screen[dest] = colormap[0x00FF & source[frac & heightmask]];
						dest += SCREENWIDTH;
						frac += fracstep;
						screen[dest] = colormap[0x00FF & source[frac & heightmask]];
						dest += SCREENWIDTH;
						frac += fracstep;
						screen[dest] = colormap[0x00FF & source[frac & heightmask]];
						dest += SCREENWIDTH;
						frac += fracstep;
						screen[dest] = colormap[0x00FF & source[frac & heightmask]];
						dest += SCREENWIDTH;
						frac += fracstep;
						count -= 4;
					}

					while (count > 0) {
						screen[dest] = colormap[0x00FF & source[frac & heightmask]];
						dest += SCREENWIDTH;
						frac += fracstep;
						count--;
					}
				}
			}
		}
	}
package rr.drawfuns;

import i.IDoomSystem;

/**
 * Drawspan loop unrolled by 4. However it has low rendering quality and bad
 * distortion. However it does actually does give a small speed boost (120
 * -> 130 fps with a Mul of 3.0)
 * 
 */

public abstract class R_DrawSpanUnrolled<T,V> extends DoomSpanFunction<T,V> {


    public R_DrawSpanUnrolled(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
            int[] columnofs, SpanVars<T, V> dsvars, V screen, IDoomSystem I) {
        super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
        // TODO Auto-generated constructor stub
    }

   public static final class HiColor extends R_DrawSpanUnrolled<byte[],short[]>{
       
       
       public HiColor(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
            int[] columnofs, SpanVars<byte[], short[]> dsvars, short[] screen,
            IDoomSystem I) {
        super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
        // TODO Auto-generated constructor stub
    }

    public void invoke() {
           int position, step;
           final byte[] source;
           final short[] colormap;
           int dest;
           int count;
           int spot;
           int xtemp;
           int ytemp;

           position = ((dsvars.ds_xfrac << 10) & 0xffff0000)
                   | ((dsvars.ds_yfrac >> 6) & 0xffff);
           step = ((dsvars.ds_xstep << 10) & 0xffff0000) | ((dsvars.ds_ystep >> 6) & 0xffff);
           source = dsvars.ds_source;
           colormap = dsvars.ds_colormap;
           dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];
           count = dsvars.ds_x2 - dsvars.ds_x1 + 1;
           //int rolls = 0;
           while (count >= 4) {
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest] = colormap[0x00FF & source[spot]];
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest + 1] = colormap[0x00FF & source[spot]];
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest + 2] = colormap[0x00FF & source[spot]];
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest + 3] = colormap[0x00FF & source[spot]];
               count -= 4;
               dest += 4;

               // Half-assed attempt to fix precision by forced periodic
               // realignment.

               /*
                * if ((rolls++)%64==0){ position =
                * ((((rolls*4)*ds_xstep+ds_xfrac) << 10) & 0xffff0000) |
                * ((((rolls*4)*ds_ystep+ds_yfrac) >> 6) & 0xffff); }
                */

           }

           while (count > 0) {
               ytemp = position >> 4;
               ytemp = ytemp & 4032;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest++] = colormap[0x00FF & source[spot]];
               count--;
           }
       }
       
   }

   
public static final class Indexed extends R_DrawSpanUnrolled<byte[],byte[]>{
       
       
       public Indexed(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
            int[] columnofs, SpanVars<byte[], byte[]> dsvars, byte[] screen,
            IDoomSystem I) {
        super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
        // TODO Auto-generated constructor stub
    }

    public void invoke() {
           int position, step;
           final byte[] source;
           final byte[] colormap;
           int dest;
           int count;
           int spot;
           int xtemp;
           int ytemp;

           position = ((dsvars.ds_xfrac << 10) & 0xffff0000)
                   | ((dsvars.ds_yfrac >> 6) & 0xffff);
           step = ((dsvars.ds_xstep << 10) & 0xffff0000) | ((dsvars.ds_ystep >> 6) & 0xffff);
           source = dsvars.ds_source;
           colormap = dsvars.ds_colormap;
           dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];
           count = dsvars.ds_x2 - dsvars.ds_x1 + 1;
           //int rolls = 0;
           while (count >= 4) {
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest] = colormap[0x00FF & source[spot]];
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest + 1] = colormap[0x00FF & source[spot]];
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest + 2] = colormap[0x00FF & source[spot]];
               ytemp = position >> 4;
               ytemp = ytemp & 0xfc0;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest + 3] = colormap[0x00FF & source[spot]];
               count -= 4;
               dest += 4;

               // Half-assed attempt to fix precision by forced periodic
               // realignment.

               /*
                * if ((rolls++)%64==0){ position =
                * ((((rolls*4)*ds_xstep+ds_xfrac) << 10) & 0xffff0000) |
                * ((((rolls*4)*ds_ystep+ds_yfrac) >> 6) & 0xffff); }
                */

           }

           while (count > 0) {
               ytemp = position >> 4;
               ytemp = ytemp & 4032;
               xtemp = position >>> 26;
               spot = xtemp | ytemp;
               position += step;
               screen[dest++] = colormap[0x00FF & source[spot]];
               count--;
           }
       }
       
   }

public static final class TrueColor extends R_DrawSpanUnrolled<byte[],int[]>{
    
    
    public TrueColor(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
         int[] columnofs, SpanVars<byte[], int[]> dsvars, int[] screen,
         IDoomSystem I) {
     super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
 }

 public void invoke() {
        int position, step;
        final byte[] source;
        final int[] colormap;
        int dest;
        int count;
        int spot;
        int xtemp;
        int ytemp;

        position = ((dsvars.ds_xfrac << 10) & 0xffff0000)
                | ((dsvars.ds_yfrac >> 6) & 0xffff);
        step = ((dsvars.ds_xstep << 10) & 0xffff0000) | ((dsvars.ds_ystep >> 6) & 0xffff);
        source = dsvars.ds_source;
        colormap = dsvars.ds_colormap;
        dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];
        count = dsvars.ds_x2 - dsvars.ds_x1 + 1;
        //int rolls = 0;
        while (count >= 4) {
            ytemp = position >> 4;
            ytemp = ytemp & 0xfc0;
            xtemp = position >>> 26;
            spot = xtemp | ytemp;
            position += step;
            screen[dest] = colormap[0x00FF & source[spot]];
            ytemp = position >> 4;
            ytemp = ytemp & 0xfc0;
            xtemp = position >>> 26;
            spot = xtemp | ytemp;
            position += step;
            screen[dest + 1] = colormap[0x00FF & source[spot]];
            ytemp = position >> 4;
            ytemp = ytemp & 0xfc0;
            xtemp = position >>> 26;
            spot = xtemp | ytemp;
            position += step;
            screen[dest + 2] = colormap[0x00FF & source[spot]];
            ytemp = position >> 4;
            ytemp = ytemp & 0xfc0;
            xtemp = position >>> 26;
            spot = xtemp | ytemp;
            position += step;
            screen[dest + 3] = colormap[0x00FF & source[spot]];
            count -= 4;
            dest += 4;

            // Half-assed attempt to fix precision by forced periodic
            // realignment.

            /*
             * if ((rolls++)%64==0){ position =
             * ((((rolls*4)*ds_xstep+ds_xfrac) << 10) & 0xffff0000) |
             * ((((rolls*4)*ds_ystep+ds_yfrac) >> 6) & 0xffff); }
             */

        }

        while (count > 0) {
            ytemp = position >> 4;
            ytemp = ytemp & 4032;
            xtemp = position >>> 26;
            spot = xtemp | ytemp;
            position += step;
            screen[dest++] = colormap[0x00FF & source[spot]];
            count--;
        }
    }
    
}
}

package rr.drawfuns;

import i.IDoomSystem;

/**
 * Low detail version. Jesus.
 */

public abstract class R_DrawFuzzColumnLow<T, V> extends
		DoomColumnFunction<T, V> {

	public R_DrawFuzzColumnLow(int SCREENWIDTH, int SCREENHEIGHT,
			int[] ylookup, int[] columnofs, ColVars<T, V> dcvars, V screen,
			IDoomSystem I, T BLURRY_MAP) {
		this(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
		this.BLURRY_MAP = BLURRY_MAP;
	}

	public R_DrawFuzzColumnLow(int SCREENWIDTH, int SCREENHEIGHT,
			int[] ylookup, int[] columnofs, ColVars<T, V> dcvars, V screen,
			IDoomSystem I) {
		super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
		this.flags = DcFlags.LOW_DETAIL | DcFlags.FUZZY;

		FUZZOFF = SCREENWIDTH;

		// Recompute fuzz table

		fuzzoffset = new int[] { FUZZOFF, -FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF,
				FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF,
				FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF,
				-FUZZOFF, -FUZZOFF, -FUZZOFF, -FUZZOFF, FUZZOFF, -FUZZOFF,
				-FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF,
				FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF, -FUZZOFF,
				FUZZOFF, FUZZOFF, -FUZZOFF, -FUZZOFF, -FUZZOFF, -FUZZOFF,
				FUZZOFF, FUZZOFF, FUZZOFF, FUZZOFF, -FUZZOFF, FUZZOFF, FUZZOFF,
				-FUZZOFF, FUZZOFF };
	}

	protected int fuzzpos;

	//
	// Spectre/Invisibility.
	//

	protected final int FUZZOFF;

	protected final int[] fuzzoffset;

	public static final class HiColor extends R_DrawFuzzColumn<byte[], short[]> {

		public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
				int[] columnofs, ColVars<byte[], short[]> dcvars,
				short[] screen, IDoomSystem I) {
			super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
					screen, I);
			// TODO Auto-generated constructor stub
		}

		public void invoke() {
			int count;
			int dest, dest2;

			// Adjust borders. Low...
			if (dcvars.dc_yl == 0)
				dcvars.dc_yl = 1;

			// .. and high.
			if (dcvars.dc_yh == dcvars.viewheight - 1)
				dcvars.dc_yh = dcvars.viewheight - 2;

			count = dcvars.dc_yh - dcvars.dc_yl;

			// Zero length.
			if (count < 0)
				return;

			if (RANGECHECK) {
				performRangeCheck();
			}

			// The idea is to draw more than one pixel at a time.
			dest = blockyDest1();
			dest2 = blockyDest2();

			// Looks like an attempt at dithering,
			// using the colormap #6 (of 0-31, a bit
			// brighter than average).
			if (count > 4)
				do {
					// Lookup framebuffer, and retrieve
					// a pixel that is either one column
					// left or right of the current one.
					// Add index from colormap to index.
					screen[dest] = screen[dest + fuzzoffset[fuzzpos]];
					screen[dest2] = screen[dest];

					// Ironically, "low detail" fuzziness was not really
					// low-detail,
					// as it normally did full-precision calculations.
					// BLURRY_MAP[0x00FF & screen[dest2+ fuzzoffset[fuzzpos]]];

					// Clamp table lookup index.
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;

					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;

					screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
					screen[dest2] = screen[dest];
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;
					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;

					screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
					screen[dest2] = screen[dest];
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;
					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;

					screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
					screen[dest2] = screen[dest];
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;
					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;
				} while ((count -= 4) > 4);

			if (count > 0)
				do {
					screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
					screen[dest2] = screen[dest];

					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;

					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;
				} while (count-- != 0);

		}

		private final short fuzzMix(short rgb) {
			// super-fast half-brite trick
			// 3DEF and >> 1: ok hue, but too dark
			// 7BDE, no shift: good compromise
			// 739C, no shift: results in too obvious tinting.

			return (short) (rgb & 0x7BDE);

		}
	}

	public static final class Indexed extends R_DrawFuzzColumn<byte[], byte[]> {

		public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
				int[] columnofs, ColVars<byte[], byte[]> dcvars, byte[] screen,
				IDoomSystem I, byte[] BLURRY_MAP) {
			super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
					screen, I, BLURRY_MAP);
		}

		public void invoke() {
			int count;
			int dest, dest2;

			// Adjust borders. Low...
			if (dcvars.dc_yl == 0)
				dcvars.dc_yl = 1;

			// .. and high.
			if (dcvars.dc_yh == dcvars.viewheight - 1)
				dcvars.dc_yh = dcvars.viewheight - 2;

			count = dcvars.dc_yh - dcvars.dc_yl;

			// Zero length.
			if (count < 0)
				return;

			if (RANGECHECK) {
				performRangeCheck();
			}

			// The idea is to draw more than one pixel at a time.
			dest = blockyDest1();
			dest2 = blockyDest2();

			// Looks like an attempt at dithering,
			// using the colormap #6 (of 0-31, a bit
			// brighter than average).
			if (count > 4)
				do {
					// Lookup framebuffer, and retrieve
					// a pixel that is either one column
					// left or right of the current one.
					// Add index from colormap to index.
					screen[dest] = BLURRY_MAP[0x00FF & screen[dest
							+ fuzzoffset[fuzzpos]]];
					screen[dest2] = screen[dest];

					// Ironically, "low detail" fuzziness was not really
					// low-detail,
					// as it normally did full-precision calculations.
					// BLURRY_MAP[0x00FF & screen[dest2+ fuzzoffset[fuzzpos]]];

					// Clamp table lookup index.
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;

					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;

					screen[dest] = BLURRY_MAP[0x00FF & screen[dest
							+ fuzzoffset[fuzzpos]]];
					screen[dest2] = screen[dest];
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;
					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;

					screen[dest] = BLURRY_MAP[0x00FF & screen[dest
							+ fuzzoffset[fuzzpos]]];
					screen[dest2] = screen[dest];
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;
					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;

					screen[dest] = BLURRY_MAP[0x00FF & screen[dest
							+ fuzzoffset[fuzzpos]]];
					screen[dest2] = screen[dest];
					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;
					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;
				} while ((count -= 4) > 4);

			if (count > 0)
				do {
					screen[dest] = BLURRY_MAP[0x00FF & screen[dest
							+ fuzzoffset[fuzzpos]]];
					screen[dest2] = screen[dest];

					if (++fuzzpos == FUZZTABLE)
						fuzzpos = 0;

					dest += SCREENWIDTH;
					dest2 += SCREENWIDTH;
				} while (count-- != 0);

		}
	}
	
	public static final class TrueColor extends R_DrawFuzzColumn<byte[], int[]> {

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], int[]> dcvars,
                int[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest, dest2;

            // Adjust borders. Low...
            if (dcvars.dc_yl == 0)
                dcvars.dc_yl = 1;

            // .. and high.
            if (dcvars.dc_yh == dcvars.viewheight - 1)
                dcvars.dc_yh = dcvars.viewheight - 2;

            count = dcvars.dc_yh - dcvars.dc_yl;

            // Zero length.
            if (count < 0)
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // The idea is to draw more than one pixel at a time.
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Looks like an attempt at dithering,
            // using the colormap #6 (of 0-31, a bit
            // brighter than average).
            if (count > 4)
                do {
                    // Lookup framebuffer, and retrieve
                    // a pixel that is either one column
                    // left or right of the current one.
                    // Add index from colormap to index.
                    screen[dest] = screen[dest + fuzzoffset[fuzzpos]];
                    screen[dest2] = screen[dest];

                    // Ironically, "low detail" fuzziness was not really
                    // low-detail,
                    // as it normally did full-precision calculations.
                    // BLURRY_MAP[0x00FF & screen[dest2+ fuzzoffset[fuzzpos]]];

                    // Clamp table lookup index.
                    if (++fuzzpos == FUZZTABLE)
                        fuzzpos = 0;

                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;

                    screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
                    screen[dest2] = screen[dest];
                    if (++fuzzpos == FUZZTABLE)
                        fuzzpos = 0;
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;

                    screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
                    screen[dest2] = screen[dest];
                    if (++fuzzpos == FUZZTABLE)
                        fuzzpos = 0;
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;

                    screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
                    screen[dest2] = screen[dest];
                    if (++fuzzpos == FUZZTABLE)
                        fuzzpos = 0;
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    screen[dest] = fuzzMix(screen[dest + fuzzoffset[fuzzpos]]);
                    screen[dest2] = screen[dest];

                    if (++fuzzpos == FUZZTABLE)
                        fuzzpos = 0;

                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                } while (count-- != 0);

        }

        private final int fuzzMix(int rgb) {
            // super-fast half-brite trick
            // 3DEF and >> 1: ok hue, but too dark
            // FF7C7C7C, no shift: good compromise
            // FF707070, no shift: results in too obvious tinting.

            return (rgb>>1)&0xFF7F7F7F;

        }
    }
}
package rr.drawfuns;

/** Either draws a column or a span
 * 
 * @author velktron
 *
 */

public interface ColumnFunction<T,V> {
    public void invoke();
    
	public void invoke(ColVars<T,V> dcvars);
	
	/** A set of flags that help identifying the type of function */
	public int getFlags();
}
package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;

/**
 * Adapted from Killough's Boom code. Specially optimized version assuming that
 * dc_source_ofs is always 0. This eliminates it from expressions.
 * 
 * @author admin
 */

public abstract class R_DrawColumnBoomOpt<T, V>
        extends DoomColumnFunction<T, V> {

    public R_DrawColumnBoomOpt(int sCREENWIDTH, int sCREENHEIGHT,
            int[] ylookup, int[] columnofs, ColVars<T, V> dcvars, V screen,
            IDoomSystem I) {
        super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
    }

    public static final class HiColor
            extends R_DrawColumnBoomOpt<byte[], short[]> {
        public HiColor(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], short[]> dcvars,
                short[] screen, IDoomSystem I) {
            super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest; // killough
            int frac; // killough
            final int fracstep;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?

            dest = computeScreenDest();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final short[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {
                        // System.err.println(dest);
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }

    public static final class Indexed
            extends R_DrawColumnBoomOpt<byte[], byte[]> {
        public Indexed(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], byte[]> dcvars, byte[] screen,
                IDoomSystem I) {
            super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest; // killough
            int frac; // killough
            final int fracstep;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?

            dest = computeScreenDest();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final byte[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {
                        // System.err.println(dest);
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }

    public static final class TrueColor
            extends R_DrawColumnBoomOpt<byte[], int[]> {
        public TrueColor(int sCREENWIDTH, int sCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], int[]> dcvars, int[] screen,
                IDoomSystem I) {
            super(sCREENWIDTH, sCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest; // killough
            int frac; // killough
            final int fracstep;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?

            dest = computeScreenDest();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final int[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {
                        // System.err.println(dest);
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }

}
package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;

/**
 * Adapted from Killough's Boom code. Low-detail variation, with DC SOURCE 
 * optimization.
 * 
 * @author admin
 * 
 */

public abstract class R_DrawColumnBoomOptLow<T,V> extends DoomColumnFunction<T,V> {

		public R_DrawColumnBoomOptLow(int SCREENWIDTH, int SCREENHEIGHT,
	            int[] ylookup, int[] columnofs, ColVars<T,V> dcvars,
	            V screen, IDoomSystem I) {
	        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	        this.flags=DcFlags.LOW_DETAIL;
	    }

		
		public static final class HiColor extends R_DrawColumnBoomOptLow<byte[],short[]>{
		
		public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                    int[] columnofs, ColVars<byte[], short[]> dcvars,
                    short[] screen, IDoomSystem I) {
                super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
            }

        public void invoke() {
            int count;
            int dest,dest2; // killough
            int frac; // killough
            final int fracstep;

            count = dcvars.dc_yh - dcvars.dc_yl + 1;
            // Assumed to be always zero for optimized draws.
            //dc_source_ofs=dcvars.dc_source_ofs;
            
            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            // Framebuffer destination address.
            // Use ylookup LUT to avoid multiply with ScreenWidth.
            // Use columnofs LUT for subwindows?
            dest = blockyDest1();
            dest2 = blockyDest2();
            
            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final short[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2 --
                                                        // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killough

                        screen[dest] = screen[dest2]=colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                        // killough
                    {

                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        dest2 += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
		}
		
		public static final class Indexed extends R_DrawColumnBoomOptLow<byte[],byte[]>{
	        
	        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
	                    int[] columnofs, ColVars<byte[], byte[]> dcvars,
	                    byte[] screen, IDoomSystem I) {
	                super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	            }

	        public void invoke() {
	            int count;
	            int dest,dest2; // killough
	            int frac; // killough
	            final int fracstep;

	            count = dcvars.dc_yh - dcvars.dc_yl + 1;
	            // Assumed to be always zero for optimized draws.
	            //dc_source_ofs=dcvars.dc_source_ofs;
	            
	            if (count <= 0) // Zero length, column does not exceed a pixel.
	                return;

	            if (RANGECHECK) {
	                performRangeCheck();
	            }

	            // Framebuffer destination address.
	            // Use ylookup LUT to avoid multiply with ScreenWidth.
	            // Use columnofs LUT for subwindows?
	            dest = blockyDest1();
	            dest2 = blockyDest2();
	            
	            // Determine scaling, which is the only mapping to be done.

	            fracstep = dcvars.dc_iscale;
	            frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;

	            // Inner loop that does the actual texture mapping,
	            // e.g. a DDA-lile scaling.
	            // This is as fast as it gets. (Yeah, right!!! -- killough)
	            //
	            // killough 2/1/98: more performance tuning

	            {
	                final byte[] source = dcvars.dc_source;
	                final byte[] colormap = dcvars.dc_colormap;
	                int heightmask = dcvars.dc_texheight - 1;
	                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2 --
	                                                        // killough
	                {
	                    heightmask++;
	                    heightmask <<= FRACBITS;

	                    if (frac < 0)
	                        while ((frac += heightmask) < 0)
	                            ;
	                    else
	                        while (frac >= heightmask)
	                            frac -= heightmask;

	                    do {
	                        // Re-map color indices from wall texture column
	                        // using a lighting/special effects LUT.

	                        // heightmask is the Tutti-Frutti fix -- killough

	                        screen[dest] = screen[dest2]=colormap[0x00FF & source[((frac >> FRACBITS))]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        if ((frac += fracstep) >= heightmask)
	                            frac -= heightmask;
	                    } while (--count > 0);
	                } else {
	                    while (count >= 4) // texture height is a power of 2 --
	                                        // killough
	                    {

	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        count -= 4;
	                    }

	                    while (count > 0) {
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        count--;
	                    }
	                }
	            }
	        }
	        }
		
		public static final class TrueColor extends R_DrawColumnBoomOptLow<byte[],int[]>{
	        
	        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
	                    int[] columnofs, ColVars<byte[], int[]> dcvars,
	                    int[] screen, IDoomSystem I) {
	                super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	            }

	        public void invoke() {
	            int count;
	            int dest,dest2; // killough
	            int frac; // killough
	            final int fracstep;

	            count = dcvars.dc_yh - dcvars.dc_yl + 1;
	            // Assumed to be always zero for optimized draws.
	            //dc_source_ofs=dcvars.dc_source_ofs;
	            
	            if (count <= 0) // Zero length, column does not exceed a pixel.
	                return;

	            if (RANGECHECK) {
	                performRangeCheck();
	            }

	            // Framebuffer destination address.
	            // Use ylookup LUT to avoid multiply with ScreenWidth.
	            // Use columnofs LUT for subwindows?
	            dest = blockyDest1();
	            dest2 = blockyDest2();
	            
	            // Determine scaling, which is the only mapping to be done.

	            fracstep = dcvars.dc_iscale;
	            frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;

	            // Inner loop that does the actual texture mapping,
	            // e.g. a DDA-lile scaling.
	            // This is as fast as it gets. (Yeah, right!!! -- killough)
	            //
	            // killough 2/1/98: more performance tuning

	            {
	                final byte[] source = dcvars.dc_source;
	                final int[] colormap = dcvars.dc_colormap;
	                int heightmask = dcvars.dc_texheight - 1;
	                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2 --
	                                                        // killough
	                {
	                    heightmask++;
	                    heightmask <<= FRACBITS;

	                    if (frac < 0)
	                        while ((frac += heightmask) < 0)
	                            ;
	                    else
	                        while (frac >= heightmask)
	                            frac -= heightmask;

	                    do {
	                        // Re-map color indices from wall texture column
	                        // using a lighting/special effects LUT.

	                        // heightmask is the Tutti-Frutti fix -- killough

	                        screen[dest] = screen[dest2]=colormap[0x00FF & source[((frac >> FRACBITS))]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        if ((frac += fracstep) >= heightmask)
	                            frac -= heightmask;
	                    } while (--count > 0);
	                } else {
	                    while (count >= 4) // texture height is a power of 2 --
	                                        // killough
	                    {

	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        count -= 4;
	                    }

	                    while (count > 0) {
	                        screen[dest] = screen[dest2]= colormap[0x00FF & source[((frac >> FRACBITS) & heightmask)]];
	                        dest += SCREENWIDTH;
	                        dest2 += SCREENWIDTH;
	                        frac += fracstep;
	                        count--;
	                    }
	                }
	            }
	        }
	        }
		
		
	}
package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;

public abstract class R_DrawTranslatedColumn<T, V>
        extends DoomColumnFunction<T, V> {

    public R_DrawTranslatedColumn(int SCREENWIDTH, int SCREENHEIGHT,
            int[] ylookup, int[] columnofs, ColVars<T, V> dcvars, V screen,
            IDoomSystem I) {
        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
        this.flags = DcFlags.TRANSLATED;
    }

    public static final class HiColor
            extends R_DrawTranslatedColumn<byte[], short[]> {
        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], short[]> dcvars,
                short[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            // MAES: you know the deal by now...
            int dest;
            int frac;
            final int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            final byte[] dc_source = dcvars.dc_source;
            final short[] dc_colormap = dcvars.dc_colormap;
            final byte[] dc_translation = dcvars.dc_translation;

            count = dcvars.dc_yh - dcvars.dc_yl;
            if (count < 0)
                return;

            if (RANGECHECK) {
                super.performRangeCheck();
            }

            // WATCOM VGA specific.
            /*
             * Keep for fixing. if (detailshift) { if (dc_x & 1) outp
             * (SC_INDEX+1,12); else outp (SC_INDEX+1,3); dest = destview +
             * dc_yl*80 + (dc_x>>1); } else { outp (SC_INDEX+1,1<<(dc_x&3));
             * dest = destview + dc_yl*80 + (dc_x>>2); }
             */

            // FIXME. As above.
            dest = computeScreenDest();

            // Looks familiar.
            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Here we do an additional index re-mapping.
            // Maes: Unroll by 4
            if (count >= 4)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;

                    frac += fracstep;
                } while (count-- != 0);
        }
    }

    public static final class Indexed
            extends R_DrawTranslatedColumn<byte[], byte[]> {

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], byte[]> dcvars, byte[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            // MAES: you know the deal by now...
            int dest;
            int frac;
            final int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            final byte[] dc_source = dcvars.dc_source;
            final byte[] dc_colormap = dcvars.dc_colormap;
            final byte[] dc_translation = dcvars.dc_translation;

            count = dcvars.dc_yh - dcvars.dc_yl;
            if (count < 0)
                return;

            if (RANGECHECK) {
                super.performRangeCheck();
            }

            // WATCOM VGA specific.
            /*
             * Keep for fixing. if (detailshift) { if (dc_x & 1) outp
             * (SC_INDEX+1,12); else outp (SC_INDEX+1,3); dest = destview +
             * dc_yl*80 + (dc_x>>1); } else { outp (SC_INDEX+1,1<<(dc_x&3));
             * dest = destview + dc_yl*80 + (dc_x>>2); }
             */

            // FIXME. As above.
            dest = computeScreenDest();

            // Looks familiar.
            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Here we do an additional index re-mapping.
            // Maes: Unroll by 4
            if (count >= 4)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;

                    frac += fracstep;
                } while (count-- != 0);
        }
    }

    public static final class TrueColor
            extends R_DrawTranslatedColumn<byte[], int[]> {
        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], int[]> dcvars, int[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            // MAES: you know the deal by now...
            int dest;
            int frac;
            final int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            final byte[] dc_source = dcvars.dc_source;
            final int[] dc_colormap = dcvars.dc_colormap;
            final byte[] dc_translation = dcvars.dc_translation;

            count = dcvars.dc_yh - dcvars.dc_yl;
            if (count < 0)
                return;

            if (RANGECHECK) {
                super.performRangeCheck();
            }

            // WATCOM VGA specific.
            /*
             * Keep for fixing. if (detailshift) { if (dc_x & 1) outp
             * (SC_INDEX+1,12); else outp (SC_INDEX+1,3); dest = destview +
             * dc_yl*80 + (dc_x>>1); } else { outp (SC_INDEX+1,1<<(dc_x&3));
             * dest = destview + dc_yl*80 + (dc_x>>2); }
             */

            // FIXME. As above.
            dest = computeScreenDest();

            // Looks familiar.
            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Here we do an additional index re-mapping.
            // Maes: Unroll by 4
            if (count >= 4)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    frac += fracstep;

                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;

                    frac += fracstep;
                } while (count-- != 0);
        }
    }
}
package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;

public abstract class R_DrawTranslatedColumnLow<T, V>
        extends DoomColumnFunction<T, V> {

    public R_DrawTranslatedColumnLow(int SCREENWIDTH, int SCREENHEIGHT,
            int[] ylookup, int[] columnofs, ColVars<T, V> dcvars, V screen,
            IDoomSystem I) {
        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
        this.flags = DcFlags.TRANSLATED | DcFlags.LOW_DETAIL;
    }

    public static final class HiColor
            extends R_DrawTranslatedColumnLow<byte[], short[]> {
        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], short[]> dcvars,
                short[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            // MAES: you know the deal by now...
            int dest, dest2;
            int frac;
            final int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            final byte[] dc_source = dcvars.dc_source;
            final short[] dc_colormap = dcvars.dc_colormap;
            final byte[] dc_translation = dcvars.dc_translation;

            count = dcvars.dc_yh - dcvars.dc_yl;
            if (count < 0)
                return;

            if (RANGECHECK) {
                super.performRangeCheck();
            }

            // The idea is to draw more than one pixel at a time.
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Looks familiar.
            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Here we do an additional index re-mapping.
            // Maes: Unroll by 4
            if (count >= 4)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;

                    frac += fracstep;
                } while (count-- != 0);
        }

    }

    public static final class Indexed
            extends R_DrawTranslatedColumnLow<byte[], byte[]> {

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], byte[]> dcvars, byte[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            // MAES: you know the deal by now...
            int dest, dest2;
            int frac;
            final int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            final byte[] dc_source = dcvars.dc_source;
            final byte[] dc_colormap = dcvars.dc_colormap;
            final byte[] dc_translation = dcvars.dc_translation;

            count = dcvars.dc_yh - dcvars.dc_yl;
            if (count < 0)
                return;

            if (RANGECHECK) {
                super.performRangeCheck();
            }

            // The idea is to draw more than one pixel at a time.
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Looks familiar.
            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Here we do an additional index re-mapping.
            // Maes: Unroll by 4
            if (count >= 4)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;

                    frac += fracstep;
                } while (count-- != 0);
        }
    }

    public static final class TrueColor
            extends R_DrawTranslatedColumnLow<byte[], int[]> {

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], int[]> dcvars, int[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            // MAES: you know the deal by now...
            int dest, dest2;
            int frac;
            final int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            final byte[] dc_source = dcvars.dc_source;
            final int[] dc_colormap = dcvars.dc_colormap;
            final byte[] dc_translation = dcvars.dc_translation;

            count = dcvars.dc_yh - dcvars.dc_yl;
            if (count < 0)
                return;

            if (RANGECHECK) {
                super.performRangeCheck();
            }

            // The idea is to draw more than one pixel at a time.
            dest = blockyDest1();
            dest2 = blockyDest2();

            // Looks familiar.
            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Here we do an additional index re-mapping.
            // Maes: Unroll by 4
            if (count >= 4)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;
                    frac += fracstep;

                } while ((count -= 4) > 4);

            if (count > 0)
                do {
                    // Translation tables are used
                    // to map certain colorramps to other ones,
                    // used with PLAY sprites.
                    // Thus the "green" ramp of the player 0 sprite
                    // is mapped to gray, red, black/indigo.
                    screen[dest] =
                        screen[dest2] =
                            dc_colormap[0x00FF & dc_translation[0xFF & dc_source[dc_source_ofs
                                    + (frac >> FRACBITS)]]];
                    dest += SCREENWIDTH;
                    dest2 += SCREENWIDTH;

                    frac += fracstep;
                } while (count-- != 0);
        }
    }

}
package rr.drawfuns;

/** Flags used to mark column functions according to type, 
 *  for quick type identification.
 * 
 * @author velktron
 *
 */

public final class DcFlags {
    public static final int FUZZY=0x1;
    public static final int TRANSLATED=0x2;
    public static final int TRANSPARENT=0x4;
    public static final int LOW_DETAIL=0x8;
}

package rr.drawfuns;

import i.IDoomSystem;

public abstract class DoomSpanFunction<T,V> implements SpanFunction<T,V> {
    
    protected final boolean RANGECHECK=false;
    protected final int SCREENWIDTH;
    protected final int SCREENHEIGHT;
    protected SpanVars<T,V> dsvars;
    protected final int[] ylookup;
    protected final int[] columnofs;
    protected final V screen;
    protected final IDoomSystem I;
    
    public DoomSpanFunction(int sCREENWIDTH, int sCREENHEIGHT,
            int[] ylookup, int[] columnofs,SpanVars<T,V> dsvars, V screen,IDoomSystem I) {
        SCREENWIDTH = sCREENWIDTH;
        SCREENHEIGHT = sCREENHEIGHT;
        this.ylookup=ylookup;
        this.columnofs=columnofs;
        this.dsvars = dsvars;
        this.screen = screen;
        this.I=I;
    }
    
    protected final void doRangeCheck(){
        if (dsvars.ds_x2 < dsvars.ds_x1 || dsvars.ds_x1 < 0 || dsvars.ds_x2 >= SCREENWIDTH
                || dsvars.ds_y > SCREENHEIGHT) {
            I.Error("R_DrawSpan: %d to %d at %d", dsvars.ds_x1, dsvars.ds_x2, dsvars.ds_y);
        }
    }

    @Override
    public final void invoke(SpanVars<T,V> dsvars) {
        this.dsvars=dsvars;
        invoke();
    }
    
}

package rr.drawfuns;

import static m.fixed_t.FRACBITS;
import i.IDoomSystem;

/**
 * Adapted from Killough's Boom code. There are optimized as well as low-detail
 * versions of it.
 * 
 * @author admin
 */

public abstract class R_DrawColumnBoom<T, V>
        extends DoomColumnFunction<T, V> {

    public R_DrawColumnBoom(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
            int[] columnofs, ColVars<T, V> dcvars, V screen, IDoomSystem I) {
        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
    }

    public static final class HiColor
            extends R_DrawColumnBoom<byte[], short[]> {

        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], short[]> dcvars,
                short[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest; // killough
            int frac; // killough
            int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            count = dcvars.dc_yh - dcvars.dc_yl + 1;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            dest = computeScreenDest();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final short[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killoughdcvars

                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {
                        // System.err.println(dest);
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        try {
                            screen[dest] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        } catch (Exception e) {
                            System.err.printf("%s %s %x %x %x\n", colormap,
                                source, dc_source_ofs, frac, heightmask);
                        }
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }

    public static final class Indexed
            extends R_DrawColumnBoom<byte[], byte[]> {

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], byte[]> dcvars, byte[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest; // killough
            int frac; // killough
            int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            count = dcvars.dc_yh - dcvars.dc_yl + 1;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            dest = computeScreenDest();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final byte[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killoughdcvars

                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {
                        // System.err.println(dest);
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        try {
                            screen[dest] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        } catch (Exception e) {
                            System.err.printf("%s %s %x %x %x\n", colormap,
                                source, dc_source_ofs, frac, heightmask);
                        }
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }

    public static final class TrueColor
            extends R_DrawColumnBoom<byte[], int[]> {

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, ColVars<byte[], int[]> dcvars, int[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars,
                    screen, I);
        }

        public void invoke() {
            int count;
            int dest; // killough
            int frac; // killough
            int fracstep;
            final int dc_source_ofs = dcvars.dc_source_ofs;
            count = dcvars.dc_yh - dcvars.dc_yl + 1;

            if (count <= 0) // Zero length, column does not exceed a pixel.
                return;

            if (RANGECHECK) {
                performRangeCheck();
            }

            dest = computeScreenDest();

            // Determine scaling, which is the only mapping to be done.

            fracstep = dcvars.dc_iscale;
            frac =
                dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery)
                        * fracstep;

            // Inner loop that does the actual texture mapping,
            // e.g. a DDA-lile scaling.
            // This is as fast as it gets. (Yeah, right!!! -- killough)
            //
            // killough 2/1/98: more performance tuning

            {
                final byte[] source = dcvars.dc_source;
                final int[] colormap = dcvars.dc_colormap;
                int heightmask = dcvars.dc_texheight - 1;
                if ((dcvars.dc_texheight & heightmask) != 0) // not a power of 2
                                                             // --
                // killough
                {
                    heightmask++;
                    heightmask <<= FRACBITS;

                    if (frac < 0)
                        while ((frac += heightmask) < 0)
                            ;
                    else
                        while (frac >= heightmask)
                            frac -= heightmask;

                    do {
                        // Re-map color indices from wall texture column
                        // using a lighting/special effects LUT.

                        // heightmask is the Tutti-Frutti fix -- killoughdcvars

                        screen[dest] =
                            colormap[0x00FF & source[((frac >> FRACBITS))]];
                        dest += SCREENWIDTH;
                        if ((frac += fracstep) >= heightmask)
                            frac -= heightmask;
                    } while (--count > 0);
                } else {
                    while (count >= 4) // texture height is a power of 2 --
                                       // killough
                    {
                        // System.err.println(dest);
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        screen[dest] =
                            colormap[0x00FF & source[dc_source_ofs
                                    + ((frac >> FRACBITS) & heightmask)]];
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count -= 4;
                    }

                    while (count > 0) {
                        try {
                            screen[dest] =
                                colormap[0x00FF & source[dc_source_ofs
                                        + ((frac >> FRACBITS) & heightmask)]];
                        } catch (Exception e) {
                            System.err.printf("%s %s %x %x %x\n", colormap,
                                source, dc_source_ofs, frac, heightmask);
                        }
                        dest += SCREENWIDTH;
                        frac += fracstep;
                        count--;
                    }
                }
            }
        }
    }
}
package rr.drawfuns;

import i.IDoomSystem;

public abstract class R_DrawSpanLow<T, V>
        extends DoomSpanFunction<T, V> {

    public R_DrawSpanLow(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
            int[] columnofs, SpanVars<T, V> dsvars, V screen, IDoomSystem I) {
        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dsvars, screen, I);
    }

    public static final class HiColor
            extends R_DrawSpanLow<byte[], short[]> {

        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, SpanVars<byte[], short[]> dsvars,
                short[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dsvars,
                    screen, I);
        }

        @Override
        public void invoke() {
            final byte[] ds_source = dsvars.ds_source;
            final short[] ds_colormap = dsvars.ds_colormap;
            final int ds_xstep = dsvars.ds_xstep;
            final int ds_ystep = dsvars.ds_ystep;
            int f_xfrac = dsvars.ds_xfrac;
            int f_yfrac = dsvars.ds_yfrac;
            int dest;
            int count;
            int spot;

            if (RANGECHECK) {
                doRangeCheck();
                // dscount++;
            }

            // MAES: count must be performed before shifting.
            count = dsvars.ds_x2 - dsvars.ds_x1;

            // Blocky mode, need to multiply by 2.
            dsvars.ds_x1 <<= 1;
            dsvars.ds_x2 <<= 1;

            dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];

            do {
                spot =
                    ((f_yfrac >> (16 - 6)) & (63 * 64))
                            + ((f_xfrac >> 16) & 63);
                // Lowres/blocky mode does it twice,
                // while scale is adjusted appropriately.

                screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];
                screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];

                f_xfrac += ds_xstep;
                f_yfrac += ds_ystep;

            } while (count-- > 0);

        }
    }

    public static final class Indexed
            extends R_DrawSpanLow<byte[], byte[]> {

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, SpanVars<byte[], byte[]> dsvars,
                byte[] screen, IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dsvars,
                    screen, I);
        }

        public void invoke() {
            final byte[] ds_source = dsvars.ds_source;
            final byte[] ds_colormap = dsvars.ds_colormap;
            final int ds_xstep = dsvars.ds_xstep;
            final int ds_ystep = dsvars.ds_ystep;
            int f_xfrac = dsvars.ds_xfrac;
            int f_yfrac = dsvars.ds_yfrac;
            int dest;
            int count;
            int spot;

            if (RANGECHECK) {
                doRangeCheck();
                // dscount++;
            }

            // MAES: count must be performed before shifting.
            count = dsvars.ds_x2 - dsvars.ds_x1;

            // Blocky mode, need to multiply by 2.
            dsvars.ds_x1 <<= 1;
            dsvars.ds_x2 <<= 1;

            dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];

            do {
                spot =
                    ((f_yfrac >> (16 - 6)) & (63 * 64))
                            + ((f_xfrac >> 16) & 63);
                // Lowres/blocky mode does it twice,
                // while scale is adjusted appropriately.

                screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];
                screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];

                f_xfrac += ds_xstep;
                f_yfrac += ds_ystep;

            } while (count-- > 0);

        }
    }

    public static final class TrueColor
            extends R_DrawSpanLow<byte[], int[]> {

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] ylookup,
                int[] columnofs, SpanVars<byte[], int[]> dsvars, int[] screen,
                IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dsvars,
                    screen, I);
        }

        @Override
        public void invoke() {
            final byte[] ds_source = dsvars.ds_source;
            final int[] ds_colormap = dsvars.ds_colormap;
            final int ds_xstep = dsvars.ds_xstep;
            final int ds_ystep = dsvars.ds_ystep;
            int f_xfrac = dsvars.ds_xfrac;
            int f_yfrac = dsvars.ds_yfrac;
            int dest;
            int count;
            int spot;

            if (RANGECHECK) {
                doRangeCheck();
                // dscount++;
            }

            // MAES: count must be performed before shifting.
            count = dsvars.ds_x2 - dsvars.ds_x1;

            // Blocky mode, need to multiply by 2.
            dsvars.ds_x1 <<= 1;
            dsvars.ds_x2 <<= 1;

            dest = ylookup[dsvars.ds_y] + columnofs[dsvars.ds_x1];

            do {
                spot =
                    ((f_yfrac >> (16 - 6)) & (63 * 64))
                            + ((f_xfrac >> 16) & 63);
                // Lowres/blocky mode does it twice,
                // while scale is adjusted appropriately.

                screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];
                screen[dest++] = ds_colormap[0x00FF & ds_source[spot]];

                f_xfrac += ds_xstep;
                f_yfrac += ds_ystep;

            } while (count-- > 0);

        }
    }
}
package rr.drawfuns;

import i.IDoomSystem;
import static m.fixed_t.FRACBITS;

public final class R_DrawColumnLow extends DoomColumnFunction<byte[],short[]> {
    
		public R_DrawColumnLow(int SCREENWIDTH, int SCREENHEIGHT,
	            int[] ylookup, int[] columnofs, ColVars<byte[],short[]> dcvars,
	            short[] screen, IDoomSystem I) {
	        super(SCREENWIDTH, SCREENHEIGHT, ylookup, columnofs, dcvars, screen, I);
	        this.flags=DcFlags.LOW_DETAIL;
	    }

        public void invoke() {
			int count;
			// MAES: were pointers. Of course...
			int dest, dest2;
			final byte[] dc_source=dcvars.dc_source;
			final short[] dc_colormap=dcvars.dc_colormap;
			final int dc_source_ofs=dcvars.dc_source_ofs;
			// Maes: fixed_t never used as such.
			int frac;
			final int fracstep;

			count = dcvars.dc_yh - dcvars.dc_yl;

			// Zero length.
			if (count < 0)
				return;

			if (RANGECHECK) {
			    performRangeCheck();
			}

			// The idea is to draw more than one pixel at a time.
			dest = blockyDest1();
			dest2 = blockyDest2();

			fracstep = dcvars.dc_iscale;
			frac = dcvars.dc_texturemid + (dcvars.dc_yl - dcvars.centery) * fracstep;
			// int spot=(frac >>> FRACBITS) & 127;
			do {

				// Hack. Does not work correctly.
				// MAES: that's good to know.
				screen[dest] = screen[dest2] = dc_colormap[0x00FF & dc_source[dc_source_ofs
						+ ((frac >>> FRACBITS) & 127)]];

				dest += SCREENWIDTH;
				dest2 += SCREENWIDTH;
				frac += fracstep;
			} while (count-- != 0);
		}
	}
package rr.drawfuns;

public class SpanVars<T,V> {

    public int ds_xfrac;
    public int ds_yfrac;
    public int ds_xstep;
    public T ds_source;
    
    /** DrawSpan colormap. */
    public V ds_colormap;
    public int ds_y;
    public int ds_x2;
    public int ds_x1;
    public int ds_ystep;
    
    public DoomSpanFunction<T,V>  spanfunc;
}

package rr.drawfuns;

/** This is all the information needed to draw a particular column. Really.
 *  So if we store all of this crap somewhere instead of drawing, we can do the
 *  drawing when it's more convenient, and since they are non-overlapping we can 
 *  parallelize them. Any questions?
 *  
 */

public class ColVars<T,V> {    
    /** when passing dc_source around, also set this */
    public T dc_source;
    public int dc_source_ofs;
    
    public T dc_translation;
    public int viewheight;
    
    /** Used by functions that accept transparency or other special 
     *  remapping tables.
     * 
     */
    public T tranmap;
    
    public int centery;
    public int dc_iscale;

    public int dc_texturemid;
    public int dc_texheight; // Boom enhancement
    public int dc_x;
    public int dc_yh;
    public int dc_yl;
    
    public int dc_flags;

    /**
     * MAES: this was a typedef for unsigned bytes, called "lighttable_t". It
     * makes more sense to make it generic and parametrize it to an array of 
     * primitives since it's performance-critical in the renderer. 
     * Now, whether this should be made bytes or shorts or chars or even ints 
     * is debatable.
     */
    
    public V dc_colormap;

    /** Copies all BUT flags */
    
    public final void copyFrom(ColVars<T,V> dcvars) {
        this.dc_source=dcvars.dc_source;
        this.dc_colormap=dcvars.dc_colormap;
        this.dc_source_ofs=dcvars.dc_source_ofs;
        this.viewheight=dcvars.viewheight;
        this.centery=dcvars.centery;
        this.dc_x=dcvars.dc_x;
        this.dc_yh=dcvars.dc_yh;
        this.dc_yl=dcvars.dc_yl;
        this.dc_texturemid=dcvars.dc_texturemid;
        this.dc_iscale=dcvars.dc_iscale;
        this.dc_texheight=dcvars.dc_texheight;        
    }
    
    /** Assigns specific flags */
    public void copyFrom(ColVars<T,V> dcvars,int flags) {
        this.copyFrom(dcvars);
        this.dc_flags=flags;
    }
    

}

package rr.drawfuns;

/** Either draws a column or a span
 * 
 * @author velktron
 *
 */

public interface SpanFunction<T,V> {
    public void invoke();
    
	public void invoke(SpanVars<T,V> dsvars);

}
package rr;

import java.io.IOException;
import java.nio.ByteBuffer;

import utils.C2JUtils;
import w.CacheableDoomObject;

/** column_t is a list of 0 or more post_t, (byte)-1 terminated
 * typedef post_t  column_t;
 * For the sake of efficiency, "column_t" will store raw data, however I added
 * some stuff to make my life easier.
 * 
 */

public class column_t implements CacheableDoomObject{
    
    /** Static buffers used during I/O. 
     *  There's ABSO-FUCKING-LUTELY no reason to manipulate them externally!!!
     *  I'M NOT KIDDING!!!11!!
     */
    
    private static final int[] guesspostofs=new int[256];
    private static final short[] guesspostlens=new short[256];
    private static final short[] guesspostdeltas=new short[256];
    
    
    // MAES: there are useless, since the renderer is using raw byte data anyway, and the per-post
    // data is available in the special arrays.
    // public short        topdelta;   // -1 is the last post in a column (actually 0xFF, since this was unsigned???)
    // public short        length;     // length data bytes follows (actually add +2)
	//public column_t[]      posts;    // This is quite tricky to read.
    /** The RAW data (includes initial header and padding, because no post gets preferential treatment). */
    public byte[] data; 
    /** Actual number of posts inside this column. All guesswork is done while loading */
	public int posts;
	/** Positions of posts inside the raw data (point at headers) */
	public int[] postofs; 
	/** Posts lengths, intended as actual drawable pixels.  Add +4 to get the whole post length */
	public short[] postlen;
	/** Vertical offset of each post. In theory it should be possible to quickly
	 *  clip to the next visible post when drawing a column */
	public short[] postdeltas;
	
    @Override
		public void unpack(ByteBuffer buf) throws IOException {
	        // Mark current position.
	        buf.mark();
	        int skipped=0;
	        short postlen=0;
	        int colheight=0;	        
	        int len=0; // How long is the WHOLE column, until the final FF?
	        int postno=0; // Actual number of posts.
	        int topdelta=0;
	        int prevdelta=-1; // HACK for DeepSea tall patches.
	        
	        // Scan every byte until we encounter an 0xFF which definitively marks the end of a column.
	        while((topdelta=C2JUtils.toUnsignedByte(buf.get()))!=0xFF){
	        
	        // From the wiki:
	        // A column's topdelta is compared to the previous column's topdelta 
	        // (or to -1 if there is no previous column in this row). If the new 
	        //  topdelta is lesser than the previous, it is interpreted as a tall
	        // patch and the two values are added together, the sum serving as the 
	        // current column's actual offset.
	            
	         int tmp=topdelta;    
	            
	        if (topdelta<prevdelta) {	            
	            topdelta+=prevdelta;
	            }

            prevdelta=tmp;
	        
	        // First byte of a post should be its "topdelta"
            guesspostdeltas[postno]=(short)topdelta;
            
	        guesspostofs[postno]=skipped+3; // 0 for first post

	        // Read one more byte...this should be the post length.
	        postlen=(short)C2JUtils.toUnsignedByte(buf.get());
	        guesspostlens[postno++]=(short) (postlen);
	        
	        // So, we already read 2 bytes (topdelta + length)
	        // Two further bytes are padding so we can safely skip 2+2+postlen bytes until the next post
	        skipped+=4+postlen;
	        buf.position(buf.position()+2+postlen);
	        
	        // Obviously, this adds to the height of the column, which might not be equal to the patch that
	        // contains it.
	        colheight+=postlen;
	        }
	        
	        // Skip final padding byte ?
	        skipped++;
	        
	        len = finalizeStatus(skipped, colheight, postno);
	        
	        // Go back...and read the raw data. That's what will actually be used in the renderer.
	        buf.reset();
	        buf.get(data, 0, len);
	    }


    /** This -almost- completes reading, by filling in the header information
     *  before the raw column data is read in.
     *  
     * @param skipped
     * @param colheight
     * @param postno
     * @return
     */
    
    private int finalizeStatus(int skipped, int colheight, int postno) {
        int len;
        // That's the TOTAL length including all padding.
        // This means we redundantly read some data
        len=(int) (skipped);
        this.data=new byte[len];
        
        this.postofs=new int[postno];
        this.postlen=new short[postno];
        // this.length=(short) colheight;
        this.postdeltas=new short[postno];
        
        System.arraycopy(guesspostofs, 0,this.postofs, 0, postno);
        System.arraycopy(guesspostlens, 0,this.postlen, 0, postno);
        System.arraycopy(guesspostdeltas, 0,this.postdeltas, 0, postno);
        
        this.posts=postno;
        return len;
    }
    
    /** based on raw data */
    public int getTopDelta(){
        return C2JUtils.toUnsignedByte(data[0]);
    }
    
    /** based on raw data */
    public int getLength(){
        return C2JUtils.toUnsignedByte(data[1]);
    }
   
}


// $Log: column_t.java,v $
// Revision 1.18  2011/10/04 14:34:08  velktron
// Removed length and topdelta members (unused).
//
// Revision 1.17  2011/07/25 14:37:20  velktron
// Added support for DeePSea tall patches.
//
// Revision 1.16  2011/07/12 16:32:05  velktron
// 4 extra padding bytes uneeded.
//
// Revision 1.15  2011/06/23 17:01:24  velktron
// column_t no longer needs to support IReadableDoomObject, since patch_t doesn't. If you really need it back, it can be done through buffering and using unpack(), without duplicate code. Also added setData() method for synthesized columns.
//
// Revision 1.14  2011/06/08 16:11:13  velktron
// IMPORTANT: postofs now skip delta,height and padding ENTIRELY (added +3). This eliminates the need to add +3 before accessing the data, saving some CPU cycles for each column. Of course, anything using column_t must take this into account.
//
package rr;

/** An interface used to ease the use of the GetCachedColumn by part
 *  of parallelized renderers.
 *  
 * @author Maes
 *
 */

public interface IGetColumn<T> {

	T GetColumn(int tex, int col);

}

package rr;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

/**
 * Texture definition.
 * Each texture is composed of one or more patches,
 * with patches being lumps stored in the WAD.
 * The lumps are referenced by number, and patched
 * into the rectangular texture space using origin
 * and possibly other attributes. 
 */

public class mappatch_t implements CacheableDoomObject {
     public short   originx;
     public short   originy;
     public short   patch;
     public short   stepdir;
     public short   colormap;
     
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        originx=buf.getShort();
        originy=buf.getShort();
        patch=buf.getShort();
        stepdir=buf.getShort();
        colormap=buf.getShort();        
    }

    public static final int size() {
        return 10;
    }
     
     
 };

package rr;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class z_vertex_t
        extends vertex_t {

    public z_vertex_t(){
        super();
    }
    
    /** Notice how we auto-expand to fixed_t */
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.x=buf.getInt();
        this.y=buf.getInt();
        
    }
    
    public final static int sizeOf() {
        return 8;
    }
    
}

package rr;

import static data.Defines.FF_FRAMEMASK;
import static data.Defines.FF_FULLBRIGHT;
import static data.Defines.SIL_BOTTOM;
import static data.Defines.SIL_TOP;
import static data.Defines.pw_invisibility;
import static doom.player_t.NUMPSPRITES;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.FixedMul;
import static p.mobj_t.MF_TRANSLATION;
import static p.mobj_t.MF_TRANSSHIFT;
import static rr.LightsAndColors.LIGHTLEVELS;
import static rr.LightsAndColors.LIGHTSCALESHIFT;
import static rr.LightsAndColors.LIGHTSEGSHIFT;
import static rr.LightsAndColors.MAXLIGHTSCALE;
import static rr.line_t.ML_DONTPEGBOTTOM;
import i.IDoomSystem;
import p.pspdef_t;
import rr.drawfuns.ColFuncs;
import rr.drawfuns.ColVars;
import rr.drawfuns.ColumnFunction;
import v.IVideoScale;
import w.IWadLoader;

/**
 * Refresh of things, i.e. objects represented by sprites. This abstract
 * class is the base for all implementations, and contains the gory clipping
 * and priority stuff. It can terminate by drawing directly, or by buffering
 * into a pipeline for parallelized drawing.
 * 
 * It need to be aware of almost everything in the renderer, which means that
 * it's a PITA to keep "disembodied". Then again, this probably means it's more 
 * extensible...
 * 
 * 
 * 
 */

public abstract class AbstractThings<T,V>
        implements IMaskedDrawer<T,V> {

    private final static boolean RANGECHECK=false;
    
    protected short[] maskedtexturecol;
    protected int pmaskedtexturecol = 0;
    
    // Cache those you get from the sprite manager
    protected int[] spritewidth, spriteoffset, spritetopoffset;

    /** fixed_t */
    protected int pspritescale, pspriteiscale, pspritexscale,
            pspriteyscale, skyscale;

    // Used for masked segs
    protected int rw_scalestep;

    protected int spryscale;

    protected int sprtopscreen;
    
    protected short[] mfloorclip;

    protected int p_mfloorclip;

    protected short[] mceilingclip;

    protected int p_mceilingclip;

    protected sector_t frontsector;

    protected sector_t backsector;

    // This must be "pegged" to the one used by the default renderer.
    protected ColVars<T, V> maskedcvars;
    
    protected ColumnFunction<T,V> colfunc;
    protected ColFuncs<T,V> colfuncs;
    protected ColFuncs<T,V> colfuncshi;
    protected ColFuncs<T,V> colfuncslow;    
    protected final LightsAndColors<V> colormaps;
    protected final ViewVars view;
    protected final SegVars seg_vars;
    protected final TextureManager<T> TexMan;
    protected final IDoomSystem I;
    protected final ISpriteManager SM;
    protected final BSPVars MyBSP;
    protected final IVisSpriteManagement<V> VIS;
    protected final IWadLoader W;
    protected final vissprite_t<V> avis;
    
    public AbstractThings(Renderer<T,V> R) {
        this.colfuncshi=R.getColFuncsHi();
        this.colfuncslow=R.getColFuncsLow();
        this.colormaps=R.getColorMap();
        this.view=R.getView();
        this.seg_vars=R.getSegVars();
        this.TexMan=R.getTextureManager();
        this.I=R.getDoomSystem();
        this.SM=R.getSpriteManager();
        this.MyBSP=R.getBSPVars();
        this.VIS=R.getVisSpriteManager();
        this.W=R.getWadLoader();
        this.avis=new vissprite_t<V>();
        this.maskedcvars=R.getMaskedDCVars();
        
    }

    @Override
    public void cacheSpriteManager(ISpriteManager SM) {
        this.spritewidth = SM.getSpriteWidth();
        this.spriteoffset = SM.getSpriteOffset();
        this.spritetopoffset = SM.getSpriteTopOffset();
    }

    // ///////////// VIDEO SCALE STUFF /////////////////////

    protected int SCREENWIDTH;

    protected int SCREENHEIGHT;

    protected IVideoScale vs;

    @Override
    public void setVideoScale(IVideoScale vs) {
        this.vs = vs;
    }

    @Override
    public void initScaling() {
        this.SCREENHEIGHT = vs.getScreenHeight();
        this.SCREENWIDTH = vs.getScreenWidth();

        // Pre-scale stuff.

        clipbot = new short[SCREENWIDTH];
        cliptop = new short[SCREENWIDTH];
    }

    /**
     * R_DrawVisSprite mfloorclip and mceilingclip should also be set.
     * Sprites are actually drawn here. MAES: Optimized. No longer needed to
     * pass x1 and x2 parameters (useless) +2 fps on nuts.wad timedemo.
     */
    protected void DrawVisSprite(vissprite_t<V> vis) {
        column_t column;
        int texturecolumn;
        int frac; // fixed_t
        patch_t patch;

        // At this point, the view angle (and patch) has already been
        // chosen. Go back.
        patch = W.CachePatchNum(vis.patch + SM.getFirstSpriteLump());

        maskedcvars.dc_colormap = vis.colormap;
        // colfunc=glasscolfunc;
        if (maskedcvars.dc_colormap == null) {
            // NULL colormap = shadow draw
            colfunc = colfuncs.fuzz;
        } else if ((vis.mobjflags & MF_TRANSLATION) != 0) {
            colfunc = colfuncs.trans;
            maskedcvars.dc_translation =
                (T) colormaps.getTranslationTable(vis.mobjflags);
        }

        maskedcvars.dc_iscale = Math.abs(vis.xiscale) >> view.detailshift;
        maskedcvars.dc_texturemid = vis.texturemid;
        frac = vis.startfrac;
        spryscale = vis.scale;
        sprtopscreen =
            view.centeryfrac
                    - FixedMul(maskedcvars.dc_texturemid, spryscale);

        // A texture height of 0 means "not tiling" and holds for
        // all sprite/masked renders.
        maskedcvars.dc_texheight = 0;

        for (maskedcvars.dc_x = vis.x1; maskedcvars.dc_x <= vis.x2; maskedcvars.dc_x++, frac +=
            vis.xiscale) {
            texturecolumn = frac >> FRACBITS;
            if (RANGECHECK) {
                if (texturecolumn < 0 || texturecolumn >= patch.width)
                    I.Error("R_DrawSpriteRange: bad texturecolumn");
            }
            column = patch.columns[texturecolumn];
            DrawMaskedColumn(column);
        }

        colfunc = colfuncs.masked;
    }

    /**
     * R_RenderMaskedSegRange
     * 
     * @param ds
     * @param x1
     * @param x2
     */
    protected void RenderMaskedSegRange(drawseg_t ds, int x1, int x2) {
        int index;

        int lightnum;
        int texnum;

        // System.out.printf("RenderMaskedSegRange from %d to %d\n",x1,x2);

        // Calculate light table.
        // Use different light tables
        // for horizontal / vertical / diagonal. Diagonal?
        // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
        MyBSP.curline = ds.curline;
        frontsector = MyBSP.curline.frontsector;
        backsector = MyBSP.curline.backsector;
        texnum = TexMan.getTextureTranslation(MyBSP.curline.sidedef.midtexture);
        // System.out.print(" for texture "+textures[texnum].name+"\n:");
        lightnum =
            (frontsector.lightlevel >> LIGHTSEGSHIFT) + colormaps.extralight;

        if (MyBSP.curline.v1y == MyBSP.curline.v2y)
            lightnum--;
        else if (MyBSP.curline.v1x == MyBSP.curline.v2x)
            lightnum++;

        // Killough code.
        colormaps.walllights =
            lightnum >= LIGHTLEVELS ? colormaps.scalelight[LIGHTLEVELS - 1]
                    : lightnum < 0 ? colormaps.scalelight[0]
                            : colormaps.scalelight[lightnum];

        // Get the list
        maskedtexturecol = ds.getMaskedTextureColList();
        // And this is the pointer.
        pmaskedtexturecol = ds.getMaskedTextureColPointer();

        rw_scalestep = ds.scalestep;
        spryscale = ds.scale1 + (x1 - ds.x1) * rw_scalestep;

        // HACK to get "pointers" inside clipping lists
        mfloorclip = ds.getSprBottomClipList();
        p_mfloorclip = ds.getSprBottomClipPointer();
        mceilingclip = ds.getSprTopClipList();
        p_mceilingclip = ds.getSprTopClipPointer();
        // find positioning
        if ((MyBSP.curline.linedef.flags & ML_DONTPEGBOTTOM) != 0) {
            maskedcvars.dc_texturemid =
                frontsector.floorheight > backsector.floorheight ? frontsector.floorheight
                        : backsector.floorheight;
            maskedcvars.dc_texturemid =
                maskedcvars.dc_texturemid + TexMan.getTextureheight(texnum)
                        - view.z;
        } else {
            maskedcvars.dc_texturemid =
                frontsector.ceilingheight < backsector.ceilingheight ? frontsector.ceilingheight
                        : backsector.ceilingheight;
            maskedcvars.dc_texturemid = maskedcvars.dc_texturemid - view.z;
        }
        maskedcvars.dc_texturemid += MyBSP.curline.sidedef.rowoffset;

        if (colormaps.fixedcolormap != null)
            maskedcvars.dc_colormap = colormaps.fixedcolormap;

        // Texture height must be set at this point. This will trigger
        // tiling. For sprites, it should be set to 0.
        maskedcvars.dc_texheight =
            TexMan.getTextureheight(texnum) >> FRACBITS;

        // draw the columns
        for (maskedcvars.dc_x = x1; maskedcvars.dc_x <= x2; maskedcvars.dc_x++) {
            // calculate lighting
            if (maskedtexturecol[pmaskedtexturecol + maskedcvars.dc_x] != Short.MAX_VALUE) {
                if (colormaps.fixedcolormap == null) {
                    index = spryscale >>> LIGHTSCALESHIFT;

                    if (index >= MAXLIGHTSCALE)
                        index = MAXLIGHTSCALE - 1;

                    maskedcvars.dc_colormap = colormaps.walllights[index];
                }

                sprtopscreen =
                    view.centeryfrac
                            - FixedMul(maskedcvars.dc_texturemid, spryscale);
                maskedcvars.dc_iscale = (int) (0xffffffffL / spryscale);

                // draw the texture
                column_t data = TexMan.GetColumnStruct(texnum,
                    (int) maskedtexturecol[pmaskedtexturecol
                            + maskedcvars.dc_x]);// -3);

                DrawMaskedColumn(data);

                maskedtexturecol[pmaskedtexturecol + maskedcvars.dc_x] =
                    Short.MAX_VALUE;
            }
            spryscale += rw_scalestep;
        }

    }

    /**
     * R_DrawPSprite Draws a "player sprite" with slighly different rules
     * than normal sprites. This is actually a PITA, at best :-/
     */

    protected void DrawPSprite(pspdef_t psp) {

        int tx;
        int x1;
        int x2;
        spritedef_t sprdef;
        spriteframe_t sprframe;
        vissprite_t<V> vis;
        int lump;
        boolean flip;

        // decide which patch to use (in terms of angle?)
        if (RANGECHECK) {
            if (psp.state.sprite.ordinal() >= SM.getNumSprites())
                I.Error("R_ProjectSprite: invalid sprite number %d ",
                    psp.state.sprite);
        }

        sprdef = SM.getSprite(psp.state.sprite.ordinal());

        if (RANGECHECK) {
            if ((psp.state.frame & FF_FRAMEMASK) >= sprdef.numframes)
                I.Error("R_ProjectSprite: invalid sprite frame %d : %d ",
                    psp.state.sprite, psp.state.frame);
        }

        sprframe = sprdef.spriteframes[psp.state.frame & FF_FRAMEMASK];

        // Base frame for "angle 0" aka viewed from dead-front.
        lump = sprframe.lump[0];
        // Q: where can this be set? A: at sprite loadtime.
        flip = (boolean) (sprframe.flip[0] != 0);

        // calculate edges of the shape. tx is expressed in "view units".
        tx = (int) (FixedMul(psp.sx, view.BOBADJUST) - view.WEAPONADJUST);

        tx -= spriteoffset[lump];

        // So...centerxfrac is the center of the screen (pixel coords in
        // fixed point).
        x1 = (view.centerxfrac + FixedMul(tx, pspritescale)) >> FRACBITS;

        // off the right side
        if (x1 > view.width)
            return;

        tx += spritewidth[lump];
        x2 =
            ((view.centerxfrac + FixedMul(tx, pspritescale)) >> FRACBITS) - 1;

        // off the left side
        if (x2 < 0)
            return;

        // store information in a vissprite ?
        vis = avis;
        vis.mobjflags = 0;
        vis.texturemid =
            ((BASEYCENTER + view.lookdir) << FRACBITS) + FRACUNIT / 2
                    - (psp.sy - spritetopoffset[lump]);
        vis.x1 = x1 < 0 ? 0 : x1;
        vis.x2 = x2 >= view.width ? view.width - 1 : x2;
        vis.scale = (pspritescale) << view.detailshift;

        if (flip) {
            vis.xiscale = -pspriteiscale;
            vis.startfrac = spritewidth[lump] - 1;
        } else {
            vis.xiscale = pspriteiscale;
            vis.startfrac = 0;
        }

        if (vis.x1 > x1)
            vis.startfrac += vis.xiscale * (vis.x1 - x1);

        vis.patch = lump;

        if ((view.player.powers[pw_invisibility] > 4 * 32)
                || (view.player.powers[pw_invisibility] & 8) != 0) {
            // shadow draw
            vis.colormap = null;

        } else if (colormaps.fixedcolormap != null) {
            // fixed color
            vis.colormap = colormaps.fixedcolormap;
            // vis.pcolormap=0;
        } else if ((psp.state.frame & FF_FULLBRIGHT) != 0) {
            // full bright
            vis.colormap = colormaps.colormaps[0];
            // vis.pcolormap=0;
        } else {
            // local light
            vis.colormap = colormaps.spritelights[MAXLIGHTSCALE - 1];
        }

        // System.out.println("Weapon draw "+vis);
        DrawVisSprite(vis);
    }

    protected int PSpriteSY[] = { 0, // staff
            5 * FRACUNIT, // goldwand
            15 * FRACUNIT, // crossbow
            15 * FRACUNIT, // blaster
            15 * FRACUNIT, // skullrod
            15 * FRACUNIT, // phoenix rod
            15 * FRACUNIT, // mace
            15 * FRACUNIT, // gauntlets
            15 * FRACUNIT // beak
        };

    /**
     * R_DrawPlayerSprites This is where stuff like guns is drawn...right?
     */

    protected final void DrawPlayerSprites() {
        int i;
        int lightnum;
        pspdef_t psp;

        // get light level
        lightnum =
            (view.player.mo.subsector.sector.lightlevel >> LIGHTSEGSHIFT)
                    + colormaps.extralight;

        if (lightnum < 0)
            colormaps.spritelights = colormaps.scalelight[0];
        else if (lightnum >= LIGHTLEVELS)
            colormaps.spritelights = colormaps.scalelight[LIGHTLEVELS - 1];
        else
            colormaps.spritelights = colormaps.scalelight[lightnum];

        // clip to screen bounds
        mfloorclip = view.screenheightarray;
        p_mfloorclip = 0;
        mceilingclip = view.negonearray;
        p_mceilingclip = 0;

        // add all active psprites
        // MAES 25/5/2011 Fixed another stupid bug that prevented
        // PSP from actually being updated. This in turn uncovered
        // other bugs in the way psp and state were treated, and the way
        // flash states were set. It should be OK now.
        for (i = 0; i < NUMPSPRITES; i++) {
            psp = view.player.psprites[i];
            if (psp.state != null && psp.state.id != 0) {
                DrawPSprite(psp);
            }
        }
    }

    // MAES: Scale to SCREENWIDTH
    protected short[] clipbot;

    protected short[] cliptop;

    /**
     * R_DrawSprite
     */

    protected final void DrawSprite(vissprite_t<V> spr) {
        int ds;
        drawseg_t dss;

        int x;
        int r1;
        int r2;
        int scale; // fixed
        int lowscale; // fixed
        int silhouette;

        for (x = spr.x1; x <= spr.x2; x++)
            clipbot[x] = cliptop[x] = -2;

        // Scan drawsegs from end to start for obscuring segs.
        // The first drawseg that has a greater scale
        // is the clip seg.
        for (ds = seg_vars.ds_p - 1; ds >= 0; ds--) {
            // determine if the drawseg obscures the sprite
            // System.out.println("Drawseg "+ds+"of "+(ds_p-1));
            dss = seg_vars.drawsegs[ds];
            if (dss.x1 > spr.x2
                    || dss.x2 < spr.x1
                    || ((dss.silhouette == 0) && (dss
                            .nullMaskedTextureCol()))) {
                // does not cover sprite
                continue;
            }

            r1 = dss.x1 < spr.x1 ? spr.x1 : dss.x1;
            r2 = dss.x2 > spr.x2 ? spr.x2 : dss.x2;

            if (dss.scale1 > dss.scale2) {
                lowscale = dss.scale2;
                scale = dss.scale1;
            } else {
                lowscale = dss.scale1;
                scale = dss.scale2;
            }

            if (scale < spr.scale
                    || (lowscale < spr.scale && (dss.curline
                            .PointOnSegSide(spr.gx, spr.gy) == 0))) {
                // masked mid texture?
                if (!dss.nullMaskedTextureCol())
                    RenderMaskedSegRange(dss, r1, r2);
                // seg is behind sprite
                continue;
            }

            // clip this piece of the sprite
            silhouette = dss.silhouette;

            if (spr.gz >= dss.bsilheight)
                silhouette &= ~SIL_BOTTOM;

            if (spr.gzt <= dss.tsilheight)
                silhouette &= ~SIL_TOP;

            // BOTTOM clipping
            if (silhouette == 1) {
                // bottom sil
                for (x = r1; x <= r2; x++)
                    if (clipbot[x] == -2)
                        clipbot[x] = dss.getSprBottomClip(x);

            } else if (silhouette == 2) {
                // top sil
                for (x = r1; x <= r2; x++)
                    if (cliptop[x] == -2)
                        cliptop[x] = dss.getSprTopClip(x);
            } else if (silhouette == 3) {
                // both
                for (x = r1; x <= r2; x++) {
                    if (clipbot[x] == -2)
                        clipbot[x] = dss.getSprBottomClip(x);
                    if (cliptop[x] == -2)
                        cliptop[x] = dss.getSprTopClip(x);
                }
            }

        }

        // all clipping has been performed, so draw the sprite

        // check for unclipped columns
        for (x = spr.x1; x <= spr.x2; x++) {
            if (clipbot[x] == -2)
                clipbot[x] = (short) view.height;
            // ?? What's this bullshit?
            if (cliptop[x] == -2)
                cliptop[x] = -1;
        }

        mfloorclip = clipbot;
        p_mfloorclip = 0;
        mceilingclip = cliptop;
        p_mceilingclip = 0;
        DrawVisSprite(spr);
    }

    /**
     * R_DrawMasked Sorts and draws vissprites (room for optimization in
     * sorting func.) Draws masked textures. Draws player weapons and
     * overlays (psprites). Sorting function can be swapped for almost
     * anything, and it will work better, in-place and be simpler to draw,
     * too.
     */

    @Override
    public void DrawMasked() {
        // vissprite_t spr;
        int ds;
        drawseg_t dss;

        // Well, it sorts visspite objects.
        // It actually IS faster to sort with comparators, but you need to
        // go into NUTS.WAD-like wads.
        // numbers. The built-in sort if about as good as it gets. In fact,
        // it's hardly slower
        // to draw sprites without sorting them when using the built-in
        // modified mergesort, while
        // the original algorithm is so dreadful it actually does slow
        // things down.

        VIS.SortVisSprites();

        // If you are feeling adventurous, try these ones. They *might*
        // perform
        // better in very extreme situations where all sprites are always on
        // one side
        // of your view, but I hardly see any benefits in that. They are
        // both
        // much better than the original anyway.

        // combSort(vissprites,vissprite_p);
        // shellsort(vissprites,vissprite_p);

        // pQuickSprite.sort(vissprites);

        // The original sort. It's incredibly bad on so many levels (uses a
        // separate
        // linked list for the sorted sequence, which is pointless since the
        // vissprite_t
        // array is gonna be changed all over in the next frame anyway, it's
        // not like
        // it helps preseving or anything. It does work in Java too, but I'd
        // say to Keep Away. No srsly.

        /*
         * SortVisSprites (); // Sprite "0" not visible? /*if (vissprite_p >
         * 0) { // draw all vissprites back to front for (spr =
         * vsprsortedhead.next ; spr != vsprsortedhead ; spr=spr.next) {
         * DrawSprite (spr); } }
         */

        // After using in-place sorts, sprites can be drawn as simply as
        // that.

        colfunc = colfuncs.masked; // Sprites use fully-masked capable
                                 // function.

        final vissprite_t<V>[] vissprites = VIS.getVisSprites();
        final int numvissprites = VIS.getNumVisSprites();

        for (int i = 0; i < numvissprites; i++) {
            DrawSprite(vissprites[i]);
        }

        // render any remaining masked mid textures
        for (ds = seg_vars.ds_p - 1; ds >= 0; ds--) {
            dss = seg_vars.drawsegs[ds];
            if (!dss.nullMaskedTextureCol())
                RenderMaskedSegRange(dss, dss.x1, dss.x2);
        }
        // draw the psprites on top of everything
        // but does not draw on side views
        // if (viewangleoffset==0)

        colfunc = colfuncs.player;
        DrawPlayerSprites();
        colfunc = colfuncs.masked;
    }

    /**
     * R_DrawMaskedColumn Used for sprites and masked mid textures. Masked
     * means: partly transparent, i.e. stored in posts/runs of opaque
     * pixels. NOTE: this version accepts raw bytes, in case you know what
     * you're doing.
     */

   /* protected final void DrawMaskedColumn(T column) {
        int topscreen;
        int bottomscreen;
        int basetexturemid; // fixed_t
        int topdelta;
        int length;

        basetexturemid = maskedcvars.dc_texturemid;
        // That's true for the whole column.
        maskedcvars.dc_source = (T) column;
        int pointer = 0;

        // for each post...
        while ((topdelta = 0xFF & column[pointer]) != 0xFF) {
            // calculate unclipped screen coordinates
            // for post
            topscreen = sprtopscreen + spryscale * topdelta;
            length = 0xff & column[pointer + 1];
            bottomscreen = topscreen + spryscale * length;

            maskedcvars.dc_yl = (topscreen + FRACUNIT - 1) >> FRACBITS;
            maskedcvars.dc_yh = (bottomscreen - 1) >> FRACBITS;

            if (maskedcvars.dc_yh >= mfloorclip[p_mfloorclip
                    + maskedcvars.dc_x])
                maskedcvars.dc_yh =
                    mfloorclip[p_mfloorclip + maskedcvars.dc_x] - 1;

            if (maskedcvars.dc_yl <= mceilingclip[p_mceilingclip
                    + maskedcvars.dc_x])
                maskedcvars.dc_yl =
                    mceilingclip[p_mceilingclip + maskedcvars.dc_x] + 1;

            // killough 3/2/98, 3/27/98: Failsafe against overflow/crash:
            if (maskedcvars.dc_yl <= maskedcvars.dc_yh
                    && maskedcvars.dc_yh < view.height) {
                // Set pointer inside column to current post's data
                // Rremember, it goes {postlen}{postdelta}{pad}[data]{pad}
                maskedcvars.dc_source_ofs = pointer + 3;
                maskedcvars.dc_texturemid =
                    basetexturemid - (topdelta << FRACBITS);

                // Drawn by either R_DrawColumn
                // or (SHADOW) R_DrawFuzzColumn.
                maskedcvars.dc_texheight = 0; // Killough

                completeColumn();
            }
            pointer += length + 4;
        }

        maskedcvars.dc_texturemid = basetexturemid;
    }
    */


    /**
     * R_DrawMaskedColumn Used for sprites and masked mid textures. Masked
     * means: partly transparent, i.e. stored in posts/runs of opaque
     * pixels. FIXME: while it does work with "raw columns", if the initial
     * post is drawn outside of the screen the rest appear screwed up.
     * SOLUTION: use the version taking raw byte[] arguments.
     */

    protected final void DrawMaskedColumn(column_t column) {
        int topscreen;
        int bottomscreen;
        int basetexturemid; // fixed_t

        basetexturemid = maskedcvars.dc_texturemid;
        // That's true for the whole column.
        maskedcvars.dc_source = (T) column.data;
        // dc_source_ofs=0;

        // for each post...
        for (int i = 0; i < column.posts; i++) {
            maskedcvars.dc_source_ofs = column.postofs[i];
            // calculate unclipped screen coordinates
            // for post
            topscreen = sprtopscreen + spryscale * column.postdeltas[i];
            bottomscreen = topscreen + spryscale * column.postlen[i];

            maskedcvars.dc_yl = (topscreen + FRACUNIT - 1) >> FRACBITS;
            maskedcvars.dc_yh = (bottomscreen - 1) >> FRACBITS;

            if (maskedcvars.dc_yh >= mfloorclip[p_mfloorclip
                    + maskedcvars.dc_x])
                maskedcvars.dc_yh =
                    mfloorclip[p_mfloorclip + maskedcvars.dc_x] - 1;
            if (maskedcvars.dc_yl <= mceilingclip[p_mceilingclip
                    + maskedcvars.dc_x])
                maskedcvars.dc_yl =
                    mceilingclip[p_mceilingclip + maskedcvars.dc_x] + 1;

            // killough 3/2/98, 3/27/98: Failsafe against overflow/crash:
            if (maskedcvars.dc_yl <= maskedcvars.dc_yh
                    && maskedcvars.dc_yh < maskedcvars.viewheight) {

                // Set pointer inside column to current post's data
                // Remember, it goes {postlen}{postdelta}{pad}[data]{pad}

                maskedcvars.dc_texturemid =
                    basetexturemid - (column.postdeltas[i] << FRACBITS);

                // Drawn by either R_DrawColumn or (SHADOW)
                // R_DrawFuzzColumn.
                // MAES: when something goes bad here, it means that the
                // following:
                //
                // fracstep = dc_iscale;
                // frac = dc_texturemid + (dc_yl - centery) * fracstep;
                //
                // results in a negative initial frac number.

                // Drawn by either R_DrawColumn
                //  or (SHADOW) R_DrawFuzzColumn.
                
                // FUN FACT: this was missing and fucked my shit up.
                maskedcvars.dc_texheight=0; // Killough
                
                completeColumn();
                 
            }
        }

        maskedcvars.dc_texturemid = basetexturemid;
    }
    
    /*
     * R_DrawMaskedColumn
     * Used for sprites and masked mid textures.
     * Masked means: partly transparent, i.e. stored
     *  in posts/runs of opaque pixels.
     *  
     *  NOTE: this version accepts raw bytes, in case you  know what you're doing.
     *  NOTE: this is a legacy function. Do not reactivate unless
     *  REALLY needed.
     *
     */
/*
    protected final  void DrawMaskedColumn (byte[] column)
    {
        int topscreen;
        int bottomscreen;
        int basetexturemid; // fixed_t
        int topdelta;
        int length;
        
        basetexturemid = dc_texturemid;
        // That's true for the whole column.
        dc_source = column;
        int pointer=0;
        
        // for each post...
        while((topdelta=0xFF&column[pointer])!=0xFF)
        {
        // calculate unclipped screen coordinates
        //  for post
        topscreen = sprtopscreen + spryscale*topdelta;
        length=0xff&column[pointer+1];
        bottomscreen = topscreen + spryscale*length;

        dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
        dc_yh = (bottomscreen-1)>>FRACBITS;
            
        if (dc_yh >= mfloorclip[p_mfloorclip+dc_x])
            dc_yh = mfloorclip[p_mfloorclip+dc_x]-1;
        
        if (dc_yl <= mceilingclip[p_mceilingclip+dc_x])
            dc_yl = mceilingclip[p_mceilingclip+dc_x]+1;

        // killough 3/2/98, 3/27/98: Failsafe against overflow/crash:
        if (dc_yl <= dc_yh && dc_yh < viewheight)
        {
            // Set pointer inside column to current post's data
            // Rremember, it goes {postlen}{postdelta}{pad}[data]{pad} 
            dc_source_ofs = pointer+3;
            dc_texturemid = basetexturemid - (topdelta<<FRACBITS);

            // Drawn by either R_DrawColumn
            //  or (SHADOW) R_DrawFuzzColumn.
            dc_texheight=0; // Killough
                
            maskedcolfunc.invoke();
        }
        pointer+=length + 4;
        }
        
        dc_texturemid = basetexturemid;
    }
      */

    @Override
    public void setPspriteIscale(int i) {
        pspriteiscale = i;

    }

    @Override
    public void setPspriteScale(int i) {
        pspritescale = i;
    }

    @Override
    public void setDetail(int detailshift){
        switch (detailshift){
        case HIGH_DETAIL:
            colfuncs=colfuncshi;
            break;
        case LOW_DETAIL:
            colfuncs=colfuncslow;
            break;
        }
    }
    
}

package rr;

//
// ?
//

public class drawseg_t {
	
	public drawseg_t(){
		
	}

     /** MAES: was pointer. Not array? */
     public  seg_t      curline;
     public int         x1, x2;

     /** fixed_t */
     public int     scale1,  scale2,  scalestep;

     /** 0=none, 1=bottom, 2=top, 3=both */
     public  int         silhouette;

     /** do not clip sprites above this (fixed_t) */
     public int     bsilheight;

     /** do not clip sprites below this (fixed_t) */
     public int     tsilheight;
     
     /** Indexes to lists for sprite clipping, 
        all three adjusted so [x1] is first value. */
     private int      psprtopclip, psprbottomclip, pmaskedtexturecol;

     /** Pointers to the actual lists  */

     private short[]      sprtopclip, sprbottomclip, maskedtexturecol;
     
     ///////////////// Accessor methods to simulate mid-array pointers ///////////
     
     public void setSprTopClip(short[] array, int index){
         this.sprtopclip=array;
         this.psprtopclip=index;         
     }
     
     public void setSprBottomClip(short[] array, int index){
         this.sprbottomclip=array;
         this.psprbottomclip=index;         
     }
     
     public void setMaskedTextureCol(short[] array, int index){
         this.maskedtexturecol=array;
         this.pmaskedtexturecol=index;         
     }
     
     public short getSprTopClip(int index){
         return this.sprtopclip[this.psprtopclip+index];
     }
     
     public short getSprBottomClip( int index){
         return this.sprbottomclip[this.psprbottomclip+index];     
         }
     
     public short getMaskedTextureCol(int index){
         return this.maskedtexturecol[this.pmaskedtexturecol+index];         
     }
     
     public short[] getSprTopClipList(){
         return this.sprtopclip;
     }
     
     public short[] getSprBottomClipList(){
         return this.sprbottomclip;
     }
     
     public short[] getMaskedTextureColList(){
         return this.maskedtexturecol;
     }
     
     public int getSprTopClipPointer(){
         return this.psprtopclip;
     }
     
     public int getSprBottomClipPointer(){
         return this.psprbottomclip;
     }
     
     public int getMaskedTextureColPointer(){
         return this.pmaskedtexturecol;
     }
     
     public void setSprTopClipPointer(int index){
         this.psprtopclip=index;
     }
     
     public void setSprBottomClipPointer(int index){
         this.psprbottomclip=index;
     }
     
     public void setMaskedTextureColPointer(int index){
         this.pmaskedtexturecol=index;
     }     
     
     public boolean nullSprTopClip(){
         return this.sprtopclip==null;
     }
     
     public boolean nullSprBottomClip(){
         return this.sprbottomclip==null;
     }
     
     public boolean nullMaskedTextureCol(){
         return this.maskedtexturecol==null;
     }
     
}

package rr;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;

import p.Interceptable;
import p.Resettable;
import s.degenmobj_t;
import w.DoomIO;
import w.IPackableDoomObject;
import w.IReadableDoomObject;
import static m.BBox.BOXBOTTOM;
import static m.BBox.BOXLEFT;
import static m.BBox.BOXRIGHT;
import static m.BBox.BOXTOP;
import static m.fixed_t.*;
import static utils.C2JUtils.eval;
import defines.slopetype_t;
import doom.thinker_t;

/** This is the actual linedef */

public class line_t
        implements Interceptable, IReadableDoomObject, IPackableDoomObject,
        Resettable {

    public static final char NO_INDEX=0xFFFF;
    
    public line_t() {
        sidenum = new char[2];
        bbox = new int[4];
        slopetype = slopetype_t.ST_HORIZONTAL;
    }

    /**
     * Vertices, from v1 to v2. NOTE: these are almost never passed as-such, nor
     * linked to Maybe we can get rid of them and only use the value semantics?
     */
    public vertex_t v1, v2;

    /** remapped vertex coords, for quick lookup with value semantics */
    public int v1x, v1y, v2x, v2y;

    /** (fixed_t) Precalculated v2 - v1 for side checking. */
    public int dx, dy;

    /** Animation related. */
    public short flags, special, tag;

    /**
     * Visual appearance: SideDefs. sidenum[1] will be 0xFFFF if one sided
     */
    public char[] sidenum;

    /**
     * Neat. Another bounding box, for the extent of the LineDef. MAES: make
     * this a proper bbox? fixed_t bbox[4];
     */
    public int[] bbox;

    /** To aid move clipping. */
    public slopetype_t slopetype;

    /**
     * Front and back sector. Note: redundant? Can be retrieved from SideDefs.
     * MAES: pointers
     */
    public sector_t frontsector, backsector;

    public int frontsectorid, backsectorid;

    /** if == validcount, already checked */
    public int validcount;

    /** thinker_t for reversable actions MAES: (void*) */
    public thinker_t specialdata;

    public int specialdataid;

    public degenmobj_t soundorg;

    // From Boom
    public int tranlump;
    
    public int id;
    
    /** killough 4/17/98: improves searches for tags. */
    public int firsttag,nexttag;    

    /** For Boom stuff, interprets sidenum specially */
    public int getSpecialSidenum() {
        return (sidenum[0] << 16) & (0x0000ffff & sidenum[1]);
    }

    public void assignVertexValues() {
        this.v1x = v1.x;
        this.v1y = v1.y;
        this.v2x = v2.x;
        this.v2y = v2.y;

    }

    /**
     * P_PointOnLineSide
     * 
     * @param x
     *        fixed_t
     * @param y
     *        fixed_t
     * @return 0 or 1 (false, true) - (front, back)
     */
    public boolean PointOnLineSide(int x, int y)

    {
    	

    	  return
    			    (dx==0) ? x <= this.v1x ? this.dy > 0 : this.dy < 0 :
    			    (dy==0) ? y <= this.v1y ? this.dx < 0 : this.dx > 0 :
    			    FixedMul(y-this.v1y, this.dx>>FRACBITS) >=
    			    FixedMul(this.dy>>FRACBITS, x-this.v1x);
    	/*
        int dx, dy, left, right;
        if (this.dx == 0) {
            if (x <= this.v1x)
                return this.dy > 0;

            return this.dy < 0;
        }
        if (this.dy == 0) {
            if (y <= this.v1y)
                return this.dx < 0;

            return this.dx > 0;
        }

        dx = (x - this.v1x);
        dy = (y - this.v1y);

        left = FixedMul(this.dy >> FRACBITS, dx);
        right = FixedMul(dy, this.dx >> FRACBITS);

        if (right < left)
            return false; // front side
        return true; // back side*/
    }

    /**
     * P_BoxOnLineSide Considers the line to be infinite Returns side 0 or 1, -1
     * if box crosses the line. Doubles as a convenient check for whether a
     * bounding box crosses a line at all
     * 
     * @param tmbox
     *        fixed_t[]
     */
    public int BoxOnLineSide(int[] tmbox) {
        boolean p1 = false;
        boolean p2 = false;

        switch (this.slopetype) {
        // Line perfectly horizontal, box floating "north" of line
        case ST_HORIZONTAL:
            p1 = tmbox[BOXTOP] > v1y;
            p2 = tmbox[BOXBOTTOM] > v1y;
            if (dx < 0) {
                p1 ^= true;
                p2 ^= true;
            }
            break;

        // Line perfectly vertical, box floating "west" of line
        case ST_VERTICAL:

            p1 = tmbox[BOXRIGHT] < v1x;
            p2 = tmbox[BOXLEFT] < v1x;
            if (dy < 0) {
                p1 ^= true;
                p2 ^= true;
            }
            break;

        case ST_POSITIVE:
            // Positive slope, both points on one side.
            p1 = PointOnLineSide(tmbox[BOXLEFT], tmbox[BOXTOP]);
            p2 = PointOnLineSide(tmbox[BOXRIGHT], tmbox[BOXBOTTOM]);
            break;

        case ST_NEGATIVE:
            // Negative slope, both points (mirrored horizontally) on one side.
            p1 = PointOnLineSide(tmbox[BOXRIGHT], tmbox[BOXTOP]);
            p2 = PointOnLineSide(tmbox[BOXLEFT], tmbox[BOXBOTTOM]);
            break;
        }

        if (p1 == p2)
            return p1 ? 1 : 0;
        // Any other result means non-inclusive crossing.
        return -1;
    }

    /**
     * Variant of P_BoxOnLineSide. Uses inclusive checks, so that even lines on
     * the border of a box will be considered crossing. This is more useful for
     * building blockmaps.
     * 
     * @param tmbox
     *        fixed_t[]
     */
    public int BoxOnLineSideInclusive(int[] tmbox) {
        boolean p1 = false;
        boolean p2 = false;

        switch (this.slopetype) {
        // Line perfectly horizontal, box floating "north" of line
        case ST_HORIZONTAL:
            p1 = tmbox[BOXTOP] >= v1y;
            p2 = tmbox[BOXBOTTOM] >= v1y;
            if (dx < 0) {
                p1 ^= true;
                p2 ^= true;
            }
            break;

        // Line perfectly vertical, box floating "west" of line
        case ST_VERTICAL:

            p1 = tmbox[BOXRIGHT] <= v1x;
            p2 = tmbox[BOXLEFT] <= v1x;
            if (dy < 0) {
                p1 ^= true;
                p2 ^= true;
            }
            break;

        case ST_POSITIVE:
            // Positive slope, both points on one side.
            p1 = PointOnLineSide(tmbox[BOXLEFT], tmbox[BOXTOP]);
            p2 = PointOnLineSide(tmbox[BOXRIGHT], tmbox[BOXBOTTOM]);
            break;

        case ST_NEGATIVE:
            // Negative slope, both points (mirrored horizontally) on one side.
            p1 = PointOnLineSide(tmbox[BOXRIGHT], tmbox[BOXTOP]);
            p2 = PointOnLineSide(tmbox[BOXLEFT], tmbox[BOXBOTTOM]);
            break;
        }

        if (p1 == p2)
            return p1 ? 1 : 0;
        // Any other result means non-inclusive crossing.
        return -1;
    }

    /**
     * getNextSector() Return sector_t * of sector next to current. NULL if not
     * two-sided line
     */

    public sector_t getNextSector(sector_t sec) {
        if (!eval(flags& ML_TWOSIDED))
            return null;

        if (frontsector == sec)
            return backsector;

        return frontsector;
    }

    public String toString() {
        return (String.format("Line %d Flags: %x Special %d Tag: %d ", this.id,this.flags,
            this.special, this.tag));
    }

    @Override
    public void read(DataInputStream f)
            throws IOException {

        // For histerical reasons, these are the only parts of line_t that
        // are archived in vanilla savegames. Go figure.
        this.flags = DoomIO.readLEShort(f);
        this.special = DoomIO.readLEShort(f);
        this.tag = DoomIO.readLEShort(f);
    }

    @Override
    public void pack(ByteBuffer buffer) {
        buffer.putShort(flags);
        buffer.putShort(special);
        buffer.putShort(tag);
        // buffer.putShort((short) 0XDEAD);
        // buffer.putShort((short) 0XBABE);
        // buffer.putShort((short) 0XBEEF);
    }

    @Override
    public void reset() {
        v1 = v2 = null;
        v1x = v1y = v2x = v2y = 0;
        dx = dy = 0;
        flags = special = tag = 0;
        Arrays.fill(sidenum, (char) 0);
        Arrays.fill(bbox, 0);
        slopetype = slopetype_t.ST_HORIZONTAL;
        frontsector = backsector = null;
        frontsectorid = backsectorid = 0;
        validcount = 0;
        specialdata = null;
        specialdataid = 0;
        soundorg = null;
        tranlump = 0;
    }
    
    /**
     * LUT, motion clipping, walls/grid element // // LineDef attributes. // /**
     * Solid, is an obstacle.
     */
    public static final int ML_BLOCKING = 1;

    /** Blocks monsters only. */
    public static final int ML_BLOCKMONSTERS = 2;

    /** Backside will not be present at all if not two sided. */
    public static final int ML_TWOSIDED = 4;

    // If a texture is pegged, the texture will have
    // the end exposed to air held constant at the
    // top or bottom of the texture (stairs or pulled
    // down things) and will move with a height change
    // of one of the neighbor sectors.
    // Unpegged textures allways have the first row of
    // the texture at the top pixel of the line for both
    // top and bottom textures (use next to windows).

    /** upper texture unpegged */
    public static final int ML_DONTPEGTOP = 8;

    /** lower texture unpegged */
    public static final int ML_DONTPEGBOTTOM = 16;

    /** In AutoMap: don't map as two sided: IT'S A SECRET! */
    public static final int ML_SECRET = 32;

    /** Sound rendering: don't let sound cross two of these. */
    public static final int ML_SOUNDBLOCK = 64;

    /** Don't draw on the automap at all. */
    public static final int ML_DONTDRAW = 128;

    /** Set if already seen, thus drawn in automap. */
    public static final int ML_MAPPED = 256;

}

package rr;

import data.Limits;
import utils.C2JUtils;

public class SegVars {
	// /// FROM BSP /////////
	
    public int MAXDRAWSEGS = Limits.MAXDRAWSEGS;

	/** pointer to drawsegs */
    public int ds_p;

    public drawseg_t[] drawsegs;

    public short[] maskedtexturecol;
    public int pmaskedtexturecol = 0;


	/**
	 * R_ClearDrawSegs
	 * 
	 * The drawseg list is reset by pointing back at 0.
	 * 
	 */
	public void ClearDrawSegs() {
		ds_p = 0;
	}

	public final void ResizeDrawsegs() {
		drawsegs = C2JUtils.resize(drawsegs[0], drawsegs, drawsegs.length*2);
	}
}

package rr;
public class pQuickSprite{

    public static final void sort(vissprite_t[] c){
        int i,j,left = 0,right = c.length - 1,stack_pointer = -1;
        int[] stack = new int[128];
        vissprite_t swap,temp;
        while(true){
            if(right - left <= 7){
                for(j=left+1;j<=right;j++){
                    swap = c[j];
                    i = j-1;
                    while(i>=left && c[i].scale>swap.scale)
                        c[i+1] = c[i--];
                    c[i+1] = swap;
                }
                if(stack_pointer == -1)
                    break;
                right = stack[stack_pointer--];
                left = stack[stack_pointer--];
            }else{
                int median = (left + right) >> 1;
                i = left + 1;
                j = right;
                swap = c[median]; c[median] = c[i]; c[i] = swap;
                /* make sure: c[left] <= c[left+1] <= c[right] */
                if(c[left].scale > c[right].scale){
                    swap = c[left]; c[left] = c[right]; c[right] = swap;
                }if(c[i].scale>c[right].scale ){
                    swap = c[i]; c[i] = c[right]; c[right] = swap;
                }if(c[left].scale>c[i].scale){
                    swap = c[left]; c[left] = c[i]; c[i] = swap;
                }
                temp = c[i];
                while(true){
                    do i++; while(c[i].scale<temp.scale);
                    do j--; while(c[j].scale>temp.scale);
                    if(j < i)
                        break;
                    swap = c[i]; c[i] = c[j]; c[j] = swap;
                }
                c[left + 1] = c[j];
                c[j] = temp;
                if(right-i+1 >= j-left){
                    stack[++stack_pointer] = i;
                    stack[++stack_pointer] = right;
                    right = j-1;
                }else{
                    stack[++stack_pointer] = left;
                    stack[++stack_pointer] = j-1;
                    left = i;
                }
            }
        }
    }
}
    
package rr;

/** Sprites are patches with a special naming convention
 * so they can be recognized by R_InitSprites.
 * The base name is NNNNFx or NNNNFxFx, with
 * x indicating the rotation, x = 0, 1-7.
 * The sprite and frame specified by a thing_t
 * is range checked at run time.
 * A sprite is a patch_t that is assumed to represent
 * a three dimensional object and may have multiple
 * rotations pre drawn.
 * Horizontal flipping is used to save space,
 * thus NNNNF2F5 defines a mirrored patch.
 * Some sprites will only have one picture used
 * for all views: NNNNF0
 */
public class spriteframe_t implements Cloneable{

 public spriteframe_t(){
     lump=new int[8];
     flip=new byte[8];
 }

 /** If false use 0 for any position.
  * Note: as eight entries are available,
  * we might as well insert the same name eight times. 
  * 
  * FIXME: this is used as a tri-state.
  * 0= false
  * 1= true
  * -1= cleared/indeterminate, which should not evaluate to either true or false.
  * */
 public int rotate;

 /** Lump to use for view angles 0-7. */
 public int[]    lump;

 /** Flip bit (1 = flip) to use for view angles 0-7. */
 public byte[]    flip;
 
 public spriteframe_t clone(){
     spriteframe_t response=new spriteframe_t();
     response.rotate=rotate;     
     System.arraycopy(this.lump, 0, response.lump, 0, lump.length);
     System.arraycopy(this.flip, 0, response.flip, 0, flip.length);
     return response;
     
 }
 

}

package rr;

import static p.MobjFlags.MF_TRANSLATION;
import static p.MobjFlags.MF_TRANSSHIFT;
import i.Main;

/**
 *   Combined colormap and light LUTs.
 *   Used for z-depth cuing per column/row,
 *   and other lighting effects (sector ambient, flash).
 *   
 * @author velktron
 *
 * @param <V> The data type of the SCREEN
 */

public class LightsAndColors<V> {
    
    /** For HiColor, these are, effectively, a bunch of 555 RGB palettes,
     *  for TrueColor they are a bunch of 32-bit ARGB palettes etc.
     *  Only for indexed they represent index remappings.  
     */

    /** "peg" this to the one from RendererData */
    public V[] colormaps;

    /** lighttable_t** */
    public V[] walllights;

    /** Use in conjunction with pfixedcolormap */
    public V fixedcolormap;
    /** Use in conjunction with fixedcolormap[] */
    public int pfixedcolormap;
	
	/**
	 * Color tables for different players, translate a limited part to another
	 * (color ramps used for suit colors).
	 */

	public byte[][] translationtables;
	
	
	/** Bits representing color levels. 5 for 32. */
	public static final int LBITS;
	
    /**
     * These two are tied by an inverse relationship. E.g. 256 levels, 0 shift
     * 128 levels, 1 shift ...etc... 16 levels, 4 shift (default). Or even less,
     * if you want.
     * 
     * By setting it to the max however you get smoother light and get rid of
     * lightsegshift globally, too. Of course, by increasing the number of light
     * levels, you also put more memory pressure, and due to their being only
     * 256 colors to begin with, visually, there won't be many differences.
     */
	
	 
    public static final int LIGHTLEVELS;
    public static final int LIGHTSEGSHIFT;
    
    
  /** Number of diminishing brightness levels.
     There a 0-31, i.e. 32 LUT in the COLORMAP lump. 
     TODO: how can those be distinct from the light levels???
     */    
    
  public static final int  NUMCOLORMAPS;

    
    // These are a bit more tricky to figure out though.

    /** Maximum index used for light levels of sprites. In practice,
     *  it's capped by the number of light levels???
     *  
     *  Normally set to 48 (32 +16???)
     */
    
    public static final int MAXLIGHTSCALE;
    
    /** Used to scale brightness of walls and sprites. Their "scale" is shifted by
     *  this amount, and this results in an index, which is capped by MAXLIGHTSCALE.
     *  Normally it's 12 for 32 levels, so 11 for 64, 10 for 128, ans 9 for 256.
     *  
     */
    public static final int LIGHTSCALESHIFT;
    
    /** This one seems arbitrary. Will auto-fit to 128 possible levels? */
    public static final int MAXLIGHTZ;
    
    
    public static final int LIGHTBRIGHT;
    
    /** Normally 20 for 32 colormaps, applied to distance.
     * Formula: 25-LBITS
     *  
     */
    public static final int LIGHTZSHIFT;

    public V[][] scalelight;
    public V[] scalelightfixed;
    public V[][] zlight;
    public V[] spritelights;

    // bumped light from gun blasts
    public int extralight;
    
    static {

        // Horrible hack.
        
        switch (Main.bpp){
        case Indexed:
        case TrueColor32:
        case HiColor:
            LBITS=5;
            break;
        case TrueColor:
            LBITS=8;
            break;
        default:
            LBITS=5;            
            break;
        }
        
        LIGHTLEVELS = 1<<LBITS;
        MAXLIGHTZ=Math.max(LIGHTLEVELS*4,256);
        LIGHTBRIGHT= 2;
        LIGHTSEGSHIFT = 8-LBITS;
        NUMCOLORMAPS=     LIGHTLEVELS;
        MAXLIGHTSCALE = 3*LIGHTLEVELS/2;
        LIGHTSCALESHIFT = 17        -LBITS;
        LIGHTZSHIFT=25-LBITS;
    }

    public final byte[] getTranslationTable(long mobjflags) {
        return translationtables[(int) ((mobjflags & MF_TRANSLATION)>>MF_TRANSSHIFT)];
    }
    
}

package rr;


/** A maptexturedef_t describes a rectangular texture,
 *  which is composed of one or more mappatch_t structures
 *  that arrange graphic patches.
 *  
 *  This is the in-memory format, which is similar to maptexture_t (which is on-disk).
 *  
 * @author Maes
 *
 */

public class texture_t {
    /** Keep name for switch changing, etc. */
    public String    name;        
    public short   width;
    public short   height;
    
    // All the patches[patchcount]
    //  are drawn back to front into the cached texture.
    public short   patchcount;
    public texpatch_t[]  patches;     
    
    /** Unmarshalling at its best! */
    
    public void copyFromMapTexture(maptexture_t mt){
        this.name=new String(mt.name);
        this.width=mt.width;
        this.height=mt.height;
        this.patchcount=mt.patchcount;
        this.patches=new texpatch_t[patchcount];
        
        for (int i=0;i<patchcount;i++){
            patches[i]=new texpatch_t();
            patches[i].copyFromMapPatch(mt.patches[i]);
        }
    }
    
    @Override
    public String toString(){
        StringBuilder sb=new StringBuilder();
        sb.append(name);
        sb.append(" Height ");
        sb.append(height);
        sb.append(" Width ");
        sb.append(width);
        sb.append(" Patchcount ");
        sb.append(patchcount);
        return sb.toString();
            
        }    
}
package rr;

/** Resets limit-removing stuff back to their initial values,
 *  either for initialization reasons or to regain memory 
 *  e.g. playing MAP02 after nuts.wad should free up some vissprite buffers. 
 *  
 * @author admin
 *
 */

public interface ILimitResettable {
    public void resetLimits();   
}

package rr;

import doom.thinker_t;

/** Used for special sector-based function for doors, ceilings 
 *  etc. that are treated as a thinker by the engine. The sector
 *  is part of the spec, so extending classes don't need to override 
 *  it. Also, it extends thinker so futher extensions are thinkers too.
 * 
 */
 
public abstract class SectorAction extends thinker_t {
  
    public sector_t sector;
    
    /** Special, only used when (un)archiving in order to re-link stuff
     *  to their proper sector.
     */
    public int sectorid;
}

package rr;

import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedMul;
import static utils.C2JUtils.eval;

import java.util.Arrays;

import p.Resettable;
import utils.C2JUtils;
import m.BBox;
import m.ISyncLogger;

/** BSP node.
 * 
 * @author Maes
 *
 */
public class node_t implements Resettable{

    
    public node_t(){
        bbox=new BBox[2];
        children= new int[2];
        C2JUtils.initArrayOfObjects(bbox, BBox.class);
    }
    
     public node_t(int x, int y, int dx, int dy, BBox[] bbox,
            int[] children) {
        this.x = x;
        this.y = y;
        this.dx = dx;
        this.dy = dy;
        this.bbox = bbox;
        this.children = children;
    }


    /** (fixed_t) Partition line. */
     public int x, y, dx, dy;

     /** Bounding box for each child. */
     //public fixed_t bbox[2][4];
     // Maes: make this into two proper bboxes?
          
     public BBox[] bbox;
     

     /** If NF_SUBSECTOR its a subsector. 
      * 
      * e6y: support for extented nodes
      */
     public int[] children;
     
     /**
      * R_PointOnSide
      * Traverse BSP (sub) tree,
      *  check point against partition plane.
      * Returns side 0 (front) or 1 (back).
      * @param x fixed
      * @param y fixed
      * 
      */

     public static int PointOnSide
     ( int   x,
       int   y,
       node_t    node )
     {
         // MAES: These are used mainly as ints, no need to use fixed_t internally.
         // fixed_t will only be used as a "pass type", but calculations will be done with ints, preferably.
         int dx; 
         int dy;
         int left;
         int right;
         
         if (node.dx==0)
         {
         if (x <= node.x)
             return (node.dy > 0)?1:0;
         
         return (node.dy < 0)?1:0;
         }
         if (node.dy==0)
         {
         if (y <= node.y)
             return (node.dx < 0)?1:0;
         
         return (node.dx > 0)?1:0;
         }
         
         dx = (x - node.x);
         dy = (y - node.y);
         
         // Try to quickly decide by looking at sign bits.
         if ( ((node.dy ^ node.dx ^ dx ^ dy)&0x80000000 )!=0)
         {
         if  ( ((node.dy ^ dx) & 0x80000000 )!=0)
         {
             // (left is negative)
             return 1;
         }
         return 0;
         }

         left = FixedMul ( node.dy>>FRACBITS , dx );
         right = FixedMul ( dy , node.dx>>FRACBITS );
         
         if (right < left)
         {
         // front side
         return 0;
         }
         // back side
         return 1;           
     }
     
   /** Since no context is needed, this is perfect for an instance method 
    *      
    * @param x fixed
    * @param y fixed
    * @return
    */
     public int PointOnSide
     ( int   x,
       int   y
       )
     {
         // MAES: These are used mainly as ints, no need to use fixed_t internally.
         // fixed_t will only be used as a "pass type", but calculations will be done with ints, preferably.
         int dx; 
         int dy;
         int left;
         int right;
         
         if (this.dx==0)
         {
         if (x <= this.x)
             return (this.dy > 0)?1:0;
         
         return (this.dy < 0)?1:0;
         }
         if (this.dy==0)
         {
         if (y <= this.y)
             return (this.dx < 0)?1:0;
         
         return (this.dx > 0)?1:0;
         }
         
         dx = (x - this.x);
         dy = (y - this.y);
         
         // Try to quickly decide by looking at sign bits.
         if ( ((this.dy ^ this.dx ^ dx ^ dy)&0x80000000 )!=0)
         {
         if  ( ((this.dy ^ dx) & 0x80000000 )!=0)
         {
             // (left is negative)
             return 1;
         }
         return 0;
         }

         left = FixedMul ( this.dy>>FRACBITS , dx );
         right = FixedMul ( dy , this.dx>>FRACBITS );
         
         if (right < left)
         {
         // front side
         return 0;
         }
         // back side
         return 1;           
     }

  /**
   * Clone of divline_t's method. Same contract, but working on node_t's to avoid casts.
   * P_DivlineSide
   * Returns side 0 (front), 1 (back), or 2 (on).
   */
 	public int
 	DivlineSide
 	( int	x,
 	  int	y)
 	{
 	    
 	      int left,right;
 	        // Boom-style code. Da fack.
 	      // [Maes]: using it leads to very different DEMO4 UD behavior.
 	        
 	       return
 	      (this.dx==0) ? x == this.x ? 2 : x <= this.x ? eval(this.dy > 0) : eval(this.dy < 0) :
 	      (this.dy==0) ? (olddemo ? x : y) == this.y ? 2 : y <= this.y ? eval(this.dx < 0) : eval(this.dx > 0) :
 	      (this.dy==0) ? y == this.y ? 2 : y <= this.y ? eval(this.dx < 0) : eval(this.dx > 0) :
 	      (right = ((y - this.y) >> FRACBITS) * (this.dx >> FRACBITS)) <
 	      (left  = ((x - this.x) >> FRACBITS) * (this.dy >> FRACBITS)) ? 0 :
 	      right == left ? 2 : 1;
 	      
 	    
 	      /*
 	    int	dx; // fixed_t
 	    int	dy;

 	    if (this.dx==0)
 	    {
 		if (x==this.x)
 		    return 2;
 		
 		if (x <= this.x)
 		    return (this.dy > 0)?1:0;

 		return (this.dy < 0)?1:0;
 	    }
 	    
 	    if (this.dy==0)
 	    {
 		if (x==this.y)
 		    return 2;

 		if (y <= this.y)
 		    return (this.dx < 0)?1:0;

 		return (this.dx > 0)?1:0;
 	    }
 		
 	    dx = (x - this.x);
 	    dy = (y - this.y);

 	    left =  (this.dy>>FRACBITS) * (dx>>FRACBITS);
 	    right = (dy>>FRACBITS) * (this.dx>>FRACBITS);
 		
 	    if (right < left)
 		return 0;	// front side
 	    
 	    if (left == right)
 		return 2;
 	    return 1;		// back side
 	    */
 	    
 	}
 	
 	private static final boolean olddemo = true;
 	
 	  public int
 	    DivlineSide
 	    ( int   x,
 	      int   y,
 	      ISyncLogger SL,
 	      boolean sync)
 	    {
 	      int result=DivlineSide(x,y);
 	      if (sync){
 	         SL.sync("DLS %d\n",
 	            result);
 	      }
 	      return result;
 	      
 	    }
@Override
    public void reset() {
    x=y=dx = dy = 0;
    for (int i=0;i<2;i++){
        bbox[i].ClearBox();
        }
    Arrays.fill(children, 0);
    
    }
     
 }


package rr;

/**
 * A very "simple" things class which just does serial rendering and uses all
 * the base methods from AbstractThings.
 * 
 * @author velktron
 * @param <T>
 * @param <V>
 */


public final class SimpleThings<T,V>
        extends AbstractThings<T,V> {

    public SimpleThings(Renderer<T, V> R) {
        super(R);
    }

    @Override
    public void completeColumn() {
        colfunc.invoke();
        }
}

package rr;

/** An interface used to ease the use of the GetCachedColumn by part
 *  of parallelized renderers.
 *  
 * @author Maes
 *
 */

public interface IGetCachedColumn<T> {

	T GetCachedColumn(int tex, int col);

}

package rr.parallel;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;

import rr.AbstractThings;
import rr.IMaskedDrawer;
import rr.ISpriteManager;
import rr.IVisSpriteManagement;
import rr.Renderer;
import v.IVideoScale;

/**  Alternate parallel sprite renderer using a split-screen strategy.
 *  For N threads, each thread gets to render only the sprites that are entirely
 *  in its own 1/Nth portion of the screen.
 *  
 *  Sprites that span more than one section, are drawn partially. Each thread
 *  only has to worry with the priority of its own sprites. Similar to the 
 *  split-seg parallel drawer.
 * 
 *  Uses the "masked workers" subsystem, there is no column pipeline: workers
 *  "tap" directly in the sprite sorted table and act accordingly (draw entirely,
 *  draw nothing, draw partially).
 *  
 *  It uses masked workers to perform the actual work, each of which is a complete
 *  Thing Drawer. 
 * 
 * @author velktron
 *
 */

public final class ParallelThings2<T,V>
        implements IMaskedDrawer<T,V> {

    MaskedWorker<T,V>[] maskedworkers;
    CyclicBarrier maskedbarrier;
    Executor tp;
    protected final IVisSpriteManagement<V> VIS;
    
    public ParallelThings2(Renderer<T,V> R) {
        this.VIS=R.getVisSpriteManager();

    }

    @Override
    public void DrawMasked() {

        VIS.SortVisSprites();

        for (int i = 0; i < maskedworkers.length; i++) {
            tp.execute(maskedworkers[i]);
        }

        try {
            maskedbarrier.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public void completeColumn() {
        // Does nothing. Dummy.
    }

    @Override
    public void setPspriteScale(int scale) {
        for (int i = 0; i < maskedworkers.length; i++)
            maskedworkers[i].setPspriteScale(scale);
    }

    @Override
    public void setPspriteIscale(int scale) {
        for (int i = 0; i < maskedworkers.length; i++)
            maskedworkers[i].setPspriteIscale(scale);
    }

    @Override
    public void setVideoScale(IVideoScale vs) {
        for (int i = 0; i < maskedworkers.length; i++)
            maskedworkers[i].setVideoScale(vs);
    }

    @Override
    public void initScaling() {
        for (int i = 0; i < maskedworkers.length; i++)
            maskedworkers[i].initScaling();
        
    }

    @Override
    public void setDetail(int detailshift) {
        for (int i = 0; i < maskedworkers.length; i++)
            maskedworkers[i].setDetail(detailshift);
        
    }

    @Override
    public void cacheSpriteManager(ISpriteManager SM) {
        for (int i = 0; i < maskedworkers.length; i++)
            maskedworkers[i].cacheSpriteManager(SM);
        
    }

}

package rr.parallel;

/** This is all the information needed to draw a particular SEG.
 * It's quite a lot, actually, but much better than in testing
 * versions.
 *  
 */

public class RenderSegInstruction<V> {    
	public int     rw_x,rw_stopx;
	public int toptexture,midtexture,bottomtexture;
	public int  pixhigh,pixlow,pixhighstep,pixlowstep,
	topfrac,    topstep,bottomfrac, bottomstep;	
	public boolean segtextured,markfloor,markceiling;
	public long     rw_centerangle; // angle_t
	/** fixed_t */
	public int     rw_offset,rw_distance,rw_scale,
	rw_scalestep,rw_midtexturemid,rw_toptexturemid,rw_bottomtexturemid;
	public int viewheight;
	V[] walllights;
	public int centery;

}

package rr.parallel;

import i.IDoomSystem;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import rr.IDetailAware;
import rr.drawfuns.ColVars;
import rr.drawfuns.DcFlags;
import rr.drawfuns.DoomColumnFunction;
import rr.drawfuns.R_DrawColumnBoom;
import rr.drawfuns.R_DrawColumnBoomLow;
import rr.drawfuns.R_DrawFuzzColumn;
import rr.drawfuns.R_DrawFuzzColumnLow;
import rr.drawfuns.R_DrawTranslatedColumn;
import rr.drawfuns.R_DrawTranslatedColumnLow;

/**
 * This is what actual executes the RenderWallInstruction. Essentially it's a
 * self-contained column rendering function.
  * 
 * @author velktron
 */

public abstract class RenderMaskedExecutor<T,V>
        implements Runnable,IDetailAware {

    protected CyclicBarrier barrier;

    protected ColVars<T,V>[] RMI;
   
    protected int rmiend;

    protected boolean lowdetail=false;
    
    protected int start, end;

    protected DoomColumnFunction<T,V> colfunchi, colfunclow;
    protected DoomColumnFunction<T,V> fuzzfunchi, fuzzfunclow;
    protected DoomColumnFunction<T,V> transfunchi, transfunclow;
    
    protected DoomColumnFunction<T,V> colfunc;

    public RenderMaskedExecutor(int SCREENWIDTH, int SCREENHEIGHT,            
            ColVars<T,V>[] RMI, CyclicBarrier barrier
            ) {
        this.RMI = RMI;
        this.barrier = barrier;
        this.SCREENWIDTH = SCREENWIDTH;
        this.SCREENHEIGHT = SCREENHEIGHT;
    }

    public void setRange(int start, int end) {
        this.end = end;
        this.start = start;
    }

    public void setDetail(int detailshift) {
        if (detailshift == 0)
            lowdetail=false;
        else
            lowdetail=true;
    }

    public void run() {

        // System.out.println("Wall executor from "+start +" to "+ end);
        int dc_flags=0;
        
        // Check out ALL valid RMIs, but only draw those on YOUR side of the screen.
        for (int i = 0; i < rmiend; i++) {
            
            if (RMI[i].dc_x>=start && RMI[i].dc_x<=end){
            // Change function type according to flags.
            // No flag change means reusing the last used type
            dc_flags=RMI[i].dc_flags;
                //System.err.printf("Flags transition %d\n",dc_flags);
                if (lowdetail){
                    if ((dc_flags&DcFlags.FUZZY)!=0)                        
                        colfunc=fuzzfunclow;
                    else
                    if ((dc_flags&DcFlags.TRANSLATED)!=0)
                            colfunc=transfunclow;
                    else
                        colfunc=colfunclow;
                } else {
                    if ((dc_flags&DcFlags.FUZZY)!=0)
                        colfunc=fuzzfunchi;
                    else
                    if ((dc_flags&DcFlags.TRANSLATED)!=0)
                        colfunc=transfunchi;
                    else
                        colfunc=colfunchi;
                    }
            
            // No need to set shared DCvars, because it's passed with the arg.
            colfunc.invoke(RMI[i]);
            }
        }

        try {
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
        
    public void setRMIEnd(int rmiend){
        this.rmiend=rmiend;
    }         

    public void updateRMI(ColVars<T,V>[] RMI) {
        this.RMI = RMI;

    }

    /////////////// VIDEO SCALE STUFF//////////////////////

    protected final int SCREENWIDTH;

    protected final int SCREENHEIGHT;
    /*
     * protected IVideoScale vs;
     * @Override public void setVideoScale(IVideoScale vs) { this.vs=vs; }
     * @Override public void initScaling() {
     * this.SCREENHEIGHT=vs.getScreenHeight();
     * this.SCREENWIDTH=vs.getScreenWidth(); }
     */
    
    public static final class HiColor extends RenderMaskedExecutor<byte[],short[]>{

        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] columnofs,
                int[] ylookup, short[] screen, ColVars<byte[], short[]>[] RMI,
                CyclicBarrier barrier,IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT,RMI, barrier);
            
            // Regular masked columns
            this.colfunc = new R_DrawColumnBoom.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.colfunclow = new R_DrawColumnBoomLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            
            // Fuzzy columns
            this.fuzzfunchi= new R_DrawFuzzColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.fuzzfunclow =new R_DrawFuzzColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);

            // Translated columns
            this.transfunchi=new R_DrawTranslatedColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.transfunclow= new R_DrawTranslatedColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);

        }
        
    }
    
    public static final class Indexed extends RenderMaskedExecutor<byte[],byte[]>{

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] columnofs,
                int[] ylookup, byte[] screen, ColVars<byte[], byte[]>[] RMI,
                CyclicBarrier barrier,IDoomSystem I,byte[] BLURRY_MAP) {
            super(SCREENWIDTH, SCREENHEIGHT,RMI, barrier);
            
            // Regular masked columns
            this.colfunc = new R_DrawColumnBoom.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.colfunclow = new R_DrawColumnBoomLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            
            // Fuzzy columns
            this.fuzzfunchi= new R_DrawFuzzColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I,BLURRY_MAP);
            this.fuzzfunclow =new R_DrawFuzzColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I,BLURRY_MAP);

            // Translated columns
            this.transfunchi=new R_DrawTranslatedColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.transfunclow= new R_DrawTranslatedColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);

        }
        
    }
    
    public static final class TrueColor extends RenderMaskedExecutor<byte[],int[]>{

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] columnofs,
                int[] ylookup, int[] screen, ColVars<byte[], int[]>[] RMI,
                CyclicBarrier barrier,IDoomSystem I) {
            super(SCREENWIDTH, SCREENHEIGHT,RMI, barrier);
            
            // Regular masked columns
            this.colfunc = new R_DrawColumnBoom.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.colfunclow = new R_DrawColumnBoomLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            
            // Fuzzy columns
            this.fuzzfunchi= new R_DrawFuzzColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.fuzzfunclow =new R_DrawFuzzColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);

            // Translated columns
            this.transfunchi=new R_DrawTranslatedColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);
            this.transfunclow= new R_DrawTranslatedColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,null,screen,I);


        }
        
    }
    
}

package rr.parallel;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import p.pspdef_t;
import static rr.LightsAndColors.*;
import rr.AbstractThings;
import rr.IDetailAware;
import rr.Renderer;
import rr.column_t;
import rr.drawseg_t;
import rr.patch_t;
import rr.spritedef_t;
import rr.spriteframe_t;
import rr.vissprite_t;
import rr.drawfuns.ColFuncs;
import rr.drawfuns.ColVars;
import rr.drawfuns.R_DrawColumnBoom;
import rr.drawfuns.R_DrawColumnBoomLow;
import rr.drawfuns.R_DrawFuzzColumn;
import rr.drawfuns.R_DrawFuzzColumnLow;
import rr.drawfuns.R_DrawTranslatedColumn;
import rr.drawfuns.R_DrawTranslatedColumnLow;
import static p.mobj_t.MF_TRANSLATION;
import static p.mobj_t.MF_TRANSSHIFT;
import static m.fixed_t.*;
import static rr.line_t.*;
import static data.Defines.FF_FRAMEMASK;
import static data.Defines.FF_FULLBRIGHT;
import static data.Defines.pw_invisibility;

/** A "Masked Worker" draws sprites in a split-screen strategy. Used by 
 * ParallelRenderer2. Each Masked Worker is essentially a complete Things
 * drawer, and reuses much of the serial methods.
 * 
 * @author velktron
 *
 * @param <T>
 * @param <V>
 */

public abstract class MaskedWorker<T,V> extends AbstractThings<T,V> implements Runnable, IDetailAware{
    
    private final static boolean DEBUG=false;
    private final static boolean RANGECHECK=false;
	
    protected final CyclicBarrier barrier;
    protected final int id;
    protected final int numthreads;
    
    protected ColVars<T,V> maskedcvars;
   
	public MaskedWorker(Renderer<T,V> R,int id,int SCREENWIDTH, int SCREENHEIGHT,int numthreads,CyclicBarrier barrier){
	    super(R);
	    // Workers have their own set, not a "pegged" one.
	    this.colfuncshi=new ColFuncs<T,V>();
	    this.colfuncslow=new ColFuncs<T,V>();
	    this.maskedcvars=new ColVars<T,V>();
	    this.id=id;
        this.numthreads=numthreads;
        this.barrier=barrier;        
        }
	
	public final void completeColumn(){
	    // Does nothing. Shuts up inheritance
	}
    
    public static final class HiColor extends MaskedWorker<byte[],short[]>{

		public HiColor(Renderer<byte[],short[]> R,int id, int SCREENWIDTH, int SCREENHEIGHT,
				int[] ylookup, int[] columnofs, int numthreads, short[] screen,
				CyclicBarrier barrier) {
			super(R,id, SCREENWIDTH, SCREENHEIGHT,numthreads, barrier);

	        // Non-optimized stuff for masked.
			colfuncshi.base=colfuncshi.main=colfuncshi.masked=new R_DrawColumnBoom.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
	        colfuncslow.masked=new R_DrawColumnBoomLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);

	        // Fuzzy columns. These are also masked.
	        colfuncshi.fuzz=new R_DrawFuzzColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
	        colfuncslow.fuzz=new R_DrawFuzzColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);

	        // Translated columns are usually sprites-only.
	        colfuncshi.trans=new R_DrawTranslatedColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
	        colfuncslow.trans=new R_DrawTranslatedColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
	        
	        colfuncs=colfuncshi;

		}
    	
    }
    
    public static final class Indexed extends MaskedWorker<byte[],byte[]>{

        public Indexed(Renderer<byte[],byte[]> R,int id, int SCREENWIDTH, int SCREENHEIGHT,
                int[] ylookup, int[] columnofs, int numthreads, byte[] screen,
                CyclicBarrier barrier,byte[] BLURRY_MAP) {
            super(R,id, SCREENWIDTH, SCREENHEIGHT,numthreads, barrier);
            colfuncshi.base=colfuncshi.main=colfuncshi.masked=new R_DrawColumnBoom.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            colfuncslow.masked=new R_DrawColumnBoomLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);

            // Fuzzy columns. These are also masked.
            colfuncshi.fuzz=new R_DrawFuzzColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I,BLURRY_MAP);
            colfuncslow.fuzz=new R_DrawFuzzColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I,BLURRY_MAP);

            // Translated columns are usually sprites-only.
            colfuncshi.trans=new R_DrawTranslatedColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            colfuncslow.trans=new R_DrawTranslatedColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            colfuncs=colfuncshi;
        }
        
    }
    
    public static final class TrueColor extends MaskedWorker<byte[],int[]>{

        public TrueColor(Renderer<byte[],int[]> R,int id, int SCREENWIDTH, int SCREENHEIGHT,
                int[] ylookup, int[] columnofs, int numthreads, int[] screen,
                CyclicBarrier barrier) {
            super(R,id, SCREENWIDTH, SCREENHEIGHT,numthreads, barrier);

            // Non-optimized stuff for masked.
            colfuncshi.base=colfuncshi.main=colfuncshi.masked=new R_DrawColumnBoom.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            colfuncslow.masked=new R_DrawColumnBoomLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);

            // Fuzzy columns. These are also masked.
            colfuncshi.fuzz=new R_DrawFuzzColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            colfuncslow.fuzz=new R_DrawFuzzColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);

            // Translated columns are usually sprites-only.
            colfuncshi.trans=new R_DrawTranslatedColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            colfuncslow.trans=new R_DrawTranslatedColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            colfuncs=colfuncshi;

        }
        
    }
    
    protected int startx, endx;
    
    /**
     * R_DrawVisSprite mfloorclip and mceilingclip should also be set.
     * 
     * Sprites are actually drawn here. Obviously overrides the serial
     * method, and only draws a portion of the sprite.
     * 
     * 
     */
    protected final void DrawVisSprite(vissprite_t<V> vis) {
        column_t column;
        int texturecolumn;
        int frac; // fixed_t
        patch_t patch;
        // The sprite may have been partially drawn on another portion of the
        // screen.
        int bias=startx-vis.x1;
            if (bias<0) bias=0; // nope, it ain't.

        // Trim bounds to zone NOW
        int x1=Math.max(startx, vis.x1);
        int x2=Math.min(endx,vis.x2);
            
        // At this point, the view angle (and patch) has already been
        // chosen. Go back.
        patch = W.CachePatchNum(vis.patch + SM.getFirstSpriteLump());
        
        maskedcvars.dc_colormap = vis.colormap;
        // colfunc=glasscolfunc;
        if (maskedcvars.dc_colormap == null) {
            // NULL colormap = shadow draw
            colfunc = colfuncs.fuzz;
        } else if ((vis.mobjflags & MF_TRANSLATION) != 0) {
            colfunc = colfuncs.trans;
            maskedcvars.dc_translation = (T) colormaps.getTranslationTable(vis.mobjflags);

        }

        maskedcvars.dc_iscale = Math.abs(vis.xiscale) >> view.detailshift;
        maskedcvars.dc_texturemid = vis.texturemid;
        // Add bias to compensate for partially drawn sprite which has not been rejected.
        frac = vis.startfrac+vis.xiscale*bias;
        spryscale = vis.scale;
        sprtopscreen = view.centeryfrac - FixedMul(maskedcvars.dc_texturemid, spryscale);

        // A texture height of 0 means "not tiling" and holds for
        // all sprite/masked renders.
        maskedcvars.dc_texheight=0;
        
        for (maskedcvars.dc_x = x1; maskedcvars.dc_x <= x2; maskedcvars.dc_x++, frac += vis.xiscale) {
            texturecolumn = frac >> FRACBITS;
            if (true) {
                if (texturecolumn < 0 || texturecolumn >= patch.width)
                    I.Error("R_DrawSpriteRange: bad texturecolumn %d vs %d %d %d",texturecolumn,patch.width,x1,x2);
            }
            column = patch.columns[texturecolumn];
            
            if (column==null)
                System.err.printf("Null column for texturecolumn %d\n",texturecolumn,x1,x2);
            else
            DrawMaskedColumn(column);
        }

        colfunc = colfuncs.masked;
    }

    /**
     * R_RenderMaskedSegRange
     * 
     * @param ds
     * @param x1
     * @param x2
     */
    
    protected final void RenderMaskedSegRange(drawseg_t ds, int x1, int x2) {
    	
    	// Trivial rejection
        if (ds.x1>endx || ds.x2<startx) return;
        
        // Trim bounds to zone NOW
        x1=Math.max(startx, x1);
        x2=Math.min(endx,x2);
    	
        int index;

        int lightnum;
        int texnum;
        int bias=startx-ds.x1; // Correct for starting outside
        if (bias<0) bias=0; // nope, it ain't.
        
        // System.out.printf("RenderMaskedSegRange from %d to %d\n",x1,x2);

        // Calculate light table.
        // Use different light tables
        // for horizontal / vertical / diagonal. Diagonal?
        // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
        MyBSP.curline = ds.curline;
        frontsector = MyBSP.curline.frontsector;
        backsector = MyBSP.curline.backsector;
        texnum = TexMan.getTextureTranslation(MyBSP.curline.sidedef.midtexture);
        // System.out.print(" for texture "+textures[texnum].name+"\n:");
        lightnum = (frontsector.lightlevel >> LIGHTSEGSHIFT) + colormaps.extralight;

        if (MyBSP.curline.v1y == MyBSP.curline.v2y)
            lightnum--;
        else if (MyBSP.curline.v1x == MyBSP.curline.v2x)
            lightnum++;

        // Killough code.
        colormaps.walllights = lightnum >= LIGHTLEVELS ? colormaps.scalelight[LIGHTLEVELS - 1]
                : lightnum < 0 ? colormaps.scalelight[0] : colormaps.scalelight[lightnum];

        // Get the list
        maskedtexturecol = ds.getMaskedTextureColList();
        // And this is the pointer.
        pmaskedtexturecol = ds.getMaskedTextureColPointer();

        rw_scalestep = ds.scalestep;
        spryscale = ds.scale1 + (x1 - ds.x1) * rw_scalestep;

        // HACK to get "pointers" inside clipping lists
        mfloorclip = ds.getSprBottomClipList();
        p_mfloorclip = ds.getSprBottomClipPointer();
        mceilingclip = ds.getSprTopClipList();
        p_mceilingclip = ds.getSprTopClipPointer();
        // find positioning
        if ((MyBSP.curline.linedef.flags & ML_DONTPEGBOTTOM) != 0) {
            maskedcvars.dc_texturemid = frontsector.floorheight > backsector.floorheight ? frontsector.floorheight
                    : backsector.floorheight;
            maskedcvars.dc_texturemid = maskedcvars.dc_texturemid + TexMan.getTextureheight(texnum)
                    - view.z;
        } else {
            maskedcvars.dc_texturemid = frontsector.ceilingheight < backsector.ceilingheight ? frontsector.ceilingheight
                    : backsector.ceilingheight;
            maskedcvars.dc_texturemid = maskedcvars.dc_texturemid - view.z;
        }
        maskedcvars.dc_texturemid += MyBSP.curline.sidedef.rowoffset;

        if (colormaps.fixedcolormap != null)
            maskedcvars.dc_colormap = colormaps.fixedcolormap;

        // Texture height must be set at this point. This will trigger
        // tiling. For sprites, it should be set to 0.
        maskedcvars.dc_texheight = TexMan.getTextureheight(texnum) >> FRACBITS;

        // draw the columns
        for (maskedcvars.dc_x = x1; maskedcvars.dc_x <= x2; maskedcvars.dc_x++) {
            // calculate lighting
            if (maskedtexturecol[pmaskedtexturecol + maskedcvars.dc_x] != Short.MAX_VALUE) {
                if (colormaps.fixedcolormap == null) {
                    index = spryscale >>> LIGHTSCALESHIFT;

                    if (index >= MAXLIGHTSCALE)
                        index = MAXLIGHTSCALE - 1;

                    maskedcvars.dc_colormap = colormaps.walllights[index];
                }

                sprtopscreen = view.centeryfrac
                        - FixedMul(maskedcvars.dc_texturemid, spryscale);
                maskedcvars.dc_iscale = (int) (0xffffffffL / spryscale);

                // draw the texture
                column_t data = TexMan.GetSmpColumn(texnum,
                        maskedtexturecol[pmaskedtexturecol + maskedcvars.dc_x],id);
                
                DrawMaskedColumn(data);
                maskedtexturecol[pmaskedtexturecol + maskedcvars.dc_x] = Short.MAX_VALUE;
            }
            spryscale += rw_scalestep;
        }

    }		
    
    /**
     * R_DrawPSprite
     * 
     * Draws a "player sprite" with slighly different rules than normal
     * sprites. This is actually a PITA, at best :-/
     * 
     * Also different than normal implementation.
     * 
     */

    protected final void DrawPSprite(pspdef_t psp) {

        int tx;
        int x1;
        int x2;
        spritedef_t sprdef;
        spriteframe_t sprframe;
        vissprite_t<V> vis;
        int lump;
        boolean flip;

        //

        // decide which patch to use (in terms of angle?)
        if (RANGECHECK) {
            if (psp.state.sprite.ordinal() >= SM.getNumSprites())
                I.Error("R_ProjectSprite: invalid sprite number %d ",
                        psp.state.sprite);
        }

        sprdef = SM.getSprite(psp.state.sprite.ordinal());
        
        if (RANGECHECK) {
            if ((psp.state.frame & FF_FRAMEMASK) >= sprdef.numframes)
                I.Error("R_ProjectSprite: invalid sprite frame %d : %d ",
                        psp.state.sprite, psp.state.frame);
        }
        
        sprframe = sprdef.spriteframes[psp.state.frame & FF_FRAMEMASK];

        // Base frame for "angle 0" aka viewed from dead-front.
        lump = sprframe.lump[0];
        // Q: where can this be set? A: at sprite loadtime.
        flip = (boolean) (sprframe.flip[0] != 0);

        // calculate edges of the shape. tx is expressed in "view units".
        tx = (int) (FixedMul(psp.sx, view.BOBADJUST) - view.WEAPONADJUST);

        tx -= spriteoffset[lump];

        // So...centerxfrac is the center of the screen (pixel coords in
        // fixed point).
        x1 = (view.centerxfrac + FixedMul(tx, pspritescale)) >> FRACBITS;

        // off the right side
        if (x1 > endx)
            return;

        tx += spritewidth[lump];
        x2 = ((view.centerxfrac + FixedMul(tx, pspritescale)) >> FRACBITS) - 1;

        // off the left side
        if (x2 < startx)
            return;

        // store information in a vissprite ?
        vis = avis;
        vis.mobjflags = 0;
        vis.texturemid = ((BASEYCENTER+view.lookdir) << FRACBITS) + FRACUNIT / 2
                - (psp.sy - spritetopoffset[lump]);
        vis.x1 = x1 < startx ? startx : x1;
        vis.x2 = x2 >= endx ? endx - 1 : x2;
        vis.scale = (pspritescale) << view.detailshift;

        if (flip) {
            vis.xiscale = -pspriteiscale;
            vis.startfrac = spritewidth[lump] - 1;
        } else {
            vis.xiscale = pspriteiscale;
            vis.startfrac = 0;
        }

        if (vis.x1 > x1)
            vis.startfrac += vis.xiscale * (vis.x1 - x1);

        vis.patch = lump;

        if ((view.player.powers[pw_invisibility] > 4 * 32)
                || (view.player.powers[pw_invisibility] & 8) != 0) {
            // shadow draw
            vis.colormap = null;

        } else if (colormaps.fixedcolormap != null) {
            // fixed color
            vis.colormap = colormaps.fixedcolormap;
            // vis.pcolormap=0;
        } else if ((psp.state.frame & FF_FULLBRIGHT) != 0) {
            // full bright
            vis.colormap = colormaps.colormaps[0];
            // vis.pcolormap=0;
        } else {
            // local light
            vis.colormap = colormaps.spritelights[MAXLIGHTSCALE - 1];
        }

        //System.out.printf("Weapon draw from %d to %d\n",vis.x1,vis.x2);
        DrawVisSprite(vis);
    }
    
    
    /**
     * R_DrawMasked
     * 
     * Sorts and draws vissprites (room for optimization in sorting func.)
     * Draws masked textures. Draws player weapons and overlays (psprites).
     * 
     * Sorting function can be swapped for almost anything, and it will work
     * better, in-place and be simpler to draw, too.
     * 
     * 
     */
    
    @Override
    public void run() {
        // vissprite_t spr;
        int ds;
        drawseg_t dss;

        // Sprites should already be sorted for distance 

        colfunc = colfuncs.masked; // Sprites use fully-masked capable
                                 // function.

        // Update view height
        
        this.maskedcvars.viewheight=view.height;
        this.maskedcvars.centery=view.centery;
        this.startx=((id*view.width)/numthreads);
        this.endx=(((id+1)*view.width)/numthreads);
        
        // Update thread's own vissprites
        
        final vissprite_t<V>[] vissprites=VIS.getVisSprites();
        final int numvissprites=VIS.getNumVisSprites();
        
        //System.out.printf("Sprites to render: %d\n",numvissprites);
        
        // Try drawing all sprites that are on your side of
        // the screen. Limit by x1 and x2, if you have to.
        for (int i = 0; i < numvissprites; i++) {
            DrawSprite(vissprites[i]);
        }
        
        //System.out.printf("Segs to render: %d\n",ds_p);

        // render any remaining masked mid textures
        for (ds = seg_vars.ds_p - 1; ds >= 0; ds--) {
            dss = seg_vars.drawsegs[ds];
            if (!(dss.x1>endx || dss.x2<startx)&&!dss.nullMaskedTextureCol())
                RenderMaskedSegRange(dss, dss.x1,dss.x2);
        }
        // draw the psprites on top of everything
        // but does not draw on side views
        // if (viewangleoffset==0)

        colfunc = colfuncs.player;
        DrawPlayerSprites();
        colfunc = colfuncs.masked;
        
        try {
            barrier.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
}

package rr.parallel;

import static rr.LightsAndColors.LIGHTLEVELS;
import static rr.LightsAndColors.MAXLIGHTSCALE;
import static rr.LightsAndColors.MAXLIGHTZ;

import java.io.IOException;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import rr.IDetailAware;
import rr.PlaneDrawer;
import rr.SimpleThings;
import rr.patch_t;
import rr.drawfuns.ColVars;
import rr.drawfuns.DcFlags;
import rr.drawfuns.R_DrawColumnBoom;
import rr.drawfuns.R_DrawColumnBoomLow;
import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;
import rr.drawfuns.R_DrawFuzzColumn;
import rr.drawfuns.R_DrawFuzzColumnLow;
import rr.drawfuns.R_DrawSpanLow;
import rr.drawfuns.R_DrawSpanUnrolled;
import rr.drawfuns.R_DrawTLColumn;
import rr.drawfuns.R_DrawTranslatedColumn;
import rr.drawfuns.R_DrawTranslatedColumnLow;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import doom.DoomMain;
import doom.player_t;

/**
 * This is Mocha Doom's famous parallel software renderer. It builds on the
 * basic software renderer, but adds specialized handling for drawing segs
 * (walls) and spans (floors) in parallel. There's inherent parallelism between
 * walls and floor, and internal parallelism between walls and between floors.
 * However, visplane limits and openings need to be pre-computed before any
 * actual drawing starts, that's why rendering of walls is stored in "RWI"s or
 * "Render Wall Instructions", and then rendered once they are all in place and
 * the can be parallelized between rendering threads. Rendering of sprites is
 * NOT parallelized yet (and probably not worth it, at this point).
 * 
 * @author admin
 */

public abstract class ParallelRenderer<T, V>
        extends AbstractParallelRenderer<T, V> {

    public ParallelRenderer(DoomMain<T, V> DM, int wallthread,
            int floorthreads, int nummaskedthreads) {
        super(DM, wallthread, floorthreads, nummaskedthreads);
        
        // Register parallel seg drawer with list of RWI subsystems.
        ParallelSegs tmp= new ParallelSegs(this);
        this.MySegs = tmp;
        RWIs= tmp;
        
        this.MyThings =
                new SimpleThings<T,V>(this);
        //this.MyPlanes = new Planes(this);// new ParallelPlanes<T, V>(DM.R);

    }

    /**
     * Default constructor, 1 seg, 1 span and two masked threads.
     * 
     * @param DM
     */
    public ParallelRenderer(DoomMain<T, V> DM) {
        this(DM, 1, 1, 2);
    }



    /**
     * R_RenderView As you can guess, this renders the player view of a
     * particular player object. In practice, it could render the view of any
     * mobj too, provided you adapt the SetupFrame method (where the viewing
     * variables are set).
     * 
     * @throws IOException
     */

    public void RenderPlayerView(player_t player) {

        // Viewing variables are set according to the player's mobj. Interesting
        // hacks like
        // free cameras or monster views can be done.
        SetupFrame(player);

        /*
         * Uncommenting this will result in a very existential experience if
         * (Math.random()>0.999){ thinker_t shit=P.getRandomThinker(); try {
         * mobj_t crap=(mobj_t)shit; player.mo=crap; } catch (ClassCastException
         * e){ } }
         */

        // Clear buffers.
        MyBSP.ClearClipSegs();
        seg_vars.ClearDrawSegs();
        vp_vars.ClearPlanes();
        MySegs.ClearClips();
        VIS.ClearSprites();
        // Check for new console commands.
        DGN.NetUpdate();

        // The head node is the last node output.
        MyBSP.RenderBSPNode(LL.numnodes - 1);

        // System.out.printf("Submitted %d RWIs\n",RWIcount);

        MySegs.CompleteRendering();

        // Check for new console commands.
        DGN.NetUpdate();

        // "Warped floor" fixed, same-height visplane merging fixed.
        MyPlanes.DrawPlanes();

        // Check for new console commands.
        DGN.NetUpdate();

        MySegs.sync();
        MyPlanes.sync();

//            drawsegsbarrier.await();
//            visplanebarrier.await();


        MyThings.DrawMasked();

        // RenderRMIPipeline();
        /*
         * try { maskedbarrier.await(); } catch (Exception e) {
         * e.printStackTrace(); }
         */

        // Check for new console commands.
        DGN.NetUpdate();
    }

    public static final class Indexed
            extends ParallelRenderer<byte[], byte[]> {

        public Indexed(DoomMain<byte[], byte[]> DM, int wallthread,
                int floorthreads, int nummaskedthreads) {
            super(DM, wallthread, floorthreads, nummaskedthreads);

            // Init light levels
            colormaps.scalelight = new byte[LIGHTLEVELS][MAXLIGHTSCALE][];
            colormaps.scalelightfixed = new byte[MAXLIGHTSCALE][];
            colormaps.zlight = new byte[LIGHTLEVELS][MAXLIGHTZ][];
            
            completeInit();
        
        }
        
        /**
         * R_InitColormaps
         * 
         * @throws IOException
         */
        protected void InitColormaps() throws IOException {
            int lump, length;

            // Load in the light tables,
            // 256 byte align tables.
            lump = W.GetNumForName("COLORMAP");
            length = W.LumpLength(lump) + 256;
            colormaps.colormaps = new byte[(length / 256)][256];
            System.out.println("Colormaps: " + colormaps.colormaps.length);

            byte[] tmp = new byte[length];
            W.ReadLump(lump,tmp);

            for (int i = 0; i < colormaps.colormaps.length; i++) {
                System.arraycopy(tmp, i * 256, colormaps.colormaps[i], 0, 256);
            }
            
            // MAES: blurry effect is hardcoded to this colormap.
            BLURRY_MAP=colormaps.colormaps[6];
            // colormaps = (byte *)( ((int)colormaps + 255)&~0xff);     

            
        }

 protected void R_InitDrawingFunctions(){            
            
            // Span functions. Common to all renderers unless overriden
            // or unused e.g. parallel renderers ignore them.
            DrawSpan=new R_DrawSpanUnrolled.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            DrawSpanLow=new R_DrawSpanLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            
            
            // Translated columns are usually sprites-only.
            DrawTranslatedColumn=new R_DrawTranslatedColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTranslatedColumnLow=new R_DrawTranslatedColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
          //  DrawTLColumn=new R_DrawTLColumn(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Fuzzy columns. These are also masked.
            DrawFuzzColumn=new R_DrawFuzzColumn.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I,BLURRY_MAP);
            DrawFuzzColumnLow=new R_DrawFuzzColumnLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I,BLURRY_MAP);
            
            // Regular draw for solid columns/walls. Full optimizations.
            DrawColumn=new R_DrawColumnBoomOpt.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            DrawColumnLow=new R_DrawColumnBoomOptLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            
            // Non-optimized stuff for masked.
            DrawColumnMasked=new R_DrawColumnBoom.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawColumnMaskedLow=new R_DrawColumnBoomLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Player uses masked
            DrawColumnPlayer=DrawColumnMasked; // Player normally uses masked.
            
            // Skies use their own. This is done in order not to stomp parallel threads.
            
            DrawColumnSkies=new R_DrawColumnBoomOpt.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            DrawColumnSkiesLow=new R_DrawColumnBoomOptLow.Indexed(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            
            super.R_InitDrawingFunctions();
        }
        
        protected void InitMaskedWorkers() {
            for (int i = 0; i < NUMMASKEDTHREADS; i++) {
                maskedworkers[i] =
                    new MaskedWorker.Indexed(this, i, SCREENWIDTH,
                            SCREENHEIGHT, ylookup, columnofs, NUMMASKEDTHREADS,
                            screen, maskedbarrier, BLURRY_MAP);
                detailaware.add(maskedworkers[i]);
                // "Peg" to sprite manager.
                maskedworkers[i].cacheSpriteManager(SM);
            }
        }

		@Override
		public RenderWallExecutor<byte[], byte[]>[] InitRWIExecutors(
				int num,ColVars<byte[], byte[]>[] RWI) {
				RenderWallExecutor<byte[],byte[]>[] tmp=
						new RenderWallExecutor.Indexed[num];
				
				for (int i=0;i<num;i++)
					tmp[i]=new RenderWallExecutor.Indexed(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup, screen, RWI, drawsegsbarrier);
			
				return tmp;
		}

    }

    @Override
    protected void InitParallelStuff() {


    	// ...yeah, it works.
    	if (!(RWIs==null)){ 
    		ColVars<T,V>[] RWI=RWIs.getRWI();
    		RenderWallExecutor<T,V>[] RWIExec=InitRWIExecutors(NUMWALLTHREADS,RWI);
    		RWIs.setExecutors(RWIExec);
    		
            for (int i = 0; i < NUMWALLTHREADS; i++) {
            	
                detailaware.add(RWIExec[i]);
            }
    		}
    		
    	
        // CATCH: this must be executed AFTER screen is set, and
        // AFTER we initialize the RWI themselves,
        // before V is set (right?)

    	
        // This actually only creates the necessary arrays and
        // barriers. Things aren't "wired" yet.

        // Using "render wall instruction" subsystem

        // Using masked sprites
       // RMIExec = new RenderMaskedExecutor[NUMMASKEDTHREADS];

        // Using
        //vpw = new Runnable[NUMFLOORTHREADS];
        //maskedworkers = new MaskedWorker.Indexed[NUMMASKEDTHREADS];






        // RWIcount = 0;

        // InitRWISubsystem();
        // InitRMISubsystem();
        // InitPlaneWorkers();
        // InitMaskedWorkers();

        // If using masked threads, set these too.
        TexMan.setSMPVars(NUMMASKEDTHREADS);

    }

    /*
     * private void InitPlaneWorkers(){ for (int i = 0; i < NUMFLOORTHREADS;
     * i++) { vpw[i] = new VisplaneWorker2(i,SCREENWIDTH, SCREENHEIGHT,
     * columnofs, ylookup, screen, visplanebarrier, NUMFLOORTHREADS);
     * //vpw[i].id = i; detailaware.add((IDetailAware) vpw[i]); } }
     */

    @Override
    public void initScaling() {
    	
    	super.initScaling();
    	

        /*
         * TODO: relay to dependent objects. super.initScaling();
         * ColVars<byte[],byte[]> fake = new ColVars<byte[],byte[]>(); RWI =
         * C2JUtils.createArrayOfObjects(fake, SCREENWIDTH * 3); // Be MUCH more
         * generous with this one. RMI = C2JUtils.createArrayOfObjects(fake,
         * SCREENWIDTH * 6);
         */

    }

    protected abstract void InitMaskedWorkers();

    public static final class HiColor
            extends ParallelRenderer<byte[], short[]> {

        public HiColor(DoomMain<byte[], short[]> DM, int wallthread,
                int floorthreads, int nummaskedthreads) {
            super(DM, wallthread, floorthreads, nummaskedthreads);
            
            // Init light levels
            colormaps.scalelight = new short[LIGHTLEVELS][MAXLIGHTSCALE][];
            colormaps.scalelightfixed = new short[MAXLIGHTSCALE][];
            colormaps.zlight = new short[LIGHTLEVELS][MAXLIGHTZ][];
        }

        protected void InitMaskedWorkers() {
            for (int i = 0; i < NUMMASKEDTHREADS; i++) {
                maskedworkers[i] =
                    new MaskedWorker.HiColor(this, i, SCREENWIDTH,
                            SCREENHEIGHT, ylookup, columnofs, NUMMASKEDTHREADS,
                            screen, maskedbarrier);
                detailaware.add(maskedworkers[i]);
                // "Peg" to sprite manager.
                maskedworkers[i].cacheSpriteManager(SM);
            }
        }

        /**
         * R_InitColormaps This is VERY different for hicolor.
         * 
         * @throws IOException
         */
        protected void InitColormaps()
                throws IOException {

            colormaps.colormaps = V.getColorMaps();
            System.out.println("COLORS15 Colormaps: "
                    + colormaps.colormaps.length);

            // MAES: blurry effect is hardcoded to this colormap.
            // Pointless, since we don't use indexes. Instead, a half-brite
            // processing works just fine.
            BLURRY_MAP = null;// colormaps[0];
        }
        
        protected void R_InitDrawingFunctions(){            
            
            // Span functions. Common to all renderers unless overriden
            // or unused e.g. parallel renderers ignore them.
            DrawSpan=new R_DrawSpanUnrolled.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            DrawSpanLow=new R_DrawSpanLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            
            
            // Translated columns are usually sprites-only.
            DrawTranslatedColumn=new R_DrawTranslatedColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTranslatedColumnLow=new R_DrawTranslatedColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTLColumn=new R_DrawTLColumn(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Fuzzy columns. These are also masked.
            DrawFuzzColumn=new R_DrawFuzzColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawFuzzColumnLow=new R_DrawFuzzColumnLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Regular draw for solid columns/walls. Full optimizations.
            DrawColumn=new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            DrawColumnLow=new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            
            // Non-optimized stuff for masked.
            DrawColumnMasked=new R_DrawColumnBoom.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawColumnMaskedLow=new R_DrawColumnBoomLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Player uses masked
            DrawColumnPlayer=DrawColumnMasked; // Player normally uses masked.
            
            // Skies use their own. This is done in order not to stomp parallel threads.
            
            DrawColumnSkies=new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            DrawColumnSkiesLow=new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            
            super.R_InitDrawingFunctions();
        }

		@Override
		public RenderWallExecutor<byte[], short[]>[] InitRWIExecutors(
				int num,ColVars<byte[], short[]>[] RWI) {
				RenderWallExecutor<byte[],short[]>[] tmp=
						new RenderWallExecutor.HiColor[num];
				
				for (int i=0;i<num;i++)
					tmp[i]=new RenderWallExecutor.HiColor(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup, screen, RWI, drawsegsbarrier);
			
				return tmp;
		}

    }

    public static final class TrueColor
            extends ParallelRenderer<byte[], int[]> {

        public TrueColor(DoomMain<byte[], int[]> DM, int wallthread,
                int floorthreads, int nummaskedthreads) {
            super(DM, wallthread, floorthreads, nummaskedthreads);
            
            // Init light levels
            colormaps.scalelight = new int[LIGHTLEVELS][MAXLIGHTSCALE][];
            colormaps.scalelightfixed = new int[MAXLIGHTSCALE][];
            colormaps.zlight = new int[LIGHTLEVELS][MAXLIGHTZ][];
        }
        
  protected void R_InitDrawingFunctions(){            
            
            // Span functions. Common to all renderers unless overriden
            // or unused e.g. parallel renderers ignore them.
            DrawSpan=new R_DrawSpanUnrolled.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            DrawSpanLow=new R_DrawSpanLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dsvars,screen,I);
            
            
            // Translated columns are usually sprites-only.
            DrawTranslatedColumn=new R_DrawTranslatedColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawTranslatedColumnLow=new R_DrawTranslatedColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            //DrawTLColumn=new R_DrawTLColumn(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Fuzzy columns. These are also masked.
            DrawFuzzColumn=new R_DrawFuzzColumn.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawFuzzColumnLow=new R_DrawFuzzColumnLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Regular draw for solid columns/walls. Full optimizations.
            DrawColumn=new R_DrawColumnBoomOpt.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            DrawColumnLow=new R_DrawColumnBoomOptLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,dcvars,screen,I);
            
            // Non-optimized stuff for masked.
            DrawColumnMasked=new R_DrawColumnBoom.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            DrawColumnMaskedLow=new R_DrawColumnBoomLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I);
            
            // Player uses masked
            DrawColumnPlayer=DrawColumnMasked; // Player normally uses masked.
            
            // Skies use their own. This is done in order not to stomp parallel threads.
            
            DrawColumnSkies=new R_DrawColumnBoomOpt.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            DrawColumnSkiesLow=new R_DrawColumnBoomOptLow.TrueColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,skydcvars,screen,I);
            
            super.R_InitDrawingFunctions();
        }

        /**
         * R_InitColormaps This is VERY different for hicolor.
         * 
         * @throws IOException
         */
        protected void InitColormaps()
                throws IOException {

            colormaps.colormaps = V.getColorMaps();
            System.out.println("COLORS15 Colormaps: "
                    + colormaps.colormaps.length);

            // MAES: blurry effect is hardcoded to this colormap.
            // Pointless, since we don't use indexes. Instead, a half-brite
            // processing works just fine.
            BLURRY_MAP = null;// colormaps[0];
        }
        
        protected void InitMaskedWorkers() {
            for (int i = 0; i < NUMMASKEDTHREADS; i++) {
                maskedworkers[i] =
                    new MaskedWorker.TrueColor(this,i, SCREENWIDTH, SCREENHEIGHT,
                            ylookup, columnofs, NUMMASKEDTHREADS, screen,
                            maskedbarrier);
                detailaware.add(maskedworkers[i]);
                // "Peg" to sprite manager.
                maskedworkers[i].cacheSpriteManager(SM);
            }
        }
        
		@Override
		public RenderWallExecutor<byte[], int[]>[] InitRWIExecutors(
				int num,ColVars<byte[], int[]>[] RWI) {
			RenderWallExecutor<byte[],int[]>[] tmp=
					new RenderWallExecutor.TrueColor[num];
			
			for (int i=0;i<num;i++)
				tmp[i]=new RenderWallExecutor.TrueColor(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup, screen, RWI, drawsegsbarrier);
		
			return tmp;
		}

    }

}

package rr.parallel;

import static data.Limits.*;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executors;

import rr.patch_t;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import doom.DoomMain;
import doom.DoomStatus;
import doom.player_t;

/** This is a second attempt at building a seg-focused parallel renderer, instead of
 * column-based. It does function, but is broken and has unsolved data dependencies.
 * It's therefore not used in official releases, and I chose to deprecate it.
 * If you still want to develop it, be my guest.
 * 
 * @author velktron
 *
 */

public class ParallelRenderer2 extends AbstractParallelRenderer {
    
    public ParallelRenderer2(DoomStatus DS, int wallthread, int floorthreads,int nummaskedthreads) {

        super(DS,wallthread,floorthreads,nummaskedthreads);
        System.out.println("Parallel Renderer 2 (Seg-based)");
        
        this.MySegs=new ParallelSegs2();
        this.MyPlanes=new ParallelPlanes();
        this.MyThings=new ParallelThings2(); 

    }

	public ParallelRenderer2(DoomStatus DS, int wallthread, int floorthreads) {

		super(DS,wallthread,floorthreads);
		System.out.println("Parallel Renderer 2 (Seg-based)");
		
		this.MySegs=new ParallelSegs2();
		this.MyPlanes=new ParallelPlanes();
		this.MyThings=new ParallelThings2(); 

	}

	/** Default constructor, 2 wall threads and one floor thread.
	 * 
	 * @param DM
	 */
	public ParallelRenderer2(DoomMain DM) {
		this(DM,2,1);
	}

	@Override
	protected void InitParallelStuff() {
		// Prepare parallel stuff
		RSIExec=new RenderSegExecutor[NUMWALLTHREADS];
		tp=   Executors.newFixedThreadPool(NUMWALLTHREADS+NUMFLOORTHREADS);
		// Prepare the barrier for MAXTHREADS + main thread.
		//wallbarrier=new CyclicBarrier(NUMWALLTHREADS+1);
		visplanebarrier=new CyclicBarrier(NUMFLOORTHREADS+NUMWALLTHREADS+1);

		vpw=new VisplaneWorker[NUMFLOORTHREADS];
		
		// Uses "seg" parallel drawer, so RSI.
        InitRSISubsystem();
        
        // Masked workers.
        maskedworkers=new MaskedWorker[NUMMASKEDTHREADS];

        maskedbarrier =
            new CyclicBarrier(NUMMASKEDTHREADS + 1);
        
        InitMaskedWorkers();
        
        // If using masked threads, set these too.
        
        smp_composite=new boolean[NUMMASKEDTHREADS];// = false;
        smp_lasttex=new int[NUMMASKEDTHREADS];// = -1;
        smp_lastlump=new int[NUMMASKEDTHREADS];// = -1;
        smp_lastpatch=new patch_t[NUMMASKEDTHREADS];// = null;
        
	}

	///////////////////////// The actual rendering calls ///////////////////////

	/**
	 * R_RenderView
	 * 
	 * As you can guess, this renders the player view of a particular player object.
	 * In practice, it could render the view of any mobj too, provided you adapt the
	 * SetupFrame method (where the viewing variables are set).
	 * 
	 */

	public void RenderPlayerView (player_t player)
	{   

		// Viewing variables are set according to the player's mobj. Interesting hacks like
		// free cameras or monster views can be done.
		SetupFrame (player);



		/* Uncommenting this will result in a very existential experience
  if (Math.random()>0.999){
	  thinker_t shit=P.getRandomThinker();
	  try {
	  mobj_t crap=(mobj_t)shit;
	  player.mo=crap;
	  } catch (ClassCastException e){

	  }
  	}*/

		// Clear buffers. 
		MyBSP.ClearClipSegs ();
		MyBSP.ClearDrawSegs ();
		MyPlanes.ClearPlanes ();
		MySegs.ClearClips();
		VIS.ClearSprites ();

		// Check for new console commands.
		DGN.NetUpdate ();

		// The head node is the last node output.
		MyBSP.RenderBSPNode (LL.numnodes-1);
		
		RenderRSIPipeline();
		// Check for new console commands.
		DGN.NetUpdate ();

		// "Warped floor" fixed, same-height visplane merging fixed.
		MyPlanes.DrawPlanes ();

		try {
			visplanebarrier.await();
		} catch (Exception e){
			e.printStackTrace();
		}



		// Check for new console commands.
		DGN.NetUpdate ();

		MyThings.DrawMasked ();

		colfunc=basecolfunc;

		// Check for new console commands.
		DGN.NetUpdate ();           
	}

	/**
	 * R_Init
	 */

	//public int  detailLevel;
	//public int  screenblocks=9; // has defa7ult

	public void Init ()

	{
		// Any good reason for this to be here?
		//drawsegs=new drawseg_t[MAXDRAWSEGS];
		//C2JUtils.initArrayOfObjects(drawsegs);

		// DON'T FORGET ABOUT MEEEEEE!!!11!!!
		this.screen=V.getScreen(DoomVideoRenderer.SCREEN_FG);

		System.out.print("\nR_InitData");
		InitData ();
		//InitPointToAngle ();
		System.out.print("\nR_InitPointToAngle");

		// ds.DM.viewwidth / ds.viewheight / detailLevel are set by the defaults
		System.out.print ("\nR_InitTables");
		InitTables ();

		SetViewSize (DM.M.getScreenBlocks(), DM.M.getDetailLevel());

		System.out.print ("\nR_InitPlanes");
		MyPlanes.InitPlanes ();

		System.out.print("\nR_InitLightTables");
		InitLightTables ();

		System.out.print("\nR_InitSkyMap: "+TexMan.InitSkyMap ());

		System.out.print("\nR_InitTranslationsTables");
		InitTranslationTables ();
		
        System.out.print("\nR_InitParallelStuff: ");
        InitParallelStuff();

		System.out.print("\nR_InitTranMap: ");
		R_InitTranMap(0);
		
		System.out.print("\nR_InitDrawingFunctions: ");
        R_InitDrawingFunctions();       		

		framecount = 0;
	}

	@Override
	public void initScaling(){
		super.initScaling();
		this.RSI=new RenderSegInstruction[MAXSEGS*3];
		C2JUtils.initArrayOfObjects(RSI);
		}


}

package rr.parallel;

import static data.Tables.finetangent;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedMul;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import data.Tables;
import doom.DoomStatus;

import rr.PlaneDrawer;
import rr.Renderer;
import rr.RendererState;
import rr.drawfuns.ColVars;
import utils.C2JUtils;

/**
 * Features and functionality which is common among parallel renderers
 * 
 * @author velktron
 */

public abstract class AbstractParallelRenderer<T, V>
        extends RendererState<T, V> implements RWI.Init<T, V>{

    public AbstractParallelRenderer(DoomStatus<T, V> DS, int wallthread,
            int floorthreads, int nummaskedthreads) {
        super(DS);
        this.NUMWALLTHREADS = wallthread;
        this.NUMFLOORTHREADS = floorthreads;
        this.NUMMASKEDTHREADS = nummaskedthreads;
        // Prepare the barriers for MAXTHREADS + main thread.
        drawsegsbarrier = new CyclicBarrier(NUMWALLTHREADS + 1);
        visplanebarrier = new CyclicBarrier(NUMFLOORTHREADS + 1);        
        maskedbarrier = new CyclicBarrier(NUMMASKEDTHREADS + 1);
        tp = Executors.newCachedThreadPool();

    }

    public AbstractParallelRenderer(DoomStatus<T, V> DS, int wallthread,
            int floorthreads) {
        super(DS);
        this.NUMWALLTHREADS = wallthread;
        this.NUMFLOORTHREADS = floorthreads;
        this.NUMMASKEDTHREADS = 1;
        // Prepare the barriers for MAXTHREADS + main thread.
        drawsegsbarrier = new CyclicBarrier(NUMWALLTHREADS + 1);
        visplanebarrier = new CyclicBarrier(NUMFLOORTHREADS + 1);        
        maskedbarrier = new CyclicBarrier(NUMMASKEDTHREADS + 1);
        tp = Executors.newCachedThreadPool();
    }

    // //////// PARALLEL OBJECTS /////////////
    protected final int NUMWALLTHREADS;

    protected final int NUMMASKEDTHREADS;

    protected final int NUMFLOORTHREADS;

    protected Executor tp;

    protected Runnable[] vpw;

    protected MaskedWorker<T, V>[] maskedworkers;

    protected CyclicBarrier drawsegsbarrier;

    protected CyclicBarrier visplanebarrier;

    protected CyclicBarrier maskedbarrier;

    protected static final boolean DEBUG = false;

    protected final class ParallelSegs
            extends SegDrawer implements RWI.Get<T,V>{

        public ParallelSegs(Renderer<?, ?> R) {
            super(R);
        }

        /**
         * Parallel version. Since there's so much crap to take into account
         * when rendering, the number of walls to render is unknown a-priori and
         * the BSP trasversal itself is not worth parallelizing, it makes more
         * sense to store "rendering instructions" as quickly as the BSP can be
         * transversed, and then execute those in parallel. Also saves on having
         * to duplicate way too much status.
         */

        @Override
        protected final void CompleteColumn() {

            // Don't wait to go over
            if (RWIcount >= RWI.length) {
                ResizeRWIBuffer();
            }

            // A deep copy is still necessary, as dc
            RWI[RWIcount].copyFrom(dcvars);

            // We only need to point to the next one in the list.
            RWIcount++;
        }

        /**
         * Starts the RenderWallExecutors. Sync is EXTERNAL, however.
         */

        @Override
        public void CompleteRendering() {

            for (int i = 0; i < NUMWALLTHREADS; i++) {

                RWIExec[i].setRange((i * RWIcount) / NUMWALLTHREADS,
                    ((i + 1) * RWIcount) / NUMWALLTHREADS);
                // RWIExec[i].setRange(i%NUMWALLTHREADS,RWIcount,NUMWALLTHREADS);
                tp.execute(RWIExec[i]);
            }

            // System.out.println("RWI count"+RWIcount);
            RWIcount = 0;
        }

        /*
         * Just what are "RWIs"? Stored wall rendering instructions. They can be
         * at most 3*SCREENWIDTH (if there are low, mid and high textures on
         * every column of the screen) Remember to init them and set screen and
         * ylookup for all of them. Their max number is static and work
         * partitioning can be done in any way, as long as you keep track of how
         * many there are in any given frame. This value is stored inside
         * RWIcount. TODO: there are cases when more than 3*SCREENWIDTH
         * instructions need to be stored. therefore we really need a resizeable
         * array here, but ArrayList is way too slow for our needs. Storing a
         * whole wall is not an option, as, once again, a wall may have a
         * variable number of columns and an irregular height profile -> we'd
         * need to look into visplanes ugh...
         */

        protected RenderWallExecutor<T, V>[] RWIExec;

        /** Array of "wall" (actually, column) instructions */

        protected ColVars<T, V>[] RWI;

        /**
         * Increment this as you submit RWIs to the "queue". Remember to reset
         * to 0 when you have drawn everything!
         */

        protected int RWIcount = 0;

        /**
         * Resizes RWI buffer, updates executors. Sorry for the hackish
         * implementation but ArrayList and pretty much everything in
         * Collections is way too slow for what we're trying to accomplish.
         */

        protected final void ResizeRWIBuffer() {
            ColVars<T, V> fake = new ColVars<T, V>();

            // Bye bye, old RWI.
            RWI = C2JUtils.resize(fake, RWI, RWI.length * 2);

            for (int i = 0; i < NUMWALLTHREADS; i++) {
                RWIExec[i].updateRWI(RWI);
            }
            // System.err.println("RWI Buffer resized. Actual capacity " +
            // RWI.length);
        }
        
        /**
         * R_InitRWISubsystem Initialize RWIs and RWI Executors. Pegs them to
         * the RWI, ylookup and screen[0].
         */

        public void initScaling() {
        	super.initScaling();
        	ColVars<T,V> fake=new ColVars<T,V>();
        	RWI=C2JUtils.createArrayOfObjects(fake, 3*SCREENWIDTH);

        }

		@Override
		public ColVars<T, V>[] getRWI() {
			return RWI;
		}

		@Override
		public void setExecutors(RenderWallExecutor<T, V>[] RWIExec) {
			this.RWIExec=RWIExec;
			
		}
		
		public void sync(){
			try {
				drawsegsbarrier.await();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
    }

    protected final class ParallelPlanes<T, V>
            extends PlaneDrawer<T, V> {

        protected ParallelPlanes(Renderer<T, V> R) {
            super(R);
        }

        /**
         * R_DrawPlanes At the end of each frame. This also means that visplanes
         * must have been set BEFORE we called this function. Therefore, look
         * for errors behind.
         * 
         * @throws IOException
         */
        public void DrawPlanes() {

            if (RANGECHECK) {
                rangeCheckErrors();
            }

            // vpw[0].setRange(0,lastvisplane/2);
            // vpw[1].setRange(lastvisplane/2,lastvisplane);

            for (int i = 0; i < NUMFLOORTHREADS; i++)
                tp.execute(vpw[i]);
        }

    } // End Plane class

    protected final class ParallelSegs2
            extends SegDrawer {

        /**
         * RenderSeg subsystem. Similar concept to RWI, but stores
         * "Render Seg Instructions" instead. More complex to build, but
         * potentially faster in some situations, as it allows distributing load
         * per-wall, rather than per-screen portion. Requires careful
         * concurrency considerations.
         */
        protected RenderSegInstruction<V>[] RSI;

        /**
         * Increment this as you submit RSIs to the "queue". Remember to reset
         * to 0 when you have drawn everything!
         */
        protected int RSIcount = 0;

        protected RenderSegExecutor<byte[], V>[] RSIExec;

        public ParallelSegs2(Renderer<?, ?> R) {
            super(R);
        }

        @Override
        protected void RenderSegLoop() {
            int angle;
            int yl, top, bottom, yh, mid, texturecolumn = 0;

            // Generate Seg rendering instruction BEFORE the looping start
            // and anything is modified. The loop will be repeated in the
            // threads, but without marking ceilings/floors etc.
            GenerateRSI();

            for (; rw_x < rw_stopx; rw_x++) {
                // mark floor / ceiling areas
                yl = (topfrac + HEIGHTUNIT - 1) >> HEIGHTBITS;

                // no space above wall?
                if (yl < ceilingclip[rw_x] + 1)
                    yl = ceilingclip[rw_x] + 1;

                if (markceiling) {
                    top = ceilingclip[rw_x] + 1;
                    bottom = yl - 1;

                    if (bottom >= floorclip[rw_x])
                        bottom = floorclip[rw_x] - 1;

                    if (top <= bottom) {
                        vp_vars.visplanes[vp_vars.ceilingplane].setTop(rw_x,
                            (char) top);
                        vp_vars.visplanes[vp_vars.ceilingplane].setBottom(rw_x,
                            (char) bottom);
                    }
                }

                yh = bottomfrac >> HEIGHTBITS;

                if (yh >= floorclip[rw_x])
                    yh = floorclip[rw_x] - 1;

                // System.out.printf("Precompute: rw %d yl %d yh %d\n",rw_x,yl,yh);

                // A particular seg has been identified as a floor marker.

                if (markfloor) {
                    top = yh + 1;
                    bottom = floorclip[rw_x] - 1;
                    if (top <= ceilingclip[rw_x])
                        top = ceilingclip[rw_x] + 1;
                    if (top <= bottom) {
                        vp_vars.visplanes[vp_vars.floorplane].setTop(rw_x,
                            (char) top);
                        vp_vars.visplanes[vp_vars.floorplane].setBottom(rw_x,
                            (char) bottom);
                    }
                }

                // texturecolumn and lighting are independent of wall tiers
                if (segtextured) {
                    // calculate texture offset. Still important to do because
                    // of masked

                    angle =
                        Tables.toBAMIndex(rw_centerangle
                                + (int) xtoviewangle[rw_x]);
                    texturecolumn =
                        rw_offset - FixedMul(finetangent[angle], rw_distance);
                    texturecolumn >>= FRACBITS;
                }

                // Don't to any drawing, only compute bounds.
                if (midtexture != 0) {

                    dcvars.dc_source =
                        TexMan.GetCachedColumn(midtexture, texturecolumn);
                    // dc_m=dcvars.dc_source_ofs;
                    // single sided line
                    ceilingclip[rw_x] = (short) view.height;
                    floorclip[rw_x] = -1;
                } else {
                    // two sided line
                    if (toptexture != 0) {
                        // top wall
                        mid = pixhigh >> HEIGHTBITS;
                        pixhigh += pixhighstep;

                        if (mid >= floorclip[rw_x])
                            mid = floorclip[rw_x] - 1;

                        if (mid >= yl) {
                            dcvars.dc_source =
                                TexMan.GetCachedColumn(toptexture,
                                    texturecolumn);
                            ceilingclip[rw_x] = (short) mid;
                        } else
                            ceilingclip[rw_x] = (short) (yl - 1);
                    } else {
                        // no top wall
                        if (markceiling)
                            ceilingclip[rw_x] = (short) (yl - 1);
                    }

                    if (bottomtexture != 0) {
                        // bottom wall
                        mid = (pixlow + HEIGHTUNIT - 1) >> HEIGHTBITS;
                        pixlow += pixlowstep;

                        // no space above wall?
                        if (mid <= ceilingclip[rw_x])
                            mid = ceilingclip[rw_x] + 1;

                        if (mid <= yh) {
                            dcvars.dc_source =
                                TexMan.GetCachedColumn(bottomtexture,
                                    texturecolumn);
                            floorclip[rw_x] = (short) mid;
                        } else
                            floorclip[rw_x] = (short) (yh + 1);
                    } else {
                        // no bottom wall
                        if (markfloor)
                            floorclip[rw_x] = (short) (yh + 1);
                    }

                    if (maskedtexture) {
                        // save texturecol
                        // for backdrawing of masked mid texture
                        seg_vars.maskedtexturecol[seg_vars.pmaskedtexturecol
                                + rw_x] = (short) texturecolumn;
                    }
                }

                rw_scale += rw_scalestep;
                topfrac += topstep;
                bottomfrac += bottomstep;
            }
        }

        protected final void GenerateRSI() {

            if (RSIcount >= RSI.length) {
                ResizeRSIBuffer();
            }

            RenderSegInstruction<V> rsi = RSI[RSIcount];
            rsi.centery = view.centery;
            rsi.bottomfrac = bottomfrac;
            rsi.bottomstep = bottomstep;
            rsi.bottomtexture = bottomtexture;
            rsi.markceiling = markceiling;
            rsi.markfloor = markfloor;
            rsi.midtexture = midtexture;
            rsi.pixhigh = pixhigh;
            rsi.pixhighstep = pixhighstep;
            rsi.pixlow = pixlow;
            rsi.pixlowstep = pixlowstep;
            rsi.rw_bottomtexturemid = rw_bottomtexturemid;
            rsi.rw_centerangle = rw_centerangle;
            rsi.rw_distance = rw_distance;
            rsi.rw_midtexturemid = rw_midtexturemid;
            rsi.rw_offset = rw_offset;
            rsi.rw_scale = rw_scale;
            rsi.rw_scalestep = rw_scalestep;
            rsi.rw_stopx = rw_stopx;
            rsi.rw_toptexturemid = rw_toptexturemid;
            rsi.rw_x = rw_x;
            rsi.segtextured = segtextured;
            rsi.topfrac = topfrac;
            rsi.topstep = topstep;
            rsi.toptexture = toptexture;
            rsi.walllights = colormaps.walllights;
            rsi.viewheight = view.height;
            // rsi.floorplane=floorplane;
            // rsi.ceilingplane=ceilingplane;
            RSIcount++;
        }

        @Override
        protected void CompleteColumn() {
            // TODO Auto-generated method stub

        }

        protected void RenderRSIPipeline() {

            for (int i = 0; i < NUMWALLTHREADS; i++) {
                RSIExec[i].setRSIEnd(RSIcount);
                // RWIExec[i].setRange(i%NUMWALLTHREADS,RWIcount,NUMWALLTHREADS);
                tp.execute(RSIExec[i]);
            }

            // System.out.println("RWI count"+RWIcount);
            RSIcount = 0;
        }

        /**
         * Resizes RWI buffer, updates executors. Sorry for the hackish
         * implementation but ArrayList and pretty much everything in
         * Collections is way too slow for what we're trying to accomplish.
         */

        protected void ResizeRSIBuffer() {

            RenderSegInstruction<V> fake = new RenderSegInstruction<V>();
            // Bye bye, old RSI.
            RSI = C2JUtils.resize(fake, RSI, RSI.length * 2);

            for (int i = 0; i < NUMWALLTHREADS; i++) {
                RSIExec[i].updateRSI(RSI);
            }

            System.out.println("RWI Buffer resized. Actual capacity "
                    + RSI.length);
        }

    }

    protected final class ParallelPlanes2<T, V>
            extends PlaneDrawer<T, V> {

        protected ParallelPlanes2(Renderer<T, V> R) {
            super(R);
        }

        /**
         * R_DrawPlanes At the end of each frame. This also means that visplanes
         * must have been set BEFORE we called this function. Therefore, look
         * for errors behind.
         * 
         * @throws IOException
         */
        public void DrawPlanes() {

            if (RANGECHECK) {
                rangeCheckErrors();
            }

            // vpw[0].setRange(0,lastvisplane/2);
            // vpw[1].setRange(lastvisplane/2,lastvisplane);

            for (int i = 0; i < NUMFLOORTHREADS; i++)
                tp.execute(vpw[i]);
        }

    } // End Plane class

    // / RWI SUBSYSTEM
    // / AKA "Render Wall Instruction": instructions that store only a single
    // column
    // from a wall

    /**
     * R_InitRSISubsystem Initialize RSIs and RSI Executors. Pegs them to the
     * RSI, ylookup and screen[0].
     */

    // protected abstract void InitRSISubsystem();

    /*
     * { // CATCH: this must be executed AFTER screen is set, and // AFTER we
     * initialize the RWI themselves, // before V is set (right?) //offsets=new
     * int[NUMWALLTHREADS]; for (int i=0;i<NUMWALLTHREADS;i++){ RSIExec[i]=new
     * RenderSegExecutor.HiColor( SCREENWIDTH, SCREENHEIGHT, i, screen, this,
     * TexMan, RSI, MySegs.getBLANKCEILINGCLIP(), MySegs.getBLANKFLOORCLIP(),
     * MySegs.getCeilingClip(), MySegs.getFloorClip(), columnofs, xtoviewangle,
     * ylookup, this.visplanes, this.visplanebarrier);
     * RSIExec[i].setVideoScale(this.vs); RSIExec[i].initScaling(); // Each
     * SegExecutor sticks to its own half (or 1/nth) of the screen.
     * RSIExec[i].setScreenRange
     * (i*(SCREENWIDTH/NUMWALLTHREADS),(i+1)*(SCREENWIDTH/NUMWALLTHREADS));
     * detailaware.add(RSIExec[i]); } for (int i=0;i<NUMFLOORTHREADS;i++){
     * vpw[i]=new VisplaneWorker(i,SCREENWIDTH,SCREENHEIGHT,columnofs,ylookup,
     * screen,visplanebarrier,NUMFLOORTHREADS); detailaware.add((IDetailAware)
     * vpw[i]); } }
     */

    /** Creates RMI Executors */

    // protected abstract void InitRMISubsystem();

    /*
     * { for (int i = 0; i < NUMMASKEDTHREADS; i++) { // Each masked executor
     * gets its own set of column functions. RMIExec[i] = new
     * RenderMaskedExecutor(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup,
     * screen, RMI, maskedbarrier, // Regular masked columns new
     * R_DrawColumnBoom
     * (SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I), new
     * R_DrawColumnBoomLow
     * (SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I), //
     * Fuzzy columns new
     * R_DrawFuzzColumn.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup
     * ,columnofs,maskedcvars,screen,I), new
     * R_DrawFuzzColumnLow.HiColor(SCREENWIDTH
     * ,SCREENHEIGHT,ylookup,columnofs,maskedcvars,screen,I), // Translated
     * columns new
     * R_DrawTranslatedColumn(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs
     * ,maskedcvars,screen,I), new
     * R_DrawTranslatedColumnLow(SCREENWIDTH,SCREENHEIGHT
     * ,ylookup,columnofs,maskedcvars,screen,I) ); detailaware.add(RMIExec[i]);
     * } }
     */

    public void Init(){
    	super.Init();
    	InitParallelStuff();
    }
    
    /**
     * Any scaling and implementation-specific stuff to do for parallel stuff
     * should go here. This method is called internally by the public Init().
     * The idea is that the renderer should be up & running after you finally
     * called this.
     */
    protected abstract void InitParallelStuff();
    
    /** Override this in one of the final implementors, if you want it to work */
    
    public RenderWallExecutor<T,V>[] InitRWIExecutors(int num,ColVars<T,V>[] RWI){
    	return null;
    }
    RWI.Get<T,V> RWIs;
    
}

package rr.parallel;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import rr.IDetailAware;
import rr.drawfuns.ColVars;
import rr.drawfuns.DoomColumnFunction;

import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;

/**
 * This is what actual executes the RenderWallInstruction. Essentially it's a
 * self-contained column rendering function.
 * 
 * @author admin
 */

public class RenderWallExecutor<T,V>
        implements Runnable,IDetailAware {

    protected CyclicBarrier barrier;

    protected ColVars<T,V>[] RWI;

    protected int start, end;

    protected DoomColumnFunction<T,V> colfunchi, colfunclow;

    protected DoomColumnFunction<T,V> colfunc;

    public RenderWallExecutor(int SCREENWIDTH, int SCREENHEIGHT,
            int[] columnofs, int[] ylookup, V screen,
            ColVars<T,V>[] RWI, CyclicBarrier barrier) {
        this.RWI = RWI;
        this.barrier = barrier;
        this.SCREENWIDTH = SCREENWIDTH;
        this.SCREENHEIGHT = SCREENHEIGHT;

    }

    public void setRange(int start, int end) {
        this.end = end;
        this.start = start;
    }

    public void setDetail(int detailshift) {
        if (detailshift == 0)
            colfunc = colfunchi;
        else
            colfunc = colfunclow;
    }

    public void run() {

        // System.out.println("Wall executor from "+start +" to "+ end);

        for (int i = start; i < end; i++) {
            colfunc.invoke(RWI[i]);
        }

        try {
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public void updateRWI(ColVars<T,V>[] RWI) {
        this.RWI = RWI;

    }

    /////////////// VIDEO SCALE STUFF//////////////////////

    protected final int SCREENWIDTH;

    protected final int SCREENHEIGHT;
    /*
     * protected IVideoScale vs;
     * @Override public void setVideoScale(IVideoScale vs) { this.vs=vs; }
     * @Override public void initScaling() {
     * this.SCREENHEIGHT=vs.getScreenHeight();
     * this.SCREENWIDTH=vs.getScreenWidth(); }
     */

    public static final class HiColor extends RenderWallExecutor<byte[],short[]> {

        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int[] columnofs,
                int[] ylookup, short[] screen,
                ColVars<byte[], short[]>[] RWI, CyclicBarrier barrier) {
            super(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup, screen, RWI, barrier);
            colfunc =
                colfunchi =
                    new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH, SCREENHEIGHT, ylookup,
                            columnofs, null, screen, null);
            colfunclow =
                new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH, SCREENHEIGHT, ylookup,
                        columnofs, null, screen, null);
        }
        
    }
    
    public static final class Indexed extends RenderWallExecutor<byte[],byte[]> {

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int[] columnofs,
                int[] ylookup, byte[] screen,
                ColVars<byte[], byte[]>[] RWI, CyclicBarrier barrier) {
            super(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup, screen, RWI, barrier);
            colfunc =
                colfunchi =
                    new R_DrawColumnBoomOpt.Indexed(SCREENWIDTH, SCREENHEIGHT, ylookup,
                            columnofs, null, screen, null);
            colfunclow =
                new R_DrawColumnBoomOptLow.Indexed(SCREENWIDTH, SCREENHEIGHT, ylookup,
                        columnofs, null, screen, null);
        }
        
    }
    
    public static final class TrueColor extends RenderWallExecutor<byte[],int[]> {

        public TrueColor(int SCREENWIDTH, int SCREENHEIGHT, int[] columnofs,
                int[] ylookup, int[] screen,
                ColVars<byte[], int[]>[] RWI, CyclicBarrier barrier) {
            super(SCREENWIDTH, SCREENHEIGHT, columnofs, ylookup, screen, RWI, barrier);
            colfunc =
                colfunchi =
                    new R_DrawColumnBoomOpt.TrueColor(SCREENWIDTH, SCREENHEIGHT, ylookup,
                            columnofs, null, screen, null);
            colfunclow =
                new R_DrawColumnBoomOptLow.TrueColor(SCREENWIDTH, SCREENHEIGHT, ylookup,
                        columnofs, null, screen, null);
        }
        
    }
    
}

package rr.parallel;

import rr.column_t;

/** An interface used to ease the use of the GetCachedColumn by part
 *  of parallelized renderers.
 *  
 * @author Maes
 *
 */

/**
 * Special version of GetColumn meant to be called concurrently by different
 * seg rendering threads, identfiex by index. This serves to avoid stomping
 * on mutual cached textures and causing crashes.
 * 
 */

public interface IGetSmpColumn {

	column_t GetSmpColumn(int tex, int col,int id);

}

package rr.parallel;

import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;

import rr.AbstractThings;
import rr.IDetailAware;
import rr.Renderer;
import rr.drawfuns.ColVars;
import rr.drawfuns.DcFlags;
import utils.C2JUtils;

/**
 * Parallel Things drawing class, column based, using RMI pipeline.
 * For N threads, each thread only draws those columns of sprites that
 * are in its own 1/N portion of the screen.
 * 
 * Overrides only the terminal drawing methods from things, using a
 * mechanism very similar to column-based wall threading. It's not very
 * efficient, since some of the really heavy parts (such as visibility
 * priority) are still done serially, and actually do take up a lot of the
 * actual rendering time, and the number of columns generated is REALLY
 * enormous (100K+ for something like nuts.wad), and the thing chokes on
 * synchronization, more than anything. The only appropriate thing to do
 * would be to have a per-vissprite renderer, which would actually move much
 * of the brunt work away from the main thread. Some interesting benchmarks
 * on nuts.wad timedemo: Normal things serial renderer: 60-62 fps "Dummy"
 * completeColumns: 72 fps "Dummy" things renderer without final drawing: 80
 * fps "Dummy" things renderer without ANY calculations: 90 fps. This means
 * that even a complete parallelization will likely have a quite limited
 * impact.
 * 
 * @author velktron
 */

public abstract class ParallelThings<T,V>
        extends AbstractThings<T,V> {
    
    // stuff to get from container
    
    
    /** Render Masked Instuction subsystem. Essentially, a way to split sprite work
     *  between threads on a column-basis.
     */

    protected ColVars<T, V>[] RMI;

    /**
     * Increment this as you submit RMIs to the "queue". Remember to reset to 0
     * when you have drawn everything!
     */
    protected int RMIcount = 0;

    protected RenderMaskedExecutor<T,V>[] RMIExec;
    
    protected final int NUMMASKEDTHREADS;
    protected final CyclicBarrier maskedbarrier;
    protected final Executor tp;
    
    public ParallelThings(Renderer<T,V> R,Executor tp, int numthreads){
        super(R);
        this.tp=tp;
        this.NUMMASKEDTHREADS=numthreads;
        this.maskedbarrier=new CyclicBarrier(NUMMASKEDTHREADS+1);
    }

    @Override
    public void DrawMasked() {
        
        // This just generates the RMI instructions.
        super.DrawMasked();
        // This splits the work among threads and fires them up
        RenderRMIPipeline();

        try {
            // Wait for them to be done.
            maskedbarrier.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void completeColumn() {

        if (view.detailshift == 1)
            flags = DcFlags.LOW_DETAIL;
        // Don't wait to go over
        if (RMIcount >= RMI.length) {
            ResizeRMIBuffer();
        }

        // A deep copy is still necessary, as well as setting dc_flags
        RMI[RMIcount].copyFrom(maskedcvars, colfunc.getFlags());

        // We only need to point to the next one in the list.
        RMIcount++;
    }

    int flags;
    
   
    protected void RenderRMIPipeline() {

        for (int i = 0; i < NUMMASKEDTHREADS; i++) {

            RMIExec[i].setRange((i * this.SCREENWIDTH) / NUMMASKEDTHREADS,
                ((i + 1) * this.SCREENWIDTH) / NUMMASKEDTHREADS);
            RMIExec[i].setRMIEnd(RMIcount);
            // RWIExec[i].setRange(i%NUMWALLTHREADS,RWIcount,NUMWALLTHREADS);
            tp.execute(RMIExec[i]);
        }

        // System.out.println("RWI count"+RWIcount);
        RMIcount = 0;
    }
    
    protected void ResizeRMIBuffer() {
        ColVars<T, V> fake = new ColVars<T, V>();
        ColVars<T, V>[] tmp =            // TODO Auto-generated constructor stub
            C2JUtils.createArrayOfObjects(fake, RMI.length * 2);
        System.arraycopy(RMI, 0, tmp, 0, RMI.length);

        // Bye bye, old RMI.
        RMI = tmp;

        for (int i = 0; i < NUMMASKEDTHREADS; i++) {
            RMIExec[i].updateRMI(RMI);
        }
        
        System.err.println("RMI Buffer resized. Actual capacity " + RMI.length);
    }
    
    protected abstract void InitRMISubsystem(int[] columnofs, int[] ylookup,V screen, CyclicBarrier
            maskedbarrier,V BLURRY_MAP, List<IDetailAware> detailaware);
    
    public static class Indexed extends ParallelThings<byte[],byte[]>{

    public Indexed(Renderer<byte[], byte[]> R, Executor tp, int numthreads) {
            super(R, tp, numthreads);
        }

    protected void InitRMISubsystem(int[] columnofs, int[] ylookup,byte[] screen, CyclicBarrier
            maskedbarrier,byte[] BLURRY_MAP, List<IDetailAware> detailaware)    {
        for (int i = 0; i < NUMMASKEDTHREADS; i++) {
            RMIExec[i] =
                new RenderMaskedExecutor.Indexed(SCREENWIDTH, SCREENHEIGHT, columnofs,
                        ylookup, screen, RMI, maskedbarrier,I,BLURRY_MAP);
                
            detailaware.add(RMIExec[i]);
            }
        }
    }
    
    public static class HiColor extends ParallelThings<byte[],short[]>{
        

        public HiColor(Renderer<byte[], short[]> R, Executor tp, int numthreads) {
            super(R, tp, numthreads);
        }

        protected void InitRMISubsystem(int[] columnofs, int[] ylookup,short[] screen, CyclicBarrier
                maskedbarrier,short[] BLURRY_MAP, List<IDetailAware> detailaware)    {
            for (int i = 0; i < NUMMASKEDTHREADS; i++) {
                RMIExec[i] =
                    new RenderMaskedExecutor.HiColor(SCREENWIDTH, SCREENHEIGHT, columnofs,
                            ylookup, screen, RMI, maskedbarrier,I);
                    
                detailaware.add(RMIExec[i]);
                }
            }
        }
    
public static class TrueColor extends ParallelThings<byte[],int[]>{


        public TrueColor(Renderer<byte[], int[]> R, Executor tp, int numthreads) {
        super(R, tp, numthreads);
    }

        protected void InitRMISubsystem(int[] columnofs, int[] ylookup,int[] screen, CyclicBarrier
                maskedbarrier,int[] BLURRY_MAP, List<IDetailAware> detailaware)    {
            for (int i = 0; i < NUMMASKEDTHREADS; i++) {
                RMIExec[i] =
                    new RenderMaskedExecutor.TrueColor(SCREENWIDTH, SCREENHEIGHT, columnofs,
                            ylookup, screen, RMI, maskedbarrier,I);
                    
                detailaware.add(RMIExec[i]);
                }
            }
        }

}

package rr.parallel;

import rr.drawfuns.ColVars;

public interface RWI<T,V> {
	public interface Init<T,V>{
		RenderWallExecutor<T,V>[] InitRWIExecutors(int num,ColVars<T,V>[] RWI);
	}
	
	public interface Get<T,V>{
		ColVars<T,V>[] getRWI();
		void setExecutors(RenderWallExecutor<T,V>[] RWIExec);
	}
}

package rr.parallel;

import static data.Defines.ANGLETOSKYSHIFT;
import static data.Tables.addAngles;
import static m.fixed_t.FRACBITS;
import static rr.LightsAndColors.LIGHTLEVELS;
import static rr.LightsAndColors.LIGHTSEGSHIFT;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import rr.IDetailAware;
import rr.PlaneDrawer;
import rr.Renderer;
import rr.visplane_t;
import rr.drawfuns.ColVars;
import rr.drawfuns.DoomColumnFunction;
import rr.drawfuns.DoomSpanFunction;
import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;
import rr.drawfuns.R_DrawSpanLow;
import rr.drawfuns.R_DrawSpanUnrolled;
import rr.drawfuns.SpanVars;

/** Visplane worker which shares work in an equal-visplane number strategy
 *  with other workers. Might be unbalanced if one worker gets too large
 *  visplanes and others get smaller ones. Balancing strategy is applied in 
 *  run(), otherwise it's practically similar to a PlaneDrwer.
 *  
 *  
 * @author velktron
 *
 */

public abstract class VisplaneWorker<T,V> extends PlaneDrawer<T,V> implements Runnable,IDetailAware{

    // Private to each thread.
    protected final int id;
    protected final int NUMFLOORTHREADS;
    protected final CyclicBarrier barrier;
    
    protected int vpw_planeheight;
    protected V[] vpw_planezlight;
    protected int vpw_basexscale,vpw_baseyscale;

    protected SpanVars<T,V> vpw_dsvars;
    protected ColVars<T,V> vpw_dcvars;
    
    // OBVIOUSLY each thread must have its own span functions.
    protected DoomSpanFunction<T,V> vpw_spanfunc;
    protected DoomColumnFunction<T,V> vpw_skyfunc;
    protected DoomSpanFunction<T,V> vpw_spanfunchi;
    protected DoomSpanFunction<T,V> vpw_spanfunclow;
    protected DoomColumnFunction<T,V> vpw_skyfunchi;
    protected DoomColumnFunction<T,V> vpw_skyfunclow;
        
    public VisplaneWorker(int id,int SCREENWIDTH, int SCREENHEIGHT, Renderer<T,V> R,CyclicBarrier visplanebarrier,int NUMFLOORTHREADS) {
        super(R); 
        this.barrier=visplanebarrier;
        this.id=id;
        this.NUMFLOORTHREADS=NUMFLOORTHREADS;
    }

    public static final class HiColor extends VisplaneWorker<byte[],short[]>{

        public HiColor(int id, int SCREENWIDTH, int SCREENHEIGHT,Renderer<byte[],short[]> R,
                int[] columnofs, int[] ylookup, short[] screen,
                CyclicBarrier visplanebarrier, int NUMFLOORTHREADS) {
            super(id, SCREENWIDTH, SCREENHEIGHT, R,  visplanebarrier, NUMFLOORTHREADS);
            // Alias to those of Planes.


            vpw_dsvars=new SpanVars<byte[],short[]>();
            vpw_dcvars=new ColVars<byte[],short[]>();
            vpw_spanfunc=vpw_spanfunchi=new R_DrawSpanUnrolled.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_spanfunclow=new R_DrawSpanLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_skyfunc=vpw_skyfunchi=new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);
            vpw_skyfunclow=new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH,SCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);
            
        }
        
    }
    
    public void setDetail(int detailshift) {
        if (detailshift == 0){
            vpw_spanfunc = vpw_spanfunchi;
            vpw_skyfunc= vpw_skyfunchi;
        }
        else{
            vpw_spanfunc = vpw_spanfunclow;
            vpw_skyfunc =vpw_skyfunclow;
        }
    }
    
    @Override
    public void run() {
        visplane_t      pln=null; //visplane_t
        // These must override the global ones
        int         light;
        int         x;
        int         stop;
        int         angle;
      
        // Now it's a good moment to set them.
        vpw_basexscale=vpvars.getBaseXScale();
        vpw_baseyscale=vpvars.getBaseYScale();
        
        // TODO: find a better way to split work. As it is, it's very uneven
        // and merged visplanes in particular are utterly dire.
        
        for (int pl= this.id; pl <vpvars.lastvisplane; pl+=NUMFLOORTHREADS) {
             pln=vpvars.visplanes[pl];
            // System.out.println(id +" : "+ pl);
             
         if (pln.minx > pln.maxx)
             continue;

         
         // sky flat
         if (pln.picnum == TexMan.getSkyFlatNum() )
         {
             // Cache skytexture stuff here. They aren't going to change while
             // being drawn, after all, are they?
             int skytexture=TexMan.getSkyTexture();
             // MAES: these must be updated to keep up with screen size changes.
             vpw_dcvars.viewheight=view.height;
             vpw_dcvars.centery=view.centery;
             vpw_dcvars.dc_texheight=TexMan.getTextureheight(skytexture)>>FRACBITS;                 
             vpw_dcvars.dc_iscale = vpvars.getSkyScale()>>view.detailshift;
             
             vpw_dcvars.dc_colormap = colormap.colormaps[0];
             vpw_dcvars.dc_texturemid = TexMan.getSkyTextureMid();
             for (x=pln.minx ; x <= pln.maxx ; x++)
             {
           
                 vpw_dcvars.dc_yl = pln.getTop(x);
                 vpw_dcvars.dc_yh = pln.getBottom(x);
             
             if (vpw_dcvars.dc_yl <= vpw_dcvars.dc_yh)
             {
                 angle = (int) (addAngles(view.angle, view.xtoviewangle[x])>>>ANGLETOSKYSHIFT);
                 vpw_dcvars.dc_x = x;
                 // Optimized: texheight is going to be the same during normal skies drawing...right?
                 vpw_dcvars.dc_source = TexMan.GetCachedColumn(TexMan.getSkyTexture(), angle);
                 vpw_skyfunc.invoke();
             }
             }
             continue;
         }
         
         // regular flat
         vpw_dsvars.ds_source = TexMan.getSafeFlat(pln.picnum);

         vpw_planeheight = Math.abs(pln.height-view.z);
         light = (pln.lightlevel >>> LIGHTSEGSHIFT)+colormap.extralight;

         if (light >= LIGHTLEVELS)
             light = LIGHTLEVELS-1;

         if (light < 0)
             light = 0;

         vpw_planezlight = colormap.zlight[light];

         // We set those values at the border of a plane's top to a "sentinel" value...ok.
         pln.setTop(pln.maxx+1,(char) 0xffff);
         pln.setTop(pln.minx-1, (char) 0xffff);
         
         stop = pln.maxx + 1;

         
         for (x=pln.minx ; x<= stop ; x++) {
          MakeSpans(x,pln.getTop(x-1),
             pln.getBottom(x-1),
             pln.getTop(x),
             pln.getBottom(x));
            }
         
         }
         // We're done, wait.

            try {
                barrier.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

     }
  
      
          
      
      
  }
package rr.parallel;

import static data.Defines.ANGLETOSKYSHIFT;
import static data.Defines.PU_STATIC;
import static data.Tables.ANGLETOFINESHIFT;
import static data.Tables.BITS32;
import static data.Tables.addAngles;
import static data.Tables.finecosine;
import static data.Tables.finesine;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedMul;
import static rr.LightsAndColors.*;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import rr.PlaneDrawer;
import rr.Renderer;
import rr.flat_t;
import rr.visplane_t;
import rr.drawfuns.ColVars;
import rr.drawfuns.DoomColumnFunction;
import rr.drawfuns.DoomSpanFunction;
import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;
import rr.drawfuns.R_DrawSpanLow;
import rr.drawfuns.R_DrawSpanUnrolled;
import rr.drawfuns.SpanVars;

/** Visplane worker which shares work in an equal screen-portions strategy.
 * 
 * More balanced, but requires careful synchronization to avoid overdrawing and
 * stomping.
 *  
 *  
 * @author vepitrop.
 *
 */

public abstract class VisplaneWorker2<T,V> extends PlaneDrawer<T,V> implements Runnable{

    protected final int id;
    protected final int NUMFLOORTHREADS;
    protected int startvp;  
    protected int endvp;
    protected int vpw_planeheight;
    protected V[] vpw_planezlight;
    protected int vpw_basexscale,vpw_baseyscale;
    protected final SpanVars<T,V> vpw_dsvars;
    protected final ColVars<T,V> vpw_dcvars;
    protected DoomSpanFunction<T,V> vpw_spanfunc;
    protected DoomColumnFunction<T,V> vpw_skyfunc;
    protected DoomSpanFunction<T,V> vpw_spanfunchi;
    protected DoomSpanFunction<T,V> vpw_spanfunclow;
    protected DoomColumnFunction<T,V> vpw_skyfunchi;
    protected DoomColumnFunction<T,V> vpw_skyfunclow;
    protected visplane_t pln;
    
    public VisplaneWorker2(Renderer<T,V> R,int id,int sCREENWIDTH, int sCREENHEIGHT, CyclicBarrier visplanebarrier,int NUMFLOORTHREADS) {
        super(R);
        this.barrier=visplanebarrier;
        this.id=id;
        // Alias to those of Planes.
        vpw_dsvars=new SpanVars<T,V>();
        vpw_dcvars=new ColVars<T,V>();
        this.NUMFLOORTHREADS=NUMFLOORTHREADS;
    }

    public static class HiColor extends VisplaneWorker2<byte[],short[]>{

        public HiColor(Renderer<byte[],short[]> R,int id, int sCREENWIDTH, int sCREENHEIGHT,
                int[] columnofs, int[] ylookup, short[] screen,
                CyclicBarrier visplanebarrier, int NUMFLOORTHREADS) {
            super(R,id, sCREENWIDTH, sCREENHEIGHT, visplanebarrier, NUMFLOORTHREADS);
            vpw_spanfunc=vpw_spanfunchi=new R_DrawSpanUnrolled.HiColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_spanfunclow=new R_DrawSpanLow.HiColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_skyfunc=vpw_skyfunchi=new R_DrawColumnBoomOpt.HiColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);
            vpw_skyfunclow=new R_DrawColumnBoomOptLow.HiColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);

        }
        
    }
    
    public static class Indexed extends VisplaneWorker2<byte[],byte[]>{

        public Indexed(Renderer<byte[],byte[]> R,int id, int sCREENWIDTH, int sCREENHEIGHT,
                int[] columnofs, int[] ylookup, byte[] screen,
                CyclicBarrier visplanebarrier, int NUMFLOORTHREADS) {
            super(R,id, sCREENWIDTH, sCREENHEIGHT, visplanebarrier, NUMFLOORTHREADS);
            vpw_spanfunc=vpw_spanfunchi=new R_DrawSpanUnrolled.Indexed(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_spanfunclow=new R_DrawSpanLow.Indexed(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_skyfunc=vpw_skyfunchi=new R_DrawColumnBoomOpt.Indexed(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);
            vpw_skyfunclow=new R_DrawColumnBoomOptLow.Indexed(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);

        }
        
    }
    
    public static class TrueColor extends VisplaneWorker2<byte[],int[]>{

        public TrueColor(Renderer<byte[],int[]> R,int id, int sCREENWIDTH, int sCREENHEIGHT,
                int[] columnofs, int[] ylookup, int[] screen,
                CyclicBarrier visplanebarrier, int NUMFLOORTHREADS) {
            super(R,id, sCREENWIDTH, sCREENHEIGHT, visplanebarrier, NUMFLOORTHREADS);
            vpw_spanfunc=vpw_spanfunchi=new R_DrawSpanUnrolled.TrueColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_spanfunclow=new R_DrawSpanLow.TrueColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dsvars,screen,I);
            vpw_skyfunc=vpw_skyfunchi=new R_DrawColumnBoomOpt.TrueColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);
            vpw_skyfunclow=new R_DrawColumnBoomOptLow.TrueColor(sCREENWIDTH,sCREENHEIGHT,ylookup,columnofs,vpw_dcvars,screen,I);

        }
        
    }
    
    @Override
    public void run() {
        pln=null; //visplane_t
        // These must override the global ones

        int         light;
        int         x;
        int         stop;
        int         angle;
        int minx,maxx;
        
        // Now it's a good moment to set them.
        vpw_basexscale=vpvars.getBaseXScale();
        vpw_baseyscale=vpvars.getBaseYScale();
        
        startvp=((id*view.width)/NUMFLOORTHREADS);
        endvp=(((id+1)*view.width)/NUMFLOORTHREADS);
        
        // TODO: find a better way to split work. As it is, it's very uneven
        // and merged visplanes in particular are utterly dire.
        
         for (int pl= 0; pl <vpvars.lastvisplane; pl++) {
             pln=vpvars.visplanes[pl];
            // System.out.println(id +" : "+ pl);

        // Trivial rejection.
         if ((pln.minx > endvp) || (pln.maxx <startvp)) 
                 continue;

         // Reject non-visible  
         if (pln.minx > pln.maxx)
             continue;

         // Trim to zone
         minx=Math.max(pln.minx,startvp);
         maxx=Math.min(pln.maxx,endvp);
         
         // sky flat
         if (pln.picnum == TexMan.getSkyFlatNum() )
         {
             // Cache skytexture stuff here. They aren't going to change while
             // being drawn, after all, are they?
             int skytexture=TexMan.getSkyTexture();
             // MAES: these must be updated to keep up with screen size changes.
             vpw_dcvars.viewheight=view.height;
             vpw_dcvars.centery=view.centery;
             vpw_dcvars.dc_texheight=TexMan.getTextureheight(skytexture)>>FRACBITS;                 
             vpw_dcvars.dc_iscale = vpvars.getSkyScale()>>view.detailshift;
             
             vpw_dcvars.dc_colormap = colormap.colormaps[0];
             vpw_dcvars.dc_texturemid = TexMan.getSkyTextureMid();
             for (x=minx ; x <= maxx ; x++)
             {
           
                 vpw_dcvars.dc_yl = pln.getTop(x);
                 vpw_dcvars.dc_yh = pln.getBottom(x);
             
             if (vpw_dcvars.dc_yl <= vpw_dcvars.dc_yh)
             {
                 angle = (int) (addAngles(view.angle, view.xtoviewangle[x])>>>ANGLETOSKYSHIFT);
                 vpw_dcvars.dc_x = x;
                 vpw_dcvars.dc_texheight=TexMan.getTextureheight(TexMan.getSkyTexture())>>FRACBITS;
                 vpw_dcvars.dc_source = TexMan.GetCachedColumn(TexMan.getSkyTexture(), angle);
                 vpw_skyfunc.invoke();
             }
             }
             continue;
         }
         
         // regular flat
         vpw_dsvars.ds_source = TexMan.getSafeFlat(pln.picnum);
         vpw_planeheight = Math.abs(pln.height-view.z);
         light = (pln.lightlevel >>> LIGHTSEGSHIFT)+colormap.extralight;

         if (light >= LIGHTLEVELS)
             light = LIGHTLEVELS-1;

         if (light < 0)
             light = 0;

         vpw_planezlight = colormap.zlight[light];

         // Some tinkering required to make sure visplanes
         // don't end prematurely on each other's stop markers
         
         char value=pln.getTop(maxx+1);
         if (!isMarker(value)) { // is it a marker?
                value|=visplane_t.SENTINEL; // Mark it so.
                value&=visplane_t.THREADIDCLEAR; //clear id bits
                value|=(id<<visplane_t.THREADIDSHIFT); // set our own id.
                } // Otherwise, it was set by another thread.
                  // Leave it be.
         
         pln.setTop(maxx+1,value);
         
         value=pln.getTop(minx-1);
         if (!isMarker(value)) { // is it a marker?
                value|=visplane_t.SENTINEL; // Mark it so.
                value&=visplane_t.THREADIDCLEAR; //clear id bits
                value|=(id<<visplane_t.THREADIDSHIFT); // set our own id.
                } // Otherwise, it was set by another thread.
                  // Leave it be.
         
         pln.setTop(minx-1, value);
         
         stop = maxx+1;
         
         for (x=minx ; x<= stop ; x++) {
          MakeSpans(x,pln.getTop(x-1),
             pln.getBottom(x-1),
             pln.getTop(x),
             pln.getBottom(x));
            }
         
         }
         // We're done, wait.

            try {
                barrier.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

     }
        
    private final boolean isMarker(int t1){
        return ((t1&visplane_t.SENTINEL)!=0);
        }
    
    private final int decodeID(int t1){
        return (t1&visplane_t.THREADIDBITS)>>visplane_t.THREADIDSHIFT;
        }
    
    private final int decodeValue(int t1){
        return t1&visplane_t.THREADVALUEBITS;
        }
    
    public void setDetail(int detailshift) {
        if (detailshift == 0){
            vpw_spanfunc = vpw_spanfunchi;
            vpw_skyfunc= vpw_skyfunchi;
        }
        else{
            vpw_spanfunc = vpw_spanfunclow;
            vpw_skyfunc =vpw_skyfunclow;
        }
    }
    
    /**
     * R_MakeSpans
     * 
     * Called only by DrawPlanes.
     * If you wondered where the actual boundaries for the visplane
     * flood-fill are laid out, this is it.
     * 
     * The system of coords seems to be defining a sort of cone.          
     *          
     * 
     * @param x Horizontal position
     * @param t1 Top-left y coord?
     * @param b1 Bottom-left y coord?
     * @param t2 Top-right y coord ?
     * @param b2 Bottom-right y coord ?
     * 
     */

      protected final void MakeSpans(int x, int t1, int b1, int t2, int b2) {
      
          // Top 1 sentinel encountered.
          if (isMarker(t1))
              if (decodeID(t1)!=id) // We didn't put it here.
                  t1=decodeValue(t1);

        // Top 2 sentinel encountered.
          if (isMarker(t2))
              if (decodeID(t2)!=id)
                  t2=decodeValue(t2);
              
          // If t1 = [sentinel value] then this part won't be executed.
          while (t1 < t2 && t1 <= b1) {
              this.MapPlane(t1, spanstart[t1], x - 1);
              t1++;
          }
          while (b1 > b2 && b1 >= t1) {
              this.MapPlane(b1, spanstart[b1], x - 1);
              b1--;
          }

          // So...if t1 for some reason is < t2, we increase t2 AND store the current x
          // at spanstart [t2] :-S
          while (t2 < t1 && t2 <= b2) {
              spanstart[t2] = x;
              t2++;
          }

          // So...if t1 for some reason b2 > b1, we decrease b2 AND store the current x
          // at spanstart [t2] :-S

          while (b2 > b1 && b2 >= t2) {
              spanstart[b2] = x;
              b2--;
          }
      }
      
      /**
       * R_MapPlane
       *
       * Called only by R_MakeSpans.
       * 
       * This is where the actual span drawing function is called.
       * 
       * Uses global vars:
       * planeheight
       *  ds_source -> flat data has already been set.
       *  basexscale -> actual drawing angle and position is computed from these
       *  baseyscale
       *  viewx
       *  viewy
       *
       * BASIC PRIMITIVE
       */
      /* TODO: entirely similar to serial version?
      private void
      MapPlane
      ( int       y,
        int       x1,
        int       x2 )
      {
          // MAES: angle_t
          int angle;
          // fixed_t
          int distance;
          int length;
          int index;
          
      if (RANGECHECK){
          if (x2 < x1
          || x1<0
          || x2>=view.width
          || y>view.height)
          {
          I.Error ("R_MapPlane: %d, %d at %d",x1,x2,y);
          }
      }

          if (vpw_planeheight != cachedheight[y])
          {
          cachedheight[y] = vpw_planeheight;
          distance = cacheddistance[y] = FixedMul (vpw_planeheight , yslope[y]);
          vpw_dsvars.ds_xstep = cachedxstep[y] = FixedMul (distance,vpw_basexscale);
          vpw_dsvars.ds_ystep = cachedystep[y] = FixedMul (distance,vpw_baseyscale);
          }
          else
          {
          distance = cacheddistance[y];
          vpw_dsvars.ds_xstep = cachedxstep[y];
          vpw_dsvars.ds_ystep = cachedystep[y];
          }
          
          length = FixedMul (distance,distscale[x1]);
          angle = (int)(((view.angle +xtoviewangle[x1])&BITS32)>>>ANGLETOFINESHIFT);
          vpw_dsvars.ds_xfrac = view.x + FixedMul(finecosine[angle], length);
          vpw_dsvars.ds_yfrac = -view.y - FixedMul(finesine[angle], length);

          if (colormap.fixedcolormap!=null)
              vpw_dsvars.ds_colormap = colormap.fixedcolormap;
          else
          {
          index = distance >>> LIGHTZSHIFT;
          
          if (index >= MAXLIGHTZ )
              index = MAXLIGHTZ-1;

          vpw_dsvars.ds_colormap = vpw_planezlight[index];
          }
          
          vpw_dsvars.ds_y = y;
          vpw_dsvars.ds_x1 = x1;
          vpw_dsvars.ds_x2 = x2;

          // high or low detail
          if (view.detailshift==0)
              vpw_spanfunc.invoke();
          else
              vpw_spanfunclow.invoke();         
      }
      */
      
      // Private to each thread.
      int[]           spanstart;
      int[]           spanstop;
      CyclicBarrier barrier;
      
  }

package rr.parallel;

import static data.Tables.finetangent;
import static m.fixed_t.*;
import static rr.LightsAndColors.*;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import rr.IDetailAware;
import rr.IGetColumn;
import rr.TextureManager;
import rr.visplane_t;
import rr.drawfuns.ColVars;
import rr.drawfuns.DoomColumnFunction;
import rr.drawfuns.R_DrawColumnBoomOpt;
import rr.drawfuns.R_DrawColumnBoomOptLow;

import data.Tables;

import v.IVideoScale;
import v.IVideoScaleAware;

/** This is what actual executes the RenderSegInstructions.
 *   *  
 *  Each thread actually operates on a FIXED PORTION OF THE SCREEN
 *  (e.g. half-width, third-width etc.) and only renders the portions
 *  of the RenderSegInstructions that are completely contained
 *  within its own screen area. For this reason, all threads
 *  check out all RenderSegInstructions of the list, and render any 
 *  and all portions that are within their responsability domain, so
 *  to speak.
 *  
 *  FIXME there's a complex data dependency with ceilingclip/floorclip 
 *  I was not quite able to fix yet. Practically, in the serial renderer,
 *  calls to RenderSegLoop are done in a correct, non-overlapping order,
 *  and certain parts are drawn before others in order to set current
 *  floor/ceiling markers and visibility e.g. think of a wall visible
 *  through windows.
 *  
 *  FIXME 7/6/2011 Data dependencies and per-thread clipping are now 
 *  fixed, however there is still visible "jitter" or "noise" on some 
 *  of the walls, probably related to column offsets.
 * 
 * @author velktron
 *
 */

public abstract class RenderSegExecutor<T,V> implements Runnable, IVideoScaleAware,IDetailAware {

	// This needs to be set by the partitioner.
    protected int rw_start, rw_end,rsiend;
	// These need to be set on creation, and are unchangeable.
	protected final TextureManager<T> TexMan;
	protected final CyclicBarrier barrier;
	protected RenderSegInstruction<V>[] RSI;
	protected final long[] xtoviewangle;
	protected final short[] ceilingclip, floorclip;

	// Each thread should do its own ceiling/floor blanking
	protected final short[] BLANKFLOORCLIP;
	protected final short[] BLANKCEILINGCLIP;

    protected static final int HEIGHTBITS   =   12;
	protected static final int HEIGHTUNIT   =   (1<<HEIGHTBITS);
	protected final int id;
	
	protected DoomColumnFunction<T,V> colfunchi,colfunclow;
	protected DoomColumnFunction<T,V> colfunc;
	protected ColVars<T,V> dcvars;
	
	public RenderSegExecutor(int SCREENWIDTH, int SCREENHEIGHT,int id,V screen, 
			TextureManager<T> texman,
			RenderSegInstruction<V>[] RSI,
			short[] BLANKCEILINGCLIP,
			short[] BLANKFLOORCLIP,
			short[] ceilingclip,
			short[] floorclip,
			int[] columnofs,
			long[] xtoviewangle,
			int[] ylookup,
			visplane_t[] visplanes,
			CyclicBarrier barrier){
		this.id=id;
		this.TexMan=texman;
		this.RSI=RSI;
		this.barrier=barrier;		
		this.ceilingclip=ceilingclip;
		this.floorclip=floorclip;
		this.xtoviewangle=xtoviewangle;
		this.BLANKCEILINGCLIP=BLANKCEILINGCLIP;
		this.BLANKFLOORCLIP=BLANKFLOORCLIP;
        
	}

	 protected final void ProcessRSI(RenderSegInstruction<V> rsi, int startx,int endx,boolean contained){
         int     angle; // angle_t
         int     index;
         int     yl; // low
         int     yh; // hight
         int     mid;
         int pixlow,pixhigh,pixhighstep,pixlowstep;
         int rw_scale,topfrac,bottomfrac,bottomstep;
         // These are going to be modified A LOT, so we cache them here.
         pixhighstep=rsi.pixhighstep;
         pixlowstep=rsi.pixlowstep;
         bottomstep=rsi.bottomstep;
         //  We must re-scale it.
         int rw_scalestep= rsi.rw_scalestep; 
         int topstep=rsi.topstep;
         int     texturecolumn=0; // fixed_t
         final int bias;
         // Well is entirely contained in our screen zone 
         // (or the very least it starts in it).
         if (contained) bias=0; 
             // We are continuing a wall that started in another 
             // screen zone.
             else bias=(startx-rsi.rw_x);
         // PROBLEM: these must be pre-biased when multithreading.
             rw_scale=rsi.rw_scale+bias*rw_scalestep;
             topfrac = rsi.topfrac+bias*topstep;
             bottomfrac = rsi.bottomfrac+ bias*bottomstep;
             pixlow=rsi.pixlow+bias*pixlowstep;
             pixhigh=rsi.pixhigh+bias*pixhighstep;

         {
            
             for ( int rw_x=startx; rw_x < endx ; rw_x++)
             {
             // mark floor / ceiling areas
             yl = (topfrac+HEIGHTUNIT-1)>>HEIGHTBITS;

             // no space above wall?
             if (yl < ceilingclip[rw_x]+1)
                 yl = ceilingclip[rw_x]+1;
                 
             yh = bottomfrac>>HEIGHTBITS;

             if (yh >= floorclip[rw_x])
                 yh = floorclip[rw_x]-1;
             
           //  System.out.printf("Thread: rw %d yl %d yh %d\n",rw_x,yl,yh);

             // A particular seg has been identified as a floor marker.
             
             
             // texturecolumn and lighting are independent of wall tiers
             if (rsi.segtextured)
             {
                 // calculate texture offset
                
                 
               // CAREFUL: a VERY anomalous point in the code. Their sum is supposed
               // to give an angle not exceeding 45 degrees (or 0x0FFF after shifting).
               // If added with pure unsigned rules, this doesn't hold anymore,
               // not even if accounting for overflow.
                 angle = Tables.toBAMIndex(rsi.rw_centerangle + (int)xtoviewangle[rw_x]);
               //angle = (int) (((rw_centerangle + xtoviewangle[rw_x])&BITS31)>>>ANGLETOFINESHIFT);
               //angle&=0x1FFF;
                 
               // FIXME: We are accessing finetangent here, the code seems pretty confident
               // in that angle won't exceed 4K no matter what. But xtoviewangle
               // alone can yield 8K when shifted.
               // This usually only overflows if we idclip and look at certain directions 
               // (probably angles get fucked up), however it seems rare enough to just 
               // "swallow" the exception. You can eliminate it by anding with 0x1FFF
               // if you're so inclined. 
               
               texturecolumn = rsi.rw_offset-FixedMul(finetangent[angle],rsi.rw_distance);
                texturecolumn >>= FRACBITS;
               // calculate lighting
               index = rw_scale>>LIGHTSCALESHIFT;
       

                 if (index >=  MAXLIGHTSCALE )
                 index = MAXLIGHTSCALE-1;

                 dcvars.dc_colormap = rsi.walllights[index];
                 dcvars.dc_x = rw_x;
                 dcvars.dc_iscale = (int) (0xffffffffL / rw_scale);
             }
             
             // draw the wall tiers
             if (rsi.midtexture!=0)
             {
                 // single sided line
                 dcvars.dc_yl = yl;
                 dcvars.dc_yh = yh;
                 dcvars.dc_texheight = TexMan.getTextureheight(rsi.midtexture)>>FRACBITS; // killough
                 dcvars.dc_texturemid = rsi.rw_midtexturemid;    
                 dcvars.dc_source = TexMan.GetCachedColumn(rsi.midtexture,texturecolumn);
                 dcvars.dc_source_ofs=0;
                 colfunc.invoke();
                 ceilingclip[rw_x] = (short) rsi.viewheight;
                 floorclip[rw_x] = -1;
             }
             else
             {
                 // two sided line
                 if (rsi.toptexture!=0)
                 {
                     // top wall
                     mid = pixhigh>>HEIGHTBITS;
                     pixhigh += pixhighstep;

                     if (mid >= floorclip[rw_x])
                         mid = floorclip[rw_x]-1;

                 if (mid >= yl)
                 {
                     dcvars.dc_yl = yl;
                     dcvars.dc_yh = mid;
                     dcvars.dc_texturemid = rsi.rw_toptexturemid;
                     dcvars.dc_texheight=TexMan.getTextureheight(rsi.toptexture)>>FRACBITS;
                     dcvars.dc_source = TexMan.GetCachedColumn(rsi.toptexture,texturecolumn);
                     //dc_source_ofs=0;
                     colfunc.invoke();
                     ceilingclip[rw_x] = (short) mid;
                 }
                 else
                     ceilingclip[rw_x] = (short) (yl-1);
                 }  // if toptexture
                 else
                 {
                     // no top wall
                     if (rsi.markceiling)
                         ceilingclip[rw_x] = (short) (yl-1);
                 } 
                     
                 if (rsi.bottomtexture!=0)
                 {
                 // bottom wall
                 mid = (pixlow+HEIGHTUNIT-1)>>HEIGHTBITS;
                 pixlow += pixlowstep;

                 // no space above wall?
                 if (mid <= ceilingclip[rw_x])
                     mid = ceilingclip[rw_x]+1;
                 
                 if (mid <= yh)
                 {
                     dcvars.dc_yl = mid;
                     dcvars.dc_yh = yh;
                     dcvars.dc_texturemid = rsi.rw_bottomtexturemid;
                     dcvars.dc_texheight=TexMan.getTextureheight(rsi.bottomtexture)>>FRACBITS;
                     dcvars.dc_source = TexMan.GetCachedColumn(rsi.bottomtexture,texturecolumn);
                     // dc_source_ofs=0;
                     colfunc.invoke();
                     floorclip[rw_x] = (short) mid;
                 }
                 else
                      floorclip[rw_x] = (short) (yh+1);

             } // end-bottomtexture
             else
             {
                 // no bottom wall
                 if (rsi.markfloor)
                     floorclip[rw_x] = (short) (yh+1);
             }
                 
            } // end-else (two-sided line)
                 rw_scale += rw_scalestep;
                 topfrac += topstep;
                 bottomfrac += bottomstep;
             } // end-rw 
         } // end-block
     }
	
	@Override
    public void setDetail(int detailshift) {
        if (detailshift == 0)
            colfunc = colfunchi;
        else
            colfunc = colfunclow;
    }
	
	/** Only called once per screen width change */
	public void setScreenRange(int rwstart, int rwend){
		this.rw_end=rwend;
		this.rw_start=rwstart;
	}

	
	/** How many instructions TOTAL are there to wade through.
	 *  Not all will be executed on one thread, except in some rare
	 *  circumstances. 
	 *  
	 * @param rsiend
	 */
	public void setRSIEnd(int rsiend){
		this.rsiend=rsiend;
	}

	public void run()
	{

		RenderSegInstruction<V> rsi;

		// Each worker blanks its own portion of the floor/ceiling clippers.
		System.arraycopy(BLANKFLOORCLIP,rw_start,floorclip, rw_start,rw_end-rw_start);
		System.arraycopy(BLANKCEILINGCLIP,rw_start,ceilingclip, rw_start,rw_end-rw_start);

		// For each "SegDraw" instruction...
		for (int i=0;i<rsiend;i++){
			rsi=RSI[i];
			dcvars.centery=RSI[i].centery;
			int startx,endx;
			// Does a wall actually start in our screen zone?
			// If yes, we need no bias, since it was meant for it.
			// If the wall started BEFORE our zone, then we
			// will need to add a bias to it (see ProcessRSI).
			// If its entirely non-contained, ProcessRSI won't be
			// called anyway, so we don't need to check for the end.
			
			boolean contained=(rsi.rw_x>=rw_start);
			// Keep to your part of the screen. It's possible that several
			// threads will process the same RSI, but different parts of it.
			
				// Trim stuff that starts before our rw_start position.
				startx=Math.max(rsi.rw_x,rw_start);
				// Similarly, trim stuff after our rw_end position.
				endx=Math.min(rsi.rw_stopx,rw_end);
				// Is there anything to actually draw?
				if ((endx-startx)>0) {
					ProcessRSI(rsi,startx,endx,contained);
					}
		} // end-instruction
	
		try {
			barrier.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
	
	//protected abstract void ProcessRSI(RenderSegInstruction<V> rsi, int startx,int endx,boolean contained);

	

	////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

	protected int SCREENWIDTH;
	protected int SCREENHEIGHT;
	protected IVideoScale vs;

	@Override
	public void setVideoScale(IVideoScale vs) {
		this.vs=vs;
	}

	@Override
	public void initScaling() {
		this.SCREENHEIGHT=vs.getScreenHeight();
		this.SCREENWIDTH=vs.getScreenWidth();
	}

	public void updateRSI(RenderSegInstruction<V>[] rsi) {
		this.RSI=rsi;
		}
	
	public static final class HiColor extends RenderSegExecutor<byte[],short[]>{

        public HiColor(int SCREENWIDTH, int SCREENHEIGHT, int id,
                short[] screen, TextureManager<byte[]> texman,
                RenderSegInstruction<short[]>[] RSI, short[] BLANKCEILINGCLIP,
                short[] BLANKFLOORCLIP, short[] ceilingclip, short[] floorclip,
                int[] columnofs, long[] xtoviewangle, int[] ylookup,
                visplane_t[] visplanes, CyclicBarrier barrier) {
            super(SCREENWIDTH, SCREENHEIGHT, id, screen, texman, RSI, BLANKCEILINGCLIP,
                    BLANKFLOORCLIP, ceilingclip, floorclip, columnofs, xtoviewangle,
                    ylookup, visplanes, barrier);
            dcvars=new ColVars<byte[],short[]>();
            colfunc=colfunchi=new R_DrawColumnBoomOpt.HiColor(SCREENWIDTH, SCREENHEIGHT,ylookup,columnofs,dcvars,screen,null );
            colfunclow=new R_DrawColumnBoomOptLow.HiColor(SCREENWIDTH, SCREENHEIGHT,ylookup,columnofs,dcvars,screen,null );
        }
	}
	
	public static final class Indexed extends RenderSegExecutor<byte[],byte[]>{

        public Indexed(int SCREENWIDTH, int SCREENHEIGHT, int id,
                byte[] screen, IGetColumn<byte[]> gc, TextureManager<byte[]> texman,
                RenderSegInstruction<byte[]>[] RSI, short[] BLANKCEILINGCLIP,
                short[] BLANKFLOORCLIP, short[] ceilingclip, short[] floorclip,
                int[] columnofs, long[] xtoviewangle, int[] ylookup,
                visplane_t[] visplanes, CyclicBarrier barrier) {
            super(SCREENWIDTH, SCREENHEIGHT, id, screen, texman, RSI, BLANKCEILINGCLIP,
                    BLANKFLOORCLIP, ceilingclip, floorclip, columnofs, xtoviewangle,
                    ylookup, visplanes, barrier);
            dcvars=new ColVars<byte[],byte[]>();
            colfunc=colfunchi=new R_DrawColumnBoomOpt.Indexed(SCREENWIDTH, SCREENHEIGHT,ylookup,columnofs,dcvars,screen,null );
            colfunclow=new R_DrawColumnBoomOptLow.Indexed(SCREENWIDTH, SCREENHEIGHT,ylookup,columnofs,dcvars,screen,null );
        }
    }
	
}

// $Log: RenderSegExecutor.java,v $
// Revision 1.2  2012/09/24 17:16:22  velktron
// Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
// Revision 1.1.2.2  2012/09/21 16:18:29  velktron
// More progress...but no cigar, yet.
//
// Revision 1.1.2.1  2012/09/20 14:20:10  velktron
// Parallel stuff in their own package (STILL BROKEN)
//
// Revision 1.12.2.4  2012/09/19 21:45:41  velktron
// More extensions...
//
// Revision 1.12.2.3  2012/09/18 16:11:50  velktron
// Started new "all in one" approach for unifying Indexed, HiColor and (future) TrueColor branches.
//
// Revision 1.12.2.2  2012/06/15 14:44:09  velktron
// Doesn't need walllights?
//
// Revision 1.12.2.1  2011/11/14 00:27:11  velktron
// A barely functional HiColor branch. Most stuff broken. DO NOT USE
//
// Revision 1.12  2011/11/01 19:04:06  velktron
// Cleaned up, using IDetailAware for subsystems.
//
// Revision 1.11  2011/10/31 18:33:56  velktron
// Much cleaner implementation using the new rendering model. Now it's quite faster, too.
//
// Revision 1.10  2011/07/25 11:39:10  velktron
// Optimized to work without dc_source_ofs (uses only cached, solid textures)
//
// Revision 1.9  2011/07/12 16:29:35  velktron
// Now using GetCachedColumn
//
// Revision 1.8  2011/07/12 16:25:02  velktron
// Removed dependency on per-thread column pointers.
//
// Revision 1.7  2011/06/07 21:21:15  velktron
// Definitively fixed jitter bug, which was due to dc_offset_contention. Now the alternative parallel renderer is just as good as the original one.
//
// Revision 1.6  2011/06/07 13:35:38  velktron
// Definitively fixed drawing priority/zones. Now to solve the jitter :-/
//
// Revision 1.5  2011/06/07 01:32:32  velktron
// Parallel Renderer 2 still buggy :-(
//
// Revision 1.4  2011/06/07 00:50:47  velktron
// Alternate Parallel Renderer fixed.
//
// Revision 1.3  2011/06/07 00:11:11  velktron
// Fixed alternate parallel renderer (seg based). No longer deprecated.
//
package rr;


/** A vissprite_t is a thing
 * that will be drawn during a refresh.
 * I.e. a sprite object that is partly visible.
 */

public class vissprite_t<V> implements Comparable<vissprite_t<V>>{

// Doubly linked list.
public vissprite_t<V> prev;
public vissprite_t<V> next;

public int         x1;
public int         x2;

// for line side calculation
public int     gx;
public int     gy;     

// global bottom / top for silhouette clipping
public int     gz;
public int     gzt;

// horizontal position of x1
public int     startfrac;

public int     scale;

// negative if flipped
public int     xiscale;    

public int     texturemid;
public int         patch;

/** for color translation and shadow draw,
 * maxbright frames as well.
 * 
 * Use paired with pcolormap;
 */ 
public V colormap;

/* pointer into colormap
public int pcolormap; */

public long mobjflags;

/** visspites are sorted by scale */

@Override
public final int compareTo(vissprite_t<V> o) {
    // We only really care if it's drawn before. 
    if (this.scale> o.scale) return 1;
    if (this.scale< o.scale) return -1;
    return 0;
}

public String toString(){    
    return ("Effective drawing position x1: "+x1 + " x2: "+ x2 +" scale "+(scale/65535.0) +" iscale "+(xiscale/65535.0));
}

}
package rr;
import java.util.Arrays;
import v.IVideoScale;

/** Now what is a visplane, anyway?
 *  Basically, it's a bunch of arrays buffer representing
 *  a top and a bottom boundary of a region to be filled with a
 *  specific kind of flat. They are as wide as the screen, 
 *  and actually store height bounding values or sentinel valuesThink of it as an arbitrary boundary.
 *  
 *  These are refreshed continuously during rendering, and mark 
 *  the limits between flat regions. Special values mean "do not 
 *  render this column at all", while clipping out of the map bounds
 *  results in well-known bleeding effects.
 * 
 * @author admin
 *
 */

public class visplane_t{
    
    public static final int TOPOFFSET=1;
    public static final int MIDDLEPADDING=2;
    public static int BOTTOMOFFSET;
    
    // Multithreading trickery (for strictly x-bounded drawers)
    // The thread if is encoded in the upper 3 bits (puts an upper limit 
    // of 8 floor threads), and the stomped value is encoded in the next 12 
    // bits (this puts an upper height limit of 4096 pixels). 
    // Not the cleanest system possible, but it's backwards compatible
    // TODO: expand visplane buffers to full-fledged ints?
    
    public static final char SENTINEL=0x8000;
    public static final char THREADIDSHIFT=12;
    public static final char THREADIDCLEAR=0x8FFF;
    public static final char THREADIDBITS=0XFFFF-THREADIDCLEAR;
    public static final char THREADVALUEBITS=THREADIDCLEAR-SENTINEL;
    
    public visplane_t(){
        this.data=new char[4+2*SCREENWIDTH];
        this.updateHashCode();
    }
    
    
    public visplane_t(int height, int picnum, int lightlevel){
        this.height=height;
        this.picnum=picnum;
        this.lightlevel=lightlevel;
        this.updateHashCode();
        this.data=new char[4+2*SCREENWIDTH];
        }
    
    
/** (fixed_t) */
public int       height;
public int           picnum;
public int           lightlevel;
public int           minx;
public int           maxx;

// leave pads for [minx-1]/[maxx+1]

/*
public byte      pad1;
// Here lies the rub for all
//  dynamic resize/change of resolution.
public byte[]      top=new byte[SCREENWIDTH];
public byte      pad2;
public byte      pad3;
// See above.
public byte[]      bottom=new byte [SCREENWIDTH];
public byte      pad4;*/

char data[];

// Hack to allow quick clearing of visplanes.
protected static char[] clearvisplane;


/** "Clear" the top with FF's.  */
public void clearTop(){
    System.arraycopy(clearvisplane, 0, this.data, TOPOFFSET, SCREENWIDTH);
      
}

/** "Clear" the bottom with FF's.  */
public void clearBottom(){
    System.arraycopy(clearvisplane, 0, this.data, BOTTOMOFFSET, SCREENWIDTH);      
}

public void setTop(int index, char value){
    this.data[TOPOFFSET+index]=value;    
}

public char getTop(int index){
    return this.data[TOPOFFSET+index];
    
}

public void setBottom(int index, char value){
    this.data[BOTTOMOFFSET+index]=value;
    
}

public int getBottom(int index){
    return this.data[BOTTOMOFFSET+index];
    
}

public String toString(){
    sb.setLength(0);
    sb.append("Visplane\n");
    sb.append('\t');
    sb.append("Height: ");
    sb.append(this.height);
    sb.append('\t');
    sb.append("Min-Max: ");
    sb.append(this.minx);
    sb.append('-');
    sb.append(this.maxx);
    sb.append('\t');
    sb.append("Picnum: ");    
    sb.append(this.picnum);
    sb.append('\t');
    sb.append("Lightlevel: ");
    sb.append(this.lightlevel);

    return sb.toString();
    
    
}

protected int hash;

/** Call this upon any changed in height, picnum or lightlevel */

public void updateHashCode(){
    this.hash=height^picnum^lightlevel;
}

public int hashCode(){
    return this.hash;
}

public static int visplaneHash(int height, int picnum, int lightlevel){
    return height^picnum^lightlevel;
    
}

protected static StringBuilder sb=new StringBuilder();


// HACK: the resolution awareness is shared between all visplanes.
// Change this if you ever plan on running multiple renderers with
// different resolution or something.
protected static int SCREENWIDTH;
protected static int SCREENHEIGHT;
protected static IVideoScale vs;

public static void setVideoScale(IVideoScale vs) {
    visplane_t.vs=vs;
}

public static void initScaling() {
    SCREENHEIGHT=vs.getScreenHeight();
    SCREENWIDTH=vs.getScreenWidth();

    // Pre-scale stuff.
    BOTTOMOFFSET=SCREENWIDTH+TOPOFFSET+MIDDLEPADDING;

    if (clearvisplane==null || clearvisplane.length<SCREENWIDTH) {
        clearvisplane=new char[SCREENWIDTH];
        Arrays.fill(clearvisplane,Character.MAX_VALUE);
        }
}


};

package rr;

import static data.Tables.ANG90;
import static data.Tables.finecosine;
import static data.Tables.finesine;
import static m.fixed_t.FixedDiv;


import utils.C2JUtils;
import v.IVideoScale;
import v.IVideoScaleAware;
import data.Limits;
import data.Tables;

/** Actual visplane data and methods are isolate here.
 *  This allows more encapsulation and some neat hacks like sharing 
 *  visplane data among parallel renderers, without duplicating them.
 */

public class Visplanes implements IVideoScaleAware{

    private static final boolean DEBUG2=false;

    protected final ViewVars view;
    protected final TextureManager<?> TexMan;
    
    public Visplanes(ViewVars view,TextureManager<?> TexMan){
        this.view=view;
        this.TexMan=TexMan;
    }

    protected int SCREENHEIGHT;
    protected int SCREENWIDTH;
    

    // HACK: An all zeroes array used for fast clearing of certain visplanes.
    public int[] cachedheight,BLANKCACHEDHEIGHT;

    
    /** To treat as fixed_t */
    public int basexscale, baseyscale;
    
    /** To treat at fixed_t */
    protected int[] yslope;
    
    // initially.
    public int MAXVISPLANES = Limits.MAXVISPLANES;
    public int MAXOPENINGS;
    
    /** visplane_t*, treat as indexes into visplanes */
    public int lastvisplane, floorplane, ceilingplane;
    public visplane_t[] visplanes = new visplane_t[MAXVISPLANES];

    /**
     * openings is supposed to show where "openings" in visplanes start and end
     * e.g. due to sprites, windows etc.
     */
    public short[] openings;
    /** Maes: this is supposed to be a pointer inside openings */
    public int lastopening;
    
    protected int skyscale;

    
    /**
     * Call only after visplanes have been properly resized for resolution.
     * In case of dynamic resolution changes, the old ones should just be
     * discarded, as they would be nonsensical.
     */

    public void initVisplanes() {
        cachedheight = new int[SCREENHEIGHT];
        C2JUtils.initArrayOfObjects(visplanes);
        
        }
    
    public int getBaseXScale(){
        return basexscale;
    }

    public int getBaseYScale(){
        return baseyscale;
    }

    public int getSkyScale(){
        return skyscale;
    }
    
    public void setSkyScale(int i) {
        skyscale=i;        
    }
    
    public int getLength(){
        return visplanes.length;
    }
    
    /** Return the last of visplanes, allocating a new one if needed */
    
    public visplane_t allocate(){
        if (lastvisplane == visplanes.length) {
            //  visplane overflows could occur at this point.
            resizeVisplanes();
        }
        
        return visplanes[lastvisplane++];
    }
    
    public final void resizeVisplanes() {
        // Bye bye, old visplanes.
        visplanes = C2JUtils.resize(visplanes[0], visplanes, visplanes.length*2);
    }
    
    /**
     * R_FindPlane
     * 
     * Checks whether a visplane with the specified height, picnum and light
     * level exists among those already created. This looks like a half-assed
     * attempt at reusing already existing visplanes, rather than creating new
     * ones. The tricky part is understanding what happens if one DOESN'T exist.
     * Called only from within R_Subsector (so while we're still trasversing
     * stuff).
     * 
     * @param height
     *            (fixed_t)
     * @param picnum
     * @param lightlevel
     * @return was visplane_t*, returns index into visplanes[]
     */

    public final int FindPlane(int height, int picnum, int lightlevel) {
        // System.out.println("\tChecking for visplane merging...");
        int check = 0; // visplane_t*
        visplane_t chk = null;

        if (picnum == TexMan.getSkyFlatNum()) {
            height = 0; // all skys map together
            lightlevel = 0;
        }

        chk = visplanes[0];

        // Find visplane with the desired attributes
        for (check = 0; check < lastvisplane; check++) {

            chk = visplanes[check];
            if (height == chk.height && picnum == chk.picnum
                    && lightlevel == chk.lightlevel) {
                // Found a visplane with the desired specs.
                break;
            }
        }

        if (check < lastvisplane) {
            return check;
        }

        // This should return the next available visplane and resize if needed,
        // no need to hack with lastvisplane++
        chk = allocate();
        // Add a visplane
        chk.height = height;
        chk.picnum = picnum;
        chk.lightlevel = lightlevel;
        chk.minx = SCREENWIDTH;
        chk.maxx = -1;
        // memset (chk.top,0xff,sizeof(chk.top));
        chk.clearTop();

        return check;
    }
    
    /**
     * R_ClearPlanes At begining of frame.
     * 
     */

    public void ClearPlanes() {
        int angle;

        /*
         * View planes are cleared at the beginning of every plane, by
         * setting them "just outside" the borders of the screen (-1 and
         * viewheight).
         */

        // Point to #1 in visplane list? OK... ?!
        lastvisplane = 0;

        // We point back to the first opening of the list openings[0],
        // again.
        lastopening = 0;

        // texture calculation
        System.arraycopy(BLANKCACHEDHEIGHT, 0, cachedheight, 0,
                BLANKCACHEDHEIGHT.length);

        // left to right mapping
        // FIXME: If viewangle is ever < ANG90, you're fucked. How can this
        // be prevented?
        // Answer: 32-bit unsigned are supposed to roll over. You can & with
        // 0xFFFFFFFFL.
        angle = (int) Tables.toBAMIndex(view.angle - ANG90);

        // scale will be unit scale at SCREENWIDTH/2 distance
        basexscale = FixedDiv(finecosine[angle], view.centerxfrac);
        baseyscale = -FixedDiv(finesine[angle], view.centerxfrac);
    }
    
    /**
     * R_CheckPlane
     * 
     * Called from within StoreWallRange
     * 
     * Presumably decides if a visplane should be split or not?
     * 
     */

    public int CheckPlane(int index, int start, int stop) {

        if (DEBUG2)
            System.out.println("Checkplane " + index + " between " + start
                    + " and " + stop);

        // Interval ?
        int intrl;
        int intrh;

        // Union?
        int unionl;
        int unionh;
        // OK, so we check out ONE particular visplane.
        visplane_t pl = visplanes[index];

        if (DEBUG2)
            System.out.println("Checking out plane " + pl);

        int x;

        // If start is smaller than the plane's min...
        //
        // start minx maxx stop
        // | | | |
        // --------PPPPPPPPPPPPPP-----------
        //
        //
        if (start < pl.minx) {
            intrl = pl.minx;
            unionl = start;
            // Then we will have this:
            //
            // unionl intrl maxx stop
            // | | | |
            // --------PPPPPPPPPPPPPP-----------
            //

        } else {
            unionl = pl.minx;
            intrl = start;

            // else we will have this:
            //
            // union1 intrl maxx stop
            // | | | |
            // --------PPPPPPPPPPPPPP-----------
            //
            // unionl comes before intrl in any case.
            //
            //
        }

        // Same as before, for for stop and maxx.
        // This time, intrh comes before unionh.
        //

        if (stop > pl.maxx) {
            intrh = pl.maxx;
            unionh = stop;
        } else {
            unionh = pl.maxx;
            intrh = stop;
        }

        // An interval is now defined, which is entirely contained in the
        // visplane.
        //

        // If the value FF is NOT stored ANYWWHERE inside it, we bail out
        // early
        for (x = intrl; x <= intrh; x++)
            if (pl.getTop(x) != Character.MAX_VALUE)
                break;

        // This can only occur if the loop above completes,
        // else the visplane we were checking has non-visible/clipped
        // portions within that range: we must split.

        if (x > intrh) {
            // Merge the visplane
            pl.minx = unionl;
            pl.maxx = unionh;
            // System.out.println("Plane modified as follows "+pl);
            // use the same one
            return index;
        }

        // SPLIT: make a new visplane at "last" position, copying materials
        // and light.

        visplane_t last=allocate();
        last.height = pl.height;
        last.picnum = pl.picnum;
        last.lightlevel = pl.lightlevel;

        pl = last;
        pl.minx = start;
        pl.maxx = stop;

        // memset (pl.top,0xff,sizeof(pl.top));
        pl.clearTop();

        // return pl;

        // System.out.println("New plane created: "+pl);
        return lastvisplane - 1;
    }

    public void initScaling() {        
        MAXOPENINGS = SCREENWIDTH * 64;
        openings = new short[MAXOPENINGS];
        BLANKCACHEDHEIGHT = new int[SCREENHEIGHT];
        yslope = new int[SCREENHEIGHT];
    }

    @Override
    public void setVideoScale(IVideoScale vs) {
        this.SCREENHEIGHT=vs.getScreenHeight();
        this.SCREENWIDTH=vs.getScreenWidth();
        
    }
    
    /*
     
       /**
     * A hashtable used to retrieve planes with particular attributes faster
     * -hopefully-. The planes are still stored in the visplane array for
     * convenience, but we can search them in the hashtable too -as a bonus, we
     * can reuse previously created planes that match newer ones-.
     */
    /*
    Hashtable<visplane_t, Integer> planehash = new Hashtable<visplane_t, Integer>(
            128);
    visplane_t check = new visplane_t();
    */

    /*
    protected final int FindPlane2(int height, int picnum, int lightlevel) {
        // System.out.println("\tChecking for visplane merging...");
        // int check=0; // visplane_t*
        visplane_t chk = null;
        Integer checknum;

        if (picnum == TexMan.getSkyFlatNum()) {
            height = 0; // all skys map together
            lightlevel = 0;
        }

        // Try and find this.
        check.lightlevel = lightlevel;
        check.picnum = picnum;
        check.height = height;
        check.updateHashCode();
        checknum = planehash.get(check);

        // Something found, get it.

        if (!(checknum == null)) {

            // Visplane exists and is within those allocated in the current tic.
            if (checknum < lastvisplane) {
                return checknum;
            }

            // Found a visplane, but we can't add anymore.
            // Resize right away. This shouldn't take too long.
            if (lastvisplane == MAXVISPLANES) {
                // I.Error ("R_FindPlane: no more visplanes");
                ResizeVisplanes();
            }
        }

        // We found a visplane (possibly one allocated on a previous tic)
        // but we can't link directly to it, we need to copy its data
        // around.

        checknum = new Integer(Math.max(0, lastvisplane));

        chk = visplanes[checknum];
        // Add a visplane
        lastvisplane++;
        chk.height = height;
        chk.picnum = picnum;
        chk.lightlevel = lightlevel;
        chk.minx = SCREENWIDTH;
        chk.maxx = -1;
        chk.updateHashCode();
        planehash.put(chk, checknum);
        // memset (chk.top,0xff,sizeof(chk.top));
        chk.clearTop();

        return checknum;
    }
    */
    
}

package rr;

public class base_ratio_t {

  public base_ratio_t(int base_width, int base_height, int psprite_offset,
            int multiplier, float gl_ratio) {
        this.base_width = base_width;
        this.base_height = base_height;
        this.psprite_offset = psprite_offset;
        this.multiplier = multiplier;
        this.gl_ratio = (float) (RMUL*gl_ratio);
    }

public int base_width;      // Base width (unused)
  public int base_height;     // Base height (used for wall visibility multiplier)
  public  int psprite_offset;  // Psprite offset (needed for "tallscreen" modes)
  public  int multiplier;      // Width or height multiplier
  public  float gl_ratio;
  
  public static final double RMUL =1.6d/1.333333d;
  
}
package awt;

import static g.Keys.*;
import i.DoomEventInterface;

import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.KeyEventDispatcher;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.LinkedList;

import doom.DoomMain;
import doom.event_t;
import doom.evtype_t;

public class AWTEvents2 implements WindowListener,KeyEventDispatcher,KeyListener,MouseListener,MouseMotionListener,DoomEventInterface {

    // modifications of eventQueue must be thread safe!
    public LinkedList<DoomEvent> eventQueue = new LinkedList<DoomEvent>();

    public DoomMain DM;
    public Component canvas;
    Robot robby;

    public AWTEvents2(DoomMain DM, Component canvas) {
        this.DM = DM;
        this.canvas = canvas;

        // AWT: create cursors.
        this.normal=canvas.getCursor();
        this.hidden=this.createInvisibleCursor();
        
        // Create AWT Robot for forcing mouse
        try {
        robby=new Robot();
        } catch (Exception e){
          System.out.println("AWT Robot could not be created, mouse input focus will be loose!");
        }

    }
    
    //////////// LISTENERS //////////
    
    @Override
    public void mouseClicked(MouseEvent mouseevent) {
        addEvent(mouseevent);
    }

    @Override
    public void mouseEntered(MouseEvent mouseevent) {
        addEvent(mouseevent);
    }

    @Override
    public void mouseExited(MouseEvent mouseevent) {
        addEvent(mouseevent);

        relockMouse(mouseevent);
    }

    @Override
    public void mousePressed(MouseEvent mouseevent) {
        addEvent(mouseevent);
        
    }

    @Override
    public void mouseReleased(MouseEvent mouseevent) {
        addEvent(mouseevent);
        
    }

    @Override
    public void mouseDragged(MouseEvent mouseevent) {
        //addEvent(mouseevent);
        mouseMoved(mouseevent);
        
    }

    ArrayList<Point[]> cancelMoves = new ArrayList<Point[]>();
    
    Point lastMousePos = new Point(0,0);
    
    @Override
    public void mouseMoved(MouseEvent mouseevent) {
        DoomEvent dEv = new DoomEvent(mouseevent);
        Point srcPos = lastMousePos;
        Point destPos = mouseevent.getLocationOnScreen();
        Point deltaPoint = new Point(destPos.x-srcPos.x, destPos.y-srcPos.y);
        dEv.deltaPoint = deltaPoint;
        addEvent(dEv);

        relockMouse(mouseevent);
    }
    
    public void relockMouse(MouseEvent mouseevent) {
        if (canvas.hasFocus()) {
            Point destPoint = new Point(canvas.getX()+canvas.getWidth()/2, canvas.getY()+canvas.getHeight()/2);

            canvas.removeMouseListener(this);
            robby.mouseMove(destPoint.x, destPoint.y);
            canvas.addMouseListener(this);
        }
        
        lastMousePos = MouseInfo.getPointerInfo().getLocation();
    }
    
    
    @Override
    public boolean dispatchKeyEvent(KeyEvent e) {
        return false;
    }

    @Override
    public void windowActivated(WindowEvent windowevent) {
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);
        
    }

    @Override
    public void windowClosed(WindowEvent windowevent) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void windowClosing(WindowEvent windowevent) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void windowDeactivated(WindowEvent windowevent) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void windowDeiconified(WindowEvent windowevent) {
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);
        
    }

    @Override
    public void windowIconified(WindowEvent windowevent) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void windowOpened(WindowEvent windowevent) {
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);
        
    }

    
    public void keyPressed(KeyEvent e) {
        //if ((e.getModifiersEx() & UNACCEPTABLE_MODIFIERS) ==0) {
        if (isAcceptableKey(new DoomEvent(e))) {
            addEvent(e);
        }
        
        
        e.consume();
    }

    public void keyReleased(KeyEvent e) {
        //if ((e.getModifiersEx() & UNACCEPTABLE_MODIFIERS) ==0) {
        if (isAcceptableKey(new DoomEvent(e))) {
            addEvent(e);
        }
        
        e.consume();
    }

    public void keyTyped(KeyEvent e) {
    //  if ((e.getModifiersEx() & UNACCEPTABLE_MODIFIERS) ==0){
        if (isAcceptableKey(new DoomEvent(e))) {
            addEvent(e);
        }
    }
    
    
    int AWTMouseToKey(DoomEvent ev) {
        int buttonIdx = ev.getButton() - MouseEvent.BUTTON1;
        return KEY_MOUSE1+buttonIdx;
    }
    
    // number of total 'button' inputs, include keyboard keys, plus virtual
    // keys (mousebuttons and joybuttons becomes keys)
    public static final int NUMKEYS         = 256;

    public static final int MOUSEBUTTONS    = 8;
    public static final int JOYBUTTONS      = 14;  // 10 bases + 4 hat
    
    //
    // mouse and joystick buttons are handled as 'virtual' keys
    //
    public static final int KEY_MOUSE1        = NUMKEYS;                  
    public static final int KEY_JOY1          = KEY_MOUSE1+MOUSEBUTTONS;  
    public static final int KEY_DBLMOUSE1     = KEY_JOY1+JOYBUTTONS;        // double clicks
    public static final int KEY_DBLJOY1       = KEY_DBLMOUSE1+MOUSEBUTTONS;
    public static final int KEY_2MOUSE1       = KEY_DBLJOY1+JOYBUTTONS;
    public static final int KEY_DBL2MOUSE1    = KEY_2MOUSE1+MOUSEBUTTONS;
    public static final int KEY_MOUSEWHEELUP  = KEY_DBL2MOUSE1+MOUSEBUTTONS;
    public static final int KEY_MOUSEWHEELDOWN= KEY_MOUSEWHEELUP+1;
    public static final int KEY_2MOUSEWHEELUP = KEY_MOUSEWHEELUP+2;
    public static final int KEY_2MOUSEWHEELDOWN= KEY_MOUSEWHEELUP+3;
    public static final int NUMINPUTS = KEY_MOUSEWHEELUP+4;
    
    int currentMouseButtons = 0;
    
    @Override
    public void GetEvent() {
        DoomEvent X_event;
        event_t event=new event_t();;
        // put event-grabbing stuff in here
        if (eventQueue.isEmpty()) return;   
        X_event=nextEvent();
        //System.out.println("Event type:"+X_event.getID());

        // Check for Event.??? shit
        if (!ignorebutton){
            switch (X_event.getID())
            {
            case Event.KEY_PRESS:
                event=new event_t(evtype_t.ev_keydown, xlatekey(/*(KeyEvent)*/X_event));
                DM.PostEvent(event);
                //System.err.println("k");
                break;
            case Event.KEY_RELEASE:
                event=new event_t(evtype_t.ev_keyup, xlatekey(/*(KeyEvent)*/X_event));
                DM.PostEvent(event);
                //System.err.println( "ku");
                break;
            }
        }

        switch (X_event.getID()){
        // ButtonPress
        case Event.MOUSE_DOWN:
            /*
            currentMouseButtons = (X_event.getButton() == MouseEvent.BUTTON1 ? 1 : 0)
            | ((X_event.getButton() == MouseEvent.BUTTON3) ? 2 : 0)
            | ((X_event.getButton() == MouseEvent.BUTTON2) ? 4 : 0);*/


            event.data1 = AWTMouseToKey(X_event);
            event.data2 = event.data3 = 0;
            event.type=evtype_t.ev_keydown;//ev_mouse;
            DM.PostEvent(event);
            break;
            // ButtonRelease
        case Event.MOUSE_UP:
            event.type = evtype_t.ev_keyup;// ev_mouse;
/*
            currentMouseButtons = currentMouseButtons
            & ~(X_event.getButton() == MouseEvent.BUTTON1 ? 1 : 0)
            & ~(X_event.getButton() == MouseEvent.BUTTON3 ? 2 : 0)
            & ~(X_event.getButton() == MouseEvent.BUTTON2 ? 4 : 0);*/

            event.data1 = AWTMouseToKey(X_event);
            event.data2 = event.data3 = 0;
            DM.PostEvent(event);
            break;
            // MotionNotify:
        case Event.MOUSE_MOVE:
        case Event.MOUSE_DRAG:
            event.type = evtype_t.ev_mouse;
            // Get buttons, as usual.
            event.data1 = currentMouseButtons;
            event.data2 = X_event.deltaPoint.x << 2;
            event.data3 = -X_event.deltaPoint.y << 2;

            if ((event.data2 | event.data3)!=0) {
                DM.PostEvent(event);
            }
            break;
        case Event.MOUSE_ENTER:
            System.err.println("ACCEPTING keyboard input");
            canvas.requestFocus();
            canvas.setCursor(hidden);
            ignorebutton=false;
            break;
        case Event.MOUSE_EXIT:
            System.err.println("IGNORING keyboard input");
            canvas.setCursor(normal);

            ignorebutton=true;
            break;
        case Event.WINDOW_EXPOSE:
            // No real single equivalent for "ConfigureNotify"
        case Event.WINDOW_MOVED:
        case Event.WINDOW_DESTROY:
            break;
        default:
            // NOT NEEDED in AWT if (doShm && X_event.type == X_shmeventtype) shmFinished = true;
            break;

        }

    }

    
    boolean isAcceptableKey(DoomEvent e) {
        return e.getKeyCode()<=KeyEvent.VK_F12 || e.getKeyChar()=='#';
    }
    

    void addEvent(AWTEvent ev) {
        addEvent(new DoomEvent(ev));

        if (ev instanceof InputEvent) {
            ((InputEvent)ev).consume();
        }
    }

    void addEvent(DoomEvent ev) {
        synchronized (eventQueue) {
            eventQueue.addLast(ev);
        }
    }

    public DoomEvent nextEvent() {
        DoomEvent ev;
        synchronized (eventQueue) {
            ev = (!eventQueue.isEmpty())?(DoomEvent)eventQueue.removeFirst():null;
        }
        return ev;
    }
    
    public static class DoomEvent {
        int keyCode;
        char keyChar;
        int ID;
        int button;
        int x;
        int y;
        Point deltaPoint;
        
        public DoomEvent(AWTEvent evt) {
            this.ID = evt.getID();
            if (evt instanceof KeyEvent) {
                this.keyChar = ((KeyEvent)evt).getKeyChar();
                this.keyCode = ((KeyEvent)evt).getKeyCode();
            }
            if (evt instanceof MouseEvent) {
                this.button = ((MouseEvent)evt).getButton();
                this.x = ((MouseEvent)evt).getX();
                this.y = ((MouseEvent)evt).getY();
            }
        }

        public int getKeyCode() {
            return keyCode;
        }

        public char getKeyChar() {
            return keyChar;
        }

        public int getID() {
            return ID;
        }

        public int getButton() {
            return button;
        }
        
        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }
    }

    
    /** FIXME: input must be made scancode dependent rather than VK_Dependent,
     *  else a lot of things just don't work. 
     * 
     * @param e
     * @return
     */

    public int xlatekey(DoomEvent e)
    {

      int rc;

      switch(rc =     e.getKeyCode())
      
          //Event.XKeycodeToKeysym(X_display, X_event.xkey.keycode, 0))

      {
      case KeyEvent.VK_LEFT:    rc = KEY_LEFTARROW; break;
      case KeyEvent.VK_RIGHT:   rc = KEY_RIGHTARROW;    break;
      case KeyEvent.VK_DOWN:    rc = KEY_DOWNARROW; break;
      case KeyEvent.VK_UP:  rc = KEY_UPARROW;   break;
        case KeyEvent.VK_ESCAPE:  rc = KEY_ESCAPE;    break;
        case KeyEvent.VK_ENTER:   rc = KEY_ENTER;     break;
        case KeyEvent.VK_CONTROL: rc= KEY_CTRL; break;
        case KeyEvent.VK_ALT: rc=KEY_ALT; break;
        case KeyEvent.VK_SHIFT: rc=KEY_SHIFT; break;
        // Added handling of pgup/pgdown/home etc.
        case KeyEvent.VK_PAGE_DOWN: rc= KEY_PGDN;	break;
        case KeyEvent.VK_PAGE_UP: rc= KEY_PGUP;	break;
        case KeyEvent.VK_HOME: rc= KEY_HOME;	break;
        case KeyEvent.VK_F1:  rc = KEY_F1;        break;
        case KeyEvent.VK_F2:  rc = KEY_F2;        break;
        case KeyEvent.VK_F3:  rc = KEY_F3;        break;
        case KeyEvent.VK_F4:  rc = KEY_F4;        break;
        case KeyEvent.VK_F5:  rc = KEY_F5;        break;
        case KeyEvent.VK_F6:  rc = KEY_F6;        break;
        case KeyEvent.VK_F7:  rc = KEY_F7;        break;
        case KeyEvent.VK_F8:  rc = KEY_F8;        break;
        case KeyEvent.VK_F9:  rc = KEY_F9;        break;
        case KeyEvent.VK_F10: rc = KEY_F10;       break;
        case KeyEvent.VK_F11: rc = KEY_F11;       break;
        case KeyEvent.VK_F12: rc = KEY_F12;       break;
        
        case KeyEvent.VK_BACK_SPACE:
        case KeyEvent.VK_DELETE:  rc = KEY_BACKSPACE; break;

        case KeyEvent.VK_PAUSE:   rc = KEY_PAUSE;     break;

        case KeyEvent.KEY_RELEASED:
        case KeyEvent.VK_TAB: rc = KEY_TAB;       break;
        
        case KeyEvent.KEY_PRESSED:
            switch(e.getKeyCode()){
            
        case KeyEvent.VK_PLUS:
        case KeyEvent.VK_EQUALS: 
            rc = KEY_EQUALS;    
            break;
        
        case (13):
        case KeyEvent.VK_SUBTRACT: 
        case KeyEvent.VK_MINUS:   
            rc = KEY_MINUS;     
            break;

        case KeyEvent.VK_SHIFT:
        rc = KEY_SHIFT;
        break;
        
        case KeyEvent.VK_CONTROL:
        rc = KEY_CTRL;
        break;                           
       
        case KeyEvent.VK_ALT:
        rc = KEY_ALT;
        break;

        case KeyEvent.VK_SPACE:
            rc = ' ';
            break;

            }
            
        default:
            
       /*if (rc >= KeyEvent.VK_SPACE && rc <= KeyEvent.VK_DEAD_TILDE)
            {
            rc = (int) (rc - KeyEvent.FOCUS_EVENT_MASK + ' ');
            break;
            } */
        if (rc >= KeyEvent.VK_A && rc <= KeyEvent.VK_Z){
            rc = rc-KeyEvent.VK_A +'a';
            break;
            }
        // Unknown. Probably fucking up with the keyboard locale. Switch to be sure.
        // Sorry for this horrible hack, but Java can't read locale-free keycodes -_-
        // this.getInputContext().selectInputMethod(java.util.Locale.US);
        //if (rc>KEY_F12) rc=KEY_RSHIFT;
        break;
      }
      
     //System.out.println("Typed "+e.getKeyCode()+" char "+e.getKeyChar()+" mapped to "+Integer.toHexString(rc));

      // Sanitize. Nothing beyond F12 must pass through, else you will
      // get the "all cheats" bug.
      return rc;//Math.min(rc,KEY_F12);

    }
    
    // This stuff should NOT get through in keyboard events.
    protected final int UNACCEPTABLE_MODIFIERS=(int) (InputEvent.ALT_GRAPH_DOWN_MASK+
                                             InputEvent.META_DOWN_MASK+
                                             InputEvent.META_MASK+
                                             InputEvent.WINDOW_EVENT_MASK+
                                             InputEvent.WINDOW_FOCUS_EVENT_MASK);

    protected boolean ignorebutton;

      /** Returns true if flags are included in arg.
       * Synonymous with (flags & arg)!=0
       * 
       * @param flags
       * @param arg
       * @return
       */
      public static final boolean flags(int flags, int arg){
          return ((flags & arg)!=0);
      }
      

      Cursor hidden;
      Cursor normal;

    /**
    * NASTY hack to hide the cursor.
    * 
    * Create a 'hidden' cursor by using a transparent image
    * ...return the invisible cursor
    */

    protected Cursor createInvisibleCursor()

    {
    Dimension bestCursorDim = Toolkit.getDefaultToolkit().getBestCursorSize(2, 2);
    BufferedImage transparentImage = new BufferedImage(bestCursorDim.width, bestCursorDim.height, BufferedImage.TYPE_INT_ARGB);
    Cursor hiddenCursor = Toolkit.getDefaultToolkit( ).createCustomCursor(transparentImage, new Point(1, 1),    "HiddenCursor");
    return hiddenCursor;
    }
}

package awt;

import java.awt.*;

import java.awt.event.*;

import javax.swing.JLabel;

/** A convenient message box class to pop up here and there.
 *  
 * @author zyklon
 *
 */

public class MsgBox extends Dialog implements ActionListener {
	/**
	 * 
	 */
	private static final long serialVersionUID = -872019680203708495L;
	private Button ok, can;
	private boolean isOk = false;

	/*  
	 * * @param frame parent frame
	 * 
	 * @param msg message to be displayed
	 * 
	 * @param okcan true : ok cancel buttons, false : ok button only
	 */

	public boolean isOk() {
		return isOk;
	}

	public MsgBox(Frame frame, String title, String msg, boolean okcan) {
		super(frame, title, true);
		setLayout(new BorderLayout());
		add("Center", new JLabel(msg));
		addOKCancelPanel(okcan);
		createFrame();
		pack();
		setVisible(true);
		this.can.requestFocus();
	}

	public MsgBox(Frame frame, String msg) {
		this(frame, "Message", msg, false);
	}

	private void addOKCancelPanel(boolean okcan) {
		Panel p = new Panel();
		p.setLayout(new FlowLayout());
		createOKButton(p);
		if (okcan == true)
			createCancelButton(p);
		add("South", p);
	}

	private void createOKButton(Panel p) {
		p.add(ok = new Button("OK"));
		ok.addActionListener(this);
	}

	private void createCancelButton(Panel p) {
		p.add(can = new Button("Cancel"));
		can.addActionListener(this);
	}

	private void createFrame() {
		Dimension d = getToolkit().getScreenSize();
		setLocation(d.width / 3, d.height / 3);		
	}

	public void actionPerformed(ActionEvent ae) {
		if (ae.getSource() == ok) {
			isOk = true;
			setVisible(false);
		} else if (ae.getSource() == can) {
			setVisible(false);
		}
	}

	/*
	 * public static void main(String args[]) { //Frame f = new Frame();
	 * //f.setSize(200,200); //f.setVisible(true); MsgBox message = new MsgBox
	 * (null , "Hey you user, are you sure ?", true); if (message.isOk)
	 * System.out.println("Ok pressed"); if (!message.isOk)
	 * System.out.println("Cancel pressed"); message.dispose(); }
	 */
}
package awt;

import java.awt.Canvas;
import java.awt.Graphics;
import java.awt.Graphics2D;
import v.DoomVideoRenderer;
import doom.DoomMain;

/** A simple Doom display & keyboard driver for AWT.
 *  Uses a Canvas for painting and implements some
 *  of the IVideo methods.
 * 
 *  Uses 8-bit buffered images and switchable IndexColorModels.
 *  
 *  It's really basic, but allows testing and user interaction.
 *  Heavily based on the original LinuxDoom X11 implementation, and
 *  is similar in goals: just a functional, reference implementation
 *  to build upon whatever fancy extensions you like.
 *  
 *  The only "hitch" is that this implementation expects to be 
 *  initialized upon a BufferedRenderer with multiple images per 
 *  screen buffer in order to perform the palette switching trick.
 *  
 *  The images themselves don't have to be "BufferedImage",
 *  and in theory it could be possible to use e.g. MemoryImageSource
 *  for the same purpose . Oh well.
 *    
 *  
 * 
 * @author Velktron
 *
 */
public abstract class AWTDoom<V> extends DoomFrame<V> {


		/**
     * 
     */
    private static final long serialVersionUID = 1L;

        /** Gimme some raw palette RGB data.
		 *  I will do the rest
		 *  
		 *  (hint: read this from the PLAYPAL
		 *   lump in the IWAD!!!).
		 * 
		 */
     
        public AWTDoom(DoomMain<?,V> DM, DoomVideoRenderer<?,V> V) {
      		super(DM, V);
      		drawhere=new Canvas();
      		gelatine=new Canvas();
        // Don't do anything yet until InitGraphics is called.
        }
        
    	public void SetGamma(int level){
    		if (D) System.err.println("Setting gamma "+level);
    		V.setUsegamma(level);
    		screen=V.getCurrentScreen(); // Refresh screen after change.
    		RAWSCREEN=V.getScreen(DoomVideoRenderer.SCREEN_FG);
    	}
        
public static final class HiColor extends AWTDoom<short[]>{
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public HiColor(DoomMain<?, short[]> DM, DoomVideoRenderer<?,short[]> V) {
        super(DM, V);
    }

    @Override
    public void ReadScreen(short[] scr) {
        System.arraycopy(this.RAWSCREEN, 0, scr, 0, RAWSCREEN.length);
        }
    
    @Override
    public void FinishUpdate() {
        int     tics;
        int     i;
        
        // draws little dots on the bottom of the screen
        /*if (true)
        {

        i = I.GetTime();
        tics = i - lasttic;
        lasttic = i;
        if (tics > 20) tics = 20;
        if (tics < 1) tics = 1;

        for (i=0 ; i<tics*2 ; i+=2)
            RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = (byte) 0xff;
        for ( ; i<20*2 ; i+=2)
            RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
        
        } */

        if (true)
        {

        i = TICK.GetTime();
        tics = i - lasttic;
        lasttic = i;
        if (tics<1) 
            frames++;
        else
        {
        //frames*=35;
        for (i=0 ; i<frames*2 ; i+=2)
            RAWSCREEN[ (height-1)*width + i] = (short) 0xffff;
        for ( ; i<20*2 ; i+=2)
            RAWSCREEN[ (height-1)*width + i] = 0x0;
        frames=0;
        }
        }

        this.update(null);
        //this.getInputContext().selectInputMethod(java.util.Locale.US);
        
    }
}

public static final class Indexed extends AWTDoom<byte[]>{
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public Indexed(DoomMain<?,byte[]> DM, DoomVideoRenderer<?,byte[]> V) {
        super(DM, V);
    }

    @Override
    public void ReadScreen(byte[] scr) {
        System.arraycopy(this.RAWSCREEN, 0, scr, 0, RAWSCREEN.length);
        }
    
    @Override
    public void FinishUpdate() {
        int     tics;
        int     i;
        
        // draws little dots on the bottom of the screen
        /*if (true)
        {

        i = I.GetTime();
        tics = i - lasttic;
        lasttic = i;
        if (tics > 20) tics = 20;
        if (tics < 1) tics = 1;

        for (i=0 ; i<tics*2 ; i+=2)
            RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = (byte) 0xff;
        for ( ; i<20*2 ; i+=2)
            RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
        
        } */

        if (true)
        {

        i = TICK.GetTime();
        tics = i - lasttic;
        lasttic = i;
        if (tics<1) 
            frames++;
        else
        {
        //frames*=35;
        for (i=0 ; i<frames*2 ; i+=2)
            RAWSCREEN[ (height-1)*width + i] = (short) 0xffff;
        for ( ; i<20*2 ; i+=2)
            RAWSCREEN[ (height-1)*width + i] = 0x0;
        frames=0;
        }
        }

        this.update(null);
        //this.getInputContext().selectInputMethod(java.util.Locale.US);
        
    }
}

public static final class TrueColor extends AWTDoom<int[]>{
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public TrueColor(DoomMain<?, int[]> DM, DoomVideoRenderer<?,int[]> V) {
        super(DM, V);
    }

    @Override
    public void ReadScreen(int[] scr) {
        System.arraycopy(this.RAWSCREEN, 0, scr, 0, RAWSCREEN.length);
        }
    
    @Override
    public void FinishUpdate() {
        int     tics;
        int     i;
        
        // draws little dots on the bottom of the screen
        /*if (true)
        {

        i = I.GetTime();
        tics = i - lasttic;
        lasttic = i;
        if (tics > 20) tics = 20;
        if (tics < 1) tics = 1;

        for (i=0 ; i<tics*2 ; i+=2)
            RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = (byte) 0xff;
        for ( ; i<20*2 ; i+=2)
            RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
        
        } */

        if (true)
        {

        i = TICK.GetTime();
        tics = i - lasttic;
        lasttic = i;
        if (tics<1) 
            frames++;
        else
        {
        //frames*=35;
        for (i=0 ; i<frames*2 ; i+=2)
            RAWSCREEN[ (height-1)*width + i] = (short) 0xffff;
        for ( ; i<20*2 ; i+=2)
            RAWSCREEN[ (height-1)*width + i] = 0x0;
        frames=0;
        }
        }

        this.update(null);
        //this.getInputContext().selectInputMethod(java.util.Locale.US);
        
    }
}

}

//$Log: AWTDoom.java,v $
//Revision 1.16  2012/11/06 16:04:34  velktron
//Spiffy new fullscreen switching system.
//
//Revision 1.15  2012/09/24 17:16:23  velktron
//Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
//Revision 1.14.2.5  2012/09/24 16:58:06  velktron
//TrueColor, Generics.
//
//Revision 1.14.2.4  2012/09/20 14:06:58  velktron
//Generic AWTDoom
//
//Revision 1.14.2.3  2012/09/17 15:57:07  velktron
//Moved common code to DoomFrame
//
//Revision 1.14.2.2  2011/11/18 21:38:30  velktron
//Uses 16-bit stuff.
//
//Revision 1.14.2.1  2011/11/14 00:27:11  velktron
//A barely functional HiColor branch. Most stuff broken. DO NOT USE
//
//Revision 1.14  2011/11/01 19:03:10  velktron
//Using screen number constants
//
//Revision 1.13  2011/10/23 18:11:07  velktron
//Split functionality into DoomFrame, gerenic compliance.
//
//Revision 1.12  2011/10/11 13:24:51  velktron
//Major overhaul to work with new renderer interface. Now only available windowing system.
//
//Revision 1.11  2011/08/01 00:59:57  velktron
//Shut up debug messages.
//
//Revision 1.10  2011/07/15 13:57:54  velktron
//Implement VI.ReadScreen as a future good practice.
//
//Revision 1.9  2011/06/23 15:42:38  velktron
//Added modular palette rotation to handle sub-14 cases.
//
//Revision 1.8  2011/06/14 09:54:20  velktron
//Separated palette generation/fixed OldAWTDoom
//
//Revision 1.7  2011/06/08 17:24:59  velktron
//Added support for gamma changes.
//
//Revision 1.6  2011/06/02 14:54:18  velktron
//Old AWTEvents deprecated. MochaEvents now default.
//
//Revision 1.3  2011/06/01 17:42:49  velktron
//Removed stupid nagging.
//
//Revision 1.2  2011/06/01 17:17:24  velktron
//New event system.
//
//Revision 1.1  2011/06/01 17:04:23  velktron
//New event system.
//
//Revision 1.4  2011/05/30 02:25:50  velktron
//Centering and offsetting on expose, proper exiting.
//
//Revision 1.3  2011/05/29 22:15:32  velktron
//Introduced IRandom interface.
//
//Revision 1.2  2011/05/29 20:58:58  velktron
//Added better mouse grabbing method, more reliable, more cross-OS.
//
//Revision 1.1  2011/05/27 13:26:56  velktron
//A slightly better, though not perfect, way to handle input, partially based on_D_'s work.
//
package awt;

import static g.Keys.*;
import i.DoomEventInterface;

import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.LinkedList;

import doom.DoomMain;
import doom.event_t;
import doom.evtype_t;

/** A very basic event handling class, directly based on linuxdoom's.
 *  Sadly, it doesn't work so well cross-platform. Use MochaEvents instead.
 * 
 * @author velktron
 *
 */

@Deprecated
public class AWTEvents implements WindowListener,KeyEventDispatcher,KeyListener,MouseListener,MouseMotionListener,DoomEventInterface {

    // modifications of eventQueue must be thread safe!
    static LinkedList<AWTEvent> eventQueue = new LinkedList<AWTEvent>();

    //// STATUS STUFF ///////////
    public final DoomMain DM;
    public final Component canvas;
    Robot robby;
    Cursor hidden;
    Cursor normal;

    //////// CURRENT MOVEMENT AND INPUT STATUS //////////////

    protected static final int POINTER_WARP_COUNTDOWN = 1;
    protected int lastmousex;
    protected int lastmousey;
    protected Point lastmouse;
    protected int mousedx;
    protected int mousedy;
    protected boolean mousemoved;
    protected boolean ignorebutton;
    protected boolean grabMouse=true;
    protected int doPointerWarp=POINTER_WARP_COUNTDOWN;


    public AWTEvents(DoomMain DM, Component canvas) {
        this.DM = DM;
        this.canvas = canvas;

        // AWT: create cursors.
        this.normal=canvas.getCursor();
        this.hidden=this.createInvisibleCursor();

        // Create AWT Robot for forcing mouse
        try {
            robby=new Robot();
        } catch (Exception e){
            System.out.println("AWT Robot could not be created, mouse input focus will be loose!");
        }
        
    }

    //////////// LISTENERS //////////

    @Override
    public boolean dispatchKeyEvent(KeyEvent e) {

        return false;
    }

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode()<=KeyEvent.VK_F12) {  
            addEvent(e);            
        }

        e.consume();
    }

    public void keyReleased(KeyEvent e) {

        //if ((e.getModifiersEx() & UNACCEPTABLE_MODIFIERS) ==0) {
        if (e.getKeyCode()<=KeyEvent.VK_F12) {
            addEvent(e);
        }
        e.consume();
    }

    public void keyTyped(KeyEvent e) {
        if (e.getKeyCode()<=KeyEvent.VK_F12) {
            addEvent(e);
        }

        e.consume();        
    }

    ///////////////////// MOUSE EVENTS   ///////////////////////

    @Override
    public void mouseClicked(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }

    @Override
    public void mouseEntered(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }

    @Override
    public void mouseExited(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }

    @Override
    public void mousePressed(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }

    @Override
    public void mouseReleased(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }

    @Override
    public void mouseDragged(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }

    @Override
    public void mouseMoved(MouseEvent mouseevent) {
        addEvent(mouseevent);

    }


    ///////////////////// QUEUE HANDLING ///////////////////////

    static void addEvent(AWTEvent ev) {
        synchronized (eventQueue) {
            eventQueue.addLast(ev);
        }
    }

    public static AWTEvent nextEvent() {
        AWTEvent ev;
        synchronized (eventQueue) {
            ev = (!eventQueue.isEmpty())?(AWTEvent)eventQueue.removeFirst():null;
        }
        return ev;
    }

    // This event here is used as a static scratch copy. When sending out
    // messages, its contents are to be actually copied (struct-like).
    // This avoids the continuous object creation/destruction overhead,
    // And it also allows creating "sticky" status.

    final event_t event=new event_t();
    // Special FORCED and PAINFUL key and mouse cancel event.
    final event_t cancelkey=new event_t(evtype_t.ev_clear,0xFF,0,0);
    final event_t cancelmouse=new event_t(evtype_t.ev_mouse,0,0,0);
    int prevmousebuttons;
    
    @Override
    public void GetEvent() {
        AWTEvent X_event;
        MouseEvent MEV;
        Point tmp;

        // put event-grabbing stuff in here
        if (eventQueue.isEmpty()) return;   
        X_event=nextEvent();
        //System.out.println("Event type:"+X_event.getID());

        // Keyboard events get priority vs mouse events.
        // In the case of combined input, however, we need
        if (!ignorebutton){
            switch (X_event.getID())
            {
            case Event.KEY_PRESS: {

                event.type=evtype_t.ev_keydown;
                event.data1=xlatekey((KeyEvent)X_event);
                DM.PostEvent(event);
                if (prevmousebuttons!=0){
                    
                // Allow combined mouse/keyboard events.
                event.data1=prevmousebuttons;
                event.type=evtype_t.ev_mouse;
                DM.PostEvent(event);
                }
                //System.err.println("k");
                break;
            }
            case Event.KEY_RELEASE:
                event.type=evtype_t.ev_keyup;
                event.data1=xlatekey((KeyEvent)X_event);
                DM.PostEvent(event);
                
                if (prevmousebuttons!=0){
                    
                    // Allow combined mouse/keyboard events.
                    event.data1=prevmousebuttons;
                    event.type=evtype_t.ev_mouse;
                    DM.PostEvent(event);
                    }
                //System.err.println( "ku");
                break;
            }
        }

        // Mouse events are also handled, but with secondary priority.
        switch (X_event.getID()){
        // ButtonPress
        case Event.MOUSE_DOWN:
            MEV=(MouseEvent)X_event;
            event.type=evtype_t.ev_mouse;
            event.data1 = prevmousebuttons=
                (MEV.getButton() == MouseEvent.BUTTON1 ? 1: 0) |
                (MEV.getButton() == MouseEvent.BUTTON2 ? 2: 0)|
                (MEV.getButton() == MouseEvent.BUTTON3 ? 4: 0);
            event.data2 = event.data3 = 0;

            DM.PostEvent(event);
            //System.err.println( "b");
            break;

            // ButtonRelease
            // This must send out an amended event.

        case Event.MOUSE_UP:
            MEV=(MouseEvent)X_event;
            event.type = evtype_t.ev_mouse;
            event.data1 =prevmousebuttons^= 
                (MEV.getButton() == MouseEvent.BUTTON1 ? 1: 0) |
                (MEV.getButton() == MouseEvent.BUTTON2 ? 2: 0)|
                (MEV.getButton() == MouseEvent.BUTTON3 ? 4: 0);
            // A PURE mouse up event has no movement.
            event.data2 = event.data3 = 0;
            DM.PostEvent(event);
            //System.err.println("bu");
            break;
            // MotionNotify:
        case Event.WINDOW_MOVED:
        	// Moving the window does change the absolute reference point, while events only
        	// give a RELATIVE one.
        	offset.x=(int) (canvas.getLocationOnScreen().x);
        	offset.y=(int) (canvas.getLocationOnScreen().y);
        	//System.out.printf("Center MOVED to %d %d\n", center.x, center.y);
        case Event.MOUSE_MOVE:
            MEV=(MouseEvent)X_event;
            tmp=MEV.getPoint();
            //this.AddPoint(tmp,center);
            event.type = evtype_t.ev_mouse;
            this.mousedx=tmp.x-this.lastmousex;
            this.mousedy=this.lastmousey-tmp.y;
            this.lastmousex=tmp.x;
            this.lastmousey=tmp.y;                 
            MEV=(MouseEvent)X_event;
            // A pure move has no buttons.
            event.data1=prevmousebuttons=0;
            event.data2 = (mousedx) << 3;
            event.data3 = (mousedy) << 3;

           // System.out.printf("Mouse MOVED to %d %d\n", lastmousex, lastmousey);
            //System.out.println("Mouse moved without buttons: "+event.data1);
            if ((event.data2 | event.data3)!=0)
            {

                DM.PostEvent(event);
                //System.err.println( "m");
                mousemoved = true;
            } else
            {
                mousemoved = false;
            }
            break;


        case Event.MOUSE_DRAG:
            MEV=(MouseEvent)X_event;
            tmp=MEV.getPoint();
            //this.AddPoint(tmp,center);
            this.mousedx=tmp.x-this.lastmousex;
            this.mousedy=this.lastmousey-tmp.y;
            this.lastmousex=tmp.x;
            this.lastmousey=tmp.y;
           // System.out.printf("Mouse MOVED to %d %d\n", lastmousex, lastmousey);

            event.type = evtype_t.ev_mouse;
            // Get buttons, as usual.
            // Well, NOT as usual: in case of a drag, the usual 
            // mousebutton flags don't work. A "drag" means that at
            // least the 1st mouse button is held down, while the other
            // two might or might not be so.
            event.data1 = prevmousebuttons;
                //(MEV.getModifiers() == MouseEvent.BUTTON1_DOWN_MASK ? 1: 0)|
                //(MEV.getModifiers() == MouseEvent.BUTTON2_DOWN_MASK ? 2: 0)|
                //(MEV.getModifiers() == MouseEvent.BUTTON3_DOWN_MASK ? 4: 0);
            event.data2 = (mousedx) << 3;
            event.data3 = (mousedy) << 3;

            //System.out.printf("Mouse DRAGGED to %d %d\n", mousedx, mousedy);
            //System.out.println("Mouse moved with buttons pressed: "+event.data1);
            if ((event.data2 | event.data3)!=0)
            {
                DM.PostEvent(event);
                //System.err.println( "m");
                mousemoved = false;
            } else
            {
                mousemoved = true;
            }
            break;
        case Event.MOUSE_ENTER:
            //System.err.println("ACCEPTING keyboard input");
            canvas.requestFocus();
            canvas.setCursor(hidden);
        	offset.x=(int) (canvas.getLocationOnScreen().x);
        	offset.y=(int) (canvas.getLocationOnScreen().y);
        	System.out.printf("Offset MOVED to %d %d\n", offset.x, offset.y);
            this.grabMouse();
            ignorebutton=false;
            break;
        case Event.MOUSE_EXIT:
            // Forcibly clear events                 

            DM.PostEvent(cancelmouse);
            DM.PostEvent(cancelkey);
            reposition();
        	System.out.printf("FORCED and PAINFUL event clearing!\n");
            canvas.setCursor(normal);             
            ignorebutton=true;
            break;
        case Event.WINDOW_EXPOSE:
        	offset.x=(int) (canvas.getLocationOnScreen().x);
        	offset.y=(int) (canvas.getLocationOnScreen().y);
        	System.out.printf("Center MOVED to %d %d\n", offset.x, offset.y);
            // No real single equivalent for "ConfigureNotify"

        case Event.WINDOW_DESTROY:
            break;
        default:
            // NOT NEEDED in AWT if (doShm && X_event.type == X_shmeventtype) shmFinished = true;
            break;

        }

    }

	/** Update relative position offset, and force mouse there.
	 * 
	 */
	void reposition() {
		lastmousex=canvas.getWidth()/2;
		lastmousey=canvas.getHeight()/2;
		offset.x=(int) (canvas.getLocationOnScreen().x);
		offset.y=(int) (canvas.getLocationOnScreen().y);
	}
    
    Point offset=new Point();

    /** Returns true if flags are included in arg.
     * Synonymous with (flags & arg)!=0
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final boolean flags(int flags, int arg){
        return ((flags & arg)!=0);
    }


    /////////////////////    WINDOW STUFF //////////////////////


    @Override
    public void windowActivated(WindowEvent windowevent) {
        System.out.println("Window activated");
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);

    }

    @Override
    public void windowClosed(WindowEvent windowevent) {
        // TODO Auto-generated method stub

    }

    @Override
    public void windowClosing(WindowEvent windowevent) {
        // TODO Auto-generated method stub

    }

    @Override
    public void windowDeactivated(WindowEvent windowevent) {
        // Clear the queue if focus is lost.
        System.out.println("Eventqueue flushed!");
        eventQueue.clear();

    }

    @Override
    public void windowDeiconified(WindowEvent windowevent) {
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);

    }

    @Override
    public void windowIconified(WindowEvent windowevent) {
        // TODO Auto-generated method stub

    }

    @Override
    public void windowOpened(WindowEvent windowevent) {
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);

    }

    /**
     * NASTY hack to hide the cursor.
     * 
     * Create a 'hidden' cursor by using a transparent image
     * ...return the invisible cursor
     */

    protected Cursor createInvisibleCursor()

    {
        Dimension bestCursorDim = Toolkit.getDefaultToolkit().getBestCursorSize(2, 2);
        BufferedImage transparentImage = new BufferedImage(bestCursorDim.width, bestCursorDim.height, BufferedImage.TYPE_INT_ARGB);
        Cursor hiddenCursor = Toolkit.getDefaultToolkit( ).createCustomCursor(transparentImage, new Point(1, 1),    "HiddenCursor");
        return hiddenCursor;
    }

    public void grabMouse() {
        // Warp the pointer back to the middle of the window
        //  or it will wander off - that is, the game will
        //  loose input focus within X11.
        if (grabMouse)
        {
            if (doPointerWarp--<=0)
            {
                // Don't warp back if we deliberately alt-tabbed away.
                Point p=canvas.getMousePosition();
                if (p!=null){
                	
                	
                   robby.mouseMove(	offset.x+canvas.getWidth()/2,
                		   offset.y+canvas.getHeight()/2);
                    lastmousex=/*center.x+*/canvas.getWidth()/2;
                    lastmousey=/*center.y+*/canvas.getHeight()/2;
                    //System.out.printf("Mouse FORCED back to %d %d\n", lastmousex, lastmousey);
                }
                doPointerWarp = POINTER_WARP_COUNTDOWN;
            } 

        }

        mousemoved = false;

    }

    /** FIXME: input must be made scancode dependent rather than VK_Dependent,
     *  else a lot of things just don't work. 
     * 
     * @param e
     * @return
     */

    public int xlatekey(KeyEvent e)
    {

        int rc;

        switch(rc =     e.getKeyCode())

        //Event.XKeycodeToKeysym(X_display, X_event.xkey.keycode, 0))

        {
        case KeyEvent.VK_LEFT:    rc = KEY_LEFTARROW; break;
        case KeyEvent.VK_RIGHT:   rc = KEY_RIGHTARROW;    break;
        case KeyEvent.VK_DOWN:    rc = KEY_DOWNARROW; break;
        case KeyEvent.VK_UP:  rc = KEY_UPARROW;   break;
        case KeyEvent.VK_ESCAPE:  rc = KEY_ESCAPE;    break;
        case KeyEvent.VK_ENTER:   rc = KEY_ENTER;     break;
        case KeyEvent.VK_CONTROL: rc= KEY_CTRL; break;
        case KeyEvent.VK_ALT: rc=KEY_ALT; break;
        case KeyEvent.VK_SHIFT: rc=KEY_SHIFT; break;
        // Added handling of pgup/pgdown/home etc.
        case KeyEvent.VK_PAGE_DOWN: rc= KEY_PGDN;	break;
        case KeyEvent.VK_PAGE_UP: rc= KEY_PGUP;	break;
        case KeyEvent.VK_HOME: rc= KEY_HOME;	break;
        case KeyEvent.VK_F1:  rc = KEY_F1;        break;
        case KeyEvent.VK_F2:  rc = KEY_F2;        break;
        case KeyEvent.VK_F3:  rc = KEY_F3;        break;
        case KeyEvent.VK_F4:  rc = KEY_F4;        break;
        case KeyEvent.VK_F5:  rc = KEY_F5;        break;
        case KeyEvent.VK_F6:  rc = KEY_F6;        break;
        case KeyEvent.VK_F7:  rc = KEY_F7;        break;
        case KeyEvent.VK_F8:  rc = KEY_F8;        break;
        case KeyEvent.VK_F9:  rc = KEY_F9;        break;
        case KeyEvent.VK_F10: rc = KEY_F10;       break;
        case KeyEvent.VK_F11: rc = KEY_F11;       break;
        case KeyEvent.VK_F12: rc = KEY_F12;       break;
        case KeyEvent.VK_BACK_SPACE:
        case KeyEvent.VK_DELETE:  rc = KEY_BACKSPACE; break;
        case KeyEvent.VK_PAUSE:   rc = KEY_PAUSE;     break;
        case KeyEvent.KEY_RELEASED:
        case KeyEvent.VK_TAB: rc = KEY_TAB;       break;

        case KeyEvent.KEY_PRESSED:
            switch(e.getKeyCode()){

            case KeyEvent.VK_PLUS:
            case KeyEvent.VK_EQUALS: 
                rc = KEY_EQUALS;    
                break;

            case (13):
            case KeyEvent.VK_SUBTRACT: 
            case KeyEvent.VK_MINUS:   
                rc = KEY_MINUS;     
                break;

            case KeyEvent.VK_SHIFT:
                rc = KEY_SHIFT;
                break;

            case KeyEvent.VK_CONTROL:
                rc = KEY_CTRL;
                break;                           

            case KeyEvent.VK_ALT:
                rc = KEY_ALT;
                break;

            case KeyEvent.VK_SPACE:
                rc = ' ';
                break;

            }

        default:

            /*if (rc >= KeyEvent.VK_SPACE && rc <= KeyEvent.VK_DEAD_TILDE)
            {
            rc = (int) (rc - KeyEvent.FOCUS_EVENT_MASK + ' ');
            break;
            } */
            if (rc >= KeyEvent.VK_A && rc <= KeyEvent.VK_Z){
                rc = rc-KeyEvent.VK_A +'a';
                break;
            }
            // Unknown. Probably fucking up with the keyboard locale. Switch to be sure.
            // Sorry for this horrible hack, but Java can't read locale-free keycodes -_-
            // this.getInputContext().selectInputMethod(java.util.Locale.US);
            //if (rc>KEY_F12) rc=KEY_RSHIFT;
            break;
        }

        //System.out.println("Typed "+e.getKeyCode()+" char "+e.getKeyChar()+" mapped to "+Integer.toHexString(rc));

        // Sanitize. Nothing beyond F12 must pass through, else you will
        // get the "all cheats" bug.
        return rc;//Math.min(rc,KEY_F12);

    }

    protected void AddPoint(Point A, Point B){
    	A.x+=B.x;
    	A.y+=B.y;
    }
    
}
package awt;

import java.awt.DisplayMode;
import java.awt.GraphicsDevice;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class DisplayModePicker {
    
    protected GraphicsDevice device;
    protected DisplayMode default_mode;
    
    public DisplayModePicker(GraphicsDevice device){
        this.device=device;
        this.default_mode=device.getDisplayMode();
    }
    
    public DisplayMode pickClosest(int width, int height){
        
        DisplayMode[] modes=device.getDisplayModes();
        
        List<DisplayMode> picks=new ArrayList<DisplayMode>();
        
        WidthComparator wc=new WidthComparator();
        HeightComparator hc=new HeightComparator();
        
        // Filter out those with too small dimensions.
        
        for (DisplayMode dm:modes){
            if (dm.getWidth()>=width && dm.getHeight()>=height)
                picks.add(dm);
        }
        
       if (picks.size()>0) {        
        Collections.sort(picks, wc);
        Collections.sort(picks, hc);
       }
        
       // First one is the minimum that satisfies the desired criteria.
        return picks.get(0);
        
    }
    
    /** Return offsets to center rasters too oddly shaped to fit entirely into 
     *  a standard display mode (unfortunately, this means most stuff > 640 x 400),
     *  with doom's standard 8:5 ratio.
     * 
     * @param width
     * @param height
     * @param dm
     * @return array, x-offset and y-offset.
     */
    
public int[] getCentering(int width, int height,DisplayMode dm){
        
        int xy[]=new int[2];
        
        xy[0]=(dm.getWidth()-width)/2;
        xy[1]=(dm.getHeight()-height)/2;
    

        return xy;
        
    }
    
    class WidthComparator implements Comparator<DisplayMode>{

        @Override
        public int compare(DisplayMode arg0, DisplayMode arg1) {
            if (arg0.getWidth()> arg1.getWidth()) return 1;
            if (arg0.getWidth()< arg1.getWidth()) return -1;
            return 0;
        }
        
    }
    
    class HeightComparator implements Comparator<DisplayMode>{

        @Override
        public int compare(DisplayMode arg0, DisplayMode arg1) {
            if (arg0.getHeight()> arg1.getHeight()) return 1;
            if (arg0.getHeight()< arg1.getHeight()) return -1;
            return 0;
        }
        
    }

}

package awt;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;

public class DoomCanvas extends Canvas {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public void paint(Graphics g){
        
        g.setColor(new Color(.3f, .4f, .5f, .6f));
        g.fillRect(0, 0, this.getWidth(), this.getHeight());
    }
}

package awt;

import i.InputListener;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.InputEvent;

import javax.swing.JPanel;

import v.DoomVideoRenderer;
import doom.DoomMain;
import doom.event_t;

/** A simple Doom display & keyboard driver for AWT.
 *  Uses a Canvas for painting and implements some
 *  of the IVideo methods.
 * 
 *  Uses 8-bit buffered images and switchable IndexColorModels.
 *  
 *  It's really basic, but allows testing and user interaction.
 *  Heavily based on the original LinuxDoom X11 implementation, and
 *  is similar in goals: just a functional, reference implementation
 *  to build upon whatever fancy extensions you like.
 *  
 *  The only "hitch" is that this implementation expects to be 
 *  initialized upon a BufferedRenderer with multiple images per 
 *  screen buffer in order to perform the palette switching trick.
 *  
 *  The images themselves don't have to be "BufferedImage",
 *  and in theory it could be possible to use e.g. MemoryImageSource
 *  for the same purpose . Oh well.
 *    
 *  
 * 
 * @author Velktron
 *
 */
public abstract class SwingDoom<V> extends DoomFrame<V> {


    private static final long serialVersionUID = 3118508722502652276L;

		JPanel drawhere;

		/** Gimme some raw palette RGB data.
		 *  I will do the rest
		 *  
		 *  (hint: read this from the PLAYPAL
		 *   lump in the IWAD!!!).
		 * 
		 */
     
        @SuppressWarnings("unchecked")
		public SwingDoom(DoomMain<?,V> DM, DoomVideoRenderer<?,V> V) {
        	super(DM, V);
        	drawhere=new JPanel();
        	}
        
        Point center;
        Rectangle rect;

        
        public String processEvents(){
            StringBuffer tmp=new StringBuffer();
            event_t event;
            while ( (event=InputListener.nextEvent()) != null ) {
                tmp.append(event.type.ordinal()+"\n");
            }
            return tmp.toString();
        }
        
    	public void SetGamma(int level){
    		if (D) System.err.println("Setting gamma "+level);
    		V.setUsegamma(level);
    		screen=V.getCurrentScreen(); // Refresh screen after change.
    		RAWSCREEN=V.getScreen(DoomVideoRenderer.SCREEN_FG);
    	}
        
        // This stuff should NOT get through in keyboard events.
        protected final int UNACCEPTABLE_MODIFIERS=(int) (InputEvent.ALT_GRAPH_DOWN_MASK+
        										 InputEvent.META_DOWN_MASK+
        										 InputEvent.META_MASK+
        										 InputEvent.WINDOW_EVENT_MASK+
        										 InputEvent.WINDOW_FOCUS_EVENT_MASK);

    public static final class HiColor extends SwingDoom<short[]>{
        
        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        public HiColor(DoomMain<?, short[]> DM, DoomVideoRenderer<?,short[]> V) {
            super(DM, V);
        }

        @Override
        public void ReadScreen(short[] scr) {
            System.arraycopy(this.RAWSCREEN, 0, scr, 0, RAWSCREEN.length);
            }
        
        @Override
        public void FinishUpdate() {
            int     tics;
            int     i;
            
            // draws little dots on the bottom of the screen
            /*if (true)
            {

            i = I.GetTime();
            tics = i - lasttic;
            lasttic = i;
            if (tics > 20) tics = 20;
            if (tics < 1) tics = 1;

            for (i=0 ; i<tics*2 ; i+=2)
                RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = (byte) 0xff;
            for ( ; i<20*2 ; i+=2)
                RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
            
            } */

            if (true)
            {

            i = TICK.GetTime();
            tics = i - lasttic;
            lasttic = i;
            if (tics<1) 
                frames++;
            else
            {
            //frames*=35;
            for (i=0 ; i<frames*2 ; i+=2)
                RAWSCREEN[ (height-1)*width + i] = (short) 0xffff;
            for ( ; i<20*2 ; i+=2)
                RAWSCREEN[ (height-1)*width + i] = 0x0;
            frames=0;
            }
            }

            this.update(null);
            //this.getInputContext().selectInputMethod(java.util.Locale.US);
            
        }
    }
    
    public static final class Indexed extends SwingDoom<byte[]>{
        
        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        public Indexed(DoomMain<?,byte[]> DM, DoomVideoRenderer<?,byte[]> V) {
            super(DM, V);
        }

        @Override
        public void ReadScreen(byte[] scr) {
            System.arraycopy(this.RAWSCREEN, 0, scr, 0, RAWSCREEN.length);
            }
        
        @Override
        public void FinishUpdate() {
            int     tics;
            int     i;
            
            // draws little dots on the bottom of the screen
            /*if (true)
            {

            i = I.GetTime();
            tics = i - lasttic;
            lasttic = i;
            if (tics > 20) tics = 20;
            if (tics < 1) tics = 1;

            for (i=0 ; i<tics*2 ; i+=2)
                RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = (byte) 0xff;
            for ( ; i<20*2 ; i+=2)
                RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
            
            } */

            if (true)
            {

            i = TICK.GetTime();
            tics = i - lasttic;
            lasttic = i;
            if (tics<1) 
                frames++;
            else
            {
            //frames*=35;
            for (i=0 ; i<frames*2 ; i+=2)
                RAWSCREEN[ (height-1)*width + i] = (short) 0xffff;
            for ( ; i<20*2 ; i+=2)
                RAWSCREEN[ (height-1)*width + i] = 0x0;
            frames=0;
            }
            }

            this.update(null);
            //this.getInputContext().selectInputMethod(java.util.Locale.US);
            
        }
    }

    public static final class TrueColor extends SwingDoom<int[]>{
        
        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        public TrueColor(DoomMain<?, int[]> DM, DoomVideoRenderer<?,int[]> V) {
            super(DM, V);
        }

        @Override
        public void ReadScreen(int[] scr) {
            System.arraycopy(this.RAWSCREEN, 0, scr, 0, RAWSCREEN.length);
            }
        
        @Override
        public void FinishUpdate() {
            int     tics;
            int     i;
            
            // draws little dots on the bottom of the screen
            /*if (true)
            {

            i = I.GetTime();
            tics = i - lasttic;
            lasttic = i;
            if (tics > 20) tics = 20;
            if (tics < 1) tics = 1;

            for (i=0 ; i<tics*2 ; i+=2)
                RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = (byte) 0xff;
            for ( ; i<20*2 ; i+=2)
                RAWSCREEN[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
            
            } */

            if (true)
            {

            i = TICK.GetTime();
            tics = i - lasttic;
            lasttic = i;
            if (tics<1) 
                frames++;
            else
            {
            //frames*=35;
            for (i=0 ; i<frames*2 ; i+=2)
                RAWSCREEN[ (height-1)*width + i] = (short) 0xffff;
            for ( ; i<20*2 ; i+=2)
                RAWSCREEN[ (height-1)*width + i] = 0x0;
            frames=0;
            }
            }

            this.update(null);
            //this.getInputContext().selectInputMethod(java.util.Locale.US);
            
        }
    }
}
package awt;

import static g.Keys.*;
import i.DoomEventInterface;

import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.KeyEventDispatcher;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import java.awt.event.WindowListener;
import java.awt.image.BufferedImage;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

import doom.DoomMain;
import doom.event_t;
import doom.evtype_t;

/** An alternate events class, more suited for handling the complex situations
 *  that might arise during daily use, window moving, etc.
 *  Use instead of the old AWTEvents, which is present but deprecated.
 * 
 * @author vekltron
 *
 */

public class MochaEvents implements WindowListener,ComponentListener,KeyEventDispatcher,KeyListener,MouseListener,MouseMotionListener,WindowFocusListener,DoomEventInterface {

    // modifications of eventQueue must be thread safe!
    private LinkedList<MochaDoomInputEvent> eventQueue = new LinkedList<MochaDoomInputEvent>();

    private HashMap<Integer, Boolean> lockingKeyStates = new HashMap<Integer, Boolean>();
    
    private static final boolean D=false;

    //// STATUS STUFF ///////////
    public final DoomMain DM;
    public final Component canvas;
    Robot robby;
    Cursor hidden;
    Cursor normal;

    //////// CURRENT MOVEMENT AND INPUT STATUS //////////////

    protected static final int POINTER_WARP_COUNTDOWN = 1;
    protected int lastmousex;
    protected int lastmousey;
    protected Point lastmouse;
    protected int mousedx;
    protected int mousedy;
    protected boolean mousemoved;
    protected boolean ignorebutton;
    protected boolean grabMouse=true;
    protected int doPointerWarp=POINTER_WARP_COUNTDOWN;


    public MochaEvents(DoomMain DM, Component canvas) {
        this.DM = DM;
        this.canvas = canvas;

        // AWT: create cursors.
        this.normal=canvas.getCursor();
        this.hidden=this.createInvisibleCursor();

        // Create AWT Robot for forcing mouse
        try {
            robby=new Robot();
        } catch (Exception e){
           System.err.println("AWT Robot could not be created, mouse input focus will be loose!");
        }

        lockingKeyStates.put(KeyEvent.VK_CAPS_LOCK, null);
        lockingKeyStates.put(KeyEvent.VK_NUM_LOCK, null);
        lockingKeyStates.put(KeyEvent.VK_SCROLL_LOCK, null);
    }

    
    ///////////////////// QUEUE HANDLING ///////////////////////

    public synchronized void addEvent(MochaDoomInputEvent ev) {
        synchronized (eventQueue) {
            eventQueue.addLast(ev);
        }
    }

    public MochaDoomInputEvent nextEvent() {
    	MochaDoomInputEvent ev;
        synchronized (eventQueue) {
            ev = (!eventQueue.isEmpty())?(MochaDoomInputEvent)eventQueue.removeFirst():null;
        }
        return ev;
    }

    // This event here is used as a static scratch copy. When sending out
    // messages, its contents are to be actually copied (struct-like).
    // This avoids the continuous object creation/destruction overhead,
    // And it also allows creating "sticky" status.

    final event_t event=new event_t();
    // Special FORCED and PAINFUL key and mouse cancel event.
    final event_t cancelkey=new event_t(evtype_t.ev_clear,0xFF,0,0);
    final event_t cancelmouse=new event_t(evtype_t.ev_mouse,0,0,0);
    int prevmousebuttons;
    // Nasty hack for CAPS LOCK. Apparently, there's no RELIABLE way
    // to get the caps lock state programmatically, so we have to make 
    // do with simply toggling
    boolean capstoggle=false;
    
    
    @Override
    public void GetEvent() {
        MochaDoomInputEvent X_event;
        MouseEvent MEV;
        Point tmp;
        // Unlike most keys, caps lock etc. can be polled, so no need to worry
        // about them getting stuck.  So they are re-polled after all other
        // key states have beeen cleared.
      /*  if (DM.shouldPollLockingKeys()) {
            for (Map.Entry<Integer, Boolean> e: lockingKeyStates.entrySet()) {
                e.setValue(null);
            }
            updateLockingKeys();
        } */
        // put event-grabbing stuff in here
        if (eventQueue.isEmpty()) return;   
        X_event=nextEvent();
        //System.out.println("Event type:"+X_event.getID());

        // Keyboard events get priority vs mouse events.
        // In the case of combined input, however, we need
        if (!ignorebutton){
            switch (X_event.type)
            {
            case MochaDoomInputEvent.KeyPress: {
                event.type=evtype_t.ev_keydown;
                event.data1=xlatekey((KeyEvent)X_event.ev, -1);
                
                // Toggle, but don't it go through.
                if (event.data1==KEY_CAPSLOCK)
                	 capstoggle=true;
                
                if (event.data1!=KEY_CAPSLOCK)
                	DM.PostEvent(event);
                
                if (prevmousebuttons!=0){
                    
                // Allow combined mouse/keyboard events.
                event.data1=prevmousebuttons;
                event.type=evtype_t.ev_mouse;
                DM.PostEvent(event);
                }
                //System.err.println("k");
                break;
            }
            
            case MochaDoomInputEvent.KeyRelease:
                event.type=evtype_t.ev_keyup;
                event.data1=xlatekey((KeyEvent)X_event.ev, -1);

                if ((event.data1!=KEY_CAPSLOCK) ||
                	((event.data1==KEY_CAPSLOCK)&&capstoggle)) {
                	DM.PostEvent(event);
                }
                
                capstoggle=false;
                
                if (prevmousebuttons!=0){
                    
                    // Allow combined mouse/keyboard events.
                    event.data1=prevmousebuttons;
                    event.type=evtype_t.ev_mouse;
                    DM.PostEvent(event);
                    }
                //System.err.println( "ku");
                break;
              /* UNUSED, see caps lock problems
            case MochaDoomInputEvent.LockOn: {
                event.type=evtype_t.ev_keydown;
                event.data1=xlatekey(null, X_event.value);
                DM.PostEvent(event);
                if (prevmousebuttons!=0){
                        
                    // Allow combined mouse/keyboard events.
                    event.data1=prevmousebuttons;
                    event.type=evtype_t.ev_mouse;
                    DM.PostEvent(event);
                }
                //System.err.println("l1");
                break;
            }

            case MochaDoomInputEvent.LockOff: {
                event.type=evtype_t.ev_keyup;
                event.data1=xlatekey(null, X_event.value);
                DM.PostEvent(event);
                
                if (prevmousebuttons!=0){
                    
                    // Allow combined mouse/keyboard events.
                    event.data1=prevmousebuttons;
                    event.type=evtype_t.ev_mouse;
                    DM.PostEvent(event);
                    }
                //System.err.println( "l0");
                break;
            }
            */
            
            case MochaDoomInputEvent.KeyType:
                event.type=evtype_t.ev_keyup;
                event.data1=xlatekey((KeyEvent)X_event.ev, -1);
                DM.PostEvent(event);
                
                if (prevmousebuttons!=0){
                    
                    // Allow combined mouse/keyboard events.
                    event.data1=prevmousebuttons;
                    event.type=evtype_t.ev_mouse;
                    DM.PostEvent(event);
                    }
                //System.err.println( "ku");
                break;
            }

        }

        // Ignore ALL mouse events if we are moving the window.
        // Mouse events are also handled, but with secondary priority.
        switch (X_event.type){
        // ButtonPress
        case MochaDoomInputEvent.ButtonPress:
            MEV=(MouseEvent)X_event.ev;
            event.type=evtype_t.ev_mouse;
            event.data1 = prevmousebuttons=
                (MEV.getButton() == MouseEvent.BUTTON1 ? 1: 0) |
                (MEV.getButton() == MouseEvent.BUTTON2 ? 2: 0)|
                (MEV.getButton() == MouseEvent.BUTTON3 ? 4: 0);
            event.data2 = event.data3 = 0;

            DM.PostEvent(event);
            //System.err.println( "b");
            break;

            // ButtonRelease
            // This must send out an amended event.

        case MochaDoomInputEvent.ButtonRelease:
            MEV=(MouseEvent)X_event.ev;
            event.type = evtype_t.ev_mouse;
            event.data1 =prevmousebuttons^= 
                (MEV.getButton() == MouseEvent.BUTTON1 ? 1: 0) |
                (MEV.getButton() == MouseEvent.BUTTON2 ? 2: 0)|
                (MEV.getButton() == MouseEvent.BUTTON3 ? 4: 0);
            // A PURE mouse up event has no movement.
            event.data2 = event.data3 = 0;
            DM.PostEvent(event);
            //System.err.println("bu");
            break;
        case MochaDoomInputEvent.MotionNotify:
            MEV=(MouseEvent)X_event.ev;
            tmp=MEV.getPoint();
            //this.AddPoint(tmp,center);
            event.type = evtype_t.ev_mouse;
            this.mousedx=(tmp.x-win_w2);
            this.mousedy=(win_h2-tmp.y);
             
            // A pure move has no buttons.
            event.data1=prevmousebuttons=0;
            event.data2 = (mousedx) << 2;
            event.data3 = (mousedy) << 2;

           // System.out.printf("Mouse MOVED to %d %d\n", lastmousex, lastmousey);
            //System.out.println("Mouse moved without buttons: "+event.data1);
            if ((event.data2 | event.data3)!=0)
            {

                DM.PostEvent(event);
                //System.err.println( "m");
                mousemoved = true;
            } else
            {
                mousemoved = false;
            }
            break;

        case MochaDoomInputEvent.DragNotify:
            MEV=(MouseEvent)X_event.ev;
            tmp=MEV.getPoint();
            this.mousedx=(tmp.x-win_w2);
            this.mousedy=(win_h2-tmp.y);
            event.type = evtype_t.ev_mouse;
            
            // A drag means no change in button state.
            event.data1 = prevmousebuttons;
            event.data2 = (mousedx) << 2;
            event.data3 = (mousedy) << 2;

            if ((event.data2 | event.data3)!=0)
            {
                DM.PostEvent(event);
                //System.err.println( "m");
                mousemoved = true;
            } else
            {
                mousemoved = false;
            }
            break;

        }
        
        // Now for window events. This includes the mouse breaking the border.
        
        switch (X_event.type){
        case MochaDoomInputEvent.FocusLost:
        case MochaDoomInputEvent.MouseExited:
            // Forcibly clear events                 
            DM.PostEvent(cancelmouse);
            DM.PostEvent(cancelkey);
            canvas.setCursor(normal);             
            ignorebutton=true;
            break;
            
        case MochaDoomInputEvent.WindowMoving:
        	// Don't try to reposition immediately during a move
        	// event, wait for a mouse click.
        	we_are_moving=true;
        	ignorebutton=true;
            // Forcibly clear events                 
            DM.PostEvent(cancelmouse);
            DM.PostEvent(cancelkey);
        	move++;
        	break;
        case MochaDoomInputEvent.MouseEntered:
        case MochaDoomInputEvent.FocusGained:
        	we_are_moving=false;
        	//reposition();
        case MochaDoomInputEvent.ConfigureNotify:
        case MochaDoomInputEvent.CreateNotify:
            // All events that have to do with the window being changed,
        	// moved etc. should go here. The most often result
        	// in focus being lost and position being changed, so we
        	// need to take charge.
            DM.justfocused=true;
            canvas.requestFocus();
            reposition();            			
        	ignorebutton=false;
			break;
        default:
            // NOT NEEDED in AWT if (doShm && X_event.type == X_shmeventtype) shmFinished = true;
            break;

        }
        
        
        // If the mouse moved, don't wait until it managed to get out of the 
        // window to bring it back.
		if (!we_are_moving && (mousedx != 0 || mousedy != 0)) {
			// move the mouse to the window center again
			robby.mouseMove(offset.x + win_w2, offset.y + win_h2);
			
		}
		
		mousedx=mousedy=0; // don't spaz.

    }
    
    private int  win_w2, win_h2;
    private int move=0;

	/** Update relative position offset, and force mouse there.
	 * 
	 */
	void reposition() {
		offset.x=(int) (canvas.getLocationOnScreen().x);
    	offset.y=(int) (canvas.getLocationOnScreen().y);
    	// Shamelessly ripped from Jake 2. Maybe it works better?
		Component c = this.canvas;
		//offset.x = 0;
		//offset.y = 0;
		win_w2 = c.getWidth() / 2;
		win_h2 = c.getHeight() / 2;
		
		robby.mouseMove(offset.x + win_w2, offset.y + win_h2);

        
        canvas.getInputContext().selectInputMethod(java.util.Locale.US);
        canvas.setCursor(hidden);
		if (D) System.err.printf("Jake 2 method: offset MOVED to %d %d\n", offset.x, offset.y);
		
	}
    
    Point offset=new Point();

    /** Returns true if flags are included in arg.
     * Synonymous with (flags & arg)!=0
     * 
     * @param flags
     * @param arg
     * @return
     */
    public static final boolean flags(int flags, int arg){
        return ((flags & arg)!=0);
    }


    /////////////////////    WINDOW STUFF //////////////////////


    @Override
    public void windowActivated(WindowEvent windowevent) {
    	if (D) System.err.println("Window activated");
    	eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.ConfigureNotify, null));
    	}

    @Override
    public void windowClosed(WindowEvent windowevent) {
        // TODO Auto-generated method stub

    	}

    @Override
    public void windowClosing(WindowEvent windowevent) {
        // TODO Auto-generated method stub

    }

    @Override
    public void windowDeactivated(WindowEvent windowevent) {
        // Clear the queue if focus is lost.
        eventQueue.clear();

    }

    @Override
    public void windowDeiconified(WindowEvent windowevent) {
    	eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.ConfigureNotify, null));

    }

    @Override
    public void windowIconified(WindowEvent windowevent) {
        // TODO Auto-generated method stub
    	eventQueue.clear();

    }

    @Override
    public void windowOpened(WindowEvent windowevent) {
    	eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.CreateNotify, null));
    }

    /**
     * NASTY hack to hide the cursor.
     * 
     * Create a 'hidden' cursor by using a transparent image
     * ...return the invisible cursor
     */

    protected Cursor createInvisibleCursor()

    {
        Dimension bestCursorDim = Toolkit.getDefaultToolkit().getBestCursorSize(2, 2);
        BufferedImage transparentImage = new BufferedImage(bestCursorDim.width, bestCursorDim.height, BufferedImage.TYPE_INT_ARGB);
        Cursor hiddenCursor = Toolkit.getDefaultToolkit( ).createCustomCursor(transparentImage, new Point(1, 1),    "HiddenCursor");
        return hiddenCursor;
    }
   
    /** FIXME: input must be made scancode dependent rather than VK_Dependent,
     *  else a lot of things just don't work. 
     * 
     * @param e
     * @param rc 
     * @return
     */

    public int xlatekey(KeyEvent e, int rc)
    {

        if (e != null) rc = e.getKeyCode();
        switch(rc)

        //Event.XKeycodeToKeysym(X_display, X_event.xkey.keycode, 0))

        {
        case KeyEvent.VK_LEFT:    rc = KEY_LEFTARROW; break;
        case KeyEvent.VK_RIGHT:   rc = KEY_RIGHTARROW;    break;
        case KeyEvent.VK_DOWN:    rc = KEY_DOWNARROW; break;
        case KeyEvent.VK_UP:  rc = KEY_UPARROW;   break;
        case KeyEvent.VK_ESCAPE:  rc = KEY_ESCAPE;    break;
        case KeyEvent.VK_ENTER:   rc = KEY_ENTER;     break;
        case KeyEvent.VK_CONTROL: rc= KEY_CTRL; break;
        case KeyEvent.VK_ALT: rc=KEY_ALT; break;
        case KeyEvent.VK_SHIFT: rc=KEY_SHIFT; break;
        // Added handling of pgup/pgdown/home etc.
        case KeyEvent.VK_PAGE_DOWN: rc= KEY_PGDN;	break;
        case KeyEvent.VK_PAGE_UP: rc= KEY_PGUP;	break;
        case KeyEvent.VK_HOME: rc= KEY_HOME;	break;
        case KeyEvent.VK_END: rc= KEY_END;	break;
        case KeyEvent.VK_F1:  rc = KEY_F1;        break;
        case KeyEvent.VK_F2:  rc = KEY_F2;        break;
        case KeyEvent.VK_F3:  rc = KEY_F3;        break;
        case KeyEvent.VK_F4:  rc = KEY_F4;        break;
        case KeyEvent.VK_F5:  rc = KEY_F5;        break;
        case KeyEvent.VK_F6:  rc = KEY_F6;        break;
        case KeyEvent.VK_F7:  rc = KEY_F7;        break;
        case KeyEvent.VK_F8:  rc = KEY_F8;        break;
        case KeyEvent.VK_F9:  rc = KEY_F9;        break;
        case KeyEvent.VK_F10: rc = KEY_F10;       break;
        case KeyEvent.VK_F11: rc = KEY_F11;       break;
        case KeyEvent.VK_F12: rc = KEY_F12;       break;

        case KeyEvent.VK_BACK_SPACE:
        case KeyEvent.VK_DELETE:  rc = KEY_BACKSPACE; break;

        case KeyEvent.VK_PAUSE:   rc = KEY_PAUSE;     break;

        case KeyEvent.VK_TAB: rc = KEY_TAB;       break;
        case KeyEvent.VK_CAPS_LOCK: rc = KEY_CAPSLOCK; break;
        case KeyEvent.VK_NUM_LOCK: rc = KEY_NUMLOCK; break;
        case KeyEvent.VK_SCROLL_LOCK: rc = KEY_SCROLLLOCK; break;
        /*
        case KeyEvent.KEY_RELEASED:
        case KeyEvent.KEY_PRESSED:
            switch(e.getKeyCode()){

            case KeyEvent.VK_PLUS:
            case KeyEvent.VK_EQUALS: 
                rc = KEY_EQUALS;    
                break;

            case (13):
            case KeyEvent.VK_SUBTRACT: 
            case KeyEvent.VK_MINUS:   
                rc = KEY_MINUS;     
                break;

            case KeyEvent.VK_SHIFT:
                rc = KEY_RSHIFT;
                break;

            case KeyEvent.VK_CONTROL:
                rc = KEY_RCTRL;
                break;                           

            case KeyEvent.VK_ALT:
                rc = KEY_RALT;
                break;

            case KeyEvent.VK_SPACE:
                rc = ' ';
                break;

            }
            */

        default:

            /*if (rc >= KeyEvent.VK_SPACE && rc <= KeyEvent.VK_DEAD_TILDE)
            {
            rc = (int) (rc - KeyEvent.FOCUS_EVENT_MASK + ' ');
            break;
            } */
            if (rc >= KeyEvent.VK_A && rc <= KeyEvent.VK_Z){
                rc = rc-KeyEvent.VK_A +'a';
                break;
            }
            break;
        }

        //System.out.println("Typed "+e.getKeyCode()+" char "+e.getKeyChar()+" mapped to "+Integer.toHexString(rc));
        return rc;//Math.min(rc,KEY_F12);

    }

    protected void AddPoint(Point A, Point B){
    	A.x+=B.x;
    	A.y+=B.y;
    }

    ////////////LISTENERS //////////

    
    ///////////////////////// KEYBOARD EVENTS ///////////////////////////////////


    // UNUSED used commented out because it doesn't appear to work
    // I think that there is no bulletproof method to poll the state of
    // the CAPS LOCK key, and forcing a call to getLockingKeyState()
    // results in an UnsupportedOperationException
    // For now, the best course of action seems to be intercepting toggling only,
    // rather than state. It also looks like a compicated thing to
    // run at every key update.
    
    private void updateLockingKeys() {
        Toolkit toolkit = canvas.getToolkit();
        for (Iterator<Map.Entry<Integer, Boolean>> it =
                 lockingKeyStates.entrySet().iterator();
             it.hasNext();
             ) {
            Map.Entry<Integer, Boolean> entry = it.next(); 
            Integer keyCode = entry.getKey();
            Boolean oldState = entry.getValue();
            try {
            	if (D) System.err.println("Trying");
                boolean newState = toolkit.getLockingKeyState(keyCode);
                if (! Boolean.valueOf(newState).equals(oldState)) {
                	if (D) System.out.println("New event");
                    int eventType =
                        newState ? MochaDoomInputEvent.LockOn
                                 : MochaDoomInputEvent.LockOff;
                    addEvent(new MochaDoomInputEvent(eventType,keyCode));
                    entry.setValue(newState);
                }
            } catch (UnsupportedOperationException ex) {
                // Key not present
                it.remove();
            }
        }
    }

    public void keyPressed(KeyEvent e) {
     // //  updateLockingKeys();
       // if (! lockingKeyStates.containsKey(e.getKeyCode())) {
            if (e.getKeyCode()<=KeyEvent.VK_F12) {  
                addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.KeyPress,e));            
            }
    
            e.consume();
       // }
    }

    public void keyReleased(KeyEvent e) {
       // updateLockingKeys();
       // if (! lockingKeyStates.containsKey(e.getKeyCode())) {
    
            //if ((e.getModifiersEx() & UNACCEPTABLE_MODIFIERS) ==0) {
            if (e.getKeyCode()<=KeyEvent.VK_F12) {
            	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.KeyRelease,e));
            }
            e.consume();
       // }
    }

    public void keyTyped(KeyEvent e) {
    	//updateLockingKeys();
    	//if (! lockingKeyStates.containsKey(e.getKeyCode())) {
        if (e.getKeyCode()<=KeyEvent.VK_F12) {
        	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.KeyType,e));
       }

        e.consume();
    	//}
    }

    //////////////////////////// MOUSE EVENTS   ////////////////////////////

    @Override
    public void mouseClicked(MouseEvent mouseevent) {
    	// Marks the end of a move. A press + release during a move will
    	// trigger a "click" event, which is handled specially.
    	if (we_are_moving) {
    		we_are_moving=false;
    		reposition();
    		ignorebutton=false;
    	}
    
    	}

    @Override
    public void mouseEntered(MouseEvent mouseevent) {
    	//System.out.println("Mouse entered");
    	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.MouseEntered,null));
    	}

    @Override
    public void mouseExited(MouseEvent mouseevent) {
    	//System.out.println("Mouse exited");
    	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.MouseExited,null));
    	}

    @Override
    public void mousePressed(MouseEvent mouseevent) {
    	if (!we_are_moving) // Don't let presses go through when moving.
    	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.ButtonPress,mouseevent));
    	}

    @Override
    public void mouseReleased(MouseEvent mouseevent) {
    	if (!we_are_moving) // Don't let presses go through when moving.
    	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.ButtonRelease,mouseevent));
    	}

    @Override
    public void mouseDragged(MouseEvent mouseevent) {
    	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.DragNotify,mouseevent));
    	}

    @Override
    public void mouseMoved(MouseEvent mouseevent) {
    	addEvent(new MochaDoomInputEvent(MochaDoomInputEvent.MotionNotify,mouseevent));
    	}

    //////////////// COMPONENT EVENTS //////////////////////////
    
    boolean we_are_moving=false;
        
	@Override
	public void componentHidden(ComponentEvent e) {
		// Do what, here? Pausing would be a good idea.
		
	}

	@Override
	public void componentMoved(ComponentEvent e) {
		eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.WindowMoving, null));
	}

	@Override
	public void componentResized(ComponentEvent e) {
		eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.ConfigureNotify, null));
		
	}

	@Override
	public void componentShown(ComponentEvent e) {
		eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.CreateNotify, null));
	}

	@Override
	public void windowGainedFocus(WindowEvent arg0) {
		eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.FocusGained, null));
	}


	@Override
	public void windowLostFocus(WindowEvent arg0) {
		eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.FocusLost, null));
	}


	public  boolean hasMoreEvents() {
		return !this.eventQueue.isEmpty();
	}


	@Override
	public boolean dispatchKeyEvent(KeyEvent e) {
		//if (e.getKeyCode() == KeyEvent.VK_TAB)
		//	eventQueue.add(new MochaDoomInputEvent(MochaDoomInputEvent.KeyRelease, e));
		return false;
	}
    
}
package awt;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.util.StringTokenizer;

import javax.swing.JFrame;

import i.DoomVideoInterface;
import i.IDoomSystem;
import i.InputListener;
import i.Strings;
import timing.ITicker;
import v.DoomVideoRenderer;
import doom.DoomMain;
import doom.ICommandLineManager;
import doom.event_t;

/** Common code for Doom's video frames */

public abstract class DoomFrame<V> extends JFrame implements DoomVideoInterface<V> {

    protected V RAWSCREEN;
    // Normally only used in fullscreen mode
    
    /** This might differ from the raster's width & height attribute for number of reasons */
    protected Dimension size;
    protected DisplayMode oldDisplayMode;
    protected DisplayMode currentDisplayMode;
    protected GraphicsDevice device;
    protected int X_OFF;
    protected int Y_OFF;    
    
    public DoomFrame(DoomMain<?,V> DM,DoomVideoRenderer<?,V> V) {
        GraphicsEnvironment env = GraphicsEnvironment.
        getLocalGraphicsEnvironment();
        
        GraphicsDevice[] devices = env.getScreenDevices();
        
        // Get device 0, because we're lazy.
        if (devices!=null)
            if (devices.length>0)
                device=devices[0];
        
    	this.DM=DM;
    	this.CM=DM.CM;
    	this.TICK=DM.TICK;
    	this.I=DM.I;
    	this.V= V;
    	
        this.width=V.getWidth();
        this.height=V.getHeight();

    	
    	// Set those here. If fullscreen isn't used, then they won't change.
    	// They are necessary for normal initialization, though.
    	setDefaultDimension(width,height);

	}
    
    /** Default window size and center spot. These might change 
     * upon entering full screen, so don't consider them absolute. 
     * Due to letterboxing and screen doubling, stretching etc. 
     * they might be different that the screen buffer (typically,
     * larger).
     * 
     * @param width
     * @param height
     */
    
    private void setDefaultDimension(int width, int height){
        this.size=new Dimension(width*multiply,height*multiply);
        this.center=new Point (X_OFF+size.width/2, Y_OFF+size.height/2);
    }
    
	/**
	 * 
	 */
	private static final long serialVersionUID = -4130528877723831825L;

	

	protected static final boolean D=false;
	
	// Must be aware of "Doom" so we can pass it event messages inside a crude queue.
	public DoomMain<?,V> DM;            // Must be aware of general status.
	public ICommandLineManager CM; // Must be aware of command line interface.
	protected IDoomSystem I;         // Must be aware of some other shit like event handler
	protected DoomVideoRenderer<?,V> V;    // Must have a video renderer....
	protected ITicker TICK;          // Must be aware of the ticker/
	protected MochaEvents eventhandler; // Separate event handler a la _D_.
	                               // However I won't make it fully "eternity like" yet
	                               // also because it works quite flakey on Linux.
	

  	protected Robot robby;
	protected Canvas drawhere;
	protected Canvas gelatine;
	/** This is the actual screen */
    protected Image screen;
    protected int palette=0;
    //InputListener in;
    protected Graphics2D g2d;
    protected Graphics2D gel2d;
    
    protected Point center;
        
    /** Dimensions of the screen buffers. The display however, might differ due 
     * to e.g. letterboxing */
    protected int width,height;
    protected int multiply=1;
    
    // This stuff should NOT get through in keyboard events.
    protected final int UNACCEPTABLE_MODIFIERS=(int) (InputEvent.ALT_GRAPH_DOWN_MASK+
    										 InputEvent.META_DOWN_MASK+
    										 InputEvent.META_MASK+
    										 InputEvent.WINDOW_EVENT_MASK+
    										 InputEvent.WINDOW_FOCUS_EVENT_MASK);
    
    public String processEvents(){
        StringBuffer tmp=new StringBuffer();
        event_t event;
        while ( (event=InputListener.nextEvent()) != null ) {
            tmp.append(event.type.ordinal()+"\n");
        }
        return tmp.toString();
    }
    

    /**
     * I_SetPalette
     * 
     * Any bit-depth specific palette manipulation is performed by 
     * the VideoRenderer. It can range from simple (paintjob) to
     * complex (multiple BufferedImages with locked data bits...ugh!
     * 
     *@param palette index (normally between 0-14).
     */
	
	@Override
	public void SetPalette (int palette)
	{
		V.setPalette(palette);
		this.screen=V.getCurrentScreen();      
	}
	
	
	/** Call this before attempting to draw anything.
	 * This will create the window, the canvas and everything.
	 * Unlike a simple JFrame, this is not automatic because of the order
	 * Doom does things.
	 * 
	 */
	
	@Override
	public void InitGraphics()
	{

	  String		displayname;
	  String		d;
	  int			n;
	  int			pnum;
	  int			x=0;
	  int			y=0;
	  
	  // warning: char format, different type arg
	  int		xsign=' ';
	  int		ysign=' ';
	  
	  boolean			oktodraw;
	  long	attribmask;

	  // Try setting the locale the US, otherwise there will be problems
	  // with non-US keyboards.
	  if (this.getInputContext()==null || !this.getInputContext().selectInputMethod(java.util.Locale.US)){
		  System.err.println("Could not set the input context to US! Keyboard input will be glitchy!");
	  } else {
		  System.err.println("Input context successfully set to US.");
	  }

	  // check for command-line display name
	  if ( (pnum=CM.CheckParm("-disp"))!=0 ) // suggest parentheses around assignment
		displayname = CM.getArgv(pnum+1);
	  else
		displayname = null;

	  // check for command-line geometry
	  if ( (pnum=CM.CheckParm("-geom"))!=0 ) // suggest parentheses around assignment
	  {
		  try{
		  String eval=CM.getArgv(pnum+1).trim();
		// warning: char format, different type arg 3,5
		//n = sscanf(myargv[pnum+1], "%c%d%c%d", &xsign, &x, &ysign, &y);
		// OK, so we have to read a string that may contain
		// ' '/'+'/'-' and a number. Twice.
		StringTokenizer tk=new StringTokenizer(eval,"-+ ");
		// Signs. Consider positive.
		xsign=1;ysign=1;
		for (int i=0;i<eval.length();i++){
			if (eval.charAt(i)=='-'){
				// First '-' on trimmed string: negagive
				if (i==0)
					xsign=-1;
				else 
					ysign=-1;
				}
			}
		
		//this should parse two numbers.
		if (tk.countTokens()==2){
			x=xsign*Integer.parseInt(tk.nextToken());
			y=ysign*Integer.parseInt(tk.nextToken());
		}
		  

		  } catch (NumberFormatException e){
		    I.Error("bad -geom parameter");
		  }
	  }

	  // open the display
	  // AWT: create the canvas.
	  try{
      //drawhere=new Canvas();
      // MAES: this method works even on "stubborn" Linux distros that 
      // fuck up the window size.
	  setCanvasSize(size);
      
      this.eventhandler=new MochaEvents(DM,drawhere);
      
      // AWT: Add listeners to CANVAS element.
      // Maybe it should go to the gelatine component?
      drawhere.addKeyListener(eventhandler);
      drawhere.addMouseListener(eventhandler);
      drawhere.addMouseMotionListener(eventhandler);
      addComponentListener(eventhandler);
      addWindowFocusListener(eventhandler);
      addWindowListener(eventhandler);
      
      if (DM.VM.getSetting("fullscreen").getBoolean())
          switchToFullScreen();
      
      
	  } catch (Exception e){
		  I.Error("Error creating AWTDoom frame. Exiting. Reason: %s",e.getMessage());
	  }
	 
	  // AWT: tab is a special case :-/
	  // We need to "peg" it to the JFrame, rather than the canvas,
	  // and the handler itself cannot auto-assign it.
	  
      final Component me=drawhere;
	  
      KeyboardFocusManager.
      getCurrentKeyboardFocusManager().
      addKeyEventDispatcher(new KeyEventDispatcher() {
    	  
    	  boolean press=false;
          public boolean dispatchKeyEvent(KeyEvent e) {    
            if (e.getKeyCode() == KeyEvent.VK_TAB) {
            	// MAES: simulating a key type.
            	if (press)
                eventhandler.keyPressed(
                		new KeyEvent(me, e.getID(), System.nanoTime(),0 , KeyEvent.VK_TAB, KeyEvent.CHAR_UNDEFINED));
            	else
                    eventhandler.keyReleased(
                    		new KeyEvent(me, e.getID(), System.nanoTime(),0 , KeyEvent.VK_TAB, KeyEvent.CHAR_UNDEFINED));
            	press=!press;
            }  
            return false;
          }
      });
	  
	  this.add(drawhere);
	 // this.add(gelatine);
	  this.getContentPane().setPreferredSize(drawhere.getPreferredSize());
	  
	  // JFrame's size is auto-set here.
	  this.pack();
	  this.setVisible(true);
      this.setResizable(false);
	  this.setTitle(Strings.MOCHA_DOOM_TITLE);
	  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  // Gently tell the eventhandler to wake up and set itself.	  
	  this.requestFocus();
	  this.eventhandler.addEvent(MochaDoomInputEvent.GET_YOUR_ASS_OFF);
	  SetGamma(0); 
	  
	}
	
    private void setCanvasSize(Dimension size) {
        
        drawhere.setPreferredSize(size);
        drawhere.setBounds(0, 0, drawhere.getWidth()-1,drawhere.getHeight()-1);
        drawhere.setBackground(Color.black);

        gelatine.setPreferredSize(size);
        gelatine.setBounds(0, 0, drawhere.getWidth()-1,drawhere.getHeight()-1);
        gelatine.setBackground(Color.black);
        
    }


    /** FULLSCREEN SWITCH CODE
     * TODO: it's not enough to do this without also switching the screen's resolution.
     * Unfortunately, Java only has a handful of options which depend on the OS, driver,
     * display, JVM etc. and it's not possible to switch to arbitrary resolutions. 
     * 
     * Therefore, a "best fit" strategy with centering is used.
     * 
     */
	
	private void switchToFullScreen() {
	    boolean isFullScreen = device.isFullScreenSupported();
	      setUndecorated(isFullScreen);
	      setResizable(!isFullScreen);
	      
	      // In case we need to revert.
	      oldDisplayMode 
	      = device.getDisplayMode();
	      
	      DisplayModePicker dmp=new DisplayModePicker(device);
	      
	      // TODO: what if bit depths are too small?
	      DisplayMode dm=dmp.pickClosest(width,height);
	      
	      int[] xy=dmp.getCentering(width,height, dm);
	      this.X_OFF=xy[0];
	      this.Y_OFF=xy[1];
	      
	      device.getDisplayModes(); 
	      
	      if (isFullScreen) {
	          // Full-screen mode
	          device.setFullScreenWindow(this);
	          if (device.isDisplayChangeSupported())
	              device.setDisplayMode(dm);
	          validate();
	          
	          Dimension newsize=new Dimension(dm.getWidth(),dm.getHeight());
	          this.setDefaultDimension(dm.getWidth(),dm.getHeight());
	          setCanvasSize(newsize);
	          
	      } else {
	          // Windowed mode
	          pack();
	          setVisible(true);
	      }
        
    }


    @Override
	public void StartFrame() {
		// Dummy. Nothing special to do...yet.
		
	}

	@Override
	public void StartTic() {

		  if (!this.isActive()) return;

		//  System.out.println("Getting events...");
		  while (eventhandler.hasMoreEvents())
			eventhandler.GetEvent();
		      
		    //eventhandler.grabMouse();

		
	}

	protected int lasttic;
	protected int frames;

    @Override
    public void UpdateNoBlit() {
        // Quite pointless, no?
        
    }

    // Convenience, for testers.
	public void GetEvent() {
		this.eventhandler.GetEvent();		
	}

	@Override
	public void ShutdownGraphics() {
		this.dispose();
		((JFrame)this).dispose();
		
	}

	   
    public void SetGamma(int level){
        if (D) System.err.println("Setting gamma "+level);
        V.setUsegamma(level);
        screen=V.getCurrentScreen(); // Refresh screen after change.
        RAWSCREEN=V.getScreen(DoomVideoRenderer.SCREEN_FG);
    }
    
    
    /** Modified update method: no context needs to passed.
     *  Will render only internal screens. Common between AWT 
     *  and Swing
     * 
     */
    public void paint(Graphics g) {
       // Techdemo v1.3: Mac OSX fix, compatible with Windows and Linux.
       // Should probably run just once. Overhead is minimal
       // compared to actually DRAWING the stuff.
       if (g2d==null) g2d = (Graphics2D)drawhere.getGraphics();
       //if (gel2d==null) gel2d= (Graphics2D)gelatine.getGraphics();
       V.update();
       //voli.getGraphics().drawImage(bi,0,0,null);
       g2d.drawImage(screen,X_OFF,Y_OFF,this);
       //gel2d.setColor(new Color(.3f, .4f, .5f, .1f));
       //gel2d.fillRect(0, 0, this.getWidth(), this.getHeight());
       
    }

}

package awt;

import java.awt.AWTEvent;

/** The older system was just a miserable pile of fuck.
 *  This system clearly codifies everything we need to be aware
 *  of, namely keypresses, mousebuttonpresses, window state
 *  changes, etc.
 *  
 *  Based on Jake2's JakeInputEvent.
 *   
 * @author velktron
 *
 */

public class MochaDoomInputEvent {
		static final int KeyPress = 0;
		static final int KeyRelease = 1;
		static final int KeyType = 2;
		static final int MotionNotify = 3;
		static final int DragNotify = 4;
		static final int ButtonPress = 5;
		static final int ButtonRelease = 6;
		static final int CreateNotify = 7;
		static final int ConfigureNotify = 8;
		static final int WheelMoved = 9;
		static final int MouseExited =10;
		static final int MouseEntered=11;
		static final int WindowMoving=12;
		static final int FocusGained=13;
		static final int FocusLost=14;
		static final int LockOn=15;
		static final int LockOff=16;
		static final int KEY_MASK=0X100; // Extract info from lower bits for this
		
		int type;
		int value;
		AWTEvent ev;
		
		MochaDoomInputEvent(int type, AWTEvent ev) {
			this.type = type;
			this.ev = ev;
		}
		
		MochaDoomInputEvent(int type, int value) {
			this.type=type;
			this.value=value;
			}

		/** Just a friendly way to remind the child component to
		 *  position and initialize itself correctly for the first
		 *  use.
		 */
		
		static MochaDoomInputEvent GET_YOUR_ASS_OFF = new
		MochaDoomInputEvent(ConfigureNotify, null);
	}

package hu;

// Emacs style mode select -*- C++ -*-
// -----------------------------------------------------------------------------
//
// $Id: HU.java,v 1.32 2012/09/24 17:16:23 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// DESCRIPTION: Heads-up displays
//
// -----------------------------------------------------------------------------

import static data.Defines.*;
import static g.Keys.*;

import defines.*;
import static data.Limits.*;
import static doom.englsh.*;
import i.DoomStatusAware;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import v.IVideoScale;
import v.IVideoScaleAware;
import m.IDoomMenu;
import m.Menu;
import rr.RendererState;
import rr.patch_t;
import s.IDoomSound;
import w.IWadLoader;
import data.sounds.sfxenum_t;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.evtype_t;
import doom.player_t;


public class HU implements DoomStatusAware, IVideoScaleAware, IHeadsUp{
    public final static String rcsid =
        "$Id: HU.java,v 1.32 2012/09/24 17:16:23 velktron Exp $";

    // MAES: Status and wad data.
    IWadLoader W;

    DoomMain<?,?> DM;

    IDoomMenu M;

    RendererState<?,?> R;
    
    DoomVideoRenderer<?,?> V;

    IDoomSound S;
    //
    // Locally used constants, shortcuts.
    // MAES: Some depend on STATE, so moved into constructor.

    String HU_TITLE, HU_TITLE2, HU_TITLEP, HU_TITLET;

    protected final static int HU_TITLEHEIGHT = 1;

    protected final static int HU_TITLEX = 0;

    protected int HU_TITLEY;// = (167 - Swap.SHORT(hu_font[0].height));

    protected final static char HU_INPUTTOGGLE = 't';

    protected final static int HU_INPUTX = HU_MSGX;

    protected int HU_INPUTY;// = (HU_MSGY +

    // HU_MSGHEIGHT*(Swap.SHORT(hu_font[0].height) +1));

    protected final static int HU_INPUTWIDTH = 64;

    protected final static int HU_INPUTHEIGHT = 1;

    public String[] chat_macros =
        { HUSTR_CHATMACRO0, HUSTR_CHATMACRO1, HUSTR_CHATMACRO2,
                HUSTR_CHATMACRO3, HUSTR_CHATMACRO4, HUSTR_CHATMACRO5,
                HUSTR_CHATMACRO6, HUSTR_CHATMACRO7, HUSTR_CHATMACRO8,
                HUSTR_CHATMACRO9 };
    
    @Override
    public void setChatMacro(int i, String s){
        this.chat_macros[i]=s;
    }

    /** Needs to be seen by DoomGame */
    public final static String[] player_names =
        { HUSTR_PLRGREEN, HUSTR_PLRINDIGO, HUSTR_PLRBROWN, HUSTR_PLRRED };

    char chat_char; // remove later.

    player_t plr;

    // MAES: a whole lot of "static" stuff which really would be HU instance
    // status.
    patch_t[] hu_font = new patch_t[HU_FONTSIZE];

    char[] chat_dest = new char[MAXPLAYERS];

    // MAES: these used to be defined in hu_lib. We're going 100% OO here...

    hu_itext_t[] w_inputbuffer;

    hu_textline_t w_title ;

    hu_itext_t w_chat;

    boolean[] always_off = { false };

    // Needs to be referenced by one of the widgets.
    public boolean[] chat_on = new boolean[1];

    // MAES: Ugly hack which allows it to be passed as reference. Sieg heil!
    boolean[] message_on = new boolean[]{true};

    boolean message_dontfuckwithme;

    boolean message_nottobefuckedwith;

    hu_stext_t w_message;

    int message_counter;

    // This is actually an "extern" pointing inside m_menu (Menu.java). So we
    // need to share Menu context.
    // int showMessages;
    // MAES: I think this is supposed to be visible by the various hu_ crap...
   // boolean automapactive;

    boolean headsupactive = false;

    //
    // Builtin map names.
    // The actual names can be found in DStrings.h.
    //

    protected String[] mapnames = // DOOM shareware/registered/retail (Ultimate)
        // names.
        {

        HUSTR_E1M1, HUSTR_E1M2, HUSTR_E1M3, HUSTR_E1M4, HUSTR_E1M5, HUSTR_E1M6,
                HUSTR_E1M7, HUSTR_E1M8, HUSTR_E1M9,

                HUSTR_E2M1, HUSTR_E2M2, HUSTR_E2M3, HUSTR_E2M4, HUSTR_E2M5,
                HUSTR_E2M6, HUSTR_E2M7, HUSTR_E2M8, HUSTR_E2M9,

                HUSTR_E3M1, HUSTR_E3M2, HUSTR_E3M3, HUSTR_E3M4, HUSTR_E3M5,
                HUSTR_E3M6, HUSTR_E3M7, HUSTR_E3M8, HUSTR_E3M9,

                HUSTR_E4M1, HUSTR_E4M2, HUSTR_E4M3, HUSTR_E4M4, HUSTR_E4M5,
                HUSTR_E4M6, HUSTR_E4M7, HUSTR_E4M8, HUSTR_E4M9,

                "NEWLEVEL", "NEWLEVEL", "NEWLEVEL", "NEWLEVEL", "NEWLEVEL",
                "NEWLEVEL", "NEWLEVEL", "NEWLEVEL", "NEWLEVEL" };

    protected String[] mapnames2 = // DOOM 2 map names.
        { HUSTR_1, HUSTR_2, HUSTR_3, HUSTR_4, HUSTR_5, HUSTR_6, HUSTR_7,
                HUSTR_8, HUSTR_9, HUSTR_10, HUSTR_11,

                HUSTR_12, HUSTR_13, HUSTR_14, HUSTR_15, HUSTR_16, HUSTR_17,
                HUSTR_18, HUSTR_19, HUSTR_20,

                HUSTR_21, HUSTR_22, HUSTR_23, HUSTR_24, HUSTR_25, HUSTR_26,
                HUSTR_27, HUSTR_28, HUSTR_29, HUSTR_30, HUSTR_31, HUSTR_32,HUSTR_33 };

    protected String[] mapnamesp = // Plutonia WAD map names.
        { PHUSTR_1, PHUSTR_2, PHUSTR_3, PHUSTR_4, PHUSTR_5, PHUSTR_6, PHUSTR_7,
                PHUSTR_8, PHUSTR_9, PHUSTR_10, PHUSTR_11,

                PHUSTR_12, PHUSTR_13, PHUSTR_14, PHUSTR_15, PHUSTR_16,
                PHUSTR_17, PHUSTR_18, PHUSTR_19, PHUSTR_20,

                PHUSTR_21, PHUSTR_22, PHUSTR_23, PHUSTR_24, PHUSTR_25,
                PHUSTR_26, PHUSTR_27, PHUSTR_28, PHUSTR_29, PHUSTR_30,
                PHUSTR_31, PHUSTR_32 };

    protected String[] mapnamest = // TNT WAD map names.
        { THUSTR_1, THUSTR_2, THUSTR_3, THUSTR_4, THUSTR_5, THUSTR_6, THUSTR_7,
                THUSTR_8, THUSTR_9, THUSTR_10, THUSTR_11,

                THUSTR_12, THUSTR_13, THUSTR_14, THUSTR_15, THUSTR_16,
                THUSTR_17, THUSTR_18, THUSTR_19, THUSTR_20,

                THUSTR_21, THUSTR_22, THUSTR_23, THUSTR_24, THUSTR_25,
                THUSTR_26, THUSTR_27, THUSTR_28, THUSTR_29, THUSTR_30,
                THUSTR_31, THUSTR_32 };

    char[] shiftxform;

    public static final char[] french_shiftxform =
        {
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                16,
                17,
                18,
                19,
                20,
                21,
                22,
                23,
                24,
                25,
                26,
                27,
                28,
                29,
                30,
                31,
                ' ',
                '!',
                '"',
                '#',
                '$',
                '%',
                '&',
                '"', // shift-'
                '(',
                ')',
                '*',
                '+',
                '?', // shift-,
                '_', // shift--
                '>', // shift-.
                '?', // shift-/
                '0', // shift-0
                '1', // shift-1
                '2', // shift-2
                '3', // shift-3
                '4', // shift-4
                '5', // shift-5
                '6', // shift-6
                '7', // shift-7
                '8', // shift-8
                '9', // shift-9
                '/',
                '.', // shift-;
                '<',
                '+', // shift-=
                '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
                'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
                'V', 'W',
                'X',
                'Y',
                'Z',
                '[', // shift-[
                '!', // shift-backslash - OH MY GOD DOES WATCOM SUCK
                ']', // shift-]
                '"',
                '_',
                '\'', // shift-`
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
                'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
                'Y', 'Z', '{', '|', '}', '~', 127

        };

    public static final char[] english_shiftxform =
        {
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                16,
                17,
                18,
                19,
                20,
                21,
                22,
                23,
                24,
                25,
                26,
                27,
                28,
                29,
                30,
                31,
                ' ',
                '!',
                '"',
                '#',
                '$',
                '%',
                '&',
                '"', // shift-'
                '(',
                ')',
                '*',
                '+',
                '<', // shift-,
                '_', // shift--
                '>', // shift-.
                '?', // shift-/
                ')', // shift-0
                '!', // shift-1
                '@', // shift-2
                '#', // shift-3
                '$', // shift-4
                '%', // shift-5
                '^', // shift-6
                '&', // shift-7
                '*', // shift-8
                '(', // shift-9
                ':',
                ':', // shift-;
                '<',
                '+', // shift-=
                '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
                'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
                'V', 'W',
                'X',
                'Y',
                'Z',
                '[', // shift-[
                '!', // shift-backslash - OH MY GOD DOES WATCOM SUCK
                ']', // shift-]
                '"',
                '_',
                '\'', // shift-`
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
                'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
                'Y', 'Z', '{', '|', '}', '~', 127 };

    // Maes: char?
    char[] frenchKeyMap =
        { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
                20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ' ', '!', '"',
                '#', '$', '%', '&', '%', '(', ')', '*', '+', ';', '-', ':',
                '!', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':',
                'M', '<', '=', '>', '?', '@', 'Q', 'B', 'C', 'D', 'E', 'F',
                'G', 'H', 'I', 'J', 'K', 'L', ',', 'N', 'O', 'P', 'A', 'R',
                'S', 'T', 'U', 'V', 'Z', 'X', 'Y', 'W', '^', '\\', '$', '^',
                '_', '@', 'Q', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                'K', 'L', ',', 'N', 'O', 'P', 'A', 'R', 'S', 'T', 'U', 'V',
                'Z', 'X', 'Y', 'W', '^', '\\', '$', '^', 127 };

    protected final char ForeignTranslation(char ch) {
        return ch < 128 ? frenchKeyMap[ch] : ch;
    }

    public HU(DoomStatus DM) {
    	this.updateStatus(DM);
    	
    	this.w_message=new hu_stext_t();

    	this.w_inputbuffer=new hu_itext_t[MAXPLAYERS];
    	for (int i=0;i<MAXPLAYERS;i++){
    		this.w_inputbuffer[i]=new hu_itext_t();
    	}
    	this.w_title=new hu_textline_t();
    	this.w_chat=new hu_itext_t();
    }

    
    /** Used only for testing */
    public HU() {

    }

    /**
     * Loads a bunch of STCFNx fonts from WAD, and sets some of the remaining
     * constants.
     * 
     * @throws Exception
     */

    @Override
    public void Init()
             {
        String xxx = new String("STCFN%03d");
        int i;
        int j;
        String buffer;

        if (DM.language == Language_t.french)
            shiftxform = french_shiftxform;
        else
            shiftxform = english_shiftxform;

        // load the heads-up font
        j = HU_FONTSTART;

        // So it basically loads a bunch of patch_t's from memory.
        C2JUtils.initArrayOfObjects(hu_font, patch_t.class);

        for (i = 0; i < HU_FONTSIZE; i++) {
            buffer = String.format(xxx,j++);
            // hu_font[i] = ((patch_t[]) wd.CacheLumpName(buffer, PU_STATIC);
            hu_font[i] = (W.CachePatchName(buffer, PU_STATIC));
        }

        // MAES: Doom's SC had a really fucked up endianness change for height.
        // I don't really see the point in that, as in the WAD patches appear
        // to be all Little Endian... mystery :-S
        // HU_TITLEY = (167 - Swap.SHORT(hu_font[0].height));
        HU_TITLEY = (167 - hu_font[0].height);
        HU_INPUTY = (HU_MSGY + HU_MSGHEIGHT * hu_font[0].height + 1);

    }
    
    @Override
    public void Stop() {
        headsupactive = false;
    }

    @Override
    public void Start() {

        int i;
        String s;
        
        // MAES: fugly hax. These were compile-time inlines,
        // so they can either work as functions, or be set whenever the HU is started
        // (typically once per level). They need to be aware of game progress,
        // and episode numbers <1 will cause it to bomb.
        // MAES: hack to handle Betray in XBLA 31/5/2011
        if ((DM.gamemap>32) && (DM.getGameMode()==GameMode_t.pack_xbla)){
        this.HU_TITLE = mapnames[(DM.gameepisode - 1) * 9 + DM.gamemap - 2];


        this.HU_TITLE2 = mapnames2[DM.gamemap - 1];
        this.HU_TITLEP = mapnamesp[DM.gamemap - 2]; // fixed from HU_TITLEPw
        this.HU_TITLET = mapnamest[DM.gamemap - 2];
        } else {
            this.HU_TITLE = mapnames[(DM.gameepisode - 1) * 9 + DM.gamemap - 1];
            this.HU_TITLE2 = mapnames2[DM.gamemap - 1];
            this.HU_TITLEP = mapnamesp[DM.gamemap - 1]; // fixed from HU_TITLEP
            this.HU_TITLET = mapnamest[DM.gamemap - 1];
        }

        if (headsupactive)
            this.Stop();

        plr = DM.players[DM.consoleplayer];
        message_on[0] = false;
        message_dontfuckwithme = false;
        message_nottobefuckedwith = false;
        chat_on[0] = false;

        // create the message widget
        this.w_message.initSText(HU_MSGX, HU_MSGY, HU_MSGHEIGHT, hu_font,
            HU_FONTSTART, this.message_on);

        // create the map title widget
        this.w_title.initTextLine(HU_TITLEX, HU_TITLEY, hu_font, HU_FONTSTART);

        switch (DM.getGameMode()) {
        case shareware:
        case registered:
        case retail:
            s = HU_TITLE;
            break;

       case pack_plut: s = HU_TITLEP; 
           break; 
       case pack_tnt: s = HU_TITLET;
       break;
       
        case commercial:
        default:
            s = HU_TITLE2;
            break;
        }

        // MAES: oh great, more pointer-char magic... oh no you don't, you ugly
        // cow horse and reindeer lover.

        // while (*s) this.w_title.addCharToTextLine(*(s++));
        int ptr=0;
        while(ptr<s.length()){
        this.w_title.addCharToTextLine(s.charAt(ptr++));
        }
        // create the chat widget
        this.w_chat.initIText(HU_INPUTX, HU_INPUTY, hu_font, HU_FONTSTART,
            chat_on);

        // create the inputbuffer widgets
        for (i = 0; i < MAXPLAYERS; i++) {
            w_inputbuffer[i] = new hu_itext_t();
            w_inputbuffer[i].initIText(0, 0, null, 0, always_off);
        }
        headsupactive = true;

    }

    @Override
    public void Drawer() {
        this.w_message.drawSText();
        this.w_chat.drawIText();
        if (DM.automapactive)
            this.w_title.drawTextLine(false);
    }

    @Override
    public void Erase() {
        this.w_message.eraseSText();
        this.w_chat.eraseIText();
        this.w_title.eraseTextLine();
    }

    @Override
    public void Ticker() {

        int i;
        boolean rc;
        char c;

        // tick down message counter if message is up
        if ((message_counter != 0) && !((--message_counter) != 0)) {
            message_on[0] = false;
            message_nottobefuckedwith = false;
        }

        if (M.getShowMessages() || message_dontfuckwithme) {

            // display message if necessary
            if (((plr.message != null) && !message_nottobefuckedwith)
                    || ((plr.message != null) && message_dontfuckwithme)) {
                this.w_message.addMessageToSText(null, plr.message);
                plr.message = null;
                message_on[0] = true;
                message_counter = HU_MSGTIMEOUT;
                message_nottobefuckedwith = message_dontfuckwithme;
                message_dontfuckwithme = false;
            }

        } // else message_on = false;

        // check for incoming chat characters
        if (DM.netgame) {
            for (i = 0; i < MAXPLAYERS; i++) {
                if (!DM.playeringame[i])
                    continue;
                if ((i != DM.consoleplayer)
                        && ((c = DM.players[i].cmd.chatchar) != 0)) {
                    if (c <= HU_BROADCAST)
                        chat_dest[i] = c;
                    else {
                        if (c >= 'a' && c <= 'z')
                            c = (char) shiftxform[c];
                        rc = w_inputbuffer[i].keyInIText(c);
                        if (rc && c == KEY_ENTER) {
                            if ((w_inputbuffer[i].l.len != 0)
                                    && (chat_dest[i] == DM.consoleplayer + 1)
                                    || (chat_dest[i] == HU_BROADCAST)) {
                                w_message.addMessageToSText(player_names[i]
                                        , w_inputbuffer[i].l.text.toString());

                                message_nottobefuckedwith = true;
                                message_on[0] = true;
                                message_counter = HU_MSGTIMEOUT;
                                if (DM.isCommercial())
                                    S.StartSound(null, sfxenum_t.sfx_radio);
                                    
                                else
                                    S.StartSound(null, sfxenum_t.sfx_tink);
                                    
                            }
                            w_inputbuffer[i].resetIText();
                        }
                    }
                    DM.players[i].cmd.chatchar = 0;
                }
            }
        }

    }

    protected final int QUEUESIZE = 128;

    protected char[] chatchars = new char[QUEUESIZE];

    protected int head = 0;

    protected int tail = 0;

    protected void queueChatChar(char c) {
        if (((head + 1) & (QUEUESIZE - 1)) == tail) {
            plr.message = HUSTR_MSGU;
        } else {
            chatchars[head] = c;
            head = (head + 1) & (QUEUESIZE - 1);
        }
    }

    @Override
    public char dequeueChatChar() {
        char c;

        if (head != tail) {
            c = chatchars[tail];
            tail = (tail + 1) & (QUEUESIZE - 1);
        } else {
            c = 0;
        }

        return c;
    }

    // MAES: These were "static" inside HU_Responder, since they were meant to
    // represent state.
    protected StringBuilder lastmessage = new StringBuilder(HU_MAXLINELENGTH + 1);

    // protected char[] lastmessage=new char[HU_MAXLINELENGTH+1];
    protected boolean shiftdown = false;

    protected boolean altdown = false;

    protected char[] destination_keys =
        { HUSTR_KEYGREEN, HUSTR_KEYINDIGO, HUSTR_KEYBROWN, HUSTR_KEYRED };

    protected int num_nobrainers = 0;

    @Override
    public boolean Responder(event_t ev) {

    	//System.out.println("Player "+DM.players[0].mo.x);
        char[] macromessage;
        boolean eatkey = false;

        char c;
        int i;
        int numplayers;

        numplayers = 0;
        // MAES: Adding BOOLEANS to ints, are we ?!
        for (i = 0; i < MAXPLAYERS; i++) {
            numplayers += (DM.playeringame[i]) ? 1 : 0;
        }

        if (ev.data1 == KEY_SHIFT) {
            shiftdown = (ev.type == evtype_t.ev_keydown);
            return false;
        } else if (ev.data1 == KEY_ALT || ev.data1 == KEY_ALT) {
            altdown = (ev.type == evtype_t.ev_keydown);
            return false;
        }

        if (ev.type != evtype_t.ev_keydown)
            return false;

        if (!chat_on[0]) {
            if (ev.data1 == HU_MSGREFRESH) {
                message_on[0] = true;
                message_counter = HU_MSGTIMEOUT;
                eatkey = true;
            } else if (DM.netgame && ev.data1 == HU_INPUTTOGGLE) {
                eatkey = chat_on[0] = true;
                w_chat.resetIText();
                this.queueChatChar(HU_BROADCAST);
            } else if (DM.netgame && numplayers > 2) {
                for (i = 0; i < MAXPLAYERS; i++) {
                    if (ev.data1 == destination_keys[i]) {
                        if (DM.playeringame[i] && i != DM.consoleplayer) {
                            eatkey = chat_on[0] = true;
                            w_chat.resetIText();
                            this.queueChatChar((char) (i + 1));
                            break;
                        } else if (i == DM.consoleplayer) {
                            num_nobrainers++;
                            if (num_nobrainers < 3)
                                plr.message = HUSTR_TALKTOSELF1;
                            else if (num_nobrainers < 6)
                                plr.message = HUSTR_TALKTOSELF2;
                            else if (num_nobrainers < 9)
                                plr.message = HUSTR_TALKTOSELF3;
                            else if (num_nobrainers < 32)
                                plr.message = HUSTR_TALKTOSELF4;
                            else
                                plr.message = HUSTR_TALKTOSELF5;
                        }
                    }
                }
            }
        } else {
            c = (char) ev.data1;
            // send a macro
            if (altdown) {
                c = (char) (c - '0');
                if (c > 9)
                    return false;
                // fprintf(stderr, "got here\n");
                macromessage = chat_macros[c].toCharArray();

                // kill last message with a '\n'
                this.queueChatChar(KEY_ENTER); // DEBUG!!!

                // send the macro message
                int index = 0;
                while (macromessage[index] != 0) {
                    this.queueChatChar(macromessage[index]);
                }
                this.queueChatChar(KEY_ENTER);

                // leave chat mode and notify that it was sent
                chat_on[0] = false;
                lastmessage.setLength(0);
                lastmessage.append(chat_macros[c]);
                plr.message = lastmessage.toString();
                eatkey = true;
            } else {
                if (DM.language == Language_t.french)
                    c = ForeignTranslation(c);
                if (shiftdown || (c >= 'a' && c <= 'z'))
                    c = shiftxform[c];
                eatkey = w_chat.keyInIText(c);
                if (eatkey) {
                    // static unsigned char buf[20]; // DEBUG
                    this.queueChatChar(c);

                    // sprintf(buf, "KEY: %d => %d", ev->data1, c);
                    // plr->message = buf;
                }
                if (c == KEY_ENTER) {
                    chat_on[0] = false;
                    if ((w_chat.l.len != 0)) {
                        lastmessage.setLength(0);
                        lastmessage.append( w_chat.l.text);
                        plr.message = new String(lastmessage);
                    }
                } else if (c == KEY_ESCAPE)
                    chat_on[0] = false;
            }
        }

        return eatkey;

    }

    // ///////////////////////////////// STRUCTS
    // ///////////////////////////////////

    /**
     *  Input Text Line widget
     *  (child of Text Line widget)
     */
    
    class hu_itext_t {


        hu_textline_t l; // text line to input on

        // left margin past which I am not to delete characters
        int lm;

        // pointer to boolean stating whether to update window
        boolean[] on;

        boolean laston; // last value of *->on;

        public hu_itext_t(){
        	
        }
        
        public void initIText(int x, int y, patch_t[] font, int startchar,
                boolean[] on) {
            this.lm = 0; // default left margin is start of text
            this.on = on;
            this.laston = true;
            l = new hu_textline_t(x, y, font, startchar);
        }

        // The following deletion routines adhere to the left margin restriction
        public void delCharFromIText() {
            if (this.l.len != this.lm)
                this.l.delCharFromTextLine();
        }

        public void eraseLineFromIText() {
            while (this.lm != this.l.len)
                l.delCharFromTextLine();
        }

        // Resets left margin as well
        public void resetIText() {
            this.lm = 0;
            this.l.clearTextLine();
        }

        public void addPrefixToIText(char[] str) {
            int ptr = 0;
            while (str[ptr] > 0) {
                l.addCharToTextLine(str[ptr++]);
                this.lm = this.l.len;
            }
        }

        // Maes: String overload
        public void addPrefixToIText(String str) {
            int ptr = 0;
            while (str.charAt(ptr) > 0) {
                l.addCharToTextLine(str.charAt(ptr++));
                this.lm = this.l.len;
            }
        }

        // wrapper function for handling general keyed input.
        // returns true if it ate the key
        public boolean keyInIText(char ch) {

            if (ch >= ' ' && ch <= '_')
                this.l.addCharToTextLine((char) ch);
            else if (ch == KEY_BACKSPACE)
                this.delCharFromIText();
            else if (ch != KEY_ENTER)
                return false; // did not eat key

            return true; // ate the key

        }

        public void drawIText() {

            if (!this.on[0])
                return;
            this.l.drawTextLine(true); // draw the line w/ cursor

        }

        void eraseIText() {
            if (this.laston && !this.on[0])
                this.l.needsupdate = 4;
            this.l.eraseTextLine();
            this.laston = this.on[0];
        }

    }

    /** Scrolling Text window widget
     *  (child of Text Line widget)
     */  

    class hu_stext_t {

        hu_textline_t[] lines = new hu_textline_t[HU_MAXLINES]; // text lines to draw

        int height; // height in lines

        int currline; // current line number

        // pointer to boolean stating whether to update window
        boolean[] on;

        boolean laston; // last value of *->on.

        public hu_stext_t(){
        	
        }
        
        public hu_stext_t(int x, int y, int h, patch_t[] font, int startchar,
                boolean[] on) {
            this.initSText(x, y, h, font, startchar, on);
        }

        public void initSText(int x, int y, int h, patch_t[] font,
                int startchar, boolean[] on) {

        	for (int i=0;i<HU_MAXLINES;i++){
        		this.lines[i]=new hu_textline_t();
        	}
            this.height = h;
            this.on = on;
            this.laston = true;
            this.currline = 0;
            for (int i = 0; i < h; i++)
                this.lines[i].initTextLine(x, y - i
                        * (font[0].height + 1), font, startchar);

        }

        public void addLineToSText() {

            // add a clear line
            if (++this.currline == this.height)
                this.currline = 0;
            this.lines[this.currline].clearTextLine();

            // everything needs updating
            for (int i = 0; i < this.height; i++)
                this.lines[i].needsupdate = 4;

        }

        public void addMessageToSText(char[] prefix, char[] msg) {
            this.addLineToSText();
            int ptr = 0;
            if ((prefix != null) && (prefix.length > 0)) {
                
                while ((ptr < prefix.length) && (prefix[ptr] > 0))
                    this.lines[this.currline].addCharToTextLine(prefix[ptr++]);
                }
            
                ptr = 0;
                while ((ptr < msg.length) && (msg[ptr] > 0))
                    this.lines[this.currline].addCharToTextLine(msg[ptr++]);
            }

        public void addMessageToSText(String prefix, String msg) {
            this.addLineToSText();
            if ((prefix != null) && (prefix.length() > 0)) {
                for (int i = 0; i < prefix.length(); i++)
                    this.lines[this.currline].addCharToTextLine(prefix.charAt(i));
            }
                for (int i = 0; i < msg.length(); i++)
                    this.lines[this.currline].addCharToTextLine(msg.charAt(i));
        }

        public void drawSText() {
            int i, idx;
            hu_textline_t l;

            if (!this.on[0])
                return; // if not on, don't draw

            
            
            // draw everything
            for (i = 0; i < this.height; i++) {                
                idx = this.currline - i;
                if (idx < 0)
                    idx += this.height; // handle queue of lines

                l = this.lines[idx];

                // need a decision made here on whether to skip the draw
                l.drawTextLine(false); // no cursor, please
            }

        }

        public void eraseSText() {
            for (int i = 0; i < this.height; i++) {
                if (laston && !on[0])
                    lines[i].needsupdate = 4;
                this.lines[i].eraseTextLine();
            }
            laston = on[0];

        }

        /**
         * MAES: this was the only variable in HUlib.c, and only instances of
         * hu_textline_t ever use it. For this reason, it makes sense to have it
         * common (?) between all instances of hu_textline_t and set it
         * somewhere else. Of course, if could be made an instance method or a
         * HUlib object could be defined.
         */
        protected boolean automapactive; // in AM_map.c

        public boolean isAutomapactive() {
            return automapactive;
        }

        public void setAutomapactive(boolean automapactive) {
            this.automapactive = automapactive;
        }

        /**
         * Same here.
         */

        // TODO: boolean : whether the screen is always erased
        protected boolean noterased; // =viewwindowx;

        public boolean isNoterased() {
            return noterased;
        }

        public void setNoterased(boolean noterased) {
            this.noterased = noterased;
        }
        
        StringBuilder sb=new StringBuilder();
        
        public String toString(){
            sb.setLength(0);
            sb.append(this.lines[0].text);
            sb.append(this.lines[1].text);
            sb.append(this.lines[2].text);
            sb.append(this.lines[3].text);
            return sb.toString();
        }

    }

    // Text Line widget
    // (parent of Scrolling Text and Input Text widgets)

    class hu_textline_t {

        // left-justified position of scrolling text window
        int x;

        int y;

        // MAES: was **
        patch_t[] f; // font

        int sc; // start character

        char[] text = new char[HU_MAXLINELENGTH+1]; // line of text

        int len; // current line length

        // whether this line needs to be udpated
        int needsupdate;

        public hu_textline_t(){
        	
        }
        
        public void clearTextLine() {
            this.len = 0;
            C2JUtils.memset(this.text, (char)0,this.text.length);
            // It's actually used as a status, go figure.
            this.needsupdate = 1;
        }

        // Maes: this could as well be the contructor

        public void initTextLine(int x, int y, patch_t[] f, int sc) {
            this.x = x;
            this.y = y;
            this.f = f;
            this.sc = sc;
            this.clearTextLine();
        }

        public hu_textline_t(int x, int y, patch_t[] f, int sc) {
            this.x = x;
            this.y = y;
            this.f = f;
            this.sc = sc;
            this.clearTextLine();
        }

        public boolean addCharToTextLine(char ch) {

            if (len == HU_MAXLINELENGTH)
                return false;
            else {
                this.text[len++]=ch;
                this.text[len]=(char)0;
                // this.l[this.len] = 0;
                // MAES: for some reason this is set as "4", so this is a status
                // rather than a boolean.
                this.needsupdate = 4;
                return true;
            }

        }

        /**
         * MAES: This is much better than cluttering up the syntax everytime a
         * STRING must be added.
         * 
         * @param s
         * @return
         */
/*
        public boolean addStringToTextLine(String s) {
            int index = 0;
            if (this.len == HU_MAXLINELENGTH)
                return false;
            else
                while ((index<s.length())&&(this.len < HU_MAXLINELENGTH)) {

                    this.l[len]append(s.charAt(index++));
                    this.len++;
                }
            this.l.append((char) 0);// final padding.

            // MAES: for some reason this is set as "4", so this is a
            // status rather than a boolean.

            this.needsupdate = 4;
            return true;
        } */

        boolean delCharFromTextLine() {

            if (this.len == 0)
                return false;
            else {
                this.text[--len]= (char)0;
                this.needsupdate = 4;
                return true;
            }

        }

        void drawTextLine(boolean drawcursor) {

            int i;
            int w;
            int x;
            char c;

            // draw the new stuff
            x = this.x;
            for (i = 0; i < this.len; i++) {
                c = Character.toUpperCase(text[i]);
                if (c != ' ' && c >= this.sc && c <= '_') {
                    // MAES: fixed a FUCKING STUPID bug caused by SWAP.SHORT
                    w = this.f[c - this.sc].width;
                    if (x + w > SCREENWIDTH)
                        break;
                    
                    V.DrawScaledPatch(x, y, FG,vs, f[c - sc]);
                    x += w;
                } else {
                    // Leave a space
                    x += 4;
                    if (x >= SCREENWIDTH)
                        break;
                }
            }

            // draw the cursor if requested
            if (drawcursor
                    && x + this.f['_' - this.sc].width <= SCREENWIDTH) {
                V.DrawScaledPatch(x, this.y, FG,vs, this.f['_' - this.sc]);
            }
        }

        // MAES: was "static" in C within HUlib. Which may mean it's instance
        // specific or global-ish. Or both.
        protected boolean lastautomapactive = true;

        // sorta called by HU_Erase and just better darn get things straight
        public void eraseTextLine() {
            int lh;

            // Only erases when NOT in automap and the screen is reduced,
            // and the text must either need updating or refreshing
            // (because of a recent change back from the automap)

            if (!DM.automapactive && (R.view.windowx != 0)
                    && (this.needsupdate > 0)) {
                lh = this.f[0].height + 1;

                for (int y = this.y, yoffset = y * SCREENWIDTH; y < this.y + lh; y++, yoffset +=
                    SCREENWIDTH) {
                    // Stuff is probably in am_map??
                    if (y < R.view.windowy
                            || y >= R.view.windowy + R.view.height)
                        R.VideoErase(yoffset, SCREENWIDTH); // erase entire
                    // line
                    else {
                        R.VideoErase(yoffset, R.view.windowx); // erase left
                        // border
                        R.VideoErase(yoffset + R.view.windowx + R.view.width,
                            R.view.windowx);
                        // erase right border
                    }
                }
            }

            lastautomapactive = DM.automapactive;
            if (this.needsupdate != 0)
                this.needsupdate--;

        }

    }

    @Override
    public patch_t[] getHUFonts() {        
        return this.hu_font;
    }

	@Override
	public void updateStatus(DoomStatus<?,?> DM) {
        this.DM = DM.DM;
        this.W = DM.W;
        this.R = (RendererState<?, ?>) DM.R;
        this.V=DM.V;
        this.S=DM.S;
        this.M=(Menu) DM.M;
		
	}
	
////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

	protected int SCREENWIDTH;
	protected int SCREENHEIGHT;
	protected int SAFE_SCALE;
	protected IVideoScale vs;


	@Override
	public void setVideoScale(IVideoScale vs) {
	    this.vs=vs;
	}

	@Override
	public void initScaling() {
	    this.SCREENHEIGHT=vs.getScreenHeight();
	    this.SCREENWIDTH=vs.getScreenWidth();
	    this.SAFE_SCALE=vs.getSafeScaling();
	}
	
}

//$Log: HU.java,v $
//Revision 1.32  2012/09/24 17:16:23  velktron
//Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
//Revision 1.31.2.2  2012/09/24 16:57:43  velktron
//Addressed generics warnings.
//
//Revision 1.31.2.1  2012/09/19 17:43:06  velktron
//Aware of new ViewVars structure.
//
//Revision 1.31  2011/11/01 22:17:46  velktron
//Cleaned up a bit, implements IHeadsUp
//
//Revision 1.30  2011/10/23 18:11:58  velktron
//Generic compliance for DoomVideoInterface
//
//Revision 1.29  2011/10/07 16:05:22  velktron
//Now using g.Keys for key input stuff.
//
//Revision 1.28  2011/05/31 23:46:18  velktron
//Fixed scaling.
//
//Revision 1.27  2011/05/31 21:42:30  velktron
//Handling for map33
//
//Revision 1.26  2011/05/24 17:45:08  velktron
//IHeadsUp interface, setChatMacro method.
//
//Revision 1.25  2011/05/23 16:56:44  velktron
//Migrated to VideoScaleInfo.
//
//Revision 1.24  2011/05/21 14:42:32  velktron
//Adapted to use new gamemode system.
//
//Revision 1.23  2011/05/20 18:27:12  velktron
//DoomMenu -> IDoomMenu
//
//Revision 1.22  2011/05/20 18:24:19  velktron
//FINALLY fixed a stupid bug that broke HU messages.
//
//Revision 1.21  2011/05/18 16:52:40  velktron
//Changed to DoomStatus
package hu;

import rr.patch_t;
import doom.event_t;

public interface IHeadsUp {

	void Ticker();

	void Erase();

	void Drawer();

	boolean Responder(event_t ev);

	patch_t[] getHUFonts();

	char dequeueChatChar();

	void Init();

	void setChatMacro(int i, String s);

	void Start();

	void Stop();

}

package w;

public class JadDecompress {

    public final static int WINDOW_SIZE = 4096;

    public final static int LOOKAHEAD_SIZE = 16;

    public final static int LENSHIFT = 4; /* this must be log2(LOOKAHEAD_SIZE) */

    public static void decode(byte[] input, byte[] output) {
        /*
         * #ifdef JAGUAR decomp_input = input; decomp_output = output;
         * gpufinished = zero; gpucodestart = (int)&decomp_start; while
         * (!I_RefreshCompleted () ) ; #else
         */
        int getidbyte = 0;
        int len;
        int pos;
        int i;
        int source_ptr, input_ptr = 0, output_ptr = 0;
        int idbyte = 0;

        while (true) {

            /* get a new idbyte if necessary */
            if (getidbyte == 0) idbyte = 0xFF & input[input_ptr++];
            getidbyte = (getidbyte + 1) & 7;

            if ((idbyte & 1) != 0) {
                /* decompress */
                pos = (0xFF & input[input_ptr++]) << LENSHIFT;
                pos = pos | ((0xFF & input[input_ptr]) >> LENSHIFT);
                source_ptr = output_ptr - pos - 1;

                len = ((0xFF & input[input_ptr++]) & 0xf) + 1;

                if (len == 1)
                    break;
                for (i = 0; i < len; i++)
                    output[output_ptr++] = output[source_ptr++];
            } else {
                output[output_ptr++] = input[input_ptr++];
            }

            idbyte = idbyte >> 1;

        }

        System.out.printf("Expanded %d to %d\n", input_ptr, output_ptr);
    }

}

package w;

/** killough 4/17/98: namespace tags, to prevent conflicts between resources */

public enum li_namespace {
      ns_global,
      ns_sprites,
      ns_flats,
      ns_colormaps,
      ns_prboom,
      ns_demos,
      ns_hires //e6y
    } // haleyjd 05/21/02: renamed from "namespace"


package w;

import java.io.IOException;
import java.nio.ByteBuffer;

/** A container allowing for caching of arrays of CacheableDoomObjects 
 *  
 *  It's a massive improvement over the older system, allowing for proper 
 *  caching and auto-unpacking of arrays of CacheableDoomObjects and much 
 *  cleaner code throughout.
 *  
 *  The container itself is a CacheableDoomObject....can you feel the
 *  abuse? ;-)
 * 
 */

public class CacheableDoomObjectContainer<T extends CacheableDoomObject> implements CacheableDoomObject {
	
	private T[] stuff;
	
	public CacheableDoomObjectContainer(T[] stuff){
		this.stuff=stuff;
	}
	
	public T[] getStuff(){
		return stuff;
	}
	
	@Override
	public void unpack(ByteBuffer buf) throws IOException {
		for (int i = 0; i < stuff.length; i++) {
				stuff[i].unpack(buf);
			}
		}
	
	/** Statically usable method
	 * 
	 * @param buf
	 * @param stuff
	 * @throws IOException
	 */
	
	public static void unpack(ByteBuffer buf, CacheableDoomObject[] stuff) throws IOException{
	       for (int i = 0; i < stuff.length; i++) {
               stuff[i].unpack(buf);
           }
	}

}

package w;

import java.io.InputStream;
import java.util.zip.ZipEntry;

// CPhipps - changed wad init
// We _must_ have the wadfiles[] the same as those actually loaded, so there 
// is no point having these separate entities. This belongs here.

public class wadfile_info_t {
      public String name; // Also used as a resource identifier, so save with full path and all.
      public ZipEntry entry; // Secondary resource identifier e.g. files inside zip archives.
      public int type; // as per InputStreamSugar
      public wad_source_t src;
      public InputStream handle;
      public boolean cached; // Whether we use local caching e.g. for URL or zips
      public long maxsize=-1; // Update when known for sure. Will speed up seeking.
    }

package w;

import java.io.IOException;
import java.nio.ByteBuffer;

public interface IPackableDoomObject {
    public void pack(ByteBuffer buf) throws IOException ;
}

package w;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import utils.C2JUtils;

/**
 * As we know, Java can be a bit awkward when handling streams e.g. you can't
 * really skip at will without doing some nasty crud. This class helps doing
 * such crud. E.g. if we are dealing with a stream that has an underlying file,
 * we can try and skip directly by using the file channel, otherwise we can try
 * (eww) closing the stream, reopening it (ASSUMING WE KNOW THE SOURCE'S URI AND
 * TYPE), and then skipping.
 * 
 * @author Maes
 */

public class InputStreamSugar {

    public static final int UNKNOWN_TYPE = 0x0;

    public static final int FILE = 0x1; // Local file. Easiest case

    public static final int NETWORK_FILE = 0x2;

    public static final int ZIP_FILE = 0x4; // Zipped file
    
    public static final int BAD_URI = -1; // Bad or unparseable 

    /**
     * Creates an inputstream from a local file, network resource, or zipped
     * file (also over a network). If an entry name is specifid AND the type is
     * specified to be zip, then a zipentry with that name will be sought.
     * 
     * @param resource
     * @param contained
     * @param type
     * @return
     */

    public static final InputStream createInputStreamFromURI(String resource,
            ZipEntry entry, int type) {

        InputStream is = null;
        URL u;

        // No entry specified or no zip type, try everything BUT zip.
        if (entry == null || !C2JUtils.flags(type,ZIP_FILE)) {
            is = getDirectInputStream(resource);
        } else {
            // Entry specified AND type specified to be zip
            // We might want to open even a zip file without looking 
            // for any particular entry.
            if (entry != null && C2JUtils.flags(type,ZIP_FILE)) {
                
                ZipInputStream zis;
                // Try it as a NET zip file
                try {
                    u = new URL(resource);
                    zis = new ZipInputStream(u.openStream());
                } catch (Exception e) {
                    // Local zip file?
                    try {
                        // Open resource as local file-backed zip input stream, 
                        // and search proper entry.
                        zis= new ZipInputStream(new FileInputStream(resource));
                        }
                    catch (Exception e1) {
                        // Well, it's not that either.
                        // At this point we almost ran out of options
                        // Try a local file and that's it.
                        is = getDirectInputStream(resource);
                        return is;
                    }
                }
                
                // All OK?
                is=getZipEntryStream(zis, entry.getName());
                if (is!=null) return is; 
                }
            }

        // At this point, you'll either get a stream or jack.

        return getDirectInputStream(resource);
    }

    /** Match zip entries in a ZipInputStream based only on their name. 
     * Luckily (?) ZipEntries do not keep references to their originating
     * streams, so opening/closing ZipInputStreams all the time won't result
     * in a garbage hell...I hope.
     * 
     * @param zis
     * @param entryname
     * @return
     */
    
    private static InputStream getZipEntryStream(ZipInputStream zis,String entryname) {
        
        ZipEntry ze = null;
        try {
            while ((ze = zis.getNextEntry()) != null) {
                // Directories cannot be opened
                if (ze.isDirectory())
                    continue;

                if (ze.getName().equals(entryname)) {
                    return zis;
                }
            }
        } catch (IOException e) {
            // Get jack
            return null;
        }
    
        // Get jack
        return null;
    }
    
    private final static InputStream getDirectInputStream(String resource) {
        InputStream is = null;
        URL u;

        try { // Is it a net resource?
            u = new URL(resource);
            is = u.openStream();
        } catch (Exception e) {
            // OK, not a valid URL or no network. We don't care.
            // Try opening as a local file.
            try {
                is = new FileInputStream(resource);
            } catch (FileNotFoundException e1) {
                // Well, it's not that either.
                // At this point we really ran out of options
                // and you'll get null
            }
        }

        return is;
    }

    /**
     * Attempt to do the Holy Grail of Java Streams, aka seek to a particular
     * position. With some types of stream, this is possible if you poke deep
     * enough. With others, it's not, and you can only close & reopen them
     * (provided you know how to do that) and then skip to a particular position
     * 
     * @param is
     * @param pos
     *        The desired position
     * @param URI
     *        Information which can help reopen a stream, e.g. a filename, URL,
     *        or zip file.
     * @peram entry If we must look into a zipfile entry
     * @return the skipped stream. Might be a totally different object.
     * @throws IOException
     */

    public static final InputStream streamSeek(InputStream is, long pos,
            long size,String URI, ZipEntry entry, int type)
            throws IOException {
        if (is == null)
            return is;

        // If we know our actual position in the stream, we can aid seeking
        // forward

        /*
         * Too buggy :-/ pity if (knownpos>=0 && knownpos<=pos){ if
         * (pos==knownpos) return is; try{ final long mustskip=pos-knownpos;
         * long skipped=0; while (skipped<mustskip){
         * skipped+=is.skip(mustskip-skipped);
         * System.out.printf("Must skip %d skipped %d\n",mustskip,skipped); }
         * return is; } catch (Exception e){ // We couldn't skip cleanly.
         * Swallow up and try normally. System.err.println("Couldn't skip"); } }
         */

        // This is a more reliable method, although it's less than impressive in
        // results.
        if (size > 0) {
            try {
                long available = is.available();
                long guesspos = size - available;
                // The stream is at a position before or equal to
                // our desired one. We can attempt skipping forward.
                if (guesspos > 0 && guesspos <= pos) {
                    long skipped=0;
                    long mustskip=pos-guesspos;
                    // Repeat skipping until proper amount reached 
                    while (skipped<mustskip)
                        skipped+=is.skip(mustskip-skipped);
                    return is;
                }
            } catch (Exception e) {
                // We couldn't skip cleanly. Swallow up and try normally.
            }
        }
        
        

        // Cast succeeded
        if (is instanceof FileInputStream) {
            try {
                ((FileInputStream) is).getChannel().position(pos);
                return is;
            } catch (IOException e) {
                // Ouch. Do a dumb close & reopening.
                is.close();
                is = createInputStreamFromURI(URI, null, 1);
                is.skip(pos);
                return is;
            }
        }

        // Cast succeeded
        if (is instanceof ZipInputStream) {
            // ZipInputStreams are VERY dumb. so...
                is.close();
                is = createInputStreamFromURI(URI,entry,type);
                is.skip(pos);
                return is;

        }

        try { // Is it a net resource? We have to reopen it :-/
              // long a=System.nanoTime();
            URL u = new URL(URI);
            InputStream nis = u.openStream();
            nis.skip(pos);
            is.close();
            // long b=System.nanoTime();
            // System.out.printf("Network stream seeked WITH closing %d\n",(b-a)/1000);
            return nis;
        } catch (Exception e) {

        }

        // TODO: zip handling?

        return is;
    }

    public static List<ZipEntry> getAllEntries(ZipInputStream zis)
            throws IOException {
        ArrayList<ZipEntry> zes = new ArrayList<ZipEntry>();

        ZipEntry z;

        while ((z = zis.getNextEntry()) != null) {
            zes.add(z);
        }

        return zes;
    }

    /** Attempts to return a stream size estimate. Only guaranteed to work 100% 
     * for streams representing local files, and zips (if you have the entry).
     * 
     * @param is
     * @param z
     * @return
     */
    
    public static long getSizeEstimate(InputStream is, ZipEntry z) {
        if (is instanceof FileInputStream) {
            try {
                return ((FileInputStream) is).getChannel().size();
            } catch (IOException e) {

            }
        }

        if (is instanceof FileInputStream) {
            if (z != null)
                return z.getSize();
        }

        // Last ditch
        try {
            return is.available();
        } catch (IOException e) {
            try {
                return is.available();
            } catch (IOException e1) {
                return -1;
            }
        }
    }

}
package w;

public enum animenum_t {

    ANIM_ALWAYS,
    ANIM_RANDOM,
    ANIM_LEVEL

}

package w;

import java.io.IOException;
import rr.patch_t;

public interface IWadLoader {

	/**
	 * W_Reload Flushes any of the reloadable lumps in memory and reloads the
	 * directory.
	 * 
	 * @throws Exception
	 */
	public abstract void Reload() throws Exception;

	/**
	 * W_InitMultipleFiles
	 *
	 * Pass a null terminated list of files to use (actually a String[] array in Java).
	 * 
	 * All files are optional, but at least one file must be found. 
	 * 
	 * Files with a .wad extension are idlink files with multiple lumps.
	 * 
	 * Other files are single lumps with the base filename for the lump name.
	 * 
	 * Lump names can appear multiple times.
	 * The name searcher looks backwards, so a later file does override all earlier ones.
	 * 
	 * @param filenames
	 * @param coalesce Choose whether to coalesce or not sprites, flats etc.
	 * 
	 */

	public abstract void InitMultipleFiles(String[] filenames, boolean coalesce) throws Exception;

	/**
	 * W_InitFile
	 * 
	 * Just initialize from a single file.
	 * 
	 * @param filename 
	 * @param coalesce Choose whether to coalesce or not sprites, flats etc.
	 * 
	 */
	public abstract void InitFile(String filename, boolean coalesce) throws Exception;

	/**
	 * W_NumLumps
	 * 
	 * Returns the total number of lumps loaded in this Wad manager. Awesome. 
	 * 
	 */
	public abstract int NumLumps();

	/**
	 * Returns actual lumpinfo_t object for a given name. Useful if you want to
	 * access something on a file, I guess?
	 * 
	 * @param name
	 * @return
	 */

	public abstract lumpinfo_t GetLumpinfoForName(String name);

	/**
	 * W_GetNumForName
	 * Calls W_CheckNumForName, but bombs out if not found.
	 */

	public abstract int GetNumForName(String name);

	/**
	 *          
	 * @param lumpnum
	 * @return
	 */
	public abstract String GetNameForNum(int lumpnum);

	//
	// W_LumpLength
	// Returns the buffer size needed to load the given lump.
	//
	public abstract int LumpLength(int lump);


    /**
     * W_CacheLumpNum Modified to read a lump as a specific type of
     * CacheableDoomObject. If the class is not identified or is null, then a
     * generic DoomBuffer object is left in the lump cache and returned.
     * @param <T>
     */
    public abstract <T> T CacheLumpNum(int lump, int tag,
            Class<T> what);

	// MAES 24/8/2011: superseded by auto-allocating version with proper 
	// container-based caching.

	@Deprecated
	public abstract void CacheLumpNumIntoArray(int lump, int tag,
			Object[] array, Class what) throws IOException;

	/**
	 * Return a cached lump based on its name, as raw bytes, no matter what.
	 * It's rare, but has its uses.
	 * 
	 * @param name
	 * @param tag
	 * @param what
	 * @return
	 */

	public abstract byte[] CacheLumpNameAsRawBytes(String name, int tag);

	/**
	 * Return a cached lump based on its num, as raw bytes, no matter what.
	 * It's rare, but has its uses.
	 * 
	 * @param name
	 * @param tag
	 * @param what
	 * @return
	 */

	public abstract byte[] CacheLumpNumAsRawBytes(int num, int tag);

	/** Get a DoomBuffer of the specified lump name
	 * 
	 * @param name
	 * @param tag
	 * @return
	 */
	
	public abstract DoomBuffer CacheLumpName(String name, int tag);

    /** Get a DoomBuffer of the specified lump num
     * 
     * @param lump
     * @return
     */

	public abstract DoomBuffer CacheLumpNumAsDoomBuffer(int lump);

	/**
	 * Specific method for loading cached patches by name, since it's by FAR the
	 * most common operation.
	 * 
	 * @param name
	 * @return
	 */

	public abstract patch_t CachePatchName(String name);

	/**
	 * Specific method for loading cached patches, since it's by FAR the most
	 * common operation.
	 * 
	 * @param name
	 * @param tag
	 * @return
	 */

	public abstract patch_t CachePatchName(String name, int tag);

	/**
	 * Specific method for loading cached patches by number.
	 * 
	 * @param num
	 * @return
	 */

	public abstract patch_t CachePatchNum(int num);

	public abstract <T extends CacheableDoomObject> T CacheLumpName(String name, int tag, Class<T> what);

	/** A lump with size 0 is a marker. This means that it
	 *  can/must be skipped, and if we want actual data we must
	 *  read the next one. 
	 * 
	 * @param lump
	 * @return
	 */
	public abstract boolean isLumpMarker(int lump);

	public abstract String GetNameForLump(int lump);

	public abstract int CheckNumForName(String name/* , int namespace */);
	
	/** Return ALL possible results for a given name, in order to resolve name clashes without
	 *  using namespaces
	 *  
	 * @param name
	 * @return
	 */
	
	public abstract int[] CheckNumsForName(String name);

	public abstract lumpinfo_t GetLumpInfo(int i);

	/** A way to cleanly close open file handles still pointed at by lumps.
	 *  Is also called upon finalize */
	public void CloseAllHandles();

	/** Null the disk lump associated with a particular object,
	 *  if any. This will NOT induce a garbage collection, unless
	 *  you also null any references you have to that object.
	 *  	  
	 * @param lump
	 */
	
	void UnlockLumpNum(int lump);

	void UnlockLumpNum(CacheableDoomObject lump);
	
	public <T extends CacheableDoomObject> T[] CacheLumpNumIntoArray(int lump, int num,
			Class<T> what);
	
	/** Verify whether a certain lump number is valid and has
	 *  the expected name.
	 *  
	 * @param lump
	 * @param lumpname
	 * @return
	 */

	boolean verifyLumpName(int lump, String lumpname);
	
	/** The index of a known loaded wadfile
	 * 
	 * @param wad1
	 * @return
	 */

    public abstract int GetWadfileIndex(wadfile_info_t wad1);

    /** The number of loaded wadfile
     * 
     * @return
     */
    public abstract int GetNumWadfiles();

    /** Force a lump (in memory) to be equal to a dictated content. Useful
     *  for when you are e.g. repairing palette lumps or doing other sanity
     *  checks.
     * 
     * @param lump
     * @param obj
     */
	void InjectLumpNum(int lump, CacheableDoomObject obj);

	/** Read a lump into a bunch of bytes straight. No caching, no frills.
	 * 
	 * @param lump
	 * @return
	 */
    byte[] ReadLump(int lump);

    /** Use your own buffer, of proper size of course.
     * 
     * @param lump
     * @param buf
     */
    void ReadLump(int lump, byte[] buf);
    
    /** Use your own buffer, of proper size AND offset.
     * 
     * @param lump
     * @param buf
     */

    void ReadLump(int lump, byte[] buf, int offset);
	
}
package w;

import java.io.DataInputStream;
import java.io.IOException;

/** This is for objects that can be read from disk, but cannot
 *  self-determine their own length for some reason.
 * 
 * @author Maes
 *
 */

public interface AidedReadableDoomObject {
    
    public void read(DataInputStream f, int len) throws IOException ;
}

package w;

import java.io.InputStream;

/*
typedef struct
{
  // WARNING: order of some fields important (see info.c).

  char  name[9];
  int   size;

    // killough 4/17/98: namespace tags, to prevent conflicts between resources
  enum {
    ns_global=0,
    ns_sprites,
    ns_flats,
    ns_colormaps,
    ns_prboom,
    ns_demos,
    ns_hires //e6y
  } li_namespace; // haleyjd 05/21/02: renamed from "namespace"

  wadfile_info_t *wadfile;
  int position;
  wad_source_t source;
  int flags; //e6y
} lumpinfo_t; */

public class lumpinfo_t implements Cloneable{
        public String    name;
        public InputStream     handle;
        public long     position;
        public long     size;
        // A 32-bit hash which should be enough for searching through hashtables.
        public int hash;
        // A 64-bit hash that just maps an 8-char string to a long num, good for hashing
        // or for direct comparisons.
        //public long stringhash;
        // Intepreting the first 32 bits of their name as an int. Used in initsprites.
        public int intname; 
        // public int next;
        //public int index;
        
        // For BOOM compatibility
        public li_namespace namespace;
        public wadfile_info_t wadfile;
        
        public int hashCode(){
            return hash;
        }
        
        public String toString(){
            return (name +" "+ Integer.toHexString(hash));
        }
        
        public lumpinfo_t clone(){
        	lumpinfo_t tmp=new lumpinfo_t();
        	tmp.name=name; // Well... a reference will do.
        	tmp.handle=handle;
        	tmp.position=position;
        	tmp.size=size;
        	tmp.hash=hash;
        	tmp.intname=intname;
        	tmp.namespace=namespace;
        	tmp.wadfile=wadfile;
        	
			return tmp;
        	
        }
        
    }

package w;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class wadheader_t implements IReadableDoomObject, IWritableDoomObject {
    public String type;
    public int numentries;
    public int tablepos;
    
    public boolean big_endian=false;
    
    public void read(DataInputStream f) throws IOException{

        type=DoomIO.readNullTerminatedString(f,4);
        
        if (!big_endian){
        numentries=(int) DoomIO.readUnsignedLEInt(f);
        tablepos=(int) DoomIO.readUnsignedLEInt(f);

        } else {
            numentries=f.readInt();
            tablepos=f.readInt();
        }
        
    }

    public static int sizeof(){
        return 16;
    }

    @Override
    public void write(DataOutputStream dos)
            throws IOException {
        DoomIO.writeString(dos, type, 4);
        
        if (!big_endian){
            DoomIO.writeLEInt(dos, (int) numentries);
            DoomIO.writeLEInt(dos, (int) tablepos);
        } else {
                dos.writeInt((int) numentries);
                dos.writeInt((int) tablepos);
        }
        
        
    }

}

package w;

import java.io.DataOutputStream;
import java.io.IOException;

public interface IWritableDoomObject {
    
    public void write(DataOutputStream dos) throws IOException ;
}

package w;

// CPhipps - defined enum in wider scope
// Ty 08/29/98 - add source field to identify where this lump came from

public enum wad_source_t {
   // CPhipps - define elements in order of 'how new/unusual'
   source_iwad,    // iwad file load 
   source_pre,       // predefined lump
   source_auto_load, // lump auto-loaded by config file
   source_pwad,      // pwad file load
   source_lmp,       // lmp file load
   source_net        // CPhipps
   //e6y
 //  ,source_deh_auto_load
   ,source_deh
   ,source_err

 }

package w;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/** A very simple WAD building utility class, just enough to lay some organized lumps on disk. Not particularly optimized 
 * 
 *  It works simply by adding IWritableDoomObjects, IPackableDoomObjects and raw byte[] data to a list. Then, when the time 
 *  to write everything to disk comes, a header, index table etc. are created as well.
 * 
 * */

public class WadBuilder {
	
	protected File file;
	protected wadheader_t header;
	protected List<IWritableDoomObject> lumps;
	protected DataOutputStream dos;
	protected FileOutputStream fos;
	protected int indexpos,totalsize;
	
	public WadBuilder(String file,String type) {
		this.header=new wadheader_t();
		this.lumps=new ArrayList<IWritableDoomObject>();
		this.header.type=type;
		this.file=new File(file);
		this.indexpos=0;
	}
	
	public void start() throws IOException {
		if (file.exists()) file.delete();
		fos=new FileOutputStream(file,false);
		dos=new DataOutputStream(fos);		
		// This header is only temporary, until we know how many lumps and data we've actually written.
		header.write(dos);
	}

	/** Add a zero-sized marker
	 * 
	 * @param lumpname
	 * @throws IOException
	 */
	public void add(String lumpname) throws IOException{		
		filelump_t lump=new filelump_t(lumpname,0,dos.size());
		lumps.add(lump);
		}
	
	/** Add and write immediately a raw byte[] bunch of data.
	 * 
	 * @param lumpname
	 * @param data
	 * @throws IOException
	 */
	
	public void add(String lumpname, byte[] data) throws IOException{		
		filelump_t lump=new filelump_t(lumpname,data.length,dos.size());
		lumps.add(lump);
		dos.write(data);
		}
	
	/** Add and write immediately an object implementing the IWritableDoomObject interface.
	 * 
	 * @param lumpname
	 * @param stuff
	 * @throws IOException
	 */
	public void add(String lumpname, IWritableDoomObject stuff) throws IOException{		
		
		long pos=dos.size(); // Save current stream position
		stuff.write(dos);
		
		// The new lump can be created ONLY after the write
		filelump_t lump=new filelump_t(lumpname,dos.size()-pos,pos);
		lumps.add(lump);
		
		}
	
	/** Add and write immediately an array of objects implementing the IWritableDoomObject interface.
	 *  Objects will be written contiguously.
	 * 
	 * @param lumpname
	 * @param stuff
	 * @throws IOException
	 */
	
	public void add(String lumpname, IWritableDoomObject stuff[]) throws IOException{		
		
		long pos=dos.size(); // Save current stream position
		
		DoomIO.writeListOfObjects(dos, stuff,stuff.length);
		
		// The new lump can be created ONLY after the write
		filelump_t lump=new filelump_t(lumpname,dos.size()-pos,pos);
		lumps.add(lump);		
		}
	
	/** When called, the WAD index will be written to the file, the header will be
	 *  updated for the total number of entries and index position, and the file closed.
	 * 
	 * @throws IOException
	 */
	
	public void close() throws IOException{
		
		this.indexpos=dos.size();
		// Time to write the index
		DoomIO.writeListOfObjects(dos, this.lumps, this.lumps.size());
		this.totalsize=dos.size();
		
		// Amend header
		this.header.numentries=lumps.size();
		this.header.tablepos=this.indexpos;
		
		// Write amended header
		fos.getChannel().position(0);
		header.write(dos);
		
		// Close streams
		dos.close();
		fos.close();
		}
	
	/** Directly copy a bunch of lumps from an IWadLoader object to this WAD file.
	 * 
	 * @param W
	 * @param lumplist
	 * @throws IOException
	 */
	
    public void add(IWadLoader W,String[] lumplist) throws IOException{
    	byte[] data;
    	
    	for (String lumpname: lumplist){
    		data=W.CacheLumpNameAsRawBytes(lumpname, 0);
    		this.add(lumpname,data);
    	}
    }
	
}

package w;

public class name8 {
    private byte[]  s;
    static byte[] ss=new byte[9];
    public int[]    x;
    public long hash;
    
    public name8(String name){
        s=new byte[9];
        x=new int[2];
        // in case the name was a full 8 chars
        this.s[8] = 0;
        
        byte[] tmp=name.getBytes();
        System.arraycopy(tmp, 0, this.s, 0, Math.min(8,tmp.length));
        this.x[0]=byteArrayToInt(s,0);
        this.x[1]=byteArrayToInt(s,4);
        this.hash=byteArrayToLong(s,0);
    }
    
    /** Returns a 64-bit number that maps directly to the ASCII
     *  8-bit representation of a fixed-length 8 char string.
     *  It's for all effects and purposes a unique 64-bit hash, and can be used to
     *  speed up comparisons.
     *  
     * @param name
     * @return
     */
    
    public static long getLongHash(String name){
        // in case the name was a full 8 chars
        for (int i=0;i<ss.length;i++){
            ss[i]=0;
        }
        
        byte[] tmp=name.getBytes();
        // We must effectively limit hashes to 31 bits to be able to use them.
        System.arraycopy(tmp, 0, ss, 0, Math.min(8,tmp.length));
        return byteArrayToLong(ss,0);
    }
    
    public static int getIntName(String name){
        // in case the name was a full 8 chars
        for (int i=0;i<ss.length;i++){
            ss[i]=0;
        }
        
        byte[] tmp=name.getBytes();
        System.arraycopy(tmp, 0, ss, 0, Math.min(4,tmp.length));
        return byteArrayToInt(ss,0);
    }
    
    public static int byteArrayToInt(byte[] src, int ofs){
        return (src[ofs]<<24)|(src[ofs+1]<<16)|(src[ofs+2]<<8)|src[ofs+3];
    }
    
    public static long byteArrayToLong(byte[] src, int ofs){
        return (((long)byteArrayToInt(src, 0)<<32)|byteArrayToInt(src, 4));
    }
    
    
    /** Probably has horrible performance...
     * 
     * @param src
     * @param ofs
     * @return
     */
    
    public static int stringToInt(String src, int ofs){
         byte[]  s=new byte[9];
         for (int i=0;i<src.length();i++){
             s[i]=(byte) src.charAt(i);
         }
        
            return (s[ofs]<<24)|(s[ofs+1]<<16)|(s[ofs+2]<<8)|s[ofs+3];
    }
        
    }

package w;

public interface IReadWriteDoomObject extends IReadableDoomObject, IWritableDoomObject{

}

package w;

import java.io.IOException;
import java.nio.ByteBuffer;

/** All objects that can be deserialized from raw byte buffers such as those
 *  read from WAD lumps should implement this method, so that the WadLoader 
 *  can cache them, and recursive calls to  sub-objects can be made.
 *  
 *  E.g. an object of type A consists of a header and a list of objects of type B.
 *  Calling A.unpack(buf) will cause A to unmarshal its own header, set the list of 
 *  B objects, and then call B.unpack() for each of them, by passing the same buffer
 *  along.
 *  
 *  This system works cleanly, and allows to simulate Doom's "cached memory" while
 *  returning proper objects of the correct type and keeping close to Java's
 *  "correct" way of doing things. 
 *   *  
 *  For example, if a patch_t is read from disk, the WadLoader uses its unpack() method
 *  to read it from a lump read from disk, and creates a new patch_t object, which is placed
 *  in the lump cache (which holds CacheableDoomObject, incidentally). The next time this
 *  same patch_t is requested, the reference to the already cached patch_t will be returned,
 *  if it hasn't been forcedly flushed from the cache. Voila', lump caching!
 *  
 *  The principle can be applied to ARRAYS of similar objects too: using the same buffer,
 *  iterative serial unpacking is possible, while still mantaining a "cached" reference
 *  to their array (TODO: actually, this needs to be implemented more efficiently. Look in
 *  WadLoader) 
 *  
 *  The opposite would be a "PackableDoomObject", aka objects that can pack themselves into
 *  a byte buffer for transmission purposes, although Doom doesn't really need to write as
 *  much as it needs reading.
 *  
 *  For the purpose of saving/loading games, which need to read/write to variable disk 
 *  structures ALL the time, use the ReadableDoomObject/WritableDoomObject interfaces.
 *  Their difference is that they are highly mutable and supposed to be read from files 
 *  or input/output streams, and that a continuous reference to them as deserialized 
 *  objects (e.g. in the caching mechanism) is not needed.
 *    
 * 
 * @author Velktron
 *
 */

public interface CacheableDoomObject {
    
    public void unpack(ByteBuffer buf) throws IOException ;
}

package w;

public enum statenum_t {

        NoState(-1),
        StatCount(0),
        ShowNextLoc(1);
        
        private int value;
        
        private statenum_t(int val){
            this.value=val;
        }

        public int getValue() {
            return value;
        }
        
    
}

package w;

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

//Created on 24.07.2004 by RST.

//$Id: DoomIO.java,v 1.4 2016/06/06 13:45:44 velktron Exp $

import java.io.*;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.List;

import m.Swap;

/**
* An extension of RandomAccessFile, which handles readString/WriteString specially 
* and offers several Doom related (and cross-OS) helper functions for reading/writing
* arrays of multiple objects or fixed-length strings from/to disk.
* 
* TO DEVELOPERS: this is the preferrered method of I/O for anything implemented.
* In addition, Doomfiles can be passed to objects implementing the IReadableDoomObject 
* and IWritableDoomObject interfaces, which will "autoread" or "autowrite" themselves
* to the implied stream.
* 
* TODO: in the light of greater future portabililty and compatibility in certain
* environments, PERHAPS this should have been implemented using Streams. Perhaps
* it's possible to change the underlying implementation without (?) changing too
* much of the exposed interface, but it's not a priority for me right now. 
* 
*/
public class DoomIO  {

	private DoomIO(){
		
	}

   /** Writes a Vector to a RandomAccessFile. */
   public static void writeVector(DataOutputStream dos,float v[]) throws IOException {
       for (int n = 0; n < 3; n++)
           dos.writeFloat(v[n]);
   }

   /** Writes a Vector to a RandomAccessFile. */
   public static float[] readVector(DataInputStream dis) throws IOException {
       float res[] = { 0, 0, 0 };
       for (int n = 0; n < 3; n++)
           res[n] = dis.readFloat();

       return res;
   }

   /** Reads a length specified string from a file. */
   public static final String readString(DataInputStream dis) throws IOException {
       int len = dis.readInt();

       if (len == -1)
           return null;

       if (len == 0)
           return "";

       byte bb[] = new byte[len];

       dis.read(bb, 0, len);

       return new String(bb, 0, len,Charset.forName("ISO-8859-1"));
   }

/** MAES: Reads a specified number of bytes from a file into a new String.
 *  With many lengths being implicit, we need to actually take the loader by the hand.
 *  
 * @param len
 * @return
 * @throws IOException
 */
   
   public final static String readString(DataInputStream dis,int len) throws IOException {

       if (len == -1)
           return null;

       if (len == 0)
           return "";

       byte bb[] = new byte[len];

       dis.read(bb, 0, len);

       return new String(bb, 0, len);
   }
   
   public static String readString(InputStream f,int len) throws IOException {

       if (len == -1)
           return null;

       if (len == 0)
           return "";

       byte bb[] = new byte[len];

       f.read(bb, 0, len);

       return new String(bb, 0, len,Charset.forName("ISO-8859-1"));
   }
   
   /** MAES: Reads a specified number of bytes from a file into a new, NULL TERMINATED String.
    *  With many lengths being implicit, we need to actually take the loader by the hand.
    *  
    * @param len
    * @return
    * @throws IOException
    */
   
      public static final String readNullTerminatedString(InputStream dis,int len) throws IOException {

          if (len == -1)
              return null;

          if (len == 0)
              return "";

          byte bb[] = new byte[len];
          int terminator=len;

          dis.read(bb, 0, len);
          
          for (int i=0;i<bb.length;i++){
              if (bb[i]==0) {
                  terminator=i;
                  break; // stop on first null
              }
              
          }
          
          // This is the One True Encoding for Doom.
          return new String(bb, 0, terminator,Charset.forName("ISO-8859-1"));
      }
   
   /** MAES: Reads multiple strings with a specified number of bytes from a file.
    * If the array is not large enough, only partial reads will occur.
    *  
    * @param len
    * @return
    * @throws IOException
    */
      
      public static final String[] readMultipleFixedLengthStrings(DataInputStream dis,String[] dest, int num, int len) throws IOException {

    	  // Some sanity checks...
          if (num<=0 || len < 0)
              return null;

          if (len == 0) {
        	  for (int i=0;i<dest.length;i++){
        		  dest[i]=new String("");
        	  }
        	  return dest;
          }        	  
          
          for (int i=0;i<num;i++){
        	  dest[i]=readString(dis,len);
          }
          return dest;
      }

   
   /** Writes a length specified string (Pascal style) to a file. 
    * 
    * */
   public static void writeString(DataOutputStream dos,String s) {
       try {
       if (s == null) {
           dos.writeInt(-1);
           return;
       }

       dos.writeInt(s.length());
       if (s.length() != 0)
           dos.writeBytes(s);
       } catch (Exception e){
           System.err.println("writeString "+s+" to DoomFile failed!");
       }
   }

   /** Writes a String with a specified len to a file.
    *  This is useful for fixed-size String fields in 
    *  files. Any leftover space will be filled with 0x00s. 
    * 
    * @param s
    * @param len
    * @throws IOException
    */
    
   public static void writeString(DataOutputStream dos,String s,int len) throws IOException {

       if (s==null) return;
       
       if (s.length() != 0){
           byte[] dest=s.getBytes("ISO-8859-1");
           dos.write(dest,0,Math.min(len,dest.length));
           // Fill in with 0s if something's left.
           if (dest.length<len){
               for (int i=0;i<len-dest.length;i++){
                   dos.write((byte)0x00);
               }
           }
       }
   }

   public static void readObjectArray(DataInputStream dis,IReadableDoomObject[] s,int len) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){           
           s[i].read(dis);
       }
   }

   public static void readObjectArrayWithReflection(DataInputStream dis,IReadableDoomObject[] s,int len) throws Exception {

       if (len==0) return;
       Class<?> c=s.getClass().getComponentType();
       
       for (int i=0;i<Math.min(len,s.length);i++){
           if (s[i]==null) s[i]=(IReadableDoomObject) c.newInstance();
           s[i].read(dis);
       }
   }
   
   public static void readObjectArray(DataInputStream dis,IReadableDoomObject[] s,int len, Class<?> c) throws Exception {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){
           if (s[i]==null) {
               s[i]=(IReadableDoomObject) c.newInstance();
           }
           s[i].read(dis);
       }
   }
   
   public static final void readIntArray(DataInputStream dis,int[] s,int len, ByteOrder bo) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){           
           s[i]=dis.readInt();
           if (bo==ByteOrder.LITTLE_ENDIAN){
               s[i]=Swap.LONG(s[i]);
           }
       }
   }
   
   public static final void readShortArray(DataInputStream dis,short[] s,int len, ByteOrder bo) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){           
           s[i]=dis.readShort();
           if (bo==ByteOrder.LITTLE_ENDIAN){
               s[i]=Swap.SHORT(s[i]);
           }
       }
   }
   
   public static final void readIntArray(DataInputStream dis,int[] s,ByteOrder bo) throws IOException {
       readIntArray(dis,s,s.length,bo);
   }
   
   public static final void readShortArray(DataInputStream dis,short[] s,ByteOrder bo) throws IOException {
       readShortArray(dis,s,s.length,bo);
   }
   
   public static void readBooleanArray(DataInputStream dis,boolean[] s,int len) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){
           s[i]=dis.readBoolean();
           }
   }
   
   
   
   /** Reads an array of "int booleans" into an array or
    * proper booleans. 4 bytes per boolean are used!
    * 
    * @param s
    * @param len
    * @throws IOException
    */
   
   public final static void readBooleanIntArray(DataInputStream dis,boolean[] s,int len) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){
           s[i]=readIntBoolean(dis);
           }
   }
   
   public static final void readBooleanIntArray(DataInputStream dis,boolean[] s) throws IOException {
       readBooleanIntArray(dis,s,s.length);
   }
   
   public static final void writeBoolean(DataOutputStream dos,boolean[] s,int len) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){
           dos.writeBoolean(s[i]);
           }
   }
   
   public static final void writeObjectArray(DataOutputStream dos,IWritableDoomObject[] s,int len) throws IOException {

       if ((s==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){           
           s[i].write(dos);
       }
   }
   
   public static final void writeListOfObjects(DataOutputStream dos,List<IWritableDoomObject> s,int len) throws IOException {

       if ((s==null)||(len<=0)) return;
       
       for (int i=0;i<Math.min(len,s.size());i++){           
           s.get(i).write(dos);
       }
   }
   
   public static final void writeListOfObjects(DataOutputStream dos,IWritableDoomObject s[],int len) throws IOException {

       if ((s==null)||(len<=0)) return;
       
       for (int i=0;i<Math.min(len,s.length);i++){           
           s[i].write(dos);
       }
   }
   
   public final static void readBooleanArray(DataInputStream dis,boolean[] s) throws IOException {
       readBooleanArray(dis,s,s.length);
       }
   
   public final static void readIntBooleanArray(DataInputStream dis,boolean[] s) throws IOException {
       readBooleanIntArray(dis,s,s.length);
       }
  
   public static final void writeCharArray(DataOutputStream dos,char[] charr,int len) throws IOException {

       if ((charr==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,charr.length);i++){           
           dos.writeChar(charr[i]);
       }
   }
   
   /** Will read an array of proper Unicode chars.
    * 
    * @param charr
    * @param len
    * @throws IOException
    */
   
   public static final void readCharArray(DataInputStream dis,char[] charr,int len) throws IOException {

       if ((charr==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,charr.length);i++){           
           charr[i]=dis.readChar();
       }
   }
   
   /** Will read a bunch of non-unicode chars into a char array.
    *  Useful when dealing with legacy text files.
    * 
    * @param charr
    * @param len
    * @throws IOException
    */
   
   public static final void readNonUnicodeCharArray(DataInputStream dis,char[] charr,int len) throws IOException {

       if ((charr==null)||(len==0)) return;
       
       for (int i=0;i<Math.min(len,charr.length);i++){           
           charr[i]=(char) dis.readUnsignedByte();
       }
   }
   
   /** Writes an item reference. 
   public void writeItem(gitem_t item) throws IOException {
       if (item == null)
           writeInt(-1);
       else
           writeInt(item.index);
   }
*/
   /** Reads the item index and returns the game item. 
   public gitem_t readItem() throws IOException {
       int ndx = readInt();
       if (ndx == -1)
           return null;
       else
           return GameItemList.itemlist[ndx];
   }
 * @throws IOException 
*/
   
   public static final long readUnsignedLEInt(DataInputStream dis) throws IOException{
       int tmp=dis.readInt();
       return 0xFFFFFFFFL&Swap.LONG(tmp);
   }
   
   public static final int readLEInt(DataInputStream dis) throws IOException{
       int tmp=dis.readInt();
       return Swap.LONG(tmp);
   }
   
   public static final int readLEInt(InputStream dis) throws IOException{	   
       int tmp=new DataInputStream(dis).readInt();
       return Swap.LONG(tmp);
   }
   
   public static final void writeLEInt(DataOutputStream dos,int value) throws IOException{       
	   dos.writeInt(Swap.LONG(value));
   }
   
// 2-byte number
   public static int SHORT_little_endian_TO_big_endian(int i)
   {
       return ((i>>8)&0xff)+((i << 8)&0xff00);
   }

   // 4-byte number
   public static int INT_little_endian_TO_big_endian(int i)
   {
       return((i&0xff)<<24)+((i&0xff00)<<8)+((i&0xff0000)>>8)+((i>>24)&0xff);
   }

public static final short readLEShort(DataInputStream dis) throws IOException {
    short tmp=dis.readShort();
    return Swap.SHORT(tmp);
}

/** Reads a "big boolean" using 4 bytes.
 * 
 * @return
 * @throws IOException
 */
public static final boolean readIntBoolean(DataInputStream dis) throws IOException {
    return (dis.readInt()!=0);

}

   
}

package w;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class wadinfo_t implements IReadableDoomObject,IWritableDoomObject{
        // Should be "IWAD" or "PWAD".
        String       identification;      
        long         numlumps;
        long         infotableofs;
             
        /** Reads the wadinfo_t from the file.*/
        public void read(DataInputStream f) throws IOException {
            identification = DoomIO.readString(f,4);
            numlumps=DoomIO.readUnsignedLEInt(f);
            infotableofs=DoomIO.readUnsignedLEInt(f);
        }

		@Override
		public void write(DataOutputStream dos) throws IOException {
			DoomIO.writeString(dos, identification, 4);
			DoomIO.writeLEInt(dos, (int)numlumps);
			DoomIO.writeLEInt(dos, (int)infotableofs);
		}
        
    }
package w;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

/** filelumps are on-disk structures. lumpinfos are almost the same, but are memory only.
 * 
 * @author Maes
 *
 */

public class filelump_t  implements IReadableDoomObject, IWritableDoomObject {
    public long         filepos;
    public long         size; // Is INT 32-bit in file!
    public String        name; // Whatever appears inside the wadfile
    public String actualname; // Sanitized name, e.g. after compression markers
        
    public boolean big_endian=false; // E.g. Jaguar
    public boolean compressed=false; // Compressed lump
    
    public filelump_t(String name, long size, long filepos) {
    	this.filepos=filepos;
    	this.size=size;
    	this.name=name;
		
	}

	public filelump_t() {
	}

	public void read(DataInputStream f) throws IOException{
        // MAES: Byte Buffers actually make it convenient changing byte order on-the-fly.
        // But RandomAccessFiles (and inputsteams) don't :-S

        if (!big_endian){
        filepos=DoomIO.readUnsignedLEInt(f);
        size=DoomIO.readUnsignedLEInt(f);

        } else {
            filepos=f.readInt();
            size=f.readInt();

        }
        
        // Names used in the reading subsystem should be upper case,
        // but check for compressed status first
        name=DoomIO.readNullTerminatedString(f,8);
        
       
        char[] stuff= name.toCharArray();
        
        // It's a compressed lump
        if (stuff[0] > 0x7F) {
            this.compressed=true;
            stuff[0]&=0x7F; 
        }
        
        actualname=new String(stuff).toUpperCase();
        
        
    }

    public static int sizeof(){
        return (4+4+8);
    }

    @Override
    public void write(DataOutputStream dos)
            throws IOException {
        if (!big_endian){
            DoomIO.writeLEInt(dos, (int) filepos);
            DoomIO.writeLEInt(dos, (int) size);
        } else {
                dos.writeInt((int) filepos);
                dos.writeInt((int) size);
        }
        DoomIO.writeString(dos, name, 8);
        
    }
    
}
// Emacs style mode select -*- C++ -*-
// -----------------------------------------------------------------------------
//
// $Id: WadLoader.java,v 1.66 2016/07/04 13:50:50 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//
//
// DESCRIPTION:
// Handles WAD file header, directory, lump I/O.
//
// -----------------------------------------------------------------------------

package w;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import rr.patch_t;
import utils.C2JUtils;
import static data.Defines.*;
import i.*;

public class WadLoader implements IWadLoader {
	
	//// FIELDS
	
	/** DoomSystem object */
	protected IDoomSystem I;

	/** Location of each lump on disk. */
	public lumpinfo_t[] lumpinfo;

	public int numlumps;

	/**
	 * MAES: probably array of byte[]??? void** lumpcache;
	 * 
	 * Actually, loaded objects will be deserialized here as the general type
	 * "CacheableDoomObject" (in the worst case they will be byte[] or
	 * ByteBuffer).
	 * 
	 * Not to brag, but this system is FAR superior to the inline unmarshaling
	 * used in other projects ;-)
	 */

	private CacheableDoomObject[] lumpcache;

	private boolean[] preloaded;

	/** Added for Boom compliance */
	private List<wadfile_info_t> wadfiles;
	
	/**
	 * #define strcmpi strcasecmp MAES: this is just capitalization. However we
	 * can't manipulate String object in Java directly like this, so this must
	 * be a return type.
	 * 
	 * TODO: maybe move this in utils?
	 */

	public String strupr(String s) {
		return s.toUpperCase();
	}

	/* ditto */
	public void strupr(char[] s) {
		for (int i = 0; i < s.length; i++) {
			s[i] = Character.toUpperCase(s[i]);
		}
	}


	int reloadlump;
	
	/** Offset inside an input stream to allow us to read lumps as "wad archives" or "WADs withing WADs". The catch is that
	 * each such lump will have to be handled with its own reader.
	 * 
	 */
	int wadarchive_offset;
	
	/** Standard constructor
	 * 
	 * @param I
	 */
	
	   public WadLoader(IDoomSystem I) {
	        this();
	        this.I = I;
	    }

	   
	   /** A default constructor with a built-in dummy system */
	   
	    public WadLoader() {
	        lumpinfo = new lumpinfo_t[0];
	        zone= new Hashtable<CacheableDoomObject, Integer>();
	        wadfiles=new ArrayList<wadfile_info_t>();
	        this.I=new DummySystem();
	    }
	

	    /** A simplified constructor for opening a single local file without coalescing
	     * 
	     * @param wadfile
	     */
		   
	    public WadLoader(String wadfile) {
	    	this();
	    	try {
				this.InitFile(wadfile,false);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

	    }
	    
	
	// MAES: was char*
	String reloadname;
    /**
     * W_AddFile:
     * 
     * This is where lumps are actually read + loaded from a file.
     * 
     * All files are optional, but at least one file must be
     * found (PWAD, if all required lumps are present).
     * Files with a .wad extension are wadlink files
     * with multiple lumps.
     * Other files are single lumps with the base filename
     * for the lump name.
     * 
     * If filename starts with a tilde, the file is handled
     * specially to allow map reloads.
     * But: the reload feature is a fragile hack...
     * 
     * @param uri
     * @param entry
     * @throws type
     */

	private void AddFile(String uri,ZipEntry entry,int type) throws Exception {
		wadinfo_t header = new wadinfo_t();
		int lump_p; // MAES: was lumpinfo_t* , but we can use it as an array
		// pointer.
		InputStream handle,storehandle;
		long length;
		int startlump;
		
		filelump_t[] fileinfo = new filelump_t[1]; // MAES: was *
		filelump_t singleinfo = new filelump_t();

		// handle reload indicator.
		if (uri.charAt(0) == '~') {
		    uri = uri.substring(1);
			reloadname = uri;
			reloadlump = numlumps;
		}

        // open the resource and add to directory
		// It can be any streamed type handled by the "sugar" utilities.
		
		try {
			handle = InputStreamSugar.createInputStreamFromURI(uri,entry,type);
		} catch (Exception e) {
			I.Error(" couldn't open resource %s \n", uri);
			return;
		}
		
        // Create and set wadfile info
        wadfile_info_t wadinfo=new wadfile_info_t();
        wadinfo.handle= handle;
        wadinfo.name=uri;
        wadinfo.entry=entry;
        wadinfo.type=type;
        
		// System.out.println(" adding " + filename + "\n");

		// We start at the number of lumps. This allows appending stuff.
		startlump = this.numlumps;
		
		String checkname=(wadinfo.entry!=null?wadinfo.entry.getName():uri);
		// If not "WAD" then we check for single lumps.
		if (!C2JUtils.checkForExtension(checkname,"wad")) {
		    
		    fileinfo[0] = singleinfo;
			singleinfo.filepos = 0;
			singleinfo.size = InputStreamSugar.getSizeEstimate(handle,wadinfo.entry);
			
			// Single lumps. Only use 8 characters			
			singleinfo.actualname=singleinfo.name = C2JUtils.removeExtension(uri).toUpperCase();
			
			// MAES: check out certain known types of extension
			if (C2JUtils.checkForExtension(uri,"lmp"))			
			    wadinfo.src=wad_source_t.source_lmp;
			else
            if (C2JUtils.checkForExtension(uri,"deh"))         
                wadinfo.src=wad_source_t.source_deh;
            else        
            if (C2JUtils.checkForExtension(uri,null))         
                    wadinfo.src=wad_source_t.source_deh;
                
			numlumps++;			
			
		} else {
			// MAES: 14/06/10 this is historical, for this is the first time I
			// implement reading something from RAF into Doom's structs. 
		    // Kudos to the JAKE2 team who solved  this problem before me.
		    // MAES: 25/10/11: In retrospect, this solution, while functional, was
		    // inelegant and limited.
		    
		    DataInputStream dis=new DataInputStream(handle);
		    
		    // Read header in one go. Usually doesn't cause trouble?
			header.read(dis);			
			
			if (header.identification.compareTo("IWAD") != 0) {
				// Homebrew levels?
				if (header.identification.compareTo("PWAD") != 0) {
					I.Error("Wad file %s doesn't have IWAD or PWAD id\n",checkname);
				} else wadinfo.src=wad_source_t.source_pwad;

				// modifiedgame = true;
			} else wadinfo.src=wad_source_t.source_iwad;

			length = header.numlumps;
			// Init everything:
			fileinfo = C2JUtils.createArrayOfObjects(filelump_t.class,(int)length);
			
			dis.close();
			
			handle=InputStreamSugar.streamSeek(handle,header.infotableofs,wadinfo.maxsize,uri,entry,type);
			
			// FIX: sometimes reading from zip files doesn't work well, so we pre-cache the TOC
			byte[] TOC=new byte[(int) (length*filelump_t.sizeof())];
			
			int read=0;
			while (read<TOC.length){ 
			 // Make sure we have all of the TOC, sometimes ZipInputStream "misses" bytes.
			 // when wrapped.
			    read+=handle.read(TOC,read,TOC.length-read);
			    }
			
			ByteArrayInputStream bais=new ByteArrayInputStream(TOC);
			
			// MAES: we can't read raw structs here, and even less BLOCKS of
			// structs.

			dis=new DataInputStream(bais);
			DoomIO.readObjectArray(dis,fileinfo, (int) length);

			numlumps += header.numlumps;
			wadinfo.maxsize=estimateWadSize(header,lumpinfo);
			
		    } // end loading wad
		
		    //  At this point, a WADFILE or LUMPFILE been successfully loaded, 
		    // and so is added to the list
		    this.wadfiles.add(wadinfo);
		    
			// Fill in lumpinfo
			// MAES: this was a realloc(lumpinfo, numlumps*sizeof(lumpinfo_t)),
			// so we have to increase size and copy over. Maybe this should be
			// an ArrayList?

			int oldsize = lumpinfo.length;
			lumpinfo_t[] newlumpinfo = new lumpinfo_t[numlumps];

			try {
				C2JUtils.initArrayOfObjects(newlumpinfo, lumpinfo_t.class);
				System.arraycopy(lumpinfo, 0, newlumpinfo, 0, oldsize);
			} catch (Exception e) {
				// if (!lumpinfo)
				I.Error("Couldn't realloc lumpinfo");
			}

			// Bye bye, old lumpinfo!
			lumpinfo = newlumpinfo;

			// MAES: lump_p was an alias for lumpinfo[startlump]. I know it's a
			// bit crude as an approximation but heh...

			lump_p = startlump;

			// MAES: if reloadname is null, handle is stored...else an invalid
			// handle?
			storehandle = (reloadname != null) ? null : handle;

			// This iterates through single files.
			int fileinfo_p = 0;

			
			for (int i = startlump; i < numlumps; i++, lump_p++, fileinfo_p++) {
				lumpinfo[lump_p].handle = storehandle;
				lumpinfo[lump_p].position = fileinfo[fileinfo_p].filepos;
				lumpinfo[lump_p].size = fileinfo[fileinfo_p].size;
				// Make all lump names uppercase. Searches should also be uppercase only.
				lumpinfo[lump_p].name = fileinfo[fileinfo_p].name.toUpperCase();
				lumpinfo[lump_p].hash =lumpinfo[lump_p].name.hashCode();
				// lumpinfo[lump_p].stringhash = name8.getLongHash(strupr(lumpinfo[lump_p].name));
				// LumpNameHash(lumpinfo[lump_p].name);
				lumpinfo[lump_p].intname = name8.getIntName(strupr(lumpinfo[lump_p].name));
				//System.out.println(lumpinfo[lump_p]);
				lumpinfo[lump_p].wadfile=wadinfo; // MAES: Add Boom provenience info
			}
			
			
			
			if (reloadname != null)
				handle.close();
	}

	/** Try to guess a realistic wad size limit based only on the number of lumps and their
	 *  STATED contents, in case it's not possible to get an accurate stream size otherwise.
	 *  Of course, they may be way off with deliberately malformed files etc.
	 *  
	 * @param header
	 * @param lumpinfo2
	 * @return
	 */
	
	private long estimateWadSize(wadinfo_t header, lumpinfo_t[] lumpinfo) {
	    
	    long maxsize=header.infotableofs+header.numlumps*16;
	    
	    for (int i=0;i<lumpinfo.length;i++){
	        if ((lumpinfo[i].position+lumpinfo[i].size) >maxsize){
	            maxsize=lumpinfo[i].position+lumpinfo[i].size;
	        }
	    }
	    
        return maxsize;
    }

    /* (non-Javadoc)
	 * @see w.IWadLoader#Reload()
	 */
	@SuppressWarnings("null")
	public void Reload() throws Exception {
		wadinfo_t header = new wadinfo_t();
		int lumpcount;
		int lump_p; // Maes: same as in W_WADload
		int i;
		DataInputStream handle = null;
		int length;
		filelump_t[] fileinfo;

		if (reloadname == null)
			return;

		try {
			handle = new DataInputStream(new BufferedInputStream(new FileInputStream(reloadname)));
		} catch (Exception e) {
			I.Error("W_Reload: couldn't open %s", reloadname);
		}

		header.read(handle);
		// Actual number of lumps in file...
		lumpcount = (int) header.numlumps;
		header.infotableofs = header.infotableofs;
		length = lumpcount;
		fileinfo = new filelump_t[length];
		
		handle.reset();
		handle.skip(header.infotableofs);

		// MAES: we can't read raw structs here, and even less BLOCKS of
		// structs.

		DoomIO.readObjectArrayWithReflection(handle,fileinfo, (int) length);

		/*
		 * for (int j=0;j<length;j++){ fileinfo[j].load (handle); }
		 */

		// numlumps += header.numlumps;
		// read (handle, fileinfo, length);

		// Fill in lumpinfo
		lump_p = reloadlump;
		int fileinfo_p = 0;
		for (i = reloadlump; i < reloadlump + lumpcount; i++, lump_p++, fileinfo_p++) {
			if (lumpcache[i] != null) {
				// That's like "freeing" it, right?
				lumpcache[i] = null;
				preloaded[i] = false;
			}

			lumpinfo[lump_p].position = fileinfo[fileinfo_p].filepos;
			lumpinfo[lump_p].size = fileinfo[fileinfo_p].size;
		}

	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#InitMultipleFiles(java.lang.String[])
	 */
	
	public void InitMultipleFiles(String[] filenames,boolean coalesce) throws Exception {
		int size;

		// open all the files, load headers, and count lumps
		numlumps = 0;

		// will be realloced as lumps are added
		lumpinfo = new lumpinfo_t[0];

		for (String s : filenames) {
			if (s != null){
				if (C2JUtils.testReadAccess(s))
				{
				    // Resource is readable, guess type.
				    int type=C2JUtils.guessResourceType(s);
				    if (C2JUtils.flags(type,InputStreamSugar.ZIP_FILE)){
				        addZipFile(s, type);
				    } else {
				    	this.AddFile(s,null, type);			        
				    }
				    
				    System.out.printf("\tadded %s (zipped: %s network: %s)\n",s,
				        C2JUtils.flags(type, InputStreamSugar.ZIP_FILE),
				        C2JUtils.flags(type, InputStreamSugar.NETWORK_FILE));
				    
				}
				else
					System.err.printf("Couldn't open resource %s\n",s);
			}
		}

		if (numlumps == 0)
			I.Error("W_InitFiles: no files found");

		if (coalesce) {
			CoalesceMarkedResource("S_START", "S_END", li_namespace.ns_sprites);
			CoalesceMarkedResource("F_START", "F_END", li_namespace.ns_flats);
			// 	CoalesceMarkedResource("P_START", "P_END", li_namespace.ns_flats);
		}
		
		// set up caching
		size = numlumps;
		lumpcache = new CacheableDoomObject[size];
		preloaded = new boolean[size];

		if (lumpcache == null)
			I.Error("Couldn't allocate lumpcache");

		this.InitLumpHash();
	}

    /**
     * @param s
     * @param type
     * @throws IOException
     * @throws Exception
     */
    protected void addZipFile(String s, int type)
            throws IOException, Exception {
        // Get entries				        
        BufferedInputStream is=new BufferedInputStream(
            InputStreamSugar.createInputStreamFromURI(s, null, type)
            );
        ZipInputStream zip=new ZipInputStream(is);
        List<ZipEntry> zes=InputStreamSugar.getAllEntries(zip);
        zip.close();
        for (ZipEntry zz:zes){
            // The name of a zip file will be used as an identifier
            if (!zz.isDirectory())
            this.AddFile(s,zz, type);
        }
    }

	public void InitFile(String filename,boolean coalesce) throws Exception {
		String[] names = new String[1];

		names[0] = filename;
		// names[1] = null;
		InitMultipleFiles(names,coalesce);
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#NumLumps()
	 */
	public final int NumLumps() {
		return numlumps;
	}

	/**
	 * W_CheckNumForName2 Returns -1 if name not found.
	 * 
	 * A slightly better implementation, uses string hashes
	 * as direct comparators (though 64-bit long descriptors
	 * could be used). It's faster than the old method, but
	 * still short from the Hashtable's performance by 
	 * an order of magnitude. 
	 * 
     * @param name
     * @return
	 *
	 * UNUSED

	    public int CheckNumForName2(String name) {

		// scan backwards so patch lump files take precedence
		int lump_p = numlumps;

		// make the name into two integers for easy compares
		// case insensitive

		long hash = name8.getLongHash(name);
		// System.out.print("Looking for "+name + " with hash "
		// +Long.toHexString(hash));
		while (lump_p-- != 0)
			if (lumpinfo[lump_p].stringhash == hash) {
				// System.out.print(" found "+lumpinfo[lump_p]+"\n" );
				return lump_p;
			}

		// TFB. Not found.
		return -1;
	} */

	/**
	 * Old, shitty method for CheckNumForName. It's an overly literal
	 * translation of how the C original worked, which was none too good 
	 * even without the overhead of converting a string to
	 * its integer representation. It's so bad, that it's two orders
	 * of magnitude slower than a Hashtable implemetation, and one from
	 * a direct hash/longname comparison with linear search.
	 * 
	 * @param name
	 * @return
	 *

	public int CheckNumForName3(String name) {

		int v1;
		int v2;
		// lumpinfo_t lump_p;

		int lump_p;
		// make the name into two integers for easy compares
		// case insensitive
		name8 union = new name8(strupr(name));

		v1 = union.x[0];
		v2 = union.x[1];

		// scan backwards so patch lump files take precedence
		lump_p = numlumps;

		while (lump_p-- != 0) {
			int a = name8.stringToInt(lumpinfo[lump_p].name, 0);
			int b = name8.stringToInt(lumpinfo[lump_p].name, 4);
			if ((a == v1) && (b == v2)) {
				return lump_p;
			}
		}

		// TFB. Not found.
		return -1;
	} */

	/* (non-Javadoc)
	 * @see w.IWadLoader#GetLumpinfoForName(java.lang.String)
	 */

	public lumpinfo_t GetLumpinfoForName(String name) {

		int v1;
		int v2;
		// lumpinfo_t lump_p;

		int lump_p;
		// make the name into two integers for easy compares
		// case insensitive
		name8 union = new name8(strupr(name));

		v1 = union.x[0];
		v2 = union.x[1];

		// scan backwards so patch lump files take precedence
		lump_p = numlumps;

		while (lump_p-- != 0) {
			int a = name8.stringToInt(lumpinfo[lump_p].name, 0);
			int b = name8.stringToInt(lumpinfo[lump_p].name, 4);
			if ((a == v1) && (b == v2)) {
				return lumpinfo[lump_p];
			}
		}

		// TFB. Not found.
		return null;
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#GetNumForName(java.lang.String)
	 */
	
	public int GetNumForName(String name) {
		int i;

		i = CheckNumForName(name.toUpperCase());

		if (i == -1) {
			Exception e = new Exception();
			e.printStackTrace();
			System.err.println("Error:" + name + "not found");
			System.err.println("Hash:"
					+ Long.toHexString(name8.getLongHash(name)));
			I.Error("W_GetNumForName: %s not found!", name);
		}

		return i;
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#GetNameForNum(int)
	 */
    public String GetNameForNum(int lumpnum) {
        if (lumpnum>=0 && lumpnum<this.numlumps){
            return this.lumpinfo[lumpnum].name;
        }
        return null;
    }
	
	//
	// W_LumpLength
	// Returns the buffer size needed to load the given lump.
	//
	/* (non-Javadoc)
	 * @see w.IWadLoader#LumpLength(int)
	 */
	public int LumpLength(int lump) {
		if (lump >= numlumps)
			I.Error("W_LumpLength: %i >= numlumps", lump);

		return (int) lumpinfo[lump].size;
	}

	@Override
	public final byte[] ReadLump(int lump){
	    lumpinfo_t l=lumpinfo[lump];
	    byte[] buf=new byte[(int) l.size];
	    ReadLump(lump, buf,0);
	    return buf;
	    
	}
	
	@Override
	public final void ReadLump(int lump, byte[] buf) {
	    ReadLump(lump, buf, 0);
	}
	
    /**
     * W_ReadLump Loads the lump into the given buffer, which must be >=
     * W_LumpLength(). SKIPS CACHING
     * 
     * @throws IOException
     */

	@Override
	public final void ReadLump(int lump, byte[] buf, int offset) {
		int c=0;
		lumpinfo_t l;
		InputStream handle = null;

		if (lump >= this.numlumps) {
			I.Error("W_ReadLump: %i >= numlumps", lump);
			return;
		}

		l = lumpinfo[lump];

		if (l.handle == null) {
			// reloadable file, so use open / read / close
			try {
			    // FIXME: reloadable files can only be that. Files.
				handle = InputStreamSugar.createInputStreamFromURI(this.reloadname,null,0);
			} catch (Exception e) {
				e.printStackTrace();
				I.Error("W_ReadLump: couldn't open %s", reloadname);
			}
		} else
			handle = l.handle;

		try {

			handle=InputStreamSugar.streamSeek(handle,l.position,
		    l.wadfile.maxsize,l.wadfile.name,l.wadfile.entry,l.wadfile.type);
		    
			// read buffered. Unfortunately that interferes badly with 
			// guesstimating the actual stream position.
			BufferedInputStream bis=new BufferedInputStream(handle,8192);
			
			while (c<l.size)
			    c+= bis.read(buf,offset+c, (int) (l.size-c));
			
			// Well, that's a no-brainer.
			//l.wadfile.knownpos=l.position+c;
				
			if (c < l.size)
				System.err.printf("W_ReadLump: only read %d of %d on lump %d %d\n", c, l.size,
						lump,l.position);

			if (l.handle == null)
				handle.close();
			else
			    l.handle=handle;
	
			I.BeginRead ();
			
			return;
			
			// ??? I_EndRead ();
		} catch (Exception e) {
			e.printStackTrace();
			I.Error("W_ReadLump: could not read lump " + lump);
			e.printStackTrace();
			return;
		}

	}


	/** The most basic of the Wadloader functions. Will attempt to read a lump
	 *  off disk, based on the specific class type (it will call the unpack()
	 *  method). If not possible to call the unpack method, it will leave a 
	 *  DoomBuffer object in its place, with the raw byte contents. It's
	 *   
	 * 
	 */
	
	@SuppressWarnings("unchecked")
    public <T> T CacheLumpNum(int lump, int tag, Class<T> what) {
		
		if (lump >= numlumps) {
			I.Error("W_CacheLumpNum: %i >= numlumps", lump);
		}

		// Nothing cached here...
		// SPECIAL case : if no class is specified (null), the lump is re-read anyway
		// and you get a raw doombuffer. Plus, it won't be cached.
		
		if ((lumpcache[lump] == null)||(what==null)) {

			// read the lump in

			// System.out.println("cache miss on lump "+lump);
			// Fake Zone system: mark this particular lump with the tag specified
			// ptr = Z_Malloc (W_LumpLength (lump), tag, &lumpcache[lump]);
			// Read as a byte buffer anyway.
			ByteBuffer thebuffer = ByteBuffer.wrap(ReadLump(lump));

			// Class type specified

			if (what != null) {
				try {
					// Can it be uncached? If so, deserialize it.

					if (implementsInterface(what, w.CacheableDoomObject.class)) {
						// MAES: this should be done whenever single lumps
						// are read. DO NOT DELEGATE TO THE READ OBJECTS THEMSELVES.
						// In case of sequential reads of similar objects, use 
						// CacheLumpNumIntoArray instead.
						thebuffer.rewind();
						lumpcache[lump] = (CacheableDoomObject) what.newInstance();
						((CacheableDoomObject) lumpcache[lump]).unpack((ByteBuffer) thebuffer);
						
						// Track it for freeing
						Track(lumpcache[lump],lump);
						
						if (what == patch_t.class) {
							((patch_t) lumpcache[lump]).name = this.lumpinfo[lump].name;
						}
					} else {
						// replace lump with parsed object.
						lumpcache[lump] = (CacheableDoomObject) thebuffer;
						
						// Track it for freeing
						Track((CacheableDoomObject)thebuffer,lump);
					}
				} catch (Exception e) {
					System.err.println("Could not auto-instantiate lump "
							+ lump + " of class " + what);
					e.printStackTrace();
				}

			} else {
				// Class not specified? Then gimme a containing DoomBuffer!
				DoomBuffer db = new DoomBuffer(thebuffer);				
				lumpcache[lump] = db;
			}
		} else {
			// System.out.println("cache hit on lump " + lump);
			// Z.ChangeTag (lumpcache[lump],tag);
		}
		
		return (T) lumpcache[lump];
	}

	/** A very useful method when you need to load a lump which can consist
	 *  of an arbitrary number of smaller fixed-size objects (assuming that you
	 *  know their number/size and the size of the lump). Practically used 
	 *  by the level loader, to handle loading of sectors, segs, things, etc.
	 *  since their size/lump/number relationship is well-defined.
	 *  
	 *  It possible to do this in other ways, but it's extremely convenient this way.
	 *  
	 *  MAES 24/8/2011: This method is deprecated, Use the much more convenient
	 *  and slipstreamed generic version, which also handles caching of arrays
	 *  and auto-allocation.
	 *  
	 *  @param lump The lump number to load.
	 *  @param tag  Caching tag
	 *  @param array The array with objects to load. Its size implies how many to read.
	 *  @return
	 */
	
	@Deprecated
	public void CacheLumpNumIntoArray(int lump, int tag, Object[] array,
			Class what) throws IOException {

		if (lump >= numlumps) {
			I.Error("W_CacheLumpNum: %i >= numlumps", lump);
		}

		// Nothing cached here...
		if ((lumpcache[lump] == null)) {

			// read the lump in

			//System.out.println("cache miss on lump " + lump);
			// Read as a byte buffer anyway.
			ByteBuffer thebuffer = ByteBuffer.wrap(ReadLump(lump));
			// Store the buffer anyway (as a DoomBuffer)
			lumpcache[lump] = new DoomBuffer(thebuffer);
			
			// Track it (as ONE lump)
			Track(lumpcache[lump],lump);


		} else {
			//System.out.println("cache hit on lump " + lump);
			// Z.ChangeTag (lumpcache[lump],tag);
		}

		// Class type specified. If the previously cached stuff is a
		// "DoomBuffer" we can go on.

		if ((what != null) && (lumpcache[lump].getClass() == DoomBuffer.class)) {
			try {
				// Can it be uncached? If so, deserialize it. FOR EVERY OBJECT.
				ByteBuffer b = ((DoomBuffer) (lumpcache[lump])).getBuffer();
				b.rewind();

				for (int i = 0; i < array.length; i++) {
					if (implementsInterface(what, w.CacheableDoomObject.class)) {
						((CacheableDoomObject) array[i]).unpack(b);
					}
				}
				// lumpcache[lump]=array;
			} catch (Exception e) {
				System.err.println("Could not auto-unpack lump " + lump
						+ " into an array of objects of class " + what);
				e.printStackTrace();
			}

		}
		
		

		return;
	}

	/** A very useful method when you need to load a lump which can consist
	 *  of an arbitrary number of smaller fixed-size objects (assuming that you
	 *  know their number/size and the size of the lump). Practically used 
	 *  by the level loader, to handle loading of sectors, segs, things, etc.
	 *  since their size/lump/number relationship is well-defined.
	 *  
	 *  It possible to do this in other (more verbose) ways, but it's 
	 *  extremely convenient this way, as a lot of common and repetitive code
	 *  is only written once, and generically, here. Trumps the older
	 *  method in v 1.43 of WadLoader, which is deprecated.
	 *  
	 *  @param lump The lump number to load.
	 *  @param num number of objects to read	 *  
	 *  @return a properly sized array of the correct type.
	 */
	
	public <T extends CacheableDoomObject> T[] CacheLumpNumIntoArray(int lump, int num,
			Class<T> what){

		if (lump >= numlumps) {
			I.Error("CacheLumpNumIntoArray: %i >= numlumps", lump);
		}

		if (!implementsInterface(what, CacheableDoomObject.class)){
			I.Error("CacheLumpNumIntoArray: %s does not implement CacheableDoomObject", what.getName());
		}
	
		// Nothing cached here...
		if ((lumpcache[lump] == null)&&(what!=null)) {
			//System.out.println("cache miss on lump " + lump);
			// Read as a byte buffer anyway.
		    ByteBuffer thebuffer = ByteBuffer.wrap(ReadLump(lump));

			T[] stuff=(T[]) C2JUtils.createArrayOfObjects(what, num);
			
			// Store the buffer anyway (as a CacheableDoomObjectContainer)
			lumpcache[lump] = new CacheableDoomObjectContainer<T>(stuff);
			
			// Auto-unpack it, if possible.

			try {
				thebuffer.rewind();
				lumpcache[lump].unpack(thebuffer);
				} catch (Exception e) {
					System.err.println("Could not auto-unpack lump " + lump
							+ " into an array of objects of class " + what);
					e.printStackTrace();
				}
			
			// Track it (as ONE lump)
			Track(lumpcache[lump],lump);


		} else {
			//System.out.println("cache hit on lump " + lump);
			// Z.ChangeTag (lumpcache[lump],tag);
		}

		if (lumpcache[lump]==null) return null;
		
		return (T[]) ((CacheableDoomObjectContainer<T>)lumpcache[lump]).getStuff();
	}
	
	public CacheableDoomObject CacheLumpNum(int lump)
	{
	  return lumpcache[lump];
	}
	
	
	/** Tells us if a class implements a certain interface.
	 *  If you know of a better way, be my guest.
	 * 
	 * @param what
	 * @param which
	 * @return
	 */
	
	protected boolean implementsInterface(Class<?> what, Class<?> which) {
		Class<?>[] shit = what.getInterfaces();
		for (int i = 0; i < shit.length; i++) {
			if (shit[i].equals(which))
				return true;
		}

		return false;
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#CacheLumpNameAsRawBytes(java.lang.String, int)
	 */

	public byte[] CacheLumpNameAsRawBytes(String name, int tag) {
		return ((DoomBuffer) this.CacheLumpNum(this.GetNumForName(name), tag,
				null)).getBuffer().array();
	}
	
	 /* (non-Javadoc)
	 * @see w.IWadLoader#CacheLumpNumAsRawBytes(int, int)
	 */

    public byte[] CacheLumpNumAsRawBytes(int num, int tag) {
        return ((DoomBuffer) this.CacheLumpNum(num, tag,
                null)).getBuffer().array();
    	}
	

	/* (non-Javadoc)
	 * @see w.IWadLoader#CacheLumpName(java.lang.String, int)
	 */

	public DoomBuffer CacheLumpName(String name, int tag) {
		return (DoomBuffer) this.CacheLumpNum(this.GetNumForName(name), tag,
				DoomBuffer.class);

	}
	
	   public DoomBuffer CacheLumpNumAsDoomBuffer(int lump) {
	        return (DoomBuffer) this.CacheLumpNum(lump, 0,
	                DoomBuffer.class);
	    }
	

	/* (non-Javadoc)
	 * @see w.IWadLoader#CachePatchName(java.lang.String)
	 */

	public patch_t CachePatchName(String name) {
		return (patch_t) this.CacheLumpNum(this.GetNumForName(name), PU_CACHE,
				patch_t.class);

	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#CachePatchName(java.lang.String, int)
	 */

	public patch_t CachePatchName(String name, int tag) {
		return (patch_t) this.CacheLumpNum(this.GetNumForName(name), tag,
				patch_t.class);
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#CachePatchNum(int, int)
	 */

	public patch_t CachePatchNum(int num) {
		return (patch_t) this.CacheLumpNum(num, PU_CACHE, patch_t.class);
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#CacheLumpName(java.lang.String, int, java.lang.Class)
	 */
	public <T extends CacheableDoomObject> T CacheLumpName(String name, int tag, Class<T> what) {
		return this.CacheLumpNum(this.GetNumForName(name.toUpperCase()), tag,
				what);
	}

	//
	// W_Profile
	//
	/* USELESS
	 char[][] info = new char[2500][10];

	int profilecount;

	void Profile() throws IOException {
		int i;
		// memblock_t block = null;
		Object ptr;
		char ch;
		FileWriter f;
		int j;
		String name;

		for (i = 0; i < numlumps; i++) {
			ptr = lumpcache[i];
			if ((ptr == null)) {
				ch = ' ';
				continue;
			} else {
				// block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
				if (block.tag < PU_PURGELEVEL)
					ch = 'S';
				else
					ch = 'P';
			}
			info[i][profilecount] = ch;
		}
		profilecount++;

		f = new FileWriter(new File("waddump.txt"));
		// name[8] = 0;

		for (i = 0; i < numlumps; i++) {
			name = lumpinfo[i].name;

			f.write(name);

			for (j = 0; j < profilecount; j++)
				f.write("    " + info[i][j]);

			f.write("\n");
		}
		f.close();
	} */
	
	/* (non-Javadoc)
	 * @see w.IWadLoader#isLumpMarker(int)
	 */
	public boolean isLumpMarker(int lump){
	    return (lumpinfo[lump].size==0);
	}
	
	   /* (non-Javadoc)
	 * @see w.IWadLoader#GetNameForLump(int)
	 */
	public String GetNameForLump(int lump){
	        return lumpinfo[lump].name;
	    }

	// /////////////////// HASHTABLE SYSTEM ///////////////////

	//
	// killough 1/31/98: Initialize lump hash table
	//

	/**
	 * Maes 12/12/2010: Some credit must go to Killough for first
	 * Introducing the hashtable system into Boom. On early releases I had
	 * copied his implementation, but it proved troublesome later on and slower
	 * than just using the language's built-in hash table. Lesson learned, kids:
	 * don't reinvent the wheel.
	 * 
	 * TO get an idea of how superior using a hashtable is, on 1000000 random
	 * lump searches the original takes 48 seconds, searching for precomputed
	 * hashes takes 2.84, and using a Hashtable takes 0.2 sec.
	 * 
	 * And the best part is that Java provides a perfectly reasonable implementation.
	 * 
	 */

	Hashtable<String, Integer> doomhash;

	protected void InitLumpHash() {

		doomhash = new Hashtable<String, Integer>(numlumps);

		//for (int i = 0; i < numlumps; i++)
		//	lumpinfo[i].index = -1; // mark slots empty

		// Insert nodes to the beginning of each chain, in first-to-last
		// lump order, so that the last lump of a given name appears first
		// in any chain, observing pwad ordering rules. killough

		for (int i = 0; i < numlumps; i++) { // hash function:
			doomhash.put(lumpinfo[i].name.toUpperCase(), new Integer(i));
		    }
	}

	/* (non-Javadoc)
	 * @see w.IWadLoader#CheckNumForName(java.lang.String)
	 */
	public int CheckNumForName(String name/* , int namespace */)

	{
		Integer r = doomhash.get(name);
		// System.out.print("Found "+r);

		if (r != null)
			return r.intValue();

		// System.out.print(" found "+lumpinfo[i]+"\n" );
		return -1;
	}

	   /* (non-Javadoc)
     * @see w.IWadLoader#CheckNumForName(java.lang.String)
     */
    public int[] CheckNumsForName(String name)

    {
        
        list.clear();
        
        // Dumb search, no chained hashtables I'm afraid :-/
        // Move backwards, so list is compiled with more recent ones first.
        for (int i=numlumps-1;i>=0;i--){
            if (name.compareToIgnoreCase(lumpinfo[i].name)==0) list.add(i);
        }
        
        final int num=list.size();
        int[] result=new int[num];
        for (int i=0;i<num;i++){
            result[i]=list.get(i);
        }
    
        // Might be empty/null, so check that out.
        return result;
    }
    
    private final ArrayList<Integer> list=new ArrayList<Integer>();
	
	@Override
	public lumpinfo_t GetLumpInfo(int i) {
		return this.lumpinfo[i];
	}
	
	@Override
	public void CloseAllHandles(){
		ArrayList<InputStream> d=new ArrayList<InputStream>();
		
		for (int i=0;i<this.lumpinfo.length;i++){
			if (!d.contains(lumpinfo[i].handle)) d.add(lumpinfo[i].handle);
		}
		
		int count=0;
		
		for (InputStream e:d){
			try {
				e.close();
				//System.err.printf("%s file handle closed",e.toString());
				count++;
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
		
		//System.err.printf("%d file handles closed",count);
				
	}
	
	@Override
	public void finalize(){
		CloseAllHandles();
	}

	public static final int ns_global=0;
	public static final int ns_flats=1;
	public static final int ns_sprites=2;
	
	/** 
	 * Based on Boom's W_CoalesceMarkedResource
	 * Sort of mashes similar namespaces together so that they form
	 * a continuous space (single start and end, e.g. so that multiple
	 * S_START and S_END as well as special DEUTEX lumps mash together
	 * under a common S_START/S_END boundary). Also also sort of performs
	 * a "bubbling down" of marked lumps at the end of the namespace.
	 * 
	 * It's convenient for sprites, but can be replaced by alternatives
	 * for flats.
	 * 
	 * killough 4/17/98: add namespace tags
	 *   
	 * @param start_marker
	 * @param end_marker
	 * @param namespace
	 * @return
	 */
	public int CoalesceMarkedResource(String start_marker,
	                                     String end_marker, li_namespace namespace)
	{
	  int result = 0;
	  lumpinfo_t[] marked = new lumpinfo_t[numlumps];
	 // C2JUtils.initArrayOfObjects(marked, lumpinfo_t.class);
	  int num_marked = 0, num_unmarked = 0;
	  boolean is_marked = false, mark_end = false;
	  lumpinfo_t lump;

	  // Scan for specified start mark
	  for (int i=0;i<numlumps;i++){
		  lump=lumpinfo[i];
	    if (IsMarker(start_marker,lump.name)) // start marker found
	      { // If this is the first start marker, add start marker to marked lumps
//	    	System.err.printf("%s identified as starter mark for %s index %d\n",lump.name,
//	    			start_marker,i);
	        if (num_marked==0)
	          {
	        	marked[num_marked]=new lumpinfo_t();
	            marked[num_marked].name=new String(start_marker);
	            marked[num_marked].size = 0;  // killough 3/20/98: force size to be 0
	            marked[num_marked].namespace =li_namespace.ns_global;        // killough 4/17/98
	            marked[num_marked].handle=lump.handle;
	            // No real use for this yet
	            marked[num_marked].wadfile = lump.wadfile;
	            num_marked = 1;
		    	//System.err.printf("%s identified as FIRST starter mark for %s index %d\n",lump.name,
		    	//		start_marker,i);
	          }
	        is_marked = true;                            // start marking lumps
	      }
	    else
	      if (IsMarker(end_marker, lump.name))       // end marker found
	        {
		    //	System.err.printf("%s identified as end mark for %s index %d\n",lump.name,
		    //			end_marker,i);
	          mark_end = true;                           // add end marker below
	          is_marked = false;                          // stop marking lumps
	        }
	      else
	        if (is_marked || lump.namespace == namespace)
	          {
	            // if we are marking lumps,
	            // move lump to marked list
	            // sf: check for namespace already set

	            // sf 26/10/99:
	            // ignore sprite lumps smaller than 8 bytes (the smallest possible)
	            // in size -- this was used by some dmadds wads
	            // as an 'empty' graphics resource
	            if(namespace != li_namespace.ns_sprites || lump.size > 8)
	            {
	              marked[num_marked] = lump.clone();
	             // System.err.printf("Marked %s as %d for %s\n",lump.name,num_marked,namespace);
	              marked[num_marked++].namespace = namespace;  // killough 4/17/98
	              result++;
	            }
	          }
	        else
	          lumpinfo[num_unmarked++] = lump.clone();       // else move down THIS list
	  }
	    
	  // Append marked list to end of unmarked list
	  System.arraycopy(marked, 0, lumpinfo, num_unmarked, num_marked);

	  numlumps = num_unmarked + num_marked;           // new total number of lumps

	  if (mark_end)                                   // add end marker
	    {
	      lumpinfo[numlumps].size = 0;  // killough 3/20/98: force size to be 0
	      //lumpinfo[numlumps].wadfile = NULL;
	      lumpinfo[numlumps].namespace = li_namespace.ns_global;   // killough 4/17/98
	      lumpinfo[numlumps++].name=end_marker;
	    }

	  return result;
	}
	  
	public final static boolean IsMarker(String marker, String name)
	{
		// Safeguard against nameless marker lumps e.g. in Galaxia.wad
		if (name==null || name.length()==0) return false;
	  boolean result= name.equalsIgnoreCase(marker) ||
	    // doubled first character test for single-character prefixes only
	    // FF_* is valid alias for F_*, but HI_* should not allow HHI_*
	    (marker.charAt(1) == '_' && name.charAt(0) == marker.charAt(0) && 
	    		name.substring(1).equalsIgnoreCase(marker));

	  return result;
	}

	@Override
	public void UnlockLumpNum(int lump) {
		lumpcache[lump]=null;
	}

	@Override
	public void InjectLumpNum(int lump, CacheableDoomObject obj){
		lumpcache[lump]=obj;
	}
	
	//// Merged remnants from LumpZone here.

	Hashtable<CacheableDoomObject, Integer> zone;

	/** Add a lump to the tracking */

	public void Track(CacheableDoomObject lump, int index){
		zone.put(lump, index);
	}

	@Override
	public void UnlockLumpNum(CacheableDoomObject lump){
		// Remove it from the reference
		Integer lumpno=zone.remove(lump);
		

		// Force nulling. This should trigger garbage collection,
		// and reclaim some memory, provided you also nulled any other 
		// reference to a certain lump. Therefore, make sure you null 
		// stuff right after calling this method, if you want to make sure 
		// that they won't be referenced anywhere else.
		
		if (lumpno!=null) {
			lumpcache[lumpno]=null;
			//System.out.printf("Lump %d %d freed\n",lump.hashCode(),lumpno);
		}
	}

    @Override
    public boolean verifyLumpName(int lump, String lumpname) {
        
        // Lump number invalid
        if (lump<0 || lump>numlumps-1) return false;
        
        String name=GetNameForLump(lump);
        
        // Expected lump name not found
        if (name==null || lumpname.compareToIgnoreCase(name)!=0) return false;        
        
        // Everything should be OK now...
        return true;
    }

    @Override
    public int GetWadfileIndex(wadfile_info_t wad1) {        
        return wadfiles.indexOf(wad1);
    }

    @Override
    public int GetNumWadfiles() {
        return wadfiles.size();
    }

	
}

//$Log: WadLoader.java,v $
//Revision 1.66  2016/07/04 13:50:50  velktron
//GPL license header
//
//Revision 1.65  2016/06/06 13:45:44  velktron
//New features to support basic WAD building/writing.
//
//Revision 1.64  2014/03/28 00:55:32  velktron
//Cleaner, generic-based design to minimize warnings and suppressions. <T extends CacheableDoomObject> used whenever possible.
//
//Revision 1.63  2013/06/03 10:36:33  velktron
//Jaguar handling (actualname)
//
//Revision 1.62.2.1  2013/01/09 14:24:12  velktron
//Uses the rest of the crap
//
//Revision 1.62  2012/11/08 17:16:12  velktron
//Made GetLumpForNum generic.
//
//Revision 1.61  2012/09/25 16:33:36  velktron
//Dummy Doomsystem for easy testing.
//
//Revision 1.60  2012/09/24 17:16:22  velktron
//Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
//Revision 1.57.2.5  2012/09/19 21:46:46  velktron
//Simpler call for getPATCH
//
//Revision 1.57.2.4  2012/09/04 15:08:34  velktron
//New GetNumsForName function.
//
//Revision 1.57.2.3  2012/06/14 22:38:20  velktron
//Uses new disk flasher.
//
//Revision 1.57.2.2  2011/12/08 00:40:40  velktron
//Fix for Galaxia.wad nameless lumps.
//
//Revision 1.57.2.1  2011/12/05 12:05:13  velktron
//Fixed a vexing bug with ZIP file header & TOC reading.
//
//Revision 1.57  2011/11/09 19:07:40  velktron
//Adapted to handling ZIP files
//
//Revision 1.56  2011/11/03 21:14:30  velktron
//Added -FINALLY!- resource access testing before adding them -_-
//
//Revision 1.55  2011/11/01 22:09:11  velktron
//Some more progress on URI handling. Not essential/not breaking.
//
//Revision 1.54  2011/10/25 19:45:51  velktron
//More efficient use of bis ;-)
//
//Revision 1.53  2011/10/25 19:42:48  velktron
//Added advanced streaming input support and more convenient byte[] ReadLump methods.
//
//Revision 1.52  2011/10/24 02:07:08  velktron
//DoomFile model abandoned. Now streams are used whenever possible, with possible future expandability to use e.g. URL streams or other types of resources other than RandomAccessFiles.
//
//Revision 1.51  2011/10/23 22:50:42  velktron
//Added InjectLumpNum function to force generated contents.
//
//Revision 1.50  2011/10/23 18:16:31  velktron
//Cleanup, moved logs to the end of the file
//
//Revision 1.49  2011/10/19 12:34:29  velktron
//Using extractFileBase in C2JUtils now, got rid of filelength
//
//Revision 1.48  2011/09/29 15:18:31  velktron
//Resource coalescing correctly handles wadfiles
//
//Revision 1.47  2011/09/27 15:57:09  velktron
//Full wadinfo (lump "ownership") system in place, borrowed from prBoom+ with a twist ;-)
//
//Revision 1.46  2011/09/16 11:17:22  velktron
//Added verifyLumpName function
//
//Revision 1.45  2011/09/02 16:29:59  velktron
//Minor interface change
//
//Revision 1.44  2011/08/24 14:55:42  velktron
//Deprecated old CacheLumpNumIntoArray method, much cleaner system introduced.
//
//Revision 1.43  2011/08/23 16:10:20  velktron
//Got rid of Z remnants, commenter out Profile (useless as it is)
//
//Revision 1.42  2011/08/23 16:08:43  velktron
//Integrated Zone functionality in WadLoader, Boom-like UnlockLump. Makes things MUCH easier.
//
//Revision 1.41  2011/08/02 13:49:56  velktron
//Fixed missing handle on generated lumpinfo_t
//
//Revision 1.40  2011/08/01 22:09:14  velktron
//Flats coalescing.
//
//Revision 1.39  2011/08/01 21:42:56  velktron
//Added BOOM CoaleseResources function.
//
//Revision 1.38  2011/07/13 16:34:18  velktron
//Started adding some BOOM wad handling stuff. Still WIP though.
//
//Revision 1.37  2011/07/05 13:26:30  velktron
//Added handle closing functionality.
//
//Revision 1.36  2011/06/12 21:52:11  velktron
//Made CheckNumForName uppercase-proof, at last.
//
//Revision 1.35  2011/06/03 16:35:27  velktron
//Default fakezone
//
//Revision 1.34  2011/06/02 14:23:20  velktron
//Added ability to "peg" an IZone manager.
//
//Revision 1.33  2011/05/23 17:00:39  velktron
//Got rid of verbosity
//
//Revision 1.32  2011/05/22 21:08:28  velktron
//Added better filename handling.
//
//Revision 1.31  2011/05/18 16:58:11  velktron
//Changed to DoomStatus
//
//Revision 1.30  2011/05/13 11:20:07  velktron
//Why the hell did this not implement IReadableDoomObject?
//
//Revision 1.29  2011/05/13 11:17:48  velktron
//Changed default read buffer behavior. Now it's ALWAYS reset when reading from disk, and not up to the CacheableDoomObject. This does not affect bulk/stream reads.
//
//Revision 1.28  2011/05/10 10:39:18  velktron
//Semi-playable Techdemo v1.3 milestone
//
//Revision 1.27  2011/01/26 00:04:45  velktron
//DEUTEX flat support, Unrolled drawspan precision fix.
//
//Revision 1.26  2011/01/10 16:40:54  velktron
//Some v1.3 commits: OSX fix, limit-removing flat management (to fix),
//
//Revision 1.25  2010/12/22 01:23:15  velktron
//Definitively fixed plain DrawColumn.
//Fixed PATCH/TEXTURE and filelump/wadloader capitalization.
//Brought back some testers.
//
//Revision 1.24  2010/12/14 17:55:59  velktron
//Fixed weapon bobbing, added translucent column drawing, separated rendering commons.
//
//Revision 1.23  2010/12/13 16:03:20  velktron
//More fixes  in the wad loading code
//
//Revision 1.22  2010/12/12 21:27:17  velktron
//Fixed hashtable bug. Now using Java's one, faster AND easier to follow.
//
//Revision 1.21  2010/10/08 16:55:50  velktron
//Duh
//
//Revision 1.20  2010/09/27 02:27:29  velktron
//BEASTLY update
//
//Revision 1.19  2010/09/24 17:58:39  velktron
//Menus and HU  functional -mostly.
//
//Revision 1.18  2010/09/23 20:36:45  velktron
//*** empty log message ***
//
//Revision 1.17  2010/09/23 15:11:57  velktron
//A bit closer...
//
//Revision 1.16  2010/09/22 16:40:02  velktron
//MASSIVE changes in the status passing model.
//DoomMain and DoomGame unified.
//Doomstat merged into DoomMain (now status and game functions are one).
//
//Most of DoomMain implemented. Possible to attempt a "classic type" start but will stop when reading sprites.
//
//Revision 1.15  2010/09/13 15:39:17  velktron
//Moving towards an unified gameplay approach...
//
//Revision 1.14  2010/09/09 01:13:19  velktron
//MUCH better rendering and testers.
//
//Revision 1.13  2010/09/07 16:23:00  velktron
//*** empty log message ***
//
//Revision 1.12  2010/09/03 15:30:34  velktron
//More work on unified renderer
//
//Revision 1.11  2010/09/02 15:56:54  velktron
//Bulk of unified renderer copyediting done.
//
//Some changes like e.g. global separate limits class and instance methods for seg_t and node_t introduced.
//
//Revision 1.10  2010/08/30 15:53:19  velktron
//Screen wipes work...Finale coded but untested.
//GRID.WAD included for testing.
//
//Revision 1.9  2010/08/23 14:36:08  velktron
//Menu mostly working, implemented Killough's fast hash-based GetNumForName, although it can probably be finetuned even more.
//
//Revision 1.8  2010/08/13 14:06:36  velktron
//Endlevel screen fully functional!
//
//Revision 1.7  2010/08/11 16:31:34  velktron
//Map loading works! Check out LevelLoaderTester for more.
//
//Revision 1.6  2010/08/10 16:41:57  velktron
//Threw some work into map loading.
//
//Revision 1.5  2010/07/22 15:37:53  velktron
//MAJOR changes in Menu system.
//
//Revision 1.4  2010/07/15 14:01:49  velktron
//Added reflector Method stuff for function pointers.
//
//Revision 1.3  2010/07/06 15:20:23  velktron
//Several changes in the WAD loading routine. Now lumps are directly unpacked as "CacheableDoomObjects" and only defaulting will result in "raw" DoomBuffer reads.
//
//Makes caching more effective.
//
//Revision 1.2 2010/06/30 11:44:40 velktron
//Added a tester for patches (one of the most loosely-coupled structs in Doom!)
//and fixed some minor stuff all around.
//
//Revision 1.1 2010/06/30 08:58:50 velktron
//Let's see if this stuff will finally commit....
//
//
//Most stuff is still being worked on. For a good place to start and get an
//idea of what is being done, I suggest checking out the "testers" package.
//
//Revision 1.1 2010/06/29 11:07:34 velktron
//Release often, release early they say...
//
//Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete,
//and there's still mixed C code in there. I suggest you load everything up in
//Eclpise and see what gives from there.
//
//A good place to start is the testers/ directory, where you can get an idea of
//how a few of the implemented stuff works.
package w;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

/** Very similar to the concept of ReadableDoomObjects
 *  but made to work with byte buffers instead. 
 *  
 *  This is normally NOT used to pass data around: I am 
 *  using it as a workaround to store raw byte buffers
 *  into a "CacheableDoomObject" array, as Java
 *  doesn't seem to like storing both ByteBuffers and
 *  CacheableDoomObjects in the same array. WTF...
 * 
 * @author admin
 *
 */

public class DoomBuffer implements CacheableDoomObject  {

    public DoomBuffer(){

    }
    
    public DoomBuffer(ByteBuffer b){
        this.buffer=b;
    }

    private ByteBuffer buffer;

    public static void readObjectArray(ByteBuffer buf,CacheableDoomObject[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){    
            s[i].unpack(buf);
        }
    }
    
    public static void readIntArray(ByteBuffer buf,int[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            s[i]=buf.getInt();
        }
    }
    
    public static void putIntArray(ByteBuffer buf,int[] s,int len,ByteOrder bo) throws IOException {
        buf.order(bo);
        
        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            buf.putInt(s[i]);
        }
    }
    
    public static void putBooleanIntArray(ByteBuffer buf,boolean[] s,int len,ByteOrder bo) throws IOException {
        buf.order(bo);
        
        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            buf.putInt(s[i]?1:0);
        }
    }
    
    public static void putBooleanInt(ByteBuffer buf,boolean s,ByteOrder bo) throws IOException {
        buf.order(bo);        
            buf.putInt(s?1:0);
    }
    
    public static void readCharArray(ByteBuffer buf,char[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            s[i]=buf.getChar();
        }
    }
    
    public static void readShortArray(ByteBuffer buf,short[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            s[i]=buf.getShort();
        }
    }

    public void readShortArray(short[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            s[i]=this.buffer.getShort();
            
        }
    }
    
    public void readCharArray(char[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            s[i]=this.buffer.getChar();
            
        }
    }
    
    public void readCharArray(int[] s,int len) throws IOException {

        if ((s==null)||(len==0)) return;
        
        for (int i=0;i<Math.min(len,s.length);i++){           
            s[i]=this.buffer.getChar();
            
        }
    }
    
    
    /** Reads a length specified string from a buffer. */
    public static String readString(ByteBuffer buf) throws IOException {
        int len = buf.getInt();

        if (len == -1)
            return null;

        if (len == 0)
            return "";

        byte bb[] = new byte[len];

        buf.get(bb, 0, len);

        return new String(bb, 0, len);
    }

 /** MAES: Reads a specified number of bytes from a buffer into a new String.
  *  With many lengths being implicit, we need to actually take the loader by the hand.
  * 
  * @param buf
  * @param len
  * @return
  * @throws IOException
  */
    
    public static String getString(ByteBuffer buf, int len) throws IOException {

        if (len == -1)
            return null;

        if (len == 0)
            return "";

        byte bb[] = new byte[len];

        buf.get(bb, 0, len);

        return new String(bb, 0, len);
    }
    
    /** MAES: Reads a maximum specified number of bytes from a buffer into a new String,
     * considering the bytes as representing a null-terminated, C-style string.
     * 
     * @param buf
     * @param len
     * @return
     * @throws IOException
     */
       
       public static String getNullTerminatedString(ByteBuffer buf, int len) throws IOException {

           if (len == -1)
               return null;

           if (len == 0)
               return "";

           byte bb[] = new byte[len];
           
           buf.get(bb, 0, len);
           // Detect null-termination.
           for (int i=0;i<len;i++){
               if (bb[i]==0x00){
                   len=i;
                   break;
               }
           }
           
           return new String(bb, 0, len);
       }
    
       /** MAES: WRITES a maximum specified number of characters from a String to a buffer, using C-style
        * null Termination.
        * 
        * @param buf
        * @param str
        * @param len
        * @return 
        * @throws IOException
        */
          
        public static int putNullTerminatedString(ByteBuffer buf, String str, int len) throws IOException {

              if (str==null || len<=0) return 0;
              
              if (str.length() != 0){
                  byte[] str8=str.getBytes("ISO-8859-1");
                  buf.put(str8,0,Math.min(len,str.length()));
                  // Fill in with 0s if something's left.
                  if (str8.length<len){
                      for (int i=0;i<len-str8.length;i++){
                          buf.put((byte)0x00);
                      }
                  }
                  return str8.length;
              }
              
              return 0;
          }
       
       
    /** MAES: Reads a specified number of bytes from a buffer into a new String.
     *  With many lengths being implicit, we need to actually take the loader by the hand.
     * 
     * @param buf
     * @param len
     * @return
     * @throws IOException
     */
       
       public static char[] getCharSeq(ByteBuffer buf, int len) throws IOException {
           return (getString(buf,len)).toCharArray();
       }

    

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        this.buffer=buf;
        
    }

    public ByteBuffer getBuffer() {
        return buffer;
    }
    
    public void setOrder(ByteOrder bo){
        this.buffer.order(bo);
    }

    public void rewind() {
        this.buffer.rewind();
    }

    public static int getBEInt(byte b3,byte b2, byte b1,byte b0) {        
        return (b3<<24|b2<<16|b1<<8|b0);
    }
    
    public static int getBEInt(byte[] buf,int offset) {        
        return (buf[offset]<<24|buf[offset+1]<<16|buf[offset+2]<<8|buf[offset+3]);
    }
    
    public static int getBEInt(byte[] buf) {        
        return (buf[0]<<24|buf[1]<<16|buf[2]<<8|buf[3]);
    }
    
    public static int getLEInt(byte b0,byte b1, byte b2,byte b3) {        
        return (b3<<24|b2<<16|b1<<8|b0);
    }
    
    public static int getLEInt(byte[] buf) {        
        return (buf[3]<<24|buf[2]<<16|buf[1]<<24|buf[0]);
    }
    
    public static short getBEShort(byte[] buf) {        
        return (short) (buf[0]<<8|buf[1]);
    }
    
    public static short getLEShort(byte[] buf) {        
        return (short) (buf[0]<<8|buf[1]);
    }
    
}

package w;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;

/** This is an interface implemented by objects that must be read form disk.
 *  Every object is supposed to do its own umarshalling. This way,
 *  structured and hierchical reads are possible. Another superior innovation
 *  of Mocha Doom ;-) Err....ok :-p
 *  
 * @author Velktron
 *
 */

public interface IReadableDoomObject {
    
    public void read(DataInputStream f) throws IOException ;
}

package g;

import java.lang.reflect.Array;

import p.intercept_t;
import rr.line_t;
import data.mapthing_t;
import doom.DoomStatus;

/* Emacs style mode select   -*- C++ -*-
 *-----------------------------------------------------------------------------
 *
 *
 *  PrBoom: a Doom port merged with LxDoom and LSDLDoom
 *  based on BOOM, a modified and improved DOOM engine
 *  Copyright (C) 1999 by
 *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
 *  Copyright (C) 1999-2000 by
 *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
 *  Copyright 2005, 2006 by
 *  Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 *  02111-1307, USA.
 *
 * DESCRIPTION:
 *
 * Overflow emulation code, totally ripped off prBoom+! Sieg Heil!
 *
 *---------------------------------------------------------------------
 */

public class Overflow {

    String[] overflow_cfgname =
    {
      "overrun_spechit_emulate",
      "overrun_reject_emulate",
      "overrun_intercept_emulate",
      "overrun_playeringame_emulate",
      "overrun_donut_emulate",
      "overrun_missedbackside_emulate"
    };
    
    class overrun_param_t{
      boolean warn;
      boolean emulate;
      boolean tmp_emulate;
      int promted;
      int shit_happens;
    }
    
    class intercepts_overrun_t
    {
        int len;
        long addr;
        boolean int16_array;
    } 


    public static final int OVERFLOW_SPECHIT=0;
    public static final int OVERFLOW_REJECT=1;
    public static final int OVERFLOW_INTERCEPT=2;
    public static final int OVERFLOW_PLYERINGAME=3;
    public static final int OVERFLOW_DONUT=4;
    public static final int OVERFLOW_MISSEDBACKSIDE=5;
    public static final int OVERFLOW_MAX=6;
    
    public static final int MAXINTERCEPTS_ORIGINAL=128;

    
    
    public static final boolean EMULATE(int overflow) {
        return (overflows[overflow].emulate || overflows[overflow].tmp_emulate);
    }
    
    public static final boolean PROCESS(int overflow) {
        return (overflows[overflow].warn || EMULATE(overflow));
    }

    static overrun_param_t[] overflows=new overrun_param_t[OVERFLOW_MAX];
    
    public static intercepts_overrun_t[] intercepts_overrun;

/*
    static void ShowOverflowWarning(int overflow, int fatal, String ... params)
    {
      overflows[overflow].shit_happens = true;

      if (overflows[overflow].warn && !overflows[overflow].promted)
      {
        va_list argptr;
        char buffer[1024];

        static const char *name[OVERFLOW_MAX] = {
          "SPECHIT", "REJECT", "INTERCEPT", "PLYERINGAME", "DONUT", "MISSEDBACKSIDE"};

        static const char str1[] =
          "Too big or not supported %s overflow has been detected. "
          "Desync or crash can occur soon "
          "or during playback with the vanilla engine in case you're recording demo.%s%s";
        
        static const char str2[] = 
          "%s overflow has been detected.%s%s";

        static const char str3[] = 
          "%s overflow has been detected. "
          "The option responsible for emulation of this overflow is switched off "
          "hence desync or crash can occur soon "
          "or during playback with the vanilla engine in case you're recording demo.%s%s";

        overflows[overflow].promted = true;

        sprintf(buffer,
          (fatal ? str1 : (EMULATE(overflow) ? str2 : str3)), 
          name[overflow],
          "\nYou can change PrBoom behaviour for this overflow through in-game menu.",
          params);
        
        va_start(argptr, params);
        I_vWarning(buffer, argptr);
        va_end(argptr);
      }
    } */

    // e6y
    //
    // Intercepts Overrun emulation
    // See more information on:
    // doomworld.com/vb/doom-speed-demos/35214-spechits-reject-and-intercepts-overflow-lists
    //
    // Thanks to Simon Howard (fraggle) for refactor the intercepts
    // overrun code so that it should work properly on big endian machines
    // as well as little endian machines.

    // Overwrite a specific memory location with a value.
    
    /*
    static void InterceptsMemoryOverrun(int location, int value)
    {
      int i, offset;
      int index;
      long addr;

      i = 0;
      offset = 0;

      // Search down the array until we find the right entry

      while (intercepts_overrun[i].len != 0)
      {
        if (offset + intercepts_overrun[i].len > location)
        {
          addr = intercepts_overrun[i].addr;

          // Write the value to the memory location.
          // 16-bit and 32-bit values are written differently.

          if (addr != NULL)
          {
            if (intercepts_overrun[i].int16_array)
            {
              index = (location - offset) / 2;
              ((short *) addr)[index] = value & 0xffff;
              ((short *) addr)[index + 1] = (value >> 16) & 0xffff;
            }
            else
            {
              index = (location - offset) / 4;
              ((int *) addr)[index] = value;
            }
          }

          break;
        }

        offset += intercepts_overrun[i].len;
        ++i;
      }
    }
*/

    /*
    void InterceptsOverrun(int num_intercepts, intercept_t intercept)
    {
      if (num_intercepts > MAXINTERCEPTS_ORIGINAL && demo_compatibility && PROCESS(OVERFLOW_INTERCEPT))
      {
        ShowOverflowWarning(OVERFLOW_INTERCEPT, false, "");

        if (EMULATE(OVERFLOW_INTERCEPT))
        {
          int location = (num_intercepts - MAXINTERCEPTS_ORIGINAL - 1) * 12;

          // Overwrite memory that is overwritten in Vanilla Doom, using
          // the values from the intercept structure.
          //
          // Note: the .d.{thing,line} member should really have its
          // address translated into the correct address value for 
          // Vanilla Doom.

          InterceptsMemoryOverrun(location, intercept.frac);
          InterceptsMemoryOverrun(location + 4, intercept.isaline);
          InterceptsMemoryOverrun(location + 8, (int) intercept.d.thing);
        }
      }
    }
*/
    // e6y
    // playeringame overrun emulation
    // it detects and emulates overflows on vex6d.wad\bug_wald(toke).lmp, etc.
    // http://www.doom2.net/doom2/research/runningbody.zip

    static boolean PlayeringameOverrun(final mapthing_t mthing, DoomStatus DS)
    {
      if (mthing.type == 0 && PROCESS(OVERFLOW_PLYERINGAME))
      {
        ShowOverflowWarning(OVERFLOW_PLYERINGAME, DS.players[4].didsecret, "");

        if (EMULATE(OVERFLOW_PLYERINGAME))
        {
          return true;
        }
      }
      return false;
    }

 //
 // spechit overrun emulation
 //

 // Spechit overrun magic value.
 public static final int DEFAULT_SPECHIT_MAGIC =0x01C09C98;

 class spechit_overrun_param_t
 {
   line_t line;

   line_t[] spechit;
   int numspechit;

   int[] tmbbox;
   int[] tmfloorz;
   int[] tmceilingz;

   boolean crushchange;
   boolean nofit;
 }

    long spechit_baseaddr = 0;

    // e6y
    // Code to emulate the behavior of Vanilla Doom when encountering an overrun
    // of the spechit array.
    // No more desyncs on compet-n\hr.wad\hr18*.lmp, all strain.wad\map07 demos etc.
    // http://www.doomworld.com/vb/showthread.php?s=&threadid=35214
    // See more information on:
    // doomworld.com/vb/doom-speed-demos/35214-spechits-reject-and-intercepts-overflow-lists
    
    /*
    static void SpechitOverrun(spechit_overrun_param_t params)
    {
      int numspechit = params.numspechit;

      if (demo_compatibility && numspechit > 8)
      {
        line_t[] spechit = params.spechit;

        ShowOverflowWarning(OVERFLOW_SPECHIT,
          numspechit > 
            (compatibility_level == dosdoom_compatibility || 
            compatibility_level == tasdoom_compatibility ? 10 : 14), 
          "\n\nThe list of LineID leading to overrun:\n%d, %d, %d, %d, %d, %d, %d, %d, %d.",
          spechit[0].iLineID, spechit[1].iLineID, spechit[2].iLineID,
          spechit[3].iLineID, spechit[4].iLineID, spechit[5].iLineID,
          spechit[6].iLineID, spechit[7].iLineID, spechit[8].iLineID);

        if (EMULATE(OVERFLOW_SPECHIT))
        {
          unsigned int addr;

          if (spechit_baseaddr == 0)
          {
            int p;

            // This is the first time we have had an overrun.  Work out
            // what base address we are going to use.
            // Allow a spechit value to be specified on the command line.

            //
            // Use the specified magic value when emulating spechit overruns.
            //

            p = M_CheckParm("-spechit");
            
            if (p > 0)
            {
              //baseaddr = atoi(myargv[p+1]);
              M_StrToInt(myargv[p+1], (long*)&spechit_baseaddr);
            }
            else
            {
              spechit_baseaddr = DEFAULT_SPECHIT_MAGIC;
            }
          }

          // Calculate address used in doom2.exe

          addr = spechit_baseaddr + (params.line - lines) * 0x3E;

          if (compatibility_level == dosdoom_compatibility || compatibility_level == tasdoom_compatibility)
          {
            // There are no more desyncs in the following dosdoom demos: 
            // flsofdth.wad\fod3uv.lmp - http://www.doomworld.com/sda/flsofdth.htm
            // hr.wad\hf181430.lmp - http://www.doomworld.com/tas/hf181430.zip
            // hr.wad\hr181329.lmp - http://www.doomworld.com/tas/hr181329.zip
            // icarus.wad\ic09uv.lmp - http://competn.doom2.net/pub/sda/i-o/icuvlmps.zip

            switch(numspechit)
            {
            case 9: 
              *(params.tmfloorz) = addr;
              break;
            case 10:
              *(params.tmceilingz) = addr;
              break;
              
            default:
              fprintf(stderr, "SpechitOverrun: Warning: unable to emulate"
                              "an overrun where numspechit=%i\n",
                               numspechit);
              break;
            }
          }
          else
          {
            switch(numspechit)
            {
            case 9: 
            case 10:
            case 11:
            case 12:
              params.tmbbox[numspechit-9] = addr;
              break;
            case 13:
              *(params.nofit) = addr;
              break;
            case 14:
              *(params.crushchange) = addr;
              break;

            default:
              lprintf(LO_ERROR, "SpechitOverrun: Warning: unable to emulate"
                                " an overrun where numspechit=%i\n",
                                numspechit);
              break;
            }
          }
        }
      }
    }
    */

    //
    // reject overrun emulation
    //

    // padding the reject table if it is too short
    // totallines must be the number returned by P_GroupLines()
    // an underflow will be padded with zeroes, or a doom.exe z_zone header
    // 
    // e6y
    // reject overrun emulation code
    // It's emulated successfully if the size of overflow no more than 16 bytes.
    // No more desync on teeth-32.wad\teeth-32.lmp.
    // http://www.doomworld.com/vb/showthread.php?s=&threadid=35214

    public static byte[] RejectOverrun(int rejectlump, final byte[] rejectmatrix, int totallines, int numsectors)
    {
      int required;
      byte []newreject;
      byte pad;
      int length=rejectmatrix.length;

      required = (numsectors * numsectors + 7) / 8;

      if (length < required)
      {
        // allocate a new block and copy the reject table into it; zero the rest
        // PU_LEVEL => will be freed on level exit
        newreject = new byte[required];
        System.arraycopy(rejectmatrix, 0, newreject, 0, length);

        // e6y
        // PrBoom 2.2.5 and 2.2.6 padded a short REJECT with 0xff
        // This command line switch is needed for all potential demos 
        // recorded with these versions of PrBoom on maps with too short REJECT
        // I don't think there are any demos that will need it but yes that seems sensible
        // pad = prboom_comp[PC_REJECT_PAD_WITH_FF].state ? 0xff : 0;
        // MAES: obviously we don't need that.
        pad=0;

        Array.setByte(newreject,length,pad);

        // unlock the original lump, it is no longer needed
        //W_UnlockLumpNum(rejectlump);
        rejectlump = -1;

        if (demo_compatibility && PROCESS(OVERFLOW_REJECT))
        {
          ShowOverflowWarning(OVERFLOW_REJECT, (required - length > 16) || (length%4 != 0), "");

          if (EMULATE(OVERFLOW_REJECT))
          {
            // merged in RejectOverrunAddInt(), and the 4 calls to it, here
            unsigned int rejectpad[4] = {
              0,        // size, will be filled in using totallines
              0,        // part of the header of a doom.exe z_zone block
              50,       // DOOM_CONST_PU_LEVEL
              0x1d4a11  // DOOM_CONST_ZONEID
            };
            unsigned int i, pad = 0, *src = rejectpad;
            byte *dest = newreject + length;

            rejectpad[0] = ((totallines*4+3)&~3)+24; // doom.exe zone header size

            // copy at most 16 bytes from rejectpad
            // emulating a 32-bit, little-endian architecture (can't memmove)
            for (i = 0; i < (unsigned int)(required - length) && i < 16; i++) { // 16 hard-coded
              if (!(i&3)) // get the next 4 bytes to copy when i=0,4,8,12
                pad = *src++;
              *dest++ = pad & 0xff; // store lowest-significant byte
              pad >>= 8; // rotate the next byte down
            }
          }
        }

        lprintf(LO_WARN, "P_LoadReject: REJECT too short (%u<%u) - padded\n", length, required);
      }
    }

    //
    // Read Access Violation emulation.
    //

    // C:\>debug
    // -d 0:0
    //
    // DOS 6.22:
    // 0000:0000  (57 92 19 00) F4 06 70 00-(16 00)
    // DOS 7.1:
    // 0000:0000  (9E 0F C9 00) 65 04 70 00-(16 00)
    // Win98:
    // 0000:0000  (9E 0F C9 00) 65 04 70 00-(16 00)
    // DOSBox under XP:
    // 0000:0000  (00 00 00 F1) ?? ?? ?? 00-(07 00)

    #define DOS_MEM_DUMP_SIZE 10

    unsigned char mem_dump_dos622[DOS_MEM_DUMP_SIZE] = {
      0x57, 0x92, 0x19, 0x00, 0xF4, 0x06, 0x70, 0x00, 0x16, 0x00};
    unsigned char mem_dump_win98[DOS_MEM_DUMP_SIZE] = {
      0x9E, 0x0F, 0xC9, 0x00, 0x65, 0x04, 0x70, 0x00, 0x16, 0x00};
    unsigned char mem_dump_dosbox[DOS_MEM_DUMP_SIZE] = {
      0x00, 0x00, 0x00, 0xF1, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00};

    unsigned char *dos_mem_dump = mem_dump_dos622;

    static int GetMemoryValue(unsigned int offset, void *value, int size)
    {
      static int firsttime = true;

      if (firsttime)
      {
        int p, i, val;

        firsttime = false;
        i = 0;

        if ((p = M_CheckParm("-setmem")) && (p < myargc-1))
        {
          if (!strcasecmp(myargv[p + 1], "dos622"))
            dos_mem_dump = mem_dump_dos622;
          if (!strcasecmp(myargv[p + 1], "dos71"))
            dos_mem_dump = mem_dump_win98;
          else if (!strcasecmp(myargv[p + 1], "dosbox"))
            dos_mem_dump = mem_dump_dosbox;
          else
          {
            while (++p != myargc && *myargv[p] != '-' && i < DOS_MEM_DUMP_SIZE)
            {
              M_StrToInt(myargv[p], &val);
              dos_mem_dump[i++] = (unsigned char)val;
            }
          }
        }
      }

      if (value)
      {
        switch (size)
        {
        case 1:
          *((unsigned char*)value) = *((unsigned char*)(&dos_mem_dump[offset]));
          return true;
        case 2:
          *((unsigned short*)value) = *((unsigned short*)(&dos_mem_dump[offset]));
          return true;
        case 4:
          *((unsigned int*)value) = *((unsigned int*)(&dos_mem_dump[offset]));
          return true;
        }
      }

      return false;
    }

    //
    // donut overrun emulation (linedef action #9)
    //

    #define DONUT_FLOORPIC_DEFAULT 0x16
    int DonutOverrun(fixed_t *pfloorheight, short *pfloorpic)
    {
      if (demo_compatibility && PROCESS(OVERFLOW_DONUT))
      {
        ShowOverflowWarning(OVERFLOW_DONUT, 0, "");

        if (EMULATE(OVERFLOW_DONUT))
        {
          if (pfloorheight && pfloorpic)
          {
            GetMemoryValue(0, pfloorheight, 4);
            GetMemoryValue(8, pfloorpic, 2);
            
            // bounds-check floorpic
            if ((*pfloorpic) <= 0 || (*pfloorpic) >= numflats)
            {
              *pfloorpic = MIN(numflats - 1, DONUT_FLOORPIC_DEFAULT);
            }

            return true;
          }
        }
      }

      return false;
    }

    //
    // MissedBackSideOverrun
    //
    int MissedBackSideOverrun(sector_t *sector, seg_t *seg)
    {
      if (demo_compatibility && PROCESS(OVERFLOW_MISSEDBACKSIDE))
      {
        if (seg)
        {
          ShowOverflowWarning(OVERFLOW_MISSEDBACKSIDE, 0,
            "\n\nLinedef %d has two-sided flag set, but no second sidedef",
            seg.linedef.iLineID);
        }
        else
        {
          ShowOverflowWarning(OVERFLOW_MISSEDBACKSIDE, 0, "");
        }

        if (EMULATE(OVERFLOW_MISSEDBACKSIDE))
        {
          if (sector)
          {
            GetMemoryValue(0, &sector.floorheight, 4);
            GetMemoryValue(4, &sector.ceilingheight, 4);
            
            return true;
          }
        }
      }

      return false;
    }

}


package g;

import defines.*;
import doom.event_t;
import doom.gameaction_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: DoomGameInterface.java,v 1.4 2010/12/20 17:15:08 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//   Duh.
// 
//-----------------------------------------------------------------------------

public interface DoomGameInterface {


//
// GAME
//
public void DeathMatchSpawnPlayer (int playernum);

public void InitNew (skill_t skill, int episode, int map);

/** Can be called by the startup code or M_Responder.
    A normal game starts at map 1,
    but a warp test can start elsewhere */
public void DeferedInitNew (skill_t skill, int episode, int map);

public void DeferedPlayDemo (String demo);

/** Can be called by the startup code or M_Responder,
  calls P_SetupLevel or W_EnterWorld. */
public void LoadGame (String name);

public void DoLoadGame ();

/** Called by M_Responder. */
public void SaveGame (int slot, String description);

/** Only called by startup code. */
public void RecordDemo (String name);

public void BeginRecording ();

public void PlayDemo (String name);
public void TimeDemo (String name);
public boolean CheckDemoStatus ();

public void ExitLevel ();
public void SecretExitLevel() ;

public void WorldDone() ;

public void Ticker() ;
public boolean Responder (event_t	ev);

public void ScreenShot() ;

public gameaction_t getGameAction();

public void setGameAction(gameaction_t ga);

public boolean getPaused();

public void setPaused(boolean on);
    
}

package g;

import static data.Defines.VERSION;
import static data.Limits.*;


import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import defines.*;
import doom.DoomStatus;
import utils.C2JUtils;
import w.CacheableDoomObject;
import w.DoomBuffer;
import w.DoomIO;
import w.IReadableDoomObject;
import w.IWritableDoomObject;


/** represents the header of Doom savegame, so that basic info can be checked quickly.
 * 
 *  To load the whole game and check if there are final mistakes, you must go through it all.
 *  Savegames need to be aware of ALL status and context, so maybe they should be inner classes?
 *  
 */


public class DoomSaveGame
        implements CacheableDoomObject, IReadableDoomObject, IWritableDoomObject{
    
    public DoomSaveGame(){
        playeringame=new boolean[MAXPLAYERS];
    }
    
    public String name; // max size SAVEGAMENAME
    public String vcheck;
    // These are for DS
    public int gameskill;
    public int gameepisode;
    public int gamemap;
    public boolean[] playeringame;
    /** what bullshit, stored as 24-bit integer?! */
    public int leveltime;
    // These help checking shit.
    public boolean wrongversion;
    public boolean properend;
   

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        name=DoomBuffer.getNullTerminatedString(buf, SAVESTRINGSIZE);
        vcheck=DoomBuffer.getNullTerminatedString(buf, VERSIONSIZE);
        String vcheckb= ("version "+VERSION);
        // no more unpacking, and report it.
        if (wrongversion = !(vcheckb.equalsIgnoreCase(vcheck))) return;
        gameskill = buf.get(); 
        gameepisode = buf.get();
        gamemap = buf.get();
        
        for (int i=0 ; i<MAXPLAYERS ; i++) 
        playeringame[i] = buf.get()!=0; 

        // load a base level (this doesn't advance the pointer?) 
        //G_InitNew (gameskill, gameepisode, gamemap); 
     
        // get the times 
        int a = C2JUtils.toUnsignedByte(buf.get()); 
        int b = C2JUtils.toUnsignedByte(buf.get());
        int c =  C2JUtils.toUnsignedByte(buf.get());
        // Quite anomalous, leveltime is stored as a BIG ENDIAN, 24-bit unsigned integer :-S
        leveltime = (a<<16) + (b<<8) + c; 

        // Mark this position...
        buf.mark();
        buf.position(buf.limit()-1);
        if (buf.get() != 0x1d) properend=false; else
            properend=true;
        buf.reset();
            
        // We've loaded whatever consistutes "header" info, the rest must be unpacked by proper
        // methods in the game engine itself.
    }
    
   
    @Override
    public void write(DataOutputStream f)
            throws IOException {
        DoomIO.writeString(f,name,SAVESTRINGSIZE);
        DoomIO.writeString(f,vcheck,VERSIONSIZE);
        f.writeByte(gameskill); 
        f.writeByte(gameepisode);
        f.writeByte(gamemap);
        for (int i=0 ; i<MAXPLAYERS ; i++) 
        f.writeBoolean(playeringame[i]); 

        // load a base level (this doesn't advance the pointer?) 
        //G_InitNew (gameskill, gameepisode, gamemap); 
     
        // get the times 
        byte a = (byte) (0x0000FF&(leveltime>>>16)); 
        byte b = (byte) (0x00FF&(leveltime>>>8));
        byte c =  (byte) (0x00FF&(leveltime));
        // Quite anomalous, leveltime is stored as a BIG ENDIAN, 24-bit unsigned integer :-S
        f.writeByte(a);
        f.writeByte(b);
        f.writeByte(c);
        
        // TODO: after this point, we should probably save some packed buffers representing raw state...
        // needs further study.

        // The end.
        f.writeByte(0x1d);
            
    } 
    
    @Override
    public void read(DataInputStream f)
            throws IOException {
        name=DoomIO.readNullTerminatedString(f,SAVESTRINGSIZE);
        vcheck=DoomIO.readNullTerminatedString(f,VERSIONSIZE);
        String vcheckb= ("version "+VERSION);
        // no more unpacking, and report it.
        if (wrongversion = !(vcheckb.equalsIgnoreCase(vcheck))) return;
        gameskill = f.readByte(); 
        gameepisode = f.readByte();
        gamemap = f.readByte();
        playeringame=new boolean[MAXPLAYERS];
        for (int i=0 ; i<MAXPLAYERS ; i++) 
        playeringame[i] = f.readBoolean(); 

        // load a base level (this doesn't advance the pointer?) 
        //G_InitNew (gameskill, gameepisode, gamemap); 
     
        // get the times 
        int a = f.readUnsignedByte(); 
        int b = f.readUnsignedByte();
        int c =  f.readUnsignedByte();
        // Quite anomalous, leveltime is stored as a BIG ENDIAN, 24-bit unsigned integer :-S
        leveltime = (a<<16) + (b<<8) + c; 

        // Mark this position...
        //long mark=f.getFilePointer();
        //f.seek(f.length()-1);
        //if (f.readByte() != 0x1d) properend=false; else
        //    properend=true;
        //f.seek(mark);
            
        long available=f.available();
        f.skip(available-1);
        if (f.readByte() != 0x1d) properend=false; else
            properend=true;
        
        // We've loaded whatever consistutes "header" info, the rest must be unpacked by proper
        // methods in the game engine itself.
        
    } 

     public void toStat(DoomStatus DS){
         System.arraycopy(this.playeringame, 0, DS.playeringame, 0, this.playeringame.length);
         DS.gameskill=skill_t.values()[this.gameskill];
         DS.gameepisode=this.gameepisode;
         DS.gamemap=this.gamemap;
         DS.leveltime=this.leveltime;        
         
     }
     
     public void fromStat(DoomStatus DS){
         System.arraycopy(DS.playeringame, 0, this.playeringame, 0, DS.playeringame.length);
         this.gameskill=DS.gameskill.ordinal();
         this.gameepisode=DS.gameepisode;
         this.gamemap=DS.gamemap;
         this.leveltime=DS.leveltime;        
         
     }

}

package g;

//
//DOOM keyboard definition.
//This is the stuff configured by Setup.Exe.
//Most key data are simple ascii (uppercased).
//
//NOTE: the codes used here are arbitrary, non-system specificm 
//however they must match what's used in the default.cfg files
//and throughout the code. Once the system input barrier has been
//crossed, Doom only understands these codes. It's the job of
//the system-specific interface to produce the correct mappings.


public class Keys {
	public static final char KEY_NULL        = 0;       // null key, triggers nothing

	public static final char KEY_ESCAPE      = 27;
	public static final char KEY_SPACE       = 32;

	public static final char KEY_NUMLOCK     = (0x80+69);
	public static final char KEY_SCROLLLOCK  = (0x80+70);

	public static final char KEY_MINUS       = 45;
	public static final char KEY_EQUALS      = 61;
	public static final char KEY_BACKSPACE   = 8;
	public static final char KEY_TAB         = 9;
	public static final char KEY_ENTER       = 13;

	//
	//  scancodes 71-83 (non-extended)
	//
	public static final char KEY_KEYPAD7     = (0x80+71);
	public static final char KEY_KEYPAD8     = (0x80+72);
	public static final char KEY_KEYPAD9     = (0x80+73);
	public static final char KEY_MINUSPAD    = (0x80+74);
	public static final char KEY_KEYPAD4     = (0x80+75);
	public static final char KEY_KEYPAD5     = (0x80+76);
	public static final char KEY_KEYPAD6     = (0x80+77);
	public static final char KEY_PLUSPAD     = (0x80+78);
	public static final char KEY_KEYPAD1     = (0x80+79);
	public static final char KEY_KEYPAD2     = (0x80+80);
	public static final char KEY_KEYPAD3     = (0x80+81);
	public static final char KEY_KEYPAD0     = (0x80+82);
	public static final char KEY_KPADDEL     = (0x80+83);

	//  windows95 keys...

	public static final char KEY_LEFTWIN     = (0x80+91);
	public static final char KEY_RIGHTWIN    = (0x80+92);
	public static final char KEY_MENU        = (0x80+93);

	//
	//  scancodes 71-83 EXTENDED are remapped
	//  to these by the keyboard handler (just add 30)
	//
	public static final char KEY_KPADSLASH   = (0x80+100);      //extended scancode 53 '/' remapped

	public static final char KEY_HOME        = (0x80+101);
	public static final char KEY_UPARROW     = (0x80+102);
	public static final char KEY_PGUP        = (0x80+103);
	public static final char KEY_LEFTARROW   = (0x80+105);
	public static final char KEY_RIGHTARROW  = (0x80+107);
	public static final char KEY_END         = (0x80+109);
	public static final char KEY_DOWNARROW   = (0x80+110);
	public static final char KEY_PGDN        = (0x80+111);
	public static final char KEY_INS         = (0x80+112);
	public static final char KEY_DEL         = (0x80+113);


	public static final char KEY_F1          = (0x80+0x3b);
	public static final char KEY_F2          = (0x80+0x3c);
	public static final char KEY_F3          = (0x80+0x3d);
	public static final char KEY_F4          = (0x80+0x3e);
	public static final char KEY_F5          = (0x80+0x3f);
	public static final char KEY_F6          = (0x80+0x40);
	public static final char KEY_F7          = (0x80+0x41);
	public static final char KEY_F8          = (0x80+0x42);
	public static final char KEY_F9          = (0x80+0x43);
	public static final char KEY_F10         = (0x80+0x44);
	public static final char KEY_F11         = (0x80+0x57);
	public static final char KEY_F12         = (0x80+0x58);

	public static final char KEY_PAUSE       = 255;

	// these ones must be non-extended scancodes (rctrl,rshift,lalt)
	public static final char KEY_SHIFT       = (0x80+54);
	public static final char KEY_CTRL        = (0x80+29);
	public static final char KEY_ALT         = (0x80+56);

	public static final char KEY_CAPSLOCK    = (0x80+58);
	public static final char KEY_CONSOLE     = (int)'`';

//	public static final char KEY_OPENBRACKETS
//	public static final char KEY_CLOSEBRACKETS

}
package testers;

import m.VarsManager;

public class TestSettingsManager {

    public static void main(String argv[]){
    
        VarsManager SM=new VarsManager();
        SM.LoadDefaults("default.cfg");
        
        System.out.println(SM.getSetting("use_mouse").getBoolean());
        
        SM.putSetting("jump_height", "56", false);
        
        System.out.println(SM.getSetting("jump_height").getInteger());
        
        System.out.println(SM.getSetting("use_mouse").getBoolean());
        
        SM.putSetting("crap_setting", "false", true);
        
        System.out.println(SM.getSetting("crap_setting").getInteger());
        System.out.println(SM.getSetting("key_left").getChar());
        
        SM.SaveDefaults("default.cfg");

        
    }
}

package testers;

import java.io.File;
import java.io.FileOutputStream;

import s.DMXSound;
import s.DSP;
import w.WadLoader;

public class LinearSoundInterpolation {
    
    public static void main(String[] argv) throws Exception{

        
        WadLoader W=new WadLoader();
        W.InitMultipleFiles(new String[]{"c:\\iwads\\doom1.wad"});
        
        int sfxlump = W.GetNumForName("dspistol");
        
        DMXSound dmx= W.CacheLumpNum(sfxlump, 0, DMXSound.class);
        
        File out=new File("original.raw");
        FileOutputStream fos=new FileOutputStream(out);
        fos.write(dmx.data);
        fos.close();
        
        fos=new FileOutputStream("linear.raw");
        
        // KRUDE
        if (dmx.speed==11025){
             //Plain linear interpolation.
            dmx.data=DSP.crudeResample(dmx.data,2);
            //DSP.filter(dmx.data,SAMPLERATE, SAMPLERATE/4);
            dmx.datasize=dmx.data.length;            
        }
        
        fos.write(dmx.data);
        fos.close();
        
            }
    
}

package testers;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import w.*;

/** DUMPS a WAD's LUMPS to disk. Any questions?! 
 * 
 */

public class WadDumper {

    public static void main(String[] argv) {
        try {
    IWadLoader W=new WadLoader();
    W.InitMultipleFiles(argv,false);
    BufferedOutputStream bos;
    
    int numlumps=W.NumLumps();
    
    for (int i=0;i<numlumps;i++){
        byte[] crap=W.ReadLump(i);
        String name=W.GetNameForLump(i);
        File f=new File(String.format("%s.lmp",name));
        bos=new BufferedOutputStream(new FileOutputStream(f));
        bos.write(crap);
        bos.close();        
        }

    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import pooling.AudioChunkPool;
import s.AudioChunk;

public class TestAudioChunkPooling {
    public static final int TESTS=10000;
    
    public static void main(String[] argv){
    
    AudioChunk[] chunks=new AudioChunk[TESTS];
    AudioChunkPool chunkpool=new AudioChunkPool();
    
    long a=System.nanoTime();
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=new AudioChunk();
    }

    for (int i=0;i<TESTS;i++){
        chunks[i]=new AudioChunk();
    }
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=new AudioChunk();
    }
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=new AudioChunk();
    }
    long b=System.nanoTime();
    
    System.out.println("Time: "+(float)(b-a)/1000000000f);
    
    a=System.nanoTime();
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=chunkpool.checkOut();
    }

    for (int i=0;i<TESTS;i++){
        chunkpool.checkIn(chunks[i]);
        chunks[i]=chunkpool.checkOut();
    }
    
    for (int i=0;i<TESTS;i++){
        chunkpool.checkIn(chunks[i]);
        chunks[i]=chunkpool.checkOut();
    }
    
    for (int i=0;i<TESTS;i++){
        chunkpool.checkIn(chunks[i]);
        chunks[i]=chunkpool.checkOut();
    }
    b=System.nanoTime();
    
    System.out.println("Time: "+(float)(b-a)/1000000000f);
    
    
    }
    

}

package testers;

import java.nio.ByteBuffer;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;

import s.SpeakerSound;

import w.WadLoader;

import defines.GameMission_t;
import doom.DoomStatus;

public class TestSpeakerSound {
    
    
    public static void main(String[] argv) throws Exception {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"C:\\iwads\\doom1.wad"});

    SpeakerSound sp=(SpeakerSound) W.CacheLumpName("DPSAWUP", 0, SpeakerSound.class);
    
    byte[] stuff=sp.toRawSample();
    
    AudioFormat format = new AudioFormat(11025,8,1,false,true);
    
    DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
    
    SourceDataLine line=null;

    if (AudioSystem.isLineSupported(info))
        try {
            line=  (SourceDataLine) AudioSystem.getSourceDataLine(format);
            line.open(format);
        } catch (Exception e){
            e.printStackTrace();
            System.err.print( "Could not play signed 16 data\n");
        }

        if (line!=null) System.err.print(" configured audio device\n" );
        line.start();
        line.write(stuff, 0,stuff.length);
        line.drain();
    
    Thread.sleep(1000);
    }
}

package testers;

import static data.Defines.PU_STATIC;
import hu.HU;

import java.nio.ByteBuffer;

import m.FixedFloat;

import rr.patch_t;
import rr.vertex_t;

import data.mapvertex_t;
import defines.*;
import doom.DoomContext;
import doom.DoomStatus;

import utils.C2JUtils;
import w.*;

/** This is a very simple tester for the WadLoader and HU modules.
 *  We use the same exact methods used in the C source code, only
 *  with a more OO approach.
 * 
 * 
 */

public class PatchLoaderTester {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    
    patch_t wall=W.CachePatchName("BAL1d0");
    System.out.println(wall.leftoffset);
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import static data.Defines.PU_STATIC;
import hu.HU;

import java.nio.ByteBuffer;

import m.FixedFloat;

import rr.vertex_t;

import data.mapvertex_t;
import defines.*;
import doom.DoomContext;
import doom.DoomStatus;

import utils.C2JUtils;
import w.*;

/** This is a very simple tester for the WadLoader and HU modules.
 *  We use the same exact methods used in the C source code, only
 *  with a more OO approach.
 * 
 * 
 */

public class WadCoalescerTester {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"/*,"sprite2.wad"*/});
    //W.AddFile("bitter.wad");

    //W.CoalesceMarkedResource("F_START", "F_END",li_namespace.ns_flats);
    //W.CoalesceMarkedResource("S_START", "S_END",li_namespace.ns_sprites);
    
    
    System.out.println("Total lumps read: "+W.numlumps);
    
    for (int i=0;i<W.numlumps;i++){
    	System.out.println(W.lumpinfo[i].name+" "+i);
    }
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import m.DoomRandom;
import m.IRandom;
import s.ClassicDoomSoundDriver;
import s.SpeakerDoomSoundDriver;
import s.SuperDoomSoundDriver;
import data.sounds.sfxenum_t;
import doom.DoomStatus;
import w.WadLoader;

public class TestSuperSound {
	public static void main(String[] argv) throws Exception{

	DoomStatus DS=new DoomStatus();
	
	
	WadLoader W=new WadLoader();
	IRandom RND=new DoomRandom();
	
	DS.W=W;
	DS.RND=RND;
	W.InitMultipleFiles(new String[]{"doom1.wad"});
	
	SuperDoomSoundDriver sound=new SuperDoomSoundDriver(DS,4);
	
	sound.InitSound();
	sound.SetChannels(3);
	
	Thread.sleep(1000);
	//sound.StartSound(1, 127, 127, 127, 0);
	for (int i=0;i<1000;i++){
	    
	    Thread.sleep(1000/35);

	    if (i%10==0) sound.StartSound(sfxenum_t.sfx_plpain.ordinal(), 127, 127, 127, 0);
	    //if (i%50==0) sound.StartSound(sfxenum_t.sfx_barexp.ordinal(), 127, 0, 127, 0);
	    //if (i%35==0) sound.StartSound(sfxenum_t.sfx_plpain.ordinal(), 127, 255, 127, 0);
	    //if (i%71==0) sound.StartSound(sfxenum_t.sfx_oof.ordinal(), 127, 192, 127, 0);
	    sound.UpdateSound();
	    
	    sound.SubmitSound();
	    
	       DS.gametic++;
	}
	sound.ShutdownSound();
	}
	
}

package testers;

import static data.Defines.KEY_F1;
import static data.Defines.PU_STATIC;
import static data.Limits.MAXEVENTS;

import hu.HU;
import i.DoomSystem;
import i.IDoomSystem;
import i.InputListener;

import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import awt.OldAWTDoom;

import rr.patch_t;
import s.DummySoundDriver;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import utils.C2JUtils;
import v.BufferedRenderer;
import v.SimpleRenderer;
import w.DoomBuffer;
import w.WadLoader;
import data.Defines;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import data.Defines.Language_t;
import data.Defines.gamestate_t;
import doom.DoomContext;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for Menu module  */

public class AWTMenuTester {
    public static final int WIDTH=320;
    public static final int HEIGHT=200;
    
    public static void main(String[] argv) {
        try {
        	
    // Create a Wad file loader.
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    
    System.out.println("Total lumps read: "+W.numlumps);
    patch_t help1=W.CachePatchName("TITLEPIC", PU_STATIC);

    // Read the paletter.
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    // Create a video renderer
    BufferedRenderer V=new BufferedRenderer(WIDTH,HEIGHT);
    V.Init();
    byte[] pal=palette.getBuffer().array();
    

    
    IDoomSystem I=new DoomSystem();
    DoomMain DM=new DoomMain();
    // Create the frame.
    OldAWTDoom frame = new OldAWTDoom(DM,V,pal);
    DM.I=I;
    DM.VI=frame;
    DM.S=new DummySoundDriver();
    frame.DM=DM;
    DM.W=W;
    DM.V=V;
    DM.DM=DM;
    HU HU=new HU(DM);
    DM.language=Language_t.english;
    HU.Init();
    DM.HU=HU;
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.gamemode=GameMode_t.shareware;
    DM.wminfo=new wbstartstruct_t();
    // Simulate being in the mid of a level.
    DM.usergame=true;
    DM.gamestate=gamestate_t.GS_LEVEL;
    C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;
   
    IDoomMenu M=DM.M=new Menu(DM);

    M.Init();
    frame.InitGraphics();
    long a=System.nanoTime();
    DM.R.menuactive=true;        
        for (int i=0;i<100000;i++){
            int ba=DM.I.GetTime();
            while (ba-DM.I.GetTime()==0){
                //Don't do that! frame.setVisible(true);
                Thread.sleep(1);               
            }
           frame.GetEvent();
           
           for ( ; DM.eventtail != DM.eventhead ; DM.eventtail = (++DM.eventtail)&(MAXEVENTS-1) )
           {
       	event_t ev = DM.events[DM.eventtail];

            //System.out.println(ev);
            if (ev!=null)
            ((Menu)M).Responder(ev);
           }
            
       
         
        V.DrawPatch(0,0,0,help1);
        M.Ticker();
        M.Drawer();
        DM.gametic++;
        frame.FinishUpdate();
        if (i%100==0){
        	   long b=System.nanoTime();
        	    
        	    System.out.println(i +" frames in " +((b-a)/1e09) +" = "+i/((b-a)/1e09) + " fps");
        }
        System.out.print(frame.processEvents());
        }
            } catch (Exception e){
                e.printStackTrace();
            }
    
    }
    
}

package testers;

import static data.Defines.*;
import static data.Limits.*;
import static m.fixed_t.FRACBITS;

import i.InputListener;

import java.awt.Frame;
import java.awt.GraphicsDevice;
import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import m.DoomRandom;
import p.LevelLoader;
import p.mobj_t;
import st.StatusBar;
import utils.C2JUtils;
import v.BufferedRenderer;
import w.DoomBuffer;
import w.WadLoader;
import automap.DoomAutoMap;
import automap.Map;
import data.Defines;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import data.Defines.skill_t;
import doom.DoomContext;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;
import doom.weapontype_t;

/** This is a very simple tester for the Automap. Combined with status bar + Level loader. */

public class AutoMapTester3 {
    
    public static final int WIDTH=320;

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);

    
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();
    BufferedRenderer V=new BufferedRenderer(WIDTH,200);
    V.Init();
    BufferedImage bi=new BufferedImage(V.getWidth(),V.getHeight(),BufferedImage.TYPE_INT_RGB);
    V.setPalette(pal);
    V.mapInternalRasterToBufferedImage(bi);
    
    DoomStatus ds = new DoomStatus();
    ds.gameepisode=1;
    ds.gamemap=1;
    ds.gamemission=GameMission_t.doom;
    ds.gamemode=GameMode_t.shareware;
    ds.wminfo=new wbstartstruct_t();
    C2JUtils.initArrayOfObjects(ds.players,player_t.class);
    Defines.SCREENWIDTH=WIDTH;
    Defines.SCREENHEIGHT=200;
    
    DoomContext DC=new DoomContext();
    DC.DS=ds;
    DC.W=W;
    DC.V=V;
    DC.RND=new DoomRandom();
    ds.players[0].cmd=new ticcmd_t();
    ds.players[0].itemcount=1337;
    ds.players[0].killcount=1337;
    ds.players[0].secretcount=1337;
    ds.players[0].weaponowned[0]=true;
    ds.players[0].weaponowned[1]=true;
    ds.players[0].weaponowned[2]=true;
    ds.players[0].weaponowned[3]=true;
    ds.players[0].readyweapon=weapontype_t.wp_pistol;
    ds.players[0].health[0]=100;
    ds.players[0].armorpoints[0]=100;
    ds.players[0].ammo[0]=400;
    ds.players[0].maxammo[0]=400;
    ds.players[0].ammo[1]=100;
    ds.players[0].maxammo[1]=100;
    ds.players[0].ammo[2]=100;
    ds.players[0].maxammo[2]=100;
    ds.players[0].ammo[3]=600;
    ds.players[0].maxammo[3]=600;

    
    ds.players[0].cards[0]=true;
    ds.players[0].cards[2]=true;
    ds.players[0].cards[4]=true;
    ds.players[0].mo=new mobj_t();
    ds.players[0].mo.x=1056<<FRACBITS;
    ds.players[0].mo.y=-3616<<FRACBITS;
    
    ds.players[0].powers[pw_allmap]=100;
    ds.deathmatch=false;
    ds.statusbaractive=true;
    
    ds.wminfo.plyr[0].in=true;
    ds.wminfo.plyr[0].sitems=1337;
    ds.wminfo.plyr[0].skills=1337;
    ds.wminfo.plyr[0].stime=28595;
    ds.wminfo.plyr[0].ssecret=1337;
    ds.playeringame[0]=true;
    ds.wminfo.last=6;
    ds.wminfo.epsd=0;
    ds.wminfo.maxitems=100;
    ds.wminfo.maxkills=100;
    ds.wminfo.maxsecret=100;
    ds.wminfo.partime=28595;

    StatusBar ST=new StatusBar(DC);
    ST.Start();
    LevelLoader PL=new LevelLoader(DC);
    PL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    DC.LL=PL;
    DC.ST=ST;
    DoomAutoMap AM=new Map(DC);
    AM.Start();
    
    ST.Responder(new event_t('i'));
    ST.Responder(new event_t('d'));
    ST.Responder(new event_t('d'));
    ST.Responder(new event_t('t'));
    
    AM.Responder(new event_t(Map.AM_FOLLOWKEY));
    AM.Responder(new event_t(Map.AM_ZOOMOUTKEY));
    AM.Responder(new event_t(Map.AM_GRIDKEY));
    
    CrappyDisplay frame = new CrappyDisplay(bi);
    frame.setTitle("MochaDoom");
    InputListener in = new InputListener();
    frame.addComponentListener(in);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setLocationRelativeTo(null);
    //frame.setUndecorated(true);
    frame.setVisible(true);
    frame.setBounds(frame.getX(), frame.getY(), WIDTH, 240);
    
    
    long a=System.nanoTime();
    int TICKS=10000;
    for (int i=0;i<TICKS;i++){
    if ((i%20)<10)
        AM.Responder(new event_t(Map.AM_ZOOMINKEY));
       else
       AM.Responder(new event_t(Map.AM_ZOOMOUTKEY)); 

    if ((i%25)<12) {
        AM.Responder(new event_t(Map.AM_PANUPKEY));
        AM.Responder(new event_t(Map.AM_PANRIGHTKEY));
    } 
       else {
       AM.Responder(new event_t(Map.AM_PANDOWNKEY));
       AM.Responder(new event_t(Map.AM_PANLEFTKEY));
       }

    
    AM.Ticker();
    AM.Drawer();
    ST.Ticker();
    ST.Drawer(false,true);
    V.changePalette((i/(2000/14))%14);
    V.remap(0);
    frame.update(null);
    /*File outputFile =
        new File(
            "tic"+i+".png");
    ImageIO.write(bi, "PNG", outputFile); */
//    V.takeScreenShot(0, "tic"+i,icm);    
    //AM.Responder(new event_t(Map.AM_PANLEFTKEY));

    }
    
    long b=System.nanoTime();
    
    System.out.println(TICKS +" tics in " +((b-a)/1e09) +" = "+TICKS/((b-a)/1e09) + " fps");
    /*
    V.takeScreenShot(0, "tic1",icm);
    for (int i=20;i<150;i++){
        EL.Ticker();
        EL.Drawer();
        if (i==100){
            ds.players[0].cmd.buttons=1; // simulate attack
            ds.players[0].attackdown=false; // simulate attack
        }
        
        if (i==120){
            ds.players[0].cmd.buttons=1; // simulate attack
            ds.players[0].attackdown=false; // simulate attack
        }
        V.takeScreenShot(0,( "tic"+i),icm);
        } */
       
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
    public static void initFullScreen(GraphicsDevice gd, Frame gf) {
        // initialize the main app frame
        gf = new Frame("Game Frame");
        gf.setUndecorated(true);
        // disable repaint mechanism
        gf.setIgnoreRepaint(true);
        // the next call shows the window
        gd.setFullScreenWindow(gf);
       }
        
    
}

package testers;

import static data.Defines.KEY_F1;
import static data.Defines.PU_STATIC;

import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import utils.C2JUtils;
import v.BufferedRenderer;
import w.DoomBuffer;
import w.WadLoader;
import data.Defines;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import doom.DoomContext;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for the End Level screen drawer.
 * 
 * 
 */

public class MenuVideoTester {

    public static final int WIDTH=320;
    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();

    IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);
    Defines.SCREENWIDTH=WIDTH;
    Defines.SCREENHEIGHT=200;
    BufferedRenderer V=new BufferedRenderer(WIDTH,200,icm);
    V.Init();
    
    IndexColorModel[] icms=new IndexColorModel[pal.length/768];
    BufferedImage[] pals=new BufferedImage[icms.length];
    
    for (int i=0;i<icms.length;i++){
        icms[i]=new IndexColorModel(8, 256,pal, i*768, false);
            pals[i]=new BufferedImage(icms[i],V.screenbuffer[0].getRaster(), false, null);
           }
    
    DoomStatus ds = new DoomStatus();
    ds.gameepisode=1;
    ds.gamemap=1;
    ds.gamemission=GameMission_t.doom;
    ds.gamemode=GameMode_t.shareware;
    ds.wminfo=new wbstartstruct_t();
    C2JUtils.initArrayOfObjects(ds.players,player_t.class);

    DoomContext DC=new DoomContext();
    DC.DS=ds;
    DC.W=W;
    DC.V=V;
    DC.RND=new DoomRandom();
    ds.players[0].cmd=new ticcmd_t();
    ds.players[0].itemcount=1337;
    ds.players[0].killcount=1337;
    ds.players[0].secretcount=1337;
    
    ds.wminfo.plyr[0].in=true;
    ds.wminfo.plyr[0].sitems=1337;
    ds.wminfo.plyr[0].skills=1337;
    ds.wminfo.plyr[0].stime=28595;
    ds.wminfo.plyr[0].ssecret=1337;
    ds.playeringame[0]=true;
    ds.wminfo.last=6;
    ds.wminfo.epsd=0;
    ds.wminfo.maxitems=100;
    ds.wminfo.maxkills=100;
    ds.wminfo.maxsecret=100;
    ds.wminfo.partime=28595;
    JFrame frame = new JFrame("MochaDoom");
    CrappyDisplay shit = new CrappyDisplay(pals);
    frame.add(shit);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setLocationRelativeTo(null);
    //frame.setUndecorated(true);
    frame.setVisible(true);


    frame.setBounds(frame.getX(), frame.getY(), WIDTH, 240);
    IDoomMenu M=new Menu(DC);
    M.Init();
   
    
    for (int i=0;i<20;i++){
        M.Ticker();
        M.Drawer();
        }
   
    V.takeScreenShot(0, "menutic19",icm);
    ds.menuactive=true;        
        for (int i=20;i<150;i++){
            M.Ticker();
            M.Drawer();

            if (i==40){
                M.Responder(new event_t(Defines.KEY_DOWNARROW));
            }

            if (i==60){
                M.Responder(new event_t(Defines.KEY_DOWNARROW));
            }
            
            if (i==80){
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            
            if (i==100){
                M.Responder(new event_t(KEY_F1));
            }
            
            if (i==120){
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            V.takeScreenShot(0,( "menutic"+i),icm);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import rr.patch_t;

import w.*;

/** A tester for loading patches off cached memory and directly from disk,
 *  proving how direct WAD access is possible, too.
 *  Will need to implement reading column pixel data and dumping it into a file somewhat...
 * 
 */

public class DiskPatchReader {

    public static void main(String[] argv) throws Exception {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"C:\\iwads\\doom1.wad"});
    System.out.println("Total lumps read: "+W.numlumps);
   
    System.out.println("Num for WALL00_1: "+W.GetNumForName("WALL00_1"));
    // We prepare a ByteBuffer to receive a "SECTORS" object. Deserializing it is
    // another matter.
    //ByteBuffer bb=W.CacheLumpName("WALL00_1", 0);
    //

    patch_t wall= W.CachePatchName("WALL00_1");
    lumpinfo_t lump= W.GetLumpinfoForName("WALL00_1");
    System.out.println(lump.name);
    System.out.println(lump.position);
    System.out.println(lump.size);
    
    // Now open Doom1.wad standalone...
    //DoomFile f=new DoomFile("doom1.wad","r");
    //patch_t wall1=new patch_t();
    //f.seek(lump.position);
    //wall1.read(f);
    //System.out.println(wall1.height);
    
    System.out.println("Num for HELP1: "+W.GetNumForName("HELP1"));
    //bb=W.CacheLumpName("HELP1", 0);
    patch_t stbar= W.CachePatchName("HELP1");
    System.out.println(stbar.height);
    System.out.println(stbar.width);
    stbar=(patch_t)W.CacheLumpName("HELP1", 0,stbar.getClass());
        }
    
}

package testers;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketTimeoutException;
import java.util.LinkedList;

import n.BasicNetworkInterface;
import doom.DoomContext;
import doom.DoomMain;
import doom.doomdata_t;
import doom.ticcmd_t;

/** Tester for Net included from DW's work
 * 
 * $Log
 *
 */

public class NetTester {
	
	static DoomMain D1, D2;
	static Object synchronizer = new Object();
	
	public static class NetInterfaceTester extends BasicNetworkInterface {
		DoomContext DC;
		
		public NetInterfaceTester(DoomContext DC) {
			super(DC);
			// TODO Auto-generated constructor stub
		}

	  private doomdata_t  sendData = new doomdata_t();
	  private doomdata_t  recvData = new doomdata_t();
		
		@Override  
		public void sendSocketPacket(DatagramSocket ds, DatagramPacket dp) throws IOException {
			DoomMain receiver;
			
			if (DM.consoleplayer == 0) {
				receiver = D2;
			}
			else {
				receiver = D1;
			}
			
			NetInterfaceTester N = (NetInterfaceTester)receiver.DNI;
			N.addReceivedPacket(dp);
			
			sendData.unpack(dp.getData());
			//System.out.println("Player "+DM.consoleplayer+" SENT: "+dataToStr(sendData));
		}
		
		/*class Elem<E> {
			E e;
			E next = null;
			public Elem(E e) {
				this.e = e;
			}
		}
		
		Elem<DatagramPacket> head = new Elem<DatagramPacket>(null);*/
		
		//ArrayList<DatagramPacket> al = new ArrayList<DatagramPacket>();
		LinkedList<DatagramPacket> al = new LinkedList<DatagramPacket>();
		
		public void addReceivedPacket(DatagramPacket dp) {
			synchronized(synchronizer) {
				al.addLast(dp);
			}
		}
		
		@Override  
		public void socketGetPacket(DatagramSocket ds, DatagramPacket dp) throws IOException {
			synchronized(synchronizer) {
				if (al.size() < 1)
					throw new SocketTimeoutException();
				DatagramPacket pop = al.removeFirst();
				dp.setData(pop.getData());
				dp.setLength(pop.getLength());
				dp.setSocketAddress(pop.getSocketAddress());
				
				recvData.unpack(dp.getData());
			}
			
			//System.out.println("Player "+DM.consoleplayer+" RECV: "+dataToStr(recvData));
		}
		
		public String dataToStr(doomdata_t dt) {
			StringBuffer sb = new StringBuffer();
			sb.append("STIC: "+dt.starttic+" NTIC: "+dt.numtics+" CMDS:\r\n");
			for (int i = 0; i < dt.numtics; i++) {
				ticcmd_t tc = dt.cmds[i];
				sb.append("    FMOVE: "+tc.forwardmove+" CONS: "+tc.consistancy+"\r\n");
			}
			return sb.toString();
				
		}
		
	}

	
	public static void main(String[] args) {
		D1=new DoomMain();
	    D1.Init();
	    D1.DNI = new NetInterfaceTester(D1);
	    D1.myargv = new String[] {"", "-net", "1", "localhost"};
	    D1.myargc = D1.myargv.length; // Bump argcount +1 to maintain CheckParm behavior

		D2=new DoomMain();
	    D2.Init();
	    D2.DNI = new NetInterfaceTester(D2);
	    D2.myargv = new String[] {"", "-net", "2", "localhost"};
	    D2.myargc = D2.myargv.length; // Bump argcount +1 to maintain CheckParm behavior

	    new Thread() {
	    	public void run() {
	    	    D1.Start (); 		
	    	}
	    }.start();
	    
	    try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	    
	    new Thread() {
	    	public void run() {
	    	    D2.Start (); 		
	    	}
	    }.start();

	}

}

package testers;

import m.fixed_t;

public class Mul
        implements Operation {

    @Override
    public void invoke(fixed_t a, fixed_t b) {
        a.FixedMul(b);

    }

}

package testers;

import w.*;

/** This is a very simple tester for the End Level screen drawer.
 * 
 * 
 */

public class LumpGetterTester {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"C:\\iwads\\doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    int random;
    int TESTS=10000;
    int[] tests=new int[TESTS];
    int hash;
    
    long a=System.nanoTime();
    for (int i=0;i<TESTS;i++){
        random =(int) (Math.random()*W.numlumps);
        String what=W.lumpinfo[random].name;
        hash=W.lumpinfo[random].hash;
        tests[i] = W.CheckNumForName3(what);
        if (!W.lumpinfo[tests[i]].name.equalsIgnoreCase(what)) System.err.println("Mismatch");
    }
    
    long b=System.nanoTime();
    
    System.out.println(b-a);
           
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import static data.Defines.*;
import static data.Limits.*;
import static m.fixed_t.FRACBITS;

import i.InputListener;

import java.awt.Frame;
import java.awt.GraphicsDevice;
import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import p.Actions;
import p.LevelLoader;
import p.mobj_t;
import st.StatusBar;
import utils.C2JUtils;
import v.BufferedRenderer;
import w.DoomBuffer;
import w.WadLoader;
import automap.DoomAutoMap;
import automap.Map;
import data.Defines;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import data.Defines.skill_t;
import doom.DoomContext;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;
import doom.weapontype_t;

/** This is a very simple tester for the Automap. Combined with status bar + Level loader. */

public class AutoMapTester2 {
    
    public static final int WIDTH=320;

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);

    
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();

    IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);
    Defines.SCREENWIDTH=WIDTH;
    Defines.SCREENHEIGHT=200;
    BufferedRenderer V=new BufferedRenderer(WIDTH,200,icm);
    V.Init();

    IndexColorModel[] icms=new IndexColorModel[palette.getBuffer().limit()/768];
    BufferedImage[] pals=new BufferedImage[icms.length];


    for (int i=0;i<icms.length;i++){
     icms[i]=new IndexColorModel(8, 256,pal, i*768, false);
    }/*
         pals[i]=new BufferedImage(icms[i],V.screenbuffer[0].getRaster(), false, null);
        }*/
    
    pals=V.getBufferedScreens(0, icms);
    
    //=V.getBufferedScreens(0,icm);>= numlumps
    
    DoomMain ds = new DoomMain();
    ds.gameepisode=1;
    ds.gamemap=1;
    ds.gamemission=GameMission_t.doom;
    ds.gamemode=GameMode_t.shareware;
    ds.wminfo=new wbstartstruct_t();
    C2JUtils.initArrayOfObjects(ds.players,player_t.class);

    
    ds.DM=ds;
    ds.W=W;
    ds.V=V;
    ds.RND=new DoomRandom();
    ds.players[0].cmd=new ticcmd_t();
    ds.players[0].itemcount=1337;
    ds.players[0].killcount=1337;
    ds.players[0].secretcount=1337;
    ds.players[0].weaponowned[0]=true;
    ds.players[0].weaponowned[1]=true;
    ds.players[0].weaponowned[2]=true;
    ds.players[0].weaponowned[3]=true;
    ds.players[0].readyweapon=weapontype_t.wp_pistol;
    ds.players[0].health[0]=100;
    ds.players[0].armorpoints[0]=100;
    ds.players[0].ammo[0]=400;
    ds.players[0].maxammo[0]=400;
    ds.players[0].ammo[1]=100;
    ds.players[0].maxammo[1]=100;
    ds.players[0].ammo[2]=100;
    ds.players[0].maxammo[2]=100;
    ds.players[0].ammo[3]=600;
    ds.players[0].maxammo[3]=600;

    
    ds.players[0].cards[0]=true;
    ds.players[0].cards[2]=true;
    ds.players[0].cards[4]=true;
    ds.players[0].mo=new mobj_t();
    ds.players[0].mo.x=1056<<FRACBITS;
    ds.players[0].mo.y=-3616<<FRACBITS;
    
    ds.players[0].powers[pw_allmap]=100;
    ds.deathmatch=false;
    ds.statusbaractive=true;
    
    ds.wminfo.plyr[0].in=true;
    ds.wminfo.plyr[0].sitems=1337;
    ds.wminfo.plyr[0].skills=1337;
    ds.wminfo.plyr[0].stime=28595;
    ds.wminfo.plyr[0].ssecret=1337;
    ds.playeringame[0]=true;
    ds.wminfo.last=6;
    ds.wminfo.epsd=0;
    ds.wminfo.maxitems=100;
    ds.wminfo.maxkills=100;
    ds.wminfo.maxsecret=100;
    ds.wminfo.partime=28595;

    StatusBar ST=new StatusBar(ds);
    ds.ST=ST;
    ST.Start();
    LevelLoader LL=new LevelLoader(ds);
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    ds.LL=LL;
    ds.ST=ST;
    DoomAutoMap AM=new Map(ds);
    ds.AM=AM;
    AM.Start();
    Actions P=new Actions(ds);
    ds.P=P;
    
    ST.Responder(new event_t('i'));
    ST.Responder(new event_t('d'));
    ST.Responder(new event_t('d'));
    ST.Responder(new event_t('t'));
    
    AM.Responder(new event_t(Map.AM_FOLLOWKEY));
    AM.Responder(new event_t(Map.AM_ZOOMOUTKEY));
    AM.Responder(new event_t(Map.AM_GRIDKEY));
    //BufferedImage bi=((BufferedRenderer)V).screenbuffer[0];
    //BufferedImage bi2=((BufferedRenderer)V).cloneScreen(0, icm2);

    CrappyDisplay frame = new CrappyDisplay(pals);
    frame.setTitle("MochaDoom");
    

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setLocationRelativeTo(null);
    //frame.setUndecorated(true);
    frame.setVisible(true);
    frame.setBounds(frame.getX(), frame.getY(), WIDTH, 240);

    
    
    long a=System.nanoTime();
    int TICKS=10000;
    for (int i=0;i<TICKS;i++){
    if ((i%20)<10)
        AM.Responder(new event_t(Map.AM_ZOOMINKEY));
       else
       AM.Responder(new event_t(Map.AM_ZOOMOUTKEY)); 

    if ((i%25)<12) {
        AM.Responder(new event_t(Map.AM_PANUPKEY));
        AM.Responder(new event_t(Map.AM_PANRIGHTKEY));
    } 
       else {
       AM.Responder(new event_t(Map.AM_PANDOWNKEY));
       AM.Responder(new event_t(Map.AM_PANLEFTKEY));
       }

    
    AM.Ticker();
    AM.Drawer();
    ST.Ticker();
    ST.Drawer(false,true);
    frame.setPalette((i/(10000/14))%14);
    frame.processEvents();
    frame.update();
    //frame.update();
    //frame.update(shit.getGraphics());
 
    }
    
    long b=System.nanoTime();
    
    System.out.println(TICKS +" tics in " +((b-a)/1e09) +" = "+TICKS/((b-a)/1e09) + " fps");
    
       
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

/** Tester for bots...heh goodnight.
 * 
 */

import static p.MapUtils.InterceptVector;

import java.awt.Point;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;

import n.BasicNetworkInterface;
import p.divline_t;
import p.intercept_t;
import p.mobj_t;
import rr.line_t;
import rr.sector_t;
import awt.OldAWTDoom;
import b.BotGame;
import b.Reachable;
import b.SearchNode_t;
import b.bot_t;
import b.BotGame.ObjKind;
import b.BotGame.ReachableGroup;
import b.BotGame.SeenNode;
import b.BotPaths.BotPath;
import b.SearchNode_t.BlockingSector;
import defines.card_t;
import doom.DoomContext;
import doom.DoomMain;
import doom.doomdata_t;
import doom.player_t;
import doom.think_t;
import doom.thinker_t;
import doom.ticcmd_t;

public class BotTester {
	static DoomMain D4, D2, D1;
	static Object synchronizer = new Object();
	
	public static class NetInterfaceTester extends BasicNetworkInterface {
		DoomContext DC;
		
		public NetInterfaceTester(DoomContext DC) {
			super(DC);
			// TODO Auto-generated constructor stub
		}

	  private doomdata_t  sendData = new doomdata_t();
	  private doomdata_t  recvData = new doomdata_t();
		
		@Override  
		public void sendSocketPacket(DatagramSocket ds, DatagramPacket dp) throws IOException {
			DoomMain receiver;
			
			if (DM.consoleplayer == 0) {
				receiver = D2;
			}
			else {
				receiver = D4;
			}
			
			NetInterfaceTester N = (NetInterfaceTester)receiver.DNI;
			N.addReceivedPacket(dp);
			
			sendData.unpack(dp.getData());
			//System.out.println("Player "+DM.consoleplayer+" SENT: "+dataToStr(sendData));
		}
		
		/*class Elem<E> {
			E e;
			E next = null;
			public Elem(E e) {
				this.e = e;
			}
		}
		
		Elem<DatagramPacket> head = new Elem<DatagramPacket>(null);*/
		
		//ArrayList<DatagramPacket> al = new ArrayList<DatagramPacket>();
		LinkedList<DatagramPacket> al = new LinkedList<DatagramPacket>();
		
		public void addReceivedPacket(DatagramPacket dp) {
			synchronized(synchronizer) {
				al.addLast(dp);
			}
		}
		
		@Override  
		public void socketGetPacket(DatagramSocket ds, DatagramPacket dp) throws IOException {
			synchronized(synchronizer) {
				if (al.size() < 1)
					throw new SocketTimeoutException();
				DatagramPacket pop = al.removeFirst();
				dp.setData(pop.getData());
				dp.setLength(pop.getLength());
				dp.setSocketAddress(pop.getSocketAddress());
				
				recvData.unpack(dp.getData());
			}
			
			//System.out.println("Player "+DM.consoleplayer+" RECV: "+dataToStr(recvData));
		}
		
		public String dataToStr(doomdata_t dt) {
			StringBuffer sb = new StringBuffer();
			sb.append("STIC: "+dt.starttic+" NTIC: "+dt.numtics+" CMDS:\r\n");
			for (int i = 0; i < dt.numtics; i++) {
				ticcmd_t tc = dt.cmds[i];
				sb.append("    FMOVE: "+tc.forwardmove+" CONS: "+tc.consistancy+"\r\n");
			}
			return sb.toString();
				
		}
		
	}

	public static class DoomMainTester extends DoomMain {
		public player_t playerBot;
		
		public DoomMainTester(String[] args) {
		    this.Init();
		    this.VI = new OldAWTDoom(this,null,null);
		    this.DNI = new NetInterfaceTester(this);
		    this.myargv = args;
		    this.myargc = this.myargv.length; // Bump argcount +1 to maintain CheckParm behavior
		    this.Start();
		    this.bgame.BN.B_InitNodes();
		    playerBot = this.players[0];
		    playerBot.bot = new bot_t(this.bgame, playerBot);
		    playerBot.bot.walkReachable = new Reachable.WalkReachable(bgame, playerBot);
		}
		
		@Override
		public void DoomLoop() {
			System.out.println("Overriding DoomLoop");
		}
	}
	
	public static void testE1L2() {
		DoomMainTester DM=new DoomMainTester(new String[] {"", "-warp", "12"});
		
		line_t unlockLine = findLine(DM, new int[] {489, -1});
		sector_t sec = DM.bgame.BSL.sectorsTaggedBy(unlockLine).get(0);
		sec.ceilingheight = 20709376;

		
		// this this was a bug where a 2nd round bridge was chosen instead of a 1st round in FindReachableNodes
		// So B_Findpath could not find a path
		mobj_t mo = findThing(DM, -2097152, -56623104);
		DM.playerBot.mo.x = 100962571;
		DM.playerBot.mo.y = -19975541;
		
		DM.playerBot.cards[card_t.it_redcard.ordinal()] = true;
		        
		DM.bgame.FindReachableNodes(DM.playerBot);

		SearchNode_t srcNode = DM.bgame.botNodeArray[135][27];
		SearchNode_t destNode = DM.bgame.botNodeArray[58][44];
		ReachableGroup contained = (DM.playerBot.bot.botPaths.nodesContained(srcNode, destNode)); 

		BotPath path = DM.playerBot.bot.botPaths.B_FindPath(srcNode, destNode, DM.playerBot.bot.walkReachable, DM.playerBot.bot.walkReachable, new HashSet<BlockingSector>(), contained);
		assrt(contained != null && path != null);
		///////////////////
		
		
		
		
		
		
		
		
		/*SearchNode_t srcNode = DM.bgame.botNodeArray[135][27];
		SearchNode_t destNode = DM.bgame.botNodeArray[67][19];
		ReachableGroup contained = (DM.playerBot.bot.botPaths.nodesContained(srcNode, destNode)); */


		SeenNode SN = DM.bgame.new SeenNode(DM.playerBot, mo);
		SN.setKind(ObjKind.item);
		SN.findPath();
		
		DM.playerBot.bot.botPaths.B_FindPath(srcNode, destNode, DM.playerBot.bot.walkReachable, DM.playerBot.bot.walkReachable, new HashSet<BlockingSector>(), contained);
		
		ArrayList<SearchNode_t> srcNodes = DM.bgame.BN.findNodesFromPoint(DM.playerBot, new Point(DM.playerBot.mo.x, DM.playerBot.mo.y), DM.playerBot.bot.walkReachable /*finalReach*/);
		//if (srcNodes.size() == 0) // bot is really stuck!
		//	return null;

		ArrayList<SearchNode_t> destNodes = SN.getNodes();
		//if (destNodes.size() == 0) 
		//	return null;
		
		/*boolean contained = false;
		for (SearchNode_t destNode: destNodes) {
			
			//if (reachableNodes.contains(destNode)) {
				for (SearchNode_t srcNode: srcNodes) {
					if (DM.playerBot.bot.botPaths.nodesContained(srcNode, destNode)) {
						contained = true;
					}
				}
		}*/
		
		assrt((SN.path!=null) == (contained!=null) );
		System.out.println("test");

		
	}
	
	public static void testDoomI() {
		testE1L2();
	}
	
	public static void main(String[] args) {
		testDoomI();
		
		// tested with Doom II maps
		D1=new DoomMainTester(new String[] {"", "-warp", "1"});
		D2=new DoomMainTester(new String[] {"", "-warp", "2"});
		D4=new DoomMainTester(new String[] {"", "-warp", "4"});

	    int[] sh = BotGame.shiftDxDy(new Point(25,25), new Point(50,50), 5);
	    assrt(sh[0] == (int)(5/Math.sqrt(2)));
	    assrt(sh[1] == (int)(-5/Math.sqrt(2)));
	    
	    
	    

	    
	    
//	    
//	    //bot should not be able to traverse the two poles at startup of level 02
//	    Point inPoint = new Point(79352584, 120685114);
//	    Point outPoint = new Point(88774769, 121236663);
//	    D2.players[0].mo.x = inPoint.x;
//	    D2.players[0].mo.y = inPoint.y;
//	    LinkedList_t<SearchNode_t> path = new LinkedList_t<SearchNode_t>();
//	    
//		Reachable.WalkReachable wr2 = new Reachable.WalkReachable(D2.bgame, D2.players[0]);
//	    assrt(!D2.bgame.BN.B_FindPath(D2.players[0], outPoint, path, wr2, wr2));
//
//	    // make sure we cant make through the pole with this diagonal way
//	    SearchNode_t node1 = D2.bgame.botNodeArray[35][53];
//	    SearchNode_t node2 = D2.bgame.botNodeArray[36][54];
//	    assrt(!D2.bgame.BN.FindPathReachable(D2.players[0], node1, node2, true));
//	    assrt(!D2.bgame.BN.FindPathReachable(D2.players[0], D2.bgame.BN.nodeToPoint(node1), D2.bgame.BN.nodeToPoint(node2), true));
//	    
//	    // test if the first switch is reachable
//	    line_t switch1 = findLine(D2, new int[] {188, -1}); // special: 102 v1: (80740352, 77594624)
//	    SeenNode snSw1 = D2.bgame.new SeenNode(D2.players[0], switch1);
//	    snSw1.reachable = new Reachable.LineReachable(D2.bgame, D2.players[0], switch1);
//	    assrt(!snSw1.isReachable());
//	    inPoint = new Point(79181929, 81924198);
//	    D2.players[0].mo.x = inPoint.x;
//	    D2.players[0].mo.y = inPoint.y;
//	    assrt(snSw1.isReachable());
//	    
//
//	    
//	    inPoint = new Point(-48443906, 31553733);
//	    line_t switchL4 = findLine(D4, new int[] {317, -1}); // special: 102
//	    SeenNode snSW = D4.bgame.new SeenNode(D4.players[0], switchL4);
//	    snSW.reachable = new Reachable.LineReachable(D4.bgame, D4.players[0], switchL4);
//	    D4.players[0].mo.x = inPoint.x;
//	    D4.players[0].mo.y = inPoint.y;
//	    
//	    assrt(snSW.getNode() != null);
//	    
//	    assrt(snSW.isReachable());
//
//	    
//	    line_t floorL4 = findLine(D4, new int[] {733, -1}); // special: 18
//	    SeenNode snFloor = D4.bgame.new SeenNode(D4.players[0], floorL4);
//	    inPoint = new Point(-111892518, 71522245);
//	    D4.players[0].mo.x = inPoint.x;
//	    D4.players[0].mo.y = inPoint.y;
//	    snFloor.reachable = new Reachable.LineReachable(D4.bgame, D4.players[0], floorL4);
//	    assrt(snFloor.isReachable());
//	    assrt(snFloor.findPath());
//
//	    // in front of teleport
//	    inPoint = new Point(-93134091, 52253824);
//	    D4.players[0].mo.x = inPoint.x;
//	    D4.players[0].mo.y = inPoint.y;
//	    assrt(snFloor.findPath());
//
//	    
//	    line_t exitL4 = findLine(D4, new int[] {757, -1}); // special: 11
//	    SeenNode snExit = D4.bgame.new SeenNode(D4.players[0], exitL4);
//	    inPoint = new Point(-127891116, 86164298);
//	    D4.players[0].mo.x = inPoint.x;
//	    D4.players[0].mo.y = inPoint.y;
//	    snExit.reachable = new Reachable.LineReachable(D4.bgame, D4.players[0], exitL4);
//	    assrt(snExit.isReachable() /*D4.bgame.BN.seenSwitchReachable(D4.players[0], inPoint, exitL4)*/);
//	    assrt(snExit.findPath());
//	    //D4.bgame.BN.B_FindPath(D4.players[0], destPoint, path, walkReach, finalReach)
//
//	    //seems not to work if on the other side of the yellow door (because of the Demon?)
//	    /*inPoint = new Point(-120594720, 85885648);
//	    D4.players[0].mo.x = inPoint.x;
//	    D4.players[0].mo.y = inPoint.y;
//	    assrt(snExit.findPath());*/
//	    
//	    
//		DoomMain D12=new DoomMainTester(new String[] {"", "-warp", "12"});
//		inPoint = new Point(89169710, 117939298);
//		outPoint = new Point(87979765, 108184173);
//		Reachable.WalkReachable wr = new Reachable.WalkReachable(D12.bgame, D12.players[0]);
//		assrt(wr.isReachable(inPoint, outPoint));
//		line_t lineD12 = findLine(D12, new int[] {1053, 1054});
//		lineD12.frontsector.floorheight = 300000;
//		assrt(wr.isReachable(inPoint, outPoint));   // should still be considered as reachable because it is an elevator...
//	    
//	    
//		D2.P.PathTraverse(69206016, 125829120, 67108864, 125829120, 0, null); // seems OK
//		D2.P.PathTraverse(69206015, 125829119, 67108864, 125829120, 0, null); // seems to bug
//		D2.P.PathTraverse(69206017, 125829119, 67108864, 125829120, 0, null); // seems to bug
//
//		// a rare case when changeX and changeY are both true
//		D1.P.PathTraverse(132120575, -56623105, 132120576, -54525952, 0, null); // seems OK
//
//		//D2: Bug with Pathtraverse: (69206015,125829119) to (67108864,125829120)
//		//D2: Bug with Pathtraverse: (69206017,125829119) to (67108864,125829120)
//		//D2: Seems OK: (69206016,125829120) to (67108864,125829120)
//		
//		//D1: Bug with Pathtraverse: (132120575,-56623105) to (132120576,-54525952)
//	    
//	    traverseTester(D4);
//	    
//	    /*SearchNode_t srcNode = D4.bgame.BN.B_GetNodeAt(-29897546, 44775535,null);
//	    SearchNode_t destNode = D4.bgame.BN.B_GetNodeAt(-27247827, 42609240,null);
//	    LinkedList<intercept_t> q = D4.bgame.QueuePathTraverse(nodeToPoint(D4, srcNode), nodeToPoint(D4, destNode));
//	    assrt(!D4.bgame.BN.FindPathReachable(D4.players[0], srcNode, destNode, true));
//
//	    srcNode.x = 48;
//	    srcNode.y = 13;
//	    destNode.x = 47;
//	    destNode.y = 12;
//	    assrt(!D4.bgame.BN.FindPathReachable(D4.players[0], srcNode, destNode, true));
//
//	    D4.players[0].mo.x = -28202630;
//	    D4.players[0].mo.y = 48802275;
//	    
//	    path = new LinkedList_t<SearchNode_t>();
//	    assrt(!D4.bgame.BN.B_FindPath(D4.players[0], new Point(-28778704, 34686148), path, D4.bgame.BN.walkReachable, D4.bgame.BN.walkReachable)); //should not have a path from "lava" to "step too high"
//	    
//	    for (SearchNode_t sn: path) {
//	    	System.out.println(D4.bgame.BN.nodeInfo(sn));
//	    }*/
//	    
//	    /*new Thread() {
//	    	public void run() {
//	    	    D1.Start (); 		
//	    	}
//	    }.start();
//
//	    try {
//			Thread.sleep(1000);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//	    
//		//D1.bgame.Got_AddBot(0,0);
//
//		/*D2=new DoomMain();
//	    D2.Init();
//	    D2.DNI = new NetInterfaceTester(D2);
//	    D2.myargv = new String[] {"", "-net", "2", "localhost"};
//	    D2.myargc = D2.myargv.length; // Bump argcount +1 to maintain CheckParm behavior
//
//	    new Thread() {
//	    	public void run() {
//	    	    D1.Start (); 		
//	    	}
//	    }.start();
//	    
//	    try {
//			Thread.sleep(1000);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//	    
//	    new Thread() {
//	    	public void run() {
//	    	    D2.Start (); 		
//	    	}
//	    }.start();*/
//	    

	}
	
	public static Point nodeToPoint(DoomMain DM, SearchNode_t node) {
		return new Point(DM.bgame.BN.posX2x(node.x), DM.bgame.BN.posY2y(node.y));
	}
	public static sector_t findSector(DoomMain DM, int id/*int special, int floorheight*/) {
		for (sector_t sec: DM.LL.sectors) {
			if (/*sec.special == special && sec.floorheight == floorheight*/sec.id == id) {
				return sec;
			}
		}
		return null;
	}
	
	public static line_t findLine(DoomMain DM, int[] sidenum /*int special, int floorheight*/) {
		for (line_t line: DM.LL.lines) {
			if (line.sidenum.length == 2 && sidenum[0]==line.sidenum[0] && sidenum[1]==line.sidenum[1]) {
				return line;
			}
		}
		return null;
	}
	
	public static mobj_t findThing(DoomMain DM, int x, int y) {
		thinker_t currentthinker = DM.P.thinkercap.next;
		while (currentthinker != DM.P.thinkercap) // search through the list
													// of all thinkers
		{
			if (currentthinker.function/* .acp1 */== think_t./* (actionf_p1) */P_MobjThinker) {
				mobj_t mo = (mobj_t) currentthinker;
				if (mo.x == x && mo.y == y)
					return mo;
			}
			currentthinker = currentthinker.next;
		}
		return null;
	}

	
	public static  void traverseTester(DoomMain DM) {
		sector_t secLava = findSector(DM, 24);//findSector(DM, 16, -1572864);
		line_t lineLava = findLine(DM, new int[] {111,112});//findSector(DM, 16, -1572864);

		Point p1 = new Point((lineLava.v1x + lineLava.v2x)/2, lineLava.v1y + 10); // in lava sector
		Point p2 = new Point((lineLava.v1x + lineLava.v2x)/2, lineLava.v1y - 10); // on step
		Point p3 = new Point((lineLava.v1x + lineLava.v2x)/2, lineLava.v1y);
		
	    D4.bgame.pointOnLine(p3, lineLava);
	    
	    divline_t trac=new divline_t();
	    trac.x = p1.x;
	    trac.y = p1.y;
	    trac.dx = p2.x-p1.x;
	    trac.dy = p2.y-p1.y;

	    divline_t trac2=new divline_t();
	    trac2.x = p2.x;
	    trac2.y = p2.y;
	    trac2.dx = p1.x-p2.x;
	    trac2.dy = p1.y-p2.y;

	    divline_t dl1 = new divline_t();
	    dl1.MakeDivline(lineLava);
	    
	    InterceptVector(trac, /*new divline_t(lineLava)*/dl1);
	    InterceptVector(trac2, /*new divline_t(lineLava)*/dl1);

	    LinkedList<intercept_t> q = D4.bgame.QueuePathTraverse(p1, p2);
	    assrt(q.size()==1 && q.get(0).line == lineLava);
	    LinkedList<intercept_t> q2 = D4.bgame.CorrectedQueuePathTraverse(p1, p2);
	    assrt(q2.size()==1 && q2.get(0).line == lineLava);

	    LinkedList<intercept_t> q3 = D4.bgame.QueuePathTraverse(p1, p3);
	    assrt(q3.size()==1 && q3.get(0).line == lineLava); // on one side we will see the line
	    LinkedList<intercept_t> q4 = D4.bgame.CorrectedQueuePathTraverse(p1, p3);
	    assrt(q4.size()==1 && q4.get(0).line == lineLava);

	    LinkedList<intercept_t> q5 = D4.bgame.QueuePathTraverse(p3, p1); 
	    assrt(q5.size()==1 && q5.get(0).line == lineLava); 
	    LinkedList<intercept_t> q6 = D4.bgame.CorrectedQueuePathTraverse(p3, p1);
	    assrt(q6.size()==0); // we want to ignore a line that srcPoint is on

	    LinkedList<intercept_t> q7 = D4.bgame.QueuePathTraverse(p2, p1);
	    assrt(q7.size()==1 && q7.get(0).line == lineLava);
	    LinkedList<intercept_t> q8 = D4.bgame.CorrectedQueuePathTraverse(p2, p1);
	    assrt(q8.size()==1 && q8.get(0).line == lineLava);

	    LinkedList<intercept_t> q9 = D4.bgame.QueuePathTraverse(p3, p2);
	    assrt(q9.size()==0 /*&& q9.get(0).line == lineLava*/); //on the other side we don't see the line
	    LinkedList<intercept_t> q10 = D4.bgame.CorrectedQueuePathTraverse(p3, p2);
	    assrt(q10.size()==0);

	    LinkedList<intercept_t> q11 = D4.bgame.QueuePathTraverse(p2, p3);
	    assrt(q11.size()==0 /*&& q11.get(0).line == lineLava*/); //on the other side we don't see the line
	    LinkedList<intercept_t> q12 = D4.bgame.CorrectedQueuePathTraverse(p2, p3);
	    assrt(q12.size()==1 && q12.get(0).line == lineLava); // we want to include the line destPoint is on

	    
	    LinkedList<BlockingSector> bs1 = D4.bgame.TraversedSecLines(p1, p2);
	    assrt(bs1.size() == 1);
	    LinkedList<BlockingSector> bs2 = D4.bgame.TraversedSecLines(p2, p1);
	    assrt(bs2.size() == 1);
	    assrt(bs1.get(0).srcSect == bs2.get(0).destSect);
	    assrt(bs2.get(0).srcSect == bs1.get(0).destSect); // bs1 should be bs2 reversed
	    
	    LinkedList<BlockingSector> bs3 = D4.bgame.TraversedSecLines(p1, p3);
	    assrt(bs3.size() == 1);
	    LinkedList<BlockingSector> bs4 = D4.bgame.TraversedSecLines(p3, p1);
	    assrt(bs4.size() == 0); // because we ignore the lines we start exactly on
	    assrt(bs1.get(0).srcSect == bs3.get(0).srcSect);
	    assrt(bs1.get(0).destSect == bs3.get(0).destSect); //bs3 should be the same as bs1

	}
	static void assrt(boolean b) {
		if (!b) {
			System.out.println("Assert failed");
		}
	}

}

package testers;

import static data.Defines.PU_STATIC;

import i.IDoomSystem;

import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import awt.OldAWTDoom;

import m.DoomRandom;
import s.IDoomSound;
import s.DummySoundDriver;
import utils.C2JUtils;
import v.BufferedRenderer;
import w.DoomBuffer;
import w.WadLoader;
import data.Defines;
import defines.*;
import doom.DoomMain;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;
import f.EndLevel;

/** This is a very simple tester for the End Level screen drawer.
 *  MAES: this is mostly historical. Too many changes have occured
 *  and it's no longer easy to operate stand-alone.
 *  
 *  Edit: well, maybe it is...
 * 
 */

public class EndLevelTester {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();

    IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);
    BufferedRenderer V=new BufferedRenderer(Defines.SCREENWIDTH,Defines.SCREENHEIGHT,icm);
    V.Init();
    
    IndexColorModel[] icms=new IndexColorModel[pal.length/768];
    BufferedImage[] pals=new BufferedImage[icms.length];
    
    for (int i=0;i<icms.length;i++){
        icms[i]=new IndexColorModel(8, 256,pal, i*768, false);
            pals[i]=new BufferedImage(icms[i],V.screenbuffer[0].getRaster(), false, null);
           }
    
    DoomMain DC=new DoomMain();
    DC.DM=DC;
    IDoomSystem I=new i.DoomSystem();
    IDoomSound S=new DummySoundDriver();
    
    DC.S=S;
    DC.I=I;
    DC.gameepisode=1;
    DC.gamemap=1;
    DC.gamemission=GameMission_t.doom;
    DC.gamemode=GameMode_t.shareware;
    DC.wminfo=new wbstartstruct_t();
    C2JUtils.initArrayOfObjects(DC.players,player_t.class);

    
    DC.DM=DC;
    DC.W=W;
    DC.V=V;
    DC.RND=new DoomRandom();
    DC.players[0].cmd=new ticcmd_t();
    DC.players[0].itemcount=1337;
    DC.players[0].killcount=1337;
    DC.players[0].secretcount=1337;
    
    DC.wminfo.plyr[0].in=true;
    DC.wminfo.plyr[0].sitems=1337;
    DC.wminfo.plyr[0].skills=1337;
    DC.wminfo.plyr[0].stime=28595;
    DC.wminfo.plyr[0].ssecret=1337;
    DC.playeringame[0]=true;
    DC.wminfo.last=6;
    DC.wminfo.epsd=0;
    DC.wminfo.maxitems=100;
    DC.wminfo.maxkills=100;
    DC.wminfo.maxsecret=100;
    DC.wminfo.partime=28595;
    //JFrame frame = new JFrame("MochaDoom");
    OldAWTDoom shit = new OldAWTDoom(DC, V, pal);
    shit.InitGraphics();
    
    //frame.setBounds(frame.getX(), frame.getY(), WIDTH, 240);
    EndLevel EL=new EndLevel(DC);
    

   // EL.Start(wbstartstruct);
    int a,b;
    a=I.GetTime();
    b=a;
    for (int i=0;i<2000;i++){
    	
    EL.Ticker();
    EL.Drawer();
    shit.update(shit.getGraphics());
    if (i==100){
            DC.players[0].cmd.buttons=1; // simulate attack
            DC.players[0].attackdown=false; // simulate attack
        }
        
        if (i==120){
            DC.players[0].cmd.buttons=1; // simulate attack
            DC.players[0].attackdown=false; // simulate attack
        }
   // Do we still have time>
        
        while((b-a)==0) {
        	b=I.GetTime();
        	}
       a=b;
    }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;

import p.LevelLoader;

import rr.SimpleTextureManager;
import rr.TextureManager;
import s.DummySoundDriver;
import s.IDoomSound;
import savegame.VanillaDSG;
import savegame.VanillaDSGHeader;

import m.MenuMisc;
import defines.GameMission_t;
import defines.GameMode_t;
import defines.skill_t;
import demo.VanillaDoomDemo;
import doom.DoomMain;
import doom.DoomStatus;
import w.*;

public class SaveGameHeaderTester {

    public static void main(String[] argv) throws Exception {

    ByteBuffer buf=MenuMisc.ReadFile("doomsav0.dsg");
    DoomFile f=new DoomFile("doomsav0.dsg","r");
    DoomStatus DS=new DoomStatus();
    
    VanillaDSGHeader vdsg=new VanillaDSGHeader();
    try {
        vdsg.read(f);
    
    
    f.seek(0);
    
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"C:\\DOOMS\\doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    System.out.println("NUm for E1M1: "+W.GetNumForName("E1M1"));
    DS.gameepisode=1;
    DS.gamemap=1;
    DS.gamemission=GameMission_t.doom;
    DS.setGameMode(GameMode_t.shareware);
    IDoomSound S=new DummySoundDriver();            
    DS.S=S;
    DS.W=W;
    LevelLoader LL=new LevelLoader(DS);
    DS.LL=LL;
    TextureManager TM=new SimpleTextureManager(DS);
    DS.TM=TM;
    LL.updateStatus(DS);
    TM.InitFlats();
    TM.InitTextures();
    
    //HU hu=new HU(DS);
    //hu.Init();
    
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);

    
    VanillaDSG DSG=new VanillaDSG();
    DSG.updateStatus(DS);    
    
    DS.playeringame[0]=true;
    DS.players[0].updateStatus(DS);
    DSG.doLoad(f);
    
    
    //    W.AddFile("bitter.wad");

    System.out.println(vdsg);
    
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }
    
}

package testers;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import javax.imageio.ImageIO;

public class PaletteShower15 {

    public static final int BLOCKSIZE=16;
    public static final int SHIFT=3;
    
    public static void main(String[] argv) {
        try {
    BufferedInputStream bis;
    bis=new BufferedInputStream(new FileInputStream(argv[0]));
    
    int size=bis.available();
    
    int blocks=size/512;
    
    
    byte[] palbuf=new byte[512];
    ByteBuffer bb= ByteBuffer.wrap(palbuf);
    bb.order(ByteOrder.LITTLE_ENDIAN);
    bb.mark();
    for (int i=0;i<blocks;i++){
        bis.read(palbuf);
        
        BufferedImage bim=new BufferedImage(16*BLOCKSIZE,16*BLOCKSIZE,BufferedImage.TYPE_INT_ARGB);
        
            for (int j=0;j<256;j++){
                short shcol=bb.getShort();
                int r=(0x7C00&shcol)>>10;
                int g=(0x3E0&shcol)>>5;
                int b=(0x01F&shcol);
                System.out.printf("%x %d %d %d\n",shcol,r,g,b);
                int colo=  0xFF000000|(r<<(16+SHIFT))|
                            (g<<(8+SHIFT))|
                            (b<<SHIFT);
            
            for (int x=0;x<BLOCKSIZE;x++){
                for (int y=0;y<BLOCKSIZE;y++){
                    bim.setRGB(BLOCKSIZE*(j%16)+x, BLOCKSIZE*(j/16)+y, colo);
                }
            }
            
        }
        
        FileOutputStream f=new FileOutputStream(String.format("%s-%d.PNG",argv[0],i));
        
        ImageIO.write(bim,"PNG",f);
        bb.reset();
        }
    
        bis.close();
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import p.LevelLoader;
import rr.UnifiedRenderer;
import utils.C2JUtils;
import w.WadLoader;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import data.Defines.skill_t;
import doom.DoomContext;
import doom.DoomStatus;
import doom.player_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for the WadLoader and HU modules.
 *  We use the same exact methods used in the C source code, only
 *  with a more OO approach.
 * 
 * 
 */

public class RenderDataLoader {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    System.out.println("Total lumps read: "+W.numlumps);

    DoomStatus ds = new DoomStatus();
    ds.gameepisode=1;
    ds.gamemap=1;
    ds.gamemission=GameMission_t.doom;
    ds.gamemode=GameMode_t.shareware;
    ds.wminfo=new wbstartstruct_t();
    C2JUtils.initArrayOfObjects(ds.players,player_t.class);
    DoomContext DC=new DoomContext();
    DC.DS=ds;
    DC.W=W;
    
    LevelLoader LL=new LevelLoader(DC);
    DC.LL=LL;
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    
    
    
    UnifiedRenderer RD=new UnifiedRenderer(DC);
    RD.InitData();
    RD.RenderPlayerView(ds.players[0]);
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import m.FixedFloat;
import m.fixed_t;
import static m.fixed_t.*;

class FPTest{         
public static final int PRECISION=16;

    public static void main(String argv[])
{
        
    byte aa=(byte) 129;
        
    fixed_t a=new fixed_t(0x8FFF0000);
    fixed_t b=new fixed_t(0xFFFFFFFF);
    
   // a=F2F(32393.244141f);
   // b=F2F(2.5f);
    
    /*System.out.println(Integer.toHexString(a.val));
    System.out.println(Integer.toHexString(b.val));
    System.out.println(FixedFloat.toFloat(a.val));
    System.out.println(FixedFloat.toFloat(b.val));

    System.out.println(FixedFloat.toDouble(a.val));
    System.out.println(FixedFloat.toDouble(b.val));*/

    int c=FixedFloat.toFixed(2.512344f);
    System.out.println(Integer.toHexString(c));
    System.out.println(FixedFloat.toFloat(c));
    System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(FixedFloat.toFloat(c))));

    int d=FixedFloat.toFixed(32768.0125d);
    int e=FixedFloat.toFixed(Double.NEGATIVE_INFINITY);
    int f=FixedFloat.toFixed(-2.5123d);
    System.out.println(FixedFloat.toFloat(d));
    System.out.println(FixedFloat.toFloat(e));
    System.out.println(FixedFloat.toFloat(f));
    
    System.out.println(FixedFloat.toDouble(d));
    System.out.println(FixedFloat.toDouble(e));
    System.out.println(FixedFloat.toDouble(f));
    
    int g=FixedFloat.toFixed(10.0);
    int h=FixedFloat.toFixed(3.0);
    System.out.println(FixedFloat.toFloat(FixedDiv(g,h)));
    
    //System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(FixedFloat.toDouble(c))));

    /*
    fixed_t.FixedMul(a,b,b);    
    System.out.println(Integer.toHexString(b.get()));    

    a=F2F(2.5f);
    b=F2F(2.5f);
    
    
   // a.set(a.val+b.val-(fixed_t.FixedMul(F2F(1.5f),a)).val);
    System.out.println(Integer.toHexString(a.get()));  
    
    a=F2F(10000.0f);
    b=F2F(0.5657f);
    
    System.out.println(Integer.toHexString(a.val));
    System.out.println(Integer.toHexString(b.val));
    
    a=fixed_t.FixedDiv(a,b);
    System.out.println(Integer.toHexString(a.val));
*/
}

public static fixed_t F2F(float f){
    fixed_t tmp;
    int ing;
    float frac;


    ing=(int)Math.floor(f);
    //System.out.println("Int: "+(int)(f));
    //System.out.println("Hex: "+Integer.toHexString(ing));

    //System.out.println("Frac: "+(f-Math.floor(f)));
    //System.out.println("Frac hex: "+Integer.toHexString(FixedDecimal(f)));

    tmp= new fixed_t((ing<<16)|FixedDecimal(f));
    //System.out.println(Integer.toHexString(tmp.val));    
    return tmp;

}

public static char FixedDecimal(float f){
         char fixint_value=0;
         float decimal_part= (float) (f-Math.floor(f));
for ( int i = 1; i <= PRECISION; i++)
{
   if (decimal_part > 1.f/(float)(i + 1.0))
   {
      decimal_part -= 1.f/(float)(i + 1.0);
      fixint_value |= (1 << PRECISION - i);
   }
}
return fixint_value;
}

public static double Value(int fixed){
    double dec=(fixed>>FRACBITS);
    double frac=0;char fixint_value=0;

    for ( int i = FRACBITS; i >=0; i--)
    {
       if (((fixed>>FRACBITS)&(0x0001))==1) {
           frac+=1/(2+(FRACBITS-i));
           }
    }
return (dec+frac);
}


}


package testers;

import i.IVideo;

public class IVideoTester {
public static void main(String argv[]){
	IVideo IV=new IVideo();
	IV.InitExpand();
	IV.InitExpand2();
	IV.InitExpand();
}
}

package testers;

import static data.Defines.KEY_BACKSPACE;
import static data.Defines.KEY_DOWNARROW;
import static data.Defines.KEY_ENTER;
import static data.Defines.KEY_EQUALS;
import static data.Defines.KEY_ESCAPE;
import static data.Defines.KEY_F1;
import static data.Defines.KEY_F10;
import static data.Defines.KEY_F11;
import static data.Defines.KEY_F12;
import static data.Defines.KEY_F2;
import static data.Defines.KEY_F3;
import static data.Defines.KEY_F4;
import static data.Defines.KEY_F5;
import static data.Defines.KEY_F6;
import static data.Defines.KEY_F7;
import static data.Defines.KEY_F8;
import static data.Defines.KEY_F9;
import static data.Defines.KEY_LEFTARROW;
import static data.Defines.KEY_MINUS;
import static data.Defines.KEY_PAUSE;
import static data.Defines.KEY_RALT;
import static data.Defines.KEY_RCTRL;
import static data.Defines.KEY_RIGHTARROW;
import static data.Defines.KEY_RSHIFT;
import static data.Defines.KEY_TAB;
import static data.Defines.KEY_UPARROW;

import i.InputListener;

import java.awt.AWTEvent;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.LinkedList;

import javax.swing.JFrame;

import doom.event_t;
import doom.evtype_t;

public class CrappyDisplay extends JFrame implements KeyListener{

     /**
	 * 
	 */
	private static final long serialVersionUID = 1L;
		Canvas drawhere;
        BufferedImage[] bi;
        int palette=0;
        Dimension size;
        Image crap;
        //InputListener in;
        Graphics2D g2d;

        public CrappyDisplay(BufferedImage[] bi) {
        	this.setBackground(Color.black);
            this.bi=bi;            
            size = new Dimension();
            size.width = bi[0].getWidth();
            size.height = bi[0].getHeight();
            this.setSize(size);
            drawhere=new Canvas();
            drawhere.setSize(size);
            drawhere.setBounds(0, 0, drawhere.getWidth(),drawhere.getHeight());
            drawhere.setBackground(Color.black);            
            this.add(drawhere);
            this.addKeyListener(this);
            //this.addComponentListener(in);
            this.setVisible(true);
            g2d = (Graphics2D)drawhere.getGraphics();
        }
        
        public CrappyDisplay(BufferedImage bi) {
            this.bi=new BufferedImage[]{bi};
            size = new Dimension();
            size.width = bi.getWidth();
            size.height = bi.getHeight();
            this.setSize(size);
            drawhere=new Canvas();
            drawhere.setSize(size);
            drawhere.setBounds(0, 0, drawhere.getWidth(),drawhere.getHeight());
            drawhere.setBackground(Color.black);
            this.add(drawhere);
            
            //in = new InputListener();
            //this.addComponentListener(in);
            this.setVisible(true);
            g2d = (Graphics2D)drawhere.getGraphics();
        }
        
        public void setPalette(int pal){
            this.palette=pal;
            
        }
        
        public void update(Graphics g) {
           
           //Graphics2D g2d = (Graphics2D)drawhere.getGraphics();
           //voli.getGraphics().drawImage(bi,0,0,null);
           g2d.drawImage(bi[palette],0,0,this);
           
        }
        
        public void update() {
            
            Graphics2D g2d = (Graphics2D)drawhere.getGraphics();
            //voli.getGraphics().drawImage(bi,0,0,null);
            g2d.drawImage(bi[palette],0,0,this);
            
         }
        
        public String processEvents(){
            StringBuffer tmp=new StringBuffer();
            event_t event;
            while ( (event=InputListener.nextEvent()) != null ) {
                tmp.append(event.type.ordinal()+"\n");
            }
            return tmp.toString();
        }

        public int xlatekey(KeyEvent e)
        {

          int rc;

          switch(rc =     e.getKeyCode())
          
              //Event.XKeycodeToKeysym(X_display, X_event.xkey.keycode, 0))

          {
            case KeyEvent.VK_LEFT:    rc = KEY_LEFTARROW; break;
            case KeyEvent.VK_RIGHT:   rc = KEY_RIGHTARROW;    break;
            case KeyEvent.VK_DOWN:    rc = KEY_DOWNARROW; break;
            case KeyEvent.VK_UP:  rc = KEY_UPARROW;   break;
            case KeyEvent.VK_ESCAPE:  rc = KEY_ESCAPE;    break;
            case KeyEvent.VK_ENTER:   rc = KEY_ENTER;     break;
            case KeyEvent.VK_TAB: rc = KEY_TAB;       break;
            case KeyEvent.VK_F1:  rc = KEY_F1;        break;
            case KeyEvent.VK_F2:  rc = KEY_F2;        break;
            case KeyEvent.VK_F3:  rc = KEY_F3;        break;
            case KeyEvent.VK_F4:  rc = KEY_F4;        break;
            case KeyEvent.VK_F5:  rc = KEY_F5;        break;
            case KeyEvent.VK_F6:  rc = KEY_F6;        break;
            case KeyEvent.VK_F7:  rc = KEY_F7;        break;
            case KeyEvent.VK_F8:  rc = KEY_F8;        break;
            case KeyEvent.VK_F9:  rc = KEY_F9;        break;
            case KeyEvent.VK_F10: rc = KEY_F10;       break;
            case KeyEvent.VK_F11: rc = KEY_F11;       break;
            case KeyEvent.VK_F12: rc = KEY_F12;       break;
            
            //case Event.BACK_SPACE:
            case KeyEvent.VK_DELETE:  rc = KEY_BACKSPACE; break;

            case KeyEvent.VK_PAUSE:   rc = KEY_PAUSE;     break;

            case KeyEvent.KEY_PRESSED:
                switch(e.getKeyCode()){
            case (KeyEvent.VK_EQUALS): 
                rc = KEY_EQUALS;    
                break;
                
            case KeyEvent.VK_SUBTRACT: 
            case KeyEvent.VK_MINUS:   
                rc = KEY_MINUS;     
                break;

            case KeyEvent.SHIFT_DOWN_MASK:
            rc = KEY_RSHIFT;
            break;
            
            case KeyEvent.CTRL_DOWN_MASK:
            rc = KEY_RCTRL;
            break;                           
           
            case KeyEvent.ALT_DOWN_MASK:
            rc = KEY_RALT;
            break;
            }
                
            default:
            /*if (rc >= KeyEvent.VK_SPACE && rc <= KeyEvent.VK_DEAD_TILDE)
                rc = (int) (rc - KeyEvent.FOCUS_EVENT_MASK + ' ');*/
            if (rc >= KeyEvent.VK_A && rc <= KeyEvent.VK_Z)
                rc = rc-KeyEvent.VK_A +'a';
            break;
          }
          
          System.out.println("Typed "+e.getKeyCode()+" char "+e.getKeyChar()+" mapped to "+Integer.toHexString(rc));

          return rc;

        }

        public void keyPressed(KeyEvent e) {
            if (!((e.getModifiersEx() & InputEvent.ALT_GRAPH_DOWN_MASK) != 0)) {
                addEvent(new event_t(evtype_t.ev_keydown, xlatekey(e)));
            }
        }

        public void keyReleased(KeyEvent e) {
          //  addEvent(new event_t(evtype_t.ev_keyup,xlatekey(e)));
        }

        public void keyTyped(KeyEvent e) {
         /*   if ((e.getModifiersEx() & InputEvent.ALT_GRAPH_DOWN_MASK) != 0) {
                addEvent(new event_t(evtype_t.ev_keydown, xlatekey(e)));
                addEvent(new event_t(evtype_t.ev_keyup, xlatekey(e)));
            } */       
        }
        
        static void addEvent(event_t ev) {
            synchronized (eventQueue) {
                eventQueue.addLast(ev);
            }
        }

        public static event_t nextEvent() {
            event_t ev;
            synchronized (eventQueue) {
                ev = (!eventQueue.isEmpty())?(event_t)eventQueue.removeFirst():null;
            }
            return ev;
        }
        
     // modifications of eventQueue must be thread safe!
        private static LinkedList<event_t> eventQueue = new LinkedList<event_t>();
    
}

package testers;

import static data.Defines.PU_STATIC;
import static data.Limits.MAXEVENTS;
import n.DummyNetworkHandler;

import hu.HU;
import i.DoomSystem;
import i.IDoomSystem;

import p.Actions;
import p.ILevelLoader;
import p.LevelLoader;

import automap.Map;
import awt.AWTDoom;
import rr.ParallelRenderer;
import rr.SimpleTextureManager;
import rr.SpriteManager;
import s.DummySoundDriver;
import st.StatusBar;
import timing.MilliTicker;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import v.BufferedRenderer;
import v.DoomVideoRenderer;
import v.GammaTables;
import v.IVideoScale;
import v.VideoScaleInfo;
import w.DoomBuffer;
import w.WadLoader;
import defines.*;
import data.Tables;
import doom.CommandLine;
import doom.DoomMain;
import doom.event_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for Menu module  */

public class AWTParallelRenderTester1 {

    static IVideoScale VSI=new VideoScaleInfo(4.0f);
    
    public static void main(String[] argv) {
        try {
    
            Tables.InitTables();
            
    // Create a Wad file loader.
    
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    
    System.out.println("Total lumps read: "+W.numlumps);

    // Read the palette.
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    // Create a video renderer
    DoomVideoRenderer V=new BufferedRenderer(VSI.getScreenWidth(),VSI.getScreenHeight());
    V.setVideoScale(VSI);
    V.initScaling();
    V.Init();
    byte[] pal=palette.getBuffer().array();
    V.createPalettes(pal, GammaTables.gammatables, 14, 256, 3, 5);
    

    
    IDoomSystem I=new DoomSystem();
    DoomMain DM=new DoomMain();
    CommandLine CM=new CommandLine(argv);
    DM.CM=CM;
    DM.TICK=new MilliTicker();    
    DM.setVideoScale(VSI);
    DM.initScaling();
    DM.singletics=true;
    DM.setTicdup(1);
    DM.DGN=new DummyNetworkHandler();
    
    // Create the frame.
    AWTDoom frame = new AWTDoom(DM,V);
    frame.InitGraphics();

    DM.I=I;
    DM.VI=frame;
    DM.S=new DummySoundDriver();
    frame.DM=DM;
    DM.W=W;
    DM.V=V;
    DM.DM=DM;
    HU HU=new HU(DM);    
    DM.language=Language_t.english;
    HU.Init();
    DM.HU=HU;
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.setGameMode(GameMode_t.shareware);
    DM.wminfo=new wbstartstruct_t();
    // Simulate being in the mid of a level.
    DM.usergame=true;
    DM.gamestate=gamestate_t.GS_LEVEL;
    DM.gameskill=skill_t.sk_hard;
    //C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;
    
   
    IDoomMenu M=DM.M=new Menu(DM);
    Map AM=new Map(DM);
    DM.AM=AM;
    StatusBar ST=(StatusBar) (DM.ST=new StatusBar(DM));
    ILevelLoader LL=DM.LL=new LevelLoader(DM);
    DM.P=new Actions(DM);
    DM.SM=new SpriteManager(DM);
    DM.R=new ParallelRenderer(DM,2,1);    
    DM.TM=new SimpleTextureManager(DM);    
    DM.P.updateStatus(DM);
    LL.updateStatus(DM);
    M.updateStatus(DM);
    ST.updateStatus(DM);
    AM.updateStatus(DM);
    DM.initializeVideoScaleStuff();
    DM.R.Init();
    DM.P.Init();
    DM.players[0].updateStatus(DM);
    DM.players[0].PlayerReborn();
    
    ST.Init();
    M.Init();
    ST.Start();
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    AM.LevelInit();
    AM.Start();
    
    DM.R.SetViewSize(11, 0);
    DM.R.ExecuteSetViewSize();
    DM.TM.setSkyTexture(DM.TM.CheckTextureNumForName("SKY1"));
    long a=System.nanoTime();
    
    DM.menuactive=false;
    DM.automapactive=true;
    DM.R.FillBackScreen();
    DM.R.DrawViewBorder();
    
    
    // Center on "bloody mess" in E1M1
    DM.players[0].mo.y+=420<<16;
    //DM.players[0].mo.x+=1650<<16;
        int pl=0;
        for (int i=0;i<20000;i++){
   
           frame.GetEvent();
           
           for ( ; DM.eventtail != DM.eventhead ; DM.eventtail = (++DM.eventtail)&(MAXEVENTS-1) )
           {
       	event_t ev = DM.events[DM.eventtail];

            //System.out.println(ev);
            if (ev!=null){
            
            AM.Responder(ev);
            M.Responder(ev);
            ST.Responder(ev);
           }
           }
            
       
           
        //V.DrawPatch(0,0,0,help1);
        //M.Ticker();
        //M.Drawer();
        AM.Ticker();
        //AM.Drawer();
        ST.Ticker();        
        DM.players[0].viewz=(40)<<16;
        //DM.players[0].mo.x=ox+(int) ((12864<<16)*Math.cos(2*Math.PI*i/500.0));
        //DM.players[0].mo.y=oy+(int) ((64<<16)*Math.sin(2*Math.PI*i/500.0));
        //DM.players[0].mo.angle= ((long)(0xFFFFFFFFL*(Math.atan2(DM.players[0].mo.y-oy,DM.players[0].mo.x-ox)+Math.PI)/(2*Math.PI)))&0xFFFFFFFFL;
        DM.players[0].mo.angle=(DM.players[0].mo.angle-0x800000)&0xFFFFFFFFL;
        //System.out.println(">>>>>>>>>>>>>>>>>> VIEW ANGLE "+360.0*(DM.players[0].mo.angle>>19)/8192.0); 
       
        DM.R.RenderPlayerView(DM.players[0]);
        //ST.Drawer(false,true);
        //System.out.println("Rendered"+DM.gametic);
        
        DM.gametic++;
        frame.FinishUpdate();
        if (i%200==0){
        	   long b=System.nanoTime();
        	    //frame.setPalette((pl++)%14);
        	    System.out.println((200) +" frames in " +((b-a)/1e09) +" = "+200/((b-a)/1e09) + " fps");
        	    a=b;
        }
        
       // System.out.print(frame.processEvents());
        /*while (ba-DM.I.GetTime()>-1){
            Thread.sleep(10);               
        }*/
        }
            } catch (Exception e){
                e.printStackTrace();
            }
    
    }
    
}

package testers;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;

import demo.VanillaDoomDemo;
import utils.C2JUtils;
import w.*;

public class JaguarFile {
    
    static final String URI="E://jagdoom/doom.wad";

    public static void main(String[] argv) throws IOException {

    DataInputStream dis=new DataInputStream(new FileInputStream("E://jagdoom/doom.wad"));
    DataOutputStream dos=new DataOutputStream(new FileOutputStream("E://jagdoom/jagdoom.wad"));
        
    wadheader_t header=new wadheader_t();
    header.big_endian=true;
    header.read(dis);
    header.big_endian=false;
    header.write(dos);

    System.out.println(header.type);
    System.out.println(header.numentries);
    System.out.println(header.tablepos);
    
    filelump_t[] stuff=new filelump_t[header.numentries];
    C2JUtils.initArrayOfObjects(stuff);
    
    byte[] data=new byte[header.tablepos-wadheader_t.sizeof()];
    dis.read(data);
    dos.write(data);
        
    int marker=dis.readInt();
    dos.writeInt(marker);
    
    for (filelump_t f:stuff){
        f.big_endian=true;
        f.read(dis);
        System.out.printf("%s %s %d %d %s\n",f.name,f.actualname,f.filepos,f.size,f.compressed);
        f.big_endian=false;
        f.write(dos);
    }
    
    dis.close();
    dos.close();
    
    FileOutputStream fos;
    FileInputStream fis =new FileInputStream("E://jagdoom/doom.wad");
    long size= InputStreamSugar.getSizeEstimate(fis, null);
    
    
    int k=0;
    for (filelump_t f:stuff){
        
        //if (k>2) break;
        k++;
        InputStreamSugar.streamSeek(fis, f.filepos, size, URI, null, InputStreamSugar.FILE);
        byte[] input=new byte[(int) Math.min(f.size,fis.available())];
        byte[] output;
        fis.read(input);
        if (f.compressed){
            System.out.printf("Decompressing %s expecting %d\n",f.actualname,f.size);
            output=new byte[(int) f.size];
            JadDecompress.decode(input, output);            
            fos=new FileOutputStream(
                String.format("E://jagdoom/DEC_%s.lmp",f.actualname));
            } else {
                output=input;
                fos=new FileOutputStream(
                    String.format("E://jagdoom/%s.lmp",f.name));
            }
        fos.write(output);
            }
        
    }
    
}

package testers;

import static data.Defines.KEY_F1;
import static data.Defines.PU_STATIC;
import static data.Limits.MAXEVENTS;

import hu.HU;
import i.DoomSystem;
import i.IDoomSystem;
import i.InputListener;

import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import p.Actions;
import p.LevelLoader;

import automap.Map;
import awt.OldAWTDoom;

import rr.UnifiedRenderer;
import rr.patch_t;
import s.DummySoundDriver;
import st.StatusBar;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import utils.C2JUtils;
import v.BufferedRenderer;
import v.SimpleRenderer;
import w.DoomBuffer;
import w.WadLoader;
import data.Defines;
import defines.*;
import doom.DoomContext;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for Menu module  */

public class AWTAutomapTester {
    public static final int WIDTH=320;
    public static final int HEIGHT=200;
    
    public static void main(String[] argv) {
        try {
        	
    // Create a Wad file loader.
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    
    System.out.println("Total lumps read: "+W.numlumps);
    patch_t help1=W.CachePatchName("TITLEPIC", PU_STATIC);

    // Read the paletter.
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    // Create a video renderer
    BufferedRenderer V=new BufferedRenderer(WIDTH,HEIGHT);
    V.Init();
    byte[] pal=palette.getBuffer().array();
    

    
    IDoomSystem I=new DoomSystem();
    DoomMain DM=new DoomMain();
    // Create the frame.
    OldAWTDoom frame = new OldAWTDoom(DM,V,pal);
    frame.InitGraphics();
    DM.I=I;
    DM.VI=frame;
    DM.S=new DummySoundDriver();
    frame.DM=DM;
    DM.W=W;
    DM.V=V;
    DM.DM=DM;
    DM.language=Language_t.english;
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.gamemode=GameMode_t.shareware;
    DM.wminfo=new wbstartstruct_t();
    // Simulate being in the mid of a level.
    DM.usergame=true;
    DM.gamestate=gamestate_t.GS_LEVEL;
    DM.gameskill=skill_t.sk_hard;
    //C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;
    DM.PlayerReborn(0);
   
    IDoomMenu M=DM.M=new Menu(DM);
    Map AM=(Map) (DM.AM=new Map(DM));
    StatusBar ST=(StatusBar) (DM.ST=new StatusBar(DM));
    LevelLoader LL=DM.LL=new LevelLoader(DM);
    DM.P=new Actions(DM);
    DM.R=new UnifiedRenderer(DM); 
    HU HU=DM.HU=new HU(DM);
    
    DM.P.updateStatus(DM);
    M.updateStatus(DM);
    ST.updateStatus(DM);
    AM.updateStatus(DM);
    HU.updateStatus(DM);
    LL.updateStatus(DM);
    DM.R.Init();
    DM.P.Init();
    HU.Init();
    LL.SetupLevel(1, 2, 0, skill_t.sk_hard);
    ST.Init();
    M.Init();    
    ST.Start();
    AM.LevelInit();
    AM.Start();
    HU.Start();
   // M.StartControlPanel();
    

    long a=System.nanoTime();
    
    DM.menuactive=false;
    DM.automapactive=false;
        for (int i=0;i<100000;i++){
            int ba=DM.I.GetTime();
            while (ba-DM.I.GetTime()==0){
               // Don't do that! frame.setVisible(true);
                Thread.sleep(1);               
            }
           frame.GetEvent();
           
           for ( ; DM.eventtail != DM.eventhead ; DM.eventtail = (++DM.eventtail)&(MAXEVENTS-1) )
           {
       	event_t ev = DM.events[DM.eventtail];

            //System.out.println(ev);
            if (ev!=null){
                AM.Responder(ev);
                M.Responder(ev);
            HU.Responder(ev);
            ST.Responder(ev);
           }
           }
            
       
         
        //V.DrawPatch(0,0,0,help1);
        AM.Ticker();
        AM.Drawer();
        HU.Ticker();
        HU.Drawer();
        ST.Ticker();
        ST.Drawer(false,true);
        M.Ticker();
        M.Drawer();

        DM.gametic++;
        frame.FinishUpdate();
        if (i%100==0){
        	   long b=System.nanoTime();
        	    
        	    System.out.println(i +" frames in " +((b-a)/1e09) +" = "+i/((b-a)/1e09) + " fps");
        }
        System.out.print(frame.processEvents());
        }
            } catch (Exception e){
                e.printStackTrace();
            }
    
    }
    
}

package testers;

import static data.Defines.PU_STATIC;
import static data.Limits.MAXEVENTS;
import n.DummyNetworkHandler;

import hu.HU;
import i.DoomSystem;
import i.IDoomSystem;

import p.Actions;
import p.ILevelLoader;
import p.LevelLoader;

import automap.Map;
import awt.AWTDoom;
import rr.ParallelRenderer2;
import rr.SimpleTextureManager;
import rr.SpriteManager;
import s.DummySoundDriver;
import st.StatusBar;
import timing.MilliTicker;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import v.BufferedRenderer;
import v.DoomVideoRenderer;
import v.GammaTables;
import v.IVideoScale;
import v.VideoScaleInfo;
import w.DoomBuffer;
import w.WadLoader;
import defines.*;
import data.Tables;
import doom.CommandLine;
import doom.DoomMain;
import doom.event_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for Menu module  */

public class AWTParallelRenderTester2 {

    static IVideoScale VSI=new VideoScaleInfo(4.0f);
    
    public static void main(String[] argv) {
        try {
    
            Tables.InitTables();
            
    // Create a Wad file loader.
    
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    
    System.out.println("Total lumps read: "+W.numlumps);

    // Read the palette.
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    // Create a video renderer
    DoomVideoRenderer<?> V=new BufferedRenderer(VSI.getScreenWidth(),VSI.getScreenHeight());
    V.setVideoScale(VSI);
    V.initScaling();
    V.Init();
    byte[] pal=palette.getBuffer().array();
    V.createPalettes(pal, GammaTables.gammatables, 14, 256, 3, 5);
    

    
    IDoomSystem I=new DoomSystem();
    DoomMain DM=new DoomMain();
    CommandLine CM=new CommandLine(argv);
    DM.CM=CM;
    DM.TICK=new MilliTicker();    
    DM.setVideoScale(VSI);
    DM.initScaling();
    DM.singletics=true;
    DM.setTicdup(1);
    DM.DGN=new DummyNetworkHandler();
    
    // Create the frame.
    AWTDoom frame = new AWTDoom(DM,(DoomVideoRenderer<byte[]>) V);
    frame.InitGraphics();

    DM.I=I;
    DM.VI=frame;
    DM.S=new DummySoundDriver();
    frame.DM=DM;
    DM.W=W;
    DM.V=V;
    DM.DM=DM;
    HU HU=new HU(DM);    
    DM.language=Language_t.english;
    HU.Init();
    DM.HU=HU;
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.setGameMode(GameMode_t.shareware);
    DM.wminfo=new wbstartstruct_t();
    // Simulate being in the mid of a level.
    DM.usergame=true;
    DM.gamestate=gamestate_t.GS_LEVEL;
    DM.gameskill=skill_t.sk_hard;
    //C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;
    
   
    IDoomMenu M=DM.M=new Menu(DM);
    Map AM=new Map(DM);
    DM.AM=AM;
    StatusBar ST=(StatusBar) (DM.ST=new StatusBar(DM));
    ILevelLoader LL=DM.LL=new LevelLoader(DM);
    DM.P=new Actions(DM);
    DM.SM=new SpriteManager(DM);
    DM.R=new ParallelRenderer2(DM,2,1); 
    DM.TM=new SimpleTextureManager(DM);
    
    DM.P.updateStatus(DM);
    LL.updateStatus(DM);
    M.updateStatus(DM);
    ST.updateStatus(DM);
    AM.updateStatus(DM);
    DM.initializeVideoScaleStuff();
    DM.R.Init();
    DM.P.Init();
    DM.players[0].updateStatus(DM);
    DM.players[0].PlayerReborn();
    
    ST.Init();
    M.Init();
    ST.Start();
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    AM.LevelInit();
    AM.Start();
    
    DM.R.SetViewSize(11, 0);
    DM.R.ExecuteSetViewSize();
    DM.TM.setSkyTexture(DM.TM.CheckTextureNumForName("SKY1"));
    long a=System.nanoTime();
    
    DM.menuactive=false;
    DM.automapactive=true;
    DM.R.FillBackScreen();
    DM.R.DrawViewBorder();
    
    
    // Center on "bloody mess" in E1M1
    DM.players[0].mo.y+=420<<16;
    //DM.players[0].mo.x+=1650<<16;
        int pl=0;
        for (int i=0;i<20000;i++){
   
           frame.GetEvent();
           
           for ( ; DM.eventtail != DM.eventhead ; DM.eventtail = (++DM.eventtail)&(MAXEVENTS-1) )
           {
       	event_t ev = DM.events[DM.eventtail];

            //System.out.println(ev);
            if (ev!=null){
            
            AM.Responder(ev);
            M.Responder(ev);
            ST.Responder(ev);
           }
           }
            
       
           
        //V.DrawPatch(0,0,0,help1);
        //M.Ticker();
        //M.Drawer();
        AM.Ticker();
        //AM.Drawer();
        ST.Ticker();        
        DM.players[0].viewz=(40)<<16;
        //DM.players[0].mo.x=ox+(int) ((12864<<16)*Math.cos(2*Math.PI*i/500.0));
        //DM.players[0].mo.y=oy+(int) ((64<<16)*Math.sin(2*Math.PI*i/500.0));
        //DM.players[0].mo.angle= ((long)(0xFFFFFFFFL*(Math.atan2(DM.players[0].mo.y-oy,DM.players[0].mo.x-ox)+Math.PI)/(2*Math.PI)))&0xFFFFFFFFL;
        DM.players[0].mo.angle=(DM.players[0].mo.angle-0x800000)&0xFFFFFFFFL;
        //System.out.println(">>>>>>>>>>>>>>>>>> VIEW ANGLE "+360.0*(DM.players[0].mo.angle>>19)/8192.0); 
       
        DM.R.RenderPlayerView(DM.players[0]);
        //ST.Drawer(false,true);
        //System.out.println("Rendered"+DM.gametic);
        
        DM.gametic++;
        frame.FinishUpdate();
        if (i%200==0){
        	   long b=System.nanoTime();
        	    //frame.setPalette((pl++)%14);
        	    System.out.println((200) +" frames in " +((b-a)/1e09) +" = "+200/((b-a)/1e09) + " fps");
        	    a=b;
        }
        
       // System.out.print(frame.processEvents());
        /*while (ba-DM.I.GetTime()>-1){
            Thread.sleep(10);               
        }*/
        }
            } catch (Exception e){
                e.printStackTrace();
            }
    
    }
    
}

package testers;

import static data.SineCosine.*;
import m.FixedFloat;

/** This is a class that tests what happens with BAM angles used in Doom
 *  Normally, they were supposed to be unsigned 32-bit types, mapping
 *  the [0...360) range to a continuum of 32-bit integer values.
 *  
 *  However, in Java we have no unsigned integer type. 
 *  A workaround is to declare angles as ints, and be careful about what operations we perform.
 *  The general rules are:
 *  
 *  a) Angles below ANG180 (1st and 2nd qdt) will compare just fine.
 *  b) Angles in the 3rd and 4th quadrant will compare OK too.
 *  c) However angles from different semiplanes won't compare correctly: they need to be extended to longs.
 *  d) Alternatively, comparisons can be done with a specialized function -> need to benchmark that.
 *  e) Sums and subtractions of angles will work ok with ints, as far as the bit content is concerned. 
 *     When they need to be compared however, the above limitations apply.
 *  f) Multiplications with work OK with either type.
 *  g) Divisions for cumulative angles between 180 and -0.0 degrees will fail due to signs.
 *  g) So, the best thing would be to expand angles to longs and use the extra value range.
 *  
 *  Some benchmark facts:
 *  1) Addition/subtraction between 32-bit and 64-bit operands are, on average, the same speed.
 *  2) Multiplication is twice as fast with 32-bit operands.
 *  2) Casting to int is usually slightly faster than ANDing with a 32-bit mask and storing as long.
 *  3) Using a special method for division between ints can be almost as 1.5x as fast 
 *     than performing long divisions on 32-bit limited numbers.
 *  4) The only thing that's undeliably faster in 64-bit mode are comparisons between "32 bit unsigned"
 *     numbers (5x as fast), and the overall.
 *     
 *     Using 32-bit ints clearly improves memory bandwidth and storage, but makes comparisons problematic.
 *     If most of the angle code consists of additions and comparisons, I'd say keep BAM angles 64-bit.
 *     Using code that's multiplication or division intensive may benefit from 32-bit BAM angles...
 *     eventally code can be locally optimized depending on what's being done.
 *     
 */

public class TestBAM {
    
    
    public final static int PASSES=2;
    public final static int TESTS=5000000;
    public final static int ANG90=0x40000000;
    public final static int ANG180=0x80000000;
    public final static int ANG270=0xC0000000;
    public final static int ANG45=ANG90/2;
    public final static int ANG135=ANG270/2;
    public final static long LANG90=0x40000000;
    public final static long LANG180=0x80000000;
    public final static long LANG270=0xC0000000L;
    public final static long LANG45=LANG90/2;
    public final static long LANG135=LANG270/2;
    public final static long ANGLETOFINESHIFT=19;
    public final static int BITS31=0x7FFFFFFF;
    
    public static void main(String argv[]){
    System.out.println("ANG90>ANG45: "+(ANG90>ANG45));
    System.out.println("LANG180> ANG90 "+ (toLong(ANG180)>ANG90));
    System.out.println("ANG180>ANG90 "+ (ANG180>ANG90)); // this resolves wrong, because ANG180 is "negative" in signed int notation.
    System.out.println("ANG180>ANG90 with GT"+ GT(ANG180,ANG90)); // this resolves wrong, because ANG180 is "negative" in signed int notation.
    System.out.println("ANG270>ANG180 " + (ANG270>ANG180)); // but this resolves correctly, because ANG270 is negative but "larger".
    System.out.println("ANG270>ANG180 " + GT(ANG270,ANG180)); // but this resolves correctly, because ANG270 is negative but "larger".
    System.out.println(ANG45>ANG270); // this resolves wrong, too. It should be false.
    System.out.println((ANG45>toLong(ANG270))); // this resolves wrong, too. It should be false.
    System.out.println((ANG270-ANG45)>ANG180); // this resolves correctly.
    System.out.println("ZILCH "+((ANG270-ANG45)>ANG90)); // this, however, won't.
    System.out.println((0-ANG45)>ANG180); // this resolves correctly too.
    System.out.println((ANG270-ANG180)>ANG45); // correct.
    System.out.println((ANG270-ANG180)==ANG90); // This is true, and correct. 
    System.out.println((ANG270/2)>ANG90); // This won't work, because it will resolve to a negative.
    System.out.println((ANG270/2)>ANG180); // This won't work either.
    System.out.println((toLong(ANG270)/2)>toLong(ANG180)); // Only this will work.
    
    
    System.out.println(ANG45>>ANGLETOFINESHIFT);
    System.out.println(ANG90>>ANGLETOFINESHIFT);
    
    System.out.println("ANG90 mult 3 == ANG270" +GE(ANG90*5,ANG90));
    System.out.println(ANG180*2);
    System.out.println((long)ANG180/2);
    System.out.println(ANG270*2 == ANG180);
    
    
    System.out.println(FixedFloat.toFloat((int) (ANG45>>>ANGLETOFINESHIFT))+" "+finesine[(int) (ANG45>>>ANGLETOFINESHIFT)]);
    System.out.println(FixedFloat.toFloat((int) (ANG270>>>ANGLETOFINESHIFT))+" "+finesine[(int) (ANG270>>>ANGLETOFINESHIFT)]);
    System.out.println(FixedFloat.toFloat((int) ((ANG45*6)>>>ANGLETOFINESHIFT))+" "+finesine[(int) (ANG45*6)>>>ANGLETOFINESHIFT]);
    System.out.println(FixedFloat.toFloat((int) (ANG45>>>ANGLETOFINESHIFT))+" "+finesine[(int) (ANG45>>>ANGLETOFINESHIFT)]);
    System.out.println(FixedFloat.toFloat((int) (ANG270>>>ANGLETOFINESHIFT))+" "+finesine[(int) (ANG270>>>ANGLETOFINESHIFT)]);
    System.out.println(FixedFloat.toFloat((int) ((ANG45*6)>>>ANGLETOFINESHIFT))+" "+finesine[(int) (ANG45*6)>>>ANGLETOFINESHIFT]);
    
    int[] BAM32=new int[TESTS];
    long[] BAM64=new long[TESTS];
    
    for (int i=0;i<TESTS;i++){
        // Keep only 32 bits.
        BAM64[i]=(Double.doubleToLongBits(Math.random())&0xFFFFFFFFL);
        BAM32[i]=(int) (BAM64[i]);
    }

    int errors=0;
    for (int i=0;i<TESTS-1;i++){
        // Keep only 32 bits.
        if ((BAM64[i]<BAM64[i+1])!=(!GE(BAM32[i],BAM32[i+1]))) errors++;
    }

    System.out.println("Comparison Errors "+ errors);
    
    errors=0;
    for (int i=0;i<TESTS-1;i++){
        // Keep only 32 bits.
        if ((int)(BAM64[i]*BAM64[i+1])!=(BAM32[i]*BAM32[i+1])) errors++;
    }

    System.out.println("Multiplication Errors "+ errors);
    
    errors=0;
    
    // Preventing overflow errors is easy.
    for (int i=0;i<TESTS-1;i++){
        // Keep only 32 bits.
        if ((toLong(BAM32[i])/2)!=((BAM64[i]/2)&0x0FFFFFFFFL)) errors++;
    }
    
    System.out.println("Overflow Errors "+ errors);
    
    errors=0;
    for (int i=0;i<TESTS-1;i++){
        // Keep only 32 bits.
        if ((int)(BAM64[i]/BAM64[i+1])!=(BAM32[i]/BAM32[i+1])) errors++;
    }
    
    System.out.println("Division Errors "+ errors);
    
    errors=0;
    for (int i=1;i<TESTS-1;i++){
        // Keep only 32 bits.
        if ((int)(BAM64[i]/i)!=BAMDiv(BAM32[i],i)) errors++;
        //System.out.println(BAMDiv(BAM32[i],i));
    }
    
    System.out.println("Division with BAMDiv Errors "+ errors);
    
    /*for (int i=0;i<tantoangle.length;i++){
        System.out.println(FixedFloat.toFloat(tantoangle[i]));
    }*/
    for (int p=0;p<PASSES;p++){
    timingTests(BAM32,BAM64);
    }
    }

    private static void timingTests(int[] bAM32, long[] bAM64) {
        
        long a,b;
        int errors;
        int results1[]=new int[TESTS];
        int results2[]=new int[TESTS];
        long results3[]=new long[TESTS];
        a=System.nanoTime();
        for (int i=0;i<TESTS-1;i++){
            // Keep only 32 bits.
            results1[i]=bAM32[i]+bAM32[i+1];
            //System.out.println(BAMDiv(BAM32[i],i));
        }
         b=System.nanoTime();
        
        System.out.println("Time for "+TESTS+" 32-bit additions: "+ (b-a));
        
        a=System.nanoTime();
        for (int i=0;i<TESTS-1;i++){
            // Keep only 32 bits.
            results2[i]=(int) (bAM64[i]+bAM64[i+1]);
            //System.out.println(BAMDiv(BAM32[i],i));
        }
        b=System.nanoTime();
        
        System.out.println("Time for "+TESTS+" 64-bit additions (int storage with cast to 32-bit): "+ (b-a));
        
        a=System.nanoTime();
        for (int i=0;i<TESTS-1;i++){
            // Keep only 32 bits.
            results3[i]=(bAM64[i]+bAM64[i+1])&0xFFFFFFFFL;
            //System.out.println(BAMDiv(BAM32[i],i));
        }
        b=System.nanoTime();
        
        System.out.println("Time for "+TESTS+" 64-bit additions (long storage with 32-bit cutoff): "+ (b-a));
        
        errors=0;
        for (int i=1;i<TESTS-1;i++){
            // Keep only 32 bits.
            if (results1[i]!=results2[i]) errors++;
            //System.out.println(BAMDiv(BAM32[i],i));
        }
        
        System.out.println("Errors "+ errors);
        
        a=System.nanoTime();
        for (int i=0;i<TESTS-1;i++){
            // Keep only 32 bits.
            results1[i]=bAM32[i]*bAM32[i+1];
            //System.out.println(BAMDiv(BAM32[i],i));
        }
         b=System.nanoTime();
         
         System.out.println("Time for "+TESTS+" 32-bit multiplications : "+ (b-a));
         
         a=System.nanoTime();
         for (int i=0;i<TESTS-1;i++){
             // Keep only 32 bits.
             results2[i]=(int)(bAM64[i]*bAM64[i+1]);
             //System.out.println(BAMDiv(BAM32[i],i));
         }
          b=System.nanoTime();
          System.out.println("Time for "+TESTS+" 64-bit multiplications (with result cast to int): "+ (b-a));
          
          errors=0;
          for (int i=1;i<TESTS-1;i++){
              // Keep only 32 bits.
              if (results1[i]!=results2[i]) errors++;
              //System.out.println(BAMDiv(BAM32[i],i));
          }
          
          System.out.println("Errors "+ errors);
          
          a=System.nanoTime();
          for (int i=1;i<TESTS-1;i++){
              // Keep only 32 bits.
              results1[i]=BAMDiv(bAM32[i],50);
              //System.out.println(BAMDiv(BAM32[i],i));
          }
           b=System.nanoTime();
           
           System.out.println("Time for "+TESTS+" 32-bit divisions with BAMDiv: "+ (b-a));
           
           a=System.nanoTime();
           for (int i=1;i<TESTS-1;i++){
               // Keep only 32 bits.
               results2[i]=(int)(bAM64[i]/50);
               //System.out.println(BAMDiv(BAM32[i],i));
           }
            b=System.nanoTime();
            System.out.println("Time for "+TESTS+" 64-bit divisions (with result cast to int): "+ (b-a));
            
            errors=0;
            for (int i=1;i<TESTS-1;i++){
                // Keep only 32 bits.
                results1[i]=(GE(bAM32[i],bAM32[i+1])?1:0);
                //System.out.println(BAMDiv(BAM32[i],i));
            }
            
            System.out.println("Time for "+TESTS+" 32-bit comparisons): "+ (b-a));
            
            a=System.nanoTime();
            for (int i=1;i<TESTS-1;i++){
                // Keep only 32 bits.
                results2[i]=(bAM64[i]>=bAM64[i+1]?1:0);
                //System.out.println(BAMDiv(BAM32[i],i));
            }
             b=System.nanoTime();
             System.out.println("Time for "+TESTS+" 64-bit comparisons (with result cast to int): "+ (b-a));
             
             errors=0;
             for (int i=1;i<TESTS-1;i++){
                 // Keep only 32 bits.
                 if (results1[i]!=results2[i]) errors++;
                 //System.out.println(BAMDiv(BAM32[i],i));
             }
             
             System.out.println("Errors "+ errors);
          
          
    }

    public static final long toLong(int a){
        return(0xFFFFFFFFL&a);
    }
 
    /** Compare BAM angles in 32-bit format 
     *  "Greater or Equal" bam0>bam1
     * */
    
    public static final boolean GE(int bam0, int bam1){
        // Handle easy case.
        if (bam0==bam1) return true;
        
        // bam0 is greater than 180 degrees.
        if (bam0<0 && bam1>=0) return true;
        // bam1 is greater than 180 degrees.
        if (bam0>=0 && bam1<0) return false;
        
        // Both "greater than 180", No other way to compare.
        bam0&=BITS31;
        bam1&=BITS31;        
        return bam0>bam1;
    }
    
    public static final boolean GT(int bam0, int bam1){       
        // bam0 is greater than 180 degrees.
        if (bam0<0 && bam1>=0) return true;
        // bam1 is greater than 180 degrees.
        if (bam0>=0 && bam1<0) return false;
        
        // Both "greater than 180", No other way to compare.
        bam0&=BITS31;
        bam1&=BITS31;        
        return bam0>bam1;
    }
    
    public static final int BAMDiv(int bam0, int bam1){       
        // bam0 is greater than 180 degrees.
        if (bam0>=0) return bam0/bam1;
        // bam0 is greater than 180 degrees.
        // We have to make is so that ANG270 0xC0000000 becomes ANG135, aka 60000000
        if (bam1>=0)
        return (int) ((long)(0x0FFFFFFFFL&bam0)/bam1);
        
        return (int) ((long)(0x0FFFFFFFFL&bam0)/(0x0FFFFFFFFL&bam1));
    }
    
}

package testers;

import demo.VanillaDoomDemo;
import w.*;

public class DemoLumpTester {

    public static void main(String[] argv) {

    WadLoader W=new WadLoader();
    try {
		W.InitMultipleFiles(new String[] {"C://DOOMS/e1m1.wad"});
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    System.out.println("NUm for DEMO1: "+W.GetNumForName("DEMO1"));
    VanillaDoomDemo demo=(VanillaDoomDemo) W.CacheLumpName("DEMO1",0,VanillaDoomDemo.class);
    System.out.println(demo);
    
    }
    
}

package testers;

import m.DoomRandom;
import m.IRandom;
import s.ClassicDoomSoundDriver;
import s.SpeakerDoomSoundDriver;
import data.sounds.sfxenum_t;
import doom.DoomStatus;
import w.WadLoader;

public class TestClassicSound {
	public static void main(String[] argv) throws Exception{

	DoomStatus DS=new DoomStatus();
	
	
	WadLoader W=new WadLoader();
	IRandom RND=new DoomRandom();
	
	DS.W=W;
	DS.RND=RND;
	W.InitMultipleFiles(new String[]{"C:\\iwads\\doom1.wad"});
	
	SpeakerDoomSoundDriver sound=new SpeakerDoomSoundDriver(DS,4);
	
	sound.InitSound();
	sound.SetChannels(3);
	
	Thread.sleep(1000);
	//sound.StartSound(1, 127, 127, 127, 0);
	for (int i=0;i<1000;i++){
	    
	    Thread.sleep(1000/35);

	    if (i%10==0) sound.StartSound(sfxenum_t.sfx_plpain.ordinal(), 127, 127, 127, 0);
	    //if (i%50==0) sound.StartSound(sfxenum_t.sfx_barexp.ordinal(), 127, 0, 127, 0);
	    //if (i%35==0) sound.StartSound(sfxenum_t.sfx_plpain.ordinal(), 127, 255, 127, 0);
	    //if (i%71==0) sound.StartSound(sfxenum_t.sfx_oof.ordinal(), 127, 192, 127, 0);
	    sound.UpdateSound();
	    
	    sound.SubmitSound();
	    
	       DS.gametic++;
	}
	sound.ShutdownSound();
	}
	
}

package testers;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import w.WadLoader;

public class TestInvoke {

    /**
     * @param args
     * @throws Exception 

     */
    public static void main(String[] args) throws Exception {
        Method shit=WadLoader.class.getDeclaredMethod("InitFile", String.class);
        Method cunt=WadLoader.class.getDeclaredMethod("LumpLength", int.class);
        Method nothing=WadLoader.class.getDeclaredMethod("Reload",null);
        WadLoader crap=new WadLoader();
        shit.invoke(crap, "~DOOM1.WAD");
        System.out.println(cunt.invoke(crap, 0));
        byte[] ahhh=crap.CacheLumpName("PLAYPAL", 0).getBuffer().array();
        System.out.println(ahhh.length);
        ahhh=crap.CacheLumpName("PLAYPAL", 0).getBuffer().array();
        System.out.println(ahhh.length);
        // This should flush the cache
        nothing.invoke(crap, (Object[])null);
        ahhh=crap.CacheLumpName("PLAYPAL", 0).getBuffer().array();
        System.out.println(ahhh.length);
    }

}

package testers;

import static data.Defines.PU_STATIC;
import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import m.DoomRandom;
import m.IRandom;
import rr.patch_t;
import v.BufferedRenderer;
import w.DoomBuffer;
import w.WadLoader;
import data.Defines;
import doom.DoomMain;
import f.Wiper;

/** This is a very simple tester for the Automap. Combined with status bar + Level loader. */

public class AssWipeTester {
	
	public static int WIDTH=320;

    public static void main(String[] argv) {
        try {
    DoomMain DC=new DoomMain();
    
    WadLoader W=new WadLoader(DC.I);
    
    IRandom RND=new DoomRandom();
    DC.RND=RND;        
    DC.W=W;
    
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);

    BufferedRenderer V=new BufferedRenderer(640,200);   
    DC.V=V;
    
    // Get the palettes
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();
    IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);    
    V.setIcm(icm);
    V.Init();
    
    
    patch_t titlepic=W.CachePatchName("TITLEPIC", PU_STATIC);
    patch_t credit=W.CachePatchName("HELP1", PU_STATIC);
    
    
    

    
    
    Wiper wipe=new Wiper(DC);
    
    Defines.SCREENWIDTH=640;
    Defines.SCREENHEIGHT=200;
    
    
    
    
    // "Hook" on screen 0.
    BufferedImage bi=((BufferedRenderer)V).screenbuffer[0];
    //BufferedImage[] pals=V.getBufferedScreens(0, icms);
    CrappyDisplay frame = new CrappyDisplay(bi);
    frame.setTitle("MochaDoom");
    

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setLocationRelativeTo(null);
    //frame.setUndecorated(true);
    frame.setVisible(true);
    frame.setBounds(frame.getX(), frame.getY(), WIDTH, 240);

    int tck=DC.I.GetTime();
    long a=System.nanoTime();
    int TICKS=10;
    int frames=0;
    for (int i=0;i<TICKS;i++){
        V.DrawPatch(0, 0, 0, titlepic);
        wipe.StartScreen(0, 0, Defines.SCREENWIDTH, Defines.SCREENHEIGHT);
        V.DrawPatch(0, 0, 0, credit);
        wipe.EndScreen(0, 0, Defines.SCREENWIDTH, Defines.SCREENHEIGHT);
        
        int wipestart = DC.I.GetTime () - 1;
        int nowtime;
        int tics;
        boolean done;
        
        patch_t tmp=credit;
        credit=titlepic;
        titlepic=tmp;
    //wipe.ScreenWipe(Wiper.wipe.Melt.ordinal(), 0, 0,  Defines.SCREENWIDTH, Defines.SCREENHEIGHT, TICKS-i);

    //ST.Drawer(false,true);
    //Thread.sleep(200);    
    
    do
    {
    do
    {
        nowtime = DC.I.GetTime ();
        tics = nowtime - wipestart;
    } while (tics<1);
    wipestart = nowtime;
    //V.DrawPatch(0, 0, 0, titlepic);
    //V.DrawPatch(320, 0, 0, titlepic);
    done = wipe.ScreenWipe(Wiper.wipe.Melt.ordinal()
                   , 0, 0, Defines.SCREENWIDTH, Defines.SCREENHEIGHT, tics);
    //I_UpdateNoBlit ();
    //M_Drawer ();                            // menu is drawn even on top of wipes
    //System.out.println(i);
    frame.update(null);
    frames++;
   
    
    } while (!done);
    
    long b=System.nanoTime();
    
    System.out.println(frames +" frames in " +((b-a)/1e09) +" = "+frames/((b-a)/1e09) + " fps");
    
    }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
      
}

package testers;

import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import javax.imageio.ImageIO;

public class PaletteShower {

    public static final int BLOCKSIZE=16;
    public static final int SHIFT=0;
    
    public static void main(String[] argv) {
        try {
    BufferedInputStream bis;
    bis=new BufferedInputStream(new FileInputStream(argv[0]));
    
    int size=bis.available();
    
    int blocks=size/768;
    
    
    byte[] palbuf=new byte[768];
    
    for (int i=0;i<blocks;i++){
        bis.read(palbuf);
        BufferedImage bim=new BufferedImage(16*BLOCKSIZE,16*BLOCKSIZE,BufferedImage.TYPE_INT_ARGB);
        
            /*
             * for (int j=0;j<256;j++){
            int color=  0xFF000000|(palbuf[j]<<(16+SHIFT))|
                        (palbuf[j]<<(8+SHIFT))|
                        (palbuf[j]<<SHIFT); 
                        }
                        */
            for (int j=0;j<256;j++){
                int colo=  0xFF000000|(0xFF0000&palbuf[j*3]<<(16+SHIFT))|
                            (0xFF00&palbuf[1+j*3]<<(8+SHIFT))|
                            (0xFF&palbuf[2+j*3]<<SHIFT);
            
            for (int x=0;x<BLOCKSIZE;x++){
                for (int y=0;y<BLOCKSIZE;y++){
                    bim.setRGB(BLOCKSIZE*(j%16)+x, BLOCKSIZE*(j/16)+y, colo);
                }
            }
            
        }
        
        FileOutputStream f=new FileOutputStream(String.format("%s-%d.PNG",argv[0],i));
        
        ImageIO.write(bim,"PNG",f);
        }
    
        bis.close();
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import static data.SineCosine.finesine;
import static data.Tables.*;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedDiv;
import static m.fixed_t.FixedMul;
import data.Tables;
import m.fixed_t;

public class TestScale {

    private static int detailshift=0;
    private static long rw_normalangle;
    private static long viewangle;
    private static int projection=0xF0000000;
    private static int rw_distance=0xFF000;
    private static final int divs=10;
    private static int viewx=0, viewy=0;
    private static int dist=256*FRACUNIT;
    
    

    public static void main(String[] argv){
        
        int[][] octants={{dist,0},{dist,dist},{0,dist},{-dist,dist},{-dist,0},{-dist,-dist},{0,-dist},{dist,-dist}};
        for (int i=0;i<octants.length;i++){
            long ang = PointToAngle (octants[i][0],octants[i][1]);
            System.out.print((ang*360.0)/0xFFFFFFFFL);            
            System.out.print(" "+(ang>>FRACBITS));
            
            System.out.print(" "+(Long.toHexString(ang)));
            System.out.print(" "+(Long.toBinaryString(ang+(ANG45*9)/2)));
            int rot = (int) (((ang+(ANG45*9)/2)&BITS32)>>29);
            System.out.print(" "+rot+"\n");
            
        }
        
        /*
        long angle=0;
        projection=0;
        int divisions=(int) (0xFFFFFFFFL/divs);
        for (int i=0;i<divs;i++){
                for (int j=0;j<divs;j++){
            System.out.println(i+" "+j+" "+rw_normalangle+" "+viewangle+" "+ScaleFromGlobalAngle(viewangle));
            viewangle+=divisions;
                }
                rw_normalangle+=divisions;
            }*/
        
        }
    
    /**
     * R_ScaleFromGlobalAngle
     * Returns the texture mapping scale
     *  for the current line (horizontal span)
     *  at the given angle.
     * rw_distance must be calculated first.
     */
    
    public static int ScaleFromGlobalAngle (long visangle)
    {
        int         scale; // fixed_t
        int         anglea;
        int         angleb;
        int         sinea;
        int         sineb;
        int         num; // fixed_t
        int         den;

        // UNUSED
    /*
    {
        fixed_t     dist;
        fixed_t     z;
        fixed_t     sinv;
        fixed_t     cosv;
        
        sinv = finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT];   
        dist = FixedDiv (rw_distance, sinv);
        cosv = finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT];
        z = abs(FixedMul (dist, cosv));
        scale = FixedDiv(projection, z);
        return scale;
    }
    */

        anglea = (int) (ANG90 +visangle-viewangle);
        angleb = (int) (ANG90 +visangle-rw_normalangle);

        // both sines are allways positive
        sinea = finesine[anglea>>>ANGLETOFINESHIFT]; 
        sineb = finesine[angleb>>>ANGLETOFINESHIFT];
        num = FixedMul(projection,sineb)<<detailshift;
        den = FixedMul(rw_distance,sinea);

        if (den > num>>16)
        {
        scale = FixedDiv (num, den);

        
        if (scale > 64*FRACUNIT)
            scale = 64*FRACUNIT;
        // Minimum scale.
        else if (scale < 256)
            scale = 256;
        }
        else
        // Top saturation scale
        scale = 64*FRACUNIT;
        
        return scale;
    }
    
    /**
     * R_PointToAngle
     *  To get a global angle from cartesian coordinates,
     *  the coordinates are flipped until they are in
     *  the first octant of the coordinate system, then
     *  the y (<=x) is scaled and divided by x to get a
     *  tangent (slope) value which is looked up in the
     *   tantoangle[] table.
     *   
     *   @param xx (fixed_t)
     *   @param yy (fixed_t)
     */

    public static long
    PointToAngle
    ( int   x,
      int   y )
    {   
        // MAES: note how we don't use &BITS32 here. That is because we know that the maximum possible
        // value of tantoangle is angle
        // This way, we are actually working with vectors emanating from our current position.
        x-= viewx;
        y-= viewy;
        
        if ( (x==0) && (y==0) )
        return 0;

        if (x>= 0)
        {
        // x >=0
        if (y>= 0)
        {
            // y>= 0

            if (x>y)
            {
            // octant 0
            return tantoangle[ SlopeDiv(y,x)];
            }
            else
            {
            // octant 1
            return (ANG90-1-tantoangle[ SlopeDiv(x,y)]);
            }
        }
        else
        {
            // y<0
            y = -y;

            if (x>y)
            {
            // octant 8
            return -tantoangle[SlopeDiv(y,x)];
            }
            else
            {
            // octant 7
            return ANG270+tantoangle[ SlopeDiv(x,y)];
            }
        }
        }
        else
        {
        // x<0
        x = -x;

        if (y>= 0)
        {
            // y>= 0
            if (x>y)
            {
            // octant 3
            return (ANG180-1-tantoangle[ SlopeDiv(y,x)]);
            }
            else
            {
            // octant 2
            return (ANG90+ tantoangle[ SlopeDiv(x,y)]);
            }
        }
        else
        {
            // y<0
            y = -y;

            if (x>y)
            {
            // octant 4
            return (ANG180+tantoangle[ SlopeDiv(y,x)]);
            }
            else
            {
             // octant 5
            return (ANG270-1-tantoangle[ SlopeDiv(x,y)]);
            }
        }
        }
        // This is actually unreachable.
       // return 0;
    }
    

    /** R_PointToDist
     * 
     * @param x fixed_t
     * @param y fixed_t
     * @return
     */
    
    public static int
    PointToDist
    ( int   x,
      int   y )
    {
        int     angle=0;
        int dx;
        int dy;
        int temp;
        int dist;
        
        dx = Math.abs(x - viewx);
        dy = Math.abs(y - viewy);
        
        // Sanity check, else it's going to bomb.
        /* if (dx==0){
            //
            if (dy>0) angle= Tables.toBAMIndex(ANG90);
            else           
            if (dy<0) angle= Tables.toBAMIndex(ANG270);
            else
                      angle= 0;     
        }
        
        else { */
        
        if (dy>dx)
        {
        temp = dx;
        dx = dy;
        dy = temp;
        }
        
        
        /* If both dx and dy are zero, this is going to bomb.
           Fixeddiv will return MAXINT aka 7FFFFFFF, >> DBITS will make it 3FFFFFF,
           addding ANG90 will make if 43FFFFFF and angletofineshi
        */
            
        angle = (int) (((tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90)&BITS32) >> ANGLETOFINESHIFT);
        
        // use as cosine
        dist = FixedDiv (dx, finesine[angle] ); 
        
        return dist;
    }
    
    
}

package testers;

import doom.event_t;
import m.cheatseq_t;

public class TestCheats {

    
    public static void main(String argv[]){
    char  cheat_ammo_seq[] =
    {
        0xb2, 0x26, 0xf2, 0x66, 0xa2, 0xff  // idkfa
    };
    
    cheatseq_t idkfa=new cheatseq_t( cheat_ammo_seq);
    //event_t[] keystokes={new event_t('i'),new event_t('d') ,new event_t('k') ,new event_t('f') ,new event_t('a') };    
    
    //idkfa.sequence=cheat_ammo_seq
    System.out.println(idkfa.CheckCheat('i'));
    System.out.println(idkfa.CheckCheat('d'));
    System.out.println(idkfa.CheckCheat('k'));
    System.out.println(idkfa.CheckCheat('f'));
    System.out.println(idkfa.CheckCheat('a'));
    System.out.println(idkfa.CheckCheat('i'));
    System.out.println(idkfa.CheckCheat('d'));
    System.out.println(idkfa.CheckCheat('k'));
    System.out.println(idkfa.CheckCheat('f'));
    System.out.println(idkfa.CheckCheat('b'));
    System.out.println(idkfa.CheckCheat('i'));
    System.out.println(idkfa.CheckCheat('d'));
    System.out.println(idkfa.CheckCheat('k'));
    System.out.println(idkfa.CheckCheat('f'));
    System.out.println(idkfa.CheckCheat('a'));
    }
    
}

package testers;

import m.FixedFloat;
import m.fixed_t;

class FPBench{         
public static final int PRECISION=16;

    public static void main(String argv[])
{
    final int tests=500000;
 for (int j=0;j<2;j++){   
    float[] a=new float[tests];
    float[] b=new float[tests];
    float[] c=new float[tests];
    fixed_t[] fa=new fixed_t[tests];
    fixed_t[] fb=new fixed_t[tests];
    fixed_t[] fc=new fixed_t[tests];
    
    long tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){           
    a[i]=((float)(Math.random()*65535.0-32678.0));
    b[i]=((float)(Math.random()*65535.0-32678.0));
    }
    long tan_1=System.nanoTime();
    
    System.out.println("Allocate "+tests+" random IEEE floats: \t" + (tan_1-tan_0));
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){           
    fa[i]=F2F(a[i]);
    fb[i]=F2F(b[i]);
    }
    tan_1=System.nanoTime();
    
    System.out.println("Convert "+tests+" random IEEE floats into fixed_t (creates new): \t" + (tan_1-tan_0));
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){           
    F2F(a[i],fa[i]);
    F2F(b[i],fb[i]);
    }
    tan_1=System.nanoTime();
    
    System.out.println("Convert "+tests+" random IEEE floats into fixed_t (reuses objects): \t" + (tan_1-tan_0));
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){           
    fa[i].set(FixedFloat.toFixed(a[i]));
    fb[i].set(FixedFloat.toFixed(b[i]));
    }
    tan_1=System.nanoTime();
    
    System.out.println("Convert "+tests+" random IEEE floats into fixed_t (new method, reuses objects): \t" + (tan_1-tan_0));
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
     c[i]=a[i]*b[i];    
    }
    tan_1=System.nanoTime();
    
    System.out.println("Perform "+tests+" random IEEE floats multiplications: \t" + (tan_1-tan_0));
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
     fc[i]=new fixed_t(fixed_t.FixedMul(fa[i],fb[i]));    
    }
    tan_1=System.nanoTime();

    System.out.println("Perform "+tests+" random fixed_t multiplications (new objects): \t"+ (tan_1-tan_0));
    
    System.out.println(tan_1-tan_0);
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
     fc[i].val=(fixed_t.FixedMulInt(fa[i],fb[i]));    
    }
    tan_1=System.nanoTime();
    
    System.out.println("Perform "+tests+" random fixed_t multiplications (integer return): \t" + (tan_1-tan_0));
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
     fixed_t.FixedMul(fa[i],fb[i],fc[i]);    
    }
    tan_1=System.nanoTime();
    
    System.out.println("Perform "+tests+" random fixed_t multiplications (in-place): \t"+ (tan_1-tan_0));

    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
     c[i]=a[i]/b[i];    
    }
    tan_1=System.nanoTime();
    
    System.out.println("Perform "+tests+" random IEEE floats divisions: \t" + (tan_1-tan_0));
    
    
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
       // fc[i]=fixed_t.FixedDiv(fa[i],fb[i]);    
    }
    tan_1=System.nanoTime();
    
    System.out.println("Perform "+tests+" random fixed_t divisions (new objects): \t"+ (tan_1-tan_0));
   
    tan_0=System.nanoTime();
    for (int i=0;i<tests;i++){
        //fixed_t.FixedDiv(fa[i],fb[i],fc[i]);    
    }
    tan_1=System.nanoTime();
    
    System.out.println("Perform "+tests+" random fixed_t divisions (in-place): \t"+ (tan_1-tan_0));
    
 }
}


public static fixed_t F2F(float f){
    fixed_t tmp;
    int ing;
    ing=(int)Math.floor(f);
    tmp= new fixed_t((ing<<16)|FixedDecimal(f));
    //System.out.println(Integer.toHexString(tmp.val));    
    return tmp;

}

public static void  F2F(float f, fixed_t tmp){
    int ing;
    ing=(int)Math.floor(f);
    tmp.set((ing<<16)|FixedDecimal(f));
}

public static char FixedDecimal(float f){
         char fixint_value=0;
         float decimal_part= (float) (f-Math.floor(f));
for ( int i = 1; i <= PRECISION; i++)
{
   if (decimal_part >= 1.f/(float)(i + 1))
   {
      decimal_part -= 1.f/(float)(i + 1);
      fixint_value |= (1 << PRECISION - i);
   }
}
return fixint_value;
}

}


package testers;

import m.fixed_t;

public interface Operation {
    public void invoke(fixed_t a,fixed_t b);
    
}

package testers;

import java.util.Arrays;

public class TestPrimitiveClassDetection {

    public static void main(String argv[]) throws InstantiationException, IllegalAccessException{
        Object shit;
        Object shiiit=new double[5];
        shit=shiiit;
        System.out.println(shit.getClass());
        int status=-1;
        double[] something = null;
        
        
         if (shit instanceof double[]) 
             something=(double[])shit;
         
        System.out.println(something.length);
        
    }
}

package testers;

import static data.Defines.PU_STATIC;
import static data.Limits.MAXEVENTS;
import n.DummyNetworkHandler;

import hu.HU;
import i.DoomSystem;
import i.IDoomSystem;
import p.Actions;
import p.ILevelLoader;
import p.LevelLoader;

import automap.Map;
import awt.AWTDoom;

import rr.SimpleTextureManager;
import rr.SpriteManager;
import rr.UnifiedRenderer;
import s.DummySoundDriver;
import st.StatusBar;
import timing.MilliTicker;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import v.BufferedRenderer16;
import v.DoomVideoRenderer;
import v.GammaTables;
import v.IVideoScale;
import v.VideoScaleInfo;
import w.DoomBuffer;
import w.WadLoader;
import defines.*;
import data.Tables;
import doom.CommandLine;
import doom.DoomMain;
import doom.event_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for Menu module  */

public class AWTRenderViewTester {

    static IVideoScale VSI=new VideoScaleInfo(3.0f);
    
    public static void main(String[] argv) {
        try {
    
            Tables.InitTables();
            
    // Create a Wad file loader.
    
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad","COLORS15.lmp"});
    
    System.out.println("Total lumps read: "+W.numlumps);

    // Read the palette.
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    // Create a video renderer
    DoomVideoRenderer<short[]> V=new BufferedRenderer16(VSI.getScreenWidth(),VSI.getScreenHeight());
    V.setVideoScale(VSI);
    V.initScaling();
    V.Init();
    byte[] pal=palette.getBuffer().array();
    V.createPalettes(pal, GammaTables.gammatables, 14, 256, 3, 5);

    
    IDoomSystem I=new DoomSystem();
    DoomMain DM=new DoomMain();
    DM.CM=new CommandLine(argv);
    DM.TICK=new MilliTicker();    
    DM.setVideoScale(VSI);
    DM.initScaling();
    DM.singletics=true;
    DM.setTicdup(1);
    DM.DGN=new DummyNetworkHandler();
    
    // Create the frame.
    AWTDoom frame = new AWTDoom(DM,(DoomVideoRenderer<short[]>) V);
    frame.InitGraphics();
    DM.I=I;
    DM.VI=frame;
    DM.S=new DummySoundDriver();
    frame.DM=DM;
    DM.W=W;
    DM.V=V;
    DM.DM=DM;
    HU HU=new HU(DM);    
    DM.language=Language_t.english;
    HU.Init();
    DM.HU=HU;
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.setGameMode(GameMode_t.shareware);
    DM.wminfo=new wbstartstruct_t();
    // Simulate being in the mid of a level.
    DM.usergame=true;
    DM.gamestate=gamestate_t.GS_LEVEL;
    DM.gameskill=skill_t.sk_hard;
    //C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;
    
   
    IDoomMenu M=DM.M=new Menu(DM);
    Map AM=new Map(DM);
    DM.AM=AM;
    StatusBar ST=(StatusBar) (DM.ST=new StatusBar(DM));
    ILevelLoader LL=DM.LL=new LevelLoader(DM);
    DM.P=new Actions(DM);
    DM.SM=new SpriteManager(DM);    
    DM.R=new UnifiedRenderer(DM);
    DM.TM=new SimpleTextureManager(DM);
    DM.P.updateStatus(DM);
    LL.updateStatus(DM);
    M.updateStatus(DM);
    ST.updateStatus(DM);
    AM.updateStatus(DM);
    //DM.R.updateStatus(DM);
   // Interesting bug: initializing the Unified renderer BEFORE applying
    // scale info, results in VERY dark visplanes.
    // This can't be done as easily with the Parallel  because a lot more
    // stuff will break.
   DM.initializeVideoScaleStuff();    
    DM.R.Init();
    
    DM.P.Init();
    DM.players[0].updateStatus(DM);
    DM.players[0].PlayerReborn();
    
    ST.Init();
    M.Init();
    ST.Start();
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    AM.LevelInit();
    AM.Start();
    
    DM.R.SetViewSize(11, 1);
    DM.R.ExecuteSetViewSize();
    DM.TM.setSkyTexture(DM.TM.CheckTextureNumForName("SKY1"));
    long a=System.nanoTime();
    
    DM.menuactive=false;
    DM.automapactive=true;
    DM.R.FillBackScreen();
    DM.R.DrawViewBorder();
    
    
    // Center on "bloody mess" in E1M1
    DM.players[0].mo.y+=420<<16;
    //DM.players[0].mo.x+=1650<<16;
        int pl=0;
        for (int i=0;i<20000;i++){
   
           frame.GetEvent();
           
           for ( ; DM.eventtail != DM.eventhead ; DM.eventtail = (++DM.eventtail)&(MAXEVENTS-1) )
           {
       	event_t ev = DM.events[DM.eventtail];

            //System.out.println(ev);
            if (ev!=null){
            
            AM.Responder(ev);
            M.Responder(ev);
            ST.Responder(ev);
           }
           }
            
       
           
        //V.DrawPatch(0,0,0,help1);
        //M.Ticker();
        //M.Drawer();
        AM.Ticker();
        //AM.Drawer();
        ST.Ticker();        
        DM.players[0].viewz=(40)<<16;
        //DM.players[0].mo.x=ox+(int) ((12864<<16)*Math.cos(2*Math.PI*i/500.0));
        //DM.players[0].mo.y=oy+(int) ((64<<16)*Math.sin(2*Math.PI*i/500.0));
        //DM.players[0].mo.angle= ((long)(0xFFFFFFFFL*(Math.atan2(DM.players[0].mo.y-oy,DM.players[0].mo.x-ox)+Math.PI)/(2*Math.PI)))&0xFFFFFFFFL;
        DM.players[0].mo.angle=(DM.players[0].mo.angle-0x800000)&0xFFFFFFFFL;
        //System.out.println(">>>>>>>>>>>>>>>>>> VIEW ANGLE "+360.0*(DM.players[0].mo.angle>>19)/8192.0); 
       
        DM.R.RenderPlayerView(DM.players[0]);
        //ST.Drawer(false,true);
        //System.out.println("Rendered"+DM.gametic);
        
        DM.gametic++;
        frame.FinishUpdate();
        if (i%200==0){
        	   long b=System.nanoTime();
        	    //frame.setPalette((pl++)%14);
        	    System.out.println((200) +" frames in " +((b-a)/1e09) +" = "+200/((b-a)/1e09) + " fps");
        	    a=b;
        }
        
       // System.out.print(frame.processEvents());
        /*while (ba-DM.I.GetTime()>-1){
            Thread.sleep(10);               
        }*/
        }
            } catch (Exception e){
                e.printStackTrace();
            }
    
    }
    
}

package testers;

import m.fixed_t;

public class Add
        implements Operation {

    @Override
    public void invoke(fixed_t a, fixed_t b) {
        a.add(b);

    }

}

package testers;

import java.util.HashMap;

import pooling.RoguePatchMap;
import pooling.RoguePatchMap2;

public class TestPatchMaps {
    public static final int TESTS=2000000;
    public static final int SET=30;
    public static final int REPS=50;
    static byte[][][] stuff=new byte[SET][1][1];
    static byte[][][] stuff2=new byte[TESTS][][];
	// A normal hashmap....
	static HashMap<Integer,byte[][]> map1= new HashMap<Integer,byte[][]> ();
	
	// And a NEW and ENHANCED implementation.
	static RoguePatchMap map2=new RoguePatchMap();
	
    public static void main(String[] argv){
    
    	for (int i=0;i<REPS;i++){
    		System.out.printf("Put %d in Hashmap: %d\n",TESTS,testPutHashmap());
    	}

    	for (int i=0;i<REPS;i++){
    		System.out.printf("Put %d in Patchmap: %d\n",TESTS,testPutPatchmap());
    	}

    	
    	for (int i=0;i<REPS;i++){
    		System.out.printf("Get %d from Hashmap: %d\n",TESTS,testGetHashmap());
    	}

    	for (int i=0;i<REPS;i++){
    		System.out.printf("Get %d from Patchmap: %d\n",TESTS,testGetPatchmap());
    	}

    	
    }
    
    private static long testPutHashmap(){
    	
    	long a=System.nanoTime();
    	for (int i=0;i<TESTS;i++){
    		map1.put(i%SET, stuff[i%SET]);
    	}
    	long b=System.nanoTime();
    	
    	return (b-a);
    }
    
    private static long testGetHashmap(){
    	
    	long a=System.nanoTime();
    	for (int i=0;i<TESTS;i++){
    		stuff2[i]=map1.get(i%SET);
    	}
    	long b=System.nanoTime();
    	
    	return (b-a);
    }
    
    private static long testPutPatchmap(){
    	
    	long a=System.nanoTime();
    	for (int i=0;i<TESTS;i++){
    		map2.put(i%SET, stuff[i%SET]);
    	}
    	long b=System.nanoTime();
    	
    	return (b-a);
    }
    
    private static long testGetPatchmap(){
    	
    	long a=System.nanoTime();
    	for (int i=0;i<TESTS;i++){
    		stuff2[i]=map2.get(i%SET);
    	}
    	long b=System.nanoTime();
    	
    	return (b-a);
    }
}

package testers;

import static data.Defines.PU_STATIC;
import static data.Defines.pw_allmap;
import static m.fixed_t.FRACBITS;
import java.awt.image.IndexColorModel;
import automap.DoomAutoMap;
import automap.Map;

import p.LevelLoader;
import p.mobj_t;

import m.DoomRandom;

import st.StatusBar;

import data.Defines;
import defines.*;
import doom.DoomContext;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.evtype_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;
import doom.weapontype_t;

import utils.C2JUtils;
import v.SimpleRenderer;
import w.*;

/** This is a very simple tester for the Automap. Combined with status bar + Level loader. */

public class AutoMapTester {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    SimpleRenderer V=new SimpleRenderer(320,200);
    V.Init();
    
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();
    IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);
        
    DoomMain DM=new DoomMain();
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.gamemode=GameMode_t.shareware;
    DM.wminfo=new wbstartstruct_t();
    C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    Defines.SCREENWIDTH=320;
    Defines.SCREENHEIGHT=200;
    
    DM.DM=(DoomMain) DM;
    DM.W=W;
    DM.V=V;
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    DM.players[0].weaponowned[0]=true;
    DM.players[0].weaponowned[1]=true;
    DM.players[0].weaponowned[2]=true;
    DM.players[0].weaponowned[3]=true;
    DM.players[0].readyweapon=weapontype_t.wp_pistol;
    DM.players[0].health[0]=100;
    DM.players[0].armorpoints[0]=666;
    DM.players[0].ammo[0]=666;
    DM.players[0].maxammo[0]=666;
    DM.players[0].ammo[1]=666;
    DM.players[0].maxammo[1]=666;
    DM.players[0].ammo[2]=666;
    DM.players[0].maxammo[2]=666;
    DM.players[0].ammo[3]=666;
    DM.players[0].maxammo[3]=666;

    
    DM.players[0].cards[0]=true;
    DM.players[0].cards[2]=true;
    DM.players[0].cards[4]=true;
    DM.players[0].mo=new mobj_t();
    DM.players[0].mo.x=1056<<FRACBITS;
    DM.players[0].mo.y=-3616<<FRACBITS;
    
    DM.players[0].powers[pw_allmap]=100;
    DM.deathmatch=false;
    DM.statusbaractive=true;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;

    StatusBar ST=(StatusBar) (DM.ST=new StatusBar(DM));
    ST.Start();

    LevelLoader PL=new LevelLoader(DM);
    PL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    DM.LL=PL;
    DM.ST=ST;
    DoomAutoMap AM=DM.AM=new Map(DM);
    AM.Start();
    
    ST.Responder(new event_t('i'));
    ST.Responder(new event_t('d'));
    ST.Responder(new event_t('d'));
    ST.Responder(new event_t('t'));

    AM.Responder(new event_t(Map.AM_FOLLOWKEY));
    AM.Responder(new event_t(Map.AM_ZOOMINKEY));
    AM.Responder(new event_t(Map.AM_GRIDKEY));
	AM.updateStatus(DM);
	ST.updateStatus(DM);
    for (int i=0;i<100;i++){
    	DM.players[0].health[0]--;
    	DM.players[0].ammo[0]=i;
    	DM.players[0].damagecount=1; // if zero, it won't update.
        AM.Responder(new event_t(evtype_t.ev_keyup,Map.AM_MSGENTERED));
    if ((i%20)<10)
        AM.Responder(new event_t(Map.AM_ZOOMINKEY));
       else
       AM.Responder(new event_t(Map.AM_ZOOMOUTKEY));

    if ((i%25)<12) {
        AM.Responder(new event_t(Map.AM_PANUPKEY));
        AM.Responder(new event_t(Map.AM_PANRIGHTKEY));
    }
       else {
       AM.Responder(new event_t(Map.AM_PANDOWNKEY));
       AM.Responder(new event_t(Map.AM_PANLEFTKEY));
       }

    
    AM.Ticker();
    AM.Drawer();
    ST.Ticker();
    ST.Drawer(false,true);
    V.takeScreenShot(0, "tic"+i,icm);    
    //AM.Responder(new event_t(Map.AM_PANLEFTKEY));

    }
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import hu.HU;
import m.DummyMenu;
import m.IDoomMenu;
import m.MenuMisc;
import demo.VanillaDoomDemo;
import doom.CommandLine;
import doom.DoomStatus;
import w.*;

public class DefaultsTester {

    public static void main(String[] argv) {

    DoomStatus DS=new DoomStatus();
    m.AbstractDoomMenu dummy= new DummyMenu();
    DS.M=dummy;
    DS.HU=new HU();
    DS.CM=new CommandLine(argv);
    
    MenuMisc.LoadDefaults(DS);
    
    MenuMisc.defaultfile="ghetto.cfg";
    MenuMisc.SaveDefaults(DS);

    
    }
    
}

package testers;

import java.lang.reflect.Method;

import m.FixedFloat;
import m.fixed_t;

import w.WadLoader;

/** A simple benchmark proving how using reflection is slower than both simply switching
 *  on a status flag, or using "invokable" objects. This affected the choice of invokable objects
 *  and simple switching whenever Doom used function pointers.
 *  
 */

public class TestReflection {

    /**
     * @param args
     * @throws Exception
     * @throws
     */
    public static void main(String[] args)
            throws Exception {
        int TESTS = 50000000;

        // "function pointer" to fadd
        Method fadd = fixed_t.class.getDeclaredMethod("add", fixed_t.class);
        Method fmul =
            fixed_t.class.getDeclaredMethod("FixedMul", fixed_t.class);

        Operation fadd2=new Add();
        Operation fmul2=new Mul();
        Operation todo;
        
        fixed_t a = new fixed_t(FixedFloat.toFixed(1.0));
        fixed_t b = new fixed_t(FixedFloat.toFixed(1.1));

        
        
        Method operation = fadd;

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                operation.invoke(a, b);
            }

            long tb = System.nanoTime();
            System.out.println("Adding with reflection :"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));

        a = new fixed_t(FixedFloat.toFixed(1.0));

        operation = fmul;

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                operation.invoke(a, b);
            }

            long tb = System.nanoTime();
            System.out.println("Multiplying with reflection :"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));

        /** add=0, mul=1 */
        int op = 0;

        a = new fixed_t(FixedFloat.toFixed(1.0));

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                switch (op) {
                case 0:
                    a.add(b);
                    break;
                case 1:
                    a.FixedMul(b);
                    break;
                }
            }

            long tb = System.nanoTime();
            System.out.println("Adding with switching :"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));

        
          op=1;
        a = new fixed_t(FixedFloat.toFixed(1.0));

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                switch (op) {
                case 0:
                    a.add(b);
                case 1:
                    a.FixedMul(b);
                }
            }

            long tb = System.nanoTime();
            System.out.println("Multiplying with switching :"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));
        
        a = new fixed_t(FixedFloat.toFixed(1.0));
        
        todo=fadd2;

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                todo.invoke(a,b);
            }

            long tb = System.nanoTime();
            System.out.println("Adding with invokable object :"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));
        
        a = new fixed_t(FixedFloat.toFixed(1.0));
        
        todo=fmul2;

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                todo.invoke(a,b);
            }

            long tb = System.nanoTime();
            System.out.println("Multiplying with invokable object :"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));
        
        operation = fadd;

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                operation.invoke(a, b);
            }

            long tb = System.nanoTime();
            System.out.println("Adding with reflection 2:"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));

        a = new fixed_t(FixedFloat.toFixed(1.0));

        operation = fmul;

        {
            long ta = System.nanoTime();
            for (int i = 0; i < TESTS; i++) {
                operation.invoke(a, b);
            }

            long tb = System.nanoTime();
            System.out.println("Multiplying with reflection 2:"+(tb - ta));
        }
        System.out.println(FixedFloat.toDouble(a.val));
        
        
    }

}

package testers;

import m.Swap;

public class TestSwap {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        short a=(short)0xBEEF;
        char c=(char)0xBABE;
        int b=0XDEADBABE;
        
        System.out.printf("%X\n",a);
        System.out.printf("%X\n",b);
        System.out.printf("%X\n",(int)c);
        a=Swap.SHORT(a);
        b=Swap.LONG(b);
        c=(char)Swap.SHORT(c);
        System.out.printf("%X\n",a);
        System.out.printf("%X\n",b);
        System.out.printf("%X\n",(int)c);
        c=(char)Swap.SHORT(a);
        System.out.printf("%X\n",(int)c);

        char aa=Swap.USHORT((char)a);
        System.out.printf("%X\n",(int)a);
        System.out.printf("%X\n",(int)aa);


    }

}

package testers;

import static data.Defines.PU_STATIC;
import hu.HU;

import java.nio.ByteBuffer;

import m.FixedFloat;

import rr.vertex_t;

import data.mapvertex_t;
import defines.*;
import doom.DoomContext;
import doom.DoomStatus;

import utils.C2JUtils;
import w.*;

/** This is a very simple tester for the WadLoader and HU modules.
 *  We use the same exact methods used in the C source code, only
 *  with a more OO approach.
 * 
 * 
 */

public class WadLoaderTester {

    public static void main(String[] argv) {
        try {
    IWadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.NumLumps());
    System.out.println("NUm for E1M1: "+W.GetNumForName("E1M1"));
    System.out.println("NUm for SECTORS: "+W.GetNumForName("SECTORS"));
    System.out.println("NUm for SSECTORS: "+W.GetNumForName("SSECTORS"));
   int lump=W.GetNumForName("VERTEXES");
   System.out.println("NUm for VERTEXES: "+W.GetNumForName("VERTEXES"));
    // We prepare a ByteBuffer to receive a "SECTORS" object. Deserializing it is
    // another matter.
    ByteBuffer bb=W.CacheLumpName("SECTORS", 0).getBuffer();
    System.out.println("Num for THINGS: "+W.GetNumForName("THINGS"));
    DoomStatus ds = new DoomStatus();
    ds.gameepisode=1;
    ds.gamemap=1;
    ds.gamemission=GameMission_t.doom;
    ds.W=W;
    
    // Testing "Heads Up" clases. Notice how we pass "doomstate" and "WadLoader" as instances,
    // instead of globals. OO all the way, baby!
    
    // Determine number of lumps:
    //  total lump length / vertex record length.
    int numvertexes = W.LumpLength (lump) / mapvertex_t.sizeOf();

    // Allocate zone memory for buffer.
    vertex_t[] vertexes;

    // Load data into cache.
    // MAES: we now have a mismatch between memory/disk: in memory, we need an array.
    // On disk, we have a single lump/blob. Thus, we need to find a way to deserialize this...
    vertexes= W.CacheLumpNumIntoArray(lump,numvertexes,vertex_t.class);

   // Copy and convert vertex coordinates,
    // internal representation as fixed.
    for (int i=0 ; i<numvertexes ; i++)
    {
        //vertexes[i].x = ml[i].x<<FRACBITS;
        //vertexes[i].y = ml[i].y<<FRACBITS;
       System.out.println(vertexes[i].x+" , "+vertexes[i].y+" "+FixedFloat.toDouble(vertexes[i].x)+" , "+FixedFloat.toDouble(vertexes[i].y));
        //System.out.println(ml[i].x+" , "+ml[i].y+" "+FPTest.Value(vertexes[i].x)+" , "+FPTest.Value(vertexes[i].y));
    }

    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;



public class TestLightLevels {

    public static final int LIGHTLEVELS= 32;
    public static final int MAXLIGHTSCALE =48;
    public static final int NUMCOLORMAPS =32;
    public static final int LIGHTBRIGHT =2;
    public static final int DISTMAP =2;
    
    public static void main(String[] argv){
        for (int i = 0; i < LIGHTLEVELS; i++) {
            int startmap = ((LIGHTLEVELS-LIGHTBRIGHT-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
            for (int j = 0; j < MAXLIGHTSCALE; j++) {
                int level =
                    startmap - j/ DISTMAP;
                if (level < 0)
                    level = 0;
                if (level >= NUMCOLORMAPS)
                    level = NUMCOLORMAPS - 1;
                System.out.printf("%d ",level);
            }
            System.out.printf("\n");
            }
        }
    }

package testers;
import static data.Defines.KEY_F1;
import static data.Defines.PU_STATIC;
import static data.Defines.pw_allmap;
import static m.fixed_t.FRACBITS;

import i.InputListener;
import i.IDoomSystem;

import java.applet.Applet;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.IndexColorModel;
import java.io.IOException;

import javax.imageio.ImageIO;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import p.LevelLoader;
import p.mobj_t;
import rr.patch_t;
import st.StatusBar;
import utils.C2JUtils;
import v.BufferedRenderer;
import w.DoomBuffer;
import w.WadLoader;
import automap.DoomAutoMap;
import automap.Map;
import data.Defines;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import data.Defines.skill_t;
import doom.DoomContext;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;
import doom.weapontype_t;
import f.EndLevel;
import f.Wiper;

public class DoomApplet
        extends Applet {
    
    public static final int WIDTH=320;
    public static final int HEIGHT=200;
    public static final int TICKS=5000;
    
    IndexColorModel[] icms;
    Canvas drawhere;
    BufferedImage[] bi;
    int palette=0;
    Dimension size;
    Image crap;
    InputListener in;
    Graphics2D g2d;
    BufferedImage[] pals;
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    IWadLoader W;
    BufferedRenderer V;
    DoomStatus ds;
    DoomContext DC;
    StatusBar ST;
    Map AM;
    Menu M;
    EndLevel EL;

    
    private patch_t titlepic;

    private patch_t help1;

    private Wiper wipe;
    
    public void start(){
        
    }
    
    public void doStuff(){
        
       // Do a screen wipe 
       WipeYoAss();
       /*
       DoMenu();
       doAutoMap();
       doEndLevel();*/
    }
    
    private void doAutoMap() {
        
        V.screens[0]=((DataBufferByte)pals[0].getRaster().getDataBuffer()).getData();
        ST.Responder(new event_t('i'));
        ST.Responder(new event_t('d'));
        ST.Responder(new event_t('d'));
        ST.Responder(new event_t('t'));
        
        AM.Responder(new event_t(Map.AM_FOLLOWKEY));
        AM.Responder(new event_t(Map.AM_ZOOMOUTKEY));
        AM.Responder(new event_t(Map.AM_GRIDKEY));
        long a=System.nanoTime();
        for (int i=0;i<TICKS;i++){
            if ((i%20)<10)
                AM.Responder(new event_t(Map.AM_ZOOMINKEY));
               else
               AM.Responder(new event_t(Map.AM_ZOOMOUTKEY)); 

            if ((i%25)<12) {
                AM.Responder(new event_t(Map.AM_PANUPKEY));
                AM.Responder(new event_t(Map.AM_PANRIGHTKEY));
            } 
               else {
               AM.Responder(new event_t(Map.AM_PANDOWNKEY));
               AM.Responder(new event_t(Map.AM_PANLEFTKEY));
               }


            V.DrawPatch(0, 0, 0, titlepic);
            AM.Ticker();
            AM.Drawer();
            ST.Ticker();
            ST.Drawer(false,true);

            this.setPalette((i/(TICKS/14))%14);
            this.processEvents();
            //System.out.println(V.isRasterNull(0));
            this.update();
        
            }
    }

    private void dump(int i) {
        try {
            V.takeScreenShot(0, "C:\\SHIT"+i+".PNG",icms[0]);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

    public void init(){
        
        // size
        size = new Dimension();
        size.width = WIDTH;
        size.height = HEIGHT;
        this.setSize(size);
        
        // Canvas
        drawhere=new Canvas();
        drawhere.setSize(size);
        drawhere.setBounds(0, 0, drawhere.getWidth(),drawhere.getHeight());
        drawhere.setBackground(Color.black);            
        this.add(drawhere);
        drawhere.setVisible(true);
        
        // Listener
        in = new InputListener();
        this.addComponentListener(in);
        
        // Graphics 
        g2d = (Graphics2D)drawhere.getGraphics();
        
        //this.setSize(new Dimension(WIDTH,));
        this.setVisible(true);

        W=new WadLoader();
        try {
            W.InitMultipleFiles(new String[] {"doom.wad"});
        } catch (Exception e) {
            e.printStackTrace();
        }
        help1=W.CachePatchName("HELP1", PU_STATIC);
        System.out.println(help1.height);
        System.out.println(help1.width);        
        System.out.println(help1);
        System.out.println(W.GetNumForName("TITLEPIC"));
        System.out.println(W.lumpinfo[W.GetNumForName("TITLEPIC")].size);
        titlepic=W.CachePatchName("HELP1", PU_STATIC);
        System.out.println(titlepic.height);
        System.out.println(titlepic.width);

        System.out.println(help1);
        System.out.println(W.GetNumForName("HELP1"));
        System.out.println(W.lumpinfo[W.GetNumForName("HELP1")].size);
        DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
        byte[] pal=palette.getBuffer().array();

        IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);
        Defines.SCREENWIDTH=WIDTH;
        Defines.SCREENHEIGHT=HEIGHT;
        V=new BufferedRenderer(WIDTH,HEIGHT,icm);
        V.Init();
        icms=new IndexColorModel[palette.getBuffer().limit()/768];
        for (int i=0;i<icms.length;i++){
            icms[i]=new IndexColorModel(8, 256,pal, i*768, false);
            }
        pals=new BufferedImage[icms.length];
        pals=V.getBufferedScreens(0, icms);
        
   /*     for (int i=0;i<icms.length;i++){
         icms[i]=new IndexColorModel(8, 256,pal, i*768, false);
             pals[i]=new BufferedImage(icms[i],V.screenbuffer[0].getRaster(), false, null);
            }
            */
        this.Init(pals);
        
        ds=new DoomStatus();
        initDoomState(ds);

        DC=new DoomContext();
        DC.DS=ds;
        DC.W=W;
        DC.V=V;
        DC.RND=new DoomRandom();
        ST=new StatusBar(DC);
        ST.Start();
        LevelLoader PL=new LevelLoader(DC);
        try {
            PL.SetupLevel(1, 1, 0, skill_t.sk_hard);
        } catch (Exception e) {
            e.printStackTrace();
        }
        DC.LL=PL;
        DC.ST=ST;
        AM=new Map(DC);
        AM.Start();
        M= new Menu(DC);
        M.Init();
        wipe=new Wiper(DC);
        EL=new EndLevel(DC);
        EL.Start(DC.DS.wminfo);
        
        doStuff();
    }

    private static void initDoomState(DoomStatus ds) {
        C2JUtils.initArrayOfObjects(ds.players,player_t.class);
        ds.gameepisode=1;
        ds.gamemap=1;
        ds.gamemission=GameMission_t.doom;
        ds.gamemode=GameMode_t.shareware;
        ds.wminfo=new wbstartstruct_t();
        ds.players[0].cmd=new ticcmd_t();
        ds.players[0].itemcount=1337;
        ds.players[0].killcount=1337;
        ds.players[0].secretcount=1337;
        ds.players[0].weaponowned[0]=true;
        ds.players[0].weaponowned[1]=true;
        ds.players[0].weaponowned[2]=true;
        ds.players[0].weaponowned[3]=true;
        ds.players[0].readyweapon=weapontype_t.wp_pistol;
        ds.players[0].health[0]=100;
        ds.players[0].armorpoints[0]=100;
        ds.players[0].ammo[0]=400;
        ds.players[0].maxammo[0]=400;
        ds.players[0].ammo[1]=100;
        ds.players[0].maxammo[1]=100;
        ds.players[0].ammo[2]=100;
        ds.players[0].maxammo[2]=100;
        ds.players[0].ammo[3]=600;
        ds.players[0].maxammo[3]=600;

        
        ds.players[0].cards[0]=true;
        ds.players[0].cards[2]=true;
        ds.players[0].cards[4]=true;
        ds.players[0].mo=new mobj_t();
        ds.players[0].mo.x=1056<<FRACBITS;
        ds.players[0].mo.y=-3616<<FRACBITS;
        
        ds.players[0].powers[pw_allmap]=100;
        ds.deathmatch=false;
        ds.statusbaractive=true;
        
        ds.wminfo.plyr[0].in=true;
        ds.wminfo.plyr[0].sitems=1337;
        ds.wminfo.plyr[0].skills=1337;
        ds.wminfo.plyr[0].stime=28595;
        ds.wminfo.plyr[0].ssecret=1337;
        ds.playeringame[0]=true;
        ds.wminfo.last=6;
        ds.wminfo.epsd=0;
        ds.wminfo.maxitems=100;
        ds.wminfo.maxkills=100;
        ds.wminfo.maxsecret=100;
        ds.wminfo.partime=28595;
    }
       
    /*
    public void paint(Graphics g){
        g2d=(Graphics2D) g;
        g2d.drawImage(bi[palette],0,0,this);        
    }*/
    
    
    public void paint(Graphics g){
        /*
        if (g==null)
            this.update(null);
        else super.paint(g);
        //g2d.drawImage(bi[palette],0,0,this);
         *         
         */
    }

    

    public void Init(BufferedImage[] bi) {
        this.setBackground(Color.black);
        this.bi=bi;            


        
    }
    
    public void Init(BufferedImage bi) {
        this.bi=new BufferedImage[]{bi};
        size = new Dimension();
        size.width = bi.getWidth();
        size.height = bi.getHeight();
        this.setSize(size);
        drawhere=new Canvas();
        drawhere.setSize(size);
        drawhere.setBounds(0, 0, drawhere.getWidth(),drawhere.getHeight());
        drawhere.setBackground(Color.black);
        this.add(drawhere);
        in = new InputListener();
        this.addComponentListener(in);
        g2d = (Graphics2D)drawhere.getGraphics();
    }
    
    public void setPalette(int pal){
        this.palette=pal;
    }
    
    public void update() {
        g2d=(Graphics2D) drawhere.getGraphics();
        g2d.drawImage(bi[palette],0,0,this);
        
        //drawhere.repaint();
        //super.update(this.getGraphics());
      }   
    
    public void update(Graphics g) {
      // g2d.drawImage(bi[palette],0,0,this);       
    }
    
    public String processEvents(){
        StringBuffer tmp=new StringBuffer();
        event_t event;
        while ( (event=InputListener.nextEvent()) != null ) {
            tmp.append(event.type.ordinal()+"\n");
        }
        return tmp.toString();
    }

    public void WipeYoAss(){
        
        int WIPES=1;
        for (int i=0;i<WIPES;i++){
            V.DrawPatch(0, 0, 0, help1);
            // Grab "help"
            wipe.StartScreen(0, 0, Defines.SCREENWIDTH, Defines.SCREENHEIGHT);
                    V.DrawPatch(0, 0, 0, titlepic);
            wipe.EndScreen(0, 0, Defines.SCREENWIDTH, Defines.SCREENHEIGHT);
            
            int wipestart = IDoomSystem.GetTime () - 1;
            int nowtime;
            int tics;
            boolean done;
        
        do
        {
        do
        {
            nowtime = IDoomSystem.GetTime ();
            tics = nowtime - wipestart;
        } while (tics<1);
        wipestart = nowtime;
        //V.DrawPatch(0, 0, 0, titlepic);
        V.DrawPatch(0, 0, 0, help1);
        //V.DrawPatch(320, 0, 0, titlepic);
        done = wipe.ScreenWipe(Wiper.wipe.Melt.ordinal()
                       , 0, 0, Defines.SCREENWIDTH, Defines.SCREENHEIGHT, tics);
        //I_UpdateNoBlit ();
        //M_Drawer ();                            // menu is drawn even on top of wipes
        //System.out.println(V.isRasterNull(0));
        this.update();
       
        
        } while (!done);
    }
}
    public void DoMenu(){
        ds.menuactive=true;        
        for (int i=0;i<600;i++){


            if (i==40){
                System.out.println("Pressing enter");
                M.Responder(new event_t(Defines.KEY_DOWNARROW));
            }

            if (i==60){
                System.out.println("Pressing down");
                M.Responder(new event_t(Defines.KEY_DOWNARROW));
            }
            
            if (i==80){
                System.out.println("Pressing escape");
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            if (i==100){
                System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==120){
                System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==140){
                System.out.println("Pressing escape");
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            
            if (i==160){
                System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==160){
                System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==300 || i==500|i==550|i==600){
                System.out.println("Pressing F1");
                M.Responder(new event_t(KEY_F1));
                System.out.println("pressed ");
            }
            
            if (i==400 || i==650){
                System.out.println("Pressing escape");
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            //V.takeScreenShot(0,( "menutic"+i),icm);
            try {
                Thread.sleep(14);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        V.DrawPatch(0,0,0,help1);
        M.Ticker();
        M.Drawer();
        System.out.println(V.isRasterNull(0));
        this.update();
        //System.out.print(frame.processEvents());
        }
    }
    
    public void doEndLevel(){
        int a,b;
        a=IDoomSystem.GetTime();
        b=a;
        for (int i=0;i<2000;i++){
            
        EL.Ticker();
        EL.Drawer();
        this.update();
        if (i==100){
                ds.players[0].cmd.buttons=1; // simulate attack
                ds.players[0].attackdown=false; // simulate attack
            }
            
            if (i==120){
                ds.players[0].cmd.buttons=1; // simulate attack
                ds.players[0].attackdown=false; // simulate attack
            }
       // Do we still have time>
            
            while((b-a)<1) {
                b=IDoomSystem.GetTime();
                }
           a=b;
        }
    }
    
}

package testers;

import v.FastTranspose;

public class TestFastTranspose {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int length=11;
        byte[] x=new byte[1<<(length<<1)];
        byte[] scratch=new byte[1<<(FastTranspose.BL<<1)];

        for(int i=0;i< 1<<(length<<1); i++ ) x[i]=(byte) ((i%256)-128);
        FastTranspose.blocktranspose(x, scratch, length);
    }

}

package testers;

import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;

import s.QMusToMid;
import s.QMusToMid.Track;

public class QMusToMidTester extends QMusToMid {

	//_D_: used by me to test and fix bugs
	//FileInputStream fisTest;
	//int nbTest = 0;

	public QMusToMidTester() {
		super();
		/*try {
			fisTest = new FileInputStream("C:\\Users\\David\\Desktop\\qmus2mid\\test.mid");
			//fisTest.read(new byte[106]); //debut track 0
			fisTest.read(new byte[6977]); //debut track 1
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}*/

	}
	public static void fwrite(byte[] bytes, int offset, int size, int count, Object file) throws IOException {
		
		//nbTest += size;
		
		if (file instanceof OutputStream) {
			//.getClass(). . isAssignableFrom(OutputStream.class))
			((OutputStream)file).write(bytes, offset, size);
			
			
			for (int i = 0; i < size; i++) {
				//System.out.println(bytes[i]);
				
				//byte b = (byte)fisTest.read();
				//if (b != bytes[offset+i]) {
					//System.out.println("Woawww byte #: "+(offset+i)+" "+b+ " VS "+bytes[offset+i]);
				//}
				
				
			}
			

		}
		if (file instanceof Writer) {
//		if (file.getClass().isAssignableFrom(Writer.class))
			char[] ch = new char[bytes.length];
			for (int i = 0; i < bytes.length; i++) {
				//System.out.println(bytes[i]);
				ch[i] = (char)toUnsigned(bytes[i]);
				
				if ((byte)ch[i] == 0x3F) {
					System.out.println("testtt");
				}
				
				//char c = (char)fisTest.read();
				//if (c != ch[i]) {
				//	System.out.println("Woawww");
				//}
				
				
			}
			
			((Writer)file).write(ch, offset, size);
		}
	}
	
	public void TWriteByte( int MIDItrack, byte byte_, Track track[] ) {
		super.TWriteByte(MIDItrack, byte_, track);
		  //_D_: this was only added by me to test and fix bugs before this worked
		/*try {
			if (MIDItrack == 1) {
			  int b;
			b = fisTest.read();
			  if ((byte)b != byte_) {
				  //System.out.println("Woawww");
			  }
			}

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}*/
	}
}

package testers;

import javax.swing.*;
import java.awt.event.*;
import java.awt.BorderLayout;
import java.awt.Dimension;

public class KeyEventDemo extends JPanel 
                          implements KeyListener,
                                     ActionListener {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    JTextArea displayArea;
    JTextField typingArea;
    static final String newline = "\n";

    public KeyEventDemo() {
        super(new BorderLayout());

        JButton button = new JButton("Clear");
        button.addActionListener(this);

        typingArea = new JTextField(20);
        typingArea.addKeyListener(this);

        //Uncomment this if you wish to turn off focus
        //traversal.  The focus subsystem consumes
        //focus traversal keys, such as Tab and Shift Tab.
        //If you uncomment the following line of code, this
        //disables focus traversal and the Tab events will
        //become available to the key event listener.
        //typingArea.setFocusTraversalKeysEnabled(false);

        displayArea = new JTextArea();
        displayArea.setEditable(false);
        JScrollPane scrollPane = new JScrollPane(displayArea);
        scrollPane.setPreferredSize(new Dimension(375, 125));

        add(typingArea, BorderLayout.PAGE_START);
        add(scrollPane, BorderLayout.CENTER);
        add(button, BorderLayout.PAGE_END);
    }

    /** Handle the key typed event from the text field. */
    public void keyTyped(KeyEvent e) {
        displayInfo(e, "KEY TYPED: ");
    }

    /** Handle the key pressed event from the text field. */
    public void keyPressed(KeyEvent e) {
        displayInfo(e, "KEY PRESSED: ");
    }

    /** Handle the key released event from the text field. */
    public void keyReleased(KeyEvent e) {
        displayInfo(e, "KEY RELEASED: ");
    }

    /** Handle the button click. */
    public void actionPerformed(ActionEvent e) {
        //Clear the text components.
        displayArea.setText("");
        typingArea.setText("");

        //Return the focus to the typing area.
        typingArea.requestFocusInWindow();
    }

    /*
     * We have to jump through some hoops to avoid
     * trying to print non-printing characters 
     * such as Shift.  (Not only do they not print, 
     * but if you put them in a String, the characters
     * afterward won't show up in the text area.)
     */
    protected void displayInfo(KeyEvent e, String s){
        String keyString, modString, tmpString,
               actionString, locationString;

        //You should only rely on the key char if the event
        //is a key typed event.
        int id = e.getID();
        if (id == KeyEvent.KEY_TYPED) {
            char c = e.getKeyChar();
            keyString = "key character = '" + c + "'";
        } else {
            int keyCode = e.getKeyCode();
            keyString = "key code = " + keyCode
                        + " ("
                        + KeyEvent.getKeyText(keyCode)
                        + ")";
        }

        int modifiers = e.getModifiersEx();
        modString = "modifiers = " + modifiers;
        tmpString = KeyEvent.getModifiersExText(modifiers);
        if (tmpString.length() > 0) {
            modString += " (" + tmpString + ")";
        } else {
            modString += " (no modifiers)";
        }

        actionString = "action key? ";
        if (e.isActionKey()) {
            actionString += "YES";
        } else {
            actionString += "NO";
        }

        locationString = "key location: ";
        int location = e.getKeyLocation();
        if (location == KeyEvent.KEY_LOCATION_STANDARD) {
            locationString += "standard";
        } else if (location == KeyEvent.KEY_LOCATION_LEFT) {
            locationString += "left";
        } else if (location == KeyEvent.KEY_LOCATION_RIGHT) {
            locationString += "right";
        } else if (location == KeyEvent.KEY_LOCATION_NUMPAD) {
            locationString += "numpad";
        } else { // (location == KeyEvent.KEY_LOCATION_UNKNOWN)
            locationString += "unknown";
        }

        displayArea.append(s + newline
                           + "    " + keyString + newline
                           + "    " + modString + newline
                           + "    " + actionString + newline
                           + "    " + locationString + newline);
        displayArea.setCaretPosition(displayArea.getDocument().getLength());
    }

    /**
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event-dispatching thread.
     */
    private static void createAndShowGUI() {
        //Make sure we have nice window decorations.
        JFrame.setDefaultLookAndFeelDecorated(true);

        //Create and set up the window.
        JFrame frame = new JFrame("KeyEventDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //Create and set up the content pane.
        JComponent newContentPane = new KeyEventDemo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

package testers;

import static data.Defines.KEY_F1;
import static data.Defines.PU_STATIC;

import hu.HU;
import i.InputListener;

import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;

import javax.swing.JFrame;

import rr.patch_t;

import m.IDoomMenu;
import m.Menu;
import m.DoomRandom;
import utils.C2JUtils;
import v.BufferedRenderer;
import v.SimpleRenderer;
import w.DoomBuffer;
import w.WadLoader;
import data.Defines;
import data.Defines.GameMission_t;
import data.Defines.GameMode_t;
import data.Defines.Language_t;
import doom.DoomContext;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.player_t;
import doom.ticcmd_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for Menu module  */

public class MenuTester {
    public static final int WIDTH=320;
    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);

    patch_t help1=W.CachePatchName("TITLEPIC", PU_STATIC);
    
    DoomBuffer palette = W.CacheLumpName("PLAYPAL", PU_STATIC);
    byte[] pal=palette.getBuffer().array();

    IndexColorModel icm=new IndexColorModel(8, 256,pal, 0, false);
    Defines.SCREENWIDTH=320;
    Defines.SCREENHEIGHT=200;
    BufferedRenderer V=new BufferedRenderer(320,200,icm);
    V.Init();

    IndexColorModel[] icms=new IndexColorModel[palette.getBuffer().limit()/768];
    BufferedImage[] pals=new BufferedImage[icms.length];
    for (int i=0;i<icms.length;i++){
        icms[i]=new IndexColorModel(8, 256,pal, i*768, false);
            pals[i]=new BufferedImage(icms[i],V.screenbuffer[0].getRaster(), false, null);
           }
        
    DoomMain DM=new DoomMain();


    DM.W=W;
    DM.V=V;
    HU HU=new HU(DM);
    HU.Init();
    DM.HU=HU;
    DM.gameepisode=1;
    DM.gamemap=1;
    DM.gamemission=GameMission_t.doom;
    DM.gamemode=GameMode_t.shareware;
    DM.wminfo=new wbstartstruct_t();
    DM.usergame=true;
    C2JUtils.initArrayOfObjects(DM.players,player_t.class);
    
    DM.RND=new DoomRandom();
    DM.players[0].cmd=new ticcmd_t();
    DM.players[0].itemcount=1337;
    DM.players[0].killcount=1337;
    DM.players[0].secretcount=1337;
    
    DM.wminfo.plyr[0].in=true;
    DM.wminfo.plyr[0].sitems=1337;
    DM.wminfo.plyr[0].skills=1337;
    DM.wminfo.plyr[0].stime=28595;
    DM.wminfo.plyr[0].ssecret=1337;
    DM.playeringame[0]=true;
    DM.wminfo.last=6;
    DM.wminfo.epsd=0;
    DM.wminfo.maxitems=100;
    DM.wminfo.maxkills=100;
    DM.wminfo.maxsecret=100;
    DM.wminfo.partime=28595;
   
    IDoomMenu M=DM.M=new Menu(DM);
    DM.language=Language_t.english;
    M.Init();
    CrappyDisplay frame = new CrappyDisplay(pals);
    frame.setTitle("MochaDoom");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setLocationRelativeTo(null);
    //frame.setUndecorated(true);
    frame.setVisible(true);
    frame.setBounds(frame.getX(), frame.getY(), WIDTH, 240);
    
    DM.menuactive=true;        
        for (int i=0;i<10000;i++){
            int a=DM.I.GetTime();
            while (a-DM.I.GetTime()==0){
                frame.setVisible(true);
                Thread.sleep(1);               
            }
            
           
            
            event_t ev=CrappyDisplay.nextEvent();
            //System.out.println(ev);
            if (ev!=null)
            ((Menu)M).Responder(ev);
            
          /*  if (i==40){
            	System.out.println("Pressing enter");
                M.Responder(new event_t(Defines.KEY_DOWNARROW));
            }

            if (i==60){
            	System.out.println("Pressing down");
                M.Responder(new event_t(Defines.KEY_DOWNARROW));
            }
            
            if (i==80){
            	System.out.println("Pressing escape");
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            if (i==100){
            	System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==120){
            	System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==140){
            	System.out.println("Pressing escape");
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            }
            
            if (i==160){
            	System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==160){
            	System.out.println("Pressing up");
                M.Responder(new event_t(Defines.KEY_UPARROW));
            }
            
            if (i==300 || i==500|i==550|i==600){
            	System.out.println("Pressing F1");
                M.Responder(new event_t(KEY_F1));
                System.out.println("pressed ");
            }
            
            if (i==400 || i==650){
            	System.out.println("Pressing escape");
                M.Responder(new event_t(Defines.KEY_ESCAPE));
            } */
            
            //V.takeScreenShot(0,( "menutic"+i),icm);
         
        V.DrawPatch(0,0,0,help1);
        M.Ticker();
        M.Drawer();
        DM.gametic++;
        frame.update(null);
        System.out.print(frame.processEvents());
        }
            } catch (Exception e){
                e.printStackTrace();
            }
    
    }
    
}

package testers;

import hu.HU;
import p.LevelLoader;
import rr.SimpleTextureManager;
import rr.TextureManager;
import s.DummySoundDriver;
import s.IDoomSound;
import utils.C2JUtils;
import w.WadLoader;
import defines.*;
import doom.DoomContext;
import doom.DoomStatus;
import doom.player_t;
import doom.wbstartstruct_t;

/** This is a very simple tester for the WadLoader and HU modules.
 *  We use the same exact methods used in the C source code, only
 *  with a more OO approach.
 * 
 * 
 */

public class LevelLoaderTester {

    public static void main(String[] argv) {
        try {
    WadLoader W=new WadLoader();
    W.InitMultipleFiles(new String[] {"C:\\DOOMS\\doom1.wad"});
    //W.AddFile("bitter.wad");
    System.out.println("Total lumps read: "+W.numlumps);
    System.out.println("NUm for E1M1: "+W.GetNumForName("E1M1"));
    DoomStatus DS = new DoomStatus();
    DS.gameepisode=1;
    DS.gamemap=1;
    DS.gamemission=GameMission_t.doom;
    DS.gamemode=GameMode_t.shareware;
    IDoomSound S=new DummySoundDriver();            
    DS.S=S;
    DS.W=W;
    LevelLoader LL=new LevelLoader(DS);
    DS.LL=LL;
    TextureManager TM=new SimpleTextureManager(DS);
    DS.TM=TM;
    LL.updateStatus(DS);
    TM.InitFlats();
    TM.InitTextures();
    
    //HU hu=new HU(DS);
    //hu.Init();
    
    LL.SetupLevel(1, 1, 0, skill_t.sk_hard);
    
    
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package testers;

import rr.MultiPatchSynthesizer;
import rr.column_t;

public class TestPatchSynthesis {
    
    public static void main(String[] argv){
        final byte[] crap={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
        final boolean[] shit={true,true,true,
                              false, false, false,
                              true, true,true,
                              false,true,false,
                              true,false,true,
                              true};
        
        column_t fuck=MultiPatchSynthesizer.getColumnStream(crap, shit, crap.length);
        
        System.out.println("FUCK" +fuck);
        
        
    }

}

package testers;

import m.DoomRandom;
import m.IRandom;

/** Another microbenchmark. According to this, casting "unsigned bytes" to chars is 
 * faster when performed with a logical function, rather than with arithmetic or
 * direct logical operations. Inlining perhaps? Furthermore, it has almost no penalty 
 * compared to not casting or to use built-in casting. So it's possible to use a
 * "toUnsigned" function of sorts, whenever you need to treat signed bytes as unsigned
 * without expanding them to chars in memory.
 *
 */

public class Unsigned {

    public static void main(String[] argv){
        int TESTS=100000000;
        IRandom r=new DoomRandom();
        
       byte[] values=new byte[TESTS];
       
       for (int i=0;i<TESTS;i++) {
    	   values[i]=(byte)r.P_Random();
       	}
           
       
       byte ub=(byte) 0xFF;
       char us=(char) ub;
       
       System.out.println((int)us);
       
       us= 0xFFFF;
       ub=(byte) us;
       System.out.println(ub);
       System.out.println((int)((char)ub));
       
       System.out.println((int)us);
       long a=System.nanoTime();
        for (int i=0;i<TESTS;i++) {
        us=(char) (0x00FF&values[i]);
    }
    long b=System.nanoTime();
        System.out.println("Time for "+TESTS+" byte to \"unsigned byte\" casts (with logical ops)"+((b-a)/1e09));

        a=System.nanoTime();
        for (int i=0;i<TESTS;i++) {
        us=unsigned(values[i]);
    }
    b=System.nanoTime();
        System.out.println("Time for "+TESTS+" byte to \"unsigned byte\" casts (with num. function) "+((b-a)/1e09));

        a=System.nanoTime();
        for (int i=0;i<TESTS;i++) {
        us=unsigned2(values[i]);
        }
    b=System.nanoTime();
        System.out.println("Time for "+TESTS+" byte to \"unsigned byte\" casts (with log. function)"+((b-a)/1e09));
        
        a=System.nanoTime();
        for (int i=0;i<TESTS;i++) {
        ub=values[i];
        us= (char) ub;
    }
    b=System.nanoTime();
        System.out.println("Time for "+TESTS+" byte to \"unsigned byte\" casts (no casting)"+((b-a)/1e09));
        
}
    public static final char unsigned(byte b){
        return (char) ((b>0)?b:(-b+128));
    }
    
    public static char unsigned2(byte b){
        return (char) (0x00FF&b);
    }
    }
    
package testers;

import m.DoomRandom;
import m.IRandom;
import s.ClassicDoomSoundDriver;
import s.ClipSFXModule;
import s.SpeakerDoomSoundDriver;
import data.sounds.sfxenum_t;
import doom.DoomStatus;
import w.WadLoader;

public class TestClipSound {
	public static void main(String[] argv) throws Exception{

	DoomStatus DS=new DoomStatus();
	
	
	WadLoader W=new WadLoader();
	IRandom RND=new DoomRandom();
	
	DS.W=W;
	DS.RND=RND;
	W.InitMultipleFiles(new String[]{"doom1.wad"});
	
	ClipSFXModule sound=new ClipSFXModule(DS,4);
	
	sound.InitSound();
	sound.SetChannels(4);
	
	Thread.sleep(1000);
	//sound.StartSound(1, 127, 127, 127, 0);
	for (int i=0;i<1000;i++){
	    
	    Thread.sleep(1000/35);

	    if (i%70==0) sound.StartSound(sfxenum_t.sfx_plpain.ordinal(), 127, 127, 127, 0);
	    if (i%90==0) sound.StartSound(sfxenum_t.sfx_barexp.ordinal(), 127, 0, 127, 0);
	    if (i%35==0) sound.StartSound(sfxenum_t.sfx_plpain.ordinal(), 127, 255, 127, 0);
	    if (i%35==0) sound.StartSound(sfxenum_t.sfx_oof.ordinal(), 127, 192, 127, 0);
	    sound.UpdateSound();
	    
	    sound.SubmitSound();
	    
	       System.out.println(DS.gametic++);
	}
	sound.ShutdownSound();
	}
	
}

package testers;

import p.Actions;
import p.mobj_t;
import pooling.AudioChunkPool;
import pooling.MobjPool;
import s.AudioChunk;

public class TestMobjPooling {
    public static final int TESTS=1000000;
    
    public static void main(String[] argv){
    
    mobj_t[] chunks=new mobj_t[TESTS];
    MobjPool chunkpool=new MobjPool(new Actions());
    
    long a=System.nanoTime();
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=new mobj_t();
    }

    for (int i=0;i<TESTS;i++){
        chunks[i]=new mobj_t();
    }
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=new mobj_t();
    }
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=new mobj_t();
    }
    long b=System.nanoTime();
    
    System.out.println("Time: "+(float)(b-a)/1000000000f);
    
    a=System.nanoTime();
    
    for (int i=0;i<TESTS;i++){
        chunks[i]=chunkpool.checkOut();
    }

    for (int i=0;i<TESTS;i++){
        chunkpool.checkIn(chunks[i]);
        chunks[i]=chunkpool.checkOut();
    }
    
    for (int i=0;i<TESTS;i++){
        chunkpool.checkIn(chunks[i]);
        chunks[i]=chunkpool.checkOut();
    }
    
    for (int i=0;i<TESTS;i++){
        chunkpool.checkIn(chunks[i]);
        chunks[i]=chunkpool.checkOut();
    }
    b=System.nanoTime();
    
    System.out.println("Time: "+(float)(b-a)/1000000000f);
    
    
    }
    

}

package testers;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import javax.imageio.ImageIO;

public class PaletteShower12 {

    public static final int BLOCKSIZE=16;
    public static final int SHIFT=4;
    
    public static void main(String[] argv) {
        try {
    BufferedInputStream bis;
    bis=new BufferedInputStream(new FileInputStream(argv[0]));
    
    int size=bis.available();
    
    int blocks=size/512;
    
    
    byte[] palbuf=new byte[512];
    ByteBuffer bb= ByteBuffer.wrap(palbuf);
    bb.order(ByteOrder.LITTLE_ENDIAN);
    bb.mark();
    for (int i=0;i<blocks;i++){
        bis.read(palbuf);
        
        BufferedImage bim=new BufferedImage(16*BLOCKSIZE,16*BLOCKSIZE,BufferedImage.TYPE_INT_ARGB);
        
            for (int j=0;j<256;j++){
                short shcol=bb.getShort();
                int r=(0xF000&shcol)>>12;
                int g=(0xF00&shcol)>>8;
                int b=(0xF0&shcol)>>4;
                System.out.printf("%x %d %d %d\n",shcol,r,g,b);
                int colo=  0xFF000000|(r<<(16+SHIFT))|
                            (g<<(8+SHIFT))|
                            (b<<SHIFT);
            
            for (int x=0;x<BLOCKSIZE;x++){
                for (int y=0;y<BLOCKSIZE;y++){
                    bim.setRGB(BLOCKSIZE*(j%16)+x, BLOCKSIZE*(j/16)+y, colo);
                }
            }
            
        }
        
        FileOutputStream f=new FileOutputStream(String.format("%s-%d.PNG",argv[0],i));
        
        ImageIO.write(bim,"PNG",f);
        bb.reset();
        }
    
        bis.close();
    
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
}

package defines;

/** Mission packs - might be useful for TC stuff?
 * 
 */
public enum GameMission_t 
{
  doom,     // DOOM 1
  doom2,    // DOOM 2
  pack_tnt, // TNT mission pack
  pack_plut,    // Plutonia pack
  none
}

package defines;

/** Move clipping aid for LineDefs. */

public enum slopetype_t
{
ST_HORIZONTAL,
ST_VERTICAL,
ST_POSITIVE,
ST_NEGATIVE

} 

package defines;


public enum skill_t
{
    sk_baby,
    sk_easy,
    sk_medium,
    sk_hard,
    sk_nightmare
}

package defines;

/** The current state of the game: whether we are
    playing, gazing at the intermission screen,    
    the game final animation, or a demo. */ 
public enum gamestate_t
{
 GS_LEVEL,
 GS_INTERMISSION,
 GS_FINALE,
 GS_DEMOSCREEN,
 GS_MINUS_ONE // hack used for the "-1" state
}

package defines;

/**
 *  Key cards.
 */
public enum card_t
{
 it_bluecard,
 it_yellowcard,
 it_redcard,
 it_blueskull,
 it_yellowskull,
 it_redskull,
 
 NUMCARDS
 
}

package defines;

//Ammunition types defined.
public enum ammotype_t
{
    am_clip,    // Pistol / chaingun ammo.
    am_shell,   // Shotgun / double barreled shotgun.
    am_cell,    // Plasma rifle, BFG.
    am_misl,    // Missile launcher.
    NUMAMMO,
    am_noammo   // Unlimited for chainsaw / fist.   

}
package defines;

/** Identify language to use, software localization. */
public enum Language_t {
    english,
    french,
    german,
    unknown
    }


package defines;


/** Game mode handling - identify IWAD version
  to handle IWAD dependend animations etc.
  */
public enum GameMode_t 
{
shareware,    // DOOM 1 shareware, E1, M9
registered,   // DOOM 1 registered, E3, M27
commercial,   // DOOM 2 retail, E1 M34
// DOOM 2 german edition not handled
retail,   // DOOM 1 retail, E4, M36
pack_tnt, // TNT mission pack
pack_plut,    // Plutonia pack
pack_xbla,    // XBLA Doom. How you got hold of it, I don't care :-p
indetermined  // Well, no IWAD found.  
} ;

package defines;

public enum statenum_t {
    S_NULL,
    S_LIGHTDONE,
    S_PUNCH,
    S_PUNCHDOWN,
    S_PUNCHUP,
    S_PUNCH1,
    S_PUNCH2,
    S_PUNCH3,
    S_PUNCH4,
    S_PUNCH5,
    S_PISTOL,
    S_PISTOLDOWN,
    S_PISTOLUP,
    S_PISTOL1,
    S_PISTOL2,
    S_PISTOL3,
    S_PISTOL4,
    S_PISTOLFLASH,
    S_SGUN,
    S_SGUNDOWN,
    S_SGUNUP,
    S_SGUN1,
    S_SGUN2,
    S_SGUN3,
    S_SGUN4,
    S_SGUN5,
    S_SGUN6,
    S_SGUN7,
    S_SGUN8,
    S_SGUN9,
    S_SGUNFLASH1,
    S_SGUNFLASH2,
    S_DSGUN,
    S_DSGUNDOWN,
    S_DSGUNUP,
    S_DSGUN1,
    S_DSGUN2,
    S_DSGUN3,
    S_DSGUN4,
    S_DSGUN5,
    S_DSGUN6,
    S_DSGUN7,
    S_DSGUN8,
    S_DSGUN9,
    S_DSGUN10,
    S_DSNR1,
    S_DSNR2,
    S_DSGUNFLASH1,
    S_DSGUNFLASH2,
    S_CHAIN,
    S_CHAINDOWN,
    S_CHAINUP,
    S_CHAIN1,
    S_CHAIN2,
    S_CHAIN3,
    S_CHAINFLASH1,
    S_CHAINFLASH2,
    S_MISSILE,
    S_MISSILEDOWN,
    S_MISSILEUP,
    S_MISSILE1,
    S_MISSILE2,
    S_MISSILE3,
    S_MISSILEFLASH1,
    S_MISSILEFLASH2,
    S_MISSILEFLASH3,
    S_MISSILEFLASH4,
    S_SAW,
    S_SAWB,
    S_SAWDOWN,
    S_SAWUP,
    S_SAW1,
    S_SAW2,
    S_SAW3,
    S_PLASMA,
    S_PLASMADOWN,
    S_PLASMAUP,
    S_PLASMA1,
    S_PLASMA2,
    S_PLASMAFLASH1,
    S_PLASMAFLASH2,
    S_BFG,
    S_BFGDOWN,
    S_BFGUP,
    S_BFG1,
    S_BFG2,
    S_BFG3,
    S_BFG4,
    S_BFGFLASH1,
    S_BFGFLASH2,
    S_BLOOD1,
    S_BLOOD2,
    S_BLOOD3,
    S_PUFF1,
    S_PUFF2,
    S_PUFF3,
    S_PUFF4,
    S_TBALL1,
    S_TBALL2,
    S_TBALLX1,
    S_TBALLX2,
    S_TBALLX3,
    S_RBALL1,
    S_RBALL2,
    S_RBALLX1,
    S_RBALLX2,
    S_RBALLX3,
    S_PLASBALL,
    S_PLASBALL2,
    S_PLASEXP,
    S_PLASEXP2,
    S_PLASEXP3,
    S_PLASEXP4,
    S_PLASEXP5,
    S_ROCKET,
    S_BFGSHOT,
    S_BFGSHOT2,
    S_BFGLAND,
    S_BFGLAND2,
    S_BFGLAND3,
    S_BFGLAND4,
    S_BFGLAND5,
    S_BFGLAND6,
    S_BFGEXP,
    S_BFGEXP2,
    S_BFGEXP3,
    S_BFGEXP4,
    S_EXPLODE1,
    S_EXPLODE2,
    S_EXPLODE3,
    S_TFOG,
    S_TFOG01,
    S_TFOG02,
    S_TFOG2,
    S_TFOG3,
    S_TFOG4,
    S_TFOG5,
    S_TFOG6,
    S_TFOG7,
    S_TFOG8,
    S_TFOG9,
    S_TFOG10,
    S_IFOG,
    S_IFOG01,
    S_IFOG02,
    S_IFOG2,
    S_IFOG3,
    S_IFOG4,
    S_IFOG5,
    S_PLAY,
    S_PLAY_RUN1,
    S_PLAY_RUN2,
    S_PLAY_RUN3,
    S_PLAY_RUN4,
    S_PLAY_ATK1,
    S_PLAY_ATK2,
    S_PLAY_PAIN,
    S_PLAY_PAIN2,
    S_PLAY_DIE1,
    S_PLAY_DIE2,
    S_PLAY_DIE3,
    S_PLAY_DIE4,
    S_PLAY_DIE5,
    S_PLAY_DIE6,
    S_PLAY_DIE7,
    S_PLAY_XDIE1,
    S_PLAY_XDIE2,
    S_PLAY_XDIE3,
    S_PLAY_XDIE4,
    S_PLAY_XDIE5,
    S_PLAY_XDIE6,
    S_PLAY_XDIE7,
    S_PLAY_XDIE8,
    S_PLAY_XDIE9,
    S_POSS_STND,
    S_POSS_STND2,
    S_POSS_RUN1,
    S_POSS_RUN2,
    S_POSS_RUN3,
    S_POSS_RUN4,
    S_POSS_RUN5,
    S_POSS_RUN6,
    S_POSS_RUN7,
    S_POSS_RUN8,
    S_POSS_ATK1,
    S_POSS_ATK2,
    S_POSS_ATK3,
    S_POSS_PAIN,
    S_POSS_PAIN2,
    S_POSS_DIE1,
    S_POSS_DIE2,
    S_POSS_DIE3,
    S_POSS_DIE4,
    S_POSS_DIE5,
    S_POSS_XDIE1,
    S_POSS_XDIE2,
    S_POSS_XDIE3,
    S_POSS_XDIE4,
    S_POSS_XDIE5,
    S_POSS_XDIE6,
    S_POSS_XDIE7,
    S_POSS_XDIE8,
    S_POSS_XDIE9,
    S_POSS_RAISE1,
    S_POSS_RAISE2,
    S_POSS_RAISE3,
    S_POSS_RAISE4,
    S_SPOS_STND,
    S_SPOS_STND2,
    S_SPOS_RUN1,
    S_SPOS_RUN2,
    S_SPOS_RUN3,
    S_SPOS_RUN4,
    S_SPOS_RUN5,
    S_SPOS_RUN6,
    S_SPOS_RUN7,
    S_SPOS_RUN8,
    S_SPOS_ATK1,
    S_SPOS_ATK2,
    S_SPOS_ATK3,
    S_SPOS_PAIN,
    S_SPOS_PAIN2,
    S_SPOS_DIE1,
    S_SPOS_DIE2,
    S_SPOS_DIE3,
    S_SPOS_DIE4,
    S_SPOS_DIE5,
    S_SPOS_XDIE1,
    S_SPOS_XDIE2,
    S_SPOS_XDIE3,
    S_SPOS_XDIE4,
    S_SPOS_XDIE5,
    S_SPOS_XDIE6,
    S_SPOS_XDIE7,
    S_SPOS_XDIE8,
    S_SPOS_XDIE9,
    S_SPOS_RAISE1,
    S_SPOS_RAISE2,
    S_SPOS_RAISE3,
    S_SPOS_RAISE4,
    S_SPOS_RAISE5,
    S_VILE_STND,
    S_VILE_STND2,
    S_VILE_RUN1,
    S_VILE_RUN2,
    S_VILE_RUN3,
    S_VILE_RUN4,
    S_VILE_RUN5,
    S_VILE_RUN6,
    S_VILE_RUN7,
    S_VILE_RUN8,
    S_VILE_RUN9,
    S_VILE_RUN10,
    S_VILE_RUN11,
    S_VILE_RUN12,
    S_VILE_ATK1,
    S_VILE_ATK2,
    S_VILE_ATK3,
    S_VILE_ATK4,
    S_VILE_ATK5,
    S_VILE_ATK6,
    S_VILE_ATK7,
    S_VILE_ATK8,
    S_VILE_ATK9,
    S_VILE_ATK10,
    S_VILE_ATK11,
    S_VILE_HEAL1,
    S_VILE_HEAL2,
    S_VILE_HEAL3,
    S_VILE_PAIN,
    S_VILE_PAIN2,
    S_VILE_DIE1,
    S_VILE_DIE2,
    S_VILE_DIE3,
    S_VILE_DIE4,
    S_VILE_DIE5,
    S_VILE_DIE6,
    S_VILE_DIE7,
    S_VILE_DIE8,
    S_VILE_DIE9,
    S_VILE_DIE10,
    S_FIRE1,
    S_FIRE2,
    S_FIRE3,
    S_FIRE4,
    S_FIRE5,
    S_FIRE6,
    S_FIRE7,
    S_FIRE8,
    S_FIRE9,
    S_FIRE10,
    S_FIRE11,
    S_FIRE12,
    S_FIRE13,
    S_FIRE14,
    S_FIRE15,
    S_FIRE16,
    S_FIRE17,
    S_FIRE18,
    S_FIRE19,
    S_FIRE20,
    S_FIRE21,
    S_FIRE22,
    S_FIRE23,
    S_FIRE24,
    S_FIRE25,
    S_FIRE26,
    S_FIRE27,
    S_FIRE28,
    S_FIRE29,
    S_FIRE30,
    S_SMOKE1,
    S_SMOKE2,
    S_SMOKE3,
    S_SMOKE4,
    S_SMOKE5,
    S_TRACER,
    S_TRACER2,
    S_TRACEEXP1,
    S_TRACEEXP2,
    S_TRACEEXP3,
    S_SKEL_STND,
    S_SKEL_STND2,
    S_SKEL_RUN1,
    S_SKEL_RUN2,
    S_SKEL_RUN3,
    S_SKEL_RUN4,
    S_SKEL_RUN5,
    S_SKEL_RUN6,
    S_SKEL_RUN7,
    S_SKEL_RUN8,
    S_SKEL_RUN9,
    S_SKEL_RUN10,
    S_SKEL_RUN11,
    S_SKEL_RUN12,
    S_SKEL_FIST1,
    S_SKEL_FIST2,
    S_SKEL_FIST3,
    S_SKEL_FIST4,
    S_SKEL_MISS1,
    S_SKEL_MISS2,
    S_SKEL_MISS3,
    S_SKEL_MISS4,
    S_SKEL_PAIN,
    S_SKEL_PAIN2,
    S_SKEL_DIE1,
    S_SKEL_DIE2,
    S_SKEL_DIE3,
    S_SKEL_DIE4,
    S_SKEL_DIE5,
    S_SKEL_DIE6,
    S_SKEL_RAISE1,
    S_SKEL_RAISE2,
    S_SKEL_RAISE3,
    S_SKEL_RAISE4,
    S_SKEL_RAISE5,
    S_SKEL_RAISE6,
    S_FATSHOT1,
    S_FATSHOT2,
    S_FATSHOTX1,
    S_FATSHOTX2,
    S_FATSHOTX3,
    S_FATT_STND,
    S_FATT_STND2,
    S_FATT_RUN1,
    S_FATT_RUN2,
    S_FATT_RUN3,
    S_FATT_RUN4,
    S_FATT_RUN5,
    S_FATT_RUN6,
    S_FATT_RUN7,
    S_FATT_RUN8,
    S_FATT_RUN9,
    S_FATT_RUN10,
    S_FATT_RUN11,
    S_FATT_RUN12,
    S_FATT_ATK1,
    S_FATT_ATK2,
    S_FATT_ATK3,
    S_FATT_ATK4,
    S_FATT_ATK5,
    S_FATT_ATK6,
    S_FATT_ATK7,
    S_FATT_ATK8,
    S_FATT_ATK9,
    S_FATT_ATK10,
    S_FATT_PAIN,
    S_FATT_PAIN2,
    S_FATT_DIE1,
    S_FATT_DIE2,
    S_FATT_DIE3,
    S_FATT_DIE4,
    S_FATT_DIE5,
    S_FATT_DIE6,
    S_FATT_DIE7,
    S_FATT_DIE8,
    S_FATT_DIE9,
    S_FATT_DIE10,
    S_FATT_RAISE1,
    S_FATT_RAISE2,
    S_FATT_RAISE3,
    S_FATT_RAISE4,
    S_FATT_RAISE5,
    S_FATT_RAISE6,
    S_FATT_RAISE7,
    S_FATT_RAISE8,
    S_CPOS_STND,
    S_CPOS_STND2,
    S_CPOS_RUN1,
    S_CPOS_RUN2,
    S_CPOS_RUN3,
    S_CPOS_RUN4,
    S_CPOS_RUN5,
    S_CPOS_RUN6,
    S_CPOS_RUN7,
    S_CPOS_RUN8,
    S_CPOS_ATK1,
    S_CPOS_ATK2,
    S_CPOS_ATK3,
    S_CPOS_ATK4,
    S_CPOS_PAIN,
    S_CPOS_PAIN2,
    S_CPOS_DIE1,
    S_CPOS_DIE2,
    S_CPOS_DIE3,
    S_CPOS_DIE4,
    S_CPOS_DIE5,
    S_CPOS_DIE6,
    S_CPOS_DIE7,
    S_CPOS_XDIE1,
    S_CPOS_XDIE2,
    S_CPOS_XDIE3,
    S_CPOS_XDIE4,
    S_CPOS_XDIE5,
    S_CPOS_XDIE6,
    S_CPOS_RAISE1,
    S_CPOS_RAISE2,
    S_CPOS_RAISE3,
    S_CPOS_RAISE4,
    S_CPOS_RAISE5,
    S_CPOS_RAISE6,
    S_CPOS_RAISE7,
    S_TROO_STND,
    S_TROO_STND2,
    S_TROO_RUN1,
    S_TROO_RUN2,
    S_TROO_RUN3,
    S_TROO_RUN4,
    S_TROO_RUN5,
    S_TROO_RUN6,
    S_TROO_RUN7,
    S_TROO_RUN8,
    S_TROO_ATK1,
    S_TROO_ATK2,
    S_TROO_ATK3,
    S_TROO_PAIN,
    S_TROO_PAIN2,
    S_TROO_DIE1,
    S_TROO_DIE2,
    S_TROO_DIE3,
    S_TROO_DIE4,
    S_TROO_DIE5,
    S_TROO_XDIE1,
    S_TROO_XDIE2,
    S_TROO_XDIE3,
    S_TROO_XDIE4,
    S_TROO_XDIE5,
    S_TROO_XDIE6,
    S_TROO_XDIE7,
    S_TROO_XDIE8,
    S_TROO_RAISE1,
    S_TROO_RAISE2,
    S_TROO_RAISE3,
    S_TROO_RAISE4,
    S_TROO_RAISE5,
    S_SARG_STND,
    S_SARG_STND2,
    S_SARG_RUN1,
    S_SARG_RUN2,
    S_SARG_RUN3,
    S_SARG_RUN4,
    S_SARG_RUN5,
    S_SARG_RUN6,
    S_SARG_RUN7,
    S_SARG_RUN8,
    S_SARG_ATK1,
    S_SARG_ATK2,
    S_SARG_ATK3,
    S_SARG_PAIN,
    S_SARG_PAIN2,
    S_SARG_DIE1,
    S_SARG_DIE2,
    S_SARG_DIE3,
    S_SARG_DIE4,
    S_SARG_DIE5,
    S_SARG_DIE6,
    S_SARG_RAISE1,
    S_SARG_RAISE2,
    S_SARG_RAISE3,
    S_SARG_RAISE4,
    S_SARG_RAISE5,
    S_SARG_RAISE6,
    S_HEAD_STND,
    S_HEAD_RUN1,
    S_HEAD_ATK1,
    S_HEAD_ATK2,
    S_HEAD_ATK3,
    S_HEAD_PAIN,
    S_HEAD_PAIN2,
    S_HEAD_PAIN3,
    S_HEAD_DIE1,
    S_HEAD_DIE2,
    S_HEAD_DIE3,
    S_HEAD_DIE4,
    S_HEAD_DIE5,
    S_HEAD_DIE6,
    S_HEAD_RAISE1,
    S_HEAD_RAISE2,
    S_HEAD_RAISE3,
    S_HEAD_RAISE4,
    S_HEAD_RAISE5,
    S_HEAD_RAISE6,
    S_BRBALL1,
    S_BRBALL2,
    S_BRBALLX1,
    S_BRBALLX2,
    S_BRBALLX3,
    S_BOSS_STND,
    S_BOSS_STND2,
    S_BOSS_RUN1,
    S_BOSS_RUN2,
    S_BOSS_RUN3,
    S_BOSS_RUN4,
    S_BOSS_RUN5,
    S_BOSS_RUN6,
    S_BOSS_RUN7,
    S_BOSS_RUN8,
    S_BOSS_ATK1,
    S_BOSS_ATK2,
    S_BOSS_ATK3,
    S_BOSS_PAIN,
    S_BOSS_PAIN2,
    S_BOSS_DIE1,
    S_BOSS_DIE2,
    S_BOSS_DIE3,
    S_BOSS_DIE4,
    S_BOSS_DIE5,
    S_BOSS_DIE6,
    S_BOSS_DIE7,
    S_BOSS_RAISE1,
    S_BOSS_RAISE2,
    S_BOSS_RAISE3,
    S_BOSS_RAISE4,
    S_BOSS_RAISE5,
    S_BOSS_RAISE6,
    S_BOSS_RAISE7,
    S_BOS2_STND,
    S_BOS2_STND2,
    S_BOS2_RUN1,
    S_BOS2_RUN2,
    S_BOS2_RUN3,
    S_BOS2_RUN4,
    S_BOS2_RUN5,
    S_BOS2_RUN6,
    S_BOS2_RUN7,
    S_BOS2_RUN8,
    S_BOS2_ATK1,
    S_BOS2_ATK2,
    S_BOS2_ATK3,
    S_BOS2_PAIN,
    S_BOS2_PAIN2,
    S_BOS2_DIE1,
    S_BOS2_DIE2,
    S_BOS2_DIE3,
    S_BOS2_DIE4,
    S_BOS2_DIE5,
    S_BOS2_DIE6,
    S_BOS2_DIE7,
    S_BOS2_RAISE1,
    S_BOS2_RAISE2,
    S_BOS2_RAISE3,
    S_BOS2_RAISE4,
    S_BOS2_RAISE5,
    S_BOS2_RAISE6,
    S_BOS2_RAISE7,
    S_SKULL_STND,
    S_SKULL_STND2,
    S_SKULL_RUN1,
    S_SKULL_RUN2,
    S_SKULL_ATK1,
    S_SKULL_ATK2,
    S_SKULL_ATK3,
    S_SKULL_ATK4,
    S_SKULL_PAIN,
    S_SKULL_PAIN2,
    S_SKULL_DIE1,
    S_SKULL_DIE2,
    S_SKULL_DIE3,
    S_SKULL_DIE4,
    S_SKULL_DIE5,
    S_SKULL_DIE6,
    S_SPID_STND,
    S_SPID_STND2,
    S_SPID_RUN1,
    S_SPID_RUN2,
    S_SPID_RUN3,
    S_SPID_RUN4,
    S_SPID_RUN5,
    S_SPID_RUN6,
    S_SPID_RUN7,
    S_SPID_RUN8,
    S_SPID_RUN9,
    S_SPID_RUN10,
    S_SPID_RUN11,
    S_SPID_RUN12,
    S_SPID_ATK1,
    S_SPID_ATK2,
    S_SPID_ATK3,
    S_SPID_ATK4,
    S_SPID_PAIN,
    S_SPID_PAIN2,
    S_SPID_DIE1,
    S_SPID_DIE2,
    S_SPID_DIE3,
    S_SPID_DIE4,
    S_SPID_DIE5,
    S_SPID_DIE6,
    S_SPID_DIE7,
    S_SPID_DIE8,
    S_SPID_DIE9,
    S_SPID_DIE10,
    S_SPID_DIE11,
    S_BSPI_STND,
    S_BSPI_STND2,
    S_BSPI_SIGHT,
    S_BSPI_RUN1,
    S_BSPI_RUN2,
    S_BSPI_RUN3,
    S_BSPI_RUN4,
    S_BSPI_RUN5,
    S_BSPI_RUN6,
    S_BSPI_RUN7,
    S_BSPI_RUN8,
    S_BSPI_RUN9,
    S_BSPI_RUN10,
    S_BSPI_RUN11,
    S_BSPI_RUN12,
    S_BSPI_ATK1,
    S_BSPI_ATK2,
    S_BSPI_ATK3,
    S_BSPI_ATK4,
    S_BSPI_PAIN,
    S_BSPI_PAIN2,
    S_BSPI_DIE1,
    S_BSPI_DIE2,
    S_BSPI_DIE3,
    S_BSPI_DIE4,
    S_BSPI_DIE5,
    S_BSPI_DIE6,
    S_BSPI_DIE7,
    S_BSPI_RAISE1,
    S_BSPI_RAISE2,
    S_BSPI_RAISE3,
    S_BSPI_RAISE4,
    S_BSPI_RAISE5,
    S_BSPI_RAISE6,
    S_BSPI_RAISE7,
    S_ARACH_PLAZ,
    S_ARACH_PLAZ2,
    S_ARACH_PLEX,
    S_ARACH_PLEX2,
    S_ARACH_PLEX3,
    S_ARACH_PLEX4,
    S_ARACH_PLEX5,
    S_CYBER_STND,
    S_CYBER_STND2,
    S_CYBER_RUN1,
    S_CYBER_RUN2,
    S_CYBER_RUN3,
    S_CYBER_RUN4,
    S_CYBER_RUN5,
    S_CYBER_RUN6,
    S_CYBER_RUN7,
    S_CYBER_RUN8,
    S_CYBER_ATK1,
    S_CYBER_ATK2,
    S_CYBER_ATK3,
    S_CYBER_ATK4,
    S_CYBER_ATK5,
    S_CYBER_ATK6,
    S_CYBER_PAIN,
    S_CYBER_DIE1,
    S_CYBER_DIE2,
    S_CYBER_DIE3,
    S_CYBER_DIE4,
    S_CYBER_DIE5,
    S_CYBER_DIE6,
    S_CYBER_DIE7,
    S_CYBER_DIE8,
    S_CYBER_DIE9,
    S_CYBER_DIE10,
    S_PAIN_STND,
    S_PAIN_RUN1,
    S_PAIN_RUN2,
    S_PAIN_RUN3,
    S_PAIN_RUN4,
    S_PAIN_RUN5,
    S_PAIN_RUN6,
    S_PAIN_ATK1,
    S_PAIN_ATK2,
    S_PAIN_ATK3,
    S_PAIN_ATK4,
    S_PAIN_PAIN,
    S_PAIN_PAIN2,
    S_PAIN_DIE1,
    S_PAIN_DIE2,
    S_PAIN_DIE3,
    S_PAIN_DIE4,
    S_PAIN_DIE5,
    S_PAIN_DIE6,
    S_PAIN_RAISE1,
    S_PAIN_RAISE2,
    S_PAIN_RAISE3,
    S_PAIN_RAISE4,
    S_PAIN_RAISE5,
    S_PAIN_RAISE6,
    S_SSWV_STND,
    S_SSWV_STND2,
    S_SSWV_RUN1,
    S_SSWV_RUN2,
    S_SSWV_RUN3,
    S_SSWV_RUN4,
    S_SSWV_RUN5,
    S_SSWV_RUN6,
    S_SSWV_RUN7,
    S_SSWV_RUN8,
    S_SSWV_ATK1,
    S_SSWV_ATK2,
    S_SSWV_ATK3,
    S_SSWV_ATK4,
    S_SSWV_ATK5,
    S_SSWV_ATK6,
    S_SSWV_PAIN,
    S_SSWV_PAIN2,
    S_SSWV_DIE1,
    S_SSWV_DIE2,
    S_SSWV_DIE3,
    S_SSWV_DIE4,
    S_SSWV_DIE5,
    S_SSWV_XDIE1,
    S_SSWV_XDIE2,
    S_SSWV_XDIE3,
    S_SSWV_XDIE4,
    S_SSWV_XDIE5,
    S_SSWV_XDIE6,
    S_SSWV_XDIE7,
    S_SSWV_XDIE8,
    S_SSWV_XDIE9,
    S_SSWV_RAISE1,
    S_SSWV_RAISE2,
    S_SSWV_RAISE3,
    S_SSWV_RAISE4,
    S_SSWV_RAISE5,
    S_KEENSTND,
    S_COMMKEEN,
    S_COMMKEEN2,
    S_COMMKEEN3,
    S_COMMKEEN4,
    S_COMMKEEN5,
    S_COMMKEEN6,
    S_COMMKEEN7,
    S_COMMKEEN8,
    S_COMMKEEN9,
    S_COMMKEEN10,
    S_COMMKEEN11,
    S_COMMKEEN12,
    S_KEENPAIN,
    S_KEENPAIN2,
    S_BRAIN,
    S_BRAIN_PAIN,
    S_BRAIN_DIE1,
    S_BRAIN_DIE2,
    S_BRAIN_DIE3,
    S_BRAIN_DIE4,
    S_BRAINEYE,
    S_BRAINEYESEE,
    S_BRAINEYE1,
    S_SPAWN1,
    S_SPAWN2,
    S_SPAWN3,
    S_SPAWN4,
    S_SPAWNFIRE1,
    S_SPAWNFIRE2,
    S_SPAWNFIRE3,
    S_SPAWNFIRE4,
    S_SPAWNFIRE5,
    S_SPAWNFIRE6,
    S_SPAWNFIRE7,
    S_SPAWNFIRE8,
    S_BRAINEXPLODE1,
    S_BRAINEXPLODE2,
    S_BRAINEXPLODE3,
    S_ARM1,
    S_ARM1A,
    S_ARM2,
    S_ARM2A,
    S_BAR1,
    S_BAR2,
    S_BEXP,
    S_BEXP2,
    S_BEXP3,
    S_BEXP4,
    S_BEXP5,
    S_BBAR1,
    S_BBAR2,
    S_BBAR3,
    S_BON1,
    S_BON1A,
    S_BON1B,
    S_BON1C,
    S_BON1D,
    S_BON1E,
    S_BON2,
    S_BON2A,
    S_BON2B,
    S_BON2C,
    S_BON2D,
    S_BON2E,
    S_BKEY,
    S_BKEY2,
    S_RKEY,
    S_RKEY2,
    S_YKEY,
    S_YKEY2,
    S_BSKULL,
    S_BSKULL2,
    S_RSKULL,
    S_RSKULL2,
    S_YSKULL,
    S_YSKULL2,
    S_STIM,
    S_MEDI,
    S_SOUL,
    S_SOUL2,
    S_SOUL3,
    S_SOUL4,
    S_SOUL5,
    S_SOUL6,
    S_PINV,
    S_PINV2,
    S_PINV3,
    S_PINV4,
    S_PSTR,
    S_PINS,
    S_PINS2,
    S_PINS3,
    S_PINS4,
    S_MEGA,
    S_MEGA2,
    S_MEGA3,
    S_MEGA4,
    S_SUIT,
    S_PMAP,
    S_PMAP2,
    S_PMAP3,
    S_PMAP4,
    S_PMAP5,
    S_PMAP6,
    S_PVIS,
    S_PVIS2,
    S_CLIP,
    S_AMMO,
    S_ROCK,
    S_BROK,
    S_CELL,
    S_CELP,
    S_SHEL,
    S_SBOX,
    S_BPAK,
    S_BFUG,
    S_MGUN,
    S_CSAW,
    S_LAUN,
    S_PLAS,
    S_SHOT,
    S_SHOT2,
    S_COLU,
    S_STALAG,
    S_BLOODYTWITCH,
    S_BLOODYTWITCH2,
    S_BLOODYTWITCH3,
    S_BLOODYTWITCH4,
    S_DEADTORSO,
    S_DEADBOTTOM,
    S_HEADSONSTICK,
    S_GIBS,
    S_HEADONASTICK,
    S_HEADCANDLES,
    S_HEADCANDLES2,
    S_DEADSTICK,
    S_LIVESTICK,
    S_LIVESTICK2,
    S_MEAT2,
    S_MEAT3,
    S_MEAT4,
    S_MEAT5,
    S_STALAGTITE,
    S_TALLGRNCOL,
    S_SHRTGRNCOL,
    S_TALLREDCOL,
    S_SHRTREDCOL,
    S_CANDLESTIK,
    S_CANDELABRA,
    S_SKULLCOL,
    S_TORCHTREE,
    S_BIGTREE,
    S_TECHPILLAR,
    S_EVILEYE,
    S_EVILEYE2,
    S_EVILEYE3,
    S_EVILEYE4,
    S_FLOATSKULL,
    S_FLOATSKULL2,
    S_FLOATSKULL3,
    S_HEARTCOL,
    S_HEARTCOL2,
    S_BLUETORCH,
    S_BLUETORCH2,
    S_BLUETORCH3,
    S_BLUETORCH4,
    S_GREENTORCH,
    S_GREENTORCH2,
    S_GREENTORCH3,
    S_GREENTORCH4,
    S_REDTORCH,
    S_REDTORCH2,
    S_REDTORCH3,
    S_REDTORCH4,
    S_BTORCHSHRT,
    S_BTORCHSHRT2,
    S_BTORCHSHRT3,
    S_BTORCHSHRT4,
    S_GTORCHSHRT,
    S_GTORCHSHRT2,
    S_GTORCHSHRT3,
    S_GTORCHSHRT4,
    S_RTORCHSHRT,
    S_RTORCHSHRT2,
    S_RTORCHSHRT3,
    S_RTORCHSHRT4,
    S_HANGNOGUTS,
    S_HANGBNOBRAIN,
    S_HANGTLOOKDN,
    S_HANGTSKULL,
    S_HANGTLOOKUP,
    S_HANGTNOBRAIN,
    S_COLONGIBS,
    S_SMALLPOOL,
    S_BRAINSTEM,
    S_TECHLAMP,
    S_TECHLAMP2,
    S_TECHLAMP3,
    S_TECHLAMP4,
    S_TECH2LAMP,
    S_TECH2LAMP2,
    S_TECH2LAMP3,
    S_TECH2LAMP4,
    NUMSTATES   
}
package automap;

import i.DoomStatusAware;
import v.IVideoScaleAware;
import doom.event_t;

public interface IAutoMap<T,V> extends IVideoScaleAware, DoomStatusAware{
 // Used by ST StatusBar stuff.
    public final int AM_MSGHEADER =(('a'<<24)+('m'<<16));
    public final int AM_MSGENTERED= (AM_MSGHEADER | ('e'<<8));
    public final int AM_MSGEXITED= (AM_MSGHEADER | ('x'<<8));

    // Color ranges for automap. Actual colors are bit-depth dependent.
    
    public final int REDRANGE= 16;
    public final int BLUERANGE   =8;
    public final int GREENRANGE  =16;
    public final int GRAYSRANGE  =16;
    public final int BROWNRANGE  =16;
    public final int YELLOWRANGE =1;
    
    public final int YOURRANGE   =0;
    public final int WALLRANGE   =REDRANGE;
    public final int TSWALLRANGE =GRAYSRANGE;
    public final int FDWALLRANGE =BROWNRANGE;
    public final int CDWALLRANGE =YELLOWRANGE;
    public final int THINGRANGE  =GREENRANGE;
    public final int SECRETWALLRANGE =WALLRANGE;
    public final int GRIDRANGE   =0;
    
    // Called by main loop.
    public boolean Responder (event_t ev);

    // Called by main loop.
    public void Ticker ();

    // Called by main loop,
    // called instead of view drawer if automap active.
    public void  Drawer ();

    // Called to force the automap to quit
    // if the level is completed while it is up.
    public void  Stop ();

    public void Start();

    // Should be called in order to set a proper scaled buffer.
    public void Init();
    
}

package automap;

/** used only in automap */

public class mline_t
{
    public mline_t(){
        this(0,0,0,0);
    }
    
    public int ax,ay,bx,by;

    public mline_t(int ax, int ay, int bx, int by) {
        this.ax = ax;
        this.ay = ay;
        this.bx = bx;
        this.by = by;
    }
    
    public mline_t(double ax, double ay, double bx, double by) {
        this.ax = (int) ax;
        this.ay = (int) ay;
        this.bx = (int) bx;
        this.by = (int) by;
    }
    
    /*
    public mline_t(mpoint_t a, mpoint_t b) {
        this.a = a;
        this.b = b;
    }

    public mline_t(int ax,int ay,int bx,int by) {
        this.a = new mpoint_t(ax,ay);
        this.b = new mpoint_t(bx,by);
    }
        
    public mline_t(double ax,double ay,double bx,double by) {
        this.a = new mpoint_t(ax,ay);
        this.b = new mpoint_t(bx,by);
    }
    
    public mpoint_t a, b;
    public int ax;
    
    public String toString(){
        return a.toString()+" - "+ b.toString();
    }
    */
}

package automap;

public class fpoint_t
{
    int x, y;
    
    public fpoint_t(){
        this(0,0);
    }
    
    public fpoint_t(int x, int y){
        this.x=x;
        this.y=y;
    }
    
}

package automap;

import m.fixed_t;

public class mpoint_t
{
  public mpoint_t(fixed_t x, fixed_t y) {
        this.x = x.val;
        this.y = y.val;
    }

  public mpoint_t(int x, int y) {
      this.x = x;
      this.y = y;
  }

  public mpoint_t(double x, double y) {
      this.x = (int) x;
      this.y = (int) y;
  }
  
  public mpoint_t(){
      this.x=0;
      this.y=0;
  }
  
  /** fixed_t */
  public int x,y;
  
  public String toString(){
      return (Integer.toHexString(x)+" , "+Integer.toHexString(y));
  }
};

package automap;

// Emacs style mode select -*- C++ -*-
// -----------------------------------------------------------------------------
//
// $Id: Map.java,v 1.37 2012/09/24 22:36:28 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
//
//
// $Log: Map.java,v $
// Revision 1.37  2012/09/24 22:36:28  velktron
// Map get color
//
// Revision 1.36  2012/09/24 17:16:23  velktron
// Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
// Revision 1.34.2.4  2012/09/24 16:58:06  velktron
// TrueColor, Generics.
//
// Revision 1.34.2.3  2012/09/20 14:06:43  velktron
// Generic automap
//
// Revision 1.34.2.2 2011/11/27 18:19:19 velktron
// Configurable colors, more parametrizable.
//
// Revision 1.34.2.1 2011/11/14 00:27:11 velktron
// A barely functional HiColor branch. Most stuff broken. DO NOT USE
//
// Revision 1.34 2011/11/03 18:11:14 velktron
// Fixed long-standing issue with 0-rot vector being reduced to pixels. Fixed
// broken map panning functionality after keymap change.
//
// Revision 1.33 2011/11/01 23:48:43 velktron
// Using FillRect
//
// Revision 1.32 2011/11/01 19:03:10 velktron
// Using screen number constants
//
// Revision 1.31 2011/10/23 18:10:32 velktron
// Generic compliance for DoomVideoInterface
//
// Revision 1.30 2011/10/07 16:08:23 velktron
// Now using g.Keys and line_t
//
// Revision 1.29 2011/09/29 13:25:09 velktron
// Eliminated "intermediate" AbstractAutoMap. Map implements IAutoMap directly.
//
// Revision 1.28 2011/07/28 16:35:03 velktron
// Well, we don't need to know that anymore.
//
// Revision 1.27 2011/06/18 23:16:34 velktron
// Added extreme scale safeguarding (e.g. for Europe.wad).
//
// Revision 1.26 2011/05/30 15:45:44 velktron
// AbstractAutoMap and IAutoMap
//
// Revision 1.25 2011/05/24 11:31:47 velktron
// Adapted to IDoomStatusBar
//
// Revision 1.24 2011/05/23 16:57:39 velktron
// Migrated to VideoScaleInfo.
//
// Revision 1.23 2011/05/17 16:50:02 velktron
// Switched to DoomStatus
//
// Revision 1.22 2011/05/10 10:39:18 velktron
// Semi-playable Techdemo v1.3 milestone
//
// Revision 1.21 2010/12/14 17:55:59 velktron
// Fixed weapon bobbing, added translucent column drawing, separated rendering
// commons.
//
// Revision 1.20 2010/12/12 19:06:18 velktron
// Tech Demo v1.1 release.
//
// Revision 1.19 2010/11/17 23:55:06 velktron
// Kind of playable/controllable.
//
// Revision 1.18 2010/11/12 13:37:25 velktron
// Rationalized the LUT system - now it's 100% procedurally generated.
//
// Revision 1.17 2010/10/01 16:47:51 velktron
// Fixed tab interception.
//
// Revision 1.16 2010/09/27 15:07:44 velktron
// meh
//
// Revision 1.15 2010/09/27 02:27:29 velktron
// BEASTLY update
//
// Revision 1.14 2010/09/23 07:31:11 velktron
// fuck
//
// Revision 1.13 2010/09/13 15:39:17 velktron
// Moving towards an unified gameplay approach...
//
// Revision 1.12 2010/09/08 21:09:01 velktron
// Better display "driver".
//
// Revision 1.11 2010/09/08 15:22:18 velktron
// x,y coords in some structs as value semantics. Possible speed increase?
//
// Revision 1.10 2010/09/06 16:02:59 velktron
// Implementation of palettes.
//
// Revision 1.9 2010/09/02 15:56:54 velktron
// Bulk of unified renderer copyediting done.
//
// Some changes like e.g. global separate limits class and instance methods for
// seg_t and node_t introduced.
//
// Revision 1.8 2010/09/01 15:53:42 velktron
// Graphics data loader implemented....still need to figure out how column
// caching works, though.
//
// Revision 1.7 2010/08/27 23:46:57 velktron
// Introduced Buffered renderer, which makes tapping directly into byte[] screen
// buffers mapped to BufferedImages possible.
//
// Revision 1.6 2010/08/26 16:43:42 velktron
// Automap functional, biatch.
//
// Revision 1.5 2010/08/25 00:50:59 velktron
// Some more work...
//
// Revision 1.4 2010/08/22 18:04:21 velktron
// Automap
//
// Revision 1.3 2010/08/19 23:14:49 velktron
// Automap
//
// Revision 1.2 2010/08/10 16:41:57 velktron
// Threw some work into map loading.
//
// Revision 1.1 2010/07/20 15:52:56 velktron
// LOTS of changes, Automap almost complete. Use of fixed_t inside methods
// severely limited.
//
// Revision 1.1 2010/06/30 08:58:51 velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still being worked on. For a good place to start and get an
// idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1 2010/06/29 11:07:34 velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete,
// and there's still mixed C code in there. I suggest you load everything up in
// Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you can get an idea of
// how a few of the implemented stuff works.
//
//
// DESCRIPTION: the automap code
//
// -----------------------------------------------------------------------------

import static g.Keys.*;
import static data.Limits.*;
import static m.fixed_t.*;
import static doom.englsh.*;
import static data.Tables.*;
import p.AbstractLevelLoader;
import p.mobj_t;
import doom.DoomMain;
import doom.DoomStatus;
import doom.event_t;
import doom.evtype_t;
import doom.player_t;
import rr.patch_t;
import st.IDoomStatusBar;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import static v.DoomVideoRenderer.V_NOSCALESTART;
import v.IVideoScale;
import w.IWadLoader;
import m.cheatseq_t;
import static rr.line_t.*;
import static data.Defines.*;

public abstract class Map<T, V>
        implements IAutoMap<T, V> {

    // ///////////////// Status objects ///////////////////

    IDoomStatusBar ST;

    IWadLoader W;

    DoomMain<T, V> DM;

    DoomVideoRenderer<T,V> V;

    AbstractLevelLoader LL;

    public final String rcsid =
        "$Id: Map.java,v 1.37 2012/09/24 22:36:28 velktron Exp $";

    // For use if I do walls with outsides/insides

    public int REDS, BLUES, GREENS, GRAYS, BROWNS, YELLOWS, BLACK, WHITE;

    // Automap colors
    public int BACKGROUND, YOURCOLORS, WALLCOLORS, TSWALLCOLORS, FDWALLCOLORS,
            CDWALLCOLORS, THINGCOLORS, SECRETWALLCOLORS, GRIDCOLORS,
            XHAIRCOLORS;

    // drawing stuff
    public static final int FB = 0;

    public static final char AM_PANDOWNKEY = KEY_DOWNARROW;

    public static final char AM_PANUPKEY = KEY_UPARROW;

    public static final char AM_PANRIGHTKEY = KEY_RIGHTARROW;

    public static final char AM_PANLEFTKEY = KEY_LEFTARROW;

    public static final char AM_ZOOMINKEY = '=';

    public static final char AM_ZOOMOUTKEY = '-';

    public static final char AM_STARTKEY = KEY_TAB; // KEY_TAB

    public static final char AM_ENDKEY = KEY_TAB; // KEY_TAB

    public static final char AM_GOBIGKEY = '0';

    public static final char AM_FOLLOWKEY = 'f';

    public static final char AM_GRIDKEY = 'g';

    public static final char AM_MARKKEY = 'm';

    public static final char AM_CLEARMARKKEY = 'c';

    public static final int AM_NUMMARKPOINTS = 10;

    // (fixed_t) scale on entry
    public static final int INITSCALEMTOF = (int) (.2 * FRACUNIT);

    // how much the automap moves window per tic in frame-buffer coordinates
    // moves 140 pixels in 1 second
    public static final int F_PANINC = 4;

    // how much zoom-in per tic
    // goes to 2x in 1 second
    public static final int M_ZOOMIN = ((int) (1.02 * FRACUNIT));

    // how much zoom-out per tic
    // pulls out to 0.5x in 1 second
    public static final int M_ZOOMOUT = ((int) (FRACUNIT / 1.02));

    public Map(DoomStatus<T, V> DS) {

        this.updateStatus(DS);
        // Some initializing...
        this.markpoints = new mpoint_t[AM_NUMMARKPOINTS];
        C2JUtils.initArrayOfObjects(markpoints, mpoint_t.class);

        f_oldloc = new mpoint_t();
        m_paninc = new mpoint_t();

        this.plr = DM.players[DM.displayplayer];

    }

    @Override
    public void Init() {

        // Use colormap-specific colors to support extended modes.
        // Moved hardcoding in here. Potentially configurable.

        REDS = 256 - 5 * 16;
        BLUES = 256 - 4 * 16 + 8;
        GREENS = 7 * 16;
        GRAYS = 6 * 16;
        BROWNS = 4 * 16;
        YELLOWS = 256 - 32 + 7;
        BLACK = 0;
        WHITE = 4;

        // Automap colors
        BACKGROUND = BLACK;
        YOURCOLORS = WHITE;
        WALLCOLORS = REDS;
        TSWALLCOLORS = GRAYS;
        FDWALLCOLORS = BROWNS;
        CDWALLCOLORS = YELLOWS;
        THINGCOLORS = GREENS;
        SECRETWALLCOLORS = WALLCOLORS;
        GRIDCOLORS = (GRAYS + GRAYSRANGE / 2);
        XHAIRCOLORS = GRAYS;

        their_colors = new int[] { GREENS, GRAYS, BROWNS, REDS };
    }

    /** translates between frame-buffer and map distances */
    private final int FTOM(int x) {
        return FixedMul(((x) << 16), scale_ftom);
    }

    /** translates between frame-buffer and map distances */
    private final int MTOF(int x) {
        return FixedMul((x), scale_mtof) >> 16;
    }

    /** translates between frame-buffer and map coordinates */
    private final int CXMTOF(int x) {
        return (f_x + MTOF((x) - m_x));
    }

    /** translates between frame-buffer and map coordinates */
    private final int CYMTOF(int y) {
        return (f_y + (f_h - MTOF((y) - m_y)));
    }

    // the following is crap
    public static final short LINE_NEVERSEE = ML_DONTDRAW;

    // This seems to be the minimum viable scale before things start breaking
    // up.
    private static final int MINIMUM_SCALE = (int) (0.7 * FRACUNIT);

    // This seems to be the limit for some maps like europe.wad
    private static final int MINIMUM_VIABLE_SCALE = FRACUNIT >> 5;

    //
    // The vector graphics for the automap.
    /**
     * A line drawing of the player pointing right, starting from the middle.
     */
    protected mline_t[] player_arrow;

    protected int NUMPLYRLINES;

    protected mline_t[] cheat_player_arrow;

    protected int NUMCHEATPLYRLINES;

    protected mline_t[] triangle_guy;

    protected int NUMTRIANGLEGUYLINES;

    protected mline_t[] thintriangle_guy;

    protected int NUMTHINTRIANGLEGUYLINES;

    protected void initVectorGraphics() {

        int R = ((8 * PLAYERRADIUS) / 7);
        player_arrow =
            new mline_t[] {
                    new mline_t(-R + R / 8, 0, R, 0), // -----
                    new mline_t(R, 0, R - R / 2, R / 4), // ----
                    new mline_t(R, 0, R - R / 2, -R / 4),
                    new mline_t(-R + R / 8, 0, -R - R / 8, R / 4), // >---
                    new mline_t(-R + R / 8, 0, -R - R / 8, -R / 4),
                    new mline_t(-R + 3 * R / 8, 0, -R + R / 8, R / 4), // >>--
                    new mline_t(-R + 3 * R / 8, 0, -R + R / 8, -R / 4) };

        NUMPLYRLINES = player_arrow.length;

        cheat_player_arrow =
            new mline_t[] {
                    new mline_t(-R + R / 8, 0, R, 0), // -----
                    new mline_t(R, 0, R - R / 2, R / 6), // ----
                    new mline_t(R, 0, R - R / 2, -R / 6),
                    new mline_t(-R + R / 8, 0, -R - R / 8, R / 6), // >----
                    new mline_t(-R + R / 8, 0, -R - R / 8, -R / 6),
                    new mline_t(-R + 3 * R / 8, 0, -R + R / 8, R / 6), // >>----
                    new mline_t(-R + 3 * R / 8, 0, -R + R / 8, -R / 6),
                    new mline_t(-R / 2, 0, -R / 2, -R / 6), // >>-d--
                    new mline_t(-R / 2, -R / 6, -R / 2 + R / 6, -R / 6),
                    new mline_t(-R / 2 + R / 6, -R / 6, -R / 2 + R / 6, R / 4),
                    new mline_t(-R / 6, 0, -R / 6, -R / 6), // >>-dd-
                    new mline_t(-R / 6, -R / 6, 0, -R / 6),
                    new mline_t(0, -R / 6, 0, R / 4),
                    new mline_t(R / 6, R / 4, R / 6, -R / 7), // >>-ddt
                    new mline_t(R / 6, -R / 7, R / 6 + R / 32, -R / 7 - R / 32),
                    new mline_t(R / 6 + R / 32, -R / 7 - R / 32,
                            R / 6 + R / 10, -R / 7) };

        NUMCHEATPLYRLINES = cheat_player_arrow.length;

        R = (FRACUNIT);
        triangle_guy =
            new mline_t[] { new mline_t(-.867 * R, -.5 * R, .867 * R, -.5 * R),
                    new mline_t(.867 * R, -.5 * R, 0, R),
                    new mline_t(0, R, -.867 * R, -.5 * R) };

        NUMTRIANGLEGUYLINES = triangle_guy.length;

        thintriangle_guy =
            new mline_t[] { new mline_t(-.5 * R, -.7 * R, R, 0),
                    new mline_t(R, 0, -.5 * R, .7 * R),
                    new mline_t(-.5 * R, .7 * R, -.5 * R, -.7 * R) };

        NUMTHINTRIANGLEGUYLINES = thintriangle_guy.length;
    }

    /** Planned overlay mode */
    protected int overlay = 0;

    protected int cheating = 0;

    protected boolean grid = false;

    protected int leveljuststarted = 1; // kluge until AM_LevelInit() is called

    protected int finit_width;

    protected int finit_height;

    // location of window on screen
    protected int f_x;

    protected int f_y;

    // size of window on screen
    protected int f_w;

    protected int f_h;

    /** used for funky strobing effect */
    protected int lightlev;

    /** pseudo-frame buffer */
    protected V fb;

    protected int amclock;

    /** (fixed_t) how far the window pans each tic (map coords) */
    protected mpoint_t m_paninc;

    /** (fixed_t) how far the window zooms in each tic (map coords) */
    protected int mtof_zoommul;

    /** (fixed_t) how far the window zooms in each tic (fb coords) */
    protected int ftom_zoommul;

    /** (fixed_t) LL x,y where the window is on the map (map coords) */
    protected int m_x, m_y;

    /** (fixed_t) UR x,y where the window is on the map (map coords) */
    protected int m_x2, m_y2;

    /** (fixed_t) width/height of window on map (map coords) */
    protected int m_w, m_h;

    /** (fixed_t) based on level size */
    protected int min_x, min_y, max_x, max_y;

    /** (fixed_t) max_x-min_x */
    protected int max_w; //

    /** (fixed_t) max_y-min_y */
    protected int max_h;

    /** (fixed_t) based on player size */
    protected int min_w, min_h;

    /** (fixed_t) used to tell when to stop zooming out */
    protected int min_scale_mtof;

    /** (fixed_t) used to tell when to stop zooming in */
    protected int max_scale_mtof;

    /** (fixed_t) old stuff for recovery later */
    protected int old_m_w, old_m_h, old_m_x, old_m_y;

    /** old location used by the Follower routine */
    protected mpoint_t f_oldloc;

    /** (fixed_t) used by MTOF to scale from map-to-frame-buffer coords */
    protected int scale_mtof = INITSCALEMTOF;

    /** used by FTOM to scale from frame-buffer-to-map coords (=1/scale_mtof) */
    protected int scale_ftom;

    /** the player represented by an arrow */
    protected player_t plr;

    /** numbers used for marking by the automap */
    private patch_t[] marknums = new patch_t[10];

    /** where the points are */
    private mpoint_t[] markpoints;

    /** next point to be assigned */
    private int markpointnum = 0;

    /** specifies whether to follow the player around */
    protected boolean followplayer = true;

    protected char[] cheat_amap_seq = { 0xb2, 0x26, 0x26, 0x2e, 0xff }; // iddt

    protected cheatseq_t cheat_amap = new cheatseq_t(cheat_amap_seq, 0);

    // MAES: STROBE cheat. It's not even cheating, strictly speaking.

    private char cheat_strobe_seq[] = { 0x6e, 0xa6, 0xea, 0x2e, 0x6a, 0xf6,
            0x62, 0xa6, 0xff // vestrobe
        };

    private cheatseq_t cheat_strobe = new cheatseq_t(cheat_strobe_seq, 0);

    private boolean stopped = true;

    // extern boolean viewactive;
    // extern byte screens[][SCREENWIDTH*SCREENHEIGHT];

    /**
     * Calculates the slope and slope according to the x-axis of a line segment
     * in map coordinates (with the upright y-axis n' all) so that it can be
     * used with the brain-dead drawing stuff.
     * 
     * @param ml
     * @param is
     */

    public final void getIslope(mline_t ml, islope_t is) {
        int dx, dy;

        dy = ml.ay - ml.by;
        dx = ml.bx - ml.ax;
        if (dy == 0)
            is.islp = (dx < 0 ? -MAXINT : MAXINT);
        else
            is.islp = FixedDiv(dx, dy);
        if (dx == 0)
            is.slp = (dy < 0 ? -MAXINT : MAXINT);
        else
            is.slp = FixedDiv(dy, dx);

    }

    //
    //
    //
    public final void activateNewScale() {
        m_x += m_w / 2;
        m_y += m_h / 2;
        m_w = FTOM(f_w);
        m_h = FTOM(f_h);
        m_x -= m_w / 2;
        m_y -= m_h / 2;
        m_x2 = m_x + m_w;
        m_y2 = m_y + m_h;
    }

    //
    //
    //
    public final void saveScaleAndLoc() {
        old_m_x = m_x;
        old_m_y = m_y;
        old_m_w = m_w;
        old_m_h = m_h;
    }

    private void restoreScaleAndLoc() {

        m_w = old_m_w;
        m_h = old_m_h;
        if (!followplayer) {
            m_x = old_m_x;
            m_y = old_m_y;
        } else {
            m_x = plr.mo.x - m_w / 2;
            m_y = plr.mo.y - m_h / 2;
        }
        m_x2 = m_x + m_w;
        m_y2 = m_y + m_h;

        // Change the scaling multipliers
        scale_mtof = FixedDiv(f_w << FRACBITS, m_w);
        scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
    }

    /**
     * adds a marker at the current location
     */

    public final void addMark() {
        markpoints[markpointnum].x = m_x + m_w / 2;
        markpoints[markpointnum].y = m_y + m_h / 2;
        markpointnum = (markpointnum + 1) % AM_NUMMARKPOINTS;

    }

    /**
     * Determines bounding box of all vertices, sets global variables
     * controlling zoom range.
     */

    public final void findMinMaxBoundaries() {
        int a; // fixed_t
        int b;

        min_x = min_y = MAXINT;
        max_x = max_y = -MAXINT;

        for (int i = 0; i < LL.numvertexes; i++) {
            if (LL.vertexes[i].x < min_x)
                min_x = LL.vertexes[i].x;
            else if (LL.vertexes[i].x > max_x)
                max_x = LL.vertexes[i].x;

            if (LL.vertexes[i].y < min_y)
                min_y = LL.vertexes[i].y;
            else if (LL.vertexes[i].y > max_y)
                max_y = LL.vertexes[i].y;
        }

        max_w = max_x - min_x;
        max_h = max_y - min_y;

        min_w = 2 * PLAYERRADIUS; // const? never changed?
        min_h = 2 * PLAYERRADIUS;

        a = FixedDiv(f_w << FRACBITS, max_w);
        b = FixedDiv(f_h << FRACBITS, max_h);

        min_scale_mtof = a < b ? a : b;
        if (min_scale_mtof < 0) {
            // MAES: safeguard against negative scaling e.g. in Europe.wad
            // This seems to be the limit.
            min_scale_mtof = MINIMUM_VIABLE_SCALE;
        }
        max_scale_mtof = FixedDiv(f_h << FRACBITS, 2 * PLAYERRADIUS);

    }

    public final void changeWindowLoc() {
        if (m_paninc.x != 0 || m_paninc.y != 0) {
            followplayer = false;
            f_oldloc.x = MAXINT;
        }

        m_x += m_paninc.x;
        m_y += m_paninc.y;

        if (m_x + m_w / 2 > max_x)
            m_x = max_x - m_w / 2;
        else if (m_x + m_w / 2 < min_x)
            m_x = min_x - m_w / 2;

        if (m_y + m_h / 2 > max_y)
            m_y = max_y - m_h / 2;
        else if (m_y + m_h / 2 < min_y)
            m_y = min_y - m_h / 2;

        m_x2 = m_x + m_w;
        m_y2 = m_y + m_h;
    }

    public final void initVariables() {
        int pnum = 0;

        DM.automapactive = true;
        fb = V.getScreen(DoomVideoRenderer.SCREEN_FG);

        f_oldloc.x = MAXINT;
        amclock = 0;
        lightlev = 0;

        m_paninc.x = m_paninc.y = 0;
        ftom_zoommul = FRACUNIT;
        mtof_zoommul = FRACUNIT;

        m_w = FTOM(f_w);
        m_h = FTOM(f_h);

        // find player to center on initially
        if (!DM.playeringame[pnum = DM.consoleplayer])
            for (pnum = 0; pnum < MAXPLAYERS; pnum++) {
                System.out.println(pnum);
                if (DM.playeringame[pnum])
                    break;
            }
        plr = DM.players[pnum];
        m_x = plr.mo.x - m_w / 2;
        m_y = plr.mo.y - m_h / 2;
        this.changeWindowLoc();

        // for saving & restoring
        old_m_x = m_x;
        old_m_y = m_y;
        old_m_w = m_w;
        old_m_h = m_h;

        // inform the status bar of the change
        ST.Responder(st_notify);

    }

    //
    //
    //
    public final void loadPics() {
        int i;
        String namebuf;

        for (i = 0; i < 10; i++) {
            namebuf = ("AMMNUM" + i);
            marknums[i] = W.CachePatchName(namebuf);
        }

    }

    public final void unloadPics() {
        int i;

        for (i = 0; i < 10; i++) {
            W.UnlockLumpNum(marknums[i]);
        }
    }

    public final void clearMarks() {
        int i;

        for (i = 0; i < AM_NUMMARKPOINTS; i++)
            markpoints[i].x = -1; // means empty
        markpointnum = 0;
    }

    /**
     * should be called at the start of every level right now, i figure it out
     * myself
     */
    public final void LevelInit() {
        leveljuststarted = 0;

        f_x = f_y = 0;
        f_w = finit_width;
        f_h = finit_height;

        // scanline=new byte[f_h*f_w];

        this.clearMarks();

        this.findMinMaxBoundaries();
        scale_mtof = FixedDiv(min_scale_mtof, MINIMUM_SCALE);
        if (scale_mtof > max_scale_mtof)
            scale_mtof = min_scale_mtof;
        scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
    }

    //
    //
    //

    protected final event_t st_notify = new event_t(evtype_t.ev_keyup,
            AM_MSGENTERED);

    // MAES: Was a "method static variable"...but what's the point? It's never
    // modified.
    protected final event_t st_notify_ex = new event_t(evtype_t.ev_keyup,
            AM_MSGEXITED);

    public final void Stop() {

        this.unloadPics();
        DM.automapactive = false;
        // This is the only way to notify the status bar responder that we're
        // exiting the automap.
        ST.Responder(st_notify_ex);
        stopped = true;
    }

    //
    //
    //

    // More "static" stuff.
    protected int lastlevel = -1, lastepisode = -1;

    public final void Start() {

        if (!stopped)
            Stop();
        stopped = false;
        if (lastlevel != DM.gamemap || lastepisode != DM.gameepisode) {
            this.LevelInit();
            lastlevel = DM.gamemap;
            lastepisode = DM.gameepisode;
        }
        this.initVectorGraphics();
        this.LevelInit();
        this.initVariables();
        this.loadPics();
    }

    /**
     * set the window scale to the maximum size
     */
    public final void minOutWindowScale() {
        scale_mtof = min_scale_mtof;
        scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
        this.activateNewScale();
    }

    /**
     * set the window scale to the minimum size
     */

    public final void maxOutWindowScale() {
        scale_mtof = max_scale_mtof;
        scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
        this.activateNewScale();
    }

    /** These belong to AM_Responder */
    protected boolean cheatstate = false, bigstate = false;

    /** static char buffer[20] in AM_Responder */
    protected String buffer;

    /** MAES: brought back strobe effect */
    private boolean strobe = false;

    /**
     * Handle events (user inputs) in automap mode
     */

    public final boolean Responder(event_t ev) {

        boolean rc;

        rc = false;

        // System.out.println(ev.data1==AM_STARTKEY);
        if (!DM.automapactive) {
            if ((ev.data1 == AM_STARTKEY) && (ev.type == evtype_t.ev_keyup)) {
                this.Start();
                DM.viewactive = false;
                rc = true;
            }
        }

        else if (ev.type == evtype_t.ev_keydown) {

            rc = true;
            switch (ev.data1) {
            case AM_PANRIGHTKEY: // pan right
                if (!followplayer)
                    m_paninc.x = FTOM(F_PANINC);
                else
                    rc = false;
                break;
            case AM_PANLEFTKEY: // pan left
                if (!followplayer)
                    m_paninc.x = -FTOM(F_PANINC);
                else
                    rc = false;
                break;
            case AM_PANUPKEY: // pan up
                if (!followplayer)
                    m_paninc.y = FTOM(F_PANINC);
                else
                    rc = false;
                break;
            case AM_PANDOWNKEY: // pan down
                if (!followplayer)
                    m_paninc.y = -FTOM(F_PANINC);
                else
                    rc = false;
                break;
            case AM_ZOOMOUTKEY: // zoom out
                mtof_zoommul = M_ZOOMOUT;
                ftom_zoommul = M_ZOOMIN;
                break;
            case AM_ZOOMINKEY: // zoom in
                mtof_zoommul = M_ZOOMIN;
                ftom_zoommul = M_ZOOMOUT;
                break;

            case AM_GOBIGKEY:
                bigstate = !bigstate;
                if (bigstate) {
                    this.saveScaleAndLoc();
                    this.minOutWindowScale();
                } else
                    this.restoreScaleAndLoc();
                break;
            case AM_FOLLOWKEY:
                followplayer = !followplayer;
                f_oldloc.x = MAXINT;
                plr.message = followplayer ? AMSTR_FOLLOWON : AMSTR_FOLLOWOFF;
                break;
            case AM_GRIDKEY:
                grid = !grid;
                plr.message = grid ? AMSTR_GRIDON : AMSTR_GRIDOFF;
                break;
            case AM_MARKKEY:
                buffer = (AMSTR_MARKEDSPOT + " " + markpointnum);
                plr.message = buffer;
                this.addMark();
                break;
            case AM_CLEARMARKKEY:
                this.clearMarks();
                plr.message = AMSTR_MARKSCLEARED;
                break;
            default:
                cheatstate = false;
                rc = false;
            }
            if (!DM.deathmatch && cheat_amap.CheckCheat((char) ev.data1)) {
                rc = false;
                cheating = (cheating + 1) % 3;
            }
            if (cheat_strobe.CheckCheat((char) ev.data1)) {
                strobe = !strobe;
            }
        }

        else if (ev.type == evtype_t.ev_keyup) {
            rc = false;
            switch (ev.data1) {
            case AM_PANRIGHTKEY:
                if (!followplayer)
                    m_paninc.x = 0;
                break;
            case AM_PANLEFTKEY:
                if (!followplayer)
                    m_paninc.x = 0;
                break;
            case AM_PANUPKEY:
                if (!followplayer)
                    m_paninc.y = 0;
                break;
            case AM_PANDOWNKEY:
                if (!followplayer)
                    m_paninc.y = 0;
                break;
            case AM_ZOOMOUTKEY:
            case AM_ZOOMINKEY:
                mtof_zoommul = FRACUNIT;
                ftom_zoommul = FRACUNIT;
                break;
            case AM_ENDKEY:
                bigstate = false;
                DM.viewactive = true;
                this.Stop();
                break;
            }
        }

        return rc;

    }

    /**
     * Zooming
     */
    private final void changeWindowScale() {

        // Change the scaling multipliers
        scale_mtof = FixedMul(scale_mtof, mtof_zoommul);
        scale_ftom = FixedDiv(FRACUNIT, scale_mtof);

        if (scale_mtof < min_scale_mtof)
            this.minOutWindowScale();
        else if (scale_mtof > max_scale_mtof)
            this.maxOutWindowScale();
        else
            this.activateNewScale();

    }

    //
    //
    //
    private final void doFollowPlayer() {

        if (f_oldloc.x != plr.mo.x || f_oldloc.y != plr.mo.y) {
            m_x = FTOM(MTOF(plr.mo.x)) - m_w / 2;
            m_y = FTOM(MTOF(plr.mo.y)) - m_h / 2;
            m_x2 = m_x + m_w;
            m_y2 = m_y + m_h;
            f_oldloc.x = plr.mo.x;
            f_oldloc.y = plr.mo.y;

            // m_x = FTOM(MTOF(plr.mo.x - m_w/2));
            // m_y = FTOM(MTOF(plr.mo.y - m_h/2));
            // m_x = plr.mo.x - m_w/2;
            // m_y = plr.mo.y - m_h/2;

        }

    }

    //
    //
    //

    protected int nexttic = 0;

    protected int[] litelevels = { 0, 4, 7, 10, 12, 14, 15, 15 };

    protected int litelevelscnt = 0;

    private final void updateLightLev() {

        // Change light level
        if (amclock > nexttic) {
            lightlev = litelevels[litelevelscnt++];
            if (litelevelscnt == litelevels.length)
                litelevelscnt = 0;
            nexttic = amclock + 6 - (amclock % 6);
        }

    }

    /**
     * Updates on Game Tick
     */
    public final void Ticker() {

        if (!DM.automapactive)
            return;

        amclock++;

        if (followplayer)
            this.doFollowPlayer();

        // Change the zoom if necessary
        if (ftom_zoommul != FRACUNIT)
            this.changeWindowScale();

        // Change x,y location
        if ((m_paninc.x | m_paninc.y) != 0)
            this.changeWindowLoc();

        // Update light level
        if (strobe)
            updateLightLev();

    }

    // private static int BUFFERSIZE=f_h*f_w;

    /**
     * Automap clipping of lines. Based on Cohen-Sutherland clipping algorithm
     * but with a slightly faster reject and precalculated slopes. If the speed
     * is needed, use a hash algorithm to handle the common cases.
     */
    private int tmpx, tmpy;// =new fpoint_t();

    private final boolean clipMline(mline_t ml, fline_t fl) {

        // System.out.print("Asked to clip from "+FixedFloat.toFloat(ml.a.x)+","+FixedFloat.toFloat(ml.a.y));
        // System.out.print(" to clip "+FixedFloat.toFloat(ml.b.x)+","+FixedFloat.toFloat(ml.b.y)+"\n");
        // These were supposed to be "registers", so they exhibit by-ref
        // properties.
        int outcode1 = 0;
        int outcode2 = 0;
        int outside;

        int dx;
        int dy;
        /*
         * fl.a.x=0; fl.a.y=0; fl.b.x=0; fl.b.y=0;
         */

        // do trivial rejects and outcodes
        if (ml.ay > m_y2)
            outcode1 = TOP;
        else if (ml.ay < m_y)
            outcode1 = BOTTOM;

        if (ml.by > m_y2)
            outcode2 = TOP;
        else if (ml.by < m_y)
            outcode2 = BOTTOM;

        if ((outcode1 & outcode2) != 0)
            return false; // trivially outside

        if (ml.ax < m_x)
            outcode1 |= LEFT;
        else if (ml.ax > m_x2)
            outcode1 |= RIGHT;

        if (ml.bx < m_x)
            outcode2 |= LEFT;
        else if (ml.bx > m_x2)
            outcode2 |= RIGHT;

        if ((outcode1 & outcode2) != 0)
            return false; // trivially outside

        // transform to frame-buffer coordinates.
        fl.ax = CXMTOF(ml.ax);
        fl.ay = CYMTOF(ml.ay);
        fl.bx = CXMTOF(ml.bx);
        fl.by = CYMTOF(ml.by);

        // System.out.println(">>>>>> ("+fl.a.x+" , "+fl.a.y+" ),("+fl.b.x+" , "+fl.b.y+" )");
        outcode1 = DOOUTCODE(fl.ax, fl.ay);
        outcode2 = DOOUTCODE(fl.bx, fl.by);

        if ((outcode1 & outcode2) != 0)
            return false;

        while ((outcode1 | outcode2) != 0) {
            // may be partially inside box
            // find an outside point
            if (outcode1 != 0)
                outside = outcode1;
            else
                outside = outcode2;

            // clip to each side
            if ((outside & TOP) != 0) {
                dy = fl.ay - fl.by;
                dx = fl.bx - fl.ax;
                tmpx = fl.ax + (dx * (fl.ay)) / dy;
                tmpy = 0;
            } else if ((outside & BOTTOM) != 0) {
                dy = fl.ay - fl.by;
                dx = fl.bx - fl.ax;
                tmpx = fl.ax + (dx * (fl.ay - f_h)) / dy;
                tmpy = f_h - 1;
            } else if ((outside & RIGHT) != 0) {
                dy = fl.by - fl.ay;
                dx = fl.bx - fl.ax;
                tmpy = fl.ay + (dy * (f_w - 1 - fl.ax)) / dx;
                tmpx = f_w - 1;
            } else if ((outside & LEFT) != 0) {
                dy = fl.by - fl.ay;
                dx = fl.bx - fl.ax;
                tmpy = fl.ay + (dy * (-fl.ax)) / dx;
                tmpx = 0;
            }

            if (outside == outcode1) {
                fl.ax = tmpx;
                fl.ay = tmpy;
                outcode1 = DOOUTCODE(fl.ax, fl.ay);
            } else {
                fl.bx = tmpx;
                fl.by = tmpy;
                outcode2 = DOOUTCODE(fl.bx, fl.by);
            }

            if ((outcode1 & outcode2) != 0)
                return false; // trivially outside
        }

        return true;
    }

    protected static int LEFT = 1, RIGHT = 2, BOTTOM = 4, TOP = 8;

    /**
     * MAES: the result was supposed to be passed in an "oc" parameter by
     * reference. Not convenient, so I made some changes...
     * 
     * @param mx
     * @param my
     */

    private final int DOOUTCODE(int mx, int my) {
        int oc = 0;
        if ((my) < 0)
            (oc) |= TOP;
        else if ((my) >= f_h)
            (oc) |= BOTTOM;
        if ((mx) < 0)
            (oc) |= LEFT;
        else if ((mx) >= f_w)
            (oc) |= RIGHT;
        return oc;
    }

    /** Not my idea ;-) */
    protected int fuck = 0;

    //
    // Classic Bresenham w/ whatever optimizations needed for speed
    //
    private final void drawFline(fline_t fl, int color) {

        // MAES: wish they were registers...
        int x;
        int y;
        int dx;
        int dy;
        int sx;
        int sy;
        int ax;
        int ay;
        int d;

        // For debugging only

        /*
         * ======= /*if ( fl.ax < 0 || fl.ax >= f_w || fl.ay < 0 || fl.ay >= f_h
         * || fl.bx < 0 || fl.bx >= f_w || fl.by < 0 || fl.by >= f_h) >>>>>>>
         * 1.11 { System.err.println("fuck "+(fuck++)+" \r"); return; <<<<<<<
         * Map.java }
         */

        dx = fl.bx - fl.ax;
        ax = 2 * (dx < 0 ? -dx : dx);
        sx = dx < 0 ? -1 : 1;

        dy = fl.by - fl.ay;
        ay = 2 * (dy < 0 ? -dy : dy);
        sy = dy < 0 ? -1 : 1;

        x = fl.ax;
        y = fl.ay;
        final int c = color;

        if (ax > ay) {
            d = ay - ax / 2;

            while (true) {
                PUTDOT(x, y, c);
                if (x == fl.bx)
                    return;
                if (d >= 0) {
                    y += sy;
                    d -= ax;
                }
                x += sx;
                d += ay;
            }
        } else {
            d = ax - ay / 2;
            while (true) {
                PUTDOT(x, y, c);
                if (y == fl.by)
                    return;
                if (d >= 0) {
                    x += sx;
                    d -= ay;
                }
                y += sy;
                d += ax;
            }
        }
    }

    /** Hopefully inlined */

    protected abstract void PUTDOT(int xx, int yy, int cc);

    /**
     * Clip lines, draw visible parts of lines.
     */
    protected int singlepixel = 0;

    private final void drawMline(mline_t ml, int color) {

        // fl.reset();

        if (this.clipMline(ml, fl)) {
            // if ((fl.a.x==fl.b.x)&&(fl.a.y==fl.b.y)) singlepixel++;
            this.drawFline(fl, color); // draws it on frame buffer using fb
                                       // coords
        }
    }

    private final fline_t fl = new fline_t();

    private final mline_t ml = new mline_t();

    /**
     * Draws flat (floor/ceiling tile) aligned grid lines.
     */
    private final void drawGrid(int color) {
        int x, y; // fixed_t
        int start, end; // fixed_t

        // Figure out start of vertical gridlines
        start = m_x;
        if (((start - LL.bmaporgx) % (MAPBLOCKUNITS << FRACBITS)) != 0)
            start +=
                (MAPBLOCKUNITS << FRACBITS)
                        - ((start - LL.bmaporgx) % (MAPBLOCKUNITS << FRACBITS));
        end = m_x + m_w;

        // draw vertical gridlines
        ml.ay = m_y;
        ml.by = m_y + m_h;
        for (x = start; x < end; x += (MAPBLOCKUNITS << FRACBITS)) {
            ml.ax = x;
            ml.bx = x;
            drawMline(ml, color);
        }

        // Figure out start of horizontal gridlines
        start = m_y;
        if (((start - LL.bmaporgy) % (MAPBLOCKUNITS << FRACBITS)) != 0)
            start +=
                (MAPBLOCKUNITS << FRACBITS)
                        - ((start - LL.bmaporgy) % (MAPBLOCKUNITS << FRACBITS));
        end = m_y + m_h;

        // draw horizontal gridlines
        ml.ax = m_x;
        ml.bx = m_x + m_w;
        for (y = start; y < end; y += (MAPBLOCKUNITS << FRACBITS)) {
            ml.ay = y;
            ml.by = y;
            drawMline(ml, color);
        }

    }

    protected mline_t l = new mline_t();

    /**
     * Determines visible lines, draws them. This is LineDef based, not LineSeg
     * based.
     */

    private final void drawWalls() {

        final int wallcolor = V.getBaseColor(WALLCOLORS + lightlev);
        final int fdwallcolor = V.getBaseColor(FDWALLCOLORS + lightlev);
        final int cdwallcolor = V.getBaseColor(CDWALLCOLORS + lightlev);
        final int tswallcolor = V.getBaseColor(CDWALLCOLORS + lightlev);
        final int secretwallcolor = V.getBaseColor(SECRETWALLCOLORS + lightlev);

        for (int i = 0; i < LL.numlines; i++) {
            l.ax = LL.lines[i].v1x;
            l.ay = LL.lines[i].v1y;
            l.bx = LL.lines[i].v2x;
            l.by = LL.lines[i].v2y;
            if ((cheating | (LL.lines[i].flags & ML_MAPPED)) != 0) {
                if (((LL.lines[i].flags & LINE_NEVERSEE) & ~cheating) != 0)
                    continue;
                if (LL.lines[i].backsector == null) {
                    drawMline(l, wallcolor);
                } else {
                    if (LL.lines[i].special == 39) { // teleporters
                        drawMline(l, WALLCOLORS + WALLRANGE / 2);
                    } else if ((LL.lines[i].flags & ML_SECRET) != 0) // secret
                                                                     // door
                    {
                        if (cheating != 0)
                            drawMline(l, secretwallcolor);
                        else
                            drawMline(l, wallcolor);
                    } else if (LL.lines[i].backsector.floorheight != LL.lines[i].frontsector.floorheight) {
                        drawMline(l, fdwallcolor); // floor level change
                    } else if (LL.lines[i].backsector.ceilingheight != LL.lines[i].frontsector.ceilingheight) {
                        drawMline(l, cdwallcolor); // ceiling level change
                    } else if (cheating != 0) {
                        drawMline(l, tswallcolor);
                    }
                }
            }
            // If we have allmap...
            else if (plr.powers[pw_allmap] != 0) {
                // Some are never seen even with that!
                if ((LL.lines[i].flags & LINE_NEVERSEE) == 0)
                    drawMline(l, GRAYS + 3);
            }
        }

        // System.out.println("Single pixel draws: "+singlepixel+" out of "+P.lines.length);
        // singlepixel=0;
    }

    //
    // Rotation in 2D.
    // Used to rotate player arrow line character.
    //
    private int rotx, roty;

    /**
     * Rotation in 2D. Used to rotate player arrow line character.
     * 
     * @param x
     *        fixed_t
     * @param y
     *        fixed_t
     * @param a
     *        angle_t -> this should be a LUT-ready BAM.
     */

    private final void rotate(int x, int y, int a) {
        // int tmpx;

        rotx = FixedMul(x, finecosine[a]) - FixedMul(y, finesine[a]);

        roty = FixedMul(x, finesine[a]) + FixedMul(y, finecosine[a]);

        // rotx.val = tmpx;
    }

    private final void drawLineCharacter(mline_t[] lineguy, int lineguylines,
            int scale, // fixed_t
            int angle, // This should be a LUT-ready angle.
            int color, int x, // fixed_t
            int y // fixed_t
    ) {
        int i;
        final boolean rotate = (angle != 0);
        mline_t l = new mline_t();

        for (i = 0; i < lineguylines; i++) {
            l.ax = lineguy[i].ax;
            l.ay = lineguy[i].ay;

            if (scale != 0) {
                l.ax = FixedMul(scale, l.ax);
                l.ay = FixedMul(scale, l.ay);
            }

            if (rotate) {
                rotate(l.ax, l.ay, angle);
                // MAES: assign rotations
                l.ax = rotx;
                l.ay = roty;
            }

            l.ax += x;
            l.ay += y;

            l.bx = lineguy[i].bx;
            l.by = lineguy[i].by;

            if (scale != 0) {
                l.bx = FixedMul(scale, l.bx);
                l.by = FixedMul(scale, l.by);
            }

            if (rotate) {
                rotate(l.bx, l.by, angle);
                // MAES: assign rotations
                l.bx = rotx;
                l.by = roty;
            }

            l.bx += x;
            l.by += y;

            drawMline(l, color);
        }
    }

    protected int their_colors[];

    public final void drawPlayers() {
        player_t p;

        int their_color = -1;
        int color;

        // System.out.println(Long.toHexString(plr.mo.angle));

        if (!DM.netgame) {
            if (cheating != 0)
                drawLineCharacter(cheat_player_arrow, NUMCHEATPLYRLINES, 0,
                    toBAMIndex(plr.mo.angle), V.getBaseColor(WHITE), plr.mo.x,
                    plr.mo.y);
            else
                drawLineCharacter(player_arrow, NUMPLYRLINES, 0,
                    toBAMIndex(plr.mo.angle), V.getBaseColor(WHITE), plr.mo.x,
                    plr.mo.y);
            return;
        }

        for (int i = 0; i < MAXPLAYERS; i++) {
            their_color++;
            p = DM.players[i];

            if ((DM.deathmatch && !DM.singledemo) && p != plr)
                continue;

            if (!DM.playeringame[i])
                continue;

            if (p.powers[pw_invisibility] != 0)
                color = 246; // *close* to black
            else
                color = their_colors[their_color];

            drawLineCharacter(player_arrow, NUMPLYRLINES, 0, (int) p.mo.angle,
                V.getBaseColor(color), p.mo.x, p.mo.y);
        }

    }

    public final void drawThings(int colors, int colorrange) {
        mobj_t t;
        int color = V.getBaseColor(colors + lightlev); // Ain't gonna change

        for (int i = 0; i < LL.numsectors; i++) {
            // MAES: get first on the list.
            t = LL.sectors[i].thinglist;
            while (t != null) {
                drawLineCharacter(thintriangle_guy, NUMTHINTRIANGLEGUYLINES,
                    16 << FRACBITS, toBAMIndex(t.angle), color, t.x, t.y);
                t = (mobj_t) t.snext;
            }
        }
    }

    public final void drawMarks() {
        int i, fx, fy, w, h;

        for (i = 0; i < AM_NUMMARKPOINTS; i++) {
            if (markpoints[i].x != -1) {
                w = marknums[i].width;
                h = marknums[i].height;
                // Nothing wrong with v1.9 IWADs, but I wouldn't put my hand on
                // the fire for older ones.
                // w = 5; // because something's wrong with the wad, i guess
                // h = 6; // because something's wrong with the wad, i guess
                fx = CXMTOF(markpoints[i].x);
                fy = CYMTOF(markpoints[i].y);
                if (fx >= f_x && fx <= f_w - w && fy >= f_y && fy <= f_h - h)
                    V.DrawScaledPatch(fx, fy, FB | V_NOSCALESTART, vs,
                        marknums[i]);
            }
        }

    }

    protected abstract void drawCrosshair(int color);

    public final void Drawer() {
        if (!DM.automapactive)
            return;
        // System.out.println("Drawing map");
        if (overlay < 1)
            V.FillRect(BACKGROUND, FB, 0, 0, f_w, f_h); // BACKGROUND
        if (grid)
            drawGrid(V.getBaseColor(GRIDCOLORS));
        drawWalls();
        drawPlayers();
        if (cheating == 2)
            drawThings(THINGCOLORS, THINGRANGE);
        drawCrosshair(V.getBaseColor(XHAIRCOLORS));

        drawMarks();

        V.MarkRect(f_x, f_y, f_w, f_h);

    }

    @Override
    public void updateStatus(DoomStatus<?,?> DC) {
        this.V = (DoomVideoRenderer<T, V>) DC.V;
        this.W = DC.W;
        this.LL = DC.LL;
        this.DM = (DoomMain<T, V>) DC.DM;
        this.ST = DC.ST;
    }

    // //////////////////////////VIDEO SCALE STUFF
    // ////////////////////////////////

    protected int SCREENWIDTH;

    protected int SCREENHEIGHT;

    protected IVideoScale vs;

    public void setVideoScale(IVideoScale vs) {
        this.vs = vs;
    }

    public void initScaling() {
        this.SCREENHEIGHT = vs.getScreenHeight();
        this.SCREENWIDTH = vs.getScreenWidth();

        // Pre-scale stuff.
        finit_width = SCREENWIDTH;
        finit_height = SCREENHEIGHT - 32 * vs.getSafeScaling();
    }

    public static final class HiColor
            extends Map<byte[], short[]> {

        public HiColor(DoomStatus<byte[], short[]> DS) {
            super(DS);
        }

        protected final void PUTDOT(int xx, int yy, int cc) {
            fb[(yy) * f_w + (xx)] = (short) (cc);
        }

        protected final void drawCrosshair(int color) {
            fb[(f_w * (f_h + 1)) / 2] = (short) color; // single point for now
        }
    }

    public static final class Indexed
            extends Map<byte[], byte[]> {

        public Indexed(DoomStatus<byte[], byte[]> DS) {
            super(DS);
        }

        protected final void PUTDOT(int xx, int yy, int cc) {
            fb[(yy) * f_w + (xx)] = (byte) (cc);
        }

        protected final void drawCrosshair(int color) {
            fb[(f_w * (f_h + 1)) / 2] = (byte) color; // single point for now
        }
    }
            
     public static final class TrueColor
            extends Map<byte[], int[]> {

        public TrueColor(DoomStatus<byte[], int[]> DS) {
            super(DS);
        }

        protected final void PUTDOT(int xx, int yy, int cc) {
            fb[(yy) * f_w + (xx)] = (int) (cc);
        }

        protected final void drawCrosshair(int color) {
            fb[(f_w * (f_h + 1)) / 2] = (int) color; // single point for now
        }
    }

}
package automap;

public class islope_t
{
    /** fixed_t */
    int slp, islp;
}

package automap;

public class fline_t
{
 
    /*
     * public fline_t(){
        a=new fpoint_t();
        b=new fpoint_t();
    }
    
    public fline_t(fpoint_t a, fpoint_t b){
        this.a=a;
        this.b=b;
    }
*/    
    public fline_t(int ax, int ay, int bx, int by){
        this.ay=ay;
        this.ax=ax;
        this.by=by;
        this.bx=bx;
    }
    
    public fline_t() {
        // TODO Auto-generated constructor stub
    }

    public int ax,ay,bx,by;
    /*
    public fpoint_t a, b;

    public void reset() {
        this.a.x=0;
        this.a.y=0;
        this.b.x=0;
        this.b.y=0;
        
    }*/
}

package boom;

public class prboom_comp_t {

    public prboom_comp_t(int minver, int maxver, boolean state, String cmd) {
        this.minver = minver;
        this.maxver = maxver;
        this.state = state;
        this.cmd = cmd;
    }

    public int minver;

    public int maxver;

    public boolean state;

    public String cmd;
}
package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import w.CacheableDoomObject;

/** ZDoom node?
 *
 */

public class mapseg_znod_t implements CacheableDoomObject{
    
    public mapseg_znod_t(){
        
    }

  	public int v1,v2; // Those are unsigned :-/
  	public char linedef;
  	public byte side;
   
   public static int sizeOf(){
       return 11;
   }
   
   @Override
   public void unpack(ByteBuffer buf)
           throws IOException {
       buf.order(ByteOrder.LITTLE_ENDIAN);
       this.v1 = buf.getInt();
       this.v2 = buf.getInt();
       this.linedef=buf.getChar();
       this.side=buf.get();
   		}
   
 };

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import w.CacheableDoomObject;

/** fixed 32 bit gl_vert format v2.0+ (glBsp 1.91) */

public class mapglvertex_t implements CacheableDoomObject{
    public int x, y; // fixed_t

    public static int sizeOf() {
        return 8;
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        x=buf.getInt();
        y=buf.getInt();
    }
}
package boom;

/* Emacs style mode select   -*- C++ -*-
 *-----------------------------------------------------------------------------
 *
 *
 *  PrBoom: a Doom port merged with LxDoom and LSDLDoom
 *  based on BOOM, a modified and improved DOOM engine
 *  Copyright (C) 1999 by
 *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
 *  Copyright (C) 1999-2000 by
 *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
 *  Copyright 2005, 2006 by
 *  Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 *  02111-1307, USA.
 *
 * DESCRIPTION:
 *
 *-----------------------------------------------------------------------------
 */

public interface E6Y{

/*
#define HU_HUDADDX (HU_HUDX)
#define HU_HUDADDY (HU_HUDY+(-1)*HU_GAPY)
#define HU_CENTERMSGX (320/2)
#define HU_CENTERMSGY ((200-ST_HEIGHT)/2 - 1 - LittleShort(hu_font[0].height))

#define HU_HUDADDX_D (HU_HUDX_LL)
#define HU_HUDADDY_D (HU_HUDY_LL+(-1)*HU_GAPY)

#define HU_MSGCENTERTIMEOUT   (2*TICRATE)
*/

public static final String STSTR_SECRETFOUND =  "A secret is revealed!";

public static final int S_CANT_GL_ARB_MULTITEXTURE= 0x10000000;
public static final int S_CANT_GL_ARB_MULTISAMPLEFACTOR=  0x20000000;

public static final int  GL_COMBINE_ARB  =  0x8570;
public static final int GL_RGB_SCALE_ARB = 0x8573;

public static final char NO_INDEX =0xFFFF;

public static final float FOV_CORRECTION_FACTOR= 1.13776f;
public static final int FOV90 =90;

//public static final double DEG2RAD( a ) ( a * Pi ) / 180.0f;
//#define RAD2DEG( a ) ( a / Pi ) * 180.0f;

public class buf_overrun_item_t
{
  String wadname;
  int map;
  int address;
} 

public class camera_t
{
  long x;
  long y;
  long z;
  long PrevX;
  long PrevY;
  long PrevZ;
  long angle;
  long pitch;
  long PrevAngle;
  long PrevPitch;
  int type;
}

/*

extern int REAL_SCREENWIDTH;
extern int REAL_SCREENHEIGHT;
extern int REAL_SCREENPITCH;

extern dboolean wasWiped;

extern int totalleveltimes;

extern int secretfound;
extern int messagecenter_counter;
extern int demo_skiptics;
extern int demo_tics_count;
extern int demo_curr_tic;
extern int demo_playerscount;
extern char demo_len_st[80];

extern int avi_shot_time;
extern int avi_shot_num;
extern const char *avi_shot_fname;
extern char avi_shot_curr_fname[PATH_MAX];

extern dboolean doSkip;
extern dboolean demo_stoponnext;
extern dboolean demo_stoponend;
extern dboolean demo_warp;

extern int key_speed_up;
extern int key_speed_down;
extern int key_speed_default;
extern int speed_step;
extern int key_nextlevel;
extern int key_demo_jointogame;
extern int key_demo_endlevel;
extern int key_walkcamera;
extern int key_showalive;

extern int hudadd_gamespeed;
extern int hudadd_leveltime;
extern int hudadd_demotime;
extern int hudadd_secretarea;
extern int hudadd_smarttotals;
extern int hudadd_demoprogressbar;
extern int movement_strafe50;
extern int movement_shorttics;
extern int movement_strafe50onturns;
extern int movement_mouselook;
extern int movement_mouseinvert;
extern int movement_maxviewpitch;
extern int mouse_handler;
extern int mouse_doubleclick_as_use;
extern int render_multisampling;
extern int render_paperitems;
extern int render_wipescreen;
extern int mouse_acceleration;
extern int demo_overwriteexisting;

extern int render_fov;
extern int render_aspect;
extern float render_ratio;
extern float render_fovratio;
extern float render_fovy;
extern float render_multiplier;
void M_ChangeAspectRatio(void);
void M_ChangeStretch(void);

extern int misc_fastexit;

extern int palette_ondamage;
extern int palette_onbonus;
extern int palette_onpowers;

extern camera_t walkcamera;

extern fixed_t sidemove_normal[2];
extern fixed_t sidemove_strafe50[2];

extern int PitchSign;
extern int mouseSensitivity_mlook;
extern angle_t viewpitch;
extern float skyscale;
extern float screen_skybox_zplane;
extern float maxNoPitch[];
extern float tan_pitch;
extern float skyUpAngle;
extern float skyUpShift;
extern float skyXShift;
extern float skyYShift;
extern dboolean mlook_or_fov;

extern hu_textline_t  w_hudadd;
extern hu_textline_t  w_centermsg;
extern hu_textline_t  w_precache;
extern char hud_add[80];
extern char hud_centermsg[80];

void e6y_assert(const char *format, ...);

void ParamsMatchingCheck();
void e6y_InitCommandLine(void);

void P_WalkTicker ();
void P_SyncWalkcam(dboolean sync_coords, dboolean sync_sight);
void P_ResetWalkcam(void);

extern dboolean sound_inited_once;
void e6y_I_uSleep(unsigned long usecs);
void G_SkipDemoStart(void);
void G_SkipDemoStop(void);
void G_SkipDemoCheck(void);
int G_GotoNextLevel(void);

#ifdef GL_DOOM
void M_ChangeMouseLook(void);
void M_ChangeMaxViewPitch(void);
void M_ChangeMouseInvert(void);
void M_ChangeFOV(void);
void M_ChangeUseDetail(void);
void M_ChangeMultiSample(void);
void M_ChangeSpriteClip(void);
void M_ChangeAllowBoomColormaps(void);
void M_ChangeTextureUseHires(void);
void M_ChangeAllowFog(void);
void M_ChangeTextureHQResize(void);
#endif
void M_ChangeRenderPrecise(void);
void M_ChangeSpeed(void);
void M_ChangeScreenMultipleFactor(void);
void M_ChangeInterlacedScanning(void);
void M_MouseMLook(int choice);
void M_MouseAccel(int choice);
void M_ChangeCompTranslucency(void);
void CheckPitch(signed int *pitch);
void I_Init2(void);

#ifdef GL_DOOM
dboolean GetMouseLook(void);
dboolean HaveMouseLook(void);
#else
#define GetMouseLook() (0)
#define HaveMouseLook() (0)
#endif

extern float viewPitch;
extern dboolean transparentpresent;

void R_ClearClipSegs (void);
void R_RenderBSPNode(int bspnum);

typedef struct prboom_comp_s
{
  unsigned int minver;
  unsigned int maxver;
  dboolean state;
  const char *cmd;
} prboom_comp_t;

enum
{
  PC_MONSTER_AVOID_HAZARDS,
  PC_REMOVE_SLIME_TRAILS,
  PC_NO_DROPOFF,
  PC_TRUNCATED_SECTOR_SPECIALS,
  PC_BOOM_BRAINAWAKE,
  PC_PRBOOM_FRICTION,
  PC_REJECT_PAD_WITH_FF,
  PC_FORCE_LXDOOM_DEMO_COMPATIBILITY,
  PC_ALLOW_SSG_DIRECT,
  PC_TREAT_NO_CLIPPING_THINGS_AS_NOT_BLOCKING,
  PC_FORCE_INCORRECT_PROCESSING_OF_RESPAWN_FRAME_ENTRY,
  PC_FORCE_CORRECT_CODE_FOR_3_KEYS_DOORS_IN_MBF,
  PC_UNINITIALIZE_CRUSH_FIELD_FOR_STAIRS,
  PC_FORCE_BOOM_FINDNEXTHIGHESTFLOOR,
  PC_ALLOW_SKY_TRANSFER_IN_BOOM,
  PC_APPLY_GREEN_ARMOR_CLASS_TO_ARMOR_BONUSES,
  PC_APPLY_BLUE_ARMOR_CLASS_TO_MEGASPHERE,
  PC_WRONG_FIXEDDIV,
  PC_FORCE_INCORRECT_BOBBING_IN_BOOM,
  PC_BOOM_DEH_PARSER,
  PC_MBF_REMOVE_THINKER_IN_KILLMOBJ,
  PC_DO_NOT_INHERIT_FRIENDLYNESS_FLAG_ON_SPAWN,
  PC_DO_NOT_USE_MISC12_FRAME_PARAMETERS_IN_A_MUSHROOM,
  PC_MAX
};

extern prboom_comp_t prboom_comp[];

int StepwiseSum(int value, int direction, int step, int minval, int maxval, int defval);

enum
{
  TT_ALLKILL,
  TT_ALLITEM,
  TT_ALLSECRET,

  TT_TIME,
  TT_TOTALTIME,
  TT_TOTALKILL,
  TT_TOTALITEM,
  TT_TOTALSECRET,

  TT_MAX
};

typedef struct timetable_s
{
  char map[16];

  int kill[MAXPLAYERS];
  int item[MAXPLAYERS];
  int secret[MAXPLAYERS];
  
  int stat[TT_MAX];
} timetable_t;

#ifdef _WIN32
const char* WINError(void);
#endif

extern int stats_level;
void e6y_G_DoCompleted(void);
void e6y_WriteStats(void);

void e6y_G_DoWorldDone(void);

void I_ProcessWin32Mouse(void);
void I_StartWin32Mouse(void);
void I_EndWin32Mouse(void);
int AccelerateMouse(int val);
void MouseAccelChanging(void);

extern int mlooky;
extern int realtic_clock_rate;

extern dboolean IsDehMaxHealth;
extern dboolean IsDehMaxSoul;
extern dboolean IsDehMegaHealth;
extern dboolean DEH_mobjinfo_bits[NUMMOBJTYPES];

extern int deh_maxhealth;
extern int deh_max_soul;
extern int deh_mega_health;

extern int maxhealthbonus;

void e6y_G_Compatibility(void);

extern dboolean zerotag_manual;
extern int comperr_zerotag;
extern int comperr_passuse;
extern int comperr_hangsolid;

dboolean compbad_get(int *compbad);

dboolean ProcessNoTagLines(line_t* line, sector_t **sec, int *secnum);

#define I_FindName(a)	((a)->Name)
#define I_FindAttr(a)	((a)->Attribs)

typedef struct
{
	unsigned int Attribs;
	unsigned int Times[3*2];
	unsigned int Size[2];
	unsigned int Reserved[2];
	char Name[PATH_MAX];
	char AltName[14];
} findstate_t;

char* PathFindFileName(const char* pPath);
void NormalizeSlashes2(char *str);
unsigned int AfxGetFileName(const char* lpszPathName, char* lpszTitle, unsigned int nMax);
void AbbreviateName(char* lpszCanon, int cchMax, int bAtLeastName);

//extern int viewMaxY;

extern dboolean isskytexture;

void D_AddDehFile (const char *file, wad_source_t source);

extern int levelstarttic;

void I_AfterUpdateVideoMode(void);

extern int force_singletics_to;

dboolean HU_DrawDemoProgress(void);

#ifdef ALL_IN_ONE
unsigned char* GetAllInOneLumpHandle(void);
#endif

#ifdef _MSC_VER
int GetFullPath(const char* FileName, const char* ext, char *Buffer, size_t BufferLength);
#endif

void I_vWarning(const char *message, va_list argList);
void I_Warning(const char *message, ...);

#define PRB_MB_OK                       0x00000000
#define PRB_MB_OKCANCEL                 0x00000001
#define PRB_MB_ABORTRETRYIGNORE         0x00000002
#define PRB_MB_YESNOCANCEL              0x00000003
#define PRB_MB_YESNO                    0x00000004
#define PRB_MB_RETRYCANCEL              0x00000005
#define PRB_MB_DEFBUTTON1               0x00000000
#define PRB_MB_DEFBUTTON2               0x00000100
#define PRB_MB_DEFBUTTON3               0x00000200
#define PRB_IDOK                1
#define PRB_IDCANCEL            2
#define PRB_IDABORT             3
#define PRB_IDRETRY             4
#define PRB_IDIGNORE            5
#define PRB_IDYES               6
#define PRB_IDNO                7
int I_MessageBox(const char* text, unsigned int type);

dboolean SmoothEdges(unsigned char * buffer,int w, int h);

#ifdef _WIN32
extern int mus_extend_volume;
void I_midiOutSetVolumes(int volume);
#endif

#endif
*/

}
package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import w.CacheableDoomObject;

/**
 *  LineSeg, generated by splitting LineDefs
 * using partition lines selected by BSP builder.
 * MAES: this is the ON-DISK structure. The corresponding memory structure, 
 * segs_t, has fixed_t members. 
 */

public class mapseg_v4_t implements CacheableDoomObject{
    
    public mapseg_v4_t(){
        
    }

  	public int v1;
  	public int v2;
  	public char angle;
  	public char linedef;
  	public char side;
  	public char offset;
   
   public static int sizeOf(){
       return 16;
   }
   
   @Override
   public void unpack(ByteBuffer buf)
           throws IOException {
       buf.order(ByteOrder.LITTLE_ENDIAN);
       this.v1 = buf.getInt();
       this.v2 = buf.getInt();
       this.angle=buf.getChar();       
       this.linedef=buf.getChar();
       this.side=buf.getChar();
       this.offset=buf.getChar();
      
   }
   
 };

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;

import utils.C2JUtils;
import w.CacheableDoomObject;

public class DeepBSPNodesV4 implements CacheableDoomObject{

	public static final byte[] DeepBSPHeader={
		'x','N','d','4',0,0,0,0
		};
	
	byte[] header=new byte[8];
	mapnode_v4_t[] nodes;
	int numnodes;
	
	public boolean formatOK(){
		return Arrays.equals(header, DeepBSPHeader);
	}

	public mapnode_v4_t[] getNodes(){
		return nodes;
	}
	
	@Override
	public void unpack(ByteBuffer buf) throws IOException {
		int length=buf.capacity();
		
		// Too short, not even header.
		if (length<8) return;
		
		numnodes=(length-8)/mapnode_v4_t.sizeOf();
		
		if (length<1) return;
		
		buf.get(header); // read header
		
		nodes=C2JUtils.createArrayOfObjects(mapnode_v4_t.class, length);
		
		for (int i=0;i<length;i++){
			nodes[i].unpack(buf);
		}
		
	}
	
	
	

}

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;

import utils.C2JUtils;
import w.CacheableDoomObject;

public class ZNodeSegs implements CacheableDoomObject{

	private static final byte[] DeepBSPHeader={
		'x','N','d','4',0,0,0,0
		};
	
	byte[] header;
	mapseg_znod_t[] nodes;
	int numnodes;
	
	public boolean formatOK(){
		return Arrays.equals(header, DeepBSPHeader);
	}

	public mapseg_znod_t[] getNodes(){
		return nodes;
	}
	
	@Override
	public void unpack(ByteBuffer buf) throws IOException {
		int length=buf.capacity();
		
		// Too short, not even header.
		if (length<8) return;
		
		numnodes=(length-8)/mapnode_v4_t.sizeOf();
		
		if (length<1) return;
		
		buf.get(header); // read header
		
		nodes=C2JUtils.createArrayOfObjects(mapseg_znod_t.class, length);
		
		for (int i=0;i<length;i++){
			nodes[i].unpack(buf);
		}
		
	}
	
	
	

}

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import utils.C2JUtils;
import w.CacheableDoomObject;

public class mapsubsector_znod_t implements CacheableDoomObject{
	
    public long numsegs;
      
  	@Override
	public void unpack(ByteBuffer buf)
        throws IOException {
    buf.order(ByteOrder.LITTLE_ENDIAN);
    this.numsegs = C2JUtils.unsigned(buf.getInt());
	} 

	public static final int sizeOf(){
    return 4;
	}
	
}

package boom;

/** cph - move compatibility levels here so we can use them in d_server.c
 * 
 * @author cph
 *
 */
 
public final class Compatibility {

      /** Doom v1.2 */
      public static final int doom_12_compatibility=0;
      
      public static final int doom_1666_compatibility=1; /* Doom v1.666 */
      public static final int doom2_19_compatibility=2;  /* Doom & Doom 2 v1.9 */
      public static final int ultdoom_compatibility=3;   /* Ultimate Doom and Doom95 */
      public static final int finaldoom_compatibility=4;     /* Final Doom */
      public static final int dosdoom_compatibility=5;     /* DosDoom 0.47 */
      public static final int tasdoom_compatibility=6;     /* TASDoom */
      public static final int boom_compatibility_compatibility=7;      /* Boom's compatibility mode */
      public static final int boom_201_compatibility=8;                /* Boom v2.01 */
      public static final int boom_202_compatibility=9;                /* Boom v2.02 */
      public static final int lxdoom_1_compatibility=10;                /* LxDoom v1.3.2+ */
      public static final int mbf_compatibility=11;                     /* MBF */
      public static final int prboom_1_compatibility=12;                /* PrBoom 2.03beta? */
      public static final int prboom_2_compatibility=13;                /* PrBoom 2.1.0-2.1.1 */
      public static final int prboom_3_compatibility=14;                /* PrBoom 2.2.x */
      public static final int prboom_4_compatibility=15;                /* PrBoom 2.3.x */
      public static final int prboom_5_compatibility=16;              /* PrBoom 2.4.0 */
      public static final int prboom_6_compatibility=17;             /* Latest PrBoom */
      public static final int MAX_COMPATIBILITY_LEVEL=18;           /* Must be last entry */
      /* Aliases follow */
      public static final int boom_compatibility = boom_201_compatibility; /* Alias used by G_Compatibility */
      public static final int best_compatibility = prboom_6_compatibility;
      
      public static final prboom_comp_t[] prboom_comp = {
              new prboom_comp_t(0xffffffff, 0x02020615, false, "-force_monster_avoid_hazards"),
              new prboom_comp_t(0x00000000, 0x02040601, false, "-force_remove_slime_trails"),
              new prboom_comp_t(0x02020200, 0x02040801, false, "-force_no_dropoff"),
              new prboom_comp_t(0x00000000, 0x02040801, false, "-force_truncated_sector_specials"),
              new prboom_comp_t(0x00000000, 0x02040802, false, "-force_boom_brainawake"),
              new prboom_comp_t(0x00000000, 0x02040802, false, "-force_prboom_friction"),
              new prboom_comp_t(0x02020500, 0x02040000, false, "-reject_pad_with_ff"),
              new prboom_comp_t(0xffffffff, 0x02040802, false, "-force_lxdoom_demo_compatibility"),
              new prboom_comp_t(0x00000000, 0x0202061b, false, "-allow_ssg_direct"),
              new prboom_comp_t(0x00000000, 0x02040601, false, "-treat_no_clipping_things_as_not_blocking"),
              new prboom_comp_t(0x00000000, 0x02040803, false, "-force_incorrect_processing_of_respawn_frame_entry"),
              new prboom_comp_t(0x00000000, 0x02040601, false, "-force_correct_code_for_3_keys_doors_in_mbf"),
              new prboom_comp_t(0x00000000, 0x02040601, false, "-uninitialize_crush_field_for_stairs"),
              new prboom_comp_t(0x00000000, 0x02040802, false, "-force_boom_findnexthighestfloor"),
              new prboom_comp_t(0x00000000, 0x02040802, false, "-allow_sky_transfer_in_boom"),
              new prboom_comp_t(0x00000000, 0x02040803, false, "-apply_green_armor_class_to_armor_bonuses"),
              new prboom_comp_t(0x00000000, 0x02040803, false, "-apply_blue_armor_class_to_megasphere"),
              new prboom_comp_t(0x02050001, 0x02050003, false, "-wrong_fixeddiv"),
              new prboom_comp_t(0x02020200, 0x02050003, false, "-force_incorrect_bobbing_in_boom"),
              new prboom_comp_t(0xffffffff, 0x00000000, false, "-boom_deh_parser"),
              new prboom_comp_t(0x00000000, 0x02050007, false, "-mbf_remove_thinker_in_killmobj"),
              new prboom_comp_t(0x00000000, 0x02050007, false, "-do_not_inherit_friendlyness_flag_on_spawn"),
              new prboom_comp_t(0x00000000, 0x02050007, false, "-do_not_use_misc12_frame_parameters_in_a_mushroom")
            };
      
      public static final int PC_MONSTER_AVOID_HAZARDS=0;
      public static final int PC_REMOVE_SLIME_TRAILS=1;
      public static final int PC_NO_DROPOFF=2;
      public static final int PC_TRUNCATED_SECTOR_SPECIALS=3;
      public static final int PC_BOOM_BRAINAWAKE=4;
      public static final int PC_PRBOOM_FRICTION=5;
      public static final int PC_REJECT_PAD_WITH_FF=6;
      public static final int PC_FORCE_LXDOOM_DEMO_COMPATIBILITY=7;
      public static final int PC_ALLOW_SSG_DIRECT=8;
      public static final int PC_TREAT_NO_CLIPPING_THINGS_AS_NOT_BLOCKING=9;
      public static final int PC_FORCE_INCORRECT_PROCESSING_OF_RESPAWN_FRAME_ENTRY=10;
      public static final int PC_FORCE_CORRECT_CODE_FOR_3_KEYS_DOORS_IN_MBF=11;
      public static final int PC_UNINITIALIZE_CRUSH_FIELD_FOR_STAIRS=12;
      public static final int PC_FORCE_BOOM_FINDNEXTHIGHESTFLOOR=13;
      public static final int PC_ALLOW_SKY_TRANSFER_IN_BOOM=14;
      public static final int PC_APPLY_GREEN_ARMOR_CLASS_TO_ARMOR_BONUSES=15;
      public static final int PC_APPLY_BLUE_ARMOR_CLASS_TO_MEGASPHERE=16;
      public static final int PC_WRONG_FIXEDDIV=17;
      public static final int PC_FORCE_INCORRECT_BOBBING_IN_BOOM=18;
      public static final int PC_BOOM_DEH_PARSER=19;
      public static final int PC_MBF_REMOVE_THINKER_IN_KILLMOBJ=20;
      public static final int PC_DO_NOT_INHERIT_FRIENDLYNESS_FLAG_ON_SPAWN=21;
      public static final int PC_DO_NOT_USE_MISC12_FRAME_PARAMETERS_IN_A_MUSHROOM=21;
      public static final int PC_MAX=23;
      
      public enum PC
      {
        PC_MONSTER_AVOID_HAZARDS,
        PC_REMOVE_SLIME_TRAILS,
        PC_NO_DROPOFF,
        PC_TRUNCATED_SECTOR_SPECIALS,
        PC_BOOM_BRAINAWAKE,
        PC_PRBOOM_FRICTION,
        PC_REJECT_PAD_WITH_FF,
        PC_FORCE_LXDOOM_DEMO_COMPATIBILITY,
        PC_ALLOW_SSG_DIRECT,
        PC_TREAT_NO_CLIPPING_THINGS_AS_NOT_BLOCKING,
        PC_FORCE_INCORRECT_PROCESSING_OF_RESPAWN_FRAME_ENTRY,
        PC_FORCE_CORRECT_CODE_FOR_3_KEYS_DOORS_IN_MBF,
        PC_UNINITIALIZE_CRUSH_FIELD_FOR_STAIRS,
        PC_FORCE_BOOM_FINDNEXTHIGHESTFLOOR,
        PC_ALLOW_SKY_TRANSFER_IN_BOOM,
        PC_APPLY_GREEN_ARMOR_CLASS_TO_ARMOR_BONUSES,
        PC_APPLY_BLUE_ARMOR_CLASS_TO_MEGASPHERE,
        PC_WRONG_FIXEDDIV,
        PC_FORCE_INCORRECT_BOBBING_IN_BOOM,
        PC_BOOM_DEH_PARSER,
        PC_MBF_REMOVE_THINKER_IN_KILLMOBJ,
        PC_DO_NOT_INHERIT_FRIENDLYNESS_FLAG_ON_SPAWN,
        PC_DO_NOT_USE_MISC12_FRAME_PARAMETERS_IN_A_MUSHROOM,
        PC_MAX
      };
      
    }

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;

/** BSP Node structure on-disk */
public class mapnode_v4_t
        implements CacheableDoomObject {

    public mapnode_v4_t() {
        this.bbox = new short[2][4];
        this.children = new int[2];
    }

    /** Partition line from (x,y) to x+dx,y+dy) */
    public short x, y, dx, dy;

    /** Bounding box for each child, clip against view frustum. */
    public short[][] bbox;

    /** If NF_SUBSECTOR its a subsector, else it's a node of another subtree. 
     *  In simpler words: if the first bit is set, strip it and use the rest
     *  as a subtree index. Else it's a node index.
     * */
    public int[] children = new int[2];

    public static final int sizeOf() {
        return (8 + 16 + 8);
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.x = buf.getShort();
        this.y = buf.getShort();
        this.dx = buf.getShort();
        this.dy = buf.getShort();
        DoomBuffer.readShortArray(buf, this.bbox[0], 4);
        DoomBuffer.readShortArray(buf, this.bbox[1], 4);
        DoomBuffer.readIntArray(buf, this.children, 2);
    }

}

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

public class mapsubsector_v4_t implements CacheableDoomObject{
	
    public char     numsegs;
  	/** Index of first one, segs are stored sequentially. */
  	public int     firstseg;
  
  	@Override
	public void unpack(ByteBuffer buf)
        throws IOException {
    buf.order(ByteOrder.LITTLE_ENDIAN);
    this.numsegs = buf.getChar();
    this.firstseg = buf.getInt();        
	} 

	public static int sizeOf(){
    return 6;
	}
	
}

package boom;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;

public class mapnode_znod_t implements CacheableDoomObject {

    
        public short x;  // Partition line from (x,y) to x+dx,y+dy)
        public short y;
        public short dx;
        public short dy;
        // Bounding box for each child, clip against view frustum.
        public short[][] bbox;
        // If NF_SUBSECTOR its a subsector, else it's a node of another subtree.
        public int[] children;
        
        public mapnode_znod_t(){
            this.bbox = new short[2][4];
            this.children = new int[2];
        }
        
        public static final int sizeOf() {
            return (8 + 16 + 8);
        }

        @Override
        public void unpack(ByteBuffer buf)
                throws IOException {
            buf.order(ByteOrder.LITTLE_ENDIAN);
            this.x = buf.getShort();
            this.y = buf.getShort();
            this.dx = buf.getShort();
            this.dy = buf.getShort();
            DoomBuffer.readShortArray(buf, this.bbox[0], 4);
            DoomBuffer.readShortArray(buf, this.bbox[1], 4);
            DoomBuffer.readIntArray(buf, this.children, 2);
            
        }

}

package pooling;

import doom.think_t;
import p.Actions;
import p.mobj_t;
import s.AudioChunk;

/* The idea is to reuse mobjs...however in practice that 
 * doesn't work out so well, with everything "freezing" after 
 * a while */

public class MobjPool extends ObjectPool<mobj_t>
{

	Actions A;
	
    public MobjPool(Actions A)    
    {
    	// A reasonable time limit for map objects?
    	super(1000L);
    	this.A=A;
    }

    protected mobj_t create()
    {
        /*
        for (int i=0;i<8192;i++){
            locked.push(new mobj_t(A));
        }
        
        return locked.pop();*/
        
        return new mobj_t(A);
    }

    public void expire(mobj_t o)
    {
        o.function=think_t.NOP;
    }

    public boolean validate(mobj_t o)
    {
        return (o.function==think_t.NOP);
    }

}

package pooling;

import s.AudioChunk;

// Referenced classes of package pooling:
//            ObjectPool

public class AudioChunkPool extends ObjectQueuePool<AudioChunk>
{

    public AudioChunkPool()    
    {
    	// A reasonable time limit for Audio chunks
    	super(10000L);
    }

    protected AudioChunk create()
    {
        return new AudioChunk();
    }

    public void expire(AudioChunk o)
    {
        o.free = true;
    }

    public boolean validate(AudioChunk o)
    {
        return o.free;
    }

}

package pooling;

public class RoguePatchMap extends GenericIntMap<byte[][]> {
	
	public RoguePatchMap(){
		super();
		 patches = new byte[DEFAULT_CAPACITY][][];
	}
}

package pooling;

import java.util.Arrays;

public abstract class GenericIntMap<K> {
    protected static final int DEFAULT_CAPACITY = 16;
    
    /** Concrete implementations must allocate patches
     *  
     */
    GenericIntMap() {
    
    	lumps = new int[DEFAULT_CAPACITY];
        // patches = new K[DEFAULT_CAPACITY];
    }
    
    public boolean containsKey(int lump) {
        return indexOf(lump) >= 0;
    }
    
    public K get(int lump) {
        int index = indexOf(lump);
        if (index >= 0) {
            return patches[index];
        } else {
            return null;
        }
    }
    
    public void put(int lump, K patch) {
        int index = indexOf(lump);
        if (index >= 0) {
            patches[index] = patch;
        } else {
            ensureCapacity(numEntries + 1);
            int newIndex = ~index;
            int moveCount = numEntries - newIndex;
            if (moveCount > 0) {
                System.arraycopy(lumps, newIndex, lumps, newIndex+1, moveCount);
                System.arraycopy(patches, newIndex, patches, newIndex+1, moveCount);
            }
            lumps[newIndex] = lump;
            patches[newIndex] = patch;
            ++ numEntries;
        }
    }
    
    protected void ensureCapacity(int cap) {
        while (lumps.length <= cap) {
            lumps =
                Arrays.copyOf(lumps, Math.max(lumps.length * 2, DEFAULT_CAPACITY));
        }
        while (patches.length <= cap) {
            patches =
                Arrays.copyOf(patches, Math.max(patches.length * 2, DEFAULT_CAPACITY));
        }
    }
    protected int indexOf(int lump) {
         return Arrays.binarySearch(lumps, 0, numEntries, lump);
    	//for (int i=0;i<numEntries;i++)
    	//	if (lumps[i]==lump) return i;
    	//
    	//return -1;
    	
    }
    
    
    protected int[] lumps;
    protected int numEntries;
    protected K[] patches;
}

package pooling;

import java.util.Arrays;

public class RoguePatchMap2 {
    private static final int DEFAULT_CAPACITY = 16;
    public RoguePatchMap2() {
        lumps = new int[DEFAULT_CAPACITY];
        patches = new byte[DEFAULT_CAPACITY][][];
    }
    boolean containsKey(int lump) {
        return indexOf(lump) >= 0;
    }
    public byte[][] get(int lump) {
        int index = indexOf(lump);
        if (index >= 0) {
            return patches[index];
        } else {
            return null;
        }
    }
    public void put(int lump, byte[][] patch) {
        int index = indexOf(lump);
        if (index >= 0) {
            patches[index] = patch;
        } else {
            ensureCapacity(numEntries + 1);
            int newIndex = ~index;
            int moveCount = numEntries - newIndex;
            if (moveCount > 0) {
                System.arraycopy(lumps, newIndex, lumps, newIndex+1, moveCount);
                System.arraycopy(patches, newIndex, patches, newIndex+1, moveCount);
            }
            lumps[newIndex] = lump;
            patches[newIndex] = patch;
            ++ numEntries;
        }
    }
    private void ensureCapacity(int cap) {
        while (lumps.length <= cap) {
            lumps =
                Arrays.copyOf(lumps, Math.max(lumps.length * 2, DEFAULT_CAPACITY));
        }
        while (patches.length <= cap) {
            patches =
                Arrays.copyOf(patches, Math.max(patches.length * 2, DEFAULT_CAPACITY));
        }
    }
    private int indexOf(int lump) {
        return Arrays.binarySearch(lumps, 0, numEntries, lump);
    }
    private int[] lumps;
    private int numEntries;
    private byte[][][] patches;
}
package pooling;

import java.util.Stack;

import p.mobj_t;

/** A convenient object pooling class, derived from the stock ObjectPool.
 *  
 *  It's about 50% faster than calling new, and MUCH faster than ObjectPool
 *  because it doesn't do that bullshit object cleanup every so often.
 * 
 */


public abstract class ObjectQueuePool<K>
{

	private static final boolean D=false;
	
    public ObjectQueuePool(long expirationTime)
    {
        locked = new Stack<K>();
        
    }

    protected abstract K create();

    public abstract boolean validate(K obj);

    public abstract void expire(K obj);

    public void drain(){
        locked.clear();
        }
    
    public K checkOut()
    {
        
        K t;
        if(!locked.isEmpty())
        {
            return locked.pop(); 

        }

        t = create();
        return t;
    }

    public void checkIn(K t)
    {
    	if (D) if (t instanceof mobj_t)
    	System.out.printf("Object %s returned to the pool\n",t.toString());
        locked.push(t);
    }

    protected Stack<K> locked;
   // private Hashtable<K,Long> unlocked;
}

package pooling;

import java.util.Enumeration;
import java.util.Hashtable;

import p.mobj_t;

/** A convenient object pooling class. Currently used for AudioChunks, but
 *  could be reused for UI events and other such things. Perhaps reusing it
 *  for mobj_t's is possible, but risky.
 * 
 */


public abstract class ObjectPool<K>
{

	private static final boolean D=false;
	
    public ObjectPool(long expirationTime)
    {
        this.expirationTime = expirationTime;
        locked = new Hashtable<K,Long>();
        unlocked = new Hashtable<K,Long>();
    }

    protected abstract K create();

    public abstract boolean validate(K obj);

    public abstract void expire(K obj);

    public synchronized K checkOut()
    {
        long now = System.currentTimeMillis();
        K t;
        if(unlocked.size() > 0)
        {
            Enumeration<K> e = unlocked.keys();
           // System.out.println((new StringBuilder("Pool size ")).append(unlocked.size()).toString());
            while(e.hasMoreElements()) 
            {
                t = e.nextElement();
                if(now - ((Long)unlocked.get(t)).longValue() > expirationTime)
                {
                	// object has expired
                	if (t instanceof mobj_t)
                	if (D) System.out.printf("Object %s expired\n",t.toString());
                    unlocked.remove(t);
                    expire(t);
                    t = null;
                } else
                {
                    if(validate(t))
                    {
                        unlocked.remove(t);
                        locked.put(t, Long.valueOf(now));
                        if (D) if (t instanceof mobj_t)
                        	System.out.printf("Object %s reused\n",t.toString());
                        return t;
                    }
                    
                    // object failed validation
                    unlocked.remove(t);
                    expire(t);
                    t = null;
                }
            }
        }

        t = create();
        locked.put(t, Long.valueOf(now));
        return t;
    }

    public synchronized void checkIn(K t)
    {
    	if (D) if (t instanceof mobj_t)
    	System.out.printf("Object %s returned to the pool\n",t.toString());
        locked.remove(t);
        unlocked.put(t, Long.valueOf(System.currentTimeMillis()));
    }

    private long expirationTime;
    protected Hashtable<K,Long> locked;
    private Hashtable<K,Long> unlocked;
}

package demo;

import w.IWritableDoomObject;
import defines.skill_t;

public interface IDoomDemo extends IWritableDoomObject{
	
    
    /** Vanilla end demo marker, to append at the end of recorded demos */
    
   public static final int DEMOMARKER =0x80;
   
    /** Get next demo command, in its raw format. Use
     * its own adapters if you need it converted to a 
     * standard ticcmd_t.
     *  
     * @return
     */
    IDemoTicCmd getNextTic();
    
    /** Record a demo command in the IDoomDemo's native format.
     * Use the IDemoTicCmd's objects adaptors to convert it.
     * 
     * @param tic
     */
    void putTic(IDemoTicCmd tic);

    int getVersion();

    void setVersion(int version);

    skill_t getSkill();

    void setSkill(skill_t skill);

    int getEpisode();

    void setEpisode(int episode);

    int getMap();

    void setMap(int map);

    boolean isDeathmatch();

    void setDeathmatch(boolean deathmatch);

    boolean isRespawnparm();
    
    void setRespawnparm(boolean respawnparm);

    boolean isFastparm();

    void setFastparm(boolean fastparm);
    
    boolean isNomonsters();

    void setNomonsters(boolean nomonsters);

    int getConsoleplayer();

    void setConsoleplayer(int consoleplayer);

    boolean[] getPlayeringame();

    void setPlayeringame(boolean[] playeringame);

    void resetDemo();

    


}

package demo;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import doom.ticcmd_t;

import utils.C2JUtils;
import w.CacheableDoomObject;
import w.IWritableDoomObject;

/** A more lightweight version of ticcmd_t, which contains
 *  too much crap and redundant data. In order to keep demo
 *  loading and recording easier, this class contains only the
 *  necessary stuff to read/write from/to disk during VANILLA
 *  demos. It can be converted from/to ticcmd_t, if needed.
 * 
 * @author admin
 *
 */
public class VanillaTiccmd implements CacheableDoomObject, IDemoTicCmd,IWritableDoomObject{

    /** *2048 for move */
    public byte forwardmove;

    /** *2048 for move */
    public byte sidemove;

    /** <<16 for angle delta */
    public byte angleturn;
    public byte buttons; 

    /** Special note: the only occasion where we'd ever be interested
     *  in reading ticcmd_t's from a lump is when playing back demos.
     *  Therefore, we use this specialized reading method which does NOT,
     *  I repeat, DOES NOT set all fields and some are read differently.
     *  NOT 1:1 intercangeable with the Datagram methods!  
     * 
     */
    @Override
    public void unpack(ByteBuffer f)
            throws IOException {
        
        // MAES: the original ID code for reference.
        // demo_p++ is a pointer inside a raw byte buffer.
        
     //cmd->forwardmove = ((signed char)*demo_p++); 
     //cmd->sidemove = ((signed char)*demo_p++); 
     //cmd->angleturn = ((unsigned char)*demo_p++)<<8; 
     //cmd->buttons = (unsigned char)*demo_p++; 
        
        forwardmove=f.get();
        sidemove=   f.get();        
        // Even if they use the "unsigned char" syntax, angleturn is signed.
        angleturn=f.get();
        buttons=f.get();
        
    }
    
    /** Ditto, we only pack some of the fields.
     * 
     * @param f
     * @throws IOException
     */
    public void pack(ByteBuffer f)
            throws IOException {
        
        f.put(forwardmove);
        f.put(sidemove);
        f.put(angleturn);
        f.put(buttons);        
    }
    
    private static StringBuilder sb=new StringBuilder();
    
    public String toString(){
        sb.setLength(0);
        sb.append(" forwardmove ");
        sb.append(this.forwardmove); 
        sb.append(" sidemove ");
        sb.append(this.sidemove); 
        sb.append(" angleturn ");
        sb.append(this.angleturn); 
        sb.append(" buttons ");
        sb.append(Integer.toHexString(this.buttons));
        return sb.toString();
    }

    @Override
    public void decode(ticcmd_t dest) {
        // Decode
        dest.forwardmove=this.forwardmove;
        dest.sidemove=this.sidemove;
        dest.angleturn=(short) (this.angleturn<<8);
        dest.buttons=(char) (C2JUtils.toUnsignedByte(this.buttons));
        }

    @Override
    public void encode(ticcmd_t source) {
        // Note: we can get away with a simple copy because
        // Demoticcmds have already been "decoded".
        this.forwardmove=source.forwardmove;
        this.sidemove=source.sidemove;
        // OUCH!!! NASTY PRECISION REDUCTION... but it's the
        // One True Vanilla way.
        this.angleturn=(byte) (source.angleturn>>>8);
        this.buttons=(byte) (source.buttons&0x00FF);
    }

    @Override
    public void write(DataOutputStream f)
            throws IOException {
        f.writeByte(forwardmove);
        f.writeByte(sidemove);
        f.writeByte(angleturn);
        f.writeByte(buttons); 
    }

}

package demo;

import static data.Limits.MAXPLAYERS;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

import utils.C2JUtils;
import w.CacheableDoomObject;
import w.DoomBuffer;
import w.DoomIO;
import defines.skill_t;

public class VanillaDoomDemo implements IDoomDemo,CacheableDoomObject{

	 // This stuff is in the demo header, in the order it appears
	 // However everything is byte-sized when read from disk or to memory.
	 public int version; 
	 public skill_t skill;
	 public int episode;
	 public int map;
	 public boolean deathmatch;
	 public boolean respawnparm;
	 public boolean fastparm;
	 public boolean nomonsters;
	 public int consoleplayer;
	 public boolean[] playeringame; // normally MAXPLAYERS (4) for vanilla.
	 
	 protected int p_demo;
	 
     //  After that, demos contain a sequence of ticcmd_t's to build dynamically at
     // load time or when recording. This abstraction allows arbitrary demo sizes
     // and easy per-step handling, and even changes/extensions. Just make sure
     // that ticcmd_t's are serializable!
     // Also, the format used in demo lumps is NOT the same as in datagrams/network
     // (e.g. there is no consistency) and their handling is modified.
     
     VanillaTiccmd[] commands;
     List<IDemoTicCmd> demorecorder;
     
     public VanillaDoomDemo(){
         this.demorecorder=new  ArrayList<IDemoTicCmd> ();
     }
     
	 public void unpack(ByteBuffer b){
	     
	     // Just the Header info for vanilla should be 13 bytes.
	     // 1 byte at the end is the end-demo marker
	     // So valid vanilla demos should have sizes that
	     // fit the formula 14+4n, since each vanilla 
	     // demo ticcmd_t is 4 bytes.
	     int lens=(b.limit()-13)/4;	     
	     boolean vanilla=(b.limit()==(14+4*lens));
	     
	     // Minimum valid vanilla demo should be 14 bytes...in theory.
     if (b.limit()<14) {
         // Use skill==null as an indicator that loading didn't go well.
         skill=null;
         return;
     }
     
     version=b.get();		
     
     try {
     skill = skill_t.values()[b.get()];
     } catch (Exception e){
         skill=null;
     }
     episode = b.get(); 
     map = b.get(); 
     deathmatch = b.get()!=0;
     respawnparm = b.get()!=0;
     fastparm = b.get()!=0;
     nomonsters = b.get()!=0;
     consoleplayer = b.get();
     
     playeringame=new boolean[MAXPLAYERS];
     
     for (int i=0 ; i<MAXPLAYERS ; i++) 
     playeringame[i] = b.get()!=0;
     
     
     this.commands=new VanillaTiccmd[lens];
     C2JUtils.initArrayOfObjects(this.commands, VanillaTiccmd.class);
     
     try {
		DoomBuffer.readObjectArray(b, this.commands, lens);
	} catch (IOException e) {
	    skill=null;
	    return;
	}

     }

    @Override
    public IDemoTicCmd getNextTic() {
        if ((commands!=null)&&(p_demo<commands.length)){

        return commands[p_demo++];
        }
        else return null;
    }

    @Override
    public void putTic(IDemoTicCmd tic) {
        demorecorder.add(tic);

    }

    @Override
    public int getVersion() {
        return version;
    }

    @Override
    public void setVersion(int version) {
        this.version = version;
    }

    @Override
    public skill_t getSkill() {
        return skill;
    }

    @Override
    public void setSkill(skill_t skill) {
        this.skill = skill;
    }

    @Override
    public int getEpisode() {
        return episode;
    }

    @Override
    public void setEpisode(int episode) {
        this.episode = episode;
    }

    @Override
    public int getMap() {
        return map;
    }

    @Override
    public void setMap(int map) {
        this.map = map;
    }

    @Override
    public boolean isDeathmatch() {
        return deathmatch;
    }

    @Override
    public void setDeathmatch(boolean deathmatch) {
        this.deathmatch = deathmatch;
    }

    @Override
    public boolean isRespawnparm() {
        return respawnparm;
    }

    @Override
    public void setRespawnparm(boolean respawnparm) {
        this.respawnparm = respawnparm;
    }

    @Override
    public boolean isFastparm() {
        return fastparm;
    }

    @Override
    public void setFastparm(boolean fastparm) {
        this.fastparm = fastparm;
    }

    @Override
    public boolean isNomonsters() {
        return nomonsters;
    }

    @Override
    public void setNomonsters(boolean nomonsters) {
        this.nomonsters = nomonsters;
    }

    @Override
    public int getConsoleplayer() {
        return consoleplayer;
    }

    @Override
    public void setConsoleplayer(int consoleplayer) {
        this.consoleplayer = consoleplayer;
    }
    
    @Override
    public boolean[] getPlayeringame() {
        return playeringame;
    }

    @Override
    public void setPlayeringame(boolean[] playeringame) {
        this.playeringame = playeringame;
    }

    @Override
    public void write(DataOutputStream f)
            throws IOException {
        
        f.writeByte(version);        
        f.writeByte(skill.ordinal()); 
        f.writeByte(episode);
        f.writeByte(map);
        f.writeBoolean(deathmatch);
        f.writeBoolean(respawnparm);
        f.writeBoolean(fastparm);
        f.writeBoolean(nomonsters);
        f.writeByte(consoleplayer);
        DoomIO.writeBoolean(f,this.playeringame,MAXPLAYERS);
        for (IDemoTicCmd i: demorecorder) {            
            i.write(f);
        }
        f.writeByte(DEMOMARKER);
        
        // TODO Auto-generated method stub
        
    }

    @Override
    public void resetDemo() {
        this.p_demo=0;
        
    }
    
    /////////////////////// VARIOUS BORING GETTERS /////////////////////
    
    
	
}

package demo;

import w.IWritableDoomObject;
import doom.ticcmd_t;

/** Demo Tic Commands can be read/written to disk/buffers,
 *  and are not necessarily equal to the in-game ticcmd_t.
 *  Thus, it's necessary for them to implement some
 *  adaptor method (both ways).
 *  
 * @author admin
 *
 */

public interface IDemoTicCmd extends IWritableDoomObject{
    /** Decode this IDemoTicCmd into a standard ticcmd_t. 
     * 
     * @param source
     */
    public void decode(ticcmd_t dest);
    
    /** Encode this IDemoTicCmd from a standard ticcmd_t.
     * 
     * @param dest
     */
    public void encode(ticcmd_t source);
    
}

package m;

import java.io.IOException;

public interface ISyncLogger {

	public void debugStart() throws IOException;
	public void debugEnd();
	public void sync(String format, Object ... args);
}


package m;

import data.mobjtype_t;
import doom.think_t;

public interface IRandom {
	public int P_Random ();
	public int M_Random ();
	public void ClearRandom ();
	public int getIndex();
	public int P_Random(int caller);
	public int P_Random(String message);
	public int P_Random(think_t caller, int sequence);
	public int P_Random(think_t caller, mobjtype_t type,int sequence);
}

package m;

import static data.Limits.*;

/** A fucked-up bounding box class.
 *  Fucked-up  because it's supposed to wrap fixed_t's.... no fucking way I'm doing
 *  this with fixed_t objects.
 *  
 * @author admin
 *
 */

public class BBox {

	public static final int BOXTOP = 0;
	public static final int BOXBOTTOM = 1;
	public static final int BOXLEFT = 2;
	public static final int BOXRIGHT = 3;
	/** (fixed_t) */
	public int[] bbox;

	/** Points of the bbox as an object */

	public BBox() {
		bbox = new int[4];
	}

	// Static method

	public static void ClearBox(fixed_t[] box) {
		box[BOXRIGHT].set(MININT);
		box[BOXTOP].set(MININT);
		box[BOXLEFT].set(MAXINT);
		box[BOXBOTTOM].set(MAXINT);
	}

	// Instance method

	public void ClearBox() {
		bbox[BOXRIGHT]=(MININT);
		bbox[BOXTOP]=(MININT);
		bbox[BOXLEFT]=(MAXINT);
		bbox[BOXBOTTOM]=(MAXINT);
	}

	public static void AddToBox(fixed_t[] box, fixed_t x, fixed_t y) {
		if (x.compareTo(box[BOXLEFT]) < 0)
			box[BOXLEFT].copy(x);
		else if (x.compareTo(box[BOXRIGHT]) > 0)
			box[BOXRIGHT].copy(x);
		if (y.compareTo(box[BOXBOTTOM]) < 0)
			box[BOXBOTTOM] = y;
		else if (y.compareTo(box[BOXTOP]) > 0)
			box[BOXTOP] = y;
	}

	public void AddToBox(fixed_t x, fixed_t y) {
		if (x.compareTo(bbox[BOXLEFT]) < 0)
			bbox[BOXLEFT]=x.val;
		else if (x.compareTo(bbox[BOXRIGHT]) > 0)
			bbox[BOXRIGHT]=x.val;
		if (y.compareTo(bbox[BOXBOTTOM]) < 0)
			bbox[BOXBOTTOM] = y.val;
		else if (y.compareTo(bbox[BOXTOP]) > 0)
			bbox[BOXTOP] = y.val;
	}

	/**
	 * MAES: Keeping with C's type (in)consistency, we also allow to input ints
	 * -_-
	 * 
	 * @param x
	 * @param y
	 */
	public void AddToBox(int x, int y) {
		if (x < bbox[BOXLEFT])
			bbox[BOXLEFT]=(x);
		if (x > bbox[BOXRIGHT])
			bbox[BOXRIGHT]=(x);
		if (y < bbox[BOXBOTTOM])
			bbox[BOXBOTTOM]=(y);
		if (y > bbox[BOXTOP])
			bbox[BOXTOP]=(y);
	}

	/**
	 * R_AddPointToBox Expand a given bbox so that it encloses a given point.
	 * 
	 * @param x
	 * @param y
	 * @param box
	 */

	public static void AddPointToBox(int x, int y, fixed_t[] box) {
		if (x < box[BOXLEFT].val)
			box[BOXLEFT].set(x);
		if (x > box[BOXRIGHT].val)
			box[BOXRIGHT].set(x);
		if (y < box[BOXBOTTOM].val)
			box[BOXBOTTOM].set(y);
		if (y > box[BOXTOP].val)
			box[BOXTOP].set(y);
	}

	/**
	 * R_AddPointToBox Expand this bbox so that it encloses a given point.
	 * 
	 * @param x
	 * @param y
	 * @param box
	 */

	public void AddPointToBox(int x, int y) {
		if (x < bbox[BOXLEFT])
			bbox[BOXLEFT]=x;
		if (x > bbox[BOXRIGHT])
			bbox[BOXRIGHT]=x;
		if (y < bbox[BOXBOTTOM])
			bbox[BOXBOTTOM]=y;
		if (y > bbox[BOXTOP])
			bbox[BOXTOP]=y;
	}

	public int get(int BOXCOORDS){
	    return this.bbox[BOXCOORDS];
	}
	
    public void set(int BOXCOORDS, int val){
        this.bbox[BOXCOORDS]=val;
    }

    public static void ClearBox(int[] bbox) {
        bbox[BOXRIGHT]=(MININT);
        bbox[BOXTOP]=(MININT);
        bbox[BOXLEFT]=(MAXINT);
        bbox[BOXBOTTOM]=(MAXINT);
    }

    public static void AddToBox(int[] box, int x, int y) {
        if (x < box[BOXLEFT])
            box[BOXLEFT]=x;
        if (x > box[BOXRIGHT])
            box[BOXRIGHT]=x;
        if (y < box[BOXBOTTOM])
            box[BOXBOTTOM]=y;
        if (y > box[BOXTOP])
            box[BOXTOP]=y;        
    }
	
}

package m;

import data.Defines;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: fixed_t.java,v 1.14 2011/10/25 19:52:13 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// DESCRIPTION:
//	Fixed point implementation.
//
//-----------------------------------------------------------------------------

//
// Fixed point, 32bit as 16.16.
//
// Most functionality of C-based ports is preserved, EXCEPT that there's
// no typedef of ints into fixed_t, and that there's no actual object fixed_t
// type that is actually instantiated in the current codebase, for performance reasons.
// There are still remnants of a full OO implementation that still do work, 
// and the usual FixedMul/FixedDiv etc. methods are still used throughout the codebase,
// but operate on int operants (signed, 32-bit integers).

public class fixed_t implements Comparable<fixed_t>{

    public static final int FRACBITS =       16;
    public static final int FRACUNIT =       (1<<FRACBITS);
    public static final int MAPFRACUNIT =    FRACUNIT/Defines.TIC_MUL;
    public int val;
    
    public fixed_t(){
        this.set(0);
    }
    
    public int get(){
        return val;
    }
    
    public void set(int val){
        this.val=val;
    }

    public void copy(fixed_t a){
        this.set(a.get());
    }

    
    public boolean equals(fixed_t a){
        return (this.get()==a.get())?true:false;
    }

    public static boolean equals(fixed_t a, fixed_t b){
        return (a.get()==b.get())?true:false;
    }    
    
    public fixed_t(int val){
        this.val=val;
    }
    
public fixed_t(fixed_t x) {
        this.val=x.val;
    }

public static final String rcsid = "$Id: fixed_t.java,v 1.14 2011/10/25 19:52:13 velktron Exp $";

/** Creates a new fixed_t object for the result a*b
 * 
 * @param a
 * @param b
 * @return
 */

public static int FixedMul
( fixed_t	a,
  fixed_t	b )
{
    return (int)(((long) a.val * (long ) b.val) >>> FRACBITS);
}

public static int FixedMul
( int   a,
  fixed_t   b )
{
    return (int)(((long) a * (long ) b.val) >>> FRACBITS);
}

public static final int FixedMul
( int   a,
  int   b )
{
    return (int)(((long) a * (long ) b) >>> FRACBITS);
}


/** Returns result straight as an int..
 * 
 * @param a
 * @param b
 * @return
 */

public static int FixedMulInt
( fixed_t   a,
        fixed_t   b )
{
    return (int)(((long) a.val * (long ) b.val) >> FRACBITS);
}

/** In-place c=a*b
 * 
 * @param a
 * @param b
 * @param c
 */

public final static void FixedMul
( fixed_t   a,
        fixed_t   b,
        fixed_t c)
{
    c.set((int)(((long) a.val * (long ) b.val) >> FRACBITS));
}


/** In-place this=this*a
 * 
 * @param a
 * @param b
 * @param c
 */

public final void FixedMul
( fixed_t   a)
{
    this.set((int)(((long) a.val * (long ) this.val) >> FRACBITS));
}


public final static int
FixedDiv
( int   a,
  int   b )
{
	  if ((Math.abs(a) >> 14) >= Math.abs(b))
	    {
		return (a^b) < 0 ? Integer.MIN_VALUE : Integer.MAX_VALUE;
	    }
	    else
	    {
		long result;

		result = ((long) a << 16) / b;

		return (int) result;
	    }
}


public final static int
FixedDiv2
( int   a,
  int   b )
{

    
    int c;
    c = (int)(((long)a<<16) / (long)b);
    return c;
    
    /*
    double c;

    c = ((double)a) / ((double)b) * FRACUNIT;

  if (c >= 2147483648.0 || c < -2147483648.0)
      throw new ArithmeticException("FixedDiv: divide by zero");
 
 return (int)c;*/
}

@Override
public int compareTo(fixed_t o) {
    if (o.getClass()!=fixed_t.class) return -1;
    if (this.val==((fixed_t)(o)).val) return 0;
    if (this.val>((fixed_t)(o)).val) return 1;
    else return -1;
    }

public int compareTo(int o) {
    if (this.val==o) return 0;
    if (this.val>o) return 1;
    else return -1;
    }

public void add(fixed_t a){
    this.val+=a.val;
}

public void sub(fixed_t a){
    this.val-=a.val;
}

public void add(int a){
    this.val+=a;
}

public void sub(int a){
    this.val-=a;
}

/** a+b
 * 
 * @param a
 * @param b
 * @return
 */

public static int add(fixed_t a,fixed_t b){
    return a.val+b.val;
}

/** a-b
 * 
 * @param a
 * @param b
 * @return
 */

public static int sub(fixed_t a,fixed_t b){
    return a.val-b.val;
}

/** c=a+b
 * 
 * @param c
 * @param a
 * @param b
 */

public static void add(fixed_t c, fixed_t a,fixed_t b){
    c.val= a.val+b.val;
}

/** c=a-b
 * 
 * @param c
 * @param a
 * @param b
 */

public static void sub(fixed_t c,fixed_t a,fixed_t b){
    c.val= a.val-b.val;
}


/** Equals Zero
 * 
 * @return
 */

public boolean isEZ() {
    return (this.val==0);
    }

/** Greater than Zero
 * 
 * @return
 */

public boolean isGZ() {
    return (this.val>0);
    }

/** Less than Zero
 * 
 * @return
 */
public boolean isLZ() {
    return (this.val<0);
    }

// These are here to make easier handling all those methods in R 
// that return "1" or "0" based on one result.

public int oneEZ(){
    return (this.val==0)?1:0;
}

public int oneGZ(){
    return (this.val>0)?1:0;
}

public int oneLZ(){
    return (this.val<0)?1:0;
}


}
package m;

// Emacs style mode select -*- C++ -*-
// -----------------------------------------------------------------------------
//
// $Id: cheatseq_t.java,v 1.8 2011/11/01 23:47:50 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// $Log: cheatseq_t.java,v $
// Revision 1.8  2011/11/01 23:47:50  velktron
// Added constructor method to start from unscrambled strings.
//
// Revision 1.7  2011/05/06 14:00:54  velktron
// More of _D_'s changes committed.
//
// Revision 1.6  2010/12/14 00:53:32  velktron
// Some input sanitizing. Far from perfect but heh...
//
// Revision 1.5  2010/08/25 00:50:59  velktron
// Some more work...
//
// Revision 1.4  2010/07/21 11:41:47  velktron
// Work on menus...
//
// Revision 1.3 2010/07/20 15:52:56 velktron
// LOTS of changes, Automap almost complete. Use of fixed_t inside methods
// severely limited.
//
// Revision 1.2 2010/07/03 23:24:13 velktron
// Added a LOT of stuff, like Status bar code & objects. Now we're cooking with
// gas!
//
// Revision 1.1 2010/06/30 08:58:50 velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still being worked on. For a good place to start and get an
// idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1 2010/06/29 11:07:34 velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete,
// and there's still mixed C code in there. I suggest you load everything up in
// Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you can get an idea of
// how a few of the implemented stuff works.
//
//
// DESCRIPTION:
// Cheat sequence checking.
//
// -----------------------------------------------------------------------------

/**
 * Cheat sequence checking. MAES: all of this stuff used to be in cheat.h and
 * cheat.c, but seeing how all manipulation is done on "cheatseq_t" objects, it
 * makes more sense to move this functionality in here, and go OO all the way.
 * So away with the fugly static methods!!!
 */

public class cheatseq_t {

    // This holds the actual data (was a char*).
    public char[] sequence;

    // This is used as a pointer inside sequence.
    // Was a char*, but in Java it makes more sense to have it as an int.
    public int p;

    public cheatseq_t(char[] sequence, int p) {
        this.sequence = sequence;
        this.p = p;
    }

    public cheatseq_t(char[] sequence) {
        this.sequence = sequence;
        this.p = 0;
    }

    public cheatseq_t(String sequence, boolean prescrambled){
    	if (prescrambled){
    		this.sequence=sequence.toCharArray();
    		p=0;
    	} else {
    		this.sequence=scrambleString(sequence);
    		p=0;
    	}    	
    	}
    
    /**
     * This was in cheat.c, but makes more sense to be used as an
     * initializer/constructor.
     */
    public void GetParam(char[] buffer) {

        // char[] p;
        char c;
        int ptr = 0;

        // p = this.sequence;
        // Increments pointer until the sequence reaches its first internal "1"
        // ???
        while (this.sequence[ptr++] != 1)
            ;
        int bptr = 0;
        // Now it copies the contents of this cheatseq_t into buffer...and nils
        // it???
        do {
            c = this.sequence[ptr];
            buffer[bptr++] = c;
            this.sequence[ptr++] = 0;
        } while ((c != 0) && (this.sequence[ptr] != 0xff));

        if (this.sequence[ptr] == 0xff)
            buffer[bptr] = 0;

    }

    /**
     * Called in st_stuff module, which handles the input. Returns true if the
     * cheat was successful, false if failed. MAES: Let's make this boolean.
     * 
     * @param cht
     * @param key
     * @return
     */

    public boolean CheckCheat(cheatseq_t cht, char key) {
        boolean rc = false;

        if (cht.p < 0)
            cht.p = 0; // initialize if first time

        if (cht.p == 0)
            // This actually points inside "sequence"
            // *(cht->p++) = key;
            cht.sequence[cht.p++] = key;
        else if (cheat_xlate_table[(char) key] == cht.sequence[cht.p])
            cht.p++;
        else
            // Failure: back to the beginning.
            cht.p = 0;

        if (cht.sequence[cht.p] == 1)
            cht.p++;
        else if (cht.sequence[cht.p] == 0xff) // end of sequence character
        {
            cht.p = 0;
            rc = true;
        }

        return rc;
    }

    /**
     * Called in st_stuff module, which handles the input. Returns true if the
     * cheat was successful, false if failed. MAES: Let's make this boolean.
     * 
     * @param key
     * @return
     */

    public boolean CheckCheat(char key) {
        boolean rc = false;



        if (this.p < 0)
            this.p = 0; // initialize if first time

        if (sequence[p] == 0)
            // This actually points inside "sequence"
            // *(cht->p++) = key;
            sequence[p++] = key;
            //p++;  //_D_: this fixed cheat with parm problem (IDCLIP)
        else if (cheat_xlate_table[(char) key] == sequence[p])
            p++;
        else
            // Failure: back to the beginning.
            p = 0;
        if (sequence[p] == 1)
            p++;
        else if (sequence[p] == 0xff) // end of sequence character
        {
            p = 0;
            rc = true;
        }

        return rc;
    }

    /**
     * Scrambles a character. 7 -> 0 6 -> 1 5 -> 5 4 -> 3 3 -> 4 2 -> 2 1 -> 6 0
     * -> 7
     * 
     * @param a
     * @return
     */
    public static char SCRAMBLE(char a) {
        return (char) ((((a) & 1) << 7) + (((a) & 2) << 5) + ((a) & 4)
                + (((a) & 8) << 1) + (((a) & 16) >>> 1) + ((a) & 32)
                + (((a) & 64) >>> 5) + (((a) & 128) >>> 7));
    }
    
    public static char[] scrambleString(String s){
    	
    	char[] tmp=new char[s.length()+1];
    	for (int i=0;i<s.length();i++){
    		tmp[i]=SCRAMBLE(s.charAt(i));
    	}    	
    	tmp[s.length()]=0xff;    	
    	
    	return tmp;    	
    }

    /**
     * These should be common among all instances, unless for soooome reason you
     * need multiple different such tables.
     */
    public static boolean firsttime = true;

    public static char[] cheat_xlate_table = new char[256];

   static {
       if (firsttime) {
           firsttime = false;
           for (char i = 0; i < 256; i++)
               cheat_xlate_table[i] = SCRAMBLE(i);
       }
   }
}

package m;

import doom.DoomStatus;
import doom.IDoomGame;
import hu.HU;
import i.DoomStatusAware;
import i.IDoomSystem;
import rr.RendererState;
import s.IDoomSound;
import timing.ITicker;
import v.DoomVideoRenderer;
import v.IVideoScaleAware;
import w.IWadLoader;

public abstract class AbstractDoomMenu
        implements IDoomMenu {

    ////////////////////// CONTEXT ///////////////////
    
    DoomStatus DM;
    IDoomGame DG;
    IWadLoader W;
    DoomVideoRenderer V;
    HU HU;
    RendererState R;
    IDoomSystem I;
    IDoomSound S;
    ITicker TICK;
    
    @Override
    public void updateStatus(DoomStatus DS) {
           this.DM=DS.DM;
           this.DG=DS.DG;
            this.V=DM.V;
            this.W=DM.W;
            this.HU=DM.HU;
            this.I=DM.I;
            this.S=DM.S;
            this.R=(RendererState) DM.R;
            this.TICK=DM.TICK;
        
    }
    
}

package m;

import i.DoomSystem;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferUShort;
import java.awt.image.IndexColorModel;
import java.io.BufferedInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Arrays;
import javax.imageio.ImageIO;

import w.IWritableDoomObject;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: MenuMisc.java,v 1.29 2012/09/24 17:16:22 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// DESCRIPTION:
//	Main loop menu stuff.
//	Default Config File.
//	PCX Screenshots.
//
//-----------------------------------------------------------------------------

public abstract class MenuMisc{

    public static final String rcsid = "$Id: MenuMisc.java,v 1.29 2012/09/24 17:16:22 velktron Exp $";
  
    //
    // SCREEN SHOTS
    //
  
    public static boolean WriteFile(String name, byte[] source, int length) {
        OutputStream handle;
        try {
            handle = new  FileOutputStream(name);
            handle.write(source, 0, length);
            handle.close();
        } catch (Exception e) {
            DoomSystem.MiscError("Couldn't write file %s (%s)", name, e.getMessage());
            return false;
        }

        return true;
    }

    public static boolean WriteFile(String name, IWritableDoomObject source) {
        DataOutputStream handle;
        try {
            handle = new DataOutputStream(new FileOutputStream(name));
            source.write(handle);
            handle.close();
        } catch (Exception e) {
            DoomSystem.MiscError("Couldn't write file %s (%s)", name, e.getMessage());
            return false;
        }

        return true;
    }


    /** M_ReadFile 
     *  This version returns a variable-size ByteBuffer, so
     *  we don't need to know a-priori how much stuff to read.
     * 
     */
    public static ByteBuffer ReadFile(String name) {
        BufferedInputStream handle;
        int length;
        // struct stat fileinfo;
        ByteBuffer buf;
        try {
            handle = new BufferedInputStream(new FileInputStream(name));
            length = (int) handle.available();
            buf = ByteBuffer.allocate(length);
            handle.read(buf.array());
            handle.close();
        } catch (Exception e) {
            DoomSystem.MiscError("Couldn't read file %s (%s)", name, e.getMessage());
            return null;
        }

        return buf;
    }

    /** M_ReadFile */
    public static int ReadFile(String name, byte[] buffer) {
    	BufferedInputStream handle;
        int count, length;
        // struct stat fileinfo;
        byte[] buf;
        try {
            handle = new BufferedInputStream(new FileInputStream(name));
            length = (int) handle.available();
            buf = new byte[length];
            count = handle.read(buf);
            handle.close();

            if (count < length)
                throw new Exception("Read only " + count + " bytes out of "
                    + length);

        } catch (Exception e) {
            DoomSystem.MiscError("Couldn't read file %s (%s)", name, e.getMessage());
            return -1;
        }
        System.arraycopy(buf, 0, buffer, 0, Math.min(count,buffer.length));
        return length;
    }

    //
 // WritePCXfile
 //
 public static void
 WritePCXfile
 ( String        filename,
   byte[]     data,
   int       width,
   int       height,
   byte[]     palette )
 {
     int     length;
     pcx_t  pcx;
     byte[]   pack;
     
     pcx = new pcx_t();
     pack=new byte[width*height*2]; // allocate that much data, just in case.

     pcx.manufacturer = 0x0a;       // PCX id
     pcx.version = 5;           // 256 color
     pcx.encoding = 1;          // uncompressed
     pcx.bits_per_pixel = 8;        // 256 color
     pcx.xmin = 0;
     pcx.ymin = 0;
     pcx.xmax = (char) (width-1);
     pcx.ymax = (char) (height-1);
     pcx.hres = (char) width;
     pcx.vres = (char) height;
     // memset (pcx->palette,0,sizeof(pcx->palette));
     pcx.color_planes = 1;      // chunky image
     pcx.bytes_per_line = (char) width;
     pcx.palette_type = 2;   // not a grey scale
     //memset (pcx->filler,0,sizeof(pcx->filler));


     // pack the image
     //pack = &pcx->data;
     int p_pack=0;
     
     for (int i=0 ; i<width*height ; i++)
     {
     if ( (data[i] & 0xc0) != 0xc0)
         pack[p_pack++] = data[i];
     else
     {
         pack[p_pack++] = (byte) 0xc1;
         pack[p_pack++] = data[i];
     }
     }
     
     // write the palette
     pack[p_pack++] = 0x0c; // palette ID byte
     for (int i=0 ; i<768 ; i++)
         pack[p_pack++] = palette[i];
     
     // write output file
     length = p_pack;
     pcx.data=Arrays.copyOf(pack, length);
     
     DataOutputStream f=null;
    try {
        f = new DataOutputStream(new FileOutputStream(filename));
        
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
     
    try {
        //f.setLength(0);
        pcx.write(f);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    
     }
    
    public abstract boolean getShowMessages();

    public abstract void setShowMessages(boolean val);

	public static void WritePNGfile(String imagename, short[] linear,
			int width, int height) {
		
		BufferedImage buf=new BufferedImage(width,height,BufferedImage.TYPE_USHORT_555_RGB);
		DataBufferUShort sh=(DataBufferUShort) buf.getRaster().getDataBuffer();
		short[] shd=sh.getData();
		System.arraycopy(linear,0,shd,0,Math.min(linear.length,shd.length));
		try {
			ImageIO.write(buf, "PNG",new File(imagename));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// TODO Auto-generated method stub
		
	}

	public static void WritePNGfile(String imagename, int[] linear,
            int width, int height) {
        
        BufferedImage buf=new BufferedImage(width,height,BufferedImage.TYPE_INT_ARGB);
        DataBufferInt sh=(DataBufferInt) buf.getRaster().getDataBuffer();
        int[] shd=sh.getData();
        System.arraycopy(linear,0,shd,0,Math.min(linear.length,shd.length));
        try {
            ImageIO.write(buf, "PNG",new File(imagename));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // TODO Auto-generated method stub
        
    }
	
	public static void WritePNGfile(String imagename, byte[] linear,
            int width, int height,IndexColorModel icm) {
        BufferedImage buf=new BufferedImage(width,height,BufferedImage.TYPE_BYTE_INDEXED,icm);
        DataBufferByte sh=(DataBufferByte) buf.getRaster().getDataBuffer();
        byte[] shd=sh.getData();
        System.arraycopy(linear,0,shd,0,Math.min(linear.length,shd.length));
        try {
            ImageIO.write(buf, "PNG",new File(imagename));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // TODO Auto-generated method stub
        
    }
	
}

// $Log: MenuMisc.java,v $
// Revision 1.29  2012/09/24 17:16:22  velktron
// Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
// Revision 1.28.2.4  2012/09/24 16:57:43  velktron
// Addressed generics warnings.
//
// Revision 1.28.2.3  2012/09/17 15:58:58  velktron
// Defaults loading & handling moved out to variables management subsystem
//
// Revision 1.28.2.2  2011/11/18 21:37:59  velktron
// Saves PNGs now.
//
// Revision 1.28.2.1  2011/11/14 00:27:11  velktron
// A barely functional HiColor branch. Most stuff broken. DO NOT USE
//
// Revision 1.28  2011/10/25 19:52:03  velktron
// Using buffered I/O when possible
//
// Revision 1.27  2011/10/24 02:11:27  velktron
// Stream compliancy
//
// Revision 1.26  2011/07/30 22:04:30  velktron
// Removed unused imports (including one that would cause problems compiling with OpenJDK).
//
// Revision 1.25  2011/07/15 13:53:52  velktron
// Implemented WritePCXFile, at last.
//
// Revision 1.24  2011/06/03 16:37:09  velktron
// Readfile will only read at most as much as the buffer allows.
//
// Revision 1.23  2011/05/31 13:33:54  velktron
// -verbosity
//
// Revision 1.22  2011/05/31 09:57:45  velktron
// Fixed broken parsing of unspaced strings. 
// It's never fun having to come up with your own function for string manipulation!
//
// Revision 1.21  2011/05/30 15:46:50  velktron
// AbstractDoomMenu implemented.
//
// Revision 1.20  2011/05/26 17:54:16  velktron
// Removed some Menu verbosity, better defaults functionality.
//
// Revision 1.19  2011/05/26 13:39:15  velktron
// Now using ICommandLineManager
//
// Revision 1.18  2011/05/24 17:46:03  velktron
// Added vanilla default.cfg loading.
//
package m;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.StringTokenizer;

import doom.ICommandLineManager;

import utils.C2JUtils;

/** Variables manager registers and retrieves variables (or "settings")
 *  For the purposes of Doom, three types will suffice: 
 *  boolean, integer (maybe float?), and string.
 *  
 *  Variables can be registered at startup, through *.cfg files,
 *  and through a (future) console. They can also be deleted 
 *  and updated.
 *  
 *  The variables manager just has the job of managing them. 
 *  Applying/making use of the variables themselves is the job 
 *  of the code that specifically uses them. 
 *  
 *  Proposed way of proceeding: making an "IUseVariables" interface,
 *  which is module-specific, and is called whenever new settings must
 *  be applied.
 *  
 *  E.g. stuff is read from config.cfg, and the the updateSettings()
 *  method of e.g. DoomMain is called, applying whatever changes need 
 *  to be done. Same thing with menus.
 *  
 *  TODO: a similar system was being planned for the CommandLine manager,
 *  but never implemented, wtf.... fix now?
 *  
 */

public class VarsManager implements IVariablesManager {
    
    private final HashMap<String,DoomSetting> settings;
    private final ICommandLineManager CLM;
    
    public VarsManager(ICommandLineManager CLM){
        this.settings=new HashMap<String,DoomSetting>();
        this.CLM=CLM;
    }
    
    @Override
    public DoomSetting getSetting(String name){
        
        DoomSetting tmp=settings.get(name);
        if (tmp!=null) {
            return tmp;
        }
        
        // Good question...what to do here?
        return DoomSetting.NULL_SETTING;
    }
    
    @Override
    public DoomSetting getSetting(Settings name){
        
        DoomSetting tmp=settings.get(name.name());
        if (tmp!=null) {
            return tmp;
        }
        
        // Good question...what to do here?
        return DoomSetting.NULL_SETTING;
    }
    
    @Override
    public boolean isSettingLiteral(String name,String value){
        
        return getSetting(name).getString().equalsIgnoreCase(value);
    }
    
    
    /** Creates a new setting, overriding any existing ones */

    @Override
    public void putSetting(String name,Object value,boolean persist){        
        DoomSetting tmp=new DoomSetting(name,value.toString(),persist);
        settings.put(name,tmp);
    }

    @Override
    public void putSetting(Settings name,Object value){        
        DoomSetting tmp=new DoomSetting(name.name(),value.toString(),true);
        settings.put(name.name(),tmp);
    }
    
    @Override
    public void putSetting(String name,Object value){        
        DoomSetting tmp=new DoomSetting(name,value.toString(),true);
        settings.put(name,tmp);
    }
    
    //
    // M_LoadDefaults
    //

    @Override
    public void LoadDefaults (String defaultfile)
    {
        int     i;
        BufferedReader  in;

        // Set everything to base values. These are persistent.
        int numdefaults = Settings.values().length;
        for (i=0 ; i<numdefaults ; i++){            
            putSetting(Settings.values()[i].name(),Settings.values()[i].value,true);
        }

        try {

            // read the file in, overriding any set defaults
            in = new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream(defaultfile))));
            if (in!=null)
            {
                String name = null, value = null;
                String s;
                
                // Let's make this the sane way...read a string.
                while (( s=in.readLine())!=null)
                {

                    StringTokenizer tk=new StringTokenizer(s);

                    // They should be exactly two.
                    int tokens=tk.countTokens();
                    if (tokens==2){
                        name=tk.nextToken();
                        value=tk.nextToken();
                        
                        // TODO default value?
                        if (value==null) value="0";
                    } else if (tokens>2){
                        // Not clear what to do in case of multiple values on
                        // the same line. Either introduce multi-value vars (ugh...)
                        // or "join" the tokens, assuming that they are unquoted strings.
                        name=tk.nextToken();
                        value = C2JUtils.unquote(s,'"');
                        if (value==null) continue;
                    }

                        // All var names should be lower case.
                        name=name.toLowerCase();
                        //System.out.printf("NAME: %s VALUE: %s\n",name,value);

                        // Everything read from the file should be marked
                        // as "persistent". There are no "unknown" settings. 
                        // Unusable, maybe.
                        settings.put(name, new DoomSetting(name,value, true));
                        
                } // end-while


                in.close();
            } // not null
        }catch (IOException e){
            // This won't destroy successfully read values, though.
            System.err.printf("I just can't read the settings file %s, will use defaults.\n",defaultfile);
        }
    }

    @Override
    public void applySetting(IUseVariables setme, String name, String value) {
        // TODO Auto-generated method stub
        
    }
    
    //
    // M_SaveDefaults
    //
    
    @Override
    public void SaveDefaults (String defaultfile)
    {
        OutputStream f;
        PrintStream  ps;

        try {
            f = new FileOutputStream(defaultfile);
        } catch (FileNotFoundException e) {
            // can't write the file, but don't complain
            return;
        }

        ps=new PrintStream(f);
        
        Set<Entry<String,DoomSetting>> stuff=settings.entrySet();
        List<DoomSetting> save=new ArrayList<DoomSetting>();
        
        for (Entry<String,DoomSetting> entry :stuff)
        {
            
            DoomSetting set=entry.getValue();
            
            // Save only stuff marked as "persistent"
            if (set.getPersist()){
                save.add(set);
            }
        }
        
        // Nicely sorted alphabetically :-)
        Collections.sort(save);
        
        for (DoomSetting var :save){
            if (C2JUtils.flags(var.getTypeFlag(),DoomSetting.BOOLEAN)){
                ps.printf("%s\t\t%s\n",var.getName(),var.getBoolean());
                continue;
            }
            
            if (C2JUtils.flags(var.getTypeFlag(),DoomSetting.CHAR)){
                ps.printf("%s\t\t\'%c\'\n",var.getName(),var.getChar());
                continue;
            }
            
            if (C2JUtils.flags(var.getTypeFlag(),DoomSetting.INTEGER)){
                ps.printf("%s\t\t%s\n",var.getName(),var.getString());
                continue;
            }
        
            ps.printf("%s\t\t\"%s\"\n",var.getName(),var.getString());
        }

        
        try {
            f.close();}
        catch (IOException e) {
            // Well duh....
            return;
        }
    }
    

    public String getDefaultFile(){
    // check for a custom default file

    int i = CLM.CheckParm("-config");
    if ((i>0) && i<CLM.getArgc()-1)
    {
        return CLM.getArgv(i+1);
        //System.out.printf("   default file: %s\n",defaultfile);
    }
    else
        return Settings.basedefault;
    }

    
}

package m;

import java.io.DataOutputStream;
import java.io.IOException;

import w.IWritableDoomObject;

/** Yeah, this is actually a PCX header implementation, and Mocha Doom
 *  saved PCX screenshots. Implemented it back just to shot that it can be
 *  done (will switch to PNG ASAP though). 
 *  
 *  @author Maes
 * 
 */

public class pcx_t implements IWritableDoomObject{

	//
	// SCREEN SHOTS
	//

		// char -> byte Bytes.
        /** manufacturer byte, must be 10 decimal */
		public byte		manufacturer;
		
		/** PCX version number */
		byte		version;
		
		/** run length encoding byte, must be 1 */
		byte		encoding;
		
		/** number of bits per pixel per bit plane */
		byte		bits_per_pixel;
		
		/** image limits in pixels: Xmin, Ymin, Xmax, Ymax */
		public char	xmin,ymin,xmax,ymax;
	    
		/** horizontal dots per inch when printed (unreliable) */
		char	hres;
		
		/** vertical dots per inch when printed (unreliable) */
		char	vres;

		/** 16-color palette (16 RGB triples between 0-255) 
		 *  UNUSED in Doom. */
		byte[]	palette=new byte[48];
	    
		/** reserved, must be zero */
	    byte		reserved;
	    
	    /** number of bit planes */
	    byte		color_planes;

	    /** video memory bytes per image row */
	    char	bytes_per_line;
	    
	    /** 16-color palette interpretation (unreliable) 0=color/b&w 1=grayscale */
	    char	palette_type;
	    
	    // Seems off-spec. However it's left all zeroed out.
	    byte[]		filler=new byte[58];

	    //unsigned char	data;
	    byte[] data;
	    
		@Override
		public void write(DataOutputStream f) throws IOException {
			// char -> byte Bytes.

			f.writeByte(manufacturer);
			f.writeByte(version);
			f.writeByte(encoding);
			f.writeByte(bits_per_pixel);
			
			// unsigned short -> char
			f.writeChar(Swap.SHORT(xmin));
			f.writeChar(Swap.SHORT(ymin));
			f.writeChar(Swap.SHORT(xmax));
			f.writeChar(Swap.SHORT(ymax));
		    
			f.writeChar(Swap.SHORT(hres));
			f.writeChar(Swap.SHORT(vres));
			f.write(palette);
		    
		    f.writeByte(reserved);
		    f.writeByte(color_planes);
		 // unsigned short -> char
		    f.writeChar(Swap.SHORT(bytes_per_line));
		    f.writeChar(Swap.SHORT(palette_type));
		    
		    f.write(filler);
		    //unsigned char	data;		// unbounded
		    f.write(data);
		}
	} ;

package m;

/** Some utilities for switching between floating and signed 16.16 fixed-point at will.
 *  They use direct bit manipulation with little -if any- looping.
 *  
 *  The methods can probably be generalized but not a priority for now.
 *  They do not handle Infinities, NaNs and unnormalized numbers.
 *  
 * @author Maes
 *
 */

public class FixedFloat {

    // Various bit masks for IEEE-754 floating point 
    public static final int MANTISSA_32=0x007FFFFF;    
    public static final int EXP_32=0x7F800000;
    public static final int IMPLICIT_32=0x00800000;
    public static final int SIGN_32=0x80000000;
    public static final int NONSIGN_32=0x7FFFFFFF;
    public static final long SIGN_64=0x8000000000000000L;
    public static final long EXP_64=0x7FF0000000000000L;
    public static final long IMPLICIT_64=0x0010000000000000L;
    public static final long MANTISSA_64=0x000fffffffffffffL;
    
    public static float toFloat(int fixed){
        if (fixed==0) return (float)(0.0);
        // Remember sign.
        int sign=fixed&SIGN_32;
        if (fixed<0) fixed=-fixed;
        int exp=findShift(fixed);
        // First shift to left to "cancel" bits "above" the first.
        int mantissa=(fixed<<(exp+2))>>>9;
        int result=sign|(((14-exp)+127)<<23)|mantissa;
        /*if (fixed<0) System.out.println(Integer.toBinaryString(fixed) +"\n"+
                                        Integer.toBinaryString(-fixed) +"\n"+
                                        Integer.toBinaryString(result));*/
        return Float.intBitsToFloat(result);
    }
 
    private static int findShift(int fixed){
        // only non-sign bits.
        fixed&=NONSIGN_32;
        // We assume that the MSb after the sign is set.
        int shift=30;
        while((shift>=0)&&(fixed>>>shift)==0)
            // It's not, apparently
            shift--;

        // Positions 0-15 are fractional, anything above 15 is integer.
        // Return two's complement shift.
        return (30-shift);
        
    }
    
    public static double toDouble(int fixed){
        
        
        // Remember sign.
        
        long fx=fixed;
        fx<<=32;
        long sign=(long)fx&SIGN_64;
        
         if (fixed<0) {
             fixed=-fixed;
             fx=-fx;
         }
        long exp=findShift(fixed);
        // First shift to left to "swallow" sign and implicit 1.
        long bits=(fx<<(exp+2))>>>12;
        long result=sign|(((14-exp)+1023)<<52)|bits;
        return Double.longBitsToDouble(result);
    }
    
    public static int toFixed(float fl){
        // Get the raw bits.
        int flbits=Float.floatToRawIntBits(fl);
        // Remember sign.
        int sign=flbits&SIGN_32;
        // Join together: the implcit 1 and the mantissa bits.
        // We now have the "denormalized" value. 
        int denorm=IMPLICIT_32|(flbits&MANTISSA_32);
        // Get exponent...acceptable values are (-15 ~ 15), else wrap around (use only sign and lowest 4 bits).
        int exp=(((flbits&EXP_32)>>23)-127)&0x8000000F;
        /* Remember, leftmost "1" will be at position 23.
         * So for an exponent of 0, we must shift to position 16.
         * For positive exponents in general, we must shift -7 + exp.
         * and for one of 15, to position 30, plus the sign.
         * While there is space for all bits, we can't keep them all, 
         * as some (well, many)numbers can't be represented in fixed point.
         * 
         */
        int result;
        if ((exp-7)>=0)
            result=sign|(denorm<<(exp-7));
        else
            result=sign|(denorm>>>(7-exp));
        return result;
        }
    
    public static int toFixed(double fl){
        
        // Get the raw bits.
        long flbits=Double.doubleToRawLongBits(fl);
        // Remember sign.
        int sign=(int)((flbits&SIGN_64)>>32);
        // Join together: the implcit 1 and the mantissa bits.
        // We now have the "denormalized" value. 
        long denorm=IMPLICIT_64|(flbits&MANTISSA_64);
        //System.out.println("Denorm"+Integer.toBinaryString(denorm));
        // Get exponent...acceptable values are (-15 ~ 15), else wrap around (use only sign and lowest 4 bits).
        int exp=(int)(((flbits&EXP_64)>>52)-1023)&0x8000000F;
        /* Remember, leftmost "1" will be at position 53.
         * So for an exponent of 0, we must shift to position 16.
         * For positive exponents in general, we must shift -37 + exp.
         * and for one of 15, to position 30, plus the sign.
         * While there is space for all bits, we can't keep them all, 
         * as some (well, many)numbers can't be represented in fixed point.
         * 
         */
        int result;
        if ((exp-36)>=0)
            result=(int) (sign|(denorm<<(exp-36)));
        else
            result=(int) (sign|(denorm>>>(36-exp)));
        //int result=sign|(IMPLICIT_32|(mantissa<<(exp-127)))<<8;
        return result;
        }
    
}

package m;

import static g.Keys.*;
import static doom.englsh.*;


/** An anumeration with the most basic default Doom settings their default
 *  values, used if nothing else is available. They are applied first thing, 
 *  and then updated from the .cfg file. 
 *  
 */

public enum Settings {
    mouse_sensitivity("5"),
    sfx_volume("8"),
   music_volume("8"),
   show_messages("1"),
   alwaysrun("1"),
   key_right(KEY_RIGHTARROW),
   key_left(KEY_LEFTARROW),
   key_up('w'),
   key_down('s'),
   key_strafeleft('a'),
   key_straferight('d'),
   key_fire(KEY_CTRL),
   key_use(' '),
   key_strafe(KEY_ALT),
   key_speed(KEY_SHIFT),
   use_mouse(1),
   mouseb_fire(0),
   mouseb_strafe(1),
   mouseb_forward(2),
   use_joystick( 0),
   joyb_fire(0),
   joyb_strafe(1),
   joyb_use(3),
   joyb_speed(2),
   screenblocks(10),
   detaillevel(0),
   snd_channels(6),
   usegamma(0),
   mb_used(2),
   chatmacro0(HUSTR_CHATMACRO0 ),
   chatmacro1(HUSTR_CHATMACRO1 ),
   chatmacro2( HUSTR_CHATMACRO2 ),
   chatmacro3(HUSTR_CHATMACRO3 ),
   chatmacro4( HUSTR_CHATMACRO4 ),
   chatmacro5( HUSTR_CHATMACRO5 ),
   chatmacro6(HUSTR_CHATMACRO6 ),
   chatmacro7( HUSTR_CHATMACRO7 ),
   chatmacro8(HUSTR_CHATMACRO8 ),
   chatmacro9( HUSTR_CHATMACRO9 );

         private Settings(String defaultval){
            this.value=defaultval;
        }
         

         private Settings(int defaultval){
            this.value=Integer.toString(defaultval);
        }
    
    public String value;
    
    /** Normally this is default.cfg, might be .doomrc on lunix??? */
    
    public static String basedefault="default.cfg";      

}
package m;

import java.util.Random;

import data.mobjtype_t;
import doom.think_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: JavaRandom.java,v 1.3 2013/06/03 11:00:03 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// DESCRIPTION:
//	Random number LUT using java.util.Random
// Don't expect vanilla demo compatibility with THIS!
//
//-----------------------------------------------------------------------------

public class JavaRandom implements IRandom{

protected int	rndindex = 0;
protected int	prndindex = 0;

// Which one is deterministic?
public int P_Random ()
{
	rndindex++;
	return (0xFF&r.nextInt());
	
}

public int M_Random ()
{
	prndindex++;
	return (0xFF&m.nextInt());
}

public void ClearRandom ()
{
	rndindex=prndindex=0;
    r.setSeed(666);
}

public JavaRandom(){
	r=new Random(666);
	m=new Random(666);
    this.ClearRandom();
}

public int getIndex(){
	return rndindex;
}

private Random r;
private Random m;

@Override
public int P_Random(int caller) {    
    // DUMMY
    return P_Random();
}

@Override
public int P_Random(String message) {
    // DUMMY
    return P_Random();
}

@Override
public int P_Random(think_t caller, int sequence) {
    // DUMMY
    return P_Random();
}

@Override
public int P_Random(think_t caller, mobjtype_t type, int sequence) {
    // DUMMY
    return P_Random();
}

}


//$Log: JavaRandom.java,v $
//Revision 1.3  2013/06/03 11:00:03  velktron
//Implements interface without logging.
//
//Revision 1.2  2011/07/27 20:47:46  velktron
//Proper commenting, cleanup.
//
//Revision 1.1  2011/05/29 22:15:32  velktron
//Introduced IRandom interface.


package m;

public class menuitem_t {

	    public menuitem_t(int status, String name, MenuRoutine routine, char alphaKey) {
	    	this.status=status;
	    	this.name=name;
	    	this.routine= routine;
	    	this.alphaKey=alphaKey;
	}	

		public menuitem_t(int status, String name, MenuRoutine routine) {
		     this.status=status;
	            this.name=name;
	            this.routine= routine;
        }

        /** 0 = no cursor here, 1 = ok, 2 = arrows ok */
	    int	status;
	    
	    String	name;
	    
	    // choice = menu item #.
	    // if status = 2,
	    //   choice=0:leftarrow,1:rightarrow
	    // MAES: OK... to probably we need some sort of "MenuRoutine" class for this one.
	    // void	(*routine)(int choice);
	    MenuRoutine routine;
	    
	    /** hotkey in menu */
	    char	alphaKey;			
	} 
package m;

/** menu_t required a function pointer to a (routine)() that drew stuff.
 *  So any class implementing them will implement this interface, and
 *  we can have a single class type for all of them.
 * 
 * @author Maes
 *
 */
public interface DrawRoutine {
	
public void invoke();
}

package m;

import v.IVideoScaleAware;
import i.DoomStatusAware;
import doom.DoomStatus;
import doom.event_t;

// Emacs style mode select -*- C++ -*-
// -----------------------------------------------------------------------------
//
// $Id: IDoomMenu.java,v 1.5 2011/09/29 15:16:23 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// DESCRIPTION:
// Menu widget stuff, episode selection and such.
//    
// -----------------------------------------------------------------------------

/**
 * 
 */

public interface IDoomMenu extends IVideoScaleAware, DoomStatusAware{

    //
    // MENUS
    //

    /**
     * Called by main loop, saves config file and calls I_Quit when user exits.
     * Even when the menu is not displayed, this can resize the view and change
     * game parameters. Does all the real work of the menu interaction.
     */
    public boolean Responder(event_t ev);

    /**
     * Called by main loop, only used for menu (skull cursor) animation.
     */
    public void Ticker();

    /**
     * Called by main loop, draws the menus directly into the screen buffer.
     */
    public void Drawer();

    /**
     * Called by D_DoomMain, loads the config file.
     */
    public void Init();

    /**
     * Called by intro code to force menu up upon a keypress, does nothing if
     * menu is already up.
     */
    public void StartControlPanel();

    public boolean getShowMessages();

    public void setShowMessages(boolean val);
    
    public int getScreenBlocks();
    
    public void setScreenBlocks(int val);
    
    public int getDetailLevel();

	void ClearMenus();
}
    
package m;

/** General form for a classic, Doom-style menu with a bunch of
 *  items and a drawing routine (menu_t's don't have action callbacks
 *  proper, though).
 * 
 * @author Maes
 *
 */

public class menu_t {
	    public menu_t(int numitems, menu_t prev, menuitem_t[] items,
            DrawRoutine drawroutine, int x, int y, int lastOn) {
	        this.numitems=numitems;
	        this.prevMenu=prev;
	        this.menuitems=items;
	        this.routine=drawroutine;
	        this.x=x;
	        this.y=y;
	        this.lastOn=lastOn;
	        
    }
	    /** # of menu items */	    
        public int		numitems;
        
	    /**  previous menu */
	    public menu_t	prevMenu;

	    /** menu items */
	    public menuitem_t[]		menuitems;	
	    /** draw routine */
	    public DrawRoutine routine;
	    /**  x,y of menu */
	    public int		x,y;
	    /** last item user was on in menu */
	    public int		lastOn;
	} 

package m;

import data.mobjtype_t;
import doom.think_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: DoomRandom.java,v 1.4 2013/06/04 11:29:25 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// $Log: DoomRandom.java,v $
// Revision 1.4  2013/06/04 11:29:25  velktron
// Dummy implementations
//
// Revision 1.3  2013/06/03 10:53:29  velktron
// Implements the new IRandom.
//
// Revision 1.2.10.3  2013/01/09 19:38:26  velktron
// Printing arbitrary messages
//
// Revision 1.2.10.2  2012/11/20 15:59:20  velktron
// More tooling functions.
//
// Revision 1.2.10.1  2012/11/19 22:11:36  velktron
// Added demo sync tooling.
//
// Revision 1.2  2011/05/30 02:24:30  velktron
// *** empty log message ***
//
// Revision 1.1  2011/05/29 22:15:32  velktron
// Introduced IRandom interface.
//
// Revision 1.4  2010/09/22 16:40:02  velktron
// MASSIVE changes in the status passing model.
// DoomMain and DoomGame unified.
// Doomstat merged into DoomMain (now status and game functions are one).
//
// Most of DoomMain implemented. Possible to attempt a "classic type" start but will stop when reading sprites.
//
// Revision 1.3  2010/09/10 17:35:49  velktron
// DoomGame, Menu, renderers
//
// Revision 1.2  2010/07/06 16:32:38  velktron
// Threw some work in WI, now EndLevel. YEAH THERE'S GONNA BE A SEPARATE EndLevel OBJECT THAT'S HOW PIMP THE PROJECT IS!!!!11!!!
//
// Revision 1.1  2010/06/30 08:58:50  velktron
// Let's see if this stuff will finally commit....
//
//
// Most stuff is still  being worked on. For a good place to start and get an idea of what is being done, I suggest checking out the "testers" package.
//
// Revision 1.1  2010/06/29 11:07:34  velktron
// Release often, release early they say...
//
// Commiting ALL stuff done so far. A lot of stuff is still broken/incomplete, and there's still mixed C code in there. I suggest you load everything up in Eclpise and see what gives from there.
//
// A good place to start is the testers/ directory, where you  can get an idea of how a few of the implemented stuff works.
//
//
// DESCRIPTION:
//	Random number LUT.
//
//-----------------------------------------------------------------------------

public class DoomRandom implements IRandom{

//
// M_Random
// Returns a 0-255 number. Made into shorts for Java, because of their nature.
//
public static short rndtable[] = {
    0,   8, 109, 220, 222, 241, 149, 107,  75, 248, 254, 140,  16,  66 ,
    74,  21, 211,  47,  80, 242, 154,  27, 205, 128, 161,  89,  77,  36 ,
    95, 110,  85,  48, 212, 140, 211, 249,  22,  79, 200,  50,  28, 188 ,
    52, 140, 202, 120,  68, 145,  62,  70, 184, 190,  91, 197, 152, 224 ,
    149, 104,  25, 178, 252, 182, 202, 182, 141, 197,   4,  81, 181, 242 ,
    145,  42,  39, 227, 156, 198, 225, 193, 219,  93, 122, 175, 249,   0 ,
    175, 143,  70, 239,  46, 246, 163,  53, 163, 109, 168, 135,   2, 235 ,
    25,  92,  20, 145, 138,  77,  69, 166,  78, 176, 173, 212, 166, 113 ,
    94, 161,  41,  50, 239,  49, 111, 164,  70,  60,   2,  37, 171,  75 ,
    136, 156,  11,  56,  42, 146, 138, 229,  73, 146,  77,  61,  98, 196 ,
    135, 106,  63, 197, 195,  86,  96, 203, 113, 101, 170, 247, 181, 113 ,
    80, 250, 108,   7, 255, 237, 129, 226,  79, 107, 112, 166, 103, 241 ,
    24, 223, 239, 120, 198,  58,  60,  82, 128,   3, 184,  66, 143, 224 ,
    145, 224,  81, 206, 163,  45,  63,  90, 168, 114,  59,  33, 159,  95 ,
    28, 139, 123,  98, 125, 196,  15,  70, 194, 253,  54,  14, 109, 226 ,
    71,  17, 161,  93, 186,  87, 244, 138,  20,  52, 123, 251,  26,  36 ,
    17,  46,  52, 231, 232,  76,  31, 221,  84,  37, 216, 165, 212, 106 ,
    197, 242,  98,  43,  39, 175, 254, 145, 190,  84, 118, 222, 187, 136 ,
    120, 163, 236, 249
};

protected int	rndindex = 0;
protected int	prndindex = 0;

// Which one is deterministic?
public int P_Random ()
{
    prndindex = (prndindex+1)&0xff;
    return rndtable[prndindex];
}

/** [Maes] I'd rather dispatch the call here, than making IRandom aware of
 * DoomStatus. Replace RND.P_Random calls with DM.P_Random(callerid) etc.
 * 
 * Fixme: this could be made into a proper enum
 * 
 * @param caller
 */

public int P_Random(int caller) {
	int value = P_Random();
	SLY.sync("PR #%d [%d]=%d\n",caller,prndindex,value);
	return value;
}

public int P_Random(String message) {
	int value = P_Random();
	SLY.sync("PR %s [%d]=%d\n", message,
			prndindex, value);
	return value;
}

public int P_Random(think_t caller, int sequence) {
	int value = P_Random();
	/*
	SLY.sync("PR #%d %s_%d [%d]=%d\n", caller.ordinal(),caller,sequence,
			prndindex, value);*/
	return value;
}

public int P_Random(think_t caller, mobjtype_t type,int sequence) {
    int value = P_Random();
    /*
    SLY.sync("PR #%d %s_%d %s [%d]=%d\n", caller.ordinal(),caller,sequence,
        type, prndindex, value);*/
    return value;
}

public int M_Random ()
{
    rndindex = (rndindex+1)&0xff;
    return rndtable[rndindex];
}

public void ClearRandom ()
{
    rndindex = prndindex = 0;
}

public DoomRandom(){
	SLY=null;
}

public int getIndex(){
	return prndindex;
}

public DoomRandom(ISyncLogger SLY){
	this.SLY=SLY;
}

private final ISyncLogger SLY;


}





package m;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: Swap.java,v 1.2 2011/07/27 20:48:20 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//	Endianess handling, swapping 16bit and 32bit.
//  It's role is much less important than in C-based ports (because of stream
//  built-in endianness settings), but they are still used occasionally.
//
//-----------------------------------------------------------------------------

public final class Swap{


// Swap 16bit, that is, MSB and LSB byte.
public final static short SHORT(short x)
{
    // No masking with 0xFF should be necessary. 
    // MAES: necessary with java due to sign trailing.
    
    return (short) ((short) ((x>>>8)&0xFF) | (x<<8));
}

//Swap 16bit, that is, MSB and LSB byte.
public final static short SHORT(char x)
{
    // No masking with 0xFF should be necessary. 
    // MAES: necessary with java due to sign trailing.
    
    return (short) ((short) ((x>>>8)&0xFF) | (x<<8));
}

//Swap 16bit, that is, MSB and LSB byte.
public final static char USHORT(char x)
{
    // No masking with 0xFF should be necessary. 
    // MAES: necessary with java due to sign trailing.
    
    return (char) ((char) ((x>>>8)&0xFF) | (x<<8));
}


// Swapping 32bit.
// Maes: the "long" here is really 32-bit.
public final static int LONG( int x)
{
    return
	(x>>>24)
	| ((x>>>8) & 0xff00)
	| ((x<<8) & 0xff0000)
	| (x<<24);
}
}

//$Log: Swap.java,v $
//Revision 1.2  2011/07/27 20:48:20  velktron
//Proper commenting, cleanup.
//
//Revision 1.1  2010/06/30 08:58:50  velktron
//Let's see if this stuff will finally commit....

package m;

/** menuitem_t required a function pointer to a (routine)(int choice)
 *  So any class implementing them will implement this interface, and
 *  we can have a single class type for all of them.
 * 
 * @author Velktron
 *
 */
public interface MenuRoutine {
	
	
public void invoke(int choice);
}

package m;

import utils.C2JUtils;

/** A "Doom setting". Based on current experience, it could 
 *  represent an integer value, a string, or a boolean value.
 * 
 *  Therefore, every setting can be interpreted as any of the above, 
 *  based on some rules. Strings that can be interpreted as parseable 
 *  numbers are obvious, and numbers can also be interpreted as strings.
 *  Strings that can't be interpreted as numbers will return "0" as a default
 *  value.
 *  
 *  A numerical value of 1 means "true", any other value is "false".
 *  A string representing the (case insensitive) value "true" will 
 *  be interpreted as a true boolean, false otherwise.
 * 
 * @author velktron
 *
 * 
 */

public class DoomSetting implements Comparable<DoomSetting> {
    
    public static final int BOOLEAN=1;
    public static final int CHAR=2;
    public static final int DOUBLE=4;
    public static final int INTEGER=8;
    public static final int STRING=16;
    
    private String name;
    
    private int typeflag;
    
    // Every setting can be readily interpreted as any of these
    private int int_val;
    private long long_val;
    private char char_val;
    private double double_val;
    private boolean boolean_val;
    private String string_val;
    
    /** Should be saved to file */
    private boolean persist;
    
    public DoomSetting(String name,  String value, boolean persist){
        this.name=name;
        this.typeflag=STRING;
        this.updateValue(value);
        this.persist=persist;
    }
    
    public String getName(){
        return name;
    }
    
    public int getInteger(){
        return int_val;
    }
    
    public long getLong(){
        return long_val;
    }
    
    public char getChar(){
        return (char)int_val;
    }
    
    public String getString(){
        return string_val;
    }
    
    public double getDouble(){
        return double_val;
    }

    public boolean getBoolean(){
        return boolean_val;
    }
    
    public boolean getPersist(){
        return persist;
    }

    public int getTypeFlag(){
        return typeflag;
    }

    
    /** All the gory disambiguation work should go here.
     * 
     * @param value
     */
    
    public void updateValue(String value){

        boolean quoted=false;
        
        if (value.length()>2)        
        if (quoted=C2JUtils.isQuoted(value,'"' ))
            value=C2JUtils.unquote(value, '"');
        else
            if (quoted=C2JUtils.isQuoted(value,'\'' ))
                value=C2JUtils.unquote(value, '\'');

        // String value always available
        this.string_val=value;
       
        // If quoted and sensibly ranged, it gets priority as a "character"        
        
        if (quoted && value.length()==1 && value.charAt(0)>=0 && value.charAt(0)<255){
            char_val=Character.toLowerCase(value.charAt(0));
            int_val=char_val;
            long_val=char_val;
            double_val=char_val;
            typeflag|=CHAR;
            return;
        }
        
        // Not a character, try all other stuff
        
            try {
            this.int_val=Integer.parseInt(value);
            typeflag|=INTEGER;
            } catch (NumberFormatException e) {
                // No nookie
                this.int_val=-1;
            }
            
            try {
                this.long_val=Long.parseLong(value);
                } catch (NumberFormatException e) {
                    try {
                    // Try decoding it as hex, octal, whatever.
                    this.long_val=Long.decode(value);
                    typeflag|=INTEGER;
                    } catch (NumberFormatException h){
                        // If even THAT fails, then no nookie.
                    this.long_val=-1;
                    }
                }
            
            try {
            this.double_val=Double.parseDouble(value);
            typeflag|=DOUBLE;
            } catch (NumberFormatException e) {
                // No nookie
                this.double_val=Double.NaN;
            }            
            
            // Use long value to "trump" smaller ones
            int_val=(int)long_val;
            char_val=(char)int_val;
            
            // Boolean has a few more options;
            // Only mark something explicitly as boolean if the string reads 
            // actually "true" or "false". Numbers such as 0 and 1 might still get
            // interpreted as booleans, but that shouldn't trump the entire number,
            // otherwise everything and the cat is boolean
            
            this.boolean_val=(int_val==1);
            
            if (Boolean.parseBoolean(value) || 
                    (value.compareToIgnoreCase("false")==0)){
                this.boolean_val=(int_val==1) || Boolean.parseBoolean(value);
                this.typeflag|=BOOLEAN;
            }
        }
        
        /** Answer definitively if a setting cannot ABSOLUTELY be 
         *  parsed into a number using simple Integer rules. 
         *  This excludes some special names like "+Inf" and "NaN".
         * 
         * @return
         */
    
        public boolean isIntegerNumeric(){
            
            try {
                this.long_val=Long.parseLong(string_val);
                } catch (NumberFormatException e) {
                    try {
                    // Try decoding it as hex, octal, whatever.
                    Long.decode(string_val);

                    } catch (NumberFormatException h){
                        // If even THAT fails, then no nookie.
                    return false;
                    }
                }
                
                // Everything OK, I presume...
                return true;
        }

        /** Settings are "comparable" to each other by name, so we can save
         *  nicely sorted setting files ;-) 
         *  
         * @param o
         * @return
         */
        
        @Override
        public int compareTo(DoomSetting o) {
            return this.name.compareToIgnoreCase(o.getName());
        }
        
        public String toString(){
            return string_val;
        }

        /** A special setting that returns false, 0 and an empty string, if required.
         * Simplifies handling of nulls A LOT. So code that relies on specific settings
         * should be organized to work only on clear positivies (e.g. use a "fullscreen" setting
         * that must exist and be equal to 1 or true, instead of assuming that a zero/false
         * value enables it. */
        
        public static DoomSetting NULL_SETTING=new DoomSetting("NULL","",false);
        
        static {
            // It's EVERYTHING
            NULL_SETTING.typeflag=0x1F;
            NULL_SETTING.string_val="";
            NULL_SETTING.char_val=0;
            NULL_SETTING.double_val=0;
            NULL_SETTING.boolean_val=false;
            NULL_SETTING.int_val=0;
            NULL_SETTING.long_val=0;            
        }
        
        
    }

package m;

import defines.*;
import static data.Defines.HU_FONTSIZE;
import static data.Defines.HU_FONTSTART;
import static g.Keys.*;
import static data.Defines.PU_CACHE;
import static data.Defines.SAVESTRINGSIZE;
import static data.dstrings.NUM_QUITMESSAGES;
import static data.dstrings.SAVEGAMENAME;
import static data.dstrings.endmsg;
import static doom.englsh.DOSY;
import static doom.englsh.EMPTYSTRING;
import static doom.englsh.ENDGAME;
import static doom.englsh.LOADNET;
import static doom.englsh.MSGOFF;
import static doom.englsh.MSGON;
import static doom.englsh.NETEND;
import static doom.englsh.NEWGAME;
import static doom.englsh.NIGHTMARE;
import static doom.englsh.QLOADNET;
import static doom.englsh.QLPROMPT;
import static doom.englsh.QSAVESPOT;
import static doom.englsh.QSPROMPT;
import static doom.englsh.SAVEDEAD;
import static doom.englsh.SWSTRING;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

import rr.patch_t;
import utils.C2JUtils;
import v.IVideoScale;
import w.DoomIO;
import data.sounds.sfxenum_t;
import doom.DoomStatus;
import doom.englsh;
import doom.event_t;
import doom.evtype_t;

public class Menu extends AbstractDoomMenu {

	////////////////// CONSTRUCTOR ////////////////
    
    public Menu(DoomStatus DS){
    	this.updateStatus(DS);
    }

    /** The fonts  ... must "peg" them to those from HU */
    patch_t[] hu_font = new patch_t[HU_FONTSIZE];

    /** WTF?! */

    boolean message_dontfuckwithme;
    
    // int mouseSensitivity; // has default

    /** Show messages has default, 0 = off, 1 = on */

    private boolean showMessages=false;

    /**
     * showMessages can be read outside of Menu, but not modified. Menu has the
     * actual C definition (not declaration)
     */
    
    @Override
    public boolean getShowMessages() {
        return showMessages;
    }

    @Override
    public void setShowMessages(boolean val) {
        this.showMessages=val;
    }
    
    /** Blocky mode, has default, 0 = high, 1 = normal */
    int detailLevel;

    int screenblocks=10; // has default

    /** temp for screenblocks (0-9) */
    int screenSize;

    /** -1 = no quicksave slot picked! */
    int quickSaveSlot;

    /** 1 = message to be printed */
    boolean messageToPrint;

    /** ...and here is the message string! */
    String messageString;

    /** message x & y */
    int messx, messy;

    boolean messageLastMenuActive;

    /** timed message = no input from user */
    boolean messageNeedsInput;

    /** Probably I need some MessageRoutine interface at this point? */
    public MenuRoutine messageRoutine;


    /** we are going to be entering a savegame string */
    boolean saveStringEnter;

    int saveSlot; // which slot to save in

    int saveCharIndex; // which char we're editing

    /** old save description before edit */
    char[] saveOldString = new char[SAVESTRINGSIZE];

    boolean inhelpscreens;

    //int menuactive;

    protected static final int SKULLXOFF = -32;

    protected static final int LINEHEIGHT = 16;

    char[][] savegamestrings = new char[10][SAVESTRINGSIZE];

    String endstring = new String();

    //
    // MENU TYPEDEFS
    //

    /** menu item skull is on */
    short itemOn;

    /** skull animation counter */
    short skullAnimCounter;

    /** which skull to draw */
    short whichSkull;

    /**
     * graphic name of skulls warning: initializer-string for array of chars is
     * too long
     */
    private static String[] skullName = { "M_SKULL1", "M_SKULL2" };

    /** current menudef */
    // MAES: pointer? array?
    menu_t currentMenu;

    //
    // DOOM MENU
    //

    // MAES: was an enum called "main_e" used purely as numerals. No need for
    // strong typing.

    /**
     * MenuRoutine class definitions, replacing "function pointers".
     */
    MenuRoutine ChangeDetail, ChangeMessages, ChangeSensitivity, ChooseSkill,
            EndGame, EndGameResponse, Episode, FinishReadThis, LoadGame,
            LoadSelect, MusicVol, NewGame, Options, VerifyNightmare,
            SaveSelect, SfxVol, SizeDisplay, SaveGame, Sound, QuitDOOM,
            QuitResponse, QuickLoadResponse, QuickSaveResponse, ReadThis, ReadThis2;

    /** DrawRoutine class definitions, replacing "function pointers". */

    DrawRoutine DrawEpisode, DrawLoad,DrawMainMenu,DrawNewGame,DrawOptions,
    			DrawReadThis1, DrawReadThis2, DrawSave, DrawSound;

    /** Initialize menu routines first */
    
    private void initMenuRoutines() {




        ChangeMessages = new M_ChangeMessages();
        ChangeDetail = new M_ChangeDetail();
        ChangeSensitivity = new M_ChangeSensitivity();
        ChooseSkill = new M_ChooseSkill();
        EndGame = new M_EndGame();
        EndGameResponse = new M_EndGameResponse();
        Episode = new M_Episode();
        FinishReadThis=new M_FinishReadThis();
        LoadGame=new M_LoadGame();
        LoadSelect=new M_LoadSelect();
        MusicVol=new M_MusicVol();
        NewGame = new M_NewGame();
        Options = new M_Options();


        QuitDOOM = new M_QuitDOOM();
        QuickLoadResponse = new M_QuickLoadResponse();
        QuickSaveResponse= new M_QuickSaveResponse();
        QuitResponse = new M_QuitResponse();
        
        ReadThis = new M_ReadThis();
        ReadThis2 = new M_ReadThis2();
         
        SaveGame=new M_SaveGame();
        SaveSelect= new M_SaveSelect();
        SfxVol=new M_SfxVol();
        SizeDisplay = new M_SizeDisplay();
        Sound = new M_Sound();
        VerifyNightmare = new M_VerifyNightmare();
    }

    /** Then drawroutines */
    
    private void initDrawRoutines() {
        DrawEpisode = new M_DrawEpisode();
        DrawNewGame = new M_DrawNewGame();
        DrawReadThis1 = new M_DrawReadThis1();
        DrawReadThis2 = new M_DrawReadThis2();
        DrawOptions = new M_DrawOptions();
        DrawLoad = new M_DrawLoad();
        DrawSave = new M_DrawSave();
        DrawSound=new M_DrawSound();
        DrawMainMenu = new M_DrawMainMenu();
    }

    /** Menuitem definitions. A "menu" can consist of multiple menuitems */
    menuitem_t[] MainMenu,EpisodeMenu,NewGameMenu, OptionsMenu,ReadMenu1,ReadMenu2,SoundMenu,LoadMenu,SaveMenu;
    
    /** Actual menus. Each can point to an array of menuitems */
    menu_t MainDef, EpiDef,NewDef,OptionsDef,ReadDef1, ReadDef2,SoundDef,LoadDef,SaveDef;
    
    /** First initialize those */
    
    private void initMenuItems(){
    
    MainMenu = new menuitem_t[]
        { new menuitem_t( 1, "M_NGAME", NewGame, 'n'),
                new menuitem_t(1, "M_OPTION", Options, 'o'),
                new menuitem_t(1, "M_LOADG", LoadGame, 'l'),
                new menuitem_t(1, "M_SAVEG", SaveGame, 's'),
                // Another hickup with Special edition.
                new menuitem_t(1, "M_RDTHIS", ReadThis, 'r'),
                new menuitem_t(1, "M_QUITG", QuitDOOM, 'q') };

    MainDef =
        new menu_t(main_end, null, MainMenu, DrawMainMenu, 97, 64, 0);

    //
    // EPISODE SELECT
    //

    EpisodeMenu = new menuitem_t[]
        { new menuitem_t(1, "M_EPI1", Episode, 'k'),
                new menuitem_t(1, "M_EPI2", Episode, 't'),
                new menuitem_t(1, "M_EPI3", Episode, 'i'),
                new menuitem_t(1, "M_EPI4", Episode, 't') };

    EpiDef = new menu_t(ep_end, // # of menu items
            MainDef, // previous menu
            EpisodeMenu, // menuitem_t ->
            DrawEpisode, // drawing routine ->
            48, 63, // x,y
            ep1 // lastOn
        );

    //
    // NEW GAME
    //


     NewGameMenu  = new menuitem_t[]
        { new menuitem_t(1, "M_JKILL", ChooseSkill, 'i'),
                new menuitem_t(1, "M_ROUGH", ChooseSkill, 'h'),
                new menuitem_t(1, "M_HURT", ChooseSkill, 'h'),
                new menuitem_t(1, "M_ULTRA", ChooseSkill, 'u'),
                new menuitem_t(1, "M_NMARE", ChooseSkill, 'n') };

     NewDef = new menu_t(newg_end, // # of menu items
            EpiDef, // previous menu
            NewGameMenu, // menuitem_t ->
            DrawNewGame, // drawing routine ->
            48, 63, // x,y
            hurtme // lastOn
        );

    //
    // OPTIONS MENU
    //

    OptionsMenu = new  menuitem_t[]
        { new menuitem_t(1, "M_ENDGAM", EndGame, 'e'),
                new menuitem_t(1, "M_MESSG", ChangeMessages, 'm'),
                new menuitem_t(1, "M_DETAIL", ChangeDetail, 'g'),
                new menuitem_t(2, "M_SCRNSZ", SizeDisplay, 's'),
                new menuitem_t(-1, "", null),
                new menuitem_t(2, "M_MSENS", ChangeSensitivity, 'm'),
                new menuitem_t(-1, "", null),
                new menuitem_t(1, "M_SVOL", Sound, 's') };

    OptionsDef =
        new menu_t(opt_end, this.MainDef, OptionsMenu, DrawOptions, 60, 37, 0);

    // Read This! MENU 1 

    ReadMenu1 = new menuitem_t[] { new menuitem_t(1, "", ReadThis2, (char) 0) };

    ReadDef1 =
        new menu_t(read1_end, MainDef, ReadMenu1, DrawReadThis1, 280, 185, 0);

    // Read This! MENU 2

    ReadMenu2 = new menuitem_t[] 
        { new menuitem_t(1, "", FinishReadThis, (char) 0) };

    ReadDef2 =
        new menu_t(read2_end, ReadDef1, ReadMenu2, DrawReadThis2, 330, 175, 0);

    //
    // SOUND VOLUME MENU
    //



    SoundMenu = new menuitem_t[]
        { new menuitem_t(2, "M_SFXVOL", SfxVol, 's'),
                new menuitem_t(-1, "", null),
                new menuitem_t(2, "M_MUSVOL", MusicVol, 'm'),
                new menuitem_t(-1, "", null) };

    SoundDef =
        new menu_t(sound_end, OptionsDef, SoundMenu, DrawSound, 80, 64, 0);

    //
    // LOAD GAME MENU
    //

    LoadMenu =new menuitem_t[]
        { new menuitem_t(1, "", LoadSelect, '1'),
                new menuitem_t(1, "", LoadSelect, '2'),
                new menuitem_t(1, "", LoadSelect, '3'),
                new menuitem_t(1, "", LoadSelect, '4'),
                new menuitem_t(1, "", LoadSelect, '5'),
                new menuitem_t(1, "", LoadSelect, '6') };

    LoadDef =
        new menu_t(load_end, MainDef, LoadMenu, DrawLoad, 80, 54, 0);

    //
    // SAVE GAME MENU
    //
    SaveMenu = new menuitem_t[]
        { new menuitem_t(1, "", SaveSelect, '1'),
                new menuitem_t(1, "", SaveSelect, '2'),
                new menuitem_t(1, "", SaveSelect, '3'),
                new menuitem_t(1, "", SaveSelect, '4'),
                new menuitem_t(1, "", SaveSelect, '5'),
                new menuitem_t(1, "", SaveSelect, '6') };

    SaveDef =
        new menu_t(load_end, MainDef, SaveMenu, DrawSave, 80, 54, 0);
    }
    
    /**
     * M_ReadSaveStrings
     * read the strings from the savegame files
     */
    
    public void ReadSaveStrings() {
        DataInputStream handle;
        int count;
        int i;
        String name;

        for (i = 0; i < load_end; i++) {
            if (DM.CM.CheckParm("-cdrom") != 0)
                name = "c:\\doomdata\\" + SAVEGAMENAME + (i) + ".dsg";
            else
                name = SAVEGAMENAME + (i) + ".dsg";

            try {
                handle = new DataInputStream(new BufferedInputStream(new FileInputStream(name)));
                savegamestrings[i] =
                    DoomIO.readString(handle,SAVESTRINGSIZE).toCharArray();
                handle.close();
                LoadMenu[i].status = 1;
            } catch (IOException e) {
                savegamestrings[i][0] = 0x00;
                LoadMenu[i].status = 0;
                continue;
            }

        }
    }

    /**
     * Draw border for the savegame description. This is special in that it's
     * not "invokable" like the other drawroutines, but standalone.
     */
    private void DrawSaveLoadBorder(int x, int y) {
        int i;

        V.DrawScaledPatch(x - 8, y + 7, 0, vs,W.CachePatchName("M_LSLEFT"));

        for (i = 0; i < 24; i++) {
            V.DrawScaledPatch(x, y + 7, 0, vs,W.CachePatchName("M_LSCNTR"));
            x += 8;
        }

        V.DrawScaledPatch(x, y + 7, 0, vs,W.CachePatchName("M_LSRGHT"));
    }

    /** Draws slider rail of a specified width (each notch is 8 base units wide)
     *  and with a slider selector at position thermDot.
     * 
     * @param x
     * @param y
     * @param thermWidth
     * @param thermDot
     */
    
    public void DrawThermo(int x, int y, int thermWidth, int thermDot) {
        int xx;
        int i;

        xx = x;
        V.DrawScaledPatch(xx, y, 0, vs,W.CachePatchName("M_THERML"));
        xx += 8;
        for (i = 0; i < thermWidth; i++) {
            V.DrawScaledPatch(xx, y, 0, vs,W.CachePatchName("M_THERMM"));
            xx += 8;
        }
        V.DrawScaledPatch(xx, y, 0,vs, W.CachePatchName("M_THERMR"));

        V.DrawScaledPatch((x + 8) + thermDot * 8, y, 0,vs, W
                .CachePatchName("M_THERMO"));
    }

    public void DrawEmptyCell(menu_t menu, int item) {
        V.DrawScaledPatch(menu.x - 10, menu.y + item * LINEHEIGHT - 1, 0,vs,
            (patch_t) W.CacheLumpName("M_CELL1", PU_CACHE, patch_t.class));
    }

    public void DrawSelCell(menu_t menu, int item) {
        V.DrawScaledPatch(menu.x - 10, menu.y + item * LINEHEIGHT - 1, 0,vs,
            (patch_t) W.CacheLumpName("M_CELL2", PU_CACHE, patch_t.class));
    }

    //
    // M_SaveGame & Cie.
    //
    public class M_DrawSave implements DrawRoutine {
    	@Override
    	public void invoke(){
        int i;
        V.DrawScaledPatch(72, 28, 0, vs,W.CachePatchName("M_SAVEG"));
        for (i = 0; i < load_end; i++) {
            DrawSaveLoadBorder(LoadDef.x, LoadDef.y + LINEHEIGHT * i);
            WriteText(LoadDef.x, LoadDef.y + LINEHEIGHT * i, savegamestrings[i]);
        }

        if (saveStringEnter) {
            i = StringWidth(savegamestrings[saveSlot]);
            WriteText(LoadDef.x + i, LoadDef.y + LINEHEIGHT * saveSlot, "_");
        }
    	}
    }

    /**
     * M_Responder calls this when user is finished
     * 
     * @param slot
     */

    public void DoSave(int slot) {
        DG.SaveGame(slot, new String(savegamestrings[slot]));
        ClearMenus();

        // PICK QUICKSAVE SLOT YET?
        if (quickSaveSlot == -2)
            quickSaveSlot = slot;
    }

    /**
     * User wants to save. Start string input for M_Responder
     */

    class M_SaveSelect
            implements MenuRoutine {
        @Override
        public void invoke(int choice) {
            // we are going to be intercepting all chars
        	//System.out.println("ACCEPTING typing input");
            saveStringEnter = true;

            saveSlot = choice;
            C2JUtils.strcpy(saveOldString, savegamestrings[choice]);
            if (C2JUtils.strcmp(savegamestrings[choice], EMPTYSTRING))
                savegamestrings[choice][0] = 0;
            saveCharIndex = C2JUtils.strlen(savegamestrings[choice]);
        }
    }

    /**
     * Selected from DOOM menu
     */
    class M_SaveGame
            implements MenuRoutine {
        @Override
        public void invoke(int choice) {
            if (!DM.usergame) {
                StartMessage(SAVEDEAD, null, false);
                return;
            }

            if (DM.gamestate != gamestate_t.GS_LEVEL)
                return;

            SetupNextMenu(SaveDef);
            ReadSaveStrings();
        }
    }

    //
    // M_QuickSave
    //
    private String tempstring;

    class M_QuickSaveResponse
            implements MenuRoutine {
        @Override
        public void invoke(int ch) {
            if (ch == 'y') {
                DoSave(quickSaveSlot);
                S.StartSound(null, sfxenum_t.sfx_swtchx);
            }
        }
    }

    private void QuickSave() {
        if (!DM.usergame) {
            S.StartSound(null, sfxenum_t.sfx_oof);
            return;
        }

        if (DM.gamestate != gamestate_t.GS_LEVEL)
            return;

        if (quickSaveSlot < 0) {
            StartControlPanel();
            ReadSaveStrings();
            SetupNextMenu(SaveDef);
            quickSaveSlot = -2; // means to pick a slot now
            return;
        }
        tempstring = String.format(QSPROMPT,C2JUtils.nullTerminatedString(savegamestrings[quickSaveSlot]));
        StartMessage(tempstring,this.QuickSaveResponse,true);
    }

    //
    // M_QuickLoad
    //
    class M_QuickLoadResponse
            implements MenuRoutine {
        @Override
        public void invoke(int ch) {
            if (ch == 'y') {
                LoadSelect.invoke(quickSaveSlot);
                S.StartSound(null, sfxenum_t.sfx_swtchx);
            }
        }
    }

    class M_QuitResponse
            implements MenuRoutine {
        @Override
        public void invoke(int ch) {
            if (ch != 'y')
                return;
            if (!DM.netgame) {
                if (DM.isCommercial())
                    S.StartSound(null, quitsounds2[(DM.gametic >> 2) & 7]);
                else
                    S.StartSound(null, quitsounds[(DM.gametic >> 2) & 7]);
                // TI.WaitVBL(105);
            }
            I.Quit();
        }
    }

    public void QuickLoad() {
        if (DM.netgame) {
            StartMessage(QLOADNET, null, false);
            return;
        }

        if (quickSaveSlot < 0) {
            StartMessage(QSAVESPOT, null, false);
            return;
        }
        tempstring = String.format(QLPROMPT, C2JUtils.nullTerminatedString(savegamestrings[quickSaveSlot]));
        StartMessage(tempstring, QuickLoadResponse, true);
    }

    class M_Sound
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {

            SetupNextMenu(SoundDef);
        }
    }

    class M_SfxVol
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            switch (choice) {
            case 0:
                if (DM.snd_SfxVolume != 0)
                    DM.snd_SfxVolume--;
                break;
            case 1:
                if (DM.snd_SfxVolume < 15)
                    DM.snd_SfxVolume++;
                break;
            }

           S.SetSfxVolume(DM.snd_SfxVolume *8);
        }
    }

    class M_MusicVol
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            switch (choice) {
            case 0:
                if (DM.snd_MusicVolume != 0)
                    DM.snd_MusicVolume--;
                break;
            case 1:
                if (DM.snd_MusicVolume < 15)
                    DM.snd_MusicVolume++;
                break;
            }

            S.SetMusicVolume(DM.snd_MusicVolume*8);
        }
    }

    //
    // M_Episode
    //
    private int epi;

    class M_VerifyNightmare
            implements MenuRoutine {

        @Override
        public void invoke(int ch) {
            if (ch != 'y')
                return;

            DG.DeferedInitNew(skill_t.sk_nightmare, epi + 1, 1);
            ClearMenus();
        }
    }

    /**
     * M_ReadThis
     */

    class M_ReadThis
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            choice = 0;
            SetupNextMenu(ReadDef1);
        }
    }

    class M_ReadThis2
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            choice = 0;
            SetupNextMenu(ReadDef2);
        }
    }

    class M_FinishReadThis
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            choice = 0;
            SetupNextMenu(MainDef);
        }
    }

    //
    // M_QuitDOOM
    //

    class M_QuitDOOM
            implements MenuRoutine {
        @Override
        public void invoke(int choice) {
            // We pick index 0 which is language sensitive,
            // or one at random, between 1 and maximum number.
            if (DM.language != Language_t.english)
                endstring = endmsg[0] + "\n\n" + DOSY;
            else
                endstring =
                    endmsg[(DM.gametic % (NUM_QUITMESSAGES - 2)) + 1] + "\n\n"
                            + DOSY;
            StartMessage(endstring, QuitResponse, true);
        }
    }

    class M_QuitGame
            implements MenuRoutine {

        @Override
        public void invoke(int ch) {
            if (ch != 'y')
                return;
            if (!DM.netgame) {
                if (DM.isCommercial())
                S.StartSound(null,quitsounds2[(DM.gametic>>2)&7]);
                else
                S.StartSound(null,quitsounds[(DM.gametic>>2)&7]);
                I.WaitVBL(105);
            }
           I.Quit ();
        }
    }

    class M_SizeDisplay
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            switch (choice) {
            case 0:
                if (screenSize > 0) {
                    screenblocks--;
                    screenSize--;
                }
                break;
            case 1:
                if (screenSize < 8) {
                    screenblocks++;
                    screenSize++;
                }
                break;
            }

            R.SetViewSize (screenblocks, detailLevel);
        }

    }

    class M_Options
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            SetupNextMenu(OptionsDef);
        }

    }

    class M_NewGame
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            if (DM.netgame && !DM.demoplayback) {
                StartMessage(NEWGAME, null, false);
                return;
            }

            if (DM.isCommercial())
                SetupNextMenu(NewDef);
            else
                SetupNextMenu(EpiDef);
        }

    }

    public void StartMessage(String string, MenuRoutine routine, boolean input) {
        messageLastMenuActive = DM.menuactive;
        messageToPrint = true;
        messageString = new String(string);
        messageRoutine = routine;
        messageNeedsInput = input;
        DM.menuactive = true; // "true"
        return;
    }

    public void StopMessage() {
        DM.menuactive = messageLastMenuActive;
        messageToPrint = false;
    }

    /**
     * Find string width from hu_font chars
     */
    public int StringWidth(char[] string) {
        int i;
        int w = 0;
        int c;

        for (i = 0; i < C2JUtils.strlen(string); i++) {
            c = Character.toUpperCase(string[i]) - HU_FONTSTART;
            if (c < 0 || c >= HU_FONTSIZE)
                w += 4;
            else
                w += hu_font[c].width;
        }

        return w;
    }

    /**
     * Find string height from hu_font chars.
     * 
     * Actually it just counts occurences of 'n' and adds height to height.
     */
    private int StringHeight(char[] string) {
        int i;
        int h;
        int height = hu_font[0].height;

        h = height;
        for (i = 0; i < string.length; i++)
            if (string[i] == '\n')
                h += height;

        return h;
    }

    /**
     * Find string height from hu_font chars
     */
    private int StringHeight(String string) {
        return this.StringHeight(string.toCharArray());
    }

    /**
     * Write a string using the hu_font
     */

    private void WriteText(int x, int y, char[] string) {
        int w;
        char[] ch;
        int c;
        int cx;
        int cy;

        ch = string;
        int chptr = 0;
        cx = x;
        cy = y;

        while (chptr<ch.length) {
            c = ch[chptr];
            chptr++;
            if (c == 0)
                break;
            if (c == '\n') {
                cx = x;
                cy += 12;
                continue;
            }
            
            c = Character.toUpperCase(c) - HU_FONTSTART;
            if (c < 0 || c >= HU_FONTSIZE) {
                cx += 4;
                continue;
            }

            w = hu_font[c].width;
            if (cx + w > SCREENWIDTH)
                break;
            
            V.DrawScaledPatch(cx, cy, 0,vs, hu_font[c]);
            cx += w;
        }

    }

    private void WriteText(int x, int y, String string) {
        if (string == null || string.length() == 0)
            return;

        int w;
        int cx;
        int cy;

        int chptr = 0;
        char c;

        cx = x;
        cy = y;

        while (chptr<string.length()) {
            c = string.charAt(chptr++);
            if (c == 0)
                break;
            if (c == '\n') {
                cx = x;
                cy += 12;
                continue;
            }

            c = (char) (Character.toUpperCase(c) - HU_FONTSTART);
            if (c < 0 || c >= HU_FONTSIZE) {
                cx += 4;
                continue;
            }

            w = hu_font[c].width;
            if (cx + w > SCREENWIDTH)
                break;
            V.DrawScaledPatch(cx, cy, 0,vs, hu_font[c]);
            cx += w;
        }

    }

    // These belong to the responder.
    
    private int joywait = 0;

    private int mousewait = 0;

    private int mousey = 0;

    private int lasty = 0;

    private int mousex = 0;

    private int lastx = 0;

    public boolean Responder(event_t ev) {

        char ch;
        int i;
        ch = 0xFFFF;

        //System.out.println("Processing keyevent:" +(ev.type==evtype_t.ev_keydown || ev.type==evtype_t.ev_keyup)+ " value = "+(char)ev.data1);
        
        // Joystick input
        
        if (ev.type == evtype_t.ev_joystick && joywait < TICK.GetTime()) {
            if (ev.data3 == -1) {
                ch = KEY_UPARROW;
                joywait = TICK.GetTime() + 5;
            } else if (ev.data3 == 1) {
                ch = KEY_DOWNARROW;
                joywait = TICK.GetTime() + 5;
            }

            if (ev.data2 == -1) {
                ch = KEY_LEFTARROW;
                joywait = TICK.GetTime() + 2;
            } else if (ev.data2 == 1) {
                ch = KEY_RIGHTARROW;
                joywait = TICK.GetTime() + 2;
            }

            if ((ev.data1 & 1) != 0) {
                ch = KEY_ENTER;
                joywait = TICK.GetTime() + 5;
            }
            if ((ev.data1 & 2) != 0) {
                ch = KEY_BACKSPACE;
                joywait = TICK.GetTime() + 5;
            }
        } else 
        // Mouse input 
        {
            if (ev.type == evtype_t.ev_mouse && mousewait < TICK.GetTime()) {
                mousey += ev.data3;
                if (mousey < lasty - 30) {
                    ch = KEY_DOWNARROW;
                    mousewait = TICK.GetTime() + 5;
                    mousey = lasty -= 30;
                } else if (mousey > lasty + 30) {
                    ch = KEY_UPARROW;
                    mousewait = TICK.GetTime() + 5;
                    mousey = lasty += 30;
                }

                mousex += ev.data2;
                if (mousex < lastx - 30) {
                    ch = KEY_LEFTARROW;
                    mousewait = TICK.GetTime() + 5;
                    mousex = lastx -= 30;
                } else if (mousex > lastx + 30) {
                    ch = KEY_RIGHTARROW;
                    mousewait = TICK.GetTime() + 5;
                    mousex = lastx += 30;
                }

                if ((ev.data1 & 1) != 0) {
                    ch = KEY_ENTER;
                    mousewait = TICK.GetTime() + 15;
                }

                if ((ev.data1 & 2) != 0) {
                    ch = KEY_BACKSPACE;
                    mousewait = TICK.GetTime() + 15;
                }
            } else if (ev.type == evtype_t.ev_keydown) {
                ch = (char) ev.data1;
            }
        }

        if (ch == 0xFFFF)
            return false;

        // Save Game string input
        if (saveStringEnter) {

            switch (ch) {
            case KEY_BACKSPACE:
                if (saveCharIndex > 0) {
                    saveCharIndex--;
                    savegamestrings[saveSlot][saveCharIndex] = 0;
                }
                break;

            case KEY_ESCAPE:
                saveStringEnter = false;
                C2JUtils.strcpy(savegamestrings[saveSlot], saveOldString);
                break;

            case KEY_ENTER:            	
                saveStringEnter = false;
                if (savegamestrings[saveSlot][0] != 0)
                    DoSave(saveSlot);
                break;

            default:
                ch = Character.toUpperCase(ch);
            	if (ch != 32)
                    if (ch - HU_FONTSTART < 0
                            || ch - HU_FONTSTART >= HU_FONTSIZE)
                        break;
                if (ch >= 32
                        && ch <= 127
                        && saveCharIndex < SAVESTRINGSIZE - 1
                        && StringWidth(savegamestrings[saveSlot]) < (SAVESTRINGSIZE - 2) * 8) {
                    savegamestrings[saveSlot][saveCharIndex++] = ch;
                    savegamestrings[saveSlot][saveCharIndex] = 0;
                }
                break;
            }
            return true;
        }

        // Take care of any messages that need input
        if (messageToPrint) {
            if (messageNeedsInput == true
                    && !(ch == ' ' || ch == 'n' || ch == 'y' || ch == KEY_ESCAPE))
                return false;

            DM.menuactive = messageLastMenuActive;
            messageToPrint = false;
            if (messageRoutine != null)
                messageRoutine.invoke(ch);

            DM.menuactive = false; // "false"
            S.StartSound(null, sfxenum_t.sfx_swtchx);
            return true;
        }

        if (DM.devparm && ch == KEY_F1) {
            DG.ScreenShot();
            return true;
        }

        // F-Keys
        if (!DM.menuactive){
            switch (ch) {
            case KEY_MINUS: // Screen size down
                if (DM.automapactive || HU.chat_on[0])
                    return false;
                SizeDisplay.invoke(0);
                S.StartSound(null, sfxenum_t.sfx_stnmov);
                return true;

            case KEY_EQUALS: // Screen size up
                if (DM.automapactive || HU.chat_on[0])
                    return false;
                SizeDisplay.invoke(1);
                S.StartSound(null, sfxenum_t.sfx_stnmov);
                return true;

            case KEY_F1: // Help key
                StartControlPanel();

                if (DM.isRetail() || currentMenu==ReadDef1)
                    currentMenu = ReadDef2;
                else
                    currentMenu = ReadDef1;
                itemOn = 0;
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                return true;

            case KEY_F2: // Save
                StartControlPanel();
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                SaveGame.invoke(0);
                return true;

            case KEY_F3: // Load
                StartControlPanel();
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                LoadGame.invoke(0);
                return true;

            case KEY_F4: // Sound Volume
                StartControlPanel();
                currentMenu = SoundDef;
                itemOn = (short) sfx_vol;
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                return true;

            case KEY_F5: // Detail toggle
                ChangeDetail.invoke(0);
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                return true;

            case KEY_F6: // Quicksave
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                QuickSave();
                return true;

            case KEY_F7: // End game
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                EndGame.invoke(0);
                return true;

            case KEY_F8: // Toggle messages
                ChangeMessages.invoke(0);
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                return true;

            case KEY_F9: // Quickload
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                QuickLoad();
                return true;

            case KEY_F10: // Quit DOOM
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                QuitDOOM.invoke(0);
                return true;

            case KEY_F11: // gamma toggle
                int usegamma = V.getUsegamma();
                usegamma++;
                if (usegamma > 4)
                    usegamma = 0;
                DM.players[DM.consoleplayer].message = gammamsg[usegamma];
                // FIXME: it's pointless to reload the same palette.
                //I.SetPalette (W.CacheLumpName ("PLAYPAL",PU_CACHE));
                DM.VI.SetPalette(0);
                DM.VI.SetGamma(usegamma);
                return true;

            }
    }
        // Pop-up menu?
        if (!DM.menuactive) {
            if (ch == KEY_ESCAPE) {
                StartControlPanel();
                S.StartSound(null, sfxenum_t.sfx_swtchn);
                return true;
            }
            return false;
        }

        // Keys usable within menu
        switch (ch) {
        case KEY_DOWNARROW:
            do {
                if (itemOn + 1 > currentMenu.numitems - 1)
                    itemOn = 0;
                else
                    itemOn++;
                S.StartSound(null, sfxenum_t.sfx_pstop);
            } while (currentMenu.menuitems[itemOn].status == -1);
            return true;

        case KEY_UPARROW:
            do {
                if (itemOn == 0)
                    itemOn = (short) (currentMenu.numitems - 1);
                else
                    itemOn--;
              S.StartSound(null, sfxenum_t.sfx_pstop);
            } while (currentMenu.menuitems[itemOn].status == -1);
            return true;

        case KEY_LEFTARROW:
            if ((currentMenu.menuitems[itemOn].routine != null)
                    && (currentMenu.menuitems[itemOn].status == 2)) {
                S.StartSound(null, sfxenum_t.sfx_stnmov);
                currentMenu.menuitems[itemOn].routine.invoke(0);
            }
            return true;

        case KEY_RIGHTARROW:
            if ((currentMenu.menuitems[itemOn].routine != null)
                    && (currentMenu.menuitems[itemOn].status == 2)) {
            	S.StartSound(null, sfxenum_t.sfx_stnmov);
                currentMenu.menuitems[itemOn].routine.invoke(1);
            }
            return true;

        case KEY_ENTER: {
            if ((currentMenu.menuitems[itemOn].routine != null)
                    && currentMenu.menuitems[itemOn].status != 0) {
                currentMenu.lastOn = itemOn;
                if (currentMenu.menuitems[itemOn].status == 2) {
                    currentMenu.menuitems[itemOn].routine.invoke(1); // right
                    // arrow
                    S.StartSound(null, sfxenum_t.sfx_stnmov);
                } else {
                    currentMenu.menuitems[itemOn].routine.invoke(itemOn);
                    S.StartSound(null, sfxenum_t.sfx_pistol);
                }
            }
        }
            return true;

        case KEY_ESCAPE:
            currentMenu.lastOn = itemOn;
            ClearMenus();
            S.StartSound(null, sfxenum_t.sfx_swtchx);
            return true;

        case KEY_BACKSPACE:
            currentMenu.lastOn = itemOn;
            if (currentMenu.prevMenu != null) {
                currentMenu = currentMenu.prevMenu;
                itemOn = (short) currentMenu.lastOn;
                 S.StartSound(null, sfxenum_t.sfx_swtchn);
            }
            return true;

        default:
            for (i = itemOn + 1; i < currentMenu.numitems; i++)
                if (currentMenu.menuitems[i].alphaKey == ch) {
                    itemOn = (short) i;
                    S.StartSound(null, sfxenum_t.sfx_pstop);
                    return true;
                }
            for (i = 0; i <= itemOn; i++)
                if (currentMenu.menuitems[i].alphaKey == ch) {
                    itemOn = (short) i;
                    S.StartSound(null, sfxenum_t.sfx_pstop);
                    return true;
                }
            break;

        }

        return false;
    }

    /**
     * M_StartControlPanel
     */
    public void StartControlPanel() {
        // intro might call this repeatedly
        if (DM.menuactive)
            return;

        DM.menuactive = true;
        currentMenu = MainDef; // JDC
        itemOn = (short) currentMenu.lastOn; // JDC
    }

    /**
     * M_Drawer Called after the view has been rendered, but before it has been
     * blitted.
     */
    public void Drawer() {

        int x;
        int y;
        int max;
        char[] string = new char[40];
        char[] msstring;
        int start;
        inhelpscreens = false; // Horiz. & Vertically center string and print
        // it.
        if (messageToPrint) {
            start = 0;
            y = 100 - this.StringHeight(messageString) / 2;
            msstring = messageString.toCharArray();
            while(start<messageString.length()) {
                int i=0;
                for ( i = 0; i < messageString.length() - start; i++) 
                    if (msstring[start + i] == '\n') {
                        C2JUtils.memset(string, (char) 0, 40);
                        C2JUtils.strcpy(string, msstring, start, i);
                        start += i + 1;
                        break;
                    }
                
                    if (i == (messageString.length() - start)) {
                        C2JUtils.strcpy(string, msstring,start);
                        start += i;
                    }
                    x = 160 - this.StringWidth(string) / 2;
                    this.WriteText(x, y, string);
                    y += hu_font[0].height;
                }
                return;
            }
            if (!DM.menuactive)
                return;
            if (currentMenu.routine != null){
                currentMenu.routine.invoke(); // call Draw routine
            }
            // DRAW MENU
            x = currentMenu.x;
            y = currentMenu.y;
            max = currentMenu.numitems;
            for (int i = 0; i < max; i++) {
                if (currentMenu.menuitems[i].name != null && currentMenu.menuitems[i].name!="")
                    V.DrawScaledPatch(x, y, 0,vs, W.CachePatchName(
                        currentMenu.menuitems[i].name, PU_CACHE));
                y += LINEHEIGHT;
            }

            // DRAW SKULL
            V.DrawScaledPatch(x + SKULLXOFF, currentMenu.y - 5 + itemOn
                    * LINEHEIGHT, 0, vs,W.CachePatchName(skullName[whichSkull],
                PU_CACHE));
    }

    //
    // M_ClearMenus
    //
    public void ClearMenus() {
        DM.menuactive = false;
        V.clearCaches();
        // MAES: was commented out :-/
        //if (!DM.netgame && DM.usergame && DM.paused)
        //    DM.setPaused(true);
    }

    /**
     * M_SetupNextMenu
     */
    public void SetupNextMenu(menu_t menudef) {
        currentMenu = menudef;
        itemOn = (short) currentMenu.lastOn;
    }

    /**
     * M_Ticker
     */
    public void Ticker() {
        if (--skullAnimCounter <= 0) {
            whichSkull ^= 1;
            skullAnimCounter = 8;
        }
    }

    /**
     * M_Init
     */
    public void Init() {
        
        // Init menus.
        this.initMenuRoutines();
        this.initDrawRoutines();
        this.initMenuItems();
        this.hu_font=HU.getHUFonts();

        currentMenu = MainDef;
        DM.menuactive = false;
        itemOn = (short) currentMenu.lastOn;
        whichSkull = 0;
        skullAnimCounter = 10;
        screenSize = screenblocks - 3;
        messageToPrint = false;
        messageString = null;
        messageLastMenuActive = DM.menuactive;
        quickSaveSlot = -1;

        // Here we could catch other version dependencies,
        // like HELP1/2, and four episodes.

        switch (DM.getGameMode()) {
        case commercial:
        case pack_plut:
        case pack_tnt:
            // This is used because DOOM 2 had only one HELP
            // page. I use CREDIT as second page now, but
            // kept this hack for educational purposes.
            MainMenu[readthis] = MainMenu[quitdoom];
            MainDef.numitems--;
            MainDef.y += 8;
            NewDef.prevMenu = MainDef;
            ReadDef1.routine = DrawReadThis1;
            ReadDef1.x = 330;
            ReadDef1.y = 165;
            ReadMenu1[0].routine = FinishReadThis;
            break;
        case shareware:
            // Episode 2 and 3 are handled,
            // branching to an ad screen.
        case registered:
            // We need to remove the fourth episode.
            EpiDef.numitems--;
            break;
        case retail:
            // We are fine.
        default:
            break;
        }

    }

    

    /**
     * M_DrawText Returns the final X coordinate HU_Init must have been called
     * to init the font. Unused?
     * 
     * @param x
     * @param y
     * @param direct
     * @param string
     * @return
     */

    public int DrawText(int x, int y, boolean direct, String string) {
        int c;
        int w;
        int ptr = 0;
        
        while ((c=string.charAt(ptr)) > 0) {
            c = Character.toUpperCase(c) - HU_FONTSTART;
            ptr++;
            if (c < 0 || c > HU_FONTSIZE) {
                x += 4;
                continue;
            }

            w = hu_font[c].width;
            if (x + w > SCREENWIDTH)
                break;
            if (direct)
                V.DrawScaledPatch(x, y, 0,vs, hu_font[c]);
            else
                V.DrawScaledPatch(x, y, 0,vs, hu_font[c]);
            x += w;
        }

        return x;
    }

    

    // ////////////////////////// DRAWROUTINES
    // //////////////////////////////////

    class M_DrawEpisode
            implements DrawRoutine {

        @Override
        public void invoke() {
            V.DrawScaledPatch(54, 38, 0,vs, W.CachePatchName("M_EPISOD"));
        }

    }

    /**
     * M_LoadGame & Cie.
     */

    class M_DrawLoad
            implements DrawRoutine {
        @Override
        public void invoke() {
            int i;

            V.DrawScaledPatch(72, 28, 0,vs, W.CachePatchName("M_LOADG"));
            for (i = 0; i < load_end; i++) {
                DrawSaveLoadBorder(LoadDef.x, LoadDef.y + LINEHEIGHT * i);
                WriteText(LoadDef.x, LoadDef.y + LINEHEIGHT * i,
                    savegamestrings[i]);
            }

        }
    }

    class M_DrawMainMenu
            implements DrawRoutine {
        @Override
        public void invoke() {
            V.DrawScaledPatch(94, 2, 0,vs, (patch_t) (W.CachePatchName("M_DOOM")));
        }
    }

    class M_DrawNewGame
            implements DrawRoutine {

        @Override
        public void invoke() {
            V.DrawScaledPatch(96, 14, 0, vs,(patch_t) W.CachePatchName("M_NEWG"));
            V.DrawScaledPatch(54, 38, 0, vs,(patch_t) W.CachePatchName("M_SKILL"));
        }
    }

    class M_DrawOptions
            implements DrawRoutine {

        private String detailNames[] = { "M_GDHIGH", "M_GDLOW" };

        private String msgNames[] = { "M_MSGOFF", "M_MSGON" };

        @Override
        public void invoke() {
            V.DrawScaledPatch(108, 15, 0, vs,W.CachePatchName("M_OPTTTL"));

            V.DrawScaledPatch(OptionsDef.x + 175, OptionsDef.y + LINEHEIGHT
                    * detail, 0,vs, W.CachePatchName(detailNames[detailLevel]));

            V.DrawScaledPatch(OptionsDef.x + 120, OptionsDef.y + LINEHEIGHT
                    * messages, 0,vs, W.CachePatchName(msgNames[showMessages?1:0]));

            DrawThermo(OptionsDef.x, OptionsDef.y + LINEHEIGHT
                    * (mousesens + 1), 10, DM.mouseSensitivity);

            DrawThermo(OptionsDef.x,
                OptionsDef.y + LINEHEIGHT * (scrnsize + 1), 9, screenSize);

        }

    }

    /**
     * Read This Menus Had a "quick hack to fix romero bug"
     */

    class M_DrawReadThis1
            implements DrawRoutine {

        @Override
        public void invoke() {
            inhelpscreens = true;
            switch (DM.getGameMode()) {
            case commercial:
                V.DrawPatchSolidScaled(0, 0, 0, vs,W.CachePatchName("HELP"));
                break;
            case shareware:
            case registered:
            case retail:
                V.DrawPatchSolidScaled(0, 0, 0,vs, W.CachePatchName("HELP1"));
                break;
            default:
                break;
            }
            
            // Maes: we need to do this here, otherwide the status bar appears "dirty"
            DM.ST.forceRefresh();
            return;
        }
    }

    /**
     * Read This Menus - optional second page.
     */
    class M_DrawReadThis2
            implements DrawRoutine {

        @Override
        public void invoke() {
            inhelpscreens = true;
            switch (DM.getGameMode()) {
            case retail:
            case commercial:
                // This hack keeps us from having to change menus.
                V.DrawPatchSolidScaled(0, 0, 0, vs,W.CachePatchName("CREDIT"));
                break;
            case shareware:
            case registered:
                V.DrawPatchSolidScaled(0, 0, 0, vs,W.CachePatchName("HELP2"));
                break;
            default:
                break;
            }
            
            // Maes: we need to do this here, otherwide the status bar appears "dirty"
            DM.ST.forceRefresh();
            return;
        }
    }

    /**
     * Change Sfx & Music volumes
     */
    class M_DrawSound
            implements DrawRoutine {

        public void invoke() {
            V.DrawScaledPatch(60, 38, 0,vs, (patch_t) W.CacheLumpName("M_SVOL",
                PU_CACHE, patch_t.class));

            DrawThermo(SoundDef.x, SoundDef.y + LINEHEIGHT * (sfx_vol + 1), 16,
                DM.snd_SfxVolume);

            DrawThermo(SoundDef.x, SoundDef.y + LINEHEIGHT * (music_vol + 1),
                16, DM.snd_MusicVolume);
        }
    }

    // /////////////////////////// MENU ROUTINES
    // ///////////////////////////////////

    class M_ChangeDetail
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            choice = 0;
            detailLevel = 1 - detailLevel;

            // FIXME - does not work. Remove anyway?
            //System.err.print("M_ChangeDetail: low detail mode n.a.\n");

            //return;

            R.SetViewSize (screenblocks, detailLevel); 
            if (detailLevel==0) DM.players[DM.consoleplayer].message = englsh.DETAILHI;
             else DM.players[DM.consoleplayer].message = englsh.DETAILLO;
             

        }
    }

    /**
     * Toggle messages on/off
     */
    class M_ChangeMessages
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            // warning: unused parameter `int choice'
            //choice = 0;
            showMessages = !showMessages;

            if (!showMessages)
                DM.players[DM.consoleplayer].message = MSGOFF;
            else
                DM.players[DM.consoleplayer].message = MSGON;

            message_dontfuckwithme = true;
        }
    }

    class M_ChangeSensitivity
            implements MenuRoutine {
        @Override
        public void invoke(int choice) {
            switch (choice) {
            case 0:
                if (DM.mouseSensitivity != 0)
                	DM.mouseSensitivity--;
                break;
            case 1:
                if (DM.mouseSensitivity < 9)
                	DM.mouseSensitivity++;
                break;
            }
        }
    }

    class M_ChooseSkill
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            if (choice == nightmare) {
                StartMessage(NIGHTMARE, VerifyNightmare, true);
                return;
            }

            DG.DeferedInitNew(skill_t.values()[choice], epi + 1, 1);
            ClearMenus();
        }

    }

    /**
     * M_EndGame
     */

    class M_EndGame
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {
            choice = 0;
            if (!DM.usergame) {
                 S.StartSound(null, sfxenum_t.sfx_oof);
                return;
            }

            if (DM.netgame) {
                StartMessage(NETEND, null, false);
                return;
            }

            StartMessage(ENDGAME, EndGameResponse, true);
        }
    }

    class M_EndGameResponse
            implements MenuRoutine {

        @Override
        public void invoke(int ch) {
            if (ch != 'y')
                return;

            currentMenu.lastOn = itemOn;
            ClearMenus();
            DG.StartTitle();
        }
    }

    class M_Episode
            implements MenuRoutine {

        @Override
        public void invoke(int choice) {

            if (DM.isShareware() && (choice != 0)) {
                StartMessage(SWSTRING, null, false);
                SetupNextMenu(ReadDef2);
                return;
            }

            // Yet another hack...
            if (!DM.isRetail() && (choice > 2)) {
                System.err
                        .print("M_Episode: 4th episode requires UltimateDOOM\n");
                choice = 0;
            }

            epi = choice;
            SetupNextMenu(NewDef);
        }

    }

    /**
     * User wants to load this game
     */
    class M_LoadSelect
            implements MenuRoutine {
        @Override
        public void invoke(int choice) {
            String name;

            if (DM.CM.CheckParm("-cdrom") != 0)
                name = ("c:\\doomdata\\" + SAVEGAMENAME + (choice) + ".dsg");
            else
                name = (SAVEGAMENAME + (choice) + ".dsg");
            DG.LoadGame(name);
            ClearMenus();
        }
    }

    /**
     * Selected from DOOM menu
     */
    class M_LoadGame
            implements MenuRoutine {
        @Override
        public void invoke(int choice) {

            if (DM.netgame) {
                StartMessage(LOADNET, null, false);
                return;
            }

            SetupNextMenu(LoadDef);
            ReadSaveStrings();
        }
    }

    // ////////////////////// VARIOUS CONSTS //////////////////////

    private static final sfxenum_t[] quitsounds =
        { sfxenum_t.sfx_pldeth, sfxenum_t.sfx_dmpain, sfxenum_t.sfx_popain,
                sfxenum_t.sfx_slop, sfxenum_t.sfx_telept, sfxenum_t.sfx_posit1,
                sfxenum_t.sfx_posit3, sfxenum_t.sfx_sgtatk };

    private static final sfxenum_t[] quitsounds2 =
        { sfxenum_t.sfx_vilact, sfxenum_t.sfx_getpow, sfxenum_t.sfx_boscub,
                sfxenum_t.sfx_slop, sfxenum_t.sfx_skeswg, sfxenum_t.sfx_kntdth,
                sfxenum_t.sfx_bspact, sfxenum_t.sfx_sgtatk };

    /** episodes_e enum */
    private static final int ep1 = 0, ep2 = 1, ep3 = 2, ep4 = 3, ep_end = 4;

    /** load_e enum */
    private static final int load1 = 0, load2 = 1, load3 = 2, load4 = 3, load5 = 4,
            load6 = 5, load_end = 6;

    /** options_e enum; */

    private static final int endgame = 0, messages = 1, detail = 2, scrnsize = 3,
            option_empty1 = 4, mousesens = 5, option_empty2 = 6, soundvol = 7,
            opt_end = 8;

    /** main_e enum; */
    private static final int  newgame = 0, options = 1, loadgam = 2, savegame = 3,
            readthis = 4, quitdoom = 5, main_end = 6;

    /** read_e enum */
    private static final int rdthsempty1 = 0, read1_end = 1;

    /** read_2 enum */
    private static final int rdthsempty2 = 0, read2_end = 1;

    /**  newgame_e enum;*/
    public static final int killthings = 0, toorough = 1, hurtme = 2, violence = 3,
            nightmare = 4, newg_end = 5;
    
    private static final String[] gammamsg = { "GAMMALVL0",

        "GAMMALVL1", "GAMMALVL2", "GAMMALVL3", "GAMMALVL4" };

    /** sound_e enum */
    static final int sfx_vol = 0, sfx_empty1 = 1, music_vol = 2, sfx_empty2 = 3,
            sound_end = 4;

    @Override
    public void setScreenBlocks(int val) {
        this.screenblocks=val;
    }
    
	@Override
	public int getScreenBlocks() {
		return this.screenblocks;
	}

	@Override
	public int getDetailLevel() {
		return this.detailLevel;
	}
	
////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

	protected int SCREENWIDTH;
	protected int SCREENHEIGHT;
	protected IVideoScale vs;


	@Override
	public void setVideoScale(IVideoScale vs) {
	    this.vs=vs;
	}

	@Override
	public void initScaling() {
	    this.SCREENHEIGHT=vs.getScreenHeight();
	    this.SCREENWIDTH=vs.getScreenWidth();
	}




}
package m;

public interface IUseVariables {
    
    
    /** Register a variable manager with this module.
     * 
     * @param manager
     */
    public void registerVariableManager(IVariablesManager manager);
    
    
    /** Apply listener-specific variables, asking the manager for them.
     *  Every listener should concern itself with its own variables/settings.
     *  
     *  This method should be called by the manager on every registered
     *  listener. Each listener then "knows" which settings it must update.
     *  
     *  Good for block updates, but maybe a more lightweight mechanism should
     *  be provided, e.g. being able to update just one setting for a listener.
     * 
     */
    public void update();
    
    /** If the variables user makes too many changes, it may be better to 
     * communicate them back to the manager in-block. This shouldn't be needed,
     * if everywhere a certain setting has to be modified tis done through the
     * manager.
     */
    
    public void commit();


}

package m;

public interface IVariablesManager {
    
    /** Does two things: sets a variable, and then calls setme.
     * This way, immediate updates of a single variables user 
     * are possible, avoiding some of the overhead. 
     * 
     * Sadly, users with too many variables will still incur an
     * O(n) penalty.
     * 
     * @param setme
     * @param name
     * @param value
     */
    
    public void applySetting(IUseVariables setme,String name, String value);

    public DoomSetting getSetting(String name);
    
    public DoomSetting getSetting(Settings name);

    public boolean isSettingLiteral(String name,String value);
    
 /** Creates a new setting, overriding any existing ones.
  *   
  * @param name
  * @param value
  * @param persist
  */
    
    public void putSetting(String name, Object value, boolean persist);
    
    /** Puts a new setting or updates an existing one. In this case,
     * the value of the "persist" field is kept unaltered, so that persistent
     * settings are not lost during updates. 
     * 
     * @param name
     * @param value
     */
    
    public void putSetting(String name, Object value);
    public void putSetting(Settings name, Object value);

    void LoadDefaults(String defaultfile);

    void SaveDefaults(String defaultfile);
    
    String getDefaultFile();
    
}

package m;

import v.IVideoScale;
import doom.DoomStatus;
import doom.event_t;

/** A dummy menu, useful for testers that do need a defined
 *  menu object.
 * 
 * @author Maes
 *
 */

public class DummyMenu
        extends AbstractDoomMenu {

    @Override
    public void setVideoScale(IVideoScale vs) {
        // TODO Auto-generated method stub

    }

    @Override
    public void initScaling() {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean Responder(event_t ev) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public void Ticker() {
        // TODO Auto-generated method stub

    }

    @Override
    public void Drawer() {
        // TODO Auto-generated method stub

    }

    @Override
    public void Init() {
        // TODO Auto-generated method stub

    }

    @Override
    public void StartControlPanel() {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean getShowMessages() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public void setShowMessages(boolean val) {
        // TODO Auto-generated method stub

    }

    @Override
    public int getScreenBlocks() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void setScreenBlocks(int val) {
        // TODO Auto-generated method stub

    }

    @Override
    public int getDetailLevel() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void updateStatus(DoomStatus DS) {
        // TODO Auto-generated method stub

    }

	@Override
	public void ClearMenus() {
		// TODO Auto-generated method stub
		
	}

}

package m;

public class default_t {

    public default_t(String name, int[] location, int defaultvalue) {
        this.name = name;
        this.location = location;
        this.defaultvalue = defaultvalue;
    }

    public String name;

    /** this is supposed to be a pointer */
    public int[] location;

    public int defaultvalue;

    int scantranslate; // PC scan code hack

    int untranslated; // lousy hack
};

package st;

enum st_chatstateenum_t {
	    StartChatState,
	    WaitDestState,
	    GetChatState
}

package st;

// Emacs style mode select -*- C++ -*-
// -----------------------------------------------------------------------------
//
// $Id: StatusBar.java,v 1.47 2011/11/01 23:46:37 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// DESCRIPTION:
// Status bar code.
// Does the face/direction indicator animatin.
// Does palette indicators as well (red pain/berserk, bright pickup)
//
// -----------------------------------------------------------------------------

import defines.*;
import static data.Limits.MAXPLAYERS;
import static g.Keys.*;
import static data.Defines.*;
import static doom.englsh.*;
import static automap.IAutoMap.*;
import static doom.player_t.*;
import static doom.items.*;
import static data.Tables.*;
import p.mobj_t;
import m.cheatseq_t;
import data.sounds.musicenum_t;
import doom.DoomStatus;
import doom.event_t;
import doom.evtype_t;
import doom.player_t;
import doom.weapontype_t;
import rr.patch_t;
import v.IVideoScale;
import static v.DoomVideoRenderer.*;

public class StatusBar extends AbstractStatusBar   {
    public static final String rcsid =
        "$Id: StatusBar.java,v 1.47 2011/11/01 23:46:37 velktron Exp $";

   
    
    // Size of statusbar.
    // Now sensitive for scaling.

    //
    // STATUS BAR DATA
    //

    // Palette indices.
    // For damage/bonus red-/gold-shifts
    private static int STARTREDPALS = 1;

    private static int STARTBONUSPALS = 9;

    private static int NUMREDPALS = 8;

    private static int NUMBONUSPALS = 4;

    // Radiation suit, green shift.
    private static int RADIATIONPAL = 13;

    // N/256*100% probability
    // that the normal face state will change
    private static int ST_FACEPROBABILITY = 96;

    // For Responder
    private static int ST_TOGGLECHAT = KEY_ENTER;

    // Location of status bar
    private int ST_X = 0;
    private int ST_X2;
    private int ST_FX;
    private int ST_FY;

    // Should be set to patch width
    // for tall numbers later on
    // TODO: private static int ST_TALLNUMWIDTH = (tallnum[0].width);

    // Number of status faces.
    private static int ST_NUMPAINFACES = 5;

    private static int ST_NUMSTRAIGHTFACES = 3;

    private static int ST_NUMTURNFACES = 2;

    private static int ST_NUMSPECIALFACES = 3;

    private static int ST_FACESTRIDE =
        (ST_NUMSTRAIGHTFACES + ST_NUMTURNFACES + ST_NUMSPECIALFACES);

    private static int ST_NUMEXTRAFACES = 2;

    private static int ST_NUMFACES =
        (ST_FACESTRIDE * ST_NUMPAINFACES + ST_NUMEXTRAFACES);

    private static int ST_TURNOFFSET = (ST_NUMSTRAIGHTFACES);

    private static int ST_OUCHOFFSET = (ST_TURNOFFSET + ST_NUMTURNFACES);

    private static int ST_EVILGRINOFFSET = (ST_OUCHOFFSET + 1);

    private static int ST_RAMPAGEOFFSET = (ST_EVILGRINOFFSET + 1);

    private static int ST_GODFACE = (ST_NUMPAINFACES * ST_FACESTRIDE);

    private static int ST_DEADFACE = (ST_GODFACE + 1);

    private int ST_FACESX;

    private int ST_FACESY;

    private static int ST_EVILGRINCOUNT = (2 * TICRATE);

    private static int ST_STRAIGHTFACECOUNT = (TICRATE / 2);

    private static int ST_TURNCOUNT = (1 * TICRATE);

    private static int ST_OUCHCOUNT = (1 * TICRATE);

    private static int ST_RAMPAGEDELAY = (2 * TICRATE);

    private static int ST_MUCHPAIN = 20;

    // Location and size of statistics,
    // justified according to widget type.
    // Problem is, within which space? STbar? Screen?
    // Note: this could be read in by a lump.
    // Problem is, is the stuff rendered
    // into a buffer,
    // or into the frame buffer?

    // AMMO number pos.
    private int ST_AMMOWIDTH;
    private int ST_AMMOX;
    private int ST_AMMOY;

    // HEALTH number pos.
    private int ST_HEALTHWIDTH=3;
    private int ST_HEALTHX;
    private int ST_HEALTHY;

    // Weapon pos.
    private int ST_ARMSX;
    private int ST_ARMSY;
    private int ST_ARMSBGX;
    private int ST_ARMSBGY;
    private int ST_ARMSXSPACE;
    private int ST_ARMSYSPACE;

    // Frags pos.
    private int ST_FRAGSX;
    private int ST_FRAGSY;
    private int ST_FRAGSWIDTH;

    // ARMOR number pos.
    private int ST_ARMORWIDTH = 3;

    private int ST_ARMORX;

    private int ST_ARMORY;

    // Key icon positions.
    private int ST_KEY0WIDTH;
    private int ST_KEY0HEIGHT;
    private int ST_KEY0X;
    private int ST_KEY0Y;

    private int ST_KEY1WIDTH;
    private int ST_KEY1X;
    private int ST_KEY1Y;

    private int ST_KEY2WIDTH;
    private int ST_KEY2X;
    private int ST_KEY2Y;

    // Ammunition counter.
    private int ST_AMMO0WIDTH;
    private int ST_AMMO0HEIGHT;

    private int ST_AMMO0X;
    private int ST_AMMO0Y;

    private int ST_AMMO1WIDTH;

    private int ST_AMMO1X;

    private int ST_AMMO1Y;

    private int ST_AMMO2WIDTH;

    private int ST_AMMO2X;

    private int ST_AMMO2Y;

    private int ST_AMMO3WIDTH;

    private int ST_AMMO3X;

    private int ST_AMMO3Y;

    // Indicate maximum ammunition.
    // Only needed because backpack exists.
    private int ST_MAXAMMO0WIDTH;

    private int ST_MAXAMMO0HEIGHT;

    private int ST_MAXAMMO0X;

    private int ST_MAXAMMO0Y;

    private int ST_MAXAMMO1WIDTH;

    private int ST_MAXAMMO1X;

    private int ST_MAXAMMO1Y;

    private int ST_MAXAMMO2WIDTH;

    private int ST_MAXAMMO2X;

    private int ST_MAXAMMO2Y;

    private int ST_MAXAMMO3WIDTH;

    private int ST_MAXAMMO3X;
    private int ST_MAXAMMO3Y;
    
    // pistol
    private int ST_WEAPON0X;
    private int ST_WEAPON0Y;

    // shotgun
    private int ST_WEAPON1X;
    private int ST_WEAPON1Y;

    // chain gun
    private int ST_WEAPON2X;
    private int ST_WEAPON2Y;

    // missile launcher
    private int ST_WEAPON3X;
    private int ST_WEAPON3Y;

    // plasma gun
    private int ST_WEAPON4X;
    private int ST_WEAPON4Y;

    // bfg
    private int ST_WEAPON5X;
    private int ST_WEAPON5Y;

    // WPNS title
    private int ST_WPNSX;
    private int ST_WPNSY;

    // DETH title
    private int ST_DETHX;
    private int ST_DETHY;

    // Incoming messages window location
    // UNUSED
    // #define ST_MSGTEXTX (viewwindowx)
    // #define ST_MSGTEXTY (viewwindowy+viewheight-18)
    private static int ST_MSGTEXTX = 0;

    private static int ST_MSGTEXTY = 0;

    // Dimensions given in characters.
    private static int ST_MSGWIDTH = 52;

    // Or shall I say, in lines?
    private static int ST_MSGHEIGHT = 1;

    private static int ST_OUTTEXTX = 0;

    private static int ST_OUTTEXTY = 6;

    // Width, in characters again.
    private static int ST_OUTWIDTH = 52;

    // Height, in lines.
    private static int ST_OUTHEIGHT = 1;

    // TODO private static int ST_MAPWIDTH =
    // (mapnames[(gameepisode-1)*9+(gamemap-1)].length));

    // TODO private static int ST_MAPTITLEX = (SCREENWIDTH - ST_MAPWIDTH *
    // ST_CHATFONTWIDTH);

    private static int ST_MAPTITLEY = 0;

    private static int ST_MAPHEIGHT = 1;

    // main player in game
    private player_t plyr;

    // ST_Start() has just been called, OR we want to force an redraw anyway.
    private boolean st_firsttime;
    
    @Override
    public void forceRefresh(){
        st_firsttime=true;
    }

    // used to execute ST_Init() only once
    private int veryfirsttime = 1;

    // lump number for PLAYPAL
    private int lu_palette;

    // used for timing (unsigned int .. maybe long !)
    private long st_clock;

    // used for making messages go away
    int st_msgcounter = 0;

    // used when in chat
    private st_chatstateenum_t st_chatstate;

    // whether in automap or first-person
    private st_stateenum_t st_gamestate;

    /** whether left-side main status bar is active. This fugly hax
     *  (and others like it) are necessary in order to have something
     *  close to a pointer.
     */
    private boolean[] st_statusbaron={false};

    // whether status bar chat is active
    private boolean st_chat;

    // value of st_chat before message popped up
    private boolean st_oldchat;

    // whether chat window has the cursor on
    private boolean[] st_cursoron={false};

    /** !deathmatch */
    private boolean[] st_notdeathmatch={true};

    /** !deathmatch && st_statusbaron */
    private boolean[] st_armson={true};

    /** !deathmatch */
    private boolean[] st_fragson={false};

    // main bar left
    private patch_t sbar;

    // 0-9, tall numbers
    private patch_t[] tallnum = new patch_t[10];

    // tall % sign
    private patch_t tallpercent;

    // 0-9, short, yellow (,different!) numbers
    private patch_t[] shortnum = new patch_t[10];

    // 3 key-cards, 3 skulls
    private patch_t[] keys = new patch_t[NUMCARDS];

    // face status patches
    private patch_t[] faces = new patch_t[ST_NUMFACES];

    // face background
    private patch_t faceback;

    // main bar right
    private patch_t armsbg;

    // weapon ownership patches
    private patch_t[][] arms = new patch_t[6][2];
   
    // // WIDGETS /////

    // ready-weapon widget
    private st_number_t w_ready;

    // in deathmatch only, summary of frags stats
    private st_number_t w_frags;

    // health widget
    private st_percent_t w_health;

    // arms background
    private st_binicon_t w_armsbg;

    // weapon ownership widgets
    private st_multicon_t[] w_arms = new st_multicon_t[6];

    // face status widget
    private st_multicon_t w_faces;

    // keycard widgets
    private st_multicon_t[] w_keyboxes = new st_multicon_t[3];

    // armor widget
    private st_percent_t w_armor;

    // ammo widgets
    private st_number_t[] w_ammo = new st_number_t[4];

    // max ammo widgets
    private st_number_t[] w_maxammo = new st_number_t[4];

    // / END WIDGETS ////

    // number of frags so far in deathmatch
    private int[] st_fragscount={0};

    // used to use appopriately pained face
    private int st_oldhealth = -1;

    // used for evil grin
    private boolean[] oldweaponsowned = new boolean[NUMWEAPONS];

    // count until face changes
    private int st_facecount = 0;

    // current face index, used by w_faces
    private int[] st_faceindex = new int[1];

    // holds key-type for each key box on bar
    private int[] keyboxes = new int[3];

    // a random number per tick
    private int st_randomnumber;
    
    // idmypos toggle mode
    private boolean st_idmypos=false;

    // Massive bunches of cheat shit
    // to keep it from being easy to figure them out.
    // Yeah, right...
    private char cheat_mus_seq[] =
        { 0xb2, 0x26, 0xb6, 0xae, 0xea, 1, 0, 0, 0xff };

    private char cheat_choppers_seq[] =
        { 0xb2, 0x26, 0xe2, 0x32, 0xf6, 0x2a, 0x2a, 0xa6, 0x6a, 0xea, 0xff // id...
        };

    private char cheat_god_seq[] = { 0xb2, 0x26, 0x26, 0xaa, 0x26, 0xff // iddqd
        };

    private char cheat_ammo_seq[] = { 0xb2, 0x26, 0xf2, 0x66, 0xa2, 0xff // idkfa
        };

    private char cheat_ammonokey_seq[] = { 0xb2, 0x26, 0x66, 0xa2, 0xff // idfa
        };

    // Smashing Pumpkins Into Samml Piles Of Putried Debris.
    private char cheat_noclip_seq[] = { 0xb2, 0x26, 0xea, 0x2a, 0xb2, // idspispopd
            0xea, 0x2a, 0xf6, 0x2a, 0x26, 0xff };

    //
    private char cheat_commercial_noclip_seq[] =
        { 0xb2, 0x26, 0xe2, 0x36, 0xb2, 0x2a, 0xff // idclip
        };

    private char cheat_powerup_seq[][] =
        { { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x6e, 0xff }, // beholdv
                { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xea, 0xff }, // beholds
                { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xb2, 0xff }, // beholdi
                { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x6a, 0xff }, // beholdr
                { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xa2, 0xff }, // beholda
                { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x36, 0xff }, // beholdl
                { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xff } // behold
        };

    private char cheat_clev_seq[] =
        { 0xb2, 0x26, 0xe2, 0x36, 0xa6, 0x6e, 1, 0, 0, 0xff // idclev
        };

    // my position cheat
    private char cheat_mypos_seq[] =
        { 0xb2, 0x26, 0xb6, 0xba, 0x2a, 0xf6, 0xea, 0xff // idmypos
        };

    // Now what?
    cheatseq_t cheat_mus = new cheatseq_t(cheat_mus_seq, 0);

    cheatseq_t cheat_god = new cheatseq_t(cheat_god_seq, 0);

    cheatseq_t cheat_ammo = new cheatseq_t(cheat_ammo_seq, 0);

    cheatseq_t cheat_ammonokey = new cheatseq_t(cheat_ammonokey_seq, 0);

    cheatseq_t cheat_noclip = new cheatseq_t(cheat_noclip_seq, 0);

    cheatseq_t cheat_commercial_noclip =
        new cheatseq_t(cheat_commercial_noclip_seq, 0);

    cheatseq_t[] cheat_powerup =
        { new cheatseq_t(cheat_powerup_seq[0], 0),
                new cheatseq_t(cheat_powerup_seq[1], 0),
                new cheatseq_t(cheat_powerup_seq[2], 0),
                new cheatseq_t(cheat_powerup_seq[3], 0),
                new cheatseq_t(cheat_powerup_seq[4], 0),
                new cheatseq_t(cheat_powerup_seq[5], 0),
                new cheatseq_t(cheat_powerup_seq[6], 0) };

    cheatseq_t cheat_choppers = new cheatseq_t(cheat_choppers_seq, 0);

    cheatseq_t cheat_clev = new cheatseq_t(cheat_clev_seq, 0);

    cheatseq_t cheat_mypos = new cheatseq_t(cheat_mypos_seq, 0);
    
    cheatseq_t cheat_tnthom= new cheatseq_t("tnthom",false);

    // 
    String[] mapnames;

    //
    // STATUS BAR CODE
    //

    public StatusBar(DoomStatus DC) {
    	this.updateStatus(DC);
    	//this.plyr=DM.players[DM.]
    }

    public void refreshBackground() {

        if (st_statusbaron[0]) {
            V.DrawPatchSolidScaled(ST_X, 0, SAFE_SCALE, SAFE_SCALE, BG, sbar);
            //V.DrawPatch(ST_X, 0, BG, sbar);

            if (DM.netgame)
                V.DrawScaledPatch(ST_FX, 0, BG,vs, faceback);
                //V.DrawPatch(ST_FX, 0, BG, faceback);

            // Buffers the background.
            V.CopyRect(ST_X, 0, BG, ST_WIDTH, ST_HEIGHT, ST_X, ST_Y, FG);
        }

    }

    public void Init() {
        veryfirsttime = 0;
        loadData();
        // MAES: screen(4) of the Video Renderer is actually reserved for the status bar.
        // The "clean" status bar is cached in there, and redrawn only as required.
        
        this.V.setScreen(BG,ST_WIDTH,ST_HEIGHT);
    }

    protected boolean st_stopped = true;

    public void Start() {

        if (!st_stopped)
            Stop();

        initData();
        createWidgets();
        st_stopped = false;

    }

    public void Stop() {
        if (st_stopped)
            return;
        // Reset palette.
        VI.SetPalette (0);

        st_stopped = true;
    }

    public void loadData() {
        lu_palette = W.GetNumForName("PLAYPAL");
        loadGraphics();
    }

    // Respond to keyboard input events,
    // intercept cheats.

    public boolean Responder(event_t ev) {
        int i;

        // Filter automap on/off.
        if (ev.type == evtype_t.ev_keyup
                && ((ev.data1 & 0xffff0000) == AM_MSGHEADER)) {
            switch (ev.data1) {
            case AM_MSGENTERED:
                st_gamestate = st_stateenum_t.AutomapState;
                st_firsttime = true;
                break;

            case AM_MSGEXITED:
                // fprintf(stderr, "AM exited\n");
                st_gamestate = st_stateenum_t.FirstPersonState;
                break;
            }
        }

        // if a user keypress...
        else if (ev.type == evtype_t.ev_keydown) {
            if (!DM.netgame) {
                // b. - enabled for more debug fun.
                // if (gameskill != sk_nightmare) {

                // 'dqd' cheat for toggleable god mode
                if (cheat_god.CheckCheat((char) ev.data1)) {
                    plyr.cheats ^= CF_GODMODE;
                    if ((plyr.cheats & CF_GODMODE) != 0) {
                        if (plyr.mo != null)
                            plyr.mo.health = 100;

                        plyr.health[0] = 100;
                        plyr.message = STSTR_DQDON;
                    } else
                        plyr.message = STSTR_DQDOFF;
                }
                // 'fa' cheat for killer fucking arsenal
                else if (cheat_ammonokey.CheckCheat((char) ev.data1)) {
                    plyr.armorpoints[0] = 200;
                    plyr.armortype = 2;

                    for (i = 0; i < NUMWEAPONS; i++)
                        plyr.weaponowned[i] = true; // true

                    for (i = 0; i < NUMAMMO; i++)
                        plyr.ammo[i] = plyr.maxammo[i];

                    plyr.message = STSTR_FAADDED;
                }
                // 'kfa' cheat for key full ammo
                else if (cheat_ammo.CheckCheat((char) ev.data1)) {
                    plyr.armorpoints[0] = 200;
                    plyr.armortype = 2;

                    for (i = 0; i < NUMWEAPONS; i++)
                        plyr.weaponowned[i] = true; // true

                    for (i = 0; i < NUMAMMO; i++)
                        plyr.ammo[i] = plyr.maxammo[i];

                    for (i = 0; i < NUMCARDS; i++)
                        plyr.cards[i] = true;

                    plyr.message = STSTR_KFAADDED;
                }
                // 'mus' cheat for changing music
                else if (cheat_mus.CheckCheat((char) ev.data1)) {

                    char[] buf = new char[3];
                    int musnum;

                    plyr.message = STSTR_MUS;
                    cheat_mus.GetParam(buf);

                    if (DM.isCommercial()) {
                        musnum =
                            musicenum_t.mus_runnin.ordinal() + (buf[0] - '0')
                                    * 10 + buf[1] - '0' - 1;

                        if (((buf[0] - '0') * 10 + buf[1] - '0') > 35)
                            plyr.message = STSTR_NOMUS;
                        else
                        S.ChangeMusic(musnum, true);
                    } else {
                        musnum =
                            musicenum_t.mus_e1m1.ordinal() + (buf[0] - '1') * 9
                                    + (buf[1] - '1');

                        if (((buf[0] - '1') * 9 + buf[1] - '1') > 31)
                            plyr.message = STSTR_NOMUS;
                        else
                       S.ChangeMusic(musnum, true);
                    }
                }
                // Simplified, accepting both "noclip" and "idspispopd".
                // no clipping mode cheat
                else if (cheat_noclip.CheckCheat((char) ev.data1)
                        || cheat_commercial_noclip.CheckCheat((char) ev.data1)) {
                    plyr.cheats ^= CF_NOCLIP;

                    if ((plyr.cheats & CF_NOCLIP) != 0)
                        plyr.message = STSTR_NCON;
                    else
                        plyr.message = STSTR_NCOFF;
                }
                // 'behold?' power-up cheats
                for (i = 0; i < 6; i++) {
                    if (cheat_powerup[i].CheckCheat((char) ev.data1)) {
                        if (plyr.powers[i] == 0)
                           plyr.GivePower(i);
                        else if (i != pw_strength)
                            plyr.powers[i] = 1;
                        else
                            plyr.powers[i] = 0;

                        plyr.message = STSTR_BEHOLDX;
                    }
                }

                // 'behold' power-up menu
                if (cheat_powerup[6].CheckCheat((char) ev.data1)) {
                    plyr.message = STSTR_BEHOLD;
                }
                // 'choppers' invulnerability & chainsaw
                else if (cheat_choppers.CheckCheat((char) ev.data1)) {
                    plyr.weaponowned[weapontype_t.wp_chainsaw.ordinal()] = true;
                    plyr.powers[pw_invulnerability] = 1; // true
                    plyr.message = STSTR_CHOPPERS;
                }
                // 'mypos' for player position
                else if (cheat_mypos.CheckCheat((char) ev.data1)) {
                    // MAES: made into a toggleable cheat.
                   this.st_idmypos=!st_idmypos;
                }
                else if (cheat_tnthom.CheckCheat((char) ev.data1)) {
                    // MAES: made into a toggleable cheat.
                	plyr.message = (DM.flashing_hom = !DM.flashing_hom) ? "HOM Detection On" :
                	    "HOM Detection Off";
                }
            }

            // 'clev' change-level cheat
            if (cheat_clev.CheckCheat((char) ev.data1)) {
                char[] buf = new char[3];
                int epsd;
                int map;

                cheat_clev.GetParam(buf);

                // This applies to Doom II, Plutonia and TNT.
                if (DM.isCommercial())
                		{
                    epsd = 0;
                    map = (buf[0] - '0') * 10 + buf[1] - '0';
                } else {
                    epsd = buf[0] - '0';
                    map = buf[1] - '0';
                }

                // Catch invalid maps.
                if (epsd < 1 && (!DM.isCommercial()))
                    return false;

                if (map < 1)
                    return false;

                // Ohmygod - this is not going to work.
                if (DM.isRetail()
                        && ((epsd > 4) || (map > 9)))
                    return false;

                // MAES: If it's doom.wad but not ultimate
                if (DM.isRegistered()&& !DM.isRetail()
                        && ((epsd > 3) || (map > 9)))
                    return false;

                if (DM.isShareware()
                        && ((epsd > 1) || (map > 9)))
                    return false;

                if (DM.isCommercial()
                        && ((epsd > 1) || (map > 34)))
                    return false;

                // So be it.
                plyr.message = STSTR_CLEV;
                DM.DeferedInitNew(DM.gameskill, epsd, map);
            }
        }
        return false;
    }

    protected int lastcalc;

    protected int oldhealth = -1;

    public int calcPainOffset() {
        int health = 0;

        health = plyr.health[0] > 100 ? 100 : plyr.health[0];

        if (health != oldhealth) {
            lastcalc =
                ST_FACESTRIDE * (((100 - health) * ST_NUMPAINFACES) / 101);
            oldhealth = health;
        }
        return lastcalc;
    }

    protected int lastattackdown = -1;

    protected int priority = 0;

    /**
     * This is a not-very-pretty routine which handles the face states and their
     * timing. the precedence of expressions is: dead > evil grin > turned head
     * > straight ahead
     */
    public void updateFaceWidget() {
        long badguyangle; // angle_t
        long diffang;

        boolean doevilgrin;

        if (priority < 10) {
            // dead
            if (plyr.health[0] == 0) {
                priority = 9;
                st_faceindex[0] = ST_DEADFACE;
                st_facecount = 1;
            }
        }

        if (priority < 9) {
            if (plyr.bonuscount != 0) {
                // picking up bonus
                doevilgrin = false;

                for (int i = 0; i < NUMWEAPONS; i++) {
                    if (oldweaponsowned[i] != plyr.weaponowned[i]) {
                        doevilgrin = true;
                        oldweaponsowned[i] = plyr.weaponowned[i];
                    }
                }
                if (doevilgrin) {
                    // evil grin if just picked up weapon
                    priority = 8;
                    st_facecount = ST_EVILGRINCOUNT;
                    st_faceindex[0] = calcPainOffset() + ST_EVILGRINOFFSET;
                }
            }

        }

        if (priority < 8) {
            if ((plyr.damagecount != 0) && (plyr.attacker != null)
                    && (plyr.attacker != plyr.mo)) {
                // being attacked
                priority = 7;

                if (plyr.health[0] - st_oldhealth > ST_MUCHPAIN) {
                    st_facecount = ST_TURNCOUNT;
                    st_faceindex[0] = calcPainOffset() + ST_OUCHOFFSET;
                } else {
                    badguyangle =
                        R.PointToAngle2(plyr.mo.x, plyr.mo.y, plyr.attacker.x,
                            plyr.attacker.y);
                    boolean obtuse; // that's another "i"

                    if (badguyangle > plyr.mo.angle) {
                        // whether right or left
                        diffang = badguyangle - plyr.mo.angle;
                        obtuse = diffang > ANG180;
                    } else {
                        // whether left or right
                        diffang = plyr.mo.angle - badguyangle;
                        obtuse = diffang <= ANG180;
                    } // confusing, aint it?

                    st_facecount = ST_TURNCOUNT;
                    st_faceindex[0] = calcPainOffset();

                    if (diffang < ANG45) {
                        // head-on
                        st_faceindex[0] += ST_RAMPAGEOFFSET;
                    } else if (obtuse) {
                        // turn face right
                        st_faceindex[0] += ST_TURNOFFSET;
                    } else {
                        // turn face left
                        st_faceindex[0] += ST_TURNOFFSET + 1;
                    }
                }
            }
        }

        if (priority < 7) {
            // getting hurt because of your own damn stupidity
            if (plyr.damagecount != 0) {
                if (plyr.health[0] - st_oldhealth > ST_MUCHPAIN) {
                    priority = 7;
                    st_facecount = ST_TURNCOUNT;
                    st_faceindex[0] = calcPainOffset() + ST_OUCHOFFSET;
                } else {
                    priority = 6;
                    st_facecount = ST_TURNCOUNT;
                    st_faceindex[0] = calcPainOffset() + ST_RAMPAGEOFFSET;
                }

            }

        }

        if (priority < 6) {
            // rapid firing
            if (plyr.attackdown) {
                if (lastattackdown == -1)
                    lastattackdown = ST_RAMPAGEDELAY;
                else if (--lastattackdown == 0) {
                    priority = 5;
                    st_faceindex[0] = calcPainOffset() + ST_RAMPAGEOFFSET;
                    st_facecount = 1;
                    lastattackdown = 1;
                }
            } else
                lastattackdown = -1;

        }

        if (priority < 5) {
            // invulnerability
            if (((plyr.cheats & CF_GODMODE) != 0)
                    || (plyr.powers[pw_invulnerability] != 0)) {
                priority = 4;

                st_faceindex[0] = ST_GODFACE;
                st_facecount = 1;

            }

        }

        // look left or look right if the facecount has timed out
        if (st_facecount == 0) {
            st_faceindex[0] = calcPainOffset() + (st_randomnumber % 3);
            st_facecount = ST_STRAIGHTFACECOUNT;
            priority = 0;
        }

        st_facecount--;

    }

    protected int largeammo = 1994; // means "n/a"

    /**
     * MAES: this code updated the widgets. Now, due to the way they are
     * constructed, they originally were "hooked" to actual variables using
     * pointers so that they could tap into them directly and self-update.
     * Clearly we can't do that in Java unless said variables are inside an
     * array and we provide both the array AND an index. For other cases, we
     * must simply build ad-hoc hacks.
     * 
     * In any case, only "status" updates are performed here. Actual visual
     * updates are performed by the Drawer.
     * 
     */

    public void updateWidgets() {

        int i;

        // MAES: sticky idmypos cheat that is actually useful
        // TODO: this spams the player message queue at every tic.
        // A direct overlay with a widget would be more useful.
        
        if (this.st_idmypos){
            mobj_t mo = DM.players[DM.consoleplayer].mo;
            plyr.message = String.format("ang= 0x%x; x,y= (%x, %x)",
                        (int)mo.angle,mo.x,mo.y);

        }
        

        // must redirect the pointer if the ready weapon has changed.
        // if (w_ready.data != plyr.readyweapon)
        // {
        if (weaponinfo[plyr.readyweapon.ordinal()].ammo == ammotype_t.am_noammo)
            w_ready.numindex = largeammo;
        else
            w_ready.numindex =
                weaponinfo[plyr.readyweapon.ordinal()].ammo.ordinal();

        w_ready.data = plyr.readyweapon.ordinal();

        // if (*w_ready.on)
        // STlib_updateNum(&w_ready, true);
        // refresh weapon change
        // }

        // update keycard multiple widgets
        for (i = 0; i < 3; i++) {
            keyboxes[i] = plyr.cards[i] ? i : -1;

            if (plyr.cards[i + 3])
                keyboxes[i] = i + 3;
        }

        // refresh everything if this is him coming back to life
        updateFaceWidget();

        // used by the w_armsbg widget
        st_notdeathmatch[0] = !DM.deathmatch;

        // used by w_arms[] widgets
        st_armson[0] = st_statusbaron[0] && !(DM.altdeath||DM.deathmatch);

        // used by w_frags widget
        st_fragson[0] = (DM.altdeath||DM.deathmatch) && st_statusbaron[0];
        st_fragscount[0] = 0;

        for (i = 0; i < MAXPLAYERS; i++) {
            if (i != DM.consoleplayer)
                st_fragscount[0] += plyr.frags[i];
            else
                st_fragscount[0] -= plyr.frags[i];
        }

        // get rid of chat window if up because of message
        if (--st_msgcounter == 0)
            st_chat = st_oldchat;

    }

    public void Ticker() {

        st_clock++;
        st_randomnumber = RND.M_Random();
        updateWidgets();
        st_oldhealth = plyr.health[0];

    }

    static int st_palette = 0;

    public void doPaletteStuff() {

        int palette;
        //byte[] pal;
        int cnt;
        int bzc;

        cnt = plyr.damagecount;

        if (plyr.powers[pw_strength] != 0) {
            // slowly fade the berzerk out
            bzc = 12 - (plyr.powers[pw_strength] >> 6);

            if (bzc > cnt)
                cnt = bzc;
        }

        if (cnt != 0) {
            palette = (cnt + 7) >> 3;

            if (palette >= NUMREDPALS)
                palette = NUMREDPALS - 1;

            palette += STARTREDPALS;
        }

        else if (plyr.bonuscount != 0) {
            palette = (plyr.bonuscount + 7) >> 3;

            if (palette >= NUMBONUSPALS)
                palette = NUMBONUSPALS - 1;

            palette += STARTBONUSPALS;
        }

        else if (plyr.powers[pw_ironfeet] > 4 * 32
                || (plyr.powers[pw_ironfeet] & 8) != 0)
            palette = RADIATIONPAL;
        else
            palette = 0;

        if (palette != st_palette) {
            st_palette = palette;
            VI.SetPalette (palette);
        }

    }

    public void drawWidgets(boolean refresh) {
        int i;

        // used by w_arms[] widgets
        st_armson[0] = st_statusbaron[0] && !(DM.altdeath||DM.deathmatch);

        // used by w_frags widget
        st_fragson[0] = DM.deathmatch && st_statusbaron[0];

        w_ready.update(refresh);

        for (i = 0; i < 4; i++) {
            w_ammo[i].update(refresh);
            w_maxammo[i].update(refresh);
        }

        w_health.update(refresh);
        w_armor.update(refresh);

        w_armsbg.update(refresh);

        for (i = 0; i < 6; i++)
            w_arms[i].update(refresh);

        w_faces.update(refresh);

        for (i = 0; i < 3; i++)
            w_keyboxes[i].update(refresh);

        w_frags.update(refresh);

    }

    public void doRefresh() {

        st_firsttime = false;

        // draw status bar background to off-screen buff
        refreshBackground();

        // and refresh all widgets
        drawWidgets(true);

    }

    public void diffDraw() {
        // update all widgets
        drawWidgets(false);
    }

    public void Drawer(boolean fullscreen, boolean refresh) {

        st_statusbaron[0] = (!fullscreen) || DM.automapactive;
        st_firsttime = st_firsttime || refresh;

        // Do red-/gold-shifts from damage/items
        doPaletteStuff();

        // If just after ST_Start(), refresh all
        if (st_firsttime)
            doRefresh();
        // Otherwise, update as little as possible
        else
            diffDraw();

    }

    public void loadGraphics() {

        int i;
        int j;
        int facenum;

        String namebuf;

        // Load the numbers, tall and short
        for (i = 0; i < 10; i++) {
            namebuf = ("STTNUM" + i);
            tallnum[i] = W.CachePatchName(namebuf, PU_STATIC);

            namebuf = ("STYSNUM" + i);
            shortnum[i] = W.CachePatchName(namebuf, PU_STATIC);

        }

        // Load percent key.
        // Note: why not load STMINUS here, too?
        tallpercent = W.CachePatchName("STTPRCNT", PU_STATIC);
        // MAES: in fact, I do this for sanity. Fuck them. Seriously.
        sttminus= W.CachePatchName("STTMINUS");

        // key cards
        for (i = 0; i < NUMCARDS; i++) {
            namebuf = ("STKEYS" + i);
            keys[i] = W.CachePatchName(namebuf, PU_STATIC);
        }

        // arms background
        armsbg = W.CachePatchName("STARMS", PU_STATIC);

        // arms ownership widgets
        for (i = 0; i < 6; i++) {
            namebuf = ("STGNUM" + (i + 2));

            // gray #
            arms[i][0] = W.CachePatchName(namebuf, PU_STATIC);

            // yellow #
            arms[i][1] = shortnum[i + 2];
        }

        // face backgrounds for different color players
        namebuf = ("STFB" + DM.consoleplayer);
        faceback = W.CachePatchName(namebuf, PU_STATIC);

        // status bar background bits
        sbar = W.CachePatchName("STBAR", PU_STATIC);

        // face states
        facenum = 0;
        for (i = 0; i < ST_NUMPAINFACES; i++) {
            for (j = 0; j < ST_NUMSTRAIGHTFACES; j++) {
                namebuf = ("STFST" + (i) + (j));
                faces[facenum++] = W.CachePatchName(namebuf, PU_STATIC);
            }
            namebuf = "STFTR" + i + "0"; // turn right
            faces[facenum++] = W.CachePatchName(namebuf, PU_STATIC);
            namebuf = "STFTL" + i + "0"; // turn left
            faces[facenum++] = W.CachePatchName(namebuf, PU_STATIC);
            namebuf = "STFOUCH" + i; // ouch!
            faces[facenum++] = W.CachePatchName(namebuf, PU_STATIC);
            namebuf = "STFEVL" + i; // evil grin ;)
            faces[facenum++] = W.CachePatchName(namebuf, PU_STATIC);
            namebuf = "STFKILL" + i; // pissed off
            faces[facenum++] = W.CachePatchName(namebuf, PU_STATIC);
        }
        faces[facenum++] = W.CachePatchName("STFGOD0", PU_STATIC);
        faces[facenum++] = W.CachePatchName("STFDEAD0", PU_STATIC);

    }

    public void unloadGraphics() {
    	
          int i; // unload the numbers, tall and short 
          for (i=0;i<10;i++) {
        	  W.UnlockLumpNum(tallnum[i]);
        	  tallnum[i]=null;
        	  W.UnlockLumpNum(shortnum[i]);
        	  shortnum[i]=null;
          }
        
       // unload tall percent
          W.UnlockLumpNum(tallpercent);
          tallpercent=null;
          	
        	  
         // unload arms background          
          W.UnlockLumpNum(armsbg);
          armsbg=null;
         // unload gray #'s          
          for (i=0;i<6;i++) { 
        	  W.UnlockLumpNum(arms[i][0]);
        	  arms[i][0]=null;
        	  W.UnlockLumpNum(arms[i][1]);
        	  arms[i][1]=null;

          }
          
          // unload the key cards for (i=0;i<NUMCARDS;i++)
          
          for (i=0;i<6;i++) { 
        	  W.UnlockLumpNum(keys[i]);
        	  keys[i]=null;
          }
          
          W.UnlockLumpNum(sbar);
          sbar=null;
          
          W.UnlockLumpNum(faceback);
          faceback=null;
          
           for (i=0;i<ST_NUMFACES;i++){
        	   W.UnlockLumpNum(faces[i]);
        	   faces[i]=null;
           	}
         

        // Note: nobody ain't seen no unloading
        // of stminus yet. Dude.

    }

    public void unloadData() {
        unloadGraphics();
    }

    public void initData() {

        int i;

        st_firsttime = true;
        plyr = DM.players[DM.consoleplayer];

        st_clock = 0;
        st_chatstate = st_chatstateenum_t.StartChatState;
        st_gamestate = st_stateenum_t.FirstPersonState;

        st_statusbaron[0] = true;
        st_oldchat = st_chat = false;
        st_cursoron[0] = false;

        st_faceindex[0] = 0;
        st_palette = -1;

        st_oldhealth = -1;

        for (i = 0; i < NUMWEAPONS; i++)
            oldweaponsowned[i] = plyr.weaponowned[i];

        for (i = 0; i < 3; i++)
            keyboxes[i] = -1;

        Init();

    }

    /**
     * Widgets are created here. Be careful, because their "constructors" used
     * reference to boolean or int variables so that they could be auto-updated
     * by the global refresh functions. We can only do this with some
     * limitations in Java (e.g. passing an array AND an index).
     */

    public void createWidgets() {

        int i;

        // ready weapon ammo

        w_ready =
            new st_number_t(ST_AMMOX, ST_AMMOY, tallnum, plyr.ammo,
                    weaponinfo[plyr.readyweapon.ordinal()].ammo.ordinal(),
                    st_statusbaron, 0,ST_AMMOWIDTH);

        // the last weapon type
        w_ready.data = plyr.readyweapon.ordinal();

        // health percentage
        w_health =
            new st_percent_t(ST_HEALTHX, ST_HEALTHY, tallnum, plyr.health,
                    0, st_statusbaron,0, tallpercent);

        // arms background
        w_armsbg =
            new st_binicon_t(ST_ARMSBGX, ST_ARMSBGY, armsbg, st_notdeathmatch,0,
                    st_statusbaron,0);

        // weapons owned
        for (i = 0; i < 6; i++) {
            w_arms[i] =
                new st_multicon_t(ST_ARMSX + (i % 3) * ST_ARMSXSPACE, ST_ARMSY
                        + (i / 3) * ST_ARMSYSPACE, arms[i], plyr.weaponowned,
                        i + 1, st_armson,0);
        }

        // frags sum
        w_frags =
            new st_number_t(ST_FRAGSX, ST_FRAGSY, tallnum, st_fragscount, 0, // dummy,
                                                                             // we're
                                                                             // passing
                                                                             // an
                                                                             // integer.
                    st_fragson,0, ST_FRAGSWIDTH);

        // faces
        w_faces =
            new st_multicon_t(ST_FACESX, ST_FACESY, faces, st_faceindex, 0,
                    st_statusbaron,0);

        // armor percentage - should be colored later
        w_armor =
            new st_percent_t(ST_ARMORX, ST_ARMORY, tallnum, plyr.armorpoints,
                    0, st_statusbaron, 0,tallpercent);

        // keyboxes 0-2
        w_keyboxes[0] =
            new st_multicon_t(ST_KEY0X, ST_KEY0Y, keys, keyboxes, 0,
                    st_statusbaron,0);

        w_keyboxes[1] =
            new st_multicon_t(ST_KEY1X, ST_KEY1Y, keys, keyboxes, 1,
                    st_statusbaron,0);

        w_keyboxes[2] =
            new st_multicon_t(ST_KEY2X, ST_KEY2Y, keys, keyboxes, 2,
                    st_statusbaron,0);

        // ammo count (all four kinds)

        w_ammo[0] =
            new st_number_t(ST_AMMO0X, ST_AMMO0Y, shortnum, plyr.ammo, 0,
                    st_statusbaron,0, ST_AMMO0WIDTH);

        w_ammo[1] =
            new st_number_t(ST_AMMO1X, ST_AMMO1Y, shortnum, plyr.ammo, 1,
                    st_statusbaron,0, ST_AMMO1WIDTH);

        w_ammo[2] =
            new st_number_t(ST_AMMO2X, ST_AMMO2Y, shortnum, plyr.ammo, 2,
                    st_statusbaron,0, ST_AMMO2WIDTH);

        w_ammo[3] =
            new st_number_t(ST_AMMO3X, ST_AMMO3Y, shortnum, plyr.ammo, 3,
                    st_statusbaron,0, ST_AMMO3WIDTH);

        // max ammo count (all four kinds)
        w_maxammo[0] =
            new st_number_t(ST_MAXAMMO0X, ST_MAXAMMO0Y, shortnum, plyr.maxammo,
                    0, st_statusbaron,0, ST_MAXAMMO0WIDTH);

        w_maxammo[1] =
            new st_number_t(ST_MAXAMMO1X, ST_MAXAMMO1Y, shortnum, plyr.maxammo,
                    1, st_statusbaron,0, ST_MAXAMMO1WIDTH);

        w_maxammo[2] =
            new st_number_t(ST_MAXAMMO2X, ST_MAXAMMO2Y, shortnum, plyr.maxammo,
                    2, st_statusbaron,0, ST_MAXAMMO2WIDTH);

        w_maxammo[3] =
            new st_number_t(ST_MAXAMMO3X, ST_MAXAMMO3Y, shortnum, plyr.maxammo,
                    3, st_statusbaron,0, ST_MAXAMMO3WIDTH);

    }

    /** Binary Icon widget 
     *  This is used for stuff such as keys or weapons, which you either have
     *  or you don't.
     * 
     * */

    class st_binicon_t
            implements StatusBarWidget {

        // center-justified location of icon
        int x;

        int y;

        // last icon value
        boolean oldval;

        /** pointer to current icon status */
        boolean[] val;
        int valindex;

        /** pointer to boolean
            stating whether to update icon */
        boolean[] on;
        int onindex;
        
        patch_t p; // icon

        int data; // user data

        // Binary Icon widget routines

        public st_binicon_t(int x, int y, patch_t i, boolean[] val, int valindex, boolean[] on, int onindex) {
            this.x = x;
            this.y = y;
            this.oldval = false;
            this.val = val;
            this.valindex=valindex;
            this.on = on;
            this.onindex=onindex;
            this.p = i;
            this.val[valindex]=false;;
        }

        @Override
        public void update(boolean refresh) {
            st_binicon_t bi = this;
            int x;
            int y;
            int w;
            int h;

            if (bi.on[onindex] && ((bi.oldval != bi.val[valindex]) || refresh)) {
                x = bi.x - bi.p.leftoffset;
                y = bi.y - bi.p.topoffset;
                w = bi.p.width;
                h = bi.p.height;

                if (y - ST_Y < 0)
                    I.Error("updateBinIcon: y - ST_Y < 0");                    
                if (bi.val[valindex])
                    V.DrawScaledPatch(bi.x, bi.y, V_PREDIVIDE|FG,vs, bi.p);
                else
                    V.CopyRect(x/vs.getScalingX(), y/vs.getScalingY() - ST_Y, BG, w*BEST_X_SCALE, h*BEST_Y_SCALE, x, y, FG);

                bi.oldval = bi.val[valindex];
            }

        }

    }

    /** Icon widget */

    class st_multicon_t
            implements StatusBarWidget {

        // center-justified location of icons
        int x;

        int y;

        // last icon number
        int oldinum;

        /** pointer to current icon, if not an array type. */
        int[] iarray;

        int inum;

        // pointer to boolean stating
        // whether to update icon
        boolean[] on;
        int onindex;

        // list of icons
        patch_t[] p;

        // user data
        int data;

        /** special status 0=boolean[] 1=integer[] -1= unspecified */
        int status = -1;

        protected boolean[] asboolean;

        protected int[] asint;

        public st_multicon_t(int x, int y, patch_t[] il, Object iarray,
                int inum, boolean []on,int onindex) {
            this.x = x;
            this.y = y;
            this.oldinum = -1;
            this.inum = inum;
            this.on = on;
            this.p = il;
            if (iarray instanceof boolean[]) {
                status = 0;
                asboolean = (boolean[]) iarray;
            } else 
                if (iarray instanceof int[]){
                    status = 1;
                asint = (int[]) iarray;               
            }  
        }

        @Override
        public void update(boolean refresh) {

            int w;
            int h;
            int x;
            int y;

            // Actual value to be considered. Poor man's generics!
            int thevalue = -1;
            switch (status) {
            case 0:
                thevalue = asboolean[inum] ? 1 : 0;
                break;
            case 1:
                thevalue = asint[inum];
                break;            
            }

            // Unified treatment of boolean and integer references
            // So the widget will update iff:
            // a) It's on AND
            // b) The new value is different than the old one
            // c) Neither of them is -1
            // d) We actually asked for a refresh.
            if (this.on[onindex] && ((this.oldinum != thevalue) || refresh)
                    && (thevalue != -1)) {
            	// Previous value must not have been -1.
                if (this.oldinum != -1) { 
                    x = this.x - this.p[this.oldinum].leftoffset*BEST_X_SCALE;
                    y = this.y - this.p[this.oldinum].topoffset*BEST_Y_SCALE;
                    w = this.p[this.oldinum].width*BEST_X_SCALE;
                    h = this.p[this.oldinum].height*BEST_Y_SCALE;

                    if (y - ST_Y < 0)
                        I.Error("updateMultIcon: y - ST_Y < 0");
                    //System.out.printf("Restoring at x y %d %d w h %d %d\n",x, y - ST_Y,w,h);
                    V.CopyRect(x, y - ST_Y, BG, w, h, x, y, FG);
                    //V.FillRect(x, y - ST_Y, w, h, FG);
                }
                
                //System.out.printf("Drawing at x y %d %d w h %d %d\n",this.x,this.y,p[thevalue].width,p[thevalue].height);
                V.DrawScaledPatch(this.x,this.y, V_SCALEOFFSET|V_NOSCALESTART|FG, vs,this.p[thevalue]);
                
                this.oldinum = thevalue;
            }
        }
    }

    protected patch_t sttminus;

    /** Number widget */

    class st_number_t
            implements StatusBarWidget {

        /** upper right-hand corner of the number (right-justified) */
        int x, y;

        /** max # of digits in number */
        int width;

        /** last number value */
        int oldnum;

        /**
         * Array in which to point with num. 
         * 
         * Fun fact: initially I tried to use Integer and Boolean, but those are
         * immutable -_-. Fuck that, Java.
         * 
         */
        int[] numarray;

        /** pointer to current value. Of course makes sense only for arrays. */
        int numindex;

        /** pointer to boolean stating whether to update number */
        boolean[] on;
        int onindex;

        /** list of patches for 0-9 */
        patch_t[] p;

        /** user data */
        int data;

        // Number widget routines

        public st_number_t(int x, int y, patch_t[] pl, int[] numarray,
                int numindex, boolean[] on,int onindex, int width) {
                init(x, y, pl, numarray, numindex, on,onindex, width);
                    }

        public void init(int x, int y, patch_t[] pl, int[] numarray,int numindex,
                boolean[] on, int onindex, int width) {
            this.x = x;
            this.y = y;
            this.oldnum = 0;
            this.width = width;
            this.numarray = numarray;
            this.on = on;
            this.onindex=onindex;
            this.p = pl;
            this.numindex=numindex; // _D_ fixed this bug
        }

        // 
        // A fairly efficient way to draw a number
        // based on differences from the old number.
        // Note: worth the trouble?
        //
        public void drawNum(boolean refresh) {

            if (this.numindex==largeammo) return;
            
            //st_number_t n = this;
            int numdigits = this.width; // HELL NO. This only worked while the width happened
            							// to be 3.
            int num = ((int[]) this.numarray)[this.numindex];

            int w = this.p[0].width*BEST_X_SCALE;
            int h = this.p[0].height*BEST_Y_SCALE;
            int x = this.x;

            boolean neg;

            // In this way, num and oldnum are exactly the same. Maybe this
            // should go in the end?
            this.oldnum = num;

            neg = num < 0;

            if (neg) {
                if (numdigits == 2 && num < -9)
                    num = -9;
                else if (numdigits == 3 && num < -99)
                    num = -99;

                num = -num;
            }

            // clear the area
            x = this.x - numdigits * w;

            if (this.y - ST_Y < 0) {
                I.Error("drawNum: n.y - ST_Y < 0");
            }

            // Restore BG from buffer
            //V.FillRect(x+(numdigits-3) * w, y, w*3 , h, FG);
            V.CopyRect(x+(numdigits-3)*w, y- ST_Y, BG, w * 3, h, x+(numdigits-3)*w, y, FG);

            // if non-number, do not draw it
            if (num == 1994)
                return;

            x = this.x;

            // in the special case of 0, you draw 0
            if (num == 0)
                //V.DrawPatch(x - w, n.y, FG, n.p[0]);
                V.DrawScaledPatch(x - w, this.y, FG|V_NOSCALESTART|V_TRANSLUCENTPATCH, vs,p[0]);
                
                
            // draw the new number
            while (((num != 0) && (numdigits-- != 0))) {
                x -= w;
                //V.DrawPatch(x, n.y, FG, n.p[num % 10]);
                V.DrawScaledPatch(x, this.y, FG|V_NOSCALESTART|V_TRANSLUCENTPATCH,vs, p[num % 10]);
                num /= 10;
            }

            // draw a minus sign if necessary
            if (neg)
                V.DrawScaledPatch/*DrawPatch*/(x - 8*BEST_X_SCALE, this.y, FG|V_NOSCALESTART|V_TRANSLUCENTPATCH,vs, sttminus);
                //V.DrawPatch(x - sttminus.width*vs.getScalingX(), n.y, FG, sttminus);
        }

        @Override
        public void update(boolean refresh) {
            if (this.on[onindex])
                drawNum(refresh);
        }

    }

    class st_percent_t
            implements StatusBarWidget {

        // Percent widget ("child" of number widget,
        // or, more precisely, contains a number widget.)
        // number information
        st_number_t n;

        // percent sign graphic
        patch_t p;

        public st_percent_t(int x, int y, patch_t[] pl, int[] numarray,
                int numindex, boolean[] on, int onindex, patch_t percent) {
            n = new st_number_t(x, y, pl, numarray, numindex, on,onindex, 3);
            p = percent;
        }

        @Override
        public void update(boolean refresh) {
            if (refresh && this.n.on[0])
                V.DrawScaledPatch(n.x, n.y, V_PREDIVIDE|FG,vs, p);

            n.update(refresh);
        }

    }

    interface StatusBarWidget {
        public void update(boolean refresh);
    }
	
	// Size of statusbar.
	// Now sensitive for scaling.
	public int ST_HEIGHT;
	public int ST_WIDTH;
	public int ST_Y;

////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

	protected int SCREENWIDTH;
	protected int SCREENHEIGHT;
	protected int SAFE_SCALE;
	protected int BEST_X_SCALE;
	protected int BEST_Y_SCALE;
	protected IVideoScale vs;


	@Override
	public void setVideoScale(IVideoScale vs) {
	    this.vs=vs;
	}

	@Override
	public void initScaling() {
	    SCREENHEIGHT=vs.getScreenHeight();
	    SCREENWIDTH=vs.getScreenWidth();
	    SAFE_SCALE=vs.getSafeScaling();
	    BEST_X_SCALE=vs.getScalingX();
	    BEST_Y_SCALE=vs.getScalingY();
	    
	    // Pre-scale stuff.
	    ST_HEIGHT =32*SAFE_SCALE;
	    ST_WIDTH  =SCREENWIDTH;
	    ST_Y      =(SCREENHEIGHT - ST_HEIGHT);
	    ST_X2 = (int) (104*SAFE_SCALE);
	    ST_FX = (int) (143*SAFE_SCALE);
	    ST_FY = (int) (169*SAFE_SCALE);
	    ST_FACESX = (int) (143*SAFE_SCALE);

	    ST_FACESY = (int) (168*SAFE_SCALE);
	    
	     // AMMO number pos.
	     ST_AMMOWIDTH= 3;	    
	     ST_AMMOX = (int) (44*SAFE_SCALE);
	     ST_AMMOY = (int) (171*SAFE_SCALE);

	     // HEALTH number pos
	     ST_HEALTHWIDTH= 3;
	     ST_HEALTHX = (int) (90*SAFE_SCALE);
	     ST_HEALTHY = (int) (171*SAFE_SCALE);

	    // Weapon pos.
	     ST_ARMSX = (int) (111*SAFE_SCALE);
	     ST_ARMSY = (int) (172*SAFE_SCALE);
	     ST_ARMSBGX = (int) (104*SAFE_SCALE);
	     ST_ARMSBGY = (int) (168*SAFE_SCALE);
	     ST_ARMSXSPACE = 12*SAFE_SCALE;;
	     ST_ARMSYSPACE = 10*SAFE_SCALE;;
	     
	     // Frags pos.
	     ST_FRAGSX = (int) (138*SAFE_SCALE);
	     ST_FRAGSY = (int) (171*SAFE_SCALE);
	     ST_FRAGSWIDTH=2;
	     
	     //
	     

	     
	     ST_ARMORX = (int) (221*SAFE_SCALE);

	     ST_ARMORY = (int) (171*SAFE_SCALE);

	     // Key icon positions.
	     ST_KEY0WIDTH = 8*SAFE_SCALE;;
	     ST_KEY0HEIGHT = 5*SAFE_SCALE;;
	     
	     ST_KEY0X = (int) (239*SAFE_SCALE);
	     ST_KEY0Y = (int) (171*SAFE_SCALE);

	     ST_KEY1WIDTH = ST_KEY0WIDTH;
	     ST_KEY1X = (int) (239*SAFE_SCALE);
	     ST_KEY1Y = (int) (181*SAFE_SCALE);

	     ST_KEY2WIDTH = ST_KEY0WIDTH;
	     ST_KEY2X = (int) (239*SAFE_SCALE);
	     ST_KEY2Y = (int) (191*SAFE_SCALE);

	    // Ammunition counter.
	    ST_AMMO0WIDTH = 3*SAFE_SCALE;
	    ST_AMMO0HEIGHT = 6*SAFE_SCALE;

	     ST_AMMO0X = (int) (288*SAFE_SCALE);

	     ST_AMMO0Y = (int) (173*SAFE_SCALE);

	    ST_AMMO1WIDTH = ST_AMMO0WIDTH;

	     ST_AMMO1X = (int) (288*SAFE_SCALE);

	     ST_AMMO1Y = (int) (179*SAFE_SCALE);

	    ST_AMMO2WIDTH = ST_AMMO0WIDTH;

	     ST_AMMO2X = (int) (288*SAFE_SCALE);

	     ST_AMMO2Y = (int) (191*SAFE_SCALE);

	    ST_AMMO3WIDTH = ST_AMMO0WIDTH;

	     ST_AMMO3X = (int) (288*SAFE_SCALE);

	     ST_AMMO3Y = (int) (185*SAFE_SCALE);

	    // Indicate maximum ammunition.
	    // Only needed because backpack exists.
	    ST_MAXAMMO0WIDTH = 3*SAFE_SCALE;
	    ST_MAXAMMO0HEIGHT = 5*SAFE_SCALE;

	     ST_MAXAMMO0X = (int) (314*SAFE_SCALE);
	     ST_MAXAMMO0Y = (int) (173*SAFE_SCALE);

	    ST_MAXAMMO1WIDTH = ST_MAXAMMO0WIDTH;
	    ST_MAXAMMO1X = 314*SAFE_SCALE;
	     ST_MAXAMMO1Y = (int) (179*SAFE_SCALE);

	    ST_MAXAMMO2WIDTH = ST_MAXAMMO0WIDTH;
	     ST_MAXAMMO2X = (int) (314*SAFE_SCALE);
	     ST_MAXAMMO2Y = (int) (191*SAFE_SCALE);

	    ST_MAXAMMO3WIDTH = ST_MAXAMMO0WIDTH;
	     ST_MAXAMMO3X = (int) (314*SAFE_SCALE);
	     ST_MAXAMMO3Y = (int) (185*SAFE_SCALE);

	    // pistol
	     ST_WEAPON0X = (int) (110*SAFE_SCALE);
	     ST_WEAPON0Y = (int) (172*SAFE_SCALE);

	    // shotgun
	     ST_WEAPON1X = (int) (122*SAFE_SCALE);
	     ST_WEAPON1Y = (int) (172*SAFE_SCALE);

	    // chain gun
	     ST_WEAPON2X = (int) (134*SAFE_SCALE);

	     ST_WEAPON2Y = (int) (172*SAFE_SCALE);

	    // missile launcher
	     ST_WEAPON3X = (int) (110*SAFE_SCALE);

	     ST_WEAPON3Y = (int) (181*SAFE_SCALE);

	    // plasma gun
	     ST_WEAPON4X = (int) (122*SAFE_SCALE);

	     ST_WEAPON4Y = (int) (181*SAFE_SCALE);

	    // bfg
	     ST_WEAPON5X = (int) (134*SAFE_SCALE);

	     ST_WEAPON5Y = (int) (181*SAFE_SCALE);

	    // WPNS title
	     ST_WPNSX = (int) (109*SAFE_SCALE);

	     ST_WPNSY = (int) (191*SAFE_SCALE);

	    // DETH title
	     ST_DETHX = (int) (109*SAFE_SCALE);

	     ST_DETHY = (int) (191*SAFE_SCALE);

	    
	}

    @Override
    public int getHeight() {
        return this.ST_HEIGHT;
    }

	
}

//$Log: StatusBar.java,v $
//Revision 1.47  2011/11/01 23:46:37  velktron
//Added TNTHOM cheat.
//
//Revision 1.46  2011/10/23 15:57:08  velktron
//BG reference
//
//Revision 1.45  2011/10/07 16:07:14  velktron
//Now using g.Keys for key input stuff.
//
//Revision 1.44  2011/08/23 16:15:30  velktron
//Got rid of Z remnants.
//
//Revision 1.43  2011/07/28 10:29:46  velktron
//Added hack for forcing full redraw of status bar after help screen drawing.
//
//Revision 1.42  2011/07/22 15:37:16  velktron
//Sticky idmypos cheat
//
//Revision 1.41  2011/06/23 17:17:04  velktron
//Using BG constant.
//
//Revision 1.40  2011/06/13 21:03:48  velktron
//Fixed Ultimate Doom clev bug
//
//Revision 1.39  2011/06/02 14:20:45  velktron
//Implemented unloading code....kind of pointless, really.
//
//Revision 1.38  2011/06/01 18:13:37  velktron
//Fixed idmypos crash.
//
//Revision 1.37  2011/06/01 00:07:26  velktron
//Moved status, fixed soundinterface.
//
//Revision 1.36  2011/05/31 13:32:03  velktron
//Added V_SCALEOFFSET flag to doomguy's mug.
//
//Revision 1.35  2011/05/31 12:39:31  velktron
//Face centering fixed.
//
//Revision 1.34  2011/05/30 15:47:34  velktron
//AbstractStatusBar introduced.
//
//Revision 1.33  2011/05/30 10:34:20  velktron
//Fixed binicon refresh bug...
//
//Revision 1.32  2011/05/30 02:21:08  velktron
//Fixed number widget diffdraw
//
//Revision 1.31  2011/05/29 22:15:32  velktron
//Introduced IRandom interface.
//
//Revision 1.30  2011/05/29 20:54:43  velktron
//Fixed status bar scaling
//
//Revision 1.29  2011/05/24 13:42:22  velktron
//Fidgeting around with the STBar refresh
//
//Revision 1.28  2011/05/24 11:31:23  velktron
//Got rid of a whole bunch of useless interfaces.
//
//Revision 1.27  2011/05/23 16:59:02  velktron
//Migrated to VideoScaleInfo.
//
//Revision 1.26  2011/05/21 15:00:14  velktron
//Adapted to use new gamemode system.
//
//Revision 1.25  2011/05/18 16:57:21  velktron
//Changed to DoomStatus

package st;

// States for the chat code.

enum st_enumstatcodes_t {

	    StartChatState,
	    WaitDestState,
	    GetChatState
	    
	}
package st;

import m.IRandom;
import doom.DoomMain;
import doom.DoomStatus;
import i.DoomVideoInterface;
import i.IDoomSystem;
import rr.Renderer;
import s.IDoomSound;
import v.DoomVideoRenderer;
import v.IVideoScaleAware;
import w.IWadLoader;

public abstract class AbstractStatusBar implements IDoomStatusBar, IVideoScaleAware{

	 // /// STATUS //////////

    protected DoomVideoRenderer<?,?> V;

    protected IWadLoader W;

    protected Renderer<?,?> R;

    protected DoomMain<?,?> DM;

    protected IRandom RND;
    
    protected IDoomSystem I;
    
    protected DoomVideoInterface<?> VI;

    protected IDoomSound S;
    
	@Override
	public void updateStatus(DoomStatus<?,?> DC) {
        this.DM=DC.DM;
        this.V=DC.V;
        this.W=DC.W;
        this.RND=DC.RND;
        this.R= DC.R;
        this.VI=DC.VI;
        this.I=DC.I;
        this.S=DC.S;
    }
	
}

package st;
// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: IDoomStatusBar.java,v 1.4 2012/09/24 17:16:23 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//	Status bar code.
//	Does the face/direction indicator animatin.
//	Does palette indicators as well (red pain/berserk, bright pickup)
//
//-----------------------------------------------------------------------------

import i.DoomStatusAware;
import v.IVideoScaleAware;
import doom.event_t;

public interface IDoomStatusBar extends IVideoScaleAware,DoomStatusAware{

    
    
    /** Points to "screen 4" which is treated as a buffer */
    static final int BG =4;

    /** Points to "screen 0" which is what you actually see */
     static final int FG =0;

    //
    // STATUS BAR
    //

    /** Called by main loop. */
    public boolean Responder (event_t ev);

    /** Called by main loop. */
    public void Ticker ();

    /** Called by main loop.*/
    public void Drawer (boolean fullscreen, boolean refresh);

    /** Called when the console player is spawned on each level. */
    public void Start ();

    /** Called by startup code. */
    public void Init ();

    /** Used externally to determine window scaling. 
     *  This means that drawing transparent status bars is possible, but
     *  it will look fugly because of the solid windowing (and possibly
     *  HOMS).
     */
    public int getHeight();
    
    /** Forces a full refresh for reasons not handled otherwise, e.g. after full-page
     *  draws of help screens, which normally don't trigger a complete redraw even if
     *  they should, really.
     */
    
    void forceRefresh();

}
package st;

//States for status bar code.

public enum st_stateenum_t {

	
		    AutomapState,
	    FirstPersonState
	    
	} 
package tools;

import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;

import rr.line_t;
import data.maplinedef_t;
import data.mapsector_t;
import data.mapsidedef_t;
import data.mapthing_t;
import data.mapvertex_t;
import doom64.MapLights;
import doom64.MapLinedef;
import doom64.MapSector;
import doom64.MapSidedef;
import doom64.MapThing;
import doom64.MapVertex;
import utils.C2JUtils;
import w.*;


public class D64Converter {	    
	    
	    static final String[] MAPS={"MAP01" ,"MAP02","MAP03","MAP04","MAP05",
	    							"MAP06","MAP07","MAP08","MAP09","MAP10",
	    							"MAP11","MAP12","MAP13","MAP14","MAP15",
	    							"MAP16","MAP17","MAP18","MAP19","MAP20",
	    							"MAP21","MAP22","MAP23","MAP24","MAP25",
	    							"MAP26","MAP27","MAP28","MAP29","MAP30",
	    							"MAP31","MAP32","MAP33"};
	    static final String DOOM64="d://doom//iwads//doom64.wad";
	    
	    static final String[] COPY_LUMPS_1={"SEGS","SSECTORS","NODES"};
	    static final String[] COPY_LUMPS_2={"REJECT","BLOCKMAP"};
	    static final String VOID_TEXTURE="-";
	    WadLoader W,WAD64;
	    String[] TEXTURES,FLATS;
	    HashMap<Integer,String> TexHash,FlatHash;

	    /* ResourceManager::getTextureHash
	     * Returns the Doom64 hash of a given texture name, computed using
	     * the same hash algorithm as Doom64 EX itself
	     *******************************************************************/
	    public static int getTextureHash(String name)
	    {
	    	char[] str=new char[8];
	    	
	    	Arrays.fill(str, (char)0);
	    	
	    	 for (int c = 0; c < name.length() && c < 8; c++)
	    		str[c] = name.charAt(c);

	    	long hash = 1315423911;
	    	for(int i = 0; i < 8 && str[i] != '\0'; ++i){
	    		hash ^= ((hash << 5)+ Character.toUpperCase(str[i]) + (hash >> 2));
	    		hash&=0x00FFFFFFFFL;
	    	}
	    	
	    	hash %= 65536;
	    	return (int) hash;
	    }
	    
	    public mapsector_t[] ConvertSectors(int lump, MapLights[] lights) throws IOException
	    {
	        MapSector[] data;
	        mapsector_t[] sectors;
	        MapSector    d64;
	        mapsector_t  doom;
	        
	        
	        int numsectors = WAD64.LumpLength (lump) / MapSector.sizeOf();
	        
	       
	        // Read "mapsectors"
	        data=WAD64.CacheLumpNumIntoArray(lump,numsectors,MapSector.class);
	        sectors = C2JUtils.createArrayOfObjects(mapsector_t.class,numsectors);
	        
	        
	        for (int i=0 ; i<numsectors ; i++)
	        {
	        	d64 = data[i];
	        	doom = sectors[i];
	        	doom.floorheight =d64.floorheight;
	        	doom.ceilingheight = d64.ceilingheight;
	        	doom.floorpic=FlatHash.get(new Integer(d64.floorpic));
	        	doom.ceilingpic=FlatHash.get(new Integer(d64.ceilingpic));
	        	
	        	if (doom.floorpic==null) doom.floorpic=TexHash.get(new Integer(d64.floorpic));
	        	if (doom.floorpic==null) System.err.printf("Warning: Sector %d floorpic hash %d has null mapping!\n",i,(int)d64.floorpic);

	        	if (doom.ceilingpic==null) doom.ceilingpic=TexHash.get(new Integer(d64.ceilingpic));
	        	if (doom.ceilingpic==null) System.err.printf("Warning: Sector %d ceilingpic hash %d has null mapping!\n",i,(int)d64.ceilingpic);
	        	
	        	if(doom.floorpic.equals("?")) doom.floorpic=VOID_TEXTURE;
	        	if(doom.ceilingpic.equals("?")) doom.ceilingpic=VOID_TEXTURE;
	        	
	        	// System.out.printf("Sector %d mapped to %s %s\n",i,dooms.floorpic,dooms.ceilingpic);
	        	doom.lightlevel=lights[d64.thingcolor].greyscaleLightLevel();
	        	//dooms.floorpic = FLATS[d64s.floorpic];
	        	//dooms.ceilingpic = FLATS[d64s.ceilingpic];
	        	//dooms.lightlevel = ms.lightlevel;
	        	doom.special = d64.special;
	        	doom.tag = d64.tag;
	        }
	        
	        return sectors;

	    }
	    
	    /**
	     * P_LoadThings
	   * @throws IOException 
	     */
	    public mapthing_t[] ConvertThings(int lump) throws IOException
	    {
	        MapThing[]       data;
	        mapthing_t[] things;
	        MapThing d64thing;
	        mapthing_t     mt;
	        int         numthings;
     
	        
	        numthings = WAD64.LumpLength (lump) / MapThing.sizeOf();
	        
	        data=WAD64.CacheLumpNumIntoArray(lump,numthings,MapThing.class);
	        things = C2JUtils.createArrayOfObjects(mapthing_t.class,numthings);
	        
	        for (int i=0 ; i<numthings ; i++)   {
	        	mt=things[i];
	        	d64thing=data[i];
	        	mt.x=d64thing.x;
	        	mt.y=d64thing.y;
	        	mt.angle=d64thing.angle;
	        	mt.options=d64thing.flags;
	        	mt.type=d64thing.type;
	        }        
	        
	        return things;
	        
	    }

	    public maplinedef_t[] ConvertLinedefs(int lump) throws IOException
	    {
	        MapLinedef[]       data;
	        maplinedef_t[]       lines;
	        MapLinedef d64l;
	        maplinedef_t   mld;
	        
	        int numlines = WAD64.LumpLength (lump) / MapLinedef.sizeOf();
	        lines = C2JUtils.createArrayOfObjects(maplinedef_t.class,numlines);

	        // read "maplinedefs"
	        data = WAD64.CacheLumpNumIntoArray(lump,numlines,MapLinedef.class);
	        
	        for (int i=0 ; i<numlines ; i++)
	        {
	            d64l=data[i];
	        	mld=lines[i];      	        
	        	
	        	mld.v1=(char) d64l.v1;
	        	mld.v2=(char) d64l.v2;
	        	// TODO: adapt flags
	        	mld.flags = (short) (d64l.flags&0xFFFF);
	        	mld.special = (short) (d64l.special&0xFF);
	        	mld.tag = d64l.tag;
	        	mld.sidenum[0]=(char) d64l.left;
	        	mld.sidenum[1]=(char) d64l.right;
	        	
	        }
	        
	        return lines;	        

	     }
	
	    public mapsidedef_t[] ConvertSidedefs(int lump) throws IOException
	    {
	        MapSidedef[] data;
	        mapsidedef_t[] sides;
	        MapSidedef    d64;
	        mapsidedef_t  doom;	        
	        
	        int numsides = WAD64.LumpLength (lump) / MapSidedef.sizeOf();
	        
	       
	        // Read "mapsectors"
	        data=WAD64.CacheLumpNumIntoArray(lump,numsides,MapSidedef.class);
	        sides = C2JUtils.createArrayOfObjects(mapsidedef_t.class,numsides);
	        
	        
	        for (int i=0 ; i<numsides ; i++)
	        {
	        	d64 = data[i];
	        	doom = sides[i];
	        	doom.textureoffset=d64.xoffset;
	        	doom.rowoffset=d64.yoffset;
	        	doom.sector=d64.sector;
	        	doom.bottomtexture=TexHash.get(new Integer(d64.bottomtexture));
	        	doom.midtexture=TexHash.get(new Integer(d64.midtexture));
	        	doom.toptexture=TexHash.get(new Integer(d64.toptexture));
	        		
        		if (doom.bottomtexture==null)	doom.bottomtexture=FlatHash.get(new Integer(d64.bottomtexture));
	        	if (doom.bottomtexture==null) System.err.printf("Warning: Sidedef %d bottomtexture hash %d has null mapping!\n",i,(int)d64.bottomtexture);
	        	
	        	if (doom.midtexture==null) doom.midtexture=FlatHash.get(new Integer(d64.midtexture));
	        	if (doom.midtexture==null) System.err.printf("Warning: Sidedef %d midtexture hash %d has null mapping!\n",i,(int)d64.midtexture);
	        	
	        	if (doom.toptexture==null) doom.toptexture=FlatHash.get(new Integer(d64.toptexture));
	        	if (doom.toptexture==null) System.err.printf("Warning: Sidedef %d toptexture hash %d has null mapping!\n",i,(int)d64.toptexture);
	        	
	        	if(doom.bottomtexture.equals("?")) doom.bottomtexture=VOID_TEXTURE;
	        	if(doom.midtexture.equals("?")) doom.midtexture=VOID_TEXTURE;
	        	if(doom.toptexture.equals("?")) doom.toptexture=VOID_TEXTURE;
	        	
	        	// System.out.printf("Sidedef %d mapped to %s %s %s\n",i,doom.bottomtexture,doom.midtexture,doom.toptexture);
	        }
	        
	        return sides;

	    }
	    
	    public mapvertex_t[] ConvertVertexes(int lump) throws IOException
	    {
	        MapVertex[] data;
	        mapvertex_t[] vertexes;
	        MapVertex    d64;
	        mapvertex_t  doom;	        
	        
	        int numvertexes = WAD64.LumpLength (lump) / MapVertex.sizeOf();	        
	       
	        data=WAD64.CacheLumpNumIntoArray(lump,numvertexes,MapVertex.class);
	        vertexes = C2JUtils.createArrayOfObjects(mapvertex_t.class,numvertexes);	        
	        
	        for (int i=0 ; i<numvertexes ; i++)
	        {
	        	d64 = data[i];
	        	doom = vertexes[i];
	        	doom.x= (short) (d64.x>>16);
	        	doom.y= (short) (d64.y>>16);
	        }
	        
	        return vertexes;

	    }	    	    
	    
	    
		private MapLights[] ConvertLights(int lump) {
			MapLights[] lights;
			MapLights[] data;
	        
	        int numlights = WAD64.LumpLength (lump) / MapLights.sizeOf();
	        
	        // First 256 lights are auto-generated
	        lights=new MapLights[256+numlights];
	        
	        for (int i=0;i<256;i++){
	        	lights[i]=new MapLights((short) i);	        	
	        }
	        	       
	        // Read extra lights
	        data=WAD64.CacheLumpNumIntoArray(lump,numlights,MapLights.class);
	        
	        for (int i=0;i<numlights;i++)	lights[256+i]=data[i];
	        return lights;
		}
	    
	    
	    public static void main(String[] argv) throws Exception {	    	
	    	D64Converter conv=new D64Converter();
	    	conv.gogogo();
	    }
	    
	    public void gogogo() throws Exception{	    	
		    DataInputStream dis=new DataInputStream(new FileInputStream(DOOM64));
	    
		    W=new WadLoader(DOOM64);
		    
		    System.out.println(W.numlumps);
		    
		    int T_START=W.GetNumForName("T_START");
		    int T_END=W.GetNumForName("T_END");
		    
	    
		    // Find "?" textures. The first texture and the first flat will both be "?"
		    
		    int[] suck_markers=new int[2];
		    int mark=0;
		    
		    for (int lump=T_START+1;lump<T_END;lump++){
		    	if (W.GetNameForNum(lump).equals("?")) suck_markers[mark++]=lump;
		    	if (mark>1) break;
		    }
		    
		    // Can't separate between flats and textures, not enough "?"
		    if (mark<2) return;
		    
		    TEXTURES=new String[suck_markers[1]-suck_markers[0]];
		    FLATS=new String[T_END-suck_markers[1]];
		    
		    TexHash=new HashMap<Integer,String>();
		    FlatHash=new HashMap<Integer,String>();
		    
		    
		    int k=0;
		    for (int lump=suck_markers[0];lump<suck_markers[1];lump++,k++){
		    	TEXTURES[k]=W.GetNameForNum(lump);
		    	System.out.printf("Texture %d %s hash %d\n",k,TEXTURES[k],getTextureHash(TEXTURES[k]));
		    	TexHash.put(getTextureHash(TEXTURES[k]),TEXTURES[k]);
		    }
		    
		    k=0;
		    for (int lump=suck_markers[1];lump<T_END;lump++,k++){
		    	FLATS[k]=W.GetNameForNum(lump);
		    	System.out.printf("Flat %d %s hash %d\n",k,FLATS[k],getTextureHash(FLATS[k]));
		    	FlatHash.put(getTextureHash(FLATS[k]),FLATS[k]);
		    }
		    
		    WadBuilder WB=new WadBuilder("Doom64conv.wad", "PWAD");
		    WB.start();
		    
		    for (String map: MAPS){
		    		System.err.println(map);
	    	
		            byte[] mapdata=W.CacheLumpNameAsRawBytes(map,0);
		            File f=new File(String.format("%s.d64.wad",map));
		            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(f));
		            bos.write(mapdata);
		            bos.close();
		            
		            WAD64=new WadLoader(f.getName());
		            System.out.printf("%s %d\n",f.getName(),WAD64.numlumps);

		            // We have no use for the LEAFS and MACROS nodes, but we do have some use for the LIGHTS node,
		            // since it's the only way to deduct some lighting information.
		            
		            int lump=WAD64.GetNumForName("LIGHTS");
		            MapLights[] lights=ConvertLights(lump);
		            
		            lump=WAD64.GetNumForName("THINGS");
		            mapthing_t[] things=ConvertThings(lump);

		            lump=WAD64.GetNumForName("LINEDEFS");
		            maplinedef_t[] lines=ConvertLinedefs(lump);		            
		            
		            lump=WAD64.GetNumForName("SIDEDEFS");
		            mapsidedef_t[] sides=ConvertSidedefs(lump);
		            
		            ProcessLinesSides(lines,sides);
	            
		            lump=WAD64.GetNumForName("SECTORS");
		            mapsector_t[] sectors=ConvertSectors(lump,lights);
		            
		            lump=WAD64.GetNumForName("VERTEXES");
		            mapvertex_t[] vertexes=ConvertVertexes(lump);
	            
		            WB.add(map);
		            WB.add("THINGS", things);
		            WB.add("LINEDEFS", lines);
		            WB.add("SIDEDEFS", sides);
		            WB.add("VERTEXES", vertexes);
		            
		            // SEGS, SSECTORS and NODES are the same as vanilla
		            WB.add(WAD64,COPY_LUMPS_1);
		            
		            WB.add("SECTORS", sectors);
		            
		            // REJECT and BLOCKMAP are the same as vanilla...
		            WB.add(WAD64,COPY_LUMPS_2);	            
		            }
		    
            	WB.close();
	    }

		private void ProcessLinesSides(maplinedef_t[] lines,
				mapsidedef_t[] sides) {

			for (int k=0;k<lines.length;k++){
				//  Samuel: there's a flag in D64 maps that is "render mid-texture"
				// if that flag is not set but there is a midtexture present, it should be nullified to no texture
				// note that the nullification should only occur on two-sided lines, one-sided lines should be left alone in that regard
				//
				
				if (C2JUtils.flags(lines[k].flags,line_t.ML_TWOSIDED) &&
						!C2JUtils.flags(lines[k].flags,MapLinedef.D64_ML_RENDERMIDDLE)) {
					int front=lines[k].sidenum[0];
					int back=lines[k].sidenum[1];
						
					if(front!=0xFFFF && !sides[front].midtexture.equals(VOID_TEXTURE)){
	        			System.err.printf("Linedef %d Sidedef %d (front) Flags %x Mid %s =>",k,front,lines[k].flags,sides[front].midtexture);
	        			sides[front].midtexture=VOID_TEXTURE;
	        			System.err.printf(" %s\n",sides[front].midtexture);
	        		}
					
					if(back!=0xFFFF && !sides[back].midtexture.equals(VOID_TEXTURE)){
	        			System.err.printf("Linedef %d Sidedef %d (front) Flags %x Mid %s =>",k,back,lines[k].flags,sides[back].midtexture);
	        			sides[back].midtexture=VOID_TEXTURE;
	        			System.err.printf(" %s\n",sides[back].midtexture);
	        		}

					
	        	}

			}
		
		}

}

package v;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferUShort;
import m.BBox;

public class BufferedRenderer32 extends SoftwareVideoRenderer32 {
	
static final String rcsid = "$Id: BufferedRenderer32.java,v 1.4 2016/07/04 07:52:26 velktron Exp $";

/** Buffered Renderer has a bunch of images "pegged" to the underlying arrays */

public BufferedImage[] screenbuffer=new BufferedImage[5];

public BufferedRenderer32(int w, int h) {
    super(w,h);
}

@Override
public final void Init () 
{ 
 int		i;
 for (i=0 ; i<4 ; i++){
	//screens[i] = new byte[this.getHeight()*this.getWidth()];
     this.setScreen(i, this.width, this.height);     
	}
     dirtybox=new BBox();
}

/** This implementation will "tie" a bufferedimage to the underlying byte raster.
 * 
 * NOTE: this relies on the ability to "tap" into a BufferedImage's backing array,
 * in order to have fast writes without setpixel/getpixel. If that is not possible,
 * then we'll need to use a special renderer.
 * 
 */
@Override
public final void setScreen(int index, int width, int height){

	if (screens[index]==null){
		screenbuffer[index]=new BufferedImage(width,height,BufferedImage.TYPE_INT_ARGB);
    
    	screens[index]=((DataBufferInt)screenbuffer[index].getRaster().getDataBuffer()).getData();
		}
}

public void setPalette(int palette){
    this.usepalette=palette%maxpalettes;

    // Invalidate cached graphics, otherwise older colormaps
    // will persist.
    this.clearCaches();

    
    // Tint the current set of colormaps.
    getCachedCmap(palette);

    
	//this.currentpal=palette%maxpalettes;
	this.currentscreen=this.screenbuffer[0];
	
}

@Override
public void setUsegamma(int gamma) {
	this.usegamma=gamma%maxgammas;

   // Invalidate palette cache.
    super.clearPalettes();

	
	// Re-synthesize current palette.
	setPalette(usepalette);
}

public void setCurrentScreen(int screen){
	  super.setCurrentScreen(screen);
	  this.currentscreen=this.screenbuffer[0];
}

@Override
protected final void specificPaletteCreation(byte[] paldata,
        short[][] gammadata, 
        final int palettes, 
        final int colors,
        final int stride,
        final int gammalevels){

      System.out.printf("Enough data for %d palettes",maxpalettes);
      System.out.printf("Enough data for %d gamma levels",maxgammas);
      
      //this.palettes=new int[maxpalettes*maxgammas][];
      this.palettes=new int[maxpalettes][];
      
      // Apply gammas a-posteriori, not a-priori.
      // Initial palette can be neutral or based upon "gamma 0",
      // which is actually a bit biased and distorted
      
      for (int z=0;z<1;z++){
          
          // For each palette
          for (int y=0;y<maxpalettes;y++){
              this.palettes[z*maxpalettes+y]=new int[colors];
              
              for (int x=0;x<colors;x++){
                  int r=gammadata[z][0xFF&paldata[y*colors*stride+stride*x]]; // R
                  int g=gammadata[z][0xFF&paldata[1+y*colors*stride+stride*x]]; // G
                  int b=gammadata[z][0xFF&paldata[2+y*colors*stride+stride*x]]; // B
                  int color=0xFF000000|r<<16|g<<8|b;
                  this.palettes[z*maxpalettes+y][x]=color;
                }
            }
      }
      
      // Set base colormap
      
      cmap_base=PaletteGenerator.RF_BuildLights24(this.palettes[0], NUMLIGHTS);
      cmap_work=PaletteGenerator.RF_BuildLights24(this.palettes[0], NUMLIGHTS);

}

public int getBaseColor(int color){
	return cmap_work[0][color];
}

}

package v;

import doom.ICommandLineManager;
import static utils.C2JUtils.*;

public class VisualSettings {

    /** Default video scale is "triple vanilla: 3 x (320 x 200) */
    public final static IVideoScale vanilla=new VideoScaleInfo(1.0f);
    public final static IVideoScale double_vanilla=new VideoScaleInfo(2.0f);
    public final static IVideoScale triple_vanilla=new VideoScaleInfo(3.0f);
    public final static IVideoScale default_scale=triple_vanilla;
    
    /** Parses the command line for resolution-specific commands, and creates
     *  an appropriate IVideoScale object.
     *  
     * @param CM
     * @return
     */
    
    public final static IVideoScale parse(ICommandLineManager CM){
        
        int width=-1;
        int height=-1;
        
        // -multiply parameter defined from linux doom.
        // It gets priority over all others, if present.
        int p=CM.CheckParm("-multiply");
        if (eval(p)) {            
            try {
                width=Integer.parseInt(CM.getArgv(p+1));
            } catch (NumberFormatException e){
                // We failed. Mark the occasion.
                width=-1;
            }
        }
        
        // If -multiply was successful, trump any others.
        // Implied to be a solid multiple of the vanilla resolution.
        if (width>0 && width<=5) return new VideoScaleInfo(width); 
        
        // Width defined?
        p=CM.CheckParm("-width");
        if (eval(p)) {            
            try {
                width=Integer.parseInt(CM.getArgv(p+1));
            } catch (NumberFormatException e){
                // We failed. Mark the occasion.
                width=-1;
            }
        }
        
        p=CM.CheckParm("-height");
        if (eval(p)) {
            try {
                height=Integer.parseInt(CM.getArgv(p+1));
            } catch (NumberFormatException e){
                // We failed. Mark the occasion.
                height=-1;
            }
        }
    
        // Nothing to do?
        if (height==-1 && width==-1) return default_scale;

        // At least one of them is not a dud.
        int mulx, muly,mulf;
        
        // Break them down to the nearest multiple of the base width or height.
        mulx=Math.round((float)width/IVideoScale.BASE_WIDTH);
        muly=Math.round((float)height/IVideoScale.BASE_HEIGHT);
        
        // Do not accept zero or sub-vanilla resolutions
        if (mulx>0 || muly>0){
        
        // Use the maximum multiplier. We don't support skewed
        // aspect ratios yet.
        mulf=Math.max(mulx,muly);
        if (mulf>=1 && mulf<=5) return new VideoScaleInfo(mulf);
        }
        
        // In all other cases...
        return default_scale;
        
        
        
    }
    
}

package v;

import java.awt.Image;
import java.awt.image.IndexColorModel;
import java.io.IOException;

import rr.patch_t;

/** DoomVideoSystem is now an interface, that all "video drivers" (wheter do screen, disk, etc.)
 *  must implement. 
 *  
 *  23/10/2011: Made into a generic type, which affects the underlying raw screen data
 *  type. This should make -in theory- true colour or super-indexed (>8 bits) video modes
 *  possible. The catch is that everything directly meddling with the renderer must also
 *  be aware of the underlying implementation. E.g. the various screen arrays will not be
 *  necessarily byte[].
 * 
 * @author Maes
 *
 */

public interface DoomVideoRenderer<T,V> extends IVideoScaleAware {
    
    //flags hacked in scrn (not supported by all functions (see src))
    // Added by _D_. Unsure if I should use VSI objects instead, as they
    // already carry scaling information which doesn't need to be repacked...
    public static final int V_NOSCALESTART =      0x010000;   // dont scale x,y, start coords
    public static final int V_SCALESTART        = 0x020000;   // scale x,y, start coords
    public static final int V_SCALEPATCH        = 0x040000;   // scale patch
    public static final int V_NOSCALEPATCH      = 0x080000;   // don't scale patch
    public static final int V_WHITEMAP          = 0x100000;   // draw white (for v_drawstring)    
    public static final int V_FLIPPEDPATCH      = 0x200000;   // flipped in y
    public static final int V_TRANSLUCENTPATCH  = 0x400000;   // draw patch translucent    
    public static final int V_PREDIVIDE  = 0x800000;   // pre-divide by best x/y scale.    
    public static final int V_SCALEOFFSET = 0x1000000; // Scale the patch offset
    
    public static final int SCREEN_FG = 0; // Foreground screen
    public static final int SCREEN_BG= 1; // Used for endlevel/finale BG
    public static final int SCREEN_WS = 2; // Wipe start screen, also used for screenshots
    public static final int SCREEN_WE = 3; // Wipe end screen
    public static final int SCREEN_SB = 4; // Used for status bar
    
    // Allocates buffer screens, call before R_Init.
    public void Init();

    public void CopyRect(int srcx, int srcy, int srcscrn, int width,
            int height, int destx, int desty, int destscrn);
    
    public void FillRect(int srcx, int srcy, int width,
            int height,int destscrn);

    public void DrawPatch(int x, int y, int scrn, patch_t patch);
    
    public void DrawPatchFlipped ( int      x,   int        y,    int       scrn,  patch_t  patch );

    public void DrawPatchDirect(int x, int y, int scrn, patch_t patch);

    /** V_DrawPatch
     * Draws a SOLID (non-masked) patch to the screen with integer scaling
     * m and n.
     * Useful for stuff such as help screens, titlepic and status bar. Not 
     * very useful for menus, though.
     * desttop, dest and source were byte
     */ 

    public void DrawPatchSolidScaled ( int x, int y,int m, int n, int scrn, patch_t patch );
    
    public void DrawPatchSolidScaled ( int x, int y,  int scrn, IVideoScale vs, patch_t patch );
    
    // Draw a linear block of pixels into the view buffer.
    public void DrawBlock(int x, int y, int scrn, int width, int height,
            T src);

    // Draw a linear block of pixels into the view buffer.
    public void DrawBlock(int x, int y, int scrn, int width, int height,
            T src,int offset);
    
    // Reads a linear block of pixels into the view buffer.
    public void GetBlock(int x, int y, int scrn, int width, int height,
            V dest);

    public void MarkRect(int x, int y, int width, int height);

    public V getScreen(int index);
    
    public void setScreen(int index, int width, int height);
    
    public int getUsegamma();    
    
    public void takeScreenShot(int screen, String imagefile, IndexColorModel icm) throws IOException;
    
    public int getWidth();
    
    public int getHeight();
    
    /** Shamelessly ripped from Doom Legacy (for menus, etc) by _D_ ;-)
     * It uses FLAGS (see above) hacked into the scrn parameter, to be
     * parsed afterwards.
     */
    public void DrawScaledPatch(int x, int y, int scrn, IVideoScale VSI,  // hacked flags in it...
            patch_t patch);

    void DrawPatchColScaled(int x,  patch_t patch,int col, IVideoScale vs,
            int screen);
    
    /** Perform any action necessary so that palettes get modified according to specified gamma.
     *  Consider this a TIME CONSUMING operation, so don't call it unless really necessary.
     * 
     * @param gammalevel
     * 
     */
    void setUsegamma(int gammalevel);
    
    /** Perform any action necessary so that the screen output uses the specified palette
     * Consider this a TIME CONSUMING operation, so don't call it unless really necessary.
     * 
     * @param palette
     */
    
    void setPalette(int palette);
    
    
    /** Perform any action necessary so that palettes and gamma tables are created, e.g. by reading
     * from on-disk resources or from somewhere else.
     * 
     */
    void createPalettes(byte[] paldata, short[][] gammadata, final int palettes, final int colors, final int stride,final int gammalevels);
    
    
    /** No matter how complex/weird/arcane palette manipulations you do internally, the AWT module
     *  must always be able to "tap" into what's the current, "correct" screen after all manipulation and
     *  color juju was applied. Call after a palette/gamma change.
     * 
     */
    Image getCurrentScreen();
    
    /** Final call before updating a particular screen. 
     *  In case that e.g. manual palette application or additonal
     *  rendering must be performed on a screen.
     * 
     */
    
    void update();
    
    
    /** Which of the internal screens you want to display next time you call getCurrentScreen
     * 
     * @param screen
     */
    void setCurrentScreen(int screen);

    void FillRect(int color, int screen, int x, int y, int width, int height);
    
    V[] getColorMaps();

    /** Get the value corresponding to a base color (0-255).
     *  Depending on the implementation this might be indexed,
     *  RGB etc. Use whenever you need "absolute" colors.
     * 
     * @return
     */
    int getBaseColor(int color);
    
    /** Clear any byte-to-short or byte-to-int post or flat caches generated 
     *  during e.g. extended color blits or OpenGL acceleration.
     *  
     *  Good moments to call this function include:
     *  *After starting a new level.
     *  *After Menu, Finale, Endlevel screens or Wipers have been deactivated.
     *  *In general, after anything that might use fixed graphics has completed.
     *  
     *  This is necessary because the cache keeps references to 
     */
    
	void clearCaches();
	
	/** Return current palette. Only works for 8-bit renderer, others return null */	
	
	IndexColorModel getPalette();

    
}

package v;

import static data.Defines.RANGECHECK;

import i.DoomStatusAware;
import i.IDoomSystem;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.IndexColorModel;

import doom.DoomStatus;

import m.BBox;
import rr.LightsAndColors;
import rr.patch_t;

public abstract class SoftwareVideoRenderer<T,V>
        implements DoomVideoRenderer<T,V>, IVideoScaleAware, DoomStatusAware{
    
    /** Light levels. Binded to the colormap subsystem */
    public static final int NUMLIGHTS=LightsAndColors.LIGHTLEVELS;
    
    /** Colormap used for static graphics (menu etc.) */
    public static final int CMAP_FIXED=0;

    protected IDoomSystem I;
    protected Image currentscreen;
    
    public Image getCurrentScreen(){
    	return currentscreen;
    }
    
    public final void updateStatus(DoomStatus<?,?> DM){
    	this.I=DM.I;
    }
    
    protected int width;
    protected int height;

    /** Each screen is [SCREENWIDTH*SCREENHEIGHT]; 
     *  This is what the various modules (menu, automap,
     *  renderer etc.) get to manipulate at the pixel
     *  level. To go beyond 8 bit displays, these must be extended */ 
    protected V[]         screens;  
     
    //MAES: maybe this should be a bbox?

    public BBox             dirtybox=new BBox();
    
    /** Colormaps are now part of the base software renderer. This 
     *  allows some flexibility over manipulating them.
     *  
     *  Use base as immutable, use work for applying effects.
     *  
     */
    
    protected V[] cmap_base,cmap_work;
    
    /** PLAYPAL-read palettes, used to build dynamic color maps 
     *  Use [z*maxpalettes+y] form, where z=gamme, y=palette
     * */
    
    protected int[][] palettes;
    
    
    public SoftwareVideoRenderer(){
        // Defaults
        width=SCREENWIDTH;
        height=SCREENHEIGHT;
    }

    public SoftwareVideoRenderer(int w,int h){
        // Defaults
        width=w;
        height=h;
    }
    
    protected int  usegamma=0;
    protected int  usepalette=0;
    protected int maxpalettes;
    protected int maxgammas;
    protected int currentpal;
    protected int currentgamma;
    protected int usescreen=0;
    
    public final int getUsegamma() {
        return usegamma;
    }
    
    /** V_Markrect:
     *  Apparently, video.c had its own "dirtybox" bbox, and this was a crude method for 
     *  expanding it.
     * 
     */
    
    public final void MarkRect ( int      x,  int     y,  int     width,  int     height ) 
    { 
        dirtybox.AddToBox(x, y); 
        dirtybox.AddToBox(x+width-1, y+height-1); 
    } 
    
  /**
   *  V_CopyRect 
   */

  public final void CopyRect (int       srcx,
          int     srcy,
          int     srcscrn,
          int     width,
          int     height,
          int     destx,
          int     desty,
          int     destscrn ) 
  { 
      // These are pointers inside an array.
      final V  src=screens[srcscrn];
      final V  dest=screens[destscrn]; 

      if  (RANGECHECK) {
          if (srcx<0
                  ||srcx+width >this.width
                  || srcy<0
                  || srcy+height>SCREENHEIGHT 
                  ||destx<0||destx+width >this.width
                  || desty<0
                  || desty+height>SCREENHEIGHT 
                  || srcscrn>4
                  || destscrn>4)
          {
              I.Error ("Bad V_CopyRect");
          }
      } 
      this.MarkRect (destx, desty, width, height); 


      // MAES: these were pointers to a specific position inside the screen.
      int srcPos = this.width*srcy+srcx; 
      int destPos = this.width*desty+destx; 

      for ( ; height>0 ; height--) 
      { 
          System.arraycopy(src,srcPos, dest, destPos, width);
          //memcpy (dest, src, width); 
          srcPos += this.width; 
          destPos += this.width; 
      }

  }
   
  protected final boolean doRangeCheck(int x, int y,patch_t patch, int scrn){
    return      (x<0
                  ||x+patch.width >this.width
                  || y<0
                  || y+patch.height>this.height 
                  || scrn>4);
  }

  protected final boolean doRangeCheck(int x, int y, int scrn){
      return      (x<0
                    ||x>this.width
                    || y<0
                    || y>this.height 
                    || scrn>4);
    }

  public void DrawPatchSolidScaled ( int x, int y,  int scrn, IVideoScale vs, patch_t patch ){
      this.DrawPatchSolidScaled(x, y, vs.getScalingX(), vs.getScalingY(),scrn, patch);
  }
  
  public final int getHeight() {
      return this.height;
  } 
  public final int getWidth() {
      return this.width;
  } 
  
  public final void DrawPatchDirect(int x, int y, int scrn, patch_t patch) {
      this.DrawPatch(x, y, scrn, patch);
      
  }

  public final V getScreen(int index) {
     return screens[index];
  }
  /*
  public final boolean isRasterNull(int screen){
      for (int i=0;i<screens[screen].length;i++){
          if (screens[screen][i]!=0) return false;
      }
      return true;
  } */
  
  public void setCurrentScreen(int screen){
	  this.usescreen=screen;
  }
  
  public void update(){
	// Override only if there's something else to be done, e.g. map palette to truecolor buffer  
  }
  
  public void report(BufferedImage[] b){
	    System.out.println("Main video buffer "+screens[0]);
	    for (int i=0;i<b.length;i++){
	    System.out.println(((Object)b[i].getRaster()).toString()+" "+b[i].getRaster().hashCode()+" "+((DataBufferByte)(b[i].getRaster().getDataBuffer())).getData());
	    }
	}
  
////////////////////////////VIDEO SCALE STUFF ////////////////////////////////

  protected int SCREENWIDTH=320;
  protected int SCREENHEIGHT=200;
  protected IVideoScale vs;


  @Override
  public void setVideoScale(IVideoScale vs) {
      this.vs=vs;
  }

  @Override
  public void initScaling() {
      this.SCREENHEIGHT=vs.getScreenHeight();
      this.SCREENWIDTH=vs.getScreenWidth();
  }

  /** Built-in method for recovering from palette disasters.
   * Uses PaletteGenerator class to generate Doom's palettes with only the data of
   * the first palette.
   * 
   */
protected final void paletteRecovery() {
	createPalettes(PaletteGenerator.generatePalette(PaletteGenerator.playpal, 256,ColorTint.tints), GammaTables.gammatables, 14, 256, 3, 5);
	
}

/** Internal method for setting up palettes (and gamma tables)
 * 
 */

public void createPalettes(byte[] paldata, short[][] gammadata, final int palettes, final int colors, final int stride,final int gammalevels){
	
	// Sanity check on supplied data length. If there is not enough data to create the specified palettes,
	// their number will be limited.
	
	if (paldata!=null) 	// As many as are likely contained
		maxpalettes=paldata.length/(colors*stride);
	else
		maxpalettes=0; // Do some default action on null palette.

	if (gammadata!=null) 	// As many as are likely contained
		maxgammas=gammadata.length;
	else
		maxgammas=0; // Do some default action on null gamma tables.
	
	if (maxgammas==0){
		gammadata=GammaTables.gammatables;
		maxgammas=GammaTables.gammatables.length;
	}
	

	// Enough data for all palettes. 
	// Enough data for all palettes. 
	if (maxpalettes>0 && maxgammas>0)
			specificPaletteCreation(paldata,gammadata,palettes,colors,stride,gammalevels);
		 else 
			 paletteRecovery();
    	  
      }
    
/** Override this in extending classes to perform specific actions depending on the
 *  type of renderer. It's better not to assign a default action, nor make assumptions
 *  on the underlying types of actual palettes
 * 
 * @param paldata
 * @param gammadata
 * @param palettes
 * @param colors
 * @param stride
 * @param gammalevels
 */

protected abstract void specificPaletteCreation(byte[] paldata,
		short[][] gammadata, 
		final int palettes, 
		final int colors,
		final int stride,
		final int gammalevels);

protected int lastcolor=-1;
protected byte[] scanline;

public int getBaseColor(int color){
    return color;
}

/** Override if there's something special to do for colormap caches, e.g. during
 *  palette or gamma changes. Not required for indexed.
 */

public void clearCaches(){
    // Does nothing for indexed.
}

/** Should return colormaps, if you ever move their management in here.
 * 
 */

public V[] getColorMaps(){
    return null;
}

public void setColorMaps(V[] colormaps,int num){
    // Dummy
}

public IndexColorModel getPalette(){
    return null;
    }
}

package v;

import static data.Defines.RANGECHECK;

import i.DoomStatusAware;
import i.IDoomSystem;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;

import javax.imageio.ImageIO;

import doom.DoomStatus;

import m.BBox;

import rr.column_t;
import rr.patch_t;
import utils.C2JUtils;

public abstract class SoftwareVideoRenderer16 extends SoftwareVideoRenderer<byte[],short[]> {


	// MAES: maybe this should be a bbox?

	public BBox dirtybox = new BBox();

	public SoftwareVideoRenderer16() {
		// Defaults
	    super();
		screens = new short[5][];
	}

	public SoftwareVideoRenderer16(int w, int h) {
		super(w,h);
		screens = new short[5][];
	}

	/**
	 * V_Fillrect
	 */
	@Override
	public void FillRect(int srcx, int srcy, int width, int height, int destscrn) {
		// These are pointers inside an array.
		final short[] dest = screens[destscrn];

		if (RANGECHECK) {
			if (srcx < 0 || srcx + width > this.width || srcy < 0
					|| srcy + height > SCREENHEIGHT || destscrn > 4) {
				I.Error("Bad V_FillRect");
			}
		}
		this.MarkRect(srcx, srcy, width, height);

		// MAES: these were pointers to a specific position inside the screen.
		int srcPos = this.width * srcy + srcx;

		for (; height > 0; height--) {
			for (int i = 0; i < width; i++) {
				dest[srcPos + i] = 0;
			}
			// memcpy (dest, src, width);
			srcPos += this.width;
		}

	}

	/**
	 * V_DrawPatch Masks a column based masked pic to the screen. desttop, dest
	 * and source were byte*
	 */

	public final void DrawPatch(int x, int y, int scrn, patch_t patch) {

		column_t column;
		int desttop;
		final short[] dest = screens[scrn];
		int w;

		y -= patch.topoffset;
		x -= patch.leftoffset;
		if (RANGECHECK)
			if (doRangeCheck(x, y, patch, scrn)) {
				System.err.print("Patch at " + x + "," + y + " exceeds LFB\n");
				// No I_Error abort - what is up with TNT.WAD?
				System.err.print("V_DrawPatch: bad patch (ignored)\n");
				return;
			}

		if (scrn == 0)
			this.MarkRect(x, y, patch.width, patch.height);

		w = patch.width;
		desttop = x + this.width * y;
		// For each column..
		int destPos;
		int ptr = 0;
		for (int col = 0; col < w; desttop++, col++, x++) {
			// This points at a "column" object.
			// column = (column_t *)((byte *)patch +
			// LONG(patch->columnofs[col]));
			column = patch.columns[col];
			final short[] data=getShortVersion(column.data);
			// For each post...
			for (int i = 0; i < column.posts; i++) {
				// Get pointer to post offset.
				ptr = column.postofs[i];
				// Get post delta
				short delta = column.postdeltas[i];
				// We skip delta, len and padding.
				// ptr+=3; NOT NEEDED< pre-skipped at parsing.

				// Skip transparent rows...
				if (delta == 0xFF)
					break;

				destPos = desttop + delta * this.width;

				// These lengths are already correct.
				for (int j = 0; j < column.postlen[i]; j++) {
					dest[destPos] = data[ptr++];
					destPos += this.width;
				}
			}
		}

	}

	/**
	 * V_DrawPatchSolidScaled Draws a SOLID (non-masked) patch to the screen
	 * with integer scaling m and n. Useful for stuff such as help screens,
	 * titlepic and status bar. Not very useful for menus, though. desttop, dest
	 * and source were byte
	 */

	public final void DrawPatchSolidScaled(int x, int y, int m, int n,
			int scrn, patch_t patch) {

		if ((m == 1) && (n == 1)) {
			DrawPatch(x, y, scrn, patch);
			return;
		}

		column_t column;
		short[] data;
		int desttop;
		final short[] dest = screens[scrn];
		int w;

		y = y * n - patch.topoffset;
		x = x * m - patch.leftoffset;
		if (RANGECHECK)
			if (doRangeCheck(x, y, patch, scrn)) {
				System.err.print("Patch at " + x + "," + y + " exceeds LFB\n");
				// No I_Error abort - what is up with TNT.WAD?
				System.err.print("V_DrawPatch: bad patch (ignored)\n");
				return;
			}

		if (scrn == 0)
			this.MarkRect(x, y, patch.width, patch.height);

		w = patch.width;
		desttop = m * x + this.width * y;
		// For each column..
		int destPos;
		int ptr = 0;
		// x increases by m.

		// Some unrolling...

		if (m == 2) {
			// desttop=2*desttop;
			for (int col = 0; col < w; desttop += 2, col++)

			{

				// This points at a "column" object.
				// column = (column_t *)((byte *)patch +
				// LONG(patch->columnofs[col]));
				column = patch.columns[col];
				data=this.getShortVersion(column.data);
				
				// For each post...
				for (int i = 0; i < column.posts; i++) {
					// Get pointer to post offset.
					ptr = column.postofs[i];
					// Get post delta
					short delta = column.postdeltas[i];
					// We skip delta, len and padding.
					// ptr+=3;

					// Skip transparent rows...
					if (delta == 0xFF)
						break;

					destPos = desttop + n * delta * this.width;

					// These lengths are already correct.
					for (int j = 0; j < column.postlen[i]; j++) {
						dest[destPos] = data[ptr++];
						dest[destPos + 1] = dest[destPos];
						destPos += n * this.width;
					}
				}
			}
		} else if (m == 3) {
			// desttop=3*desttop;
			for (int col = 0; col < w; desttop += 3, col++)

			{

				column = patch.columns[col];
				data=this.getShortVersion(column.data);
				
				// For each post...
				for (int i = 0; i < column.posts; i++) {
					// Get pointer to post offset.
					ptr = column.postofs[i];
					// Get post delta
					short delta = column.postdeltas[i];
					// We skip delta, len and padding.
					// ptr+=3;

					// Skip transparent rows...
					if (delta == 0xFF)
						break;

					destPos = desttop + n * delta * this.width;

					// These lengths are already correct.
					for (int j = 0; j < column.postlen[i]; j++) {
						dest[destPos] = data[ptr++];
						dest[destPos + 1] = dest[destPos];
						dest[destPos + 2] = dest[destPos];
						destPos += n * this.width;
					}

				}
			}
		} else if (m == 4) {
			// desttop=4*desttop;
			for (int col = 0; col < w; desttop += 4, col++)

			{

				column = patch.columns[col];
				data=this.getShortVersion(column.data);
				
				// For each post...
				for (int i = 0; i < column.posts; i++) {
					// Get pointer to post offset.
					ptr = column.postofs[i];
					// Get post delta
					short delta = column.postdeltas[i];
					// We skip delta, len and padding.
					// ptr+=3;

					// Skip transparent rows...
					if (delta == 0xFF)
						break;

					destPos = desttop + n * delta * this.width;

					// These lengths are already correct.
					for (int j = 0; j < column.postlen[i]; j++) {
						dest[destPos] = data[ptr++];
						dest[destPos + 1] = dest[destPos];
						dest[destPos + 2] = dest[destPos];
						dest[destPos + 3] = dest[destPos];
						destPos += n * this.width;
					}
				}
			}
		} else {
			// desttop=m*desttop;
			for (int col = 0; col < w; desttop += m, col++)

			{

				// This points at a "column" object.
				// column = (column_t *)((byte *)patch +
				// LONG(patch->columnofs[col]));
				column = patch.columns[col];
				// For each post...
				for (int i = 0; i < column.posts; i++) {
					// Get pointer to post offset.
					ptr = column.postofs[i];
					// Get post delta
					short delta = column.postdeltas[i];
					// We skip delta, len and padding.
					// ptr+=3;

					// Skip transparent rows...
					if (delta == 0xFF)
						break;

					destPos = desttop + n * delta * this.width;

					// These lengths are already correct.
					for (int j = 0; j < column.postlen[i]; j++) {
						for (int k = 0; k < m; k++)
							dest[destPos + k] = column.data[ptr];
						ptr++;
						destPos += n * this.width;
					}
				}
			}

		}

		scaleSolid(m, n, scrn, m * patch.width);
	}

	/**
	 * Pretty crude in-place scaling. It's fast, but only works full-screen
	 * Width needs to be specific, height is implied.
	 * */

	protected final void scaleSolid(int m, int n, int screen, int width) {
		int height = screens[screen].length / width;
		for (int i = 0; i < height; i += n) {

			for (int j = 0; j < n - 1; j++) {

				System.arraycopy(screens[screen], (i + j) * width,
						screens[screen], (i + j + 1) * width, width);
			}
		}

	}

	/**
	 * V_DrawPatchFlipped Masks a column based masked pic to the screen. Flips
	 * horizontally, e.g. to mirror face.
	 * 
	 * Currently UNUSED, as any occurence to it is also scaled and best served
	 * by another function.
	 * 
	 * 
	 */

	public final void DrawPatchFlipped(int x, int y, int scrn, patch_t patch) {

		column_t column;
		int desttop;
		short[] dest = screens[scrn];
		int w;

		y -= patch.topoffset;
		x -= patch.leftoffset;

		if (RANGECHECK)
			if (doRangeCheck(x, y, patch, scrn)) {
				{
					System.err.print("Patch origin " + x + "," + y
							+ " exceeds LFB\n");
					// No I_Error abort - what is up with TNT.WAD?
					I.Error("Bad V_DrawPatch in V_DrawPatchFlipped");
				}
			}

		if (scrn == 0)
			this.MarkRect(x, y, patch.width, patch.height);

		// Set x and y coords inside dest array.

		w = patch.width;
		desttop = y * this.width + x;
		// For each column..
		for (int col = 0; col < w; desttop++, col++) {

			// This points at a "column" object.
			// Notice the flipping on this one.
			// column = (column_t *)((byte *)patch +
			// LONG(patch->columnofs[w-1-col]));
			column = patch.columns[w - 1 - col];

			// For each post...
			// System.out.println("Column"+(w-1-col));
			for (int i = 0; i < column.posts; i++) {
				// Get pointer to post offset.
				int ptr = column.postofs[i];
				// Get post delta
				int delta = 0xFF & column.data[ptr];
				// We skip delta, len and padding.
				// ptr+=3;
				if (delta == 0xFF)
					break;
				int destPos = desttop + delta * this.width;
				// count = column.length;

				// These lengths are already correct.
				for (int j = 0; j < column.postlen[i]; j++, destPos += this.width) {
					dest[destPos] = column.data[ptr + j];
					// next line

				}
			}
		}

	}

	/**
	 * V_DrawScaledPatch like V_DrawPatch, but scaled 2,3,4 times the original
	 * size and position this is used for menu and title screens, with high
	 * resolutions
	 * 
	 * added:05-02-98: default params : scale patch and scale start
	 * 
	 * Iniially implemented for Mocha Doom by _D_ (shamelessly ripped from
	 * Eternity Engine ;-), adapted to scale based on a scaling info object
	 * (VSI).
	 * 
	 * Unless overriden by flags, starting x and y are automatically scaled
	 * (implied V_SCALESTART)
	 * 
	 */
	@Override
	public void DrawScaledPatch(int x, int y, int scrn, IVideoScale VSI,
			patch_t patch) {
		int col;
		column_t column;
		int desttop;
		final short[] dest = screens[scrn & 0xFF];
		// byte[] source;

		int dupx, dupy;
		int colfrac, rowfrac;

		// System.out.printf("V_DrawScaledPatch %d %d \n",x,y);
		// draw an hardware converted patch
		/*
		 * #ifdef HWRENDER if (rendermode != render_soft) {
		 * HWR_DrawPatch((GlidePatch_t *) patch, x, y, scrn); return; } #endif
		 */

		// A very common operation, eliminates the need to pre-divide.
		if (C2JUtils.flags(scrn, V_PREDIVIDE)) {
			x /= vs.getScalingX();
			y /= vs.getScalingY();
		}

		if (C2JUtils.flags(scrn, V_NOSCALEPATCH))
			dupx = dupy = 1;
		else {
			dupx = VSI.getScalingX();
			dupy = VSI.getScalingY();
		}

		// Eliminates.
		// MAES: added this fix so that non-zero patch offsets can be
		// taken into account, regardless of whether we use pre-scaled
		// coords or not. Only Doomguy's face needs this hack for now.

		if (C2JUtils.flags(scrn, V_SCALEOFFSET)) {
			y -= patch.topoffset * dupx;
			x -= patch.leftoffset * dupy;
		} else {
			y -= patch.topoffset;
			x -= patch.leftoffset;
		}

		colfrac = dupx;
		rowfrac = dupy;

		// desttop = screens[scrn & 0xFF];
		if (C2JUtils.flags(scrn, V_NOSCALESTART))
			desttop = (y * this.width) + x;
		else
			desttop = (y * dupy * this.width) + (x * dupx) /* + scaledofs */;
		// destend = desttop + /*SHORT(*/patch.width/*)*/ * dupx;

		int w = patch.width * dupx;

		int colInc = 1;
		col = 0;
		if (C2JUtils.flags(scrn, V_FLIPPEDPATCH)) {
			colInc = -1;
			col = w - 1;// (/*SHORT(*/patch.width/*)*/ << fixed_t.FRACBITS) +
						// colfrac;
		}

		for (; col >= 0 && col < w/* ; desttop < destend */; col += colInc, desttop++) {
			// column = (column_t *) ((byte *) patch + LONG(patch.columnofs[col
			// >> FRACBITS]));
			column = patch.columns[col / colfrac];
			final short[] data=getShortVersion(column.data);

			int destPos;
			int ptr = 0;
			int ptrOfs;

			// while (column.topdelta != 0xff)
			for (int i = 0; i < column.posts; i++) {
				{
					ptrOfs = column.postofs[i];// +3;
					ptr = 0;
					short delta = column.postdeltas[i];

					// Skip transparent rows...
					if (delta == 0xFF)
						break;

					destPos = desttop + delta * dupy * this.width;
					// dest = desttop + column.topdelta * dupy * this.width;

					// ofs = 0;
					// while (count-- > 0)
					for (int j = 0; j < column.postlen[i] * dupy; j++) {
						dest[destPos] = data[ptrOfs + ptr / rowfrac];
						destPos += this.width;

						ptr++;
						// ofs += rowfrac;
					}

					// column = (column_t *) ((byte *) column + column.length +
					// 4);
				}
			}
		}
	}

	@Override
	public final void DrawBlock(int x, int y, int scrn, int width, int height,
			byte[] src) {
		DrawBlock(x,y,scrn,width,height,src,0);
	}

	@Override
	public final void DrawBlock(int x, int y, int scrn, int width, int height,
			byte[] src,int offset) {
		// This is "screens[scrn]"
		final short[] dest = screens[scrn];
		final short[] data=getShortVersion(src);
		
		if (doRangeCheck(x, y, scrn)) {
			I.Error("Bad V_DrawBlock");
		}

		this.MarkRect(x, y, width, height);

		int destPos = /* screens[scrn] + */y * this.width + x;
		// MAES: making an assumption here. A BIIIIG one.
		int srcPos = offset;
		while ((height--) > 0) {
			// A real dog. It's good that this ain't used
			// so often.
			for (int xx=0;xx<width;xx++)
				dest[destPos+xx]=data[srcPos+xx];
				//System.arraycopy(src, srcPos, dest, destPos, width);
			srcPos += width;
			destPos += this.width;
		}
	}
	

	/**
	 * Replaces DrawPatchCol for bunny scrolled in Finale.
	 * 
	 * 
	 */

	@Override
	public final void DrawPatchColScaled(int x, patch_t patch, int col,
			IVideoScale vs, int screen) {
		column_t column;
		int source;
		final short[] dest;
		final short[] data;
		int desttop;
		final int scale = vs.getScalingX();

		column = patch.columns[col];
		data=this.getShortVersion(column.data);
		desttop = x * scale; // Scale X position.
		dest = screens[screen];
		// step through the posts in a column

		for (int i = 0; i < column.posts; i++) {
			// Get pointer to post offset.
			source = column.postofs[i];
			// Get post delta
			short delta = column.postdeltas[i];
			// We skip delta, len and padding.
			// source+=3; NOT NEEDED ANYMORE, skipped by parsing.

			// Skip transparent rows...
			if (delta == 0xFF)
				break;

			// Replicate each column scale times vertically,
			// with spaced pixels.
			final int startsource = source;
			for (int kl = 0; kl < scale; kl++) {
				int destPos = desttop + (delta + kl) * SCREENWIDTH;
				for (int j = 0; j < column.postlen[i]; j++) {
					final short datap = data[source++];
					// replicate each column's pixel horizontally and
					// vertically.
					for (int k = 0; k < scale; k++)
						dest[destPos + k] = datap;
					destPos += scale * SCREENWIDTH;
				}
				source = startsource;
			}
		}
	}

	public void setScreen(int index, int width, int height) {
		this.screens[index] = new short[width * height];
	}

	public final void takeScreenShot(int screen, String imagefile,
			IndexColorModel icm) throws IOException {

		BufferedImage b = new BufferedImage(this.getWidth(), this.getHeight(),
				BufferedImage.TYPE_BYTE_INDEXED, icm);

		int[] tmp = new int[this.screens[screen].length];
		for (int i = 0; i < this.screens[screen].length; i++) {
			tmp[i] = this.screens[screen][i];
		}

		b.getRaster().setPixels(0, 0, this.getWidth(), this.getHeight(), tmp);

		File outputFile = new File(imagefile + ".png");
		ImageIO.write(b, "PNG", outputFile);

	}

	
	/** Internal method for setting up palettes (and gamma tables)
	 * 
	 */

	public void createPalettes(byte[] paldata, short[][] gammadata, final int palettes, final int colors, final int stride,final int gammalevels){
	    
	    // Sanity check on supplied data length. If there is not enough data to create the specified palettes,
	    // their number will be limited.
	    
	    if (paldata!=null)  // As many as are likely contained
	        maxpalettes=paldata.length/(colors*stride);
	    else
	        maxpalettes=0; // Do some default action on null palette.

	    if (gammadata!=null)    // As many as are likely contained
	        maxgammas=gammadata.length;
	    else
	        maxgammas=0; // Do some default action on null gamma tables.
	    
	    if (maxgammas==0){
	        gammadata=GammaTables.gammatables;
	        maxgammas=GammaTables.gammatables.length;
	    }
	    

	    // Enough data for all palettes. 
	    // Enough data for all palettes. 
	    if (maxpalettes>0 && maxgammas>0)
	            specificPaletteCreation(paldata,gammadata,palettes,colors,stride,gammalevels);
	         else 
	             paletteRecovery();
	          
	      }
	
	/** Override this in extending classes to perform specific actions depending on the
	 *  type of renderer. It's better not to assign a default action, nor make assumptions
	 *  on the underlying types of actual palettes
	 * 
	 * @param paldata
	 * @param gammadata
	 * @param palettes
	 * @param colors
	 * @param stride
	 * @param gammalevels
	 */

	protected abstract void specificPaletteCreation(byte[] paldata,
	        short[][] gammadata, 
	        final int palettes, 
	        final int colors,
	        final int stride,
	        final int gammalevels);
	
	
	/**
	 * Clear automap frame buffer or fill solid color
	 * MAES: optimized for efficiency, seen the lack of a proper "memset" in Java.
	 * 
	 */

	@Override
	public final void FillRect(int color, int screen, int x, int y, int width,
			int height) {
		short[] arr = screens[screen];

		// Do a "per scanline" copy.
		int fromIndex = x + y * SCREENWIDTH;
		int toIndex = x + (y + height - 1) * SCREENWIDTH;

		final short c=(short) getBaseColor(color);
		
		// First scanline.
		for (int i = 0; i < width; i++)
			arr[fromIndex + i] = c;

		for (; fromIndex < toIndex; fromIndex += SCREENWIDTH) {
			System.arraycopy(arr, fromIndex, arr, fromIndex + SCREENWIDTH,
					width);
		}
	}

	public final void GetBlock(int x, int y, int scrn, int width, int height,
			short[] dest) {
		final short[] src = screens[scrn];

		if (RANGECHECK) {
			if (doRangeCheck(x, y, scrn)) {
				I.Error("Bad V_DrawBlock");
			}

		}
		int srcPos = y * this.width + x;
		int destPos = 0;

		while ((height--) > 0) {
			System.arraycopy(src, srcPos, dest, destPos, width);
			// memcpy (dest, src, width);
			srcPos += width;
			destPos += this.width;
		}
	}
	
	public final void setColorMaps(short[] stuff, int num){
		// For HiCOlor, load COLORS15 lump

		this.cmap_base=new short[num][256];		
		this.cmap_work=new short[num][256];       
		
		for (int i = 0; i < cmap_base.length; i++) {
			System.arraycopy(stuff, i * 256, cmap_base[i], 0, 256);
			System.arraycopy(stuff, i * 256, cmap_work[i], 0, 256);
		}
	}
	
	public final void setColorMaps(int[] stuff, int num){
		// For HiCOlor, load COLORS15 lump

        this.cmap_base=new short[num][256];     
        this.cmap_work=new short[num][256];    
		
		for (int i = 0; i < cmap_base.length; i++) {
			for (int j=0;j<256;j++){
			    cmap_base[i][j]=PaletteGenerator.rgb888to555(stuff[i*256+j]);
			    cmap_work[i][j]=cmap_base[i][j];
			}
		}
	}
	
	public short[][] getColorMaps(){
		return cmap_work;
	}
	
	///// MEGA HACK FOR SUPER-8BIT MODES
	
	private final HashMap<Integer,short[]> colcache=new HashMap<Integer,short[]>();
	
	private final short[] getShortVersion(byte[] data){
		if (!colcache.containsKey(data.hashCode())){
			//System.out.printf("Generated cache for %d\n",data.hashCode());
			short[] stuff=new short[data.length];
			for (int i=0;i<stuff.length;i++){
				stuff[i]=cmap_work[CMAP_FIXED][0xFF&data[i]];
			}
			colcache.put(data.hashCode(),stuff);
			
		}
		return colcache.get(data.hashCode());
		
	}
	
	@Override
	public final void clearCaches(){
		this.colcache.clear();
	}
	
	///// MODIFIED COLORMAP CACHING //////////
	
	private final HashMap<Integer,short[][]> cmapcache=new HashMap<Integer,short[][]>();
	
	/** Cache colormaps in order to avoid expensive re-computations 
	 *  Invalidate if gamma is changed. Changes are applied on-the-fly
	 *  to working_colormap.
	 * 
	 * */
	
	   protected final void getCachedCmap(int palette){
	       
	        short[][] stuff=cmapcache.get(palette);	       
	        
	        if (stuff==null){
	            // Generate the full range of colormap for a given palette effect	            
	            
	            //stuff=
	            //PaletteGenerator.RF_BuildLights15(palettes[usegamma*maxpalettes+usepalette], NUMLIGHTS);

	            // Tinting more faithful to the original, thanks to Sodaholic's input.
                stuff=new short[cmap_base.length][cmap_base[0].length];
                for (int i = 0; i < stuff.length; i++) { 
                  PaletteGenerator.tintColormap(cmap_base[i], stuff[i], 256, ColorTint.tints[palette%14],GammaTables.gammatables[usegamma]);
                }
                  

	            cmapcache.put(palette,stuff);	            
	        }
	        
	        // Use fast arraycopy to copy data to working colormap.
	        for (int i = 0; i < stuff.length; i++) {
	            System.arraycopy(stuff[i], 0, cmap_work[i], 0, 256);
	        }	        
	    }
	   
	    protected final void clearPalettes(){
	        this.cmapcache.clear();
	    }
	
}

package v;

import static data.Defines.RANGECHECK;

import i.DoomStatusAware;
import i.IDoomSystem;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;

import javax.imageio.ImageIO;

import doom.DoomStatus;

import m.BBox;

import rr.column_t;
import rr.patch_t;
import utils.C2JUtils;

public abstract class SoftwareVideoRenderer32 extends SoftwareVideoRenderer<byte[],int[]> {

    // MAES: maybe this should be a bbox?

    public BBox dirtybox = new BBox();

    public SoftwareVideoRenderer32() {
        // Defaults
        super();
        screens = new int[5][];
    }

    public SoftwareVideoRenderer32(int w, int h) {
        super(w,h);
        screens = new int[5][];
    }

    /**
     * V_Fillrect
     */
    @Override
    public void FillRect(int srcx, int srcy, int width, int height, int destscrn) {
        // These are pointers inside an array.
        final int[] dest = screens[destscrn];

        if (RANGECHECK) {
            if (srcx < 0 || srcx + width > this.width || srcy < 0
                    || srcy + height > SCREENHEIGHT || destscrn > 4) {
                I.Error("Bad V_FillRect");
            }
        }
        this.MarkRect(srcx, srcy, width, height);

        // MAES: these were pointers to a specific position inside the screen.
        int srcPos = this.width * srcy + srcx;

        for (; height > 0; height--) {
            for (int i = 0; i < width; i++) {
                dest[srcPos + i] = 0;
            }
            // memcpy (dest, src, width);
            srcPos += this.width;
        }

    }

    /**
     * V_DrawPatch Masks a column based masked pic to the screen. desttop, dest
     * and source were byte*
     */

    public final void DrawPatch(int x, int y, int scrn, patch_t patch) {

        column_t column;
        int desttop;
        final int[] dest = screens[scrn];
        int w;

        y -= patch.topoffset;
        x -= patch.leftoffset;
        if (RANGECHECK)
            if (doRangeCheck(x, y, patch, scrn)) {
                System.err.print("Patch at " + x + "," + y + " exceeds LFB\n");
                // No I_Error abort - what is up with TNT.WAD?
                System.err.print("V_DrawPatch: bad patch (ignored)\n");
                return;
            }

        if (scrn == 0)
            this.MarkRect(x, y, patch.width, patch.height);

        w = patch.width;
        desttop = x + this.width * y;
        // For each column..
        int destPos;
        int ptr = 0;
        for (int col = 0; col < w; desttop++, col++, x++) {
            // This points at a "column" object.
            // column = (column_t *)((byte *)patch +
            // LONG(patch->columnofs[col]));
            column = patch.columns[col];
            final int[] data=getShortVersion(column.data);
            // For each post...
            for (int i = 0; i < column.posts; i++) {
                // Get pointer to post offset.
                ptr = column.postofs[i];
                // Get post delta
                short delta = column.postdeltas[i];
                // We skip delta, len and padding.
                // ptr+=3; NOT NEEDED< pre-skipped at parsing.

                // Skip transparent rows...
                if (delta == 0xFF)
                    break;

                destPos = desttop + delta * this.width;

                // These lengths are already correct.
                for (int j = 0; j < column.postlen[i]; j++) {
                    dest[destPos] = data[ptr++];
                    destPos += this.width;
                }
            }
        }

    }

    /**
     * V_DrawPatchSolidScaled Draws a SOLID (non-masked) patch to the screen
     * with integer scaling m and n. Useful for stuff such as help screens,
     * titlepic and status bar. Not very useful for menus, though. desttop, dest
     * and source were byte
     */

    public final void DrawPatchSolidScaled(int x, int y, int m, int n,
            int scrn, patch_t patch) {

        if ((m == 1) && (n == 1)) {
            DrawPatch(x, y, scrn, patch);
            return;
        }

        column_t column;
        int[] data;
        int desttop;
        final int[] dest = screens[scrn];
        int w;

        y = y * n - patch.topoffset;
        x = x * m - patch.leftoffset;
        if (RANGECHECK)
            if (doRangeCheck(x, y, patch, scrn)) {
                System.err.print("Patch at " + x + "," + y + " exceeds LFB\n");
                // No I_Error abort - what is up with TNT.WAD?
                System.err.print("V_DrawPatch: bad patch (ignored)\n");
                return;
            }

        if (scrn == 0)
            this.MarkRect(x, y, patch.width, patch.height);

        w = patch.width;
        desttop = m * x + this.width * y;
        // For each column..
        int destPos;
        int ptr = 0;
        // x increases by m.

        // Some unrolling...

        if (m == 2) {
            // desttop=2*desttop;
            for (int col = 0; col < w; desttop += 2, col++)

            {

                // This points at a "column" object.
                // column = (column_t *)((byte *)patch +
                // LONG(patch->columnofs[col]));
                column = patch.columns[col];
                data=this.getShortVersion(column.data);
                
                // For each post...
                for (int i = 0; i < column.posts; i++) {
                    // Get pointer to post offset.
                    ptr = column.postofs[i];
                    // Get post delta
                    short delta = column.postdeltas[i];
                    // We skip delta, len and padding.
                    // ptr+=3;

                    // Skip transparent rows...
                    if (delta == 0xFF)
                        break;

                    destPos = desttop + n * delta * this.width;

                    // These lengths are already correct.
                    for (int j = 0; j < column.postlen[i]; j++) {
                        dest[destPos] = data[ptr++];
                        dest[destPos + 1] = dest[destPos];
                        destPos += n * this.width;
                    }
                }
            }
        } else if (m == 3) {
            // desttop=3*desttop;
            for (int col = 0; col < w; desttop += 3, col++)

            {

                column = patch.columns[col];
                data=this.getShortVersion(column.data);
                
                // For each post...
                for (int i = 0; i < column.posts; i++) {
                    // Get pointer to post offset.
                    ptr = column.postofs[i];
                    // Get post delta
                    short delta = column.postdeltas[i];
                    // We skip delta, len and padding.
                    // ptr+=3;

                    // Skip transparent rows...
                    if (delta == 0xFF)
                        break;

                    destPos = desttop + n * delta * this.width;

                    // These lengths are already correct.
                    for (int j = 0; j < column.postlen[i]; j++) {
                        dest[destPos] = data[ptr++];
                        dest[destPos + 1] = dest[destPos];
                        dest[destPos + 2] = dest[destPos];
                        destPos += n * this.width;
                    }

                }
            }
        } else if (m == 4) {
            // desttop=4*desttop;
            for (int col = 0; col < w; desttop += 4, col++)

            {

                column = patch.columns[col];
                data=this.getShortVersion(column.data);
                
                // For each post...
                for (int i = 0; i < column.posts; i++) {
                    // Get pointer to post offset.
                    ptr = column.postofs[i];
                    // Get post delta
                    short delta = column.postdeltas[i];
                    // We skip delta, len and padding.
                    // ptr+=3;

                    // Skip transparent rows...
                    if (delta == 0xFF)
                        break;

                    destPos = desttop + n * delta * this.width;

                    // These lengths are already correct.
                    for (int j = 0; j < column.postlen[i]; j++) {
                        dest[destPos] = data[ptr++];
                        dest[destPos + 1] = dest[destPos];
                        dest[destPos + 2] = dest[destPos];
                        dest[destPos + 3] = dest[destPos];
                        destPos += n * this.width;
                    }
                }
            }
        } else {
            // desttop=m*desttop;
            for (int col = 0; col < w; desttop += m, col++)

            {

                // This points at a "column" object.
                // column = (column_t *)((byte *)patch +
                // LONG(patch->columnofs[col]));
                column = patch.columns[col];
                // For each post...
                for (int i = 0; i < column.posts; i++) {
                    // Get pointer to post offset.
                    ptr = column.postofs[i];
                    // Get post delta
                    short delta = column.postdeltas[i];
                    // We skip delta, len and padding.
                    // ptr+=3;

                    // Skip transparent rows...
                    if (delta == 0xFF)
                        break;

                    destPos = desttop + n * delta * this.width;

                    // These lengths are already correct.
                    for (int j = 0; j < column.postlen[i]; j++) {
                        for (int k = 0; k < m; k++)
                            dest[destPos + k] = column.data[ptr];
                        ptr++;
                        destPos += n * this.width;
                    }
                }
            }

        }

        scaleSolid(m, n, scrn, m * patch.width);
    }

    /**
     * Pretty crude in-place scaling. It's fast, but only works full-screen
     * Width needs to be specific, height is implied.
     * */

    protected final void scaleSolid(int m, int n, int screen, int width) {
        int height = screens[screen].length / width;
        for (int i = 0; i < height; i += n) {

            for (int j = 0; j < n - 1; j++) {

                System.arraycopy(screens[screen], (i + j) * width,
                        screens[screen], (i + j + 1) * width, width);
            }
        }

    }

    /**
     * V_DrawPatchFlipped Masks a column based masked pic to the screen. Flips
     * horizontally, e.g. to mirror face.
     * 
     * Currently UNUSED, as any occurence to it is also scaled and best served
     * by another function.
     * 
     * 
     */

    public final void DrawPatchFlipped(int x, int y, int scrn, patch_t patch) {

        column_t column;
        int desttop;
        int[] dest = screens[scrn];
        int w;

        y -= patch.topoffset;
        x -= patch.leftoffset;

        if (RANGECHECK)
            if (doRangeCheck(x, y, patch, scrn)) {
                {
                    System.err.print("Patch origin " + x + "," + y
                            + " exceeds LFB\n");
                    // No I_Error abort - what is up with TNT.WAD?
                    I.Error("Bad V_DrawPatch in V_DrawPatchFlipped");
                }
            }

        if (scrn == 0)
            this.MarkRect(x, y, patch.width, patch.height);

        // Set x and y coords inside dest array.

        w = patch.width;
        desttop = y * this.width + x;
        // For each column..
        for (int col = 0; col < w; desttop++, col++) {

            // This points at a "column" object.
            // Notice the flipping on this one.
            // column = (column_t *)((byte *)patch +
            // LONG(patch->columnofs[w-1-col]));
            column = patch.columns[w - 1 - col];

            // For each post...
            // System.out.println("Column"+(w-1-col));
            for (int i = 0; i < column.posts; i++) {
                // Get pointer to post offset.
                int ptr = column.postofs[i];
                // Get post delta
                int delta = 0xFF & column.data[ptr];
                // We skip delta, len and padding.
                // ptr+=3;
                if (delta == 0xFF)
                    break;
                int destPos = desttop + delta * this.width;
                // count = column.length;

                // These lengths are already correct.
                for (int j = 0; j < column.postlen[i]; j++, destPos += this.width) {
                    dest[destPos] = column.data[ptr + j];
                    // next line

                }
            }
        }

    }

    /**
     * V_DrawScaledPatch like V_DrawPatch, but scaled 2,3,4 times the original
     * size and position this is used for menu and title screens, with high
     * resolutions
     * 
     * added:05-02-98: default params : scale patch and scale start
     * 
     * Iniially implemented for Mocha Doom by _D_ (shamelessly ripped from
     * Eternity Engine ;-), adapted to scale based on a scaling info object
     * (VSI).
     * 
     * Unless overriden by flags, starting x and y are automatically scaled
     * (implied V_SCALESTART)
     * 
     */
    @Override
    public void DrawScaledPatch(int x, int y, int scrn, IVideoScale VSI,
            patch_t patch) {
        int col;
        column_t column;
        int desttop;
        final int[] dest = screens[scrn & 0xFF];
        // byte[] source;

        int dupx, dupy;
        int colfrac, rowfrac;

        // System.out.printf("V_DrawScaledPatch %d %d \n",x,y);
        // draw an hardware converted patch
        /*
         * #ifdef HWRENDER if (rendermode != render_soft) {
         * HWR_DrawPatch((GlidePatch_t *) patch, x, y, scrn); return; } #endif
         */

        // A very common operation, eliminates the need to pre-divide.
        if (C2JUtils.flags(scrn, V_PREDIVIDE)) {
            x /= vs.getScalingX();
            y /= vs.getScalingY();
        }

        if (C2JUtils.flags(scrn, V_NOSCALEPATCH))
            dupx = dupy = 1;
        else {
            dupx = VSI.getScalingX();
            dupy = VSI.getScalingY();
        }

        // Eliminates.
        // MAES: added this fix so that non-zero patch offsets can be
        // taken into account, regardless of whether we use pre-scaled
        // coords or not. Only Doomguy's face needs this hack for now.

        if (C2JUtils.flags(scrn, V_SCALEOFFSET)) {
            y -= patch.topoffset * dupx;
            x -= patch.leftoffset * dupy;
        } else {
            y -= patch.topoffset;
            x -= patch.leftoffset;
        }

        colfrac = dupx;
        rowfrac = dupy;

        // desttop = screens[scrn & 0xFF];
        if (C2JUtils.flags(scrn, V_NOSCALESTART))
            desttop = (y * this.width) + x;
        else
            desttop = (y * dupy * this.width) + (x * dupx) /* + scaledofs */;
        // destend = desttop + /*SHORT(*/patch.width/*)*/ * dupx;

        int w = patch.width * dupx;

        int colInc = 1;
        col = 0;
        if (C2JUtils.flags(scrn, V_FLIPPEDPATCH)) {
            colInc = -1;
            col = w - 1;// (/*SHORT(*/patch.width/*)*/ << fixed_t.FRACBITS) +
                        // colfrac;
        }

        for (; col >= 0 && col < w/* ; desttop < destend */; col += colInc, desttop++) {
            // column = (column_t *) ((byte *) patch + LONG(patch.columnofs[col
            // >> FRACBITS]));
            column = patch.columns[col / colfrac];
            final int[] data=getShortVersion(column.data);

            int destPos;
            int ptr = 0;
            int ptrOfs;

            // while (column.topdelta != 0xff)
            for (int i = 0; i < column.posts; i++) {
                {
                    ptrOfs = column.postofs[i];// +3;
                    ptr = 0;
                    short delta = column.postdeltas[i];

                    // Skip transparent rows...
                    if (delta == 0xFF)
                        break;

                    destPos = desttop + delta * dupy * this.width;
                    // dest = desttop + column.topdelta * dupy * this.width;

                    // ofs = 0;
                    // while (count-- > 0)
                    for (int j = 0; j < column.postlen[i] * dupy; j++) {
                        dest[destPos] = data[ptrOfs + ptr / rowfrac];
                        destPos += this.width;

                        ptr++;
                        // ofs += rowfrac;
                    }

                    // column = (column_t *) ((byte *) column + column.length +
                    // 4);
                }
            }
        }
    }

    @Override
    public final void DrawBlock(int x, int y, int scrn, int width, int height,
            byte[] src) {
        DrawBlock(x,y,scrn,width,height,src,0);
    }

    @Override
    public final void DrawBlock(int x, int y, int scrn, int width, int height,
            byte[] src,int offset) {
        // This is "screens[scrn]"
        final int[] dest = screens[scrn];
        final int[] data=getShortVersion(src);
        
        if (doRangeCheck(x, y, scrn)) {
            I.Error("Bad V_DrawBlock");
        }

        this.MarkRect(x, y, width, height);

        int destPos = /* screens[scrn] + */y * this.width + x;
        // MAES: making an assumption here. A BIIIIG one.
        int srcPos = offset;
        while ((height--) > 0) {
            // A real dog. It's good that this ain't used
            // so often.
            for (int xx=0;xx<width;xx++)
                dest[destPos+xx]=data[srcPos+xx];
                //System.arraycopy(src, srcPos, dest, destPos, width);
            srcPos += width;
            destPos += this.width;
        }
    }
    

    /**
     * Replaces DrawPatchCol for bunny scrolled in Finale.
     * 
     * 
     */

    @Override
    public final void DrawPatchColScaled(int x, patch_t patch, int col,
            IVideoScale vs, int screen) {
        column_t column;
        int source;
        final int[] dest;
        final int[] data;
        int desttop;
        final int scale = vs.getScalingX();

        column = patch.columns[col];
        data=this.getShortVersion(column.data);
        desttop = x * scale; // Scale X position.
        dest = screens[screen];
        // step through the posts in a column

        for (int i = 0; i < column.posts; i++) {
            // Get pointer to post offset.
            source = column.postofs[i];
            // Get post delta
            short delta = column.postdeltas[i];
            // We skip delta, len and padding.
            // source+=3; NOT NEEDED ANYMORE, skipped by parsing.

            // Skip transparent rows...
            if (delta == 0xFF)
                break;

            // Replicate each column scale times vertically,
            // with spaced pixels.
            final int startsource = source;
            for (int kl = 0; kl < scale; kl++) {
                int destPos = desttop + (delta + kl) * SCREENWIDTH;
                for (int j = 0; j < column.postlen[i]; j++) {
                    final int datap = data[source++];
                    // replicate each column's pixel horizontally and
                    // vertically.
                    for (int k = 0; k < scale; k++)
                        dest[destPos + k] = datap;
                    destPos += scale * SCREENWIDTH;
                }
                source = startsource;
            }
        }
    }

    public void setScreen(int index, int width, int height) {
        this.screens[index] = new int[width * height];
    }

    public final void takeScreenShot(int screen, String imagefile,
            IndexColorModel icm) throws IOException {

        BufferedImage b = new BufferedImage(this.getWidth(), this.getHeight(),
                BufferedImage.TYPE_BYTE_INDEXED, icm);

        int[] tmp = new int[this.screens[screen].length];
        for (int i = 0; i < this.screens[screen].length; i++) {
            tmp[i] = this.screens[screen][i];
        }

        b.getRaster().setPixels(0, 0, this.getWidth(), this.getHeight(), tmp);

        File outputFile = new File(imagefile + ".png");
        ImageIO.write(b, "PNG", outputFile);

    }

    /** Internal method for setting up palettes (and gamma tables)
     * 
     */

    public void createPalettes(byte[] paldata, short[][] gammadata, final int palettes, final int colors, final int stride,final int gammalevels){
        
        // Sanity check on supplied data length. If there is not enough data to create the specified palettes,
        // their number will be limited.
        
        if (paldata!=null)  // As many as are likely contained
            maxpalettes=paldata.length/(colors*stride);
        else
            maxpalettes=0; // Do some default action on null palette.

        if (gammadata!=null)    // As many as are likely contained
            maxgammas=gammadata.length;
        else
            maxgammas=0; // Do some default action on null gamma tables.
        
        if (maxgammas==0){
            gammadata=GammaTables.gammatables;
            maxgammas=GammaTables.gammatables.length;
        }
        

        // Enough data for all palettes. 
        // Enough data for all palettes. 
        if (maxpalettes>0 && maxgammas>0)
                specificPaletteCreation(paldata,gammadata,palettes,colors,stride,gammalevels);
             else 
                 paletteRecovery();
              
          }
    
    /** Override this in extending classes to perform specific actions depending on the
     *  type of renderer. It's better not to assign a default action, nor make assumptions
     *  on the underlying types of actual palettes
     * 
     * @param paldata
     * @param gammadata
     * @param palettes
     * @param colors
     * @param stride
     * @param gammalevels
     */

    protected abstract void specificPaletteCreation(byte[] paldata,
            short[][] gammadata, 
            final int palettes, 
            final int colors,
            final int stride,
            final int gammalevels);
    
    
    /**
     * Clear automap frame buffer or fill solid color
     * MAES: optimized for efficiency, seen the lack of a proper "memset" in Java.
     * 
     */

    @Override
    public final void FillRect(int color, int screen, int x, int y, int width,
            int height) {
        int[] arr = screens[screen];
        final int c=getBaseColor(color);

        // Do a "per scanline" copy.
        int fromIndex = x + y * SCREENWIDTH;
        int toIndex = x + (y + height - 1) * SCREENWIDTH;

        // First scanline.
        for (int i = 0; i < width; i++)
            arr[fromIndex + i] = c;

        for (; fromIndex < toIndex; fromIndex += SCREENWIDTH) {
            System.arraycopy(arr, fromIndex, arr, fromIndex + SCREENWIDTH,
                    width);
        }
    }

    public final void GetBlock(int x, int y, int scrn, int width, int height,
            int[] dest) {
        final int[] src = screens[scrn];

        if (RANGECHECK) {
            if (doRangeCheck(x, y, scrn)) {
                I.Error("Bad V_DrawBlock");
            }

        }
        int srcPos = y * this.width + x;
        int destPos = 0;

        while ((height--) > 0) {
            System.arraycopy(src, srcPos, dest, destPos, width);
            // memcpy (dest, src, width);
            srcPos += width;
            destPos += this.width;
        }
    }
    
    public final void setColorMaps(short[] stuff, int num){
        // For HiCOlor, load COLORS15 lump

        this.cmap_base=new int[num][256];     
        this.cmap_work=new int[num][256];       
        
        for (int i = 0; i < cmap_base.length; i++) {
            System.arraycopy(stuff, i * 256, cmap_base[i], 0, 256);
            System.arraycopy(stuff, i * 256, cmap_work[i], 0, 256);
        }
    }
    
    public final void setColorMaps(int[] stuff, int num){
        // For HiCOlor, load COLORS15 lump

        this.cmap_base=new int[num][256];     
        this.cmap_work=new int[num][256];    
        
        for (int i = 0; i < cmap_base.length; i++) {
            for (int j=0;j<256;j++){
                cmap_base[i][j]=PaletteGenerator.rgb888to555(stuff[i*256+j]);
                cmap_work[i][j]=cmap_base[i][j];
            }
        }
    }
    
    public int[][] getColorMaps(){
        return cmap_work;
    }
    
    ///// MEGA HACK FOR SUPER-8BIT MODES
    
    private final HashMap<Integer,int[]> colcache=new HashMap<Integer,int[]>();
    
    private final int[] getShortVersion(byte[] data){
        if (!colcache.containsKey(data.hashCode())){
            //System.out.printf("Generated cache for %d\n",data.hashCode());
            int[] stuff=new int[data.length];
            for (int i=0;i<stuff.length;i++){
                stuff[i]=cmap_work[CMAP_FIXED][0xFF&data[i]];
            }
            colcache.put(data.hashCode(),stuff);
            
        }
        return colcache.get(data.hashCode());
        
    }
    
    @Override
    public final void clearCaches(){
        this.colcache.clear();
    }
    
    ///// MODIFIED COLORMAP CACHING //////////
    
    private final HashMap<Integer,int[][]> cmapcache=new HashMap<Integer,int[][]>();
    
    /** Cache colormaps in order to avoid expensive re-computations 
     *  Invalidate if gamma is changed. Changes are applied on-the-fly
     *  to working_colormap.
     * 
     * */
    
       protected final void getCachedCmap(int palette){
           
            int[][] stuff=cmapcache.get(palette);        
            
            if (stuff==null){
                // Generate the full range of colormap for a given palette effect               
                
                // Results in different tinting behavior than vanilla.
                //stuff=
                //PaletteGenerator.RF_BuildLights24(palettes[usegamma*maxpalettes+usepalette], NUMLIGHTS);
                
                // Tinting more faithful to the original, thanks to Sodaholic's input.
                stuff=new int[cmap_base.length][cmap_base[0].length];
                for (int i = 0; i < stuff.length; i++) 
                  PaletteGenerator.tintColormap(cmap_base[i], stuff[i], 256, ColorTint.tints[palette%14],GammaTables.gammatables[usegamma]);
                cmapcache.put(palette,stuff);               
            }
            
            // Use fast arraycopy to copy data to working colormap.
            for (int i = 0; i < stuff.length; i++) {
                System.arraycopy(stuff[i], 0, cmap_work[i], 0, 256);
            }           
        }
       
        protected final void clearPalettes(){
            this.cmapcache.clear();
        }
    
}

package v;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
//$Id: GammaTables.java,v 1.2 2016/07/04 07:52:26 velktron Exp $
//
//Copyright (C) 1993-1996 by id Software, Inc.
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//
//DESCRIPTION:
//	Gamma correction LUT stuff.
//

public class GammaTables {
	 // Now where did these came from? /*[5][256]*/
    public static final short[][] gammatables =
    {
        {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
         17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
         33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
         49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
         65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
         81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,
         97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
         113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
         128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
         144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
         160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
         176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
         192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
         208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
         224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
         240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255},

        {2,4,5,7,8,10,11,12,14,15,16,18,19,20,21,23,24,25,26,27,29,30,31,
         32,33,34,36,37,38,39,40,41,42,44,45,46,47,48,49,50,51,52,54,55,
         56,57,58,59,60,61,62,63,64,65,66,67,69,70,71,72,73,74,75,76,77,
         78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,
         99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,
         115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,129,
         130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,
         146,147,148,148,149,150,151,152,153,154,155,156,157,158,159,160,
         161,162,163,163,164,165,166,167,168,169,170,171,172,173,174,175,
         175,176,177,178,179,180,181,182,183,184,185,186,186,187,188,189,
         190,191,192,193,194,195,196,196,197,198,199,200,201,202,203,204,
         205,205,206,207,208,209,210,211,212,213,214,214,215,216,217,218,
         219,220,221,222,222,223,224,225,226,227,228,229,230,230,231,232,
         233,234,235,236,237,237,238,239,240,241,242,243,244,245,245,246,
         247,248,249,250,251,252,252,253,254,255},

        {4,7,9,11,13,15,17,19,21,22,24,26,27,29,30,32,33,35,36,38,39,40,42,
         43,45,46,47,48,50,51,52,54,55,56,57,59,60,61,62,63,65,66,67,68,69,
         70,72,73,74,75,76,77,78,79,80,82,83,84,85,86,87,88,89,90,91,92,93,
         94,95,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,
         113,114,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
         129,130,131,132,133,133,134,135,136,137,138,139,140,141,142,143,144,
         144,145,146,147,148,149,150,151,152,153,153,154,155,156,157,158,159,
         160,160,161,162,163,164,165,166,166,167,168,169,170,171,172,172,173,
         174,175,176,177,178,178,179,180,181,182,183,183,184,185,186,187,188,
         188,189,190,191,192,193,193,194,195,196,197,197,198,199,200,201,201,
         202,203,204,205,206,206,207,208,209,210,210,211,212,213,213,214,215,
         216,217,217,218,219,220,221,221,222,223,224,224,225,226,227,228,228,
         229,230,231,231,232,233,234,235,235,236,237,238,238,239,240,241,241,
         242,243,244,244,245,246,247,247,248,249,250,251,251,252,253,254,254,
         255},

        {8,12,16,19,22,24,27,29,31,34,36,38,40,41,43,45,47,49,50,52,53,55,
         57,58,60,61,63,64,65,67,68,70,71,72,74,75,76,77,79,80,81,82,84,85,
         86,87,88,90,91,92,93,94,95,96,98,99,100,101,102,103,104,105,106,107,
         108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,
         125,126,127,128,129,130,131,132,133,134,135,135,136,137,138,139,140,
         141,142,143,143,144,145,146,147,148,149,150,150,151,152,153,154,155,
         155,156,157,158,159,160,160,161,162,163,164,165,165,166,167,168,169,
         169,170,171,172,173,173,174,175,176,176,177,178,179,180,180,181,182,
         183,183,184,185,186,186,187,188,189,189,190,191,192,192,193,194,195,
         195,196,197,197,198,199,200,200,201,202,202,203,204,205,205,206,207,
         207,208,209,210,210,211,212,212,213,214,214,215,216,216,217,218,219,
         219,220,221,221,222,223,223,224,225,225,226,227,227,228,229,229,230,
         231,231,232,233,233,234,235,235,236,237,237,238,238,239,240,240,241,
         242,242,243,244,244,245,246,246,247,247,248,249,249,250,251,251,252,
         253,253,254,254,255},

        {16,23,28,32,36,39,42,45,48,50,53,55,57,60,62,64,66,68,69,71,73,75,76,
         78,80,81,83,84,86,87,89,90,92,93,94,96,97,98,100,101,102,103,105,106,
         107,108,109,110,112,113,114,115,116,117,118,119,120,121,122,123,124,
         125,126,128,128,129,130,131,132,133,134,135,136,137,138,139,140,141,
         142,143,143,144,145,146,147,148,149,150,150,151,152,153,154,155,155,
         156,157,158,159,159,160,161,162,163,163,164,165,166,166,167,168,169,
         169,170,171,172,172,173,174,175,175,176,177,177,178,179,180,180,181,
         182,182,183,184,184,185,186,187,187,188,189,189,190,191,191,192,193,
         193,194,195,195,196,196,197,198,198,199,200,200,201,202,202,203,203,
         204,205,205,206,207,207,208,208,209,210,210,211,211,212,213,213,214,
         214,215,216,216,217,217,218,219,219,220,220,221,221,222,223,223,224,
         224,225,225,226,227,227,228,228,229,229,230,230,231,232,232,233,233,
         234,234,235,235,236,236,237,237,238,239,239,240,240,241,241,242,242,
         243,243,244,244,245,245,246,246,247,247,248,248,249,249,250,250,251,
         251,252,252,253,254,254,255,255}
    };
}

package v;

import java.awt.Color;

/**
 * Palette generation failsafe. Uses only data from the first palette, and
 * generates the rest by tinting according to the Doom wiki specs. Uses info
 * from: http://doom.wikia.com/wiki/PLAYPAL
 * 
 * Now extended to contain many extended color synthesizing tools, used
 * in super-indexed and truecolor software rendered displays.
 * 
 * @author Maes
 */
public class PaletteGenerator {
    public final static int playpal[] = { 0x00, 0x00, 0x00, 0x1F, 0x17, 0x0B,
            0x17, 0x0F, 0x07, 0x4B, 0x4B, 0x4B, 0xFF, 0xFF, 0xFF, 0x1B, 0x1B,
            0x1B, 0x13, 0x13, 0x13, 0x0B, 0x0B, 0x0B, 0x07, 0x07, 0x07, 0x2F,
            0x37, 0x1F, 0x23, 0x2B, 0x0F, 0x17, 0x1F, 0x07, 0x0F, 0x17, 0x00,
            0x4F, 0x3B, 0x2B, 0x47, 0x33, 0x23, 0x3F, 0x2B, 0x1B, 0xFF, 0xB7,
            0xB7, 0xF7, 0xAB, 0xAB, 0xF3, 0xA3, 0xA3, 0xEB, 0x97, 0x97, 0xE7,
            0x8F, 0x8F, 0xDF, 0x87, 0x87, 0xDB, 0x7B, 0x7B, 0xD3, 0x73, 0x73,
            0xCB, 0x6B, 0x6B, 0xC7, 0x63, 0x63, 0xBF, 0x5B, 0x5B, 0xBB, 0x57,
            0x57, 0xB3, 0x4F, 0x4F, 0xAF, 0x47, 0x47, 0xA7, 0x3F, 0x3F, 0xA3,
            0x3B, 0x3B, 0x9B, 0x33, 0x33, 0x97, 0x2F, 0x2F, 0x8F, 0x2B, 0x2B,
            0x8B, 0x23, 0x23, 0x83, 0x1F, 0x1F, 0x7F, 0x1B, 0x1B, 0x77, 0x17,
            0x17, 0x73, 0x13, 0x13, 0x6B, 0x0F, 0x0F, 0x67, 0x0B, 0x0B, 0x5F,
            0x07, 0x07, 0x5B, 0x07, 0x07, 0x53, 0x07, 0x07, 0x4F, 0x00, 0x00,
            0x47, 0x00, 0x00, 0x43, 0x00, 0x00, 0xFF, 0xEB, 0xDF, 0xFF, 0xE3,
            0xD3, 0xFF, 0xDB, 0xC7, 0xFF, 0xD3, 0xBB, 0xFF, 0xCF, 0xB3, 0xFF,
            0xC7, 0xA7, 0xFF, 0xBF, 0x9B, 0xFF, 0xBB, 0x93, 0xFF, 0xB3, 0x83,
            0xF7, 0xAB, 0x7B, 0xEF, 0xA3, 0x73, 0xE7, 0x9B, 0x6B, 0xDF, 0x93,
            0x63, 0xD7, 0x8B, 0x5B, 0xCF, 0x83, 0x53, 0xCB, 0x7F, 0x4F, 0xBF,
            0x7B, 0x4B, 0xB3, 0x73, 0x47, 0xAB, 0x6F, 0x43, 0xA3, 0x6B, 0x3F,
            0x9B, 0x63, 0x3B, 0x8F, 0x5F, 0x37, 0x87, 0x57, 0x33, 0x7F, 0x53,
            0x2F, 0x77, 0x4F, 0x2B, 0x6B, 0x47, 0x27, 0x5F, 0x43, 0x23, 0x53,
            0x3F, 0x1F, 0x4B, 0x37, 0x1B, 0x3F, 0x2F, 0x17, 0x33, 0x2B, 0x13,
            0x2B, 0x23, 0x0F, 0xEF, 0xEF, 0xEF, 0xE7, 0xE7, 0xE7, 0xDF, 0xDF,
            0xDF, 0xDB, 0xDB, 0xDB, 0xD3, 0xD3, 0xD3, 0xCB, 0xCB, 0xCB, 0xC7,
            0xC7, 0xC7, 0xBF, 0xBF, 0xBF, 0xB7, 0xB7, 0xB7, 0xB3, 0xB3, 0xB3,
            0xAB, 0xAB, 0xAB, 0xA7, 0xA7, 0xA7, 0x9F, 0x9F, 0x9F, 0x97, 0x97,
            0x97, 0x93, 0x93, 0x93, 0x8B, 0x8B, 0x8B, 0x83, 0x83, 0x83, 0x7F,
            0x7F, 0x7F, 0x77, 0x77, 0x77, 0x6F, 0x6F, 0x6F, 0x6B, 0x6B, 0x6B,
            0x63, 0x63, 0x63, 0x5B, 0x5B, 0x5B, 0x57, 0x57, 0x57, 0x4F, 0x4F,
            0x4F, 0x47, 0x47, 0x47, 0x43, 0x43, 0x43, 0x3B, 0x3B, 0x3B, 0x37,
            0x37, 0x37, 0x2F, 0x2F, 0x2F, 0x27, 0x27, 0x27, 0x23, 0x23, 0x23,
            0x77, 0xFF, 0x6F, 0x6F, 0xEF, 0x67, 0x67, 0xDF, 0x5F, 0x5F, 0xCF,
            0x57, 0x5B, 0xBF, 0x4F, 0x53, 0xAF, 0x47, 0x4B, 0x9F, 0x3F, 0x43,
            0x93, 0x37, 0x3F, 0x83, 0x2F, 0x37, 0x73, 0x2B, 0x2F, 0x63, 0x23,
            0x27, 0x53, 0x1B, 0x1F, 0x43, 0x17, 0x17, 0x33, 0x0F, 0x13, 0x23,
            0x0B, 0x0B, 0x17, 0x07, 0xBF, 0xA7, 0x8F, 0xB7, 0x9F, 0x87, 0xAF,
            0x97, 0x7F, 0xA7, 0x8F, 0x77, 0x9F, 0x87, 0x6F, 0x9B, 0x7F, 0x6B,
            0x93, 0x7B, 0x63, 0x8B, 0x73, 0x5B, 0x83, 0x6B, 0x57, 0x7B, 0x63,
            0x4F, 0x77, 0x5F, 0x4B, 0x6F, 0x57, 0x43, 0x67, 0x53, 0x3F, 0x5F,
            0x4B, 0x37, 0x57, 0x43, 0x33, 0x53, 0x3F, 0x2F, 0x9F, 0x83, 0x63,
            0x8F, 0x77, 0x53, 0x83, 0x6B, 0x4B, 0x77, 0x5F, 0x3F, 0x67, 0x53,
            0x33, 0x5B, 0x47, 0x2B, 0x4F, 0x3B, 0x23, 0x43, 0x33, 0x1B, 0x7B,
            0x7F, 0x63, 0x6F, 0x73, 0x57, 0x67, 0x6B, 0x4F, 0x5B, 0x63, 0x47,
            0x53, 0x57, 0x3B, 0x47, 0x4F, 0x33, 0x3F, 0x47, 0x2B, 0x37, 0x3F,
            0x27, 0xFF, 0xFF, 0x73, 0xEB, 0xDB, 0x57, 0xD7, 0xBB, 0x43, 0xC3,
            0x9B, 0x2F, 0xAF, 0x7B, 0x1F, 0x9B, 0x5B, 0x13, 0x87, 0x43, 0x07,
            0x73, 0x2B, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xDB, 0xDB, 0xFF, 0xBB,
            0xBB, 0xFF, 0x9B, 0x9B, 0xFF, 0x7B, 0x7B, 0xFF, 0x5F, 0x5F, 0xFF,
            0x3F, 0x3F, 0xFF, 0x1F, 0x1F, 0xFF, 0x00, 0x00, 0xEF, 0x00, 0x00,
            0xE3, 0x00, 0x00, 0xD7, 0x00, 0x00, 0xCB, 0x00, 0x00, 0xBF, 0x00,
            0x00, 0xB3, 0x00, 0x00, 0xA7, 0x00, 0x00, 0x9B, 0x00, 0x00, 0x8B,
            0x00, 0x00, 0x7F, 0x00, 0x00, 0x73, 0x00, 0x00, 0x67, 0x00, 0x00,
            0x5B, 0x00, 0x00, 0x4F, 0x00, 0x00, 0x43, 0x00, 0x00, 0xE7, 0xE7,
            0xFF, 0xC7, 0xC7, 0xFF, 0xAB, 0xAB, 0xFF, 0x8F, 0x8F, 0xFF, 0x73,
            0x73, 0xFF, 0x53, 0x53, 0xFF, 0x37, 0x37, 0xFF, 0x1B, 0x1B, 0xFF,
            0x00, 0x00, 0xFF, 0x00, 0x00, 0xE3, 0x00, 0x00, 0xCB, 0x00, 0x00,
            0xB3, 0x00, 0x00, 0x9B, 0x00, 0x00, 0x83, 0x00, 0x00, 0x6B, 0x00,
            0x00, 0x53, 0xFF, 0xFF, 0xFF, 0xFF, 0xEB, 0xDB, 0xFF, 0xD7, 0xBB,
            0xFF, 0xC7, 0x9B, 0xFF, 0xB3, 0x7B, 0xFF, 0xA3, 0x5B, 0xFF, 0x8F,
            0x3B, 0xFF, 0x7F, 0x1B, 0xF3, 0x73, 0x17, 0xEB, 0x6F, 0x0F, 0xDF,
            0x67, 0x0F, 0xD7, 0x5F, 0x0B, 0xCB, 0x57, 0x07, 0xC3, 0x4F, 0x00,
            0xB7, 0x47, 0x00, 0xAF, 0x43, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xD7, 0xFF, 0xFF, 0xB3, 0xFF, 0xFF, 0x8F, 0xFF, 0xFF, 0x6B, 0xFF,
            0xFF, 0x47, 0xFF, 0xFF, 0x23, 0xFF, 0xFF, 0x00, 0xA7, 0x3F, 0x00,
            0x9F, 0x37, 0x00, 0x93, 0x2F, 0x00, 0x87, 0x23, 0x00, 0x4F, 0x3B,
            0x27, 0x43, 0x2F, 0x1B, 0x37, 0x23, 0x13, 0x2F, 0x1B, 0x0B, 0x00,
            0x00, 0x53, 0x00, 0x00, 0x47, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x2F,
            0x00, 0x00, 0x23, 0x00, 0x00, 0x17, 0x00, 0x00, 0x0B, 0x00, 0x00,
            0x00, 0xFF, 0x9F, 0x43, 0xFF, 0xE7, 0x4B, 0xFF, 0x7B, 0xFF, 0xFF,
            0x00, 0xFF, 0xCF, 0x00, 0xCF, 0x9F, 0x00, 0x9B, 0x6F, 0x00, 0x6B,
            0xA7, 0x6B, 0x6B };

    public final static int greypal[] = new int[768];


    public static byte[] generatePalette(int[] data, int colors,
            ColorTint[] tints) {

        final int palstride = colors * 3;
        final byte[] tmp = new byte[palstride * tints.length];
        final int[] rgb = new int[3];
        final int[] rgb2 = new int[3];

        for (int i = 0; i < colors; i++) {
            rgb[0] = data[3 * i];
            rgb[1] = data[1 + 3 * i];
            rgb[2] = data[2 + 3 * i];

            for (int t = 0; t < tints.length; t++) {
                tintRGB(tints[t], rgb, rgb2);
                tmp[palstride * t + 3 * i] = (byte) rgb2[0];
                tmp[palstride * t + 3 * i + 1] = (byte) rgb2[1];
                tmp[palstride * t + 3 * i + 2] = (byte) rgb2[2];
            }

        }

        return tmp;

    }

    /**
     * Tint a part of a RGB_888 colormap.
     * 
     * @param original
     *        The original reference colormap. DO NOT modify!
     * @param modified
     * @param colors
     *        Usually 256.
     * @param tint
     * @param gamma
     */

    public static void tintColormap(final int[] original, int[] modified,
            int colors, ColorTint tint,short[] gamma) {

        final int[] rgb = new int[4];
        final int[] rgb2 = new int[4];

        for (int i = 0; i < colors; i++) {
            final int rgba=original[i];
            rgb[0] = getRed(rgba);
            rgb[1] = getGreen(rgba);
            rgb[2] = getBlue(rgba);            

            tintRGB(tint, rgb, rgb2);
            
            // Apply gamma correction.
            rgb2[0]=gamma[rgb2[0]];
            rgb2[1]=gamma[rgb2[1]];
            rgb2[2]=gamma[rgb2[2]];
            
            modified[i] = getARGB(rgb2[0],rgb2[1],rgb2[2]);
        }

    }

    public static void tintColormap(final short[] original, short[] modified,
            int colors, ColorTint tint,short[] gamma) {

        final int[] rgb = new int[3];
        final int[] rgb2 = new int[3];

        for (int i = 0; i < colors; i++) {
            final int rgba = rgb555to888(original[i]);
            rgb[0] = getRed(rgba);
            rgb[1] = getGreen(rgba);
            rgb[2] = getBlue(rgba);

            tintRGB(tint, rgb, rgb2);
            
            // Apply gamma correction.
            rgb2[0]=gamma[rgb2[0]];
            rgb2[1]=gamma[rgb2[1]];
            rgb2[2]=gamma[rgb2[2]];
            modified[i] = rgb888to555(rgb2[0],rgb2[1],rgb2[2]);
        }

    }

    public static final void tintRGB(final ColorTint tint, final int[] rgb,
            int[] rgb2) {
        rgb2[0] = (int) (rgb[0] * (1 - tint.tint) + tint.r * tint.tint);
        rgb2[1] = (int) (rgb[1] * (1 - tint.tint) + tint.g * tint.tint);
        rgb2[2] = (int) (rgb[2] * (1 - tint.tint) + tint.b * tint.tint);
        if (rgb2[0] > 255)
            rgb2[0] = 255;
        if (rgb2[1] > 255)
            rgb2[1] = 255;
        if (rgb2[2] > 255)
            rgb2[2] = 255;

    }

    /**
     * ColorShiftPalette - lifted from dcolors.c Operates on RGB888 palettes in
     * separate bytes. at shift = 0, the colors are normal at shift = steps, the
     * colors are all the given rgb
     */

    public static final void ColorShiftPalette(byte[] inpal, byte[] outpal,
            int r, int g, int b, int shift, int steps) {
        int i;
        int dr, dg, db;
        int in_p, out_p;

        in_p = 0;
        out_p = 0;

        for (i = 0; i < 256; i++) {
            dr = r - inpal[in_p + 0];
            dg = g - inpal[in_p + 1];
            db = b - inpal[in_p + 2];

            outpal[out_p + 0] = (byte) (inpal[in_p + 0] + dr * shift / steps);
            outpal[out_p + 1] = (byte) (inpal[in_p + 1] + dg * shift / steps);
            outpal[out_p + 2] = (byte) (inpal[in_p + 2] + db * shift / steps);

            in_p += 3;
            out_p += 3;
        }
    }
  
    /** Get ARGB_8888 from RGB_555, with proper higher-bit
     *  replication.
     * 
     * @param rgb
     * @return
     */
    
    protected static final int rgb555to888(short rgb) {
        int ri, gi, bi;
        int bits;

        // .... .... .... ....
        // 111 11 = 7C00
        // 11 111 = 03E0
        // 1F= 1 1111
        ri = (0x7C00 & rgb) >> 7;
        gi = (0x03E0 & rgb) >> 2;
        bi = (0x001F & rgb) << 3;

        // replicate 3 higher bits
        bits = (ri & 0xE0) >> 5;
        ri = ri + bits;

        bits = (gi & 0xE0) >> 5;
        gi = gi + bits;

        bits = (bi & 0xE0) >> 5;
        bi = bi + bits;

        // ARGB 8888 packed
        
        return 0xFF000000+(ri << 16) + (gi << 8) + (bi);
    }

    protected static final short rgb4444to555(short rgb) {
        int ri, gi, bi;
        int bits;

        // .... .... .... ....
        // 1111

        ri = (0xF000 & rgb) >> 11;
        gi = (0x0F00 & rgb) >> 7;
        bi = (0x00F0 & rgb) >> 3;

        bits = (ri & 0x10) >> 4;
        ri = ri + bits;

        bits = (gi & 0x10) >> 4;
        gi = gi + bits;

        bits = (bi & 0x10) >> 4;
        bi = bi + bits;

        // RGBA 555 packed for NeXT

        return (short) ((ri << 10) + (gi << 5) + (bi));
    }

    /** Get RGB_555 from packed ARGB_8888.
     * 
     * @param argb
     * @return
     */
    
    protected static final short rgb888to555(int rgb) {
        int ri, gi, bi;

        ri = (0xFF0000 & rgb) >> 19;
        gi = (0x00FF00 & rgb) >> 11;
        bi = (0x0000FF & rgb) >> 3;

        return (short) ((ri << 10) + (gi << 5) + (bi));
    }

    /** Get packed RGB_555 word from individual 8-bit RGB components. 
     * 
     *  WARNING: there's no sanity/overflow check for performance reasons.
     * 
     * @param r
     * @param g
     * @param b
     * @return
     */
    
    protected static final short rgb888to555(int r,int g,int b) {

        return (short) (((r>>3) << 10) + ((g>>3) << 5) + (b>>3));
    }
    
    /** Get red from packed argb long word.
     * 
     * @param argb
     * @return
     */
    protected final static int getRed(int argb) {
        return (0xFF0000 & argb) >> 16;
    }

    /** Get green from packed argb long word.
     * 
     * @param argb
     * @return
     */
    
    protected final static int getGreen(int argb) {
        return (0x00FF00 & argb) >> 8;
    }

    /** Get blue from packed argb long word.
     * 
     * @param argb
     * @return
     */
    
    protected final static int getBlue(int argb) {
        return (0x0000FF & argb);
    }

    protected final static int getARGB(int r,int g, int b){
        return 0xFF000000+(r << 16) + (g << 8) + (b);
    }
    
    protected static final short getRGB555(int red,int green,int blue){
        int ri,gi,bi;
        
        ri = (((red+4)>255?255:red+4))>>3;
        ri = ri > 31 ? 31 : ri;
        gi = (((green+4)>255?255:green+4))>>3;
        gi = gi > 31 ? 31 : gi;
        bi = (((blue+4)>255?255:blue+4))>>3;
        bi = bi > 31 ? 31 : bi;

        // RGB555 for HiColor
        return (short) ((ri<<10) + (gi<<5) + bi);
    }
    
    protected static final short getRGB555(int rgb){
        return getRGB555(getRed(rgb),getGreen(rgb),getBlue(rgb));
    }
    
    /**RF_BuildLights lifted from dcolors.c
     * 
     * Used to compute extended-color colormaps even in absence of the
     * COLORS15 lump. Must be recomputed if gamma levels change, since 
     * they actually modify the RGB envelopes.
     * 
     * @author John Carmack
     * @author Velktron
     * @param palette A packed ARGB 256-entry int palette, eventually tinted.
     * @param NUMLIGHTS Number of light levels to synth. Usually 32.
     */

    public static final short[][] RF_BuildLights15 (int[] palette,int NUMLIGHTS)
    {
        int     l,c;
        int     red,green,blue;
        short[][] stuff=new short[NUMLIGHTS+1][256];

        for (l=0;l<NUMLIGHTS;l++)
        {
            for (c=0;c<256;c++)
            {
                red = getRed(palette[c]);
                green = getGreen(palette[c]);
                blue = getBlue(palette[c]);

                red = (red*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;
                green = (green*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;
                blue = (blue*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;

                // RGB555 for HiColor
                stuff[l][c] = getRGB555(red,green,blue);
            }
        }
        
        // Build special map for invulnerability
        BuildSpecials15(stuff[NUMLIGHTS],palette); 
        
        return stuff;
    }
    
    private static final void BuildSpecials15 (short[] stuff, int[] palette)
    {
        int     c,gray,best;
        int   red, green, blue;;

        for (c=0;c<256;c++)
        {
            red = getRed(palette[c]);
            green = getGreen(palette[c]);
            blue = getBlue(palette[c]);

            gray = (int) (255*(1.0-((float)red*0.299/256.0 + 
            						(float)green*0.587/256.0 +
            						(float)blue*0.114/256.0)));            
            
            // We are not done. Because of the grayscaling, the all-white cmap
            
            best=palette[BestColor(gray,gray,gray,palette,0,255)];
            stuff[c] = getRGB555(best);
            
        }
        

        // will lack tinting.
        
        
    }
    
    private static final void BuildSpecials24 (int[] stuff, int[] palette)
    {
        int     c,gray,best;
        int   red, green, blue;;

        for (c=0;c<256;c++)
        {
            red = getRed(palette[c]);
            green = getGreen(palette[c]);
            blue = getBlue(palette[c]);

            gray = (int) (255*(1.0-((float)red*0.299/256.0 + 
                                    (float)green*0.587/256.0 +
                                    (float)blue*0.114/256.0)));            
            
            // We are not done. Because of the grayscaling, the all-white cmap
            
            //best=palette[BestColor(gray,gray,gray,palette,0,255)];
            stuff[c] = new Color(gray,gray,gray).getRGB();
            
        }
        

        // will lack tinting.
        
        
    }
    
    public static final int BestColor (int r, int g, int b, int[] palette, int rangel, int rangeh)
	{
		int	i;
		long	dr, dg, db;
		long	bestdistortion, distortion;
		int	bestcolor;
		int	pal;

	//
	// let any color go to 0 as a last resort
	//
		bestdistortion = ( (long)r*r + (long)g*g + (long)b*b )*2;
		bestcolor = 0;

		for (i=rangel ; i<= rangeh ; i++)
		{
			dr = r - getRed(palette[i]);
			dg = g - getGreen(palette[i]);
			db = b - getBlue(palette[i]);
			distortion = dr*dr + dg*dg + db*db;
			if (distortion < bestdistortion)
			{
				if (distortion==0)
					return i;		// perfect match

				bestdistortion = distortion;
				bestcolor = i;
			}
		}

		return bestcolor;
	}
    
    /** Variation that produces true-color lightmaps
     * 
     * @author John Carmack
     * @param palette A packed ARGB 256-entry int palette, eventually tinted.
     * @param NUMLIGHTS Number of light levels to synth. Usually 32.
     */

    public static final int[][] RF_BuildLights24 (int[] palette,int NUMLIGHTS)
    {
        int     l,c;
        int     red,green,blue;
        int[][] stuff=new int[NUMLIGHTS+1][256];

        for (l=0;l<NUMLIGHTS;l++)
        {
            for (c=0;c<256;c++)
            {
                red = getRed(palette[c]);
                green = getGreen(palette[c]);
                blue = getBlue(palette[c]);

                red = (red*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;
                green = (green*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;
                blue = (blue*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;

                // Full-quality truecolor.
                stuff[l][c] = new Color(red,green,blue).getRGB();
            }
        }
        
        BuildSpecials24(stuff[NUMLIGHTS],palette); 
        
        return stuff;
    }
    
    public static final int[][] BuildLights24 (int[] palette,int NUMLIGHTS)
    {
        int     l,c;
        int     red,green,blue;
        int[][] stuff=new int[NUMLIGHTS+1][256];

        for (l=0;l<NUMLIGHTS;l++)
        {
            for (c=0;c<256;c++)
            {
                red = getRed(palette[c]);
                green = getGreen(palette[c]);
                blue = getBlue(palette[c]);

                red = (red*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;
                green = (green*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;
                blue = (blue*(NUMLIGHTS-l)+NUMLIGHTS/2)/NUMLIGHTS;

                // Full-quality truecolor.
                stuff[l][c] = new Color(red,green,blue).getRGB();
            }
        }
        
        BuildSpecials24(stuff[NUMLIGHTS],palette); 
        
        return stuff;
    }
    
    static {
        for (int i = 0; i < 256; i++) {
            greypal[3 * i] = i;
            greypal[3 * i + 1] = i;
            greypal[3 * i + 2] = i;
        }

    }
    
}

package v;

public interface IVideoScaleAware {    
    
    
    /** Set the video scale for a certain object. Setting
     * does NOT (re)initialize an object yet. This is only done
     * by calling the init() method at a safe moment.
     * 
     * @param vs
     */
    public void setVideoScale(IVideoScale vs);
    
    /** Initialize an object according to the current video scale
     * settings. This should adapt multipliers, static constants,
     * etc. and should be set before the object is first used
     * or after a dynamic (if ever implemented) resolution change.
     * 
     * The proposed method is to initialize everything en-bloc
     * before entering the display loop, and after initializing
     * 
     */    
    public void initScaling();

}

package v;

public class ColorTint {
    public ColorTint(int r, int g, int b, float tint) {
        super();
        this.r = r;
        this.g = g;
        this.b = b;
        this.tint = tint;
    }

    public int r, g, b;

    public float tint;

    public static final ColorTint[] tints = { new ColorTint(0, 0, 0, .0f), // 0
                                                                           // Normal
            new ColorTint(255, 2, 3, 0.11f), // 1 Unused. 11% red tint of
                                             // RGB(252, 2, 3).
            new ColorTint(255, 0, 0, 0.22f), // 2
            new ColorTint(255, 0, 0, 0.33f), // 3
            new ColorTint(255, 0, 0, 0.44f), // 4
            new ColorTint(255, 0, 0, 0.55f), // 5
            new ColorTint(255, 0, 0, 0.66f), // 6
            new ColorTint(255, 0, 0, 0.77f), // 7
            new ColorTint(255, 0, 0, 0.88f), // 8
            new ColorTint(215, 185, 68, 0.12f), // 9
            new ColorTint(215, 185, 68, 0.25f), // 10
            new ColorTint(215, 185, 68, 0.375f), // 11
            new ColorTint(215, 185, 68, 0.50f), // 12
            new ColorTint(3, 253, 3, 0.125f) // 13

        };
}
package v;

import static data.Defines.RANGECHECK;

import i.DoomStatusAware;
import i.IDoomSystem;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.IndexColorModel;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import doom.DoomStatus;

import m.BBox;

import rr.column_t;
import rr.patch_t;
import utils.C2JUtils;

public abstract class SoftwareVideoRenderer8 extends SoftwareVideoRenderer<byte[],byte[]> {

    public Image getCurrentScreen(){
    	return currentscreen;
    }

    public SoftwareVideoRenderer8(){
        super();
        screens=new byte[5][];
    }

    public SoftwareVideoRenderer8(int w,int h){
        super(w,h);
        screens=new byte[5][];
    }
   
  /** V_DrawPatch
   * Masks a column based masked pic to the screen. 
   *  desttop, dest and source were byte*
   */ 

  public final void DrawPatch
  ( int       x,
  int     y,
  int     scrn,
  patch_t patch ) 
  { 

   column_t   column; 
   int    desttop;
   final  byte[] dest=screens[scrn];
   int        w; 
       
   y -= patch.topoffset; 
   x -= patch.leftoffset; 
  if (RANGECHECK) 
   if (doRangeCheck(x,y,patch,scrn))
   {
     System.err.print("Patch at "+x+","+y+" exceeds LFB\n");
     // No I_Error abort - what is up with TNT.WAD?
     System.err.print("V_DrawPatch: bad patch (ignored)\n");
     return;
   }

   if (scrn==0)
      this.MarkRect (x, y, patch.width, patch.height); 

       
   w = patch.width; 
   desttop = x+this.width*y; 
   // For each column..
   int destPos;
   int ptr=0;
   for (int col=0 ; col<w ; desttop++, col++,x++)
   { 
      // This points at a "column" object.     
      //column = (column_t *)((byte *)patch + LONG(patch->columnofs[col])); 
      column=patch.columns[col];
      // For each post...
      for (int i=0;i<column.posts;i++){
          // Get pointer to post offset.
          ptr=column.postofs[i];
          // Get post delta
          short delta=column.postdeltas[i];
          // We skip delta, len and padding.
          // ptr+=3; NOT NEEDED< pre-skipped at parsing. 
          
          // Skip transparent rows...
          if (delta==0xFF) break;

          destPos = desttop + delta*this.width;  
          
          // These lengths are already correct.
          for (int j=0;j<column.postlen[i];j++){
                 dest[destPos] = column.data[ptr++];
                 destPos += this.width;
          }
      }
   }
      
      
  }

  /** V_DrawPatchSolidScaled
   * Draws a SOLID (non-masked) patch to the screen with integer scaling
   * m and n.
   * Useful for stuff such as help screens, titlepic and status bar. Not 
   * very useful for menus, though.
   * desttop, dest and source were byte
   */ 

  public final void DrawPatchSolidScaled
  ( int       x,
  int     y,int m, int n,
  int     scrn,
  patch_t patch ) 
  { 

   if ((m==1)&&(n==1)){
       DrawPatch(x,y,scrn,patch);
       return;
   }
      
   column_t   column; 
   int    desttop;
   final byte[] dest=screens[scrn];
   int        w; 
       
   y =y*n- patch.topoffset; 
   x =x*m- patch.leftoffset; 
  if (RANGECHECK) 
   if (doRangeCheck(x,y,patch,scrn))
   {
     System.err.print("Patch at "+x+","+y+" exceeds LFB\n");
     // No I_Error abort - what is up with TNT.WAD?
     System.err.print("V_DrawPatch: bad patch (ignored)\n");
     return;
   }

   if (scrn==0)
      this.MarkRect (x, y, patch.width, patch.height); 

       
   w = patch.width; 
   desttop = m*x+this.width*y; 
   // For each column..
   int destPos;
   int ptr=0;
   // x increases by m.
   
   // Some unrolling...
   
   if (m==2) {
       //desttop=2*desttop;
       for (int col=0 ; col<w ; desttop+=2, col++)

       { 

           // This points at a "column" object.     
           //column = (column_t *)((byte *)patch + LONG(patch->columnofs[col])); 
           column=patch.columns[col];
           // For each post...
           for (int i=0;i<column.posts;i++){
               // Get pointer to post offset.
               ptr=column.postofs[i];
               // Get post delta
               short delta=column.postdeltas[i];
               // We skip delta, len and padding.
               //ptr+=3; 

               // Skip transparent rows...
               if (delta==0xFF) break;

               destPos = desttop+ n*delta*this.width;  

               // These lengths are already correct.
               for (int j=0;j<column.postlen[i];j++){
                   dest[destPos] = column.data[ptr++];
                   dest[destPos+1] = dest[destPos];
                   destPos += n*this.width;
               }
           }
       }
   } else  if (m==3) {
      // desttop=3*desttop;
       for (int col=0 ; col<w ; desttop+=3, col++)

       { 

           // This points at a "column" object.     
           //column = (column_t *)((byte *)patch + LONG(patch->columnofs[col])); 
           column=patch.columns[col];
           // For each post...
           for (int i=0;i<column.posts;i++){
               // Get pointer to post offset.
               ptr=column.postofs[i];
               // Get post delta
               short delta=column.postdeltas[i];
               // We skip delta, len and padding.
               //ptr+=3; 

               // Skip transparent rows...
               if (delta==0xFF) break;

               destPos = desttop + n*delta*this.width;  

               // These lengths are already correct.
               for (int j=0;j<column.postlen[i];j++){
                   dest[destPos] = column.data[ptr++];
                   dest[destPos+1] = dest[destPos];
                   dest[destPos+2] = dest[destPos];
                   destPos += n*this.width;    
               }
               
           }
       }
   }else  if (m==4) {
           //desttop=4*desttop;
           for (int col=0 ; col<w ; desttop+=4, col++)

           { 

               // This points at a "column" object.     
               //column = (column_t *)((byte *)patch + LONG(patch->columnofs[col])); 
               column=patch.columns[col];
               // For each post...
               for (int i=0;i<column.posts;i++){
                   // Get pointer to post offset.
                   ptr=column.postofs[i];
                   // Get post delta
                   short delta=column.postdeltas[i];
                   // We skip delta, len and padding.
                   //ptr+=3; 

                   // Skip transparent rows...
                   if (delta==0xFF) break;

                   destPos = desttop + n*delta*this.width;  

                   // These lengths are already correct.
                   for (int j=0;j<column.postlen[i];j++){
                       dest[destPos] = column.data[ptr++];
                       dest[destPos+1] = dest[destPos];
                       dest[destPos+2] = dest[destPos];
                       dest[destPos+3] = dest[destPos];
                       destPos += n*this.width;
                   }
               }
           }
       }
           else  {
              // desttop=m*desttop;
               for (int col=0 ; col<w ; desttop+=m, col++)

               { 

                   // This points at a "column" object.     
                   //column = (column_t *)((byte *)patch + LONG(patch->columnofs[col])); 
                   column=patch.columns[col];
                   // For each post...
                   for (int i=0;i<column.posts;i++){
                       // Get pointer to post offset.
                       ptr=column.postofs[i];
                       // Get post delta
                       short delta=column.postdeltas[i];
                       // We skip delta, len and padding.
                       //ptr+=3; 

                       // Skip transparent rows...
                       if (delta==0xFF) break;

                       destPos = desttop + n*delta*this.width;  

                       // These lengths are already correct.
                       for (int j=0;j<column.postlen[i];j++){
                           for (int k=0;k<m;k++)
                           dest[destPos+k] = column.data[ptr];
                           ptr++;
                           destPos += n*this.width;
                       }
                   }
               }
       
       
   }
   
   
    scaleSolid(m,n, scrn,m*patch.width);  
  }
  

  /** Pretty crude in-place scaling. It's fast, but only works full-screen 
   * Width needs to be specific, height is implied.
   *  */
  
  protected final void scaleSolid(int m, int n, int screen,int width){
      int height=screens[screen].length/width;
      for (int i=0;i<height;i+=n){
           
          for (int j=0;j<n-1;j++){

              System.arraycopy(screens[screen], (i+j)*width, screens[screen],(i+j+1)*width,width);
          }
      }
      
  }

  public void DrawPatchSolidScaled ( int x, int y,  int scrn, IVideoScale vs, patch_t patch ){
      this.DrawPatchSolidScaled(x, y, vs.getScalingX(), vs.getScalingY(),scrn, patch);
  }
  
  /**
   * V_DrawPatchFlipped 
   * Masks a column based masked pic to the screen.
   * Flips horizontally, e.g. to mirror face.
   * 
   * Currently UNUSED, as any occurence to it is also scaled and
   * best served by another function.
   * 
   * 
   */

  public final void DrawPatchFlipped ( int      x,   int        y,    int       scrn,  patch_t  patch ) 
  { 

      column_t    column; 
      int desttop;
      final byte[]  dest=screens[scrn];
      int     w; 
       
      y -= patch.topoffset; 
      x -= patch.leftoffset;
      

      if (RANGECHECK) 
          if (doRangeCheck(x,y,patch,scrn))
          {
      {
          System.err.print("Patch origin "+x+","+y +" exceeds LFB\n" );
          // No I_Error abort - what is up with TNT.WAD?
          I.Error("Bad V_DrawPatch in V_DrawPatchFlipped");
          }
      }
   
      if (scrn==0)
          this.MarkRect (x, y, patch.width, patch.height); 

   // Set x and y coords inside dest array.
    
        
      w = patch.width; 
      desttop = y*this.width+x;     
   // For each column..
      for (int col=0 ; col<w ; desttop++,col++)
      {         

          // This points at a "column" object.     
         // Notice the flipping on this one.
         // column = (column_t *)((byte *)patch + LONG(patch->columnofs[w-1-col]));  
         column=patch.columns[w-1-col];
         
         // For each post...
         //System.out.println("Column"+(w-1-col));
         for (int i=0;i<column.posts;i++){
             // Get pointer to post offset.
             int ptr=column.postofs[i];
             // Get post delta
             int delta=0xFF&column.data[ptr];
             // We skip delta, len and padding.
             //ptr+=3;
             if (delta==0xFF) break;
             int destPos = desttop+delta*this.width;
             //count = column.length; 

             // These lengths are already correct.
             for (int j=0;j<column.postlen[i];j++,   destPos += this.width){
                    dest[destPos] = column.data[ptr+j];
                    // next line
                  
             }
         }
      }
      
  } 
   
/**
 * V_DrawScaledPatch
 * like V_DrawPatch, but scaled 2,3,4 times the original size and position
 * this is used for menu and title screens, with high resolutions
 * 
 *added:05-02-98:
 *default params : scale patch and scale start
 *
 * Iniially implemented for Mocha Doom by _D_ (shamelessly ripped from 
 * Eternity Engine ;-), adapted to scale based on a scaling info object (VSI).
 * 
 * Unless overriden by flags, starting x and y are automatically
 * scaled (implied V_SCALESTART)
 *
 */
@Override
public void DrawScaledPatch(int x, int y, int scrn, IVideoScale VSI, patch_t patch)
{
    int col;
    column_t column;
    int desttop;
    final byte[] dest = screens[scrn&0xFF];
    //byte[] source;

    int dupx, dupy;
    int colfrac, rowfrac;

   // System.out.printf("V_DrawScaledPatch %d %d \n",x,y);
    // draw an hardware converted patch
    /*#ifdef HWRENDER
  if (rendermode != render_soft)
  {
      HWR_DrawPatch((GlidePatch_t *) patch, x, y, scrn);
      return;
  }
#endif*/

    // A very common operation, eliminates the need to pre-divide.
    if (C2JUtils.flags(scrn,V_PREDIVIDE)){
        x/=vs.getScalingX();
        y/=vs.getScalingY();
    }
    
    if (C2JUtils.flags(scrn, V_NOSCALEPATCH))
        dupx = dupy = 1;
    else
    {
        dupx = VSI.getScalingX();
        dupy = VSI.getScalingY();
    }

    // Eliminates.
    // MAES: added this fix so that non-zero patch offsets can be 
    // taken into account, regardless of whether we use pre-scaled
    // coords or not. Only Doomguy's face needs this hack for now.
    
    if (C2JUtils.flags(scrn, V_SCALEOFFSET)) {
    y -= patch.topoffset*dupx;
    x -= patch.leftoffset*dupy;
    } else {
        y -= patch.topoffset;
        x -= patch.leftoffset;
    }
    

    colfrac = dupx;
    rowfrac = dupy;

    //desttop = screens[scrn & 0xFF];
    if (C2JUtils.flags(scrn, V_NOSCALESTART))
        desttop = (y * this.width) + x;
    else
        desttop = (y * dupy * this.width) + (x * dupx) /*+ scaledofs*/;
    //destend = desttop + /*SHORT(*/patch.width/*)*/ * dupx;

    int w = patch.width*dupx;

    int colInc = 1;
    col = 0;
    if (C2JUtils.flags(scrn, V_FLIPPEDPATCH))
    {
        colInc = -1;
        col = w-1;//(/*SHORT(*/patch.width/*)*/ << fixed_t.FRACBITS) + colfrac;
    }
    
    for (; col >= 0 && col<w/*; desttop < destend*/; col += colInc, desttop++)
    {
        //column = (column_t *) ((byte *) patch + LONG(patch.columnofs[col >> FRACBITS]));
        column=patch.columns[col/colfrac];

        int destPos;
        int ptr = 0;
        int ptrOfs;

        //while (column.topdelta != 0xff)
        for (int i=0;i<column.posts;i++){
            {
                ptrOfs = column.postofs[i];//+3;
                ptr = 0;
                short delta = column.postdeltas[i];

                // Skip transparent rows...
                if (delta==0xFF) break;

                destPos = desttop + delta*dupy*this.width;  
                //dest = desttop + column.topdelta * dupy * this.width;

                //ofs = 0;
                //while (count-- > 0)
                for (int j=0;j<column.postlen[i]*dupy;j++)
                {
                    dest[destPos] = column.data[ptrOfs+ptr/rowfrac];
                    destPos += this.width;

                    ptr++;
                    //ofs += rowfrac;
                }

                //column = (column_t *) ((byte *) column + column.length + 4);
            }
        }
    }
}

  @Override
  public final void
  DrawBlock
  ( int       x,
    int       y,
    int       scrn,
    int       width,
    int       height,
    byte[]        src ) 
  { 
      // This is "screens[scrn]"
	  final  byte[]  dest=screens[scrn];  
       
  if (doRangeCheck(x, y, scrn))
      {
      I.Error("Bad V_DrawBlock");
      }

   
      this.MarkRect(x, y, width, height); 
   
      int destPos = /*screens[scrn] +*/ y*this.width +x;
      // MAES: making an assumption here. A BIIIIG one.
      int srcPos=0;
      while ((height--)>0) 
      { 
          //  memcpy (dest, src, width);
      System.arraycopy(src, srcPos, dest, destPos, width);
      srcPos += width; 
      destPos += this.width; 
      } 
  }
  
  @Override
  public final void DrawBlock(int x, int y, int scrn, int width, int height,
          byte[] src,int offset) {
      // This is "screens[scrn]"
      final byte[] dest = screens[scrn];
      
      if (doRangeCheck(x, y, scrn)) {
          I.Error("Bad V_DrawBlock");
      }

      this.MarkRect(x, y, width, height);

      int destPos = /* screens[scrn] + */y * this.width + x;
      // MAES: making an assumption here. A BIIIIG one.
      int srcPos = offset;
      while ((height--) > 0) {
              System.arraycopy(src, srcPos, dest, destPos, width);
          srcPos += width;
          destPos += this.width;
      }
  }

   

  /**
   * V_GetBlock
   * Gets a linear block of pixels from the view buffer.
   */


  public final void
  GetBlock
  ( int       x,
    int       y,
    int       scrn,
    int       width,
    int       height,
    byte[]        dest ) 
  { 
	  final byte[]  src=screens[scrn]; 
       
  if (RANGECHECK){
      if (doRangeCheck(x,y,scrn)){    
      I.Error ("Bad V_DrawBlock");
      }
      
   }
      int srcPos = y*this.width+x;
      int destPos=0;

      while ((height--)>0) 
      { 
      System.arraycopy(src, srcPos, dest, destPos, width);
      //memcpy (dest, src, width); 
      srcPos += width; 
      destPos += this.width; 
      } 
  }
  
  
  /** Replaces DrawPatchCol for bunny scrolled in Finale.
   * 
   * 
   */
  
  @Override
  public final void
  DrawPatchColScaled
  ( int       x, patch_t  patch,int col, 
          IVideoScale vs, int       screen )
  {
      column_t   column;
      int   source;
      final byte[]   dest;
      int   desttop;
      final int scale=vs.getScalingX();
      
      column = patch.columns[col];
      desttop = x*scale; // Scale X position.
      dest=screens[screen];
      // step through the posts in a column
      
      
      for (int i=0;i<column.posts;i++){
          // Get pointer to post offset.
          source=column.postofs[i];
          // Get post delta
          short delta=column.postdeltas[i];
          // We skip delta, len and padding.
          //source+=3;  NOT NEEDED ANYMORE, skipped by parsing.
          
          // Skip transparent rows...
          if (delta==0xFF) break;

            
          
          // Replicate each column scale times vertically,
          // with spaced pixels.
          final int startsource=source;
          for (int kl=0;kl<scale;kl++){
              int destPos = desttop + (delta+kl)*SCREENWIDTH;
          for (int j=0;j<column.postlen[i];j++){
              final byte data=column.data[source++];
              // replicate each column's pixel horizontally and vertically.
                  for (int k=0;k<scale;k++)
                  dest[destPos+k] =data; 
                 destPos += scale*SCREENWIDTH;
              }
          source=startsource;
          }
      }
  }

  public void setScreen(int index, int width, int height){
      this.screens[index]=new byte[width*height];
  }
  
  public final void takeScreenShot(int screen, String imagefile, IndexColorModel icm) throws IOException {
      
      BufferedImage b=new BufferedImage(this.getWidth(),this.getHeight(), BufferedImage.TYPE_BYTE_INDEXED, icm);
      
      
      int[] tmp=new int[this.screens[screen].length];
      for (int i=0;i<this.screens[screen].length;i++){
          tmp[i]=this.screens[screen][i];
      }
      
      b.getRaster().setPixels(0, 0, this.getWidth(),this.getHeight(), tmp);
      
      File outputFile =
          new File(
              imagefile+".png");
      ImageIO.write(b, "PNG", outputFile);
      
  }
  
  /*
  public final boolean isRasterNull(int screen){
      for (int i=0;i<screens[screen].length;i++){
          if (screens[screen][i]!=0) return false;
      }
      return true;
  } */
  
  public void setCurrentScreen(int screen){
	  this.usescreen=screen;
  }
  
  public void update(){
	// Override only if there's something else to be done, e.g. map palette to truecolor buffer  
  }
  
  public void report(BufferedImage[] b){
	    System.out.println("Main video buffer "+screens[0]);
	    for (int i=0;i<b.length;i++){
	    System.out.println(((Object)b[i].getRaster()).toString()+" "+b[i].getRaster().hashCode()+" "+((DataBufferByte)(b[i].getRaster().getDataBuffer())).getData());
	    }
	}
  
/** Internal method for setting up palettes (and gamma tables)
 * 
 */

public void createPalettes(byte[] paldata, short[][] gammadata, final int palettes, final int colors, final int stride,final int gammalevels){
	
	// Sanity check on supplied data length. If there is not enough data to create the specified palettes,
	// their number will be limited.
	
	if (paldata!=null) 	// As many as are likely contained
		maxpalettes=paldata.length/(colors*stride);
	else
		maxpalettes=0; // Do some default action on null palette.

	if (gammadata!=null) 	// As many as are likely contained
		maxgammas=gammadata.length;
	else
		maxgammas=0; // Do some default action on null gamma tables.
	
	if (maxgammas==0){
		gammadata=GammaTables.gammatables;
		maxgammas=GammaTables.gammatables.length;
	}
	

	// Enough data for all palettes. 
	// Enough data for all palettes. 
	if (maxpalettes>0 && maxgammas>0)
			specificPaletteCreation(paldata,gammadata,palettes,colors,stride,gammalevels);
		 else 
			 paletteRecovery();
    	  
      }
    
/** Override this in extending classes to perform specific actions depending on the
 *  type of renderer. It's better not to assign a default action, nor make assumptions
 *  on the underlying types of actual palettes
 * 
 * @param paldata
 * @param gammadata
 * @param palettes
 * @param colors
 * @param stride
 * @param gammalevels
 */

protected abstract void specificPaletteCreation(byte[] paldata,
		short[][] gammadata, 
		final int palettes, 
		final int colors,
		final int stride,
		final int gammalevels);

protected int lastcolor=-1;
protected byte[] scanline;

/**
 * Clear automap frame buffer or fi
 * MAES: optimized for efficiency, seen the lack of a proper "memset" in Java.
 * 
 */

@Override
public final void FillRect(int color,int screen, int x,int y,int width, int height) {
    
    if  (RANGECHECK) {
        if (x<0
                ||x+width >this.width
                || y<0
                || y+height>SCREENHEIGHT 
                || screen>4)
        {
            I.Error ("Bad V_FillRect");
        }
    }
    
    byte[] arr=screens[screen];
    
    // Do a "per scanline" copy. 
    int fromIndex=x+y*SCREENWIDTH;
    int toIndex=x+(y+height-1)*SCREENWIDTH;
    
    // First scanline.
    for (int i=0;i<width;i++)
    	arr[fromIndex+i]=(byte) color;
    
    for (;fromIndex<toIndex;fromIndex+=SCREENWIDTH){
    		System.arraycopy(arr,fromIndex,arr,fromIndex+SCREENWIDTH,width);
        }
}

/**
 * V_Fillrect
 */
@Override
public void FillRect(int srcx, int srcy, int width, int height, int destscrn) {
    // These are pointers inside an array.
    final byte[] dest = screens[destscrn];

    if (RANGECHECK) {
        if (srcx < 0 || srcx + width > this.width || srcy < 0
                || srcy + height > SCREENHEIGHT || destscrn > 4) {
            I.Error("Bad V_FillRect");
        }
    }
    this.MarkRect(srcx, srcy, width, height);

    // MAES: these were pointers to a specific position inside the screen.
    int srcPos = this.width * srcy + srcx;

    for (; height > 0; height--) {
        for (int i = 0; i < width; i++) {
            dest[srcPos + i] = 0;
        }
        // memcpy (dest, src, width);
        srcPos += this.width;
    }

}

/** Should return colormaps, if you ever move their management in here.
 * 
 */

public final byte[][] getColorMaps(){
    return null;
}


}

package v;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferUShort;
import static rr.LightsAndColors.LIGHTLEVELS;
import m.BBox;

public class BufferedRenderer16 extends SoftwareVideoRenderer16 {
	
static final String rcsid = "$Id: BufferedRenderer16.java,v 1.5 2016/07/04 07:52:26 velktron Exp $";

/** Buffered Renderer has a bunch of images "pegged" to the underlying arrays */

public BufferedImage[] screenbuffer=new BufferedImage[5];

public BufferedRenderer16(int w, int h) {
    super(w,h);
}

@Override
public final void Init () 
{ 
 int		i;
 for (i=0 ; i<4 ; i++){
	//screens[i] = new byte[this.getHeight()*this.getWidth()];
     this.setScreen(i, this.width, this.height);     
	}
     dirtybox=new BBox();
}

/** This implementation will "tie" a bufferedimage to the underlying byte raster.
 * 
 * NOTE: this relies on the ability to "tap" into a BufferedImage's backing array,
 * in order to have fast writes without setpixel/getpixel. If that is not possible,
 * then we'll need to use a special renderer.
 * 
 */
@Override
public final void setScreen(int index, int width, int height){

	if (screens[index]==null){
		screenbuffer[index]=new BufferedImage(width,height,BufferedImage.TYPE_USHORT_555_RGB);
    
    	screens[index]=((DataBufferUShort)screenbuffer[index].getRaster().getDataBuffer()).getData();
		}
}

public void setPalette(int palette){
    this.usepalette=palette%maxpalettes;

    // Invalidate cached graphics, otherwise older colormaps
    // will persist.
    this.clearCaches();

    
    // Tint the current set of colormaps.
    getCachedCmap(palette);

    
	//this.currentpal=palette%maxpalettes;
	this.currentscreen=this.screenbuffer[0];
	
}

@Override
public void setUsegamma(int gamma) {
	this.usegamma=gamma%maxgammas;

   // Invalidate palette cache.
    super.clearPalettes();

	
	// Re-synthesize current palette.
	setPalette(usepalette);
}

public void setCurrentScreen(int screen){
	  super.setCurrentScreen(screen);
	  this.currentscreen=this.screenbuffer[0];
}

@Override
protected final void specificPaletteCreation(byte[] paldata,
        short[][] gammadata, 
        final int palettes, 
        final int colors,
        final int stride,
        final int gammalevels){

      System.out.printf("Enough data for %d palettes",maxpalettes);
      System.out.printf("Enough data for %d gamma levels",maxgammas);
      
      //this.palettes=new int[maxpalettes*maxgammas][];
      this.palettes=new int[maxpalettes][];
      
      // Apply gammas a-posteriori, not a-priori.
      // Initial palette can be neutral or based upon "gamma 0",
      // which is actually a bit biased and distorted
      
      for (int z=0;z<1;z++){
          
          // For each palette
          for (int y=0;y<maxpalettes;y++){
              this.palettes[z*maxpalettes+y]=new int[colors];
              
              for (int x=0;x<colors;x++){
                  int r=gammadata[z][0xFF&paldata[y*colors*stride+stride*x]]; // R
                  int g=gammadata[z][0xFF&paldata[1+y*colors*stride+stride*x]]; // G
                  int b=gammadata[z][0xFF&paldata[2+y*colors*stride+stride*x]]; // B
                  int color=0xFF000000|r<<16|g<<8|b;
                  this.palettes[z*maxpalettes+y][x]=color;
                }
            }
      }
      
      // Set base colormap
      
      cmap_base=PaletteGenerator.RF_BuildLights15(this.palettes[0], NUMLIGHTS);
      cmap_work=PaletteGenerator.RF_BuildLights15(this.palettes[0], NUMLIGHTS);

}

public int getBaseColor(int color){
	return cmap_work[0][color];
}

}

package v;

import static data.Defines.RANGECHECK;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import rr.column_t;
import rr.patch_t;
import m.BBox;

/** N.B. this renderer just uses 8-bit resources and 256 color, but renders directly onto a 
 *  24-bit canvas, so technically it should be a byte[],byte[] renderer. It's not a "true color" 
 *  renderer in the sense of using extended colormaps etc. 
 * 
 * @author velktron
 *
 */

public class ParallelTrueColorRenderer extends SoftwareVideoRenderer<byte[],byte[]> {
	
static final String rcsid = "$Id: ParallelTrueColorRenderer.java,v 1.3 2016/06/06 14:27:55 velktron Exp $";


/* With a truecolour raster, some things are indeed easier */
protected int[][] palettes;
protected int[] raster;
protected final int nrOfProcessors;
protected Runnable[] paletteThreads;
protected final Executor executor;

public ParallelTrueColorRenderer(){
super();
Runtime runtime = Runtime.getRuntime();
nrOfProcessors = runtime.availableProcessors();
updateBarrier=new CyclicBarrier(nrOfProcessors+1);
paletteThreads=new PaletteThread[nrOfProcessors];
int len=this.getHeight()*this.getWidth();
int chunk=len/nrOfProcessors;
for (int i=0;i<nrOfProcessors;i++){
	paletteThreads[i]=new PaletteThread(i*chunk,(i+1)*chunk);
}
this.executor=Executors.newFixedThreadPool(nrOfProcessors);
}

public ParallelTrueColorRenderer(int w,int h){
    // Defaults
    super(w,h);
    Runtime runtime = Runtime.getRuntime();
    nrOfProcessors = runtime.availableProcessors();
    updateBarrier=new CyclicBarrier(nrOfProcessors+1);
    paletteThreads=new PaletteThread[nrOfProcessors];
    int len=w*h;
    int chunk=len/nrOfProcessors;
    for (int i=0;i<nrOfProcessors;i++){
    	paletteThreads[i]=new PaletteThread(i*chunk,(i+1)*chunk);
    }
    this.executor=Executors.newFixedThreadPool(nrOfProcessors);
}

public void Init () 
{ 
 int		i;
 for (i=0 ; i<screens.length ; i++){
	screens[i] = new byte[this.getHeight()*this.getWidth()];
	}
     dirtybox=new BBox();
     
  // Using ARGB is half the speed, WTF? While RGB is almost as fast as indexed. Go figure.
  this.currentscreen=new BufferedImage(width,height, BufferedImage.TYPE_INT_RGB);
  this.mapInternalRasterToBufferedImage((BufferedImage) currentscreen);
}

@Override
public void setUsegamma(int gammalevel) {
	this.usegamma=gammalevel%maxgammas;
	
}

@Override
public void setPalette(int palette) {
	this.usepalette=palette%maxpalettes;
}

@Override
protected final void specificPaletteCreation(byte[] paldata,
		short[][] gammadata, 
		final int palettes, 
		final int colors,
		final int stride,
		final int gammalevels){

	  System.out.printf("Enough data for %d palettes",maxpalettes);
	  System.out.printf("Enough data for %d gamma levels",maxgammas);
	  
	  this.palettes=new int[maxgammas*maxpalettes][];
	  
	  for (int z=0;z<maxgammas;z++){
		  
		  // For each palette
		  for (int y=0;y<maxpalettes;y++){
			  this.palettes[z*maxpalettes+y]=new int[colors];
			  
			  for (int x=0;x<colors;x++){
				  int r=gammadata[z][0xFF&paldata[y*colors*stride+stride*x]]; // R
				  int g=gammadata[z][0xFF&paldata[1+y*colors*stride+stride*x]]; // G
				  int b=gammadata[z][0xFF&paldata[2+y*colors*stride+stride*x]]; // B
				  int color=0xFF000000|r<<16|g<<8|b;
				  this.palettes[z*maxpalettes+y][x]=color;
			  	}
	  		}
	  }

}

/** Hotlinks a 32-bit "canvas" (the raster int[] array) to an externally supplied
 *  buffered image. Now whatever we write into raster, will appear in the image as well,
 *  without using drawing primitives. Necessary for fast rendering.
 *  
 * @param b
 */

private void mapInternalRasterToBufferedImage(BufferedImage b){
    raster=((DataBufferInt)(b.getRaster().getDataBuffer())).getData();
    
}

/** Update "canvas" to one of the internal screens.
 *  
 * @param screen
 * @param b
 */

@Override
public  final void update()  {
	
	for (int i=0;i<this.nrOfProcessors;i++){
		executor.execute(paletteThreads[i]);
	}
	try {
		updateBarrier.await();
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (BrokenBarrierException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
	/*
    final byte[] scr=this.screens[usescreen];
    final int length=scr.length; 
    final int[] pal=this.palettes[usegamma*maxpalettes+usepalette];
    for (int i=0;i<length;i+=16){
        raster[i]=pal[0xFF&scr[i]];
        raster[i+1]=pal[0xFF&scr[i+1]];
        raster[i+2]=pal[0xFF&scr[i+2]];
        raster[i+3]=pal[0xFF&scr[i+3]];
        raster[i+4]=pal[0xFF&scr[i+4]];
        raster[i+5]=pal[0xFF&scr[i+5]];
        raster[i+6]=pal[0xFF&scr[i+6]];
        raster[i+7]=pal[0xFF&scr[i+7]];
        raster[i+8]=pal[0xFF&scr[i+8]];
        raster[i+9]=pal[0xFF&scr[i+9]];
        raster[i+10]=pal[0xFF&scr[i+10]];
        raster[i+11]=pal[0xFF&scr[i+11]];
        raster[i+12]=pal[0xFF&scr[i+12]];
        raster[i+13]=pal[0xFF&scr[i+13]];
        raster[i+14]=pal[0xFF&scr[i+14]];
        raster[i+15]=pal[0xFF&scr[i+15]];

    } */
}

protected final CyclicBarrier updateBarrier;

private class PaletteThread implements Runnable{

	private final int start;
	private final int stop;
	
	public PaletteThread(int start, int stop){
		this.start=start;
		this.stop=stop;
	}
	
	@Override
	public void run() {
		
    	final byte[] scr=screens[usescreen];
    	final int[] pal=palettes[usegamma*maxpalettes+usepalette];
	    for (int i=start;i<stop;i+=16){
	    	raster[i]=pal[0xFF&scr[i]];
	        raster[i+1]=pal[0xFF&scr[i+1]];
	        raster[i+2]=pal[0xFF&scr[i+2]];
	        raster[i+3]=pal[0xFF&scr[i+3]];
	        raster[i+4]=pal[0xFF&scr[i+4]];
	        raster[i+5]=pal[0xFF&scr[i+5]];
	        raster[i+6]=pal[0xFF&scr[i+6]];
	        raster[i+7]=pal[0xFF&scr[i+7]];
	        raster[i+8]=pal[0xFF&scr[i+8]];
	        raster[i+9]=pal[0xFF&scr[i+9]];
	        raster[i+10]=pal[0xFF&scr[i+10]];
	        raster[i+11]=pal[0xFF&scr[i+11]];
	        raster[i+12]=pal[0xFF&scr[i+12]];
	        raster[i+13]=pal[0xFF&scr[i+13]];
	        raster[i+14]=pal[0xFF&scr[i+14]];
	        raster[i+15]=pal[0xFF&scr[i+15]];

	    }
        try {
			updateBarrier.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

public final void DrawPatch
( int       x,
int     y,
int     scrn,
patch_t patch ) 
{ 

 column_t   column; 
 int    desttop;
 final  byte[] dest=screens[scrn];
 int        w; 
     
 y -= patch.topoffset; 
 x -= patch.leftoffset; 
if (RANGECHECK) 
 if (doRangeCheck(x,y,patch,scrn))
 {
   System.err.print("Patch at "+x+","+y+" exceeds LFB\n");
   // No I_Error abort - what is up with TNT.WAD?
   System.err.print("V_DrawPatch: bad patch (ignored)\n");
   return;
 }

 if (scrn==0)
    this.MarkRect (x, y, patch.width, patch.height); 

     
 w = patch.width; 
 desttop = x+this.width*y; 
 // For each column..
 int destPos;
 int ptr=0;
 for (int col=0 ; col<w ; desttop++, col++,x++)
 { 
    // This points at a "column" object.     
    //column = (column_t *)((byte *)patch + LONG(patch->columnofs[col])); 
    column=patch.columns[col];
    // For each post...
    for (int i=0;i<column.posts;i++){
        // Get pointer to post offset.
        ptr=column.postofs[i];
        // Get post delta
        short delta=column.postdeltas[i];
        // We skip delta, len and padding.
        // ptr+=3; NOT NEEDED< pre-skipped at parsing. 
        
        // Skip transparent rows...
        if (delta==0xFF) break;

        destPos = desttop + delta*this.width;  
        
        // These lengths are already correct.
        for (int j=0;j<column.postlen[i];j++){
               dest[destPos] = column.data[ptr++];
               destPos += this.width;
        }
    }
 }
    
    
}

}


package v;

import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.IndexColorModel;
import java.awt.image.RasterOp;
import java.awt.image.WritableRaster;

import m.BBox;

public class BufferedRenderer extends SoftwareVideoRenderer8 {
	
static final String rcsid = "$Id: BufferedRenderer.java,v 1.18 2012/09/24 17:16:23 velktron Exp $";

/** Buffered Renderer has a bunch of images "pegged" to the underlying arrays */

private BufferedImage[] screenbuffer;

/** Indexed renderers keep separate color models for each colormap (intended as gamma levels) and 
 * palette levels */
private IndexColorModel[][] cmaps;

public BufferedRenderer(int w, int h, IndexColorModel icm) {
    super(w,h);
    this.setIcm(icm);
}

/** Normally, you only have the palettes available ONLY after you read the palette from disk.
 *  So use the super contructor, and then this when the palettes are available.
 *  
 * @param icm2
 */

public void setIcm(IndexColorModel icm2) {
    this.icm=icm2;
    
}

public BufferedRenderer(int w, int h) {
    super(w,h);
}

// Used only for internal status.
private IndexColorModel icm;

@Override
public final void Init () 
{ 
 int		i;
 for (i=0 ; i<4 ; i++){
	//screens[i] = new byte[this.getHeight()*this.getWidth()];
     this.setScreen(i, this.width, this.height);     
	}
     dirtybox=new BBox();
}

/** This actually creates a raster with a fixed underlying array, but NOT the images
 *  themselves. So it's possible to have "imageless" rasters (unless you specifically
 *  request to make them visible, of course).
 *  
 */

@Override
public final void setScreen(int index, int width, int height){
	
    // We must FIRST initialize the image, so that the (immutable) color model will be set.
    if (this.icm==null){
    	final byte[] dummy=new byte[256];
    	for (int i=0;i<dummy.length;i++)
    		dummy[i]=(byte) i;    	
    	icm=new IndexColorModel(8,256,dummy,dummy,dummy);
    }
    
    r[index]=icm.createCompatibleWritableRaster(width,height);
    
    // Only create non-visible data, pegged to the raster. Create visible images
    // only on-demand.
    
    screens[index]=((DataBufferByte)r[index].getDataBuffer()).getData();

}


/** We only call this once we have a stable WritableRaster, and we only want
 *  a different colormodel (e.g. after changing gamma). It's slower than keepings
 *  severerl BufferedImages ready, so it's only used when changing gamma. The
 *  backing screen, array etc. should not have changed at this moment.
 * 
 * @param index
 * @param r
 */

private final BufferedImage createScreen(int index,IndexColorModel icm, WritableRaster r){
    return new BufferedImage(icm,r,false,null);
}

/*
public BufferedImage mapBufferedImageToScreen(int screen, IndexColorModel icm){
    // Map databuffer to one of the screens.
    DataBufferByte dbb=new DataBufferByte(screens[screen],screens[screen].length);
    BufferedImage b=new BufferedImage(this.getWidth(),this.getHeight(),BufferedImage.TYPE_BYTE_INDEXED,icm);
    WritableRaster r=WritableRaster.createPackedRaster(dbb,b.getWidth(), b.getHeight(), 8,
        new Point(0,0));
    b.setData(r);
    
    return b;
    
} */

/*
public BufferedImage cloneScreen(int screen, IndexColorModel icm){
    BufferedImage b=new BufferedImage(this.getWidth(),this.getHeight(),BufferedImage.TYPE_BYTE_INDEXED,icm);
    b.setData(screenbuffer[0].getRaster());
    return b;
    
} */




public final void changePalette(int pal){
    this.usepalette=(pal<<8);//+0x00FF;
    //this.usepalette=/*(pal<<8)+*/0xFF;
    
}

/** Get a bunch of BufferedImages "pegged" on the same output screen of this
 *  Doom Video Renderer, but with different palettes, defined in icms[].
 *  This is VERY speed efficient assuming that an IndexedColorModel will be used,
 *  rather than a 32-bit canvas, and memory overhead is minimal. Call this ONLY
 *  ONCE when initializing the video renderer, else it will invalidate pretty much
 *  everything in an ongoing game.
 * 
 *  NOTE: this will actually CREATE a new byte array for the screen, so it's important
 *  that this is called BEFORE anything else taps into it.
 * 
 * @param screen
 * @param icms
 * @return
 */

private BufferedImage[] createScreenForPalettes(int screen,IndexColorModel[] icms) {
        
		// These screens represent a complete range of palettes for a specific gamma
		// and specific screen
        BufferedImage[] b=new BufferedImage[icms.length];
        
        
        // MEGA hack: all images share the same raster data as screenbuffer[screen]
        // If this is the first time we called this method, the actually backing array
        // will be actually created. If not...

        // Create the first of the screens.
        this.icm=icms[0];
        
        if (r[screen]==null){
        	// This will create the first buffered image (and its data array)/
            // as screenbuffer[0]	   	
        	setScreen(screen,this.getWidth(),this.getHeight());
       		}
        
        // This is the base image for this set of palettes (usually index 0).
       
       
        // Create the rest of the screens (with different palettes) on the same raster.
        for (int i=0;i<icms.length;i++){
        	 b[i]=createScreen(screen,icms[i],r[screen]);
        }
        
        return b;
        
    }

protected final void specificPaletteCreation(byte[] paldata,
		short[][] gammadata, 
		final int palettes, 
		final int colors,
		final int stride,
		final int gammalevels){

	  System.out.printf("Enough data for %d palettes",maxpalettes);
	  System.out.printf("Enough data for %d gamma levels",maxgammas);
	  
	  // Create as gamma levels as specified.
	  cmaps=new IndexColorModel[maxgammas][];
	  
	  // First set of palettes, normal gamma.
	  cmaps[0]=new IndexColorModel[maxpalettes];

	  // Now we have our palettes.
	  for (int i=0;i<maxpalettes;i++){
		  cmaps[0][i]=new IndexColorModel(8, colors,paldata, i*stride*colors, false);
	  		}
  
  // Wire the others according to the gamma table.
	  byte[] tmpcmap=new byte[colors*stride];
	  
	  // For each gamma value...
	  for (int j=1;j<maxgammas;j++){
		  
		  cmaps[j]=new IndexColorModel[maxpalettes];
		  
		  // For each palette
		  for (int i=0;i<maxpalettes;i++){
			  
			  for (int k=1;k<256;k++){
				  tmpcmap[3*k]=(byte) gammadata[j][0x00FF&paldata[i*colors*stride+stride*k]]; // R
				  tmpcmap[3*k+1]=(byte) gammadata[j][0x00FF&paldata[1+i*colors*stride+stride*k]]; // G
				  tmpcmap[3*k+2]=(byte) gammadata[j][0x00FF&paldata[2+i*colors*stride+stride*k]]; // B
			  	}

			  cmaps[j][i]=new IndexColorModel(8, 256,tmpcmap, 0, false);
	  		}
	  }

}

private WritableRaster[] r=new WritableRaster[5];

public void setPalette(int palette){
	this.currentpal=palette%maxpalettes;
	this.currentscreen=this.screenbuffer[currentpal];
}

@Override
public void setUsegamma(int gamma) {
	this.usegamma=gamma%maxgammas;
	// Changing gamma also "fixes" the screens!
	this.setCurrentScreen(0);
}

public void setCurrentScreen(int screen){
	  super.setCurrentScreen(screen);
	  this.screenbuffer=this.createScreenForPalettes(usescreen, cmaps[usegamma]);
	  this.currentscreen=this.screenbuffer[currentpal];
}

public IndexColorModel getPalette(){
    return cmaps[0][this.usepalette];
    }

}

//$Log: BufferedRenderer.java,v $
//Revision 1.18  2012/09/24 17:16:23  velktron
//Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
//Revision 1.17.2.3  2012/09/24 16:56:06  velktron
//New hierarchy, less code repetition.
//

package v;

/** Interface for an object that conveys screen resolution/scaling
 * information, meant to replace the static declarations in Defines.
 * 
 * Classes that rely on resolution changes should implement an interface
 * called "IVideoScaleAware", which should support
 * 
 * @author admin
 *
 */

public interface IVideoScale {
    
  //It is educational but futile to change this
  //scaling e.g. to 2. Drawing of status bar,
  //menues etc. is tied to the scale implied
  //by the graphics.

  public static double INV_ASPECT_RATIO =   0.625; // 0.75, ideally

  //
  // For resize of screen, at start of game.
  // It will not work dynamically, see visplanes.
  //
  public static final int BASE_WIDTH =     320;
  public static final int BASE_HEIGHT=     (int) (INV_ASPECT_RATIO*320); // 200

    
    int getScreenWidth();
    int getScreenHeight();
    int getScalingX();
    int getScalingY();
    
    /** Safest global scaling for fixed stuff like menus, titlepic etc */
    int getSafeScaling();
    
    /** Get floating point screen multiplier. Not recommended, as it causes
     *  visual glitches. Replace with safe scale, whenever possible */
    float getScreenMul();
    
    /** Future, should signal aware objects that they should
     * refresh their resolution-dependent state, structures, variables etc.
     * 
     * @return
     */
    boolean changed();
    
}

package v;

public class VideoScaleInfo
        implements IVideoScale {
    
   protected float scale;
   protected int width;
   protected int height;
   protected int bestScaleX;
   protected int bestScaleY;
   

   protected int bestSafeScale;
   
   /** Scale is intended as a multiple of the base resolution, 320 x 200.
    *  If changing the ratio is also desired, then keep in mind that
    *  the base width is always considered fixed, while the base height
    *  is not. 
    * 
    * @param scale
    */
   
   public VideoScaleInfo(float scale){
       this.scale=scale;
       width=(int) (BASE_WIDTH*scale);
       height=(int) (scale*BASE_WIDTH*INV_ASPECT_RATIO);
       bestScaleX= (int) Math.floor((float)width/(float)BASE_WIDTH);
       bestScaleY= (int) Math.floor((float)height/(float)BASE_HEIGHT);
       bestSafeScale= Math.min(bestScaleX, bestScaleY);
       
   }
   
   /** It's possible to specify other aspect ratios, too, keeping in mind
    *  that there are maximum width and height limits to take into account,
    *  and that scaling of graphics etc. will be rather problematic. Default
    *  ratio is 0.625, 0.75 will give a nice 4:3 ratio.
    *  
    *  TODO: pretty lame...
    *  
    * @param scale
    * @param ratio
    */
   
   public VideoScaleInfo(float scale, float ratio){
       this.scale=scale;
       width=(int) (BASE_WIDTH*scale);
       height=(int) (scale*BASE_WIDTH*ratio);
       bestScaleX= (int) Math.floor((float)width/(float)BASE_WIDTH);
       bestScaleY= (int) Math.floor((float)height/(float)BASE_HEIGHT);
       bestSafeScale= Math.min(bestScaleX, bestScaleY);
       
   }
      
    @Override
    public int getScreenWidth() {
        return width;
    }

    @Override
    public int getScreenHeight() {      
        return height;
    }

    @Override
    public int getScalingX() {
        return bestScaleX;
    }

    @Override
    public int getScalingY() {
        return bestScaleY;
    }

    @Override
    public int getSafeScaling() {
        return bestSafeScale;
    }

    @Override
    public boolean changed() {
        return false;
    }

    @Override
    public float getScreenMul() {        
        return scale;
    }

}

package doom64;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

public class MapThing implements CacheableDoomObject{

	public short x;
    public short y;    
    public short z;
    public short angle;
    public short type;
    public short flags;    
    public short id;
	
	public MapThing() {
		// TODO Auto-generated constructor stub
	}

	@Override
	public void unpack(ByteBuffer buf) throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.x = buf.getShort();
        this.y = buf.getShort();
        this.z = buf.getShort();
        this.angle = buf.getShort();
        this.type = buf.getShort();
        this.flags = buf.getShort();
        this.id = buf.getShort();		
	}

    public static int sizeOf() {
        return 14;
    }

	
}

package doom64;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

public class MapLinedef implements CacheableDoomObject{
	
	public short v1;
	public short v2;
	public int flags;
	public short special;
	public short tag;
	public short left;
	public short right;

	public MapLinedef() {
	}
	
    public void unpack(ByteBuffer buf)
            throws IOException {
    buf.order(ByteOrder.LITTLE_ENDIAN);
    this.v1 = buf.getShort();
    this.v2 = buf.getShort();
    this.flags = buf.getInt();
    this.special = buf.getShort();
    this.tag = buf.getShort();
    this.left= buf.getShort();
    this.right= buf.getShort();
    }
    
    public static int sizeOf() {
        return 16;
    }

    
    /* These are Doom 64-specific linedef flags (not all of them) */
    public static final int D64_ML_RENDERMIDDLE= 0x200;
    public static final int D64_ML_NOT_CLIPPED= 0x400;
    public static final int D64_ML_DONTPEGMIDDLE= 0x800;
    public static final int D64_ML_KILLTRIGGER= 0x1000;
    public static final int D64_ML_SWMASK1= 0x2000;
    public static final int D64_ML_SWMASK2= 0x4000;
    public static final int D64_ML_SWMASK3= 0x8000;
    
}

package doom64;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;

public class MapLights implements CacheableDoomObject {	
	
	/** N.B.: read those as unsigned bytes */
	public short red,green,blue;
	public byte pad;
	public short tag;
	

	public MapLights() {
		// TODO Auto-generated constructor stub
	}

	public MapLights(short i) {
		this.red=this.green=this.blue= i;
	}

	@Override
	public void unpack(ByteBuffer buf) throws IOException {
		buf.order(ByteOrder.LITTLE_ENDIAN);
		this.red=(short) (0x00FF&buf.get());
		this.green=(short) (0x00FF&buf.get());
		this.blue=(short) (0x00FF&buf.get());
		this.pad=buf.get();
		this.tag=buf.getShort();
	}
	
	public final static int sizeOf(){
		return 6;
	}
	
	public short greyscaleLightLevel(){
		return (short) (0.2989 * red + 0.5870 * green + 0.1140 * blue); 
	}

}

package doom64;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

public class MapSidedef implements CacheableDoomObject{
	
    public short xoffset;

    public short yoffset;

    /* unsigned short hashes for DOOM64EX */
    public char toptexture;

    public char bottomtexture;

    public char midtexture;
    
    public short sector;    

	public MapSidedef() {
		// TODO Auto-generated constructor stub
	}

	@Override
	public void unpack(ByteBuffer buf) throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.xoffset= buf.getShort();
        this.yoffset= buf.getShort();
        this.toptexture= buf.getChar();
        this.bottomtexture= buf.getChar();
        this.midtexture= buf.getChar();
        this.sector = buf.getShort();
	}
	
    public static int sizeOf() {
        return 12;
    }
}

package doom64;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

public class MapVertex implements CacheableDoomObject{
	
    public int x;
    public int y;

	public MapVertex() {
	}

	@Override
	public void unpack(ByteBuffer buf) throws IOException {
		buf.order(ByteOrder.LITTLE_ENDIAN);		
		x=buf.getInt();
		y=buf.getInt();		
	}

	public static final int sizeOf() {
		return 8;
	}

}

package doom64;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

public class MapSector implements CacheableDoomObject{

	
	public short floorheight;
	public short ceilingheight;
	public char floorpic;
	public char ceilingpic;
	public short floorcolor;
	public short ceilingcolor;
	public short thingcolor;
	public short walltopcolor;
	public short wallbottomcolor;
	public short special;
	public short tag;
	public short flags;
	
	public MapSector() {
		// TODO Auto-generated constructor stub
	}

	@Override
	public void unpack(ByteBuffer buf) throws IOException {
        // ACHTUNG: the only situation where we'd
        // like to read memory-format sector_t's is from
        // savegames, and in vanilla savegames, not all info
        // is saved (or read) from disk.
		buf.order(ByteOrder.LITTLE_ENDIAN);
        this.floorheight = buf.getShort();
        this.ceilingheight = buf.getShort();
        this.floorpic = (char) buf.getShort();
        this.ceilingpic = (char) buf.getShort();
    	this.floorcolor= buf.getShort();
    	this.ceilingcolor= buf.getShort();
    	this.thingcolor= buf.getShort();
    	this.walltopcolor= buf.getShort();
    	this.wallbottomcolor= buf.getShort();
        
        this.special = buf.getShort();
        this.tag = buf.getShort();
        this.flags= buf.getShort();
    }
	
    public static int sizeOf() {
        return 24;
    }

	private static final ByteBuffer iobuffer=ByteBuffer.allocate(MapSector.sizeOf());

}

package savegame;
import static data.Limits.*;
import i.DoomStatusAware;
import i.IDoomSystem;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

import data.info;
import doom.DoomStatus;
import doom.player_t;
import doom.think_t;
import doom.thinker_t;

import p.AbstractLevelLoader;
import p.Actions;
import p.ThinkerList;
import p.ceiling_t;
import p.floormove_t;
import p.glow_t;
import p.lightflash_t;
import p.mobj_t;
import p.plat_t;
import p.strobe_t;
import p.vldoor_t;
import rr.line_t;
import rr.sector_t;
import rr.side_t;
import utils.C2JUtils;

public class VanillaDSG implements IDoomSaveGame, DoomStatusAware {
    
    VanillaDSGHeader header;
    DoomStatus<?,?> DS;
    AbstractLevelLoader LL;
    Actions A;
    IDoomSystem I;
    
    public VanillaDSG(){
        
    }
    

    @Override
    public void setThinkerList(ThinkerList li) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public IDoomSaveGameHeader getHeader() {
        return header;
    }

    @Override
    public void setHeader(IDoomSaveGameHeader header) {
        this.header=(VanillaDSGHeader) header;
        
    }

    private DataInputStream f;
    private DataOutputStream fo;
    private int maxsize;
    
    @Override
    public boolean doLoad(DataInputStream f)
            {
        try {
        this.f=f;
        maxsize=f.available();
        System.out.println("Max size "+maxsize);
        this.header=new VanillaDSGHeader();
        header.read(f);
        UnArchivePlayers();
        UnArchiveWorld();
        UnArchiveThinkers();
        UnArchiveSpecials();
        byte terminator=f.readByte();
        if (terminator != 0x1D) return false;
        else return true;
        } catch (Exception e){
            e.printStackTrace();
            System.err.printf("Error while loading savegame! Cause: %s",e.getMessage());
            return false; // Needed to shut up compiler.
        }
        
    }
    
    
 /**
  * P_UnArchivePlayers
 * @throws IOException 
  */
 protected void UnArchivePlayers () throws IOException
 {
     int     i;
     int     j;
     
     for (i=0 ; i<MAXPLAYERS ; i++)
     {
     // Multiplayer savegames are different!
     if (!DS.playeringame[i])
         continue;
     PADSAVEP(f,maxsize); // this will move us on the 52th byte, instead of 50th.
     DS.players[i].read(f);
     
     //memcpy (&players[i],save_p, sizeof(player_t));
     //save_p += sizeof(player_t);
     
     // will be set when unarc thinker
     DS.players[i].mo = null;   
     DS.players[i].message = null;
     DS.players[i].attacker = null;

     
     for (j=0 ; j<player_t.NUMPSPRITES ; j++)
     {
         if (C2JUtils.eval(DS.players[i].psprites[j].state))
         {
             // MAES HACK to accomoadate state_t type punning a-posteriori
             DS.players[i].psprites[j].state =
             info.states[DS.players[i].psprites[j].readstate];
         }
     }
     }
 }
    
 /**
  * P_UnArchivePlayers
 * @throws IOException 
  */
 protected void ArchivePlayers () throws IOException
 {
     for (int i=0 ; i<MAXPLAYERS ; i++)
     {
     // Multiplayer savegames are different!
     if (!DS.playeringame[i])
         continue;
     
     PADSAVEP(fo); // this will move us on the 52th byte, instead of 50th.

     // State will have to be serialized when saving.
     DS.players[i].write(fo);

     //System.out.printf("Player %d has mobj hashcode %d",(1+i),DS.players[i].mo.hashCode());
     }
 }

 //
//P_ArchiveWorld
//
protected void ArchiveWorld () throws IOException
{
  int         i;
  int         j;
  sector_t       sec;
  line_t     li;
  side_t     si;
  
  // do sectors (allocate 14 bytes per sector)
  ByteBuffer buffer=ByteBuffer.allocate(LL.numsectors*14);
  buffer.order(ByteOrder.LITTLE_ENDIAN);
  
  deAdaptSectors();
  for (i=0; i<LL.numsectors ; i++)
  {
      sec=LL.sectors[i];
      // MAES: sectors are actually carefully
      // marshalled, so we don't just read/write
      // their entire memory footprint to disk.
      sec.pack(buffer);
  }
  
  adaptSectors();
  fo.write(buffer.array(),0,buffer.position());
  
  // do lines 
  // Allocate for the worst-case scenario (6+20 per line)
  buffer=ByteBuffer.allocate(LL.numlines*(6+20));
  buffer.order(ByteOrder.LITTLE_ENDIAN);
  buffer.position(0); 
  
  //final side_t test1=new side_t(0x11111111,0x11111111,(short) 0x1111,(short)0x1111,(short)0x1111,null);
  //final side_t test2=new side_t(0x22222222,0x22222222,(short) 0x2222,(short)0x2222,(short)0x2222,null);
  
  for (i=0; i<LL.numlines ; i++)
  {
  li=LL.lines[i];
  li.pack(buffer);

  for (j=0 ; j<2 ; j++)
  {
      if (li.sidenum[j] == line_t.NO_INDEX)
      continue;
      si = LL.sides[li.sidenum[j]];
      si.pack(buffer);
      //if (j==0) test1.pack(buffer);
      //else test2.pack(buffer);
      
  }
  }
  
  int write=buffer.position();
  fo.write(buffer.array(),0,write);
}

 
//
//P_UnArchiveWorld
//
protected final void UnArchiveWorld () throws IOException
{
  int         i;
  int         j;
  sector_t       sec;
  line_t     li;
  side_t     si;
  // short      get;
  //get = (short *)save_p;

  //List<sector_t> sectors=new ArrayList<sector_t>();
  // do sectors
  for (i=0; i<LL.numsectors ; i++)
  {
      sec=LL.sectors[i];
      // MAES: sectors were actually carefully
      // unmarshalled, so we don't just read/write
      // their entire memory footprint to disk.
      sec.read(f);
      sec.specialdata = null;
      sec.soundtarget = null;
  }
  adaptSectors();
  // do lines
  for (i=0 ; i<LL.numlines ; i++)
  {
  li=LL.lines[i];
  // MAES: something similar occurs with lines, too.
  li.read(f);
  //System.out.println("Line "+i+": "+li);
  //System.out.print(i+ " {");
  for (j=0 ; j<2 ; j++)
  {
    //  System.out.print(li.sidenum[j]);
    //  if (j<2) System.out.print(",");
   //   System.out.printf("Skipped sidenum %d for line %d\n",j,i);
      if (li.sidenum[j] == line_t.NO_INDEX){
  //        System.out.printf("Skipped sidenum %d for line %d\n",j,i);
      continue;
      }
      // Similarly, sides also get a careful unmarshalling even
      // in vanilla. No "dumb" block reads here.
      si = LL.sides[li.sidenum[j]];
      si.read(f);

  }
  //System.out.printf("Position at end of WORLD: %d\n",f.getFilePointer());
  }
  
}

/** Convert loaded sectors from vanilla savegames into the internal,
 *  continuous index progression, by intercepting breaks corresponding to markers.
 */

protected void adaptSectors(){
	sector_t sec;
	switch(DS.getGameMode()){
	case registered:
	case shareware:
	for (int i=0;i<LL.numsectors;i++){
		sec=LL.sectors[i];
		// Between the F1_START and F1_END mark (in vanilla)
		if (sec.floorpic<=54){
			sec.floorpic-=1;
		} else {
		// Between the F2_START and F2_END mark (in vanilla)
			sec.floorpic-=3;
		}
		if (sec.ceilingpic<=54){
			sec.ceilingpic-=1;
		} else {
		// Between the F2_START and F2_END mark (in vanilla)
			sec.ceilingpic-=3;
		}
		
	}
	break;
	case commercial:
	case pack_plut:
	case pack_tnt:
		
		for (int i=0;i<LL.numsectors;i++){
			sec=LL.sectors[i];
			// Between the F1_START and F1_END mark (in vanilla)
			if (sec.floorpic<=54){
				sec.floorpic-=1;
			} else 
			if (sec.floorpic<=99){
			// Between the F2_START and F2_END mark (in vanilla)
				sec.floorpic-=3;
			} else {
				sec.floorpic-=5;
			}
			
			if (sec.ceilingpic<=54){
				sec.ceilingpic-=1;
			} else if (sec.ceilingpic<=99){
			// Between the F2_START and F2_END mark (in vanilla)
				sec.ceilingpic-=3;
			} else {
				sec.ceilingpic-=5;
			}
			
		}
	}
}

/** De-convert sectors from an absolute to a vanilla-like index
 *  progression, by adding proper skips
 */

protected void deAdaptSectors(){
    sector_t sec;
    switch(DS.getGameMode()){
    case registered:
    case shareware:
    for (int i=0;i<LL.numsectors;i++){
        sec=LL.sectors[i];
        // Between the F1_START and F1_END mark (in vanilla)
        if (sec.floorpic<54){
            sec.floorpic+=1;
        } else {
        // Between the F2_START and F2_END mark (in vanilla)
            sec.floorpic+=3;
        }
        if (sec.ceilingpic<54){
            sec.ceilingpic+=1;
        } else {
        // Between the F2_START and F2_END mark (in vanilla)
            sec.ceilingpic+=3;
        }
        
    }
    break;
    case commercial:
    case pack_plut:
    case pack_tnt:
        
        for (int i=0;i<LL.numsectors;i++){
            sec=LL.sectors[i];
            // Between the F1_START and F1_END mark (in vanilla)
            if (sec.floorpic<54){
                sec.floorpic+=1;
            } else 
            if (sec.floorpic<99){
            // Between the F2_START and F2_END mark (in vanilla)
                sec.floorpic+=3;
            } else {
                sec.floorpic+=5;
            }
            
            if (sec.ceilingpic<54){
                sec.ceilingpic+=1;
            } else if (sec.ceilingpic<99){
            // Between the F2_START and F2_END mark (in vanilla)
                sec.ceilingpic+=3;
            } else {
                sec.ceilingpic+=5;
            }
            
        }
    }
}


//
//Thinkers
//
protected enum thinkerclass_t 
{
 tc_end,
 tc_mobj;
}
 
List<mobj_t> TL=new ArrayList<mobj_t>();

//
//P_UnArchiveThinkers
//
protected void ArchiveThinkers () throws IOException
{
    thinker_t      th;
    mobj_t     mobj;

// save off the current thinkers
for (th = A.getThinkerCap().next ; th != A.getThinkerCap(); th=th.next)
{
if (th.function!=null && th.function==think_t.P_MobjThinker)
{
    // Indicate valid thinker
    fo.writeByte(thinkerclass_t.tc_mobj.ordinal());
    // Pad...
    PADSAVEP(fo);
    mobj=(mobj_t)th;
    mobj.write(fo);
   
    // MAES: state is explicit in state.id
   // save_p += sizeof(*mobj);
   // mobj->state = (state_t *)(mobj->state - states);
    
    // MAES: player is automatically generated at runtime and handled by the writer.
    //if (mobj->player)
    //mobj->player = (player_t *)((mobj->player-players) + 1);
    continue;
}
    
// I_Error ("P_ArchiveThinkers: Unknown thinker function");
}

// add a terminating marker
fo.writeByte(thinkerclass_t.tc_end.ordinal());

}

//
//P_UnArchiveThinkers
//
protected void UnArchiveThinkers () throws IOException
{
 thinkerclass_t        tclass; // was "byte", therefore unsigned
 thinker_t      currentthinker;
 thinker_t      next;
 mobj_t     mobj;
 int id=0;
 
 
 
 // remove all the current thinkers
 
 currentthinker = A.getThinkerCap().next;
 while (currentthinker!=null && currentthinker != A.getThinkerCap())
 {
 next = currentthinker.next;
 
 if (currentthinker.function ==  think_t.P_MobjThinker)
     A.RemoveMobj ((mobj_t)currentthinker);
 else{
     //currentthinker.next.prev=currentthinker.prev;
     //currentthinker.prev.next=currentthinker.next;
     currentthinker=null;
 }
     
 currentthinker = next;
 }
 
 A.InitThinkers ();
 
 // read in saved thinkers
 boolean end=false;
 while (!end)
 {
     int tmp=f.readUnsignedByte();
     tclass=thinkerclass_t.values()[tmp];
 switch (tclass)
 {
   case tc_end:
       // That's how we know when to stop.
       end=true;
     break;     // end of list
         
   case tc_mobj:
     PADSAVEP(f,maxsize);     
     mobj=new mobj_t(A);
     mobj.read(f);
     mobj.id=++id;
     TL.add(mobj);
     mobj.state = info.states[mobj.stateid];
     mobj.target = null;
     if (mobj.playerid!=0)
     {
     mobj.player = DS.players[mobj.playerid-1];
     mobj.player.mo = mobj;

     }
     LL.SetThingPosition (mobj);
     mobj.info = info.mobjinfo[mobj.type.ordinal()];
     mobj.floorz = mobj.subsector.sector.floorheight;
     mobj.ceilingz = mobj.subsector.sector.ceilingheight;
     mobj.function = think_t.P_MobjThinker;
     A.AddThinker (mobj);
     break;
         
   default:
     I.Error ("Unknown tclass %d in savegame",tclass);
 }
 
 }
 reconstructPointers();
 rewirePointers();
}

Hashtable<Integer,mobj_t> pointindex=new Hashtable<Integer,mobj_t> ();

/** Allows reconstructing infighting targets from stored pointers/indices.
 *  Works even with vanilla savegames as long as whatever it is that you
 *  store is unique. A good choice would be progressive indices or hash values.
 * 
 */

protected void reconstructPointers(){
    
    int player=0;
    
    for(mobj_t th: TL){

        if (th.player!=null){
        player=th.id;
        // Player found, so that's our first key.
        pointindex.put(th.player.p_mobj,th);
        }
    }
    
    if (player==0) {
        System.err.println("Player not found, cannot reconstruct pointers!");
        return;
    }
    
    int curr; // next or prev index
    
    // We start from the player's index, if found.
    // We subtract -1 so it matches that inside the thinkers list.
    for (int i=(player-1);i<TL.size()-1;i++){
        // Get "next" pointer.
        curr=TL.get(i).nextid;
        pointindex.put(curr, TL.get(i+1));
    }
    
    // We also search backwards, in case player wasn't first object
    // (can this even happen, in vanilla?)
    // -1 so it matches that of the TL list.
    for (int i=(player-1);i>0;i--){
        // Get "prev" pointer.
    	curr=TL.get(i).previd;
    	pointindex.put(curr,TL.get(i-1));
    }

}

/** Allows reconstructing infighting targets from stored pointers/indices from
 * the hashtable created by reconstructPointers.
 * 
 */

protected void rewirePointers(){
    
    for(mobj_t th: TL){
        if (th.p_target!=0){
            th.target=pointindex.get(th.p_target);
            th.tracer=pointindex.get(th.p_tracer);
           // System.out.printf("Object %s has target %s\n",th.type.toString(),th.target.type.toString());
        }
    }
}

protected enum specials_e
{
    tc_ceiling,
    tc_door,
    tc_floor,
    tc_plat,
    tc_flash,
    tc_strobe,
    tc_glow,
    tc_endspecials

} ;   

//
//P_UrchiveSpecials
//
protected void ArchiveSpecials () throws IOException
{
ceiling_t      ceiling;
vldoor_t       door;
floormove_t    floor;
plat_t     plat;
lightflash_t   flash;
strobe_t       strobe;
glow_t     glow;
int i;

// Most of these objects are quite hefty, but estimating 128 bytes tops
// for each should do (largest one is 56);
ByteBuffer buffer=ByteBuffer.allocate(128);
buffer.order(ByteOrder.LITTLE_ENDIAN);

// save off the current thinkers
for (thinker_t th = A.getThinkerCap().next ; th != A.getThinkerCap() ; th=th.next){
    
    // Write out any pending objects.
    if (buffer.position()>0){
        fo.write(buffer.array(),0,buffer.position());
        //System.out.println("Wrote out "+buffer.position()+" bytes");
            
        }
    
    // Back to the beginning.
    buffer.position(0);
    
    // So ceilings don't think?
    if (th.function== null) {
        // i maintains status between iterations
        for (i = 0; i < A.getMaxCeilings();i++)
        if ((th instanceof ceiling_t) && (A.getActiveCeilings()[i] == (ceiling_t)th))
            break;
        
        if (i<MAXCEILINGS)
        {
        fo.writeByte(specials_e.tc_ceiling.ordinal());
        PADSAVEP(fo);        
        // Set id for saving        
        ceiling=(ceiling_t)th;
        ceiling.sectorid=ceiling.sector.id;
        ceiling.pack(buffer);        
        }
        continue;
    }

    // Well, apparently some do.
    if (th.function== think_t.T_MoveCeiling) {
        
        fo.writeByte(specials_e.tc_ceiling.ordinal());
        PADSAVEP(fo);        
        ceiling=(ceiling_t)th;
        ceiling.sectorid=ceiling.sector.id;
        ceiling.pack(buffer);
        continue;
        }
   
    // Well, apparently some do.
    if (th.function== think_t.T_VerticalDoor) {

        fo.writeByte(specials_e.tc_door.ordinal());
        PADSAVEP(fo);
        door=(vldoor_t)th;
        door.sectorid=door.sector.id;
        door.pack(buffer);
        continue;
        }
    
    // Well, apparently some do.
    if (th.function== think_t.T_MoveFloor) {
        fo.writeByte(specials_e.tc_floor.ordinal());
        PADSAVEP(fo);
        floor=(floormove_t)th;
        floor.sectorid=floor.sector.id;
        floor.pack(buffer);
        continue;
        }
    
    // Well, apparently some do.
    if (th.function== think_t.T_PlatRaise) {
        fo.writeByte(specials_e.tc_plat.ordinal());
        PADSAVEP(fo);
        plat=(plat_t)th;
        plat.sectorid=plat.sector.id;
        plat.pack(buffer);
        continue;
        }

    // Well, apparently some do.
    if (th.function== think_t.T_LightFlash) {
        fo.writeByte(specials_e.tc_flash.ordinal());
        PADSAVEP(fo);
        flash=(lightflash_t)th;
        flash.sectorid=flash.sector.id;
        flash.pack(buffer);
        continue;
        }

    // Well, apparently some do.
    if (th.function== think_t.T_StrobeFlash) {
        fo.writeByte(specials_e.tc_strobe.ordinal());
        PADSAVEP(fo);
        strobe=(strobe_t)th;
        strobe.sectorid=strobe.sector.id;
        strobe.pack(buffer);
        continue;
        }
    
    // Well, apparently some do.
    if (th.function== think_t.T_Glow) {
        fo.writeByte(specials_e.tc_glow.ordinal());
        PADSAVEP(fo);
        glow=(glow_t)th;
        glow.sectorid=glow.sector.id;
        glow.pack(buffer);
        continue;
        }
    
}

if (buffer.position()>0){
    fo.write(buffer.array(),0,buffer.position());        
    }


// Finito!
fo.writeByte((byte) specials_e.tc_endspecials.ordinal());
}


//
//P_UnArchiveSpecials
//
protected void UnArchiveSpecials () throws IOException
{
    specials_e        tclass;
 ceiling_t      ceiling;
 vldoor_t       door;
 floormove_t    floor;
 plat_t     plat;
 lightflash_t   flash;
 strobe_t       strobe;
 glow_t     glow;
 
 //List<thinker_t> A=new ArrayList<thinker_t>();
 
 A.ClearPlatsBeforeLoading();
 A.ClearCeilingsBeforeLoading();
 
 // read in saved thinkers
 while (true)
 {
     int tmp=f.readUnsignedByte();
     //tmp&=0x00ff; // To "unsigned byte"
     tclass=specials_e.values()[tmp];
 switch (tclass)
 {
   case tc_endspecials:
     return; // end of list
         
   case tc_ceiling:
     PADSAVEP(f,maxsize);
     ceiling = new ceiling_t();
     ceiling.read(f);
     ceiling.sector = LL.sectors[ceiling.sectorid];
     ceiling.sector.specialdata = ceiling;

     if (ceiling.functionid!=0)
     ceiling.function = think_t.T_MoveCeiling;

     A.AddThinker (ceiling);
     A.AddActiveCeiling(ceiling);
     break;
             
   case tc_door:
     PADSAVEP(f,maxsize);
     door=new vldoor_t();
     door.read(f);
     door.sector = LL.sectors[door.sectorid];
     door.sector.specialdata = door;
     door.function = think_t.T_VerticalDoor;
     
     A.AddThinker (door);
     break;
             
   case tc_floor:
     PADSAVEP(f,maxsize);
     floor=new floormove_t();
     floor.read(f);
     floor.sector = LL.sectors[floor.sectorid];
     floor.sector.specialdata = floor;
     floor.function = think_t.T_MoveFloor;
     
     A.AddThinker (floor);
     break;
             
   case tc_plat:
     PADSAVEP(f,maxsize);
     plat=new plat_t();
     plat.read(f);
     plat.sector = LL.sectors[plat.sectorid];
     plat.sector.specialdata = plat;

     if (plat.functionid!=0)
     plat.function =  think_t.T_PlatRaise;
     
     A.AddThinker (plat);
     A.AddActivePlat(plat);
     break;
             
   case tc_flash:
     PADSAVEP(f,maxsize);
     flash=new lightflash_t(this.DS.RND);
     flash.read(f);
     
     flash.sector =LL.sectors[flash.sectorid];
     flash.function =  think_t.T_LightFlash;
     
     A.AddThinker (flash);
     break;
             
   case tc_strobe:
     PADSAVEP(f,maxsize);
     
     strobe = new strobe_t();
     strobe.read(f);
     strobe.sector = LL.sectors[strobe.sectorid];
     strobe.function =  think_t.T_StrobeFlash;
     
     A.AddThinker (strobe);
     break;
             
   case tc_glow:
     PADSAVEP(f,maxsize);
     glow = new glow_t();
     glow.read(f);
     glow.sector = LL.sectors[glow.sectorid];
     glow.function = think_t.T_Glow;
     
     A.AddThinker (glow);
     break;
             
   default:
     I.Error ("P_UnarchiveSpecials:Unknown tclass %d in savegame",tmp);
 }
 }
 
 }

    /**
     * Pads save_p to a 4-byte boundary
     * so that the load/save works on SGI&Gecko.
     * 
     * @param save_p
     */
    
    protected final int PADSAVEP(int save_p){
        return (save_p += (4 - ((int) save_p & 3)) & 3);
    }
    
    //protected final int PADSAVEP(ByteBuffer b, int save_p){
    //    ByteBuffer
    //    return (save_p += (4 - ((int) save_p & 3)) & 3);
    //}

    protected final long PADSAVEP(DataInputStream f, int maxsize) throws IOException{
        long save_p=maxsize-f.available();
        int padding =(4 - ((int) save_p & 3)) & 3;
       // System.out.printf("Current position %d Padding by %d bytes %d\n",save_p,padding,maxsize);        
        f.skip(padding);
        return padding;        
        }
    
    protected final long PADSAVEP(DataOutputStream f) throws IOException{
        long save_p=f.size();
        int padding =(4 - ((int) save_p & 3)) & 3;
       // System.out.printf("Current position %d Padding by %d bytes\n",save_p,padding);
        for (int i=0;i<padding;i++)
        	f.write(0);
        return padding;        
        }

    @Override
    public void updateStatus(DoomStatus<?,?> DS) {
        this.DS=DS;
        this.LL=DS.LL;
        this.A=DS.P;       
    	}


    @Override
    public boolean doSave(DataOutputStream f) {
            try {
             // The header must have been set, at this point.
                this.fo=f;
                //f.setLength(0); // Kill old info.
                header.write(f);
            
            
            //header.read(f);
            ArchivePlayers ();
            ArchiveWorld();
            ArchiveThinkers();  
            ArchiveSpecials();
            // TODO: the rest...
            f.write(0x1D);
            } catch (Exception e){
                e.printStackTrace();
                System.err.printf("Error while saving savegame! Cause: %s",e.getMessage());
                return false; // Needed to shut up compiler.
            }
        return true;
    }

}
package savegame;

import p.ThinkerList;

public interface ILoadSaveGame {
    void setThinkerList(ThinkerList li);
    void doSave(ThinkerList li);
    void doLoad(ThinkerList li);
}

package savegame;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import i.DoomStatusAware;
import p.ThinkerList;

public interface IDoomSaveGame extends DoomStatusAware{    
    void setThinkerList(ThinkerList li);
    boolean doLoad(DataInputStream f);
    IDoomSaveGameHeader getHeader();
    void setHeader(IDoomSaveGameHeader header);
    boolean doSave(DataOutputStream f);
}

package savegame;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import utils.C2JUtils;
import w.CacheableDoomObject;
import w.DoomBuffer;
import w.DoomIO;
import w.IReadableDoomObject;
import w.IWritableDoomObject;
import defines.skill_t;

import static data.Defines.VERSION;
import static data.Limits.MAXPLAYERS;
import static data.Limits.SAVESTRINGSIZE;
import static data.Limits.VERSIONSIZE;

/** The header of a vanilla savegame.
 *  
 *  It contains a fixed-length, null-terminated string of 24 bytes max, in any case.
 *  Then a 16-byte "version string", which normally reads "version 109".
 *  Then bytes that record:
 *  skill +1
 *  episode +1
 *  map +1
 *  players in game +4
 *  gametime +3 (as 24-bit big-endian)
 *  
 *  So the header has an total size of *drum roll* 50 bytes.
 *  
 * 
 * @author admin
 *
 */


public class  VanillaDSGHeader implements IDoomSaveGameHeader,IReadableDoomObject, IWritableDoomObject, CacheableDoomObject{
    
public String name; // max size SAVEGAMENAME
public String vcheck;
    // These are for DS
public skill_t gameskill;
public int gameepisode;
public int gamemap;
public boolean[] playeringame;
    /** what bullshit, stored as 24-bit integer?! */
 public int leveltime;
    // These help checking shit.
public boolean wrongversion;
   public boolean properend;
    
   public VanillaDSGHeader(){
       this.playeringame=new boolean[MAXPLAYERS];
   }
   
   
   @Override
   public void unpack(ByteBuffer buf)
           throws IOException {
       name=DoomBuffer.getNullTerminatedString(buf, SAVESTRINGSIZE);
       vcheck=DoomBuffer.getNullTerminatedString(buf, VERSIONSIZE);
       String vcheckb= ("version "+VERSION);
       // no more unpacking, and report it.
       if (wrongversion = !(vcheckb.equalsIgnoreCase(vcheck))) return;
       gameskill = skill_t.values()[buf.get()]; 
       gameepisode = buf.get();
       gamemap = buf.get();
       
              for (int i=0 ; i<MAXPLAYERS ; i++)
       playeringame[i] = buf.get()!=0; 

       // load a base level (this doesn't advance the pointer?) 
       //G_InitNew (gameskill, gameepisode, gamemap); 
    
       // get the times 
       int a = C2JUtils.toUnsignedByte(buf.get()); 
       int b = C2JUtils.toUnsignedByte(buf.get());
       int c =  C2JUtils.toUnsignedByte(buf.get());
       // Quite anomalous, leveltime is stored as a BIG ENDIAN, 24-bit unsigned integer :-S
       leveltime = (a<<16) | (b<<8) | c; 

       // Mark this position...
       buf.mark();
       buf.position(buf.limit()-1);
       if (buf.get() != 0x1d) properend=false; else
           properend=true;
       buf.reset();
           
       // We've loaded whatever consistutes "header" info, the rest must be unpacked by proper
       // methods in the game engine itself.
   }
   
   @Override
   public void write(DataOutputStream f)
           throws IOException {
       DoomIO.writeString(f,name,SAVESTRINGSIZE);
       DoomIO.writeString(f,vcheck,VERSIONSIZE);
       f.writeByte(gameskill.ordinal()); 
       f.writeByte(gameepisode);
       f.writeByte(gamemap);
       for (int i=0 ; i<MAXPLAYERS ; i++) 
       f.writeBoolean(playeringame[i]); 

       // load a base level (this doesn't advance the pointer?) 
       //G_InitNew (gameskill, gameepisode, gamemap); 
    
       // get the times 
       byte a = (byte) (0x0000FF&(leveltime>>16)); 
       byte b = (byte) (0x00FF&(leveltime>>8));
       byte c =  (byte) (0x00FF&(leveltime));
       // Quite anomalous, leveltime is stored as a BIG ENDIAN, 24-bit unsigned integer :-S
       f.writeByte(a);
       f.writeByte(b);
       f.writeByte(c);

       // The end. This is actually just the header, so we don't "end" here just yet.
       // f.writeByte(0x1d);
           
   } 
   
   @Override
   public void read(DataInputStream f)
           throws IOException {
       name= DoomIO.readNullTerminatedString(f,SAVESTRINGSIZE);
       vcheck=DoomIO.readNullTerminatedString(f,VERSIONSIZE);
       gameskill=skill_t.values()[f.readUnsignedByte()]; 
       gameepisode=f.readByte();
       gamemap=f.readByte();
       for (int i=0 ; i<MAXPLAYERS ; i++) 
           playeringame[i]=f.readBoolean(); 
    
       // get the times 
       int a = f.readUnsignedByte(); 
       int b = f.readUnsignedByte();
       int c = f.readUnsignedByte();
       // Quite anomalous, leveltime is stored as a BIG ENDIAN, 24-bit unsigned integer :-S
       leveltime = (a<<16) | (b<<8) | c; 
           
   } 
   
   ////////////////////////// NASTY GETTERS //////////////////////////////
    
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String getVersion() {
        return vcheck;
    }
    @Override
    public void setVersion(String vcheck) {
        this.vcheck = vcheck;
    }
    @Override
    public skill_t getGameskill() {
        return gameskill;
    }
    @Override
    public void setGameskill(skill_t gameskill) {
        this.gameskill = gameskill;
    }
    @Override
    public int getGameepisode() {
        return gameepisode;
    }
    @Override
    public void setGameepisode(int gameepisode) {
        this.gameepisode = gameepisode;
    }
    @Override
    public int getGamemap() {
        return gamemap;
    }
    @Override
    public void setGamemap(int gamemap) {
        this.gamemap = gamemap;
    }
    @Override
    public boolean[] getPlayeringame() {
        return playeringame;
    }
    @Override
    public void setPlayeringame(boolean[] playeringame) {
        this.playeringame = playeringame;
    }
    @Override
    public int getLeveltime() {
        return leveltime;
    }
    @Override
    public void setLeveltime(int leveltime) {
        this.leveltime = leveltime;
    }
    @Override
    public boolean isWrongversion() {
        return wrongversion;
    }
    @Override
    public void setWrongversion(boolean wrongversion) {
        this.wrongversion = wrongversion;
    }
    @Override
    public boolean isProperend() {
        return properend;
    }

}

package savegame;

import defines.skill_t;


/** A Save Game Header should be able to be loaded quickly and return 
 *  some basic info about it (name, version, game time, etc.) in an unified
 *  manner, no matter what actual format you use for saving.
 * 
 * @author admin
 *
 */

public interface IDoomSaveGameHeader {

    String getName();

    void setName(String name);

    skill_t getGameskill();

    void setGameskill(skill_t gameskill);
    
    String getVersion();

    void setVersion(String vcheck);

    int getGameepisode();
    
    void setGameepisode(int gameepisode);

    boolean isProperend();

    void setWrongversion(boolean wrongversion);

    boolean isWrongversion();

    void setLeveltime(int leveltime);

    int getLeveltime();

    void setPlayeringame(boolean[] playeringame);

    boolean[] getPlayeringame();

    void setGamemap(int gamemap);

    int getGamemap();

}

package timing;

import static data.Defines.TICRATE;

public class NanoTicker
        implements ITicker {

    /**
     * I_GetTime
     * returns time in 1/70th second tics
     */
   
    @Override
    public int GetTime ()
    {
        long    tp;
        //struct timezone   tzp;
        int         newtics;
        
        // Attention: System.nanoTime() might not be consistent across multicore CPUs.
        // To avoid the core getting back to the past,
        tp=System.nanoTime();
        if (basetime==0)
        basetime = tp;
        newtics = (int) (((tp-basetime)*TICRATE)/1000000000);// + tp.tv_usec*TICRATE/1000000;
        if (newtics<oldtics) {
            System.err.printf("Timer discrepancies detected : %d",(++discrepancies));
            return oldtics;
        }
        return (oldtics=newtics);
    }

    protected volatile long basetime=0;
    protected volatile int oldtics=0;
    protected volatile int discrepancies;
    
}

package timing;

public interface ITicker {
    public int GetTime();
    
}

package timing;

import static data.Defines.TICRATE;

public class MilliTicker
        implements ITicker {

    /**
     * I_GetTime
     * returns time in 1/70th second tics
     */
   
    @Override    public int GetTime ()
    {
        long    tp;
        //struct timezone   tzp;
        int         newtics;
        
        tp=System.currentTimeMillis();
        if (basetime==0)
        basetime = tp;
        newtics = (int) (((tp-basetime)*TICRATE)/1000);
        return newtics;
    }
    
    protected volatile long basetime=0;
    protected volatile int oldtics=0;
    protected volatile int discrepancies;
    
}

package timing;

public class FastTicker
        implements ITicker {

    /**
     * I_GetTime
     * returns time in 1/70th second tics
     */
   
    @Override
    public int GetTime ()
    {
        return fasttic++;
    }

    protected volatile int fasttic=0;
    
}

package s;

import static data.sounds.S_sfx;

import java.util.HashMap;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Semaphore;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;

import pooling.AudioChunkPool;
import data.sounds.sfxenum_t;
import doom.DoomStatus;

/**
 * A spiffy new sound system, based on the Classic sound driver.
 * It is entirely asynchronous (runs in its own thread) and even has its own timer.
 * This allows it to continue mixing even when the main loop is not responding 
 * (something which, arguably, could be achieved just with a timer calling
 * UpdateSound and SubmitSound). Uses message passing to deliver channel status
 * info, and mixed audio directly without using an intermediate buffer,
 * saving memory bandwidth.
 * 
 * PROS:
 * a) All those of ClassicSoundDriver plus:
 * b) Continues normal playback even under heavy CPU load, works smoother
 *    even on lower powered CPUs.
 * c) More efficient due to less copying of audio blocks.
 * c) Fewer audio glitches compared to ClassicSoundDriver.
 * 
 * CONS:
 * a) All those of ClassicSoundDriver plus regarding timing accuracy.
 * 
 * @author Maes
 */

public class SuperDoomSoundDriver extends AbstractSoundDriver
         {

    protected final Semaphore produce;

    protected final Semaphore consume;

    protected final Semaphore update_mixer;

    protected int chunk = 0;

    //protected FileOutputStream fos;
    //protected DataOutputStream dao;

    // The one and only line
    protected SourceDataLine line = null;

    protected HashMap<Integer, byte[]> cachedSounds =
        new HashMap<Integer, byte[]>();

    protected final Timer MIXTIMER;
        
    public SuperDoomSoundDriver(DoomStatus DS, int numChannels) {
    	super(DS,numChannels);
        channels = new boolean[numChannels];
        produce = new Semaphore(1);
        consume = new Semaphore(1);
        update_mixer = new Semaphore(1);
        produce.drainPermits();
        update_mixer.drainPermits();
        this.MIXSRV=new MixServer(numChannels);
        MIXTIMER= new Timer(true);
        // Sound tics every 1/35th of a second. Grossly
        // inaccurate under Windows though, will get rounded
        // down to the closest multiple of 15 or 16 ms.
        MIXTIMER.schedule(new SoundTimer(), 0,SOUND_PERIOD);        
    }




    /** These are still defined here to decouple them from the mixer's 
     *  ones, however they serve  more as placeholders/status indicators;
     */
    protected volatile boolean[] channels;

    protected volatile boolean mixed = false;

    /**
     * This function loops all active (internal) sound channels, retrieves a
     * given number of samples from the raw sound data, modifies it according to
     * the current (internal) channel parameters, mixes the per channel samples
     * into the global mixbuffer, clamping it to the allowed range, and sets up
     * everything for transferring the contents of the mixbuffer to the (two)
     * hardware channels (left and right, that is). This function currently
     * supports only 16bit.
     */

    public void UpdateSound() {
    	// This is pretty much a dummy.
    	// The mixing thread goes on by itself, guaranteeing that it will
    	// carry out at least currently enqueued mixing messages, regardless
    	// of how badly the engine lags.

    }

    /**
     * SFX API Note: this was called by S_Init. However, whatever they did in
     * the old DPMS based DOS version, this were simply dummies in the Linux
     * version. See soundserver initdata().
     */

    @Override
    public void SetChannels(int numChannels) {
        // Init internal lookups (raw data, mixing buffer, channels).
        // This function sets up internal lookups used during
        // the mixing process.

        int steptablemid = 128;

        // Okay, reset internal mixing channels to zero.
        for (int i = 0; i < this.numChannels; i++) {
            channels[i] = false;
        }
        
        generateStepTable(steptablemid);

        generateVolumeLUT();
    }
    
    protected  PlaybackServer SOUNDSRV;
    protected final MixServer MIXSRV;
    
    protected Thread MIXTHREAD;
    protected Thread SOUNDTHREAD;

    @Override
    public boolean InitSound() {

        // Secure and configure sound device first.
        System.err.println("I_InitSound: ");

        // We only need a single data line.
        // PCM, signed, 16-bit, stereo, 22025 KHz, 2048 bytes per "frame",
        // maximum of 44100/2048 "fps"
        AudioFormat format = new AudioFormat(SAMPLERATE, 16, 2, true, true);

        DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

        if (AudioSystem.isLineSupported(info))
            try {
                line = (SourceDataLine) AudioSystem.getSourceDataLine(format);
                line.open(format, AUDIOLINE_BUFFER);
            }	catch (Exception e) {
                e.printStackTrace();
                System.err.print("Could not play signed 16 data\n");
                return false;
            }

        if (line != null) {
            System.err.print(" configured audio device\n");
            line.start();
        } else {
        	 System.err.print(" could not configure audio device\n");
        	 return false;
        }

        SOUNDSRV = new PlaybackServer(line);
        SOUNDTHREAD = new Thread(SOUNDSRV);
        SOUNDTHREAD.setDaemon(true);
        SOUNDTHREAD.start();
        // Vroom!        
        MIXTHREAD= new Thread(MIXSRV);
        MIXTHREAD.setDaemon(true);
        MIXTHREAD.start();
        
        // Initialize external data (all sounds) at start, keep static.
        System.err.print("I_InitSound: ");

        super.initSound8();

        System.err.print(" pre-cached all sound data\n");

        // Finished initialization.
        System.err.print("I_InitSound: sound module ready\n");
        
        return true;

    }

    @Override
    protected int addsfx(int sfxid, int volume, int step, int seperation) {
        int i;
        int rc = -1;

        int oldest = DS.gametic;
        int oldestnum = 0;
        int slot;

        int rightvol;
        int leftvol;

        int broken=-1;
        
        // Chainsaw troubles.
        // Play these sound effects only one at a time.
        if (sfxid == sfxenum_t.sfx_sawup.ordinal()
                || sfxid == sfxenum_t.sfx_sawidl.ordinal()
                || sfxid == sfxenum_t.sfx_sawful.ordinal()
                || sfxid == sfxenum_t.sfx_sawhit.ordinal()
                || sfxid == sfxenum_t.sfx_stnmov.ordinal()
                || sfxid == sfxenum_t.sfx_pistol.ordinal()) {
            // Loop all channels, check.
            for (i = 0; i < numChannels; i++) {
                // Active, and using the same SFX?
                if (channels[i] && (channelids[i] == sfxid)) {
                    // Reset.
                	
                	MixMessage m=new MixMessage();
                	m.stop=true;
                	
                    // We are sure that iff,
                    // there will only be one.
                    broken=i;
                    break;
                }
            }
        }

        // Loop all channels to find oldest SFX.
        if (broken>=0) {
        	i=broken;
        	oldestnum=broken;
        }
        else
        for (i = 0; (i < numChannels) && channels[i]; i++) {
            if (channelstart[i] < oldest) {
                oldestnum = i;
            }
        }

        oldest = channelstart[oldestnum];
        
        // Tales from the cryptic.
        // If we found a channel, fine.
        // If not, we simply overwrite the first one, 0.
        // Probably only happens at startup.
        if (i == numChannels)
            slot = oldestnum;
        else
            slot = i;

        
        MixMessage m=new MixMessage();
        
        // Okay, in the less recent channel,
        // we will handle the new SFX.
        // Set pointer to raw data.
        channels[slot]=true;
        m.channel=slot;
        m.data=S_sfx[sfxid].data;

        // MAES: if you don't zero-out the channel pointer here, it gets ugly
        m.pointer= 0;

        // Set pointer to end of raw data.
        m.end = lengths[sfxid];

        // Reset current handle number, limited to 0..100.
        if (handlenums == 0) // was !handlenums, so it's actually 1...100?
            handlenums = 100;

        // Assign current handle number.
        // Preserved so sounds could be stopped (unused).
        // Maes: this should really be decreasing, otherwide handles
        // should start at 0 and go towards 100. Just saying.
        channelhandles[slot] = rc = handlenums--;

        // Set stepping???
        // Kinda getting the impression this is never used.
        // MAES: you're wrong amigo.
        m.step= step;
        // ???
        m.remainder = 0;
        // Should be gametic, I presume.
        channelstart[slot] = DS.gametic;

        // Separation, that is, orientation/stereo.
        // range is: 1 - 256
        seperation += 1;

        // Per left/right channel.
        // x^2 seperation,
        // adjust volume properly.
        leftvol = volume - ((volume * seperation * seperation) >> 16); // /(256*256);
        seperation = seperation - 257;
        rightvol = volume - ((volume * seperation * seperation) >> 16);

        // Sanity check, clamp volume.

        if (rightvol < 0 || rightvol > 127)
            DS.I.Error("rightvol out of bounds");

        if (leftvol < 0 || leftvol > 127)
            DS.I.Error("leftvol out of bounds");

        // Get the proper lookup table piece
        // for this volume level???
        m.leftvol_lookup = vol_lookup[leftvol];
        m.rightvol_lookup = vol_lookup[rightvol];

        // Preserve sound SFX id,
        // e.g. for avoiding duplicates of chainsaw.
        channelids[slot] = sfxid;

        if (D) System.err.println(channelStatus());
        if (D) System.err.printf(
                "Playing sfxid %d handle %d length %d vol %d on channel %d\n",
                sfxid, rc, S_sfx[sfxid].data.length, volume, slot);

        
        MIXSRV.submitMixMessage(m);
        
        // You tell me.
        return rc;
    }

    @Override
    public void ShutdownSound() {

        boolean done;

        // Unlock sound thread if it's waiting.
        produce.release();
        update_mixer.release();

        int i=0;
        do {
        	done=true;
            for (i=0; i < numChannels; i++) {
            	// If even one channel is playing, loop again.
            	done&=!channels[i];            	
            	}
            	//System.out.println(done+" "+this.channelStatus());
            	
            } while (!done);
        
        
        this.line.flush();
        
        
        SOUNDSRV.terminate = true;
        MIXSRV.terminate = true;
        produce.release();
        update_mixer.release();
        try {
            SOUNDTHREAD.join();
            MIXTHREAD.join();
        } catch (InterruptedException e) {
        	// Well, I don't care.
        }
        System.err.printf("3\n");
        line.close();
        System.err.printf("4\n");

    }

    protected class PlaybackServer
            implements Runnable {

        public boolean terminate = false;

        public PlaybackServer(SourceDataLine line) {
            this.auline = line;
        }

        private SourceDataLine auline;

        private ArrayBlockingQueue<AudioChunk> audiochunks =
            new ArrayBlockingQueue<AudioChunk>(BUFFER_CHUNKS * 2);

        public void addChunk(AudioChunk chunk) {
            audiochunks.offer(chunk);
        }

        public volatile int currstate = 0;

        public void run() {

            while (!terminate) {

                // while (timing[mixstate]<=mytime){

                // Try acquiring a produce permit before going on.

                try {
                    //System.err.print("Waiting for a permit...");
                    produce.acquire();
                    //System.err.print("...got it\n");
                } catch (InterruptedException e) {
                    // Well, ouch.
                    e.printStackTrace();
                }

                int chunks = 0;

                // System.err.printf("Audio queue has %d chunks\n",audiochunks.size());

                // Play back only at most a given number of chunks once you reach
                // this spot.
                
                int atMost=Math.min(ISoundDriver.BUFFER_CHUNKS,audiochunks.size());
                
                while (atMost-->0){

                    AudioChunk chunk = null;
                    try {
                        chunk = audiochunks.take();
                    } catch (InterruptedException e1) {
                        // Should not block
                    }
                    // Play back all chunks present in a buffer ASAP
                    auline.write(chunk.buffer, 0, MIXBUFFERSIZE);
                    chunks++;
                    // No matter what, give the chunk back!
                    chunk.free = true;
                    audiochunkpool.checkIn(chunk);
                }
                
                //System.err.println(">>>>>>>>>>>>>>>>> CHUNKS " +chunks);
                // Signal that we consumed a whole buffer and we are ready for
                // another one.
                
                consume.release();
            }
        }
    }
    
    /** A single channel does carry a lot of crap, figuratively speaking.
     *  Instead of making updates to ALL channel parameters, it makes more
     *  sense having a "mixing queue" with instructions that tell the 
     *  mixer routine to do so-and-so with a certain channel. The mixer
     *  will then "empty" the queue when it has completed a complete servicing
     *  of all messages and mapped them to its internal status.
     *
     */
    protected class MixMessage {
    	/** If this is set, the mixer considers that channel "muted" */
    	public boolean stop;
    	
    	/** This signals an update of a currently active channel. 
    	 * Therefore pointer, remainder and data should remain untouched. 
    	 * However volume and step of a particular channel can change.
    	 */
    	public boolean update; 
    	
		public int remainder;
		public int end;
		public int channel;
    	public byte[] data;    	
    	public int step;
    	public int stepremainder;
    	public int[] leftvol_lookup;
    	public int[] rightvol_lookup;

    	public int pointer;
    	
    }
    
    /** Mixing thread. Mixing and submission must still go on even if
     *  the engine lags behind due to excessive CPU load.
     * 
     * @author Maes
     *
     */
    protected class MixServer
    implements Runnable {

        private final ArrayBlockingQueue<MixMessage> mixmessages;
    	
        /**
         * MAES: we'll have to use this for actual pointing. channels[] holds just
         * the data.
         */
        protected int[] p_channels;

        /**
         * The second one is supposed to point at "the end", so I'll make it an int.
         */
        protected int[] channelsend;

    	private final byte[][] channels;
        /** The channel step amount... */
        protected final int[] channelstep;

        /** ... and a 0.16 bit remainder of last step. */
        protected final int[] channelstepremainder;
        
        protected final int[][] channelrightvol_lookup;
        protected final int[][] channelleftvol_lookup;
    	    	
    	private volatile boolean update=false;
    	
    	public MixServer(int numChannels){
    		// We can put only so many messages "on hold"
    		mixmessages=new ArrayBlockingQueue<MixMessage>(35*numChannels);
    		this.p_channels=new int[numChannels];
    		this.channels=new byte[numChannels][];
    		this.channelstepremainder=new int[numChannels];
    		this.channelsend=new int[numChannels];
    		this.channelstep=new int[numChannels];
    		this.channelleftvol_lookup=new int[numChannels][];
    		this.channelrightvol_lookup=new int[numChannels][];
    	}
    	
    	/** Adds a channel mixing message to the queue */
    	
    	public void submitMixMessage(MixMessage m){
    	    try{
    		this.mixmessages.add(m);
    	    } catch (IllegalStateException  e){
    	        // Queue full. Force clear (VERY rare).
    	        mixmessages.clear();
    	        mixmessages.add(m);
    	    }
    		}
    	
    	public boolean terminate=false;
    	
    	@Override
		public void run()  {

	        // Mix current sound data.
	        // Data, from raw sound, for right and left.
	        int sample = 0;
	        int dl;
	        int dr;

	        // Pointers in global mixbuffer, left, right, end.
	        // Maes: those were explicitly signed short pointers...

	        int leftout;
	        int rightout;
	        
	        // Step in mixbuffer, left and right, thus two.
	        final int step=4;

	        // Mixing channel index.
	        int chan;
	        
	        // Determine end, for left channel only
	        // (right channel is implicit).
	        // MAES: this implies that the buffer will only mix
	        // that many samples at a time, and that the size is just right.
	        // Thus, it must be flushed (p_mixbuffer=0) before reusing it.
	        final int leftend = SAMPLECOUNT * step;

	        // Mix the next chunk, regardless of what the rest of the game is doing. 
	        while (!terminate) {
	        	
		        // POINTERS to Left and right channel
		        // which are in global mixbuffer, alternating.

		        leftout = 0;
		        rightout = 2;

	        	// Wait on interrupt semaphore anyway before draining queue.
	        	// This allows continuing mixing even if the main game loop
	        	// is stalled. This will result in continuous sounds,
	        	// rather than choppy interruptions.

	        		try {
	        			//System.err.print("Waiting on semaphore...");
						update_mixer.acquire();
						//System.err.print("...broke free\n");
					} catch (InterruptedException e) {
						// Nothing to do. Suck it down.
					}
	        	
	        	
	        	
	        	// Get current number of element in queue.
	        	// At worse, there will be none.
	        	int messages=mixmessages.size();
	
	        	// Drain the queue, applying changes to currently
	        	// looping channels, if applicable. This may result in new channels,
	        	// older ones being stopped, or current ones being altered. Changes
	        	// will be applied with priority either way.
	        	if (messages>0) drainAndApply(messages);

	        	// This may have changed in the mean.
	        	mixed=activeChannels();
	        
	        if (mixed) {// Avoid mixing entirely if no active channel.
			
				// Get audio chunk NOW
				gunk= audiochunkpool.checkOut();
    	        // Ha ha you're ass is mine!
    	        gunk.free = false;
				mixbuffer=gunk.buffer;
			
	        while (leftout < leftend) {
	            // Reset left/right value.
	            dl = 0;
	            dr = 0;

	            // Love thy L2 chache - made this a loop.
	            // Now more channels could be set at compile time
	            // as well. Thus loop those channels.

	            for (chan = 0; chan < numChannels; chan++) {

	                // Check channel, if active.
	                // MAES: this means that we must point to raw data here.
	                if (channels[chan] != null) {
	                    int channel_pointer = p_channels[chan];

	                    // Get the raw data from the channel.
	                    // Maes: this is supposed to be an 8-bit unsigned value.
	                        sample = 0x00FF & channels[chan][channel_pointer];
	                        
	                    // Add left and right part for this channel (sound)
	                    // to the current data. Adjust volume accordingly.                        
	                    // Q: could this be optimized by converting samples to 16-bit
	                    // at load time, while also allowing for stereo samples?
	                    // A: Only for the stereo part. You would still look a lookup
	                    // for the CURRENT volume level.

	                    dl += channelleftvol_lookup[chan][sample];
	                    dr += channelrightvol_lookup[chan][sample];

	                    // This should increment the index inside a channel, but is
	                    // expressed in 16.16 fixed point arithmetic.
	                    channelstepremainder[chan] += channelstep[chan];

	                    // The actual channel pointer is increased here.
	                    // The above trickery allows playing back different pitches.
	                    // The shifting retains only the integer part.
	                    channel_pointer += channelstepremainder[chan] >> 16;

	                    // This limits it to the "decimal" part in order to
	                    // avoid undue accumulation.
	                    channelstepremainder[chan] &= 0xFFFF;

	                    // Check whether we are done. Also to avoid overflows.
	                    if (channel_pointer >= channelsend[chan]) {
	                        // Reset pointer for a channel.
	                           if (D)  System.err
	                                    .printf(
	                                        "Channel %d handle %d pointer %d thus done, stopping\n",
	                                        chan, channelhandles[chan],
	                                        channel_pointer);
	                        channels[chan] = null;
	                        
	                        // Communicate back to driver.
	                        SuperDoomSoundDriver.this.channels[chan]=false;
	                        channel_pointer = 0;
	                    }

	                    // Write pointer back, so we know where a certain channel
	                    // is the next time UpdateSounds is called.

	                    p_channels[chan] = channel_pointer;
	                }

	            } // for all channels.

	            // MAES: at this point, the actual values for a single sample
	            // (YIKES!) are in d1 and d2. We must use the leftout/rightout
	            // pointers to write them back into the mixbuffer.

	            // Clamp to range. Left hardware channel.
	            // Remnant of 8-bit mixing code? That must have raped ears
	            // and made them bleed.
	            // if (dl > 127) *leftout = 127;
	            // else if (dl < -128) *leftout = -128;
	            // else *leftout = dl;

	            if (dl > 0x7fff)
	                dl = 0x7fff;
	            else if (dl < -0x8000)
	                dl = -0x8000;

	            // Write left channel
	            mixbuffer[leftout] = (byte) ((dl & 0xFF00) >>> 8);
	            mixbuffer[leftout + 1] = (byte) (dl & 0x00FF);

	            // Same for right hardware channel.
	            if (dr > 0x7fff)
	                dr = 0x7fff;
	            else if (dr < -0x8000)
	                dr = -0x8000;

	            // Write right channel.
	            mixbuffer[rightout] = (byte) ((dr & 0xFF00) >>> 8);
	            mixbuffer[rightout + 1] = (byte) (dr & 0x00FF);

	            // Increment current pointers in mixbuffer.
	            leftout += step;
	            rightout += step;
	        } // End leftend/leftout while

	       // for (chan = 0; chan < numChannels; chan++) {
	       // 	if (channels[chan]!=null){
	       // 		System.err.printf("Channel %d pointer %d\n",chan,this.p_channels[chan]);
	       // 	}
	       // }

		   } // if-mixed
		   
	        // After an entire buffer has been mixed, we can apply any updates.
			// This includes silent updates.
	        submitSound();
			
	        
	        } // terminate loop
    	}	
    	
		private AudioChunk gunk;
		
    		private final void submitSound(){
    			// It's possible to stay entirely silent and give the audio
    	        // queue a chance to get drained. without sending any data.
    			// Saves BW and CPU cycles.
    	        if (mixed) {
    	            silence=0;


    	            // System.err.printf("Submitted sound chunk %d to buffer %d \n",chunk,mixstate);

    	            // Copy the currently mixed chunk into its position inside the
    	            // master buffer.
    	            // System.arraycopy(mixbuffer, 0, gunk.buffer, 0, MIXBUFFERSIZE);

    	            SOUNDSRV.addChunk(gunk);

    	            // System.err.println(chunk++);

    	            chunk++;
    	            // System.err.println(chunk);

    	            if (consume.tryAcquire())
    	                produce.release();

    	        } else {
    	            silence++;
    	            // MAES: attempt to fix lingering noise error
    	            if (silence >ISoundDriver.BUFFER_CHUNKS){
    	                line.flush();
    	                silence=0;
    	                }
    	        }
    		}
    	
    		/** Drains message queue and applies to individual channels. 
    		 *  More recently enqueued messages will trump older ones. This method
    		 *  only changes the STATUS of channels, and actual message submissions 
    		 *  can occur at most every sound frame. 
    		 *  
    		 * @param messages
    		 */
    		
	        private void drainAndApply(int messages ) {			
	        	MixMessage m;
	        	for (int i=0;i<messages;i++){
	        		// There should be no problems, in theory.
	        		m=this.mixmessages.remove();
	        		if (m.stop){
	        			stopChannel(m.channel);
	        			}
	        		else if (m.update){
	        			updateChannel(m);
	        		} else insertChannel(m);			
	        		}
	        	}
	        
	        private final void stopChannel(int channel){
	        	//System.err.printf("Stopping channel %d\n",channel);
	        	this.channels[channel]=null;
    			this.p_channels[channel]=0;
	        	}
	        
	        private final void updateChannel(MixMessage m){
	        	//System.err.printf("Updating channel %d\n",m.channel);
	        	this.channelleftvol_lookup[m.channel]=m.leftvol_lookup;
	        	this.channelrightvol_lookup[m.channel]=m.rightvol_lookup;
	        	this.channelstep[m.channel]=m.step;
	        	this.channelsend[m.channel]=m.end;
	        }
	        
	        private final void insertChannel(MixMessage m){
	        	int ch=m.channel;
	        	//System.err.printf("Inserting channel %d\n",ch);
    			this.channels[ch]=m.data;
    			this.p_channels[ch]=m.pointer;
    			this.channelsend[ch]=m.end;
    			this.channelstepremainder[ch]=m.remainder;
	        	this.channelleftvol_lookup[ch]=m.leftvol_lookup;
	        	this.channelrightvol_lookup[ch]=m.rightvol_lookup;
	        	this.channelstep[ch]=m.step;
	        }
			
			private final boolean activeChannels(){
		        for (int chan = 0; chan < numChannels; chan++) {
		            if (channels[chan] != null)
		                // SOME mixing has taken place.
		                return true;
		        		}
		        
		        return false;
	        }
			
			public final boolean channelIsPlaying(int num){
				return (channels[num]!=null);
			}
	        
		}

    
    @Override
    public boolean SoundIsPlaying(int handle) {

        int c = getChannelFromHandle(handle);
        return (c != -2 && channels[c]);

    }

    /**
     * Internal use.
     * 
     * @param handle
     * @return the channel that has the handle, or -2 if none has it.
     */
    protected int getChannelFromHandle(int handle) {
        // Which channel has it?
        for (int i = 0; i < numChannels; i++) {
            if (channelhandles[i] == handle)
                return i;
        }

        return BUSY_HANDLE;
    }

    @Override
    public void StopSound(int handle) {
        // Which channel has it?
        int hnd = getChannelFromHandle(handle);
        if (hnd >= 0) {
        	
            channels[hnd] = false;
            
            
            this.channelhandles[hnd] = IDLE_HANDLE;
            
			MixMessage m=new MixMessage();
			m.channel=hnd;
			m.stop=true;
			// We can only "ask" the mixer to stop at the next
			//chunk.
            MIXSRV.submitMixMessage(m);
        }
    }

    @Override
    public void SubmitSound() {

        // Also a dummy. The mixing thread is in a better position to
    	// judge when sound should be submitted.
    }
    
    private int silence=0; 

    @Override
    public void UpdateSoundParams(int handle, int vol, int sep, int pitch) {

        int chan = this.getChannelFromHandle(handle);
        // Per left/right channel.
        // x^2 seperation,
        // adjust volume properly.
        int leftvol = vol - ((vol * sep * sep) >> 16); // /(256*256);
        sep = sep - 257;
        int rightvol = vol - ((vol * sep * sep) >> 16);

        // Sanity check, clamp volume.

        if (rightvol < 0 || rightvol > 127)
            DS.I.Error("rightvol out of bounds");

        if (leftvol < 0 || leftvol > 127)
            DS.I.Error("leftvol out of bounds");

        MixMessage m=new MixMessage();
        
        // We are updating a currently active channel
        m.update=true;
        m.channel=chan;
        
        // Get the proper lookup table piece
        // for this volume level???
        
        m.leftvol_lookup = vol_lookup[leftvol];
        m.rightvol_lookup = vol_lookup[rightvol];

        // Well, if you can get pitch to change too...
        m.step = steptable[pitch];
        
        // Oddly enough, we could be picking a different channel here? :-S
        m.end = lengths[channelids[chan]];
        
        
        MIXSRV.submitMixMessage(m);
    }

    protected StringBuilder sb = new StringBuilder();

    public String channelStatus() {
        sb.setLength(0);
        for (int i = 0; i < numChannels; i++) {
            if (MIXSRV.channelIsPlaying(i))
                sb.append(i);
            else
                sb.append('-');
        }

        return sb.toString();

    }

    
    // Schedule this to release the sound thread at regular intervals
    // so that it doesn't outrun the audioline's buffer and game updates.
    
    protected class SoundTimer extends TimerTask {
        public void run() {
           update_mixer.release();         
        }
      }
    
    
    protected final AudioChunk SILENT_CHUNK = new AudioChunk();

    protected final AudioChunkPool audiochunkpool = new AudioChunkPool();
}
package s;

import data.sfxinfo_t;
import data.sounds.musicenum_t;
import data.sounds.sfxenum_t;
import p.mobj_t;

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: IDoomSound.java,v 1.5 2011/08/24 15:55:12 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//	The not so system specific sound interface (s_sound.*)
// Anything high-level like e.g. handling of panning, sound origin,
// sound multiplicity etc. should be handled here, but not e.g. actual
// sound playback, sound threads, etc.
//  That's the job of ISound and IMusic (roughly equivelnt to i_sound.*, but
// with separate concerns for SFX and MUSIC.
//
//-----------------------------------------------------------------------------

public interface IDoomSound {

	class channel_t{

		    // sound information (if null, channel avail.)
		    sfxinfo_t	sfxinfo;

		    // origin of sound
		    ISoundOrigin	origin;

		    // handle of the sound being played
		    int		handle;
			}
	
	/** Convenience hack */
	public static final int NUMSFX=sfxenum_t.NUMSFX.ordinal();
	
	// Purpose?
	public static final char snd_prefixen[]
	                                      = { 'P', 'P', 'A', 'S', 'S', 'S', 'M', 'M', 'M', 'S', 'S', 'S' };

	public static final int S_MAX_VOLUME=127;

	// when to clip out sounds
	// Does not fit the large outdoor areas.
	public static final int S_CLIPPING_DIST	=	(1200*0x10000);

	// Distance tp origin when sounds should be maxed out.
	// This should relate to movement clipping resolution
	// (see BLOCKMAP handling).
	// Originally: (200*0x10000).
	public static final int S_CLOSE_DIST	=(160*0x10000);

	public static final int S_ATTENUATOR	=((S_CLIPPING_DIST-S_CLOSE_DIST)>>m.fixed_t.FRACBITS);

	// Adjustable by menu.
	//protected final int NORM_VOLUME    		snd_MaxVolume

	public static final int NORM_PITCH    = 		128;
	public final static int NORM_PRIORITY	=	64;
	public final static int NORM_SEP		=128;

	public final static int S_PITCH_PERTURB	=	1;
	public final static int S_STEREO_SWING	=	(96*0x10000);

	// percent attenuation from front to back
	public final static int S_IFRACVOL	=	30;

	public final static int NA	=		0;
	public final static int S_NUMCHANNELS=		2;

	/**
	 * Initializes sound stuff, including volume Sets channels, SFX and music
	 * volume, allocates channel buffer, sets S_sfx lookup.
	 */

	void Init(int sfxVolume, int musicVolume);

	/**
	 * Per level startup code. Kills playing sounds at start of level,
	 * determines music if any, changes music.
	 */
	public void Start();

	/**
	 * Start sound for thing at <origin> using <sound_id> from sounds.h
	 */
	public void StartSound(ISoundOrigin origin, int sound_id);

	/**
	 * Start sound for thing at <origin> using <sound_id> from sounds.h
	 * Convenience method using sfxenum_t instead. Delegated to int version.
	 * 
	 */
	public void StartSound(ISoundOrigin origin, sfxenum_t sound_id);
	
	/** Will start a sound at a given volume. */
	public void StartSoundAtVolume(ISoundOrigin origin, int sound_id, int volume);

	/** Stop sound for thing at <origin> */
	public void StopSound(ISoundOrigin origin);

	/**
	 * Start music using <music_id> from sounds.h, and set whether looping
	 * 
	 * @param musicnum
	 * @param looping
	 */
	public void ChangeMusic(int musicnum, boolean looping);
	
	public void ChangeMusic(musicenum_t musicnum, boolean looping);

	/** Stops the music fer sure. */
	public void StopMusic();

	/** Stop and resume music, during game PAUSE. */
	public void PauseSound();

	public void ResumeSound();

	/**
	 * Updates music & sounds
	 * 
	 * @param listener
	 */
	public void UpdateSounds(mobj_t listener);

	public void SetMusicVolume(int volume);

	public void SetSfxVolume(int volume);


	/** Start music using <music_id> from sounds.h */
	public void StartMusic(int music_id);
	
	/** Start music using <music_id> from sounds.h 
	 *  Convenience method using musicenum_t.
	 */
	public void StartMusic(musicenum_t music_id);
	
	//
	// Internals. 
	// 
	// MAES: these appear to be only of value for internal implementation,
	// and are never called externally. Thus, they might as well
	// not be part of the interface, even though it's convenient to reuse them.
	//
	
	/*
	int
	S_getChannel
	( mobj_t		origin,
	  sfxinfo_t	sfxinfo );


	int
	S_AdjustSoundParams
	( mobj_t	listener,
	  mobj_t	source,
	  int		vol,
	  int		sep,
	  int		pitch );

	void S_StopChannel(int cnum);
	*/

}

package s;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;
import javax.sound.midi.Sequence;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.SysexMessage;
import javax.sound.midi.Track;
import javax.sound.midi.Transmitter;

/** A music driver that bypasses Sequences and sends events from a MUS lump
 *  directly to a MIDI device.
 *
 *  Some songs (e.g. D_E1M8) vary individual channel volumes dynamically. This
 *  driver multiplies the dynamic volume by the music volume set in the menu.
 *  This does not work well with a {@link Sequence} because changes to events
 *  (e.g. channel volume change events) do not take effect while the sequencer
 *  is running.
 *  
 *  Disadvantages of this driver:
 *  <ul><li>Supports MUS lumps only (no MID, OGG etc.)</li>
 *      <li>Creates its own thread</li>
 *      <li>Pausing is not implemented yet</li></ul>
 *
 * @author finnw
 *
 */
public class FinnwMusicModule implements IMusic {

    public FinnwMusicModule() {
        this.lock = new ReentrantLock();
        this.channels = new ArrayList<Channel>(15);
        this.songs = new ArrayList<Song>(1);
        for (int midiChan = 0; midiChan < 16; ++ midiChan) {
            if (midiChan != 9) {
                channels.add(new Channel(midiChan));
            }
        }
        channels.add(new Channel(9));
    }

    @Override
    public void InitMusic() {
        try {
            receiver = getReceiver();
            EventGroup genMidiEG = new EventGroup(1f);
            genMidiEG.generalMidi(1);
            genMidiEG.sendTo(receiver);
            sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
        } catch (MidiUnavailableException ex) {
            System.err.println(ex);
            receiver = null;
        }
        exec = Executors.newSingleThreadScheduledExecutor(new ThreadFactoryImpl());
    }

    /** Not yet implemented */
    @Override
    public void PauseSong(int handle) {
    }

    @Override
    public void PlaySong(int handle, boolean looping) {
        lock.lock();
        try {
            if (currentTransmitter != null) {
                currentTransmitter.stop();
            }
            currentTransmitter = null;
            if (0 <= handle && handle < songs.size()) {
                prepare(receiver);
                Song song = songs.get(handle);
                currentTransmitter =
                    new ScheduledTransmitter(song.getScoreBuffer(), looping);
                currentTransmitter.setReceiver(receiver);
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public int RegisterSong(byte[] data) {
        return RegisterSong(ByteBuffer.wrap(data));
    }

    public int RegisterSong(ByteBuffer data) {
        Song song = new Song(data);
        lock.lock();
        try {
            int result = songs.indexOf(null);
            if (result >= 0) {
                songs.set(result, song);
            } else {
                result = songs.size();
                songs.add(song);
            }
            return result;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void ResumeSong(int handle) {
    }

    @Override
    public void SetMusicVolume(int volume) {
        float fVol = volume * (1/127f);
        fVol = Math.max(0f, Math.min(fVol, 1f));
        lock.lock();
        try {
            this.volume = fVol;
            if (currentTransmitter != null) {
                currentTransmitter.volumeChanged();
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void ShutdownMusic() {
        exec.shutdown();
    }

    @Override
    public void StopSong(int handle) {
        lock.lock();
        try {
            if (currentTransmitter != null) {
                currentTransmitter.stop();
                currentTransmitter = null;
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void UnRegisterSong(int handle) {
        lock.lock();
        try {
            if (0 <= handle && handle < songs.size()) {
                songs.set(handle, null);
            }
        } finally {
            lock.unlock();
        }
    }

    static boolean hasMusMagic(ByteBuffer magicBuf) {
        return magicBuf.get(0) == 'M' &&
               magicBuf.get(1) == 'U' &&
               magicBuf.get(2) == 'S' &&
               magicBuf.get(3) == 0x1a;
    }

    EventGroup nextEventGroup(ByteBuffer scoreBuffer, boolean looping)  {
        EventGroup result = new EventGroup(volume);
        boolean last;
        do {
            if (! scoreBuffer.hasRemaining()) {
                if (looping) {
                    scoreBuffer.flip();
                } else {
                    return result.emptyToNull();
                }
            }
            int descriptor = scoreBuffer.get() & 0xff;
            last = (descriptor & 0x80) != 0;
            int eventType = (descriptor >> 4) & 7;
            int chanIndex = descriptor & 15;
            Channel channel = channels.get(chanIndex);
            switch (eventType) {
            case 0:
                {
                    int note = scoreBuffer.get() & 0xff;
                    if ((note & 0x80) != 0) {
                        throw new IllegalArgumentException("Invalid note byte");
                    }
                    checkChannelExists("note off", channel).noteOff(note, result);
                }
                break;
            case 1:
                {
                    int note = scoreBuffer.get() & 0xff;
                    boolean hasVelocity = (note & 0x80) != 0;
                    if (hasVelocity) {
                        int velocity = scoreBuffer.get() & 0xff;
                        if ((velocity & 0x80) != 0) {
                            throw new IllegalArgumentException("Invalid velocity byte");
                        }
                        checkChannelExists("note on", channel).noteOn(note & 127, velocity, result);
                    } else {
                        checkChannelExists("note on", channel).noteOn(note, result);
                    }
                }
                break;
            case 2:
                {
                    int wheelVal = scoreBuffer.get() & 0xff;
                    checkChannelExists("pitch bend", channel).pitchBend(wheelVal, result);
                }
                break;
            case 3:
                {
                    int sysEvt = scoreBuffer.get() & 0xff;
                    switch (sysEvt) {
                    case 10:
                        checkChannelExists("all sounds off", channel).allSoundsOff(result);
                        break;
                    case 11:
                        checkChannelExists("all notes off", channel).allNotesOff(result);
                        break;
                    case 14:
                        checkChannelExists("reset all controllers", channel).resetAll(result);
                        break;
                    default:
                        String msg = String.format("Invalid system event (%d)", sysEvt);
                        throw new IllegalArgumentException(msg);
                    }
                }
                break;
            case 4:
                int cNum = scoreBuffer.get() & 0xff;
                if ((cNum & 0x80) != 0) {
                    throw new IllegalArgumentException("Invalid controller number ");
                }
                int cVal = scoreBuffer.get() & 0xff;
                if (cNum == 3 && 133 <= cVal && cVal <= 135) {
                    // workaround for some TNT.WAD tracks
                    cVal = 127;
                }
                if ((cVal & 0x80) != 0) {
                    String msg = String.format("Invalid controller value (%d; cNum=%d)", cVal, cNum);
                    throw new IllegalArgumentException(msg);
                }
                switch (cNum) {
                case 0:
                    checkChannelExists("patch change", channel).patchChange(cVal, result);
                    break;
                case 1:
                    // Don't forward this to the MIDI device.  Some devices
                    // react badly to banks that are undefined in GM Level 1
                    checkChannelExists("bank switch", channel);
                    break;
                case 2:
                    checkChannelExists("vibrato change", channel).vibratoChange(cVal, result);
                    break;
                case 3:
                    checkChannelExists("volume", channel).volume(cVal, result);
                    break;
                case 4:
                    checkChannelExists("pan", channel).pan(cVal, result);
                    break;
                case 5:
                    checkChannelExists("expression", channel).expression(cVal, result);
                    break;
                case 6:
                    checkChannelExists("reverb depth", channel).reverbDepth(cVal, result);
                    break;
                case 7:
                    checkChannelExists("chorus depth", channel).chorusDepth(cVal, result);
                    break;
                default:
                    throw new AssertionError("Controller number " + cNum + ": not yet implemented");
                }
                break;
            case 6:
                if (looping) {
                    scoreBuffer.flip();
                } else {
                    return result.emptyToNull();
                }
                break;
            default:
                String msg = String.format("Unknown event type: last=%5s eventType=%d chanIndex=%d%n", last, eventType, chanIndex);
                throw new IllegalArgumentException(msg);
            }
        } while (! last);
        int qTics = readTime(scoreBuffer);
        result.addDelay(qTics);
        return result;
    }

    static class EventGroup {
        EventGroup(float volScale) {
            this.messages = new ArrayList<MidiMessage>();
            this.volScale = volScale;
        }
        void addDelay(int tics) {
            delay += tics;
        }
        private static final int CHM_ALL_NOTES_OFF = 123;
        private static final int CHM_ALL_SOUND_OFF = 120;
        private static final int CTRL_CHORUS_DEPTH = 93;
        private static final int CTRL_EXPRESSION_POT = 11;
        private static final int CTRL_PAN = 10;
        private static final int RPM_PITCH_BEND_SENSITIVITY = 0;
        private static final int RPL_PITCH_BEND_SENSITIVITY = 0;
        private static final int CHM_RESET_ALL = 121;
        private static final int CTRL_REVERB_DEPTH = 91;
        private static final int CTRL_MODULATION_POT = 1;
        private static final int CTRL_VOLUME = 7;
        void allNotesOff(int midiChan) {
            addControlChange(midiChan, CHM_ALL_NOTES_OFF, 0);
        }
        void allSoundsOff(int midiChan) {
            addControlChange(midiChan, CHM_ALL_SOUND_OFF, 0);
        }
        long appendTo(Sequence sequence, int trackNum, long pos) {
            Track track = sequence.getTracks()[trackNum];
            for (MidiMessage msg: messages) {
                track.add(new MidiEvent(msg, pos));
            }
            return pos + delay * 3;
        }
        long appendTo(Track track, long pos, int scale) {
            for (MidiMessage msg: messages) {
                track.add(new MidiEvent(msg, pos));
            }
            return pos + delay * scale;
        }
        void chorusDepth(int midiChan, int depth) {
            addControlChange(midiChan, CTRL_CHORUS_DEPTH, depth);
        }
        void generalMidi(int mode) {
             addSysExMessage(0xf0, (byte)0x7e, (byte)0x7f, (byte)9, (byte)mode, (byte)0xf7);
        }
        EventGroup emptyToNull() {
            if (messages.isEmpty()) {
                return null;
            } else {
                return this;
            }
        }
        void expression(int midiChan, int expr) {
            addControlChange(midiChan, CTRL_EXPRESSION_POT, expr);
        }
        int getDelay() {
            return delay;
        }
        void noteOn(int midiChan, int note, int velocity) {
            addShortMessage(midiChan, ShortMessage.NOTE_ON, note, velocity);
        }
        void noteOff(int midiChan, int note) {
            addShortMessage(midiChan, ShortMessage.NOTE_OFF, note, 0);
        }
        void pan(int midiChan, int pan) {
            addControlChange(midiChan, CTRL_PAN, pan);
        }
        void patchChange(int midiChan, int patchId) {
            addShortMessage(midiChan, ShortMessage.PROGRAM_CHANGE, patchId, 0);
        }
        void pitchBend(int midiChan, int wheelVal) {
            int pb14 = wheelVal * 64;
            addShortMessage(midiChan, ShortMessage.PITCH_BEND, pb14 % 128, pb14 / 128);
        }
        void pitchBendSensitivity(int midiChan, int semitones) {
            addRegParamChange(midiChan, RPM_PITCH_BEND_SENSITIVITY, RPL_PITCH_BEND_SENSITIVITY, semitones);
        }
        void resetAllControllern(int midiChan) {
            addControlChange(midiChan, CHM_RESET_ALL, 0);
        }
        void reverbDepth(int midiChan, int depth) {
            addControlChange(midiChan, CTRL_REVERB_DEPTH, depth);
        }
        void sendTo(Receiver receiver) {
            for (MidiMessage msg: messages) {
                receiver.send(msg, -1);
            }
        }
        void vibratoChange(int midiChan, int depth) {
            addControlChange(midiChan, CTRL_MODULATION_POT, depth);
        }
        void volume(int midiChan, int vol) {
            vol = (int) Math.round(vol * volScale);
            addControlChange(midiChan, CTRL_VOLUME, vol);
        }
        private void addControlChange(int midiChan, int ctrlId, int ctrlVal) {
            addShortMessage(midiChan, ShortMessage.CONTROL_CHANGE, ctrlId, ctrlVal);
        }
        private void addRegParamChange(int midiChan, int paramMsb, int paramLsb, int valMsb) {
            addControlChange(midiChan, 101, paramMsb);
            addControlChange(midiChan, 100, paramLsb);
            addControlChange(midiChan, 6, valMsb);
        }
        private void addShortMessage(int midiChan, int cmd, int data1, int data2) {
            try {
                ShortMessage msg = new ShortMessage();
                msg.setMessage(cmd, midiChan, data1, data2);
                messages.add(msg);
            } catch (InvalidMidiDataException ex) {
                throw new RuntimeException(ex);
            }
        }
        private void addSysExMessage(int status, byte... data) {
            try {
                SysexMessage msg = new SysexMessage();
                msg.setMessage(status, data, data.length);
                messages.add(msg);
            } catch (InvalidMidiDataException ex) {
                throw new RuntimeException(ex);
            }
        }
        private int delay;
        private final List<MidiMessage> messages;
        private final float volScale;
    }

    /** A collection of kludges to pick a MIDI output device until cvars are implemented */
    static class MidiDeviceComparator implements Comparator<MidiDevice.Info> {
        @Override
        public int compare(MidiDevice.Info o1, MidiDevice.Info o2) {
            float score1 = score(o1), score2 = score(o2);
            if (score1 < score2) {
                return 1;
            } else if (score1 > score2) {
                return -1;
            } else {
                return 0;
            }
        }
        private float score(MidiDevice.Info info) {
            String lcName = info.getName().toLowerCase(Locale.ENGLISH);
            float result = 0f;
            if (lcName.contains("mapper")) {
                // "Midi Mapper" is ideal, because the user can select the default output device in the control panel
                result += 100;
            } else {
                if (lcName.contains("synth")) {
                    // A synthesizer is usually better than a sequencer or USB MIDI port
                    result += 50;
                    if (lcName.contains("java")) {
                        // "Java Sound Synthesizer" has a low sample rate; Prefer another software synth
                        result -= 20;
                    }
                    if (lcName.contains("microsoft")) {
                        // "Microsoft GS Wavetable Synth" is notoriously unpopular, but sometimes it's the only one
                        // with a decent sample rate.
                        result -= 7;
                    }
                }
            }
            return result;
        }
    }

    static class ThreadFactoryImpl implements ThreadFactory {
        @Override
        public Thread newThread(final Runnable r) {
            Thread thread =
                new Thread(r, String.format("FinnwMusicModule-%d", NEXT_ID.getAndIncrement()));
            thread.setPriority(Thread.MAX_PRIORITY - 1);
            return thread;
        }
        private static final AtomicInteger NEXT_ID =
            new AtomicInteger(1);
    }

    final Lock lock;

    static final long nanosPerTick = 1000000000 / 140;

    /** Channels in MUS order (0-14 = instruments, 15 = percussion) */
    final List<Channel> channels;

    ScheduledExecutorService exec;

    float volume;

    private static Receiver getReceiver() throws MidiUnavailableException {
        List<MidiDevice.Info> dInfos =
            new ArrayList<MidiDevice.Info>(Arrays.asList(MidiSystem.getMidiDeviceInfo()));
        for (Iterator<MidiDevice.Info> it = dInfos.iterator();
             it.hasNext();
             ) {
            MidiDevice.Info dInfo = it.next();
            MidiDevice dev = MidiSystem.getMidiDevice(dInfo);
            if (dev.getMaxReceivers() == 0) {
                // We cannot use input-only devices
                it.remove();
            }
        }
        if (dInfos.isEmpty()) return null;
        Collections.sort(dInfos, new MidiDeviceComparator());
        MidiDevice.Info dInfo = dInfos.get(0);
        MidiDevice dev = MidiSystem.getMidiDevice((MidiDevice.Info) dInfo);
        dev.open();
        return dev.getReceiver();
    }

    private void prepare(Receiver receiver) {
        EventGroup setupEG = new EventGroup(volume);
        for (Channel chan: channels) {
            chan.allSoundsOff(setupEG);
            chan.resetAll(setupEG);
            chan.pitchBendSensitivity(2, setupEG);
            chan.volume(127, setupEG);
        }
        setupEG.sendTo(receiver);
    }

    private static void sleepUninterruptibly(int timeout, TimeUnit timeUnit) {
        boolean interrupted = false;
        long now = System.nanoTime();
        final long expiry = now + timeUnit.toNanos(timeout);
        long remaining;
        while ((remaining = expiry - now) > 0L) {
            try {
                TimeUnit.NANOSECONDS.sleep(remaining);
            } catch (InterruptedException ex) {
                interrupted = true;
            } finally {
                now = System.nanoTime();
            }
        }
        if (interrupted) {
            Thread.currentThread().interrupt();
        }
    }
    private static Channel checkChannelExists(String type, Channel channel)
            throws IllegalArgumentException {
        if (channel == null) {
            String msg = String.format("Invalid channel for %s message", type);
            throw new IllegalArgumentException(msg);
        } else {
            return channel;
        }
    }

    private int readTime(ByteBuffer scoreBuffer) {
        int result = 0;
        boolean last;
        do {
            int digit = scoreBuffer.get() & 0xff;
            last = (digit & 0x80) == 0;
            result <<= 7;
            result |= digit & 127;
        } while (! last);
        return result;
    }

    private static class Channel {
        Channel(int midiChan) {
            this.midiChan = midiChan;
        }
        void allNotesOff(EventGroup eventGroup) {
            eventGroup.allNotesOff(midiChan);
        }
        void allSoundsOff(EventGroup eventGroup) {
            eventGroup.allSoundsOff(midiChan);
        }
        void chorusDepth(int depth, EventGroup eventGroup) {
            eventGroup.chorusDepth(midiChan, depth);
        }
        void expression(int expr, EventGroup eventGroup) {
            eventGroup.expression(midiChan, expr);
        }
        void noteOff(int note, EventGroup eventGroup) {
            eventGroup.noteOff(midiChan, note);
        }
        void noteOn(int note, EventGroup eventGroup) {
            eventGroup.noteOn(midiChan, note, lastVelocity);
        }
        void noteOn(int note, int velocity, EventGroup eventGroup) {
            lastVelocity = velocity;
            noteOn(note, eventGroup);
        }
        void pan(int pan, EventGroup eventGroup) {
            eventGroup.pan(midiChan, pan);
        }
        void patchChange(int patchId, EventGroup eventGroup) {
            eventGroup.patchChange(midiChan, patchId);
        }
        void pitchBend(int wheelVal, EventGroup eventGroup) {
            eventGroup.pitchBend(midiChan, wheelVal);
        }
        void pitchBendSensitivity(int semitones, EventGroup eventGroup) {
            eventGroup.pitchBendSensitivity(midiChan, semitones);
        }
        void resetAll(EventGroup eventGroup) {
            eventGroup.resetAllControllern(midiChan);
        }
        void reverbDepth(int depth, EventGroup eventGroup) {
            eventGroup.reverbDepth(midiChan, depth);
        }
        void vibratoChange(int depth, EventGroup eventGroup) {
            eventGroup.vibratoChange(midiChan, depth);
        }
        void volume(int vol, EventGroup eventGroup) {
            eventGroup.volume(midiChan, vol);
            lastVolume = vol;
        }
        void volumeChanged(EventGroup eventGroup) {
            eventGroup.volume(midiChan, lastVolume);
        }
        private int lastVelocity;
        private int lastVolume;
        private final int midiChan;
    }

    private class ScheduledTransmitter implements Transmitter {

        @Override
        public void close() {
            lock.lock();
            try {
                if (autoShutdown && exec != null) {
                    exec.shutdown();
                }
                autoShutdown = false;
                exec = null;
            } finally {
                lock.unlock();
            }
        }

        @Override
        public Receiver getReceiver() {
            return receiver;
        }

        @Override
        public void setReceiver(Receiver receiver) {
            EventGroup currentGroup = null;
            lock.lock();
            try {
                if (this.receiver != null) {
                    if (this.future.cancel(false)) {
                        currentGroup = triggerTask.eventGroup;
                    }
                } else {
                    nextGroupTime = System.nanoTime();
                }
                this.receiver = receiver;
                scheduleIfRequired(receiver, currentGroup);
            } finally {
                lock.unlock();
            }
        }

        ScheduledTransmitter(ByteBuffer scoreBuffer, boolean looping) {
            this.exec = FinnwMusicModule.this.exec;
            this.looping = looping;
            this.scoreBuffer = scoreBuffer;
        }

        void scheduleIfRequired(Receiver receiver,
                                EventGroup currentGroup) {
            assert (((ReentrantLock) lock).isHeldByCurrentThread());
            if (currentGroup == null) {
                try {
                    currentGroup = nextEventGroup(scoreBuffer, looping);
                    if (currentGroup != null) {
                        triggerTask = new TriggerTask(currentGroup, receiver);
                        long delay = Math.max(0, nextGroupTime - System.nanoTime());
                        future =
                            exec.schedule(triggerTask, delay, TimeUnit.NANOSECONDS);
                        nextGroupTime += currentGroup.getDelay() * nanosPerTick;
                    } else {
                        triggerTask = null;
                        future = null;
                    }
                } catch (RejectedExecutionException ex) {
                    // This is normal when shutting down
                } catch (Exception ex) {
                    System.err.println(ex);
                }
            }
        }

        void stop() {
            assert (((ReentrantLock) lock).isHeldByCurrentThread());
            if (future != null) {
                future.cancel(false);
                try {
                    future.get();
                } catch (InterruptedException ex) {
                } catch (ExecutionException ex) {
                } catch (CancellationException ex) {
                }
                future = null;
            }
            EventGroup cleanup = new EventGroup(0f);
            for (Channel chan: channels) {
                chan.allNotesOff(cleanup);
            }
            cleanup.sendTo(receiver);
        }

        void volumeChanged() {
            assert (((ReentrantLock) lock).isHeldByCurrentThread());
            EventGroup adjust = new EventGroup(volume);
            for (Channel chan: channels) {
                chan.volumeChanged(adjust);
            }
            adjust.sendTo(receiver);
        }
        TriggerTask triggerTask;

        private class TriggerTask implements Runnable {
            @Override
            public void run() {
                boolean shouldSend = false;
                lock.lock();
                try {
                    if (triggerTask == this) {
                        shouldSend = true;
                        scheduleIfRequired(receiver, null);
                    }
                } finally {
                    lock.unlock();
                }
                if (shouldSend) {
                    eventGroup.sendTo(receiver);
                }
            }
            TriggerTask(EventGroup eventGroup, Receiver receiver) {
                this.eventGroup = eventGroup;
                this.receiver = receiver;
            }

            final EventGroup eventGroup;
            final Receiver receiver;
        }

        private boolean autoShutdown;

        private ScheduledExecutorService exec;

        private ScheduledFuture<?> future;

        private final boolean looping;

        private long nextGroupTime;

        private Receiver receiver;

        private final ByteBuffer scoreBuffer;
    }

    /** Contains unfiltered MUS data */
    private class Song {
        Song(ByteBuffer data) {
            this.data = data.asReadOnlyBuffer();
            this.data.order(ByteOrder.LITTLE_ENDIAN);
            byte[] magic = new byte[4];
            this.data.get(magic);
            ByteBuffer magicBuf = ByteBuffer.wrap(magic);
            if (! hasMusMagic(magicBuf)) {
                throw new IllegalArgumentException("Expected magic string \"MUS\\x1a\" but found " + Arrays.toString(magic));
            }
            this.scoreLen = this.data.getShort() & 0xffff;
            this.scoreStart = this.data.getShort() & 0xffff;
        }

        /** Get only the score part of the data (skipping the header) */
        ByteBuffer getScoreBuffer() {
            ByteBuffer scoreBuffer = this.data.duplicate();
            scoreBuffer.position(scoreStart);
            scoreBuffer.limit(scoreStart + scoreLen);
            ByteBuffer slice = scoreBuffer.slice();
            return slice;
        }
        private final ByteBuffer data;
        private final int scoreLen;
        private final int scoreStart;
    }

    private ScheduledTransmitter currentTransmitter;

    private Receiver receiver;

    /** Songs indexed by handle */
    private final List<Song> songs;

}

package s;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;
import javax.sound.midi.Sequencer;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.Synthesizer;

/** A {@link Receiver} that scales channel volumes.
 * 
 * Works by recognising channel volume change events and scaling the new volume
 * by the global music volume setting before forwarding the event to the
 * synthesizer.
 *
 * @author finnw
 *
 */
public class VolumeScalingReceiver implements Receiver {

    /** Guess which is the "best" available synthesizer & create a
     *  VolumeScalingReceiver that forwards to it.
     *
     * @return a <code>VolumeScalingReceiver</code> connected to a semi-
     * intelligently-chosen synthesizer.
     *
     */
    public static VolumeScalingReceiver getInstance() {
        try {
            List<MidiDevice.Info> dInfos =
                new ArrayList<MidiDevice.Info>(Arrays.asList(MidiSystem.getMidiDeviceInfo()));
            for (Iterator<MidiDevice.Info> it = dInfos.iterator();
                 it.hasNext();
                 ) {
                MidiDevice.Info dInfo = it.next();
                MidiDevice dev = MidiSystem.getMidiDevice(dInfo);
                if (dev.getMaxReceivers() == 0) {
                    // We cannot use input-only devices
                    it.remove();
                }
            }
            if (dInfos.isEmpty()) return null;
            Collections.sort(dInfos, new MidiDeviceComparator());
            MidiDevice.Info dInfo = dInfos.get(0);
            MidiDevice dev = MidiSystem.getMidiDevice((MidiDevice.Info) dInfo);
            dev.open();
            return new VolumeScalingReceiver(dev.getReceiver());
        } catch (MidiUnavailableException ex) {
            return null;
        }
    }

    /** Create a VolumeScalingReceiver connected to a specific receiver. */
    public VolumeScalingReceiver(Receiver delegate) {
        this.channelVolume = new int[16];
        this.synthReceiver = delegate;
        Arrays.fill(this.channelVolume, 127);
    }

    @Override
    public void close() {
        synthReceiver.close();
    }

    /** Set the scaling factor to be applied to all channel volumes */
    public synchronized void setGlobalVolume(float globalVolume) {
        this.globalVolume = globalVolume;
        for (int chan = 0; chan < 16; ++ chan) {
            int volScaled = (int) Math.round(channelVolume[chan] * globalVolume);
            sendVolumeChange(chan, volScaled, -1);
        }
    }

    /** A collection of kludges to pick a synthesizer until cvars are implemented */
    static class MidiDeviceComparator implements Comparator<MidiDevice.Info> {
        @Override
        public int compare(MidiDevice.Info o1, MidiDevice.Info o2) {
            float score1 = score(o1), score2 = score(o2);
            if (score1 < score2) {
                return 1;
            } else if (score1 > score2) {
                return -1;
            } else {
                return 0;
            }
        }
        /** Guess how suitable a MidiDevice is for music output. */
        private float score(MidiDevice.Info info) {
            String lcName = info.getName().toLowerCase(Locale.ENGLISH);
            float result = 0f;
            try {
                MidiDevice dev = MidiSystem.getMidiDevice(info);
                dev.open();
                try {
                    if (dev instanceof Sequencer) {
                        // The sequencer cannot be the same device as the synthesizer - that would create an infinite loop.
                        return Float.NEGATIVE_INFINITY;
                    } else if (lcName.contains("mapper")) {
                        // "Midi Mapper" is ideal, because the user can select the default output device in the control panel
                        result += 100;
                    } else {
                        if (dev instanceof Synthesizer) {
                            // A synthesizer is usually better than a sequencer or USB MIDI port
                            result += 50;
                            if (lcName.contains("java")) {
                                // "Java Sound Synthesizer" often has a low sample rate or no default soundbank;  Prefer another software synth
                                if (((Synthesizer) dev).getDefaultSoundbank() != null) {
                                    result -= 10;
                                } else {
                                    // Probably won't be audible
                                    result -= 500;
                                }
                            }
                            if (lcName.contains("microsoft")) {
                                // "Microsoft GS Wavetable Synth" is notoriously unpopular, but sometimes it's the only one
                                // with a decent sample rate.
                                result -= 7;
                            }
                        }
                    }
                    return result;
                } finally {
                    dev.close();
                }
            } catch (MidiUnavailableException ex) {
                // Cannot use this one
                return Float.NEGATIVE_INFINITY;
            }
        }
    }

    /** Forward a message to the synthesizer.
     * 
     *  If <code>message</code> is a volume change message, the volume is
     *  first multiplied by the global volume.  Otherwise, the message is
     *  passed unmodified to the synthesizer.
     */
    @Override
    public synchronized void send(MidiMessage message, long timeStamp) {
        int chan = getVolumeChangeChannel(message);
        if (chan < 0) {
            synthReceiver.send(message, timeStamp);
        } else {
            int newVolUnscaled = message.getMessage()[2];
            channelVolume[chan] = newVolUnscaled;
            int newVolScaled = (int) Math.round(newVolUnscaled * globalVolume);
            sendVolumeChange(chan, newVolScaled, timeStamp);
        }
    }

    /** Send a volume update to a specific channel.
     *
     *  This is used for both local & global volume changes.
     */
    private void sendVolumeChange(int chan, int newVolScaled, long timeStamp) {
        newVolScaled = Math.max(0, Math.min(newVolScaled, 127));
        ShortMessage message = new ShortMessage();
        try {
            message.setMessage(0xb0 | (chan & 15), 7, newVolScaled);
            synthReceiver.send(message, timeStamp);
        } catch (InvalidMidiDataException ex) {
            System.err.println(ex);
        }
    }

    /** Determine if the given message is a channel volume change.
     *
     * @return Channel number for which volume is being changed, or -1 if not a
     * channel volume change command.
     */
    private int getVolumeChangeChannel(MidiMessage message) {
        if (message.getLength() >= 3) {
            byte[] mBytes = message.getMessage();
            if ((byte) 0xb0 <= mBytes[0] && mBytes[0] < (byte) 0xc0 &&
                mBytes[1] == 7) {
                return mBytes[0] & 15;
            }
        }
        return -1;
    }

    private final int[] channelVolume;

    private float globalVolume;

    private final Receiver synthReceiver;

}

package s;

//
//  MUSIC I/O
//

public interface IMusic {

	void InitMusic();
	void ShutdownMusic();
	// Volume.
	void SetMusicVolume(int volume);
	/** PAUSE game handling. */
	void PauseSong(int handle);
	void ResumeSong(int handle);
	
	/** Registers a song handle to song data. 
	 *  This should handle any conversions from MUS/MIDI/OPL/etc.
	 * 
	 * */
	int RegisterSong(byte[] data);
	
	
	/** Called by anything that wishes to start music.
	   plays a song, and when the song is done,
	  starts playing it again in an endless loop.
     Horrible thing to do, considering. */
	
	void
	PlaySong
	( int		handle,
	  boolean		looping );
	
	/** Stops a song over 3 seconds. */
	void StopSong(int handle);
	
	/** See above (register), then think backwards */
	void UnRegisterSong(int handle);
}

package s;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MetaMessage;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Sequence;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.Track;

import m.Swap;

/**
 * A MUS lump reader that loads directly to a Sequence.
 * 
 * Unlike QMusToMid, does not keep the MIDI version in a temporary file.
 *
 * @author finnw
 *
 */
public class MusReader {

    /** Create a sequence from an InputStream.
     *  This is the counterpart of {@link MidiSystem#getSequence(InputStream)}
     *  for MUS format.
     *
     * @param is MUS data (this method does not try to auto-detect the format.)
     */
    public static Sequence getSequence(InputStream is)
    throws IOException, InvalidMidiDataException {
        DataInputStream dis = new DataInputStream(is);
        dis.skip(6);
        int rus = dis.readUnsignedShort();
        short scoreStart = Swap.SHORT((char) rus);
        dis.skip(scoreStart - 8);
        Sequence sequence = new Sequence(Sequence.SMPTE_30, 14, 1);
        Track track = sequence.getTracks()[0];
        int[] chanVelocity = new int[16];
        Arrays.fill(chanVelocity, 100);
        EventGroup eg;
        long tick = 0;
        while ((eg = nextEventGroup(dis, chanVelocity)) != null) {
            tick = eg.appendTo(track, tick);
        }
        MetaMessage endOfSequence = new MetaMessage();
        endOfSequence.setMessage(47, new byte[] {0}, 1);
        track.add(new MidiEvent(endOfSequence, tick));
        return sequence;
    }

    private static EventGroup
    nextEventGroup(InputStream is, int[] channelVelocity) throws IOException {
        EventGroup result = new EventGroup();
        boolean last;
        do {
            int b = is.read();
            if (b < 0) {
                return result.emptyToNull();
            }
            int descriptor = b & 0xff;
            last = (descriptor & 0x80) != 0;
            int eventType = (descriptor >> 4) & 7;
            int chanIndex = descriptor & 15;
            final int midiChan;
            if (chanIndex < 9) {
                midiChan = chanIndex;
            } else if (chanIndex < 15) {
                midiChan = chanIndex + 1;
            } else {
                midiChan = 9;
            }
            switch (eventType) {
            case 0:
                {
                    int note = is.read() & 0xff;
                    if ((note & 0x80) != 0) {
                        throw new IllegalArgumentException("Invalid note byte");
                    }
                    result.noteOff(midiChan, note);
                }
                break;
            case 1:
                {
                    int note = is.read() & 0xff;
                    boolean hasVelocity = (note & 0x80) != 0;
                    final int velocity;
                    if (hasVelocity) {
                        velocity = is.read() & 0xff;
                        if ((velocity & 0x80) != 0) {
                            throw new IllegalArgumentException("Invalid velocity byte");
                        }
                        channelVelocity[midiChan] = velocity;
                    } else {
                        velocity = channelVelocity[midiChan];
                    }
                    result.noteOn(midiChan, note & 0x7f, velocity);
                }
                break;
            case 2:
                {
                    int wheelVal = is.read() & 0xff;
                    result.pitchBend(midiChan, wheelVal);
                }
                break;
            case 3:
                {
                    int sysEvt = is.read() & 0xff;
                    switch (sysEvt) {
                    case 10:
                        result.allSoundsOff(midiChan);
                        break;
                    case 11:
                        result.allNotesOff(midiChan);
                        break;
                    case 14:
                        result.resetAllControllers(midiChan);
                        break;
                    default:
                        String msg = String.format("Invalid system event (%d)", sysEvt);
                        throw new IllegalArgumentException(msg);
                    }
                }
                break;
            case 4:
                int cNum = is.read() & 0xff;
                if ((cNum & 0x80) != 0) {
                    throw new IllegalArgumentException("Invalid controller number ");
                }
                int cVal = is.read() & 0xff;
                if (cNum == 3 && 133 <= cVal && cVal <= 135) {
                    // workaround for some TNT.WAD tracks
                    cVal = 127;
                }
                if ((cVal & 0x80) != 0) {
                    String msg = String.format("Invalid controller value (%d; cNum=%d)", cVal, cNum);
                    throw new IllegalArgumentException(msg);
                }
                switch (cNum) {
                case 0:
                    result.patchChange(midiChan, cVal);
                    break;
                case 1:
                    // Don't forward this to the MIDI device.  Some synths if
                    // in GM level 1 mode will react badly to banks that are
                    // undefined in GM Level 1
                    break;
                case 2:
                    result.vibratoChange(midiChan, cVal);
                    break;
                case 3:
                    result.volume(midiChan, cVal);
                    break;
                case 4:
                    result.pan(midiChan, cVal);
                    break;
                case 5:
                    result.expression(midiChan, cVal);
                    break;
                case 6:
                    result.reverbDepth(midiChan, cVal);
                    break;
                case 7:
                    result.chorusDepth(midiChan, cVal);
                    break;
                case 8:
                    result.sustain(midiChan, cVal);
                    break;
                default:
                    throw new AssertionError("Unknown controller number: " + cNum + "(value: " + cVal + ")");
                }
                break;
            case 6:
                return result.emptyToNull();
            default:
                String msg = String.format("Unknown event type: %d", eventType);
                throw new IllegalArgumentException(msg);
            }
        } while (! last);
        int qTics = readVLV(is);
        result.addDelay(qTics);
        return result;
    }

    private static int readVLV(InputStream is) throws IOException {
        int result = 0;
        boolean last;
        do {
            int digit = is.read() & 0xff;
            last = (digit & 0x80) == 0;
            result <<= 7;
            result |= digit & 127;
        } while (! last);
        return result;
    }

    private static class EventGroup {
        EventGroup() {
            this.messages = new ArrayList<MidiMessage>();
        }
        void addDelay(long ticks) {
            delay += ticks;
        }
        void allNotesOff(int midiChan) {
            addControlChange(midiChan, CHM_ALL_NOTES_OFF, 0);
        }
        void allSoundsOff(int midiChan) {
            addControlChange(midiChan, CHM_ALL_SOUND_OFF, 0);
        }
        long appendTo(Track track, long tick) {
            for (MidiMessage msg: messages) {
                track.add(new MidiEvent(msg, tick));
            }
            return tick + delay * 3;
        }
        void chorusDepth(int midiChan, int depth) {
            addControlChange(midiChan, CTRL_CHORUS_DEPTH, depth);
        }
        EventGroup emptyToNull() {
            if (messages.isEmpty()) {
                return null;
            } else {
                return this;
            }
        }
        void expression(int midiChan, int expr) {
            addControlChange(midiChan, CTRL_EXPRESSION_POT, expr);
        }
        void noteOn(int midiChan, int note, int velocity) {
            addShortMessage(midiChan, ShortMessage.NOTE_ON, note, velocity);
        }
        void noteOff(int midiChan, int note) {
            addShortMessage(midiChan, ShortMessage.NOTE_OFF, note, 0);
        }
        void pan(int midiChan, int pan) {
            addControlChange(midiChan, CTRL_PAN, pan);
        }
        void patchChange(int midiChan, int patchId) {
            addShortMessage(midiChan, ShortMessage.PROGRAM_CHANGE, patchId, 0);
        }
        void pitchBend(int midiChan, int wheelVal) {
            int pb14 = wheelVal * 64;
            addShortMessage(midiChan, ShortMessage.PITCH_BEND, pb14 % 128, pb14 / 128);
        }
        void resetAllControllers(int midiChan) {
            addControlChange(midiChan, CHM_RESET_ALL, 0);
        }
        void reverbDepth(int midiChan, int depth) {
            addControlChange(midiChan, CTRL_REVERB_DEPTH, depth);
        }
        void sustain(int midiChan, int on) {
            addControlChange(midiChan, CTRL_SUSTAIN, on);
        }
        void vibratoChange(int midiChan, int depth) {
            addControlChange(midiChan, CTRL_MODULATION_POT, depth);
        }
        void volume(int midiChan, int vol) {
            addControlChange(midiChan, CTRL_VOLUME, vol);
        }
        private void addControlChange(int midiChan, int ctrlId, int ctrlVal) {
            addShortMessage(midiChan, ShortMessage.CONTROL_CHANGE, ctrlId, ctrlVal);
        }
        private void addShortMessage(int midiChan, int cmd, int data1, int data2) {
            try {
                ShortMessage msg = new ShortMessage();
                msg.setMessage(cmd, midiChan, data1, data2);
                messages.add(msg);
            } catch (InvalidMidiDataException ex) {
                throw new RuntimeException(ex);
            }
        }

        private static final int CHM_ALL_NOTES_OFF = 123;
        private static final int CHM_ALL_SOUND_OFF = 120;
        private static final int CTRL_CHORUS_DEPTH = 93;
        private static final int CTRL_EXPRESSION_POT = 11;
        private static final int CTRL_PAN = 10;
        private static final int CTRL_SUSTAIN = 64;
        private static final int CHM_RESET_ALL = 121;
        private static final int CTRL_REVERB_DEPTH = 91;
        private static final int CTRL_MODULATION_POT = 1;
        private static final int CTRL_VOLUME = 7;

        private long delay;
        private final List<MidiMessage> messages;
    }

}

package s;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.SourceDataLine;

import p.mobj_t;
import data.sfxinfo_t;

public class channel_t 
{
	
	public channel_t(){
		sfxinfo=new sfxinfo_t();
	}
    
	/** Currently playing sound. If null, then it's free */
	DoomSound currentSound = null;
	
    sfxinfo_t	sfxinfo;

    // origin of sound (usually a mobj_t).
    mobj_t	origin;

    // handle of the sound being played
    int		handle;
    
    AudioFormat format;
    
	public int sfxVolume;
    
	SourceDataLine auline = null;
}

package s;

import static data.sounds.S_sfx;
import m.FixedFloat;
import data.sfxinfo_t;
import data.sounds;
import doom.DoomStatus;

/**
 * Functionality and fields that are common among the various "sound drivers"
 * should go here.
 * 
 * @author Maes
 */

public abstract class AbstractSoundDriver
        implements ISoundDriver {

    protected final static boolean D = false; // debug
    
    protected final DoomStatus<?,?> DS;

    /**
     * The global mixing buffer. Basically, samples from all active internal
     * channels are modifed and added, and stored in the buffer that is
     * submitted to the audio device. This is a 16-bit stereo signed PCM
     * mixbuffer. Memory order is LSB (?) and channel order is L-R-L-R...
     * 
     * Not all i
     * 
     */

    protected byte[] mixbuffer;// = new byte[MIXBUFFERSIZE];
    
    protected final int numChannels;

    /** The actual lengths of all sound effects. */
    protected final int[] lengths = new int[NUMSFX];

    /**
     * The sound in channel handles, determined on registration, might be used
     * to unregister/stop/modify, currently unused.
     */

    protected final int[] channelhandles;

    /**
     * SFX id of the playing sound effect. Used to catch duplicates (like
     * chainsaw).
     */
    protected final int[] channelids;

    /**
     * Pitch to stepping lookup, used in ClassicSoundDriver It's actually rigged
     * to have a -/+ 400% pitch variation!
     */
    protected final int[] steptable = new int[256];

    /** Volume lookups. 128 levels */
    protected final int[][] vol_lookup = new int[128][256];

    /**
     * Time/gametic that the channel started playing, used to determine oldest,
     * which automatically has lowest priority. In case number of active sounds
     * exceeds available channels.
     */
    protected final int[] channelstart;

    // protected final static DataLine.Info info = new DataLine.Info(Clip.class,
    // format);

    public AbstractSoundDriver(DoomStatus<?,?> DS, int numChannels) {
        this.DS = DS;
        this.numChannels = numChannels;
        channelids = new int[numChannels];
        channelhandles = new int[numChannels];
        channelstart = new int[numChannels];
    }

    /**
     * Generates volume lookup tables which also turn the unsigned samples into
     * signed samples.
     */

    protected final void generateVolumeLUT() {
        for (int i = 0; i < 128; i++)
            for (int j = 0; j < 256; j++)
                vol_lookup[i][j] = (i * (j - 128) * 256) / 127;
    }

    /**
     * This table provides step widths for pitch parameters. Values go from 16K
     * to 256K roughly, with the middle of the table being 64K, and presumably
     * representing unitary pitch. So the pitch variation can be quite extreme,
     * allowing -/+ 400% stepping :-S
     * 
     * @param steptablemid
     * @return
     */

    protected void generateStepTable(int steptablemid) {
        for (int i = -128; i < 128; i++) {
            steptable[steptablemid + i] =
                (int) (Math.pow(2.0, (i / 64.0)) * 65536.0);
            //System.out.printf("Pitch %d %d %f\n",i,steptable[steptablemid + i],FixedFloat.toFloat(steptable[steptablemid + i]));
        }
    }

    /** Read a Doom-format sound effect from disk, leaving it in 8-bit mono format but
     *  upsampling it to the target sample rate.
     *  
     * @param sfxname
     * @param len
     * @param index
     * @return
     */
    
    protected byte[] getsfx(String sfxname, int[] len, int index) {
        byte[] sfx;
        byte[] paddedsfx;
        int i;
        int size;
        int paddedsize;
        String name;
        int sfxlump;

        // Get the sound data from the WAD, allocate lump
        // in zone memory.
        name = String.format("ds%s", sfxname).toUpperCase();

        // Now, there is a severe problem with the
        // sound handling, in it is not (yet/anymore)
        // gamemode aware. That means, sounds from
        // DOOM II will be requested even with DOOM
        // shareware.
        // The sound list is wired into sounds.c,
        // which sets the external variable.
        // I do not do runtime patches to that
        // variable. Instead, we will use a
        // default sound for replacement.
        if (DS.W.CheckNumForName(name) == -1)
            sfxlump = DS.W.GetNumForName("dspistol");
        else
            sfxlump = DS.W.GetNumForName(name);

        DMXSound dmx= DS.W.CacheLumpNum(sfxlump, 0, DMXSound.class);
        
        // KRUDE
        if (dmx.speed==SAMPLERATE/2){
            // Plain linear interpolation.
            dmx.data=DSP.crudeResample(dmx.data,2);
            //DSP.filter(dmx.data,SAMPLERATE, SAMPLERATE/4);
            dmx.datasize=dmx.data.length;
            
        }
        
        sfx = dmx.data;

        // MAES: A-ha! So that's how they do it.
        // SOund effects are padded to the highest multiple integer of
        // the mixing buffer's size (with silence)

        paddedsize =
            ((dmx.datasize + (SAMPLECOUNT - 1)) / SAMPLECOUNT) * SAMPLECOUNT;

        // Allocate from zone memory.
        paddedsfx = new byte[paddedsize];

        // Now copy and pad. The first 8 bytes are header info, so we discard
        // them.
        System.arraycopy(sfx, 0, paddedsfx, 0, dmx.datasize);

        // Pad with silence (unsigned)
        for (i = dmx.datasize; i < paddedsize; i++)
            paddedsfx[i] = (byte) 127;

        // Remove the cached lump.
        DS.W.UnlockLumpNum(sfxlump);

        if (D) System.out.printf("SFX %d name %s size %d speed %d padded to %d\n", index, S_sfx[index].name, dmx.datasize,dmx.speed,paddedsize);
        // Preserve padded length.
        len[index] = paddedsize;

        // Return allocated padded data.
        // So the first 8 bytes are useless?
        return paddedsfx;
    }

    /**
     * Modified getsfx, which transforms samples into 16-bit, signed, stereo
     * beforehand, before being "fed" to the audio clips.
     * 
     * @param sfxname
     * @param index
     * @return
     */
    protected final byte[] getsfx16(String sfxname, int[] len, int index) {
        byte[] sfx;
        byte[] paddedsfx;
        int i;
        int size;
        int paddedsize;
        String name;
        int sfxlump;

        // Get the sound data from the WAD, allocate lump
        // in zone memory.
        name = String.format("ds%s", sfxname).toUpperCase();

        // Now, there is a severe problem with the
        // sound handling, in it is not (yet/anymore)
        // gamemode aware. That means, sounds from
        // DOOM II will be requested even with DOOM
        // shareware.
        // The sound list is wired into sounds.c,
        // which sets the external variable.
        // I do not do runtime patches to that
        // variable. Instead, we will use a
        // default sound for replacement.
        if (DS.W.CheckNumForName(name) == -1)
            sfxlump = DS.W.GetNumForName("dspistol");
        else
            sfxlump = DS.W.GetNumForName(name);

        size = DS.W.LumpLength(sfxlump);

        sfx = DS.W.CacheLumpNumAsRawBytes(sfxlump, 0);

        // Size blown up to accommodate two channels and 16 bits.
        // Sampling rate stays the same.

        paddedsize = (size - 8) * 2 * 2;
        // Allocate from zone memory.
        paddedsfx = new byte[paddedsize];

        // Skip first 8 bytes (header), blow up the data
        // to stereo, BIG ENDIAN, SIGNED, 16 bit. Don't expect any fancy DSP
        // here!

        int sample = 0;
        for (i = 8; i < size; i++) {
            // final short sam=(short) vol_lookup[127][0xFF&sfx[i]];
            final short sam = (short) ((0xFF & sfx[i] - 128) << 8);
            paddedsfx[sample++] = (byte) (0xFF & (sam >> 8));
            paddedsfx[sample++] = (byte) (0xFF & sam);
            paddedsfx[sample++] = (byte) (0xFF & (sam >> 8));
            paddedsfx[sample++] = (byte) (0xFF & sam);
        }

        // Remove the cached lump.
        DS.W.UnlockLumpNum(sfxlump);

        // Preserve padded length.
        len[index] = paddedsize;

        // Return allocated padded data.
        // So the first 8 bytes are useless?
        return paddedsfx;
    }

    /**
     * Starting a sound means adding it to the current list of active sounds in
     * the internal channels. As the SFX info struct contains e.g. a pointer to
     * the raw data it is ignored. As our sound handling does not handle
     * priority, it is ignored. Pitching (that is, increased speed of playback)
     * is set, but whether it's used or not depends on the final implementation
     * (e.g. classic mixer uses it, but AudioLine-based implementations are not
     * guaranteed.
     */

    @Override
    public int StartSound(int id, int vol, int sep, int pitch, int priority) {

        if (id < 1 || id > S_sfx.length - 1)
            return BUSY_HANDLE;

        // Find a free channel and get a timestamp/handle for the new sound.
        int handle = this.addsfx(id, vol, steptable[pitch], sep);

        return handle;
    }

    /**
     * This function adds a sound to the list of currently active sounds, which
     * is maintained as a given number (eight, usually) of internal channels.
     * Returns a handle.
     * 
     * @param sfxid
     * @param volume
     * @param step
     * @param seperation
     * @return
     */

    protected abstract int addsfx(int sfxid, int volume, int step,
            int seperation);

    protected short handlenums = 0;

    //
    // Retrieve the raw data lump index
    // for a given SFX name.
    //
    public final int GetSfxLumpNum(sfxinfo_t sfx) {
        String namebuf;
        namebuf = String.format("ds%s", sfx.name).toUpperCase();
        if (namebuf.equals("DSNONE"))
            return -1;

        int lump;
        try {
            lump = DS.W.GetNumForName(namebuf);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }

        return lump;
    }

    /**
     * Initialize 
     * 
     * @return
     */
    protected  final void initMixBuffer() {
        for (int i = 0; i < MIXBUFFERSIZE; i += 4) {
            mixbuffer[i] =
                (byte) (((int) (0x7FFF * Math.sin(1.5 * Math.PI * (double) i
                        / MIXBUFFERSIZE)) & 0xff00) >>> 8);
            mixbuffer[i + 1] =
                (byte) ((int) (0x7FFF * Math.sin(1.5 * Math.PI * (double) i
                        / MIXBUFFERSIZE)) & 0xff);
            mixbuffer[i + 2] =
                (byte) (((int) (0x7FFF * Math.sin(1.5 * Math.PI * (double) i
                        / MIXBUFFERSIZE)) & 0xff00) >>> 8);
            mixbuffer[i + 3] =
                (byte) ((int) (0x7FFF * Math.sin(1.5 * Math.PI * (double) i
                        / MIXBUFFERSIZE)) & 0xff);

        }
    }
    
    /**
     * Loads samples in 8-bit format, forcibly converts them to the common sampling rate.
     * Used by.
     */

    protected final void initSound8() {
        int i;

        // Initialize external data (all sounds) at start, keep static.

        for (i = 1; i < NUMSFX; i++) {
            // Alias? Example is the chaingun sound linked to pistol.
            if (sounds.S_sfx[i].link == null) {
                // Load data from WAD file.
                S_sfx[i].data = getsfx(S_sfx[i].name, lengths, i);
            } else {
                // Previously loaded already?
                S_sfx[i].data = S_sfx[i].link.data;
            }
        }
    }

    /**
     * This is only the common part of InitSound that caches sound data in
     * 16-bit, stereo format (used by Audiolines). INTO sfxenum_t.
     * 
     * Only used by the Clip and David "drivers".
     * 
     */

    protected final void initSound16() {
        int i;

        // Initialize external data (all sounds) at start, keep static.

        for (i = 1; i < NUMSFX; i++) {
            // Alias? Example is the chaingun sound linked to pistol.
            if (sounds.S_sfx[i].link == null) {
                // Load data from WAD file.
                S_sfx[i].data = getsfx16(S_sfx[i].name, lengths, i);
            } else {
                // Previously loaded already?
                S_sfx[i].data = S_sfx[i].link.data;
            }
        }
    }

}

package s;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Hashtable;

import w.CacheableDoomObject;

/** Blatantly ripping off Chocolate Doom */

public class SpeakerSound implements CacheableDoomObject{
    
    public short header;
    public short length;
    public byte[] data;
    
    public static int[] timer_values=new int[]{0,
        6818,        6628,        6449,        6279,
        6087,        5906,        5736,        5575,
        5423,        5279,        5120,        4971,
        4830,        4697,        4554,        4435,
        4307,        4186,        4058,        3950,
        3836,        3728,        3615,        3519,
        3418,        3323,        3224,        3131,
        3043,        2960,        2875,        2794,
        2711,        2633,        2560,        2485,
        2415,        2348,        2281,        2213,
        2153,        2089,        2032,        1975,
        1918,        1864,        1810,        1757,
        1709,        1659,        1612,        1565,
        1521,        1478,        1435,         1395,
        1355,        1316,        1280,        1242,
        1207,        1173,       1140,         1107,
        1075,        1045,        1015,        986,
        959,        931,        905,        879,
        854,        829,        806,        783,
        760,        739,        718,        697,
        677,        658,        640,        621,
        604,        586,        570,        553,
        538,        522,        507,        493,
        479,        465,        452};
    
    /* From analysis of fraggle's PC Speaker timings, it was found
     * that their natural logarithm had the following intercept 
     * (starting at x=1) and slope. Therefore, it's possible
     * to go beyong the original 95 hardcoded values.
     */
    public static final double INTERCEPT=8.827321453;
    public static final double SLOPE=-0.028890647;
    public static final int CIA_8543_FREQ=1193182;

    public static float[] f=new float[256];
    
    static {
        f[0]=0;
        
        for (int x=1;x<f.length;x++){
            
            //f[x] = CIA_8543_FREQ/timer_values[x];
            
            f[x] = (float) (CIA_8543_FREQ/Math.exp(INTERCEPT+SLOPE*(x-1)));
            
        }
    }

    /** Will return a very basic, 8-bit 11.025 KHz rendition of the sound 
     *  This ain't no CuBase or MatLab, so if you were expecting perfect
     *  sound and solid DSP, go elsewhere.
     * 
     */
    public byte[] toRawSample(){
        // Length is in 1/140th's of a second 
        byte[] chunk=new byte[this.length*11025/140];

        int counter=0;
        for (int i=0;i<this.length;i++){
            byte[] tmp=getPhoneme(this.data[i]);
            System.arraycopy(tmp, 0,chunk,counter,tmp.length);
            counter+=tmp.length;
        }
        return chunk;
    }
    
    private static Hashtable<Integer,byte[]> phonemes=new Hashtable<Integer,byte[]>();
    
    public static byte[] getPhoneme(int phoneme){
        
        if (!phonemes.containsKey(phoneme)){
            
            // Generate a square wave with a duration of 1/140th of a second
            int samples=11025/140;
            byte[] tmp=new byte[samples];

            float frequency=f[phoneme];
            for (int i=0;i<samples;i++){                
                tmp[i]=(byte) (127+127*Math.signum(Math.sin(frequency*Math.PI*2*(i/11025f))));
            }
            
            phonemes.put(phoneme, tmp);
        }
        
        return phonemes.get(phoneme);
        
    }
    
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        buf.order(ByteOrder.LITTLE_ENDIAN);
        header=buf.getShort();
        length=buf.getShort();
        data=new byte[length];
        buf.get(data);
        
    }
    
}

package s;

public class DummyMusic implements IMusic {

	@Override
	public void InitMusic() {
		// TODO Auto-generated method stub

	}

	@Override
	public void ShutdownMusic() {
		// TODO Auto-generated method stub

	}

	@Override
	public void SetMusicVolume(int volume) {
		// TODO Auto-generated method stub

	}

	@Override
	public void PauseSong(int handle) {
		// TODO Auto-generated method stub

	}

	@Override
	public void ResumeSong(int handle) {
		// TODO Auto-generated method stub

	}

	@Override
	public int RegisterSong(byte[] data) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void PlaySong(int handle, boolean looping) {
		// TODO Auto-generated method stub

	}

	@Override
	public void StopSong(int handle) {
		// TODO Auto-generated method stub

	}

	@Override
	public void UnRegisterSong(int handle) {
		// TODO Auto-generated method stub

	}

}

package s;

import p.mobj_t;
import data.sounds.musicenum_t;
import data.sounds.sfxenum_t;

/** Does nothing. Just allows me to code without
 *  commenting out ALL sound-related code. Hopefully
 *  it will be superseded by a real sound driver one day.
 * 
 * @author Velktron
 *
 */

public class DummySoundDriver implements IDoomSound{

	@Override
	public void Init(int sfxVolume, int musicVolume) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void Start() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StartSound(ISoundOrigin origin, int sound_id) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StartSound(ISoundOrigin origin, sfxenum_t sound_id) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StartSoundAtVolume(ISoundOrigin origin, int sound_id, int volume) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StopSound(ISoundOrigin origin) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void ChangeMusic(int musicnum, boolean looping) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StopMusic() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void PauseSound() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void ResumeSound() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void UpdateSounds(mobj_t listener) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void SetMusicVolume(int volume) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void SetSfxVolume(int volume) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StartMusic(int music_id) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void StartMusic(musicenum_t music_id) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void ChangeMusic(musicenum_t musicnum, boolean looping) {
		// TODO Auto-generated method stub
		
	}

}

package s;

import java.util.ArrayList;
import java.util.concurrent.Semaphore;

import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.FloatControl;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.FloatControl.Type;

import data.sounds;
import data.sounds.sfxenum_t;
import doom.DoomStatus;

/** David Martel's sound driver for Mocha Doom. Excellent work!
 * 
 *  However, it's based on Java Audiolines, and as such has a number
 *  of drawbacks:
 *  
 * a) Sounds are forcibly blown to be stereo, 16-bit otherwise it's 
 *    impossible to get panning controls.
 * b) Volume, master gain, panning, pitch etc. controls are NOT guaranteed
 *    to be granted across different OSes , and your mileage may vary. It's
 *    fairly OK under Windows and OS X, but Linux is very clunky. The only
 *    control that is -somewhat- guaranteed is the volume one.
 * c) Spawns as many threads as channels. Even if semaphore waiting it used,
 *    that can be taxing for slower systems.

 * 
 * @author David
 * @author Velktron
 *
 */

public class DavidSFXModule extends AbstractSoundDriver{
	
	ArrayList<DoomSound> cachedSounds=new ArrayList<DoomSound>();
	
	public final float[] linear2db;	
	
	private SoundWorker[] channels;
	private Thread[] soundThread;
	
	public DavidSFXModule(DoomStatus DS,int numChannels) {
		super(DS,numChannels);
		linear2db=computeLinear2DB();
		
		}
	
    private float[] computeLinear2DB() {
    	
    	// Maximum volume is 0 db, minimum is ... -96 db.
    	// We rig this so that half-scale actually gives quarter power,
    	// and so is -6 dB.
    	float[] tmp=new float[VOLUME_STEPS];
    	
    	for (int i=0;i<VOLUME_STEPS;i++){
    		float linear=(float)(10*Math.log10((float)i/(float)VOLUME_STEPS));
    		// Hack. The minimum allowed value as of now is -80 db.
    		if (linear<-36.0) linear=-36.0f;
    		tmp[i]= linear;
    		
    	}
    		
    		
    		
		return tmp;
	}

	@Override
	public boolean InitSound() {
        // Secure and configure sound device first.
        System.err.println("I_InitSound: ");

        // Initialize external data (all sounds) at start, keep static.

        initSound16();

        // Cache sounds internally so they can be "fed" to AudioLine threads later.
        // These can be more than the usual built-in sounds.
        
        
        for (int i=0;i<sounds.S_sfx.length;i++){
        	DoomSound tmp=new DoomSound(sounds.S_sfx[i],DoomSound.DEFAULT_SAMPLES_FORMAT);
        	cachedSounds.add(tmp);	
        	}
        
        System.err.print(" pre-cached all sound data\n");
        // Finished initialization.
        System.err.print("I_InitSound: sound module ready\n");
        
        return true;
		
	}

	@Override
	public void UpdateSound() {
		// In theory, we should update volume + panning for each active channel.
		// Ouch. Ouch Ouch.
		
	}

	@Override
	public void SubmitSound() {
		// Sound should be submitted to the sound threads, which they pretty much
		// do themselves.
		
	}

	@Override
	public void ShutdownSound() {
		 // Wait till all pending sounds are finished.
		  boolean done = false;
		  int i;
		  
		  while ( !done)
		  {
		    for( i=0 ; i<numChannels && !(channels[i].isPlaying()) ; i++);
		    if (i==numChannels)  done=true;
		  }
		  
		  for( i=0 ; i<numChannels; i++){
			channels[i].terminate=true;  
			channels[i].wait.release();
			try {
				this.soundThread[i].join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		  }
		  // Done.
		  return;
		
	}

	@Override
	public void SetChannels(int numChannels) {

		channels= new SoundWorker[numChannels];
		soundThread= new Thread[numChannels];	
		
		// This is actually called from IDoomSound.
		for (int i = 0; i < numChannels; i++) {
			channels[i]=new SoundWorker(i);
			soundThread[i] = new Thread(channels[i]);
			soundThread[i].start();
		}
		
	}
	
	/** This one will only create datalines for common clip/audioline samples
	 *  directly.
	 * 
	 * @param c
	 * @param sfxid
	 */
	private final void  createDataLineForChannel(int c, int sfxid){
		
		// None? Make a new one.
		
		if (channels[c].auline == null) {
        	try {
        		DoomSound tmp=cachedSounds.get(sfxid);
        		// Sorry, Charlie. Gotta make a new one.
        		DataLine.Info info = new DataLine.Info(SourceDataLine.class, DoomSound.DEFAULT_SAMPLES_FORMAT);
				channels[c].auline = (SourceDataLine) AudioSystem.getLine(info);
				channels[c].auline.open(tmp.format);
			} catch (LineUnavailableException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
					boolean errors=false;
        			// Add individual volume control.
        			if (channels[c].auline.isControlSupported(Type.MASTER_GAIN))
        				channels[c].vc=(FloatControl) channels[c].auline
        				.getControl(Type.MASTER_GAIN);
        			else {
        			System.err.print("MASTER_GAIN, ");
        			errors=true;
        			if (channels[c].auline.isControlSupported(Type.VOLUME))
            				channels[c].vc=(FloatControl) channels[c].auline
            				.getControl(Type.VOLUME);
        			else 
        				System.err.print("VOLUME, ");
        			} 
        			

        			// Add individual pitch control.
        			if (channels[c].auline.isControlSupported(Type.SAMPLE_RATE)){
        				channels[c].pc=(FloatControl) channels[c].auline
        				.getControl(Type.SAMPLE_RATE);
        			} else {
        				errors=true;
        				System.err.print("SAMPLE_RATE, ");
        			} 
        			
        			// Add individual pan control
        			if (channels[c].auline.isControlSupported(Type.BALANCE)){
        				channels[c].bc=(FloatControl) channels[c].auline
        				.getControl(FloatControl.Type.BALANCE);
        			} else {
        				System.err.print("BALANCE, ");
        				errors=true;
        				if (channels[c].auline.isControlSupported(Type.PAN)){        					
        				channels[c].bc=(FloatControl) channels[c].auline
        				.getControl(FloatControl.Type.PAN);
        			} else {
        				System.err.print("PANNING ");
        				}
        			}

        			if (errors) System.err.printf("for channel %d NOT supported!\n",c);
        			
        			channels[c].auline.start();
        		}
	}

	/* UNUSED version, designed to work on any type of sample (in theory).
	   Requires a DoomSound container for separate format information.
	  
	 private final void  createDataLineForChannel(int c, DoomSound sound){
		if (channels[c].auline == null) {
        	AudioFormat format = sound.ais.getFormat();
        	DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
        	try {
				channels[c].auline = (SourceDataLine) AudioSystem.getLine(info);
				channels[c].auline.open(format);
			} catch (LineUnavailableException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
        			// Add individual volume control.
        			if (channels[c].auline.isControlSupported(Type.MASTER_GAIN))
        				channels[c].vc=(FloatControl) channels[c].auline
        				.getControl(Type.MASTER_GAIN);
        			else {
        			System.err.printf("MASTER_GAIN for channel %d NOT supported!\n",c);
        			if (channels[c].auline.isControlSupported(Type.VOLUME))
            				channels[c].vc=(FloatControl) channels[c].auline
            				.getControl(Type.VOLUME);
        			else 
        				System.err.printf("VOLUME for channel %d NOT supported!\n",c);
        			} 
        			

        			// Add individual pitch control.
        			if (channels[c].auline.isControlSupported(Type.SAMPLE_RATE)){
        				channels[c].pc=(FloatControl) channels[c].auline
        				.getControl(Type.SAMPLE_RATE);
        			} else {
        				System.err.printf("SAMPLE_RATE for channel %d NOT supported!\n",c);
        			} 
        			
        			// Add individual pan control (TODO: proper positioning).
        			if (channels[c].auline.isControlSupported(Type.BALANCE)){
        				channels[c].bc=(FloatControl) channels[c].auline
        				.getControl(FloatControl.Type.BALANCE);
        			} else {
        				System.err.printf("BALANCE for channel %d NOT supported!\n",c);
        				if (channels[c].auline.isControlSupported(Type.PAN)){        					
        				channels[c].bc=(FloatControl) channels[c].auline
        				.getControl(FloatControl.Type.PAN);
        			} else {
        				System.err.printf("PAN for channel %d NOT supported!\n",c);
        			}
        			}

        			channels[c].auline.start();
        		}
	}
	*/
	
	@Override
	protected int addsfx( int sfxid,int volume,int pitch, int seperation)
	{
		int		i;
		int		rc = -1;

		int		oldest = DS.gametic;
		int		oldestnum = 0;
		int		slot;

		int		rightvol;
		int		leftvol;

		// Chainsaw troubles.
		// Play these sound effects only one at a time.
		if ( sfxid == sfxenum_t.sfx_sawup.ordinal()
				|| sfxid == sfxenum_t.sfx_sawidl.ordinal()
				|| sfxid == sfxenum_t.sfx_sawful.ordinal()
				|| sfxid == sfxenum_t.sfx_sawhit.ordinal()
				|| sfxid == sfxenum_t.sfx_stnmov.ordinal()
				|| sfxid == sfxenum_t.sfx_pistol.ordinal()	 )
		{
			// Loop all channels, check.
			for (i=0 ; i<numChannels ; i++)
			{
				// Active, and using the same SFX?
				if ( (channels[i].isPlaying())
						&& (channelids[i] == sfxid) )
				{
					// Reset.
					channels[i].stopSound();
					// We are sure that iff,
					//  there will only be one.
					break;
				}
			}
		}

		// Loop all channels to find oldest SFX.
		for (i=0; (i<numChannels) && (channels[i]!=null); i++)
		{
			if (channelstart[i] < oldest)
			{
				oldestnum = i;
				oldest = channelstart[i];
			}
		}

		// Tales from the cryptic.
		// If we found a channel, fine.
		// If not, we simply overwrite the first one, 0.
		// Probably only happens at startup.
		if (i == numChannels)
			slot = oldestnum;
		else
			slot = i;

		// Okay, in the less recent channel,
		//  we will handle the new SFX.
		// Set pointer to raw data.
	      
        // Create a dataline for the "lucky" channel,
		// or reuse an existing one if it exists.
        createDataLineForChannel(slot,sfxid);

		// Reset current handle number, limited to 0..100.
		if (handlenums==0) // was !handlenums, so it's actually 1...100?
			handlenums = MAXHANDLES;

		// Assign current handle number.
		// Preserved so sounds could be stopped (unused).
		channelhandles[slot]= rc = handlenums--;
		channelstart[slot] = DS.gametic;

		// Separation, that is, orientation/stereo.
		//  range is: 1 - 256
		seperation += 1;

		// Per left/right channel.
		//  x^2 seperation,
		//  adjust volume properly.
		leftvol =
			volume - ((volume*seperation*seperation) >> 16); ///(256*256);
		seperation = seperation - 257;
		rightvol =
			volume - ((volume*seperation*seperation) >> 16);	


		// Sanity check, clamp volume.

		if (rightvol < 0 || rightvol > 127)
			DS.I.Error("rightvol out of bounds");

		if (leftvol < 0 || leftvol > 127)
			DS.I.Error("leftvol out of bounds"); 

		// Preserve sound SFX id,
		//  e.g. for avoiding duplicates of chainsaw.
		channelids[slot] = sfxid;

		channels[slot].setVolume(volume);
		channels[slot].setPanning(seperation+256);
		channels[slot].addSound(cachedSounds.get(sfxid).data, handlenums);
		channels[slot].setPitch(pitch);
		
		if (D) System.err.println(channelStatus());
        if (D) System.err.printf("Playing %d vol %d on channel %d\n",rc,volume,slot);
		// You tell me.
		return rc;
	}
	
	@Override
	public void StopSound(int handle) {
		// Which channel has it?
		int  hnd=getChannelFromHandle(handle);
		if (hnd>=0) 
			channels[hnd].stopSound();
	}

	@Override
	public boolean SoundIsPlaying(int handle) {
		
		return getChannelFromHandle(handle)!=BUSY_HANDLE;
		}

	
	@Override
	public void UpdateSoundParams(int handle, int vol, int sep, int pitch) {
		
		// This should be called on sounds that are ALREADY playing. We really need
		// to retrieve channels from their handles.
		
		//System.err.printf("Updating sound with handle %d vol %d sep %d pitch %d\n",handle,vol,sep,pitch);
		
		int i=getChannelFromHandle(handle);
		// None has it?
		if (i!=BUSY_HANDLE){
			//System.err.printf("Updating sound with handle %d in channel %d\n",handle,i);
			channels[i].setVolume(vol);
			channels[i].setPitch(pitch);
			channels[i].setPanning(sep);
			}
		
	}
	
	/** Internal use. 
	 * 
	 * @param handle
	 * @return the channel that has the handle, or -2 if none has it.
	 */
	private int getChannelFromHandle(int handle){
		// Which channel has it?
		for (int i=0;i<numChannels;i++){
			if (channelhandles[i]==handle) return i;
		}
		
		return BUSY_HANDLE;
	}
	
	/** A Thread for playing digital sound effects.
	 * 
	 *  Obviously you need as many as channels?
	 *   
	 *  In order not to end up in a hell of effects,
	 *  certain types of sounds must be limited to 1 per object.
	 *
	 */


	private class SoundWorker implements Runnable {
			public Semaphore wait; // Holds the worker still until there's a new sound
			FloatControl vc; // linear volume control
			FloatControl bc; // balance/panning control
			FloatControl pc; // pitch control
			byte[] currentSoundSync;
			byte[] currentSound;
			
			public SoundWorker(int id){
				this.id=id;
				this.handle=IDLE_HANDLE;
				wait=new Semaphore(1);
			}
			

			int id;
			/** Used to find out whether the same object is continuously making
			 *  sounds. E.g. the player, ceilings etc. In that case, they must be
			 *  interrupted.
			 */
			int handle;
			public boolean terminate;
			SourceDataLine auline;
			
			/** This is how you tell the thread to play a sound,
			 * I suppose.  */
			
			public void addSound(byte[] ds, int handle) {
				
				if (D) System.out.printf("Added handle %d to channel %d\n",handle,id);
				this.handle=handle;
				this.currentSound=ds;
				this.auline.stop();
				this.auline.start();
				this.wait.release();
				
			}

			/** Accepts volume in "Doom" format (0-127).
			 * 
			 * @param volume
			 */
			public void setVolume(int volume){
				if (vc!=null){
					if (vc.getType()==FloatControl.Type.MASTER_GAIN) {
						float vol = linear2db[volume];
						vc.setValue(vol);
						}
					else if (vc.getType()==FloatControl.Type.VOLUME){
						float vol = vc.getMinimum()+(vc.getMaximum()-vc.getMinimum())*(float)volume/127f;
						vc.setValue(vol);
					}
				}
				}
			
			public void setPanning(int sep){
				// Q: how does Doom's sep map to stereo panning?
				// A: Apparently it's 0-255 L-R.
				if (bc!=null){
				float pan= bc.getMinimum()+(bc.getMaximum()-bc.getMinimum())*(float)(sep)/ISoundDriver.PANNING_STEPS;
				//System.err.printf("Panning %d %f %f %f\n",sep,bc.getMinimum(),bc.getMaximum(),pan);
				bc.setValue(pan);
				}
			}
			
			/** Expects a steptable value between 16K and 256K, with
			 *  64K being the middle.
			 * 
			 * @param pitch
			 */
			public void setPitch(int pitch){
				if (pc!=null){
				float pan= (float) (pc.getValue()*((float)pitch/65536.0));
				pc.setValue(pan);
				}
			}
			
			public void run() {
				System.err.printf("Sound thread %d started\n",id);
				while (!terminate) {
					currentSoundSync = currentSound;
					if (currentSoundSync != null) {

						try {
							auline.write(currentSoundSync, 0, currentSoundSync.length);
						} catch (Exception e) { 
							e.printStackTrace();
							return;
						} finally {
							// The previous steps are actually VERY fast.
							// However this one waits until the data has been
							// consumed, Interruptions/signals won't reach  here,
							// so it's pointless trying to interrupt the actual filling.
							//long a=System.nanoTime();
							auline.drain();
							//long b=System.nanoTime();
							//System.out.printf("Channel %d completed in %f.\n",id,(float)(b-a)/1000000000f);
							}
						// Report that this channel is free.
						currentSound = null;
						// Remove its handle.
						
						//System.out.printf("Channel  %d with handle %d done. Marking as free\n",id,handle);
						if (handle>0)
						channelhandles[this.id]=IDLE_HANDLE;
						this.handle=IDLE_HANDLE;
					}

					// If we don't sleep at least a bit here, busy waiting becomes
					// way too taxing. Waiting on a semaphore (triggered by adding a new sound)
					// seems like a better method.

					try {
						wait.acquire();
					} catch (InterruptedException e) {
					} 
				}
			}

			public void stopSound() {
					auline.stop();
					auline.flush();
					//System.out.printf("Channel %d with handle %d interrupted. Marking as free\n",id,handle);
					channelhandles[this.id]=IDLE_HANDLE;
					this.handle=IDLE_HANDLE;
					currentSound = null;
					auline.start();
					}

			public boolean isPlaying() {
				//System.out.printf("Channel %d with handle %d queried\n",id,handle);
				return (this.handle!=IDLE_HANDLE||this.currentSound!=null);
			}

		}

		StringBuilder sb=new StringBuilder();
	
		public String channelStatus(){
			sb.setLength(0);
			for (int i=0;i<numChannels;i++){
				if (channels[i].isPlaying())
				sb.append(i);
				else sb.append('-');
			}
			
			return sb.toString();
			
			
		}
	
}


package s;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioFormat.Encoding;

import data.sfxinfo_t;

/** A class representing a sample in memory 
 *  Convenient for wrapping/mirroring it regardless of what it represents.
 * */
class DoomSound extends sfxinfo_t {

	/** This audio format is the one used by internal samples (16 bit, 11KHz, Stereo) 
     *  for Clips and AudioLines. Sure, it's not general enough... who cares though?
     */
	public final static AudioFormat DEFAULT_SAMPLES_FORMAT=new AudioFormat(Encoding.PCM_SIGNED, ISoundDriver.SAMPLERATE, 16, 2, 4, ISoundDriver.SAMPLERATE, true);
	
	public final static AudioFormat DEFAULT_DOOM_FORMAT=new AudioFormat(Encoding.PCM_UNSIGNED, ISoundDriver.SAMPLERATE, 8, 1, 1, ISoundDriver.SAMPLERATE, true);
	
	
	public AudioFormat format;
	
	public DoomSound(AudioFormat format) {
		this.format=format;
	}
	
	public DoomSound(){
		this.format=DEFAULT_DOOM_FORMAT;
	}
	
	public DoomSound(sfxinfo_t sfx,AudioFormat format){
		this(format);
		this.data=sfx.data;
		this.pitch=sfx.pitch;
		this.link=sfx.link;
		this.lumpnum=sfx.lumpnum;
		this.name=sfx.name;
		this.priority=sfx.priority;
		this.singularity=sfx.singularity;
		this.usefulness=sfx.usefulness;
		this.volume=sfx.volume;
		}
	
}

package s;

import data.sfxinfo_t;

public class DummySFX implements ISoundDriver {

	@Override
	public boolean InitSound() {
		// Dummy is super-reliable ;-)
		return true;
	}

	@Override
	public void UpdateSound() {
		// TODO Auto-generated method stub

	}

	@Override
	public void SubmitSound() {
		// TODO Auto-generated method stub

	}

	@Override
	public void ShutdownSound() {
		// TODO Auto-generated method stub

	}

	@Override
	public int GetSfxLumpNum(sfxinfo_t sfxinfo) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int StartSound(int id, int vol, int sep, int pitch, int priority) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void StopSound(int handle) {
		// TODO Auto-generated method stub

	}

	@Override
	public boolean SoundIsPlaying(int handle) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void UpdateSoundParams(int handle, int vol, int sep, int pitch) {
		// TODO Auto-generated method stub

	}

	@Override
	public void SetChannels(int numChannels) {
		// TODO Auto-generated method stub
		
	}

}

package s;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import utils.C2JUtils;

public class DoomToWave {

	static int MEMORYCACHE = 0x8000;
	static class RIFFHEAD	{
	  byte[] riff = new byte[4];
	  int length;
	  byte[] wave = new byte[4];
	  
	  public void pack(ByteBuffer b){
		  b.put(riff);
		  b.putInt(length);
		  b.put(wave);
	  }
	  
	  public int size(){
		  return 12;
	  }
	  
	}
	
	RIFFHEAD headr = new RIFFHEAD();
	
	static class CHUNK 
	{ byte[] name = new byte[4];
	  int size;
	  
	  public void pack(ByteBuffer b){
		  b.put(name);
		  b.putInt(size);
	  }
	  
	  public int size(){
		  return 8;
	  }
	}
	
	CHUNK headc = new CHUNK();
	
	static class WAVEFMT
	{ byte[] fmt = new byte[4];      /* "fmt " */
	  int fmtsize;    /*0x10*/
	  int tag;        /*format tag. 1=PCM*/
	  int channel;    /*1*/
	  int smplrate;
	  int bytescnd;   /*average bytes per second*/
	  int align;      /*block alignment, in bytes*/
	  int nbits;      /*specific to PCM format*/
	  
	  public void pack(ByteBuffer b){
		  b.put(fmt);
		  b.putInt(fmtsize);
		  b.putChar((char) tag);
		  b.putChar((char) channel);
		  b.putInt(smplrate);
		  b.putInt(bytescnd);
		  b.putChar((char) align);
		  b.putChar((char) nbits);
	  	}	
	  
	  public int size(){
		  return 24;
	  }
	}
	
	WAVEFMT headf = new WAVEFMT();
	int SIZEOF_WAVEFMT = 24;

	static class WAVEDATA /*data*/
	{  byte[] data = new byte[4];    /* "data" */
	   int datasize;
	   
		  public void pack(ByteBuffer b){
			  b.put(data);
			  b.putInt(datasize);
		  	}	
	}
	WAVEDATA headw = new WAVEDATA();
	int SIZEOF_WAVEDATA = 8;

	public void SNDsaveSound(InputStream is, OutputStream os) throws IOException {
	  int type = DoomIO.freadint(is, 2);//  peek_i16_le (buffer);
	  int speed = DoomIO.freadint(is, 2);//peek_u16_le (buffer + 2);
	  int datasize = DoomIO.freadint(is, 4);//peek_i32_le (buffer + 4);
	  if (type!=3)
	    System.out.println("Sound: weird type "+type+". Extracting anyway.");
	  
	  int headsize = 2 + 2 + 4;
	  int size = is.available();
	  
	  int phys_size = size /*- headsize*/;
	  if (datasize > phys_size)
	  {
	    System.out.println("Sound %s: declared sample size %lu greater than lump size %lu ;"/*,
		lump_name (name), (unsigned long) datasize, (unsigned long) phys_size*/);
	    System.out.println("Sound %s: truncating to lump size."/*, lump_name (name)*/);
	    datasize = phys_size;
	  }
	  /* Sometimes the size of sound lump is greater
	     than the declared sound size. */

	  else if (datasize < phys_size)
	  {
	    if (/*fullSND == TRUE*/true)       /* Save entire lump */
	      datasize = phys_size;
	    else
	    {
	      /*Warning (
		"Sound %s: lump size %lu greater than declared sample size %lu ;",
		lump_name (name), (unsigned long) datasize, (unsigned long) phys_size);
	      Warning ("Sound %s: truncating to declared sample size.",
		  lump_name (name));*/
	    }
	  }
	  
	  DoomIO.writeEndian = DoomIO.Endian.BIG;

	  SNDsaveWave(is, os, speed, datasize);
	}
	
	public byte[] DMX2Wave(byte[] DMXSound) throws IOException {
		  ByteBuffer is=ByteBuffer.wrap(DMXSound);
		  is.order(ByteOrder.LITTLE_ENDIAN);
		  int type = 0x0000FFFF&is.getShort();//  peek_i16_le (buffer);
		  int speed = 0x0000FFFF&is.getShort();//peek_u16_le (buffer + 2);
		  int datasize = is.getInt();//peek_i32_le (buffer + 4);
		  if (type!=3)
		    System.out.println("Sound: weird type "+type+". Extracting anyway.");
		  
		  int headsize = 2 + 2 + 4;
		  int size = is.remaining();
		  
		  int phys_size = size /*- headsize*/;
		  if (datasize > phys_size)
		  {
		    System.out.println("Sound %s: declared sample size %lu greater than lump size %lu ;"/*,
			lump_name (name), (unsigned long) datasize, (unsigned long) phys_size*/);
		    System.out.println("Sound %s: truncating to lump size."/*, lump_name (name)*/);
		    datasize = phys_size;
		  }
		  /* Sometimes the size of sound lump is greater
		     than the declared sound size. */

		  else if (datasize < phys_size)
		  {
		    if (/*fullSND == TRUE*/true)       /* Save entire lump */
		      datasize = phys_size;
		    else
		    {
		      /*Warning (
			"Sound %s: lump size %lu greater than declared sample size %lu ;",
			lump_name (name), (unsigned long) datasize, (unsigned long) phys_size);
		      Warning ("Sound %s: truncating to declared sample size.",
			  lump_name (name));*/
		    }
		  }

		  return SNDsaveWave(is, speed, datasize);
		}
	
	protected byte[] SNDsaveWave(ByteBuffer is, int speed, int size) throws IOException
	{
	
		// Size with header and data etc.
		byte[] output=new byte[headr.size()+headf.size() + SIZEOF_WAVEDATA+2*size];
		ByteBuffer os=ByteBuffer.wrap(output);
		os.order(ByteOrder.LITTLE_ENDIAN);
		os.position(0);
	  headr.riff = ("RIFF").getBytes();
	  int siz = 4 + SIZEOF_WAVEFMT + SIZEOF_WAVEDATA+2*size;
	  headr.length = siz;
	  headr.wave = C2JUtils.toByteArray("WAVE");
	  
	  headr.pack(os);

	  headf.fmt = C2JUtils.toByteArray("fmt ");
	  headf.fmtsize = SIZEOF_WAVEFMT - 8;
	  headf.tag = 1;
	  headf.channel = 2; // Maes: HACK to force stereo lines.
	  headf.smplrate = speed;
	  headf.bytescnd = 2*speed; // Ditto.
	  headf.align = 1;
	  headf.nbits = 8;

	  headf.pack(os);

	  headw.data = C2JUtils.toByteArray("data");
	  headw.datasize = 2*size;
	  //byte[] wtf=DoomIO.toByteArray(headw.datasize, 4);
	  
	  
	  headw.pack(os);
	
	  byte tmp;
	  
	  for (int i=0;i<size;i++)
	  {
	  tmp=is.get();
	  os.put(tmp);
	  os.put(tmp);
	  }
	  
	  return os.array();
	}
	

	void SNDsaveWave(InputStream is, OutputStream os, int speed, int size) throws IOException
	{
	  int wsize,sz=0;
	  headr.riff = DoomIO.toByteArray("RIFF");
	  int siz = 4 + SIZEOF_WAVEFMT + SIZEOF_WAVEDATA+size;
	  headr.length = siz;
	  headr.wave = DoomIO.toByteArray("WAVE");
	  
	  DoomIO.fwrite2(headr.riff, os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headr.length, 4), os);
	  DoomIO.fwrite2(headr.wave, os);

	  headf.fmt = DoomIO.toByteArray("fmt ");
	  headf.fmtsize = SIZEOF_WAVEFMT - 8;
	  headf.tag = 1;
	  headf.channel = 1; // Maes: HACK to force stereo lines.
	  headf.smplrate = speed;
	  headf.bytescnd = speed;
	  headf.align = 1;
	  headf.nbits = 8;

	  DoomIO.fwrite2(headf.fmt, os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.fmtsize, 4), os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.tag, 2), os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.channel, 2), os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.smplrate, 4), os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.bytescnd, 4), os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.align, 2), os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headf.nbits, 2), os);

	  headw.data = DoomIO.toByteArray("data");
	  headw.datasize = size;
	  
	  DoomIO.fwrite2(headw.data, os);
	  DoomIO.fwrite2(DoomIO.toByteArray(headw.datasize, 4), os);
	  
	  ByteArrayOutputStream shit=( ByteArrayOutputStream)os;
	 
	  byte[] crap=shit.toByteArray();
	  
	  byte[] bytes = new byte[MEMORYCACHE];
	  for(wsize=0;wsize<size;wsize+=sz)
	  { sz= (size-wsize>MEMORYCACHE)? MEMORYCACHE:(size-wsize);
	  is.read(bytes, 0, sz);
	  os.write(bytes, 0, sz);
	    //if(fwrite((buffer+(wsize)),(size_t)sz,1,fp)!=1)
	    //  ProgError("%s: write error (%s)", fname (file), strerror (errno));
	  }
	}

}

package s;

public class DSP {

    /**
     * QDSS Windowed Sinc ReSampling subroutine in Basic
     * 
     * @param x
     *        new sample point location (relative to old indexes) (e.g. every
     *        other integer for 0.5x decimation)
     * @param indat
     *        = original data array
     * @param alim
     *        = size of data array
     * @param fmax
     *        = low pass filter cutoff frequency
     * @param fsr
     *        = sample rate
     * @param wnwdth
     *        = width of windowed Sinc used as the low pass filter rem resamp()
     *        returns a filtered new sample point
     */

    public float resamp(float x, float[] indat, int alim, float fmax,
            float fsr, int wnwdth) {
        int i, j;
        float r_w, r_g, r_a;
        int r_snc, r_y; // some local variables
        r_g = 2 * fmax / fsr; // Calc gain correction factor
        r_y = 0;
        for (i = -wnwdth / 2; i < wnwdth / 2; i++) { // For 1 window width
            j = (int) (x + i); // Calc input sample index
            // calculate von Hann Window. Scale and calculate Sinc
            r_w =
                (float) (0.5 - 0.5 * Math.cos(2 * Math.PI
                        * (0.5 + (j - x) / wnwdth)));
            r_a = (float) (2 * Math.PI * (j - x) * fmax / fsr);
            r_snc = 1;
            if (Math.abs(r_a) > 0)
                r_snc = (int) (Math.sin(r_a) / r_a);
            if ((j >= 0) && (j < alim)) {
                r_y = (int) (r_y + r_g * r_w * r_snc * indat[j]);
            }
        }
        return r_y; // return new filtered sample
    }

    /*
     * Ron Nicholson's QDSS ReSampler cookbook recipe QDSS = Quick, Dirty,
     * Simple and Short Version 0.1b - 2007-Aug-01 Copyright 2007 Ronald H.
     * Nicholson Jr. No warranties implied. Error checking, optimization, and
     * quality assessment of the "results" is left as an exercise for the
     * student. (consider this code Open Source under a BSD style license) IMHO.
     * YMMV. http://www.nicholson.com/rhn/dsp.html
     */

    /**
     * R. Nicholson's QDDS FIR filter generator cookbook recipe QDDS = Quick,
     * Dirty, Dumb and Short version 0.6b - 2006-Dec-14, 2007-Sep-30 No
     * warranties implied. Error checking, optimization, and quality assessment
     * of the "results" is left as an exercise for the student. (consider this
     * code Open Source under a BSD style license) Some example filter
     * parameters:
     * 
     * @param fsr
     *        = 44100 : rem set fsr = sample rate
     * @param fc
     *        = 0 : rem set fc = 0 for lowpass fc = center frequency for
     *        bandpass filter fc = fsr/2 for a highpass
     * @param bw
     *        = 3000 : rem bw = bandwidth, range 0 .. fsr/2 and bw >= fsr/n bw =
     *        3 db corner frequency for a lowpass bw = half the 3 db passband
     *        for a bandpass filter
     * @param nt
     *        = 128 : rem nt = number of taps + 1 (nt must be even) nt should be
     *        > fsr / bw transition band will be around 3.5 * fsr / nt depending
     *        on the window applied and ripple spec.
     * @param g
     *        = 1 : rem g = filter gain for bandpass g = 0.5 , half the gain for
     *        a lowpass filter
     * @return array of FIR taps
     */

    public static double[] wsfiltgen(int nt, double fc, double fsr, double bw, double g) {
        double[] fir = new double[nt];//
        // fir(0) = 0
        // fir(1) is the first tap
        // fir(nt/2) is the middle tap
        // fir(nt-1) is the last tap

        double a, ys, yg, yf, yw;
        for (int i = 1; i < nt; i++) {
            a = (i - nt / 2) * 2.0 * Math.PI * bw / fsr; // scale Sinc width
            ys = 1;
            if (Math.abs(a) > 0)
                ys = Math.sin(a) / a; // calculate Sinc function
            yg = g * (4.0 * bw / fsr); // correct window gain
            yw = 0.54 - 0.46 * Math.cos(i * 2.0 * Math.PI / nt); // Hamming
                                                                 // window
            yf = Math.cos((i - nt / 2) * 2.0 * Math.PI * fc / fsr); // spectral
                                                                    // shift to
                                                                    // fc
            fir[i] = yf * yw * yg * ys; // rem assign fir coeff.
        }
        return fir;
    }
    
    public static void main(String[] argv){
        double[] fir=wsfiltgen(128,11025/2.0,22050,22050*3.0/4,0.5);
        System.out.println(fir);
        
    }
    
    public static byte[] crudeResample(byte[] input,int factor){        
        
        if (input==null || input.length<1) return null;
        
        final int LEN=input.length;
        
        byte[] res=new byte[LEN*factor];
        int k=0;        
        float start,end;
        
        res[0]=input[0];
        
        for (int i=0;i<LEN;i++){
            
            if (i==0) 
                start=127;
            else
                start=0xFF&input[i];
            
            if (i<LEN-1)
                end=0xFF&input[i+1];
            else
                end=127;
            
            double slope=(end-start)/factor;
            
            res[k]=input[i];
            //res[k+factor]=input[i+1];
            
            for (int j=1;j<factor;j++){
                double ratio=j/(double)factor;
                double value=start+slope*ratio;
                byte bval=(byte)Math.round(value);
                res[k+j]=bval;
                }
            k+=factor;
        }
        
        return res;
        
    }
    
    public static void filter(byte[] input,int samplerate, int cutoff){        
       
        double[] tmp=new double[input.length];
        
        // Normalize
        for (int i=0;i<input.length;i++){
            tmp[i]=(0xFF&input[i])/255.0;
        }
        
        filter(tmp,samplerate,cutoff,tmp.length);
        
        // De-normalize
        for (int i=0;i<input.length;i++){
            input[i]=(byte) (0xFF&(int)(tmp[i]*255.0));
        }
        
    }
    

    /** Taken from here
     * http://baumdevblog.blogspot.gr/2010/11/butterworth-lowpass-filter-coefficients.html
     */
    
    private static void getLPCoefficientsButterworth2Pole(final int samplerate, final double cutoff, final double[] ax, final double[] by)
    {
        double PI      = 3.1415926535897932385;
        double sqrt2 = 1.4142135623730950488;

        double QcRaw  = (2 * PI * cutoff) / samplerate; // Find cutoff frequency in [0..PI]
        double QcWarp = Math.tan(QcRaw); // Warp cutoff frequency

        double gain = 1 / (1+sqrt2/QcWarp + 2/(QcWarp*QcWarp));
        by[2] = (1 - sqrt2/QcWarp + 2/(QcWarp*QcWarp)) * gain;
        by[1] = (2 - 2 * 2/(QcWarp*QcWarp)) * gain;
        by[0] = 1;
        ax[0] = 1 * gain;
        ax[1] = 2 * gain;
        ax[2] = 1 * gain;
    }



    public static void filter(double[] samples, int smp, double cutoff,int count)
    {
      // Essentially a 3-tap filter?
       double[] ax=new double[3];
       double[] by=new double[3];
       double[] xv=new double[3];
       double[] yv=new double[3];

       getLPCoefficientsButterworth2Pole(smp, cutoff, ax, by);

       for (int i=0;i<count;i++)
       {
           xv[2] = xv[1];
           xv[1] = xv[0];
           xv[0] = samples[i];
           
           yv[2] = yv[1]; 
           yv[1] = yv[0];
           yv[0] =   (ax[0] * xv[0] + ax[1] * xv[1] + ax[2] * xv[2]
                        - by[1] * yv[0]
                        - by[2] * yv[1]);

           samples[i] = yv[0];
       }
    }
    
}

package s;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;

/** An object representation of Doom's sound format */

public class DMXSound implements CacheableDoomObject{

    /** ushort, all Doom samples are "type 3". No idea how  */    
    public int type;
    /** ushort, speed in Hz. */
    public int speed;    
    /** uint */
    public int datasize;

    public byte[] data;
    
    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
       buf.order(ByteOrder.LITTLE_ENDIAN);
       type=buf.getChar();
       speed=buf.getChar();
       datasize=buf.getInt();
       data=new byte[Math.min(buf.remaining(),datasize)];
       buf.get(data);
    }

}

package s;

import static data.sounds.S_sfx;

import java.util.Collection;
import java.util.HashMap;

import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.FloatControl;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.FloatControl.Type;

import w.DoomBuffer;
import data.sounds.sfxenum_t;
import doom.DoomStatus;

/** Experimental Clip based driver. It does work, but it has no
 *  tangible advantages over the Audioline or Classic one. If the
 *  Audioline can be used, there's no reason to fall back to this 
 *  one.
 * 
 * KNOWN ISSUES:
 * 
 * a) Same general restrictions as audiolines (in fact, Clips ARE Audioline 
 *    in disguise)
 * b) Multiple instances of the same sound require multiple clips, so
 *    even caching them is a half-baked solution, and if you have e.g. 40 imps
 *    sound in a room.... 
 *    
 *    
 *  Currently unused.
 * 
 * @author Velktron
 *
 */

public class ClipSFXModule extends AbstractSoundDriver{
	
	HashMap<Integer,Clip> cachedSounds = new HashMap<Integer,Clip>();

	
	// Either it's null (no clip is playing) or non-null (some clip is playing).
	Clip[] channels;

	
	public final float[] linear2db;
	
	public ClipSFXModule(DoomStatus DS, int numChannels) {
		super(DS,numChannels);
		linear2db=computeLinear2DB();		
		}
	
    private float[] computeLinear2DB() {
    	
    	// Maximum volume is 0 db, minimum is ... -96 db.
    	// We rig this so that half-scale actually gives quarter power,
    	// and so is -6 dB.
    	float[] tmp=new float[VOLUME_STEPS];
    	
    	for (int i=0;i<VOLUME_STEPS;i++){
    		float linear=(float)(20*Math.log10((float)i/(float)VOLUME_STEPS));
    		// Hack. The minimum allowed value as of now is -80 db.
    		if (linear<-36.0) linear=-36.0f;
    		tmp[i]= linear;
    		
    	}
    		
    		
    		
		return tmp;
	}



	@Override
	public boolean InitSound() {
        // Secure and configure sound device first.
        System.err.println("I_InitSound: ");

        // We don't actually do this here (will happen only when we
        // create the first audio clip).

        // Initialize external data (all sounds) at start, keep static.

        initSound16();

        System.err.print(" pre-cached all sound data\n");
        // Finished initialization.
        System.err.print("I_InitSound: sound module ready\n");
        return true;

    }


/** Modified getsfx. The individual length of each sfx is not of interest.
 * However, they must be transformed into 16-bit, signed, stereo samples
 * beforehand, before being "fed" to the audio clips.
 * 
 * @param sfxname
 * @param index
 * @return
 */
	 protected byte[] getsfx(String sfxname,int index) {
	        byte[] sfx;
	        byte[] paddedsfx;
	        int i;
	        int size;
	        int paddedsize;
	        String name;
	        int sfxlump;

	        // Get the sound data from the WAD, allocate lump
	        // in zone memory.
	        name = String.format("ds%s", sfxname).toUpperCase();

	        // Now, there is a severe problem with the
	        // sound handling, in it is not (yet/anymore)
	        // gamemode aware. That means, sounds from
	        // DOOM II will be requested even with DOOM
	        // shareware.
	        // The sound list is wired into sounds.c,
	        // which sets the external variable.
	        // I do not do runtime patches to that
	        // variable. Instead, we will use a
	        // default sound for replacement.
	        if (DS.W.CheckNumForName(name) == -1)
	            sfxlump = DS.W.GetNumForName("dspistol");
	        else
	            sfxlump = DS.W.GetNumForName(name);

	        size = DS.W.LumpLength(sfxlump);

	        sfx = DS.W.CacheLumpNumAsRawBytes(sfxlump, 0);

	        // Size blown up to accommodate two channels and 16 bits.
	        // Sampling rate stays the same.
	        
	        paddedsize = (size-8)*2*2;
	        // Allocate from zone memory.
	        paddedsfx = new byte[paddedsize];

	        // Skip first 8 bytes (header), blow up the data
	        // to stereo, BIG ENDIAN, SIGNED, 16 bit. Don't expect any fancy DSP here!

	        int sample=0;
	        for (i = 8; i < size; i++){
	        	// final short sam=(short) vol_lookup[127][0xFF&sfx[i]];
	        	final short sam=(short) ((0xFF&sfx[i]-128)<<8);
	            paddedsfx[sample++] = (byte) (0xFF&(sam>>8));
	            paddedsfx[sample++]=(byte) (0xFF&sam);
	            paddedsfx[sample++]=(byte) (0xFF&(sam>>8));
	            paddedsfx[sample++]=(byte) (0xFF&sam);
	        }
	        
	        // Remove the cached lump.
	        DS.W.UnlockLumpNum(sfxlump);

	        // Return allocated padded data.
	        // So the first 8 bytes are useless?
	        return paddedsfx;
	    }

	@Override
	public void UpdateSound() {
		// We do nothing here, since the mixing is delegated to the OS
		// Just hope that it's more efficient that our own...
		
	}

	@Override
	public void SubmitSound() {
		// Dummy. Nothing actual to do here.
		
	}

	@Override
	public void ShutdownSound() {
		 // Wait till all pending sounds are finished.
		  boolean done = false;
		  int i;
		  

		  // FIXME (below).
		  //fprintf( stderr, "I_ShutdownSound: NOT finishing pending sounds\n");
		  //fflush( stderr );
		  
		  while ( !done)
		  {
		    for( i=0 ; i<numChannels && ((channels[i]==null)||(!channels[i].isActive())) ; i++);
		    // FIXME. No proper channel output.
		    if (i==numChannels)  done=true;
		  }
		  
		  for( i=0 ; i<numChannels; i++){
			  if (channels[i]!=null)
			channels[i].close();			
		  	}
		  
		  // Free up resources taken up by cached clips.
		  Collection<Clip> clips=this.cachedSounds.values();
		  for (Clip c:clips){
			  c.close();
		  }
		  
		  // Done.
		  return;
		
	}

	@Override
	public void SetChannels(int numChannels) {
		channels= new Clip[numChannels];
	}
	
	private final void  getClipForChannel(int c, int sfxid){
		
		// Try to see if we already have such a clip.
		Clip clip=this.cachedSounds.get(sfxid);
		
		boolean exists=false;
		
		// Does it exist?
		if (clip!=null){
			
			// Well, it does, but we are not done yet.
			exists=true;
			// Is it NOT playing already?
			if (!clip.isActive()){
				// Assign it to the channel.
				channels[c]=clip;
				return;
			}
		}
		
		// Sorry, Charlie. Gotta make a new one.
		DataLine.Info info = new DataLine.Info(Clip.class, DoomSound.DEFAULT_SAMPLES_FORMAT);
		
		try {
			clip = (Clip) AudioSystem.getLine(info);
		} catch (LineUnavailableException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	    try {
			clip.open( DoomSound.DEFAULT_SAMPLES_FORMAT, S_sfx[sfxid].data, 0, S_sfx[sfxid].data.length);
		} catch (LineUnavailableException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		if (!exists)
		this.cachedSounds.put(sfxid,clip);
		
	    channels[c]=clip;
	    
		
	   // Control[] cs=clip.getControls();
	   // 
	   // for (Control cc:cs){
	   // 	System.out.println("Control "+cc.getType().toString());
       // 		}
	}
	
	//
	// This function adds a sound to the
	//  list of currently active sounds,
	//  which is maintained as a given number
	//  (eight, usually) of internal channels.
	// Returns a handle.
	//
	protected short	handlenums = 0;

	protected int addsfx 	( int sfxid,int		volume,int pitch,int		seperation)
	{
		int		i;
		int		rc = -1;

		int		oldest = DS.gametic;
		int		oldestnum = 0;
		int		slot;

		// Chainsaw troubles.
		// Play these sound effects only one at a time.
		if ( sfxid == sfxenum_t.sfx_sawup.ordinal()
				|| sfxid == sfxenum_t.sfx_sawidl.ordinal()
				|| sfxid == sfxenum_t.sfx_sawful.ordinal()
				|| sfxid == sfxenum_t.sfx_sawhit.ordinal()
				|| sfxid == sfxenum_t.sfx_stnmov.ordinal()
				|| sfxid == sfxenum_t.sfx_pistol.ordinal()	 )
		{
			// Loop all channels, check.
			for (i=0 ; i<numChannels ; i++)
			{
				// Active, and using the same SFX?
				if (channels[i]!=null && channels[i].isRunning()
						&& channelids[i] == sfxid)
				{
					// Reset.
					channels[i].stop();
					// We are sure that iff,
					//  there will only be one.
					break;
				}
			}
		}

		// Loop all channels to find oldest SFX.
		for (i=0; (i<numChannels) && (channels[i]!=null); i++)
		{
			if (channelstart[i] < oldest)
			{
				oldestnum = i;
				oldest = channelstart[i];
			}
		}

		// Tales from the cryptic.
		// If we found a channel, fine.
		// If not, we simply overwrite the first one, 0.
		// Probably only happens at startup.
		if (i == numChannels)
			slot = oldestnum;
		else
			slot = i;

		// Okay, in the less recent channel,
		//  we will handle the new SFX.
		
		// We need to decide whether we can reuse an existing clip
		// or create a new one. In any case, when this method return 
		// we should have a valid clip assigned to channel "slot".

        getClipForChannel(slot,sfxid);

        
		// Reset current handle number, limited to 0..100.
		if (handlenums==0) // was !handlenums, so it's actually 1...100?
			handlenums = MAXHANDLES;

		// Assign current handle number.
		// Preserved so sounds could be stopped (unused).
		channelhandles[slot]= rc = handlenums--;

		// Should be gametic, I presume.
		channelstart[slot] = DS.gametic;

		// Get the proper lookup table piece
		//  for this volume level???
		//channelleftvol_lookup[slot] = vol_lookup[leftvol];
		//channelrightvol_lookup[slot] = vol_lookup[rightvol];

		// Preserve sound SFX id,
		//  e.g. for avoiding duplicates of chainsaw.
		channelids[slot] = sfxid;

		setVolume(slot,volume);
		setPanning(slot,seperation);
		//channels[slot].addSound(sound, handlenums);
		//channels[slot].setPitch(pitch);
		
		if(D) System.err.println(channelStatus());
        if(D) System.err.printf("Playing %d vol %d on channel %d\n",rc,volume,slot);
		// Well...play it.
      
        // FIXME VERY BIG PROBLEM: stop() is blocking!!!! WTF ?!
        //channels[slot].stop();
        //long  a=System.nanoTime();
        channels[slot].setFramePosition(0);
		channels[slot].start();
		// b=System.nanoTime();
		//System.err.printf("Sound playback completed in %d\n",(b-a));
        
        // You tell me.
		return rc;
	}
	
	
	/** Accepts volume in "Doom" format (0-127).
	 * 
	 * @param volume
	 */
	public void setVolume(int chan,int volume){
		Clip c=channels[chan];
		
		if (c.isControlSupported(Type.MASTER_GAIN)){
			FloatControl vc=(FloatControl) c.getControl(Type.MASTER_GAIN);
				float vol = linear2db[volume];
				vc.setValue(vol);
				}
			else if (c.isControlSupported(Type.VOLUME)){
				FloatControl vc=(FloatControl) c.getControl(Type.VOLUME);
				float vol = vc.getMinimum()+(vc.getMaximum()-vc.getMinimum())*(float)volume/127f;
				vc.setValue(vol);
			}
		}
	
	public void setPanning(int chan,int sep){
		Clip c=channels[chan];
		
		if (c.isControlSupported(Type.PAN)){
			FloatControl bc=(FloatControl) c.getControl(Type.PAN);
			// Q: how does Doom's sep map to stereo panning?
			// A: Apparently it's 0-255 L-R.
			float pan= bc.getMinimum()+(bc.getMaximum()-bc.getMinimum())*(float)sep/ISoundDriver.PANNING_STEPS;
			bc.setValue(pan);
			}
		}
	
	@Override
	public void StopSound(int handle) {
		// Which channel has it?
		int  hnd=getChannelFromHandle(handle);
		if (hnd>=0) {
			channels[hnd].stop();
			channels[hnd]=null;
		}
	}

	@Override
	public boolean SoundIsPlaying(int handle) {
		
		return getChannelFromHandle(handle)!=BUSY_HANDLE;
		}

	
	@Override
	public void UpdateSoundParams(int handle, int vol, int sep, int pitch) {
		
		// This should be called on sounds that are ALREADY playing. We really need
		// to retrieve channels from their handles.
		
		//System.err.printf("Updating sound with handle %d vol %d sep %d pitch %d\n",handle,vol,sep,pitch);
		
		int i=getChannelFromHandle(handle);
		// None has it?
		if (i!=BUSY_HANDLE){
			//System.err.printf("Updating sound with handle %d in channel %d\n",handle,i);
			setVolume(i,vol);
			setPanning(i,sep);
			//channels[i].setPanning(sep);
			}
		
	}
	
	
	/** Internal use. 
	 * 
	 * @param handle
	 * @return the channel that has the handle, or -2 if none has it.
	 */
	private int getChannelFromHandle(int handle){
		// Which channel has it?
		for (int i=0;i<numChannels;i++){
			if (channelhandles[i]==handle) return i;
		}
		
		return BUSY_HANDLE;
	}

		StringBuilder sb=new StringBuilder();
	
		public String channelStatus(){
			sb.setLength(0);
			for (int i=0;i<numChannels;i++){
				if (channels[i]!=null && channels[i].isActive())
				sb.append(i);
				else sb.append('-');
			}
			
			return sb.toString();
			
			
		}
	
}


package s;

import static data.Tables.ANGLETOFINESHIFT;
import static data.Tables.BITS32;
import static data.Tables.finesine;
import static data.sounds.S_sfx;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedMul;
import p.mobj_t;
import data.Defines;
import data.musicinfo_t;
import data.sfxinfo_t;
import data.sounds;
import data.sounds.musicenum_t;
import data.sounds.sfxenum_t;
import doom.DoomStatus;

/** Some stuff that is not implementation dependant
 *  This includes channel management, sound priorities,
 *  positioning, distance attenuation etc. It's up to 
 *  lower-level "drivers" to actually implements those.
 *  This particular class needs not be a dummy itself, but
 *  the drivers it "talks" to might be. 
 *  
 * 
 * */


public class AbstractDoomAudio implements IDoomSound{

	protected final DoomStatus<?,?> DS;
	protected final IMusic IMUS;
	protected final ISoundDriver ISND;

	protected final int numChannels;

	protected final static boolean D=false;

	/** the set of channels available. These are "soft" descriptor
	   channels,  not to be confused with actual hardware audio 
	   lines, which are an entirely different concern.

	 */

	protected final channel_t[]	channels;


	// These are not used, but should be (menu).
	// Maximum volume of a sound effect.
	// Internal default is max out of 0-15.
	protected int 		snd_SfxVolume = 15;

	// Maximum volume of music. Useless so far.
	protected int 		snd_MusicVolume = 15; 

	// whether songs are mus_paused
	protected boolean mus_paused;

	// music currently being played
	protected musicinfo_t mus_playing;

	protected int nextcleanup;

	public AbstractDoomAudio(DoomStatus<?,?> DS, int numChannels){
		this.DS = DS;
		this.numChannels=numChannels;
		this.channels=new channel_t[numChannels];
		this.IMUS=DS.IMUS;
		this.ISND=DS.ISND;
	}



	/** Volume, pitch, separation  & priority packed for parameter passing */

	protected class vps_t{
		int volume;
		int pitch;
		int sep;
		int priority;
	}


	/**
	 * Initializes sound stuff, including volume
	 * Sets channels, SFX and music volume,
	 *  allocates channel buffer, sets S_sfx lookup.
	 */

	public void Init
	( int		sfxVolume,
			int		musicVolume )
	{  
		int		i;

		System.err.printf("S_Init: default sfx volume %d\n", sfxVolume);

		this.snd_SfxVolume=sfxVolume;
		this.snd_MusicVolume=musicVolume;
		// Whatever these did with DMX, these are rather dummies now.
		// MAES: any implementation-dependant channel setup should start here.
		ISND.SetChannels(numChannels);

		SetSfxVolume(sfxVolume);
		// No music with Linux - another dummy.
		// MAES: these must be initialized somewhere, perhaps not here?
		IMUS.SetMusicVolume(musicVolume);

		// Allocating the internal channels for mixing
		// (the maximum numer of sounds rendered
		// simultaneously) within zone memory.
		// MAES: already done that in the constructor.

		// Free all channels for use
		for (i=0 ; i<numChannels ; i++){
			channels[i]=new channel_t();
			//channels[i].sfxinfo = null;
		}

		// no sounds are playing, and they are not mus_paused
		mus_paused = false;

		// Note that sounds have not been cached (yet).
		for (i=1 ; i<S_sfx.length ; i++)
			S_sfx[i].lumpnum = S_sfx[i].usefulness = -1;
	}

	//
	// Per level startup code.
	// Kills playing sounds at start of level,
	//  determines music if any, changes music.
	//
	public void Start()
	{
		int cnum;
		int mnum;

		// kill all playing sounds at start of level
		//  (trust me - a good idea)
		for (cnum=0 ; cnum<numChannels ; cnum++)
			if (channels[cnum].sfxinfo!=null)
				StopChannel(cnum);

		// start new music for the level
		mus_paused = false;

		if (DS.isCommercial())
			mnum = musicenum_t.mus_runnin.ordinal() + DS.gamemap - 1;
		else
		{
			musicenum_t[] spmus=
			{
					// Song - Who? - Where?

					musicenum_t.mus_e3m4,	// American	e4m1
					musicenum_t.mus_e3m2,	// Romero	e4m2
					musicenum_t.mus_e3m3,	// Shawn	e4m3
					musicenum_t.mus_e1m5,	// American	e4m4
					musicenum_t.mus_e2m7,	// Tim 	e4m5
					musicenum_t.mus_e2m4,	// Romero	e4m6
					musicenum_t.mus_e2m6,	// J.Anderson	e4m7 CHIRON.WAD
					musicenum_t.mus_e2m5,	// Shawn	e4m8
					musicenum_t.mus_e1m9	// Tim		e4m9
			};

			if (DS.gameepisode < 4)
				mnum = musicenum_t.mus_e1m1.ordinal() + (DS.gameepisode-1)*9 + DS.gamemap-1;
			else
				mnum = spmus[DS.gamemap-1].ordinal();
		}	

		// HACK FOR COMMERCIAL
		//  if (commercial && mnum > mus_e3m9)	
		//      mnum -= mus_e3m9;

		ChangeMusic(mnum, true);

		nextcleanup = 15;
	}

	private vps_t vps=new vps_t();

	public void
	StartSoundAtVolume
	( ISoundOrigin		origin_p,
			int		sfx_id,
			int		volume )
	{

		boolean		rc;
		int		sep = 0; // This is set later.
		int		pitch;
		int		priority;
		sfxinfo_t	sfx;
		int		cnum;

		ISoundOrigin	origin = (ISoundOrigin) origin_p;


		// Debug.
		
		//if (origin!=null && origin.type!=null)
		// System.err.printf(
	  	//   "S_StartSoundAtVolume: playing sound %d (%s) from %s %d\n",
	  	 //  sfx_id, S_sfx[sfx_id].name , origin.type.toString(),origin.hashCode());
		 

		// check for bogus sound #
		if (sfx_id < 1 || sfx_id > NUMSFX){
			Exception e=new Exception();
			e.printStackTrace();
			DS.I.Error("Bad sfx #: %d", sfx_id);
		}

		sfx = S_sfx[sfx_id];

		// Initialize sound parameters
		if (sfx.link!=null)
		{
			pitch = sfx.pitch;
			priority = sfx.priority;
			volume += sfx.volume;

			if (volume < 1)
				return;

			if (volume > snd_SfxVolume)
				volume = snd_SfxVolume;
		}	
		else
		{
			pitch = NORM_PITCH;
			priority = NORM_PRIORITY;
		}


		// Check to see if it is audible,
		//  and if not, modify the params
		if ((origin!=null) && origin != DS.players[DS.consoleplayer].mo)
		{
			vps.volume=volume;
			vps.pitch=pitch;
			vps.sep=sep;
			rc = AdjustSoundParams(DS.players[DS.consoleplayer].mo,
					origin, vps);
			volume=vps.volume;
			pitch=vps.pitch;
			sep=vps.sep;


			if ( origin.getX() == DS.players[DS.consoleplayer].mo.x
					&& origin.getY() == DS.players[DS.consoleplayer].mo.y)
			{	
				sep 	= NORM_SEP;
			}

			if (!rc) {
				//System.err.printf("S_StartSoundAtVolume: Sound %d (%s) rejected because: inaudible\n",
			  	//   sfx_id, S_sfx[sfx_id].name );
				return;
			}
		}	
		else
		{
			sep = NORM_SEP;
		}

		// hacks to vary the sfx pitches
		if (sfx_id >= sfxenum_t.sfx_sawup.ordinal()
				&& sfx_id <= sfxenum_t.sfx_sawhit.ordinal())
		{	
			pitch += 8 - (DS.RND.M_Random()&15);

			if (pitch<0)
				pitch = 0;
			else if (pitch>255)
				pitch = 255;
		}
		else if (sfx_id != sfxenum_t.sfx_itemup.ordinal()
				&& sfx_id != sfxenum_t.sfx_tink.ordinal())
		{
			pitch += 16 - (DS.RND.M_Random()&31);

			if (pitch<0)
				pitch = 0;
			else if (pitch>255)
				pitch = 255;
		}

		// kill old sound
		StopSound(origin);

		// try to find a channel
		cnum = getChannel(origin, sfx);

		if (cnum<0)
			return;

		//
		// This is supposed to handle the loading/caching.
		// For some odd reason, the caching is done nearly
		//  each time the sound is needed?
		//

		// get lumpnum if necessary
		if (sfx.lumpnum < 0) // Now, it crosses into specific territory.
			sfx.lumpnum = ISND.GetSfxLumpNum(sfx);

		/*
	#ifndef SNDSRV
	  // cache data if necessary
	  if (!sfx->data)
	  {
	    fprintf( stderr,
		     "S_StartSoundAtVolume: 16bit and not pre-cached - wtf?\n");

	    // DOS remains, 8bit handling
	    //sfx->data = (void *) W_CacheLumpNum(sfx->lumpnum, PU_MUSIC);
	    // fprintf( stderr,
	    //	     "S_StartSoundAtVolume: loading %d (lump %d) : 0x%x\n",
	    //       sfx_id, sfx->lumpnum, (int)sfx->data );

	  }
	#endif */

		// increase the usefulness
		if (sfx.usefulness++ < 0)
			sfx.usefulness = 1;

		// Assigns the handle to one of the channels in the
		//  mix/output buffer. This is when things actually
		// become hard (pun intended).
		// TODO: which channel? How do we know how the actual hardware 
		// ones map with the "soft" ones?
		// Essentially we're begging to get an actual channel.		
		
		channels[cnum].handle = ISND.StartSound(sfx_id,
				/*sfx->data,*/
				volume,
				sep,
				pitch,
				priority);
		
		if (D) System.err.printf("Handle %d for channel %d for sound %s vol %d sep %d\n",channels[cnum].handle,
				cnum,sfx.name,volume,sep);
	}	


	public void
	StartSound
	( ISoundOrigin		origin,
			sfxenum_t		sfx_id ){
		//  MAES: necessary sanity check at this point.
		if (sfx_id!=null && sfx_id.ordinal()>0)
			StartSound(origin,sfx_id.ordinal());
	}

	public void
	StartSound
	( ISoundOrigin		origin,
			int		sfx_id )
	{
		/* #ifdef SAWDEBUG
	    // if (sfx_id == sfx_sawful)
	    // sfx_id = sfx_itemup;
	#endif */

		StartSoundAtVolume(origin, sfx_id, snd_SfxVolume);


		// UNUSED. We had problems, had we not?
		/* #ifdef SAWDEBUG
	{
	    int i;
	    int n;

	    static mobj_t*      last_saw_origins[10] = {1,1,1,1,1,1,1,1,1,1};
	    static int		first_saw=0;
	    static int		next_saw=0;

	    if (sfx_id == sfx_sawidl
		|| sfx_id == sfx_sawful
		|| sfx_id == sfx_sawhit)
	    {
		for (i=first_saw;i!=next_saw;i=(i+1)%10)
		    if (last_saw_origins[i] != origin)
			fprintf(stderr, "old origin 0x%lx != "
				"origin 0x%lx for sfx %d\n",
				last_saw_origins[i],
				origin,
				sfx_id);

		last_saw_origins[next_saw] = origin;
		next_saw = (next_saw + 1) % 10;
		if (next_saw == first_saw)
		    first_saw = (first_saw + 1) % 10;

		for (n=i=0; i<numChannels ; i++)
		{
		    if (channels[i].sfxinfo == &S_sfx[sfx_sawidl]
			|| channels[i].sfxinfo == &S_sfx[sfx_sawful]
			|| channels[i].sfxinfo == &S_sfx[sfx_sawhit]) n++;
		}

		if (n>1)
		{
		    for (i=0; i<numChannels ; i++)
		    {
			if (channels[i].sfxinfo == &S_sfx[sfx_sawidl]
			    || channels[i].sfxinfo == &S_sfx[sfx_sawful]
			    || channels[i].sfxinfo == &S_sfx[sfx_sawhit])
			{
			    fprintf(stderr,
				    "chn: sfxinfo=0x%lx, origin=0x%lx, "
				    "handle=%d\n",
				    channels[i].sfxinfo,
				    channels[i].origin,
				    channels[i].handle);
			}
		    }
		    fprintf(stderr, "\n");
		}
	    }
	}
	#endif*/

	}

	// This one is public.
	public void StopSound(ISoundOrigin origin)
	{

		int cnum;

		for (cnum=0 ; cnum<numChannels ; cnum++)
		{
			if (channels[cnum].sfxinfo!=null && channels[cnum].origin == origin)
			{
				// This one is not.
				StopChannel(cnum);
				break;
			}
		}
	}

	//
	// Stop and resume music, during game PAUSE.
	//
	public void PauseSound()
	{
		if (mus_playing!=null && !mus_paused)
		{
			IMUS.PauseSong(mus_playing.handle);
			mus_paused = true;
		}
	}

	public void ResumeSound()
	{
		if (mus_playing!=null && mus_paused)
		{
			IMUS.ResumeSong(mus_playing.handle);
			mus_paused = false;
		}
	}

	@Override
	public void UpdateSounds(mobj_t listener) {
		boolean		audible;
		int		cnum;
		//int		volume;
		//int		sep;
		//int		pitch;
		sfxinfo_t	sfx;
		channel_t	c;

		// Clean up unused data.
		// This is currently not done for 16bit (sounds cached static).
		// DOS 8bit remains. 
		/*if (gametic.nextcleanup)
		    {
			for (i=1 ; i<NUMSFX ; i++)
			{
			    if (S_sfx[i].usefulness < 1
				&& S_sfx[i].usefulness > -1)
			    {
				if (--S_sfx[i].usefulness == -1)
				{
				    Z_ChangeTag(S_sfx[i].data, PU_CACHE);
				    S_sfx[i].data = 0;
				}
			    }
			}
			nextcleanup = gametic + 15;
		    }*/

		for (cnum=0 ; cnum<numChannels ; cnum++)
		{		    
			c = channels[cnum];
			sfx = c.sfxinfo;

			//System.out.printf("Updating channel %d %s\n",cnum,c);
			if (c.sfxinfo!=null)
			{
				if (ISND.SoundIsPlaying(c.handle))
				{
					// initialize parameters
					vps.volume = snd_SfxVolume;
					vps.pitch = NORM_PITCH;
					vps.sep = NORM_SEP;

					sfx=c.sfxinfo;

					if (sfx.link!=null)
					{
						vps.pitch = sfx.pitch;
						vps.volume += sfx.volume;
						if (vps.volume < 1)
						{
							StopChannel(cnum);
							continue;
						}
						else if (vps.volume > snd_SfxVolume)
						{
							vps.volume = snd_SfxVolume;
						}
					}

					// check non-local sounds for distance clipping
					//  or modify their params
					if (c.origin!=null && (listener != c.origin))
					{
						audible = AdjustSoundParams(listener,
								c.origin,
								vps);

						if (!audible)
						{
							StopChannel(cnum);
						}
						else
							ISND.UpdateSoundParams(c.handle, vps.volume, vps.sep, vps.pitch);
					}
				}
				else
				{
					// if channel is allocated but sound has stopped,
					//  free it
					StopChannel(cnum);
				}
			}
		}
		// kill music if it is a single-play && finished
		// if (	mus_playing
		//      && !I_QrySongPlaying(mus_playing->handle)
		//      && !mus_paused )
		// S_StopMusic();
	}

	public void SetMusicVolume(int volume)
	{
		if (volume < 0 || volume > 127)
		{
			DS.I.Error("Attempt to set music volume at %d",
					volume);
		}    

		IMUS.SetMusicVolume(volume);
		snd_MusicVolume = volume;
	}

	public void SetSfxVolume(int volume)
	{

		if (volume < 0 || volume > 127)
			DS.I.Error("Attempt to set sfx volume at %d", volume);

		snd_SfxVolume = volume;

	}

	//
	// Starts some music with the music id found in sounds.h.
	//
	public void StartMusic(int m_id)
	{
		ChangeMusic(m_id, false);
	}

	//
	// Starts some music with the music id found in sounds.h.
	//
	public void StartMusic(musicenum_t m_id)
	{
		ChangeMusic(m_id.ordinal(), false);
	}
	
	public void ChangeMusic(musicenum_t musicnum,
			boolean			looping )
	{
		ChangeMusic(musicnum.ordinal(), false);
	}


	public void
	ChangeMusic
	( int			musicnum,
			boolean			looping )
	{
		musicinfo_t	music = null;
		String		namebuf;

		if ( (musicnum <= musicenum_t.mus_None.ordinal())
				|| (musicnum >= musicenum_t.NUMMUSIC.ordinal()) )
		{

			DS.I.Error("Bad music number %d", musicnum);
		}
		else
			music = sounds.S_music[musicnum];

		if (mus_playing == music)
			return;

		// shutdown old music
		StopMusic();

		// get lumpnum if neccessary
		if (music.lumpnum==0)
		{
			namebuf=String.format("d_%s", music.name);
			music.lumpnum = DS.W.GetNumForName(namebuf);
		}

		// load & register it
		music.data = DS.W.CacheLumpNumAsRawBytes(music.lumpnum, Defines.PU_MUSIC);
		music.handle = IMUS.RegisterSong(music.data);

		// play it
		IMUS.PlaySong(music.handle, looping);
		SetMusicVolume(this.snd_MusicVolume);

		mus_playing = music;
	}

	public void StopMusic()
	{
		if (mus_playing!=null)
		{
			if (mus_paused)
				IMUS.ResumeSong(mus_playing.handle);

			IMUS.StopSong(mus_playing.handle);
			IMUS.UnRegisterSong(mus_playing.handle);
			//Z_ChangeTag(mus_playing->data, PU_CACHE);

			mus_playing.data = null;
			mus_playing = null;
		}
	}


	/** This is S_StopChannel. There's another StopChannel
	 *  with a similar contract in ISound. Don't confuse the two.
	 *  
	 * 
	 *  
	 * @param cnum
	 */

	protected void StopChannel(int cnum)
	{

		int		i;
		channel_t	c = channels[cnum];

		// Is it playing?
		if (c.sfxinfo!=null)
		{
			// stop the sound playing
			if (ISND.SoundIsPlaying(c.handle))
			{
				/*#ifdef SAWDEBUG
		    if (c.sfxinfo == &S_sfx[sfx_sawful])
			fprintf(stderr, "stopped\n");
	#endif*/
				ISND.StopSound(c.handle);
			}

			// check to see
			//  if other channels are playing the sound
			for (i=0 ; i<numChannels ; i++)
			{
				if (cnum != i
						&& c.sfxinfo == channels[i].sfxinfo)
				{
					break;
				}
			}

			// degrade usefulness of sound data
			c.sfxinfo.usefulness--;

			c.sfxinfo = null;
		}
	}

	//
	// Changes volume, stereo-separation, and pitch variables
	//  from the norm of a sound effect to be played.
	// If the sound is not audible, returns a 0.
	// Otherwise, modifies parameters and returns 1.
	//
	protected boolean 
	AdjustSoundParams
	( mobj_t	listener,
			ISoundOrigin	source,
			vps_t vps)
	{
		int	approx_dist;
		int	adx;
		int	ady;
		long	angle;

		// calculate the distance to sound origin
		//  and clip it if necessary
		adx = Math.abs(listener.x - source.getX());
		ady = Math.abs(listener.y - source.getY());

		// From _GG1_ p.428. Appox. eucledian distance fast.
		approx_dist = adx + ady - ((adx < ady ? adx : ady)>>1);

		if (DS.gamemap != 8
				&& approx_dist > S_CLIPPING_DIST)
		{
			return false;
		}

		// angle of source to listener
		angle = rr.RendererState.PointToAngle(listener.x,
				listener.y,
				source.getX(),
				source.getY());

		if (angle > listener.angle)
			angle = angle - listener.angle;
		else
			angle = angle + (0xffffffffL - listener.angle&BITS32);

		angle&=BITS32;
		angle >>= ANGLETOFINESHIFT;

		// stereo separation
		vps.sep = 128 - (FixedMul(S_STEREO_SWING,finesine[(int) angle])>>FRACBITS);

		// volume calculation
		if (approx_dist < S_CLOSE_DIST)
		{
			vps.volume = snd_SfxVolume;
		}
		else if (DS.gamemap == 8)
		{
			if (approx_dist > S_CLIPPING_DIST)
				approx_dist = S_CLIPPING_DIST;

			vps.volume = 15+ ((snd_SfxVolume-15)
					*((S_CLIPPING_DIST - approx_dist)>>FRACBITS))
					/ S_ATTENUATOR;
		}
		else
		{
			// distance effect
			vps.volume = (snd_SfxVolume
					* ((S_CLIPPING_DIST - approx_dist)>>FRACBITS))
					/ S_ATTENUATOR;
			// Let's do some maths here: S_CLIPPING_DIST-approx_dist
			// can be at most 0x04100000. shifting left means 0x0410,
			// or 1040 in decimal. 
			// The unmultiplied max volume is 15, attenuator is 1040.
			// So snd_SfxVolume should be 0-127.
			
		}
		
		// MAES: pitch calculation for doppler effects. Nothing to write
		// home about.
		
		/*
		
		// calculate the relative speed between source and sound origin.
		//  and clip it if necessary
		adx = Math.abs(listener.momx - source.momx);
		ady = Math.abs(listener.momy - source.momy);
			
		// From _GG1_ p.428. Appox. eucledian distance fast.
		// Here used for "approximate speed"
		approx_dist = adx + ady - ((adx < ady ? adx : ady)>>1);
		
		// The idea is that for low speeds, no doppler effect occurs.
		// For higher ones however, a shift occurs. We don't want this
		// to be annoying, so we'll only apply it for large speed differences
		// Then again, Doomguy can sprint like Carl Lewis...
			
		if (approx_dist>0x100000){
		
		// Quickly decide sign of pitch based on speed vectors
			
			// angle of source (speed) to listener (speed)
			angle = rr.RendererState.PointToAngle(listener.momx,
					listener.momy,
					source.momx,
					source.momy);
			
			if ((0<=angle && angle<=Tables.ANG90)||
				(180<=angle && angle<=Tables.ANG270))
		vps.pitch+=(approx_dist>>16);
			else
		vps.pitch-=(approx_dist>>16);
		}

		if (vps.pitch<0) vps.pitch=0;
		if (vps.pitch>255) vps.pitch=255;
		*/
		
		return (vps.volume > 0);
	}




	//
	// S_getChannel :
	//   If none available, return -1.  Otherwise channel #.
	//
	protected int 	getChannel( ISoundOrigin origin,sfxinfo_t	sfxinfo )
	{
		// channel number to use
		int		cnum;

		channel_t	c;

		// Find an open channel
		// If it's null, OK, use that.
		// If it's an origin-specific sound and has the same origin, override.
		for (cnum=0 ; cnum<numChannels ; cnum++)
		{
			if (channels[cnum].sfxinfo==null)
				break;
			else if (origin!=null &&  channels[cnum].origin ==  origin)
			{
				StopChannel(cnum);
				break;
			}
		}

		// None available
		if (cnum == numChannels)
		{
			// Look for lower priority
			for (cnum=0 ; cnum<numChannels ; cnum++)
				if (channels[cnum].sfxinfo.priority >= sfxinfo.priority) break;

			if (cnum == numChannels)
			{
				// FUCK!  No lower priority.  Sorry, Charlie.
				return -1;
			}
			else
			{
				// Otherwise, kick out lower priority.
				StopChannel(cnum);
			}
		}

		c = channels[cnum];

		// channel is decided to be cnum.
		c.sfxinfo = sfxinfo;
		c.origin = origin;

		return cnum;
	}	

	/** Nice one. A sound should have a maximum duration in tics,
	 * and we can give it a handle proportional to the future tics
	 * it should play until. Ofc, this means the minimum timeframe
	 * for cutting a sound off is just 1 tic.
	 * 
	 * @param handle
	 * @return
	 */

	/*
	public boolean SoundIsPlaying(int handle)
	{
	    // Ouch.
	    return (DS.gametic < handle);
	} */



}

package s;

import java.io.ByteArrayInputStream;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.SysexMessage;
import javax.sound.midi.Transmitter;

/** Concern separated from David Martel's MIDI & MUS player
 *  for Mocha Doom. Greatly improved upon by finnw, perfecting volume changes
 *  and MIDI device detection.
 *  
 * @author David Martel
 * @author velktron
 * @author finnw
 *
 */

public class DavidMusicModule implements IMusic {
	
	public static final int CHANGE_VOLUME=7;
	public static final int CHANGE_VOLUME_FINE=9;
	
	Sequencer sequencer;
	VolumeScalingReceiver receiver;
	Transmitter transmitter;
	boolean songloaded;
	
	public DavidMusicModule(){

	}

	@Override
	public void InitMusic() {
		try {
			
			 int x=-1;
			MidiDevice.Info[] info = MidiSystem.getMidiDeviceInfo();   
		     for (int i = 0; i < info.length; i++)  {
		    	 MidiDevice mdev=MidiSystem.getMidiDevice(info[i]);
		    	 if (mdev instanceof Sequencer) x=i;
		        //  System.out.println(info[i].getName()+"\t\t\t"+ mdev.isOpen()+"\t"+mdev.hashCode());
		          
		     }
		
		     //System.out.printf("x %d y %d \n",x,y);
		     //--This sets the Sequencer and Synthesizer  
		     //--The indices x and y correspond to the correct entries for the  
		     //--default Sequencer and Synthesizer, as determined above  	       
		      
		    if (x!=-1)
		    	sequencer = (Sequencer) MidiSystem.getMidiDevice(info[x]);
		    else
		    	sequencer = (Sequencer) MidiSystem.getSequencer(false);
			sequencer.open();
			
		    receiver = VolumeScalingReceiver.getInstance();
		    // Configure General MIDI level 1
		    sendSysexMessage(receiver, (byte)0xf0, (byte)0x7e, (byte)0x7f, (byte)9, (byte)1, (byte)0xf7);
		    transmitter = sequencer.getTransmitter();
		    transmitter.setReceiver(receiver);
		} catch (MidiUnavailableException e) {
			e.printStackTrace();
		}
	}

    private static void sendControlChange(Receiver receiver, int midiChan, int ctrlId, int value) {
        ShortMessage msg = new ShortMessage();
        try {
            msg.setMessage(ShortMessage.CONTROL_CHANGE, midiChan, ctrlId, value);
        } catch (InvalidMidiDataException ex) {
            throw new RuntimeException(ex);
        }
        receiver.send(msg, -1);
    }

	private static void sendSysexMessage(Receiver receiver, byte... message) {
	    SysexMessage msg = new SysexMessage();
	    try {
            msg.setMessage(message, message.length);
        } catch (InvalidMidiDataException ex) {
            throw new RuntimeException(ex);
        }
        receiver.send(msg, -1);
    }

    @Override
	public void ShutdownMusic() {
		sequencer.stop();
		sequencer.close();
	}

	@Override
	public void SetMusicVolume(int volume) {
		
		System.out.println("Midi volume set to "+volume);
		receiver.setGlobalVolume(volume / 127f);

	}

	@Override
	public void PauseSong(int handle) {
		if (songloaded)
		sequencer.stop();
		}

	@Override
	public void ResumeSong(int handle) {		
		if (songloaded){
			System.out.println("Resuming song");
		sequencer.start();
		}

	}

	@Override
	public int RegisterSong(byte[] data) {
		try {
            Sequence sequence;
	        ByteArrayInputStream bis;
	        try {
	            // If data is a midi file, load it directly
	            bis = new ByteArrayInputStream(data);
	            sequence = MidiSystem.getSequence(bis);
	        } catch (InvalidMidiDataException ex) {
	        	// Well, it wasn't. Dude.
                bis = new ByteArrayInputStream(data);
	            sequence = MusReader.getSequence(bis);
	        }
            sequencer.stop(); // stops current music if any
            sequencer.setSequence(sequence); // Create a sequencer for the sequence
            songloaded=true;
	    } catch (Exception e) {
	    	e.printStackTrace();
	    	return -1;
	    } 
		// In good old C style, we return 0 upon success?
		return 0;
	}

	@Override
	public void PlaySong(int handle, boolean looping) {
		if (songloaded){
	        for (int midiChan = 0; midiChan < 16; ++ midiChan) {
	            setPitchBendSensitivity(receiver, midiChan, 2);
	        }
            if (looping)
            	sequencer.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);
            else
            	sequencer.setLoopCount(0);
            sequencer.start(); // Start playing
		}
	}

	private void setPitchBendSensitivity(Receiver receiver, int midiChan, int semitones) {
	    sendRegParamChange(receiver, midiChan, 0, 0, 2);
    }

    private void sendRegParamChange(Receiver receiver, int midiChan, int paramMsb, int paramLsb, int valMsb) {
        sendControlChange(receiver, midiChan, 101, paramMsb);
        sendControlChange(receiver, midiChan, 100, paramLsb);
        sendControlChange(receiver, midiChan, 6, valMsb);
    }

    @Override
	public void StopSong(int handle) {
		sequencer.stop();

	}

	@Override
	public void UnRegisterSong(int handle) {
		// In theory, we should ask the sequencer to "forget" about the song.
		// However since we can register another without unregistering the first,
		// this is practically a dummy.
		
		songloaded=false;

	}

}

package s;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Writer;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class DoomIO {
	InputStream is;
	OutputStream os;
	
	public DoomIO(InputStream is, OutputStream os) {
		this.is = is;
		this.os = os;
	}
	
	public static int toUnsigned(byte signed) {
		int unsigned = (signed & 0xff);
		unsigned = (signed >= 0 ? signed : 256 + signed);
		unsigned = (256 + signed) % 256;
		return unsigned;
	}

	public static int fread(byte[] bytes, int size, int count, InputStream file) throws IOException {
		int retour = 0;
		do {
			if (file.read(bytes, retour*size, size) < size)
				return retour;
			retour++;
		}
		while (--count > 0);
		return retour;
	}

	public static int freadint(InputStream file) throws IOException {
		/*byte[] bytes = new byte[2];
		if (fread(bytes, 2, 1, file) < 1)
			return -1;
		int retour = toUnsigned(bytes[1])*256 + toUnsigned(bytes[0]);
		return retour;*/
		return freadint(file, 2);
	}

	public static int freadint(InputStream file, int nbBytes) throws IOException {
		byte[] bytes = new byte[nbBytes];
		if (fread(bytes, nbBytes, 1, file) < 1)
			return -1;
		long retour = 0;
		for (int i = 0; i < nbBytes; i++) {
			retour += toUnsigned(bytes[i])*(long)Math.pow(256, i);
		}
		//toUnsigned(bytes[1])*256 + toUnsigned(bytes[0]);
		
		if (retour > (long)Math.pow(256, nbBytes)/2)
			retour -= (long)Math.pow(256, nbBytes);
		
		return (int)retour;
	}

	public static int fwrite2(byte[] ptr, int offset, int size, Object file) throws IOException
	{
		fwrite(ptr, offset, size, 1, file);
		return 0;
	}

	public static int fwrite2(byte[] ptr, int size, Object file) throws IOException
	{
		return fwrite2(ptr, 0, size, file);
	}

	public static int fwrite2(byte[] ptr, Object file) throws IOException
	{
		return fwrite2(ptr, 0, ptr.length, file);
	}

	public static void fwrite(String bytes, int size, int count, Object file) throws IOException {
		fwrite(toByteArray(bytes), size, count, file);
	}

	public static void fwrite(byte[] bytes, int size, int count, Object file) throws IOException {
		fwrite(bytes, 0, size, count, file);
	}

	public static void fwrite(byte[] bytes, int offset, int size, int count, Object file) throws IOException {
		if (file instanceof OutputStream) {
			/*byte[] b = bytes;
			if (bytes.length < size) {
				b = new byte[size];
				copyBytes(from, to, offset)
			}*/
			
			((OutputStream)file).write(bytes, offset, Math.min(bytes.length, size));
			for (int i = bytes.length; i < size; i++)
				((OutputStream)file).write((byte)0);  // padding effect if size is bigger than byte array
		}
		if (file instanceof Writer) {
			char[] ch = new char[bytes.length];
			for (int i = 0; i < bytes.length; i++) {
				ch[i] = (char)toUnsigned(bytes[i]);
			}
			
			((Writer)file).write(ch, offset, size);
		}
	}
	
	public static byte[] toByteArray(String str) {
			byte[] retour = new byte[str.length()];
			for (int i = 0; i < str.length(); i++) {
				retour[i] = (byte)(str.charAt(i) & 0xFF);
			}
			return retour;
		}

		public static byte[] toByteArray(int str) {
			return toByteArray(str, 2);
		}

		 public static enum Endian { BIG, LITTLE }
		 public static Endian writeEndian = Endian.LITTLE;

		 static int byteIdx(int i, int nbBytes) {
			return (writeEndian == Endian.BIG ? i : nbBytes-1-i);
		}
		
		 public static void copyBytes(byte[] from, byte[] to, int offset) {
			 for (byte b: from) {
				 to[offset++] = b;
			 }
		 }
		 
		 public static byte[] toByteArray(Long str, int nbBytes) {
			 return toByteArray(str.intValue(), nbBytes);
		 }

		 public static byte[] toByteArray(Short str, int nbBytes) {
			 return toByteArray(str.intValue(), nbBytes);
		 }

		 public static byte[] toByteArray(int[] str, int nbBytes) {
			 byte[] bytes = new byte[str.length*nbBytes];
			 for (int i = 0; i < str.length; i++) {
				 copyBytes(toByteArray(str[i], nbBytes), bytes, i*nbBytes);
			 }
			 return bytes;
		 }

		 /*
		 public static byte[] toByteArray(boolean[] bools, int nbBytes) {
			 byte[] bytes = new byte[bools.length*nbBytes];
			 for (int i = 0; i < bools.length; i++) {
				 copyBytes(toByteArray(bools[i], nbBytes), bytes, i*nbBytes);
			 }
			 return bytes;
		 } */

		 /*
		 public static byte[] toByteArray(Boolean bool, int nbBytes) {
			 int val = (bool?1:0);
			 return toByteArray(val, nbBytes);
		 }*/

		 public static byte[] toByteArray(Integer str, int nbBytes) {
			 Long val = str.longValue();
			 if (val < 0)
				 val = (long)Math.pow(256, nbBytes) + val;
			 
			 byte[] bytes = new byte[nbBytes];
			long tmp = val;
			for (int i = 0; i <nbBytes-1; i++) {
				bytes[byteIdx(i, nbBytes)] = (byte)(tmp%256);
				tmp = tmp / 256;
			}
			
			bytes[byteIdx(nbBytes-1, nbBytes)] = (byte)(tmp);
			return bytes;
		}

		 private static Field getField(Class clazz, String fieldName) throws NoSuchFieldException {     
			 try {       
				 return clazz.getDeclaredField(fieldName);     
			 } catch (NoSuchFieldException e) {
				 Class superClass = clazz.getSuperclass();
				 if (superClass == null) {
					 throw e;    
				 } else {  
					 return getField(superClass, fieldName);     
				 }    
			 }  
		 } 

		 public static void linkBA(Object obj, Object fieldName, Object stream, int size) {
		    	if (stream instanceof OutputStream) {
		    		try {
		    			Object val = null;
		    			if (fieldName instanceof String) {
		    				val = getField(obj.getClass(), (String)fieldName).get(obj);
			    			if (val instanceof Enum) {
			    				val = ((Enum)val).ordinal();
			    			}
		    			}
		    			if (fieldName instanceof Integer) {
		    				val = fieldName;
		    			}

		    			Method method = DoomIO.class.getMethod("toByteArray", val.getClass(), int.class);
		    			byte[] bytes = (byte[])method.invoke(null, val, size);
		    			((OutputStream)stream).write(bytes);

		    		} catch (Exception e) {
		    			// TODO Auto-generated catch block
		    			e.printStackTrace();
		    		}
		    	}
		    	
		    	if (stream instanceof InputStream) {
		    		try {
		    			if (fieldName instanceof String) {
		    				Field field = obj.getClass().getField((String)fieldName);
		    				assigner(obj, field, (InputStream)stream, size);
		    			}
		    			if (fieldName instanceof Integer) {
		    				((InputStream)stream).read(new byte[size]);
		    			}

					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
		    	}

		    	
//		    	public static int freadint(InputStream file, int nbBytes) throws IOException {

		    }
		 public static void assigner(Object obj, Field field, InputStream is, int size) throws IOException, IllegalArgumentException, IllegalAccessException {

				Class c = field.getType();
				if (c.isArray()) {
					Object a = field.get(obj);
					int len = Array.getLength(a);
					for (int i = 0; i < len; i++) {
						int val = DoomIO.freadint((InputStream)is, size);
						Object o = Array.get(a, i);
						Array.set(a, i, assignValue(val, o, o.getClass()));
					}
					return;
				}
				
				int val = DoomIO.freadint((InputStream)is, size);
				Object v = assignValue(val, field.get(obj), field.getType());
				field.set(obj, v);

				/*Object[] enums = c.getEnumConstants();
				if (enums != null) {
					int val = DoomIO.freadint((InputStream)is, size);
					field.set(obj, enums[val]);
				}
				else {
					int val = DoomIO.freadint((InputStream)is, size);
					field.set(obj, val);
				}*/
		 }
		 
		 public static Object assignValue(int val, Object objToReplace, Class classe) {
			 if (classe.isAssignableFrom(Boolean.class) || classe.isAssignableFrom(boolean.class)) {
				 return (val == 0 ? false : true);
			 }
			 
				Object[] enums = classe.getEnumConstants();
				if (enums != null) {
					//int val = DoomIO.freadint((InputStream)is, size);
					return enums[val];
					//field.set(obj, enums[val]);
				}
				else {
					//int val = DoomIO.freadint((InputStream)is, size);
					//field.set(obj, val);
				}
			 
			 return val;
		 }
		 
		 public static String baToString(byte[] bytes) {
			 String str = "";
			 for (int i = 0; i < bytes.length && bytes[i] != 0; i++)
				 str += (char)bytes[i];
			 return str;
		 }
		 
		   public static int indexOfArray(Object[] a, Object o) {
			   for (int i = 0; i < a.length/* Array.getLength(a)*/; i++) {
				   if (/*Array.get(a, i)*/a[i] == o)
					   return i;
			   }
			   return -1;
		   }

}

package s;

public final class degenmobj_t
        implements ISoundOrigin {

    private final int x, y, z;

    public degenmobj_t(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    public degenmobj_t(int x, int y) {
        this.x = x;
        this.y = y;
        this.z = 0;
    }

    @Override
    public final int getX() {
        return x;
    }

    @Override
    public final int getY() {
        return y;
    }

    @Override
    public final int getZ() {
        return z;
    }

}

package s;

/** Use this instead of that degemobj_t crud */

public interface ISoundOrigin {
	public int getX();
	public int getY();
	public int getZ();
	}

package s;

public class AudioChunk{
    public AudioChunk() {
        buffer=new byte[s.ISoundDriver.MIXBUFFERSIZE];
        setStuff(0,0);
        this.free=true;
    }
    
    public void setStuff(int chunk, int time){
        this.chunk = chunk;
        this.time = time;
    }
    
    public int chunk;
    public int time;
    public byte[] buffer;
    public boolean free;
    

}
package s;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Writer;

public class QMusToMid {

	public static final int NOTMUSFILE  =    1;       /* Not a MUS file */
	public static final int COMUSFILE   =    2;       /* Can't open MUS file */
	public static final int COTMPFILE   =    3;       /* Can't open TMP file */
	public static final int CWMIDFILE   =    4;       /* Can't write MID file */
	public static final int MUSFILECOR  =    5;       /* MUS file corrupted */
	public static final int TOOMCHAN    =    6;       /* Too many channels */
	public static final int MEMALLOC    =    7;       /* Memory allocation error */

	/* some (old) compilers mistake the "MUS\x1A" construct (interpreting
	   it as "MUSx1A")      */

	public static final String MUSMAGIC =    "MUS\032";                    /* this seems to work */
	public static final String MIDIMAGIC =   "MThd\000\000\000\006\000\001";
	public static final String TRACKMAGIC1 =  "\000\377\003\035";
	public static final String TRACKMAGIC2 = "\000\377\057\000";
	public static final String TRACKMAGIC3 = "\000\377\002\026";
	public static final String TRACKMAGIC4 = "\000\377\131\002\000\000";
	public static final String TRACKMAGIC5 = "\000\377\121\003\011\243\032";
	public static final String TRACKMAGIC6 = "\000\377\057\000";

	public static final int EOF = -1;
	public static class Ptr<a> {
		a val;
		
		public Ptr(a val) {
			this.val = val;
		}
		
		public a get() {
			return val;
		}
		
		public void set(a newval) {
			val = newval;
		}
	}

	public static class MUSheader
	{
		byte[]        ID = new byte[4];            /* identifier "MUS" 0x1A */
		int        ScoreLength;
		int        ScoreStart;
		int        channels;         /* count of primary channels */
		int        SecChannels;      /* count of secondary channels (?) */
		int        InstrCnt;
		int        dummy;
		/* variable-length part starts here */
		int[]        instruments;
	}

	public static class Track
	{
		long  current;
		byte           vel;
		long           DeltaTime;
		byte  LastEvent;
		byte[]           data;            /* Primary data */
	}


	long TRACKBUFFERSIZE = 65536L ;  /* 64 Ko */


	void TWriteByte( int MIDItrack, byte byte_, Track track[] )
	{
	  long pos ;

	  pos = track[MIDItrack].current ;
	  if( pos < TRACKBUFFERSIZE )
	    track[MIDItrack].data[(int)pos] = byte_ ;
	  else
	    {
	      System.out.println("ERROR : Track buffer full.\n"+
	             "Increase the track buffer size (option -size).\n" ) ;
	      System.exit(1);
	    }
	  track[MIDItrack].current++ ;
	}


	void TWriteVarLen( int tracknum, long value, 
	                  Track[] track )
	{
	  long buffer ;

	  buffer = value & 0x7f ;
	  while( (value >>= 7) != 0 )
	    {
	      buffer <<= 8 ;
	      buffer |= 0x80 ;
	      buffer += (value & 0x7f) ;
	    }
	  while( true )
	    {
	      TWriteByte( tracknum, (byte)buffer, track ) ;
	      if( (buffer & 0x80) != 0 )
	        buffer >>= 8 ;
	      else
	        break;
	    }
	}

	int ReadMUSheader( MUSheader MUSh, InputStream file )
	{
		try {
	  if( DoomIO.fread( MUSh.ID, 4, 1, file ) != 1 ) return COMUSFILE ;
	  
	  /*if( strncmp( MUSh->ID, MUSMAGIC, 4 ) ) 
	    return NOTMUSFILE ;*/
	  if( (MUSh.ScoreLength = DoomIO.freadint(file)) == -1 ) return COMUSFILE ;
	  if( (MUSh.ScoreStart = DoomIO.freadint(file)) == -1 ) return COMUSFILE ;
	  if( (MUSh.channels = DoomIO.freadint(file)) == -1 ) return COMUSFILE ;
	  if( (MUSh.SecChannels = DoomIO.freadint(file)) == -1 ) return COMUSFILE ;
	  if( (MUSh.InstrCnt = DoomIO.freadint(file)) == -1 ) return COMUSFILE ;
	  if( (MUSh.dummy = DoomIO.freadint(file)) == -1 ) return COMUSFILE ;

	  MUSh.instruments = new int[MUSh.InstrCnt];
	  for (int i = 0; i < MUSh.InstrCnt; i++) {
		  if ((MUSh.instruments[i] = DoomIO.freadint(file)) == -1) {
		      return COMUSFILE ;
		  }
	  }

	  return 0 ;
		}
		catch (Exception e) {
			e.printStackTrace();
			return COMUSFILE;
		}
	}

	int WriteMIDheader( int ntrks, int division, Object file )
	{
		try {
			//_D_: those two lines for testing purposes only
			//fisTest.close();
			//fisTest = new FileInputStream("C:\\Users\\David\\Desktop\\qmus2mid\\test.mid");

			  DoomIO.fwrite( MIDIMAGIC , 10, 1, file ) ;
			  DoomIO.fwrite2( DoomIO.toByteArray(ntrks), 2, file) ;
			  DoomIO.fwrite2( DoomIO.toByteArray(division), 2, file ) ;
		} catch (IOException e) {
			e.printStackTrace();
		}

		return 0 ;
	}

	byte last(int e) {
		return (byte)(e & 0x80);
	}
	byte event_type(int e) {
		return (byte)((e & 0x7F) >> 4);
	}
	byte channel(int e) {
		return (byte)(e & 0x0F);
	}
	
	void TWriteString( char tracknum, String string, int length,
	                   Track[] track )
	{
	  int i ;

	  for( i = 0 ; i < length ; i++ )
	    TWriteByte( tracknum, (byte)string.charAt(i), track ) ;
	}


	void WriteTrack( int tracknum, Object file, Track[] track )
	{
	  long size ;
	  int quot, rem ;

	  try {
	  /* Do we risk overflow here ? */
	  size = track[tracknum].current+4 ;
	  DoomIO.fwrite( "MTrk", 4, 1, file );
	  if( tracknum == 0) size += 33 ;

	  DoomIO.fwrite2( DoomIO.toByteArray((int)size, 4), 4, file ) ;
	  if( tracknum == 0)
		  DoomIO.fwrite( TRACKMAGIC1 + "Quick MUS->MID ! by S.Bacquet", 33, 1, file ) ;

	  quot = (int) (track[tracknum].current / 4096) ;
	  rem = (int) (track[tracknum].current - quot*4096) ;
	  
	  DoomIO.fwrite(track[tracknum].data, (int)track[tracknum].current, 1, file ) ;
	  DoomIO.fwrite( TRACKMAGIC2, 4, 1, file ) ;
	  }
	  catch (Exception e) {
		  e.printStackTrace();
	  }
	}

	void WriteFirstTrack( Object file )
	{
		try {
			  byte[] size = DoomIO.toByteArray(43, 4);
			  
			  DoomIO.fwrite( "MTrk", 4, 1, file ) ;
			  DoomIO.fwrite2( size, 4, file ) ;
			  DoomIO.fwrite( TRACKMAGIC3 , 4, 1, file ) ;
			  DoomIO.fwrite( "QMUS2MID (C) S.Bacquet", 22, 1, file ) ;
			  DoomIO.fwrite( TRACKMAGIC4, 6, 1, file ) ;
			  DoomIO.fwrite( TRACKMAGIC5, 7, 1, file ) ;
			  DoomIO.fwrite( TRACKMAGIC6, 4, 1, file ) ;

		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	long ReadTime( InputStream file ) throws IOException
	{
	  long time = 0 ;
	  int byte_ ;

	  do
	    {
	      byte_ = getc( file ) ;
	      if( byte_ != EOF ) time = (time << 7) + (byte_ & 0x7F) ;
	    } while( (byte_ != EOF) && ((byte_ & 0x80) != 0) ) ;

	  return time ;
	}

	byte FirstChannelAvailable( byte[] MUS2MIDchannel )
	{
	  int i ;
	  byte old15 = MUS2MIDchannel[15], max = -1 ;

	  MUS2MIDchannel[15] = -1 ;
	  for( i = 0 ; i < 16 ; i++ )
	    if( MUS2MIDchannel[i] > max ) max = MUS2MIDchannel[i] ;
	  MUS2MIDchannel[15] = old15 ;

	  return (max == 8 ? 10 : (byte)(max+1)) ;
	}


	int getc(InputStream is) throws IOException {
		return is.read();
	}
	
	int qmus2mid( InputStream mus, Object mid, boolean nodisplay, 
	             int division, int BufferSize, boolean nocomp ) throws IOException
	{
	  Track[] track = new Track[16] ;
	  for (int i = 0; i < track.length; i++)
		  track[i] = new Track(); 
	  
	  int TrackCnt = 0 ;
	  byte et, MUSchannel, MIDIchannel, MIDItrack, NewEvent ;
	  int i, event, data, r ;
	  MUSheader MUSh = new MUSheader() ;
	  long DeltaTime, TotalTime = 0, time, min, n = 0 ;
	  byte[] MUS2MIDcontrol = new byte[] {
	    0,                          /* Program change - not a MIDI control change */
	    0x00,                       /* Bank select */
	    0x01,                       /* Modulation pot */
	    0x07,                       /* Volume */
	    0x0A,                       /* Pan pot */
	    0x0B,                       /* Expression pot */
	    0x5B,                       /* Reverb depth */
	    0x5D,                       /* Chorus depth */
	    0x40,                       /* Sustain pedal */
	    0x43,                       /* Soft pedal */
	    0x78,                       /* All sounds off */
	    0x7B,                       /* All notes off */
	    0x7E,                       /* Mono */
	    0x7F,                       /* Poly */
	    0x79                        /* Reset all controllers */
	  };
	  byte[] MIDIchan2track = new byte[16];
	  byte[] MUS2MIDchannel = new byte[16] ;
	  char ouch = 0, sec ;

	  DoomIO.writeEndian = DoomIO.Endian.LITTLE;
	  
	  r = ReadMUSheader( MUSh, mus ) ;
	  if( r != 0)
	    {
	      return r ;
	    }
	 /* if( fseek( file_mus, MUSh.ScoreStart, SEEK_SET ) )
	    {
	      Close() ;
	      return MUSFILECOR ;
	    }*/
	  if( !nodisplay )
	    System.out.println( mus+" ("+mus.available()+"  bytes) contains "+MUSh.channels+" melodic channel"+ (MUSh.channels >= 2 ? "s" : "")+"\n");

	  if( MUSh.channels > 15 )      /* <=> MUSchannels+drums > 16 */
	    {
	      return TOOMCHAN ;
	    }

	  for( i = 0 ; i < 16 ; i++ )
	    {
	      MUS2MIDchannel[i] = -1 ;
	      track[i].current = 0 ;
	      track[i].vel = 64 ;
	      track[i].DeltaTime = 0 ;
	      track[i].LastEvent = 0 ;
	      track[i].data = null ;
	    }
	  if( BufferSize != 0)
	    {
	      TRACKBUFFERSIZE = ((long) BufferSize) << 10 ;
	      if( !nodisplay )
	      System.out.println( "Track buffer size set to "+BufferSize+" KB.\n") ;
	    }
	  
	  if( !nodisplay )
	    {
	  System.out.println( "Converting..." ) ;
	    }
	  event = getc( mus ) ;
	  et = event_type( event ) ;
	  MUSchannel = channel( event ) ;
	  while( (et != 6) && mus.available() > 0 && (event != EOF) )
	    {
	      if( MUS2MIDchannel[MUSchannel] == -1 )
	        {
	          MIDIchannel = MUS2MIDchannel[MUSchannel ] = 
	            (MUSchannel == 15 ? 9 : FirstChannelAvailable( MUS2MIDchannel)) ;
	          MIDItrack   = MIDIchan2track[MIDIchannel] = (byte)TrackCnt++ ;
	          if( (track[MIDItrack].data = new byte[(int)TRACKBUFFERSIZE]) == null )
	            {
	              return MEMALLOC ;
	            }
	        }
	      else
	        {
	          MIDIchannel = MUS2MIDchannel[MUSchannel] ;
	          MIDItrack   = MIDIchan2track [MIDIchannel] ;
	        }
	      TWriteVarLen( MIDItrack, track[MIDItrack].DeltaTime, track ) ;
	      track[MIDItrack].DeltaTime = 0 ;
	      switch( et )
	        {
	        case 0 :                /* release note */
	          NewEvent = (byte)(0x90 | MIDIchannel) ;
	          if( (NewEvent != track[MIDItrack].LastEvent) || (nocomp) )
	            {
	              TWriteByte( MIDItrack, NewEvent, track ) ;
	              track[MIDItrack].LastEvent = NewEvent ;
	            }
	          else
	            n++ ;
	          data = getc( mus ) ;
	          TWriteByte( MIDItrack, (byte)data, track ) ;
	          TWriteByte( MIDItrack, (byte)0, track ) ;
	          break ;
	        case 1 :
	          NewEvent = (byte)(0x90 | MIDIchannel) ;
	          if( (NewEvent != track[MIDItrack].LastEvent) || (nocomp) )
	            {
	              TWriteByte( MIDItrack, NewEvent, track ) ;
	              track[MIDItrack].LastEvent = NewEvent ;
	            }
	          else
	            n++ ;
	          data = getc( mus ) ;
	          TWriteByte( MIDItrack, (byte)(data & 0x7F), track ) ;
	          if( (data & 0x80) != 0 )
	            track[MIDItrack].vel = (byte)getc( mus ) ;
	          TWriteByte( MIDItrack, (byte)track[MIDItrack].vel, track ) ;
	          break ;
	        case 2 :
	          NewEvent = (byte)(0xE0 | MIDIchannel) ;
	          if( (NewEvent != track[MIDItrack].LastEvent) || (nocomp) )
	            {
	              TWriteByte( MIDItrack, NewEvent, track ) ;
	              track[MIDItrack].LastEvent = NewEvent ;
	            }
	          else
	            n++ ;
	          data = getc( mus ) ;
	          TWriteByte( MIDItrack, (byte)((data & 1) << 6), track ) ;
	          TWriteByte( MIDItrack, (byte)(data >> 1), track ) ;
	          break ;
	        case 3 :
	          NewEvent = (byte)(0xB0 | MIDIchannel) ;
	          if( (NewEvent != track[MIDItrack].LastEvent) || (nocomp) )
	            {
	              TWriteByte( MIDItrack, NewEvent, track ) ;
	              track[MIDItrack].LastEvent = NewEvent ;
	            }
	          else
	            n++ ;
	          data = getc( mus ) ;
	          TWriteByte( MIDItrack, MUS2MIDcontrol[data], track ) ;
	          if( data == 12 )
	            TWriteByte( MIDItrack, (byte)(MUSh.channels+1), track ) ;
	          else
	            TWriteByte( MIDItrack, (byte)0, track ) ;
	          break ;
	        case 4 :
	          data = getc( mus ) ;
	          if( data != 0 )
	            {
	              NewEvent = (byte)(0xB0 | MIDIchannel) ;
	              if( (NewEvent != track[MIDItrack].LastEvent) || (nocomp) )
	                {
	                  TWriteByte( MIDItrack, NewEvent, track ) ;
	                  track[MIDItrack].LastEvent = NewEvent ;
	                }
	              else
	                n++ ;
	              TWriteByte( MIDItrack, MUS2MIDcontrol[data], track ) ;
	            }
	          else
	            {
	              NewEvent = (byte)(0xC0 | MIDIchannel) ;
	              if( (NewEvent != track[MIDItrack].LastEvent) || (nocomp) )
	                {
	                  TWriteByte( MIDItrack, NewEvent, track ) ;
	                  track[MIDItrack].LastEvent = NewEvent ;
	                }
	              else
	                n++ ;
	            }
	          data = getc( mus ) ;
	          TWriteByte( MIDItrack, (byte)data, track ) ;
	          break ;
	        case 5 :
	        case 7 :
	          return MUSFILECOR ;
	        default : break ;
	        }
	      if( last( event ) != 0 )
		{
	          DeltaTime = ReadTime( mus ) ;
	          TotalTime += DeltaTime ;
		  for( i = 0 ; i < (int) TrackCnt ; i++ )
		    track[i].DeltaTime += DeltaTime ;
	        }
	      event = getc( mus ) ;
	      if( event != EOF )
	                  {
	          et = event_type( event ) ;
	          MUSchannel = channel( event ) ;
	        }
	      else
	        ouch = 1 ;
	    }
	  if( !nodisplay ) System.out.println( "done !\n" ) ;
	  if( ouch != 0 )
	    System.out.println( "WARNING : There are bytes missing at the end of "+mus+".\n          "+
	           "The end of the MIDI file might not fit the original one.\n") ;
	  if( division == 0 )
	    division = 89 ;
	  else
	    if( !nodisplay ) System.out.println( "Ticks per quarter note set to "+division+".\n") ;
	  if( !nodisplay )
	    {
	      if( division != 89 )
	        {
	          time = TotalTime / 140 ;
	          min = time / 60 ;
	          sec = (char) (time - min*60) ;
	          //System.out.println( "Playing time of the MUS file : %u'%.2u''.\n", min, sec ) ;
	        }
	      time = (TotalTime * 89) / (140 * division) ;
	      min = time / 60 ;
	      sec = (char) (time - min*60) ;
	      if( division != 89 )
	    	  System.out.println( "                    MID file" ) ;
	      else
	    	  System.out.println( "Playing time: "+min+"min "+sec+"sec") ;
	    }
	  if( !nodisplay )
	    {
	      System.out.println("Writing..." ) ;
	    }
	  WriteMIDheader( TrackCnt+1, division, mid ) ;
	  WriteFirstTrack( mid ) ;
	  for( i = 0 ; i < (int) TrackCnt ; i++ )
	    WriteTrack( i, mid, track ) ;
	  if( !nodisplay )
	    System.out.println( "done !\n" ) ;
	  if( !nodisplay && (!nocomp) )
	    System.out.println( "Compression : %u%%.\n"/*,
	           (100 * n) / (n+ (long) ftell( mid ))*/ ) ;
	  
	  return 0 ;
	}


	int convert( String mus, String mid, boolean nodisplay, int div,
            int size, boolean nocomp, Ptr<Integer> ow ) throws IOException
{
		InputStream is = new BufferedInputStream(new FileInputStream(new File(mid)));
		OutputStream os = new BufferedOutputStream(new FileOutputStream(new File(mid)));
		
	  int error;
	  //struct stat file_data ;
	  char[] buffer = new char[30] ;


	  /* we don't need _all_ that checking, do we ? */
	  /* Answer : it's more user-friendly */
	/*#ifdef MSDOG

	  if( access( mus, 0 ) )
	    {
	      System.out.println( "ERROR : %s does not exist.\n", mus ) ;
	      return 1 ;
	    }

	  if( !access( mid, 0 ) )
	    {
	      if( !*ow )
	        {
	          System.out.println( "Can't overwrite %s.\n", mid ) ;
	          return 2 ;
	        }
	      if( *ow == 1 )
	        {
	          System.out.println( "%s exists : overwrite (Y=Yes,N=No,A=yes for All,Q=Quit)"
	                 " ? [Y]\b\b", mid ) ;
	          fflush( stdout ) ;
	          do
	            n = toupper( getxkey() ) ;
	          while( (n != 'Y') && (n != 'N') && (n != K_Return) && (n != 'A')
	                && (n != 'Q')) ;
	          switch( n )
	            {
	            case 'N' :
	              System.out.println( "N\n%s NOT converted.\n", mus ) ;
	              return 3 ;
	            case 'A' :
	              System.out.println( "A" ) ;
	              *ow = 2 ;
	              break ;
	            case 'Q' :
	              System.out.println( "Q\nQMUS2MID aborted.\n" ) ;
	              exit( 0 ) ;
	              break ;
	            default : break ;
	            }
	          System.out.println( "\n" ) ;
	        }
	    }
	#else*/
	  /*if ( ow.get() == 0 ) {
	    file = fopen(mid, "r");
	    if ( file ) {
	      fclose(file);
	      System.out.println( "qmus2mid: file %s exists, not removed.\n", mid ) ;
	      return 2 ;
	    }
	  }*/
	/*#endif*/

	  return convert(is, os, nodisplay, div, size, nocomp, ow);
}
	
	int convert( InputStream mus, Object mid, boolean nodisplay, int div,
            int size, boolean nocomp, Ptr<Integer> ow ) throws IOException
{
	  int error = qmus2mid( mus, mid, nodisplay, div, size, nocomp ) ;

	  if( error != 0 )
	    {
		  System.out.println( "ERROR : " ) ;
	      switch( error )
	        {
	        case NOTMUSFILE :
	        	System.out.println( "%s is not a MUS file.\n"/*, mus*/ ) ; break ;
	        case COMUSFILE :
	        	System.out.println( "Can't open %s for read.\n"/*, mus*/ ) ; break ;
	        case COTMPFILE :
	        	System.out.println( "Can't open temp file.\n" ) ; break  ;
	        case CWMIDFILE :
	        	System.out.println( "Can't write %s (?).\n"/*, mid */) ; break ;
	        case MUSFILECOR :
	        	System.out.println( "%s is corrupted.\n"/*, mus*/) ; break ;
	        case TOOMCHAN :
	        	System.out.println( "%s contains more than 16 channels.\n"/*, mus*/ ) ; break ;
	        case MEMALLOC :
	        	System.out.println( "Not enough memory.\n" ) ; break ;
	        default : break ;
	        }
	      return 4 ;
	    }

	  if( !nodisplay )
	    {
	      System.out.println( mus+" converted successfully.\n") ;
	      /*if( (file = fopen( mid, "rb" )) != NULL )
	        {
	          //stat( mid, &file_data ) ;
	          fclose( file ) ;
	          sSystem.out.println( buffer, " : %lu bytes", (long) file_data.st_size ) ;
	        }*/
	      
	      /*System.out.println( "%s (%scompressed) written%s.\n", mid, nocomp ? "NOT " : "",
	             file ? buffer : ""  ) ;*/
	    }

	  return 0 ;
	}


//	int CheckParm( char[] check, int argc, char *argv[] )
//	{
//	  int i;
//
//	  for ( i = 1 ; i<argc ; i++ )
//	/*#ifdef MSDOG
//	    if( !stricmp( check, argv[i] ) )
//	#else*/
//	    if( !strcmp( check, argv[i] ) )
//	/*#endif*/
//	      return i ;
//
//	  return 0;
//	}


	void PrintHeader( )
	{
//	  System.out.println( "===============================================================================\n"
//	         "              Quick MUS->MID v2.0 ! (C) 1995,96 Sebastien Bacquet\n"
//	         "                        E-mail : bacquet@iie.cnam.fr\n"
//	         "===============================================================================\n" ) ;
	}


	void PrintSyntax( )
	{
//	  PrintHeader() ;
//	  System.out.println( 
//	#ifdef MSDOG
//	         "\nSyntax : QMUS2MID musfile1[.mus] {musfile2[.mus] ... | "
//	         "midifile.mid} [options]\n"
//	         "   Wildcards are accepted.\n"
//	         "   Options are :\n"
//	         "     -query    : Query before processing\n"
//	         "     -ow       : OK, overwrite (without query)\n"
//	#else
//	         "\nSyntax : QMUS2MID musfile midifile [options]\n"
//	         "   Options are :\n"
//	#endif
//	         "     -noow     : Don't overwrite !\n"
//	         "     -nodisp   : Display nothing ! (except errors)\n"
//	         "     -nocomp   : Don't compress !\n"
//	         "     -size ### : Set the track buffer size to ### (in KB). "
//	         "Default = 64 KB\n"
//	         "     -t ###    : Ticks per quarter note. Default = 89\n" 
//	         ) ;
	}


	int main( int argc, char[] argv )
	{
	  int div = 0, ow = 1, nocomp = 0, size = 0, n ;
	  boolean nodisplay = false;
	/*#ifdef MSDOG
	  int FileCount, query = 0, i, line = 0 ;
	  char mus[MAXPATH], mid[MAXPATH], drive[MAXDRIVE], middrive[MAXDRIVE],
	  dir[MAXDIR], middir[MAXDIR], musname[MAXFILE], midname[MAXFILE],
	  ext[MAXEXT] ;
	  struct stat s ;
	#else*/
	  String  mus, mid;
	/*#endif*/


	/*#ifndef MSDOG
	  if ( !LittleEndian() ) {
	    System.out.println("\nSorry, this program presently only works on "
		   "little-endian machines... \n\n");
	    exit( EXIT_FAILURE ) ;
	  }
	#endif*/

	/*#ifdef MSDOG
	  if( (argc == 1) || (argv[1][0] == '-') )
	#else
	    if( argc < 3 )
	#endif
	      {
	        PrintSyntax() ;
	        exit( EXIT_FAILURE ) ;
	      }*/

	/*#ifdef MSDOG
	  if( (strrchr( argv[1], '*' ) != NULL) || (strrchr( argv[1], '?' ) != NULL) )
	    {
	      PrintHeader() ;
	      System.out.println( "Sorry, there is nothing matching %s...\n", argv[1] ) ;
	      exit( EXIT_FAILURE ) ;
	    }
	  strncpy( mus, argv[1], MAXPATH ) ;
	  strupr( mus ) ;
	  if( !(fnsplit( mus, drive, dir, musname, NULL ) & FILENAME) )
	    {
	      PrintSyntax() ;
	      exit( EXIT_FAILURE ) ;
	    }
	#else*/
	  //strncpy( mus, argv[1], FILENAME_MAX ) ;
	  //strncpy( mid, argv[2], FILENAME_MAX ) ;
	/*#endif*/

	/*#ifdef MSDOG
	  if( CheckParm( "-query", argc, argv ) )
	    query = 1 ;
	#endif*/

	/*  if( CheckParm( "-nodisp", argc, argv ) )
	    nodisplay = 1 ;
	  */
	  if( !nodisplay )
	    PrintHeader() ;
	  
	  /*if( (n = CheckParm( "-size", argc, argv )) != 0 )
	    size = atoi( argv[n+1] ) ;*/
	/*#ifdef MSDOG
	  if( CheckParm( "-ow", argc, argv ) )
	    ow += 1 ;
	#endif
	  if( CheckParm( "-noow", argc, argv ) )
	    ow -= 1 ;
	  if( (n = CheckParm( "-t", argc, argv )) != 0 )
	    div = atoi( argv[n+1] ) ;
	  if( CheckParm( "-nocomp", argc, argv ) )
	    nocomp = 1 ;*/

	/*#ifdef MSDOG
	  for( FileCount = 1 ; (FileCount < argc) && (argv[FileCount][0] != '-') ;
	      FileCount++ ) ;
	  FileCount-- ;
	  midname[0] = middrive[0] = middir[0] = 0 ;
	  if( FileCount == 2 )
	    {
	      if( fnsplit( argv[FileCount], middrive, middir, midname, ext )
	         & FILENAME )
	        {
	          if( stricmp( ext, ".MID" ) )
	            midname[0] = middrive[0] = middir[0] = 0 ;
	          else
	            {
	              strcpy( mid, argv[FileCount--] ) ;
	              strupr( mid ) ;
	            }
	        }
	      else
	        FileCount-- ;
	    }
	  if( FileCount > 2 )
	    {
	      if( fnsplit( argv[FileCount], middrive, middir, NULL, NULL ) & FILENAME )
	        midname[0] = middrive[0] = middir[0] = 0 ;
	      else
	        FileCount-- ;
	    }
	  for( i = 0 ; i < FileCount ; i++ )
	    {
	      strupr( argv[i+1] ) ;
	      n = fnsplit( argv[i+1], drive, dir, musname, ext ) ;
	      if( !(n & EXTENSION) || !stricmp( ext, ".MUS" ) )
	        {
	          stat( argv[i+1], &s ) ;
	          if( !S_ISDIR( s.st_mode ) )
	            {
	              fnmerge( mus, drive, dir, musname, ".MUS" ) ;
	              if( line && !nodisplay )
	                System.out.println( "\n" ) ;
	              if( query )
	                {
	                  System.out.println( "Convert %s ? (Y=Yes,N=No,A=yes for All,Q=Quit)"
	                         " [Y]\b\b", mus ) ;
	                  fflush( stdout ) ;
	                  do
	                    n = toupper( getxkey() ) ;
	                  while( (n != 'Y') && (n != 'N') && (n != K_Return) 
	                        && (n != 'A') && (n != 'Q')) ;
	                  switch( n )
	                    {
	                    case 'N' :
	                      System.out.println( "N\n%s NOT converted.\n", mus ) ;
	                      line = 1 ;
	                      continue ;
	                      break ;
	                    case 'Q' :
	                      System.out.println( "Q\nQMUS2MID aborted.\n" ) ;
	                      exit( 0 ) ;
	                      break ;
	                    case 'A' :
	                      query = 0 ;
	                      System.out.println( "A\n" ) ;
	                      break ;
	                    default :
	                      System.out.println( "\n" ) ;
	                      break ;
	                    }
	                }
	              if( !midname[0] )
	                {
	                  fnmerge( mid, middrive, middir, musname, ".MID" ) ;
	                  strupr( mid ) ;
	                }
	              convert( mus, mid, nodisplay, div, size, nocomp, &ow ) ;
	              line = 1 ;
	            }
	        }
	    }
	  if( !line && !nodisplay && !query )
	    System.out.println( "Sorry, there is no MUS file matching...\n" ) ;
	  
	#else*/
	      //convert( mus, mid, nodisplay, div, size, nocomp, ow ) ;
/*	#endif*/

	  return 0;
	}


}

package s;

import static data.sounds.S_sfx;

import java.util.HashMap;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Semaphore;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;

import pooling.AudioChunkPool;
import data.sounds.sfxenum_t;
import doom.DoomStatus;

/**
 * A close recreation of the classic linux doom sound mixer.
 * 
 * PROS:
 * a) Very faithful to pitch and stereo effects, and original
 *    volume ramping.
 * b) Uses only one audioline and one playback thread
 * 
 * CONS:
 * a) May sound a bit off if production/consumption rates don't match
 * b) Sounds awful when mixing too many sounds together, just like the original.
 * 
 * @author Maes
 */

public class ClassicDoomSoundDriver extends AbstractSoundDriver
         {

    protected final Semaphore produce;

    protected final Semaphore consume;

    protected int chunk = 0;

    // protected FileOutputStream fos;
    // protected DataOutputStream dao;

    // The one and only line
    protected SourceDataLine line = null;

    protected HashMap<Integer, byte[]> cachedSounds =
        new HashMap<Integer, byte[]>();

    public ClassicDoomSoundDriver(DoomStatus<?,?> DS, int numChannels) {
    	super(DS,numChannels);
        channelleftvol_lookup = new int[numChannels][];
        channelrightvol_lookup = new int[numChannels][];
        channelstep = new int[numChannels];
        channelstepremainder = new int[numChannels];
        channels = new byte[numChannels][];
        p_channels = new int[numChannels];
        channelsend = new int[numChannels];
        produce = new Semaphore(1);
        consume = new Semaphore(1);
        produce.drainPermits();
        mixbuffer= new byte[MIXBUFFERSIZE];
    }

    /** The channel step amount... */
    protected final int[] channelstep;

    /** ... and a 0.16 bit remainder of last step. */
    protected final int[] channelstepremainder;

    /**
     * The channel data pointers, start and end. These were referred to as
     * "channels" in two different source files: s_sound.c and i_sound.c. In
     * s_sound.c they are actually channel_t (they are only informational). In
     * i_sound.c they are actual data channels.
     */
    protected byte[][] channels;

    /**
     * MAES: we'll have to use this for actual pointing. channels[] holds just
     * the data.
     */
    protected int[] p_channels;

    /**
     * The second one is supposed to point at "the end", so I'll make it an int.
     */
    protected int[] channelsend;

    /** Hardware left and right channel volume lookup. */
    protected final int[][] channelleftvol_lookup, channelrightvol_lookup;

    protected volatile boolean mixed = false;

    /**
     * This function loops all active (internal) sound channels, retrieves a
     * given number of samples from the raw sound data, modifies it according to
     * the current (internal) channel parameters, mixes the per channel samples
     * into the global mixbuffer, clamping it to the allowed range, and sets up
     * everything for transferring the contents of the mixbuffer to the (two)
     * hardware channels (left and right, that is). This function currently
     * supports only 16bit.
     */

    public void UpdateSound() {

        mixed = false;

        // Mix current sound data.
        // Data, from raw sound, for right and left.
        int sample = 0;
        int dl;
        int dr;

        // Pointers in global mixbuffer, left, right, end.
        // Maes: those were explicitly signed short pointers...

        int leftout;
        int rightout;
        int leftend;
        // Step in mixbuffer, left and right, thus two.
        int step;

        // Mixing channel index.
        int chan;

        // POINTERS to Left and right channel
        // which are in global mixbuffer, alternating.
        leftout = 0;
        rightout = 2;
        step = 4;

        // Determine end, for left channel only
        // (right channel is implicit).
        // MAES: this implies that the buffer will only mix
        // that many samples at a time, and that the size is just right.
        // Thus, it must be flushed (p_mixbuffer=0) before reusing it.
        leftend = SAMPLECOUNT * step;

        for (chan = 0; chan < numChannels; chan++) {
            if (channels[chan] != null)
                // SOME mixing has taken place.
                mixed = true;
        }

        // Mix sounds into the mixing buffer.
        // Loop over step*SAMPLECOUNT,
        // that is SAMPLECOUNT values for two channels.

        while (leftout < leftend) {
            // Reset left/right value.
            dl = 0;
            dr = 0;

            // Love thy L2 chache - made this a loop.
            // Now more channels could be set at compile time
            // as well. Thus loop those channels.

            for (chan = 0; chan < numChannels; chan++) {

                // if (D) System.err.printf("Checking channel %d\n",chan);
                // Check channel, if active.
                // MAES: this means that we must point to raw data here.
                if (channels[chan] != null) {
                    int channel_pointer = p_channels[chan];

                    // Get the raw data from the channel.
                    // Maes: this is supposed to be an 8-bit unsigned value.
                        sample = 0x00FF & channels[chan][channel_pointer];
                        
                    // Add left and right part for this channel (sound)
                    // to the current data. Adjust volume accordingly.                        
                    // Q: could this be optimized by converting samples to 16-bit
                    // at load time, while also allowing for stereo samples?
                    // A: Only for the stereo part. You would still look a lookup
                    // for the CURRENT volume level.

                    dl += channelleftvol_lookup[chan][sample];
                    dr += channelrightvol_lookup[chan][sample];

                    // This should increment the index inside a channel, but is
                    // expressed in 16.16 fixed point arithmetic.
                    channelstepremainder[chan] += channelstep[chan];

                    // The actual channel pointer is increased here.
                    // The above trickery allows playing back different pitches.
                    // The shifting retains only the integer part.
                    channel_pointer += channelstepremainder[chan] >> 16;

                    // This limits it to the "decimal" part in order to
                    // avoid undue accumulation.
                    channelstepremainder[chan] &= 0xFFFF;

                    // Check whether we are done. Also to avoid overflows.
                    if (channel_pointer >= channelsend[chan]) {
                        // Reset pointer for a channel.
                        if (D)
                            System.err
                                    .printf(
                                        "Channel %d handle %d pointer %d thus done, stopping\n",
                                        chan, this.channelhandles[chan],
                                        channel_pointer);
                        channels[chan] = null;
                        channel_pointer = 0;
                    }

                    // Write pointer back, so we know where a certain channel
                    // is the next time UpdateSounds is called.

                    p_channels[chan] = channel_pointer;
                }

            } // for all channels.

            // MAES: at this point, the actual values for a single sample
            // (YIKES!) are in d1 and d2. We must use the leftout/rightout
            // pointers to write them back into the mixbuffer.

            // Clamp to range. Left hardware channel.
            // Remnant of 8-bit mixing code? That must have raped ears
            // and made them bleed.
            // if (dl > 127) *leftout = 127;
            // else if (dl < -128) *leftout = -128;
            // else *leftout = dl;

            if (dl > 0x7fff)
                dl = 0x7fff;
            else if (dl < -0x8000)
                dl = -0x8000;

            // Write left channel
            mixbuffer[leftout] = (byte) ((dl & 0xFF00) >>> 8);
            mixbuffer[leftout + 1] = (byte) (dl & 0x00FF);

            // Same for right hardware channel.
            if (dr > 0x7fff)
                dr = 0x7fff;
            else if (dr < -0x8000)
                dr = -0x8000;

            // Write right channel.
            mixbuffer[rightout] = (byte) ((dr & 0xFF00) >>> 8);
            mixbuffer[rightout + 1] = (byte) (dr & 0x00FF);

            // Increment current pointers in mixbuffer.
            leftout += 4;
            rightout += 4;
        } // End leftend/leftout while

        // Q: how do we know whether the mixbuffer isn't entirely used
        // and instead it has residual garbage samples in it?
        // A: DOOM kind of padded samples in memory, so presumably
        // they all played silence.
        // Q: what's the purpose of channelremainder etc?
        // A: pitch variations were done with fractional pointers 16.16
        // style.

    }

    /**
     * SFX API Note: this was called by S_Init. However, whatever they did in
     * the old DPMS based DOS version, this were simply dummies in the Linux
     * version. See soundserver initdata().
     */

    @Override
    public void SetChannels(int numChannels) {
        // Init internal lookups (raw data, mixing buffer, channels).
        // This function sets up internal lookups used during
        // the mixing process.

        int steptablemid = 128;

        // Okay, reset internal mixing channels to zero.
        for (int i = 0; i < this.numChannels; i++) {
            channels[i] = null;
        }
        
        generateStepTable(steptablemid);

        generateVolumeLUT();
    }
    
    protected MixServer SOUNDSRV;

    protected Thread SOUNDTHREAD;

    @Override
    public boolean InitSound() {

        // Secure and configure sound device first.
        System.out.println("I_InitSound: ");

        // We only need a single data line.
        // PCM, signed, 16-bit, stereo, 22025 KHz, 2048 bytes per "frame",
        // maximum of 44100/2048 "fps"
        AudioFormat format = new AudioFormat(SAMPLERATE, 16, 2, true, true);

        DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

        if (AudioSystem.isLineSupported(info))
            try {
                line = (SourceDataLine) AudioSystem.getSourceDataLine(format);
                line.open(format,AUDIOLINE_BUFFER);
            } catch (Exception e) {
                e.printStackTrace();
                System.err.print("Could not play signed 16 data\n");
                return false;
            }

        if (line != null) {
            System.err.print(" configured audio device\n");
            line.start();
        } else {
        	 System.err.print(" could not configure audio device\n");
        	 return false;
        }

        // This was here only for debugging purposes
        /*
         * try { fos=new FileOutputStream("test.raw"); dao=new
         * DataOutputStream(fos); } catch (FileNotFoundException e) {
         * Auto-generated catch block e.printStackTrace(); }
         */

        SOUNDSRV = new MixServer(line);
        SOUNDTHREAD = new Thread(SOUNDSRV);
        SOUNDTHREAD.start();

        // Initialize external data (all sounds) at start, keep static.
        System.err.print("I_InitSound: ");

        super.initSound8();

        System.err.print(" pre-cached all sound data\n");

        // Now initialize mixbuffer with zero.
        initMixBuffer();

        // Finished initialization.
        System.err.print("I_InitSound: sound module ready\n");

        return true;
    }


    @Override
    protected int addsfx(int sfxid, int volume, int step, int seperation) {
        int i;
        int rc = -1;

        int oldest = DS.gametic;
        int oldestnum = 0;
        int slot;

        int rightvol;
        int leftvol;

        int broken=-1;
        
        // Chainsaw troubles.
        // Play these sound effects only one at a time.
        if ((sfxid >= sfxenum_t.sfx_sawup.ordinal()
                && sfxid <= sfxenum_t.sfx_sawhit.ordinal())
                || sfxid == sfxenum_t.sfx_stnmov.ordinal()
                || sfxid == sfxenum_t.sfx_pistol.ordinal()) {
            // Loop all channels, check.
            for (i = 0; i < numChannels; i++) {
                // Active, and using the same SFX?
                if ((channels[i] != null) && (channelids[i] == sfxid)) {
                    // Reset.
                    this.p_channels[i] = 0;
                    this.channels[i]=null;
                    // We are sure that iff,
                    // there will only be one.
                    broken=i;
                    break;
                }
            }
        }

        // Loop all channels to find oldest SFX.
        if (broken>=0) {
        	i=broken;
        	oldestnum=broken;
        }
        else
        for (i = 0; (i < numChannels) && (channels[i] != null); i++) {
            if (channelstart[i] < oldest) {
                oldestnum = i;
            }
        }

        oldest = channelstart[oldestnum];
        
        // Tales from the cryptic.
        // If we found a channel, fine.
        // If not, we simply overwrite the first one, 0.
        // Probably only happens at startup.
        if (i == numChannels)
            slot = oldestnum;
        else
            slot = i;

        // Okay, in the less recent channel,
        // we will handle the new SFX.
        // Set pointer to raw data.
        channels[slot] = S_sfx[sfxid].data;

        // MAES: if you don't zero-out the channel pointer here, it gets ugly
        p_channels[slot] = 0;

        // Set pointer to end of raw data.
        channelsend[slot] = lengths[sfxid];

        // Reset current handle number, limited to 0..100.
        if (handlenums == 0) // was !handlenums, so it's actually 1...100?
            handlenums = 100;

        // Assign current handle number.
        // Preserved so sounds could be stopped (unused).
        // Maes: this should really be decreasing, otherwide handles
        // should start at 0 and go towards 100. Just saying.
        channelhandles[slot] = rc = handlenums--;

        // Set stepping???
        // Kinda getting the impression this is never used.
        // MAES: you're wrong amigo.
        channelstep[slot] = step;
        // ???
        channelstepremainder[slot] = 0;
        // Should be gametic, I presume.
        channelstart[slot] = DS.gametic;

        // Separation, that is, orientation/stereo.
        // range is: 1 - 256
        seperation += 1;

        // Per left/right channel.
        // x^2 seperation,
        // adjust volume properly.
        leftvol = volume - ((volume * seperation * seperation) >> 16); // /(256*256);
        seperation = seperation - 257;
        rightvol = volume - ((volume * seperation * seperation) >> 16);

        // Sanity check, clamp volume.
        // Maes: better to clamp than to crash, no?

        if (rightvol < 0) rightvol=0;
        if (rightvol >127) rightvol=127;
        if (leftvol < 0) leftvol=0;
        if (leftvol >127) leftvol=127;

        // Get the proper lookup table piece
        // for this volume level???
        channelleftvol_lookup[slot] = vol_lookup[leftvol];
        channelrightvol_lookup[slot] = vol_lookup[rightvol];

        // Preserve sound SFX id,
        // e.g. for avoiding duplicates of chainsaw.
        channelids[slot] = sfxid;

        if (D) System.err.println(channelStatus());
        if (D) System.err.printf(
                "Playing sfxid %d handle %d length %d vol %d on channel %d\n",
                sfxid, rc, S_sfx[sfxid].data.length, volume, slot);

        // You tell me.
        return rc;
    }

    @Override
    public void ShutdownSound() {

        boolean done = false;

        // Unlock sound thread if it's waiting.
        produce.release();

        int i;
        while (!done) {
            for (i = 0; i < numChannels && (channels[i] == null); i++) {

            }

            // System.err.printf("%d channels died off\n",i);

            UpdateSound();
            SubmitSound();
            if (i == numChannels)
                done = true;
        }

        this.line.drain();
        SOUNDSRV.terminate = true;
        produce.release();

        try {
            SOUNDTHREAD.join();
        } catch (InterruptedException e) {
        	// Well, I don't care.
        }
        line.close();

    }

    protected class MixServer
            implements Runnable {

        public boolean terminate = false;

        public MixServer(SourceDataLine line) {
            this.auline = line;
        }

        private SourceDataLine auline;

        private ArrayBlockingQueue<AudioChunk> audiochunks =
            new ArrayBlockingQueue<AudioChunk>(BUFFER_CHUNKS * 2);

        public void addChunk(AudioChunk chunk) {
            audiochunks.offer(chunk);
        }

        public volatile int currstate = 0;

        public void run() {

            while (!terminate) {

                // while (timing[mixstate]<=mytime){

                // Try acquiring a produce permit before going on.

                try {
                    // System.err.println("Waiting for a permit...");
                    produce.acquire();
                    // System.err.println("Got a permit");
                } catch (InterruptedException e) {
                    // Well, ouch.
                    e.printStackTrace();
                }

                int chunks = 0;

                // System.err.printf("Audio queue has %d chunks\n",audiochunks.size());

                // Play back only at most a given number of chunks once you reach
                // this spot
                
                int atMost=Math.min(ISoundDriver.BUFFER_CHUNKS,audiochunks.size());
                
                while (atMost-->0){

                    AudioChunk chunk = null;
                    try {
                        chunk = audiochunks.take();
                    } catch (InterruptedException e1) {
                        // Should not block
                    }
                    // Play back all chunks present in a buffer ASAP
                    auline.write(chunk.buffer, 0, MIXBUFFERSIZE);
                    chunks++;
                    // No matter what, give the chunk back!
                    chunk.free = true;
                    audiochunkpool.checkIn(chunk);
                }

                // Signal that we consumed a whole buffer and we are ready for
                // another one.
                
                consume.release();
            }
        }
    }

    @Override
    public boolean SoundIsPlaying(int handle) {

        int c = getChannelFromHandle(handle);
        return (c != -2 && channels[c] == null);

    }

    /**
     * Internal use.
     * 
     * @param handle
     * @return the channel that has the handle, or -2 if none has it.
     */
    protected int getChannelFromHandle(int handle) {
        // Which channel has it?
        for (int i = 0; i < numChannels; i++) {
            if (channelhandles[i] == handle)
                return i;
        }

        return BUSY_HANDLE;
    }

    @Override
    public void StopSound(int handle) {
        // Which channel has it?
        int hnd = getChannelFromHandle(handle);
        if (hnd >= 0) {
            channels[hnd] = null;
            p_channels[hnd] = 0;
            this.channelhandles[hnd] = IDLE_HANDLE;
        }
    }

    @Override
    public void SubmitSound() {

        // It's possible for us to stay silent and give the audio
        // queue a chance to get drained.
        if (mixed) {
            silence=0;
            AudioChunk gunk = audiochunkpool.checkOut();
            // Ha ha you're ass is mine!
            gunk.free = false;

            // System.err.printf("Submitted sound chunk %d to buffer %d \n",chunk,mixstate);

            // Copy the currently mixed chunk into its position inside the
            // master buffer.
            System.arraycopy(mixbuffer, 0, gunk.buffer, 0, MIXBUFFERSIZE);

            this.SOUNDSRV.addChunk(gunk);

            // System.err.println(chunk++);

            chunk++;
            // System.err.println(chunk);

            if (consume.tryAcquire())
                produce.release();

        } else {
            silence++;
            // MAES: attempt to fix lingering noise error
            if (silence >ISoundDriver.BUFFER_CHUNKS*5){
                line.flush();
                silence=0;
                }
            // System.err.println("SILENT_CHUNK");
            // this.SOUNDSRV.addChunk(SILENT_CHUNK);
        }
        // line.write(mixbuffer, 0, mixbuffer.length);

    }
    
    private int silence=0; 

    @Override
    public void UpdateSoundParams(int handle, int vol, int sep, int pitch) {

        int chan = this.getChannelFromHandle(handle);
        // Per left/right channel.
        // x^2 seperation,
        // adjust volume properly.
        int leftvol = vol - ((vol * sep * sep) >> 16); // /(256*256);
        sep = sep - 257;
        int rightvol = vol - ((vol * sep * sep) >> 16);

        // Sanity check, clamp volume.

        if (rightvol < 0 || rightvol > 127)
            DS.I.Error("rightvol out of bounds");

        if (leftvol < 0 || leftvol > 127)
            DS.I.Error("leftvol out of bounds");

        // Get the proper lookup table piece
        // for this volume level???
        channelleftvol_lookup[chan] = vol_lookup[leftvol];
        channelrightvol_lookup[chan] = vol_lookup[rightvol];

        // Well, if you can get pitch to change too...
        this.channelstep[chan] = steptable[pitch];
        channelsend[chan] = this.lengths[this.channelids[chan]];

    }

    protected StringBuilder sb = new StringBuilder();

    public String channelStatus() {
        sb.setLength(0);
        for (int i = 0; i < numChannels; i++) {
            if (channels[i] != null)
                sb.append(i);
            else
                sb.append('-');
        }

        return sb.toString();

    }

    protected final AudioChunk SILENT_CHUNK = new AudioChunk();

    protected final AudioChunkPool audiochunkpool = new AudioChunkPool();
}

package s;

import data.sfxinfo_t;
import data.sounds.sfxenum_t;
import static data.Defines.TICRATE;

//Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: ISoundDriver.java,v 1.1 2012/11/08 17:12:42 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// DESCRIPTION:
// System interface, sound. Anything implementation-specific should
// implement this.
//
//-----------------------------------------------------------------------------

public interface ISoundDriver {

	
	public static final int VOLUME_STEPS = 128;
	public static final int PANNING_STEPS = 256;
	public static final int IDLE_HANDLE = -1;
	public static final int BUSY_HANDLE = -2;
	// Needed for calling the actual sound output
	// We mix 1024 samples each time, but we only call UpdateSound()
	// 1 time out of three.
	
	public static final int NUM_CHANNELS	=	8;
	// It is 2 for 16bit, and 2 for two channels.
	public static final int BUFMUL            =      4;

	public static final int SAMPLERATE	=	22050;	// Hz
	
	// Update all 30 millisecs, approx. 30fps synchronized.
	// Linux resolution is allegedly 10 millisecs,
	//  scale is microseconds.
	public static final int SOUND_INTERVAL =    500;
	
	/** Yes, it's possible to select a different sound frame rate */
	
	public static final int SND_FRAME_RATE =21;
	// Was 512, but if you mix that many samples per tic you will
	// eventually outrun the buffer :-/ I fail to see the mathematical
	// justification behind this, unless they simply wanted the buffer to 
	// be a nice round number in size.
	public static final int SAMPLECOUNT		=SAMPLERATE/SND_FRAME_RATE;
	public static final int MIXBUFFERSIZE		=(SAMPLECOUNT*BUFMUL);
	public static final int SAMPLESIZE	=	16 ;  	// 16bit
	public static final int NUMSFX	=	sfxenum_t.NUMSFX.ordinal() ; 
	public static final int MAXHANDLES = 100;
	/** How many audio chunks/frames to mix before submitting them to
	 *  the output.
	 */
	public static final int BUFFER_CHUNKS=5;
	
	/** Ths audio buffer size of the audioline itself. 
	 *  Increasing this is the only effective way to combat output stuttering on
	 *  slower machines.
	 */
	public static final int AUDIOLINE_BUFFER=2*BUFFER_CHUNKS*MIXBUFFERSIZE;
	public static final int SOUND_PERIOD = 1000/SND_FRAME_RATE; // in ms
	
	/** Init at program start. Return false if device invalid,
	 *  so that caller can decide best course of action. 
	 *  The suggested one is to swap the sound "driver" for a dummy.
	 *  
	 * @return
	 */
	boolean InitSound();

	// ... update sound buffer and audio device at runtime...
	void UpdateSound();
	void SubmitSound();

	// ... shut down and relase at program termination.
	void ShutdownSound();


	//
	//  SFX I/O
	//

	// Initialize channels?
	void SetChannels(int numChannels);

	// Get raw data lump index for sound descriptor.
	int GetSfxLumpNum (sfxinfo_t sfxinfo );


	// Starts a sound in a particular sound channel.
	int StartSound
	( int		id,
	  int		vol,
	  int		sep,
	  int		pitch,
	  int		priority );


	// Stops a sound channel.
	void StopSound(int handle);

	/** Called by S_*() functions to see if a channel is still playing.
	    Returns false if no longer playing, true if playing. This is 
	    a relatively "high level" function, so its accuracy relies on
	    what the "system specific" sound code reports back */
	boolean SoundIsPlaying(int handle);

	/* Updates the volume, separation,
	   and pitch of a sound channel. */
	void UpdateSoundParams
	( int		handle,
	  int		vol,
	  int		sep,
	  int		pitch );
	
}

package s;

import w.DoomBuffer;
import doom.DoomStatus;

/** A variation of the Classic Sound Driver, decoding the DP-lumps
 *  instead of the DS. A better way would be to build-in an 
 *  automatic "WAV to SPEAKER" conversion, but that can wait...
 * 
 * @author Maes
 *
 */

public class SpeakerDoomSoundDriver extends ClassicDoomSoundDriver {

    public SpeakerDoomSoundDriver(DoomStatus DS, int numChannels) {
        super(DS, numChannels);
        // TODO Auto-generated constructor stub
    }
	
    /** Rigged so it gets SPEAKER sounds instead of regular ones */
    
    @Override
    protected byte[] getsfx
    ( String         sfxname,
            int[]          len, int index )
    {
        byte[]      sfx;
        byte[]      paddedsfx;
        int                 i;
        int                 size;
        int                 paddedsize;
        String                name;
        int                 sfxlump;

        // Get the sound data from the WAD, allocate lump
        //  in zone memory.
        name=String.format("dp%s", sfxname).toUpperCase();

        // Now, there is a severe problem with the
        //  sound handling, in it is not (yet/anymore)
        //  gamemode aware. That means, sounds from
        //  DOOM II will be requested even with DOOM
        //  shareware.
        // The sound list is wired into sounds.c,
        //  which sets the external variable.
        // I do not do runtime patches to that
        //  variable. Instead, we will use a
        //  default sound for replacement.
        if ( DS.W.CheckNumForName(name) == -1 )
            sfxlump = DS.W.GetNumForName("dppistol");
        else
            sfxlump = DS.W.GetNumForName(name);

        // We must first load and convert it to raw samples.
        
        SpeakerSound SP=(SpeakerSound) DS.W.CacheLumpNum(sfxlump, 0,SpeakerSound.class);
        
        sfx = SP.toRawSample();
        
        size = sfx.length;

        // MAES: A-ha! So that's how they do it.
        // SOund effects are padded to the highest multiple integer of 
        // the mixing buffer's size (with silence)

        paddedsize = ((size-8 + (SAMPLECOUNT-1)) / SAMPLECOUNT) * SAMPLECOUNT;

        // Allocate from zone memory.
        paddedsfx = new byte[paddedsize];

        // Now copy and pad. The first 8 bytes are header info, so we discard them.
        System.arraycopy(sfx,8, paddedsfx, 0,size-8 );
        
        for (i=size-8 ; i<paddedsize ; i++)
            paddedsfx[i] = (byte) 127;

        
        
        // Hmm....silence?
        for (i=size-8 ; i<paddedsize ; i++)
            paddedsfx[i] = (byte) 127;

        // Remove the cached lump.
        DS.W.UnlockLumpNum(sfxlump);

        if (D) System.out.printf("SFX %d size %d padded to %d\n",index,size,paddedsize);
        // Preserve padded length.
        len[index] = paddedsize;

        // Return allocated padded data.
        // So the first 8 bytes are useless?
        return paddedsfx;
    }

}

package p;

import doom.think_t;
import rr.SectorAction;
import rr.line_t;
import rr.sector_t;

public class slidedoor_t extends SectorAction {
	    sdt_e	type;
	    line_t	line;
	    int		frame;
	    int		whichDoorIndex;
	    int		timer;
	    sector_t	frontsector;
	    sector_t	backsector;
	    sd_e	 status;
	    
	    public slidedoor_t(){
	    	type=sdt_e.sdt_closeOnly;
	    	status=sd_e.sd_closing;
	    	function=think_t.T_SlidingDoor;
	    }

	}
package p;

import java.io.IOException;

import i.DoomStatusAware;
import rr.subsector_t;
import defines.skill_t;

public interface ILevelLoader extends DoomStatusAware {

	// Lump order in a map WAD: each map needs a couple of lumps
    // to provide a complete scene geometry description.

    public static final int ML_LABEL = 0;

    /** A separator, name, ExMx or MAPxx */
    public static final int ML_THINGS = 1;

    /** Monsters, items.. */
    public static final int ML_LINEDEFS = 2;

    /** LineDefs, from editing */
    public static final int ML_SIDEDEFS = 3;

    /** SideDefs, from editing */
    public static final int ML_VERTEXES = 4;

    /** Vertices, edited and BSP splits generated */
    public static final int ML_SEGS = 5;

    /** LineSegs, from LineDefs split by BSP */
    public static final int ML_SSECTORS = 6;

    /** SubSectors, list of LineSegs */
    public static final int ML_NODES = 7;

    /** BSP nodes */
    public static final int ML_SECTORS = 8;

    /** Sectors, from editing */
    public static final int ML_REJECT = 9;

    /** LUT, sector-sector visibility */
    public static final int ML_BLOCKMAP = 10;
    
    // Maintain single and multi player starting spots.
    public static final int MAX_DEATHMATCH_STARTS  = 10;

    /** Expected lump names for verification */
    public static final String[] LABELS={"MAPNAME","THINGS","LINEDEFS","SIDEDEFS",
                                        "VERTEXES","SEGS","SSECTORS","NODES",
                                        "SECTORS","REJECT","BLOCKMAP"};

    /** P_SetupLevel 
     * 
     * @param episode
     * @param map
     * @param playermask
     * @param skill
     * @throws IOException 
     */
	void SetupLevel(int episode, int map, int playermask, skill_t skill) throws IOException;

	/**
	 * P_SetThingPosition Links a thing into both a block and a subsector based
	 * on it's x y. Sets thing.subsector properly
	 *
	 * 
	 * @param thing
	 */
	void SetThingPosition(mobj_t thing);

	  /**
	   * R_PointInSubsector
	   * 
	   * MAES: it makes more sense to have this here.
	   * 
	   * @param x fixed
	   * @param y fixed
	   * 
	   */
	
	subsector_t PointInSubsector(int x, int y);
        
	
}

package p;

public enum floor_e {
    // lower floor to highest surrounding floor
    lowerFloor,
    
    // lower floor to lowest surrounding floor
    lowerFloorToLowest,
    
    // lower floor to highest surrounding floor VERY FAST
    turboLower,
    
    // raise floor to lowest surrounding CEILING
    raiseFloor,
    
    // raise floor to next highest surrounding floor
    raiseFloorToNearest,

    // raise floor to shortest height texture around it
    raiseToTexture,
    
    // lower floor to lowest surrounding floor
    //  and change floorpic
    lowerAndChange,
  
    raiseFloor24,
    raiseFloor24AndChange,
    raiseFloorCrush,

     // raise to next highest floor, turbo-speed
    raiseFloorTurbo,       
    donutRaise,
    raiseFloor512
    
}

package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import w.DoomIO;
import w.IPackableDoomObject;
import w.IReadableDoomObject;
import data.state_t;

public class pspdef_t implements IReadableDoomObject,IPackableDoomObject{

    public pspdef_t(){
        state=new state_t();
    }

    /** a NULL state means not active */
    public state_t	state;	
    public int		tics;
    /** fixed_t */
    public int	sx, sy;
    // When read from disk.
    public int readstate;
    
    @Override
    public void read(DataInputStream f) throws IOException {
        //state=data.info.states[f.readLEInt()];
        readstate=DoomIO.readLEInt(f);
        tics=DoomIO.readLEInt(f);
        sx=DoomIO.readLEInt(f);
        sy=DoomIO.readLEInt(f);
    }
    
    @Override
    public void pack(ByteBuffer f) throws IOException {
        if (state==null) f.putInt(0);
        else f.putInt(state.id);
        f.putInt(tics);
        f.putInt(sx);
        f.putInt(sy);
    }

}

package p;

import static data.Defines.BLOCKMAPPADDING;
import static data.Defines.MAPBLOCKSHIFT;
import static data.Defines.MAPBLOCKUNITS;
import static data.Defines.NF_SUBSECTOR;
import static data.Defines.PU_LEVEL;
import static m.fixed_t.FRACBITS;
import static p.mobj_t.MF_NOBLOCKMAP;
import static p.mobj_t.MF_NOSECTOR;
import static utils.C2JUtils.flags;
import m.BBox;
import i.IDoomSystem;
import rr.Renderer;
import rr.TextureManager;
import rr.line_t;
import rr.node_t;
import rr.sector_t;
import rr.seg_t;
import rr.side_t;
import rr.subsector_t;
import rr.vertex_t;
import s.IDoomSound;
import utils.C2JUtils;
import v.DoomVideoRenderer;
import w.IWadLoader;
import data.Limits;
import data.mapthing_t;
import doom.DoomStatus;

/**
 * The idea is to lump common externally readable properties that need DIRECT
 * ACCESS (aka not behindsetters/getters) here, as well as some common shared
 * internal structures/status objects. If you need access to stuff like the
 * blockmap/reject table etc. then you should ask for this class. If you only
 * need access to some methods like e.g. SetupLevel, you can simply use the
 * ILevelLoader interface.
 * 
 * @author velktron
 */

public abstract class AbstractLevelLoader
        implements ILevelLoader {

    // ///////////////// Status objects ///////////////////

    IDoomSystem I;

    IWadLoader W;

    DoomStatus<?,?> DM;

    DoomVideoRenderer<?,?> V;

    Renderer<?,?> R;

    TextureManager<?> TM;

    Actions P;

    IDoomSound S;

    //
    // MAP related Lookup tables.
    // Store VERTEXES, LINEDEFS, SIDEDEFS, etc.
    //
    public int numvertexes;

    public vertex_t[] vertexes;

    public int numsegs;

    public seg_t[] segs;

    public int numsectors;

    public sector_t[] sectors;

    public int numsubsectors;

    public subsector_t[] subsectors;

    public int numnodes;

    public node_t[] nodes;

    public int numlines;

    public line_t[] lines;

    public int numsides;

    public side_t[] sides;

    // BLOCKMAP
    // Created from axis aligned bounding box
    // of the map, a rectangular array of
    // blocks of size ...
    // Used to speed up collision detection
    // by spatial subdivision in 2D.
    //
    /** Blockmap size. */
    protected int bmapwidth, bmapheight; // size in mapblocks

    /**
     * killough 3/1/98: remove blockmap limit internally. Maes 29/9/2011: Header
     * stripped during loading and pointers pre-modified, so there's no double
     * arraying.
     */
    public int[] blockmap; // was short -- killough

    /**
     * Maes 29/9/2011: Used only during loading. No more dichotomy with
     * blockmap.
     */
    protected int[] blockmaplump; // was short -- killough

    /** (fixed_t) origin of block map */
    public int bmaporgx, bmaporgy;

    /** for thing chains */
    public mobj_t[] blocklinks;

    /**
     * REJECT For fast sight rejection. Speeds up enemy AI by skipping detailed
     * LineOf Sight calculation. Without special effect, this could be used as a
     * PVS lookup as well.
     */

    protected byte[] rejectmatrix;

    // Maintain single and multi player starting spots.

    // 1/11/98 killough: Remove limit on deathmatch starts
    protected mapthing_t[] deathmatchstarts; // killough

    protected int num_deathmatchstarts; // killough

    // mapthing_t* deathmatch_p;
    protected int deathmatch_p;

    protected mapthing_t[] playerstarts = new mapthing_t[Limits.MAXPLAYERS];

    public AbstractLevelLoader(DoomStatus<?,?> DC) {
        this.updateStatus(DC);
    }

    @Override
    public void updateStatus(DoomStatus<?,?> DC) {
        this.W = DC.W;
        this.DM = DC;
        this.P = DC.P;
        this.R = DC.R;
        this.I = DC.I;
        this.S = DC.S;
        this.TM = DC.TM;

    }

    /**
     * P_SetThingPosition Links a thing into both a block and a subsector based
     * on it's x y. Sets thing.subsector properly
     */

    @Override
    public void SetThingPosition(mobj_t thing) {
        final subsector_t ss;
        final sector_t sec;
        int blockx;
        int blocky;
        final mobj_t link;

        // link into subsector
        ss = PointInSubsector(thing.x, thing.y);
        thing.subsector = ss;

        if (!flags(thing.flags, MF_NOSECTOR)) {
            // invisible things don't go into the sector links
            sec = ss.sector;

            thing.sprev = null;
            thing.snext = sec.thinglist;

            if (sec.thinglist != null)
                sec.thinglist.sprev = thing;

            sec.thinglist = thing;
        }

        // link into blockmap
        if (!flags(thing.flags, MF_NOBLOCKMAP)) {
            // inert things don't need to be in blockmap
            blockx = getSafeBlockX(thing.x - bmaporgx);
            blocky = getSafeBlockY(thing.y - bmaporgy);
            
            // Valid block?
            if (blockx >= 0 && blockx < bmapwidth && blocky >= 0
                    && blocky < bmapheight) {

                // Get said block.
                link = blocklinks[blocky * bmapwidth + blockx];
                thing.bprev = null; // Thing is put at head of block...
                thing.bnext = link;
                if (link != null) // block links back at thing...
                    // This will work
                    link.bprev = thing;

                // "thing" is now effectively the new head
                // Iterators only follow "bnext", not "bprev".
                // If link was null, then thing is the first entry.
                blocklinks[blocky * bmapwidth + blockx] = thing;
            } else {
                // thing is off the map
                thing.bnext = thing.bprev = null;
            }
        }

    }

    @Override
    public subsector_t PointInSubsector(int x, int y) {
        node_t node;
        int side;
        int nodenum;

        // single subsector is a special case
        if (numnodes == 0)
            return subsectors[0];
        
        nodenum = numnodes - 1;
        
        while ((nodenum & NF_SUBSECTOR) == 0) {
            node = nodes[nodenum];
            side = node.PointOnSide(x, y);
            nodenum = node.children[side];
        }

        return subsectors[nodenum & ~NF_SUBSECTOR];
    }

    //
    // jff 10/6/98
    // New code added to speed up calculation of internal blockmap
    // Algorithm is order of nlines*(ncols+nrows) not nlines*ncols*nrows
    //

    protected static final int blkshift = 7; /*
                                              * places to shift rel position for
                                              * cell num
                                              */

    protected static final int blkmask = ((1 << blkshift) - 1);/*
                                                                * mask for rel
                                                                * position
                                                                * within cell
                                                                */

    protected static final int blkmargin = 0; /* size guardband around map used */

    // jff 10/8/98 use guardband>0
    // jff 10/12/98 0 ok with + 1 in rows,cols

    protected class linelist_t // type used to list lines in each block
    {
        public int num;

        public linelist_t next;
    }

    /**
     * Subroutine to add a line number to a block list It simply returns if the
     * line is already in the block
     * 
     * @param lists
     * @param count
     * @param done
     * @param blockno
     * @param lineno
     */
    private final void AddBlockLine(linelist_t[] lists, int[] count,
            boolean[] done, int blockno, int lineno) {
        long a=System.nanoTime();
        linelist_t l;

        if (done[blockno])
            return;

        l = new linelist_t();
        l.num = lineno;
        l.next = lists[blockno];
        lists[blockno] = l;
        count[blockno]++;
        done[blockno] = true;
        long b=System.nanoTime();
        
        total+=(b-a);
    }

    long total=0;
    
    /**
     * Actually construct the blockmap lump from the level data This finds the
     * intersection of each linedef with the column and row lines at the left
     * and bottom of each blockmap cell. It then adds the line to all block
     * lists touching the intersection. MAES 30/9/2011: Converted to Java. It's
     * important that LINEDEFS and VERTEXES are already read-in and defined, so
     * it is necessary to change map lump ordering for this to work.
     */

    protected final void CreateBlockMap() {
        int xorg, yorg; // blockmap origin (lower left)
        int nrows, ncols; // blockmap dimensions
        linelist_t[] blocklists = null; // array of pointers to lists of lines
        int[] blockcount = null; // array of counters of line lists
        boolean[] blockdone = null; // array keeping track of blocks/line
        int NBlocks; // number of cells = nrows*ncols
        int linetotal = 0; // total length of all blocklists
        int map_minx = Integer.MAX_VALUE; // init for map limits search
        int map_miny = Integer.MAX_VALUE;
        int map_maxx = Integer.MIN_VALUE;
        int map_maxy = Integer.MIN_VALUE;

        long a = System.nanoTime();

        // scan for map limits, which the blockmap must enclose

        for (int i = 0; i < numvertexes; i++) {
            int t;

            if ((t = vertexes[i].x) < map_minx)
                map_minx = t;
            else if (t > map_maxx)
                map_maxx = t;
            if ((t = vertexes[i].y) < map_miny)
                map_miny = t;
            else if (t > map_maxy)
                map_maxy = t;
        }
        map_minx >>= FRACBITS; // work in map coords, not fixed_t
        map_maxx >>= FRACBITS;
        map_miny >>= FRACBITS;
        map_maxy >>= FRACBITS;

        // set up blockmap area to enclose level plus margin

        xorg = map_minx - blkmargin;
        yorg = map_miny - blkmargin;
        ncols = (map_maxx + blkmargin - xorg + 1 + blkmask) >> blkshift; // jff
                                                                         // 10/12/98
        nrows = (map_maxy + blkmargin - yorg + 1 + blkmask) >> blkshift; // +1
                                                                         // needed
                                                                         // for
        NBlocks = ncols * nrows; // map exactly 1 cell

        // create the array of pointers on NBlocks to blocklists
        // also create an array of linelist counts on NBlocks
        // finally make an array in which we can mark blocks done per line

        // CPhipps - calloc's
        blocklists = new linelist_t[NBlocks];
        blockcount = new int[NBlocks];
        blockdone = new boolean[NBlocks];

        // initialize each blocklist, and enter the trailing -1 in all
        // blocklists
        // note the linked list of lines grows backwards

        for (int i = 0; i < NBlocks; i++) {
            blocklists[i] = new linelist_t();
            blocklists[i].num = -1;
            blocklists[i].next = null;
            blockcount[i]++;
        }

        // For each linedef in the wad, determine all blockmap blocks it
        // touches,
        // and add the linedef number to the blocklists for those blocks

        for (int i = 0; i < numlines; i++) {
            int x1 = lines[i].v1x >> FRACBITS; // lines[i] map coords
            int y1 = lines[i].v1y >> FRACBITS;
            int x2 = lines[i].v2x >> FRACBITS;
            int y2 = lines[i].v2y >> FRACBITS;
            int dx = x2 - x1;
            int dy = y2 - y1;
            boolean vert = dx == 0; // lines[i] slopetype
            boolean horiz = dy == 0;
            boolean spos = (dx ^ dy) > 0;
            boolean sneg = (dx ^ dy) < 0;
            int bx, by; // block cell coords
            int minx = x1 > x2 ? x2 : x1; // extremal lines[i] coords
            int maxx = x1 > x2 ? x1 : x2;
            int miny = y1 > y2 ? y2 : y1;
            int maxy = y1 > y2 ? y1 : y2;

            // no blocks done for this linedef yet

            C2JUtils.memset(blockdone, false, NBlocks);

            // The line always belongs to the blocks containing its endpoints

            bx = (x1 - xorg) >> blkshift;
            by = (y1 - yorg) >> blkshift;
            AddBlockLine(blocklists, blockcount, blockdone, by * ncols + bx, i);
            bx = (x2 - xorg) >> blkshift;
            by = (y2 - yorg) >> blkshift;
            AddBlockLine(blocklists, blockcount, blockdone, by * ncols + bx, i);

            // For each column, see where the line along its left edge, which
            // it contains, intersects the Linedef i. Add i to each
            // corresponding
            // blocklist.

            if (!vert) // don't interesect vertical lines with columns
            {
                for (int j = 0; j < ncols; j++) {
                    // intersection of Linedef with x=xorg+(j<<blkshift)
                    // (y-y1)*dx = dy*(x-x1)
                    // y = dy*(x-x1)+y1*dx;

                    int x = xorg + (j << blkshift); // (x,y) is intersection
                    int y = (dy * (x - x1)) / dx + y1;
                    int yb = (y - yorg) >> blkshift; // block row number
                    int yp = (y - yorg) & blkmask; // y position within block

                    if (yb < 0 || yb > nrows - 1) // outside blockmap, continue
                        continue;

                    if (x < minx || x > maxx) // line doesn't touch column
                        continue;

                    // The cell that contains the intersection point is always
                    // added

                    AddBlockLine(blocklists, blockcount, blockdone, ncols * yb
                            + j, i);

                    // if the intersection is at a corner it depends on the
                    // slope
                    // (and whether the line extends past the intersection)
                    // which
                    // blocks are hit

                    if (yp == 0) // intersection at a corner
                    {
                        if (sneg) // \ - blocks x,y-, x-,y
                        {
                            if (yb > 0 && miny < y)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * (yb - 1) + j, i);
                            if (j > 0 && minx < x)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * yb + j - 1, i);
                        } else if (spos) // / - block x-,y-
                        {
                            if (yb > 0 && j > 0 && minx < x)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * (yb - 1) + j - 1, i);
                        } else if (horiz) // - - block x-,y
                        {
                            if (j > 0 && minx < x)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * yb + j - 1, i);
                        }
                    } else if (j > 0 && minx < x) // else not at corner: x-,y
                        AddBlockLine(blocklists, blockcount, blockdone, ncols
                                * yb + j - 1, i);
                }
            }

            // For each row, see where the line along its bottom edge, which
            // it contains, intersects the Linedef i. Add i to all the
            // corresponding
            // blocklists.

            if (!horiz) {
                for (int j = 0; j < nrows; j++) {
                    // intersection of Linedef with y=yorg+(j<<blkshift)
                    // (x,y) on Linedef i satisfies: (y-y1)*dx = dy*(x-x1)
                    // x = dx*(y-y1)/dy+x1;

                    int y = yorg + (j << blkshift); // (x,y) is intersection
                    int x = (dx * (y - y1)) / dy + x1;
                    int xb = (x - xorg) >> blkshift; // block column number
                    int xp = (x - xorg) & blkmask; // x position within block

                    if (xb < 0 || xb > ncols - 1) // outside blockmap, continue
                        continue;

                    if (y < miny || y > maxy) // line doesn't touch row
                        continue;

                    // The cell that contains the intersection point is always
                    // added

                    AddBlockLine(blocklists, blockcount, blockdone, ncols * j
                            + xb, i);

                    // if the intersection is at a corner it depends on the
                    // slope
                    // (and whether the line extends past the intersection)
                    // which
                    // blocks are hit

                    if (xp == 0) // intersection at a corner
                    {
                        if (sneg) // \ - blocks x,y-, x-,y
                        {
                            if (j > 0 && miny < y)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * (j - 1) + xb, i);
                            if (xb > 0 && minx < x)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * j + xb - 1, i);
                        } else if (vert) // | - block x,y-
                        {
                            if (j > 0 && miny < y)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * (j - 1) + xb, i);
                        } else if (spos) // / - block x-,y-
                        {
                            if (xb > 0 && j > 0 && miny < y)
                                AddBlockLine(blocklists, blockcount, blockdone,
                                    ncols * (j - 1) + xb - 1, i);
                        }
                    } else if (j > 0 && miny < y) // else not on a corner: x,y-
                        AddBlockLine(blocklists, blockcount, blockdone, ncols
                                * (j - 1) + xb, i);
                }
            }
        }

        // Add initial 0 to all blocklists
        // count the total number of lines (and 0's and -1's)

        C2JUtils.memset(blockdone, false, NBlocks);

        linetotal = 0;

        for (int i = 0; i < NBlocks; i++) {
            AddBlockLine(blocklists, blockcount, blockdone, i, 0);
            linetotal += blockcount[i];
        }

        // Create the blockmap lump

        // blockmaplump = malloc_IfSameLevel(blockmaplump, 4 + NBlocks +
        // linetotal);
        blockmaplump = new int[(int) (4 + NBlocks + linetotal)];
        // blockmap header

        blockmaplump[0] = bmaporgx = xorg << FRACBITS;
        blockmaplump[1] = bmaporgy = yorg << FRACBITS;
        blockmaplump[2] = bmapwidth = ncols;
        blockmaplump[3] = bmapheight = nrows;

        // offsets to lists and block lists

        for (int i = 0; i < NBlocks; i++) {
            linelist_t bl = blocklists[i];
            int offs =
                blockmaplump[4 + i] = // set offset to block's list
                    (i != 0 ? blockmaplump[4 + i - 1] : 4 + NBlocks)
                            + (i != 0 ? blockcount[i - 1] : 0);

            // add the lines in each block's list to the blockmaplump
            // delete each list node as we go

            while (bl != null) {
                linelist_t tmp = bl.next;
                blockmaplump[offs++] = bl.num;
                bl = tmp;
            }
        }

        long b = System.nanoTime();

        System.err.printf("Blockmap generated in %f sec\n", (b - a) / 1e9);
        System.err.printf("Time spend in AddBlockLine : %f sec\n", total / 1e9);
    }

    // jff 10/6/98
    // End new code added to speed up calculation of internal blockmap

    //
    // P_VerifyBlockMap
    //
    // haleyjd 03/04/10: do verification on validity of blockmap.
    //
    protected boolean VerifyBlockMap(int count) {
        int x, y;
        int p_maxoffs = count;

        for (y = 0; y < bmapheight; y++) {
            for (x = 0; x < bmapwidth; x++) {
                int offset;
                int p_list;
                int tmplist;
                int blockoffset;

                offset = y * bmapwidth + x;
                blockoffset = offset + 4; // That's where the shit starts.

                // check that block offset is in bounds
                if (blockoffset >= p_maxoffs) {
                    System.err
                            .printf("P_VerifyBlockMap: block offset overflow\n");
                    return false;
                }

                offset = blockmaplump[blockoffset];

                // check that list offset is in bounds
                if (offset < 4 || offset >= count) {
                    System.err
                            .printf("P_VerifyBlockMap: list offset overflow\n");
                    return false;
                }

                p_list = offset;

                // scan forward for a -1 terminator before maxoffs
                for (tmplist = p_list;; tmplist++) {
                    // we have overflowed the lump?
                    if (tmplist >= p_maxoffs) {
                        System.err.printf("P_VerifyBlockMap: open blocklist\n");
                        return false;
                    }
                    if (blockmaplump[tmplist] == -1) // found -1
                        break;
                }

                // scan the list for out-of-range linedef indicies in list
                for (tmplist = p_list; blockmaplump[tmplist] != -1; tmplist++) {
                    if (blockmaplump[tmplist] < 0
                            || blockmaplump[tmplist] >= numlines) {
                        System.err
                                .printf("P_VerifyBlockMap: index >= numlines\n");
                        return false;
                    }
                }
            }
        }

        return true;
    }

    // cph - convenient sub-function
    protected void AddLineToSector(line_t li, sector_t sector) {
        int[] bbox = sector.blockbox;

        sector.lines[sector.linecount++] = li;
        BBox.AddToBox(bbox, li.v1.x, li.v1.y);
        BBox.AddToBox(bbox, li.v2.x, li.v2.y);
    }

    /**
     * Compute density of reject table. Aids choosing LUT optimizations.
     * 
     * @return
     */

    protected float rejectDensity() {
        // float[] rowdensity=new float[numsectors];
        float tabledensity;
        int tcount = 0;

        for (int i = 0; i < numsectors; i++) {
            // int colcount=0;
            for (int j = 0; j < numsectors; j++) {
                // Determine subsector entries in REJECT table.
                int pnum = i * numsectors + j;
                int bytenum = pnum >> 3;
                int bitnum = 1 << (pnum & 7);

                // Check in REJECT table.
                if (!flags(rejectmatrix[bytenum], bitnum)) {
                    tcount++;
                    // colcount++;
                }
            }
            // rowdensity[i]=((float)colcount/numsectors);
        }

        tabledensity = (float) tcount / (numsectors * numsectors);
        return tabledensity;

    }

    protected static int[] POKE_REJECT = new int[] { 1, 2, 4, 8, 16, 32, 64,
            128 };

    /**
     * Updates Reject table dynamically based on what expensive LOS checks say.
     * It does decrease the "reject density" the longer the level runs, however
     * its by no means perfect, and results in many sleeping monsters. When
     * called, visibility between sectors x and y will be set to "false" for the
     * rest of the level, aka they will be rejected based on subsequent sight
     * checks.
     * 
     * @param x
     * @param y
     */

    protected void pokeIntoReject(int x, int y) {
        // Locate bit pointer e.g. for a 4x4 table, x=2 and y=3 give
        // 3*4+2=14
        final int pnum = y * numsectors + x;

        // Which byte?
        // 14= 1110 >>3 = 0001 so
        // Byte 0 Byte 1
        // xxxxxxxx xxxxxxxx
        // ^
        // 0.....bits......16
        // We are writing inside the second Byte 1
        final int bytenum = pnum >> 3;

        // OK, so how we pinpoint that one bit?
        // 1110 & 0111 = 0110 = 6 so it's the sixth bit
        // of the second byte
        final int bitnum = pnum & 7;

        // This sets only that one bit, and the reject lookup will be faster
        // next time.
        rejectmatrix[bytenum] |= POKE_REJECT[bitnum];

        System.out.println(rejectDensity());

    }

    protected void retrieveFromReject(int x, int y, boolean value) {
        // Locate bit pointer e.g. for a 4x4 table, x=2 and y=3 give
        // 3*4+2=14
        final int pnum = y * numsectors + x;

        // Which byte?
        // 14= 1110 >>3 = 0001 so
        // Byte 0 Byte 1
        // xxxxxxxx xxxxxxxx
        // ^
        // 0.....bits......16
        // We are writing inside the second Byte 1
        final int bytenum = pnum >> 3;

        // OK, so how we pinpoint that one bit?
        // 1110 & 0111 = 0110 = 6 so it's the sixth bit
        // of the second byte
        final int bitnum = pnum & 7;

        // This sets only that one bit, and the reject lookup will be faster
        // next time.
        rejectmatrix[bytenum] |= POKE_REJECT[bitnum];

        System.out.println(rejectDensity());

    }

    // Keeps track of lines that belong to a sector, to exclude e.g.
    // orphaned ones from the blockmap.
    protected boolean[] used_lines;

    // MAES: extensions to support 512x512 blockmaps.
    // They represent the maximum negative number which represents
    // a positive offset, otherwise they are left at -257, which
    // never triggers a check.
    // If a blockmap index is ever LE than either, then
    // its actual value is to be interpreted as 0x01FF&x.
    // Full 512x512 blockmaps get this value set to -1.
    // A 511x511 blockmap would still have a valid negative number
    // e.g. -1..510, so they would be set to -2
    
    public int blockmapxneg=-257;
    public int blockmapyneg=-257;

    /**
     * Returns an int[] array with orgx, orgy, and number of blocks. Order is:
     * orgx,orgy,bckx,bcky
     * 
     * @return
     */

    protected final int[] getMapBoundingBox(boolean playable) {

        int minx = Integer.MAX_VALUE;
        int miny = Integer.MAX_VALUE;
        int maxx = Integer.MIN_VALUE;
        int maxy = Integer.MIN_VALUE;

        // Scan linedefs to detect extremes

        for (int i = 0; i < this.lines.length; i++) {

            if (playable || used_lines[i]) {
                if (lines[i].v1x > maxx)
                    maxx = lines[i].v1x;
                if (lines[i].v1x < minx)
                    minx = lines[i].v1x;
                if (lines[i].v1y > maxy)
                    maxy = lines[i].v1y;
                if (lines[i].v1y < miny)
                    miny = lines[i].v1y;
                if (lines[i].v2x > maxx)
                    maxx = lines[i].v2x;
                if (lines[i].v2x < minx)
                    minx = lines[i].v2x;
                if (lines[i].v2y > maxy)
                    maxy = lines[i].v2y;
                if (lines[i].v2y < miny)
                    miny = lines[i].v2y;
            }
        }

        System.err.printf("Map bounding %d %d %d %d\n", minx >> FRACBITS,
            miny >> FRACBITS, maxx >> FRACBITS, maxy >> FRACBITS);

        // Blow up bounding to the closest 128-sized block, adding 8 units as
        // padding.
        // This seems to be the "official" formula.
        int orgx = -BLOCKMAPPADDING + MAPBLOCKUNITS * (minx / MAPBLOCKUNITS);
        int orgy = -BLOCKMAPPADDING + MAPBLOCKUNITS * (miny / MAPBLOCKUNITS);
        int bckx = ((BLOCKMAPPADDING + maxx) - orgx);
        int bcky = ((BLOCKMAPPADDING + maxy) - orgy);

        System.err.printf("%d %d %d %d\n", orgx >> FRACBITS, orgy >> FRACBITS,
            1 + (bckx >> MAPBLOCKSHIFT), 1 + (bcky >> MAPBLOCKSHIFT));

        return new int[] { orgx, orgy, bckx, bcky };
    }

    protected void LoadReject(int lumpnum) {
        byte[] tmpreject = new byte[0];

        // _D_: uncommented the rejectmatrix variable, this permitted changing
        // level to work
        try {
            tmpreject = W.CacheLumpNumAsRawBytes(lumpnum, PU_LEVEL);
        } catch (Exception e) {
            // Any exception at this point means missing REJECT lump. Fuck that,
            // and move on.
            // If everything goes OK, tmpreject will contain the REJECT lump's
            // data
            // BUT, alas, we're not done yet.
        }

        // Sanity check on matrix.
        // E.g. a 5-sector map will result in ceil(25/8)=4 bytes.
        // If the reject table is broken/corrupt, too bad. It will all be
        // zeroes.
        // Much better than overflowing.
        // TODO: build-in a REJECT-matrix rebuilder?
        rejectmatrix =
            new byte[(int) (Math
                    .ceil((this.numsectors * this.numsectors) / 8.0))];
        System.arraycopy(tmpreject, 0, rejectmatrix, 0,
            Math.min(tmpreject.length, rejectmatrix.length));

        // Do warn on atypical reject map lengths, but use either default
        // all-zeroes one,
        // or whatever you happened to read anyway.
        if (tmpreject.length < rejectmatrix.length)
            System.err.printf("BROKEN REJECT MAP! Length %d expected %d\n",
                tmpreject.length, rejectmatrix.length);

        // Maes: purely academic. Most maps are well above 0.68
        // System.out.printf("Reject table density: %f",rejectDensity());
    }
    
    /** Gets the proper blockmap block for a given X 16.16 Coordinate, sanitized
     *  for 512-wide blockmaps. 
     * 
     * @param blockx
     * @return
     */

    public final int getSafeBlockX(int blockx){
        blockx>>=MAPBLOCKSHIFT;
        return (blockx<=this.blockmapxneg)?blockx&0x1FF:blockx;
    }
    
    public final int getSafeBlockX(long blockx){
        blockx>>=MAPBLOCKSHIFT;
        return (int) ((blockx<=this.blockmapxneg)?blockx&0x1FF:blockx);
    }
    
    /** Gets the proper blockmap block for a given Y 16.16 Coordinate, sanitized
     *  for 512-wide blockmaps. 
     * 
     * @param blocky
     * @return     */

    
    public final int getSafeBlockY(int blocky){
        blocky>>=MAPBLOCKSHIFT;
        return (blocky<=this.blockmapyneg)?blocky&0x1FF:blocky;
    }
    
    public final int getSafeBlockY(long blocky){
        blocky>>=MAPBLOCKSHIFT;
        return (int) ((blocky<=this.blockmapyneg)?blocky&0x1FF:blocky);
    }

    /// Sector tag stuff, lifted off Boom
    
  /** Hash the sector tags across the sectors and linedefs.
   *  Call in SpawnSpecials.
   */
    
    public void InitTagLists()
    {
      int i;

      for (i=numsectors; --i>=0; )        // Initially make all slots empty.
        sectors[i].firsttag = -1;
      for (i=numsectors; --i>=0; )        // Proceed from last to first sector
        {                                 // so that lower sectors appear first
          int j = sectors[i].tag % numsectors; // Hash func
          sectors[i].nexttag = sectors[j].firsttag;   // Prepend sector to chain
          sectors[j].firsttag = i;
        }

      // killough 4/17/98: same thing, only for linedefs

      for (i=numlines; --i>=0; )        // Initially make all slots empty.
        lines[i].firsttag = -1;
      for (i=numlines; --i>=0; )        // Proceed from last to first linedef
        {                               // so that lower linedefs appear first
          int j = lines[i].tag % numlines; // Hash func
          lines[i].nexttag = lines[j].firsttag;   // Prepend linedef to chain
          lines[j].firsttag = i;
        }
    }
    
}

package p;

//
// P_PLATS
//

public enum plat_e {
        up,
        down,
        waiting,
        in_stasis
        } 

package p;

public class slideframe_t {
	int[] frontFrames = new int[4];
	int[] backFrames = new int[4];

}
package p;

import static m.fixed_t.FixedDiv;
import static m.fixed_t.FixedMul;
import static utils.C2JUtils.eval;

public class MapUtils {


   /**
   *  AproxDistance
   * Gives an estimation of distance (not exact)
   *
   * @param dx fixed_t
   * @param dy fixed_t
   * @return fixed_t
   */
  //
  public static int
  AproxDistance
  ( int   dx,
  int   dy )
  {
   dx = Math.abs(dx);
   dy = Math.abs(dy);
   if (dx < dy)
   return dx+dy-(dx>>1);
   return dx+dy-(dy>>1);
  }
  
  /**
   * P_InterceptVector
   * Returns the fractional intercept point
   * along the first divline.
   * This is only called by the addthings
   * and addlines traversers.
   * 
   * @return int to be treated as fixed_t
   */

  public static int 
  InterceptVector
  ( divline_t    v2,
  divline_t    v1 )
  {
   int frac, num,den; // fixed_t
   
   den = FixedMul (v1.dy>>8,v2.dx) - FixedMul(v1.dx>>8,v2.dy);

   if (den == 0)
   return 0;
   //  I_Error ("P_InterceptVector: parallel");
   
   num =
   FixedMul ( (v1.x - v2.x)>>8 ,v1.dy )
   +FixedMul ( (v2.y - v1.y)>>8, v1.dx );

   frac = FixedDiv (num , den);

   return frac;
  /*
   #else   // UNUSED, float debug.
   float   frac;
   float   num;
   float   den;
   float   v1x;
   float   v1y;
   float   v1dx;
   float   v1dy;
   float   v2x;
   float   v2y;
   float   v2dx;
   float   v2dy;

   v1x = (float)v1.x/FRACUNIT;
   v1y = (float)v1.y/FRACUNIT;
   v1dx = (float)v1.dx/FRACUNIT;
   v1dy = (float)v1.dy/FRACUNIT;
   v2x = (float)v2.x/FRACUNIT;
   v2y = (float)v2.y/FRACUNIT;
   v2dx = (float)v2.dx/FRACUNIT;
   v2dy = (float)v2.dy/FRACUNIT;
   
   den = v1dy*v2dx - v1dx*v2dy;

   if (den == 0)
   return 0;   // parallel
   
   num = (v1x - v2x)*v1dy + (v2y - v1y)*v1dx;
   frac = num / den;

   return frac*FRACUNIT;
  #endif */
  }
  

  /* cph - this is killough's 4/19/98 version of P_InterceptVector and
   *  P_InterceptVector2 (which were interchangeable). We still use this
   *  in compatibility mode. */
  private static final int P_InterceptVector2(final divline_t v2, final divline_t v1)
  {
    int  den;
    return eval(den = FixedMul(v1.dy>>8, v2.dx) - FixedMul(v1.dx>>8, v2.dy)) ?
      FixedDiv(FixedMul((v1.x - v2.x)>>8, v1.dy) +
               FixedMul((v2.y - v1.y)>>8, v1.dx), den) : 0;
  }

  
  /** Used by CrossSubSector
   * 
   * @param v2
   * @param v1
   * @return
   */
  public static final int P_InterceptVector(final divline_t v2, final divline_t v1)
  {
    if (false/*compatibility_level < prboom_4_compatibility*/)
      return P_InterceptVector2(v2, v1);
    else {
      /* cph - This was introduced at prboom_4_compatibility - no precision/overflow problems */
      long den = (long)v1.dy * v2.dx - (long)v1.dx * v2.dy;
      den >>= 16;
      if (!eval(den))
        return 0;
      return (int)(((long)(v1.x - v2.x) * v1.dy - (long)(v1.y - v2.y) * v1.dx) / den);
    }
  }
  
  /**
   * P_InterceptVector2 Returns the fractional intercept point along the
   * first divline. This is only called by the addthings and addlines
   * traversers.
   * 
   * @param v2
   * @param v1
   * @returnP_InterceptVector2
   */

  public static final int InterceptVector2(divline_t v2, divline_t v1) {
      int frac; // fixed_t
      int num; // fixed_t
      int den; // fixed_t

      den = FixedMul(v1.dy >> 8, v2.dx) - FixedMul(v1.dx >> 8, v2.dy);

      if (den == 0)
          return 0;
      // I_Error ("P_InterceptVector: parallel");

      num =
          FixedMul((v1.x - v2.x) >> 8, v1.dy)
                  + FixedMul((v2.y - v1.y) >> 8, v1.dx);
      frac = FixedDiv(num, den);

      return frac;
  }
  
}

package p;

import static m.fixed_t.MAPFRACUNIT;
import static data.Defines.TIC_MUL;

public final class ChaseDirections {

    public static final int DI_EAST = 0;

    public static final int DI_NORTHEAST = 1;

    public static final int DI_NORTH = 2;

    public static final int DI_NORTHWEST = 3;

    public static final int DI_WEST = 4;

    public static final int DI_SOUTHWEST = 5;

    public static final int DI_SOUTH = 6;

    public static final int DI_SOUTHEAST = 7;

    public static final int DI_NODIR = 8;

    public static final int NUMDIR = 9;
    
    //
    // P_NewChaseDir related LUT.
    //
    public final static int opposite[] =
        { DI_WEST, DI_SOUTHWEST, DI_SOUTH, DI_SOUTHEAST, DI_EAST, DI_NORTHEAST,
                DI_NORTH, DI_NORTHWEST, DI_NODIR };

    public final static int diags[] =
        { DI_NORTHWEST, DI_NORTHEAST, DI_SOUTHWEST, DI_SOUTHEAST };

    public final static int[] xspeed =
        { MAPFRACUNIT, 47000/TIC_MUL, 0, -47000/TIC_MUL, -MAPFRACUNIT, -47000/TIC_MUL, 0, 47000/TIC_MUL }; // all
                                                                     // fixed

    public final static int[] yspeed =
        { 0, 47000/TIC_MUL, MAPFRACUNIT, 47000/TIC_MUL, 0, -47000/TIC_MUL, -MAPFRACUNIT, -47000/TIC_MUL }; // all
                                                                     // fixed
    
}

package p;

public interface ISightChecker {

    public void setZStartTopBOttom(int zstart, int top, int bottom);
    public void setSTrace(mobj_t t1, mobj_t t2);
    public boolean CrossBSPNode(int bspnum);
    
}

package p;

import defines.*;
import static p.ChaseDirections.*;
import static p.DoorDefines.*;
import static data.Defines.BASETHRESHOLD;
import static data.Defines.FLOATSPEED;
import static data.Defines.ITEMQUESIZE;
import static data.Defines.MAPBLOCKSHIFT;
import static data.Defines.MAPBLOCKSIZE;
import static data.Defines.MAPBTOFRAC;
import static data.Defines.MELEERANGE;
import static data.Defines.MISSILERANGE;
import static rr.line_t.*;
import static data.Defines.MTF_AMBUSH;
import static data.Defines.NUMCARDS;
import static data.Defines.ONCEILINGZ;
import static data.Defines.ONFLOORZ;
import static data.Defines.PST_DEAD;
import static data.Defines.PST_LIVE;
import static data.Defines.PST_REBORN;
import static data.Defines.PT_ADDLINES;
import static data.Defines.PT_ADDTHINGS;
import static data.Defines.PT_EARLYOUT;
import static data.Defines.USERANGE;
import static data.Defines.VIEWHEIGHT;
import static data.Defines.pw_invulnerability;
import static data.Limits.CEILSPEED;
import static data.Limits.MAXCEILINGS;
import static data.Limits.MAXINT;
import static data.Limits.MAXMOVE;
import static data.Limits.MAXPLAYERS;
import static data.Limits.MAXRADIUS;
import static data.Limits.MAXSPECIALCROSS;
import static data.Limits.NUMMOBJTYPES;
import static data.Tables.*;
import static data.info.mobjinfo;
import static data.info.states;
import static doom.englsh.PD_BLUEK;
import static doom.englsh.PD_BLUEO;
import static doom.englsh.PD_REDK;
import static doom.englsh.PD_REDO;
import static doom.englsh.PD_YELLOWK;
import static doom.englsh.PD_YELLOWO;
import static m.BBox.BOXBOTTOM;
import static m.BBox.BOXLEFT;
import static m.BBox.BOXRIGHT;
import static m.BBox.BOXTOP;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.MAPFRACUNIT;
import static m.fixed_t.FixedDiv;
import static m.fixed_t.FixedMul;
import static p.ChaseDirections.DI_EAST;
import static p.ChaseDirections.DI_NODIR;
import static p.ChaseDirections.DI_NORTH;
import static p.ChaseDirections.DI_SOUTH;
import static p.ChaseDirections.DI_SOUTHEAST;
import static p.ChaseDirections.DI_WEST;
import static p.ChaseDirections.diags;
import static p.ChaseDirections.opposite;
import static p.MapUtils.AproxDistance;
import static utils.C2JUtils.*;

import static p.mobj_t.*;
import rr.line_t;
import rr.sector_t;
import rr.side_t;
import rr.subsector_t;
import utils.C2JUtils;
import data.Tables;
import data.mapthing_t;
import data.mobjinfo_t;
import data.mobjtype_t;
import data.state_t;
import data.sounds.sfxenum_t;
import doom.DoomStatus;
import doom.player_t;
import doom.think_t;
import doom.thinker_t;
import doom.weapontype_t;

/** Action functions need to be aware of:
    *  Random number generator (RND)
    *  Broader gameplay context (DoomGame)
    *  Some door actions
    *  Playfield checks.
    *  etc. etc. so they COULD be made into a separate file
    * 
    * @author admin
    *
    */

public class Actions extends UnifiedGameMap {
      
      //
      // CEILINGS
      //

      private ceiling_t[]  activeceilings=new ceiling_t[MAXCEILINGS];

      /** This needs to be called before loading, otherwise
       *  crushers won't be able to be restarted. 
       */
      public void ClearCeilingsBeforeLoading(){

    	  this.activeceilings=new ceiling_t[MAXCEILINGS];
          
    	  /*
    	  for (int i = 0; i < MAXPLATS; i++) {
                  this.activeceilings[i] = null;
              } */
      }
      
      
      /**
       * T_MoveCeiling
       */

      protected void MoveCeiling (ceiling_t ceiling)
      {
          result_e    res;
          
          switch(ceiling.direction)
          {
            case 0:
          // IN STASIS
          break;
            case 1:
          // UP
          res = MovePlane(ceiling.sector,
                    ceiling.speed,
                    ceiling.topheight,
                    false,1,ceiling.direction);
          
          if (!eval(DM.leveltime&7))
          {
              switch(ceiling.type)
              {
                case silentCrushAndRaise:
              break;
                default:
              S.StartSound(ceiling.sector.soundorg,sfxenum_t.sfx_stnmov);
                       
              // ?
              break;
              }
          }
          
          if (res == result_e.pastdest)
          {
              switch(ceiling.type)
              {
                case raiseToHighest:
              RemoveActiveCeiling(ceiling);
              break;
              
                case silentCrushAndRaise:
                    S.StartSound(ceiling.sector.soundorg, sfxenum_t.sfx_pstop);
                case fastCrushAndRaise:
                case crushAndRaise:
              ceiling.direction = -1;
              break;
              
                default:
              break;
              }
              
          }
          break;
          
            case -1:
          // DOWN
          res = MovePlane(ceiling.sector,
                    ceiling.speed,
                    ceiling.bottomheight,
                    ceiling.crush,1,ceiling.direction);
          
          if (!eval(DM.leveltime&7))
          {
              switch(ceiling.type)
              {
                case silentCrushAndRaise: break;
                default:
                	S.StartSound(ceiling.sector.soundorg,  sfxenum_t.sfx_stnmov);
                     
              }
          }
          
          if (res == result_e.pastdest)
          {
              switch(ceiling.type)
              {
                case silentCrushAndRaise:
                	S.StartSound(ceiling.sector.soundorg, sfxenum_t.sfx_pstop);
                case crushAndRaise:
              ceiling.speed = CEILSPEED;
                case fastCrushAndRaise:
              ceiling.direction = 1;
              break;

                case lowerAndCrush:
                case lowerToFloor:
              RemoveActiveCeiling(ceiling);
              break;

                default:
              break;
              }
          }
          else // ( res != result_e.pastdest )
          {
              if (res == result_e.crushed)
              {
              switch(ceiling.type)
              {
                case silentCrushAndRaise:
                case crushAndRaise:
                case lowerAndCrush:
                  ceiling.speed = CEILSPEED / 8;
                  break;

                default:
                  break;
              }
              }
          }
          break;
          }
      }


      

      //
      // Add an active ceiling
      //
      public void AddActiveCeiling(ceiling_t c)
      {
          int     i;
          
          for (i = 0; i < getMaxCeilings();i++)
          {
          if (getActiveCeilings()[i] == null)
          {
              getActiveCeilings()[i] = c;
              return;
          }
          }
          // Needs rezising
          setActiveceilings(C2JUtils.resize(c, getActiveCeilings(), 2*getActiveCeilings().length));
      }



      //
      // Remove a ceiling's thinker
      //
      protected void RemoveActiveCeiling(ceiling_t c)
      {
          int     i;
          
          for (i = 0;i < getMaxCeilings();i++)
          {
          if (getActiveCeilings()[i] == c)
          {
              getActiveCeilings()[i].sector.specialdata = null;
              RemoveThinker (getActiveCeilings()[i]);
              getActiveCeilings()[i] = null;
              break;
          }
          }
      }



      //
      // Restart a ceiling that's in-stasis
      //
      protected void ActivateInStasisCeiling(line_t line)
      {
          int     i;
          
          for (i = 0;i < getMaxCeilings();i++)
          {
          if (getActiveCeilings()[i]!=null
              && (getActiveCeilings()[i].tag == line.tag)
              && (getActiveCeilings()[i].direction == 0))
          {
              getActiveCeilings()[i].direction = getActiveCeilings()[i].olddirection;
              getActiveCeilings()[i].function
                = think_t.T_MoveCeiling;
              FUNS.doWireThinker( getActiveCeilings()[i]);
          }
          }
      }
      
      

      /**
       * MOVE A FLOOR TO IT'S DESTINATION (UP OR DOWN)
       *
       */
      protected void MoveFloor(floormove_t floor)
      {
          result_e    res;
          
          res = MovePlane(floor.sector,
                    floor.speed,
                    floor.floordestheight,
                    floor.crush,0,floor.direction);
          
          if (!eval(DM.leveltime&7))
              
        	  S.StartSound(floor.sector.soundorg,  sfxenum_t.sfx_stnmov);
          
          if (res == result_e.pastdest)
          {
          floor.sector.specialdata = null;

          if (floor.direction == 1)
          {
              switch(floor.type)
              {
                case donutRaise:
              floor.sector.special = (short) floor.newspecial;
              floor.sector.floorpic = floor.texture;
                default:
              break;
              }
          }
          else if (floor.direction == -1)
          {
              switch(floor.type) //TODO: check if a null floor.type is valid or a bug 
              // MAES: actually, type should always be set to something.
              // In C, this means "zero" or "null". In Java, we must make sure
              // it's actually set to something all the time.
              {
                case lowerAndChange:
              floor.sector.special = (short) floor.newspecial;
              floor.sector.floorpic = floor.texture;
                default:
              break;
              }
          }
          RemoveThinker(floor);

          S.StartSound(floor.sector.soundorg, sfxenum_t.sfx_pstop);
          }

      }

      //
      // EV.DoCeiling
      // Move a ceiling up/down and all around!
      //
      protected boolean DoCeiling( line_t   line, ceiling_e type )
      {
          int     secnum=-1;
          boolean     rtn=false;
          sector_t   sec;
          ceiling_t  ceiling;
                   
          //  Reactivate in-stasis ceilings...for certain types.
          switch(type)
          {
            case fastCrushAndRaise:
            case silentCrushAndRaise:
            case crushAndRaise:
          ActivateInStasisCeiling(line);
            default:
          break;
          }
          
          while ((secnum = FindSectorFromLineTag(line,secnum)) >= 0)
          {
          sec = LL.sectors[secnum];
          if (sec.specialdata!=null)
              continue;
          
          // new door thinker
          rtn = true;
          ceiling = new ceiling_t();
          sec.specialdata = ceiling;
          ceiling.function = think_t.T_MoveCeiling;
          AddThinker (ceiling);
          ceiling.sector = sec;
          ceiling.crush = false;
          
          switch(type)
          {
            case fastCrushAndRaise:
              ceiling.crush = true;
              ceiling.topheight = sec.ceilingheight;
              ceiling.bottomheight = sec.floorheight + (8*FRACUNIT);
              ceiling.direction = -1;
              ceiling.speed = CEILSPEED * 2;
              break;

            case silentCrushAndRaise:
            case crushAndRaise:
              ceiling.crush = true;
              ceiling.topheight = sec.ceilingheight;
            case lowerAndCrush:
            case lowerToFloor:
              ceiling.bottomheight = sec.floorheight;
              if (type != ceiling_e.lowerToFloor)
              ceiling.bottomheight += 8*FRACUNIT;
              ceiling.direction = -1;
              ceiling.speed = CEILSPEED;
              break;

            case raiseToHighest:
              ceiling.topheight = sec.FindHighestCeilingSurrounding();
              ceiling.direction = 1;
              ceiling.speed = CEILSPEED;
              break;
          }
              
          ceiling.tag = sec.tag;
          ceiling.type = type;
          AddActiveCeiling(ceiling);
          }
          return rtn;
      }

      
      /**
       * Special Stuff that can not be categorized
       * 
       * (I'm sure it has something to do with John Romero's obsession
       *  with fucking stuff and making them his bitches).
       *
       *@param line
       * 
       */
      protected boolean DoDonut(line_t  line)
      {
          sector_t       s1;
          sector_t       s2;
          sector_t       s3;
          int         secnum;
          boolean         rtn;
          int         i;
          floormove_t    floor;
          
          secnum = -1;
          rtn = false;
          while ((secnum = FindSectorFromLineTag(line,secnum)) >= 0)
          {
          s1 = LL.sectors[secnum];
              
          // ALREADY MOVING?  IF SO, KEEP GOING...
          if (s1.specialdata!=null)
              continue;
                  
          rtn = true;
          s2 = s1.lines[0].getNextSector(s1);
          for (i = 0;i < s2.linecount;i++)
          {
              if ((!eval(s2.lines[i].flags & ML_TWOSIDED)) ||
              (s2.lines[i].backsector == s1))
              continue;
              s3 = s2.lines[i].backsector;
              
              //  Spawn rising slime
              floor = new floormove_t();
              s2.specialdata = floor;
              floor.function = think_t.T_MoveFloor;
              AddThinker (floor);
              floor.type = floor_e.donutRaise;
              floor.crush = false;
              floor.direction = 1;
              floor.sector = s2;
              floor.speed = FLOORSPEED / 2;
              floor.texture = s3.floorpic;
              floor.newspecial = 0;
              floor.floordestheight = s3.floorheight;
              
              //  Spawn lowering donut-hole
              floor = new floormove_t();
              s1.specialdata = floor;
              floor.function = think_t.T_MoveFloor;
              AddThinker (floor);
              floor.type = floor_e.lowerFloor;
              floor.crush = false;
              floor.direction = -1;
              floor.sector = s1;
              floor.speed = FLOORSPEED / 2;
              floor.floordestheight = s3.floorheight;
              break;
          }
          }
          return rtn;
      }
      
      //
      // HANDLE FLOOR TYPES
      //
      protected boolean DoFloor( line_t   line,floor_e   floortype )
      {
          int         secnum=-1;
          boolean         rtn=false;
          int         i;
          sector_t       sec;
          floormove_t    floor;

          while ((secnum = FindSectorFromLineTag(line,secnum)) >= 0)
          {
          sec = LL.sectors[secnum];
              
          // ALREADY MOVING?  IF SO, KEEP GOING...
          if (sec.specialdata!=null)
              continue;
          
          // new floor thinker
          rtn = true;
          floor = new floormove_t();
          sec.specialdata = floor;
          floor.function = think_t.T_MoveFloor;
          AddThinker (floor);
          floor.type = floortype;
          floor.crush = false;

          switch(floortype)
          {
            case lowerFloor:
              floor.direction = -1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = 
              sec.FindHighestFloorSurrounding();
              break;

            case lowerFloorToLowest:
              floor.direction = -1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = 
              sec.FindLowestFloorSurrounding();
              break;

            case turboLower:
              floor.direction = -1;
              floor.sector = sec;
              floor.speed = FLOORSPEED * 4;
              floor.floordestheight = 
              sec.FindHighestFloorSurrounding();
              if (floor.floordestheight != sec.floorheight)
              floor.floordestheight += 8*FRACUNIT;
              break;

            case raiseFloorCrush:
              floor.crush = true;
            case raiseFloor:
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = 
              sec.FindLowestCeilingSurrounding();
              if (floor.floordestheight > sec.ceilingheight)
              floor.floordestheight = sec.ceilingheight;
              floor.floordestheight -= (8*FRACUNIT)*
              eval(floortype == floor_e.raiseFloorCrush);
              break;

            case raiseFloorTurbo:
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = FLOORSPEED*4;
              floor.floordestheight = 
              sec.FindNextHighestFloor(sec.floorheight);
              break;

            case raiseFloorToNearest:
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = 
              sec.FindNextHighestFloor(sec.floorheight);
              break;

            case raiseFloor24:
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = floor.sector.floorheight +
              24 * FRACUNIT;
              break;
            case raiseFloor512:
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = floor.sector.floorheight +
              512 * FRACUNIT;
              break;

            case raiseFloor24AndChange:
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = floor.sector.floorheight +
              24 * FRACUNIT;
              sec.floorpic = line.frontsector.floorpic;
              sec.special = line.frontsector.special;
              break;

            case raiseToTexture:
            {
                int   minsize = MAXINT;
                side_t   side;
                      
                floor.direction = 1;
                floor.sector = sec;
                floor.speed = FLOORSPEED;
                for (i = 0; i < sec.linecount; i++)
                {
                if (twoSided (secnum, i) )
                {
                    side = getSide(secnum,i,0);
                    if (side.bottomtexture >= 0)
                    if (TM.getTextureheight(side.bottomtexture) < 
                        minsize)
                        minsize = 
                        TM.getTextureheight(side.bottomtexture);
                    side = getSide(secnum,i,1);
                    if (side.bottomtexture >= 0)
                    if (TM.getTextureheight(side.bottomtexture) < 
                        minsize)
                        minsize = 
                        TM.getTextureheight(side.bottomtexture);
                }
                }
                floor.floordestheight =
                floor.sector.floorheight + minsize;
            }
            break;
            
            case lowerAndChange:
              floor.direction = -1;
              floor.sector = sec;
              floor.speed = FLOORSPEED;
              floor.floordestheight = 
              sec.FindLowestFloorSurrounding();
              floor.texture = sec.floorpic;

              for (i = 0; i < sec.linecount; i++)
              {
              if ( twoSided(secnum, i) )
              {
                  if (getSide(secnum,i,0).sector.id == secnum)
                  {
                  sec = getSector(secnum,i,1);

                  if (sec.floorheight == floor.floordestheight)
                  {
                      floor.texture = sec.floorpic;
                      floor.newspecial = sec.special;
                      break;
                  }
                  }
                  else
                  {
                  sec = getSector(secnum,i,0);

                  if (sec.floorheight == floor.floordestheight)
                  {
                      floor.texture = sec.floorpic;
                      floor.newspecial = sec.special;
                      break;
                  }
                  }
              }
              }
            default:
              break;
          }
          }
          return rtn;
      }

      //
      // EV_CeilingCrushStop
      // Stop a ceiling from crushing!
      //
      int CeilingCrushStop(line_t  line)
      {
          int     i;
          int     rtn;
          
          rtn = 0;
          for (i = 0;i < getMaxCeilings();i++)
          {
          if (getActiveCeilings()[i]!=null
              && (getActiveCeilings()[i].tag == line.tag)
              && (getActiveCeilings()[i].direction != 0))
          {
              getActiveCeilings()[i].olddirection = getActiveCeilings()[i].direction;
              // MAES: don't set it to NOP here, otherwise its thinker will be
              // removed and it won't be possible to restart it.
              getActiveCeilings()[i].function = null;
              getActiveCeilings()[i].direction = 0;       // in-stasis
              rtn = 1;
          }
          }
          

          return rtn;
      }


      /**
       * BUILD A STAIRCASE!
       */
      
      protected boolean BuildStairs(line_t line, stair_e type )
      {
          int         secnum;
          int         height;
          int         i;
          int         newsecnum;
          int         texture;
          boolean         ok;
          boolean         rtn;
          
          sector_t       sec;
          sector_t       tsec;

          floormove_t    floor;
          
          int     stairsize = 0; 
          int     speed=0; // shut up compiler

          secnum = -1;
          rtn = false;
          while ((secnum = FindSectorFromLineTag(line,secnum)) >= 0)
          {
          sec = LL.sectors[secnum];
              
          // ALREADY MOVING?  IF SO, KEEP GOING...
          if (sec.specialdata!=null)
              continue;
          
          // new floor thinker
          rtn = true;
          floor = new floormove_t ();
          sec.specialdata = floor;
          floor.function = think_t.T_MoveFloor;
          AddThinker (floor);
          floor.direction = 1;
          floor.sector = sec;
          switch(type)
          {
            case build8:
              speed = FLOORSPEED/4;
              stairsize = 8*FRACUNIT;
              break;
            case turbo16:
              speed = FLOORSPEED*4;
              stairsize = 16*FRACUNIT;
              break;
          }
          floor.speed = speed;
          height = sec.floorheight + stairsize;
          floor.floordestheight = height;
              
          texture = sec.floorpic;
          
          // Find next sector to raise
          // 1.   Find 2-sided line with same sector side[0]
          // 2.   Other side is the next sector to raise
          do
          {
              ok = false;
              for (i = 0;i < sec.linecount;i++)
              {
              if ( !eval((sec.lines[i]).flags & ML_TWOSIDED) )
                  continue;
                          
              tsec = (sec.lines[i]).frontsector;
              newsecnum = tsec.id;
              
              if (secnum != newsecnum)
                  continue;

              tsec = (sec.lines[i]).backsector;
              newsecnum = tsec.id;

              if (tsec.floorpic != texture)
                  continue;
                          
              height += stairsize;

              if (tsec.specialdata!=null)
                  continue;
                          
              sec = tsec;
              secnum = newsecnum;
              floor = new floormove_t();
              sec.specialdata = floor;
              floor.function = think_t.T_MoveFloor;
              AddThinker (floor);
              floor.direction = 1;
              floor.sector = sec;
              floor.speed = speed;
              floor.floordestheight = height;
              ok = true;
              break;
              }
          } while(ok);
          }
          return rtn;
      }
      



      //
      // VERTICAL DOORS
      //

      /**
       * T_VerticalDoor
       */
      protected void VerticalDoor (vldoor_t door)
      {
          result_e   res;
         
          switch(door.direction)
          {
            case 0:
         // WAITING
         if (!eval(--door.topcountdown))
         {
             switch(door.type)
             {
               case blazeRaise:
             door.direction = -1; // time to go back down
             S.StartSound(door.sector.soundorg,sfxenum_t.sfx_bdcls);
             break;
             
               case normal:
             door.direction = -1; // time to go back down
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_dorcls);
             break;
             
               case close30ThenOpen:
             door.direction = 1;
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_doropn);
             break;
             
               default:
             break;
             }
         }
         break;
         
            case 2:
         //  INITIAL WAIT
         if (!eval(--door.topcountdown))
         {
             switch(door.type)
             {
               case raiseIn5Mins:
             door.direction = 1;
             door.type = vldoor_e.normal;
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_doropn);
             break;
             
               default:
             break;
             }
         }
         break;
         
            case -1:
         // DOWN
         res = MovePlane(door.sector,
                   door.speed,
                   door.sector.floorheight,
                   false,1,door.direction);
         if (res == result_e.pastdest)
         {
             switch(door.type)
             {
               case blazeRaise:
               case blazeClose:
             door.sector.specialdata = null;
             RemoveThinker (door);  // unlink and free
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_bdcls);
             break;
             
               case normal:
               case close:
             door.sector.specialdata = null;
             RemoveThinker (door);  // unlink and free
             break;
             
               case close30ThenOpen:
             door.direction = 0;
             door.topcountdown = 35*30;
             break;
             
               default:
             break;
             }
         }
         else if (res == result_e.crushed)
         {
             switch(door.type)
             {
               case blazeClose:
               case close:       // DO NOT GO BACK UP!
             break;
             
               default:
             door.direction = 1;
               S.StartSound(door.sector.soundorg, sfxenum_t.sfx_doropn);
             break;
             }
         }
         break;
         
            case 1:
         // UP
         res = MovePlane(door.sector,
                   door.speed,
                   door.topheight,
                   false,1,door.direction);
         
         if (res == result_e.pastdest)
         {
             switch(door.type)
             {
               case blazeRaise:
               case normal:
             door.direction = 0; // wait at top
             door.topcountdown = door.topwait;
             break;
             
               case close30ThenOpen:
               case blazeOpen:
               case open:
             door.sector.specialdata = null;
             RemoveThinker (door);  // unlink and free
             break;
             
               default:
             break;
             }
         }
         break;
          }
      }


      /**
       * EV_DoLockedDoor
       * Move a locked door up/down
       */

      protected boolean DoLockedDoor
      ( line_t   line,
        vldoor_e type,
        mobj_t   thing )
      {
          player_t   p;
         
          p = thing.player;
         
          if (p==null)
         return false;
             
          switch(line.special)
          {
            case 99: // Blue Lock
            case 133:
/*         if ( p==null )
             return false; */
         if (!p.cards[card_t.it_bluecard.ordinal()] && !p.cards[card_t.it_blueskull.ordinal()])
         {
             p.message = PD_BLUEO;
             S.StartSound(null,sfxenum_t.sfx_oof);
             return false;
         }
         break;
         
            case 134: // Red Lock
            case 135:
 /*        if ( p==null )
             return false; */
         if (!p.cards[card_t.it_redcard.ordinal()] && !p.cards[card_t.it_redskull.ordinal()])
         {
             p.message = PD_REDO;
             S.StartSound(null,sfxenum_t.sfx_oof);
             return false;
         }
         break;
         
            case 136:    // Yellow Lock
            case 137:
 /*        if ( p==null )
             return false; */
         if (!p.cards[card_t.it_yellowcard.ordinal()] &&
             !p.cards[card_t.it_yellowskull.ordinal()])
         {
             p.message = PD_YELLOWO;
             S.StartSound(null,sfxenum_t.sfx_oof);
             return false;
         }
         break;  
          }

          return DoDoor(line,type);
      }


      protected boolean DoDoor(line_t line,vldoor_e type)
      {
          int        secnum;
          boolean rtn=false;
          sector_t   sec;
          vldoor_t   door;
         
          secnum = -1;
          
          while ((secnum = FindSectorFromLineTag(line,secnum)) >= 0)
          {
         sec = LL.sectors[secnum];
         if (sec.specialdata!=null)
             continue;
             
         
         // new door thinker
         rtn = true;
         door = new vldoor_t();
         sec.specialdata = door;
         door.function = think_t.T_VerticalDoor;
         AddThinker (door);
         door.sector = sec;
         door.type = type;
         door.topwait = VDOORWAIT;
         door.speed = VDOORSPEED;
             
         switch(type)
         {
           case blazeClose:
             door.topheight = sec.FindLowestCeilingSurrounding();
             door.topheight -= 4*FRACUNIT;
             door.direction = -1;
             door.speed = VDOORSPEED * 4;
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_bdcls);
             break;
             
           case close:
             door.topheight = sec.FindLowestCeilingSurrounding();
             door.topheight -= 4*FRACUNIT;
             door.direction = -1;
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_dorcls);
             break;
             
           case close30ThenOpen:
             door.topheight = sec.ceilingheight;
             door.direction = -1;
             S.StartSound(door.sector.soundorg, sfxenum_t.sfx_dorcls);
             break;
             
           case blazeRaise:
           case blazeOpen:
             door.direction = 1;
             door.topheight = sec.FindLowestCeilingSurrounding();
             door.topheight -= 4*FRACUNIT;
             door.speed = VDOORSPEED * 4;
             if (door.topheight != sec.ceilingheight)
            	 S.StartSound(door.sector.soundorg, sfxenum_t.sfx_bdopn);
             break;
             
           case normal:
           case open:
             door.direction = 1;
             door.topheight = sec.FindLowestCeilingSurrounding();
             door.topheight -= 4*FRACUNIT;
             if (door.topheight != sec.ceilingheight)
            	 S.StartSound(door.sector.soundorg, sfxenum_t.sfx_doropn);
             break;
             
           default:
             break;
         }
             
          }
          return rtn;
      }


      /**
       * EV_VerticalDoor : open a door manually, no tag value
       */
      
      protected void VerticalDoor(line_t line, mobj_t thing )
      {
          player_t   player;
          //int      secnum;
          sector_t   sec;
          vldoor_t   door;
          int        side;
         
          side = 0;  // only front sides can be used

          // Check for locks
          player = thing.player;
             
          switch(line.special)
          {
            case 26: // Blue Lock
            case 32:
         if ( player ==null)
             return;
         
         if (!player.cards[card_t.it_bluecard.ordinal()] && !player.cards[card_t.it_blueskull.ordinal()])
         {
             player.message = PD_BLUEK;
             S.StartSound(null,sfxenum_t.sfx_oof);
             return;
         }
         break;
         
            case 27: // Yellow Lock
            case 34:
         if ( player ==null)
             return;
         
         if (!player.cards[card_t.it_yellowcard.ordinal()] &&
             !player.cards[card_t.it_yellowskull.ordinal()])
         {
             player.message = PD_YELLOWK;
             S.StartSound(null,sfxenum_t.sfx_oof);
             return;
         }
         break;
         
            case 28: // Red Lock
            case 33:
         if ( player ==null)
             return;
         
         if (!player.cards[card_t.it_redcard.ordinal()] && !player.cards[card_t.it_redskull.ordinal()])
         {
             player.message = PD_REDK;
             S.StartSound(null,sfxenum_t.sfx_oof);
             return;
         }
         break;
          }
         
          // if the sector has an active thinker, use it
          sec = LL.sides[ line.sidenum[side^1]].sector;
         // secnum = sec.id;

          if (sec.specialdata!=null)
          {
        
        	  if (sec.specialdata instanceof plat_t)
        // [MAES]: demo sync for e1nm0646: emulates active plat_t interpreted
        // as door. TODO: add our own overflow handling class.
         door = ((plat_t)sec.specialdata).asVlDoor(LL.sectors);
        	  else
         door = (vldoor_t) sec.specialdata;
         switch(line.special)
         {
           case  1: // ONLY FOR "RAISE" DOORS, NOT "OPEN"s
           case  26:
           case  27:
           case  28:
           case  117:
             if (door.direction == -1)
             door.direction = 1; // go back up
             else
             {
             if (thing.player==null)
                 return;     // JDC: bad guys never close doors
             
             door.direction = -1;    // start going down immediately
             }
             return;
         }
          }
         
          // for proper sound
          switch(line.special)
          {
            case 117:    // BLAZING DOOR RAISE
            case 118:    // BLAZING DOOR OPEN
            	S.StartSound(sec.soundorg,sfxenum_t.sfx_bdopn);
         break;
         
            case 1:  // NORMAL DOOR SOUND
            case 31:
            	S.StartSound(sec.soundorg,sfxenum_t.sfx_doropn);
         break;
         
            default: // LOCKED DOOR SOUND
            	S.StartSound(sec.soundorg,sfxenum_t.sfx_doropn);
         break;
          }
         
          
          // new door thinker
          door = new vldoor_t();
          sec.specialdata = door;
          door.function = think_t.T_VerticalDoor;
          AddThinker (door);
          door.sector = sec;
          door.direction = 1;
          door.speed = VDOORSPEED;
          door.topwait = VDOORWAIT;

          switch(line.special)
          {
            case 1:
            case 26:
            case 27:
            case 28:
         door.type = vldoor_e.normal;
         break;
         
            case 31:
            case 32:
            case 33:
            case 34:
         door.type = vldoor_e.open;
         line.special = 0;
         break;
         
            case 117:    // blazing door raise
         door.type = vldoor_e.blazeRaise;
         door.speed = VDOORSPEED*4;
         break;
            case 118:    // blazing door open
         door.type = vldoor_e.blazeOpen;
         line.special = 0;
         door.speed = VDOORSPEED*4;
         break;
          }
          
          // find the top and bottom of the movement range
          door.topheight = sec.FindLowestCeilingSurrounding();
          door.topheight -= 4*FRACUNIT;
      }


     

  //
  // P_BulletSlope
  // Sets a slope so a near miss is at aproximately
  // the height of the intended target
  //
  int     bulletslope;


  void P_BulletSlope (mobj_t mo)
  {
      long an;

      // see which target is to be aimed at
      // FIXME: angle can already be negative here.
      // Not a problem if it's just moving about (accumulation will work)
      // but it needs to be sanitized before being used in any function.
      an = mo.angle;
      //_D_: &BITS32 will be used later in this function, by fine(co)sine()
      bulletslope = AimLineAttack (mo, an/*&BITS32*/, 16*64*FRACUNIT);

      if (!eval(linetarget))
      {
          an += 1<<26;
          bulletslope = AimLineAttack (mo, an/*&BITS32*/, 16*64*FRACUNIT);
          if (!eval(linetarget))
          {
              an -= 2<<26;
              bulletslope = AimLineAttack (mo, an/*&BITS32*/, 16*64*FRACUNIT);
          }
          
          // Give it one more try, with freelook
          if (mo.player.lookdir!=0 && !eval(linetarget)) 
          {
              an += 2<<26;
              an&=BITS32;
              bulletslope = (mo.player.lookdir<<FRACBITS)/173;
          }
      }
  }


  //
  // P_GunShot
  //
  void
  P_GunShot
  ( mobj_t   mo,
    boolean   accurate )
  {
      long angle;
      int     damage;
      
      damage = 5*(RND.P_Random ()%3+1);
      angle = mo.angle;

      if (!accurate)
      angle += (RND.P_Random()-RND.P_Random())<<18;

      LineAttack (mo, angle, MISSILERANGE, bulletslope, damage);
  }

    boolean Move (mobj_t actor)
    {
        // fixed_t
        int tryx;
        int tryy;
        
        line_t ld;
        
        // warning: 'catch', 'throw', and 'try'
        // are all C++ reserved words
        boolean try_ok;
        boolean good;
            
        if (actor.movedir == DI_NODIR)
        return false;
            
        if (actor.movedir >= 8)
        I.Error ("Weird actor.movedir!");
            
        tryx = actor.x + actor.info.speed*xspeed[actor.movedir];
        tryy = actor.y + actor.info.speed*yspeed[actor.movedir];

        try_ok = TryMove (actor, tryx, tryy);

        if (!try_ok)
        {
        // open any specials
        if (eval(actor.flags & MF_FLOAT) && floatok)
        {
            // must adjust height
            if (actor.z < tmfloorz)
            actor.z += FLOATSPEED;
            else
            actor.z -= FLOATSPEED;

            actor.flags |= MF_INFLOAT;
            return true;
        }
            
        if (numspechit==0)
            return false;
                
        actor.movedir = DI_NODIR;
        good = false;
        while ((numspechit--)>0)
        {
            ld = spechit[numspechit];
            // if the special is not a door
            // that can be opened,
            // return false
            if (UseSpecialLine (actor, ld,false))
            good = true;
        }
        return good;
        }
        else
        {
        actor.flags &= ~MF_INFLOAT;
        }
        
        
        if (! eval(actor.flags & MF_FLOAT) )   
        actor.z = actor.floorz;
        return true; 
    }

    //dirtype
    private int d1,d2;
    
    void NewChaseDir (mobj_t actor)
    {
        // fixed_t
        int deltax,deltay;        
        
        int     tdir;
        int   olddir;
        // dirtypes
        int   turnaround;

        if (actor.target==null)
        I.Error ("P_NewChaseDir: called with no target");
            
        olddir = actor.movedir;
        turnaround=opposite[olddir];

        deltax = actor.target.x - actor.x;
        deltay = actor.target.y - actor.y;

        if (deltax>10*FRACUNIT)
        d1= DI_EAST;
        else if (deltax<-10*FRACUNIT)
        d1= DI_WEST;
        else
        d1=DI_NODIR;

        if (deltay<-10*FRACUNIT)
        d2= DI_SOUTH;
        else if (deltay>10*FRACUNIT)
        d2= DI_NORTH;
        else
        d2=DI_NODIR;

        // try direct route
        if (d1 != DI_NODIR
        && d2 != DI_NODIR)
        {
        actor.movedir = diags[(eval(deltay<0)<<1)+eval(deltax>0)];
        if (actor.movedir != turnaround && TryWalk(actor))
            return;
        }

        // try other directions
        if (RND.P_Random() > 200
        ||  Math.abs(deltay)>Math.abs(deltax))
        {
        tdir=d1;
        d1=d2;
        d2=tdir;
        }

        if (d1==turnaround)
        d1=DI_NODIR;
        if (d2==turnaround)
        d2=DI_NODIR;
        
        if (d1!=DI_NODIR)
        {
        actor.movedir = d1;
        if (TryWalk(actor))
        {
            // either moved forward or attacked
            return;
        }
        }

        if (d2!=DI_NODIR)
        {
        actor.movedir =d2;

        if (TryWalk(actor))
            return;
        }

        // there is no direct path to the player,
        // so pick another direction.
        if (olddir!=DI_NODIR)
        {
        actor.movedir =olddir;

        if (TryWalk(actor))
            return;
        }

        // randomly determine direction of search
        if (eval(RND.P_Random()&1))   
        {
        for ( tdir=DI_EAST;
              tdir<=DI_SOUTHEAST;
              tdir++ )
        {
            if (tdir!=turnaround)
            {
            actor.movedir =tdir;
            
            if ( TryWalk(actor) )
                return;
            }
        }
        }
        else
        {
        for ( tdir=DI_SOUTHEAST;
              tdir != (DI_EAST-1);
              tdir-- )
        {
            if (tdir!=turnaround)
            {
            actor.movedir =tdir;
            
            if ( TryWalk(actor) )
                return;
            }
        }
        }

        if (turnaround !=  DI_NODIR)
        {
        actor.movedir =turnaround;
        if ( TryWalk(actor) )
            return;
        }

        actor.movedir = DI_NODIR;  // can not move
    }
    

    /**
     * TryWalk
     * Attempts to move actor on
     * in its current (ob.moveangle) direction.
     * If blocked by either a wall or an actor
     * returns FALSE
     * If move is either clear or blocked only by a door,
     * returns TRUE and sets...
     * If a door is in the way,
     * an OpenDoor call is made to start it opening.
     */
    private boolean TryWalk (mobj_t actor)
    {   
        if (!Move (actor))
        {
        return false;
        }

        actor.movecount = RND.P_Random()&15;
        return true;
    }

/**
 * P_NightmareRespawn
 */
void
NightmareRespawn (mobj_t mobj)
{
int     x,y, z; // fixed 
subsector_t    ss; 
mobj_t     mo;
mapthing_t     mthing;
  
x = mobj.spawnpoint.x << FRACBITS; 
y = mobj.spawnpoint.y << FRACBITS; 

// somthing is occupying it's position?
if (!CheckPosition (mobj, x, y) ) 
return; // no respwan

// spawn a teleport fog at old spot
// because of removal of the body?
mo = SpawnMobj (mobj.x,
        mobj.y,
        mobj.subsector.sector.floorheight , mobjtype_t.MT_TFOG); 
// initiate teleport sound
S.StartSound(mo, sfxenum_t.sfx_telept);

// spawn a teleport fog at the new spot
ss = LL.PointInSubsector (x,y); 

mo = SpawnMobj (x, y, ss.sector.floorheight , mobjtype_t.MT_TFOG); 

S.StartSound(mo, sfxenum_t.sfx_telept);

// spawn the new monster
mthing = mobj.spawnpoint;

// spawn it
if (eval(mobj.info.flags & MF_SPAWNCEILING))
z = ONCEILINGZ;
else
z = ONFLOORZ;

// inherit attributes from deceased one
mo = SpawnMobj (x,y,z, mobj.type);
mo.spawnpoint = mobj.spawnpoint;  
mo.angle = ANG45 * (mthing.angle/45);

if (eval(mthing.options & MTF_AMBUSH))
mo.flags |= MF_AMBUSH;

mo.reactiontime = 18;

// remove the old monster,
RemoveMobj (mobj);
}

/** P_SpawnMobj
 * 
 * @param x fixed
 * @param y fixed
 * @param z fixed
 * @param type
 * @return
 */

public mobj_t
SpawnMobj
( int   x,
        int   y,
        int   z,
mobjtype_t    type )
{
mobj_t mobj;
state_t    st;
mobjinfo_t info;

// MAES: I tried this approach but it's not really worth it.
// Testing with NUTS.WAD yielded pretty much identical results,
// and that was without using locking. Just let the GC do its
// job.
// mobj = mobjpool.checkOut();
mobj=new mobj_t(this);
info = mobjinfo[type.ordinal()];

mobj.type = type;
mobj.info = info;
mobj.x = x;
mobj.y = y;
mobj.radius = info.radius;
mobj.height = info.height;
mobj.flags = info.flags;
mobj.health = info.spawnhealth;

if (DM.gameskill != skill_t.sk_nightmare)
mobj.reactiontime = info.reactiontime;

mobj.lastlook = RND.P_Random () % MAXPLAYERS;
// do not set the state with P_SetMobjState,
// because action routines can not be called yet
st = states[info.spawnstate.ordinal()];

mobj.state = st;
mobj.tics = st.tics;
mobj.sprite = st.sprite;
mobj.frame = st.frame;

// set subsector and/or block links
LL.SetThingPosition (mobj);

mobj.floorz = mobj.subsector.sector.floorheight;
mobj.ceilingz = mobj.subsector.sector.ceilingheight;

if (z == ONFLOORZ)
mobj.z = mobj.floorz;
else if (z == ONCEILINGZ)
mobj.z = mobj.ceilingz - mobj.info.height;
else 
mobj.z = z;

mobj.function=think_t.P_MobjThinker;
AddThinker (mobj);

return mobj;
}

/**
 * P_RespawnSpecials
 */

void RespawnSpecials ()
{
int     x, y,z; // fixed

subsector_t    ss; 
mobj_t     mo;
mapthing_t     mthing;

int         i;

// only respawn items in deathmatch (deathmatch!=2)
if (!DM.altdeath)
return; // 

// nothing left to respawn?
if (iquehead == iquetail)
return;     

// wait at least 30 seconds
if (DM.leveltime - itemrespawntime[iquetail] < 30*35)
return;         

mthing = itemrespawnque[iquetail];

x = mthing.x << FRACBITS; 
y = mthing.y << FRACBITS; 

// spawn a teleport fog at the new spot
ss = LL.PointInSubsector (x,y); 
mo = SpawnMobj (x, y, ss.sector.floorheight , mobjtype_t.MT_IFOG); 
S.StartSound(mo, sfxenum_t.sfx_itmbk);

// find which type to spawn
for (i=0 ; i< mobjtype_t.NUMMOBJTYPES.ordinal() ; i++)
{
if (mthing.type == mobjinfo[i].doomednum)
  break;
}

// spawn it
if (eval(mobjinfo[i].flags &MF_SPAWNCEILING))
z = ONCEILINGZ;
else
z = ONFLOORZ;

mo = SpawnMobj (x,y,z, mobjtype_t.values()[i]);
mo.spawnpoint = mthing;   
mo.angle = ANG45 * (mthing.angle/45);

// pull it from the que
iquetail = (iquetail+1)&(ITEMQUESIZE-1);
}

/**
 * P_SpawnPlayer
 * Called when a player is spawned on the level.
 * Most of the player structure stays unchanged
 *  between levels.
 */
public void SpawnPlayer (mapthing_t mthing)
{
player_t       p;
int     x;
int     y;
int     z;

mobj_t     mobj;

int         i;

// not playing?
if (!DM.playeringame[mthing.type-1])
return;                 
  
p = DM.players[mthing.type-1];

if (p.playerstate == PST_REBORN)
	p.PlayerReborn();
//DM.PlayerReborn (mthing.type-1);

x       = mthing.x << FRACBITS;
y       = mthing.y << FRACBITS;
z       = ONFLOORZ;
mobj    = SpawnMobj (x,y,z, mobjtype_t.MT_PLAYER);

// set color translations for player sprites
if (mthing.type > 1)       
mobj.flags |= (mthing.type-1)<<MF_TRANSSHIFT;
  
mobj.angle = ANG45 * (mthing.angle/45);
mobj.player = p;
mobj.health = p.health[0];

p.mo = mobj;
p.playerstate = PST_LIVE;  
p.refire = 0;
p.message = null;
p.damagecount = 0;
p.bonuscount = 0;
p.extralight = 0;
p.fixedcolormap = 0;
p.viewheight = VIEWHEIGHT;

// setup gun psprite
p.SetupPsprites ();

// give all cards in death match mode
if (DM.deathmatch)
for (i=0 ; i<NUMCARDS ; i++)
  p.cards[i] = true;
      
if (mthing.type-1 == DM.consoleplayer)
{
// wake up the status bar
ST.Start ();
// wake up the heads up text
HU.Start ();        
}
}

/**
 * P_SpawnMapThing
 * The fields of the mapthing should
 * already be in host byte order.
 */

mobj_t SpawnMapThing (mapthing_t mthing)
{
int         i;
int         bit;
mobj_t     mobj;
int     x;
int     y;
int     z;

// count deathmatch start positions
if (mthing.type == 11)
{
if (DM.deathmatch_p < 10/*DM.deathmatchstarts[10]*/)
{
 // memcpy (deathmatch_p, mthing, sizeof(*mthing));
    DM.deathmatchstarts[DM.deathmatch_p]=new mapthing_t(mthing);
  DM.deathmatch_p++;
}
return null;
}

if (mthing.type <= 0)
{
    // Ripped from Chocolate Doom :-p
	// Thing type 0 is actually "player -1 start".  
    // For some reason, Vanilla Doom accepts/ignores this.
	// MAES: no kidding.

    return null;
}


// check for players specially
if (mthing.type <= 4 && mthing.type > 0)  // killough 2/26/98 -- fix crashes
{
// save spots for respawning in network games
DM.playerstarts[mthing.type-1]=new mapthing_t(mthing);
if (!DM.deathmatch)
  SpawnPlayer (mthing);

return null;
}

// check for apropriate skill level
if (!DM.netgame && eval(mthing.options & 16) )
return null;
  
if (DM.gameskill == skill_t.sk_baby)
bit = 1;
else if (DM.gameskill == skill_t.sk_nightmare)
bit = 4;
else
bit = 1<<(DM.gameskill.ordinal()-1);

if (!eval(mthing.options & bit) )
return null;

// find which type to spawn
for (i=0 ; i< NUMMOBJTYPES ; i++)
if (mthing.type == mobjinfo[i].doomednum)
  break;

// phares 5/16/98:
// Do not abort because of an unknown thing. Ignore it, but post a
// warning message for the player.

if (i==NUMMOBJTYPES) {
System.err.printf ("P_SpawnMapThing: Unknown type %d at (%d, %d)",
   mthing.type,
   mthing.x, mthing.y);
   return null;
}
  
// don't spawn keycards and players in deathmatch
if (DM.deathmatch && eval(mobjinfo[i].flags & MF_NOTDMATCH))
return null;
  
// don't spawn any monsters if -nomonsters
if (DM.nomonsters
&& ( i == mobjtype_t.MT_SKULL.ordinal()
   || eval(mobjinfo[i].flags & MF_COUNTKILL)) )
{
return null;
}

// spawn it
x = mthing.x << FRACBITS;
y = mthing.y << FRACBITS;

if (eval(mobjinfo[i].flags & MF_SPAWNCEILING))
z = ONCEILINGZ;
else
z = ONFLOORZ;

mobj = SpawnMobj (x,y,z, mobjtype_t.values()[i]);
mobj.spawnpoint.copyFrom(mthing);

if (mobj.tics > 0)
mobj.tics = 1 + (RND.P_Random () % mobj.tics);
if (eval(mobj.flags & MF_COUNTKILL))
DM.totalkills++;
if (eval(mobj.flags & MF_COUNTITEM))
DM.totalitems++;
  
mobj.angle = ANG45 * (mthing.angle/45);
if (eval(mthing.options & MTF_AMBUSH))
mobj.flags |= MF_AMBUSH;

return mobj;

}

/** P_SpawnBlood
 * 
 * @param x fixed
 * @param y fixed
 * @param z fixed
 * @param damage
 */

void
SpawnBlood
( int   x,
        int   y,
        int   z,
int       damage )
{
mobj_t th;

z += ((RND.P_Random()-RND.P_Random())<<10);
th = SpawnMobj (x,y,z, mobjtype_t.MT_BLOOD);
th.momz = FRACUNIT*2;
th.tics -= RND.P_Random()&3;

if (th.tics < 1)
th.tics = 1;
  
if (damage <= 12 && damage >= 9)
    th.SetMobjState (statenum_t.S_BLOOD2);
else if (damage < 9)
    th.SetMobjState (statenum_t.S_BLOOD3);
}

/** P_SpawnPuff
 * 
 * @param x fixed
 * @param y fixed
 * @param z fixed
 * 
 */

void
SpawnPuff
( int   x,
int   y,
int   z )
{
mobj_t th;

z += ((RND.P_Random()-RND.P_Random())<<10);

th = SpawnMobj (x,y,z, mobjtype_t.MT_PUFF);
th.momz = FRACUNIT;
th.tics -= RND.P_Random()&3;

if (th.tics < 1)
th.tics = 1;

// don't make punches spark on the wall
if (attackrange == MELEERANGE)
    th.SetMobjState (statenum_t.S_PUFF3);
}

/**
 * P_SpawnMissile
 */

protected mobj_t
SpawnMissile
( mobj_t   source,
mobj_t   dest,
mobjtype_t    type )
{
mobj_t th;
long an; // angle_t
int     dist;

th = SpawnMobj (source.x,
        source.y,
        source.z + 4*8*FRACUNIT, type);

if (th.info.seesound!=null)
	S.StartSound(th, th.info.seesound);

th.target = source;    // where it came from
an = R.PointToAngle2 (source.x, source.y, dest.x, dest.y)&BITS32;  

// fuzzy player
if (eval(dest.flags & MF_SHADOW))
an += (RND.P_Random()-RND.P_Random())<<20; 

th.angle = an&BITS32;
//an >>= ANGLETOFINESHIFT;
th.momx = FixedMul (th.info.speed, finecosine(an));
th.momy = FixedMul (th.info.speed, finesine(an));

dist = AproxDistance (dest.x - source.x, dest.y - source.y);
dist = dist / th.info.speed;

if (dist < 1)
dist = 1;

th.momz = (dest.z - source.z) / dist;
CheckMissileSpawn (th);

return th;
}


/**
* P_SpawnPlayerMissile
* Tries to aim at a nearby monster
*/

    public void SpawnPlayerMissile(mobj_t source, mobjtype_t type) {
        mobj_t th;
        long an; // angle_t
        int x, y, z, slope; // think_t

        // see which target is to be aimed at
        an = source.angle;
        slope = AimLineAttack(source, an, 16 * 64 * FRACUNIT);

        if (linetarget == null) {
            an += 1 << 26;
            an &= BITS32;
            slope = AimLineAttack(source, an, 16 * 64 * FRACUNIT);

            if (linetarget == null) {
                an -= 2 << 26;
                an &= BITS32;
                slope = AimLineAttack(source, an, 16 * 64 * FRACUNIT);
            }

            if (linetarget == null) {
                an = source.angle & BITS32;
                // angle should be "sane"..right?
                // Just this line allows freelook.
                slope = ((source.player.lookdir)<<FRACBITS)/173;
            }
        }

        x = source.x;
        y = source.y;
        z = source.z + 4 * 8 * FRACUNIT+slope;

        th = SpawnMobj(x, y, z, type);

        if (th.info.seesound != null)
            S.StartSound(th, th.info.seesound);

        th.target = source;
        th.angle = an;
        th.momx = FixedMul(th.info.speed, finecosine(an));
        th.momy = FixedMul(th.info.speed, finesine(an));
        th.momz = FixedMul(th.info.speed, slope);

        CheckMissileSpawn(th);
    }

    //
    // P_DamageMobj
    // Damages both enemies and players
    // "inflictor" is the thing that caused the damage
    //  creature or missile, can be NULL (slime, etc)
    // "source" is the thing to target after taking damage
    //  creature or NULL
    // Source and inflictor are the same for melee attacks.
    // Source can be NULL for slime, barrel explosions
    // and other environmental stuff.
    //
    public void
    DamageMobj
    ( mobj_t   target,
      mobj_t   inflictor,
      mobj_t   source,
      int       damage )
    {
        long    ang; // unsigned
        int     saved;
        player_t   player;
        int thrust; // fixed_t
        int     temp;
        
        if ( !eval(target.flags& MF_SHOOTABLE))
        return; // shouldn't happen...
            
        if (target.health <= 0)
        return;

        if ( eval(target.flags & MF_SKULLFLY ))
        {
        target.momx = target.momy = target.momz = 0;
        }
        
        player = target.player;
        if ((player!=null) && DM.gameskill == skill_t.sk_baby)
        damage >>= 1;   // take half damage in trainer mode
            

        // Some close combat weapons should not
        // inflict thrust and push the victim out of reach,
        // thus kick away unless using the chainsaw.
        if ((inflictor !=null)
        && !eval(target.flags& MF_NOCLIP)
        && (source==null
            || source.player==null
            || source.player.readyweapon != weapontype_t.wp_chainsaw))
        {
        ang = R.PointToAngle2 ( inflictor.x,
                    inflictor.y,
                    target.x,
                    target.y)&BITS32;
            
        thrust = damage*(MAPFRACUNIT>>3)*100/target.info.mass;

        // make fall forwards sometimes
        if ( (damage < 40)
             && (damage > target.health)
             && (target.z - inflictor.z > 64*FRACUNIT)
             && eval(RND.P_Random()&1) )
        {
            ang += ANG180;
            thrust *= 4;
        }
            
        //ang >>= ANGLETOFINESHIFT;
        target.momx += FixedMul (thrust, finecosine(ang));
        target.momy += FixedMul (thrust, finesine(ang));
        }
        
        // player specific
        if (player!=null)
        {
        // end of game hell hack
        if (target.subsector.sector.special == 11
            && damage >= target.health)
        {
            damage = target.health - 1;
        }
        

        // Below certain threshold,
        // ignore damage in GOD mode, or with INVUL power.
        if ( damage < 1000
             && ( eval(player.cheats&player_t.CF_GODMODE))
              || player.powers[pw_invulnerability]!=0 ) 
        {
            return;
        }
        
        if (player.armortype!=0)
        {
            if (player.armortype == 1)
            saved = damage/3;
            else
            saved = damage/2;
            
            if (player.armorpoints[0] <= saved)
            {
            // armor is used up
            saved = player.armorpoints[0];
            player.armortype = 0;
            }
            player.armorpoints[0] -= saved;
            damage -= saved;
        }
        player.health[0] -= damage;   // mirror mobj health here for Dave
        if (player.health[0] < 0)
            player.health[0] = 0;
        
        player.attacker = source;
        player.damagecount += damage;  // add damage after armor / invuln

        if (player.damagecount > 100)
            player.damagecount = 100;  // teleport stomp does 10k points...
        
        temp = damage < 100 ? damage : 100;

        if (player == DM.players[DM.consoleplayer]) 
            I.Tactile (40,10,40+temp*2);
        }
        
        // do the damage    
        target.health -= damage;   
        if (target.health <= 0)
        {
        KillMobj (source, target);
        return;
        }

        if ( (RND.P_Random () < target.info.painchance)
         && !eval(target.flags&MF_SKULLFLY) )
        {
        target.flags |= MF_JUSTHIT;    // fight back!
        
        target.SetMobjState (target.info.painstate);
        }
                
        target.reactiontime = 0;       // we're awake now...   

        if ( ((target.threshold==0) || (target.type == mobjtype_t.MT_VILE))
         && (source!=null) && (source != target)
         && (source.type != mobjtype_t.MT_VILE))
        {
        // if not intent on another player,
        // chase after this one
        target.target = source;        
        target.threshold = BASETHRESHOLD;
        if (target.state == states[target.info.spawnstate.ordinal()]
            && target.info.seestate != statenum_t.S_NULL)
            target.SetMobjState (target.info.seestate);
        }
                
    }
    
    //
    // KillMobj
    //
    public void
    KillMobj
    ( mobj_t   source,
      mobj_t   target )
    {
        mobjtype_t  item;
        mobj_t mo;
        
        // Maes: this seems necessary in order for barrel damage
        // to propagate inflictors.
        target.target=source;
        
        target.flags &= ~(MF_SHOOTABLE|MF_FLOAT|MF_SKULLFLY);

        if (target.type != mobjtype_t.MT_SKULL)
        target.flags &= ~MF_NOGRAVITY;

        target.flags |= MF_CORPSE|MF_DROPOFF;
        target.height >>= 2;

        if (source!=null && source.player!=null)
        {
        // count for intermission
        if ((target.flags & MF_COUNTKILL)!=0)
            source.player.killcount++;    

        if (target.player!=null) //; <-- _D_: that semicolon caused a bug!
           source.player.frags[target.player.identify()]++;
           // It's probably intended to increment the frags of source player vs target player. Lookup? 
        }
        else if (!DM.netgame && ((target.flags & MF_COUNTKILL)!=0) )
        {
        // count all monster deaths,
        // even those caused by other monsters
        DM.players[0].killcount++;
        }
        
        if (target.player!=null)
        {
        // count environment kills against you
        if (source==null)    
            // TODO: some way to indentify which one of the 
            // four possiblelayers is the current player
            
            target.player.frags[target.player.identify()]++;
                
        target.flags &= ~MF_SOLID;
        target.player.playerstate = PST_DEAD;
        target.player.DropWeapon (); // in PSPR

        if (target.player == DM.players[DM.consoleplayer]
            && DM.automapactive)
        {
            // don't die in auto map,
            // switch view prior to dying
            AM.Stop ();
        }
        
        }

        if (target.health < -target.info.spawnhealth 
        && target.info.xdeathstate!=statenum_t.S_NULL)
        {
            target.SetMobjState(target.info.xdeathstate);
        }
        else
            target.SetMobjState (target.info.deathstate);
        target.tics -= RND.P_Random()&3;

        if (target.tics < 1)
        target.tics = 1;
            
        //  I_StartSound (&actor.r, actor.info.deathsound);

        // Drop stuff.
        // This determines the kind of object spawned
        // during the death frame of a thing.
        switch (target.type)
        {
          case MT_WOLFSS:
          case MT_POSSESSED:
        item = mobjtype_t.MT_CLIP;
        break;
        
          case MT_SHOTGUY:
        item = mobjtype_t.MT_SHOTGUN;
        break;
        
          case MT_CHAINGUY:
        item = mobjtype_t.MT_CHAINGUN;
        break;
        
          default:
        return;
        }

        mo = SpawnMobj (target.x,target.y,ONFLOORZ, item);
        mo.flags |= MF_DROPPED;    // special versions of items
    }
    
  //
 // TELEPORTATION
 //
 int
 Teleport
 ( line_t    line,
   int       side,
   mobj_t    thing )
 {
     int     i;
     int     tag;
     mobj_t  m;     
     mobj_t  fog;
     int an;
     thinker_t   thinker;
     sector_t    sector;
     int oldx, oldy, oldz; // fixed_t

     // don't teleport missiles
     if ((thing.flags & MF_MISSILE)!=0)
     return 0;       

     // Don't teleport if hit back of line,
     //  so you can get out of teleporter.
     if (side == 1)      
     return 0;   

     
     tag = line.tag;
     for (i = 0; i < LL.numsectors; i++)
     {
     if (LL.sectors[ i ].tag == tag )
     {
         thinker = thinkercap.next;
         for (thinker = thinkercap.next;
          thinker != thinkercap;
          thinker = thinker.next)
         {
         // not a mobj
         if (thinker.function != think_t.P_MobjThinker)
             continue;   

         m = (mobj_t)thinker;
         
         // not a teleportman
         if (m.type != mobjtype_t.MT_TELEPORTMAN )
             continue;       

         sector = m.subsector.sector;
         // wrong sector
         if (sector.id != i )
             continue;   

         oldx = thing.x;
         oldy = thing.y;
         oldz = thing.z;
                 
         if (!TeleportMove (thing, m.x, m.y))
             return 0;
         
         thing.z = thing.floorz;  //fixme: not needed?
         if (thing.player!=null) {
             thing.player.viewz = thing.z+thing.player.viewheight;
             thing.player.lookdir = 0; // Reset lookdir
         }
                 
         // spawn teleport fog at source and destination
         fog = SpawnMobj (oldx, oldy, oldz, mobjtype_t.MT_TFOG);
         S.StartSound( fog, sfxenum_t.sfx_telept);
         an = Tables.toBAMIndex(m.angle);
         fog = SpawnMobj (m.x+20*finecosine[an], m.y+20*finesine[an]
                    , thing.z, mobjtype_t.MT_TFOG);

         // emit sound, where?
         S.StartSound (fog, sfxenum_t.sfx_telept);
         
         // don't move for a bit
         if (thing.player!=null)
             thing.reactiontime = 18;   

         thing.angle = m.angle;
         thing.momx = thing.momy = thing.momz = 0;
         return 1;
         }   
     }
     }
     return 0;
 }
 
 //
//EVENTS
//Events are operations triggered by using, crossing,
//or shooting special lines, or by timed thinkers.
//

/**
* P_CrossSpecialLine - TRIGGER
* Called every time a thing origin is about
*  to cross a line with a non 0 special.
*/

void
CrossSpecialLine
( line_t       line,
int       side,
mobj_t  thing )
{
  //line_t line;
  boolean     ok;

  //line = LL.lines[linenum];
  
  //  Triggers that other things can activate
  if (thing.player==null)
  {
  // Things that should NOT trigger specials...
  switch(thing.type)
  {
    case MT_ROCKET:
    case MT_PLASMA:
    case MT_BFG:
    case MT_TROOPSHOT:
    case MT_HEADSHOT:
    case MT_BRUISERSHOT:
      return;
     // break;
      
    default: break;
  }
      
  ok = false;
  switch(line.special)
  {
    case 39:  // TELEPORT TRIGGER
    case 97:  // TELEPORT RETRIGGER
    case 125: // TELEPORT MONSTERONLY TRIGGER
    case 126: // TELEPORT MONSTERONLY RETRIGGER
    case 4:   // RAISE DOOR
    case 10:  // PLAT DOWN-WAIT-UP-STAY TRIGGER
    case 88:  // PLAT DOWN-WAIT-UP-STAY RETRIGGER
      ok = true;
      break;
  }
  if (!ok)
      return;
  }

  
  // Note: could use some const's here.
  switch (line.special)
  {
  // TRIGGERS.
  // All from here to RETRIGGERS.
    case 2:
  // Open Door
  DoDoor(line,vldoor_e.open);
  line.special = 0;
  break;

    case 3:
  // Close Door
  DoDoor(line,vldoor_e.close);
  line.special = 0;
  break;

    case 4:
  // Raise Door
  DoDoor(line,vldoor_e.normal);
  line.special = 0;
  break;
  
    case 5:
  // Raise Floor
  DoFloor(line,floor_e.raiseFloor);
  line.special = 0;
  break;
  
    case 6:
  // Fast Ceiling Crush & Raise
  DoCeiling(line,ceiling_e.fastCrushAndRaise);
  line.special = 0;
  break;
  
    case 8:
  // Build Stairs
  BuildStairs(line,stair_e.build8);
  line.special = 0;
  break;
  
    case 10:
  // PlatDownWaitUp
  PEV.DoPlat(line,plattype_e.downWaitUpStay,0);
  line.special = 0;
  break;
  
    case 12:
  // Light Turn On - brightest near
  LEV.LightTurnOn(line,0);
  line.special = 0;
  break;
  
    case 13:
  // Light Turn On 255
  LEV.LightTurnOn(line,255);
  line.special = 0;
  break;
  
    case 16:
  // Close Door 30
  DoDoor(line,vldoor_e.close30ThenOpen);
  line.special = 0;
  break;
  
    case 17:
  // Start Light Strobing
  LEV.StartLightStrobing(line);
  line.special = 0;
  break;
  
    case 19:
  // Lower Floor
  DoFloor(line,floor_e.lowerFloor);
  line.special = 0;
  break;
  
    case 22:
  // Raise floor to nearest height and change texture
  PEV.DoPlat(line,plattype_e.raiseToNearestAndChange,0);
  line.special = 0;
  break;
  
    case 25:
  // Ceiling Crush and Raise
  DoCeiling(line,ceiling_e.crushAndRaise);
  line.special = 0;
  break;
  
    case 30:
  // Raise floor to shortest texture height
  //  on either side of lines.
  DoFloor(line,floor_e.raiseToTexture);
  line.special = 0;
  break;
  
    case 35:
  // Lights Very Dark
  LEV.LightTurnOn(line,35);
  line.special = 0;
  break;
  
    case 36:
  // Lower Floor (TURBO)
  DoFloor(line,floor_e.turboLower);
  line.special = 0;
  break;
  
    case 37:
  // LowerAndChange
  DoFloor(line,floor_e.lowerAndChange);
  line.special = 0;
  break;
  
    case 38:
  // Lower Floor To Lowest
  DoFloor( line, floor_e.lowerFloorToLowest );
  line.special = 0;
  break;
  
    case 39:
  // TELEPORT!
  Teleport( line, side, thing );
  line.special = 0;
  break;

    case 40:
  // RaiseCeilingLowerFloor
  DoCeiling( line, ceiling_e.raiseToHighest );
  DoFloor( line, floor_e.lowerFloorToLowest );
  line.special = 0;
  break;
  
    case 44:
  // Ceiling Crush
  DoCeiling( line, ceiling_e.lowerAndCrush );
  line.special = 0;
  break;
  
    case 52:
  // EXIT!
  DM.ExitLevel ();
  break;
  
    case 53:
  // Perpetual Platform Raise
  PEV.DoPlat(line,plattype_e.perpetualRaise,0);
  line.special = 0;
  break;
  
    case 54:
  // Platform Stop
  PEV.StopPlat(line);
  line.special = 0;
  break;

    case 56:
  // Raise Floor Crush
  DoFloor(line,floor_e.raiseFloorCrush);
  line.special = 0;
  break;

    case 57:
  // Ceiling Crush Stop
  CeilingCrushStop(line);
  line.special = 0;
  break;
  
    case 58:
  // Raise Floor 24
  DoFloor(line,floor_e.raiseFloor24);
  line.special = 0;
  break;

    case 59:
  // Raise Floor 24 And Change
  DoFloor(line,floor_e.raiseFloor24AndChange);
  line.special = 0;
  break;
  
    case 104:
  // Turn lights off in sector(tag)
  LEV.TurnTagLightsOff(line);
  line.special = 0;
  break;
  
    case 108:
  // Blazing Door Raise (faster than TURBO!)
  DoDoor (line,vldoor_e.blazeRaise);
  line.special = 0;
  break;
  
    case 109:
  // Blazing Door Open (faster than TURBO!)
        DoDoor (line,vldoor_e.blazeOpen);
  line.special = 0;
  break;
  
    case 100:
  // Build Stairs Turbo 16
  BuildStairs(line,stair_e.turbo16);
  line.special = 0;
  break;
  
    case 110:
  // Blazing Door Close (faster than TURBO!)
  DoDoor (line,vldoor_e.blazeClose);
  line.special = 0;
  break;

    case 119:
  // Raise floor to nearest surr. floor
  DoFloor(line,floor_e.raiseFloorToNearest);
  line.special = 0;
  break;
  
    case 121:
  // Blazing PlatDownWaitUpStay
  PEV.DoPlat(line,plattype_e.blazeDWUS,0);
  line.special = 0;
  break;
  
    case 124:
  // Secret EXIT
  DM.SecretExitLevel ();
  break;
      
    case 125:
  // TELEPORT MonsterONLY
  if (thing.player==null)
  {
      Teleport( line, side, thing );
      line.special = 0;
  }
  break;
  
    case 130:
  // Raise Floor Turbo
  DoFloor(line,floor_e.raiseFloorTurbo);
  line.special = 0;
  break;
  
    case 141:
  // Silent Ceiling Crush & Raise
  DoCeiling(line,ceiling_e.silentCrushAndRaise);
  line.special = 0;
  break;
  
  // RETRIGGERS.  All from here till end.
    case 72:
  // Ceiling Crush
  DoCeiling( line, ceiling_e.lowerAndCrush );
  break;

    case 73:
  // Ceiling Crush and Raise
  DoCeiling(line,ceiling_e.crushAndRaise);
  break;

    case 74:
  // Ceiling Crush Stop
  CeilingCrushStop(line);
  break;
  
    case 75:
  // Close Door
  DoDoor(line,vldoor_e.close);
  break;
  
    case 76:
  // Close Door 30
  DoDoor(line,vldoor_e.close30ThenOpen);
  break;
  
    case 77:
  // Fast Ceiling Crush & Raise
  DoCeiling(line,ceiling_e.fastCrushAndRaise);
  break;
  
    case 79:
  // Lights Very Dark
  LEV.LightTurnOn(line,35);
  break;
  
    case 80:
  // Light Turn On - brightest near
  LEV.LightTurnOn(line,0);
  break;
  
    case 81:
  // Light Turn On 255
  LEV.LightTurnOn(line,255);
  break;
  
    case 82:
  // Lower Floor To Lowest
  DoFloor( line, floor_e.lowerFloorToLowest );
  break;
  
    case 83:
  // Lower Floor
  DoFloor(line,floor_e.lowerFloor);
  break;

    case 84:
  // LowerAndChange
  DoFloor(line,floor_e.lowerAndChange);
  break;

    case 86:
  // Open Door
  DoDoor(line,vldoor_e.open);
  break;
  
    case 87:
  // Perpetual Platform Raise
  PEV.DoPlat(line,plattype_e.perpetualRaise,0);
  break;
  
    case 88:
  // PlatDownWaitUp
  PEV.DoPlat(line,plattype_e.downWaitUpStay,0);
  break;
  
    case 89:
  // Platform Stop
  PEV.StopPlat(line);
  break;
  
    case 90:
  // Raise Door
  DoDoor(line,vldoor_e.normal);
  break;
  
    case 91:
  // Raise Floor
  DoFloor(line,floor_e.raiseFloor);
  break;
  
    case 92:
  // Raise Floor 24
  DoFloor(line,floor_e.raiseFloor24);
  break;
  
    case 93:
  // Raise Floor 24 And Change
  DoFloor(line,floor_e.raiseFloor24AndChange);
  break;
  
    case 94:
  // Raise Floor Crush
  DoFloor(line,floor_e.raiseFloorCrush);
  break;
  
    case 95:
  // Raise floor to nearest height
  // and change texture.
  PEV.DoPlat(line,plattype_e.raiseToNearestAndChange,0);
  break;
  
    case 96:
  // Raise floor to shortest texture height
  // on either side of lines.
  DoFloor(line,floor_e.raiseToTexture);
  break;
  
    case 97:
  // TELEPORT!
  Teleport( line, side, thing );
  break;
  
    case 98:
  // Lower Floor (TURBO)
  DoFloor(line,floor_e.turboLower);
  break;

    case 105:
  // Blazing Door Raise (faster than TURBO!)
  DoDoor (line,vldoor_e.blazeRaise);
  break;
  
    case 106:
  // Blazing Door Open (faster than TURBO!)
  DoDoor (line,vldoor_e.blazeOpen);
  break;

    case 107:
  // Blazing Door Close (faster than TURBO!)
  DoDoor (line,vldoor_e.blazeClose);
  break;

    case 120:
  // Blazing PlatDownWaitUpStay.
  PEV.DoPlat(line,plattype_e.blazeDWUS,0);
  break;
  
    case 126:
  // TELEPORT MonsterONLY.
  if (thing.player==null)
      Teleport( line, side, thing );
  break;
  
    case 128:
  // Raise To Nearest Floor
  DoFloor(line,floor_e.raiseFloorToNearest);
  break;
  
    case 129:
  // Raise Floor Turbo
  DoFloor(line,floor_e.raiseFloorTurbo);
  break;
  }
}

///////////////// MOVEMENT'S ACTIONS ////////////////////////
    
    /** fixed_t */
    int[]       tmbbox=new int[4];
    mobj_t      tmthing;
    long     tmflags;
    /** fixed_t */
    int     tmx,    tmy;

    /** If "floatok" true, move would be ok
        if within "tmfloorz - tmceilingz". */
    public boolean     floatok;

    /** fixed_t */
    public int     tmfloorz, tmceilingz,   tmdropoffz;

    // keep track of the line that lowers the ceiling,
    // so missiles don't explode against sky hack walls
    public line_t      ceilingline;



    public line_t[]        spechit=new line_t[MAXSPECIALCROSS];
    public int     numspechit;
    
    
    protected final void ResizeSpechits() {
        spechit=C2JUtils.resize(spechit[0],spechit,spechit.length*2);
        }
    
////////////////// PTR Traverse Interception Functions ///////////////////////    
    public class PTR_AimTraverse implements PTR_InterceptFunc{ 
        public boolean
        invoke (intercept_t in)
        {
            line_t    li;
            mobj_t     th;
            int     slope;
            int     thingtopslope;
            int     thingbottomslope;
            int     dist;
                
            if (in.isaline)
            {
            li = (line_t) in.d();
            
            if ( !eval(li.flags & ML_TWOSIDED) )
                return false;       // stop
            
            // Crosses a two sided line.
            // A two sided line will restrict
            // the possible target ranges.
            LineOpening (li);
            
            if (openbottom >= opentop)
                return false;       // stop
            
            dist = FixedMul (attackrange, in.frac);

            if (li.frontsector.floorheight != li.backsector.floorheight)
            {
                slope = FixedDiv (openbottom - shootz , dist);
                if (slope > bottomslope)
                bottomslope = slope;
            }
                
            if (li.frontsector.ceilingheight != li.backsector.ceilingheight)
            {
                slope = FixedDiv (opentop - shootz , dist);
                if (slope < topslope)
                topslope = slope;
            }
                
            if (topslope <= bottomslope)
                return false;       // stop
                    
            return true;            // shot continues
            }
            
            // shoot a thing
            th = (mobj_t) in.d();
            if (th == shootthing)
            return true;            // can't shoot self
            
            if (!eval(th.flags&MF_SHOOTABLE))
            return true;            // corpse or something

            // check angles to see if the thing can be aimed at
            dist = FixedMul (attackrange, in.frac);
            thingtopslope = FixedDiv (th.z+th.height - shootz , dist);

            if (thingtopslope < bottomslope)
            return true;            // shot over the thing

            thingbottomslope = FixedDiv (th.z - shootz, dist);

            if (thingbottomslope > topslope)
            return true;            // shot under the thing
            
            // this thing can be hit!
            if (thingtopslope > topslope)
            thingtopslope = topslope;
            
            if (thingbottomslope < bottomslope)
            thingbottomslope = bottomslope;

            aimslope = (thingtopslope+thingbottomslope)/2;
            linetarget = th;

            return false;           // don't go any farther
        	}
        }
    
    /**
     * PTR_ShootTraverse
     *
     * 9/5/2011: Accepted _D_'s fix
     */
    
    public class PTR_ShootTraverse implements PTR_InterceptFunc {
    public boolean invoke(intercept_t in){
    int     x,y,z,frac; // fixed_t
    line_t    li;
    mobj_t     th;

    int     slope,dist,thingtopslope,thingbottomslope; // fixed_t

    if (in.isaline)
    {
        li = (line_t) in.d();

        if (li.special!=0)
            ShootSpecialLine (shootthing, li);

        if ( !eval(li.flags& ML_TWOSIDED) ) 
            return gotoHitLine(in, li);

        // crosses a two sided line
        LineOpening (li);

        dist = FixedMul (attackrange, in.frac);

        if (li.frontsector.floorheight != li.backsector.floorheight)
        {
            slope = FixedDiv (openbottom - shootz , dist);
            if (slope > aimslope)
                return gotoHitLine(in, li);
        }

        if (li.frontsector.ceilingheight != li.backsector.ceilingheight)
        {
            slope = FixedDiv (opentop - shootz , dist);
            if (slope < aimslope)
                return gotoHitLine(in, li);
        }

        // shot continues
        return true;            

    }

    // shoot a thing
    th = (mobj_t) in.d();
    if (th == shootthing)
        return true;        // can't shoot self

    if (!eval(th.flags&MF_SHOOTABLE))
        return true;        // corpse or something

    // check angles to see if the thing can be aimed at
    dist = FixedMul (attackrange, in.frac);
    thingtopslope = FixedDiv (th.z+th.height - shootz , dist);

    if (thingtopslope < aimslope)
        return true;        // shot over the thing

    thingbottomslope = FixedDiv (th.z - shootz, dist);

    if (thingbottomslope > aimslope)
        return true;        // shot under the thing


    // hit thing
    // position a bit closer
    frac = in.frac - FixedDiv (10*FRACUNIT,attackrange);

    x = trace.x + FixedMul (trace.dx, frac);
    y = trace.y + FixedMul (trace.dy, frac);
    z = shootz + FixedMul (aimslope, FixedMul(frac, attackrange));

    // Spawn bullet puffs or blod spots,
    // depending on target type.
    if (eval(((mobj_t)in.d()).flags & MF_NOBLOOD))
        SpawnPuff (x,y,z);
    else
        SpawnBlood (x,y,z, la_damage);

    if (la_damage!=0)
        DamageMobj (th, shootthing, shootthing, la_damage);

    // don't go any farther
    return false;
    
    
}

//_D_: NOTE: this function was added, because replacing a goto by a boolean flag caused a bug if shooting a single sided line
protected boolean gotoHitLine(intercept_t in, line_t li) {
    int x, y, z, frac;

    // position a bit closer
    frac = in.frac - FixedDiv (4*FRACUNIT,attackrange);
    x = trace.x + FixedMul (trace.dx, frac);
    y = trace.y + FixedMul (trace.dy, frac);
    z = shootz + FixedMul (aimslope, FixedMul(frac, attackrange));

    if (li.frontsector.ceilingpic == TM.getSkyFlatNum())
    {
        // don't shoot the sky!
        if (z > li.frontsector.ceilingheight)
            return false;

        // it's a sky hack wall
        if  (li.backsector!=null && li.backsector.ceilingpic == TM.getSkyFlatNum())
            return false;       
    }

    // Spawn bullet puffs.
    SpawnPuff (x,y,z);

    // don't go any farther
    return false;   
	}
    }
    
    //
    // PTR_SlideTraverse
    //   
    
    public class PTR_SlideTraverse implements PTR_InterceptFunc{ 
    public boolean
    invoke (intercept_t in)
    {
        line_t li;
        
        if (!in.isaline)
        I.Error ("PTR_SlideTraverse: not a line?");
            
        li = (line_t) in.d();
        
        if ( ! eval(li.flags &ML_TWOSIDED) )
        {
        if (li.PointOnLineSide (slidemo.x, slidemo.y))
        {
            // don't hit the back side
            return true;        
        }
        return isblocking(in,li);
        }

        // set openrange, opentop, openbottom
        LineOpening (li);
        
        if ((openrange < slidemo.height)|| // doesn't fit
            (opentop - slidemo.z < slidemo.height)|| // mobj is too high
            (openbottom - slidemo.z > 24*FRACUNIT )) // too big a step up
        {
        if (in.frac < bestslidefrac)
        {
        secondslidefrac = bestslidefrac;
        secondslideline = bestslideline;
        bestslidefrac = in.frac;
        bestslideline = li;
        }
        
        return false;   // stop
    }
        
        else
        // this line doesn't block movement
        return true;        
        

    }
    

    private final boolean isblocking(intercept_t in, line_t li){
    // the line does block movement,
    // see if it is closer than best so far
 
    if (in.frac < bestslidefrac)
    {
    secondslidefrac = bestslidefrac;
    secondslideline = bestslideline;
    bestslidefrac = in.frac;
    bestslideline = li;
    }
    
    return false;   // stop
    }
    }
    
    //
    // USE LINES
    //


    public class PTR_UseTraverse implements PTR_InterceptFunc{
    	

    public boolean invoke (intercept_t in)
    {
        boolean     side;
        // FIXME: some sanity check here?
        line_t line=(line_t) in.d();
        
        if (line.special==0)
        {
        LineOpening (line);
        if (openrange <= 0)
        {
        	 S.StartSound(A.usething, sfxenum_t.sfx_noway);
            
            // can't use through a wall
            return false;   
        }
        // not a special line, but keep checking
        return true ;       
        }
        
        side = false;
        if (line.PointOnLineSide (A.usething.x, A.usething.y))
        side = true;
        
        //  return false;       // don't use back side
        
        A.UseSpecialLine (A.usething, line, side);

        // can't use for than one special line in a row
        return false;
    	}
    }
  
    //
    //P_BlockThingsIterator
    //
    final boolean
    BlockThingsIterator
    ( int           x,
    int           y,
    PIT_MobjFunction func)
    {
     mobj_t     mobj;
     
     if ( x<0
      || y<0
      || x>=LL.bmapwidth
      || y>=LL.bmapheight)
     {
     return true;
     }
     

     for (mobj = LL.blocklinks[y*LL.bmapwidth+x] ; mobj!=null ;
      mobj = (mobj_t) mobj.bnext)
     {
     if (!func.invoke(mobj ) )
         return false;
     }
     return true;
    }

    
    //
    // TELEPORT MOVE
    // 

    //
    // P_TeleportMove
    //
    public boolean
    TeleportMove
    ( mobj_t    thing,
      int   x, //fixed
      int   y )
    {
        int         xl;
        int         xh;
        int         yl;
        int         yh;
        int         bx;
        int         by;
        
        subsector_t newsubsec;
        
        // kill anything occupying the position
        tmthing = thing;
        tmflags = thing.flags;
        
        tmx = x;
        tmy = y;
        
        tmbbox[BOXTOP] = y + tmthing.radius;
        tmbbox[BOXBOTTOM] = y - tmthing.radius;
        tmbbox[BOXRIGHT] = x + tmthing.radius;
        tmbbox[BOXLEFT] = x - tmthing.radius;

        newsubsec = LL.PointInSubsector (x,y);
        ceilingline = null;
        
        // The base floor/ceiling is from the subsector
        // that contains the point.
        // Any contacted lines the step closer together
        // will adjust them.
        tmfloorz = tmdropoffz = newsubsec.sector.floorheight;
        tmceilingz = newsubsec.sector.ceilingheight;
                
        R.increaseValidCount(1); // This is r_main's ?
        numspechit = 0;
        
        // stomp on any things contacted
        xl = LL.getSafeBlockX(tmbbox[BOXLEFT] - LL.bmaporgx - MAXRADIUS);
        xh = LL.getSafeBlockX(tmbbox[BOXRIGHT] - LL.bmaporgx + MAXRADIUS);
        yl = LL.getSafeBlockY(tmbbox[BOXBOTTOM] - LL.bmaporgy - MAXRADIUS);
        yh = LL.getSafeBlockY(tmbbox[BOXTOP] - LL.bmaporgy + MAXRADIUS);

        for (bx=xl ; bx<=xh ; bx++)
        for (by=yl ; by<=yh ; by++)
            if (!BlockThingsIterator(bx,by,StompThing))
            return false;
        
        // the move is ok,
        // so link the thing into its new position
        UnsetThingPosition (thing);

        thing.floorz = tmfloorz;
        thing.ceilingz = tmceilingz;    
        thing.x = x;
        thing.y = y;

        LL.SetThingPosition (thing);
        
        return true;
    }

    //
    // MOVEMENT CLIPPING
    //

    /**
     * P_CheckPosition
     *  This is purely informative, nothing is modified
     *  (except things picked up).
     *  
     *  in:
     *   a mobj_t (can be valid or invalid)
     *   a position to be checked
     *    (doesn't need to be related to the mobj_t.x,y)
     * 
     *  during:
     *   special things are touched if MF_PICKUP
     *   early out on solid lines?
     * 
     *  out:
     *   newsubsec
     *   floorz
     *   ceilingz
     *   tmdropoffz
     *    the lowest point contacted
     *    (monsters won't move to a dropoff)
     *   speciallines[]
     *   numspeciallines
     * @param thing
     * @param x fixed_t
     * @param y fixed_t
    */
    public boolean
    CheckPosition
    ( mobj_t    thing,
      int   x,
      int   y )
    {
        int         xl;
        int         xh;
        int         yl;
        int         yh;
        int         bx;
        int         by;
        subsector_t newsubsec;

        tmthing = thing;
        tmflags = thing.flags;
        
        tmx = x;
        tmy = y;
        
        tmbbox[BOXTOP] = y + tmthing.radius;
        tmbbox[BOXBOTTOM] = y - tmthing.radius;
        tmbbox[BOXRIGHT] = x + tmthing.radius;
        tmbbox[BOXLEFT] = x - tmthing.radius;

        newsubsec = LL.PointInSubsector (x,y);
        ceilingline = null;
        
        // The base floor / ceiling is from the subsector
        // that contains the point.
        // Any contacted lines the step closer together
        // will adjust them.
        tmfloorz = tmdropoffz = newsubsec.sector.floorheight;
        tmceilingz = newsubsec.sector.ceilingheight;
                
        R.increaseValidCount(1);
        numspechit = 0;

        if ( eval(tmflags &MF_NOCLIP ))
        return true;
        
        // Check things first, possibly picking things up.
        // The bounding box is extended by MAXRADIUS
        // because mobj_ts are grouped into mapblocks
        // based on their origin point, and can overlap
        // into adjacent blocks by up to MAXRADIUS units.
        xl = LL.getSafeBlockX(tmbbox[BOXLEFT] - LL.bmaporgx - MAXRADIUS);
        xh = LL.getSafeBlockX(tmbbox[BOXRIGHT] - LL.bmaporgx + MAXRADIUS);
        yl = LL.getSafeBlockY(tmbbox[BOXBOTTOM] - LL.bmaporgy - MAXRADIUS);
        yh = LL.getSafeBlockY(tmbbox[BOXTOP] - LL.bmaporgy + MAXRADIUS);

        for (bx=xl ; bx<=xh ; bx++)
        for (by=yl ; by<=yh ; by++)
            if (!BlockThingsIterator(bx,by,CheckThing))
            return false;
        
        // check lines
        xl = LL.getSafeBlockX(tmbbox[BOXLEFT] - LL.bmaporgx);
        xh = LL.getSafeBlockX(tmbbox[BOXRIGHT] - LL.bmaporgx);
        yl = LL.getSafeBlockY(tmbbox[BOXBOTTOM] - LL.bmaporgy);
        yh = LL.getSafeBlockY(tmbbox[BOXTOP] - LL.bmaporgy);

        // Maes's quick and dirty blockmap extension hack
        // E.g. for an extension of 511 blocks, max negative is -1.
        // A full 512x512 blockmap doesn't have negative indexes.
        
        if (xl<=LL.blockmapxneg) xl=0x1FF&xl;         // Broke width boundary
        if (xh<=LL.blockmapxneg) xh=0x1FF&xh;    // Broke width boundary
        if (yl<=LL.blockmapyneg) yl=0x1FF&yl;        // Broke height boundary
        if (yh<=LL.blockmapyneg) yh=0x1FF&yh;   // Broke height boundary     
       
        for (bx=xl ; bx<=xh ; bx++)
        for (by=yl ; by<=yh ; by++)
            if (!BlockLinesIterator (bx,by,CheckLine))
            return false;

        return true;
    }


    /**
    // P_TryMove
    // Attempt to move to a new position,
    // crossing special lines unless MF_TELEPORT is set.
     * @param x fixed_t
     * @param y fixed_t
     * 
    */
    boolean
    TryMove
    ( mobj_t    thing,
      int   x,
      int   y )
    {
        int oldx, oldy; // fixed_t    
        boolean     side, oldside; // both were int
        line_t  ld;

        floatok = false;
        if (!CheckPosition (thing, x, y))
        return false;       // solid wall or thing
        
        if ( !eval(thing.flags& MF_NOCLIP) )
        {
        if (tmceilingz - tmfloorz < thing.height)
            return false;   // doesn't fit

        floatok = true;
        
        if ( !eval(thing.flags&MF_TELEPORT) 
             &&tmceilingz - thing.z < thing.height)
            return false;   // mobj must lower itself to fit

        if ( !eval(thing.flags&MF_TELEPORT)
             && tmfloorz - thing.z > 24*FRACUNIT )
            return false;   // too big a step up

        if ( !eval(thing.flags&(MF_DROPOFF|MF_FLOAT))
             && tmfloorz - tmdropoffz > 24*FRACUNIT )
            return false;   // don't stand over a dropoff
        }
        
        // the move is ok,
        // so link the thing into its new position
        UnsetThingPosition (thing);

        oldx = thing.x;
        oldy = thing.y;
        thing.floorz = tmfloorz;
        thing.ceilingz = tmceilingz;    
        thing.x = x;
        thing.y = y;

        LL.SetThingPosition (thing);
        
        // if any special lines were hit, do the effect
        if (! eval(thing.flags&(MF_TELEPORT|MF_NOCLIP)) )
        {
        while (numspechit-->0)
        {
            // see if the line was crossed
            ld = spechit[numspechit];
            side = ld.PointOnLineSide (thing.x, thing.y );
            oldside = ld.PointOnLineSide (oldx, oldy );
            if (side != oldside)
            {
            if (ld.special!=0)
                CrossSpecialLine (ld, oldside?1:0, thing);
            }
        }
        }

        return true;
    }


    //
    // P_ThingHeightClip
    // Takes a valid thing and adjusts the thing.floorz,
    // thing.ceilingz, and possibly thing.z.
    // This is called for all nearby monsters
    // whenever a sector changes height.
    // If the thing doesn't fit,
    // the z will be set to the lowest value
    // and false will be returned.
    //
    boolean ThingHeightClip (mobj_t thing)
    {
        boolean     onfloor;
        
        onfloor = (thing.z == thing.floorz);
        
        CheckPosition (thing, thing.x, thing.y);  
        // what about stranding a monster partially off an edge?
        
        thing.floorz = tmfloorz;
        thing.ceilingz = tmceilingz;
        
        if (onfloor)
        {
        // walking monsters rise and fall with the floor
        thing.z = thing.floorz;
        }
        else
        {
        // don't adjust a floating monster unless forced to
        if (thing.z+thing.height > thing.ceilingz)
            thing.z = thing.ceilingz - thing.height;
        }
        
        if (thing.ceilingz - thing.floorz < thing.height)
        return false;
            
        return true;
    }



    //
    // SLIDE MOVE
    // Allows the player to slide along any angled walls.
    //
    int     bestslidefrac; // fixed
    int     secondslidefrac;

    line_t     bestslideline;
    line_t     secondslideline;

    mobj_t     slidemo;

    int     tmxmove; //fixed_t
    int     tmymove;



    //
    // P_HitSlideLine
    // Adjusts the xmove / ymove
    // so that the next move will slide along the wall.
    //
    private void HitSlideLine (line_t ld)
    {
        boolean         side;

        // all angles
        long     lineangle, moveangle,deltaangle;
        
        // fixed_t
        int     movelen,  newlen;
        
        
        if (ld.slopetype == slopetype_t.ST_HORIZONTAL)
        {
        tmymove = 0;
        return;
        }
        
        if (ld.slopetype == slopetype_t.ST_VERTICAL)
        {
        tmxmove = 0;
        return;
        }
        
        side = ld.PointOnLineSide (slidemo.x, slidemo.y);
        
        lineangle = R.PointToAngle2 (0,0, ld.dx, ld.dy);

        if (side == true)
        lineangle += ANG180;

        moveangle = R.PointToAngle2 (0,0, tmxmove, tmymove);
        deltaangle = (moveangle-lineangle)&BITS32;

        if (deltaangle > ANG180)
        deltaangle += ANG180;
        //  system.Error ("SlideLine: ang>ANG180");

        //lineangle >>>= ANGLETOFINESHIFT;
        //deltaangle >>>= ANGLETOFINESHIFT;
        
        movelen = AproxDistance (tmxmove, tmymove);
        newlen = FixedMul (movelen, finecosine(deltaangle));

        tmxmove = FixedMul (newlen, finecosine(lineangle)); 
        tmymove = FixedMul (newlen, finesine(lineangle));   
    }
    
    protected final static int FUDGE=0x800;///(FRACUNIT/MAPFRACUNIT);
    
    //
    // P_SlideMove
    // The momx / momy move is bad, so try to slide
    // along a wall.
    // Find the first line hit, move flush to it,
    // and slide along it
    //
    // This is a kludgy mess.
    //
    void SlideMove (mobj_t mo)
    {
        // fixed_t
        int     leadx,leady,trailx,traily,newx,newy;
        int         hitcount;
            
        slidemo = mo;
        hitcount = 0;
        
      do {
        if (++hitcount == 3) {
            // goto stairstep
            stairstep(mo);
            return;
        }     // don't loop forever

        
        // trace along the three leading corners
        if (mo.momx > 0)
        {
        leadx = mo.x + mo.radius;
        trailx = mo.x - mo.radius;
        }
        else
        {
        leadx = mo.x - mo.radius;
        trailx = mo.x + mo.radius;
        }
        
        if (mo.momy > 0)
        {
        leady = mo.y + mo.radius;
        traily = mo.y - mo.radius;
        }
        else
        {
        leady = mo.y - mo.radius;
        traily = mo.y + mo.radius;
        }
            
        bestslidefrac = FRACUNIT+1;
        
        PathTraverse ( leadx, leady, leadx+mo.momx, leady+mo.momy,
                 PT_ADDLINES, SlideTraverse );
        PathTraverse ( trailx, leady, trailx+mo.momx, leady+mo.momy,
                 PT_ADDLINES, SlideTraverse );
        PathTraverse ( leadx, traily, leadx+mo.momx, traily+mo.momy,
                 PT_ADDLINES, SlideTraverse );
        
        // move up to the wall
        if (bestslidefrac == FRACUNIT+1)
        {
            // the move most have hit the middle, so stairstep
            stairstep(mo);
            return;
          }     // don't loop forever

        // fudge a bit to make sure it doesn't hit
        bestslidefrac -= FUDGE; 
        if (bestslidefrac > 0)
        {
        newx = FixedMul (mo.momx, bestslidefrac);
        newy = FixedMul (mo.momy, bestslidefrac);
        
        if (!TryMove (mo, mo.x+newx, mo.y+newy))
        {
            // goto stairstep
            stairstep(mo);
            return;
        }     // don't loop forever
        }
        
        // Now continue along the wall.
        // First calculate remainder.
        bestslidefrac = FRACUNIT-(bestslidefrac+FUDGE);
        
        if (bestslidefrac > FRACUNIT)
        bestslidefrac = FRACUNIT;
        
        if (bestslidefrac <= 0)
        return;
        
        tmxmove = FixedMul (mo.momx, bestslidefrac);
        tmymove = FixedMul (mo.momy, bestslidefrac);

        HitSlideLine (bestslideline); // clip the moves

        mo.momx = tmxmove;
        mo.momy = tmymove;
        
          }
      // goto retry
        while (!TryMove (mo, mo.x+tmxmove, mo.y+tmymove));
    }

    /** Fugly "goto stairstep" simulation
     * 
     * @param mo
     */
    
    private final void stairstep(mobj_t mo){
        if (!TryMove (mo, mo.x, mo.y + mo.momy))
            TryMove (mo, mo.x + mo.momx, mo.y);
    }
    
    //
    // P_XYMovement  
    //
    protected final static int STOPSPEED =      0x1000;
    protected final static int FRICTION =       0xe800;

    public void XYMovement (mobj_t mo) 
    {
    //System.out.println("XYMovement");
    int     ptryx, ptryy; // pointers to fixed_t ???
    player_t   player;
    int  xmove, ymove; // fixed_t
          
    if ((mo.momx==0) && (mo.momy==0))
    {
    if ((mo.flags & MF_SKULLFLY)!=0)
    {
      // the skull slammed into something
      mo.flags &= ~MF_SKULLFLY;
      mo.momx = mo.momy = mo.momz = 0;

      mo.SetMobjState (mo.info.spawnstate);
    }
    return;
    }

    player = mo.player;
      
    if (mo.momx > MAXMOVE)
    mo.momx = MAXMOVE;
    else if (mo.momx < -MAXMOVE)
    mo.momx = -MAXMOVE;

    if (mo.momy > MAXMOVE)
    mo.momy = MAXMOVE;
    else if (mo.momy < -MAXMOVE)
    mo.momy = -MAXMOVE;
      
    xmove = mo.momx;
    ymove = mo.momy;

    do
    {
    if (xmove > MAXMOVE/2 || ymove > MAXMOVE/2)
    {
      ptryx = mo.x + xmove/2;
      ptryy = mo.y + ymove/2;
      xmove >>= 1;
      ymove >>= 1;
    }
    else
    {
      ptryx = mo.x + xmove;
      ptryy = mo.y + ymove;
      xmove = ymove = 0;
    }
      
    if (!TryMove (mo, ptryx, ptryy))
    {
      // blocked move
      if (mo.player!=null)
      {   // try to slide along it
      SlideMove (mo);
      }
      else if (eval(mo.flags & MF_MISSILE))
      {
      // explode a missile
      if (ceilingline!=null &&
          ceilingline.backsector!=null &&
          ceilingline.backsector.ceilingpic == TM.getSkyFlatNum())
      {
          // Hack to prevent missiles exploding
          // against the sky.
          // Does not handle sky floors.
          RemoveMobj (mo);
          return;
      }
      ExplodeMissile (mo);
      }
      else
      mo.momx = mo.momy = 0;
    }
    } while ((xmove | ymove)!=0);

    // slow down
    if (player!=null && eval(player.cheats & player_t.CF_NOMOMENTUM))
    {
    // debug option for no sliding at all
    mo.momx = mo.momy = 0;
    return;
    }

    if (eval(mo.flags & (MF_MISSILE | MF_SKULLFLY)) )
    return;     // no friction for missiles ever
      
    if (mo.z > mo.floorz)
    return;     // no friction when airborne

    if (eval(mo.flags & MF_CORPSE))
    {
    // do not stop sliding
    //  if halfway off a step with some momentum
    if (mo.momx > FRACUNIT/4
      || mo.momx < -FRACUNIT/4
      || mo.momy > FRACUNIT/4
      || mo.momy < -FRACUNIT/4)
    {
      if (mo.floorz != mo.subsector.sector.floorheight)
      return;
    }
    }

    if (mo.momx > -STOPSPEED
    && mo.momx < STOPSPEED
    && mo.momy > -STOPSPEED
    && mo.momy < STOPSPEED
    && (player==null
      || (player.cmd.forwardmove== 0
      && player.cmd.sidemove == 0 ) ) )
    {
    // if in a walking frame, stop moving
    // TODO: we need a way to get state indexed inside of states[], to sim pointer arithmetic.
   // FIX: added an "id" field.
    if ( player!=null&&(int)(player.mo.state.id- statenum_t.S_PLAY_RUN1.ordinal()) < 4)
        player.mo.SetMobjState (statenum_t.S_PLAY);

    mo.momx = 0;
    mo.momy = 0;
    }
    else
    {
    mo.momx = FixedMul (mo.momx, FRICTION);
    mo.momy = FixedMul (mo.momy, FRICTION);
    }
    }
    //
    // P_LineAttack
    //
    /** who got hit (or NULL) */
    public mobj_t     linetarget;
    mobj_t     shootthing;

    // Height if not aiming up or down
    // ???: use slope for monsters?
    int     shootz; // fixed_t

    int     la_damage;
    int     attackrange; // fixed_t

    int     aimslope; // fixed_t

    


    //
    // 
    //
    /** P_AimLineAttack
     * @param t1
     * @param angle long
     * @param distance int
     */
   int
   AimLineAttack
    ( mobj_t   t1,
      long   angle,
      int   distance )
    {
        int x2,y2;
        shootthing = t1;
        
        x2 = t1.x + (distance>>FRACBITS)*finecosine(angle);
        y2 = t1.y + (distance>>FRACBITS)*finesine(angle);
        shootz = t1.z + (t1.height>>1) + 8*FRACUNIT;

        // can't shoot outside view angles
        topslope = 100*FRACUNIT/160;    
        bottomslope = -100*FRACUNIT/160;
        
        attackrange = distance;
        linetarget = null;
        
        PathTraverse ( t1.x, t1.y,
                 x2, y2,
                 PT_ADDLINES|PT_ADDTHINGS,
                 AimTraverse );
            
        if (linetarget!=null)
        return aimslope;

        return 0;
    }
     

    /**
     * P_LineAttack
     * If damage == 0, it is just a test trace
     * that will leave linetarget set.
     * 
     * @param t1
     * @param angle angle_t
     * @param distance fixed_t
     * @param slope fixed_t
     * @param damage
     */
   
    void
    LineAttack
    ( mobj_t   t1,
      long   angle,
      int   distance,
      int   slope,
      int       damage )
    {
        int x2,y2;
        
        shootthing = t1;
        la_damage = damage;
        x2 = t1.x + (distance>>FRACBITS)*finecosine(angle);
        y2 = t1.y + (distance>>FRACBITS)*finesine(angle);
        shootz = t1.z + (t1.height>>1) + 8*FRACUNIT;
        attackrange = distance;
        aimslope = slope;
            
        PathTraverse ( t1.x, t1.y,
                 x2, y2,
                 PT_ADDLINES|PT_ADDTHINGS,
                 ShootTraverse );
    }
     


    //
    // USE LINES
    //
    mobj_t     usething;

    boolean UseTraverse (intercept_t in)
    {
        boolean     side;
        // FIXME: some sanity check here?
        line_t line=(line_t) in.d();
        
        if (line.special==0)
        {
        LineOpening (line);
        if (openrange <= 0)
        {
        	 S.StartSound(usething, sfxenum_t.sfx_noway);
            
            // can't use through a wall
            return false;   
        }
        // not a special line, but keep checking
        return true ;       
        }
        
        side = false;
        if (line.PointOnLineSide (usething.x, usething.y))
        side = true;
        
        //  return false;       // don't use back side
        
        UseSpecialLine (usething, line, side);

        // can't use for than one special line in a row
        return false;
    }

    /**
     * P_UseSpecialLine
     * Called when a thing uses a special line.
     * Only the front sides of lines are usable.
     */
    
    public boolean
    UseSpecialLine
    ( mobj_t   thing,
      line_t   line,
      boolean      side )
    {               

        // Err...
        // Use the back sides of VERY SPECIAL lines...
        if (side)
        {
       switch(line.special)
       {
         case 124:
	           // Sliding door open&close
	           // SL.EV_SlidingDoor(line, thing);
           break;

         default:
           return false;
           //break;
       }
        }

        
        // Switches that other things can activate.
        //_D_: little bug fixed here, see linuxdoom source
        if (thing.player==/*!=*/null)
        {
       // never open secret doors
       if (eval(line.flags& ML_SECRET))
           return false;
       
       switch(line.special)
       {
         case 1:   // MANUAL DOOR RAISE
         case 32:  // MANUAL BLUE
         case 33:  // MANUAL RED
         case 34:  // MANUAL YELLOW
           break;
           
         default:
           return false;
           //break;
       }
        }

        
        // do something  
        switch (line.special)
        {
       // MANUALS
          case 1:      // Vertical Door
          case 26:     // Blue Door/Locked
          case 27:     // Yellow Door /Locked
          case 28:     // Red Door /Locked

          case 31:     // Manual door open
          case 32:     // Blue locked door open
          case 33:     // Red locked door open
          case 34:     // Yellow locked door open

          case 117:        // Blazing door raise
          case 118:        // Blazing door open
       VerticalDoor (line, thing);
       break;
       
       //UNUSED - Door Slide Open&Close
        case 124:
         // NOTE: clashes with secret level exit.
         //SL.EV_SlidingDoor (line, thing);
         break;

       // SWITCHES
          case 7:
       // Build Stairs
       if (BuildStairs(line,stair_e.build8))
           SW.ChangeSwitchTexture(line,false);
       break;

          case 9:
       // Change Donut
       if (DoDonut(line))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 11:
       // Exit level
              SW.ChangeSwitchTexture(line,false);
       DM.ExitLevel ();
       break;
       
          case 14:
       // Raise Floor 32 and change texture
       if (PEV.DoPlat(line,plattype_e.raiseAndChange,32))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 15:
       // Raise Floor 24 and change texture
       if (PEV.DoPlat(line,plattype_e.raiseAndChange,24))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 18:
       // Raise Floor to next highest floor
       if (DoFloor(line, floor_e.raiseFloorToNearest))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 20:
       // Raise Plat next highest floor and change texture
       if (PEV.DoPlat(line,plattype_e.raiseToNearestAndChange,0))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 21:
       // PlatDownWaitUpStay
       if (PEV.DoPlat(line,plattype_e.downWaitUpStay,0))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 23:
       // Lower Floor to Lowest
       if (DoFloor(line,floor_e.lowerFloorToLowest))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 29:
       // Raise Door
       if (DoDoor(line,vldoor_e.normal))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 41:
       // Lower Ceiling to Floor
       if (DoCeiling(line,ceiling_e.lowerToFloor))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 71:
       // Turbo Lower Floor
       if (DoFloor(line,floor_e.turboLower))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 49:
       // Ceiling Crush And Raise
       if (DoCeiling(line,ceiling_e.crushAndRaise))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 50:
       // Close Door
       if (DoDoor(line,vldoor_e.close))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 51:
       // Secret EXIT
              SW.ChangeSwitchTexture(line,false);
       DM.SecretExitLevel ();
       break;
       
          case 55:
       // Raise Floor Crush
       if (DoFloor(line,floor_e.raiseFloorCrush))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 101:
       // Raise Floor
       if (DoFloor(line,floor_e.raiseFloor))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 102:
       // Lower Floor to Surrounding floor height
       if (DoFloor(line,floor_e.lowerFloor))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 103:
       // Open Door
       if (DoDoor(line,vldoor_e.open))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 111:
       // Blazing Door Raise (faster than TURBO!)
       if (DoDoor (line,vldoor_e.blazeRaise))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 112:
       // Blazing Door Open (faster than TURBO!)
       if (DoDoor (line,vldoor_e.blazeOpen))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 113:
       // Blazing Door Close (faster than TURBO!)
       if (DoDoor (line,vldoor_e.blazeClose))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 122:
       // Blazing PlatDownWaitUpStay
       if (PEV.DoPlat(line,plattype_e.blazeDWUS,0))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 127:
       // Build Stairs Turbo 16
       if (BuildStairs(line,stair_e.turbo16))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 131:
       // Raise Floor Turbo
       if (DoFloor(line,floor_e.raiseFloorTurbo))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 133:
       // BlzOpenDoor BLUE
          case 135:
       // BlzOpenDoor RED
          case 137:
       // BlzOpenDoor YELLOW
       if (DoLockedDoor (line,vldoor_e.blazeOpen,thing))
           SW.ChangeSwitchTexture(line,false);
       break;
       
          case 140:
       // Raise Floor 512
       if (DoFloor(line,floor_e.raiseFloor512))
           SW.ChangeSwitchTexture(line,false);
       break;
       
       // BUTTONS
          case 42:
       // Close Door
       if (DoDoor(line,vldoor_e.close))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 43:
       // Lower Ceiling to Floor
       if (DoCeiling(line,ceiling_e.lowerToFloor))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 45:
       // Lower Floor to Surrounding floor height
       if (DoFloor(line,floor_e.lowerFloor))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 60:
       // Lower Floor to Lowest
       if (DoFloor(line,floor_e.lowerFloorToLowest))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 61:
       // Open Door
       if (DoDoor(line,vldoor_e.open))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 62:
       // PlatDownWaitUpStay
       if (PEV.DoPlat(line,plattype_e.downWaitUpStay,1))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 63:
       // Raise Door
       if (DoDoor(line,vldoor_e.normal))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 64:
       // Raise Floor to ceiling
       if (DoFloor(line,floor_e.raiseFloor))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 66:
       // Raise Floor 24 and change texture
       if (PEV.DoPlat(line,plattype_e.raiseAndChange,24))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 67:
       // Raise Floor 32 and change texture
       if (PEV.DoPlat(line,plattype_e.raiseAndChange,32))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 65:
       // Raise Floor Crush
       if (DoFloor(line,floor_e.raiseFloorCrush))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 68:
       // Raise Plat to next highest floor and change texture
       if (PEV.DoPlat(line,plattype_e.raiseToNearestAndChange,0))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 69:
       // Raise Floor to next highest floor
       if (DoFloor(line, floor_e.raiseFloorToNearest))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 70:
       // Turbo Lower Floor
       if (DoFloor(line,floor_e.turboLower))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 114:
       // Blazing Door Raise (faster than TURBO!)
       if (DoDoor (line,vldoor_e.blazeRaise))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 115:
       // Blazing Door Open (faster than TURBO!)
       if (DoDoor (line,vldoor_e.blazeOpen))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 116:
       // Blazing Door Close (faster than TURBO!)
       if (DoDoor (line,vldoor_e.blazeClose))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 123:
       // Blazing PlatDownWaitUpStay
       if (PEV.DoPlat(line,plattype_e.blazeDWUS,0))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 132:
       // Raise Floor Turbo
       if (DoFloor(line,floor_e.raiseFloorTurbo))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 99:
       // BlzOpenDoor BLUE
          case 134:
       // BlzOpenDoor RED
          case 136:
       // BlzOpenDoor YELLOW
       if (DoLockedDoor (line,vldoor_e.blazeOpen,thing))
           SW.ChangeSwitchTexture(line,true);
       break;
       
          case 138:
       // Light Turn On
       LEV.LightTurnOn(line,255);
       SW.ChangeSwitchTexture(line,true);
       break;
       
          case 139:
       // Light Turn Off
       LEV.LightTurnOn(line,35);
       SW.ChangeSwitchTexture(line,true);
       break;
               
        }
       
        return true;
    }
    

    /**
     * P_UseLines
     * Looks for special lines in front of the player to activate.
     */
    public void UseLines (player_t  player) 
    {
        int     angle;
        int x1,y1,x2,y2;
        //System.out.println("Uselines");
        usething = player.mo;
        
        // Normally this shouldn't cause problems?
        angle = Tables.toBAMIndex(player.mo.angle);

        x1 = player.mo.x;
        y1 = player.mo.y;
        x2 = x1 + (USERANGE>>FRACBITS)*finecosine[angle];
        y2 = y1 + (USERANGE>>FRACBITS)*finesine[angle];
        
        PathTraverse ( x1, y1, x2, y2, PT_ADDLINES, UseTraverse );
    }


    //
    // RADIUS ATTACK
    //
    mobj_t     bombsource;
    mobj_t     bombspot;
    int     bombdamage;

    /**
     * P_RadiusAttack
     * Source is the creature that caused the explosion at spot.
     */
    
    void
    RadiusAttack
    ( mobj_t   spot,
      mobj_t   source,
      int       damage )
    {
        int     x;
        int     y;
        
        int     xl;
        int     xh;
        int     yl;
        int     yh;
        
        int dist; // fixed_t
        
        dist = (damage+MAXRADIUS)<<FRACBITS;
        yh = LL.getSafeBlockY(spot.y + dist - LL.bmaporgy);
        yl = LL.getSafeBlockY(spot.y - dist - LL.bmaporgy);
        xh = LL.getSafeBlockX(spot.x + dist - LL.bmaporgx);
        xl = LL.getSafeBlockX(spot.x - dist - LL.bmaporgx);
        bombspot = spot;
        bombsource = source;
        bombdamage = damage;
        
        for (y=yl ; y<=yh ; y++)
        for (x=xl ; x<=xh ; x++)
            BlockThingsIterator (x, y, RadiusAttack );
    }



    //
    // SECTOR HEIGHT CHANGING
    // After modifying a sectors floor or ceiling height,
    // call this routine to adjust the positions
    // of all things that touch the sector.
    //
    // If anything doesn't fit anymore, true will be returned.
    // If crunch is true, they will take damage
    //  as they are being crushed.
    // If Crunch is false, you should set the sector height back
    //  the way it was and call P_ChangeSector again
    //  to undo the changes.
    //
    boolean     crushchange;
    boolean     nofit;


    //
    // P_ChangeSector
    //
    boolean
    ChangeSector
    ( sector_t sector,
      boolean   crunch )
    {
        int     x;
        int     y;
        
        nofit = false;
        crushchange = crunch;
        
        // re-check heights for all things near the moving sector
        for (x=sector.blockbox[BOXLEFT] ; x<= sector.blockbox[BOXRIGHT] ; x++)
        for (y=sector.blockbox[BOXBOTTOM];y<= sector.blockbox[BOXTOP] ; y++)
            BlockThingsIterator (x, y, ChangeSector);
        
        
        return nofit;
    }
    
    /**
     * P_BlockLinesIterator
     * The validcount flags are used to avoid checking lines
     * that are marked in multiple mapblocks,
     * so increment validcount before the first call
     * to P_BlockLinesIterator, then make one or more calls
     * to it.
     */

    public boolean BlockLinesIterator (int x,int y,PIT_LineFunction func)
    {
     int         offset;
     int 		lineinblock;
     line_t     ld;
     
     if (x<0
     || y<0
     || x>=LL.bmapwidth
     || y>=LL.bmapheight)
     {
     return true;
     }
     
     // This gives us the index to look up (in blockmap)
     
     offset = y*LL.bmapwidth+x;
     
     // The index contains yet another offset, but this time 
     offset = LL.blockmap[offset];

     // MAES: blockmap terminating marker is always -1
     
     final int validcount=R.getValidCount();
     
     // [SYNC ISSUE]: don't skip offset+1 :-/
     for (int list=offset;(lineinblock=LL.blockmap[list])!=-1;list++){
    	 ld = LL.lines[lineinblock];
         //System.out.println(ld);
         if (ld.validcount == validcount)
             continue;   // line has already been checked

         ld.validcount = validcount;
         if ( !func.invoke(ld) )
             return false;
         }
     return true;    // everything was checked
    }

    
    
    /**
     * P_PathTraverse
     * Traces a line from x1,y1 to x2,y2,
     * calling the traverser function for each.
     * Returns true if the traverser function returns true
     * for all lines.
     */
	private final boolean PathTraverse(int x1, int y1, int x2, int y2, int flags,
			PTR_InterceptFunc trav) {
		// System.out.println("Pathtraverse "+x1+" , " +y1+" to "+x2 +" , "
		// +y2);
		final int xt1, yt1;
		final int xt2, yt2;
		final long _x1, _x2, _y1, _y2;
		final int mapx1, mapy1;
		final int xstep, ystep;

		int partial;

		int xintercept, yintercept;

		int mapx;
		int mapy;

		int mapxstep;
		int mapystep;

		int count;

		earlyout = eval(flags& PT_EARLYOUT);

		R.increaseValidCount(1);
		intercept_p = 0;

		if (((x1 - LL.bmaporgx) & (MAPBLOCKSIZE - 1)) == 0)
			x1 += FRACUNIT; // don't side exactly on a line

		if (((y1 - LL.bmaporgy) & (MAPBLOCKSIZE - 1)) == 0)
			y1 += FRACUNIT; // don't side exactly on a line

		trace.x = x1;
		trace.y = y1;
		trace.dx = x2 - x1;
		trace.dy = y2 - y1;

		// Code developed in common with entryway
		// for prBoom+
		
		_x1 = (long) x1 - LL.bmaporgx;
		_y1 = (long) y1 - LL.bmaporgy;
		xt1 = (int) (_x1 >> MAPBLOCKSHIFT);
		yt1 = (int) (_y1 >> MAPBLOCKSHIFT);

		mapx1 = (int) (_x1 >> MAPBTOFRAC);
		mapy1 = (int) (_y1 >> MAPBTOFRAC);

		_x2 = (long) x2 - LL.bmaporgx;
		_y2 = (long) y2 - LL.bmaporgy;
		xt2 = (int) (_x2 >> MAPBLOCKSHIFT);
		yt2 = (int) (_y2 >> MAPBLOCKSHIFT);

		x1 -= LL.bmaporgx;
		y1 -= LL.bmaporgy;
		x2 -= LL.bmaporgx;
		y2 -= LL.bmaporgy;
		
     if (xt2 > xt1)
     {
     mapxstep = 1;
     partial = FRACUNIT - (mapx1&(FRACUNIT-1));
     ystep = FixedDiv (y2-y1,Math.abs(x2-x1));
     }
     else if (xt2 < xt1)
     {
     mapxstep = -1;
     partial = mapx1&(FRACUNIT-1);
     ystep = FixedDiv (y2-y1,Math.abs(x2-x1));
     }
     else
     {
     mapxstep = 0;
     partial = FRACUNIT;
     ystep = 256*FRACUNIT;
     }   

     yintercept = (int) (mapy1 + FixedMul (partial, ystep));

     
     if (yt2 > yt1)
     {
     mapystep = 1;
     partial = FRACUNIT - (mapy1&(FRACUNIT-1));
     xstep = FixedDiv (x2-x1,Math.abs(y2-y1));
     }
     else if (yt2 < yt1)
     {
     mapystep = -1;
     partial = mapy1&(FRACUNIT-1);
     xstep = FixedDiv (x2-x1,Math.abs(y2-y1));
     }
     else
     {
     mapystep = 0;
     partial = FRACUNIT;
     xstep = 256*FRACUNIT;
     }   
     xintercept = (int) (mapx1 + FixedMul (partial, xstep));
     
     // Step through map blocks.
     // Count is present to prevent a round off error
     // from skipping the break.
     mapx = xt1;
     mapy = yt1;
     
     for (count = 0 ; count < 64 ; count++)
     {
     if (eval(flags &PT_ADDLINES))
     {
         if (!BlockLinesIterator (mapx, mapy,AddLineIntercepts))
         return false;   // early out
     }
     
     if (eval(flags &PT_ADDTHINGS))
     {
         if (!BlockThingsIterator (mapx, mapy,AddThingIntercepts))
         return false;   // early out
     }
         
     if (mapx == xt2
         && mapy == yt2)
     {
         break;
     }
     
     boolean changeX = (yintercept >> FRACBITS) == mapy;
     boolean changeY = (xintercept >> FRACBITS) == mapx;
     if (changeX)
     {
         yintercept += ystep;
         mapx += mapxstep;
     } else //[MAES]: this fixed sync issues. Lookup linuxdoom
     if (changeY)
     {
         xintercept += xstep;
         mapy += mapystep;
     }
         
     }
     // go through the sorted list
     //System.out.println("Some intercepts found");
     return TraverseIntercepts ( trav, FRACUNIT );
    } // end method
    
    //
    // FLOORS
    //
    
    private static final int FLOORSPEED= MAPFRACUNIT;

    /** Move a plane (floor or ceiling) and check for crushing
     *  @param sector
     *  @param speed fixed
     *  @param dest fixed
     *  @param crush
     *  @param floorOrCeiling
     *  @param direction
     */
    result_e
    MovePlane
    ( sector_t sector,
      int   speed,
      int   dest,
      boolean   crush,
      int       floorOrCeiling,
      int       direction )
    {
        boolean flag;
        int lastpos; // fixed_t
        
        switch(floorOrCeiling)
        {
          case 0:
        // FLOOR
        switch(direction)
        {
          case -1:
            // DOWN
            if (sector.floorheight - speed < dest)
            {
            lastpos = sector.floorheight;
            sector.floorheight = dest;
            flag = ChangeSector(sector,crush);
            if (flag == true)
            {
                sector.floorheight =lastpos;
                ChangeSector(sector,crush);
                //return crushed;
            }
            return result_e.pastdest;
            }
            else
            {
            lastpos = sector.floorheight;
            sector.floorheight -= speed;
            flag = ChangeSector(sector,crush);
            if (flag == true)
            {
                sector.floorheight = lastpos;
                ChangeSector(sector,crush);
                return result_e.crushed;
            }
            }
            break;
                            
          case 1:
            // UP
            if (sector.floorheight + speed > dest)
            {
            lastpos = sector.floorheight;
            sector.floorheight = dest;
            flag = ChangeSector(sector,crush);
            if (flag == true)
            {
                sector.floorheight = lastpos;
                ChangeSector(sector,crush);
                //return crushed;
            }
            return result_e.pastdest;
            }
            else
            {
            // COULD GET CRUSHED
            lastpos = sector.floorheight;
            sector.floorheight += speed;
            flag =ChangeSector(sector,crush);
            if (flag == true)
            {
                if (crush == true)
                return result_e.crushed;
                sector.floorheight = lastpos;
                ChangeSector(sector,crush);
                return result_e.crushed;
            }
            }
            break;
        }
        break;
                                        
          case 1:
        // CEILING
        switch(direction)
        {
          case -1:
            // DOWN
            if (sector.ceilingheight - speed < dest)
            {
            lastpos = sector.ceilingheight;
            sector.ceilingheight = dest;
            flag = ChangeSector(sector,crush);

            if (flag == true)
            {
                sector.ceilingheight = lastpos;
                ChangeSector(sector,crush);
                //return crushed;
            }
            return result_e.pastdest;
            }
            else
            {
            // COULD GET CRUSHED
            lastpos = sector.ceilingheight;
            sector.ceilingheight -= speed;
            flag = ChangeSector(sector,crush);

            if (flag == true)
            {
                if (crush == true)
                return result_e.crushed;
                sector.ceilingheight = lastpos;
                ChangeSector(sector,crush);
                return result_e.crushed;
            }
            }
            break;
                            
          case 1:
            // UP
            if (sector.ceilingheight + speed > dest)
            {
            lastpos = sector.ceilingheight;
            sector.ceilingheight = dest;
            flag =ChangeSector(sector,crush);
            if (flag == true)
            {
                sector.ceilingheight = lastpos;
                ChangeSector(sector,crush);
                //return crushed;
            }
            return result_e.pastdest;
            }
            else
            {
            lastpos = sector.ceilingheight;
            sector.ceilingheight += speed;
            flag = ChangeSector(sector,crush);
    // UNUSED
    /*
            if (flag == true)
            {
                sector.ceilingheight = lastpos;
                P_ChangeSector(sector,crush);
                return crushed;
            }
    */
            }
            break;
        }
        break;
            
        }
        return result_e.ok;
    }
    
    /** P_CheckMissileSpawn
     * Moves the missile forward a bit
     * and possibly explodes it right there.
     * 
     * @param th
     */

    void CheckMissileSpawn (mobj_t th)
    {
    th.tics -= RND.P_Random()&3;
    if (th.tics < 1)
    th.tics = 1;

    // move a little forward so an angle can
    // be computed if it immediately explodes
    th.x += (th.momx>>1);
    th.y += (th.momy>>1);
    th.z += (th.momz>>1);

    if (!TryMove (th, th.x, th.y))
    ExplodeMissile (th);
    }
    
    //
  //P_Ticker
  //

  public void Ticker ()
  {
     int     i;
     
     // run the tic
     if (DM.paused)
     return;
         
     // pause if in menu and at least one tic has been run
     if ( !DM.netgame
      && DM.menuactive
      && !DM.demoplayback
      && DM.players[DM.consoleplayer].viewz != 1)
     {
     return;
     }
     
         
     for (i=0 ; i<MAXPLAYERS ; i++)
     if (DM.playeringame[i])
         DM.players[i].PlayerThink ();
             
     RunThinkers ();
     SPECS.UpdateSpecials (); // In specials. Merge?
     RespawnSpecials ();

     // for par times
     DM.leveltime++;    
  }
  
  /**
   * P_ShootSpecialLine - IMPACT SPECIALS
   * Called when a thing shoots a special line.
   */
  public void
  ShootSpecialLine
  ( mobj_t   thing,
    line_t   line )
  {
      boolean     ok;
      
      //  Impacts that other things can activate.
      if (thing.player==null)
      {
      ok = false;
      switch(line.special)
      {
        case 46:
          // OPEN DOOR IMPACT
          ok = true;
          break;
      }
      if (!ok)
          return;
      }

      switch(line.special)
      {
        case 24:
      // RAISE FLOOR
      DoFloor(line,floor_e.raiseFloor);
      SW.ChangeSwitchTexture(line,false);
      break;
      
        case 46:
      // OPEN DOOR
      DoDoor(line,vldoor_e.open);
      SW.ChangeSwitchTexture(line,true);
      break;
      
        case 47:
      // RAISE FLOOR NEAR AND CHANGE
      PEV.DoPlat(line,plattype_e.raiseToNearestAndChange,0);
      SW.ChangeSwitchTexture(line,false);
      break;
      }
  }

  /** P_SpawnSpecials
   * After the map has been loaded, scan for specials
   * that spawn thinkers
  */

  void SpawnSpecials ()
  {
	  
	  
      sector_t   sector;
      int     i;
      
      /*int     episode;

      episode = 1;
      if (W.CheckNumForName("texture2") >= 0)
      episode = 2;
      */
      
      // See if -TIMER needs to be used.
      SPECS.levelTimer = false;
      
      i = DM.CM.CheckParm("-avg");
      if (eval(i) && DM.deathmatch)
      {
          SPECS.levelTimer = true;
          SPECS.levelTimeCount = 20 * 60 * 35;
      }
      
      i = DM.CM.CheckParm("-timer");
      if (eval(i) && DM.deathmatch)
      {
      int time;
      time = Integer.parseInt(DM.CM.getArgv(i+1)) * 60 * 35;
      SPECS.levelTimer = true;
      SPECS.levelTimeCount = time;
      }
      
      //  Init special SECTORs.
      //sector = LL.sectors;
      for (i=0 ; i<LL.numsectors ; i++)
      {
          sector=LL.sectors[i];
      if (!eval(sector.special))
          continue;
      
      switch (sector.special)
      {
        case 1:
          // FLICKERING LIGHTS
            sector.SpawnLightFlash ();
          break;

        case 2:
          // STROBE FAST
            sector.SpawnStrobeFlash(FASTDARK,0);
          break;
          
        case 3:
          // STROBE SLOW
            sector.SpawnStrobeFlash(SLOWDARK,0);
          break;
          
        case 4:
          // STROBE FAST/DEATH SLIME
            sector.SpawnStrobeFlash(FASTDARK,0);
          sector.special = 4;
          break;
          
        case 8:
          // GLOWING LIGHT
            sector.SpawnGlowingLight();
          break;
        case 9:
          // SECRET SECTOR
          DM.totalsecret++;
          break;
          
        case 10:
          // DOOR CLOSE IN 30 SECONDS
          sector.SpawnDoorCloseIn30 ();
          break;
          
        case 12:
          // SYNC STROBE SLOW
            sector.SpawnStrobeFlash (SLOWDARK, 1);
          break;

        case 13:
          // SYNC STROBE FAST
            sector.SpawnStrobeFlash ( FASTDARK, 1);
          break;

        case 14:
          // DOOR RAISE IN 5 MINUTES
            sector.SpawnDoorRaiseIn5Mins (i);
          break;
          
        case 17:
            sector.SpawnFireFlicker();
          break;
      }
      }

      
      //  Init line EFFECTs
      SPECS.numlinespecials = 0;
      for (i = 0;i < LL.numlines; i++)
      {
      switch(LL.lines[i].special)
      {
        case 48:
          // EFFECT FIRSTCOL SCROLL+
          // Maes 6/4/2012: removed length limit.
          if (SPECS.numlinespecials==SPECS.linespeciallist.length)
        	  SPECS.resizeLinesSpecialList();
          SPECS.linespeciallist[SPECS.numlinespecials] = LL.lines[i];
          SPECS.numlinespecials++;
          break;
      }
      }

      
      //  Init other misc stuff
      for (i = 0;i < getMaxCeilings();i++)
    	  getActiveCeilings()[i] = null;

      PEV.initActivePlats();
      
      SW.initButtonList();


      // UNUSED: no horizonal sliders.
      // if (SL!=null) {
      // SL.updateStatus(DM);
      //  SL.P_InitSlidingDoorFrames();
      //}
  }
  
  
  
  /**
   * Move a plat up and down
   */
  void PlatRaise(plat_t plat)
  {
      result_e    res;
      
      switch(plat.status)
      {
        case up:
      res = MovePlane(plat.sector,
                plat.speed,
                plat.high,
                plat.crush,0,1);
                      
      if (plat.type == plattype_e.raiseAndChange
          || plat.type == plattype_e.raiseToNearestAndChange)
      {
          if (!eval(DM.leveltime&7))
          S.StartSound(plat.sector.soundorg, sfxenum_t.sfx_stnmov);
      }
      
                  
      if (res == result_e.crushed && (!plat.crush))
      {
          plat.count = plat.wait;
          plat.status = plat_e.down;
          S.StartSound(plat.sector.soundorg, sfxenum_t.sfx_pstart);
      }
      else
      {
          if (res == result_e.pastdest)
          {
          plat.count = plat.wait;
          plat.status = plat_e.waiting;
          S.StartSound(plat.sector.soundorg,  sfxenum_t.sfx_pstop);

          switch(plat.type)
          {
            case blazeDWUS:
            case downWaitUpStay:
              PEV.RemoveActivePlat(plat);
              break;
              
            case raiseAndChange:
            case raiseToNearestAndChange:
              PEV.RemoveActivePlat(plat);
              break;
              
            default:
              break;
          }
          }
      }
      break;
      
        case  down:
      res = MovePlane(plat.sector,plat.speed,plat.low,false,0,-1);

      if (res == result_e.pastdest)
      {
          plat.count = plat.wait;
          plat.status = plat_e.waiting;
          S.StartSound(plat.sector.soundorg,sfxenum_t.sfx_pstop);
      }
      break;
      
        case  waiting:
      if (--plat.count==0)
      {
          if (plat.sector.floorheight == plat.low)
          plat.status = plat_e.up;
          else
          plat.status = plat_e.down;
          S.StartSound(plat.sector.soundorg,sfxenum_t.sfx_pstart);
      }
        case  in_stasis:
      break;
      }
  }
  
  public Actions(DoomStatus DC){
      super(DC);
      this.A=this;      
      SlideTraverse=new PTR_SlideTraverse();
      AimTraverse=new PTR_AimTraverse();
      ShootTraverse=new PTR_ShootTraverse();
      UseTraverse=new PTR_UseTraverse();

      AddLineIntercepts=new PIT_AddLineIntercepts();
       AddThingIntercepts=new PIT_AddThingIntercepts();
       VileCheck=new PIT_VileCheck();
       CheckLine=new PIT_CheckLine();
       StompThing=new PIT_StompThing();
       CheckThing=new PIT_CheckThing();
       RadiusAttack=new PIT_RadiusAttack();
       ChangeSector=new PIT_ChangeSector();
      
	  
  }

  //
  // P_RunThinkers
  //
  public void RunThinkers() {
      thinker_t currentthinker;

      currentthinker = thinkercap.next;
      while (currentthinker != thinkercap) {
          if (currentthinker.function == think_t.NOP) {
              // time to remove it
              currentthinker.next.prev = currentthinker.prev;
              currentthinker.prev.next = currentthinker.next;
              
              // Problem: freeing was done explicitly on think_t's, not mobj_t's.
            /*try {
            	  
            // According to certian gurus, this method is faster than instanceof
            // and almost on par with id checking. 
            // 
            // http://stackoverflow.com/questions/103564/the-performance-impact-of-using-instanceof-in-java
            	  if (currentthinker.getClass()==mobj_t.class)
              
              mobjpool.checkIn((mobj_t)currentthinker);
              } catch (ClassCastException e){
            	  // Object will simply be destroyed without reuse, in this case.
              }  */
              // Z_Free (currentthinker);
          } else {
              if (currentthinker.acp1!=null)
                  // Execute thinker's function.
            	  currentthinker.acp1.invoke((mobj_t) currentthinker);
              else
              if (currentthinker.acpss!=null) {
            	  currentthinker.acpss.invoke(currentthinker);
              }
          }
          currentthinker = currentthinker.next;
      }
  }


public void setActiveceilings(ceiling_t[] activeceilings) {
    this.activeceilings = activeceilings;
}

public final ceiling_t[] getActiveCeilings() {
    return activeceilings;
}

public final int getMaxCeilings() {
    return activeceilings.length;
}

///////////////////// PIT AND PTR FUNCTIONS //////////////////

PTR_InterceptFunc SlideTraverse;
PTR_InterceptFunc AimTraverse;
PTR_InterceptFunc ShootTraverse;
PTR_InterceptFunc UseTraverse;

PIT_AddLineIntercepts AddLineIntercepts;
PIT_AddThingIntercepts AddThingIntercepts;
PIT_VileCheck VileCheck;
PIT_CheckLine CheckLine;
PIT_StompThing StompThing;
PIT_CheckThing CheckThing;
PIT_RadiusAttack RadiusAttack;
PIT_ChangeSector ChangeSector;

/**
 * PIT_VileCheck
 * Detect a corpse that could be raised.
 */


class PIT_VileCheck  implements PIT_MobjFunction {
	
    public mobj_t      corpsehit;
    public mobj_t      vileobj;
    public int     viletryx;
    public int     viletryy;
    
    public boolean invoke (mobj_t   thing)
{
    int     maxdist;
    boolean check;
    
    if (!eval(thing.flags &MF_CORPSE) )
    return true;    // not a monster
    
    if (thing.tics != -1)
    return true;    // not lying still yet
    
    if (thing.info.raisestate == statenum_t.S_NULL)
    return true;    // monster doesn't have a raise state
    
    maxdist = thing.info.radius + mobjinfo[mobjtype_t.MT_VILE.ordinal()].radius;
    
    if ( Math.abs(thing.x - viletryx) > maxdist
     || Math.abs(thing.y - viletryy) > maxdist )
    return true;        // not actually touching
        
    corpsehit = thing;
    corpsehit.momx = corpsehit.momy = 0;
    corpsehit.height <<= 2;
    check = CheckPosition (corpsehit, corpsehit.x, corpsehit.y);
    corpsehit.height >>= 2;

    if (!check)
    return true;        // doesn't fit here
        
    return false;       // got one, so stop checking
	}

}

/**
 * PIT_ChangeSector
 */

private class PIT_ChangeSector implements PIT_MobjFunction {
public boolean invoke (mobj_t   thing)
{
    mobj_t mo;
    
    if (ThingHeightClip (thing))
    {
    // keep checking
    return true;
    }
    

    // crunch bodies to giblets
    if (thing.health <= 0)
    {
    thing.SetMobjState(statenum_t.S_GIBS);

    thing.flags &= ~MF_SOLID;
    thing.height = 0;
    thing.radius = 0;

    // keep checking
    return true;        
    }

    // crunch dropped items
    if (eval(thing.flags& MF_DROPPED))
    {
    A.RemoveMobj (thing);
    
    // keep checking
    return true;        
    }

    if (! eval(thing.flags & MF_SHOOTABLE) )
    {
    // assume it is bloody gibs or something
    return true;            
    }
    
    nofit = true;

    if (crushchange && !eval(DM.leveltime&3) )
    {
    A.DamageMobj( thing,null,null,10);

    // spray blood in a random direction
    mo = A.SpawnMobj (thing.x,
              thing.y,
              thing.z + thing.height/2, mobjtype_t.MT_BLOOD);
    
    mo.momx = (RND.P_Random() - RND.P_Random ())<<12;
    mo.momy = (RND.P_Random() - RND.P_Random ())<<12;
    }

    // keep checking (crush other things)   
    return true;    
	}
}


/** PIT_CheckLine
 * Adjusts tmfloorz and tmceilingz as lines are contacted
 * 
 */

protected class PIT_CheckLine implements PIT_LineFunction {
     public boolean invoke(line_t ld){
    if (tmbbox[BOXRIGHT] <= ld.bbox[BOXLEFT]
    || tmbbox[BOXLEFT] >= ld.bbox[BOXRIGHT]
    || tmbbox[BOXTOP] <= ld.bbox[BOXBOTTOM]
    || tmbbox[BOXBOTTOM] >= ld.bbox[BOXTOP] )
    return true;

    if (ld.BoxOnLineSide (tmbbox) != -1)
    return true;
        
    // A line has been hit
    
    // The moving thing's destination position will cross
    // the given line.
    // If this should not be allowed, return false.
    // If the line is special, keep track of it
    // to process later if the move is proven ok.
    // NOTE: specials are NOT sorted by order,
    // so two special lines that are only 8 pixels apart
    // could be crossed in either order.
    
    if (ld.backsector==null)
    return false;       // one sided line
        
    if (!eval(tmthing.flags& MF_MISSILE) )
    {
    if ( eval(ld.flags& ML_BLOCKING) )
        return false;   // explicitly blocking everything

    if ( (tmthing.player==null) && eval(ld.flags& ML_BLOCKMONSTERS ))
        return false;   // block monsters only
    }

    // set openrange, opentop, openbottom
    LineOpening (ld); 
    
    // adjust floor / ceiling heights
    if (opentop < tmceilingz)
    {
    tmceilingz = opentop;
    ceilingline = ld;
    }

    if (openbottom > tmfloorz)
    tmfloorz = openbottom;  

    if (lowfloor < tmdropoffz)
    tmdropoffz = lowfloor;
        
    // if contacted a special line, add it to the list
    if (ld.special!=0)
    {
    spechit[numspechit] = ld;
    numspechit++;
    // Let's be proactive about this.
    if (numspechit>=spechit.length) ResizeSpechits();
    }

    return true;
    }

}


/**PIT_CheckThing  */

private class PIT_CheckThing  implements PIT_MobjFunction {
    public boolean invoke (mobj_t thing) {
    int     blockdist; // fixed_t
    boolean     solid;
    int         damage;
        
    if ((thing.flags & (MF_SOLID|MF_SPECIAL|MF_SHOOTABLE) )==0)
    return true;
    
    blockdist = thing.radius + tmthing.radius;

    if ( Math.abs(thing.x - tmx) >= blockdist
     || Math.abs(thing.y - tmy) >= blockdist )
    {
    // didn't hit it
    return true;    
    }
    
    // don't clip against self
    if (thing == tmthing)
    return true;
    
    // check for skulls slamming into things
    if ((tmthing.flags & MF_SKULLFLY)!=0)
    {
    damage = ((RND.P_Random()%8)+1)*tmthing.info.damage;
    
    A.DamageMobj (thing, tmthing, tmthing, damage);
    
    tmthing.flags &= ~MF_SKULLFLY;
    tmthing.momx = tmthing.momy = tmthing.momz = 0;
    
    tmthing.SetMobjState (tmthing.info.spawnstate);
    
    return false;       // stop moving
    }

    
    // missiles can hit other things
    if (eval(tmthing.flags & MF_MISSILE))
    {
    // see if it went over / under
    if (tmthing.z > thing.z + thing.height)
        return true;        // overhead
    if (tmthing.z+tmthing.height < thing.z)
        return true;        // underneath
        
    if (tmthing.target!=null && (
        tmthing.target.type == thing.type || 
        (tmthing.target.type == mobjtype_t.MT_KNIGHT && thing.type == mobjtype_t.MT_BRUISER)||
        (tmthing.target.type == mobjtype_t.MT_BRUISER && thing.type == mobjtype_t.MT_KNIGHT) ) )
    {
        // Don't hit same species as originator.
        if (thing == tmthing.target)
        return true;

        if (thing.type != mobjtype_t.MT_PLAYER)
        {
        // Explode, but do no damage.
        // Let players missile other players.
        return false;
        }
    }
    
    if (! eval(thing.flags &MF_SHOOTABLE) )
    {
        // didn't do any damage
        return !eval(thing.flags & MF_SOLID);   
    }
    
    // damage / explode
    damage = ((RND.P_Random()%8)+1)*tmthing.info.damage;
    A.DamageMobj (thing, tmthing, tmthing.target, damage);

    // don't traverse any more
    return false;               
    }
    
    // check for special pickup
    if (eval(thing.flags & MF_SPECIAL))
    {
    solid = eval(thing.flags&MF_SOLID);
    if (eval(tmflags&MF_PICKUP))
    {
        // can remove thing
        A.TouchSpecialThing (thing, tmthing);
    }
    return !solid;
    }
    
    return !eval(thing.flags &MF_SOLID);
}

}

/**
 * PIT_RadiusAttack
 * "bombsource" is the creature
 * that caused the explosion at "bombspot".
 */

private class PIT_RadiusAttack implements PIT_MobjFunction {
    public boolean invoke (mobj_t thing)
{
    int dx,dy,dist; // fixed_t
    
    if (!eval(thing.flags & MF_SHOOTABLE) )
    return true;

    // Boss spider and cyborg
    // take no damage from concussion.
    if (thing.type == mobjtype_t.MT_CYBORG
    || thing.type == mobjtype_t.MT_SPIDER)
    return true;
        
    dx = Math.abs(thing.x - bombspot.x);
    dy = Math.abs(thing.y - bombspot.y);
    
    dist = dx>dy ? dx : dy;
    dist = (dist - thing.radius) >> FRACBITS;

    if (dist < 0)
    dist = 0;

    if (dist >= bombdamage)
    return true;    // out of range

    if ( EN.CheckSight (thing, bombspot) )
    {
    // must be in direct path
    A.DamageMobj (thing, bombspot, bombsource, bombdamage - dist);
    }
    
    return true;
	}
}

/**
 *PIT_StompThing
 */

private class PIT_StompThing implements PIT_MobjFunction {
public boolean invoke (mobj_t thing)
{
 int blockdist; // fixed_t
     
 if ((thing.flags & MF_SHOOTABLE)==0 )
 return true;
     
 blockdist = thing.radius + tmthing.radius;
 
 if ( Math.abs(thing.x - tmx) >= blockdist
  || Math.abs(thing.y - tmy) >= blockdist )
 {
 // didn't hit it
 return true;
 }
 
 // don't clip against self
 if (thing == tmthing)
 return true;
 
 // monsters don't stomp things except on boss level
 if ( (tmthing.player==null) && (DM.gamemap != 30))
 return false;   
     
 A.DamageMobj (thing, tmthing, tmthing, 10000); // in interaction
 
 return true;
}
}



}

package p;

public interface Interceptable {

}

package p;

import rr.line_t;
import s.degenmobj_t;

public class button_t implements Resettable{

        public line_t line;
        public bwhere_e    where;
        public int     btexture;
        public int     btimer;
        public degenmobj_t soundorg;
        
        public button_t(){	
        	this.btexture=0;
        	this.btimer=0;
        	this.where=bwhere_e.top;
        }
 
        public void reset(){
            this.line=null;
            this.where=bwhere_e.top;
            this.btexture=0;
            this.btimer=0;
            this.soundorg=null;
            
        }

    }
package p;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;

/**
 * Source animation definition. Made readable for compatibility with Boom's
 * SWANTBLS system. 
 * 
 * @author velktron
 */
public class animdef_t
        implements CacheableDoomObject {

    public animdef_t() {

    }

    public animdef_t(boolean istexture, String endname, String startname,
            int speed) {
        super();
        this.istexture = istexture;
        this.endname = endname;
        this.startname = startname;
        this.speed = speed;
    }

    
    /** if false, it is a flat, and will NOT be used as a texture. Unless you
     *  use "flats on walls functionality of course. */
    public boolean istexture;

    /** The END name and START name of a texture, given in this order when reading a lump 
     *  The animation system is agnostic to the actual names of of the "in-between" 
     *  frames, it's purely pointer based, and only the start/end are constant. It only
     *  counts the actual number of existing textures during initialization time.
     * 
     */
    
    public String endname,startname;

    public int speed;

    public String toString() {
        return String.format("%s %s %s %d", istexture, startname, endname,
            speed);
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        // Like most Doom structs...
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.istexture = (buf.get() != 0);
        this.startname = DoomBuffer.getNullTerminatedString(buf, 9);
        this.endname = DoomBuffer.getNullTerminatedString(buf, 9);
        this.speed = buf.getInt();
    }

    public static int size() {
        return 23;
    }

}

package p;

/** YEAH, I'M USING THE CONSTANTS INTERFACE PATTERN. DEAL WITH IT */

public interface MobjFlags {
 // // MF_ flags for mobjs.

    // Call P_SpecialThing when touched.
    public static final long MF_SPECIAL = 1;
    // Blocks.
    public static final long MF_SOLID = 2;
    // Can be hit.
    public static final long MF_SHOOTABLE = 4;
    // Don't use the sector links (invisible but touchable).
    public static final long MF_NOSECTOR = 8;
    // Don't use the blocklinks (inert but displayable)
    public static final long MF_NOBLOCKMAP = 16;

    // Not to be activated by sound, deaf monster.
    public static final long MF_AMBUSH = 32;
    // Will try to attack right back.
    public static final long MF_JUSTHIT = 64;
    // Will take at least one step before attacking.
    public static final long MF_JUSTATTACKED = 128;
    // On level spawning (initial position),
    // hang from ceiling instead of stand on floor.
    public static final long MF_SPAWNCEILING = 256;
    // Don't apply gravity (every tic),
    // that is, object will float, keeping current height
    // or changing it actively.
    public static final long MF_NOGRAVITY = 512;

    // Movement flags.
    // This allows jumps from high places.
    public static final long MF_DROPOFF = 0x400;
    // For players, will pick up items.
    public static final long MF_PICKUP = 0x800;
    // Player cheat. ???
    public static final int MF_NOCLIP = 0x1000;
    // Player: keep info about sliding along walls.
    public static final int MF_SLIDE = 0x2000;
    // Allow moves to any height, no gravity.
    // For active floaters, e.g. cacodemons, pain elementals.
    public static final int MF_FLOAT = 0x4000;
    // Don't cross lines
    // ??? or look at heights on teleport.
    public static final int MF_TELEPORT = 0x8000;
    // Don't hit same species, explode on block.
    // Player missiles as well as fireballs of various kinds.
    public static final int MF_MISSILE = 0x10000;
    // Dropped by a demon, not level spawned.
    // E.g. ammo clips dropped by dying former humans.
    public static final int MF_DROPPED = 0x20000;
    // Use fuzzy draw (shadow demons or spectres),
    // temporary player invisibility powerup.
    public static final int MF_SHADOW = 0x40000;
    // Flag: don't bleed when shot (use puff),
    // barrels and shootable furniture shall not bleed.
    public static final long MF_NOBLOOD = 0x80000;
    // Don't stop moving halfway off a step,
    // that is, have dead bodies slide down all the way.
    public static final long MF_CORPSE = 0x100000;
    // Floating to a height for a move, ???
    // don't auto float to target's height.
    public static final long MF_INFLOAT = 0x200000;

    // On kill, count this enemy object
    // towards intermission kill total.
    // Happy gathering.
    public static final long MF_COUNTKILL = 0x400000;

    // On picking up, count this item object
    // towards intermission item total.
    public static final long MF_COUNTITEM = 0x800000;

    // Special handling: skull in flight.
    // Neither a cacodemon nor a missile.
    public static final long MF_SKULLFLY = 0x1000000;

    // Don't spawn this object
    // in death match mode (e.g. key cards).
    public static final long MF_NOTDMATCH = 0x2000000;

    // Player sprites in multiplayer modes are modified
    // using an internal color lookup table for re-indexing.
    // If 0x4 0x8 or 0xc,
    // use a translation table for player colormaps
    public static final long MF_TRANSLATION = 0xc000000;
    // Hmm ???.
    public static final long MF_TRANSSHIFT = 26;

    public static final long  MF_UNUSED2      =(0x0000000010000000);
    public static final long  MF_UNUSED3      =(0x0000000020000000);

        // Translucent sprite?                                          // phares
    public static final long  MF_TRANSLUCENT  =(0x0000000040000000);

    // this is free            LONGLONG(0x0000000100000000)

    // these are greater than an int. That's why the flags below are now uint_64_t

    public static final long  MF_TOUCHY = (0x0000000100000000L);
    public static final long  MF_BOUNCES =(0x0000000200000000L);
    public static final long  MF_FRIEND = (0x0000000400000000L);

    public static final long  MF_RESSURECTED =(0x0000001000000000L);
    public static final long  MF_NO_DEPTH_TEST =(0x0000002000000000L);
    public static final long  MF_FOREGROUND = (0x0000004000000000L);
    
}

package p;

import m.IRandom;
import rr.SectorAction;

//
// P_LIGHTS
//

public class fireflicker_t extends SectorAction{
	
     private IRandom RND;
    
     public int     count;
     public int     maxlight;
     public int     minlight;
     
     public fireflicker_t(IRandom RND){
         this.RND=RND;
     }
     
     //
     // T_FireFlicker
     //
     public void FireFlicker() {
         int amount;

         if (--count != 0)
             return;

         amount = (RND.P_Random() & 3) * 16;

         if (sector.lightlevel - amount < minlight)
             sector.lightlevel = (short) minlight;
         else
             sector.lightlevel = (short) (maxlight - amount);

         count = 4;
     }
     
 } 

package p;

//
// P_CEILNG
//

public enum ceiling_e {

     lowerToFloor,
     raiseToHighest,
     lowerAndCrush,
     crushAndRaise,
     fastCrushAndRaise,
     silentCrushAndRaise;

 }

package p;

import doom.player_t;

public interface ActionType2{
	public void invoke ( player_t player, pspdef_t psp );
}
package p;

import static p.DoorDefines.GLOWSPEED;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import rr.SectorAction;
import w.DoomIO;

public class glow_t extends SectorAction{
        public int     minlight;
        public int     maxlight;
        public int     direction;

        //
        // Spawn glowing light
        //

        public void Glow() {
            switch (direction) {
            case -1:
                // DOWN
                sector.lightlevel -= GLOWSPEED;
                if (sector.lightlevel <= minlight) {
                    sector.lightlevel += GLOWSPEED;
                    direction = 1;
                }
                break;

            case 1:
                // UP
                sector.lightlevel += GLOWSPEED;
                if (sector.lightlevel >= maxlight) {
                    sector.lightlevel -= GLOWSPEED;
                    direction = -1;
                }
                break;
            }
        }
        
        @Override
        public void read(DataInputStream f) throws IOException{

            super.read(f); // Call thinker reader first            
            super.sectorid=DoomIO.readLEInt(f); // Sector index
            minlight=DoomIO.readLEInt(f);
            maxlight=DoomIO.readLEInt(f);
            direction=DoomIO.readLEInt(f);
            }
        
        @Override
        public void pack(ByteBuffer b) throws IOException{
            super.pack(b); //12            
            b.putInt(super.sectorid); // 16
            b.putInt(minlight);//20
            b.putInt(maxlight);//24
            b.putInt(direction);//38
        }
        
    }
package p;

import static rr.line_t.ML_TWOSIDED;
import static data.Defines.*;
import static data.Limits.MAXPLAYERS;
import static data.Limits.MAXRADIUS;
import static m.BBox.BOXBOTTOM;
import static m.BBox.BOXLEFT;
import static m.BBox.BOXRIGHT;
import static m.BBox.BOXTOP;
import static m.fixed_t.FRACBITS;
import static m.fixed_t.FixedDiv;
import static utils.C2JUtils.flags;
import java.io.IOException;
import java.nio.ByteOrder;

import m.BBox;
import rr.line_t;
import rr.node_t;
import rr.sector_t;
import rr.seg_t;
import rr.side_t;
import rr.subsector_t;
import rr.vertex_t;
import s.degenmobj_t;
import utils.C2JUtils;
import w.DoomBuffer;
import data.maplinedef_t;
import data.mapnode_t;
import data.mapsector_t;
import data.mapseg_t;
import data.mapsidedef_t;
import data.mapsubsector_t;
import data.mapthing_t;
import data.mapvertex_t;
import defines.*;
import doom.DoomStatus;

//Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: LevelLoader.java,v 1.44 2012/09/24 17:16:23 velktron Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//  Do all the WAD I/O, get map description,
//  set up initial state and misc. LUTs.
//
//-----------------------------------------------------------------------------

public class LevelLoader extends AbstractLevelLoader{

public static final String  rcsid = "$Id: LevelLoader.java,v 1.44 2012/09/24 17:16:23 velktron Exp $";


public LevelLoader(DoomStatus<?,?> DC) {
		super(DC);
		// Traditional loader sets limit.
		deathmatchstarts=new mapthing_t[MAX_DEATHMATCH_STARTS];
	}

  /**
  * P_LoadVertexes
 * @throws IOException 
  */
  public void LoadVertexes (int lump) throws IOException
  {
      // Make a lame-ass attempt at loading some vertexes.
      
      // Determine number of lumps:
      //  total lump length / vertex record length.
      numvertexes = W.LumpLength (lump) / mapvertex_t.sizeOf();

      // Load data into cache.
      // MAES: we now have a mismatch between memory/disk: in memory, we need an array.
      // On disk, we have a single lump/blob. Thus, we need to find a way to deserialize this...
      vertexes=W.CacheLumpNumIntoArray(lump,numvertexes,vertex_t.class);
      
     // Copy and convert vertex coordinates,
     // MAES: not needed. Intermediate mapvertex_t struct skipped.
       
  }



  /**
  * P_LoadSegs
 * @throws IOException 
  */
  public void LoadSegs (int lump) throws IOException
  {
   
      mapseg_t[] data;
      mapseg_t       ml;
      seg_t li;
      line_t     ldef;
      int         linedef;
      int         side;
      
      // Another disparity between disk/memory. Treat it the same as VERTEXES.
      numsegs = W.LumpLength (lump) / mapseg_t.sizeOf();
      segs = C2JUtils.createArrayOfObjects(seg_t.class,numsegs);
      data = W.CacheLumpNumIntoArray(lump,numsegs,mapseg_t.class);
      

      // We're not done yet!
      for (int i=0 ; i<numsegs ; i++)
      {
          li=segs[i];
          ml=data[i];
      li.v1 = vertexes[ml.v1];
      li.v2 = vertexes[ml.v2];
      li.assignVertexValues();
      
      li.angle = ((ml.angle)<<16)&0xFFFFFFFFL;
      li.offset = (ml.offset)<<16;
      linedef = ml.linedef;
      li.linedef = ldef= lines[linedef];
      side = ml.side;
      li.sidedef = sides[ldef.sidenum[side]];
      li.frontsector = sides[ldef.sidenum[side]].sector;
      if (flags(ldef.flags,ML_TWOSIDED)){
    	  // MAES: Fix double sided without back side. E.g. Linedef 16103 in Europe.wad
    	  if (ldef.sidenum[side^1]!=line_t.NO_INDEX)
          li.backsector = sides[ldef.sidenum[side^1]].sector;
          // Fix two-sided with no back side.
    	  //else {
    	  //li.backsector=null;
    	  //ldef.flags^=ML_TWOSIDED;
    	  //}
      	}
      else {
          li.backsector = null;
      		}
      }
      
  }


  /**
  * P_LoadSubsectors
 * @throws IOException 
  */
  public void LoadSubsectors (int lump) throws IOException
  {
      mapsubsector_t ms;
      subsector_t    ss;
      mapsubsector_t[] data;
      
      numsubsectors = W.LumpLength (lump) / mapsubsector_t.sizeOf();      
      subsectors = C2JUtils.createArrayOfObjects(subsector_t.class,numsubsectors);

      // Read "mapsubsectors"
      data=W.CacheLumpNumIntoArray(lump,numsubsectors, mapsubsector_t.class);
      
      for (int i=0 ; i<numsubsectors ; i++)
      {
          ms=data[i];
          ss=subsectors[i];
      ss.numlines = ms.numsegs;
      ss.firstline = ms.firstseg;
      }

  }
  
  /**
   * P_LoadSectors
 * @throws IOException 
   */
  public void LoadSectors (int lump) throws IOException
  {
      mapsector_t[]       data;
      mapsector_t    ms;
      sector_t       ss;
      
      numsectors = W.LumpLength (lump) / mapsector_t.sizeOf();
      sectors = C2JUtils.createArrayOfObjects(sector_t.class,numsectors);
     
      // Read "mapsectors"
      data=W.CacheLumpNumIntoArray(lump,numsectors,mapsector_t.class);

      for (int i=0 ; i<numsectors ; i++)
      {
          ms = data[i];
          ss = sectors[i];
      ss.floorheight = ms.floorheight<<FRACBITS;
      ss.ceilingheight = ms.ceilingheight<<FRACBITS;
      ss.floorpic = (short) TM.FlatNumForName(ms.floorpic);
      ss.ceilingpic = (short) TM.FlatNumForName(ms.ceilingpic);
      ss.lightlevel = ms.lightlevel;
      ss.special = ms.special;
      ss.tag = ms.tag;
      ss.thinglist = null;
      ss.id=i;
      ss.TL=this.P;
      ss.RND=this.DM.RND;
      }

  }


  /**
  * P_LoadNodes
 * @throws IOException 
  */
  
  public void LoadNodes (int lump) throws IOException
  {
      mapnode_t[]   data;
      int     i;
      int     j;
      int     k;
      mapnode_t  mn;
      node_t no;
      
      numnodes = W.LumpLength (lump) / mapnode_t.sizeOf();
      nodes = C2JUtils.createArrayOfObjects(node_t.class,numnodes);

      // Read "mapnodes"
      data = W.CacheLumpNumIntoArray(lump,numnodes,mapnode_t.class);
      
      for (i=0 ; i<numnodes ; i++)
      {
          mn=data[i];
          no=nodes[i];
          
      no.x = mn.x<<FRACBITS;
      no.y = mn.y<<FRACBITS;
      no.dx = mn.dx<<FRACBITS;
      no.dy = mn.dy<<FRACBITS;
      for (j=0 ; j<2 ; j++)
      {
       // e6y: support for extended nodes
          no.children[j] = (char) mn.children[j];

          // e6y: support for extended nodes
          if (no.children[j] == 0xFFFF) {
              no.children[j] = 0xFFFFFFFF;
          } else if (flags(no.children[j], NF_SUBSECTOR_CLASSIC)) {
              // Convert to extended type
              no.children[j] &= ~NF_SUBSECTOR_CLASSIC;

              // haleyjd 11/06/10: check for invalid subsector reference
              if (no.children[j] >= numsubsectors) {
                  System.err
                          .printf(
                              "P_LoadNodes: BSP tree references invalid subsector %d.\n",
                              no.children[j]);
                  no.children[j] = 0;
              }

              no.children[j] |= NF_SUBSECTOR;
          }

          
          for (k=0 ; k<4 ; k++)
          no.bbox[j].set(k, mn.bbox[j][k]<<FRACBITS);
      }
      }
      
  }


  /**
   * P_LoadThings
 * @throws IOException 
   */
  public void LoadThings (int lump) throws IOException
  {
      mapthing_t[]       data;
      mapthing_t     mt;
      int         numthings;
      boolean     spawn;      
      
      numthings = W.LumpLength (lump) / mapthing_t.sizeOf();
      // VERY IMPORTANT: since now caching is near-absolute,
      // the mapthing_t instances must be CLONED rather than just
      // referenced, otherwise missing mobj bugs start  happening.
      
      data=W.CacheLumpNumIntoArray(lump,numthings,mapthing_t.class);
      
      for (int i=0 ; i<numthings ; i++)
      {
          mt = data[i];
      spawn = true;

      // Do not spawn cool, new monsters if !commercial
      if ( !DM.isCommercial())
      {
          switch(mt.type)
          {
            case 68:  // Arachnotron
            case 64:  // Archvile
            case 88:  // Boss Brain
            case 89:  // Boss Shooter
            case 69:  // Hell Knight
            case 67:  // Mancubus
            case 71:  // Pain Elemental
            case 65:  // Former Human Commando
            case 66:  // Revenant
            case 84:  // Wolf SS
          spawn = false;
          break;
          }
      }
      if (spawn == false)
          break;

      // Do spawn all other stuff.
      // MAES: we have loaded the shit with the proper endianness, so no fucking around, bitch.
      /*mt.x = SHORT(mt.x);
      mt.y = SHORT(mt.y);
      mt.angle = SHORT(mt.angle);
      mt.type = SHORT(mt.type);
      mt.options = SHORT(mt.options);*/
      
      //System.out.printf("Spawning %d %s\n",i,mt.type);
      
      P.SpawnMapThing (mt);
      }
      
      // Status may have changed. It's better to release the resources anyway
      //W.UnlockLumpNum(lump);
      
  }


  /**
   * P_LoadLineDefs
   * Also counts secret lines for intermissions.
 * @throws IOException 
   */
  public void LoadLineDefs (int lump) throws IOException
  {
      maplinedef_t[]       data;
      maplinedef_t   mld;
      line_t     ld;
      vertex_t       v1;
      vertex_t       v2;
      
      numlines = W.LumpLength (lump) / maplinedef_t.sizeOf();
      lines = C2JUtils.createArrayOfObjects(line_t.class,numlines);
      // Check those actually used in sectors, later on.
      used_lines=new boolean[numlines]; 

      // read "maplinedefs"
      data = W.CacheLumpNumIntoArray(lump,numlines,maplinedef_t.class);
      
      for (int i=0 ; i<numlines ; i++)
      {
          mld = data[i];
          ld = lines[i];
    
      ld.flags = mld.flags;
      ld.special = mld.special;
      ld.tag = mld.tag;
      v1 = ld.v1 = vertexes[(char)mld.v1];
      v2 = ld.v2 = vertexes[(char)mld.v2];
      ld.dx = v2.x - v1.x;
      ld.dy = v2.y - v1.y;
      // Map value semantics.
      ld.assignVertexValues();
      
      if (ld.dx==0)
          ld.slopetype = slopetype_t.ST_VERTICAL;
      else if (ld.dy==0)
          ld.slopetype = slopetype_t.ST_HORIZONTAL;
      else
      {
          if (FixedDiv (ld.dy , ld.dx) > 0)
          ld.slopetype = slopetype_t.ST_POSITIVE;
          else
          ld.slopetype = slopetype_t.ST_NEGATIVE;
      }
          
      if (v1.x < v2.x)
      {
          ld.bbox[BOXLEFT] = v1.x;
          ld.bbox[BOXRIGHT] = v2.x;
      }
      else
      {
          ld.bbox[BOXLEFT] = v2.x;
          ld.bbox[BOXRIGHT] = v1.x;
      }

      if (v1.y < v2.y)
      {
          ld.bbox[BOXBOTTOM] = v1.y;
          ld.bbox[BOXTOP] = v2.y;
      }
      else
      {
          ld.bbox[BOXBOTTOM] = v2.y;
          ld.bbox[BOXTOP] = v1.y;
      }

      ld.sidenum[0] = mld.sidenum[0];
      ld.sidenum[1] = mld.sidenum[1];
      
      // Sanity check for two-sided without two valid sides.      
      if (flags(ld.flags,ML_TWOSIDED)) {
    	  if ((ld.sidenum[0] == line_t.NO_INDEX) || (ld.sidenum[1] == line_t.NO_INDEX)){
    	  // Well, dat ain't so tu-sided now, ey esse?
    	  ld.flags^=ML_TWOSIDED; 
    	  }
      }

      // Front side defined without a valid frontsector.
      if (ld.sidenum[0] != line_t.NO_INDEX){
          ld.frontsector = sides[ld.sidenum[0]].sector;
          if (ld.frontsector==null){ // // Still null? Bad map. Map to dummy.
        	  ld.frontsector=dummy_sector;
          }
          
      }
      else
          ld.frontsector = null;

      // back side defined without a valid backsector.
      if (ld.sidenum[1] != line_t.NO_INDEX){
          ld.backsector = sides[ld.sidenum[1]].sector;
          if (ld.backsector==null){ // Still null? Bad map. Map to dummy.
        	  ld.backsector=dummy_sector;
          }
      }
      else
          ld.backsector = null;
      
      // If at least one valid sector is defined, then it's not null.
      if (ld.frontsector!=null || ld.backsector!=null) {
          this.used_lines[i]=true;
          }
      
      }
      

   }


  /**
  * P_LoadSideDefs
  */
  public void LoadSideDefs (int lump) throws IOException
  {
      mapsidedef_t[]       data;
      mapsidedef_t   msd;
      side_t     sd;
      
      numsides = W.LumpLength (lump) / mapsidedef_t.sizeOf();
      sides = C2JUtils.createArrayOfObjects(side_t.class,numsides);
      
      data= W.CacheLumpNumIntoArray(lump,numsides,mapsidedef_t.class);
      
      for (int i=0 ; i<numsides ; i++)
      {
          msd = data[i];
          sd = sides[i];
          
      sd.textureoffset = (msd.textureoffset)<<FRACBITS;
      sd.rowoffset = (msd.rowoffset)<<FRACBITS;
      sd.toptexture = (short) TM.TextureNumForName(msd.toptexture);
      sd.bottomtexture = (short) TM.TextureNumForName(msd.bottomtexture);
      sd.midtexture = (short) TM.TextureNumForName(msd.midtexture);
      if (msd.sector<0) sd.sector=dummy_sector;
      else
      sd.sector = sectors[msd.sector];
      }
  }

  // MAES 22/5/2011 This hack added for PHOBOS2.WAD, in order to
  // accomodate for some linedefs having a sector number of "-1".
  // Any negative sector will get rewired to this dummy sector.
  // PROBABLY, this will handle unused sector/linedefes cleanly?
  sector_t dummy_sector=new sector_t(); 
  
  /**
   * P_LoadBlockMap
   * @throws IOException
   * 
   *  TODO: generate BLOCKMAP dynamically to
   *  handle missing cases and increase accuracy.
   *  
   */
  public void LoadBlockMap (int lump) throws IOException
  {
      int     count=0;
      
      if (DM.CM.CheckParmBool("-blockmap") || W.LumpLength(lump) < 8
              || (count = W.LumpLength(lump) / 2) >= 0x10000) // e6y
          CreateBlockMap();
      else {
      
      DoomBuffer data=(DoomBuffer)W.CacheLumpNum(lump,PU_LEVEL, DoomBuffer.class);
      count=W.LumpLength(lump)/2;
      blockmaplump=new int[count];

      data.setOrder(ByteOrder.LITTLE_ENDIAN);
      data.rewind();
      data.readCharArray(blockmaplump, count);
      
      // Maes: first four shorts are header data.
          
      bmaporgx = blockmaplump[0]<<FRACBITS;
      bmaporgy = blockmaplump[1]<<FRACBITS;
      bmapwidth = blockmaplump[2];
      bmapheight = blockmaplump[3];
      
      // MAES: use killough's code to convert terminators to -1 beforehand
      for (int i = 4; i < count; i++) {
          short t = (short) blockmaplump[i]; // killough 3/1/98
          blockmaplump[i] = (int) (t == -1 ? -1l : t & 0xffff);
      }
      
      // haleyjd 03/04/10: check for blockmap problems
      // http://www.doomworld.com/idgames/index.php?id=12935
      if (!VerifyBlockMap(count)) {
          System.err
                  .printf("P_LoadBlockMap: erroneous BLOCKMAP lump may cause crashes.\n");
          System.err
                  .printf("P_LoadBlockMap: use \"-blockmap\" command line switch for rebuilding\n");
      }
      
      }
     count = bmapwidth*bmapheight;
      
     // IMPORTANT MODIFICATION: no need to have both blockmaplump AND blockmap.
     // If the offsets in the lump are OK, then we can modify them (remove 4)
     // and copy the rest of the data in one single data array. This avoids
     // reserving memory for two arrays (we can't simply alias one in Java)
      
      blockmap=new int[blockmaplump.length-4];
      
      // Offsets are relative to START OF BLOCKMAP, and IN SHORTS, not bytes.
      for (int i=0;i<blockmaplump.length-4;i++){
    	  // Modify indexes so that we don't need two different lumps.
    	  // Can probably be further optimized if we simply shift everything backwards.
    	  // and reuse the same memory space.
    	  if (i<count)
    		  blockmaplump[i]=blockmaplump[i+4]-4;
    	  else{
    		  // Make terminators definitively -1, different that 0xffff
  	          short t = (short) blockmaplump[i+4];          // killough 3/1/98
  	          blockmaplump[i] = (int) (t == -1 ? -1l : t & 0xffff);  	          
    	  	}
      	}
      
      // clear out mobj chains
      // ATTENTION! BUG!!!
      // If blocklinks are "cleared" to void -but instantiated- objects,
      // very bad bugs happen, especially the second time a level is re-instantiated.
      // Probably caused other bugs as well, as an extra object would appear in iterators.
      
       if (blocklinks!=null && blocklinks.length==count)
          for (int i=0;i<count;i++)
              blocklinks[i]=null;
       else 
           blocklinks = new mobj_t[count];
       
       // Bye bye. Not needed.
       blockmap=blockmaplump;
  }


  /**
   * P_GroupLines
   * Builds sector line lists and subsector sector numbers.
   * Finds block bounding boxes for sectors.
  */

  
  public void GroupLines ()
  {
      int         total;
      line_t     li;
      sector_t       sector;
      subsector_t    ss;
      seg_t      seg;
      int[]     bbox=new int[4];
      int         block;
      
      // look up sector number for each subsector
      
      for (int i=0 ; i<numsubsectors ; i++)
      {
      ss = subsectors[i];
      seg = segs[ss.firstline];
      ss.sector = seg.sidedef.sector;
      }

      //linebuffer=new line_t[numsectors][0];
      // count number of lines in each sector
      
      
      total = 0;

        for (int i = 0; i < numlines; i++) {
            li = lines[i];
            total++;
            li.frontsector.linecount++;

            if ((li.backsector != null) && (li.backsector != li.frontsector)) {
                li.backsector.linecount++;
                total++;
            }

        }
      
      // build line tables for each sector    
      // MAES: we don't really need this in Java.
      // linebuffer = new line_t[total];
      // int linebuffercount=0;
      
      // We scan through ALL sectors.
      for (int i=0 ; i<numsectors ; i++)
      {
          sector = sectors[i];
          BBox.ClearBox(bbox);
          //sector->lines = linebuffer;
          // We can just construct line tables of the correct size
          // for each sector.
          int countlines=0;
      // We scan through ALL lines....
          
         // System.out.println(i+ ": looking for sector -> "+sector);
      for (int j=0 ; j<numlines ; j++)
      {
          li=lines[j];
          
          //System.out.println(j+ " front "+li.frontsector+ " back "+li.backsector);
          
          if (li.frontsector == sector || li.backsector == sector)
          {
              // This sector will have one more line.
              countlines++;
          // Expand bounding box...
          BBox.AddToBox(bbox, li.v1.x, li.v1.y);
          BBox.AddToBox (bbox, li.v2.x, li.v2.y);
          }
      }
      
      // So, this sector must have that many lines.
      sector.lines=new line_t[countlines];

      int addedlines=0;
      int pointline=0;
      
      // Add actual lines into sectors.
      for (int j=0 ; j<numlines ; j++)
      {
          li=lines[j];
          // If
          if (li.frontsector == sector || li.backsector == sector)
          {
              // This sector will have one more line.
              sectors[i].lines[pointline++]=lines[j];
              addedlines++;
          }
      }
      
      if (addedlines != sector.linecount)
    	  I.Error ("P_GroupLines: miscounted");
              
      // set the degenmobj_t to the middle of the bounding box
      sector.soundorg=new degenmobj_t(((bbox[BOXRIGHT]+bbox[BOXLEFT])/2),
    		  						  ((bbox[BOXTOP]+bbox[BOXBOTTOM])/2),(sector.ceilingheight-sector.floorheight)/2);
          
      // adjust bounding box to map blocks
      block = (bbox[BOXTOP]-bmaporgy+MAXRADIUS)>>MAPBLOCKSHIFT;
      block = block >= bmapheight ? bmapheight-1 : block;
      sector.blockbox[BOXTOP]=block;

      block = (bbox[BOXBOTTOM]-bmaporgy-MAXRADIUS)>>MAPBLOCKSHIFT;
      block = block < 0 ? 0 : block;
      sector.blockbox[BOXBOTTOM]=block;

      block = (bbox[BOXRIGHT]-bmaporgx+MAXRADIUS)>>MAPBLOCKSHIFT;
      block = block >= bmapwidth ? bmapwidth-1 : block;
      sector.blockbox[BOXRIGHT]=block;

      block = (bbox[BOXLEFT]-bmaporgx-MAXRADIUS)>>MAPBLOCKSHIFT;
      block = block < 0 ? 0 : block;
      sector.blockbox[BOXLEFT]=block;
      }
      
  }
  
  
  @Override
  public void
  SetupLevel
  ( int       episode,
    int       map,
    int       playermask,
    skill_t   skill) 
  {
      int     i;
      String    lumpname;
      int     lumpnum;
   
      try{
      DM.totalkills = DM.totalitems = DM.totalsecret = DM.wminfo.maxfrags = 0;
      DM.wminfo.partime = 180;
      for (i=0 ; i<MAXPLAYERS ; i++)
      {
      DM.players[i].killcount = DM.players[i].secretcount 
          = DM.players[i].itemcount = 0;
      }

      // Initial height of PointOfView
      // will be set by player think.
      DM.players[DM.consoleplayer].viewz = 1; 

      // Make sure all sounds are stopped before Z_FreeTags.
      S.Start ();         

  /*    
  #if 0 // UNUSED
      if (debugfile)
      {
      Z_FreeTags (PU_LEVEL, MAXINT);
      Z_FileDumpHeap (debugfile);
      }
      else
  #endif
  */
    //  Z_FreeTags (PU_LEVEL, PU_PURGELEVEL-1);


      // UNUSED W_Profile ();
      P.InitThinkers ();

      // if working with a development map, reload it
      W.Reload ();            
         
      // find map name
      if ( DM.isCommercial())
      {
      if (map<10)
          lumpname="MAP0"+map;
      else
          lumpname="MAP"+map;
      }
      else
      {
      lumpname = ("E"+
     (char)( '0' + episode)+
     "M"+
      (char)( '0' + map)
      );
      }

      lumpnum = W.GetNumForName (lumpname);
      
      DM.leveltime = 0;
      
      if (!W.verifyLumpName(lumpnum+ML_BLOCKMAP, LABELS[ML_BLOCKMAP]))
          System.err.println("Blockmap missing!");
      
      // note: most of this ordering is important
      

      this.LoadVertexes (lumpnum+ML_VERTEXES);      
      this.LoadSectors (lumpnum+ML_SECTORS);
      this.LoadSideDefs (lumpnum+ML_SIDEDEFS);
      this.LoadLineDefs (lumpnum+ML_LINEDEFS);
      this.LoadSubsectors (lumpnum+ML_SSECTORS);
      this.LoadNodes (lumpnum+ML_NODES);
      this.LoadSegs (lumpnum+ML_SEGS);
      
      // MAES: in order to apply optimizations and rebuilding, order must be changed.
      this.LoadBlockMap (lumpnum+ML_BLOCKMAP);
      //this.SanitizeBlockmap();
      //this.getMapBoundingBox();
      
      this.LoadReject(lumpnum+ML_REJECT);
      
      this.GroupLines ();

      DM.bodyqueslot = 0;
      // Reset to "deathmatch starts"
      DM.deathmatch_p = 0;
      this.LoadThings (lumpnum+ML_THINGS);
      
      // if deathmatch, randomly spawn the active players
      if (DM.deathmatch)
      {
      for (i=0 ; i<MAXPLAYERS ; i++)
          if (DM.playeringame[i])
          {
          DM.players[i].mo = null;
       //   DM.DeathMatchSpawnPlayer (i);
          }
              
      }

      // clear special respawning que
      P.iquehead = P.iquetail = 0;        
      
      // set up world state
      P.SpawnSpecials ();
      
      // build subsector connect matrix
      //  UNUSED P_ConnectSubsectors ();

      // preload graphics
      if (DM.precache){
      TM.PrecacheLevel ();
      // MAES: thinkers are separate than texture management. Maybe split sprite management as well?
      R.PreCacheThinkers();
      
      }

      } catch (Exception e){
          System.err.println("Error while loading level");
          e.printStackTrace();
      }
  }

}

//$Log: LevelLoader.java,v $
//Revision 1.44  2012/09/24 17:16:23  velktron
//Massive merge between HiColor and HEAD. There's no difference from now on, and development continues on HEAD.
//
//Revision 1.43.2.2  2012/09/24 16:57:16  velktron
//Addressed generics warnings.
//
//Revision 1.43.2.1  2012/03/26 09:53:44  velktron
//Use line_t.NO_INDEX for good measure, when possible.
//
//Revision 1.43  2011/11/03 15:19:51  velktron
//Adapted to using ISpriteManager
//
//Revision 1.42  2011/10/07 16:05:52  velktron
//Now using line_t for ML_* definitions.
//
//Revision 1.41  2011/10/06 16:44:32  velktron
//Proper support for extended nodes, made reject loading into a separate method.
//
//Revision 1.40  2011/09/30 15:20:24  velktron
//Very modified, useless SanitizeBlockmap method ditched. 
//Common utility methods moved to superclass. Shares blockmap checking and generation 
//with Boom-derived code. Now capable of running Europe.wad. 
//TODO: Blockmap generation can be really slow on large levels. 
//Optimize better for Java, or parallelize.
//
//Revision 1.39  2011/09/29 17:22:08  velktron
//Blockchain terminators are now -1 (extended)
//
//Revision 1.38  2011/09/29 17:11:32  velktron
//Blockmap optimizations.
//
//Revision 1.37  2011/09/29 15:17:48  velktron
//SetupLevel can propagate exceptions.
//
//Revision 1.36  2011/09/29 13:28:01  velktron
//Extends AbstractLevelLoader
//
//Revision 1.35  2011/09/27 18:04:36  velktron
//Fixed major blockmap bug
//
//Revision 1.34  2011/09/27 16:00:20  velktron
//Minor blockmap stuff.
//
//Revision 1.33  2011/08/24 15:52:04  velktron
//Sets proper ISoundOrigin for sectors (height, too)
//
//Revision 1.32  2011/08/24 15:00:34  velktron
//Improved version, now using createArrayOfObjects. Much better syntax.
//
//Revision 1.31  2011/08/23 16:17:22  velktron
//Got rid of Z remnants.
//
//Revision 1.30  2011/07/27 21:26:19  velktron
//Quieted down debugging for v1.5 release
//
//Revision 1.29  2011/07/25 19:56:53  velktron
//reject matrix size bugfix, fron danmaku branch.
//
//Revision 1.28  2011/07/22 15:37:52  velktron
//Began blockmap autogen code...still WIP
//
//Revision 1.27  2011/07/20 16:14:45  velktron
//Bullet-proofing vs missing or corrupt REJECT table. TODO: built-in system to re-compute it.
//
//Revision 1.26  2011/06/18 23:25:33  velktron
//Removed debugginess
//
//Revision 1.25  2011/06/18 23:21:26  velktron
//-id
//
//Revision 1.24  2011/06/18 23:18:24  velktron
//Added sanitization for broken two-sided sidedefs, and semi-support for extended blockmaps.
//
//Revision 1.23  2011/05/24 11:31:47  velktron
//Adapted to IDoomStatusBar
//
//Revision 1.22  2011/05/22 21:09:34  velktron
//Added spechit overflow handling, and unused linedefs (with -1 sector) handling.
//
//Revision 1.21  2011/05/21 14:53:57  velktron
//Adapted to use new gamemode system.
//
//Revision 1.20  2011/05/20 14:52:23  velktron
//Moved several function from the Renderer and Action code in here, since it made more sense.
//
//Revision 1.19  2011/05/18 16:55:44  velktron
//TEMPORARY TESTING VERSION, DO NOT USE
//
//Revision 1.18  2011/05/17 16:51:20  velktron
//Switched to DoomStatus
//
//Revision 1.17  2011/05/10 10:39:18  velktron
//Semi-playable Techdemo v1.3 milestone
//
//Revision 1.16  2011/05/05 17:24:22  velktron
//Started merging more of _D_'s changes.
//
//Revision 1.15  2010/12/20 17:15:08  velktron
//Made the renderer more OO -> TextureManager and other changes as well.
//
//Revision 1.14  2010/11/22 21:41:22  velktron
//Parallel rendering...sort of.It works, but either  the barriers are broken or it's simply not worthwhile at this point :-/
//
//Revision 1.13  2010/11/22 14:54:53  velktron
//Greater objectification of sectors etc.
//
//Revision 1.12  2010/11/22 01:17:16  velktron
//Fixed blockmap (for the most part), some actions implemented and functional, ambient animation/lighting functional.
//
//Revision 1.11  2010/11/14 20:00:21  velktron
//Bleeding floor bug fixed!
//
//Revision 1.10  2010/11/03 16:48:04  velktron
//"Bling" view angles fixed (perhaps related to the "bleeding line bug"?)
//
//Revision 1.9  2010/09/27 02:27:29  velktron
//BEASTLY update
//
//Revision 1.8  2010/09/23 20:36:45  velktron
//*** empty log message ***
//
//Revision 1.7  2010/09/23 15:11:57  velktron
//A bit closer...
//
//Revision 1.6  2010/09/22 16:40:02  velktron
//MASSIVE changes in the status passing model.
//DoomMain and DoomGame unified.
//Doomstat merged into DoomMain (now status and game functions are one).
//
//Most of DoomMain implemented. Possible to attempt a "classic type" start but will stop when reading sprites.
//
//Revision 1.5  2010/09/21 15:53:37  velktron
//Split the Map ...somewhat...
//
//Revision 1.4  2010/09/14 15:34:01  velktron
//The enormity of this commit is incredible (pun intended)
//
//Revision 1.3  2010/09/08 15:22:18  velktron
//x,y coords in some structs as value semantics. Possible speed increase?
//
//Revision 1.2  2010/09/02 15:56:54  velktron
//Bulk of unified renderer copyediting done.
//
//Some changes like e.g. global separate limits class and instance methods for seg_t and node_t introduced.
//
//Revision 1.1  2010/09/01 15:53:42  velktron
//Graphics data loader implemented....still need to figure out how column caching works, though.
//
//Revision 1.4  2010/08/19 23:14:49  velktron
//Automap
//
//Revision 1.3  2010/08/13 14:06:36  velktron
//Endlevel screen fully functional!
//
//Revision 1.2  2010/08/11 16:31:34  velktron
//Map loading works! Check out LevelLoaderTester for more.
//
//Revision 1.1  2010/08/10 16:41:57  velktron
//Threw some work into map loading.
//
package p;

public enum result_e {
        ok,
        crushed,
        pastdest
}

package p;

import static rr.line_t.ML_BLOCKING;
import static data.Defines.BT_ATTACK;
import static data.Defines.MAPBLOCKSHIFT;
import static data.Defines.MELEERANGE;
import static data.Defines.MISSILERANGE;
import static data.Defines.PST_DEAD;
import static data.Defines.pw_strength;
import static data.Limits.MAXPLAYERS;
import static data.Limits.MAXRADIUS;
import static data.Limits.MAXSKULLS;
import static data.Limits.NUMBRAINTARGETS;
import static data.Tables.ANG180;
import static data.Tables.ANG270;
import static data.Tables.ANG45;
import static data.Tables.ANG90;
import static data.Tables.BITS32;
import static data.Tables.FINEANGLES;
import static data.Tables.FINEMASK;
import static data.Tables.finecosine;
import static data.Tables.finesine;
import static data.info.mobjinfo;
import static data.info.states;
import static doom.items.weaponinfo;
import static doom.player_t.LOWERSPEED;
import static doom.player_t.RAISESPEED;
import static doom.player_t.WEAPONBOTTOM;
import static doom.player_t.WEAPONTOP;
import static doom.player_t.ps_flash;
import static doom.player_t.ps_weapon;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.MAPFRACUNIT;
import static m.fixed_t.FixedMul;
import static p.ChaseDirections.DI_NODIR;
import static p.ChaseDirections.xspeed;
import static p.ChaseDirections.yspeed;
import static p.MapUtils.AproxDistance;
import static p.mobj_t.MF_AMBUSH;
import static p.mobj_t.MF_COUNTKILL;
import static p.mobj_t.MF_JUSTATTACKED;
import static p.mobj_t.MF_SHADOW;
import static p.mobj_t.MF_SHOOTABLE;
import static p.mobj_t.MF_SKULLFLY;
import static p.mobj_t.MF_SOLID;
import static utils.C2JUtils.eval;
import static utils.C2JUtils.flags;
import i.DoomStatusAware;
import p.UnifiedGameMap.Enemies;
import m.IRandom;
import rr.Renderer;
import rr.line_t;
import s.IDoomSound;
import data.Tables;
import data.mobjinfo_t;
import data.mobjtype_t;
import data.state_t;
import data.sounds.sfxenum_t;
import defines.skill_t;
import defines.statenum_t;
import doom.DoomStatus;
import doom.IDoomGame;
import doom.player_t;
import doom.think_t;
import doom.thinker_t;
import doom.weapontype_t;

public class ActionFunctions implements DoomStatusAware{


	public ActionFunctions(){
		MobjThinker=new P_MobjThinker();
		  WeaponReady=new A_WeaponReady();
		  Lower=new A_Lower();
		  Raise=new A_Raise();
		  Punch=new A_Punch();
		  ReFire=new A_ReFire();
		  FirePistol=new A_FirePistol();
		  Light0=new A_Light0();
		  Light1=new A_Light1();
		  Light2=new A_Light2();
		   FireShotgun=new A_FireShotgun();	
		   FireShotgun2=new A_FireShotgun2();	
		  CheckReload=new A_CheckReload();
		  OpenShotgun2=new A_OpenShotgun2();
		  LoadShotgun2=new A_LoadShotgun2();
		  CloseShotgun2=new A_CloseShotgun2();
		  FireCGun=new A_FireCGun();
		  GunFlash=new A_GunFlash();
		  FireMissile=new A_FireMissile();
		  Saw=new A_Saw();
		  FirePlasma=new A_FirePlasma();
		  BFGsound=new A_BFGsound();
		  FireBFG=new A_FireBFG();
	      BFGSpray=new A_BFGSpray();
	      Explode=new A_Explode();
	      Pain=new A_Pain();
	      PlayerScream=new A_PlayerScream();
	      Fall=new A_Fall();
	      XScream=new A_XScream();
	      Look=new A_Look();
	      Chase=new A_Chase();
	      FaceTarget=new A_FaceTarget();
	      PosAttack=new A_PosAttack();
	      Scream=new A_Scream();
	      SPosAttack=new A_SPosAttack();
	      VileChase=new A_VileChase();
	      VileStart=new A_VileStart();
	      VileTarget=new A_VileTarget();
	      VileAttack=new A_VileAttack();
	      StartFire=new A_StartFire();
	      Fire=new A_Fire();
	      FireCrackle=new A_FireCrackle();
	      Tracer=new A_Tracer();
	      SkelWhoosh=new A_SkelWhoosh();
	      SkelFist=new A_SkelFist();
	      SkelMissile=new A_SkelMissile();
	      FatRaise=new A_FatRaise();
	      FatAttack1=new A_FatAttack1();
	      FatAttack2=new A_FatAttack2();
	      FatAttack3=new A_FatAttack3();
	      BossDeath=new A_BossDeath();
	      CPosAttack=new A_CPosAttack();
	      CPosRefire=new A_CPosRefire();
	      TroopAttack=new A_TroopAttack();
	      SargAttack=new A_SargAttack();
	      HeadAttack=new A_HeadAttack();
	     BruisAttack=new A_BruisAttack();
	      SkullAttack=new A_SkullAttack();
	      Metal=new A_Metal();
	      SpidRefire=new A_SpidRefire();
	     BabyMetal=new A_BabyMetal();
	     BspiAttack=new A_BspiAttack();
	      Hoof=new A_Hoof();
	      CyberAttack=new A_CyberAttack();
	      PainAttack=new A_PainAttack();
	      PainDie=new A_PainDie();
	      KeenDie=new A_KeenDie();
	      BrainPain=new A_BrainPain();
	      BrainScream=new A_BrainScream();
	      BrainDie=new A_BrainDie();
	      BrainAwake=new A_BrainAwake();
	      BrainSpit=new A_BrainSpit();
	      SpawnSound=new A_SpawnSound();
	      SpawnFly=new A_SpawnFly();
	      BrainExplode=new A_BrainExplode();
	      
	      // these need special handling.
	      FireFlicker=new T_FireFlicker();
	      LightFlash=new T_LightFlash();
		  StrobeFlash=new T_StrobeFlash();
		  Glow=new T_Glow();
		  MoveCeiling=new T_MoveCeiling();
		  MoveFloor=new T_MoveFloor();
		  VerticalDoor=new T_VerticalDoor();
		  PlatRaise=new T_PlatRaise();
		  SlidingDoor=new T_SlidingDoor();
		
	}
		
	public ActionFunctions(DoomStatus<?,?> DS, Enemies EN) {
		this();
		this.EN=EN;     
		updateStatus(DS);
	}

	@Override
	public void updateStatus(DoomStatus<?,?> DS){
		this.A=DS.P;
        this.RND=DS.RND;       
        this.R=DS.R;
        this.S=DS.S;
        this.LL=DS.LL;
        this.DS=DS.DM;
        this.DG=DS.DG;
//        this.SL=DS.SL;
	}
	
	protected Actions A;
	protected IRandom RND;
	protected Renderer<?,?> R;
	protected IDoomSound S;
	protected Enemies EN;
	protected AbstractLevelLoader LL;
	protected DoomStatus<?,?> DS;
	protected IDoomGame DG;
	protected SlideDoor SL;
	

	ActionType2  WeaponReady;
	ActionType2  Lower;
	ActionType2  Raise;
	ActionType2  Punch;
	ActionType2  ReFire;
	ActionType2  FirePistol;
	ActionType2  Light0;
	ActionType2  Light1;
	ActionType2  Light2;
	ActionType2   FireShotgun;	
	ActionType2  FireShotgun2;
	ActionType2  CheckReload;
	ActionType2  OpenShotgun2;
	ActionType2  LoadShotgun2;
	ActionType2  CloseShotgun2;
	ActionType2  FireCGun;
	ActionType2  GunFlash;
	ActionType2  FireMissile;
	ActionType2  Saw;
	ActionType2  FirePlasma;
	ActionType2  BFGsound;
	ActionType2  FireBFG;
    ActionType1  BFGSpray;
    ActionType1  Explode;
    ActionType1  Pain;
    ActionType1  PlayerScream;
    ActionType1 Fall;
    ActionType1  XScream;
    ActionType1  Look;
    ActionType1  Chase;
    ActionType1  FaceTarget;
    ActionType1  PosAttack;
    ActionType1  Scream;
    ActionType1  SPosAttack;
    ActionType1  VileChase;
    ActionType1  VileStart;
    ActionType1  VileTarget;
    ActionType1  VileAttack;
    ActionType1 StartFire;
    ActionType1  Fire;
    ActionType1  FireCrackle;
    ActionType1  Tracer;
    ActionType1  SkelWhoosh;
    ActionType1  SkelFist;
    ActionType1  SkelMissile;
    ActionType1  FatRaise;
    ActionType1  FatAttack1;
    ActionType1  FatAttack2;
    ActionType1 FatAttack3;
    ActionType1  BossDeath;
    ActionType1  CPosAttack;
    ActionType1  CPosRefire;
    ActionType1  TroopAttack;
    ActionType1  SargAttack;
    ActionType1  HeadAttack;
    ActionType1 BruisAttack;
    ActionType1  SkullAttack;
    ActionType1  Metal;
    ActionType1  SpidRefire;
    ActionType1 BabyMetal;
    ActionType1 BspiAttack;
    ActionType1  Hoof;
    ActionType1  CyberAttack;
    ActionType1  PainAttack;
    ActionType1  PainDie;
    ActionType1 KeenDie;
    ActionType1  BrainPain;
    ActionType1  BrainScream;
    ActionType1  BrainDie;
    ActionType1  BrainAwake;
    ActionType1  BrainSpit;
    ActionType1  SpawnSound;
    ActionType1  SpawnFly;
    ActionType1  BrainExplode;
    ActionType1  MobjThinker;
    ActionTypeSS<?>  FireFlicker;
    ActionTypeSS<?>  LightFlash;
	ActionTypeSS<?> StrobeFlash;
	ActionTypeSS<?>  Glow;
	ActionTypeSS<?>  MoveCeiling;
	ActionTypeSS<?>  MoveFloor;
	ActionTypeSS<?>  VerticalDoor;
	ActionTypeSS<?> PlatRaise;
	ActionTypeSS<?> SlidingDoor;
	
	/** Wires a state to an actual callback depending on its
	 *  enum. This eliminates the need to have a giant
	 *  switch statements in Actions, and should allow DEH
	 *  rewiring.
	 * @param st
	 */
	
	public void doWireState(state_t st){
	      //System.out.println("Dispatching: "+action);
		if (st.action==null) return;
	      switch (st.action){
	          case P_MobjThinker:
	        	  st.acp1=MobjThinker;
	        	  break;
	          case A_Light0:
	        	  st.acp2=Light0;
	        	  break;
	          case A_WeaponReady:
	        	  st.acp2=WeaponReady;
	        	  break;        	  
	          case  A_Lower:
	        	  st.acp2=Lower;
	        	  break;
	          case  A_Raise:
	        	  st.acp2=Raise;
	        	  break;
	          case  A_Punch:
	        	  st.acp2=Punch;
	        	  break;
	          case A_ReFire:
	        	  st.acp2=ReFire;
	        	  break;
	          case A_FirePistol:
	        	  st.acp2= FirePistol;
	        	  break;
	          case  A_Light1:
	        	  st.acp2=Light1;
	        	  break;
	          case A_FireShotgun:
	        	  st.acp2=FireShotgun;
	        	  break;
	          case  A_Light2:
	        	  st.acp2=Light2;
	        	  break;
	          case A_FireShotgun2:
	        	  st.acp2=FireShotgun2;
	        	  break;
	          case  A_CheckReload:
	        	  st.acp2=CheckReload;
	        	  break;
	          case A_OpenShotgun2:
	        	  st.acp2=OpenShotgun2;
	        	  break;
	          case A_LoadShotgun2:
	        	  st.acp2=LoadShotgun2;
	        	  break;
	          case A_CloseShotgun2:
	        	  st.acp2=CloseShotgun2;
	        	  break;
	          case A_FireCGun:
	        	  st.acp2=FireCGun;
	        	  break;
	          case A_GunFlash:
	        	  st.acp2=GunFlash;
	        	  break;
	          case A_FireMissile:
	        	  st.acp2=FireMissile;
	        	  break;
	          case A_Saw:
	        	  st.acp2=Saw;
	        	  break;
	          case A_FirePlasma:
	        	  st.acp2=FirePlasma;
	        	  break;
	          case A_BFGsound:
	        	  st.acp2=BFGsound;
	        	  break;
	          case A_FireBFG:
	        	  st.acp2=FireBFG;
	        	  break;
	          case A_BFGSpray:
	        	  st.acp1=BFGSpray;
	        	  break;
	          case A_Explode:
	        	  st.acp1=Explode;
	        	  break;
	          case A_Pain:
	        	  st.acp1=Pain;
	        	  break;
	          case A_PlayerScream:
	        	  st.acp1=PlayerScream;
	        	  break;
	          case A_Fall:
	        	  st.acp1=Fall;
	        	  break;
	          case  A_XScream:
	        	  st.acp1=XScream;
	        	  break;
	          case A_Look:
	        	  st.acp1=Look;
	        	  break;
	          case  A_Chase:
	        	  st.acp1=Chase;
	        	  break;
	          case  A_FaceTarget:
	        	  st.acp1=FaceTarget;
	        	  break;
	          case  A_PosAttack:
	        	  st.acp1=PosAttack;
	        	  break;
	          case  A_Scream:
	        	  st.acp1=Scream;
	        	  break;
	          case  A_SPosAttack:
	        	  st.acp1=SPosAttack;
	        	  break;
	          case  A_VileChase:
	        	  st.acp1=VileChase;
	        	  break;
	          case  A_VileStart:
	        	  st.acp1=VileStart;
	        	  break;
	          case  A_VileTarget:
	        	  st.acp1=VileTarget;
	        	  break;
	          case  A_VileAttack:
	        	  st.acp1=VileAttack;
	        	  break;
	          case  A_StartFire:
	        	  st.acp1=StartFire;
	        	  break;
	          case  A_Fire:
	        	  st.acp1=Fire;
	        	  break;
	          case  A_FireCrackle:
	        	  st.acp1=FireCrackle;
	        	  break;
	          case  A_Tracer:
	        	  st.acp1=Tracer;
	        	  break;
	          case  A_SkelWhoosh:
	        	  st.acp1=SkelWhoosh;
	        	  break;
	          case  A_SkelFist:
	        	  st.acp1=SkelFist;
	        	  break;
	          case  A_SkelMissile:
	        	  st.acp1=SkelMissile;
	        	  break;
	          case  A_FatRaise:
	        	  st.acp1=FatRaise;
	        	  break;
	          case  A_FatAttack1:
	        	  st.acp1=FatAttack1;
	        	  break;
	          case  A_FatAttack2:
	        	  st.acp1=FatAttack2;
	        	  break;
	          case A_FatAttack3:
	        	  st.acp1= FatAttack3;
	        	  break;
	          case  A_BossDeath:
	        	  st.acp1=BossDeath;
	        	  break;
	          case  A_CPosAttack:
	        	  st.acp1=CPosAttack;
	        	  break;
	          case  A_CPosRefire:
	        	  st.acp1=CPosRefire;
	        	  break;
	          case  A_TroopAttack:
	        	  st.acp1=TroopAttack;
	        	  break;
	          case  A_SargAttack:
	        	  st.acp1=SargAttack;
	        	  break;
	          case  A_HeadAttack:
	        	  st.acp1=HeadAttack;
	        	  break;
	          case  A_BruisAttack:
	        	  st.acp1=BruisAttack;
	        	  break;
	          case  A_SkullAttack:
	        	  st.acp1=SkullAttack;
	        	  break;
	          case  A_Metal:
	        	  st.acp1=Metal;
	        	  break;
	          case  A_SpidRefire:
	        	  st.acp1=SpidRefire;
	        	  break;
	          case  A_BabyMetal:
	        	  st.acp1=BabyMetal;
	        	  break;
	          case  A_BspiAttack:
	        	  st.acp1=BspiAttack;
	        	  break;
	          case  A_Hoof:
	        	  st.acp1=Hoof;
	        	  break;
	          case  A_CyberAttack:
	        	  st.acp1=CyberAttack;
	        	  break;
	          case  A_PainAttack:
	        	  st.acp1=PainAttack;
	        	  break;
	          case  A_PainDie:
	        	  st.acp1=PainDie;
	        	  break;
	          case  A_KeenDie:
	        	  st.acp1=KeenDie;
	              break;
	          case  A_BrainPain:
	        	  st.acp1= BrainPain;
	        	  break;
	          case  A_BrainScream:
	        	  st.acp1=BrainScream;
	        	  break;
	          case  A_BrainDie:
	        	  st.acp1= BrainDie;
	        	  break;
	          case  A_BrainAwake:
	        	  st.acp1=BrainAwake;
	        	  break;        	  
	          case  A_BrainSpit:
	        	  st.acp1=BrainSpit;
	        	  break;
	          case  A_SpawnSound:
	        	  st.acp1=SpawnSound;
	        	  break;
	          case  A_SpawnFly:
	        	  st.acp1=SpawnFly;
	        	  break;
	          case  A_BrainExplode:
	        	  st.acp1=BrainExplode;
	        	  break;
	          case  T_FireFlicker:
	        	  st.acpss=FireFlicker;
	        	  break;
	          case 	T_LightFlash:
	        	  st.acpss=LightFlash;
	        	  break;
	          case	T_StrobeFlash:
	        	  st.acpss=StrobeFlash;
	        	  break;
	          case	T_Glow:
	        	  st.acpss=Glow;
	        	  break;
	          case	T_MoveCeiling:
	        	  st.acpss=MoveCeiling;
	        	  break;
	          case	T_MoveFloor:
	        	  st.acpss=MoveFloor;
	        	  break;
	          case    T_VerticalDoor:
	              //_D_: changed this to make it work
	        	  st.acpss=VerticalDoor;
	              break;
	          case	T_PlatRaise:
	        	  st.acpss=PlatRaise;
	          	break;
	      }
	      
	  }
	
	public void doWireThinker(thinker_t st){
	      //System.out.println("Dispatching: "+action);
		if (st==null) return;
		
		// we don't want anything to be called on this.
		if (st.function==null){
			st.acp1=null;
			st.acp2=null;
			st.acpss=null;
			return;
		}
		
	      switch (st.function){
	          case P_MobjThinker:
	        	  st.acp1=MobjThinker;
	        	  break;
	          case A_Light0:
	        	  st.acp2=Light0;
	        	  break;
	          case A_WeaponReady:
	        	  st.acp2=WeaponReady;
	        	  break;        	  
	          case  A_Lower:
	        	  st.acp2=Lower;
	        	  break;
	          case  A_Raise:
	        	  st.acp2=Raise;
	        	  break;
	          case  A_Punch:
	        	  st.acp2=Punch;
	        	  break;
	          case A_ReFire:
	        	  st.acp2=ReFire;
	        	  break;
	          case A_FirePistol:
	        	  st.acp2= FirePistol;
	        	  break;
	          case  A_Light1:
	        	  st.acp2=Light1;
	        	  break;
	          case A_FireShotgun:
	        	  st.acp2=FireShotgun;
	        	  break;
	          case  A_Light2:
	        	  st.acp2=Light2;
	        	  break;
	          case A_FireShotgun2:
	        	  st.acp2=FireShotgun2;
	        	  break;
	          case  A_CheckReload:
	        	  st.acp2=CheckReload;
	        	  break;
	          case A_OpenShotgun2:
	        	  st.acp2=OpenShotgun2;
	        	  break;
	          case A_LoadShotgun2:
	        	  st.acp2=LoadShotgun2;
	        	  break;
	          case A_CloseShotgun2:
	        	  st.acp2=CloseShotgun2;
	        	  break;
	          case A_FireCGun:
	        	  st.acp2=FireCGun;
	        	  break;
	          case A_GunFlash:
	        	  st.acp2=GunFlash;
	        	  break;
	          case A_FireMissile:
	        	  st.acp2=FireMissile;
	        	  break;
	          case A_Saw:
	        	  st.acp2=Saw;
	        	  break;
	          case A_FirePlasma:
	        	  st.acp2=FirePlasma;
	        	  break;
	          case A_BFGsound:
	        	  st.acp2=BFGsound;
	        	  break;
	          case A_FireBFG:
	        	  st.acp2=FireBFG;
	        	  break;
	          case A_BFGSpray:
	        	  st.acp1=BFGSpray;
	        	  break;
	          case A_Explode:
	        	  st.acp1=Explode;
	        	  break;
	          case A_Pain:
	        	  st.acp1=Pain;
	        	  break;
	          case A_PlayerScream:
	        	  st.acp1=PlayerScream;
	        	  break;
	          case A_Fall:
	        	  st.acp1=Fall;
	        	  break;
	          case  A_XScream:
	        	  st.acp1=XScream;
	        	  break;
	          case A_Look:
	        	  st.acp1=Look;
	        	  break;
	          case  A_Chase:
	        	  st.acp1=Chase;
	        	  break;
	          case  A_FaceTarget:
	        	  st.acp1=FaceTarget;
	        	  break;
	          case  A_PosAttack:
	        	  st.acp1=PosAttack;
	        	  break;
	          case  A_Scream:
	        	  st.acp1=Scream;
	        	  break;
	          case  A_SPosAttack:
	        	  st.acp1=SPosAttack;
	        	  break;
	          case  A_VileChase:
	        	  st.acp1=VileChase;
	        	  break;
	          case  A_VileStart:
	        	  st.acp1=VileStart;
	        	  break;
	          case  A_VileTarget:
	        	  st.acp1=VileTarget;
	        	  break;
	          case  A_VileAttack:
	        	  st.acp1=VileAttack;
	        	  break;
	          case  A_StartFire:
	        	  st.acp1=StartFire;
	        	  break;
	          case  A_Fire:
	        	  st.acp1=Fire;
	        	  break;
	          case  A_FireCrackle:
	        	  st.acp1=FireCrackle;
	        	  break;
	          case  A_Tracer:
	        	  st.acp1=Tracer;
	        	  break;
	          case  A_SkelWhoosh:
	        	  st.acp1=SkelWhoosh;
	        	  break;
	          case  A_SkelFist:
	        	  st.acp1=SkelFist;
	        	  break;
	          case  A_SkelMissile:
	        	  st.acp1=SkelMissile;
	        	  break;
	          case  A_FatRaise:
	        	  st.acp1=FatRaise;
	        	  break;
	          case  A_FatAttack1:
	        	  st.acp1=FatAttack1;
	        	  break;
	          case  A_FatAttack2:
	        	  st.acp1=FatAttack2;
	        	  break;
	          case A_FatAttack3:
	        	  st.acp1= FatAttack3;
	        	  break;
	          case  A_BossDeath:
	        	  st.acp1=BossDeath;
	        	  break;
	          case  A_CPosAttack:
	        	  st.acp1=CPosAttack;
	        	  break;
	          case  A_CPosRefire:
	        	  st.acp1=CPosRefire;
	        	  break;
	          case  A_TroopAttack:
	        	  st.acp1=TroopAttack;
	        	  break;
	          case  A_SargAttack:
	        	  st.acp1=SargAttack;
	        	  break;
	          case  A_HeadAttack:
	        	  st.acp1=HeadAttack;
	        	  break;
	          case  A_BruisAttack:
	        	  st.acp1=BruisAttack;
	        	  break;
	          case  A_SkullAttack:
	        	  st.acp1=SkullAttack;
	        	  break;
	          case  A_Metal:
	        	  st.acp1=Metal;
	        	  break;
	          case  A_SpidRefire:
	        	  st.acp1=SpidRefire;
	        	  break;
	          case  A_BabyMetal:
	        	  st.acp1=BabyMetal;
	        	  break;
	          case  A_BspiAttack:
	        	  st.acp1=BspiAttack;
	        	  break;
	          case  A_Hoof:
	        	  st.acp1=Hoof;
	        	  break;
	          case  A_CyberAttack:
	        	  st.acp1=CyberAttack;
	        	  break;
	          case  A_PainAttack:
	        	  st.acp1=PainAttack;
	        	  break;
	          case  A_PainDie:
	        	  st.acp1=PainDie;
	        	  break;
	          case  A_KeenDie:
	        	  st.acp1=KeenDie;
	              break;
	          case  A_BrainPain:
	        	  st.acp1= BrainPain;
	        	  break;
	          case  A_BrainScream:
	        	  st.acp1=BrainScream;
	        	  break;
	          case  A_BrainDie:
	        	  st.acp1= BrainDie;
	        	  break;
	          case  A_BrainAwake:
	        	  st.acp1=BrainAwake;
	        	  break;        	  
	          case  A_BrainSpit:
	        	  st.acp1=BrainSpit;
	        	  break;
	          case  A_SpawnSound:
	        	  st.acp1=SpawnSound;
	        	  break;
	          case  A_SpawnFly:
	        	  st.acp1=SpawnFly;
	        	  break;
	          case  A_BrainExplode:
	        	  st.acp1=BrainExplode;
	        	  break;
	          case  T_FireFlicker:
	        	  st.acpss=FireFlicker;
	        	  break;
	          case 	T_LightFlash:
	        	  st.acpss=LightFlash;
	        	  break;
	          case	T_StrobeFlash:
	        	  st.acpss=StrobeFlash;
	        	  break;
	          case	T_Glow:
	        	  st.acpss=Glow;
	        	  break;
	          case	T_MoveCeiling:
	        	  st.acpss=MoveCeiling;
	        	  break;
	          case	T_MoveFloor:
	        	  st.acpss=MoveFloor;
	        	  break;
	          case    T_VerticalDoor:
	              //_D_: changed this to make it work
	        	  st.acpss=VerticalDoor;
	              break;
	          case	T_PlatRaise:
	        	  st.acpss=PlatRaise;
	          	break;
	          case	T_SlidingDoor:
	        	  st.acpss=SlidingDoor;
	          	break;
	      }
	      
	  }
	
	
	/** Causes object to move and perform actions.
	 *  Can only be called through the Actions dispatcher.
	 * 
	 * @param mobj
	 */
	      

	class P_MobjThinker implements ActionType1{
	    public void invoke(mobj_t  mobj){
			// momentum movement
			if (mobj.momx != 0 || mobj.momy != 0
					|| (eval(mobj.flags& MF_SKULLFLY))) {
				A.XYMovement(mobj);

				// FIXME: decent NOP/NULL/Nil function pointer please.
				if (mobj.function == think_t.NOP){
					return; // mobj was removed
				}
			}
			if ((mobj.z != mobj.floorz) || mobj.momz != 0) {
				mobj.ZMovement();

				// FIXME: decent NOP/NULL/Nil function pointer please.
				if (mobj.function == think_t.NOP){
					return; // mobj was removed
				}	
			}

			// cycle through states,
			// calling action functions at transitions
			if (mobj.tics != -1) {
				mobj.tics--;

				// you can cycle through multiple states in a tic
				if (!eval(mobj.tics))
					if (!mobj.SetMobjState(mobj.state.nextstate))
						return; // freed itself
			} else {
				// check for nightmare respawn
				if (!eval(mobj.flags& MF_COUNTKILL))
					return;

				if (!DS.respawnmonsters)
					return;

				mobj.movecount++;

				if (mobj.movecount < 12 * 35)
					return;

				if (eval(DS.leveltime& 31))
					return;

				if (RND.P_Random() > 4)
					return;

				A.NightmareRespawn(mobj);
			}
		}
	}

	class T_FireFlicker implements ActionTypeSS<fireflicker_t>{

		@Override
		public void invoke(fireflicker_t a) {
			a.FireFlicker();
			
		}
		
	}
	
	class T_LightFlash implements ActionTypeSS<lightflash_t>{

		@Override
		public void invoke(lightflash_t a) {
			a.LightFlash();			
		}
		
	}
	
	class T_StrobeFlash implements ActionTypeSS<strobe_t>{

		@Override
		public void invoke(strobe_t a) {
			a.StrobeFlash();			
		}
		
	}
	
	class T_Glow implements ActionTypeSS<glow_t>{

		@Override
		public void invoke(glow_t a) {
			a.Glow();
			
		}
		
	}
	
	class	T_MoveCeiling implements ActionTypeSS<ceiling_t>{

		@Override
		public void invoke(ceiling_t a) {
			A.MoveCeiling(a);			
		}
	
	}

	class T_MoveFloor implements ActionTypeSS<floormove_t>{

		@Override
		public void invoke(floormove_t a) {
			A.MoveFloor(a);			
		}
	
	}
	
	class	T_VerticalDoor implements ActionTypeSS<vldoor_t>{

		@Override
		public void invoke(vldoor_t a) {
			A.VerticalDoor(a);	
		}
	
	}

	class T_SlidingDoor implements ActionTypeSS<slidedoor_t> {

		@Override
		public void invoke(slidedoor_t door) {

			switch (door.status) {
			case sd_opening:
				if (door.timer-- == 0) {
					if (++door.frame == SlideDoor.SNUMFRAMES) {
						// IF DOOR IS DONE OPENING...
						LL.sides[door.line.sidenum[0]].midtexture = 0;
						LL.sides[door.line.sidenum[1]].midtexture = 0;
						door.line.flags &= ML_BLOCKING ^ 0xff;

						if (door.type == sdt_e.sdt_openOnly) {
							door.frontsector.specialdata = null;
							A.RemoveThinker(door);
							break;
						}

						door.timer = SlideDoor.SDOORWAIT;
						door.status = sd_e.sd_waiting;
					} else {
						// IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
						door.timer = SlideDoor.SWAITTICS;

						LL.sides[door.line.sidenum[0]].midtexture = (short) SL.slideFrames[door.whichDoorIndex].frontFrames[door.frame];
						LL.sides[door.line.sidenum[1]].midtexture = (short) SL.slideFrames[door.whichDoorIndex].backFrames[door.frame];
					}
				}
				break;

			case sd_waiting:
				// IF DOOR IS DONE WAITING...
				if (door.timer-- == 0) {
					// CAN DOOR CLOSE?
					if (door.frontsector.thinglist != null
							|| door.backsector.thinglist != null) {
						door.timer = SlideDoor.SDOORWAIT;
						break;
					}

					// door.frame = SNUMFRAMES-1;
					door.status = sd_e.sd_closing;
					door.timer = SlideDoor.SWAITTICS;
				}
				break;

			case sd_closing:
				if (door.timer-- == 0) {
					if (--door.frame < 0) {
						// IF DOOR IS DONE CLOSING...
						door.line.flags |= ML_BLOCKING;
						door.frontsector.specialdata = null;
						A.RemoveThinker(door);
						break;
					} else {
						// IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
						door.timer = SlideDoor.SWAITTICS;

						LL.sides[door.line.sidenum[0]].midtexture = (short) SL.slideFrames[door.whichDoorIndex].frontFrames[door.frame];
						LL.sides[door.line.sidenum[1]].midtexture = (short) SL.slideFrames[door.whichDoorIndex].backFrames[door.frame];
					}
				}
				break;
			}
		}
	}
	
	
	class	T_PlatRaise implements ActionTypeSS<plat_t>{

		@Override
		public void invoke(plat_t a) {
			A.PlatRaise(a);
		}
	
	}

	
	//
    // A_FaceTarget
    //
	
	public class A_FaceTarget implements ActionType1{
    public void invoke(mobj_t  actor)
    {   
        if (actor.target==null)
        return;
        
        actor.flags &= ~MF_AMBUSH;
        
        actor.angle = R.PointToAngle2 (actor.x,
                        actor.y,
                        actor.target.x,
                        actor.target.y)&BITS32;
        
        if (eval(actor.target.flags & MF_SHADOW))
        actor.angle += (RND.P_Random()-RND.P_Random())<<21;
        actor.angle&=BITS32;
    	}
    }


    //
    // A_PosAttack
    //
	class A_PosAttack implements ActionType1{
	    public void invoke(mobj_t  actor)
	    {   
        int     angle;
        int     damage;
        int     slope;
        
        if (actor.target==null)
        return;
        FaceTarget.invoke(actor);
        angle = (int) actor.angle;
        slope = A.AimLineAttack (actor, angle, MISSILERANGE);

        S.StartSound(actor, sfxenum_t.sfx_pistol);
        angle += (RND.P_Random()-RND.P_Random())<<20;
        damage = ((RND.P_Random()%5)+1)*3;
        A.LineAttack (actor, angle, MISSILERANGE, slope, damage);
	    }
	}


	class A_SPosAttack implements ActionType1{
        public void invoke(mobj_t  actor)
        {   
        int     i;
        long     angle;
        long     bangle;
        int     damage;
        int     slope;
        
        if (actor.target==null)
        return;

        S.StartSound(actor, sfxenum_t.sfx_shotgn);
        A_FaceTarget (actor);
        bangle = actor.angle;
        slope = A.AimLineAttack (actor, bangle, MISSILERANGE);

        for (i=0 ; i<3 ; i++)
        {
        angle = bangle + ((RND.P_Random()-RND.P_Random())<<20);
        damage = ((RND.P_Random()%5)+1)*3;
        A.LineAttack (actor, angle, MISSILERANGE, slope, damage);
        }
        }
	}

	class A_CPosAttack implements ActionType1{
        public void invoke(mobj_t  actor)
        {   
        long     angle;
        long     bangle;
        int     damage;
        int     slope;
        
        if (actor.target==null)
        return;

        S.StartSound(actor, sfxenum_t.sfx_shotgn);
        A_FaceTarget (actor);
        bangle = actor.angle;
        slope = A.AimLineAttack (actor, bangle, MISSILERANGE);

        angle = bangle + ((RND.P_Random()-RND.P_Random())<<20);
        damage = ((RND.P_Random()%5)+1)*3;
        A.LineAttack (actor, angle, MISSILERANGE, slope, damage);
        }
	}

	class A_CPosRefire implements ActionType1{
        public void invoke(mobj_t  actor){
        // keep firing unless target got out of sight
        A_FaceTarget (actor);

        if (RND.P_Random () < 40)
        return;

        if (actor.target==null
        || actor.target.health <= 0
        || !EN.CheckSight (actor, actor.target) )
        {
        actor.SetMobjState ( actor.info.seestate);
        }
        }
	}


	class A_SpidRefire implements ActionType1{
        public void invoke(mobj_t  actor){
        // keep firing unless target got out of sight
        A_FaceTarget (actor);

        if (RND.P_Random () < 10)
        return;

        if (actor.target==null
        || actor.target.health <= 0
        || !EN.CheckSight (actor, actor.target) )
        {
        actor.SetMobjState ( actor.info.seestate);
        	}
        }
	}

	class A_BspiAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);

        // launch a missile
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_ARACHPLAZ);
        }
	}


    //
    // A_TroopAttack
    //
	class A_TroopAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        int     damage;
        
        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);
        if (A.EN.CheckMeleeRange (actor))
        {
        	S.StartSound(actor, sfxenum_t.sfx_claw);
        damage = (RND.P_Random()%8+1)*3;
        A.DamageMobj (actor.target, actor, actor, damage);
        return;
        }

        
        // launch a missile
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_TROOPSHOT);
        }
	}

    class A_SargAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        int     damage;

        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);
        if (EN.CheckMeleeRange (actor))
        {
        damage = ((RND.P_Random()%10)+1)*4;
        A.DamageMobj (actor.target, actor, actor, damage);
        }
        }
    }


    class A_HeadAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        int     damage;
        
        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);
        if (EN.CheckMeleeRange (actor))
        {
        damage = (RND.P_Random()%6+1)*10;
        A.DamageMobj (actor.target, actor, actor, damage);
        return;
        }
        
        // launch a missile
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_HEADSHOT);
        }
    }

    class A_CyberAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_ROCKET);
        }
    }

    class A_BruisAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        int     damage;
        
        if (actor.target==null)
        return;
            
        if (EN.CheckMeleeRange (actor))
        {
        	S.StartSound(actor, sfxenum_t.sfx_claw);
        damage = (RND.P_Random()%8+1)*10;
        A.DamageMobj (actor.target, actor, actor, damage);
        return;
        }
        
        // launch a missile
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_BRUISERSHOT);
        }
       }


    //
    // A_SkelMissile
    //
    class A_SkelMissile implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  mo;
        
        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);
        actor.z += 16*FRACUNIT;    // so missile spawns higher
        mo = A.SpawnMissile (actor, actor.target, mobjtype_t.MT_TRACER);
        actor.z -= 16*FRACUNIT;    // back to normal

        mo.x += mo.momx;
        mo.y += mo.momy;
        mo.tracer = actor.target;
        }
    }

    private static final int TRACEANGLE = 0xc000000;

    class A_Tracer implements ActionType1{
        public void invoke(mobj_t  actor){ 
        long exact; //angle_t
        int dist,slope; // fixed
        mobj_t  dest;
        mobj_t  th;
            
        if (eval(DS.gametic &3))
        return;
        
        // spawn a puff of smoke behind the rocket      
        A.SpawnPuff (actor.x, actor.y, actor.z);
        
        th = A.SpawnMobj (actor.x-actor.momx,
                  actor.y-actor.momy,
                  actor.z, mobjtype_t.MT_SMOKE);
        
        th.momz = MAPFRACUNIT;
        th.tics -= RND.P_Random()&3;
        if (th.tics < 1)
        th.tics = 1;
        
        // adjust direction
        dest = actor.tracer;
        
        if (dest==null || dest.health <= 0)
        return;
        
        // change angle 
        exact = R.PointToAngle2 (actor.x,
                     actor.y,
                     dest.x,
                     dest.y)&BITS32;
        
        // MAES: let's analyze the logic here...
        // So exact is the angle between the missile and its target. 

        if (exact != actor.angle) // missile is already headed there dead-on.
        {
        if (exact - actor.angle > ANG180)
        {
            actor.angle -= TRACEANGLE;
            actor.angle&=BITS32;
            if (((exact - actor.angle)&BITS32) < ANG180)
            actor.angle = exact;
        }
        else
        {
            actor.angle += TRACEANGLE;
            actor.angle&=BITS32;
            if (((exact - actor.angle)&BITS32) > ANG180)
            actor.angle = exact;
        }
        }
        
        // MAES: fixed and sped up.
        int exact2 = Tables.toBAMIndex(actor.angle);
        actor.momx = FixedMul (actor.info.speed, finecosine[exact2]);
        actor.momy = FixedMul (actor.info.speed, finesine[exact2]);
        
        // change slope
        dist = AproxDistance (dest.x - actor.x,
                    dest.y - actor.y);
        
        dist = dist / actor.info.speed;

        if (dist < 1)
        dist = 1;
        slope = (dest.z+40*FRACUNIT - actor.z) / dist;

        if (slope < actor.momz)
        actor.momz -= FRACUNIT/8;
        else
        actor.momz += FRACUNIT/8;
        }
    }

    class A_SkelWhoosh implements ActionType1{
        public void invoke(mobj_t  actor){ 
        if (actor.target==null)
        return;
        A_FaceTarget (actor);
        S.StartSound(actor,sfxenum_t.sfx_skeswg);
        }
    }
    
    class A_SkelFist implements ActionType1{
        public void invoke(mobj_t  actor){ 
        int     damage;

        if (actor.target==null)
        return;
            
        A_FaceTarget (actor);
        
        if (EN.CheckMeleeRange (actor))
        {
        damage = ((RND.P_Random()%10)+1)*6;
        S.StartSound(actor, sfxenum_t.sfx_skepch);
        A.DamageMobj (actor.target, actor, actor, damage);
        }
        }
    }

    //
    // A_VileChase
    // Check for ressurecting a body
    //
    class A_VileChase implements ActionType1{
        public void invoke(mobj_t  actor){ 
        int         xl;
        int         xh;
        int         yl;
        int         yh;
        
        int         bx;
        int         by;

        mobjinfo_t     info;
        mobj_t      temp;
        
        if (actor.movedir != DI_NODIR)
        {
        // check for corpses to raise
        A.VileCheck.viletryx =
            actor.x + actor.info.speed*xspeed[actor.movedir];
        A.VileCheck.viletryy =
            actor.y + actor.info.speed*yspeed[actor.movedir];

        xl = LL.getSafeBlockX(A.VileCheck.viletryx - LL.bmaporgx - MAXRADIUS*2);
        xh = LL.getSafeBlockX(A.VileCheck.viletryx - LL.bmaporgx + MAXRADIUS*2);
        yl = LL.getSafeBlockY(A.VileCheck.viletryy - LL.bmaporgy - MAXRADIUS*2);
        yh = LL.getSafeBlockY(A.VileCheck.viletryy - LL.bmaporgy + MAXRADIUS*2);
        
        A.VileCheck.vileobj = actor;
        for (bx=xl ; bx<=xh ; bx++)
        {
            for (by=yl ; by<=yh ; by++)
            {
            // Call PIT_VileCheck to check
            // whether object is a corpse
            // that can be raised.
            if (!A.BlockThingsIterator(bx,by,A.VileCheck))
            {
                // got one!
                temp = actor.target;
                actor.target = A.VileCheck.corpsehit;
                A_FaceTarget (actor);
                actor.target = temp;
                        
                actor.SetMobjState ( statenum_t.S_VILE_HEAL1);
                S.StartSound(A.VileCheck.corpsehit, sfxenum_t.sfx_slop);
                info = A.VileCheck.corpsehit.info;
                
                A.VileCheck.corpsehit.SetMobjState (info.raisestate);
                A.VileCheck.corpsehit.height <<= 2;
                A.VileCheck.corpsehit.flags = info.flags;
                A.VileCheck.corpsehit.health = info.spawnhealth;
                A.VileCheck.corpsehit.target = null;

                return;
            }
            }
        }
        }

        // Return to normal attack.
        Chase.invoke (actor);
        }
    }


    //
    // A_VileStart
    //
    class A_VileStart implements ActionType1{
        public void invoke(mobj_t  actor){ 
    	S.StartSound(actor, sfxenum_t.sfx_vilatk);
        }
    }


    //
    // A_Fire
    // Keep fire in front of player unless out of sight
    //
    
    class A_StartFire implements ActionType1{
        public void invoke(mobj_t  actor){ 
    	S.StartSound(actor,sfxenum_t.sfx_flamst);
        Fire.invoke(actor);
        }
    }

    class A_FireCrackle implements ActionType1{
        public void invoke(mobj_t  actor){ 
    	S.StartSound(actor,sfxenum_t.sfx_flame);
        Fire.invoke(actor);
        }
     }
    
    //
    // A_FirePistol
    //
    class A_FirePistol implements ActionType2{
    public void invoke( player_t player, pspdef_t psp ) 
    {
  	  S.StartSound(player.mo, sfxenum_t.sfx_pistol);

        player.mo.SetMobjState ( statenum_t.S_PLAY_ATK2);
        player.ammo[weaponinfo[player.readyweapon.ordinal()].ammo.ordinal()]--;

        player.SetPsprite (
              ps_flash,
              weaponinfo[player.readyweapon.ordinal()].flashstate);

        A.P_BulletSlope (player.mo);
        A.P_GunShot (player.mo, !eval(player.refire));
    	}
    }

    //
    // A_FireShotgun
    //
    class A_FireShotgun implements ActionType2{
        public void invoke( player_t player, pspdef_t psp ) 
        {
        int     i;
        
        S.StartSound(player.mo, sfxenum_t.sfx_shotgn);
        player.mo.SetMobjState ( statenum_t.S_PLAY_ATK2);

        player.ammo[weaponinfo[player.readyweapon.ordinal()].ammo.ordinal()]--;

        player.SetPsprite (
              ps_flash,
              weaponinfo[player.readyweapon.ordinal()].flashstate);

        A.P_BulletSlope (player.mo);
        
        for (i=0 ; i<7 ; i++)
        A.P_GunShot (player.mo, false);
        }
    }


    /**
     * A_FireShotgun2
     */
    
    class A_FireShotgun2 implements ActionType2{
        public void invoke( player_t player, pspdef_t psp ) 
        {
        int     i;
        long angle;
        int     damage;
            
        
        S.StartSound (player.mo, sfxenum_t.sfx_dshtgn);
        player.mo.SetMobjState (statenum_t.S_PLAY_ATK2);

        player.ammo[weaponinfo[player.readyweapon.ordinal()].ammo.ordinal()]-=2;

        player.SetPsprite (
              ps_flash,
              weaponinfo[player.readyweapon.ordinal()].flashstate);

        A.P_BulletSlope (player.mo);
        
        for (i=0 ; i<20 ; i++)
        {
        damage = 5*(RND.P_Random ()%3+1);
        angle = player.mo.angle;
        angle += (RND.P_Random()-RND.P_Random())<<19;
        A.LineAttack (player.mo,
                  angle,
                  MISSILERANGE,
                  A.bulletslope + ((RND.P_Random()-RND.P_Random())<<5), damage);
        }
    }
    }
    
    
    class A_Fire implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  dest;
        //long    an;
            
        dest = actor.tracer;
        if (dest==null)
        return;
            
        // don't move it if the vile lost sight
        if (!EN.CheckSight (actor.target, dest) )
        return;

        // an = dest.angle >>> ANGLETOFINESHIFT;

        A.UnsetThingPosition (actor);
        actor.x = dest.x + FixedMul (24*FRACUNIT, finecosine(dest.angle));
        actor.y = dest.y + FixedMul (24*FRACUNIT, finesine(dest.angle));
        actor.z = dest.z;
        LL.SetThingPosition (actor);
        }
    }



    //
    // A_VileTarget
    // Spawn the hellfire
    //
    class A_VileTarget implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  fog;
        
        if (actor.target==null)
        return;

        A_FaceTarget (actor);

        fog = A.SpawnMobj (actor.target.x,
                   actor.target.y,
                   actor.target.z, mobjtype_t.MT_FIRE);
        
        actor.tracer = fog;
        fog.target = actor;
        fog.tracer = actor.target;
        Fire.invoke(fog);
        }
    }




    //
    // A_VileAttack
    //
    class A_VileAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  fire;
        //int     an;
        
        if (actor.target==null)
        return;
        
        A_FaceTarget (actor);

        if (!EN.CheckSight (actor, actor.target) )
        return;

        S.StartSound(actor, sfxenum_t.sfx_barexp);
        A.DamageMobj (actor.target, actor, actor, 20);
        actor.target.momz = 1000*MAPFRACUNIT/actor.target.info.mass;
        
       // an = actor.angle >> ANGLETOFINESHIFT;

        fire = actor.tracer;

        if (fire==null)
        return;
            
        // move the fire between the vile and the player
        fire.x = actor.target.x - FixedMul (24*FRACUNIT, finecosine(actor.angle));
        fire.y = actor.target.y - FixedMul (24*FRACUNIT, finesine(actor.angle));  
        A.RadiusAttack (fire, actor, 70 );
        }
    }



    //
    // Mancubus attack,
    // firing three missiles (bruisers)
    // in three different directions?
    // Doesn't look like it. 
    //
    private static final long FATSPREAD =  (ANG90/8);

    class A_FatRaise implements ActionType1{
        public void invoke(mobj_t  actor){ 
        A_FaceTarget (actor);
        S.StartSound(actor, sfxenum_t.sfx_manatk);
        }
    }


    class A_FatAttack1 implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  mo;
        int     an;
        
        A_FaceTarget (actor);
        // Change direction  to ...
        actor.angle += FATSPREAD;
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_FATSHOT);

        mo = A.SpawnMissile (actor, actor.target, mobjtype_t.MT_FATSHOT);
        mo.angle += FATSPREAD;
        an = Tables.toBAMIndex(mo.angle);
        mo.momx = FixedMul (mo.info.speed, finecosine[an]);
        mo.momy = FixedMul (mo.info.speed, finesine[an]);
        }
    }

    class A_FatAttack2 implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  mo;
        int     an;

        A_FaceTarget (actor);
        // Now here choose opposite deviation.
        actor.angle -= FATSPREAD;
        A.SpawnMissile (actor, actor.target, mobjtype_t.MT_FATSHOT);

        mo = A.SpawnMissile (actor, actor.target, mobjtype_t.MT_FATSHOT);
        mo.angle -= FATSPREAD*2;
        an = Tables.toBAMIndex(mo.angle);
        mo.momx = FixedMul (mo.info.speed, finecosine[an]);
        mo.momy = FixedMul (mo.info.speed, finesine[an]);
        }
    }

    class A_FatAttack3 implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t  mo;
        int     an;

        A_FaceTarget (actor);
        
        mo = A.SpawnMissile (actor, actor.target, mobjtype_t.MT_FATSHOT);
        mo.angle -= FATSPREAD/2;
        an = Tables.toBAMIndex(mo.angle);
        mo.momx = FixedMul (mo.info.speed, finecosine[an]);
        mo.momy = FixedMul (mo.info.speed, finesine[an]);

        mo = A.SpawnMissile (actor, actor.target, mobjtype_t.MT_FATSHOT);
        mo.angle += FATSPREAD/2;
        an = Tables.toBAMIndex(mo.angle);
        mo.momx = FixedMul (mo.info.speed, finecosine[an]);
        mo.momy = FixedMul (mo.info.speed, finesine[an]);
        }
    }



    private static final int SKULLSPEED  =    (20*MAPFRACUNIT);
    /**      
     * SkullAttack
     * Fly at the player like a missile.
     */
    class A_SkullAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        mobj_t      dest;
        int     an;
        int         dist;

        if (actor.target==null)
        return;
            
        dest = actor.target;   
        actor.flags |= MF_SKULLFLY;

        S.StartSound(actor, actor.info.attacksound);
        FaceTarget.invoke(actor);
        an = Tables.toBAMIndex(actor.angle);
        actor.momx = FixedMul (SKULLSPEED, finecosine[an]);
        actor.momy = FixedMul (SKULLSPEED, finesine[an]);
        dist = AproxDistance (dest.x - actor.x, dest.y - actor.y);
        dist = dist / SKULLSPEED;
        
        if (dist < 1)
        dist = 1;
        actor.momz = (dest.z+(dest.height>>1) - actor.z) / dist;
        }
    }


    /**
     * A_PainShootSkull
     * Spawn a lost soul and launch it at the target
     * It's not a valid callback like the others, actually.
     * No idea if some DEH patch does use it to cause
     * mayhem though.
     * 
     */
    
    private void A_PainShootSkull
    ( mobj_t    actor,
      long   angle )
    {
        int x,y, z; // fixed
        
        mobj_t  newmobj;
        int an; // angle
        int     prestep;
        int     count;
        thinker_t  currentthinker;

        // count total number of skull currently on the level
        count = 0;

        currentthinker = A.thinkercap.next;
        while (currentthinker != A.thinkercap)
        {
        if (   (currentthinker.function == think_t.P_MobjThinker)
            && ((mobj_t)currentthinker).type == mobjtype_t.MT_SKULL)
            count++;
        currentthinker = currentthinker.next;
        }

        // if there are allready 20 skulls on the level,
        // don't spit another one
        if (count > MAXSKULLS)
        return;


        // okay, there's playe for another one
        an = Tables.toBAMIndex(angle);
        
        prestep =
        4*FRACUNIT
        + 3*(actor.info.radius + mobjinfo[mobjtype_t.MT_SKULL.ordinal()].radius)/2;
        
        x = actor.x + FixedMul (prestep, finecosine[an]);
        y = actor.y + FixedMul (prestep, finesine[an]);
        z = actor.z + 8*FRACUNIT;
            
        newmobj = A.SpawnMobj (x , y, z, mobjtype_t.MT_SKULL);

        // Check for movements.
        if (!A.TryMove (newmobj, newmobj.x, newmobj.y))
        {
        // kill it immediately
        A.DamageMobj (newmobj,actor,actor,10000);   
        return;
        }
            
        newmobj.target = actor.target;
        SkullAttack.invoke (newmobj);
    }


    //
    // A_PainAttack
    // Spawn a lost soul and launch it at the target
    // 
    class A_PainAttack implements ActionType1{
        public void invoke(mobj_t  actor){ 
        if (actor.target==null)
        return;

        A_FaceTarget (actor);
        A_PainShootSkull (actor, actor.angle);
        }
    }


    class A_PainDie implements ActionType1{
        public void invoke(mobj_t  actor){ 
        Fall.invoke (actor);
        A_PainShootSkull (actor, actor.angle+ANG90);
        A_PainShootSkull (actor, actor.angle+ANG180);
        A_PainShootSkull (actor, actor.angle+ANG270);
        }
    }






    class A_Scream implements ActionType1 {
        public void invoke(mobj_t  actor){ 
        int     sound;
        
        switch (actor.info.deathsound)
        {
          case sfx_None:
        return;
            
          case sfx_podth1:
          case sfx_podth2:
          case sfx_podth3:
        sound = sfxenum_t.sfx_podth1.ordinal() + RND.P_Random ()%3;
        break;
            
          case sfx_bgdth1:
          case sfx_bgdth2:
        sound = sfxenum_t.sfx_bgdth1.ordinal() + RND.P_Random ()%2;
        break;
        
          default:
        sound = actor.info.deathsound.ordinal();
        break;
        }

        // Check for bosses.
        if (actor.type==mobjtype_t.MT_SPIDER
        || actor.type == mobjtype_t.MT_CYBORG)
        {
        // full volume
        S.StartSound (null, sound);
        }
        else
        S.StartSound (actor, sound);
        }
    }


    /**
     * A_WeaponReady
     * The player can fire the weapon
     * or change to another weapon at this time.
     * Follows after getting weapon up,
     * or after previous attack/fire sequence.
     */

    class A_WeaponReady implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
    {   
        statenum_t  newstate;
        int     angle;
        
        // get out of attack state
        if (player.mo.state == states[statenum_t.S_PLAY_ATK1.ordinal()]
        || player.mo.state == states[statenum_t.S_PLAY_ATK2.ordinal()] )
        {
        player.mo.SetMobjState (statenum_t.S_PLAY);
        }
        
        if (player.readyweapon == weapontype_t.wp_chainsaw
        && psp.state == states[statenum_t.S_SAW.ordinal()])
        {
      	  S.StartSound(player.mo, sfxenum_t.sfx_sawidl);
        }
        
        // check for change
        //  if player is dead, put the weapon away
        if (player.pendingweapon != weapontype_t.wp_nochange || !eval(player.health[0]))
        {
        // change weapon
        //  (pending weapon should allready be validated)
        newstate = weaponinfo[player.readyweapon.ordinal()].downstate;
        player.SetPsprite ( player_t.ps_weapon, newstate);
        return; 
        }
        
        // check for fire
        //  the missile launcher and bfg do not auto fire
        if (eval(player.cmd.buttons & BT_ATTACK))
        {
        if ( !player.attackdown
             || (player.readyweapon != weapontype_t.wp_missile
             && player.readyweapon != weapontype_t.wp_bfg) )
        {
            player.attackdown = true;
            EN.FireWeapon (player);      
            return;
        }
        }
        else
        player.attackdown = false;
        
        // bob the weapon based on movement speed
        angle = (128*DS.leveltime)&FINEMASK;
        psp.sx = FRACUNIT + FixedMul (player.bob, finecosine[angle]);
        angle &= FINEANGLES/2-1;
        psp.sy = player_t.WEAPONTOP + FixedMul (player.bob, finesine[angle]);
    	}
    }
    
    //
    // A_Raise
    //
    class A_Raise implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        statenum_t  newstate;
        
        //System.out.println("Trying to raise weapon");      
        //System.out.println(player.readyweapon + " height: "+psp.sy);
        psp.sy -= RAISESPEED;

        if (psp.sy > WEAPONTOP ) {
        //System.out.println("Not on top yet, exit and repeat.");
        return;
        }
        
        psp.sy = WEAPONTOP;
        
        // The weapon has been raised all the way,
        //  so change to the ready state.
        newstate = weaponinfo[player.readyweapon.ordinal()].readystate;
        //System.out.println("Weapon raised, setting new state.");
        
        player.SetPsprite (ps_weapon, newstate);
        }
    }


    //
    // A_ReFire
    // The player can re-fire the weapon
    // without lowering it entirely.
    //
    class A_ReFire implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        
        // check for fire
        //  (if a weaponchange is pending, let it go through instead)
        if ( eval(player.cmd.buttons & BT_ATTACK) 
         && player.pendingweapon == weapontype_t.wp_nochange
         && eval(player.health[0]))
        {
        player.refire++;
        EN.FireWeapon (player);
        }
        else
        {
        player.refire = 0;
        player.CheckAmmo ();
        }
        }
    }
    
    
    //
    // A_GunFlash
    //
    class A_GunFlash implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {    
        player.mo.SetMobjState (statenum_t.S_PLAY_ATK2);
        player.SetPsprite (ps_flash,weaponinfo[player.readyweapon.ordinal()].flashstate);
        }
    }

    //
    // A_Punch
    //
    class A_Punch implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        long angle; //angle_t
        int     damage;
        int     slope;
        
        damage = (RND.P_Random ()%10+1)<<1;

        if (eval(player.powers[pw_strength]))    
        damage *= 10;

        angle = player.mo.angle;
        //angle = (angle+(RND.P_Random()-RND.P_Random())<<18)/*&BITS32*/;
        // _D_: for some reason, punch didnt work until I change this
        // I think it's because of "+" VS "<<" prioritys...
        angle += (RND.P_Random()-RND.P_Random())<<18;
        slope = A.AimLineAttack (player.mo, angle, MELEERANGE);
        A.LineAttack (player.mo, angle, MELEERANGE, slope, damage);

        // turn to face target
        if (eval(A.linetarget))
        {
      	  S.StartSound(player.mo, sfxenum_t.sfx_punch);
        player.mo.angle = R.PointToAngle2 (player.mo.x,
                             player.mo.y,
                             A.linetarget.x,
                             A.linetarget.y)&BITS32;
        }
    }	
    }


    //
    // A_Saw
    //
    class A_Saw implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        long angle; // angle_t
        int     damage;
        int     slope;

        damage = 2*(RND.P_Random ()%10+1);
        angle = player.mo.angle;
        angle += (RND.P_Random()-RND.P_Random())<<18;
        angle&=BITS32;
        
        // use meleerange + 1 se the puff doesn't skip the flash
        slope = A.AimLineAttack (player.mo, angle, MELEERANGE+1);
        A.LineAttack (player.mo, angle, MELEERANGE+1, slope, damage);

        if (!eval(A.linetarget))
        {
      	  S.StartSound(player.mo, sfxenum_t.sfx_sawful);
        return;
        }
        S.StartSound(player.mo, sfxenum_t.sfx_sawhit);
        
        // turn to face target
        angle = R.PointToAngle2 (player.mo.x, player.mo.y,
                     A.linetarget.x, A.linetarget.y)&BITS32;
        /* FIXME: this comparison is going to fail.... or not?
         If e.g. angle = 359 degrees (which will be mapped to a small negative number),       
         and player.mo.angle = 160 degrees (a large, positive value), the result will be a 
         large negative value, which will still be "greater" than ANG180.
         
         It seems that *differences* between angles will always compare correctly, but
         not direct inequalities.
         
        */
        
        // Yet another screwy place where unsigned BAM angles are used as SIGNED comparisons.
        long dangle= (angle - player.mo.angle);
        dangle&=BITS32;
        if (dangle > ANG180)
        {
        if ((int)dangle < -ANG90/20)
            player.mo.angle = angle + ANG90/21;
        else
            player.mo.angle -= ANG90/20;
        }
        else
        {
        if (dangle > ANG90/20)
            player.mo.angle = angle - ANG90/21;
        else
            player.mo.angle += ANG90/20;
        }
        player.mo.angle&=BITS32;
        player.mo.flags |= MF_JUSTATTACKED;
        }
    }


    //
    // A_FireMissile
    //
    class A_FireMissile implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        player.ammo[weaponinfo[player.readyweapon.ordinal()].ammo.ordinal()]--;
        A.SpawnPlayerMissile (player.mo, mobjtype_t.MT_ROCKET);
        }
    }


    //
    // A_FireBFG
    //
    class A_FireBFG implements ActionType2 {
    	 
    	
    	 // plasma cells for a bfg attack
    	 // IDEA: make action functions partially parametrizable?
    	private static final int BFGCELLS      =  40;     
    	
    	public void invoke( player_t player, pspdef_t psp )
        {   
        player.ammo[weaponinfo[player.readyweapon.ordinal()].ammo.ordinal()] -= BFGCELLS;
        A.SpawnPlayerMissile (player.mo, mobjtype_t.MT_BFG);
        }
    }


    //
    // A_FireCGun
    //
    class A_FireCGun implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        // For convenience.
        int readyweap=player.readyweapon.ordinal();
        int flashstate=weaponinfo[readyweap].flashstate.ordinal();
        int current_state=psp.state.id;
        
        S.StartSound (player.mo, sfxenum_t.sfx_pistol);      
        if (!eval(player.ammo[weaponinfo[readyweap].ammo.ordinal()]))
        return;
            
        player.mo.SetMobjState (statenum_t.S_PLAY_ATK2);
        player.ammo[weaponinfo[readyweap].ammo.ordinal()]--;
        
        // MAES: Code to alternate between two different gun flashes
        // needed a clear rewrite, as it was way too messy.
        // We know that the flash states are a certain amount away from 
        // the firing states. This amount is two frames.
        player.SetPsprite (ps_flash,statenum_t.values()[flashstate+current_state-statenum_t.S_CHAIN1.ordinal()]
              );

        A.P_BulletSlope (player.mo);
        
        A.P_GunShot (player.mo, !eval(player.refire));
        }
    }
    
    //
    // A_FirePlasma
    //
    class A_FirePlasma implements ActionType2 {
    	public void invoke( player_t player, pspdef_t psp )
        {   
        player.ammo[weaponinfo[player.readyweapon.ordinal()].ammo.ordinal()]--;

        player.SetPsprite (
              ps_flash,
              weaponinfo[player.readyweapon.ordinal()].flashstate );

        A.SpawnPlayerMissile (player.mo, mobjtype_t.MT_PLASMA);
        }
    }
    
    class A_XScream implements ActionType1 {
        public void invoke(mobj_t  actor){ 
        S.StartSound (actor, sfxenum_t.sfx_slop); 
        }
    }

    class A_Pain implements ActionType1 {
        public void invoke(mobj_t  actor){ 
        if (actor.info.painsound!=null)
        	S.StartSound(actor, actor.info.painsound);   
        }
    }



    class A_Fall implements ActionType1 {
        public void invoke(mobj_t  actor){ 
        // actor is on ground, it can be walked over
        actor.flags &= ~MF_SOLID;

        // So change this if corpse objects
        // are meant to be obstacles.
        }
    }


    //
    // A_Explode
    //
    class A_Explode implements ActionType1 {
        public void invoke(mobj_t  thingy){ 
        A.RadiusAttack ( thingy, thingy.target, 128 );
        }
    }


    /**
     * A_BossDeath
     * Possibly trigger special effects
     * if on first boss level
     *
     * TODO: find out how Plutonia/TNT does cope with this.
     * Special clauses?
     *
     */
    class A_BossDeath implements ActionType1 {
        public void invoke(mobj_t  mo){ 
        thinker_t  th;
        mobj_t  mo2;
        line_t  junk = new line_t();
        int     i;
            
        if ( DS.isCommercial())
        {
        if (DS.gamemap != 7)
            return;
            
        if ((mo.type != mobjtype_t.MT_FATSO)
            && (mo.type != mobjtype_t.MT_BABY))
            return;
        }
        else
        {
        switch(DS.gameepisode)
        {
          case 1:
            if (DS.gamemap != 8)
            return;

            if (mo.type != mobjtype_t.MT_BRUISER)
            return;
            break;
            
          case 2:
            if (DS.gamemap != 8)
            return;

            if (mo.type != mobjtype_t.MT_CYBORG)
            return;
            break;
            
          case 3:
            if (DS.gamemap != 8)
            return;
            
            if (mo.type != mobjtype_t.MT_SPIDER)
            return;
            
            break;
            
          case 4:
            switch(DS.gamemap)
            {
              case 6:
            if (mo.type != mobjtype_t.MT_CYBORG)
                return;
            break;
            
              case 8: 
            if (mo.type != mobjtype_t.MT_SPIDER)
                return;
            break;
            
              default:
            return;
            }
            break;
            
          default:
            if (DS.gamemap != 8)
            return;
            break;
        }
            
        }

        
        // make sure there is a player alive for victory
        for (i=0 ; i<MAXPLAYERS ; i++)
        if (DS.playeringame[i] && DS.players[i].health[0] > 0)
            break;
        
        if (i==MAXPLAYERS)
        return; // no one left alive, so do not end game
        
        // scan the remaining thinkers to see
        // if all bosses are dead
        for (th = A.thinkercap.next ; th != A.thinkercap ; th=th.next)
        {
        if (th.function != think_t.P_MobjThinker)
            continue;
        
        mo2 = (mobj_t)th;
        if (mo2 != mo
            && mo2.type == mo.type
            && mo2.health > 0)
        {
            // other boss not dead
            return;
        }
        }
        
        // victory!
        if ( DS.isCommercial())
        {
        if (DS.gamemap == 7)
        {
            if (mo.type == mobjtype_t.MT_FATSO)
            {
            junk.tag = 666;
            A.DoFloor(junk,floor_e.lowerFloorToLowest);
            return;
            }
            
            if (mo.type == mobjtype_t.MT_BABY)
            {
            junk.tag = 667;
            A.DoFloor(junk,floor_e.raiseToTexture);
            return;
            }
        }
        }
        else
        {
        switch(DS.gameepisode)
        {
          case 1:
            junk.tag = 666;
            A.DoFloor (junk, floor_e.lowerFloorToLowest);
            return;
            
          case 4:
            switch(DS.gamemap)
            {
              case 6:
            junk.tag = 666;
            A.DoDoor (junk, vldoor_e.blazeOpen);
            return;
            
              case 8:
            junk.tag = 666;
            A.DoFloor (junk, floor_e.lowerFloorToLowest);
            return;
            }
        }
        }
        
        A.DM.ExitLevel ();
        }
    }

    class A_Hoof implements ActionType1 {
        public void invoke(mobj_t  mo){ 
    	S.StartSound(mo, sfxenum_t.sfx_hoof);
    	 Chase.invoke(mo);
        }
    }
    
    class A_KeenDie implements ActionType1 {
        public void invoke(mobj_t  mo){ 
        thinker_t  th;
        mobj_t mo2;
        line_t  junk = new line_t(); // MAES: fixed null 21/5/2011

        Fall.invoke(mo);
        
        // scan the remaining thinkers
        // to see if all Keens are dead
        for (th = A.thinkercap.next ; th != A.thinkercap ; th=th.next)
        {
        if (th.function != think_t.P_MobjThinker)
            continue;

        mo2 = (mobj_t)th;
        if (mo2 != mo
            && mo2.type == mo.type
            && mo2.health > 0)
        {
            // other Keen not dead
            return;     
        }
        }

        junk.tag = 666;
        A.DoDoor(junk,vldoor_e.open);
        }
    }

    class A_Metal implements ActionType1 {
        public void invoke(mobj_t  mo){ 
    	S.StartSound(mo, sfxenum_t.sfx_metal);
        Chase.invoke(mo);
        }
    }

    class A_BabyMetal implements ActionType1 {
        public void invoke(mobj_t  mo){ 
    	S.StartSound(mo, sfxenum_t.sfx_bspwlk);
        Chase.invoke (mo);
        }
    }
    
    //
    // A_BFGsound
    //
    class A_BFGsound implements ActionType2{
    	public void invoke( player_t player, pspdef_t psp )	{
    		S.StartSound(player.mo, sfxenum_t.sfx_bfg);
    	}	
    }
    
    //
    // A_BFGSpray
    // Spawn a BFG explosion on every monster in view
    //
    class A_BFGSpray implements ActionType1 {
        public void invoke(mobj_t  mo){ 
        int         i;
        int         j;
        int         damage;
        long     an; // angle_t
        
        // offset angles from its attack angle
        for (i=0 ; i<40 ; i++)
        {
        an = (mo.angle - ANG90/2 + ANG90/40*i)&BITS32;

        // mo.target is the originator (player)
        //  of the missile
        A.AimLineAttack (mo.target, an, 16*64*FRACUNIT);

        if (!eval(A.linetarget))
            continue;

        A.SpawnMobj (A.linetarget.x,
            A.linetarget.y,
            A.linetarget.z + (A.linetarget.height>>2),
                 mobjtype_t.MT_EXTRABFG);
        
        damage = 0;
        for (j=0;j<15;j++)
            damage += (RND.P_Random()&7) + 1;

        A.DamageMobj (A.linetarget, mo.target,mo.target, damage);
        }
        }
    }


    class A_OpenShotgun2 implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
    	S.StartSound(player.mo, sfxenum_t.sfx_dbopn);
		}
    }
    
    class A_LoadShotgun2 implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
    	S.StartSound(player.mo, sfxenum_t.sfx_dbload);
		}
    }

    //
    // A_Look
    // Stay in state until a player is sighted.
    //
    class A_Look implements ActionType1 {
        public void invoke(mobj_t  actor){ 
        mobj_t targ;
        boolean seeyou=false; // to avoid the fugly goto
        
        actor.threshold = 0;   // any shot will wake up
        targ = actor.subsector.sector.soundtarget;

        if (targ!=null
        && eval(targ.flags& MF_SHOOTABLE) )
        {
        actor.target = targ;

        if ( eval(actor.flags&MF_AMBUSH ))
        {
            seeyou= (EN.CheckSight (actor, actor.target));              
        } else
            seeyou=true;
        }
        if (!seeyou){
        if (!EN.LookForPlayers (actor, false) )
        return;
        }
        
        // go into chase state
      seeyou:
        if (actor.info.seesound!=null && actor.info.seesound!=sfxenum_t.sfx_None)
        {
        int     sound;
            
        switch (actor.info.seesound)
        {
          case sfx_posit1:
          case sfx_posit2:
          case sfx_posit3:
            sound = sfxenum_t.sfx_posit1.ordinal()+RND.P_Random()%3;
            break;

          case sfx_bgsit1:
          case sfx_bgsit2:
            sound = sfxenum_t.sfx_bgsit1.ordinal()+RND.P_Random()%2;
            break;

          default:
            sound = actor.info.seesound.ordinal();
            break;
        }

        if (actor.type==mobjtype_t.MT_SPIDER
            || actor.type == mobjtype_t.MT_CYBORG)
        {
            // full volume
        	S.StartSound(null, sound);
        }
        else
        	S.StartSound(actor, sound);
        }

        actor.SetMobjState(actor.info.seestate);
        }
    }
    
    class A_CloseShotgun2 implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
    	S.StartSound(player.mo, sfxenum_t.sfx_dbcls);
        ReFire.invoke(player,psp);
		}
    }

    //
    // ?
    //
    class A_Light0 implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
        player.extralight = 0;
		}
    }

    class A_Light1 implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
        player.extralight = 1;
		}
    }
    
    class A_Light2 implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
        player.extralight = 2;
		}
    }

    
    //
    // A_Lower
    // Lowers current weapon,
    //  and changes weapon at bottom.
    //
    class A_Lower implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
        psp.sy += LOWERSPEED;

        // Is already down.
        if (psp.sy < WEAPONBOTTOM )
        return;

        // Player is dead.
        if (player.playerstate == PST_DEAD)
        {
        psp.sy = WEAPONBOTTOM;

        // don't bring weapon back up
        return;     
        }
        
        // The old weapon has been lowered off the screen,
        // so change the weapon and start raising it
        if (!eval(player.health[0]))
        {
        // Player is dead, so keep the weapon off screen.
        player.SetPsprite (ps_weapon, statenum_t.S_NULL);
        return; 
        }
        
        player.readyweapon = player.pendingweapon; 

        player.BringUpWeapon ();
		}
    }
    
    class A_CheckReload implements ActionType2{
		public void invoke (player_t player,pspdef_t psp){
        player.CheckAmmo ();
    /*
        if (player.ammo[am_shell]<2)
        P_SetPsprite (player, ps_weapon, S_DSNR1);
    */}
    }
    

    // Brain status
    mobj_t[]      braintargets=new mobj_t[NUMBRAINTARGETS];
    int     numbraintargets;
    int     braintargeton;
    
    class A_BrainAwake implements ActionType1{
    	
        public void invoke(mobj_t  mo){ 
        thinker_t  thinker;
        mobj_t  m;
        
        // find all the target spots
        numbraintargets = 0;
        braintargeton = 0;
        
        thinker = A.thinkercap.next;
        for (thinker = A.thinkercap.next ;
         thinker != A.thinkercap ;
         thinker = thinker.next)
        {
        if (thinker.function != think_t.P_MobjThinker)
            continue;   // not a mobj

        m = (mobj_t)thinker;

        if (m.type == mobjtype_t.MT_BOSSTARGET )
        {
            braintargets[numbraintargets] = m;
            numbraintargets++;
        }
        }
        
        S.StartSound(null,sfxenum_t.sfx_bossit);
        }
    }


    class A_BrainPain implements ActionType1 {
        public void invoke(mobj_t  mo){ 
    	S.StartSound(null,sfxenum_t.sfx_bospn);
        }
    }


    class A_BrainScream implements ActionType1{
        public void invoke(mobj_t  mo){ 
        int     x;
        int     y;
        int     z;
        mobj_t  th;
        
        for (x=mo.x - 196*FRACUNIT ; x< mo.x + 320*FRACUNIT ; x+= FRACUNIT*8)
        {
        y = mo.y - 320*FRACUNIT;
        z = 128 + RND.P_Random()*2*FRACUNIT;
        th = A.SpawnMobj (x,y,z, mobjtype_t.MT_ROCKET);
        th.momz = RND.P_Random()*512;

        th.SetMobjState (statenum_t.S_BRAINEXPLODE1);

        th.tics -= RND.P_Random()&7;
        if (th.tics < 1)
            th.tics = 1;
        }
        
        S.StartSound(null,sfxenum_t.sfx_bosdth);
        }
    }



    class A_BrainExplode implements ActionType1{
        public void invoke(mobj_t  mo){ 
        int     x;
        int     y;
        int     z;
        mobj_t  th;
        
        x = mo.x + (RND.P_Random () - RND.P_Random ())*2048;
        y = mo.y;
        z = 128 + RND.P_Random()*2*FRACUNIT;
        th = A.SpawnMobj (x,y,z, mobjtype_t.MT_ROCKET);
        th.momz = RND.P_Random()*512;

        th.SetMobjState (statenum_t.S_BRAINEXPLODE1);

        th.tics -= RND.P_Random()&7;
        if (th.tics < 1)
        th.tics = 1;
        }
    }


    class A_BrainDie implements ActionType1{
        public void invoke(mobj_t  mo){ 
        DG.ExitLevel ();
        }
    }

    private int  easy = 0;
    
    class A_BrainSpit implements ActionType1{
        public void invoke(mobj_t  mo){ 
        mobj_t  targ;
        mobj_t  newmobj;
        
        easy ^= 1;
        if (DS.gameskill.ordinal() <= skill_t.sk_easy.ordinal() && (easy==0))
        return;
            
        // shoot a cube at current target
        targ = braintargets[braintargeton];
        
        // Load-time fix: awake on zero numbrain targets, if A_BrainSpit is called.
        if (numbraintargets==0) {BrainAwake.invoke(mo);
        						 return;
        						}
        braintargeton = (braintargeton+1)%numbraintargets;

        // spawn brain missile
        newmobj = A.SpawnMissile (mo, targ, mobjtype_t.MT_SPAWNSHOT);
        newmobj.target = targ;
        newmobj.reactiontime =
        (int) (((targ.y - mo.y)/newmobj.momy) / newmobj.state.tics);

         S.StartSound(null, sfxenum_t.sfx_bospit);
        }
    }


    // travelling cube sound
    class A_SpawnSound implements ActionType1{
        public void invoke(mobj_t  mo){ 
        S.StartSound (mo,sfxenum_t.sfx_boscub);
        SpawnFly.invoke(mo);
        }
    }

     
    class A_SpawnFly implements ActionType1{
        public void invoke(mobj_t  mo){ 
        mobj_t  newmobj;
        mobj_t  fog;
        mobj_t  targ;
        int     r;
        mobjtype_t  type;
        
        if (--mo.reactiontime!=0)
        return; // still flying
        
        targ = mo.target;

        // First spawn teleport fog.
        fog = A.SpawnMobj (targ.x, targ.y, targ.z, mobjtype_t.MT_SPAWNFIRE);
        S.StartSound (fog, sfxenum_t.sfx_telept);

        // Randomly select monster to spawn.
        r = RND.P_Random ();

        // Probability distribution (kind of :),
        // decreasing likelihood.
        if ( r<50 )
        type = mobjtype_t.MT_TROOP;
        else if (r<90)
        type = mobjtype_t.MT_SERGEANT;
        else if (r<120)
        type = mobjtype_t.MT_SHADOWS;
        else if (r<130)
        type = mobjtype_t.MT_PAIN;
        else if (r<160)
        type = mobjtype_t.MT_HEAD;
        else if (r<162)
        type = mobjtype_t.MT_VILE;
        else if (r<172)
        type = mobjtype_t.MT_UNDEAD;
        else if (r<192)
        type = mobjtype_t.MT_BABY;
        else if (r<222)
        type = mobjtype_t.MT_FATSO;
        else if (r<246)
        type = mobjtype_t.MT_KNIGHT;
        else
        type = mobjtype_t.MT_BRUISER;      

        newmobj = A.SpawnMobj (targ.x, targ.y, targ.z, type);
        if (EN.LookForPlayers (newmobj, true) )
        newmobj.SetMobjState (newmobj.info.seestate);
        
        // telefrag anything in this spot
        A.TeleportMove (newmobj, newmobj.x, newmobj.y);

        // remove self (i.e., cube).
        A.RemoveMobj (mo);
    }
    }
//
//P_MobjThinker
//
  
      class A_PlayerScream implements ActionType1{
          public void invoke(mobj_t  actor){ 
          // Default death sound.
          sfxenum_t     sound = sfxenum_t.sfx_pldeth;
          
          if ( DS.isCommercial()
          &&  (actor.health < -50))
          {
          // IF THE PLAYER DIES
          // LESS THAN -50% WITHOUT GIBBING
          sound =  sfxenum_t.sfx_pdiehi;
          }
          
          S.StartSound(actor, sound);
          }
      }

      //
      // A_FaceTarget. This is called by many other functions anyway, 
      // other than autonomously.
      //
      void A_FaceTarget (mobj_t  actor)
      {   
          if (actor.target==null)
          return;
          
          actor.flags &= ~MF_AMBUSH;
          
          actor.angle = R.PointToAngle2 (actor.x,
                          actor.y,
                          actor.target.x,
                          actor.target.y)&BITS32;
          
          if (eval(actor.target.flags & MF_SHADOW))
          actor.angle += (RND.P_Random()-RND.P_Random())<<21;
          actor.angle&=BITS32;
      }
      
      /**
       * A_Chase
       * Actor has a melee attack,
       * so it tries to close as fast as possible
       */
      
      class A_Chase implements ActionType1{
          public void invoke(mobj_t  actor){ 
          int     delta;
          boolean nomissile=false; // for the fugly goto

          if (actor.reactiontime!=0)
              actor.reactiontime--;


          // modify target threshold
          if  (actor.threshold!=0)
          {
              if (actor.target==null
                      || actor.target.health <= 0)
              {
                  actor.threshold = 0;
              }
              else
                  actor.threshold--;
          }

          // turn towards movement direction if not there yet
          if (actor.movedir < 8)
          {
              actor.angle &= (7<<29);
              actor.angle&=BITS32;
              // Nice problem, here!
              delta = (int) (actor.angle - (actor.movedir << 29));

              if (delta > 0)
                  actor.angle -= ANG45;
              else if (delta < 0)
                  actor.angle += ANG45;
              
              actor.angle&=BITS32;
          }

          
          
          if (actor.target==null
                  || !eval(actor.target.flags&MF_SHOOTABLE))
          {
              // look for a new target
              if (EN.LookForPlayers(actor,true))
                  return;     // got a new target

              actor.SetMobjState (actor.info.spawnstate);
              return;
          }

          // do not attack twice in a row
          if (eval(actor.flags & MF_JUSTATTACKED))
          {
              actor.flags &= ~MF_JUSTATTACKED;
              if (DS.gameskill != skill_t.sk_nightmare && !DS.fastparm)
                  A.NewChaseDir (actor);
              return;
          }

          // check for melee attack
          if (actor.info.meleestate!=statenum_t.S_NULL /*null*/
                  && EN.CheckMeleeRange (actor))
          {
              if (actor.info.attacksound!=null){
                  S.StartSound (actor, actor.info.attacksound);
              }
              actor.SetMobjState(actor.info.meleestate);
              return;
          }

          // check for missile attack
          if (actor.info.missilestate!=statenum_t.S_NULL /*!= null*/) //_D_: this caused a bug where Demon for example were disappearing
          {
              // Assume that a missile attack is possible
              if (DS.gameskill.ordinal() < skill_t.sk_nightmare.ordinal()
                      && !DS.fastparm && actor.movecount!=0)
              {
                  // Uhm....no.
                  nomissile=true;
              }
              else
                  if (!EN.CheckMissileRange (actor))
                      nomissile=true; // Out of range

              if (!nomissile){
                  // Perform the attack
                  actor.SetMobjState ( actor.info.missilestate);
                  actor.flags |= MF_JUSTATTACKED;
                  return;
              }
          }

          // This should be executed always, if not averted by returns.
          
              // possibly choose another target
              if (DS.netgame
                      && actor.threshold==0
                      && !EN.CheckSight (actor, actor.target) )
              {
                  if (EN.LookForPlayers(actor,true))
                      return; // got a new target
              }

          // chase towards player
          if (--actor.movecount<0
                  || !A.Move (actor))
          {
             A.NewChaseDir (actor);
          }

          // make active sound
          if (actor.info.activesound!=null
                  && RND.P_Random() < 3)
          {
              S.StartSound (actor, actor.info.activesound);
          }
          }
      }
      

      
}

package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import m.IRandom;
import rr.SectorAction;
import w.DoomIO;

//
// BROKEN LIGHT EFFECT
//

public class lightflash_t extends SectorAction{
	
    private IRandom RND;
    
    public int     count;
    public int     maxlight;
    public int     minlight;
    public int     maxtime;
    public int     mintime;
    
    public lightflash_t(){
    
    }
    
    public lightflash_t(IRandom RND){
        this.RND=RND;
    }
    
    /**
     * T_LightFlash
     * Do flashing lights.
     */
    
    public void LightFlash() {
        if (--count != 0)
            return;

        if (sector.lightlevel == maxlight) {
            sector.lightlevel = (short)minlight;
            count = (RND.P_Random() & mintime) + 1;
        } else {
            sector.lightlevel = (short)maxlight;
            count = (RND.P_Random() & maxtime) + 1;
        }

    }
    
    @Override
    public void read(DataInputStream f) throws IOException{

        super.read(f); // Call thinker reader first            
        super.sectorid=DoomIO.readLEInt(f); // Sector index
        count=DoomIO.readLEInt(f);
        maxlight=DoomIO.readLEInt(f);
        minlight=DoomIO.readLEInt(f);
        maxtime=DoomIO.readLEInt(f);
        mintime=DoomIO.readLEInt(f);
        }
    
    @Override
    public void pack(ByteBuffer b) throws IOException{
        super.pack(b); //12            
        b.putInt(super.sectorid); // 16
        b.putInt(count); //20
        b.putInt(maxlight);//24
        b.putInt(minlight);//28
        b.putInt(maxtime);//32
        b.putInt(mintime);//36
    }
    
}
package p;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;

import m.BBox;
import m.fixed_t;

import boom.DeepBSPNodesV4;
import boom.mapglvertex_t;
import boom.mapnode_v4_t;
import boom.mapnode_znod_t;
import boom.mapseg_v4_t;
import boom.mapseg_znod_t;
import boom.mapsubsector_v4_t;
import boom.mapsubsector_znod_t;

import data.Limits;
import data.maplinedef_t;
import data.mapnode_t;
import data.mapsector_t;
import data.mapseg_t;
import data.mapsidedef_t;
import data.mapsubsector_t;
import data.mapthing_t;
import data.mapvertex_t;
import defines.skill_t;
import defines.slopetype_t;
import doom.DoomStatus;
import rr.RendererState;
import rr.line_t;
import static rr.line_t.ML_TWOSIDED;
import rr.node_t;
import rr.sector_t;
import rr.seg_t;
import rr.side_t;
import rr.subsector_t;
import rr.vertex_t;
import rr.z_vertex_t;
import s.degenmobj_t;
import utils.C2JUtils;
import w.CacheableDoomObjectContainer;
import w.DoomBuffer;
import w.wadfile_info_t;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.FRACBITS;
import static data.Defines.*;
import static utils.C2JUtils.flags;
import static utils.C2JUtils.unsigned;
import static boom.E6Y.NO_INDEX;
import static m.BBox.*;
import static boom.Compatibility.*;

/*
 * Emacs style mode select -*- C++ -*-
 * -----------------------------------------------------------------------------
 * PrBoom: a Doom port merged with LxDoom and LSDLDoom based on BOOM, a modified
 * and improved DOOM engine Copyright (C) 1999 by id Software, Chi Hoang, Lee
 * Killough, Jim Flynn, Rand Phares, Ty Halderman Copyright (C) 1999-2000 by
 * Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze Copyright 2005,
 * 2006 by Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko This
 * program is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version. This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details. You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. DESCRIPTION: Do all
 * the WAD I/O, get map description, set up initial state and misc. LUTs.
 * 
 * MAES 30/9/2011: This is a direct translation of prBoom+'s 2.5.0.8 p_setup.c
 * and p_setup.h.
 * 
 * 
 * 
 * -----------------------------------------------------------------------------
 */

public class BoomLevelLoader
        extends AbstractLevelLoader {

    public BoomLevelLoader(DoomStatus<?,?> DC) {
        super(DC);
        // TODO Auto-generated constructor stub
    }

    // OpenGL related.
    byte[] map_subsectors;

    // //////////////////////////////////////////////////////////////////////////////////////////
    // figgi 08/21/00 -- finalants and globals for glBsp support
    public static final int gNd2 = 0x32644E67; // figgi -- suppport for new
                                               // GL_VERT format v2.0

    public static final int gNd3 = 0x33644E67;

    public static final int gNd4 = 0x34644E67;

    public static final int gNd5 = 0x35644E67;

    public static final int ZNOD = 0x444F4E5A;

    public static final int ZGLN = 0x4E4C475A;

    public static final int GL_VERT_OFFSET = 4;

    int firstglvertex = 0;

    int nodesVersion = 0;

    boolean forceOldBsp = false;

    // figgi 08/21/00 -- glSegs
    class glseg_t {
        char v1; // start vertex (16 bit)

        char v2; // end vertex (16 bit)

        char linedef; // linedef, or -1 for minisegs

        short side; // side on linedef: 0 for right, 1 for left

        short partner; // corresponding partner seg, or -1 on one-sided walls
    }

    public static final int ML_GL_LABEL = 0; // A separator name, GL_ExMx or
                                             // GL_MAPxx

    public static final int ML_GL_VERTS = 1; // Extra Vertices

    public static final int ML_GL_SEGS = 2; // Segs, from linedefs & minisegs

    public static final int ML_GL_SSECT = 3; // SubSectors, list of segs

    public static final int ML_GL_NODES = 4; // GL BSP nodes

    // //////////////////////////////////////////////////////////////////////////////////////////

    //
    // REJECT
    // For fast sight rejection.
    // Speeds up enemy AI by skipping detailed
    // LineOf Sight calculation.
    // Without the special effect, this could
    // be used as a PVS lookup as well.
    //

    private int rejectlump = -1;// cph - store reject lump num if cached

    private int current_episode = -1;

    private int current_map = -1;

    private int current_nodesVersion = -1;

    private boolean samelevel = false;

    /**
     * e6y: Smart malloc Used by P_SetupLevel() for smart data loading. Do
     * nothing if level is the same. Passing a null array forces allocation.
     * 
     * @param p
     *        generically typed array to consider
     * @param numstuff
     *        elements to realloc
     */

    private <T> T[] malloc_IfSameLevel(T[] p, int numstuff, Class<T> type) {
        if (!samelevel || (p == null)) {
            return (T[]) C2JUtils.createArrayOfObjects(type, numstuff);
        }
        return p;
    }

    // e6y: Smart calloc
    // Used by P_SetupLevel() for smart data loading
    // Clear the memory without allocation if level is the same
    private <T> T[] calloc_IfSameLevel(T[] p, int numstuff, Class<T> type) {
        if (!samelevel) {
            return (T[]) C2JUtils.createArrayOfObjects(type, numstuff);
        } else {

            // TODO: stuff should be resetted!
            C2JUtils.resetAll((Resettable[]) p);
            return p;
        }
    }

    //
    // P_CheckForZDoomNodes
    //

    private boolean P_CheckForZDoomNodes(int lumpnum, int gl_lumpnum) {
        byte[] data;
        int check;
        
        data = W.CacheLumpNumAsRawBytes(lumpnum + ML_NODES, 0);
        check=ByteBuffer.wrap(data).getInt();
        
        if (check == ZNOD)
            I.Error("P_CheckForZDoomNodes: ZDoom nodes not supported yet");

        data = W.CacheLumpNumAsRawBytes(lumpnum + ML_SSECTORS, 0);
        if (check == ZGLN)
            I.Error("P_CheckForZDoomNodes: ZDoom GL nodes not supported yet");

        // Unlock them to force different buffering interpretation.
        W.UnlockLumpNum(lumpnum + ML_NODES);
        W.UnlockLumpNum(lumpnum + ML_SSECTORS);

        return false;
    }

    //
    // P_CheckForDeePBSPv4Nodes
    // http://www.sbsoftware.com/files/DeePBSPV4specs.txt
    //

    private boolean P_CheckForDeePBSPv4Nodes(int lumpnum, int gl_lumpnum) {
        byte[] data;
        boolean result = false;

        data = W.CacheLumpNumAsRawBytes(lumpnum + ML_NODES, 0);
        byte[] compare = Arrays.copyOfRange(data, 0, 7);

        if (Arrays.equals(compare, DeepBSPNodesV4.DeepBSPHeader)) {
            System.out
                    .println("P_CheckForDeePBSPv4Nodes: DeePBSP v4 Extended nodes are detected\n");
            result = true;
        }

        W.UnlockLumpNum(lumpnum + ML_NODES);

        return result;
    }

    //
    // P_CheckForZDoomUncompressedNodes
    // http://zdoom.org/wiki/ZDBSP#Compressed_Nodes
    //

    private static final int XNOD = 0x584e4f44;

    private boolean P_CheckForZDoomUncompressedNodes(int lumpnum, int gl_lumpnum) {
        byte[] data;
        int wrapper;
        boolean result = false;

        data = W.CacheLumpNumAsRawBytes(lumpnum + ML_NODES, 0);
        wrapper=ByteBuffer.wrap(data).getInt();

        if (wrapper==XNOD) {
            System.out.println("P_CheckForZDoomUncompressedNodes: ZDoom uncompressed normal nodes are detected\n");
            result = true;
        }

        W.UnlockLumpNum(lumpnum + ML_NODES);

        return result;
    }

    //
    // P_GetNodesVersion
    //

    public void P_GetNodesVersion(int lumpnum, int gl_lumpnum) {
        int ver = -1;
        nodesVersion = 0;

        if ((gl_lumpnum > lumpnum) && (forceOldBsp == false)
            &&(DoomStatus.compatibility_level>=prboom_2_compatibility)
                                                             ) {

            byte[] data = W.CacheLumpNumAsRawBytes(gl_lumpnum + ML_GL_VERTS, 0);
            int wrapper = ByteBuffer.wrap(data).getInt();
            if (wrapper == gNd2) {
                data = W.CacheLumpNumAsRawBytes(gl_lumpnum + ML_GL_SEGS, 0);
                wrapper = ByteBuffer.wrap(data).getInt();
                if (wrapper == gNd3) {
                    ver = 3;
                } else {
                    nodesVersion = gNd2;
                    System.out
                            .println("P_GetNodesVersion: found version 2 nodes\n");
                }
            }
            if (wrapper == gNd4) {
                ver = 4;
            }
            if (wrapper == gNd5) {
                ver = 5;
            }
            // e6y: unknown gl nodes will be ignored
            if (nodesVersion == 0 && ver != -1) {
                System.out.printf(
                    "P_GetNodesVersion: found version %d nodes\n", ver);
                System.out.printf(
                    "P_GetNodesVersion: version %d nodes not supported\n", ver);
            }
        } else {
            nodesVersion = 0;
            System.out.println("P_GetNodesVersion: using normal BSP nodes\n");
            if (P_CheckForZDoomNodes(lumpnum, gl_lumpnum))
                I.Error("P_GetNodesVersion: ZDoom nodes not supported yet");
        }
    }

    //
    // P_LoadVertexes
    //
    // killough 5/3/98: reformatted, cleaned up
    //
    private void P_LoadVertexes(int lump) {
        final mapvertex_t[] data; // cph - final

        // Determine number of lumps:
        // total lump length / vertex record length.
        numvertexes = W.LumpLength(lump) / mapvertex_t.sizeOf();

        // Allocate zone memory for buffer.
        vertexes =
            (vertex_t[]) calloc_IfSameLevel(vertexes, numvertexes,
                vertex_t.class);

        // Load data into cache.
        // cph 2006/07/29 - cast to mapvertex_t here, making the loop below much
        // neater
        data = W.CacheLumpNumIntoArray(lump, numvertexes, mapvertex_t.class);

        // Copy and convert vertex coordinates,
        // internal representation as fixed.
        for (int i = 0; i < numvertexes; i++) {
            vertexes[i].x = data[i].x << m.fixed_t.FRACBITS;
            vertexes[i].y = data[i].y << FRACBITS;
        }

        // Free buffer memory.
        W.UnlockLumpNum(lump);
    }

    /*******************************************
     * Name : P_LoadVertexes2 * modified : 09/18/00, adapted for PrBoom * author
     * : figgi * what : support for gl nodes
     * 
     * @throws IOException
     *         *
     *******************************************/

    // figgi -- FIXME: Automap showes wrong zoom boundaries when starting game
    // when P_LoadVertexes2 is used with classic BSP nodes.

    private void P_LoadVertexes2(int lump, int gllump)
            throws IOException {
        final ByteBuffer gldata;
        int i;
        mapvertex_t[] ml;

        // GL vertexes come after regular ones.
        firstglvertex = W.LumpLength(lump) / mapvertex_t.sizeOf();
        numvertexes = W.LumpLength(lump) / mapvertex_t.sizeOf();

        if (gllump >= 0) // check for glVertices
        {
            // Read GL lump into buffer. This allows some flexibility
            gldata = W.CacheLumpNumAsDoomBuffer(gllump).getBuffer();

            if (nodesVersion == gNd2) // 32 bit GL_VERT format (16.16 fixed)
            {

                // These vertexes are double in size than regular Doom vertexes.
                // Furthermore, we have to skip the first 4 bytes
                // (GL_VERT_OFFSET)
                // of the gl lump.
                numvertexes +=
                    (W.LumpLength(gllump) - GL_VERT_OFFSET)
                            / mapglvertex_t.sizeOf();

                // Vertexes size accomodates both normal and GL nodes.
                vertexes =
                    malloc_IfSameLevel(vertexes, numvertexes, vertex_t.class);

                final mapglvertex_t[] mgl =
                    C2JUtils.createArrayOfObjects(mapglvertex_t.class,
                        numvertexes - firstglvertex);

                // Get lump and skip first 4 bytes
                gldata.rewind();
                gldata.position(GL_VERT_OFFSET);

                CacheableDoomObjectContainer.unpack(gldata, mgl);

                int mgl_count = 0;

                for (i = firstglvertex; i < numvertexes; i++) {
                    vertexes[i].x = mgl[mgl_count].x;
                    vertexes[i].y = mgl[mgl_count].y;
                    mgl_count++;
                }
            } else {
                // Vertexes size accomodates both normal and GL nodes.
                numvertexes += W.LumpLength(gllump) / mapvertex_t.sizeOf();
                vertexes =
                    malloc_IfSameLevel(vertexes, numvertexes, vertex_t.class);

                ml =
                    C2JUtils.createArrayOfObjects(mapvertex_t.class,
                        numvertexes - firstglvertex);

                // We can read this "directly" because no skipping is involved.
                gldata.rewind();
                CacheableDoomObjectContainer.unpack(gldata, ml);
                // ml = W.CacheLumpNumIntoArray(gllump,
                // numvertexes-firstglvertex,mapvertex_t.class);
                int ml_count = 0;

                for (i = firstglvertex; i < numvertexes; i++) {
                    vertexes[i].x = ml[ml_count].x;
                    vertexes[i].y = ml[ml_count].y;
                    ml_count++;
                }
            }
            W.UnlockLumpNum(gllump);
        }

        // Loading of regular lumps (sheesh!)
        ml = W.CacheLumpNumIntoArray(lump, firstglvertex, mapvertex_t.class);

        for (i = 0; i < firstglvertex; i++) {
            vertexes[i].x = ml[i].x;
            vertexes[i].y = ml[i].y;
        }

        W.UnlockLumpNum(lump);

    }

    /*******************************************
     * created : 08/13/00 * modified : 09/18/00, adapted for PrBoom * author :
     * figgi * what : basic functions needed for * computing gl nodes *
     *******************************************/

    public int checkGLVertex(int num) {
        if ((num & 0x8000) != 0)
            num = (num & 0x7FFF) + firstglvertex;
        return num;
    }

    public static float GetDistance(int dx, int dy) {
        float fx = (float) (dx) / FRACUNIT, fy = (float) (dy) / FRACUNIT;
        return (float) Math.sqrt(fx * fx + fy * fy);
    }

    public static float GetTexelDistance(int dx, int dy) {
        // return (float)((int)(GetDistance(dx, dy) + 0.5f));
        float fx = (float) (dx) / FRACUNIT, fy = (float) (dy) / FRACUNIT;
        return (float) ((int) (0.5f + (float) Math.sqrt(fx * fx + fy * fy)));
    }

    public static int GetOffset(vertex_t v1, vertex_t v2) {
        float a, b;
        int r;
        a = (float) (v1.x - v2.x) / (float) FRACUNIT;
        b = (float) (v1.y - v2.y) / (float) FRACUNIT;
        r = (int) (Math.sqrt(a * a + b * b) * (float) FRACUNIT);
        return r;
    }

    //
    // P_LoadSegs
    //
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadSegs(int lump) {
        int i;
        final mapseg_t[] data; // cph - final

        numsegs = W.LumpLength(lump) / mapseg_t.sizeOf();
        segs = (seg_t[]) calloc_IfSameLevel(segs, numsegs, seg_t.class);

        data = W.CacheLumpNumIntoArray(lump, numsegs, mapseg_t.class); // cph -
                                                                       // wad
                                                                       // lump
                                                                       // handling
                                                                       // updated

        if ((data == null) || (numsegs == 0))
            I.Error("P_LoadSegs: no segs in level");

        for (i = 0; i < numsegs; i++) {
            seg_t li = segs[i];
            final mapseg_t ml = data[i];
            char v1, v2;

            int side, linedef;
            line_t ldef;

            li.iSegID = i; // proff 11/05/2000: needed for OpenGL

            v1 = (char) ml.v1;
            v2 = (char) ml.v2;

            // e6y
            // moved down for additional checks to avoid overflow
            // if wrong vertexe's indexes are in SEGS lump
            // see below for more detailed information
            // li.v1 = &vertexes[v1];
            // li.v2 = &vertexes[v2];

            li.miniseg = false; // figgi -- there are no minisegs in classic BSP
                                // nodes

            // e6y: moved down, see below
            // li.length = GetDistance(li.v2.x - li.v1.x, li.v2.y - li.v1.y);

            li.angle = ml.angle << 16;
            li.offset = ml.offset << 16;
            linedef = (char) ml.linedef;

            // e6y: check for wrong indexes
            if (linedef >= numlines) {
                I.Error(
                    "P_LoadSegs: seg %d references a non-existent linedef %d",
                    i, linedef);
            }

            ldef = lines[linedef];
            li.linedef = ldef;
            side = ml.side;

            // e6y: fix wrong side index
            if (side != 0 && side != 1) {
                System.err
                        .printf(
                            "P_LoadSegs: seg %d contains wrong side index %d. Replaced with 1.\n",
                            i, side);
                side = 1;
            }

            // e6y: check for wrong indexes
            if ((char) ldef.sidenum[side] >= (char) numsides) {
                I.Error(
                    "P_LoadSegs: linedef %d for seg %d references a non-existent sidedef %d",
                    linedef, i, ldef.sidenum[side]);
            }

            li.sidedef = sides[ldef.sidenum[side]];

            /*
             * cph 2006/09/30 - our frontsector can be the second side of the
             * linedef, so must check for NO_INDEX in case we are incorrectly
             * referencing the back of a 1S line
             */
            if (ldef.sidenum[side] != NO_INDEX)
                li.frontsector = sides[ldef.sidenum[side]].sector;
            else {
                li.frontsector = null;
                System.err.printf(
                    "P_LoadSegs: front of seg %i has no sidedef\n", i);
            }

            if (flags(ldef.flags, ML_TWOSIDED)
                    && ldef.sidenum[side ^ 1] != NO_INDEX)
                li.backsector = sides[ldef.sidenum[side ^ 1]].sector;
            else
                li.backsector = null;

            // e6y
            // check and fix wrong references to non-existent vertexes
            // see e1m9 @ NIVELES.WAD
            // http://www.doomworld.com/idgames/index.php?id=12647
            if (v1 >= numvertexes || v2 >= numvertexes) {
                String str =
                    "P_LoadSegs: compatibility loss - seg %d references a non-existent vertex %d\n";

                if (DM.demorecording) {
                    I.Error(
                        str
                                + "Demo recording on levels with invalid nodes is not allowed",
                        i, (v1 >= numvertexes ? v1 : v2));
                }

                if (v1 >= numvertexes)
                    System.err.printf(str, i, v1);
                if (v2 >= numvertexes)
                    System.err.printf(str, i, v2);

                if (li.sidedef == sides[li.linedef.sidenum[0]]) {
                    li.v1 = lines[ml.linedef].v1;
                    li.v2 = lines[ml.linedef].v2;
                } else {
                    li.v1 = lines[ml.linedef].v2;
                    li.v2 = lines[ml.linedef].v1;
                }
            } else {
                li.v1 = vertexes[v1];
                li.v2 = vertexes[v2];
            }

            li.assignVertexValues();

            // e6y: now we can calculate it
            li.length = GetDistance(li.v2x - li.v1x, li.v2y - li.v1y);

            // Recalculate seg offsets that are sometimes incorrect
            // with certain nodebuilders. Fixes among others, line 20365
            // of DV.wad, map 5
            li.offset = GetOffset(li.v1, (ml.side != 0 ? ldef.v2 : ldef.v1));
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

    private void P_LoadSegs_V4(int lump) {
        int i;
        mapseg_v4_t[] data;

        numsegs = W.LumpLength(lump) / mapseg_v4_t.sizeOf();
        segs = (seg_t[]) calloc_IfSameLevel(segs, numsegs, seg_t.class);
        data = W.CacheLumpNumIntoArray(lump, numsegs, mapseg_v4_t.class);

        if ((data == null) || (numsegs == 0))
            I.Error("P_LoadSegs_V4: no segs in level");

        for (i = 0; i < numsegs; i++) {
            seg_t li = segs[i];
            final mapseg_v4_t ml = data[i];
            int v1, v2;

            int side, linedef;
            line_t ldef;

            li.iSegID = i; // proff 11/05/2000: needed for OpenGL

            v1 = ml.v1;
            v2 = ml.v2;

            li.miniseg = false; // figgi -- there are no minisegs in classic BSP
                                // nodes

            li.angle = ml.angle << 16;
            li.offset = ml.offset << 16;
            linedef = ml.linedef;

            // e6y: check for wrong indexes
            if (unsigned(linedef) >= unsigned(numlines)) {
                I.Error(
                    "P_LoadSegs_V4: seg %d references a non-existent linedef %d",
                    i, unsigned(linedef));
            }

            ldef = lines[linedef];
            li.linedef = ldef;
            side = ml.side;

            // e6y: fix wrong side index
            if (side != 0 && side != 1) {
                System.err
                        .printf(
                            "P_LoadSegs_V4: seg %d contains wrong side index %d. Replaced with 1.\n",
                            i, side);
                side = 1;
            }

            // e6y: check for wrong indexes
            if (unsigned(ldef.sidenum[side]) >= unsigned(numsides)) {
                I.Error(
                    "P_LoadSegs_V4: linedef %d for seg %d references a non-existent sidedef %d",
                    linedef, i, unsigned(ldef.sidenum[side]));
            }

            li.sidedef = sides[ldef.sidenum[side]];

            /*
             * cph 2006/09/30 - our frontsector can be the second side of the
             * linedef, so must check for NO_INDEX in case we are incorrectly
             * referencing the back of a 1S line
             */
            if (ldef.sidenum[side] != NO_INDEX) {
                li.frontsector = sides[ldef.sidenum[side]].sector;
            } else {
                li.frontsector = null;
                System.err.printf(
                    "P_LoadSegs_V4: front of seg %i has no sidedef\n", i);
            }

            if (flags(ldef.flags, ML_TWOSIDED)
                    && ldef.sidenum[side ^ 1] != NO_INDEX)
                li.backsector = sides[ldef.sidenum[side ^ 1]].sector;
            else
                li.backsector = null;

            // e6y
            // check and fix wrong references to non-existent vertexes
            // see e1m9 @ NIVELES.WAD
            // http://www.doomworld.com/idgames/index.php?id=12647
            if (v1 >= numvertexes || v2 >= numvertexes) {
                String str =
                    "P_LoadSegs_V4: compatibility loss - seg %d references a non-existent vertex %d\n";

                if (DM.demorecording) {
                    I.Error(
                        (str + "Demo recording on levels with invalid nodes is not allowed"),
                        i, (v1 >= numvertexes ? v1 : v2));
                }

                if (v1 >= numvertexes)
                    System.err.printf(str, i, v1);
                if (v2 >= numvertexes)
                    System.err.printf(str, i, v2);

                if (li.sidedef == sides[li.linedef.sidenum[0]]) {
                    li.v1 = lines[ml.linedef].v1;
                    li.v2 = lines[ml.linedef].v2;
                } else {
                    li.v1 = lines[ml.linedef].v2;
                    li.v2 = lines[ml.linedef].v1;
                }
            } else {
                li.v1 = vertexes[v1];
                li.v2 = vertexes[v2];
            }

            // e6y: now we can calculate it
            li.length = GetDistance(li.v2.x - li.v1.x, li.v2.y - li.v1.y);

            // Recalculate seg offsets that are sometimes incorrect
            // with certain nodebuilders. Fixes among others, line 20365
            // of DV.wad, map 5
            li.offset = GetOffset(li.v1, (ml.side != 0 ? ldef.v2 : ldef.v1));
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

    /*******************************************
     * Name : P_LoadGLSegs * created : 08/13/00 * modified : 09/18/00, adapted
     * for PrBoom * author : figgi * what : support for gl nodes *
     *******************************************/
    /*
     * private void P_LoadGLSegs(int lump) { int i; final glseg_t ml; line_t
     * ldef; numsegs = W.LumpLength(lump) / sizeof(glseg_t); segs =
     * malloc_IfSameLevel(segs, numsegs * sizeof(seg_t)); memset(segs, 0,
     * numsegs * sizeof(seg_t)); ml = (final glseg_t*)W.CacheLumpNum(lump); if
     * ((!ml) || (!numsegs)) I_Error("P_LoadGLSegs: no glsegs in level"); for(i
     * = 0; i < numsegs; i++) { // check for gl-vertices segs[i].v1 =
     * &vertexes[checkGLVertex(LittleShort(ml.v1))]; segs[i].v2 =
     * &vertexes[checkGLVertex(LittleShort(ml.v2))]; segs[i].iSegID = i;
     * if(ml.linedef != (unsigned short)-1) // skip minisegs { ldef =
     * &lines[ml.linedef]; segs[i].linedef = ldef; segs[i].miniseg = false;
     * segs[i].angle =
     * R_PointToAngle2(segs[i].v1.x,segs[i].v1.y,segs[i].v2.x,segs[i].v2.y);
     * segs[i].sidedef = &sides[ldef.sidenum[ml.side]]; segs[i].length =
     * GetDistance(segs[i].v2.x - segs[i].v1.x, segs[i].v2.y - segs[i].v1.y);
     * segs[i].frontsector = sides[ldef.sidenum[ml.side]].sector; if (ldef.flags
     * & ML_TWOSIDED) segs[i].backsector =
     * sides[ldef.sidenum[ml.side^1]].sector; else segs[i].backsector = 0; if
     * (ml.side) segs[i].offset = GetOffset(segs[i].v1, ldef.v2); else
     * segs[i].offset = GetOffset(segs[i].v1, ldef.v1); } else { segs[i].miniseg
     * = true; segs[i].angle = 0; segs[i].offset = 0; segs[i].length = 0;
     * segs[i].linedef = NULL; segs[i].sidedef = NULL; segs[i].frontsector =
     * NULL; segs[i].backsector = NULL; } ml++; } W.UnlockLumpNum(lump); }
     */

    //
    // P_LoadSubsectors
    //
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadSubsectors(int lump) {
        /*
         * cph 2006/07/29 - make data a final mapsubsector_t *, so the loop
         * below is simpler & gives no finalness warnings
         */
        final mapsubsector_t[] data;
        int i;

        numsubsectors = W.LumpLength(lump) / mapsubsector_t.sizeOf();
        subsectors =
            (subsector_t[]) calloc_IfSameLevel(subsectors, numsubsectors,
                subsector_t.class);
        data =
            W.CacheLumpNumIntoArray(lump, numsubsectors, mapsubsector_t.class);

        if ((data == null) || (numsubsectors == 0))
            I.Error("P_LoadSubsectors: no subsectors in level");

        for (i = 0; i < numsubsectors; i++) {
            // e6y: support for extended nodes
            subsectors[i].numlines = (char) data[i].numsegs;
            subsectors[i].firstline = (char) data[i].firstseg;
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

    private void P_LoadSubsectors_V4(int lump) {
        /*
         * cph 2006/07/29 - make data a final mapsubsector_t *, so the loop
         * below is simpler & gives no finalness warnings
         */
        final mapsubsector_v4_t[] data;
        int i;

        numsubsectors = W.LumpLength(lump) / mapsubsector_v4_t.sizeOf();
        subsectors =
            calloc_IfSameLevel(subsectors, numsubsectors, subsector_t.class);
        data =
            W.CacheLumpNumIntoArray(lump, numsubsectors,
                mapsubsector_v4_t.class);

        if ((data == null) || (numsubsectors == 0))
            I.Error("P_LoadSubsectors_V4: no subsectors in level");

        for (i = 0; i < numsubsectors; i++) {
            subsectors[i].numlines = (int) data[i].numsegs;
            subsectors[i].firstline = (int) data[i].firstseg;
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

    //
    // P_LoadSectors
    //
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadSectors(int lump) {
        final mapsector_t[] data; // cph - final*
        int i;

        numsectors = W.LumpLength(lump) / mapsector_t.sizeOf();
        sectors = calloc_IfSameLevel(sectors, numsectors, sector_t.class);
        data = W.CacheLumpNumIntoArray(lump, numsectors, mapsector_t.class); // cph
                                                                             // -
                                                                             // wad
                                                                             // lump
                                                                             // handling
                                                                             // updated

        for (i = 0; i < numsectors; i++) {
            sector_t ss = sectors[i];
            final mapsector_t ms = data[i];

            ss.id = i; // proff 04/05/2000: needed for OpenGL
            ss.floorheight = ms.floorheight << FRACBITS;
            ss.ceilingheight = ms.ceilingheight << FRACBITS;
            ss.floorpic = (short) TM.FlatNumForName(ms.floorpic);
            ss.ceilingpic = (short) TM.FlatNumForName(ms.ceilingpic);
            ss.lightlevel = ms.lightlevel;
            ss.special = ms.special;
            // ss.oldspecial = ms.special; huh?
            ss.tag = ms.tag;
            ss.thinglist = null;
            // MAES: link to thinker list and RNG
            ss.TL = this.P;
            ss.RND = this.DM.RND;

            // ss.touching_thinglist = null; // phares 3/14/98

            // ss.nextsec = -1; //jff 2/26/98 add fields to support locking out
            // ss.prevsec = -1; // stair retriggering until build completes

            // killough 3/7/98:
            // ss.floor_xoffs = 0;
            // ss.floor_yoffs = 0; // floor and ceiling flats offsets
            // ss.ceiling_xoffs = 0;
            // ss.ceiling_yoffs = 0;
            // ss.heightsec = -1; // sector used to get floor and ceiling height
            // ss.floorlightsec = -1; // sector used to get floor lighting
            // killough 3/7/98: end changes

            // killough 4/11/98 sector used to get ceiling lighting:
            // ss.ceilinglightsec = -1;

            // killough 4/4/98: colormaps:
            // ss.bottommap = ss.midmap = ss.topmap = 0;

            // killough 10/98: sky textures coming from sidedefs:
            // ss.sky = 0;
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

    //
    // P_LoadNodes
    //
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadNodes(int lump) {
        final mapnode_t[] data; // cph - final*
        int i;

        numnodes = W.LumpLength(lump) / mapnode_t.sizeOf();
        nodes = (node_t[]) malloc_IfSameLevel(nodes, numnodes, node_t.class);
        data = W.CacheLumpNumIntoArray(lump, numnodes, mapnode_t.class); // cph
                                                                         // -
                                                                         // wad
                                                                         // lump
                                                                         // handling
                                                                         // updated

        if ((data == null) || (numnodes == 0)) {
            // allow trivial maps
            if (numsubsectors == 1)
                System.out
                        .print("P_LoadNodes: trivial map (no nodes, one subsector)\n");
            else
                I.Error("P_LoadNodes: no nodes in level");
        }

        for (i = 0; i < numnodes; i++) {
            node_t no = nodes[i];
            final mapnode_t mn = data[i];
            int j;

            no.x = mn.x << FRACBITS;
            no.y = mn.y << FRACBITS;
            no.dx = mn.dx << FRACBITS;
            no.dy = mn.dy << FRACBITS;

            for (j = 0; j < 2; j++) {
                int k;
                // e6y: support for extended nodes
                no.children[j] = (char) mn.children[j];

                // e6y: support for extended nodes
                if (no.children[j] == 0xFFFF) {
                    no.children[j] = 0xFFFFFFFF;
                } else if (flags(no.children[j], NF_SUBSECTOR_CLASSIC)) {
                    // Convert to extended type
                    no.children[j] &= ~NF_SUBSECTOR_CLASSIC;

                    // haleyjd 11/06/10: check for invalid subsector reference
                    if (no.children[j] >= numsubsectors) {
                        System.err
                                .printf(
                                    "P_LoadNodes: BSP tree references invalid subsector %d.\n",
                                    no.children[j]);
                        no.children[j] = 0;
                    }

                    no.children[j] |= NF_SUBSECTOR;
                }

                for (k = 0; k < 4; k++)
                    no.bbox[j].set(k, mn.bbox[j][k] << FRACBITS);
            }
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

    private void P_LoadNodes_V4(int lump) {
        final DeepBSPNodesV4 data; // cph - final*
        int i;

        numnodes = (W.LumpLength(lump) - 8) / mapnode_v4_t.sizeOf();
        nodes = (node_t[]) malloc_IfSameLevel(nodes, numnodes, node_t.class);
        data = (DeepBSPNodesV4) W.CacheLumpNum(lump, 0, DeepBSPNodesV4.class); // cph
                                                                               // -
                                                                               // wad
                                                                               // lump
                                                                               // handling
                                                                               // updated

        if ((data == null) || (numnodes == 0)) {
            // allow trivial maps
            if (numsubsectors == 1)
                System.out
                        .print("P_LoadNodes_V4: trivial map (no nodes, one subsector)\n");
            else
                I.Error("P_LoadNodes_V4: no nodes in level");
        }

        for (i = 0; i < numnodes; i++) {
            node_t no = nodes[i];
            final mapnode_v4_t mn = data.getNodes()[i];
            int j;

            no.x = mn.x << FRACBITS;
            no.y = mn.y << FRACBITS;
            no.dx = mn.dx << FRACBITS;
            no.dy = mn.dy << FRACBITS;

            for (j = 0; j < 2; j++) {
                int k;
                no.children[j] = mn.children[j];

                for (k = 0; k < 4; k++)
                    no.bbox[j].bbox[k] = mn.bbox[j][k] << FRACBITS;
            }
            
            
        }

        W.UnlockLumpNum(lump); // cph - release the data
    }

     private void P_LoadZSegs(ByteBuffer data) throws IOException {
        int i;

        final mapseg_znod_t nodes[] = C2JUtils.createArrayOfObjects(mapseg_znod_t.class,numsegs);
        CacheableDoomObjectContainer.unpack(data,nodes);

        for (i = 0; i < numsegs; i++) {
            line_t ldef;
            int v1, v2;
            int linedef;
            char side;
            seg_t li = segs[i];
            final mapseg_znod_t ml = nodes[i];

            v1 = ml.v1;
            v2 = ml.v2;

            li.iSegID = i; // proff 11/05/2000: needed for OpenGL
            li.miniseg = false;

            linedef = (char) ml.linedef;

            // e6y: check for wrong indexes
            if (unsigned(linedef) >= unsigned(numlines)) {
                I.Error(
                    "P_LoadZSegs: seg %d references a non-existent linedef %d",
                    i, unsigned(linedef));
            }

            ldef = lines[linedef];
            li.linedef = ldef;
            side = (char) ml.side;

            // e6y: fix wrong side index
            if (side != 0 && side != 1) {
                System.err
                        .printf(
                            "P_LoadZSegs: seg %d contains wrong side index %d. Replaced with 1.\n",
                            i, side);
                side = 1;
            }

            // e6y: check for wrong indexes
            if (unsigned(ldef.sidenum[side]) >= unsigned(numsides)) {
                I.Error(
                    "P_LoadZSegs: linedef %d for seg %d references a non-existent sidedef %d",
                    linedef, i, unsigned(ldef.sidenum[side]));
            }

            li.sidedef = sides[ldef.sidenum[side]];

            /*
             * cph 2006/09/30 - our frontsector can be the second side of the
             * linedef, so must check for NO_INDEX in case we are incorrectly
             * referencing the back of a 1S line
             */
            if (ldef.sidenum[side] != NO_INDEX) {
                li.frontsector = sides[ldef.sidenum[side]].sector;
            } else {
                li.frontsector = null;
                System.err.printf(
                    "P_LoadZSegs: front of seg %i has no sidedef\n", i);
            }

            if (flags(ldef.flags, ML_TWOSIDED)
                    && (ldef.sidenum[side ^ 1] != NO_INDEX))
                li.backsector = sides[ldef.sidenum[side ^ 1]].sector;
            else
                li.backsector = null;

            li.v1 = vertexes[v1];
            li.v2 = vertexes[v2];

            li.length = GetDistance(li.v2.x - li.v1.x, li.v2.y - li.v1.y);
            li.offset = GetOffset(li.v1, (side != 0 ? ldef.v2 : ldef.v1));
            li.angle =
                RendererState.PointToAngle(segs[i].v1.x, segs[i].v1.y,
                    segs[i].v2.x, segs[i].v2.y);
            // li.angle = (int)((float)atan2(li.v2.y - li.v1.y,li.v2.x -
            // li.v1.x) * (ANG180 / M_PI));
        }
    }

    private int CheckZNodesOverflow(int size, int count)
    {
      size -= count;

      if (size < 0)
      {
        I.Error("P_LoadZNodes: incorrect nodes");
      }
      
      return size;
    }
    
    private void P_LoadZNodes(int lump, int glnodes) throws IOException
    {
      ByteBuffer data;
      int i, len;
      int header; // for debugging
      
      int orgVerts, newVerts;
      int numSubs, currSeg;
      int numSegs;
      int numNodes;
      vertex_t[] newvertarray = null;

      data = W.CacheLumpNumAsDoomBuffer(lump).getBuffer();
      data.order(ByteOrder.LITTLE_ENDIAN);
      len =  W.LumpLength(lump);
      
      // skip header
      len=CheckZNodesOverflow(len, 4);
      header=data.getInt();

      // Read extra vertices added during node building
      len=CheckZNodesOverflow(len, 4);
      orgVerts = data.getInt();

      len=CheckZNodesOverflow(len, 4);
      newVerts = data.getInt();

      if (!samelevel)
      {
        if (orgVerts + newVerts == numvertexes)
        {
          newvertarray = vertexes;
        }
        else
        {
          newvertarray = C2JUtils.createArrayOfObjects(vertex_t.class, orgVerts + newVerts);
          System.arraycopy(vertexes, 0, newvertarray, 0, orgVerts);
        }

        //(sizeof(newvertarray[0].x) + sizeof(newvertarray[0].y))
        len=CheckZNodesOverflow(len, newVerts * vertex_t.sizeOf());
        z_vertex_t tmp=new z_vertex_t();
        
        for (i = 0; i < newVerts; i++)
        {
            tmp.unpack(data);
            newvertarray[i + orgVerts].x=tmp.x;
            newvertarray[i + orgVerts].y=tmp.y;
        }

        // Extra vertexes read in
        if (vertexes != newvertarray)
        {
          for (i = 0; i < numlines; i++)
          {
            //lines[i].v1 = lines[i].v1 - vertexes + newvertarray;
            //lines[i].v2 = lines[i].v2 - vertexes + newvertarray;
              // Find indexes of v1 & v2 inside old vertexes array
              // (.v1-vertexes) and use that index to re-point inside newvertarray              
              lines[i].v1=newvertarray[C2JUtils.indexOf(vertexes,lines[i].v1)];
              lines[i].v2=newvertarray[C2JUtils.indexOf(vertexes,lines[i].v2)];
          }
          // free(vertexes);
          vertexes = newvertarray;
          numvertexes = orgVerts + newVerts;
        }
      }
      else
      {
        // Skip the reading of all these new vertices and the expensive indexOf searches.
        int size = newVerts * z_vertex_t.sizeOf();
        len=CheckZNodesOverflow(len, size);
        data.position(data.position()+ size);
      }

      // Read the subsectors
      len=CheckZNodesOverflow(len, 4);
      numSubs=data.getInt();

      numsubsectors = numSubs;
      if (numsubsectors <= 0)
        I.Error("P_LoadZNodes: no subsectors in level");
      subsectors = calloc_IfSameLevel(subsectors, numsubsectors,subsector_t.class);

      len=CheckZNodesOverflow(len, numSubs * mapsubsector_znod_t.sizeOf());
      final mapsubsector_znod_t mseg=new mapsubsector_znod_t();
      for (i = currSeg = 0; i < numSubs; i++)
      {
         mseg.unpack(data);

        subsectors[i].firstline = currSeg;
        subsectors[i].numlines = (int) mseg.numsegs;
        currSeg += mseg.numsegs;
      }      

      // Read the segs
      len=CheckZNodesOverflow(len, 4);
      numSegs = data.getInt();

      // The number of segs stored should match the number of
      // segs used by subsectors.
      if (numSegs != currSeg)
      {
        I.Error("P_LoadZNodes: Incorrect number of segs in nodes.");
      }

      numsegs = numSegs;
      segs = calloc_IfSameLevel(segs, numsegs, seg_t.class);

      if (glnodes == 0)
      {
        len=CheckZNodesOverflow(len, numsegs *mapseg_znod_t.sizeOf());
        P_LoadZSegs(data);
      }
      else
      {
        //P_LoadGLZSegs (data, glnodes);
        I.Error("P_LoadZNodes: GL segs are not supported.");
      }

      // Read nodes
      len=CheckZNodesOverflow(len, 4);
      numNodes = data.getInt();      

      numnodes = numNodes;
      nodes = calloc_IfSameLevel(nodes, numNodes, node_t.class);

      len=CheckZNodesOverflow(len, numNodes * mapnode_znod_t.sizeOf());
      
      mapnode_znod_t[] znodes=C2JUtils.createArrayOfObjects(mapnode_znod_t.class, numNodes);
      CacheableDoomObjectContainer.unpack(data,znodes);      
      
      for (i = 0; i < numNodes; i++)
      {
        int j, k;
        node_t no = nodes[i];
        final mapnode_znod_t mn = znodes[i];

        no.x = mn.x << FRACBITS;
        no.y = mn.y << FRACBITS;
        no.dx = mn.dx<< FRACBITS;
        no.dy = mn.dy<< FRACBITS;

        for (j = 0; j < 2; j++)
        {
          no.children[j] = mn.children[j];

          for (k = 0; k < 4; k++)
            no.bbox[j].bbox[k] = mn.bbox[j][k] << FRACBITS;
        }
      }

      W.UnlockLumpNum(lump); // cph - release the data
    }
    
    private boolean no_overlapped_sprites;

    private final int GETXY(mobj_t mobj) {
        return (mobj.x + (mobj.y >> 16));
    }

    private final int dicmp_sprite_by_pos(final Object a, final Object b) {
        mobj_t m1 = (mobj_t) a;
        mobj_t m2 = (mobj_t) b;

        int res = GETXY(m2) - GETXY(m1);
        no_overlapped_sprites = no_overlapped_sprites && (res != 0);
        return res;
    }

    /*
     * P_LoadThings killough 5/3/98: reformatted, cleaned up cph 2001/07/07 -
     * don't write into the lump cache, especially non-idepotent changes like
     * byte order reversals. Take a copy to edit.
     */

    private void P_LoadThings(int lump) {
        int i, numthings = W.LumpLength(lump) / mapthing_t.sizeOf();
        final mapthing_t[] data =
            W.CacheLumpNumIntoArray(lump, numthings, mapthing_t.class);

        mobj_t mobj;
        int mobjcount = 0;
        mobj_t[] mobjlist =
            C2JUtils.createArrayOfObjects(mobj_t.class, numthings);

        if ((data == null) || (numthings == 0))
            I.Error("P_LoadThings: no things in level");

        for (i = 0; i < numthings; i++) {
            mapthing_t mt = data[i];

            /*
             * Not needed. Handled during unmarshaling. mt.x =
             * LittleShort(mt.x); mt.y = LittleShort(mt.y); mt.angle =
             * LittleShort(mt.angle); mt.type = LittleShort(mt.type); mt.options
             * = LittleShort(mt.options);
             */

            if (!P_IsDoomnumAllowed(mt.type))
                continue;

            // Do spawn all other stuff.
            mobj = P.SpawnMapThing(mt/* , i */);
            if (mobj != null && mobj.info.speed == 0)
                mobjlist[mobjcount++] = mobj;
        }

        W.UnlockLumpNum(lump); // cph - release the data
        /*
         * #ifdef GL_DOOM if (V_GetMode() == VID_MODEGL) { no_overlapped_sprites
         * = true; qsort(mobjlist, mobjcount, sizeof(mobjlist[0]),
         * dicmp_sprite_by_pos); if (!no_overlapped_sprites) { i = 1; while (i <
         * mobjcount) { mobj_t *m1 = mobjlist[i - 1]; mobj_t *m2 = mobjlist[i -
         * 0]; if (GETXY(m1) == GETXY(m2)) { mobj_t *mo = (m1.index < m2.index ?
         * m1 : m2); i++; while (i < mobjcount && GETXY(mobjlist[i]) ==
         * GETXY(m1)) { if (mobjlist[i].index < mo.index) { mo = mobjlist[i]; }
         * i++; } // 'nearest' mo.flags |= MF_FOREGROUND; } i++; } } } #endif
         */

    }

    /*
     * P_IsDoomnumAllowed() Based on code taken from P_LoadThings() in
     * src/p_setup.c Return TRUE if the thing in question is expected to be
     * available in the gamemode used.
     */

    boolean P_IsDoomnumAllowed(int doomnum) {
        // Do not spawn cool, new monsters if !commercial
        if (!DM.isCommercial())
            switch (doomnum) {
            case 64: // Archvile
            case 65: // Former Human Commando
            case 66: // Revenant
            case 67: // Mancubus
            case 68: // Arachnotron
            case 69: // Hell Knight
            case 71: // Pain Elemental
            case 84: // Wolf SS
            case 88: // Boss Brain
            case 89: // Boss Shooter
                return false;
            }

        return true;
    }

    //
    // P_LoadLineDefs
    // Also counts secret lines for intermissions.
    // ^^^
    // ??? killough ???
    // Does this mean secrets used to be linedef-based, rather than
    // sector-based?
    //
    // killough 4/4/98: split into two functions, to allow sidedef overloading
    //
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadLineDefs(int lump) {
        final maplinedef_t[] data; // cph - final*
        int i;

        numlines = W.LumpLength(lump) / maplinedef_t.sizeOf();
        lines = calloc_IfSameLevel(lines, numlines, line_t.class);
        data = W.CacheLumpNumIntoArray(lump, numlines, maplinedef_t.class); // cph
                                                                            // -
                                                                            // wad
                                                                            // lump
                                                                            // handling
                                                                            // updated

        for (i = 0; i < numlines; i++) {
            final maplinedef_t mld = data[i];
            line_t ld = lines[i];
            ld.id=i;
            vertex_t v1, v2;

            ld.flags = mld.flags;
            ld.special = mld.special;
            ld.tag = mld.tag;
            v1 = ld.v1 = vertexes[(char) mld.v1];
            v2 = ld.v2 = vertexes[(char) mld.v2];
            ld.dx = v2.x - v1.x;
            ld.dy = v2.y - v1.y;
            // Maes: map value semantics.
            ld.assignVertexValues();

            /*
             * #ifdef GL_DOOM // e6y // Rounding the wall length to the nearest
             * integer // when determining length instead of always rounding
             * down // There is no more glitches on seams between identical
             * textures. ld.texel_length = GetTexelDistance(ld.dx, ld.dy);
             * #endif
             */

            ld.tranlump = -1; // killough 4/11/98: no translucency by default

            ld.slopetype =
                (ld.dx == 0) ? slopetype_t.ST_VERTICAL
                        : (ld.dy == 0) ? slopetype_t.ST_HORIZONTAL
                                : fixed_t.FixedDiv(ld.dy, ld.dx) > 0 ? slopetype_t.ST_POSITIVE
                                        : slopetype_t.ST_NEGATIVE;

            if (v1.x < v2.x) {
                ld.bbox[BBox.BOXLEFT] = v1.x;
                ld.bbox[BBox.BOXRIGHT] = v2.x;
            } else {
                ld.bbox[BBox.BOXLEFT] = v2.x;
                ld.bbox[BBox.BOXRIGHT] = v1.x;
            }
            if (v1.y < v2.y) {
                ld.bbox[BBox.BOXBOTTOM] = v1.y;
                ld.bbox[BBox.BOXTOP] = v2.y;
            } else {
                ld.bbox[BBox.BOXBOTTOM] = v2.y;
                ld.bbox[BBox.BOXTOP] = v1.y;
            }

            /* calculate sound origin of line to be its midpoint */
            // e6y: fix sound origin for large levels
            // no need for comp_sound test, these are only used when comp_sound
            // = 0
            ld.soundorg =
                new degenmobj_t(ld.bbox[BBox.BOXLEFT] / 2
                        + ld.bbox[BBox.BOXRIGHT] / 2, ld.bbox[BBox.BOXTOP] / 2
                        + ld.bbox[BBox.BOXBOTTOM] / 2, 0);

            // TODO
            // ld.iLineID=i; // proff 04/05/2000: needed for OpenGL
            ld.sidenum[0] = mld.sidenum[0];
            ld.sidenum[1] = mld.sidenum[1];

            {
                /*
                 * cph 2006/09/30 - fix sidedef errors right away. cph
                 * 2002/07/20 - these errors are fatal if not fixed, so apply
                 * them in compatibility mode - a desync is better than a crash!
                 */
                int j;

                for (j = 0; j < 2; j++) {
                    if (ld.sidenum[j] != NO_INDEX && ld.sidenum[j] >= numsides) {
                        ld.sidenum[j] = NO_INDEX;
                        System.err
                                .printf(
                                    "P_LoadLineDefs: linedef %d has out-of-range sidedef number\n",
                                    numlines - i - 1);
                    }
                }

                // killough 11/98: fix common wad errors (missing sidedefs):

                if (ld.sidenum[0] == NO_INDEX) {
                    ld.sidenum[0] = 0; // Substitute dummy sidedef for missing
                                       // right side
                    // cph - print a warning about the bug
                    System.err.printf(
                        "P_LoadLineDefs: linedef %d missing first sidedef\n",
                        numlines - i - 1);
                }

                if ((ld.sidenum[1] == NO_INDEX) && flags(ld.flags, ML_TWOSIDED)) {
                    // e6y
                    // ML_TWOSIDED flag shouldn't be cleared for compatibility
                    // purposes
                    // see CLNJ-506.LMP at http://doomedsda.us/wad1005.html
                    // TODO: we don't really care, but still...
                    // if (!demo_compatibility ||
                    // !overflows[OVERFLOW.MISSEDBACKSIDE].emulate)
                    // {
                    ld.flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left
                                              // side
                    // }
                    // Mark such lines and do not draw them only in
                    // demo_compatibility,
                    // because Boom's behaviour is different
                    // See OTTAWAU.WAD E1M1, sectors 226 and 300
                    // http://www.doomworld.com/idgames/index.php?id=1651
                    // TODO ehhh?
                    // ld.r_flags = RF_IGNORE_COMPAT;
                    // cph - print a warning about the bug
                    System.err
                            .printf(
                                "P_LoadLineDefs: linedef %d has two-sided flag set, but no second sidedef\n",
                                numlines - i - 1);
                }
            }

            // killough 4/4/98: support special sidedef interpretation below
            // TODO:
            // if (ld.sidenum[0] != NO_INDEX && ld.special!=0)
            // sides[(ld.sidenum[0]<<16)& (0x0000FFFF&ld.sidenum[1])].special =
            // ld.special;
        }

        W.UnlockLumpNum(lump); // cph - release the lump
    }

    // killough 4/4/98: delay using sidedefs until they are loaded
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadLineDefs2(int lump) {
        line_t ld;

        for (int i = 0; i < numlines; i++) {
            ld = lines[i];
            ld.frontsector = sides[ld.sidenum[0]].sector; // e6y: Can't be
                                                          // NO_INDEX here
            ld.backsector =
                ld.sidenum[1] != NO_INDEX ? sides[ld.sidenum[1]].sector : null;
            switch (ld.special) { // killough 4/11/98: handle special types
            case 260: // killough 4/11/98: translucent 2s textures
                // TODO: transparentpresent = true;//e6y
                // int lmp = sides[ld.getSpecialSidenum()].special; //
                // translucency from sidedef
                // if (!ld.tag) // if tag==0,
                // ld.tranlump = lmp; // affect this linedef only
                // else
                // for (int j=0;j<numlines;j++) // if tag!=0,
                // if (lines[j].tag == ld.tag) // affect all matching linedefs
                // lines[j].tranlump = lump;
                // break;
            }
        }
    }

    //
    // P_LoadSideDefs
    //
    // killough 4/4/98: split into two functions

    private void P_LoadSideDefs(int lump) {
        numsides = W.LumpLength(lump) / mapsidedef_t.sizeOf();
        sides = calloc_IfSameLevel(sides, numsides, side_t.class);
    }

    // killough 4/4/98: delay using texture names until
    // after linedefs are loaded, to allow overloading.
    // killough 5/3/98: reformatted, cleaned up

    private void P_LoadSideDefs2(int lump) {
        // cph - final*, wad lump handling updated
        final mapsidedef_t[] data =
            W.CacheLumpNumIntoArray(lump, numsides, mapsidedef_t.class);
        int i;

        for (i = 0; i < numsides; i++) {
            final mapsidedef_t msd = data[i];
            side_t sd = sides[i];
            sector_t sec;

            sd.textureoffset = msd.textureoffset << FRACBITS;
            sd.rowoffset = msd.rowoffset << FRACBITS;

            { /*
               * cph 2006/09/30 - catch out-of-range sector numbers; use sector
               * 0 instead
               */
                char sector_num = (char) msd.sector;
                if (sector_num >= numsectors) {
                    System.err
                            .printf(
                                "P_LoadSideDefs2: sidedef %i has out-of-range sector num %u\n",
                                i, sector_num);
                    sector_num = 0;
                }
                sd.sector = sec = sectors[sector_num];
            }

            // killough 4/4/98: allow sidedef texture names to be overloaded
            // killough 4/11/98: refined to allow colormaps to work as wall
            // textures if invalid as colormaps but valid as textures.
            switch (sd.special) {
            case 242: // variable colormap via 242 linedef
                /*
                 * sd.bottomtexture = (sec.bottommap =
                 * R.ColormapNumForName(msd.bottomtexture)) < 0 ? sec.bottommap
                 * = 0, R.TextureNumForName(msd.bottomtexture): 0 ;
                 * sd.midtexture = (sec.midmap =
                 * R.ColormapNumForName(msd.midtexture)) < 0 ? sec.midmap = 0,
                 * R.TextureNumForName(msd.midtexture) : 0 ; sd.toptexture =
                 * (sec.topmap = R.ColormapNumForName(msd.toptexture)) < 0 ?
                 * sec.topmap = 0, R.TextureNumForName(msd.toptexture) : 0 ;
                 */

                break;

            case 260: // killough 4/11/98: apply translucency to 2s normal
                      // texture
                if (msd.midtexture.compareToIgnoreCase("TRANMAP") == 0) {
                    if ((sd.special = W.CheckNumForName(msd.midtexture)) < 0
                            || W.LumpLength(sd.special) != 65536) {
                        sd.special = 0;
                        sd.midtexture =
                            (short) TM.TextureNumForName(msd.midtexture);
                    } else {
                        sd.special++;
                        sd.midtexture = 0;
                    }
                } else
                    sd.midtexture = (short) (sd.special = 0);
                sd.toptexture = (short) TM.TextureNumForName(msd.toptexture);
                sd.bottomtexture =
                    (short) TM.TextureNumForName(msd.bottomtexture);
                break;

            /*
             * #ifdef GL_DOOM case 271: case 272: if
             * (R_CheckTextureNumForName(msd.toptexture) == -1) {
             * sd.skybox_index = R_BoxSkyboxNumForName(msd.toptexture); } #endif
             */

            default: // normal cases
                // TODO: Boom uses "SafeTextureNumForName" here. Find out what
                // it does.
                sd.midtexture =
                    (short) TM.CheckTextureNumForName(msd.midtexture);
                sd.toptexture =
                    (short) TM.CheckTextureNumForName(msd.toptexture);
                sd.bottomtexture =
                    (short) TM.CheckTextureNumForName(msd.bottomtexture);
                break;
            }
        }

        W.UnlockLumpNum(lump); // cph - release the lump
    }

    //
    // P_LoadBlockMap
    //
    // killough 3/1/98: substantially modified to work
    // towards removing blockmap limit (a wad limitation)
    //
    // killough 3/30/98: Rewritten to remove blockmap limit,
    // though current algorithm is brute-force and unoptimal.
    //

    private void P_LoadBlockMap(int lump)
            throws IOException {
        int count = 0;

        if (DM.CM.CheckParmBool("-blockmap") || W.LumpLength(lump) < 8
                || (count = W.LumpLength(lump) / 2) >= 0x10000) // e6y
            CreateBlockMap();
        else {
            int i;
            // cph - final*, wad lump handling updated
            final char[] wadblockmaplump;

            DoomBuffer data =
                (DoomBuffer) W.CacheLumpNum(lump, PU_LEVEL, DoomBuffer.class);
            count = W.LumpLength(lump) / 2;
            wadblockmaplump = new char[count];

            data.setOrder(ByteOrder.LITTLE_ENDIAN);
            data.rewind();
            data.readCharArray(wadblockmaplump, count);

            if (!samelevel) // Reallocate if required.
                blockmaplump = new int[count];

            // killough 3/1/98: Expand wad blockmap into larger internal one,
            // by treating all offsets except -1 as unsigned and zero-extending
            // them. This potentially doubles the size of blockmaps allowed,
            // because Doom originally considered the offsets as always signed.

            blockmaplump[0] = wadblockmaplump[0];
            blockmaplump[1] = wadblockmaplump[1];
            blockmaplump[2] = (int) (wadblockmaplump[2] & 0xffff);
            blockmaplump[3] = (int) (wadblockmaplump[3] & 0xffff);

            for (i = 4; i < count; i++) {
                short t = (short) wadblockmaplump[i]; // killough 3/1/98
                blockmaplump[i] = (int) (t == -1 ? -1l : t & 0xffff);
            }

            W.UnlockLumpNum(lump); // cph - unlock the lump

            bmaporgx = blockmaplump[0] << FRACBITS;
            bmaporgy = blockmaplump[1] << FRACBITS;
            bmapwidth = blockmaplump[2];
            bmapheight = blockmaplump[3];

            // haleyjd 03/04/10: check for blockmap problems
            // http://www.doomworld.com/idgames/index.php?id=12935
            if (!VerifyBlockMap(count)) {
                System.err
                        .printf("P_LoadBlockMap: erroneous BLOCKMAP lump may cause crashes.\n");
                System.err
                        .printf("P_LoadBlockMap: use \"-blockmap\" command line switch for rebuilding\n");
            }
        }

        // MAES: blockmap was generated, rather than loaded.
        if (count == 0)
            count = blockmaplump.length - 4;

        // clear out mobj chains - CPhipps - use calloc
        // blocklinks = calloc_IfSameLevel(blocklinks, bmapwidth *
        // bmapheight.mobj_t.);
        // clear out mobj chains
        // ATTENTION! BUG!!!
        // If blocklinks are "cleared" to void -but instantiated- objects,
        // very bad bugs happen, especially the second time a level is
        // re-instantiated.
        // Probably caused other bugs as well, as an extra object would appear
        // in iterators.

        if (blocklinks != null && samelevel)
            for (int i = 0; i < bmapwidth * bmapheight; i++)
                blocklinks[i] = null;
        else
            blocklinks = new mobj_t[bmapwidth * bmapheight];

        // IMPORTANT MODIFICATION: no need to have both blockmaplump AND
        // blockmap.
        // If the offsets in the lump are OK, then we can modify them (remove 4)
        // and copy the rest of the data in one single data array. This avoids
        // reserving memory for two arrays (we can't simply alias one in Java)

        blockmap = new int[blockmaplump.length - 4];
        count = bmapwidth * bmapheight;
        // Offsets are relative to START OF BLOCKMAP, and IN SHORTS, not bytes.
        for (int i = 0; i < blockmaplump.length - 4; i++) {
            // Modify indexes so that we don't need two different lumps.
            // Can probably be further optimized if we simply shift everything
            // backwards.
            // and reuse the same memory space.
            if (i < count)
                blockmaplump[i] = blockmaplump[i + 4] - 4;
            else
                blockmaplump[i] = blockmaplump[i + 4];
        }

        
        // MAES: set blockmapxneg and blockmapyneg
        // E.g. for a full 512x512 map, they should be both
        // -1. For a 257*257, they should be both -255 etc.
        if (bmapwidth>255)
            blockmapxneg= bmapwidth-512;
        if (bmapheight>255)
            blockmapyneg= bmapheight-512;
        
        blockmap = blockmaplump;

    }

    //
    // P_LoadReject - load the reject table
    //

    private void P_LoadReject(int lumpnum, int totallines) {
        // dump any old cached reject lump, then cache the new one
        if (rejectlump != -1)
            W.UnlockLumpNum(rejectlump);
        rejectlump = lumpnum + ML_REJECT;
        rejectmatrix = W.CacheLumpNumAsRawBytes(rejectlump, 0);

        // e6y: check for overflow
        // TODO: g.Overflow.RejectOverrun(rejectlump, rejectmatrix,
        // totallines,numsectors);
    }

    //
    // P_GroupLines
    // Builds sector line lists and subsector sector numbers.
    // Finds block bounding boxes for sectors.
    //
    // killough 5/3/98: reformatted, cleaned up
    // cph 18/8/99: rewritten to avoid O(numlines * numsectors) section
    // It makes things more complicated, but saves seconds on big levels
    // figgi 09/18/00 -- adapted for gl-nodes

    
    // modified to return totallines (needed by P_LoadReject)
    private int P_GroupLines() {
        line_t li;
        sector_t sector;
        int i, j, total = numlines;

        // figgi
        for (i = 0; i < numsubsectors; i++) {
            int seg = subsectors[i].firstline;
            subsectors[i].sector = null;
            for (j = 0; j < subsectors[i].numlines; j++) {
                if (segs[seg].sidedef != null) {
                    subsectors[i].sector = segs[seg].sidedef.sector;
                    break;
                }
                seg++;
            }
            if (subsectors[i].sector == null)
                I.Error("P_GroupLines: Subsector a part of no sector!\n");
        }

        // count number of lines in each sector
        for (i = 0; i < numlines; i++) {
            li = lines[i];
            li.frontsector.linecount++;
            if (li.backsector != null && (li.backsector != li.frontsector)) {
                li.backsector.linecount++;
                total++;
            }
        }

         // allocate line tables for each sector
          // line_t[] linebuffer =
          // C2JUtils.createArrayOfObjects(line_t.class,total);
          // e6y: REJECT overrun emulation code
          // moved to P_LoadReject

            for (i = 0; i < numsectors; i++) {
                sector = sectors[i];
                sector.lines =
                    C2JUtils.createArrayOfObjects(line_t.class,
                        sector.linecount);
                // linebuffer += sector.linecount;
                sector.linecount = 0;
                BBox.ClearBox(sector.blockbox);
            }
        

        // Enter those lines
        for (i = 0; i < numlines; i++) {
            li = lines[i];
            AddLineToSector(li, li.frontsector);
            if (li.backsector != null && li.backsector != li.frontsector)
                AddLineToSector(li, li.backsector);
        }

        for (i = 0; i < numsectors; i++) {
            sector = sectors[i];
            int[] bbox = sector.blockbox; // cph - For convenience, so
                                          // I can sue the old code unchanged
            int block;

            // set the degenmobj_t to the middle of the bounding box
            // TODO
            if (true/* comp[comp_sound] */) {
                sector.soundorg =
                    new degenmobj_t((bbox[BOXRIGHT] + bbox[BOXLEFT]) / 2,
                            (bbox[BOXTOP] + bbox[BOXBOTTOM]) / 2);
            } else {
                // e6y: fix sound origin for large levels
                sector.soundorg =
                    new degenmobj_t((bbox[BOXRIGHT] / 2 + bbox[BOXLEFT] / 2),
                            bbox[BOXTOP] / 2 + bbox[BOXBOTTOM] / 2);
            }

            // adjust bounding box to map blocks
            block =getSafeBlockY(bbox[BOXTOP] - bmaporgy + Limits.MAXRADIUS);
            block = block >= bmapheight ? bmapheight - 1 : block;
            sector.blockbox[BOXTOP] = block;

            block =getSafeBlockY(bbox[BOXBOTTOM] - bmaporgy - Limits.MAXRADIUS);
            block = block < 0 ? 0 : block;
            sector.blockbox[BOXBOTTOM] = block;

            block =getSafeBlockX(bbox[BOXRIGHT] - bmaporgx + Limits.MAXRADIUS);
            block = block >= bmapwidth ? bmapwidth - 1 : block;
            sector.blockbox[BOXRIGHT] = block;

            block =getSafeBlockX(bbox[BOXLEFT] - bmaporgx - Limits.MAXRADIUS);
            block = block < 0 ? 0 : block;
            sector.blockbox[BOXLEFT] = block;
        }

        return total; // this value is needed by the reject overrun emulation
                      // code
    }

    //
    // killough 10/98
    //
    // Remove slime trails.
    //
    // Slime trails are inherent to Doom's coordinate system -- i.e. there is
    // nothing that a node builder can do to prevent slime trails ALL of the
    // time,
    // because it's a product of the integer coodinate system, and just because
    // two lines pass through exact integer coordinates, doesn't necessarily
    // mean
    // that they will intersect at integer coordinates. Thus we must allow for
    // fractional coordinates if we are to be able to split segs with node
    // lines,
    // as a node builder must do when creating a BSP tree.
    //
    // A wad file does not allow fractional coordinates, so node builders are
    // out
    // of luck except that they can try to limit the number of splits (they
    // might
    // also be able to detect the degree of roundoff error and try to avoid
    // splits
    // with a high degree of roundoff error). But we can use fractional
    // coordinates
    // here, inside the engine. It's like the difference between square inches
    // and
    // square miles, in terms of granularity.
    //
    // For each vertex of every seg, check to see whether it's also a vertex of
    // the linedef associated with the seg (i.e, it's an endpoint). If it's not
    // an endpoint, and it wasn't already moved, move the vertex towards the
    // linedef by projecting it using the law of cosines. Formula:
    //
    // 2 2 2 2
    // dx x0 + dy x1 + dx dy (y0 - y1) dy y0 + dx y1 + dx dy (x0 - x1)
    // {---------------------------------, ---------------------------------}
    // 2 2 2 2
    // dx + dy dx + dy
    //
    // (x0,y0) is the vertex being moved, and (x1,y1)-(x1+dx,y1+dy) is the
    // reference linedef.
    //
    // Segs corresponding to orthogonal linedefs (exactly vertical or horizontal
    // linedefs), which comprise at least half of all linedefs in most wads,
    // don't
    // need to be considered, because they almost never contribute to slime
    // trails
    // (because then any roundoff error is parallel to the linedef, which
    // doesn't
    // cause slime). Skipping simple orthogonal lines lets the code finish
    // quicker.
    //
    // Please note: This section of code is not interchangable with TeamTNT's
    // code which attempts to fix the same problem.
    //
    // Firelines (TM) is a Rezistered Trademark of MBF Productions
    //

    private void P_RemoveSlimeTrails() // killough 10/98
    {
        // Hitlist for vertices
        boolean[] hit = new boolean[numvertexes];

        // Searchlist for

        int i;
        for (i = 0; i < numsegs; i++) // Go through each seg
        {
            final line_t l;

            if (segs[i].miniseg == true) // figgi -- skip minisegs
                return;

            l = segs[i].linedef; // The parent linedef
            if (l.dx != 0 && l.dy != 0) // We can ignore orthogonal lines
            {
                vertex_t v = segs[i].v1;
                do {
                    int index = C2JUtils.indexOf(vertexes, v);
                    if (!hit[index]) // If we haven't processed vertex
                    {
                        hit[index] = true; // Mark this vertex as processed
                        if (v != l.v1 && v != l.v2) // Exclude endpoints of
                                                    // linedefs
                        { // Project the vertex back onto the parent linedef
                            long dx2 = (l.dx >> FRACBITS) * (l.dx >> FRACBITS);
                            long dy2 = (l.dy >> FRACBITS) * (l.dy >> FRACBITS);
                            long dxy = (l.dx >> FRACBITS) * (l.dy >> FRACBITS);
                            long s = dx2 + dy2;
                            int x0 = v.x, y0 = v.y, x1 = l.v1.x, y1 = l.v1.y;
                            v.x =
                                (int) ((dx2 * x0 + dy2 * x1 + dxy * (y0 - y1)) / s);
                            v.y =
                                (int) ((dy2 * y0 + dx2 * y1 + dxy * (x0 - x1)) / s);
                        }
                    } // Obsfucated C contest entry: :)
                } while ((v != segs[i].v2) && ((v = segs[i].v2) != null));
            }
            // Assign modified vertex values.
            l.assignVertexValues();
        }
    }

    //
    // P_CheckLumpsForSameSource
    //
    // Are these lumps in the same wad file?
    //

    boolean P_CheckLumpsForSameSource(int lump1, int lump2) {
        int wad1_index, wad2_index;
        wadfile_info_t wad1, wad2;

        if ((unsigned(lump1) >= unsigned(W.NumLumps()))
                || (unsigned(lump2) >= unsigned(W.NumLumps())))
            return false;

        wad1 = W.GetLumpInfo(lump1).wadfile;
        wad2 = W.GetLumpInfo(lump2).wadfile;

        if (wad1 == null || wad2 == null)
            return false;

        wad1_index = W.GetWadfileIndex(wad1);
        wad2_index = W.GetWadfileIndex(wad2);

        if (wad1_index != wad2_index)
            return false;

        if ((wad1_index < 0) || (wad1_index >= W.GetNumWadfiles()))
            return false;

        if ((wad2_index < 0) || (wad2_index >= W.GetNumWadfiles()))
            return false;

        return true;
    }

    private static final String[] ml_labels = { "ML_LABEL", // A separator,
                                                            // name, ExMx or
                                                            // MAPxx
            "ML_THINGS", // Monsters, items..
            "ML_LINEDEFS", // LineDefs, from editing
            "ML_SIDEDEFS", // SideDefs, from editing
            "ML_VERTEXES", // Vertices, edited and BSP splits generated
            "ML_SEGS", // LineSegs, from LineDefs split by BSP
            "ML_SSECTORS", // SubSectors, list of LineSegs
            "ML_NODES", // BSP nodes
            "ML_SECTORS", // Sectors, from editing
            "ML_REJECT", // LUT, sector-sector visibility
            "ML_BLOCKMAP", // LUT, motion clipping, walls/grid element
    };

    private static final boolean GL_DOOM = false;

    //
    // P_CheckLevelFormat
    //
    // Checking for presence of necessary lumps
    //

    void P_CheckLevelWadStructure(final String mapname) {
        int i, lumpnum;

        if (mapname == null) {
            I.Error("P_SetupLevel: Wrong map name");
        }

        lumpnum = W.CheckNumForName(mapname.toUpperCase());

        if (lumpnum < 0) {
            I.Error("P_SetupLevel: There is no %s map.", mapname);
        }

        for (i = ML_THINGS + 1; i <= ML_SECTORS; i++) {
            if (!P_CheckLumpsForSameSource(lumpnum, lumpnum + i)) {
                I.Error(
                    "P_SetupLevel: Level wad structure is incomplete. There is no %s lump. (%s)",
                    ml_labels[i], W.GetNameForLump(lumpnum));
            }
        }

        // refuse to load Hexen-format maps, avoid segfaults
        i = lumpnum + ML_BLOCKMAP + 1;
        if (P_CheckLumpsForSameSource(lumpnum, i)) {
            if (W.GetLumpInfo(i).name.compareToIgnoreCase("BEHAVIOR") == 0) {
                I.Error("P_SetupLevel: %s: Hexen format not supported", mapname);
            }
        }
    }

    //
    // P_SetupLevel
    //
    // killough 5/3/98: reformatted, cleaned up

    public void SetupLevel(int episode, int map, int playermask, skill_t skill)
            throws IOException {
        int i;
        String lumpname;
        int lumpnum;

        String gl_lumpname;
        int gl_lumpnum;

        // e6y
        DM.totallive = 0;
        // TODO: transparentpresent = false;

        // R_StopAllInterpolations();

        DM.totallive =
            DM.totalkills =
                DM.totalitems = DM.totalsecret = DM.wminfo.maxfrags = 0;
        DM.wminfo.partime = 180;

        for (i = 0; i < Limits.MAXPLAYERS; i++) {
            DM.players[i].killcount =
                DM.players[i].secretcount = DM.players[i].itemcount = 0;
            // TODO DM.players[i].resurectedkillcount = 0;//e6y
        }

        // Initial height of PointOfView will be set by player think.
        DM.players[DM.consoleplayer].viewz = 1;

        // Make sure all sounds are stopped before Z_FreeTags.
        S.Start();

        // Z_FreeTags(PU_LEVEL, PU_PURGELEVEL-1);
        if (rejectlump != -1) { // cph - unlock the reject table
            W.UnlockLumpNum(rejectlump);
            rejectlump = -1;
        }

        P.InitThinkers();

        // if working with a devlopment map, reload it
        // W.Reload (); killough 1/31/98: W.Reload obsolete

        // find map name
        if (DM.isCommercial()) {
            lumpname = String.format("map%02d", map); // killough 1/24/98:
                                                      // simplify
            gl_lumpname = String.format("gl_map%02d", map); // figgi
        } else {
            lumpname = String.format("E%dM%d", episode, map); // killough
                                                              // 1/24/98:
                                                              // simplify
            gl_lumpname = String.format("GL_E%dM%d", episode, map); // figgi
        }

        lumpnum = W.GetNumForName(lumpname);
        gl_lumpnum = W.CheckNumForName(gl_lumpname); // figgi

        // e6y
        // Refuse to load a map with incomplete pwad structure.
        // Avoid segfaults on levels without nodes.
        P_CheckLevelWadStructure(lumpname);

        DM.leveltime = 0;
        DM.totallive = 0;

        // note: most of this ordering is important

        // killough 3/1/98: P_LoadBlockMap call moved down to below
        // killough 4/4/98: split load of sidedefs into two parts,
        // to allow texture names to be used in special linedefs

        // figgi 10/19/00 -- check for gl lumps and load them
        P_GetNodesVersion(lumpnum, gl_lumpnum);

        // e6y: speedup of level reloading
        // Most of level's structures now are allocated with PU_STATIC instead
        // of PU_LEVEL
        // It is important for OpenGL, because in case of the same data in
        // memory
        // we can skip recalculation of much stuff

        samelevel =
            (map == current_map) && (episode == current_episode)
                    && (nodesVersion == current_nodesVersion);

        current_episode = episode;
        current_map = map;
        current_nodesVersion = nodesVersion;

        if (!samelevel) {

            /*
             * if (GL_DOOM){ // proff 11/99: clean the memory from textures etc.
             * gld_CleanMemory(); }
             */

            // free(segs);
            // free(nodes);
            // free(subsectors);
            /*
             * #ifdef GL_DOOM free(map_subsectors); #endif
             */

            // free(blocklinks);
            // free(blockmaplump);

            // free(lines);
            // free(sides);
            // free(sectors);
            // free(vertexes);
        }

        if (nodesVersion > 0)
            this.P_LoadVertexes2(lumpnum + ML_VERTEXES, gl_lumpnum
                    + ML_GL_VERTS);
        else
            P_LoadVertexes(lumpnum + ML_VERTEXES);
        P_LoadSectors(lumpnum + ML_SECTORS);
        P_LoadSideDefs(lumpnum + ML_SIDEDEFS);
        P_LoadLineDefs(lumpnum + ML_LINEDEFS);
        P_LoadSideDefs2(lumpnum + ML_SIDEDEFS);
        P_LoadLineDefs2(lumpnum + ML_LINEDEFS);

        // e6y: speedup of level reloading
        // Do not reload BlockMap for same level,
        // because in case of big level P_CreateBlockMap eats much time
        if (!samelevel) {
            P_LoadBlockMap(lumpnum + ML_BLOCKMAP);
        } else {
            // clear out mobj chains
            if (blocklinks != null
                    && blocklinks.length == bmapwidth * bmapheight) {
                for (i = 0; i < bmapwidth * bmapheight; i++) {
                    blocklinks[i] = null;
                }
            } else
                blocklinks =
                    C2JUtils.createArrayOfObjects(mobj_t.class, bmapwidth
                            * bmapheight);
        }

        if (nodesVersion > 0) {
            P_LoadSubsectors(gl_lumpnum + ML_GL_SSECT);
            P_LoadNodes(gl_lumpnum + ML_GL_NODES);
            // TODO: P_LoadGLSegs(gl_lumpnum + ML_GL_SEGS);
        } else {
            if (P_CheckForZDoomUncompressedNodes(lumpnum, gl_lumpnum)) {
                P_LoadZNodes(lumpnum + ML_NODES, 0);
            } else if (P_CheckForDeePBSPv4Nodes(lumpnum, gl_lumpnum)) {
                P_LoadSubsectors_V4(lumpnum + ML_SSECTORS);
                P_LoadNodes_V4(lumpnum + ML_NODES);
                P_LoadSegs_V4(lumpnum + ML_SEGS);
            } else {
                P_LoadSubsectors(lumpnum + ML_SSECTORS);
                P_LoadNodes(lumpnum + ML_NODES);
                P_LoadSegs(lumpnum + ML_SEGS);
            }
        }

        /*
         * if (GL_DOOM){ map_subsectors = calloc_IfSameLevel(map_subsectors,
         * numsubsectors); }
         */

        // reject loading and underflow padding separated out into new function
        // P_GroupLines modified to return a number the underflow padding needs
        // P_LoadReject(lumpnum, P_GroupLines());
        P_GroupLines();
        super.LoadReject(lumpnum+ML_REJECT);

        // e6y
        // Correction of desync on dv04-423.lmp/dv.wad
        // http://www.doomworld.com/vb/showthread.php?s=&postid=627257#post627257
        // if (DoomStatus.compatibility_level>=lxdoom_1_compatibility ||
        // Compatibility.prboom_comp[PC.PC_REMOVE_SLIME_TRAILS.ordinal()].state)
        P_RemoveSlimeTrails(); // killough 10/98: remove slime trails from wad

        // Note: you don't need to clear player queue slots --
        // a much simpler fix is in g_game.c -- killough 10/98

        DM.bodyqueslot = 0;

        /* cph - reset all multiplayer starts */

        for (i = 0; i < playerstarts.length; i++) {
            DM.playerstarts[i] = null;
        }

        deathmatch_p = 0;

        for (i = 0; i < Limits.MAXPLAYERS; i++)
            DM.players[i].mo = null;
        // TODO: TracerClearStarts();

        // Hmm? P_MapStart();

        P_LoadThings(lumpnum + ML_THINGS);

        // if deathmatch, randomly spawn the active players
        if (DM.deathmatch) {
            for (i = 0; i < Limits.MAXPLAYERS; i++)
                if (DM.playeringame[i]) {
                    DM.players[i].mo = null; // not needed? - done before
                                             // P_LoadThings
                    DM.DG.DeathMatchSpawnPlayer(i);
                }
        } else // if !deathmatch, check all necessary player starts actually
               // exist
        {
            for (i = 0; i < Limits.MAXPLAYERS; i++)
                if (DM.playeringame[i] && !C2JUtils.eval(DM.players[i].mo))
                    I.Error("P_SetupLevel: missing player %d start\n", i + 1);
        }

        // killough 3/26/98: Spawn icon landings:
        // TODO: if (DM.isCommercial())
        // P.SpawnBrainTargets();

        if (!DM.isShareware()) {
            // TODO: S.ParseMusInfo(lumpname);
        }

        // clear special respawning que
        P.iquehead = P.iquetail = 0;

        // set up world state
        P.SpawnSpecials();

        // TODO: P.MapEnd();

        // preload graphics
        if (DM.precache)
            TM.PrecacheLevel();

        // MAES: thinkers are separate than texture management. Maybe split
        // sprite management as well?
        R.PreCacheThinkers();

        /*
         * if (GL_DOOM){ if (V_GetMode() == VID_MODEGL) { // e6y // Do not
         * preprocess GL data during skipping, // because it potentially will
         * not be used. // But preprocessing must be called immediately after
         * stop of skipping. if (!doSkip) { // proff 11/99: calculate all OpenGL
         * specific tables etc. gld_PreprocessLevel(); } } }
         */
        // e6y
        // TODO P_SyncWalkcam(true, true);
        // TODO R_SmoothPlaying_Reset(NULL);
    }

}

package p;

public enum sd_e {
	    sd_opening,
	    sd_waiting,
	    sd_closing
	}
package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import rr.SectorAction;
import rr.sector_t;
import w.DoomIO;
import w.IReadableDoomObject;

public class plat_t extends SectorAction implements IReadableDoomObject{
        
        public sector_t   sector;
        /** fixed_t */
        public int speed,low,high;
        int     wait;
        int     count;
        public plat_e  status;
        public plat_e  oldstatus;
        boolean crush;
        public int     tag;
        public plattype_e  type;
        
        public plat_t (){
        	// These must never be null so they get the lowest ordinal value.
        	// by default.
        	this.status=plat_e.up;
        	this.oldstatus=plat_e.up;
        }
        
        @Override
        public void read(DataInputStream f) throws IOException{

            super.read(f); // Call thinker reader first            
            super.sectorid=DoomIO.readLEInt(f); // Sector index
            speed=DoomIO.readLEInt(f);
            low=DoomIO.readLEInt(f);
            high=DoomIO.readLEInt(f);
            wait=DoomIO.readLEInt(f);
            count=DoomIO.readLEInt(f);
            status=plat_e.values()[DoomIO.readLEInt(f)];
            oldstatus=plat_e.values()[DoomIO.readLEInt(f)];
            System.out.println(status);
            System.out.println(oldstatus);
            crush=DoomIO.readIntBoolean(f);
            tag=DoomIO.readLEInt(f);
            type=plattype_e.values()[DoomIO.readLEInt(f)];        
            }
        
        @Override
        public void pack(ByteBuffer b) throws IOException{
            super.pack(b); //12            
            b.putInt(super.sectorid); // 16
            b.putInt(speed);//20
            b.putInt(low); // 24
            b.putInt(high); //28
            b.putInt(wait); //32
            b.putInt(count); //36
            b.putInt(status.ordinal()); //40
            b.putInt(oldstatus.ordinal()); //44
            System.out.println(status);
            System.out.println(oldstatus);
            b.putInt(crush?1:0); // 48
            b.putInt(tag); // 52
            b.putInt(type.ordinal()); // 56
        }
        
        public vldoor_t asVlDoor(sector_t[] sectors){
        	/*
        	typedef struct
        	{
        	    thinker_t	thinker;
        	    vldoor_e	type;
        	    sector_t*	sector;
        	    fixed_t	topheight;
        	    fixed_t	speed;

        	    // 1 = up, 0 = waiting at top, -1 = down
        	    int             direction;
        	    
        	    // tics to wait at the top
        	    int             topwait;
        	    // (keep in case a door going down is reset)
        	    // when it reaches 0, start going down
        	    int             topcountdown;
        	    
        	} vldoor_t;
        	*/
        	
        	vldoor_t tmp=new vldoor_t();
        	tmp.next=this.next;
        	tmp.prev=this.prev;
        	tmp.function=this.function;
        	tmp.type=vldoor_e.values()[sector.id%vldoor_e.VALUES];
        	tmp.sector=sectors[this.speed%sectors.length];
        	tmp.topheight=this.low;
        	tmp.speed=this.high;
        	tmp.direction=this.wait;
        	tmp.topwait=this.count;
        	tmp.topcountdown=this.status.ordinal();

        	
        	return tmp;
        }
        
    } 
package p;

public class slidename_t {

	public slidename_t() {

	}

	public slidename_t(String frontFrame1, String frontFrame2,
			String frontFrame3, String frontFrame4, String backFrame1,
			String backFrame2, String backFrame3, String backFrame4) {
		this.frontFrame1 = frontFrame1;
		this.frontFrame2 = frontFrame2;
		this.frontFrame3 = frontFrame3;
		this.frontFrame4 = frontFrame4;
		this.backFrame1 = backFrame1;
		this.backFrame2 = backFrame2;
		this.backFrame3 = backFrame3;
		this.backFrame4 = backFrame4;
	}

	String frontFrame1;
	String frontFrame2;
	String frontFrame3;
	String frontFrame4;
	String backFrame1;
	String backFrame2;
	String backFrame3;
	String backFrame4;

}
package p;

//
// P_DOORS
//

public enum vldoor_e {
     normal,
     close30ThenOpen,
     close,
     open,
     raiseIn5Mins,
     blazeRaise,
     blazeOpen,
     blazeClose;
     
     public static final int VALUES=vldoor_e.values().length;
 }
package p;

import doom.thinker_t;

/** Generic single-thinker argument action function. 
 *  Useful for handling stuff such as sector actions, doors, etc.
 *  or special thinker objects that don't qualify as mobj_t's.
 * 
 * @author velktron
 *
 * @param <T>
 */

public interface ActionTypeSS<T extends thinker_t>{
	public void invoke (T a);
}
package p;

import static rr.line_t.*;
import static data.Defines.ITEMQUESIZE;
import static data.Defines.MELEERANGE;
import static data.Defines.NF_SUBSECTOR;
import static data.Defines.NUMAMMO;
import static data.Defines.RANGECHECK;
import static data.Defines.pw_allmap;
import static data.Defines.pw_infrared;
import static data.Defines.pw_invisibility;
import static data.Defines.pw_invulnerability;
import static data.Defines.pw_ironfeet;
import static data.Defines.pw_strength;
import static data.Limits.BUTTONTIME;
import static data.Limits.MAXANIMS;
import static data.Limits.MAXBUTTONS;
import static data.Limits.MAXINT;
import static data.Limits.MAXINTERCEPTS;
import static data.Limits.MAXSPECIALCROSS;
import static data.Limits.MAXSWITCHES;
import static data.Limits.PLATSPEED;
import static data.Limits.PLATWAIT;
import static data.Tables.ANG270;
import static data.Tables.ANG90;
import static data.Tables.BITS32;
import static data.info.mobjinfo;
import static data.info.states;
import static doom.englsh.GOTARMBONUS;
import static doom.englsh.GOTARMOR;
import static doom.englsh.GOTBACKPACK;
import static doom.englsh.GOTBERSERK;
import static doom.englsh.GOTBFG9000;
import static doom.englsh.GOTBLUECARD;
import static doom.englsh.GOTBLUESKUL;
import static doom.englsh.GOTCELL;
import static doom.englsh.GOTCELLBOX;
import static doom.englsh.GOTCHAINGUN;
import static doom.englsh.GOTCHAINSAW;
import static doom.englsh.GOTCLIP;
import static doom.englsh.GOTCLIPBOX;
import static doom.englsh.GOTHTHBONUS;
import static doom.englsh.GOTINVIS;
import static doom.englsh.GOTINVUL;
import static doom.englsh.GOTLAUNCHER;
import static doom.englsh.GOTMAP;
import static doom.englsh.GOTMEDIKIT;
import static doom.englsh.GOTMEDINEED;
import static doom.englsh.GOTMEGA;
import static doom.englsh.GOTMSPHERE;
import static doom.englsh.GOTPLASMA;
import static doom.englsh.GOTREDCARD;
import static doom.englsh.GOTREDSKULL;
import static doom.englsh.GOTROCKBOX;
import static doom.englsh.GOTROCKET;
import static doom.englsh.GOTSHELLBOX;
import static doom.englsh.GOTSHELLS;
import static doom.englsh.GOTSHOTGUN;
import static doom.englsh.GOTSHOTGUN2;
import static doom.englsh.GOTSTIM;
import static doom.englsh.GOTSUIT;
import static doom.englsh.GOTSUPER;
import static doom.englsh.GOTVISOR;
import static doom.englsh.GOTYELWCARD;
import static doom.englsh.GOTYELWSKUL;
import static doom.items.weaponinfo;
import static m.fixed_t.FRACUNIT;
import static m.fixed_t.MAPFRACUNIT;
import static m.fixed_t.FixedDiv;
import static p.DoorDefines.SLOWDARK;
import static p.MapUtils.AproxDistance;
import static p.MapUtils.InterceptVector;
import static p.MobjFlags.*;
import static utils.C2JUtils.eval;
import static utils.C2JUtils.flags;
import java.util.Arrays;

import hu.HU;
import i.DoomStatusAware;
import i.IDoomSystem;
import m.IRandom;
import rr.ISpriteManager;
import rr.Renderer;
import rr.TextureManager;
import rr.line_t;
import rr.node_t;
import rr.sector_t;
import rr.side_t;
import rr.subsector_t;
import s.IDoomSound;
import st.StatusBar;
import utils.C2JUtils;
import w.IWadLoader;
import automap.IAutoMap;
import data.Limits;
import data.mapthing_t;
import data.mobjtype_t;
import data.state_t;
import data.sounds.sfxenum_t;
import defines.ammotype_t;
import defines.card_t;
import defines.statenum_t;
import doom.DoomMain;
import doom.DoomStatus;
import doom.IDoomGame;
import doom.player_t;
import doom.th_class;
import doom.think_t;
import doom.thinker_t;
import doom.weapontype_t;

// // FROM SIGHT

public abstract class UnifiedGameMap implements ThinkerList,DoomStatusAware{
    
    
    public UnifiedGameMap(DoomStatus<?,?> DS){
        this.SW=new Switches();
        this.LEV=new Lights();
        this.SPECS=new Specials();
        this.PEV=new Plats();
        this.See=new Sight(); // Didn't initialize that.
        this.EN=new Enemies();
        this.thinkercap=new thinker_t();
        for (int i=0; i<th_class.NUMTHCLASS; i++)  // killough 8/29/98: initialize threaded lists
            thinkerclasscap[i]=new thinker_t();
        
        this.RemoveThinkerDelayed=new P_RemoveThinkerDelayed();
        
        intercepts = new intercept_t[MAXINTERCEPTS];
        C2JUtils.initArrayOfObjects(intercepts,intercept_t.class);

        this.updateStatus(DS);
        // Normally unused. It clashes with line attribute 124, and looks like ass
        // anyway. However it's fully implemented.
        //this.SL=new SlideDoor(DS);
        //DS.SL=SL;
        this.FUNS=new ActionFunctions(DS,EN);
        
        // "Wire" all states to the proper functions.
        for (int i=0;i<states.length;i++){
        	FUNS.doWireState(states[i]);
        }

        
    }
    
    /////////////////// STATUS ///////////////////

    IWadLoader W;

    IAutoMap<?,?> AM;

    IRandom RND;

    Renderer<?,?> R;
    
    TextureManager<?> TM;

    AbstractLevelLoader LL;

    DoomMain<?,?> DM;

    IDoomGame DG;
    
    StatusBar ST;

    HU HU;
    
    IDoomSystem I;
    
    IDoomSound S;
    
    ISpriteManager SM;

    @Override
    public void updateStatus(DoomStatus<?,?> DC) {
            this.I=DC.I;
            this.DG=DC.DG;
            this.S=DC.S;
            this.LL=DC.LL;
            this.RND=DC.RND;
            this.DM=DC.DM;
            this.R=DC.R;
            this.W=DC.W;
            this.AM=DC.AM;
            this.ST= (StatusBar) DC.ST;
            this.AM=DC.AM;
            this.HU=DC.HU;
            this.TM=DC.TM;
            this.SM=DC.SM;
            if (FUNS!=null)
            FUNS.updateStatus(DC);
            
            }
      
    
    // //////////// Internal singletons //////////////
    public Actions A;

    protected Specials SPECS;

    // DoorsFloors EV;
    protected Plats PEV;

    protected Lights LEV;

    protected Switches SW;

    protected Sight See;

    protected Enemies EN;
    
    protected ActionFunctions FUNS;
    
    protected SlideDoor SL;

    // ////////////////////////////////////////////

    public int topslope;

    public int bottomslope; // slopes to top and bottom of target

    int attackrange;
    
    

    //
    // UTILITIES
    //

    //
    // getSide()
    // Will return a side_t*
    // given the number of the current sector,
    // the line number, and the side (0/1) that you want.
    //
    side_t getSide(int currentSector, int line, int side) {
        return LL.sides[(LL.sectors[currentSector].lines[line]).sidenum[side]];
    }

    /**
     * getSector()
     * Will return a sector_t
     * given the number of the current sector,
     * the line number and the side (0/1) that you want.
     */
    
    sector_t getSector(int currentSector, int line, int side) {
        return LL.sides[(LL.sectors[currentSector].lines[line]).sidenum[side]].sector;
    }

    /**
     * twoSided()
     * Given the sector number and the line number,
     * it will tell you whether the line is two-sided or not.
     */
    
    protected boolean twoSided(int sector, int line) {
        return eval((LL.sectors[sector].lines[line]).flags& ML_TWOSIDED);
    }

    /**
     * RETURN NEXT SECTOR # THAT LINE TAG REFERS TO
     */
    
    protected int FindSectorFromLineTag(line_t line, int start) {
        int i;

        for (i = start + 1; i < LL.numsectors; i++)
            if (LL.sectors[i].tag == line.tag)
                return i;

        return -1;
    }

    

    // //////////////////// FROM p_maputl.c ////////////////////

    /** fixed_t */
    protected int opentop, openbottom, openrange, lowfloor;

    /**
     * P_LineOpening Sets opentop and openbottom to the window through a two
     * sided line. OPTIMIZE: keep this precalculated
     */

    public void LineOpening(line_t linedef) {
        sector_t front;
        sector_t back;

        if (linedef.sidenum[1] == line_t.NO_INDEX) {
            // single sided line
            openrange = 0;
            return;
        }

        front = linedef.frontsector;
        back = linedef.backsector;

        if (front.ceilingheight < back.ceilingheight)
            opentop = front.ceilingheight;
        else
            opentop = back.ceilingheight;

        if (front.floorheight > back.floorheight) {
            openbottom = front.floorheight;
            lowfloor = back.floorheight;
        } else {
            openbottom = back.floorheight;
            lowfloor = front.floorheight;
        }

        openrange = opentop - openbottom;
    }

    //
    // THING POSITION SETTING
    //

    /**
     * P_UnsetThingPosition Unlinks a thing from block map and sectors. On each
     * position change, BLOCKMAP and other lookups maintaining lists ot things
     * inside these structures need to be updated.
     */

    public void UnsetThingPosition(mobj_t thing) {
        final int blockx;
        final int blocky;

        if (!eval(thing.flags& MF_NOSECTOR)) {
            // inert things don't need to be in blockmap?
            // unlink from subsector
            if (thing.snext != null)
                ((mobj_t) thing.snext).sprev = thing.sprev;

            if (thing.sprev != null)
                ((mobj_t) thing.sprev).snext = thing.snext;
            else
                thing.subsector.sector.thinglist = (mobj_t) thing.snext;
        }

        if (!eval(thing.flags& MF_NOBLOCKMAP)) {
            // inert things don't need to be in blockmap
            // unlink from block map
            if (thing.bnext != null)
                ((mobj_t) thing.bnext).bprev = thing.bprev;

            if (thing.bprev != null)
                ((mobj_t) thing.bprev).bnext = thing.bnext;
            else {
                blockx = LL.getSafeBlockX(thing.x - LL.bmaporgx);
                blocky = LL.getSafeBlockY(thing.y - LL.bmaporgy);
                
                if (blockx >= 0 && blockx < LL.bmapwidth && blocky >= 0
                        && blocky < LL.bmapheight) {
                    LL.blocklinks[blocky * LL.bmapwidth + blockx] =
                        (mobj_t) thing.bnext;
                }
            }
        }
    }

    //
    // BLOCK MAP ITERATORS
    // For each line/thing in the given mapblock,
    // call the passed PIT_* function.
    // If the function returns false,
    // exit with false without checking anything else.
    //

    //
    // INTERCEPT ROUTINES
    //
    protected intercept_t[] intercepts;

    int intercept_p;

    public divline_t trace=new divline_t();

    boolean earlyout;

    int ptflags;
    
    //
    //P_TraverseIntercepts
    //Returns true if the traverser function returns true
    //for all lines.
    //
    boolean
    TraverseIntercepts
    ( PTR_InterceptFunc   func,
    int   maxfrac )
    {
     int         count;
     int     dist; //fixed_t
     intercept_t    in=null;  // shut up compiler warning
     
     count = intercept_p;

     while (count-->0)
     {
     dist = MAXINT;
     for (int scan = 0 ; scan<intercept_p ; scan++)
     {
         if (intercepts[scan].frac < dist)
         {
         dist = intercepts[scan].frac;
         in = intercepts[scan];
         }
     }
     
     if (dist > maxfrac)
         return true;    // checked everything in range      

    /*  // UNUSED
     {
     // don't check these yet, there may be others inserted
     in = scan = intercepts;
     for ( scan = intercepts ; scan<intercept_p ; scan++)
         if (scan.frac > maxfrac)
         *in++ = *scan;
     intercept_p = in;
     return false;
     }
    */

         if ( !func.invoke(in) )
         return false;   // don't bother going farther

     in.frac = MAXINT;
     }
     
     return true;        // everything was traversed
    }
    
    protected void UpdateThinker(thinker_t thinker)
    {
      thinker_t th;
      // find the class the thinker belongs to

      th_class cls =
        thinker.function == think_t.NOP ? th_class.th_delete :
        thinker.function == think_t.P_MobjThinker &&
        ((mobj_t) thinker).health > 0 &&
        (eval((((mobj_t) thinker).flags) & MF_COUNTKILL) ||
         ((mobj_t) thinker).type == mobjtype_t.MT_SKULL) ?
        eval((((mobj_t) thinker).flags) & MF_FRIEND) ?
        th_class.th_friends : th_class.th_enemies : th_class.th_misc;

      {
        /* Remove from current thread, if in one */
        if ((th = thinker.cnext)!= null)
          (th.cprev = thinker.cprev).cnext = th;
      }

      // Add to appropriate thread
      th = thinkerclasscap[cls.ordinal()];
      th.cprev.cnext = thinker;
      thinker.cnext = th;
      thinker.cprev = th.cprev;
      th.cprev = thinker;
    }
    
    protected final thinker_t[] thinkerclasscap=new thinker_t[th_class.NUMTHCLASS];

    public boolean sight_debug;
    
    protected final void ResizeIntercepts() {
        intercepts=C2JUtils.resize(intercepts[0],intercepts,intercepts.length*2);
    	}    

    class Lights {

        //
        // Start strobing lights (usually from a trigger)
        //
        void StartLightStrobing(line_t line) {
            int secnum;
            sector_t sec;

            secnum = -1;
            while ((secnum = FindSectorFromLineTag(line, secnum)) >= 0) {
                sec = LL.sectors[secnum];
                if (sec.specialdata != null)
                    continue;

                sec.SpawnStrobeFlash(SLOWDARK, 0);
            }
        }

        //
        // TURN LINE'S TAG LIGHTS OFF
        //
        void TurnTagLightsOff(line_t line) {
            int i;
            int min;
            sector_t sector;
            sector_t tsec;
            line_t templine;

            for (int j = 0; j < LL.numsectors; j++) {
                sector = LL.sectors[j];
                if (sector.tag == line.tag) {

                    min = sector.lightlevel;
                    for (i = 0; i < sector.linecount; i++) {
                        templine = sector.lines[i];
                        tsec = templine.getNextSector(sector);
                        if (tsec == null)
                            continue;
                        if (tsec.lightlevel < min)
                            min = tsec.lightlevel;
                    }
                    sector.lightlevel = (short) min;
                }
            }
        }

        //
        // TURN LINE'S TAG LIGHTS ON
        //
        void LightTurnOn(line_t line, int bright) {

            sector_t sector;
            sector_t temp;
            line_t templine;

            for (int i = 0; i < LL.numsectors; i++) {
                sector = LL.sectors[i];
                if (sector.tag == line.tag) {
                    // bright = 0 means to search
                    // for highest light level
                    // surrounding sector
                    if (bright == 0) {
                        for (int j = 0; j < sector.linecount; j++) {
                            templine = sector.lines[j];
                            temp = templine.getNextSector( sector);

                            if (temp == null)
                                continue;

                            if (temp.lightlevel > bright)
                                bright = temp.lightlevel;
                        }
                    }
                    sector.lightlevel = (short) bright;
                }
            }
        }

    }

    class Enemies {

        // void A_Fall (mobj_t *actor);

        //
        // ENEMY THINKING
        // Enemies are allways spawned
        // with targetplayer = -1, threshold = 0
        // Most monsters are spawned unaware of all players,
        // but some can be made preaware
        //

        /**
         * P_CheckMeleeRange
         */

        boolean CheckMeleeRange(mobj_t actor) {
            mobj_t pl;
            int dist; // fixed_t

            if (actor.target == null)
                return false;

            pl = actor.target;
            dist = AproxDistance(pl.x - actor.x, pl.y - actor.y);

            if (dist >= MELEERANGE - 20 * FRACUNIT + pl.info.radius)
                return false;

            if (!EN.CheckSight(actor, actor.target))
                return false;

            return true;
        }

        /**
         * P_CheckMissileRange
         */

        boolean CheckMissileRange(mobj_t actor) {
            int dist; // fixed_t

            if (!CheckSight(actor, actor.target))
                return false;

            if ((actor.flags & MF_JUSTHIT) != 0) {
                // the target just hit the enemy,
                // so fight back!
                actor.flags &= ~MF_JUSTHIT;
                return true;
            }

            if (actor.reactiontime != 0)
                return false; // do not attack yet

            // OPTIMIZE: get this from a global checksight
            dist =
                AproxDistance(actor.x - actor.target.x, actor.y
                        - actor.target.y)
                        - 64 * FRACUNIT;

            // [SYNC}: Major desync cause of desyncs.
            // DO NOT compare with null!
            if (actor.info.meleestate == statenum_t.S_NULL)
                dist -= 128 * FRACUNIT; // no melee attack, so fire more

            dist >>= 16;

            if (actor.type == mobjtype_t.MT_VILE) {
                if (dist > 14 * 64)
                    return false; // too far away
            }

            if (actor.type == mobjtype_t.MT_UNDEAD) {
                if (dist < 196)
                    return false; // close for fist attack
                dist >>= 1;
            }

            if (actor.type == mobjtype_t.MT_CYBORG
                    || actor.type == mobjtype_t.MT_SPIDER
                    || actor.type == mobjtype_t.MT_SKULL) {
                dist >>= 1;
            }

            if (dist > 200)
                dist = 200;

            if (actor.type == mobjtype_t.MT_CYBORG && dist > 160)
                dist = 160;

            if (RND.P_Random() < dist)
                return false;

            return true;
        }

        /**
         * P_CheckSight Returns true if a straight line between t1 and t2 is
         * unobstructed. Uses REJECT.
         */

        boolean CheckSight(mobj_t t1, mobj_t t2) {
            int s1;
            int s2;
            int pnum;
            int bytenum;
            int bitnum;

            // First check for trivial rejection.

            // Determine subsector entries in REJECT table.
            s1 = t1.subsector.sector.id; // (t1.subsector.sector - sectors);
            s2 = t2.subsector.sector.id;// - sectors);
            pnum = s1 * LL.numsectors + s2;
            bytenum = pnum >> 3;
            bitnum = 1 << (pnum & 7);

            // Check in REJECT table.
            if (eval(LL.rejectmatrix[bytenum]& bitnum)) {
                See.sightcounts[0]++;

                // can't possibly be connected
                return false;
            }

            // An unobstructed LOS is possible.
            // Now look from eyes of t1 to any part of t2.
            See.sightcounts[1]++;

            R.increaseValidCount(1);

            See.sightzstart = t1.z + t1.height - (t1.height >> 2);
            topslope = (t2.z + t2.height) - See.sightzstart;
            bottomslope = (t2.z) - See.sightzstart;

            See.strace.x = t1.x;
            See.strace.y = t1.y;
            See.t2x = t2.x;
            See.t2y = t2.y;
            See.strace.dx = t2.x - t1.x;
            See.strace.dy = t2.y - t1.y;

            // the head node is the last node output
            return See.CrossBSPNode(LL.numnodes - 1);
        }

        //
        // Called by P_NoiseAlert.
        // Recursively traverse adjacent sectors,
        // sound blocking lines cut off traversal.
        //

        mobj_t soundtarget;

        private void RecursiveSound(sector_t sec, int soundblocks) {
            int i;
            line_t check;
            sector_t other;

            // wake up all monsters in this sector
            if (sec.validcount == R.getValidCount()
                    && sec.soundtraversed <= soundblocks + 1) {
                return; // already flooded
            }

            sec.validcount = R.getValidCount();
            sec.soundtraversed = soundblocks + 1;
            sec.soundtarget = soundtarget;

            // "peg" to the level loader for syntactic sugar
            side_t[] sides = LL.sides;

            for (i = 0; i < sec.linecount; i++) {
                check = sec.lines[i];
                if ((check.flags & ML_TWOSIDED) == 0)
                    continue;

                LineOpening(check);

                if (openrange <= 0)
                    continue; // closed door

                if (sides[check.sidenum[0]].sector == sec)
                    other = sides[check.sidenum[1]].sector;
                else
                    other = sides[check.sidenum[0]].sector;

                if ((check.flags & ML_SOUNDBLOCK) != 0) {
                    if (soundblocks == 0)
                        RecursiveSound(other, 1);
                } else
                    RecursiveSound(other, soundblocks);
            }
        }

        /**
         * P_NoiseAlert
         * If a monster yells at a player,
         * it will alert other monsters to the player.
         */
        
        void NoiseAlert(mobj_t target, mobj_t emmiter) {
            soundtarget = target;
            R.increaseValidCount(1);
            RecursiveSound(emmiter.subsector.sector, 0);
        }

        /**
         * P_FireWeapon. Originally in pspr
         */
        public void FireWeapon(player_t player) {
            statenum_t newstate;

            if (!player.CheckAmmo())
                return;

            player.mo.SetMobjState(statenum_t.S_PLAY_ATK1);
            newstate = weaponinfo[player.readyweapon.ordinal()].atkstate;
            player.SetPsprite(player_t.ps_weapon, newstate);
            NoiseAlert(player.mo, player.mo);
        }

        //
        // P_Move
        // Move in the current direction,
        // returns false if the move is blocked.
        //

        // Peg to map movement
        line_t[] spechitp = new line_t[MAXSPECIALCROSS];

        int numspechit;

        /**
         * P_LookForPlayers If allaround is false, only look 180 degrees in
         * front. Returns true if a player is targeted.
         */

        boolean LookForPlayers(mobj_t actor, boolean allaround) {
            int c;
            int stop;
            player_t player;
            // sector_t sector;
            long an; // angle
            int dist; // fixed

            // sector = actor.subsector.sector;

            c = 0;
            stop = (actor.lastlook - 1) & 3;

            for (;; actor.lastlook = (actor.lastlook + 1) & 3) {
                if (!DM.playeringame[actor.lastlook])
                    continue;

                if (c++ == 2 || actor.lastlook == stop) {
                    // done looking
                    return false;
                }

                player = DM.players[actor.lastlook];

                if (player.health[0] <= 0)
                    continue; // dead

                if (!CheckSight(actor, player.mo))
                    continue; // out of sight

                if (!allaround) {
                    an =
                        (R.PointToAngle2(actor.x, actor.y, player.mo.x,
                            player.mo.y)
                                - actor.angle)&BITS32;

                    if (an > ANG90 && an < ANG270) {
                        dist =
                            AproxDistance(player.mo.x - actor.x, player.mo.y
                                    - actor.y);
                        // if real close, react anyway
                        if (dist > MELEERANGE)
                            continue; // behind back
                    }
                }

                actor.target = player.mo;
                return true;
            }
            // The compiler complains that this is unreachable
            // return false;
        }

    }

    class Plats {

        public Plats() {
        	initActivePlats();
        }

        plat_t[] activeplats;

        //
        // Do Platforms
        // "amount" is only used for SOME platforms.
        //
        boolean DoPlat(line_t line, plattype_e type, int amount) {
            plat_t plat;
            int secnum = -1;
            boolean rtn = false;
            sector_t sec;

            // Activate all <type> plats that are in_stasis
            switch (type) {
            case perpetualRaise:
                ActivateInStasis(line.tag);
                break;

            default:
                break;
            }

            while ((secnum = FindSectorFromLineTag(line, secnum)) >= 0) {
                sec = LL.sectors[secnum];

                if (sec.specialdata != null)
                    continue;

                // Find lowest & highest floors around sector
                rtn = true;
                plat = new plat_t();


                plat.type = type;
                plat.sector = sec;
                plat.sector.specialdata = plat;
                plat.function = think_t.T_PlatRaise;
                AddThinker(plat);
                plat.crush = false;
                plat.tag = line.tag;

                switch (type) {
                case raiseToNearestAndChange:
                    plat.speed = PLATSPEED / 2;
                    sec.floorpic = LL.sides[line.sidenum[0]].sector.floorpic;
                    plat.high = sec.FindNextHighestFloor(sec.floorheight);
                    plat.wait = 0;
                    plat.status = plat_e.up;
                    // NO MORE DAMAGE, IF APPLICABLE
                    sec.special = 0;

                    S.StartSound(sec.soundorg,sfxenum_t.sfx_stnmov);
                    break;

                case raiseAndChange:
                    plat.speed = PLATSPEED / 2;
                    sec.floorpic = LL.sides[line.sidenum[0]].sector.floorpic;
                    plat.high = sec.floorheight + amount * FRACUNIT;
                    plat.wait = 0;
                    plat.status = plat_e.up;

                    S.StartSound(sec.soundorg,sfxenum_t.sfx_stnmov);
                    break;

                case downWaitUpStay:
                    plat.speed = PLATSPEED * 4;
                    plat.low = sec.FindLowestFloorSurrounding();

                    if (plat.low > sec.floorheight)
                        plat.low = sec.floorheight;

                    plat.high = sec.floorheight;
                    plat.wait = 35 * PLATWAIT;
                    plat.status = plat_e.down;
                    S.StartSound(sec.soundorg,sfxenum_t.sfx_pstart);
                    break;

                case blazeDWUS:
                    plat.speed = PLATSPEED * 8;
                    plat.low = sec.FindLowestFloorSurrounding();

                    if (plat.low > sec.floorheight)
                        plat.low = sec.floorheight;

                    plat.high = sec.floorheight;
                    plat.wait = 35 * PLATWAIT;
                    plat.status = plat_e.down;
                    S.StartSound(sec.soundorg,sfxenum_t.sfx_pstart);
                    break;

                case perpetualRaise:
                    plat.speed = PLATSPEED;
                    plat.low = sec.FindLowestFloorSurrounding();

                    if (plat.low > sec.floorheight)
                        plat.low = sec.floorheight;

                    plat.high = sec.FindHighestFloorSurrounding();

                    if (plat.high < sec.floorheight)
                        plat.high = sec.floorheight;

                    plat.wait = 35 * PLATWAIT;
                    // Guaranteed to be 0 or 1.
                    plat.status = plat_e.values()[RND.P_Random() & 1];

                    S.StartSound(sec.soundorg,sfxenum_t.sfx_pstart);;
                    break;
                }
                AddActivePlat(plat);
            }
            return rtn;
        }

        void ActivateInStasis(int tag) {
            int i;

            for (i = 0; i < activeplats.length; i++)
                if ((activeplats[i] != null) && (activeplats[i].tag == tag)
                        && (activeplats[i].status == plat_e.in_stasis)) {
                    (activeplats[i]).status = (activeplats[i]).oldstatus;
                    (activeplats[i]).function = think_t.T_PlatRaise;
                    FUNS.doWireThinker(activeplats[i]);
                }
        }

        void StopPlat(line_t line) {
            int j;

            for (j = 0; j < activeplats.length; j++)
                if ((activeplats[j] != null)
                        && (activeplats[j].status != plat_e.in_stasis)
                        && (activeplats[j].tag == line.tag)) {
                    (activeplats[j]).oldstatus = (activeplats[j]).status;
                    (activeplats[j]).status = plat_e.in_stasis;
                    (activeplats[j]).function = null;
                    FUNS.doWireThinker(activeplats[j]);
                }
        }

        
        /*
        void AddActivePlat(plat_t plat) {
            int i;

            for (i = 0; i < MAXPLATS; i++)
                if (activeplats[i] == null) {
                    activeplats[i] = plat;
                    return;
                }
            I.Error("P_AddActivePlat: no more plats!");
        } */

        void RemoveActivePlat(plat_t plat) {
            int i;
            for (i = 0; i < activeplats.length; i++)
                if (plat == activeplats[i]) {
                    (activeplats[i]).sector.specialdata = null;
                    RemoveThinker(activeplats[i]);
                    activeplats[i] = null;

                    return;
                }
            I.Error("P_RemoveActivePlat: can't find plat!");
        }

		public void initActivePlats() {
			// activeplats is just a placeholder. Plat objects aren't
			// actually reused, so we don't need an initialized array.
			// Same rule when resizing.
			activeplats=new plat_t[data.Limits.MAXPLATS];
		}

    }

    class Sight {
        
        public Sight(){
            strace=new divline_t();
            sightcounts= new int[2];
        }
        
        int sightzstart; // eye z of looker

        divline_t strace; // from t1 to t2

        int t2x;

        int t2y;

        int[] sightcounts ;

        

        /**
         * P_CrossSubsector Returns true if strace crosses the given subsector
         * successfully.
         */

        boolean CrossSubsector(int num) {
            int seg; // pointer inside segs
            line_t line;
            int s1;
            int s2;
            int count;
            subsector_t sub;
            sector_t front;
            sector_t back;
            int opentop; // fixed_t
            int openbottom;
            divline_t divl = new divline_t();
            //vertex_t v1;
            //vertex_t v2;
            int frac; // fixed_t
            int slope;

            if (RANGECHECK) {
                if (num >= LL.numsubsectors)
                    I.Error("P_CrossSubsector: ss %d with numss = %d",
                        num, LL.numsubsectors);
            }

            sub = LL.subsectors[num];

            // check lines
            count = sub.numlines;
            seg = sub.firstline;// LL.segs[sub.firstline];

            for (; count > 0; seg++, count--) {
                line = LL.segs[seg].linedef;

                // allready checked other side?
                if (line.validcount == R.getValidCount())
                    continue;

                line.validcount = R.getValidCount();

                //v1 = line.v1;
                //v2 = line.v2;
                s1 = strace.DivlineSide(line.v1x, line.v1y);
                s2 = strace.DivlineSide(line.v2x, line.v2y);

                // line isn't crossed?
                if (s1 == s2)
                    continue;

                divl.x = line.v1x;
                divl.y = line.v1y;
                divl.dx = line.v2x - line.v1x;
                divl.dy = line.v2y - line.v1y;
                s1 = divl.DivlineSide(strace.x, strace.y);
                s2 = divl.DivlineSide(t2x, t2y);

                // line isn't crossed?
                if (s1 == s2)
                    continue;

                // stop because it is not two sided anyway
                // might do this after updating validcount?
                if (!flags(line.flags,ML_TWOSIDED))
                    return false;

                // crosses a two sided line
                front = LL.segs[seg].frontsector;
                back = LL.segs[seg].backsector;

                // no wall to block sight with?
                if (front.floorheight == back.floorheight
                        && front.ceilingheight == back.ceilingheight)
                    continue;

                // possible occluder
                // because of ceiling height differences
                if (front.ceilingheight < back.ceilingheight)
                    opentop = front.ceilingheight;
                else
                    opentop = back.ceilingheight;

                // because of ceiling height differences
                if (front.floorheight > back.floorheight)
                    openbottom = front.floorheight;
                else
                    openbottom = back.floorheight;

                // quick test for totally closed doors
                if (openbottom >= opentop)
                    return false; // stop

                frac = MapUtils.P_InterceptVector(strace, divl);

                if (front.floorheight != back.floorheight) {
                    slope = FixedDiv(openbottom - sightzstart, frac);
                    if (slope > bottomslope)
                        bottomslope = slope;
                }

                if (front.ceilingheight != back.ceilingheight) {
                    slope = FixedDiv(opentop - sightzstart, frac);
                    if (slope < topslope)
                        topslope = slope;
                }

                if (topslope <= bottomslope)
                    return false; // stop
            }
            // passed the subsector ok
            return true;
        }

        /**
         * P_CrossBSPNode Returns true if strace crosses the given node
         * successfully.
         */

        boolean CrossBSPNode(int bspnum) {
            node_t bsp;
            int side;

            if (eval(bspnum& NF_SUBSECTOR)) {
                if (bspnum == -1)
                    return CrossSubsector(0);
                else
                    return CrossSubsector(bspnum & (~NF_SUBSECTOR));
            }

            bsp = LL.nodes[bspnum];

            // decide which side the start point is on
            side = bsp.DivlineSide(strace.x, strace.y);
            if (side == 2)
                side = 0; // an "on" should cross both sides

            // cross the starting side
            if (!CrossBSPNode(bsp.children[side]))
                return false;

            // the partition plane is crossed here
            if (side == bsp.DivlineSide(t2x, t2y)) {
                // the line doesn't touch the other side
                return true;
            }

            // cross the ending side
            return CrossBSPNode(bsp.children[side ^ 1]);
        }

    }

    //
    // P_InitPicAnims
    //

    /**
     * Floor/ceiling animation sequences, defined by first and last frame, i.e.
     * the flat (64x64 tile) name to be used. The full animation sequence is
     * given using all the flats between the start and end entry, in the order
     * found in the WAD file.
     */

    private final animdef_t[] animdefs =
        {
                new animdef_t(false, "NUKAGE3", "NUKAGE1", 8),
                new animdef_t(false, "FWATER4", "FWATER1", 8),
                new animdef_t(false, "SWATER4", "SWATER1", 8),
                new animdef_t(false, "LAVA4", "LAVA1", 8),
                new animdef_t(false, "BLOOD3", "BLOOD1", 8),

                // DOOM II flat animations.
                new animdef_t(false, "RROCK08", "RROCK05", 8),
                new animdef_t(false, "SLIME04", "SLIME01", 8),
                new animdef_t(false, "SLIME08", "SLIME05", 8),
                new animdef_t(false, "SLIME12", "SLIME09", 8),

                new animdef_t(true, "BLODGR4", "BLODGR1", 8),
                new animdef_t(true, "SLADRIP3", "SLADRIP1", 8),

                new animdef_t(true, "BLODRIP4", "BLODRIP1", 8),
                new animdef_t(true, "FIREWALL", "FIREWALA", 8),
                new animdef_t(true, "GSTFONT3", "GSTFONT1", 8),
                new animdef_t(true, "FIRELAVA", "FIRELAV3", 8),
                new animdef_t(true, "FIREMAG3", "FIREMAG1", 8),
                new animdef_t(true, "FIREBLU2", "FIREBLU1", 8),
                new animdef_t(true, "ROCKRED3", "ROCKRED1", 8),

                new animdef_t(true, "BFALL4", "BFALL1", 8),
                new animdef_t(true, "SFALL4", "SFALL1", 8),
                new animdef_t(true, "WFALL4", "WFALL1", 8),
                new animdef_t(true, "DBRAIN4", "DBRAIN1", 8)
        };
                // MAES: this was a cheap trick to mark the end of the sequence
                // with a value of "-1".
                // It won't work in Java, so just use animdefs.length-1
                // new animdef_t(false, "", "", 0) };

    

    //
    // SPECIAL SPAWNING
    //

    class Specials {
        public static final int ok = 0, crushed = 1, pastdest = 2;

        protected line_t[] linespeciallist = new line_t[Limits.MAXLINEANIMS];
        public short numlinespecials;
        
        /**
         * These are NOT the same anims found in defines. Dunno why they fucked up
         * this one so badly. Even the type has the same name, but is entirely
         * different. No way they could be overlapped/unionized either. So WTF.
         * Really. WTF.
         */
        public anim_t[] anims = new anim_t[MAXANIMS];

        // MAES: was a pointer
        public int lastanim;

        //
        // P_UpdateSpecials
        // Animate planes, scroll walls, etc.
        //
        boolean levelTimer;

        int levelTimeCount;

        public void UpdateSpecials() {
            int pic;
            line_t line;
            anim_t anim;

            // LEVEL TIMER
            if (levelTimer == true) {
                levelTimeCount--;
                if (levelTimeCount == 0)
                    DG.ExitLevel();
            }

            // ANIMATE FLATS AND TEXTURES GLOBALLY

            for (int j = 0; j < lastanim; j++) {
                anim = anims[j];
                
                for (int i = anim.basepic; i < anim.basepic + anim.numpics; i++) {
                    pic =
                        anim.basepic
                                + ((DM.leveltime / anim.speed + i) % anim.numpics);
                    if (anim.istexture)
                        TM.setTextureTranslation(i,pic);
                    else
                        TM.setFlatTranslation(i,pic);
                }
            }

            // ANIMATE LINE SPECIALS
            for (int i = 0; i < numlinespecials; i++) {
                line = linespeciallist[i];
                switch (line.special) {
                case 48:
                    // EFFECT FIRSTCOL SCROLL +
                    LL.sides[line.sidenum[0]].textureoffset += MAPFRACUNIT;
                    break;
                }
            }

            // DO BUTTONS
            SW.doButtons();
        }

        public void InitPicAnims() {
        	C2JUtils.initArrayOfObjects(anims);
            anim_t lstanim; 
            // Init animation. MAES: sneaky base pointer conversion ;-)
            this.lastanim = 0;
            // MAES: for (i=0 ; animdefs[i].istexture != -1 ; i++)
            for (int i = 0; i<animdefs.length-1; i++) {
            	lstanim= anims[this.lastanim];
                if (animdefs[i].istexture) {
                    // different episode ?
                    if (TM.CheckTextureNumForName(animdefs[i].startname) == -1)
                        continue;
                    // So, if it IS a valid texture, it goes straight into anims.
                    lstanim.picnum = TM.TextureNumForName(animdefs[i].endname);
                    lstanim.basepic = TM.TextureNumForName(animdefs[i].startname);
                } else { // If not a texture, it's a flat.
                    if (W.CheckNumForName(animdefs[i].startname) == -1)
                        continue;
                    System.out.println(animdefs[i]);
                    // Otherwise, lstanim seems to go nowhere :-/
                    lstanim.picnum = TM.FlatNumForName(animdefs[i].endname);
                    lstanim.basepic = TM.FlatNumForName(animdefs[i].startname);
                }

                lstanim.istexture = animdefs[i].istexture;
                lstanim.numpics = lstanim.picnum - lstanim.basepic + 1;

                if (lstanim.numpics < 2)
                    I.Error("P_InitPicAnims: bad cycle from %s to %s",
                        animdefs[i].startname, animdefs[i].endname);

                lstanim.speed = animdefs[i].speed;
                this.lastanim++;
            }
        }

        protected final void resizeLinesSpecialList() {
        	linespeciallist=C2JUtils.resize(linespeciallist[0],linespeciallist,linespeciallist.length*2);
            }   
        
        
    }

    class Switches {

    	public Switches(){
    		switchlist= new int[MAXSWITCHES];
    		initButtonList();
    	}
        public void doButtons() {
        	for (int i = 0; i < buttonlist.length; i++)
                if (eval(buttonlist[i].btimer)) {
                    buttonlist[i].btimer--;
                    if (!eval(buttonlist[i].btimer)) {
                        switch (buttonlist[i].where) {
                        case top:
                            LL.sides[buttonlist[i].line.sidenum[0]].toptexture =
                                (short) buttonlist[i].btexture;
                            break;

                        case middle:
                            LL.sides[buttonlist[i].line.sidenum[0]].midtexture =
                                (short) buttonlist[i].btexture;
                            break;

                        case bottom:
                            LL.sides[buttonlist[i].line.sidenum[0]].bottomtexture =
                                (short) buttonlist[i].btexture;
                            break;
                        }
                        S.StartSound(buttonlist[i].soundorg,sfxenum_t.sfx_swtchn);
                        buttonlist[i].reset();
                    }
                }
			
		}
		//
        // CHANGE THE TEXTURE OF A WALL SWITCH TO ITS OPPOSITE
        //
        switchlist_t[] alphSwitchList =
            {
                    // Doom shareware episode 1 switches
                    new switchlist_t("SW1BRCOM", "SW2BRCOM", 1),
                    new switchlist_t("SW1BRN1", "SW2BRN1", 1),
                    new switchlist_t("SW1BRN2", "SW2BRN2", 1),
                    new switchlist_t("SW1BRNGN", "SW2BRNGN", 1),
                    new switchlist_t("SW1BROWN", "SW2BROWN", 1),
                    new switchlist_t("SW1COMM", "SW2COMM", 1),
                    new switchlist_t("SW1COMP", "SW2COMP", 1),
                    new switchlist_t("SW1DIRT", "SW2DIRT", 1),
                    new switchlist_t("SW1EXIT", "SW2EXIT", 1),
                    new switchlist_t("SW1GRAY", "SW2GRAY", 1),
                    new switchlist_t("SW1GRAY1", "SW2GRAY1", 1),
                    new switchlist_t("SW1METAL", "SW2METAL", 1),
                    new switchlist_t("SW1PIPE", "SW2PIPE", 1),
                    new switchlist_t("SW1SLAD", "SW2SLAD", 1),
                    new switchlist_t("SW1STARG", "SW2STARG", 1),
                    new switchlist_t("SW1STON1", "SW2STON1", 1),
                    new switchlist_t("SW1STON2", "SW2STON2", 1),
                    new switchlist_t("SW1STONE", "SW2STONE", 1),
                    new switchlist_t("SW1STRTN", "SW2STRTN", 1),

                    // Doom registered episodes 2&3 switches
                    new switchlist_t("SW1BLUE", "SW2BLUE", 2),
                    new switchlist_t("SW1CMT", "SW2CMT", 2),
                    new switchlist_t("SW1GARG", "SW2GARG", 2),
                    new switchlist_t("SW1GSTON", "SW2GSTON", 2),
                    new switchlist_t("SW1HOT", "SW2HOT", 2),
                    new switchlist_t("SW1LION", "SW2LION", 2),
                    new switchlist_t("SW1SATYR", "SW2SATYR", 2),
                    new switchlist_t("SW1SKIN", "SW2SKIN", 2),
                    new switchlist_t("SW1VINE", "SW2VINE", 2),
                    new switchlist_t("SW1WOOD", "SW2WOOD", 2),

                    // Doom II switches
                    new switchlist_t("SW1PANEL", "SW2PANEL", 3),
                    new switchlist_t("SW1ROCK", "SW2ROCK", 3),
                    new switchlist_t("SW1MET2", "SW2MET2", 3),
                    new switchlist_t("SW1WDMET", "SW2WDMET", 3),
                    new switchlist_t("SW1BRIK", "SW2BRIK", 3),
                    new switchlist_t("SW1MOD1", "SW2MOD1", 3),
                    new switchlist_t("SW1ZIM", "SW2ZIM", 3),
                    new switchlist_t("SW1STON6", "SW2STON6", 3),
                    new switchlist_t("SW1TEK", "SW2TEK", 3),
                    new switchlist_t("SW1MARB", "SW2MARB", 3),
                    new switchlist_t("SW1SKULL", "SW2SKULL", 3),

                    new switchlist_t("\0", "\0", 0) };

        /** A (runtime generated) list of the KNOWN button types */
        int[] switchlist;

        int numswitches;

        button_t[] buttonlist;
        //
        // P_InitSwitchList
        // Only called at game initialization.
        //
        public void InitSwitchList() {
            int i;
            int index;
            int episode;

            episode = 1;

            // MAES: if this isn't changed Ultimate Doom's switches
            // won't work visually.
            if (DM.isRegistered())
                episode = 2;
            else if (DM.isCommercial())
                episode = 3;

            for (index = 0, i = 0; i < MAXSWITCHES; i++) {
            	
            	if (index>=switchlist.length) {
            		// Remove limit
            		switchlist=Arrays.copyOf(switchlist,switchlist.length>0?switchlist.length*2:8);
            		}
            	// Trickery. Looks for "end of list" marker
            	// Since the list has pairs of switches, the
            	// actual number of distinct switches is index/2
                if (alphSwitchList[i].episode == 0) {
                    numswitches = index / 2;
                    switchlist[index] = -1;
                    break;
                }

                if (alphSwitchList[i].episode <= episode) {
                    /*
                     * // UNUSED - debug? int value; if
                     * (R_CheckTextureNumForName(alphSwitchList[i].name1) < 0) {
                     * system.Error("Can't find switch texture '%s'!",
                     * alphSwitchList[i].name1); continue; } value =
                     * R_TextureNumForName(alphSwitchList[i].name1);
                     */
                    switchlist[index++] =
                        TM.TextureNumForName(alphSwitchList[i].name1);
                    switchlist[index++] =
                        TM.TextureNumForName(alphSwitchList[i].name2);
                }
            }
        }

        //
        // Start a button counting down till it turns off.
        //
        void StartButton(line_t line, bwhere_e w, int texture, int time) {
            int i;

            // See if button is already pressed
            for (i = 0; i < buttonlist.length; i++) {
                if (buttonlist[i].btimer != 0 && buttonlist[i].line == line) {

                    return;
                }
            }
            
            // At this point, it may mean that THE button of that particular
            // line was not active, or simply that there were not enough 
            // buttons in buttonlist to support an additional entry.

            // Search for a free button slot.
            for (i = 0; i < buttonlist.length; i++) {
                if (buttonlist[i].btimer == 0) {
                    buttonlist[i].line = line;
                    buttonlist[i].where = w;
                    buttonlist[i].btexture = texture;
                    buttonlist[i].btimer = time;
                    buttonlist[i].soundorg = line.soundorg;
                    return;
                }
            }
            
            // Extremely rare event, We must be able to push more than MAXBUTTONS buttons
            // in one tic, which can't normally happen except in really pathological maps.
            // In any case, resizing should solve this problem.
            buttonlist=C2JUtils.resize(buttonlist[0], buttonlist, buttonlist.length*2);
            // Try again
            StartButton(line,w,texture,time);
            // I.Error("P_StartButton: no button slots left!");
        }

        //
        // Function that changes wall texture.
        // Tell it if switch is ok to use again (true=yes, it's a button).
        //
        void ChangeSwitchTexture(line_t line, boolean useAgain) {
            int texTop;
            int texMid;
            int texBot;
            int i;
            int sound;

            if (!useAgain)
                line.special = 0;

            texTop = LL.sides[line.sidenum[0]].toptexture;
            texMid = LL.sides[line.sidenum[0]].midtexture;
            texBot = LL.sides[line.sidenum[0]].bottomtexture;

            sound = sfxenum_t.sfx_swtchn.ordinal();

            // EXIT SWITCH?
            if (line.special == 11)
                sound = sfxenum_t.sfx_swtchx.ordinal();

            for (i = 0; i < numswitches * 2; i++) {
                if (switchlist[i] == texTop) {
                    S.StartSound(buttonlist[0].soundorg,sound);
                    LL.sides[line.sidenum[0]].toptexture =
                        (short) switchlist[i ^ 1];

                    if (useAgain)
                        StartButton(line, bwhere_e.top, switchlist[i],
                            BUTTONTIME);

                    return;
                } else {
                    if (switchlist[i] == texMid) {
                    	 S.StartSound(buttonlist[0].soundorg,sound);
                        LL.sides[line.sidenum[0]].midtexture =
                            (short) switchlist[i ^ 1];

                        if (useAgain)
                            StartButton(line, bwhere_e.middle, switchlist[i],
                                BUTTONTIME);

                        return;
                    } else {
                        if (switchlist[i] == texBot) {
                        	 S.StartSound(buttonlist[0].soundorg,sound);
                            LL.sides[line.sidenum[0]].bottomtexture =
                                (short) switchlist[i ^ 1];

                            if (useAgain)
                                StartButton(line, bwhere_e.bottom,
                                    switchlist[i], BUTTONTIME);

                            return;
                        }
                    }
                }
            }
        }
		public void initButtonList() {
			// Unlike plats, buttonlist needs statically allocated and reusable
			// objects. The MAXBUTTONS limit actually applied to buttons PRESSED
			// or ACTIVE at once, not how many there can actually be in a map.
			
    		buttonlist =  C2JUtils.createArrayOfObjects(button_t.class,MAXBUTTONS);
			}

    }

    //
    // MOVEMENT ITERATOR FUNCTIONS
    //

    interface PIT_LineFunction {
        public boolean invoke(line_t ld);
    }

    interface PIT_MobjFunction {
        public boolean invoke(mobj_t thing);
    }
    
    interface PTR_InterceptFunc {
    	public boolean invoke(intercept_t in);
    }

   /* enum PTR {
        SlideTraverse,
        AimTraverse,
        ShootTraverse,
        UseTraverse
    } */

    //////////////// PIT FUNCTION OBJECTS ///////////////////
    
    //
 // PIT_AddLineIntercepts.
 // Looks for lines in the given block
 // that intercept the given trace
 // to add to the intercepts list.
 //
 // A line is crossed if its endpoints
 // are on opposite sides of the trace.
 // Returns true if earlyout and a solid line hit.
 //

 protected class PIT_AddLineIntercepts implements PIT_LineFunction{

 divline_t dl = new divline_t();

 public boolean invoke(line_t ld) {
     boolean s1;
     boolean s2;
     int frac;
     // avoid precision problems with two routines
     if (trace.dx > FRACUNIT * 16 || trace.dy > FRACUNIT * 16
             || trace.dx < -FRACUNIT * 16 || trace.dy < -FRACUNIT * 16) {
         s1 = trace.PointOnDivlineSide(ld.v1x, ld.v1y);
         s2 = trace.PointOnDivlineSide(ld.v2x, ld.v2y);
         //s1 = trace.DivlineSide(ld.v1x, ld.v1.y);
         //s2 = trace.DivlineSide(ld.v2x, ld.v2y);
     } else {
         s1 = ld.PointOnLineSide(trace.x, trace.y);
         s2 = ld.PointOnLineSide(trace.x + trace.dx, trace.y + trace.dy);
         //s1 = new divline_t(ld).DivlineSide(trace.x, trace.y);
         //s2 = new divline_t(ld).DivlineSide(trace.x + trace.dx, trace.y + trace.dy);
     }

     if (s1 == s2)
         return true; // line isn't crossed

     // hit the line
     dl.MakeDivline(ld);
     frac = InterceptVector(trace, dl);

     if (frac < 0)
         return true; // behind source

     // try to early out the check
     if (earlyout && frac < FRACUNIT && ld.backsector == null) {
         return false; // stop checking
     }

     // "create" a new intercept in the static intercept pool.
     if (intercept_p>=intercepts.length){
         ResizeIntercepts();
     }
     
     intercepts[intercept_p].frac = frac;
     intercepts[intercept_p].isaline = true;
     intercepts[intercept_p].line = ld;
     intercept_p++;

     return true; // continue
 	}

 }


 //
 // PIT_AddThingIntercepts
 //

 protected class PIT_AddThingIntercepts implements PIT_MobjFunction{
	 

     // maybe make this a shared instance variable?
     private divline_t dl = new divline_t();
	 
 public boolean invoke(mobj_t thing) {
	 // FIXME: is false ever returned?
     int x1, y1, x2, y2; // fixed_t

     boolean s1, s2;

     boolean tracepositive;


     int frac; // fixed_t

     tracepositive = (trace.dx ^ trace.dy) > 0;

     // check a corner to corner crossection for hit
     if (tracepositive) {
         x1 = thing.x - thing.radius;
         y1 = thing.y + thing.radius;

         x2 = thing.x + thing.radius;
         y2 = thing.y - thing.radius;
     } else {
         x1 = thing.x - thing.radius;
         y1 = thing.y - thing.radius;

         x2 = thing.x + thing.radius;
         y2 = thing.y + thing.radius;
     }

     s1 = trace.PointOnDivlineSide(x1, y1);
     s2 = trace.PointOnDivlineSide(x2, y2);

     if (s1 == s2)
         return true; // line isn't crossed

     dl.x = x1;
     dl.y = y1;
     dl.dx = x2 - x1;
     dl.dy = y2 - y1;

     frac = InterceptVector(trace, dl);

     if (frac < 0)
         return true; // behind source

     // "create" a new intercept in the static intercept pool.
     // FIXME: this is certainly NOT vanilla compatible behavior.
     // TODO: add overflow emulation for this?
     if (intercept_p>=intercepts.length){
         ResizeIntercepts();
     }
     intercepts[intercept_p].frac = frac;
     intercepts[intercept_p].isaline = false;
     intercepts[intercept_p].thing = thing;
     intercept_p++;

     return true; // keep going
 	}
 }

   
    
    
   /////////// BEGIN MAP OBJECT CODE, USE AS BASIC

    /**
     * P_ExplodeMissile
     */
    
    protected void ExplodeMissile(mobj_t mo) {
        mo.momx = mo.momy = mo.momz = 0;

        // MAES 9/5/2011: using mobj code for that.
        mo.SetMobjState(mobjinfo[mo.type.ordinal()].deathstate);

        mo.tics -= RND.P_Random() & 3;

        if (mo.tics < 1)
            mo.tics = 1;

        mo.flags &= ~MF_MISSILE;

        if (mo.info.deathsound != null)
        S.StartSound(mo, mo.info.deathsound);
    }

    //
    // P_RemoveMobj
    //
    mapthing_t[] itemrespawnque = new mapthing_t[ITEMQUESIZE];

    int[] itemrespawntime = new int[ITEMQUESIZE];

    int iquehead;

    int iquetail;

    public void RemoveMobj(mobj_t mobj) {
        if (eval(mobj.flags& MF_SPECIAL) && !eval(mobj.flags& MF_DROPPED)
                && (mobj.type != mobjtype_t.MT_INV)
                && (mobj.type != mobjtype_t.MT_INS)) {
            itemrespawnque[iquehead] = mobj.spawnpoint;
            itemrespawntime[iquehead] = DM.leveltime;
            iquehead = (iquehead + 1) & (ITEMQUESIZE - 1);

            // lose one off the end?
            if (iquehead == iquetail)
                iquetail = (iquetail + 1) & (ITEMQUESIZE - 1);
        }

        // unlink from sector and block lists
        UnsetThingPosition(mobj);
        
        // stop any playing sound
        S.StopSound (mobj);
        
        // free block
        RemoveThinker((thinker_t) mobj);
    }

    // //////////////////////////////// THINKER CODE, GLOBALLY VISIBLE
    // /////////////////

    //
    // THINKERS
    // All thinkers should be allocated by Z_Malloc
    // so they can be operated on uniformly.
    // The actual structures will vary in size,
    // but the first element must be thinker_t.
    //

    /** Both the head and the tail of the thinkers list */
    public thinker_t thinkercap;
    
    /* An approximation of the active number of thinkers */ 
    private int numthinkers;
    

    //
    // P_InitThinkers
    //
    @Override
    public void InitThinkers() {
    	
        // mobjpool.drain();
        
        for (int i=0; i<th_class.NUMTHCLASS; i++)  // killough 8/29/98: initialize threaded lists
            thinkerclasscap[i].cprev = thinkerclasscap[i].cnext = thinkerclasscap[i];
        
    	thinker_t next=thinkercap.next;
    	thinker_t prev=thinkercap.prev;
    	
    	// Unlink the "dangling" thinkers that may still be attached
    	// to the thinkercap. When loading a new level, they DO NOT get unloaded,
    	// wtf...
    	if (next!=null && next!=thinkercap) {
    		//System.err.println("Next link to thinkercap nulled");
    		next.prev=null;
    	}

    	if (prev!=null && prev!=thinkercap) {
    		//System.err.println("Prev link to thinkercap nulled");
    		prev.next=null;
    	}
    	
        thinkercap.next = thinkercap;
        thinkercap.prev = thinkercap;
    }

    /** cph 2002/01/13 - iterator for thinker list
     * WARNING: Do not modify thinkers between calls to this functin
     */
    thinker_t NextThinker(thinker_t th, th_class cl)
    {
      thinker_t top = thinkerclasscap[cl.ordinal()];
      if (th==null) th = top;
      th = cl == th_class.th_all ? th.next : th.cnext;
      return th == top ? null : th;
    }
    
    /**
     * P_AddThinker Adds a new thinker at the end of the list.
     */

    public void AddThinker(thinker_t thinker) {
    	
    	// If something was too weird to be wired before, it will
    	// be wired here for sure, so don't worry about searching 
    	// all of the code.
    	if (thinker.function!=null && (thinker.acp1==null && thinker.acp2==null))
    		FUNS.doWireThinker(thinker);
    	
        thinkercap.prev.next = thinker;
        thinker.next = thinkercap;
        thinker.prev = thinkercap.prev;
        thinkercap.prev = thinker;
        
        // killough 8/29/98: set sentinel pointers, and then add to appropriate list
        thinker.cnext = thinker.cprev = null;
        UpdateThinker(thinker);
        
        // [Maes] seems only used for interpolations
        //newthinkerpresent = true;
        
        numthinkers++;
    }
   
    public void ClearPlatsBeforeLoading(){
        for (int i = 0; i < PEV.activeplats.length; i++) {
                PEV.activeplats[i] = null;
            }
    }
    
    public void AddActivePlat(plat_t plat) {
        int i;

        for (i = 0; i < PEV.activeplats.length; i++)
            if (PEV.activeplats[i] == null) {
                PEV.activeplats[i] = plat;
                return;
            }
        // Uhh... lemme guess. Needs to resize?
        // Resize but leave extra items empty.
        PEV.activeplats=C2JUtils.resizeNoAutoInit(PEV.activeplats,2*PEV.activeplats.length);
        AddActivePlat(plat);
        
        //I.Error("P_AddActivePlat: no more plats!");
    }
        
    // MAES: works, but not worth it.
    // MobjPool mobjpool;
        
    //
    // P_RemoveThinker
    // Deallocation is lazy -- it will not actually be freed
    // until its thinking turn comes up.
    //
    //
    // killough 4/25/98:
    //
    // Instead of marking the function with -1 value cast to a function pointer,
    // set the function to P_RemoveThinkerDelayed(), so that later, it will be
    // removed automatically as part of the thinker process.
    //
    
    public void RemoveThinker(thinker_t thinker) {
        //thinker.function = think_t.NOP;
        // Wire to this special function.
        thinker.function=think_t.NOP;
        thinker.acpss = this.RemoveThinkerDelayed;
        // Remove any type 1 or 2 special functions.
        thinker.acp1 = null;

        thinker.acp2 = null;
        numthinkers--;
        
    }

    //
    // P_AllocateThinker
    // Allocates memory and adds a new thinker at the end of the list.
    //
    public void AllocateThinker(thinker_t thinker) {
        // UNUSED
    }

    public thinker_t getRandomThinker() {    	
    	
    	int pick=(int) (Math.random()*numthinkers);
    	thinker_t th=this.getThinkerCap();
    	
    	for (int i=0;i<pick;i++){
    		th=th.next;
    	}
    	
    	return th;
    }
    
    
    public int getNumThinkers(){
    	return numthinkers;
    	
    }

    //
    // P_Init
    //
    public void Init() {
        SW.InitSwitchList();
        SPECS.InitPicAnims();
        SM.InitSprites(ISpriteManager.doomsprnames);
    }

    /**
     * P_TouchSpecialThing LIKE ROMERO's ASS!!!
     */
    public void TouchSpecialThing(mobj_t special, mobj_t toucher) {
        player_t player;
        int i;
        int delta;// fixed_t
        sfxenum_t sound;

        delta = special.z - toucher.z;

        if (delta > toucher.height || delta < -8 * FRACUNIT) {
            // out of reach
            return;
        }

        sound = sfxenum_t.sfx_itemup;
        player = toucher.player;

        // Dead thing touching.
        // Can happen with a sliding player corpse.
        if (toucher.health <= 0)
            return;

        // Identify by sprite.
        switch (special.sprite) {
        // armor
        case SPR_ARM1:
            if (!player.GiveArmor(1))
                return;
            player.message = GOTARMOR;
            break;

        case SPR_ARM2:
            if (!player.GiveArmor(2))
                return;
            player.message = GOTMEGA;
            break;

        // bonus items
        case SPR_BON1:
            player.health[0]++; // can go over 100%
            if (player.health[0] > 200)
                player.health[0] = 200;
            player.mo.health = player.health[0];
            player.message = GOTHTHBONUS;
            break;

        case SPR_BON2:
            player.armorpoints[0]++; // can go over 100%
            if (player.armorpoints[0] > 200)
                player.armorpoints[0] = 200;
            if (player.armortype == 0)
                player.armortype = 1;
            player.message = GOTARMBONUS;
            break;

        case SPR_SOUL:
            player.health[0] += 100;
            if (player.health[0] > 200)
                player.health[0] = 200;
            player.mo.health = player.health[0];
            player.message = GOTSUPER;
            sound = sfxenum_t.sfx_getpow;
            break;

        case SPR_MEGA:
            if (!DM.isCommercial())
                return;
            player.health[0] = 200;
            player.mo.health = player.health[0];
            player.GiveArmor(2);
            player.message = GOTMSPHERE;
            sound = sfxenum_t.sfx_getpow;
            break;

        // cards
        // leave cards for everyone
        case SPR_BKEY:
            if (!player.cards[card_t.it_bluecard.ordinal()])
                player.message = GOTBLUECARD;
            player.GiveCard(card_t.it_bluecard);
            if (!DM.netgame)
                break;
            return;

        case SPR_YKEY:
            if (!player.cards[card_t.it_yellowcard.ordinal()])
                player.message = GOTYELWCARD;
            player.GiveCard(card_t.it_yellowcard);
            if (!DM.netgame)
                break;
            return;

        case SPR_RKEY:
            if (!player.cards[card_t.it_redcard.ordinal()])
                player.message = GOTREDCARD;
            player.GiveCard(card_t.it_redcard);
            if (!DM.netgame)
                break;
            return;

        case SPR_BSKU:
            if (!player.cards[card_t.it_blueskull.ordinal()])
                player.message = GOTBLUESKUL;
            player.GiveCard(card_t.it_blueskull);
            if (!DM.netgame)
                break;
            return;

        case SPR_YSKU:
            if (!player.cards[card_t.it_yellowskull.ordinal()])
                player.message = GOTYELWSKUL;
            player.GiveCard(card_t.it_yellowskull);
            if (!DM.netgame)
                break;
            return;

        case SPR_RSKU:
            if (!player.cards[card_t.it_redskull.ordinal()])
                player.message = GOTREDSKULL;
            player.GiveCard(card_t.it_redskull);
            if (!DM.netgame)
                break;
            return;

            // medikits, heals
        case SPR_STIM:
            if (!player.GiveBody(10))
                return;
            player.message = GOTSTIM;
            break;

        case SPR_MEDI:
            if (!player.GiveBody(25))
                return;

            if (player.health[0] < 25)
                player.message = GOTMEDINEED;
            else
                player.message = GOTMEDIKIT;
            break;

        // power ups
        case SPR_PINV:
            if (!player.GivePower(pw_invulnerability))
                return;
            player.message = GOTINVUL;
            sound = sfxenum_t.sfx_getpow;
            break;

        case SPR_PSTR:
            if (!player.GivePower(pw_strength))
                return;
            player.message = GOTBERSERK;
            if (player.readyweapon != weapontype_t.wp_fist)
                player.pendingweapon = weapontype_t.wp_fist;
            sound = sfxenum_t.sfx_getpow;
            break;

        case SPR_PINS:
            if (!player.GivePower(pw_invisibility))
                return;
            player.message = GOTINVIS;
            sound = sfxenum_t.sfx_getpow;
            break;

        case SPR_SUIT:
            if (!player.GivePower(pw_ironfeet))
                return;
            player.message = GOTSUIT;
            sound = sfxenum_t.sfx_getpow;
            break;

        case SPR_PMAP:
            if (!player.GivePower(pw_allmap))
                return;
            player.message = GOTMAP;
            sound = sfxenum_t.sfx_getpow;
            break;

        case SPR_PVIS:
            if (!player.GivePower(pw_infrared))
                return;
            player.message = GOTVISOR;
            sound = sfxenum_t.sfx_getpow;
            break;

        // ammo
        case SPR_CLIP:
            if ((special.flags & MF_DROPPED) != 0) {
                if (!player.GiveAmmo(ammotype_t.am_clip, 0))
                    return;
            } else {
                if (!player.GiveAmmo(ammotype_t.am_clip, 1))
                    return;
            }
            player.message = GOTCLIP;
            break;

        case SPR_AMMO:
            if (!player.GiveAmmo(ammotype_t.am_clip, 5))
                return;
            player.message = GOTCLIPBOX;
            break;

        case SPR_ROCK:
            if (!player.GiveAmmo(ammotype_t.am_misl, 1))
                return;
            player.message = GOTROCKET;
            break;

        case SPR_BROK:
            if (!player.GiveAmmo(ammotype_t.am_misl, 5))
                return;
            player.message = GOTROCKBOX;
            break;

        case SPR_CELL:
            if (!player.GiveAmmo(ammotype_t.am_cell, 1))
                return;
            player.message = GOTCELL;
            break;

        case SPR_CELP:
            if (!player.GiveAmmo(ammotype_t.am_cell, 5))
                return;
            player.message = GOTCELLBOX;
            break;

        case SPR_SHEL:
            if (!player.GiveAmmo(ammotype_t.am_shell, 1))
                return;
            player.message = GOTSHELLS;
            break;

        case SPR_SBOX:
            if (!player.GiveAmmo(ammotype_t.am_shell, 5))
                return;
            player.message = GOTSHELLBOX;
            break;

        case SPR_BPAK:
            if (!player.backpack) {
                for (i = 0; i < NUMAMMO; i++)
                    player.maxammo[i] *= 2;
                player.backpack = true;
            }
            for (i = 0; i < NUMAMMO; i++)
                player.GiveAmmo(ammotype_t.values()[i], 1);
            player.message = GOTBACKPACK;
            break;

        // weapons
        case SPR_BFUG:
            if (!player.GiveWeapon(weapontype_t.wp_bfg, false))
                return;
            player.message = GOTBFG9000;
            sound = sfxenum_t.sfx_wpnup;
            break;

        case SPR_MGUN:
            if (!player.GiveWeapon(weapontype_t.wp_chaingun,
                (special.flags & MF_DROPPED) != 0))
                return;
            player.message = GOTCHAINGUN;
            sound = sfxenum_t.sfx_wpnup;
            break;

        case SPR_CSAW:
            if (!player.GiveWeapon(weapontype_t.wp_chainsaw, false))
                return;
            player.message = GOTCHAINSAW;
            sound = sfxenum_t.sfx_wpnup;
            break;

        case SPR_LAUN:
            if (!player.GiveWeapon(weapontype_t.wp_missile, false))
                return;
            player.message = GOTLAUNCHER;
            sound = sfxenum_t.sfx_wpnup;
            break;

        case SPR_PLAS:
            if (!player.GiveWeapon(weapontype_t.wp_plasma, false))
                return;
            player.message = GOTPLASMA;
            sound = sfxenum_t.sfx_wpnup;
            break;

        case SPR_SHOT:
            if (!player.GiveWeapon(weapontype_t.wp_shotgun,
                (special.flags & MF_DROPPED) != 0))
                return;
            player.message = GOTSHOTGUN;
            sound = sfxenum_t.sfx_wpnup;
            break;

        case SPR_SGN2:
            if (!player.GiveWeapon(weapontype_t.wp_supershotgun,
                (special.flags & MF_DROPPED) != 0))
                return;
            player.message = GOTSHOTGUN2;
            sound = sfxenum_t.sfx_wpnup;
            break;

        default:
            I.Error("P_SpecialThing: Unknown gettable thing");
        }

        if ((special.flags & MF_COUNTITEM) != 0)
            player.itemcount++;
        RemoveMobj(special);
        player.bonuscount += player_t.BONUSADD;
        if (player == DM.players[DM.consoleplayer])
        S.StartSound (null, sound);
    }

    
    @Override
    public thinker_t getThinkerCap() {
        return thinkercap;
    }
    
 /**
  * killough 11/98:
  *
  * Make currentthinker external, so that P_RemoveThinkerDelayed
  * can adjust currentthinker when thinkers self-remove.
  */
    
    protected thinker_t currentthinker;
    
    protected final P_RemoveThinkerDelayed RemoveThinkerDelayed; 
    
    public class P_RemoveThinkerDelayed implements ActionTypeSS <thinker_t>{
        
    @Override
    public void invoke(thinker_t thinker) {
        
    	/*
        try {
        System.err.printf("Delete: %s %d<= %s %d => %s %d\n",
            ((mobj_t)thinker.prev).type,((mobj_t)thinker.prev).thingnum,
            ((mobj_t)thinker).type,((mobj_t)thinker).thingnum,
            ((mobj_t)thinker.next).type,((mobj_t)thinker.next).thingnum);
        } catch (ClassCastException e){
            
        } */
        
        // Unlike Boom, if we reach here it gets zapped anyway
        //if (!thinker->references)
        //{
          { /* Remove from main thinker list */
            thinker_t next = thinker.next;
            /* Note that currentthinker is guaranteed to point to us,
             * and since we're freeing our memory, we had better change that. So
             * point it to thinker->prev, so the iterator will correctly move on to
             * thinker->prev->next = thinker->next */
            (next.prev = currentthinker = thinker.prev).next = next;
            //thinker.next=thinker.prev=null;
            try {
           // System.err.printf("Delete: %s %d <==> %s %d\n",
           //     ((mobj_t)currentthinker.prev).type,((mobj_t)currentthinker.prev).thingnum,
           //     ((mobj_t)currentthinker.next).type,((mobj_t)currentthinker.next).thingnum);
            } catch (ClassCastException e){
                
            }
            
          }
          {
            /* Remove from current thinker class list */
            thinker_t th = thinker.cnext;
            (th.cprev = thinker.cprev).cnext = th;
            //thinker.cnext=thinker.cprev=null;
          }
        }
    }
    
} // End unified map
package p;

import static m.fixed_t.*;
import rr.line_t;
import static utils.C2JUtils.eval;
//
// P_MAPUTL
//

public class divline_t {

    /** fixed_t */
     public int x, y, dx, dy;
     

     /**
      *P_PointOnDivlineSide
      *Returns 0 or 1. (false or true)
      *@param x fixed
      *@param y fixed
      *@param divline_t
      */
     public boolean
     PointOnDivlineSide
     ( int   x,
     int   y
     )
     {
    	 
    	 
    	 // Using Killough's version.
    	  return
    	    (dx==0) ? x <= this.x ? dy > 0 : dy < 0 :
    	    (dy==0) ? y <= this.y ? dx < 0 : dx > 0 :
    	    (dy^dx^(x -= this.x)^(y -= this.y)) < 0 ? (dy^x) < 0 :
    	    FixedMul(y>>8, this.dx>>8) >= FixedMul(this.dy>>8, x>>8);
    	    /*
    	    int PUREFUNC P_PointOnDivlineSide(fixed_t x, fixed_t y, const divline_t *line)
    	    {
    	      return
    	        !line->dx ? x <= line->x ? line->dy > 0 : line->dy < 0 :
    	        !line->dy ? y <= line->y ? line->dx < 0 : line->dx > 0 :
    	        (line->dy^line->dx^(x -= line->x)^(y -= line->y)) < 0 ? (line->dy^x) < 0 :
    	        FixedMul(y>>8, line->dx>>8) >= FixedMul(line->dy>>8, x>>8);
    	    }*/
    	    
    /*
      int dx;
      int dy;
      int left;
      int right;
      
      if (this.dx==0)
      {
      if (x <= this.x)
          return this.dy > 0;
      
      return this.dy < 0;
      }
      if (this.dy==0)
      {
      if (y <= this.y)
          return this.dx < 0;

      return this.dx > 0;
      }
      
      dx = (x - this.x);
      dy = (y - this.y);
      
      // try to quickly decide by looking at sign bits
      if ( ((this.dy ^ this.dx ^ dx ^ dy)&0x80000000) !=0)
      {
      if (((this.dy ^ dx) & 0x80000000) !=0)
          return true;       // (left is negative)
      return false;
      }
      
      left = FixedMul ( this.dy>>8, dx>>8 );
      right = FixedMul ( dy>>8 , this.dx>>8 );
      
      if (right < left)
      return false;       // front side
      return true;           // back side
      */
     }



     //
     //P_MakeDivline
     //
     public void
     MakeDivline
     ( line_t   li)
     {
      this.x = li.v1x;
      this.y = li.v1y;
      this.dx = li.dx;
      this.dy = li.dy;
     }

     public divline_t(line_t   li)
     {
      this.x = li.v1x;
      this.y = li.v1y;
      this.dx = li.dx;
      this.dy = li.dy;
     }

     public divline_t() {
		// TODO Auto-generated constructor stub
	}



	/**
 	  * P_DivlineSide
 	  * Returns side 0 (front), 1 (back), or 2 (on).
 	 */
 	public int
 	DivlineSide
 	( int	x,
 	  int	y)
 	{
 	    
 	   int left,right;
 	    // Boom-style code. Da fack.
 	   // [Maes:] it is MUCH more corrent than the linuxdoom one, for whatever reason.
 	    
 	   return
 	  (this.dx==0) ? x == this.x ? 2 : x <= this.x ? eval(this.dy > 0) : eval(this.dy < 0) :
 	  (this.dy==0) ? (olddemo ? x : y) == this.y ? 2 : y <= this.y ? eval(this.dx < 0) : eval(this.dx > 0) :
 	  (this.dy==0) ? y == this.y ? 2 : y <= this.y ? eval(this.dx < 0) : eval(this.dx > 0) :
 	  (right = ((y - this.y) >> FRACBITS) * (this.dx >> FRACBITS)) <
 	  (left  = ((x - this.x) >> FRACBITS) * (this.dy >> FRACBITS)) ? 0 :
 	  right == left ? 2 : 1;
 	  
 	  /*  
 	    
 	    int	left,right,dx,dy;

 	    if (this.dx==0)
 	    {
 	    if (x==this.x)
 	        return 2;
 	    
 	    if (x <= this.x)
 	        return eval(this.dy > 0);

 	    return eval(this.y < 0);
 	    }
 	    
 	    if (this.dy==0)
 	    {
 	    if (x==this.y)
 	        return 2;

 	    if (y <= this.y)
 	        return eval(this.dx < 0);

 	    return eval(this.dx > 0);
 	    }
 	    
 	    dx = (x - this.x);
 	    dy = (y - this.y);

 	    left =  (this.dy>>FRACBITS) * (dx>>FRACBITS);
 	    right = (dy>>FRACBITS) * (this.dx>>FRACBITS);
 	    
 	    if (right < left)
 	    return 0;   // front side
 	    
 	    if (left == right)
 	    return 2;
 	    return 1;       // back side
 	    */
 	}
 	
 	private static final boolean olddemo = true;
     
     
 }

package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import rr.SectorAction;
import w.DoomIO;
import w.IReadableDoomObject;

public class floormove_t extends SectorAction implements IReadableDoomObject{
    
    public floormove_t(){
        // MAES HACK: floors are implied to be at least of "lowerFloor" type
        // unless set otherwise, due to implicit zero-enum value.
        this.type=floor_e.lowerFloor;
    }
    
    public floor_e type;
    public boolean crush;

    public int     direction;
    public int     newspecial;
    public short   texture;
    /** fixed_t */
    public int floordestheight;
    /** fixed_t */
    public int speed;

    @Override
    public void read(DataInputStream f) throws IOException{

        super.read(f); // Call thinker reader first            
        type=floor_e.values()[DoomIO.readLEInt(f)];
        crush=DoomIO.readIntBoolean(f);
        super.sectorid=DoomIO.readLEInt(f); // Sector index (or pointer?)
        direction=DoomIO.readLEInt(f);
        newspecial=DoomIO.readLEInt(f);
        texture=DoomIO.readLEShort(f);
        floordestheight=DoomIO.readLEInt(f);
        speed=DoomIO.readLEInt(f);        
        }
   
    @Override
    public void pack(ByteBuffer b) throws IOException{
        super.pack(b); //12            
        b.putInt(type.ordinal()); // 16
        b.putInt(crush?1:0); //20
        b.putInt(super.sectorid); // 24
        b.putInt(direction); // 28
        b.putInt(newspecial); // 32
        b.putShort(texture); // 34
        b.putInt(floordestheight); // 38
        b.putInt(speed); // 42
    }
    
}
package p;

import static m.fixed_t.FRACUNIT;
import static m.fixed_t.MAPFRACUNIT;

public final class DoorDefines {
    
    // Doors
    public static final int VDOORSPEED = MAPFRACUNIT * 2;
    public static final int VDOORWAIT = 150;
    
    
    // Lights
    public static final int GLOWSPEED = 5;

    public static final int STROBEBRIGHT = 5;

    public static final int FASTDARK = 15;

    public static final int SLOWDARK = 35;
    
    
}

package p;

public enum plattype_e {
        perpetualRaise,
        downWaitUpStay,
        raiseAndChange,
        raiseToNearestAndChange,
        blazeDWUS

    } 
package p;

public enum stair_e
{
    build8, // slowly build by 8
    turbo16 // quickly build by 16    
} 
package p;

import i.DoomStatusAware;
import i.IDoomSystem;
import doom.DoomStatus;
import doom.think_t;
import rr.TextureManager;
import rr.line_t;
import rr.sector_t;
import utils.C2JUtils;

public class SlideDoor implements DoomStatusAware {
	
		protected TextureManager<?> TM;
	
		protected AbstractLevelLoader LL;
		
		protected DoomStatus<?,?> DM;
		
		protected Actions P;
		
		protected IDoomSystem I;
	
	      // UNUSED
	      // Separate into p_slidoor.c?

	      // ABANDONED TO THE MISTS OF TIME!!!
	      //
	      // EV_SlidingDoor : slide a door horizontally
	      // (animate midtexture, then set noblocking line)
	      //

	      public static final int MAXSLIDEDOORS	=5;
	   // how many frames of animation
	      public static final int SNUMFRAMES	=	4;

	      public static final int SDOORWAIT		=35*3;
	      public static final int SWAITTICS	=	4;
	      
	      final slidename_t[]    slideFrameNames= {
		          new slidename_t("GDOORF1","GDOORF2","GDOORF3","GDOORF4",  // front
		    	           "GDOORB1","GDOORB2","GDOORB3","GDOORB4"), // back
		    	          
		    	          new slidename_t(),new slidename_t(),new slidename_t(),new slidename_t()
		    	      };
	    	  
	      final slideframe_t[] slideFrames;

	      public SlideDoor(){
	    	  slideFrames=new slideframe_t[MAXSLIDEDOORS];
	    	  C2JUtils.initArrayOfObjects(slideFrames);
	    	     
	      }
	      
	      public SlideDoor(DoomStatus<?,?> DS) {
	    	this();
			this.updateStatus(DS);
		}

		void P_InitSlidingDoorFrames()
	      {
	          int        i;
	          int        f1;
	          int        f2;
	          int        f3;
	          int        f4;
	         
	          // DOOM II ONLY...
	          if (!DM.isCommercial())
	         return;
	         
	          for (i = 0;i < MAXSLIDEDOORS; i++)
	          {
	         if (slideFrameNames[i].frontFrame1==null)
	             break;
	                 
	         f1 = TM.TextureNumForName(slideFrameNames[i].frontFrame1);
	         f2 = TM.TextureNumForName(slideFrameNames[i].frontFrame2);
	         f3 = TM.TextureNumForName(slideFrameNames[i].frontFrame3);
	         f4 = TM.TextureNumForName(slideFrameNames[i].frontFrame4);

	         slideFrames[i].frontFrames[0] = f1;
	         slideFrames[i].frontFrames[1] = f2;
	         slideFrames[i].frontFrames[2] = f3;
	         slideFrames[i].frontFrames[3] = f4;
	             
	         f1 = TM.TextureNumForName(slideFrameNames[i].backFrame1);
	         f2 = TM.TextureNumForName(slideFrameNames[i].backFrame2);
	         f3 = TM.TextureNumForName(slideFrameNames[i].backFrame3);
	         f4 = TM.TextureNumForName(slideFrameNames[i].backFrame4);

	         slideFrames[i].backFrames[0] = f1;
	         slideFrames[i].backFrames[1] = f2;
	         slideFrames[i].backFrames[2] = f3;
	         slideFrames[i].backFrames[3] = f4;
	          }
	      }


	      //
	      // Return index into "slideFrames" array
	      // for which door type to use
	      //
	      int P_FindSlidingDoorType(line_t  line)
	      {
	          int        i;
	          int        val;
	         
	          for (i = 0;i < MAXSLIDEDOORS;i++)
	          {
	         val = LL.sides[line.sidenum[0]].midtexture;
	         if (val == slideFrames[i].frontFrames[0])
	             return i;
	          }
	         
	          return -1;
	      }

	     



	     public void
	      EV_SlidingDoor
	      ( line_t  line,
	        mobj_t  thing )
	      {
	          sector_t       sec;
	          slidedoor_t   door;
	         
	          // DOOM II ONLY...
	          if (!DM.isCommercial())
	         return;
	          
	          System.err.println("EV_SlidingDoor");
	          
	          // Make sure door isn't already being animated
	          sec = line.frontsector;
	          door = null;
	          if (sec.specialdata!=null)
	          {
	         if (thing.player==null)
	             return;
	                 
	         door = (slidedoor_t) sec.specialdata;
	         if (door.type == sdt_e.sdt_openAndClose)
	         {
	             if (door.status == sd_e.sd_waiting)
	             door.status = sd_e.sd_closing;
	         }
	         else
	             return;
	          }
	          
	          // Init sliding door vars
	          if (door==null)
	          {
	         door = new slidedoor_t();
	         P.AddThinker (door);
	         sec.specialdata = door;
	             
	         door.type = sdt_e.sdt_openAndClose;
	         door.status = sd_e.sd_opening;
	         door.whichDoorIndex = P_FindSlidingDoorType(line);

	         if (door.whichDoorIndex < 0)
	             I.Error("EV_SlidingDoor: Can't use texture for sliding door!");
	                 
	         door.frontsector = sec;
	         door.backsector = line.backsector;
	         door.function = think_t.T_SlidingDoor;
	         door.timer = SWAITTICS;
	         door.frame = 0;
	         door.line = line;
	          }
	      }

		@Override
		public void updateStatus(DoomStatus<?,?> DS) {
			this.DM=DS;
			this.I=DM.I;
			this.LL=DM.LL;
			this.P=DM.P;
			this.TM=DM.TM;			
		}
	  }

package p;

/** For objects that needed to be memset to 0 in C,
 * rather than being reallocated. */

public interface Resettable {
    public void reset();
}

package p;

public interface ActionType1{
	public void invoke (mobj_t actor);
}

package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import rr.SectorAction;
import w.DoomIO;
import w.IReadableDoomObject;

public class vldoor_t extends SectorAction implements IReadableDoomObject{
        
        public vldoor_e    type;
        /** fixed_t */
        public int topheight, speed;

        /** 1 = up, 0 = waiting at top, -1 = down */
        public int direction;
        
        /** tics to wait at the top */
        public int             topwait;
        
        /**(keep in case a door going down is reset)
           when it reaches 0, start going down */        
        public int             topcountdown;
        
        @Override
        public void read(DataInputStream f) throws IOException{

            super.read(f); // Call thinker reader first            
            type=vldoor_e.values()[DoomIO.readLEInt(f)];
            super.sectorid=DoomIO.readLEInt(f); // Sector index (or pointer?)
            topheight=DoomIO.readLEInt(f);
            speed=DoomIO.readLEInt(f);
            direction=DoomIO.readLEInt(f);
            topwait=DoomIO.readLEInt(f);
            topcountdown=DoomIO.readLEInt(f);            
            }
        
        @Override
        public void pack(ByteBuffer b) throws IOException{
            super.pack(b); //12            
            b.putInt(type.ordinal()); // 16
            b.putInt(super.sectorid); // 20
            b.putInt(topheight); // 24
            b.putInt(speed); //28
            b.putInt(direction); // 32
            b.putInt(topwait); //36
            b.putInt(topcountdown); //40
        }
        
    }
package p;

import static data.Defines.FLOATSPEED;
import static data.Defines.GRAVITY;
import static data.Defines.VIEWHEIGHT;
import static data.info.states;
import static p.MapUtils.AproxDistance;
import static utils.C2JUtils.pointer;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import rr.subsector_t;
import s.ISoundOrigin;
import w.IPackableDoomObject;
import w.IReadableDoomObject;
import w.IWritableDoomObject;
import data.Tables;
import data.mapthing_t;
import data.mobjinfo_t;
import data.mobjtype_t;
import data.sounds.sfxenum_t;
import data.spritenum_t;
import data.state_t;
import defines.*;
import doom.player_t;
import doom.thinker_t;

/**
 * 
 * NOTES: mobj_t
 * 
 * mobj_ts are used to tell the refresh where to draw an image, tell the world
 * simulation when objects are contacted, and tell the sound driver how to
 * position a sound.
 * 
 * The refresh uses the next and prev links to follow lists of things in sectors
 * as they are being drawn. The sprite, frame, and angle elements determine
 * which patch_t is used to draw the sprite if it is visible. The sprite and
 * frame values are allmost allways set from state_t structures. The
 * statescr.exe utility generates the states.h and states.c files that contain
 * the sprite/frame numbers from the statescr.txt source file. The xyz origin
 * point represents a point at the bottom middle of the sprite (between the feet
 * of a biped). This is the default origin position for patch_ts grabbed with
 * lumpy.exe. A walking creature will have its z equal to the floor it is
 * standing on.
 * 
 * The sound code uses the x,y, and subsector fields to do stereo positioning of
 * any sound effited by the mobj_t.
 * 
 * The play simulation uses the blocklinks, x,y,z, radius, height to determine
 * when mobj_ts are touching each other, touching lines in the map, or hit by
 * trace lines (gunshots, lines of sight, etc). The mobj_t->flags element has
 * various bit flags used by the simulation.
 * 
 * Every mobj_t is linked into a single sector based on its origin coordinates.
 * The subsector_t is found with R_PointInSubsector(x,y), and the sector_t can
 * be found with subsector->sector. The sector links are only used by the
 * rendering code, the play simulation does not care about them at all.
 * 
 * Any mobj_t that needs to be acted upon by something else in the play world
 * (block movement, be shot, etc) will also need to be linked into the blockmap.
 * If the thing has the MF_NOBLOCK flag set, it will not use the block links. It
 * can still interact with other things, but only as the instigator (missiles
 * will run into other things, but nothing can run into a missile). Each block
 * in the grid is 128*128 units, and knows about every line_t that it contains a
 * piece of, and every interactable mobj_t that has its origin contained.
 * 
 * A valid mobj_t is a mobj_t that has the proper subsector_t filled in for its
 * xy coordinates and is linked into the sector from which the subsector was
 * made, or has the MF_NOSECTOR flag set (the subsector_t needs to be valid even
 * if MF_NOSECTOR is set), and is linked into a blockmap block or has the
 * MF_NOBLOCKMAP flag set. Links should only be modified by the
 * P_[Un]SetThingPosition() functions. Do not change the MF_NO? flags while a
 * thing is valid.
 * 
 * Any questions?
 * 
 * @author admin
 * 
 */

public class mobj_t extends thinker_t implements ISoundOrigin, Interceptable,
		IWritableDoomObject, IPackableDoomObject, IReadableDoomObject {

	Actions A;

	public mobj_t() {
		this.spawnpoint = new mapthing_t();
	}

	public mobj_t(Actions A) {
		this();
		this.A = A;
		// A mobj_t is ALSO a thinker, as it always contains the struct.
		// Don't fall for C's trickery ;-)
		// this.thinker=new thinker_t();
	}

	/* List: thinker links. */
	// public thinker_t thinker;

	/** (fixed_t) Info for drawing: position. */
	public int x, y, z;

	/** More list: links in sector (if needed) */
	public thinker_t snext, sprev;

	// More drawing info: to determine current sprite.
	/**
	 * orientation. This needs to be long or else certain checks will fail...but
	 * I need to see it working in order to confirm
	 */
	public long angle;

	/** used to find patch_t and flip value */
	public spritenum_t sprite;
	/** might be ORed with FF_FULLBRIGHT */
	public int frame;

	/** Interaction info, by BLOCKMAP. Links in blocks (if needed). */
	public thinker_t bnext, bprev;

	/** MAES: was actually a pointer to a struct subsector_s */
	public subsector_t subsector;

	/** (fixed_t) The closest interval over all contacted Sectors. */
	public int floorz, ceilingz;

	/** (fixed_t) For movement checking. */
	public int radius, height;

	/** (fixed_t) Momentums, used to update position. */
	public int momx, momy, momz;

	/** If == validcount, already checked. */
	public int validcount;

	public mobjtype_t type;
	// MAES: was a pointer
	public mobjinfo_t info; // &mobjinfo[mobj.type]

	public long tics; // state tic counter
	// MAES: was a pointer
	public state_t state;
	public long flags;
	public int health;

	/** Movement direction, movement generation (zig-zagging). */
	public int movedir; // 0-7
	public int movecount; // when 0, select a new dir

	/**
	 * Thing being chased/attacked (or NULL), also the originator for missiles.
	 * MAES: was a pointer
	 */
	public mobj_t target;
	public int p_target; // for savegames

	/**
	 * Reaction time: if non 0, don't attack yet. Used by player to freeze a bit
	 * after teleporting.
	 */
	public int reactiontime;

	/**
	 * If >0, the target will be chased no matter what (even if shot)
	 */
	public int threshold;

	/**
	 * Additional info record for player avatars only. Only valid if type ==
	 * MT_PLAYER struct player_s* player;
	 */

	public player_t player;

	/** Player number last looked for. */
	public int lastlook;

	/** For nightmare respawn. */
	public mapthing_t spawnpoint; // struct

	/** Thing being chased/attacked for tracers. */

	public mobj_t tracer; // MAES: was a pointer

	// // MF_ flags for mobjs.

	// Call P_SpecialThing when touched.
	public static final int MF_SPECIAL = 1;
	// Blocks.
	public static final int MF_SOLID = 2;
	// Can be hit.
	public static final int MF_SHOOTABLE = 4;
	// Don't use the sector links (invisible but touchable).
	public static final int MF_NOSECTOR = 8;
	// Don't use the blocklinks (inert but displayable)
	public static final int MF_NOBLOCKMAP = 16;

	// Not to be activated by sound, deaf monster.
	public static final int MF_AMBUSH = 32;
	// Will try to attack right back.
	public static final int MF_JUSTHIT = 64;
	// Will take at least one step before attacking.
	public static final int MF_JUSTATTACKED = 128;
	// On level spawning (initial position),
	// hang from ceiling instead of stand on floor.
	public static final int MF_SPAWNCEILING = 256;
	// Don't apply gravity (every tic),
	// that is, object will float, keeping current height
	// or changing it actively.
	public static final int MF_NOGRAVITY = 512;

	// Movement flags.
	// This allows jumps from high places.
	public static final int MF_DROPOFF = 0x400;
	// For players, will pick up items.
	public static final int MF_PICKUP = 0x800;
	// Player cheat. ???
	public static final int MF_NOCLIP = 0x1000;
	// Player: keep info about sliding along walls.
	public static final int MF_SLIDE = 0x2000;
	// Allow moves to any height, no gravity.
	// For active floaters, e.g. cacodemons, pain elementals.
	public static final int MF_FLOAT = 0x4000;
	// Don't cross lines
	// ??? or look at heights on teleport.
	public static final int MF_TELEPORT = 0x8000;
	// Don't hit same species, explode on block.
	// Player missiles as well as fireballs of various kinds.
	public static final int MF_MISSILE = 0x10000;
	// Dropped by a demon, not level spawned.
	// E.g. ammo clips dropped by dying former humans.
	public static final int MF_DROPPED = 0x20000;
	// Use fuzzy draw (shadow demons or spectres),
	// temporary player invisibility powerup.
	public static final int MF_SHADOW = 0x40000;
	// Flag: don't bleed when shot (use puff),
	// barrels and shootable furniture shall not bleed.
	public static final int MF_NOBLOOD = 0x80000;
	// Don't stop moving halfway off a step,
	// that is, have dead bodies slide down all the way.
	public static final int MF_CORPSE = 0x100000;
	// Floating to a height for a move, ???
	// don't auto float to target's height.
	public static final int MF_INFLOAT = 0x200000;

	// On kill, count this enemy object
	// towards intermission kill total.
	// Happy gathering.
	public static final int MF_COUNTKILL = 0x400000;

	// On picking up, count this item object
	// towards intermission item total.
	public static final int MF_COUNTITEM = 0x800000;

	// Special handling: skull in flight.
	// Neither a cacodemon nor a missile.
	public static final int MF_SKULLFLY = 0x1000000;

	// Don't spawn this object
	// in death match mode (e.g. key cards).
	public static final int MF_NOTDMATCH = 0x2000000;

	// Player sprites in multiplayer modes are modified
	// using an internal color lookup table for re-indexing.
	// If 0x4 0x8 or 0xc,
	// use a translation table for player colormaps
	public static final int MF_TRANSLATION = 0xc000000;
	// Hmm ???.
	public static final int MF_TRANSSHIFT = 26;

	/*
	 * The following methods were for the most part "contextless" and
	 * instance-specific, so they were implemented here rather that being
	 * scattered all over the package.
	 */

	/**
	 * P_SetMobjState Returns true if the mobj is still present.
	 */

	public boolean SetMobjState(statenum_t state) {
		state_t st;

		do {
			if (state == statenum_t.S_NULL) {
				state = null;
				// MAES/_D_: uncommented this as it should work by now (?).
				A.RemoveMobj(this);
				return false;
			}

			st = states[state.ordinal()];
			this.state = st;
			tics = st.tics;
			sprite = st.sprite;
			frame = (int) st.frame;

			// Modified handling.
			// Call action functions when the state is set

			if (st.acp1 != null) {
				st.acp1.invoke(this);
			}

			state = st.nextstate;
		} while (tics == 0);

		return true;
	}

	/**
	 * P_ZMovement
	 */

	public void ZMovement() {
		// fixed_t
		int dist;
		int delta;

		// check for smooth step up
		if ((player != null) && z < floorz) {
			player.viewheight -= floorz - z;

			player.deltaviewheight = (VIEWHEIGHT - player.viewheight) >> 3;
		}

		// adjust height
		z += momz;

		if (((flags & MF_FLOAT) != 0) && target != null) {
			// float down towards target if too close
			if ((flags & MF_SKULLFLY) == 0 && (flags & MF_INFLOAT) == 0) {
				dist = AproxDistance(x - target.x, y - target.y);

				delta = (target.z + (height >> 1)) - z;

				if (delta < 0 && dist < -(delta * 3))
					z -= FLOATSPEED;
				else if (delta > 0 && dist < (delta * 3))
					z += FLOATSPEED;
			}

		}

		// clip movement
		if (z <= floorz) {
			// hit the floor

			// Note (id):
			// somebody left this after the setting momz to 0,
			// kinda useless there.
			if ((flags & MF_SKULLFLY) != 0) {
				// the skull slammed into something
				momz = -momz;
			}

			if (momz < 0) {
				if (player != null && (momz < -GRAVITY * 8)) {
					// Squat down.
					// Decrease viewheight for a moment
					// after hitting the ground (hard),
					// and utter appropriate sound.
					player.deltaviewheight = momz >> 3;
					A.S.StartSound(this, sfxenum_t.sfx_oof);
				}
				momz = 0;
			}
			z = floorz;

			if ((flags & MF_MISSILE) != 0 && (flags & MF_NOCLIP) == 0) {
				A.ExplodeMissile(this);
				return;
			}
		} else if ((flags & MF_NOGRAVITY) == 0) {
			if (momz == 0)
				momz = -GRAVITY * 2;
			else
				momz -= GRAVITY;
		}

		if (z + height > ceilingz) {
			// hit the ceiling
			if (momz > 0)
				momz = 0;
			{
				z = ceilingz - height;
			}

			if ((flags & MF_SKULLFLY) != 0) { // the skull slammed into
												// something
				momz = -momz;
			}

			if ((flags & MF_MISSILE) != 0 && (flags & MF_NOCLIP) == 0) {
				A.ExplodeMissile(this);
				return;
			}
		}
	}

	public int eflags; // DOOM LEGACY

	// Fields used only during DSG unmarshalling
	public int stateid;
	public int playerid;
	public int p_tracer;

	/** Unique thing id, used during sync debugging */
    public int thingnum;

	public void clear() {
		fastclear.rewind();
		try {
			this.unpack(mobj_t.fastclear);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	// _D_: to permit this object to save/load
	public void read(DataInputStream f) throws IOException {
		// More efficient, avoids duplicating code and
		// handles little endian better.
		buffer.position(0);
		buffer.order(ByteOrder.LITTLE_ENDIAN);
		f.read(buffer.array());
		this.unpack(buffer);
	}

	@Override
	public void write(DataOutputStream f) throws IOException {

		// More efficient, avoids duplicating code and
		// handles little endian better.
		buffer.position(0);
		buffer.order(ByteOrder.LITTLE_ENDIAN);
		this.pack(buffer);
		f.write(buffer.array());

	}

	public void pack(ByteBuffer b) throws IOException {
		b.order(ByteOrder.LITTLE_ENDIAN);
		super.pack(b); // Pack the head thinker.
		b.putInt(x);
		b.putInt(y);
		b.putInt(z);
		b.putInt(pointer(snext));
		b.putInt(pointer(sprev));
		b.putInt((int) (this.angle & Tables.BITS32));
		b.putInt(this.sprite.ordinal());
		b.putInt(this.frame);
		b.putInt(pointer(bnext));
		b.putInt(pointer(bprev));
		b.putInt(pointer(subsector));
		b.putInt(floorz);
		b.putInt(ceilingz);
		b.putInt(radius);
		b.putInt(height);
		b.putInt(momx);
		b.putInt(momy);
		b.putInt(momz);
		b.putInt(validcount);
		b.putInt(type.ordinal());
		b.putInt(pointer(info)); // TODO: mobjinfo
		b.putInt((int) (this.tics & Tables.BITS32));
		b.putInt(this.state.id); // TODO: state OK?
		b.putInt((int) this.flags); // truncate
		b.putInt(this.health);
		b.putInt(this.movedir);
		b.putInt(this.movecount);
		b.putInt(pointer(target)); // TODO: p_target?
		b.putInt(this.reactiontime);
		b.putInt(this.threshold);
		// Check for player.
		if (this.player != null) {
			b.putInt(1 + this.player.identify());

			// System.out.printf("Mobj with hashcode %d is player %d",pointer(this),1+this.player.identify());
		} else
			b.putInt(0);
		b.putInt(lastlook);
		spawnpoint.pack(b);
		b.putInt(pointer(tracer)); // tracer pointer stored.

	}

	public void unpack(ByteBuffer b) throws IOException {
		b.order(ByteOrder.LITTLE_ENDIAN);
		super.unpack(b); // 12 Read the head thinker.
		this.x = b.getInt(); // 16
		this.y = b.getInt(); // 20
		this.z = b.getInt(); // 24
		b.getLong(); // TODO: snext, sprev. When are those set? 32
		this.angle = Tables.BITS32 & b.getInt(); // 36
		this.sprite = spritenum_t.values()[b.getInt()]; // 40
		this.frame = b.getInt(); // 44
		b.getLong(); // TODO: bnext, bprev. When are those set? 52
		b.getInt(); // TODO: subsector 56
		this.floorz = b.getInt(); // 60
		this.ceilingz = b.getInt(); // 64
		this.radius = b.getInt(); // 68
		this.height = b.getInt(); // 72
		this.momx = b.getInt(); // 76
		this.momy = b.getInt(); // 80
		this.momz = b.getInt(); // 84
		this.validcount = b.getInt(); // 88
		this.type = mobjtype_t.values()[b.getInt()]; // 92
		b.getInt(); // TODO: mobjinfo (deduced from type) //96
		this.tics = Tables.BITS32 & b.getInt(); // 100
		// System.out.println("State"+f.readLEInt());
		this.stateid = b.getInt(); // TODO: state OK?
		this.flags = b.getInt()&Tables.BITS32; // Only 32-bit flags can be restored
		this.health = b.getInt();
		this.movedir = b.getInt();
		this.movecount = b.getInt();
		this.p_target = b.getInt();
		this.reactiontime = b.getInt();
		this.threshold = b.getInt();
		this.playerid = b.getInt(); // TODO: player. Non null should mean that
									// it IS a player.
		this.lastlook = b.getInt();
		spawnpoint.unpack(b);
		this.p_tracer = b.getInt(); // TODO: tracer
	}

	private static ByteBuffer buffer = ByteBuffer.allocate(154);
	private static ByteBuffer fastclear = ByteBuffer.allocate(154);

	/*
	 * @Override protected void finalize(){ count++; if (count%100==0)
	 * System.err
	 * .printf("Total %d Mobj %s@%d finalized free memory: %d\n",count,
	 * this.type.name(),this.hashCode(),Runtime.getRuntime().freeMemory()); }
	 */
	protected static int count = 0;

	// TODO: a linked list of sectors where this object appears
	// public msecnode_t touching_sectorlist;

	// Sound origin stuff
	
	@Override
	public final int getX() {
		return x;
	}

	@Override
	public final int getY() {
		return y;
	}

	@Override
	public final int getZ() {
		return z;
	}
	
	public String toString(){
	    return String.format("%s %d",this.type,this.thingnum);
	}

}

package p;

import doom.thinker_t;

public interface ThinkerList {

    void AddThinker(thinker_t thinker);
    void RemoveThinker(thinker_t thinker);
    void InitThinkers();
    int getNumThinkers();
    thinker_t getRandomThinker();
    thinker_t getThinkerCap();
}

package p;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import w.CacheableDoomObject;
import w.DoomBuffer;
//
// P_SWITCH
//

public class switchlist_t
        implements CacheableDoomObject {
    
    public switchlist_t(){
        
    }
    
    // Were char[9]
    public String name1;

    public String name2;

    public short episode;

    public switchlist_t(String name1, String name2, int episode) {
        super();
        this.name1 = name1;
        this.name2 = name2;
        this.episode = (short) episode;
    }

    @Override
    public void unpack(ByteBuffer buf)
            throws IOException {
        // Like most Doom structs...
        buf.order(ByteOrder.LITTLE_ENDIAN);
        this.name1 = DoomBuffer.getNullTerminatedString(buf, 9);
        this.name2 = DoomBuffer.getNullTerminatedString(buf, 9);
        this.episode = buf.getShort();
    }

    public final static int size() {
        return 20;
    }

    public String toString() {
        return String.format("%s %s %d", name1, name2, episode);
    }
}
package p;

import rr.line_t;

/** An object that carries...interception information, I guess...with either a line
 *  or an object?
 *  
 * @author Velktron
 *
 */

public class intercept_t {
		
		/** most intercepts will belong to a static pool */
	
		public intercept_t() {
		
		}
	
		public intercept_t(int frac, mobj_t thing){
			this.frac=frac;
			this.thing=thing;
			this.isaline=false;
		}
		
		public intercept_t(int frac, line_t line){
			this.frac=frac;
			this.line=line;
			this.isaline=true;
		}
		
		/** fixed_t, along trace line */
        public int frac; 
        public boolean isaline;
        // MAES: this was an union of a mobj_t and a line_t,
        // returned as "d".
        mobj_t thing;
        line_t line;
        
        public Interceptable d(){
            return (isaline)? line: thing;
        }
        
    }

package p;

import m.fixed_t;

public interface DoomPlayer {
	
	public fixed_t
	AimLineAttack
	( mobj_t	t1,
	  int	angle,
	  fixed_t	distance );

	public void
	LineAttack
	( mobj_t	t1,
	  int	angle,
	  fixed_t	distance,
	  fixed_t	slope,
	  int		damage );

	void
	RadiusAttack
	( mobj_t	spot,
	  mobj_t	source,
	  int		damage );
	
	void
	TouchSpecialThing
	( mobj_t	special,
	  mobj_t	toucher );

	void
	DamageMobj
	( mobj_t	target,
	  mobj_t	inflictor,
	  mobj_t	source,
	  int		damage );
	}

package p;

/** Animating textures and planes
 *  There is another anim_t used in wi_stuff, unrelated.
 * 
 * @author admin
 *
 */



public class anim_t {
	
		public anim_t(){
			
		}
    
      public anim_t(boolean istexture, int picnum, int basepic, int numpics,
            int speed) {
        super();
        this.istexture = istexture;
        this.picnum = picnum;
        this.basepic = basepic;
        this.numpics = numpics;
        this.speed = speed;
    }
    public  boolean istexture;
      public   int     picnum;
      public  int     basepic;
      public  int     numpics;
      public int     speed;
        
    }

package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import rr.SectorAction;
import w.CacheableDoomObject;
import w.IPackableDoomObject;
import w.IReadableDoomObject;

public class ceiling_t extends SectorAction implements CacheableDoomObject,IReadableDoomObject,IPackableDoomObject{

        public ceiling_e   type;
        /** fixed_t */
        public int bottomheight;
        /** fixed_t */
        public int topheight;
        /** fixed_t */
        public int speed;
        boolean crush;

        // 1 = up, 0 = waiting, -1 = down
        public int     direction;

        // ID
        public int     tag;                   
        public int     olddirection;
        
        public ceiling_t(){
        	// Set to the smallest ordinal type.
        	this.type=ceiling_e.lowerToFloor;
        }
        
        // HACK for speed.
        public static final ceiling_e[] values=ceiling_e.values();
        
        @Override
        public void read(DataInputStream f) throws IOException{
        	// Read 48 bytes.
        	readbuffer.position(0);
        	readbuffer.order(ByteOrder.LITTLE_ENDIAN);
        	f.read(readbuffer.array(), 0,48);
        	unpack(readbuffer);        	
            }

        @Override
        public void pack(ByteBuffer b) throws IOException{
        	b.order(ByteOrder.LITTLE_ENDIAN);
            super.pack(b); //12            
            b.putInt(type.ordinal()); // 16            
            b.putInt(super.sectorid); // 20
            b.putInt(bottomheight); 
            b.putInt(topheight); // 28
            b.putInt(speed);
            b.putInt(crush?1:0); 
            b.putInt(direction); // 40
            b.putInt(tag);
            b.putInt(olddirection); //48
        	}

		@Override
		public void unpack(ByteBuffer b) throws IOException {
			b.order(ByteOrder.LITTLE_ENDIAN);
			super.unpack(b); // Call thinker reader first
			type=values[b.getInt()];
            super.sectorid=b.getInt(); // sector pointer.
            bottomheight=b.getInt();
            topheight=b.getInt();
            speed=b.getInt();
            crush=(b.getInt()!=0);
            direction=b.getInt();
            tag=b.getInt();
            olddirection=b.getInt();			
			}
        
		private static ByteBuffer readbuffer=ByteBuffer.allocate(48);
		
        }

package p;

public enum sdt_e {
	    sdt_openOnly,
	    sdt_closeOnly,
	    sdt_openAndClose
	}
package p;

public enum bwhere_e {
        top,
        middle,
        bottom
        }
package p;

import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import rr.SectorAction;
import w.DoomIO;

public class strobe_t extends SectorAction{
		
        public int     count;
        public int     minlight;
        public int     maxlight;
        public int     darktime;
        public int     brighttime;
        
        //
        // T_StrobeFlash
        //
        public void StrobeFlash() {
            if (--count != 0)
                return;

            if (sector.lightlevel == minlight) {
                sector.lightlevel = (short) maxlight;
                count = brighttime;
            } else {
                sector.lightlevel = (short) minlight;
                count = darktime;
            }

        }
        
        @Override
        public void read(DataInputStream f) throws IOException{

            super.read(f); // Call thinker reader first            
            super.sectorid=DoomIO.readLEInt(f); // Sector index
            count=DoomIO.readLEInt(f);
            maxlight=DoomIO.readLEInt(f);
            minlight=DoomIO.readLEInt(f);
            darktime=DoomIO.readLEInt(f);
            brighttime=DoomIO.readLEInt(f);       
            }
        
        @Override
        public void pack(ByteBuffer b) throws IOException{
            super.pack(b); //12            
            b.putInt(super.sectorid); // 16
            b.putInt(count); //20
            b.putInt(maxlight);//24
            b.putInt(minlight);//28
            b.putInt(darktime);//32
            b.putInt(brighttime);//36
        }
        
    };