Game character items LibGDX - libgdx

I'm working on simple 2D platformer game where player walk and collect items (like gun's, sword's, etc). So here is my player (or character)
public class CoolGuy extends GameObject {
private Rectangle bottom, left, right, top, full;
private Sprite sprite;
public CoolGuy(){
full = new Rectangle(0, 0, 50, 98);
bottom = new Rectangle(0, 0, 50, 15);
top = new Rectangle(0, 83, 50, 15);
left = new Rectangle(0, 15, 25, 68);
right = new Rectangle(25, 15, 25, 68);
sprite = new Sprite(TextureManager.coolGuy);
sprite.setSize(50, 98);
}
/* lots of code here */
}
also I have my Item class. When player collides with this class sprite (and rectangle) player should gain new power (like shooting and so on...)
public class Gun extends ItemObject{
private Sprite sprite;
private Rectangle full;
public Gun(int x, int y){
sprite = new Sprite(TextureManager.gunItem);
sprite.setSize(25, 15);
full = new Rectangle(0, 0, 25, 15);
setPosition(x, y);
}
#Override
public int hits(Rectangle r) {
if(full.overlaps(r)){
return 1;
}
return -1;
}
/* lots of code here */
}
And here is my new power class. In this case new power is shooting.
public class PlayerBullet extends ItemObject{
private Sprite sprite;
private Rectangle full;
public PlayerBullet(){
sprite = new Sprite(TextureManager.playerBullet);
sprite.setSize(15, 15);
full = new Rectangle(0,0,15,15);
}
#Override
public int hits(Rectangle r) {
if(full.overlaps(r)){
return 9;
}
return -1;
}
/* A lot of code here */
}
So how I need to add this power to my player? I know I could have lots of booleans and even PlayerBullet object in my CoolGuy (player class) and set them all to null and later if player collides with my Gun class I could create new object and so on... But I believe there are other way.

Make a reference to an "ItemObject" in your player class and don't initialize it yet. This reference will keep track of your current powerup. When the player walks over the sprite, set the referance to that object. Now when you want to do item specific actions, put those actions/methods inside powerup class, which in your case is PlayerBullet. Now you don't need to check which item your player has and you can perform item specific actions efficiantly.
CoolGuy class:
public class CoolGuy extends GameObject {
private Rectangle bottom, left, right, top, full;
private Sprite sprite;'
ItemObject currentItem;
public CoolGuy(){
full = new Rectangle(0, 0, 50, 98);
bottom = new Rectangle(0, 0, 50, 15);
top = new Rectangle(0, 83, 50, 15);
left = new Rectangle(0, 15, 25, 68);
right = new Rectangle(25, 15, 25, 68);
sprite = new Sprite(TextureManager.coolGuy);
sprite.setSize(50, 98);
}
public void equipItem(ItemObject item){
currentItem = item;
}
/* lots of code here */
}
You can call this equipItem() method and pass it the object that collides with player. For using powerup, you can add another method to PlayerBullet or Gun:
public void ItemUsed(){
//item use effect
}
And then make another method in Player and call ItemUsed from that method:
public void useItem(){
//check if player has any item
if(currentItem != null){
//if it has then use item
currentItem.useItem();
}
}
Of course you will have to add an ArrayList or Array of you want to equip more than one item at a time.
This was just a sample or an idea for how you can implement what you want. You will have to do a few extra things to get it working.

#user3334375 You Just Have to draw this box carefully. Mean that If you are giving some points with this Gun power box check that If points are counted then remove box.
For example
if (!powerboxscored){Draw power box} //
this method takes powerboxscored boolean.
If the boolean is false it will draw this box untill the boolean becomes true and it will only become true when u add power in ur code...
I hope it helps..

Related

TextButton does not receive clicks in LibGDX

