2

我正在制作某种“游戏分数跟踪器”。以下是该应用程序当前的工作方式：

  1. 用户通过在 EditText 中输入名称然后单击确定按钮来添加玩家。
  2. 用户添加完新玩家后，他按下“开始游戏”按钮，一个新的活动打开。
  3. 玩家被添加到 Parcelable extra 并被带到下一个活动。
  4. 在下一个活动中，用户有一个微调器、EditText 和 +、- 按钮。在用户从微调器中选择某个玩家后，输入某个分数，然后输入一个 + 或 -，一个新的 TextView 将出现，其中包含玩家名称和分数。

示例：如果有 3 名玩家“詹姆斯、约翰和罗伯特”。然后用户给 James 加 5 分，给 John 加 10 分，给 Robert 加 15 分。这就是 TextView 的样子：

詹姆斯 5

约翰福音 10

罗伯特 15

然后，如果用户再次执行完全相同的操作，则会发生这种情况：

詹姆斯 5

约翰福音 10

罗伯特 15

詹姆斯 10

约翰 20

罗伯特 30

正如你所看到的，我没有为每个玩家保留相同的 TextView，但我一直在添加它们（我确实想要这样，我希望用户能够看到他的动作，当他点击 - 和 + 时。但是有办法为每个用户设置颜色吗？例如：James 是蓝色，John 是红色，Robert 是绿色。如何预先确定每个 Player 的 TextView 的颜色？

球员等级：

public static class Player implements Parcelable{
    String name;
    int score;
    @Override
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(score);
        dest.writeString(name);
    }

    public Player(Parcel source){
        score = source.readInt();
        name = source.readString();
    }

    public Player(){
    }

    public static final Parcelable.Creator<Player> CREATOR = new Parcelable.Creator<Novaigra.Player>() {

        @Override
        public Player createFromParcel(Parcel source) {
            return new Player(source);
        }

        @Override
        public Player[] newArray(int size) {
            return new Player[size];
        }
    };
}

我可以在添加玩家时向活动添加某种调色板，以便用户可以预先确定颜色或其他东西吗？

4

2 回答 2

0

这是一个颜色选择器，android没有内置的，随意修改它以满足您的需要

import android.app.Dialog;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.Shader;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;

public class ColorPickerDialog extends Dialog {

public interface OnColorChangedListener {
    void colorChanged(String key, int color);
}

private OnColorChangedListener mListener;
private int mInitialColor, mDefaultColor;
private String mKey;

private class ColorPickerView extends View {
    private Paint mPaint;
    private float mCurrentHue = 0;
    private int mCurrentX = 0, mCurrentY = 0;
    private int mCurrentColor, mDefaultColor;
    private final int[] mHueBarColors = new int[258];
    private int[] mMainColors = new int[65536];
    private OnColorChangedListener mListener;
    private int width,height;

    ColorPickerView(Context c, OnColorChangedListener l, int color,
            int defaultColor) {
        super(c);
        mListener = l;
        mDefaultColor = defaultColor;

        // Get the current hue from the current color and update the main
        // color field
        float[] hsv = new float[3];
        Color.colorToHSV(color, hsv);
        mCurrentHue = hsv[0];
        updateMainColors();

        mCurrentColor = color;

        // Initialize the colors of the hue slider bar
        int index = 0;
        for (float i = 0; i < 256; i += 256 / 42) // Red (#f00) to pink
                                                    // (#f0f)
        {
            mHueBarColors[index] = Color.rgb(255, 0, (int) i);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) // Pink (#f0f) to blue
                                                    // (#00f)
        {
            mHueBarColors[index] = Color.rgb(255 - (int) i, 0, 255);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) // Blue (#00f) to light
                                                    // blue (#0ff)
        {
            mHueBarColors[index] = Color.rgb(0, (int) i, 255);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) // Light blue (#0ff) to
                                                    // green (#0f0)
        {
            mHueBarColors[index] = Color.rgb(0, 255, 255 - (int) i);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) // Green (#0f0) to yellow
                                                    // (#ff0)
        {
            mHueBarColors[index] = Color.rgb((int) i, 255, 0);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) // Yellow (#ff0) to red
                                                    // (#f00)
        {
            mHueBarColors[index] = Color.rgb(255, 255 - (int) i, 0);
            index++;
        }

        // Initializes the Paint that will draw the View
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setTextAlign(Paint.Align.CENTER);
        mPaint.setTextSize(12);
    }

