src/com/replica/replicaisland/HudSystem.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.replica.replicaisland;

 /**
  * A very simple manager for orthographic in-game UI elements.
  * TODO: This should probably manage a number of hud objects in keeping with the component-centric
  * architecture of this engine.  The current code is monolithic and should be refactored.
  */
 public class HudSystem extends BaseObject {
     private static final int FUEL_BAR_EDGE_PADDING = 15;
     private static final float FUEL_DECREASE_BAR_SPEED = 0.75f;
     private static final float FUEL_INCREASE_BAR_SPEED = 2.0f;
     private static final float FLY_BUTTON_X = -12.0f;
     private static final float FLY_BUTTON_Y = -5.0f;
     private static final float STOMP_BUTTON_X = 85.0f;
     private static final float STOMP_BUTTON_Y = -10.0f;
     private static final float STOMP_BUTTON_SCALE = 0.65f;
     private static final int COLLECTABLE_EDGE_PADDING = 8;
     private static final int MAX_DIGITS = 4;
     private static final float MOVEMENT_SLIDER_BASE_X = 20.0f;
     private static final float MOVEMENT_SLIDER_BASE_Y = 32.0f;
     private static final float MOVEMENT_SLIDER_BUTTON_X = MOVEMENT_SLIDER_BASE_X + 32.0f;
     private static final float MOVEMENT_SLIDER_BUTTON_Y =  MOVEMENT_SLIDER_BASE_Y - 16.0f;
     private static final float FLY_BUTTON_WIDTH = 128;
     private static final float STOMP_BUTTON_WIDTH = FLY_BUTTON_WIDTH * STOMP_BUTTON_SCALE;
     private static final float MOVEMENT_SLIDER_WIDTH = 128;

     private DrawableBitmap mFuelDrawable;
     private DrawableBitmap mFuelBackgroundDrawable;
     private float mFuelPercent;
     private float mFuelTargetPercent;

     private Texture mFadeTexture;
     private float mFadeStartTime;
     private float mFadeDuration;
     private boolean mFadeIn;
     private boolean mFading;
     private int mFadePendingEventType;
 	private int mFadePendingEventIndex;

     private DrawableBitmap mFlyButtonEnabledDrawable;
     private DrawableBitmap mFlyButtonDisabledDrawable;
     private DrawableBitmap mFlyButtonDepressedDrawable;

     private DrawableBitmap mStompButtonEnabledDrawable;
     private DrawableBitmap mStompButtonDepressedDrawable;

     private DrawableBitmap mMovementSliderBaseDrawable;
     private DrawableBitmap mMovementSliderButtonDrawable;
     private DrawableBitmap mMovementSliderButtonDepressedDrawable;


     private Vector2 mFlyButtonLocation;
     private boolean mFlyButtonActive;
     private boolean mFlyButtonPressed;

     private Vector2 mStompButtonLocation;
     private boolean mStompButtonPressed;

     private Vector2 mMovementSliderBaseLocation;
     private Vector2 mMovementSliderButtonLocation;
     private boolean mMovementSliderMode;
     private boolean mMovementSliderButtonPressed;

     private DrawableBitmap mRubyDrawable;
     private DrawableBitmap mCoinDrawable;

     private int mCoinCount;
     private int mRubyCount;
     private Vector2 mCoinLocation;
     private Vector2 mRubyLocation;
     private int[] mCoinDigits;
     private int[] mRubyDigits;
     private boolean mCoinDigitsChanged;
     private boolean mRubyDigitsChanged;

     private int mFPS;
     private Vector2 mFPSLocation;
     private int[] mFPSDigits;
     private boolean mFPSDigitsChanged;
     private boolean mShowFPS;

     private DrawableBitmap[] mDigitDrawables;
     private DrawableBitmap mXDrawable;


     public HudSystem() {
         super();
         mFlyButtonLocation = new Vector2();
         mStompButtonLocation = new Vector2();
         mCoinLocation = new Vector2();
         mRubyLocation = new Vector2();
         mFPSLocation = new Vector2();
         mDigitDrawables = new DrawableBitmap[10];
         mCoinDigits = new int[MAX_DIGITS];
         mRubyDigits = new int[MAX_DIGITS];
         mFPSDigits = new int[MAX_DIGITS];
         mMovementSliderBaseLocation = new Vector2();
         mMovementSliderButtonLocation = new Vector2();

         reset();
     }

     @Override
     public void reset() {
         mFuelDrawable = null;
         mFadeTexture = null;
         mFuelPercent = 1.0f;
         mFuelTargetPercent = 1.0f;
         mFading = false;
         mFlyButtonDisabledDrawable = null;
         mFlyButtonEnabledDrawable = null;
         mFlyButtonDepressedDrawable = null;
         mFlyButtonLocation.set(FLY_BUTTON_X, FLY_BUTTON_Y);
         mFlyButtonActive = true;
         mFlyButtonPressed = false;
         mStompButtonEnabledDrawable = null;
         mStompButtonDepressedDrawable = null;
         mStompButtonLocation.set(STOMP_BUTTON_X, STOMP_BUTTON_Y);
         mStompButtonPressed = false;
         mCoinCount = 0;
         mRubyCount = 0;
         mCoinDigits[0] = 0;
         mCoinDigits[1] = -1;
         mRubyDigits[0] = 0;
         mRubyDigits[1] = -1;
         mCoinDigitsChanged = true;
         mRubyDigitsChanged = true;
         mFPS = 0;
         mFPSDigits[0] = 0;
         mFPSDigits[1] = -1;
         mFPSDigitsChanged = true;
         mShowFPS = false;
         for (int x = 0; x < mDigitDrawables.length; x++) {
             mDigitDrawables[x] = null;
         }
         mXDrawable = null;
         mFadePendingEventType = GameFlowEvent.EVENT_INVALID;
         mFadePendingEventIndex = 0;

         mMovementSliderBaseDrawable = null;
         mMovementSliderButtonDrawable = null;
         mMovementSliderButtonDepressedDrawable = null;
         mMovementSliderBaseLocation.set(MOVEMENT_SLIDER_BASE_X, MOVEMENT_SLIDER_BASE_Y);
         mMovementSliderButtonLocation.set(MOVEMENT_SLIDER_BUTTON_X, MOVEMENT_SLIDER_BUTTON_Y);
         mMovementSliderMode = false;
         mMovementSliderButtonPressed = false;
     }

     public void setFuelPercent(float percent) {
         mFuelTargetPercent = percent;
     }

     public void setFuelDrawable(DrawableBitmap fuel, DrawableBitmap background) {
         mFuelDrawable = fuel;
         mFuelBackgroundDrawable = background;
     }

     public void setFadeTexture(Texture texture) {
         mFadeTexture = texture;
     }

     public void setButtonDrawables(DrawableBitmap disabled, DrawableBitmap enabled, DrawableBitmap depressed,
     		DrawableBitmap stompEnabled, DrawableBitmap stompDepressed,
     		DrawableBitmap sliderBase, DrawableBitmap sliderButton, DrawableBitmap sliderDepressed) {
         mFlyButtonDisabledDrawable = disabled;
         mFlyButtonEnabledDrawable = enabled;
         mFlyButtonDepressedDrawable = depressed;
         mStompButtonEnabledDrawable = stompEnabled;
         mStompButtonDepressedDrawable = stompDepressed;
         mMovementSliderBaseDrawable = sliderBase;
         mMovementSliderButtonDrawable = sliderButton;
         mMovementSliderButtonDepressedDrawable = sliderDepressed;
     }

     public void setDigitDrawables(DrawableBitmap[] digits, DrawableBitmap xMark) {
         mXDrawable = xMark;
         for (int x = 0; x < mDigitDrawables.length && x < digits.length; x++) {
             mDigitDrawables[x] = digits[x];
         }
     }

     public void setCollectableDrawables(DrawableBitmap coin, DrawableBitmap ruby) {
         mCoinDrawable = coin;
         mRubyDrawable = ruby;
     }

     public void setButtonState(boolean pressed, boolean attackPressed, boolean sliderPressed) {
         mFlyButtonPressed = pressed;
         mStompButtonPressed = attackPressed;
         mMovementSliderButtonPressed = sliderPressed;
     }

     public void startFade(boolean in, float duration) {
         mFadeStartTime = sSystemRegistry.timeSystem.getRealTime();
         mFadeDuration = duration;
         mFadeIn = in;
         mFading = true;
     }

     public void clearFade() {
         mFading = false;
     }

     public boolean isFading() {
         return mFading;
     }

     public void updateInventory(InventoryComponent.UpdateRecord newInventory) {
     	mCoinDigitsChanged = (mCoinCount != newInventory.coinCount);
     	mRubyDigitsChanged = (mRubyCount != newInventory.rubyCount);

         mCoinCount = newInventory.coinCount;
         mRubyCount = newInventory.rubyCount;
     }

     public void setFPS(int fps) {
     	mFPSDigitsChanged = (fps != mFPS);
     	mFPS = fps;
     }

     public void setShowFPS(boolean show) {
     	mShowFPS = show;
     }

     public void setMovementSliderMode(boolean sliderOn) {
     	mMovementSliderMode = sliderOn;
     	if (sliderOn) {
     		ContextParameters params = sSystemRegistry.contextParameters;
     		mFlyButtonLocation.set(params.gameWidth - FLY_BUTTON_WIDTH - FLY_BUTTON_X, FLY_BUTTON_Y);
     		mStompButtonLocation.set(params.gameWidth - STOMP_BUTTON_WIDTH - STOMP_BUTTON_X, STOMP_BUTTON_Y);
     	} else {
     		mFlyButtonLocation.set(FLY_BUTTON_X, FLY_BUTTON_Y);
     		mStompButtonLocation.set(STOMP_BUTTON_X, STOMP_BUTTON_Y);
     	}
     }
     public void setMovementSliderOffset(float offset) {
         mMovementSliderButtonLocation.set(MOVEMENT_SLIDER_BUTTON_X + (offset * (MOVEMENT_SLIDER_WIDTH / 2.0f)), MOVEMENT_SLIDER_BUTTON_Y);
     }

     @Override
     public void update(float timeDelta, BaseObject parent) {
         final RenderSystem render = sSystemRegistry.renderSystem;
         final VectorPool pool = sSystemRegistry.vectorPool;
         final ContextParameters params = sSystemRegistry.contextParameters;
         final DrawableFactory factory = sSystemRegistry.drawableFactory;

         final GameObjectManager manager = sSystemRegistry.gameObjectManager;

         if (manager != null && manager.getPlayer() != null) {
         	// Only draw player-specific HUD elements when there's a player.
 	        if (mFuelDrawable != null && mFuelBackgroundDrawable != null
 	                && render != null && pool != null && factory != null && params != null) {
 	            if (mFuelPercent < mFuelTargetPercent) {
 	                mFuelPercent += (FUEL_INCREASE_BAR_SPEED * timeDelta);
 	                if (mFuelPercent > mFuelTargetPercent) {
 	                    mFuelPercent = mFuelTargetPercent;
 	                }
 	            } else if (mFuelPercent > mFuelTargetPercent) {
 	                mFuelPercent -= (FUEL_DECREASE_BAR_SPEED * timeDelta);
 	                if (mFuelPercent < mFuelTargetPercent) {
 	                    mFuelPercent = mFuelTargetPercent;
 	                }
 	            }

 	            if (mFuelBackgroundDrawable.getWidth() == 0) {
 	                // first time init
 	                Texture tex = mFuelDrawable.getTexture();
 	                mFuelDrawable.resize(tex.width, tex.height);
 	                Texture backgroundTex = mFuelBackgroundDrawable.getTexture();
 	                mFuelBackgroundDrawable.resize(backgroundTex.width, backgroundTex.height);
 	            }

 	            final int height = mFuelDrawable.getHeight();


 	            Vector2 location = pool.allocate();
 	            location.set(FUEL_BAR_EDGE_PADDING,
 	                    params.gameHeight - height - FUEL_BAR_EDGE_PADDING);
 	            render.scheduleForDraw(mFuelBackgroundDrawable, location, SortConstants.HUD, false);
 	            location.x += 2;
 	            location.y += 2;
 	            final int barWidth = (int)((100 - 4) * mFuelPercent);
 	            if (barWidth >= 1) {
 		            DrawableBitmap bitmap = factory.allocateDrawableBitmap();
 		            if (bitmap != null) {
 		                bitmap.resize(barWidth, mFuelDrawable.getHeight());
 		                bitmap.setTexture(mFuelDrawable.getTexture());
 		                render.scheduleForDraw(bitmap, location, SortConstants.HUD + 1, false);
 		            }
 	            }

 	            pool.release(location);
 	        }

 	        if (mFlyButtonDisabledDrawable != null && mFlyButtonEnabledDrawable != null
 	                && mFlyButtonDepressedDrawable != null) {

 	            DrawableBitmap bitmap = mFlyButtonEnabledDrawable;
 	            if (mFlyButtonActive && mFlyButtonPressed) {
 	                bitmap = mFlyButtonDepressedDrawable;
 	            } else if (!mFlyButtonActive) {
 	                bitmap = mFlyButtonDisabledDrawable;
 	            }

 	            if (bitmap.getWidth() == 0) {
 	                // first time init
 	                Texture tex = bitmap.getTexture();
 	                bitmap.resize(tex.width, tex.height);
 	            }

 	            render.scheduleForDraw(bitmap, mFlyButtonLocation, SortConstants.HUD, false);
 	        }


 	        if (mStompButtonEnabledDrawable != null && mStompButtonDepressedDrawable != null) {

 	            DrawableBitmap bitmap = mStompButtonEnabledDrawable;
 	            if (mStompButtonPressed) {
 	                bitmap = mStompButtonDepressedDrawable;
 	            }

 	            if (bitmap.getWidth() == 0) {
 	                // first time init
 	                Texture tex = bitmap.getTexture();
 	                bitmap.resize(tex.width, tex.height);
 	                bitmap.setWidth((int)(tex.width * STOMP_BUTTON_SCALE));
 	                bitmap.setHeight((int)(tex.height * STOMP_BUTTON_SCALE));
 	            }

 	            render.scheduleForDraw(bitmap, mStompButtonLocation, SortConstants.HUD, false);
 	        }

 	        if (mMovementSliderMode &&
 	        		mMovementSliderBaseDrawable != null && mMovementSliderButtonDrawable != null) {

 	            if (mMovementSliderBaseDrawable.getWidth() == 0) {
 	                // first time init
 	                Texture tex = mMovementSliderBaseDrawable.getTexture();
 	                mMovementSliderBaseDrawable.resize(tex.width, tex.height);
 	            }

 	            if (mMovementSliderButtonDrawable.getWidth() == 0) {
 	                // first time init
 	                Texture tex = mMovementSliderButtonDrawable.getTexture();
 	                mMovementSliderButtonDrawable.resize(tex.width, tex.height);
 	            }

 	            if (mMovementSliderButtonDepressedDrawable.getWidth() == 0) {
 	                // first time init
 	                Texture tex = mMovementSliderButtonDepressedDrawable.getTexture();
 	                mMovementSliderButtonDepressedDrawable.resize(tex.width, tex.height);
 	            }

 	            DrawableBitmap bitmap = mMovementSliderButtonDrawable;

 	            if (mMovementSliderButtonPressed) {
 	            	bitmap = mMovementSliderButtonDepressedDrawable;
 	            }

 	            render.scheduleForDraw(mMovementSliderBaseDrawable, mMovementSliderBaseLocation, SortConstants.HUD, false);
 	            render.scheduleForDraw(bitmap, mMovementSliderButtonLocation, SortConstants.HUD + 1, false);

 	        }


 	        if (mCoinDrawable != null) {
 	            if (mCoinDrawable.getWidth() == 0) {
 	                // first time init
 	                Texture tex = mCoinDrawable.getTexture();
 	                mCoinDrawable.resize(tex.width, tex.height);
 	                mCoinLocation.x = (params.gameWidth / 2.0f) - tex.width / 2.0f;
 	                mCoinLocation.y = params.gameHeight - tex.height - COLLECTABLE_EDGE_PADDING;
 	            }

 	            render.scheduleForDraw(mCoinDrawable, mCoinLocation, SortConstants.HUD, false);
 	            if (mCoinDigitsChanged) {
 	            	intToDigitArray(mCoinCount, mCoinDigits);
 	            	mCoinDigitsChanged = false;
 	            }
 	            final float offset = mCoinDrawable.getWidth() * 0.75f;
 	            mCoinLocation.x += offset;
 	            drawNumber(mCoinLocation, mCoinDigits, true);
 	            mCoinLocation.x -= offset;
 	        }

 	        if (mRubyDrawable != null) {
 	            if (mRubyDrawable.getWidth() == 0) {
 	                // first time init
 	                Texture tex = mRubyDrawable.getTexture();
 	                mRubyDrawable.resize(tex.width, tex.height);
 	                mRubyLocation.x = (params.gameWidth / 2.0f) + 100.0f;
 	                mRubyLocation.y = params.gameHeight - tex.height - COLLECTABLE_EDGE_PADDING;
 	            }
 	            render.scheduleForDraw(mRubyDrawable, mRubyLocation, SortConstants.HUD, false);
 	            if (mRubyDigitsChanged) {
 	            	intToDigitArray(mRubyCount, mRubyDigits);
 	            	mRubyDigitsChanged = false;
 	            }
 	            final float offset = mRubyDrawable.getWidth() * 0.75f;
 	            mRubyLocation.x += offset;
 	            drawNumber(mRubyLocation, mRubyDigits, true);
 	            mRubyLocation.x -= offset;
 	        }
         }

         if (mShowFPS) {
         	if (mFPSDigitsChanged) {
             	int count = intToDigitArray(mFPS, mFPSDigits);
             	mFPSDigitsChanged = false;
                 mFPSLocation.set(params.gameWidth - 10.0f - ((count + 1) * (mDigitDrawables[0].getWidth() / 2.0f)), 10.0f);

             }
             drawNumber(mFPSLocation, mFPSDigits, false);
         }

         if (mFading && factory != null) {

             final float time = sSystemRegistry.timeSystem.getRealTime();
             final float fadeDelta = (time - mFadeStartTime);

             float percentComplete = 1.0f;
             if (fadeDelta < mFadeDuration) {
                 percentComplete = fadeDelta / mFadeDuration;
             } else if (mFadeIn) {
                 // We've faded in.  Turn fading off.
                 mFading = false;
             }

             if (percentComplete < 1.0f || !mFadeIn) {
                 float opacityValue = percentComplete;
                 if (mFadeIn) {
                     opacityValue = 1.0f - percentComplete;
                 }

                 DrawableBitmap bitmap = factory.allocateDrawableBitmap();
                 if (bitmap != null) {
                     bitmap.setWidth(params.gameWidth);
                     bitmap.setHeight(params.gameHeight);
                     bitmap.setTexture(mFadeTexture);
                     bitmap.setCrop(0, mFadeTexture.height, mFadeTexture.width, mFadeTexture.height);
                     bitmap.setOpacity(opacityValue);
                     render.scheduleForDraw(bitmap, Vector2.ZERO, SortConstants.FADE, false);
                 }
             }

             if (percentComplete >= 1.0f && mFadePendingEventType != GameFlowEvent.EVENT_INVALID) {
             	LevelSystem level = sSystemRegistry.levelSystem;
             	if (level != null) {
             		level.sendGameEvent(mFadePendingEventType, mFadePendingEventIndex, false);
             		mFadePendingEventType = GameFlowEvent.EVENT_INVALID;
             		mFadePendingEventIndex = 0;
             	}
             }
         }
     }

     private void drawNumber(Vector2 location, int[] digits, boolean drawX) {
         final RenderSystem render = sSystemRegistry.renderSystem;

         if (mDigitDrawables[0].getWidth() == 0) {
             // first time init
             for (int x = 0; x < mDigitDrawables.length; x++) {
                 Texture tex = mDigitDrawables[x].getTexture();
                 mDigitDrawables[x].resize(tex.width, tex.height);
             }
         }

         if (mXDrawable.getWidth() == 0) {
             // first time init
             Texture tex = mXDrawable.getTexture();
             mXDrawable.resize(tex.width, tex.height);
         }

         final float characterWidth = mDigitDrawables[0].getWidth() / 2.0f;
         float offset = 0.0f;

         if (mXDrawable != null && drawX) {
             render.scheduleForDraw(mXDrawable, location, SortConstants.HUD, false);
             location.x += characterWidth;
             offset += characterWidth;
          }

         for (int x = 0; x < digits.length && digits[x] != -1; x++) {
             int index = digits[x];
             DrawableBitmap digit = mDigitDrawables[index];
             if (digit != null) {
                 render.scheduleForDraw(digit, location, SortConstants.HUD, false);
                 location.x += characterWidth;
                 offset += characterWidth;
             }
         }

         location.x -= offset;


     }

     public int intToDigitArray(int value, int[] digits) {
     	int characterCount = 1;
         if (value >= 1000) {
             characterCount = 4;
         } else if (value >= 100) {
             characterCount = 3;
         } else if (value >= 10) {
             characterCount = 2;
         }

     	int remainingValue = value;
         int count = 0;
 	    do {
 	        int index = remainingValue != 0 ? remainingValue % 10 : 0;
 	        remainingValue /= 10;
 	        digits[characterCount - 1 - count] = index;
 	        count++;
 	    } while (remainingValue > 0 && count < digits.length);

 	    if (count < digits.length) {
 	    	digits[count] = -1;
 	    }
 	    return characterCount;
     }

 	public void sendGameEventOnFadeComplete(int eventType, int eventIndex) {
 		mFadePendingEventType = eventType;
 		mFadePendingEventIndex = eventIndex;
 	}


 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.replica.replicaisland;

	/**
	* A very simple manager for orthographic in-game UI elements.
	* TODO: This should probably manage a number of hud objects in keeping with the component-centric
	* architecture of this engine. The current code is monolithic and should be refactored.
	*/
	public class HudSystem extends BaseObject {
	private static final int FUEL_BAR_EDGE_PADDING = 15;
	private static final float FUEL_DECREASE_BAR_SPEED = 0.75f;
	private static final float FUEL_INCREASE_BAR_SPEED = 2.0f;
	private static final float FLY_BUTTON_X = -12.0f;
	private static final float FLY_BUTTON_Y = -5.0f;
	private static final float STOMP_BUTTON_X = 85.0f;
	private static final float STOMP_BUTTON_Y = -10.0f;
	private static final float STOMP_BUTTON_SCALE = 0.65f;
	private static final int COLLECTABLE_EDGE_PADDING = 8;
	private static final int MAX_DIGITS = 4;
	private static final float MOVEMENT_SLIDER_BASE_X = 20.0f;
	private static final float MOVEMENT_SLIDER_BASE_Y = 32.0f;
	private static final float MOVEMENT_SLIDER_BUTTON_X = MOVEMENT_SLIDER_BASE_X + 32.0f;
	private static final float MOVEMENT_SLIDER_BUTTON_Y = MOVEMENT_SLIDER_BASE_Y - 16.0f;
	private static final float FLY_BUTTON_WIDTH = 128;
	private static final float STOMP_BUTTON_WIDTH = FLY_BUTTON_WIDTH * STOMP_BUTTON_SCALE;
	private static final float MOVEMENT_SLIDER_WIDTH = 128;

	private DrawableBitmap mFuelDrawable;
	private DrawableBitmap mFuelBackgroundDrawable;
	private float mFuelPercent;
	private float mFuelTargetPercent;

	private Texture mFadeTexture;
	private float mFadeStartTime;
	private float mFadeDuration;
	private boolean mFadeIn;
	private boolean mFading;
	private int mFadePendingEventType;
	private int mFadePendingEventIndex;

	private DrawableBitmap mFlyButtonEnabledDrawable;
	private DrawableBitmap mFlyButtonDisabledDrawable;
	private DrawableBitmap mFlyButtonDepressedDrawable;

	private DrawableBitmap mStompButtonEnabledDrawable;
	private DrawableBitmap mStompButtonDepressedDrawable;

	private DrawableBitmap mMovementSliderBaseDrawable;
	private DrawableBitmap mMovementSliderButtonDrawable;
	private DrawableBitmap mMovementSliderButtonDepressedDrawable;


	private Vector2 mFlyButtonLocation;
	private boolean mFlyButtonActive;
	private boolean mFlyButtonPressed;

	private Vector2 mStompButtonLocation;
	private boolean mStompButtonPressed;

	private Vector2 mMovementSliderBaseLocation;
	private Vector2 mMovementSliderButtonLocation;
	private boolean mMovementSliderMode;
	private boolean mMovementSliderButtonPressed;

	private DrawableBitmap mRubyDrawable;
	private DrawableBitmap mCoinDrawable;

	private int mCoinCount;
	private int mRubyCount;
	private Vector2 mCoinLocation;
	private Vector2 mRubyLocation;
	private int[] mCoinDigits;
	private int[] mRubyDigits;
	private boolean mCoinDigitsChanged;
	private boolean mRubyDigitsChanged;

	private int mFPS;
	private Vector2 mFPSLocation;
	private int[] mFPSDigits;
	private boolean mFPSDigitsChanged;
	private boolean mShowFPS;

	private DrawableBitmap[] mDigitDrawables;
	private DrawableBitmap mXDrawable;


	public HudSystem() {
	super();
	mFlyButtonLocation = new Vector2();
	mStompButtonLocation = new Vector2();
	mCoinLocation = new Vector2();
	mRubyLocation = new Vector2();
	mFPSLocation = new Vector2();
	mDigitDrawables = new DrawableBitmap[10];
	mCoinDigits = new int[MAX_DIGITS];
	mRubyDigits = new int[MAX_DIGITS];
	mFPSDigits = new int[MAX_DIGITS];
	mMovementSliderBaseLocation = new Vector2();
	mMovementSliderButtonLocation = new Vector2();

	reset();
	}

	@Override
	public void reset() {
	mFuelDrawable = null;
	mFadeTexture = null;
	mFuelPercent = 1.0f;
	mFuelTargetPercent = 1.0f;
	mFading = false;
	mFlyButtonDisabledDrawable = null;
	mFlyButtonEnabledDrawable = null;
	mFlyButtonDepressedDrawable = null;
	mFlyButtonLocation.set(FLY_BUTTON_X, FLY_BUTTON_Y);
	mFlyButtonActive = true;
	mFlyButtonPressed = false;
	mStompButtonEnabledDrawable = null;
	mStompButtonDepressedDrawable = null;
	mStompButtonLocation.set(STOMP_BUTTON_X, STOMP_BUTTON_Y);
	mStompButtonPressed = false;
	mCoinCount = 0;
	mRubyCount = 0;
	mCoinDigits[0] = 0;
	mCoinDigits[1] = -1;
	mRubyDigits[0] = 0;
	mRubyDigits[1] = -1;
	mCoinDigitsChanged = true;
	mRubyDigitsChanged = true;
	mFPS = 0;
	mFPSDigits[0] = 0;
	mFPSDigits[1] = -1;
	mFPSDigitsChanged = true;
	mShowFPS = false;
	for (int x = 0; x < mDigitDrawables.length; x++) {
	mDigitDrawables[x] = null;
	}
	mXDrawable = null;
	mFadePendingEventType = GameFlowEvent.EVENT_INVALID;
	mFadePendingEventIndex = 0;

	mMovementSliderBaseDrawable = null;
	mMovementSliderButtonDrawable = null;
	mMovementSliderButtonDepressedDrawable = null;
	mMovementSliderBaseLocation.set(MOVEMENT_SLIDER_BASE_X, MOVEMENT_SLIDER_BASE_Y);
	mMovementSliderButtonLocation.set(MOVEMENT_SLIDER_BUTTON_X, MOVEMENT_SLIDER_BUTTON_Y);
	mMovementSliderMode = false;
	mMovementSliderButtonPressed = false;
	}

	public void setFuelPercent(float percent) {
	mFuelTargetPercent = percent;
	}

	public void setFuelDrawable(DrawableBitmap fuel, DrawableBitmap background) {
	mFuelDrawable = fuel;
	mFuelBackgroundDrawable = background;
	}

	public void setFadeTexture(Texture texture) {
	mFadeTexture = texture;
	}

	public void setButtonDrawables(DrawableBitmap disabled, DrawableBitmap enabled, DrawableBitmap depressed,
	DrawableBitmap stompEnabled, DrawableBitmap stompDepressed,
	DrawableBitmap sliderBase, DrawableBitmap sliderButton, DrawableBitmap sliderDepressed) {
	mFlyButtonDisabledDrawable = disabled;
	mFlyButtonEnabledDrawable = enabled;
	mFlyButtonDepressedDrawable = depressed;
	mStompButtonEnabledDrawable = stompEnabled;
	mStompButtonDepressedDrawable = stompDepressed;
	mMovementSliderBaseDrawable = sliderBase;
	mMovementSliderButtonDrawable = sliderButton;
	mMovementSliderButtonDepressedDrawable = sliderDepressed;
	}

	public void setDigitDrawables(DrawableBitmap[] digits, DrawableBitmap xMark) {
	mXDrawable = xMark;
	for (int x = 0; x < mDigitDrawables.length && x < digits.length; x++) {
	mDigitDrawables[x] = digits[x];
	}
	}

	public void setCollectableDrawables(DrawableBitmap coin, DrawableBitmap ruby) {
	mCoinDrawable = coin;
	mRubyDrawable = ruby;
	}

	public void setButtonState(boolean pressed, boolean attackPressed, boolean sliderPressed) {
	mFlyButtonPressed = pressed;
	mStompButtonPressed = attackPressed;
	mMovementSliderButtonPressed = sliderPressed;
	}

	public void startFade(boolean in, float duration) {
	mFadeStartTime = sSystemRegistry.timeSystem.getRealTime();
	mFadeDuration = duration;
	mFadeIn = in;
	mFading = true;
	}

	public void clearFade() {
	mFading = false;
	}

	public boolean isFading() {
	return mFading;
	}

	public void updateInventory(InventoryComponent.UpdateRecord newInventory) {
	mCoinDigitsChanged = (mCoinCount != newInventory.coinCount);
	mRubyDigitsChanged = (mRubyCount != newInventory.rubyCount);

	mCoinCount = newInventory.coinCount;
	mRubyCount = newInventory.rubyCount;
	}

	public void setFPS(int fps) {
	mFPSDigitsChanged = (fps != mFPS);
	mFPS = fps;
	}

	public void setShowFPS(boolean show) {
	mShowFPS = show;
	}

	public void setMovementSliderMode(boolean sliderOn) {
	mMovementSliderMode = sliderOn;
	if (sliderOn) {
	ContextParameters params = sSystemRegistry.contextParameters;
	mFlyButtonLocation.set(params.gameWidth - FLY_BUTTON_WIDTH - FLY_BUTTON_X, FLY_BUTTON_Y);
	mStompButtonLocation.set(params.gameWidth - STOMP_BUTTON_WIDTH - STOMP_BUTTON_X, STOMP_BUTTON_Y);
	} else {
	mFlyButtonLocation.set(FLY_BUTTON_X, FLY_BUTTON_Y);
	mStompButtonLocation.set(STOMP_BUTTON_X, STOMP_BUTTON_Y);
	}
	}
	public void setMovementSliderOffset(float offset) {
	mMovementSliderButtonLocation.set(MOVEMENT_SLIDER_BUTTON_X + (offset * (MOVEMENT_SLIDER_WIDTH / 2.0f)), MOVEMENT_SLIDER_BUTTON_Y);
	}

	@Override
	public void update(float timeDelta, BaseObject parent) {
	final RenderSystem render = sSystemRegistry.renderSystem;
	final VectorPool pool = sSystemRegistry.vectorPool;
	final ContextParameters params = sSystemRegistry.contextParameters;
	final DrawableFactory factory = sSystemRegistry.drawableFactory;

	final GameObjectManager manager = sSystemRegistry.gameObjectManager;

	if (manager != null && manager.getPlayer() != null) {
	// Only draw player-specific HUD elements when there's a player.
	if (mFuelDrawable != null && mFuelBackgroundDrawable != null
	&& render != null && pool != null && factory != null && params != null) {
	if (mFuelPercent < mFuelTargetPercent) {
	mFuelPercent += (FUEL_INCREASE_BAR_SPEED * timeDelta);
	if (mFuelPercent > mFuelTargetPercent) {
	mFuelPercent = mFuelTargetPercent;
	}
	} else if (mFuelPercent > mFuelTargetPercent) {
	mFuelPercent -= (FUEL_DECREASE_BAR_SPEED * timeDelta);
	if (mFuelPercent < mFuelTargetPercent) {
	mFuelPercent = mFuelTargetPercent;
	}
	}

	if (mFuelBackgroundDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mFuelDrawable.getTexture();
	mFuelDrawable.resize(tex.width, tex.height);
	Texture backgroundTex = mFuelBackgroundDrawable.getTexture();
	mFuelBackgroundDrawable.resize(backgroundTex.width, backgroundTex.height);
	}

	final int height = mFuelDrawable.getHeight();


	Vector2 location = pool.allocate();
	location.set(FUEL_BAR_EDGE_PADDING,
	params.gameHeight - height - FUEL_BAR_EDGE_PADDING);
	render.scheduleForDraw(mFuelBackgroundDrawable, location, SortConstants.HUD, false);
	location.x += 2;
	location.y += 2;
	final int barWidth = (int)((100 - 4) * mFuelPercent);
	if (barWidth >= 1) {
	DrawableBitmap bitmap = factory.allocateDrawableBitmap();
	if (bitmap != null) {
	bitmap.resize(barWidth, mFuelDrawable.getHeight());
	bitmap.setTexture(mFuelDrawable.getTexture());
	render.scheduleForDraw(bitmap, location, SortConstants.HUD + 1, false);
	}
	}

	pool.release(location);
	}

	if (mFlyButtonDisabledDrawable != null && mFlyButtonEnabledDrawable != null
	&& mFlyButtonDepressedDrawable != null) {

	DrawableBitmap bitmap = mFlyButtonEnabledDrawable;
	if (mFlyButtonActive && mFlyButtonPressed) {
	bitmap = mFlyButtonDepressedDrawable;
	} else if (!mFlyButtonActive) {
	bitmap = mFlyButtonDisabledDrawable;
	}

	if (bitmap.getWidth() == 0) {
	// first time init
	Texture tex = bitmap.getTexture();
	bitmap.resize(tex.width, tex.height);
	}

	render.scheduleForDraw(bitmap, mFlyButtonLocation, SortConstants.HUD, false);
	}



	if (mStompButtonEnabledDrawable != null && mStompButtonDepressedDrawable != null) {

	DrawableBitmap bitmap = mStompButtonEnabledDrawable;
	if (mStompButtonPressed) {
	bitmap = mStompButtonDepressedDrawable;
	}

	if (bitmap.getWidth() == 0) {
	// first time init
	Texture tex = bitmap.getTexture();
	bitmap.resize(tex.width, tex.height);
	bitmap.setWidth((int)(tex.width * STOMP_BUTTON_SCALE));
	bitmap.setHeight((int)(tex.height * STOMP_BUTTON_SCALE));
	}

	render.scheduleForDraw(bitmap, mStompButtonLocation, SortConstants.HUD, false);
	}

	if (mMovementSliderMode &&
	mMovementSliderBaseDrawable != null && mMovementSliderButtonDrawable != null) {

	if (mMovementSliderBaseDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mMovementSliderBaseDrawable.getTexture();
	mMovementSliderBaseDrawable.resize(tex.width, tex.height);
	}

	if (mMovementSliderButtonDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mMovementSliderButtonDrawable.getTexture();
	mMovementSliderButtonDrawable.resize(tex.width, tex.height);
	}

	if (mMovementSliderButtonDepressedDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mMovementSliderButtonDepressedDrawable.getTexture();
	mMovementSliderButtonDepressedDrawable.resize(tex.width, tex.height);
	}

	DrawableBitmap bitmap = mMovementSliderButtonDrawable;

	if (mMovementSliderButtonPressed) {
	bitmap = mMovementSliderButtonDepressedDrawable;
	}

	render.scheduleForDraw(mMovementSliderBaseDrawable, mMovementSliderBaseLocation, SortConstants.HUD, false);
	render.scheduleForDraw(bitmap, mMovementSliderButtonLocation, SortConstants.HUD + 1, false);

	}


	if (mCoinDrawable != null) {
	if (mCoinDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mCoinDrawable.getTexture();
	mCoinDrawable.resize(tex.width, tex.height);
	mCoinLocation.x = (params.gameWidth / 2.0f) - tex.width / 2.0f;
	mCoinLocation.y = params.gameHeight - tex.height - COLLECTABLE_EDGE_PADDING;
	}

	render.scheduleForDraw(mCoinDrawable, mCoinLocation, SortConstants.HUD, false);
	if (mCoinDigitsChanged) {
	intToDigitArray(mCoinCount, mCoinDigits);
	mCoinDigitsChanged = false;
	}
	final float offset = mCoinDrawable.getWidth() * 0.75f;
	mCoinLocation.x += offset;
	drawNumber(mCoinLocation, mCoinDigits, true);
	mCoinLocation.x -= offset;
	}

	if (mRubyDrawable != null) {
	if (mRubyDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mRubyDrawable.getTexture();
	mRubyDrawable.resize(tex.width, tex.height);
	mRubyLocation.x = (params.gameWidth / 2.0f) + 100.0f;
	mRubyLocation.y = params.gameHeight - tex.height - COLLECTABLE_EDGE_PADDING;
	}
	render.scheduleForDraw(mRubyDrawable, mRubyLocation, SortConstants.HUD, false);
	if (mRubyDigitsChanged) {
	intToDigitArray(mRubyCount, mRubyDigits);
	mRubyDigitsChanged = false;
	}
	final float offset = mRubyDrawable.getWidth() * 0.75f;
	mRubyLocation.x += offset;
	drawNumber(mRubyLocation, mRubyDigits, true);
	mRubyLocation.x -= offset;
	}
	}

	if (mShowFPS) {
	if (mFPSDigitsChanged) {
	int count = intToDigitArray(mFPS, mFPSDigits);
	mFPSDigitsChanged = false;
	mFPSLocation.set(params.gameWidth - 10.0f - ((count + 1) * (mDigitDrawables[0].getWidth() / 2.0f)), 10.0f);

	}
	drawNumber(mFPSLocation, mFPSDigits, false);
	}

	if (mFading && factory != null) {

	final float time = sSystemRegistry.timeSystem.getRealTime();
	final float fadeDelta = (time - mFadeStartTime);

	float percentComplete = 1.0f;
	if (fadeDelta < mFadeDuration) {
	percentComplete = fadeDelta / mFadeDuration;
	} else if (mFadeIn) {
	// We've faded in. Turn fading off.
	mFading = false;
	}

	if (percentComplete < 1.0f \|\| !mFadeIn) {
	float opacityValue = percentComplete;
	if (mFadeIn) {
	opacityValue = 1.0f - percentComplete;
	}

	DrawableBitmap bitmap = factory.allocateDrawableBitmap();
	if (bitmap != null) {
	bitmap.setWidth(params.gameWidth);
	bitmap.setHeight(params.gameHeight);
	bitmap.setTexture(mFadeTexture);
	bitmap.setCrop(0, mFadeTexture.height, mFadeTexture.width, mFadeTexture.height);
	bitmap.setOpacity(opacityValue);
	render.scheduleForDraw(bitmap, Vector2.ZERO, SortConstants.FADE, false);
	}
	}

	if (percentComplete >= 1.0f && mFadePendingEventType != GameFlowEvent.EVENT_INVALID) {
	LevelSystem level = sSystemRegistry.levelSystem;
	if (level != null) {
	level.sendGameEvent(mFadePendingEventType, mFadePendingEventIndex, false);
	mFadePendingEventType = GameFlowEvent.EVENT_INVALID;
	mFadePendingEventIndex = 0;
	}
	}
	}
	}

	private void drawNumber(Vector2 location, int[] digits, boolean drawX) {
	final RenderSystem render = sSystemRegistry.renderSystem;

	if (mDigitDrawables[0].getWidth() == 0) {
	// first time init
	for (int x = 0; x < mDigitDrawables.length; x++) {
	Texture tex = mDigitDrawables[x].getTexture();
	mDigitDrawables[x].resize(tex.width, tex.height);
	}
	}

	if (mXDrawable.getWidth() == 0) {
	// first time init
	Texture tex = mXDrawable.getTexture();
	mXDrawable.resize(tex.width, tex.height);
	}

	final float characterWidth = mDigitDrawables[0].getWidth() / 2.0f;
	float offset = 0.0f;

	if (mXDrawable != null && drawX) {
	render.scheduleForDraw(mXDrawable, location, SortConstants.HUD, false);
	location.x += characterWidth;
	offset += characterWidth;
	}

	for (int x = 0; x < digits.length && digits[x] != -1; x++) {
	int index = digits[x];
	DrawableBitmap digit = mDigitDrawables[index];
	if (digit != null) {
	render.scheduleForDraw(digit, location, SortConstants.HUD, false);
	location.x += characterWidth;
	offset += characterWidth;
	}
	}

	location.x -= offset;


	}

	public int intToDigitArray(int value, int[] digits) {
	int characterCount = 1;
	if (value >= 1000) {
	characterCount = 4;
	} else if (value >= 100) {
	characterCount = 3;
	} else if (value >= 10) {
	characterCount = 2;
	}

	int remainingValue = value;
	int count = 0;
	do {
	int index = remainingValue != 0 ? remainingValue % 10 : 0;
	remainingValue /= 10;
	digits[characterCount - 1 - count] = index;
	count++;
	} while (remainingValue > 0 && count < digits.length);

	if (count < digits.length) {
	digits[count] = -1;
	}
	return characterCount;
	}

	public void sendGameEventOnFadeComplete(int eventType, int eventIndex) {
	mFadePendingEventType = eventType;
	mFadePendingEventIndex = eventIndex;
	}


	}