Here is my code:
public WelcomeScreen(final WallGame game) {
this.game = game;
// Setting up camera and viewport.
camera = new OrthographicCamera();
viewport = new StretchViewport(GAME_WORLD_WIDTH, GAME_WORLD_HEIGHT, camera);
viewport.apply();
stage = new Stage(viewport);
camera.position.set(camera.viewportWidth / 2, camera.viewportHeight / 2, 0);
Gdx.input.setInputProcessor(stage);
skin = new Skin(Gdx.files.internal("uiskin.json"));
skin.getFont("default-font").getData().setScale(0.1f, 0.1f);
backgroundTxtr = new Texture(Gdx.files.internal("background/background.png"));
background = new Image(backgroundTxtr);
background.setBounds(0, 0, GAME_WORLD_WIDTH, GAME_WORLD_HEIGHT);
final TextButton button = new TextButton("start", skin, "red-button");
button.setBounds(10, 10, 50, 50);
button.setTouchable(Touchable.enabled);
button.addListener(new ClickListener() {
public void clicked(InputEvent event, float x, float y) {
Gdx.app.log("AKS", "CLICKED");
}
});
final Dialog dialog = new Dialog("Click Message", skin);
dialog.setBounds(50, 50, 40, 40);
stage.addActor(background);
stage.addActor(button);
stage.addActor(dialog);
}
I can't seem to make the button work, I have an image to be shown when the button is clicked (the "down" attribute of the TextButton) but it doesn't change. What am I doing wrong?
I figured it out. I hadn't created a Table object to add the button into. It worked after I did that.

libGDX 1.4.1 can't slow down animations