    // Get the current selected color from the hue bar
    private int getCurrentMainColor() {
        int translatedHue = 255 - (int) (mCurrentHue * 255 / 360);
        int index = 0;
        for (float i = 0; i < 256; i += 256 / 42) {
            if (index == translatedHue)
                return Color.rgb(255, 0, (int) i);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) {
            if (index == translatedHue)
                return Color.rgb(255 - (int) i, 0, 255);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) {
            if (index == translatedHue)
                return Color.rgb(0, (int) i, 255);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) {
            if (index == translatedHue)
                return Color.rgb(0, 255, 255 - (int) i);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) {
            if (index == translatedHue)
                return Color.rgb((int) i, 255, 0);
            index++;
        }
        for (float i = 0; i < 256; i += 256 / 42) {
            if (index == translatedHue)
                return Color.rgb(255, 255 - (int) i, 0);
            index++;
        }
        return Color.RED;
    }

    // Update the main field colors depending on the current selected hue
    private void updateMainColors() {
        int mainColor = getCurrentMainColor();
        int index = 0;
        int[] topColors = new int[256];
        for (int y = 0; y < 256; y++) {
            for (int x = 0; x < 256; x++) {
                if (y == 0) {
                    mMainColors[index] = Color.rgb(
                            255 - (255 - Color.red(mainColor)) * x / 255,
                            255 - (255 - Color.green(mainColor)) * x / 255,
                            255 - (255 - Color.blue(mainColor)) * x / 255);
                    topColors[x] = mMainColors[index];
                } else
                    mMainColors[index] = Color.rgb(
                            (255 - y) * Color.red(topColors[x]) / 255,
                            (255 - y) * Color.green(topColors[x]) / 255,
                            (255 - y) * Color.blue(topColors[x]) / 255);
                index++;
            }
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        int translatedHue = 255 - (int) (mCurrentHue * 255 / 360);
        // Display all the colors of the hue bar with lines
        for (int x = 0; x < 256; x++) {
            // If this is not the current selected hue, display the actual
            // color
            if (translatedHue != x) {
                mPaint.setColor(mHueBarColors[x]);
                mPaint.setStrokeWidth(1);
            } else // else display a slightly larger black line
            {
                mPaint.setColor(Color.BLACK);
                mPaint.setStrokeWidth(3);
            }
            canvas.drawLine(x + 10, 0, x + 10, 40, mPaint);
            // canvas.drawLine(0, x+10, 40, x+10, mPaint);
            //canvas.drawLine(x + width/27, 0, x + width/27,height/8 , mPaint);
        }

        // Display the main field colors using LinearGradient
        for (int x = 0; x < 256; x++) {
            int[] colors = new int[2];
            colors[0] = mMainColors[x];
            colors[1] = Color.BLACK;
            Shader shader = new LinearGradient(0, 50, 0, 306, colors, null,
                    Shader.TileMode.REPEAT);//0,50,0,306
            mPaint.setShader(shader);
            canvas.drawLine(x + 10, 50, x + 10, 306, mPaint);
            //canvas.drawLine(x + width/27, height/8 + 10, x + width/27, height*(5/6), mPaint);
        }
        mPaint.setShader(null);

        // Display the circle around the currently selected color in the
        // main field
        if (mCurrentX != 0 && mCurrentY != 0) {
            mPaint.setStyle(Paint.Style.STROKE);
            mPaint.setColor(Color.BLACK);
            canvas.drawCircle(mCurrentX, mCurrentY, 10, mPaint);
        }

        // Draw a 'button' with the currently selected color
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(mCurrentColor);
        //canvas.drawRect(10, 316, 138, 356, mPaint);
        //canvas.drawRect(width/27, height*(5/6), width/2, height, mPaint);

        // Set the text color according to the brightness of the color
        if (Color.red(mCurrentColor) + Color.green(mCurrentColor)
                + Color.blue(mCurrentColor) < 384)
            mPaint.setColor(Color.WHITE);
        else
            mPaint.setColor(Color.BLACK);
       // canvas.drawText(
               // "New Color", 74,
                //340, mPaint);

        // Draw a 'button' with the default color
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(mDefaultColor);
        //canvas.drawRect(138, 316, 266, 356, mPaint);
        //canvas.drawRect(width/2, height*(5/6), width, height, mPaint);

        // Set the text color according to the brightness of the color
        if (Color.red(mDefaultColor) + Color.green(mDefaultColor)
                + Color.blue(mDefaultColor) < 384)
            mPaint.setColor(Color.WHITE);
        else
            mPaint.setColor(Color.BLACK);
        //canvas.drawText(
              //  "Default Color", 202, 340,
                //mPaint);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(276,366 );//276,366
        width = widthMeasureSpec;
        height = heightMeasureSpec;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() != MotionEvent.ACTION_DOWN)
            return true;
        float x = event.getX();
        float y = event.getY();

        // If the touch event is located in the hue bar
        if (x > 10 && x < 266 && y > 0 && y < 40) {
            // Update the main field colors
            mCurrentHue = (255 - x) * 360 / 255;
            updateMainColors();

            // Update the current selected color
            int transX = mCurrentX - 10;
            int transY = mCurrentY - 60;
            int index = 256 * (transY - 1) + transX;
            if (index > 0 && index < mMainColors.length)
                mCurrentColor = mMainColors[256 * (transY - 1) + transX];

            // Force the redraw of the dialog
            invalidate();
        }

        // If the touch event is located in the main field
        if (x > 10 && x < 266 && y > 50 && y < 306) {
            mCurrentX = (int) x;
            mCurrentY = (int) y;
            int transX = mCurrentX - 10;
            int transY = mCurrentY - 60;
            int index = 256 * (transY - 1) + transX;
            if (index > 0 && index < mMainColors.length) {
                // Update the current color
                mCurrentColor = mMainColors[index];
                mListener.colorChanged("", mCurrentColor);
                // Force the redraw of the dialog
                invalidate();
            }
        }

        // If the touch event is located in the left button, notify the
        // listener with the current color
        //if (x > 10 && x < 138 && y > 316 && y < 356)
          //  mListener.colorChanged("", mCurrentColor);

        // If the touch event is located in the right button, notify the
        // listener with the default color
        //if (x > 138 && x < 266 && y > 316 && y < 356)
          //  mListener.colorChanged("", mDefaultColor);

        return true;
    }
}

public ColorPickerDialog(Context context, OnColorChangedListener listener,
        String key, int initialColor, int defaultColor) {
    super(context);

    mListener = listener;
    mKey = key;
    mInitialColor = initialColor;
    mDefaultColor = defaultColor;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    OnColorChangedListener l = new OnColorChangedListener() {
        public void colorChanged(String key, int color) {
            mListener.colorChanged(mKey, color);
            dismiss();
        }
    };

    setContentView(new ColorPickerView(getContext(), l, mInitialColor,
            mDefaultColor));
    setTitle("Pick Text Color");

    }
}

然后，当您从 colorchangelistener 中获取 int 颜色时，他们选择或者如果它使用默认值或将 int 保存到播放器中

编辑：我想我去掉了这个默认值，因为它不能很好地跨设备扩展，我不记得了，你可能想通过它检查一下，虽然你需要一个按钮或其他东西来触发颜色选择器，但它可以工作

在你的活动中

import "your package name".ColorPickerDialog

然后做你的活动

implement OnColorChangeListener

然后在颜色选择器的按钮中出现

ColorPickerDialog color = new ColorPickerDialog(this,this, "picker",Color.BLACK,Color.WHITE);
        color.show();

您应该能够覆盖的方法，因为您实现了 OnColorChangeListener 是

@Override
public void colorChanged(String key, int color) {
    // TODO Auto-generated method stub
    paint.setColor(color);
}

我在那里只有paint.setColor（），但是您可以将int color 女巫保存为在颜色选择器中选择的颜色到您的Player 类中，并将其用于文本视图中的文本颜色。

于 2013-08-31T20:12:23.083 回答
0

You can show a color picker dialog to let the user choose a color. Color picker dialog and example of how to use it can be found here: https://github.com/chiralcode/Android-Color-Picker/

于 2013-08-31T20:50:47.500 回答