This is what I have:
...
private Array<Sprite> fireballFadeOutAnim;
private Array<Sprite> bucketFadeOutAnim;
private TextureAtlas fballAnimSheet;
private TextureAtlas bucketAnimSheet;
private Animation catch_animation;
private Animation visual_feedback;
private float elapsedTime = 0f;
...
#Override
public void create () {
...
fballAnimSheet = new TextureAtlas("animations/fireball_fadeout.txt");
bucketAnimSheet = new TextureAtlas("animations/bucket_fadeout.txt");
fireballFadeOutAnim = fballAnimSheet.createSprites("fireball_fadeout");
bucketFadeOutAnim = bucketAnimSheet.createSprites("bucket_fadeout");
catch_animation = new Animation(1/15f, fballAnimSheet.getRegions(), Animation.PlayMode.NORMAL);
visual_feedback = new Animation(1/15f, bucketAnimSheet.getRegions(), Animation.PlayMode.LOOP);
...
}
#Override
public void render () {
...
// Set the anim_elipsed_time
elapsedTime += Gdx.graphics.getDeltaTime();
...
// I try to draw them later on (under the render method) like this:
// Start and draw animation of fireball catch
batch.begin();
batch.draw(catch_animation.getKeyFrame(elapsedTime, true), fireBallRect.getX(), fireBallRect.getY());
batch.end();
}
I can see both animations happening extremely fast (they look like a white-flash), they do not loop even if the animation mode is set to "LOOP".
What am I doing wrong ? I can't seem to be able to slow them down or to have them LOOP. Thanks much.
Edited:
As requested, I upload all the code
public class MainActivity extends ApplicationAdapter {
public enum State {
PAUSE,
RUN,
RESUME,
STOPPED
}
public static State state = State.RUN;
private SpriteBatch batch;
private OrthographicCamera camera;
private Stage stage;
private Texture backgroundImage;
private Texture bucketImage;
private Texture fireballImage;
private Texture heart;
private TextureRegion criticalTexture;
private Sprite backgroundSprit;
private Sprite bucketSprite;
private Sprite fireballSprite;
private Sprite heartSprite;
private Rectangle bucketRect;
private Rectangle fireBallRect;
private Rectangle bucketSpriteRect;
private ShapeRenderer bucketRenderer;
private ShapeRenderer fireballRenderer;
private Button pauseButton;
private Array<Rectangle> fireballArray;
private Skin progressBarSkin;
private long lastFireballTime;
public static Sound bucket_tap;
public static Sound bucket_drag;
private Sound fireball_missed_sound;
private Sound catchFireball;
private Sound pauseBtnSound;
private Music bgMusic;
private float volume = 0.30f; // music and sfx volume control
public static int w;
public static int h;
private int barLength = 325;
private int numberOfFails = 10; // change numberOfFails to increase or decrese
// the total num. of missed fireballs the player
private int deductedBarSegment = barLength / numberOfFails;
private int numOfBallsLeft = numberOfFails; // use this var to check how many fballs left
private long fireballFrequency = 1000000000L; // change fireballFrequency to increase or decrease
// the number of fireballs on the screen
private int fireballSpeed = 400; // change the fireballSpeed to increase or decrease
// the speed at which the fireballs fall
private InputProcessor gameInputProcessor; // this sets the game input controller for the bucket
private InputMultiplexer multiplexer; // this sets the input processors from the game and UI
/************************************ Animation Properties ************************************/
private TextureAtlas fballAtlas;
private TextureAtlas bucketAtlas;
private Animation catch_animation;
private Animation visual_feedback;
private float elapsedTime = 0f;
private Actor feedbackPanel;
/**********************************************************************************************/
#Override
public void create () {
// Parse Test
//ParseObject testObject = new ParseObject("TestObject");
//testObject.put("foo", "bar");
//testObject.saveInBackground();
// Catch the dynamic size of the screen based on the device that's ran on
w = Gdx.graphics.getWidth();
h = Gdx.graphics.getHeight();
// Set up the camera
camera = new OrthographicCamera();
camera.setToOrtho(false, (float)w, (float)h);
// Instantiate the batch
batch = new SpriteBatch();
/***************************** These renders are for debugging only *****************************/
bucketRenderer = new ShapeRenderer();
fireballRenderer = new ShapeRenderer();
/**************************************************************************************************/
/******************************************** Stage and HUD ***************************************/
stage = new Stage();
pauseButton = new Button(new TextureRegionDrawable(
new TextureRegion(new Texture(Gdx.files.internal("images/pase_button_red.png")))),
new TextureRegionDrawable(new TextureRegion(new Texture(Gdx.files.internal("images/pase_button_white.png")))));
pauseButton.setX(flipCoordinates(w, 150));
pauseButton.setY(flipCoordinates(h, 170));
pauseButton.act(Gdx.graphics.getDeltaTime());
stage.addActor(pauseButton);
pauseButton.addListener(new ChangeListener() {
#Override
public void changed (ChangeEvent event, Actor actor) {
// Do something when the pauseButton is pressed
// Control multiple touches on the pauseButton
if(state == State.RUN) {
state = State.PAUSE;
pauseBtnSound.play();
// Set the pauseButton icon to the white version
//pauseButton.setColor(Color.WHITE);
}
else {
state = State.RUN;
pauseBtnSound.play();
}
}
});
// Add the critical_life indicator to the stage as an actor
criticalTexture = new TextureRegion(new Texture(Gdx.files.internal("images/critical_life.png")));
feedbackPanel = new Actor() {
public void draw(Batch batch, float alpha) {
batch.draw(criticalTexture, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
getScaleX(), getScaleY(), getRotation());
}
};
feedbackPanel.setBounds(w / 2, h / 2,
criticalTexture.getRegionWidth(), criticalTexture.getRegionHeight());
// Set up an Action for the critical life actor
feedbackPanel.addAction(forever(sequence(scaleTo(2, 2, 0.5f), scaleTo(1, 1, 0.5f), delay(0.5f))));
feedbackPanel.act(Gdx.graphics.getDeltaTime());
stage.addActor(feedbackPanel);
/**************************************************************************************************/
/*********************************** Set up the Input Controllers *********************************/
// The multiplexer helps target several input processes (in this case, the stage and the
// InputProcessor.class)
multiplexer = new InputMultiplexer();
multiplexer.addProcessor(stage);
multiplexer.addProcessor(new GameInputProcessor());
// InputAdaptor
Gdx.input.setInputProcessor(multiplexer);
/**************************************************************************************************/
backgroundImage = new Texture("images/bg.jpg");
bucketImage = new Texture("images/bucket_small.png");
fireballImage = new Texture("images/fireball_small.png");
heart = new Texture("images/heart.png");
/*************************************** Animations Setup *****************************************/
fballAtlas = new TextureAtlas("animations/fireball_fadeout.txt");
bucketAtlas = new TextureAtlas("animations/bucket_fadeout.txt");
catch_animation = new Animation(0.50f, fballAtlas.getRegions());
visual_feedback = new Animation(0.15f, bucketAtlas.getRegions());
/**************************************************************************************************/
// Instantiate all sounds
bucket_tap = Gdx.audio.newSound(Gdx.files.internal("sounds/bucket_tap.ogg"));
bucket_drag = Gdx.audio.newSound(Gdx.files.internal("sounds/bucket_drag.ogg"));
fireball_missed_sound = Gdx.audio.newSound(Gdx.files.internal("sounds/fireball_missed.ogg"));
catchFireball = Gdx.audio.newSound(Gdx.files.internal("sounds/fastSteam.ogg"));
pauseBtnSound = Gdx.audio.newSound(Gdx.files.internal("sounds/pauseBtn_sound.ogg"));
bgMusic = Gdx.audio.newMusic(Gdx.files.internal("sounds/music_bg.mp3"));
bgMusic.setLooping(true);
bgMusic.play(); // <----------- turn bg music on/off
// Instantiate the progressBarSkin
progressBarSkin = new Skin();
progressBarSkin.add("progressBarBg", new Texture("images/progress-bar_bg.png"));
progressBarSkin.add("progressBar", new Texture("images/progress-bar_dynamic_red.png"));
// Create bg sprite
backgroundSprit = new Sprite(backgroundImage);
//backgroundSprit.setPosition((float)w / 2, (float)h / 2);
//backgroundSprit.setSize((float)w, (float)h);
// Bucket sprite
bucketSprite = new Sprite(bucketImage);
// Fireball sprite
fireballSprite = new Sprite(fireballImage);
// Heart sprite
heartSprite = new Sprite(heart);
// Set the bucketRect into the rect from the bucketSprite (THE GREEN ONE)
bucketSpriteRect = bucketSprite.getBoundingRectangle();
bucketSpriteRect.x = w / 2 - 100 / 2;
bucketSpriteRect.y = 20;
bucketSpriteRect.setSize(200, 200);
// Set the collision rectangle (THE RED ONE)
bucketRect = new Rectangle();
bucketRect.x = bucketSpriteRect.getX() + 70; // <---- adjust position left/right
bucketRect.y = bucketSpriteRect.getY() + 150; // <---- adjust position up/down
bucketRect.setSize(100, 10);
// Set a rectangle for each fireball sprite (THE WHITE ONE)
fireBallRect = new Rectangle();
fireBallRect.x = fireballSprite.getX();
fireBallRect.y = fireballSprite.getY();
fireBallRect.width = 55;
fireBallRect.height = 55;
fireballArray = new Array<Rectangle>();
}
#Override
public void render () {
// Devide the Render method into a few switch cases based on the game's state
switch (state) {
case RUN:
// Do all the batch drawing here
Gdx.gl.glClearColor(1, 1, 1, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
elipsedTime += Gdx.graphics.getDeltaTime();
batch.setProjectionMatrix(camera.combined);
batch.begin();
batch.draw(backgroundSprit, 0, 0, w, h);
batch.draw(bucketSprite, bucketSpriteRect.x, bucketSpriteRect.y,
bucketSprite.getWidth() - 160, bucketSprite.getHeight() - 140);
for(Rectangle fireball: fireballArray) {
batch.draw(fireballSprite, fireball.x, fireball.y,
fireballSprite.getWidth() - 20, fireballSprite.getHeight() - 20);
}
batch.draw(progressBarSkin.getSprite("progressBarBg"), 200, flipCoordinates(h, 170));
batch.draw(progressBarSkin.getSprite("progressBar"),
210, flipCoordinates(h, 162), barLength, 6); // <---- modify x, x, <x>, x to adjust the length of the life-bar
batch.draw(heartSprite, 95, flipCoordinates(h, 200), 90, 76);
stage.act(Gdx.graphics.getDeltaTime());
stage.draw();
batch.end();
/***************************************Debugging Rectangles************************************/
// Draw rects around sprites
// bucketRenderer.begin(ShapeRenderer.ShapeType.Line);
// bucketRenderer.setColor(Color.GREEN);
// bucketRenderer.rect(bucketSpriteRect.getX(), bucketSpriteRect.getY(),
// bucketSprite.getWidth() - 160, bucketSprite.getHeight() -140);
// bucketRenderer.end();
//
// bucketRenderer.begin(ShapeRenderer.ShapeType.Line);
// bucketRenderer.setColor(Color.RED);
// bucketRenderer.rect(bucketRect.getX(), bucketRect.getY(), 100, 10);
// //bucketRenderer.point(bucketRect.getX(), bucketRect.getY(), 0f);
// bucketRenderer.end();
//
// fireballRenderer.begin(ShapeRenderer.ShapeType.Line);
// fireballRenderer.setColor(Color.WHITE);
// fireballRenderer.rect(fireBallRect.x, fireBallRect.y,
// fireballSprite.getWidth() - 20, fireballSprite.getHeight() - 20);
// fireballRenderer.end();
// To avoid sprite flickering, surround batch.draw with a game state check
if (state != State.PAUSE) {
Iterator<Rectangle> iter = fireballArray.iterator();
while(iter.hasNext()) {
fireBallRect = iter.next();
fireBallRect.y -= fireballSpeed * Gdx.graphics.getDeltaTime();
// Remove the fireBallRect from the array as soon as it leaves the screen
if(fireBallRect.y + 106 < 0) {
iter.remove();
// The player missed the fireball, play a the fireball_missed_sound
fireball_missed_sound.play();
// Subtract a ball from the total number allowed to be missed
numOfBallsLeft --;
// Call life deduction
deductLifePoints();
// Check to see if this is the last fball left to fail
if (numOfBallsLeft == 1) {
}
// Check to see if life points are 0 or < 0
if (numOfBallsLeft <= 0) {
// Game over logic
barLength = 0;
// Set the game state to PAUSED
//state = State.PAUSE;
//bucketSprite.setColor(Color.RED);
batch.begin();
batch.draw(bucketSprite, bucketSpriteRect.x, bucketSpriteRect.y,
bucketSprite.getWidth() - 160, bucketSprite.getHeight() - 140);
batch.end();
}
}
// Collision detector
if(bucketRect.overlaps(fireBallRect)) {
catchFireball.play(volume);
// Start and draw animagion of fireball catch
batch.begin();
batch.draw(catch_animation.getKeyFrame(elapsedTime, true), fireBallRect.getX(), fireBallRect.getY());
batch.end();
// Remove the fireball that collides with the bucket
iter.remove();
}
}
}
// Touch input controller
if(Gdx.input.isTouched()) {
Vector3 touchPos = new Vector3();
touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
camera.unproject(touchPos);
if(touchPos.y <= 250) {
bucketSpriteRect.setX(touchPos.x - 115);
bucketRect.setX(touchPos.x - 50); // <---- adjust position left/right on touch
}
}
if(TimeUtils.nanoTime() - lastFireballTime > fireballFrequency) {
fireBallRect = new Rectangle();
fireBallRect.x = MathUtils.random(50, w - 270);
fireBallRect.y = h;
fireBallRect.width = 75;
fireBallRect.height = 75;
fireballArray.add(fireBallRect);
lastFireballTime = TimeUtils.nanoTime();
}
/**************************************************************************************************/
break;
case PAUSE:
// Pause the game here
/******************************** Redraw the sprites to avoid flickering **************************/
batch.begin();
batch.draw(backgroundSprit, 0, 0, w, h);
batch.draw(bucketSprite, bucketSpriteRect.x, bucketSpriteRect.y,
bucketSprite.getWidth() - 160, bucketSprite.getHeight() - 140);
for(Rectangle fireball: fireballArray) {
batch.draw(fireballSprite, fireball.x, fireball.y,
fireballSprite.getWidth() - 20, fireballSprite.getHeight() - 20);
}
batch.draw(progressBarSkin.getSprite("progressBarBg"), 200, flipCoordinates(h, 170));
batch.draw(progressBarSkin.getSprite("progressBar"),
210, flipCoordinates(h, 162), barLength, 6); // <---- modify x, x, <x>, x to adjust the length of the life-bar
batch.draw(heartSprite, 95, flipCoordinates(h, 200), 90, 76);
//pauseButton.draw(batch, 1);
stage.act(Gdx.graphics.getDeltaTime());
stage.draw();
batch.end();
/**************************************************************************************************/
break;
case RESUME:
break;
default:
break;
}
}
/************************************* Implement Dispose **************************************/
#Override
public void dispose() {
batch.dispose();
bucketRenderer.dispose();
fireballRenderer.dispose();
backgroundImage.dispose();
bucketImage.dispose();
fireballImage.dispose();
bucket_tap.dispose();
bucket_drag.dispose();
catchFireball.dispose();
bgMusic.dispose();
fireball_missed_sound.dispose();
progressBarSkin.dispose();
fballAtlas.dispose();
stage.dispose();
}
/************************************* Flip Coordinates Method ********************************/
public static float flipCoordinates(float height, float xORy) {
float newPosition = height - xORy;
return newPosition;
}
/************************************** Deduces Life Points ***********************************/
private void deductLifePoints() {
barLength -= deductedBarSegment;
}
/************************************** Set the Game's state **********************************/
public void setGameState(State s) {
this.state = s;
}
/******************************** Android's Lyfe-Cycle Overrides ******************************/
#Override
public void pause() {
super.pause();
this.state = State.PAUSE;
}
#Override
public void resume() {
super.resume();
this.state = State.PAUSE;
}
}
The first parameter of the Animation constructor is the frameDuration in seconds. You are passing it 1/15f, which is really fast. Try something greater, like 0.15f.

How to make a sprite blink X seconds?

I'm using libGDX and I want to make my main character of my game to blinking x seconds on enemy touch (lose life)
Can someone tell me how can I make sprite to blinding?
Here is my solution, I use it exactly for the same purpose you described (blinking character when he injured).
public class Blinker {
private float BLINK_TIME = 1f;
private int BLINKING_FRAMES = 4;
private boolean isBlinking;
private int blinkFrameCounter;
private float blinkTimer;
public Blinker() {
this.blinkTimer = 0;
this.blinkFrameCounter = 0;
this.isBlinking = false;
}
public boolean shouldBlink(float delta) {
if (isBlinking) {
blinkTimer += delta;
blinkFrameCounter++;
if (blinkTimer < BLINK_TIME) {
if (blinkFrameCounter % BLINKING_FRAMES == 0) {
return true;
}
} else {
blinkTimer = 0;
isBlinking = false;
}
}
return false;
}
public boolean isBlinking() {
return isBlinking;
}
public void setBlinking(boolean isBlinking) {
this.isBlinking = isBlinking;
}
}
Usage:
first init the blinker object;
Blinker blinker= new Blinker();
blinker.setBlinking(true);
and then just add this to your draw() method (I suppose that you have separate method for drawing character, which you call in your screen draw method), before you draw the sprite you want to blink.
if (blinker.shouldBlink(delta))
return;
I recommend looking at something like this.
https://github.com/libgdx/libgdx/wiki/2D-Animation
You use this technique and adjust the frame duration.
walkAnimation = new Animation(0.025f, walkFrames); // #11
When you need to start making the animation blink faster. adjust the frame duration value.
public void setFrameDuration(float frameDuration)
I recommend doing it this way but if you HAVE to tint it w/e.... I guess this works.
private Texture texture;
private TextureRegion region;
private Sprite sprite;
...
texture = new Texture(Gdx.files.internal("image.png"));
region = new TextureRegion(texture, 20, 20, 50, 50);
sprite = new Sprite(texture, 20, 20, 50, 50);
sprite.setPosition(100, 10);
sprite.setColor(0, 0, 1, 1);
...
batch.begin();
batch.setColor(1, 0, 0, 1);
batch.draw(texture, 10, 10);
batch.setColor(0, 1, 0, 1);
batch.draw(region, 50, 10);
sprite.draw(batch);
batch.end();
key thing is Alpha is ignored if blending is disabled.
The previous answer from prgenhard will work, but I don't think that is sufficient enough, if you are using it without care.
You can use TweenEngine to interpolate alpha value with different functions.
It can be really cool.
Those values you can set on sprite's or actor's alpha and easily achieve flashing effect.
You can read more about it here:
http://www.aurelienribon.com/blog/projects/universal-tween-engine/
It should be enough.
And also it can be easily used within Libgdx engine.
Hope this helps.

how can I change the color of one shape by clicking on clicking another object of sprite in actionscript

I have drawn intersecting lines. The user can click on a region inside the angle formed by the two lines.When the user clicks inside the area, the small region formed by the arc between the two lines showing the angle should change. How can I do that.the region between the intersecting lines is sprite object to dispatch event listener, but the arc is shape object.
public class changeColor extends Sprite {
private var mySpr:Sprite;
public function changeColor() {
super();
mySpr = new Sprite();
mySpr.graphics.beginFill(0xFF0000, 1);
mySpr.graphics.drawRect(0, 0, 100, 100);
mySpr.graphics.endFill();
mySpr.addEventListener(MouseEvent.CLICK, action);
addChild(mySpr);
}
public function changeSprColor(inputColor:uint):void {
var myCt:ColorTransform = new ColorTransform();
myCt.color = inputColor;
mySpr.transform.colorTransform = myCt;
}
private function action(e:MouseEvent):void {
changeSprColor(0x00FF00);
}
}

How to send image data to a custom class?

I'm trying to create a custom class that will create a tile (a small rounded square) when requested, with a small image on it. I can successfully create the tile, as shown in the code below, but I don't know how to pass the class the pictures data.
Is it possible to do this using bitmapData, or by referancing it throught the library (if i store my picture in a movieclip in the library?
Here is my class so far:
package com{
import flash.display.MovieClip;
import fl.transitions.Tween;
import fl.transitions.easing.Strong;
public class tileCreator extends MovieClip{
public var tiled:MovieClip;
public var sourceImage:MovieClip = new MovieClip;
public function tileCreator() {
trace("tile creator");
tiled = new MovieClip;
tiled.graphics.beginFill(0x666666, 0.3);
tiled.graphics.drawRoundRect(-55/2, -55/2, 55, 55, 15, 15);
this.addChild(tiled);
}
}
}
yes, it's possible using BitmapData.
import an image to the library and right-click it to change "settings ...".
you have to check "export for actionscript" and put a name into the second textfield underneath the checkbox - let's say 'MyImage'. (flash automatically adds the base-class of type flash.display.BitmapData).
then you can create an instance of the image saying:
var myImage:MyImage = new MyImage();
it's a BitmapData object, because your MyImage class extends BitmapData.
then you just have to add the BitmapData to the constructor as an argument (rename your class to Tile, because it's not a creator but the tile itself you create. and use a capital letter!).
public class Tile extends MovieClip
{
public function Tile (img:BitmapData)
{
var bmp:Bitmap = new Bitmap(img);
addChild(bmp);
tiled = new MovieClip;
tiled.graphics.beginFill(0x666666, 0.3);
tiled.graphics.drawRoundRect(-55/2, -55/2, 55, 55, 15, 15);
addChild(tiled);
bmp.mask = tiled;
}
}
you need to do it in the folowin way:
function createBitmap ( yourMovieClipYouWantToBeAsImage : DisplayObject ) : Bitmap
{
var bitmapData:BitmapData = new BitmapData ( width, height );
bitmapData.draw ( yourMovieClipYouWantToBeAsImage );
var bitmap:Bitmap = new Bitmap ( bitmapData );
return bitmap; // do what ever you want with it but now as an image
}
You can create a "snapshot" of this using bitmapData. You can then pass this to any other class you want. Code is shown below.
//This code goes into your TileCreator-class
public function draw():BitmapData
{
//True and 0 at the end of creating this bitmap ensure transparancy
//for the transparant pixels (else these would be opaque)
var bmp:BitmapData = new BitmapData(width, height, true, 0);
bmp.draw(this);
return bmp;
}