Android——手机彩票摇晃选号（双色球） 实现原理

实现思路：因为手机传感器每隔一段时间会发送采集到的数据包， 首先获取第一个数据包所在的三个轴的加速度值，记录， 当过一段时间之后再次获取三个轴的加速度值，计算增量，将相邻两个点的增量进行汇总，当达到预先设定的阀值，说明手机摇晃了。

实现步骤：
1、记录第一个点的数据： 三个轴的加速度，为了屏蔽不同手机采样的时间间隔差异，将第一个点的时间也记录下 来。
2、选取第二个点的数据：当有新的传感器数据传递进来后，用当前的时间与第一个点的时间进行比对，判断时间间 隔，如果满足了时间间隔（经验值：100）的要求，认为是合格的第二个点，否则舍弃改数据包。
3、 进行增量的计算：获取到的新的加速度值与第一个点上的加速度值进行差值运算，获取到一点和二点之间的增量，将三个增量值进行汇总。
4、以此类推，获取到相邻两个点的增量，进行汇总。
5、通过汇总的值与之前设定好的阀值（经验值：200）进行比对，如果>=阀值，用户摇晃手机。否则记录当前点的数据（加速度的值 和 该点的时间）。

一、核心传感器监听代码：

package com.huang.mylottery.view.sensor;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.os.Vibrator;

/** * 处理传感器监听 * * @author wuseyukui * */
public abstract class ShakeListener implements SensorEventListener {

      // 判断手机摇晃的阈值
      private final static float SWITH_VALUE = 200f;
      private final static long DURATION = 100;

      private Vibrator vibrator;

      private float lastX;
      private float lastY;
      private float lastZ;
      private long lastTime;
      private float total;

      public ShakeListener(Context context) {
             super();
             vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE );
      }


      private void initParam() {
             lastX = 0;
             lastY = 0;
             lastZ = 0;
             lastTime = 0;
             total = 0;
      }


      @Override
      public void onSensorChanged(SensorEvent event) {
             // 判断 是否第一个点
             if ( lastX == 0 && lastY == 0 && lastZ == 0 && lastTime == 0) {
                   // 记录三个轴的加速度值
                   float[] values = event. values;
                   lastX = values[0];
                   lastY = values[1];
                   lastZ = values[2];
                   lastTime = System. currentTimeMillis();
                   total = lastX + lastY + lastZ;

            } else {
                   // 尽可能屏蔽掉不同手机传感器的差异
                   if (System. currentTimeMillis() - lastTime > DURATION) {
                         float[] values = event. values;
                         // 第二个点及以后
                         float x = values[0];
                         float y = values[1];
                         float z = values[2];

                         // 计算增量
                         float dx = Math. abs(x-lastX);
                         float dy = Math. abs(y-lastY);
                         float dz = Math. abs(z-lastZ);

                         // 尽量屏蔽掉微小的增量值
                         if (dx < 1) {
                              dx = 0;
                        }
                         if (dy < 1) {
                              dy = 0;
                        }
                         if (dz < 1) {
                              dz = 0;
                        }

                         // 极个别手机，静止状态 某个轴的增量会大于1，10以上，甚至100以上
                         if (dx == 0 && dy == 0 && dz == 0) {
                              initParam();
                               return;
                        }

                         // 汇总(一点和二点总得增量)
                         float shake = dx + dy + dz;

                         if(shake == 0) {
                              initParam();
                               return;
                        }

                         total += shake;

                         if ( total >= SWITH_VALUE) {
                               // 手机摇晃了
                               // 机选一注彩票
                              RandomCure();
                               // 提示用户
                               vibrator.vibrate(100);
                               // 所有的数据都要初始化
                              initParam();

                        } else {
                               lastX = x;
                               lastY = y;
                               lastZ = z;
                               lastTime = System. currentTimeMillis();
                        }
                  }
            }
      }


      public abstract void RandomCure();


      @Override
      public void onAccuracyChanged(Sensor sensor, int accuracy) {

      }

}


二、注册监听

listener = new ShakeListener(context){
      @Override
      public void RandomCure() {
     //机选一注
     randomSSQ();
   }
 };
 // 注册传感器监听
  sensor.registerListener( listener,
                          sensor.getDefaultSensor(Sensor. TYPE_ACCELEROMETER),
                          SensorManager. SENSOR_DELAY_FASTEST);

二、各种彩票的算法

package cn.com.soarmobile.lottery;

import android.content.res.TypedArray;
import cn.com.soarmobile.SoarEngine;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;

/** * Type代表彩种玩法(如：任选一、任选二); Mode代表选号类型(如：直选) * * @author Administrator * */
public abstract class LotteryBase {
     /** * 彩种LOGO */
     public int icon;

     /** * 彩种名字 例如排列三 */
     public String name;
     /** * 彩种名字编号 例如排列三:p3 双色球:ssq */
     public String gameName;

     /** * 彩种代号 例如双色球:001 福彩3D:002 */
     public String code;
     /** * 官方规则 */
     public int officialrule;

     /** * 奖金说明 */
     public int prizeexplain;
     /** * 彩票期数 例如20110115 */
     public String issue;
     /** * 彩种简介，例如：天天排列3，不愁吃喝穿 */
     public String summary;
     /** * 购买一注的价格 */
     public int price;
     /** * 购买截止时间 */
     public String deadLine;
     /** * 红色选号区标签 如只有红色球 则显示选号 蓝球选号区域不显示 */
     public String redTag;
     /** * 蓝色选号区标签 如果木有蓝球 该区域不显示 */
     public String buleTag;
     /** * 最少要选择的红球数 例如双色球至少选6个红球 */
     public int redMin;
     /** * 最少要选择的蓝球数 例如双色球至少选1个蓝球 值可以为0 */
     public int blueMin;
     /** * 选号规则介绍 例如 请选择至少六个红球和一个蓝球 */
     public String[] rules;
     /** * 当前模式选号规则 */
     public String currentRule;
     /** * 彩种玩法，例如：任选一、任选二 */
     public String[] playType;
     /** * 当前彩种玩法 <br> * 参照{@link #playType playType} */
     protected String currentType;
     /** * 机选玩法，例如：二星、三星、五星 <br> * 该玩法目前为{@link #playType playType}的子集 */
     public String[] autoPlayType = null;

     /** * 选号类型，例如：直选、组选、通选 */
     public String[] playMode;
     /** * 当前选号类型 <br> * 参照{@link #playMode playMode} */
     protected String currentMode;
     /** * 不同玩法 模式的注意事项提醒 */
     public String[] notices;
     /** * 当前模式注意事项 */
     public String currentNotice;

     /** * 是否允许追加 */
     public boolean allowAddTo = false;
     /** * 是否格式化显示号码 例如 双色球01，02，03 */
     public boolean format = false;

     /** * 获取红球选号池 例如 :排列三{0,1,2,3,4,5,6,7,8,9} 选号类型和选号模式影响改返回值 * * @return */
     /** * 根据playtype和playmode计算出来当前索引 */
     public int currentIndex;

     public abstract int[] getRedPool();

     protected int[] getRedPool(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          int count = Integer.parseInt(string[1]);
          int start = Integer.parseInt(string[2]);
          int end = Integer.parseInt(string[3]);
          return CalculatorUtils.createBalls(count, start, end);
     }

     /** * 红球选择区的显示时候的列数 * * @return */
     public abstract int getRedColumnCount();

     protected int getRedColumnCount(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          return Integer.parseInt(string[0]);
     }

     /** * 获取蓝球选号池 例如排列三{0,1,2,3,4,5,6,7,8,9} 选号类型和选号模式影响改返回值 * * @return */
     public abstract int[] getBluePool();

     protected int[] getBluePool(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          int count = Integer.parseInt(string[1]);
          int start = Integer.parseInt(string[2]);
          int end = Integer.parseInt(string[3]);
          return CalculatorUtils.createBalls(count, start, end);
     }

     /** * 蓝球选择区的显示时候的列数 * * @return */
     public abstract int getBlueColumnCount();

     protected int getBlueColumnCount(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          return Integer.parseInt(string[0]);
     }

     /** * 机选红球 */
     public abstract int[] getRandomRed();

     /** * 机选蓝球 */
     public abstract int[] getRandomBlue();

     /** * 机选n注号码 * 返回int[][] */
     public abstract int[][] getRandom(int n);

     /** * 机选n注号码 * 返回String[] * 这样就不用根据redMin blueMin判断填充那种颜色了， * 减少彩种切换时对redMin和blueMin的管理 */
     public abstract String[] getRandomString(int n);

     /** * 判断当前选择是否合法 * * @param red * @param bule * @return */
     public abstract boolean isValid(int[] red, int[] bule);

     /** * 计算当前选了多少注 数学公式C(red,bule)或A(red,bule) * * @param red * 当前选择的红球 * @param bule * 当前选择的蓝球 * @return 计算出注数 */
     public abstract long calculatorBoxes(int[] red, int[] bule);

     /** * 重新为默认设置 */
     public abstract void reset(boolean isAutoToManual);

     /** * 根据plaype和playMode获取索引 例如 福彩3d {直选 复式}对应索引0 {直选 單式}对应索引1 {组三 复式}对应索引2 */
     public int getIndex(int resId) {
          int n = 0;
          for (int i = 0; i < playType.length; i++) {
               String[] strings = CountModeByType(resId, i);
               for (int j = 0; j < strings.length; j++) {
                    if (currentType.equals(playType[i])
                              && currentMode.equals(strings[j])) {
                         return n;
                    }
                    n++;
               }
          }

          for (int i = 0; i < playMode.length; i++) {
               if (currentMode.equals(playMode[i])) {
                    return n;
               }
               n++;
          }
          return n;
     }

     /** * * @return 获取当前选择playType的索引 例如 福彩3d {直选，组三，组六}对应的索引分别为{0,1,2} */
     public int getPlayTypeIndex() {
          for (int i = 0; i < playType.length; i++) {
               if (currentType.equals(playType[i])) {
                    return i;
               }

          }
          return 0;
     }

     /** * * @param resId * R.array.xx_playmodes * @param index * 当前选择playType的索引 例如 福彩3d {直选，组三，组六}对应的索引分别为{0,1,2} * @return 对应plaype下的playmodes 例如 福彩3d直选 {复式 单式} */
     public String[] CountModeByType(int resId, int index) {
          TypedArray typedArray = SoarEngine.getInstance().getResources()
                    .obtainTypedArray(resId);
          resId = typedArray.getResourceId(index, -1);
          return getStringArray(resId);

     }

     /** * 彩种playype发生变化 例如 福彩3d{直选 组三} */
     public abstract void notifyPlayTypeChanged();

     /** * 当有的彩种的玩法类型改变时，其redMin或buleMin的值会相应的被改变， 这种情况下，在具体的彩种类中要重写该方法，使玩法类型与redMin * 和buleMin相对应。例如，11选5的玩法，任选二 任选三等的最小 红球数不同，切换玩法类型时就要对redMin做相应的改变，否则在自选 * 和机选间切换时会出问题，因为机选显示号码个数时会用到以上量值。 {@link #setCurrentMode(String) * setCurrentMode()}类似。 * * @param currentType */
     public void setCurrentType(String currentType) {
          this.currentType = currentType;
          notifyPlayTypeChanged();
     }

     public String getCurrentType() {
          return currentType;
     }

     /** * 彩种playMode发生变化 例如 福彩3d{单式 复式} */
     public abstract void notifyPlayModeChanged();

     /** * 使用说明参考{@link #setCurrentType(String) setCurrentType} * * @return */
     public void setCurrentMode(String currentMode) {
          this.currentMode = currentMode;
          notifyPlayModeChanged();
     }

     public String getCurrentMode() {
          return currentMode;
     }

     /** * * @param resId * R.arrat.xx_playmodes * @return 当前PlayType对应的PlayMode 例如 福彩3d直选{复式，单式} */
     public String[] getPlayModes(int resId) {
          TypedArray typedArray = SoarEngine.getInstance().getResources()
                    .obtainTypedArray(resId);
          resId = typedArray.getResourceId(getPlayTypeIndex(), -1);
          return getStringArray(resId);

     }

     protected String getString(int resId) {
          return SoarEngine.getInstance().getResources().getString(resId);
     }

     protected String[] getStringArray(int resId) {
          return SoarEngine.getInstance().getResources().getStringArray(resId);
     }

     protected int getInteger(int resId) {
          return SoarEngine.getInstance().getResources().getInteger(resId);

     }

     protected boolean getBoolean(int resId) {
          return SoarEngine.getInstance().getResources().getBoolean(resId);
     }

     /** * 判断当前想要选择的红球是否能被选选择 * * @param selected * 当前已经选中的红球 * @param index * 想要选择的红球 * @return */
     public abstract String canSelecteRed(int[] selected, int index);

     /** * 判断当前想要选择的蓝球是否能被选选择 * * @param selected * 当前已经选中的蓝球 * @param index * 想要选择的蓝球 * @return */
     public abstract String canSelecteBlue(int[] selected, int index);

     /** * 根据当前已选红球和想要选择的红球计算出新的选中状态 * * @param selected * 当前已经选中的红球 * @param index * @return */
     public abstract int[][] newRedBalls(int[] selected, int index,
               boolean isCancel);

     /** * 根据当前已选红球和想要选择的蓝球计算出新的选中状态 * * @param selected * 当前已经选中的红球 * @param index * @return */
     public abstract int[][] newblueBalls(int[] selected, int index,
               boolean isCancel);

     /** * 将当前已经选择的红球格式化为字符串 例如 已经选择3 6 7格式化为3，6，7 * * @param text * @param index * @return */
     public abstract String formatSelectedRed(String[] texts, int[] indexs);

     /** * 将当前已经选择的蓝球格式化为字符串 例如 已经选择3 6 7格式化为3，6，7 * * @param text * @param index * @return */
     public abstract String formatSelectedBlue(String[] texts, int[] indexs);

     //根据当前选号情况创建代表当前选好的彩票订单项目
     /** * @param redpool 红球 * @param bluepool 蓝球 * @param result 方案信息（X注X元） * @param zhuijia 是否追加 */
     public abstract LotteryCartItem createLotteryCartItem(String redpool,String bluepool,String result,boolean zhuijia);

     public abstract int getTypeCodeByMode(String mode);
}

package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

public class Lottery11x5 extends LotteryRed {
     public Lottery11x5() {
          icon = R.string.llx5_icon;
          name = getString(R.string.llx5_name);
          gameName = getString(R.string.llx5_game_name);
          code = getString(R.string.llx5_code);
          issue = getString(R.string.llx5_issue);
          summary = getString(R.string.llx5_summary);
          price = getInteger(R.integer.llx5_price);
          deadLine = getString(R.string.llx5_deadline);
          redTag = getString(R.string.llx5_redtag);
          buleTag = getString(R.string.llx5_bluetag);
          redMin = getInteger(R.integer.llx5_redmin);
          blueMin = getInteger(R.integer.llx5_bluemin);
          rules = getStringArray(R.array.llx5_rules);
          notices = getStringArray(R.array.llx5_notices);
          playType = getStringArray(R.array.llx5_playtypes);
          currentType = getString(R.string.llx5_defaulttype);
          playMode = getStringArray(R.array.llx5_playmodes);
          currentMode = getString(R.string.llx5_defaultmode);
          allowAddTo = getBoolean(R.integer.llx5_allowAdd);
          format = getBoolean(R.integer.llx5_format);
          officialrule = R.string.llx5_officialrule;
          prizeexplain = R.string.llx5_prizeexplain;
          autoPlayType = getStringArray(R.array.llx5_auto_playtypes);
          notifyPlayTypeChanged();
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.llx5_redpools);
     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.llx5_redpools);
     }

     @Override
     public int[] getRandomRed() {
          int n = getIndex(R.array.llx5_playmodes);
          int column = getRedColumnCount();
          switch (n) {
          case 0:// 任一-直选
               return CalculatorUtils.getRandomArrayNumber(1, 0, 10);
          case 1:// 任二-直选
               return CalculatorUtils.getRandomArrayNumber(2, 0, 10);
          case 2:// 任三-直选
               return CalculatorUtils.getRandomArrayNumber(3, 0, 10);
          case 3:// 任四-直选
               return CalculatorUtils.getRandomArrayNumber(4, 0, 10);
          case 4:// 任五-直选
               return CalculatorUtils.getRandomArrayNumber(5, 0, 10);
          case 5:// 任六-直选
               return CalculatorUtils.getRandomArrayNumber(6, 0, 10);
          case 6:// 任七-直选
               return CalculatorUtils.getRandomArrayNumber(7, 0, 10);
          case 7:// 任八-直选
               return CalculatorUtils.getRandomArrayNumber(8, 0, 10);
          case 8:// 前二-直选
               int[] reds = CalculatorUtils.getRandomArrayNumber(2, 0, 10);
               for (int i = 0; i < reds.length; i++) {
                    reds[i] = reds[i] + column * i;
               }
               return reds;
          case 9:// 前二-组选
               return CalculatorUtils.getRandomArrayNumber(2, 0, 10);
          case 10:// 前三-直选
               reds = CalculatorUtils.getRandomArrayNumber(3, 0, 10);
               for (int i = 0; i < reds.length; i++) {
                    reds[i] = reds[i] + column * i;
               }
               return reds;
          case 11:// 前三-组选
               return CalculatorUtils.getRandomArrayNumber(3, 0, 10);

          }
          return null;

     }

     @Override
     public int[][] getRandom(int n) {
          if (n < 1) {
               n = 1;
          }
          int[][] result = new int[n][redMin];
          for (int i = 0; i < n; i++) {
               for (int j = 0; j < redMin; j++) {
                    result[i][j] = CalculatorUtils.getRandomNumber(1, 11);
               }
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          if (n < 1) {
               n = 1;
          }
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               int[] nums = CalculatorUtils.getRandomArrayNumber(redMin, 1, 11);
               for (int j = 0; j < redMin; j++) {
                    sBuffer.append(StringUtil.format(nums[j]) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;

          switch (currentIndex) {
          case 0:// 任一-直选
               break;
          case 1:// 任二-直选
               break;
          case 2:// 任三-直选
               break;
          case 3:// 任四-直选
               break;
          case 4:// 任五-直选
               break;
          case 5:// 任六-直选
               break;
          case 6:// 任七-直选
               break;
          case 7:// 任八-直选
               break;
          case 8:// 前二-直选
               if (red[red.length - 1] / getRedColumnCount() != 1)
                    return false;
          case 9:// 前二-组选
               break;
          case 10:// 前三-直选
               if (red[red.length - 1] / getRedColumnCount() != 2)
                    return false;
          case 11:// 前三-组选
               break;

          }
          if (red.length < redMin)
               return false;
          return true;
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:
          case 1:
          case 2:
          case 3:
          case 4:
          case 5:
          case 6:
          case 7:// 任一-直选 到 任八-直选
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          case 8:// 前二-直选
               return CalculatorUtils.calculatorBoxs(red, column);
          case 9:// 前二-组选
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          case 10:// 前三-直选
               return CalculatorUtils.calculatorBoxs(red, column);
          case 11:// 前三-组选
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          }
          return 0;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.llx5_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          playMode = getPlayModes(R.array.llx5_playmodes);
          currentMode = playMode[0];
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.llx5_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[getIndex(R.array.llx5_playmodes)];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[getIndex(R.array.llx5_playmodes)];
          switch (currentIndex) {
          case 0:// 任一-直选
               redMin = 1;
               break;
          case 1:// 任二-直选
               redMin = 2;
               break;
          case 2:// 任三-直选
               redMin = 3;
               break;
          case 3:// 任四-直选
               redMin = 4;
               break;
          case 4:// 任五-直选
               redMin = 5;
               break;
          case 5:// 任六-直选
               redMin = 6;
               break;
          case 6:// 任七-直选
               redMin = 7;
               break;
          case 7:// 任八-直选
               redMin = 8;
               break;
          case 8:// 前二-直选
               redMin = 2;
               break;
          case 9:// 前二-组选
               redMin = 2;
               break;
          case 10:// 前三-直选
               redMin = 3;
               break;
          case 11:// 前三-组选
               redMin = 3;
               break;

          }
     }

     @Override
     public String canSelecteRed(int[] selected, int index) {
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 任一-直选
               break;
          case 1:// 任二-直选
               break;
          case 2:// 任三-直选
               break;
          case 3:// 任四-直选
               break;
          case 4:// 任五-直选
               break;
          case 5:// 任六-直选
               break;
          case 6:// 任七-直选
               break;
          case 7:// 任八-直选
               if(selected.length>=8){
                    return "最多只能选8个号码！";
               }
               break;
          case 8:// 前二-直选
               if (index / column == 0) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index + column) {
                              return "前二选号：各位不能重复";
                         }
                    }
               } else if (index / column == 1) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index - column) {
                              return "前二选号：各位不能重复";
                         }
                    }
               }

               break;
          case 9:// 前二-组选
               break;
          case 10:// 前三-直选

               if (index / column == 0) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index + column
                                   || selected[i] == index + 2 * column) {
                              return "前三选号：各位不能重复";
                         }
                    }
               } else if (index / column == 1) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index - column
                                   || selected[i] == index + column) {
                              return "前三选号：各位不能重复";
                         }
                    }
               } else if (index / column == 2) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index - column
                                   || selected[i] == index - 2 * column) {
                              return "前三选号：各位不能重复";
                         }
                    }
               }
               break;
          case 11:// 前三-组选
               break;

          }
          return "yes";
     }

     public int[][] zhixuanrenyi(int[] selected, int index) {
          int[][] state = new int[2][];
          int[] remove = selected;
          int[] add = new int[] { index };
          state[0] = add;
          state[1] = remove;
          return state;
     }

     public int[][] zhixuan(int[] selected, int index) {
          int[][] state = new int[2][];
          int[] remove = null;
          int[] add = new int[] { index };
          state[0] = add;
          state[1] = remove;
          return state;
     }

     public int[][] zuxuan(int[] selected, int index) {
          int[][] state = new int[2][];
          int[] remove = null;
          int[] add = new int[] { index };
          state[0] = add;
          state[1] = remove;
          return state;
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int n = getIndex(R.array.llx5_playmodes);
          switch (n) {
          case 0:
               return zhixuanrenyi(selected, index);
          case 1:
               return zhixuan(selected, index);
          case 2:
               return zhixuan(selected, index);
          case 3:
               return zhixuan(selected, index);
          case 4:
               return zhixuan(selected, index);
          case 5:
               return zhixuan(selected, index);
          case 6:
               return zhixuan(selected, index);
          case 7:
               return zhixuan(selected, index);
          case 8:
               return zhixuan(selected, index);
          case 9:
               return zuxuan(selected, index);
          case 10:
               return zhixuan(selected, index);
          case 11:
               return zuxuan(selected, index);

          }

          return null;
     }

     @Override
     public String formatSelectedRed(String[] text, int[] index) {
          int n = getIndex(R.array.llx5_playmodes);
          switch (n) {
          case 0:
               return format(text, index);
          case 1:
               return format(text, index);
          case 2:
               return format(text, index);
          case 3:
               return format(text, index);
          case 4:
               return format(text, index);
          case 5:
               return format(text, index);
          case 6:
               return format(text, index);
          case 7:
               return format(text, index);
          case 8:
               return format(text, index, 2);
          case 9:
               return format(text, index);
          case 10:
               return format(text, index, 3);
          case 11:
               return format(text, index);
          }

          return null;
     }

     // 与行号无关 格式化为{2,3,4,5,6}
     public String format(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < text.length; i++) {
               stringBuffer.append(text[i]);
               if (i < text.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     // 与行号有关 格式化为{2 3 4,11 15}
     public String format(String[] text, int[] index, int count) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < count; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j] + ",");
                    }
               }
               if (stringBuffer.lastIndexOf(",") > -1)
                    stringBuffer.deleteCharAt(stringBuffer.lastIndexOf(","));
               if (i != count - 1)
                    stringBuffer.append("|");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          lotteryCartItem.mode = currentMode;
          lotteryCartItem.number = redpool;
          if (count == 1) {
               lotteryCartItem.mode += "单";
          } else {
               lotteryCartItem.mode += "复";
          }
          lotteryCartItem.mode = currentType + lotteryCartItem.mode;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("任一直选单".equals(mode)) {
               return 101;
          } else if ("任一直选复".equals(mode)) {
               return 102;
          } else if ("任二直选单".equals(mode)) {
               return 103;
          } else if ("任二直选复".equals(mode)) {
               return 104;
          } else if ("任三直选单".equals(mode)) {
               return 105;
          } else if ("任三直选复".equals(mode)) {
               return 106;
          } else if ("任四直选单".equals(mode)) {
               return 107;
          } else if ("任四直选复".equals(mode)) {
               return 108;
          } else if ("任五直选单".equals(mode)) {
               return 109;
          } else if ("任五直选复".equals(mode)) {
               return 110;
          } else if ("任六直选单".equals(mode)) {
               return 111;
          } else if ("任六直选复".equals(mode)) {
               return 112;
          } else if ("任七直选单".equals(mode)) {
               return 113;
          } else if ("任七直选复".equals(mode)) {
               return 114;
          } else if ("任八直选单".equals(mode)) {
               return 115;
          } else if ("任八直选复".equals(mode)) {
               return 116;
          } else if ("前二直选单".equals(mode)) {
               return 117;
          } else if ("前二直选复".equals(mode)) {
               return 118;
          } else if ("前三直选单".equals(mode)) {
               return 119;
          } else if ("前三直选复".equals(mode)) {
               return 120;
          } else if ("前二组选单".equals(mode)) {
               return 121;
          } else if ("前二组选复".equals(mode)) {
               return 122;
          } else if ("前三组选单".equals(mode)) {
               return 123;
          } else if ("前三组选复".equals(mode)) {
               return 124;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}
package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 22选5 */
public class Lottery22x5 extends LotteryRed {
     public Lottery22x5() {
          icon = R.string.zzx5_icon;
          name = getString(R.string.zzx5_name);
          gameName = getString(R.string.zzx5_game_name);
          code = getString(R.string.zzx5_code);
          issue = getString(R.string.zzx5_issue);
          summary = getString(R.string.zzx5_summary);
          price = getInteger(R.integer.zzx5_price);
          deadLine = getString(R.string.zzx5_deadline);
          redTag = getString(R.string.zzx5_redtag);
          buleTag = getString(R.string.zzx5_bluetag);
          redMin = getInteger(R.integer.zzx5_redmin);
          blueMin = getInteger(R.integer.zzx5_bluemin);
          rules = getStringArray(R.array.zzx5_rules);
          notices = getStringArray(R.array.zzx5_notices);
          playType = getStringArray(R.array.zzx5_playtypes);
          currentType = getString(R.string.zzx5_defaulttype);
          playMode = getStringArray(R.array.zzx5_playmodes);
          currentMode = getString(R.string.zzx5_defaultmode);
          allowAddTo = getBoolean(R.integer.zzx5_allowAdd);
          format = getBoolean(R.integer.zzx5_format);
          officialrule = R.string.zzx5_officialrule;
          prizeexplain = R.string.zzx5_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          return CalculatorUtils.calculatorCombination(red.length, redMin);
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][5];
          for (int i = 0; i < n; i++) {
               result[i] = CalculatorUtils.getRandomArrayNumber(5, 1, 25);
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          int[] temp;
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               temp = CalculatorUtils.getRandomArrayNumber(5, 1, 25);
               for (int j = 0; j < 5; j++) {
                    sBuffer.append(StringUtil.format(temp[j]) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public int[] getRandomRed() {
          return CalculatorUtils.getRandomArrayNumber(redMin, 0, 21);
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.zzx5_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;
          if (red.length >= redMin) {
               return true;
          }
          return false;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.zzx5_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.zzx5_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];

     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.zzx5_redpools);
     }

     @Override
     public String canSelecteRed(int[] a, int b) {
          return "yes";
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancle) {
          if (isCancle) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          state[0] = addballs;
          return state;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < texts.length; i++) {
               stringBuffer.append(texts[i]);
               if (i != texts.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          if (count == 1) {
               lotteryCartItem.mode = "单式";
          } else {
               lotteryCartItem.mode = "复式";
          }
          lotteryCartItem.number = redpool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("单式".equals(mode)) {
               return 101;
          } else if ("复式".equals(mode)) {
               return 102;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}

package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 福彩3D * * @author dzb * */
public class Lottery3D extends LotteryRed {

     private final int TOTAL = 3; // 单注选号数
     private final int START = 0; // 选号起始数
     private final int END = 9; // 选号终止数

     public Lottery3D() {
          icon = R.string.fc3d_icon;
          name = getString(R.string.fc3d_name);
          gameName = getString(R.string.fc3d_game_name);
          code = getString(R.string.fc3d_code);
          issue = getString(R.string.fc3d_issue);
          summary = getString(R.string.fc3d_summary);
          price = getInteger(R.integer.fc3d_price);
          deadLine = getString(R.string.fc3d_deadline);
          redTag = getString(R.string.fc3d_redtag);
          buleTag = getString(R.string.fc3d_bluetag);
          redMin = getInteger(R.integer.fc3d_redmin);
          blueMin = getInteger(R.integer.fc3d_bluemin);
          rules = getStringArray(R.array.fc3d_rules);
          notices = getStringArray(R.array.fc3d_notices);
          playType = getStringArray(R.array.fc3d_playtypes);
          currentType = getString(R.string.fc3d_defaulttype);
          playMode = getStringArray(R.array.fc3d_playmodes);
          currentMode = getString(R.string.fc3d_defaultmode);
          allowAddTo = getBoolean(R.integer.fc3d_allowAdd);
          format = getBoolean(R.integer.fc3d_format);
          officialrule = R.string.fc3d_officialrule;
          prizeexplain = R.string.fc3d_prizeexplain;
          notifyPlayTypeChanged();
     }

     /** * 计算直选_和值情况下的注数 * * @param column * @param sum * @return */
     private int calculatorBoxes_zxhz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = 0; j < column; j++) {
                    for (int h = 0; h < column; h++) {
                         if (i + j + h == sum) {
                              count++;
                         }
                    }
               }
          }
          return count;

     }

     /** * 计算组三_和值情况下的注数 * * @param column * @param sum * @return */
     private int calculatorBoxes_zshz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = i; j < column; j++) {
                    if (j == i) {
                         continue;
                    }
                    if (2 * i + j == sum) {
                         count++;
                    }
                    if (2 * j + i == sum) {
                         count++;
                    }
               }
          }
          return count;

     }

     /** * 计算组六_和值情况下的注数 * * @param column * @param sum * @return */
     private int calculatorBoxes_zlhz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = i + 1; j < column; j++) {
                    for (int h = j + 1; h < column; h++) {
                         if (i + j + h == sum) {
                              count++;
                         }
                    }
               }
          }
          return count;

     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          switch (currentIndex) {
          case 0:// 直选-复式
               return CalculatorUtils.calculatorBoxs(red, getRedColumnCount());
          case 1:// 直选-和值
               return calculatorBoxes_zxhz(getRedColumnCount(), red[0] + 1);
          case 2:// 组三-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 3:// 组三-和值 组三最小{0,0,1} 为1
               return calculatorBoxes_zshz(getRedColumnCount(), red[0] + 1);
          case 4:// 组六-复式
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          case 5:// 组六-和值 组三最小{0,1,2} 为3
               return calculatorBoxes_zlhz(getRedColumnCount(), red[0] + 3);
          }
          return 0;
     }

     @Override
     public int[][] getRandom(int n) {
          if (n < 1) {
               n = 1;
          }
          int[][] result = new int[n][3];
          for (int i = 0; i < n; i++) {
               result[i] = CalculatorUtils.getRandomArrayNumber(TOTAL, START, END);
          }

          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          if (n < 1) {
               n = 1;
          }
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          int[] temp;
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               temp = CalculatorUtils.getRandomArrayNumber(3, 0, 9);
               for (int j = 0; j < temp.length; j++) {
                    sBuffer.append(temp[j] + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public int[] getRandomRed() {
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 直选-复式
               int[] red = new int[3];
               for (int i = 0; i < red.length; i++) {
                    red[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
               }
               return red;
          case 1:// 直选-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 27);
          case 2:// 组三-复式
               return CalculatorUtils.getRandomArrayNumber(2, 0, 9);
          case 3:// 组三-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 25);
          case 4:// 组六-复式
               return CalculatorUtils.getRandomArrayNumber(3, 0, 9);
          case 5:// 组六-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 21);

          }
          return null;
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.fc3d_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0) {
               return false;
          }
          switch (currentIndex) {
          case 0:// 直选-复式
               if (red[red.length - 1] / getRedColumnCount() != 2)
                    return false;
          case 1:// 直选-单式
               break;
          case 2:// 组三-复式
               break;
          case 3:// 组三-和值
               break;
          case 4:// 组六-复式
               break;
          case 5:// 组六-和值
               break;
          }
          if (red.length < redMin) {
               return false;
          }
          return true;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.fc3d_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          playMode = getPlayModes(R.array.fc3d_playmodes);
          currentMode = playMode[0];
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.fc3d_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];

          switch (currentIndex) {
          case 0:// 直选-复式
               redMin = 3;
               break;
          case 1:// 直选-和值
               redMin = 1;
               break;
          case 2:// 组三-复式
               redMin = 2;
               break;
          case 3:// 组三-和值
               redMin = 1;
               break;
          case 4:// 组六-复式
               redMin = 3;
               break;
          case 5:// 组六-和值
               redMin = 1;
               break;
          }

     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.fc3d_redpools);
     }

     @Override
     public String canSelecteRed(int[] selected, int index) {
          return "yes";
     }

     public int[][] fushi(int[] a, int b) {
          int[][] state = new int[2][];
          int[] add = new int[] { b };
          int[] remove = null;
          state[0] = add;
          state[1] = remove;
          return state;
     }

     public int[][] hezhi(int[] a, int b) {
          int[][] state = new int[2][];
          int[] add = new int[] { b };
          int[] remove = a;
          state[0] = add;
          state[1] = remove;
          return state;
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          switch (currentIndex) {
          case 0:// 直选-复式
               return fushi(selected, index);
          case 1:// 直选-和值
               return hezhi(selected, index);
          case 2:// 组三-复式
               return fushi(selected, index);
          case 3:// 组三-和值
               return hezhi(selected, index);
          case 4:// 组六-复式
               return fushi(selected, index);
          case 5:// 组六-和值
               return hezhi(selected, index);
          }
          return null;

     }

     @Override
     public String formatSelectedRed(String[] text, int[] indexs) {
          switch (currentIndex) {
          case 0:// 直选-复式
               return format(text, indexs, 3);
          case 1:// 直选-和值
               return format(text, indexs);
          case 2:// 组三-复式
               return format(text, indexs);
          case 3:// 组三-和值
               return format(text, indexs);
          case 4:// 组六-复式
               return format(text, indexs);
          case 5:// 组六-和值
               return format(text, indexs);
          }
          return null;
     }

     // 与行号有关 格式化为{2 3 4,11 15}
     private String format(String[] text, int[] index, int count) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < count; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != count - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     // 与行号无关 格式化为{2,3,4,5,6}
     public String format(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < text.length; i++) {
               stringBuffer.append(text[i]);
               if (i < text.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          lotteryCartItem.mode = currentMode;
          if (lotteryCartItem.mode.equals("复式")) {
               if (count == 1) {
                    lotteryCartItem.mode = "单式";
               }
          }
          lotteryCartItem.mode = currentType + lotteryCartItem.mode;
          lotteryCartItem.number = redpool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("直选单式".equals(mode)) {
               return 201;
          } else if ("直选复式".equals(mode)) {
               return 202;
          } else if ("直选和值".equals(mode)) {
               return 204;
          } else if ("组三复式".equals(mode)) {
               return 203;
          } else if ("组六单式".equals(mode)) {
               return 205;
          } else if ("组六复式".equals(mode)) {
               return 206;
          } else if ("组三和值".equals(mode)) {
               return 207;
          } else if ("组六和值".equals(mode)) {
               return 208;
          } else if (StringUtil.isEmpty(mode)) {
               return 201;
          }
          return 201;
     }

}
package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 大乐透 */
public class LotteryDLT extends LotteryBase {
     public LotteryDLT() {
          icon = R.string.dlt_icon;
          name = getString(R.string.dlt_name);
          gameName = getString(R.string.dlt_game_name);
          code = getString(R.string.dlt_code);
          issue = getString(R.string.dlt_issue);
          summary = getString(R.string.dlt_summary);
          price = getInteger(R.integer.dlt_price);
          deadLine = getString(R.string.dlt_deadline);
          redTag = getString(R.string.dlt_redtag);
          buleTag = getString(R.string.dlt_bluetag);
          redMin = getInteger(R.integer.dlt_redmin);
          blueMin = getInteger(R.integer.dlt_bluemin);
          rules = getStringArray(R.array.dlt_rules);
          notices = getStringArray(R.array.dlt_notices);
          playType = getStringArray(R.array.dlt_playtypes);
          currentType = getString(R.string.dlt_defaulttype);
          playMode = getStringArray(R.array.dlt_playmodes);
          currentMode = getString(R.string.dlt_defaultmode);
          allowAddTo = getBoolean(R.integer.dlt_allowAdd);
          format = getBoolean(R.integer.dlt_format);
          officialrule = R.string.dlt_officialrule;
          prizeexplain = R.string.dlt_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          long rednum = CalculatorUtils.calculatorCombination(red.length, redMin);
          long bluenum = CalculatorUtils.calculatorCombination(blue.length,
                    blueMin);
          return rednum * bluenum;
     }

     @Override
     public int[] getBluePool() {
          return super.getBluePool(R.array.dlt_bluepools);
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][7];
          for (int i = 0; i < n; i++) {
               result[i] = combineArray(
                         CalculatorUtils.getRandomArrayNumber(5, 1, 35),
                         CalculatorUtils.getRandomArrayNumber(2, 1, 12));
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          if (n < 1) {
               n = 1;
          }
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          int[] temp;
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               //随机红球
               temp = CalculatorUtils.getRandomArrayNumber(5, 1,35);
               for(int red = 0; red < 5; red++) {
                    sBuffer.append(StringUtil.format(temp[red]) + ",");
               }
               sBuffer.deleteCharAt(sBuffer.lastIndexOf(","));
               sBuffer.append("|");
               //随机蓝球
               temp = CalculatorUtils.getRandomArrayNumber(2, 1, 12);
               for(int blue = 0; blue < 2; blue++) {
                    sBuffer.append(StringUtil.format(temp[blue]) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }


          return result;
     }

     @Override
     public int[] getRandomBlue() {
          return CalculatorUtils.getRandomArrayNumber(blueMin, 0, 11);
     }

     @Override
     public int[] getRandomRed() {
          return CalculatorUtils.getRandomArrayNumber(redMin, 0, 34);
     }

     /** * 合并红球和蓝球到一个数组 * * @param red * @param blue * @return */
     private int[] combineArray(int[] red, int[] blue) {
          int redLen = red.length;
          int blueLen = blue.length;
          int[] result = new int[red.length + blueLen];
          int n = 0;
          for (n = 0; n < redLen; n++) {
               result[n] = red[n];
          }
          for (int i = 0; i < blueLen; i++) {
               result[n++] = blue[i];
          }

          return result;
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.dlt_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0 || bule.length == 0) {
               return false;
          }
          if (red.length >= redMin && bule.length >= blueMin) {
               return true;
          }
          return false;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.dlt_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.dlt_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];

     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.dlt_redpools);
     }

     @Override
     public int getBlueColumnCount() {
          return super.getBlueColumnCount(R.array.dlt_bluepools);
     }

     @Override
     public String canSelecteRed(int[] a, int b) {
          return "yes";
     }

     @Override
     public String canSelecteBlue(int[] a, int b) {
          return "yes";
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          state[0] = addballs;
          return state;
     }

     @Override
     public int[][] newblueBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          state[0] = addballs;
          return state;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < texts.length; i++) {
               stringBuffer.append(texts[i]);
               if (i != texts.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public String formatSelectedBlue(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < texts.length; i++) {
               stringBuffer.append(texts[i]);
               if (i != texts.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          if (zhuijia) {
               lotteryCartItem.mode = "追加";
          } else {
               lotteryCartItem.mode = "";
          }
          if (count == 1) {
               lotteryCartItem.mode += "单式";
          } else {
               lotteryCartItem.mode += "复式";
          }

          lotteryCartItem.number = redpool + "|" + bluepool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }
     @Override
     public int getTypeCodeByMode(String mode) {
          if ("单式".equals(mode)) {
               return 101;
          } else if ("复式".equals(mode)) {
               return 102;
          } else if ("追加单式".equals(mode)||"追加单".equals(mode)) {
               return 103;
          } else if ("追加复式".equals(mode)) {
               return 104;
          }else if ("追加".equals(mode)) {
               return 101;
          }
          else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}

package cn.com.soarmobile.lottery;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

import cn.com.soarmobile.SoarEngine;

public class LotteryFactory {
     static Map<Class<?>, LotteryBase> lotterys = new HashMap<Class<?>, LotteryBase>();
     static LotteryBase currentLottery;
     private static LotteryFootSFC sfcLottery;

     public static LotteryFootSFC getSFCLottery() {
          if (sfcLottery == null) {
               sfcLottery = new LotteryFootSFC();
          }
          return sfcLottery;
     }

     public static LotteryBase getCurrentLottery() {
          return currentLottery;
     }

     public static <T extends LotteryBase> void setCurrentLottery(
               Class<T> lotteryClass) {
          LotteryFactory.currentLottery = createLottery(lotteryClass);

          // 彩种切换时清空购物车 重设奖期信息
          SoarEngine.getInstance().lotteryCart.clear();
          currentLottery.issue = null;
          currentLottery.deadLine =null;
     }

     private static <T extends LotteryBase> LotteryBase createLottery(
               Class<T> lotteryClass) {
          LotteryBase lottery = null;
          if (lotterys.get(lotteryClass) == null) {
               try {
                    Constructor<T> constructor = lotteryClass
                              .getConstructor(new Class[] {});
                    lottery = constructor.newInstance();
                    lotterys.put(lotteryClass, lottery);
               } catch (SecurityException e) {
                    lottery = null;
                    e.printStackTrace();
               } catch (NoSuchMethodException e) {
                    lottery = null;
                    e.printStackTrace();
               } catch (IllegalArgumentException e) {
                    lottery = null;
                    e.printStackTrace();
               } catch (InstantiationException e) {
                    lottery = null;
                    e.printStackTrace();
               } catch (IllegalAccessException e) {
                    lottery = null;
                    e.printStackTrace();
               } catch (InvocationTargetException e) {
                    lottery = null;
                    e.printStackTrace();
               }
          } else {
               lottery = lotterys.get(lotteryClass);
          }
          return lottery;
     }
}


package cn.com.soarmobile.lottery;

/** * 排列三 */
import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

public class LotteryPLS extends LotteryRed {
     public LotteryPLS() {
          icon = R.string.pls_icon;
          name = getString(R.string.pls_name);
          gameName = getString(R.string.pls_game_name);
          code = getString(R.string.pls_code);
          issue = getString(R.string.pls_issue);
          summary = getString(R.string.pls_summary);
          price = getInteger(R.integer.pls_price);
          deadLine = getString(R.string.pls_deadline);
          redTag = getString(R.string.pls_redtag);
          buleTag = getString(R.string.pls_bluetag);
          redMin = getInteger(R.integer.pls_redmin);
          blueMin = getInteger(R.integer.pls_bluemin);
          rules = getStringArray(R.array.pls_rules);
          notices = getStringArray(R.array.pls_notices);
          playType = getStringArray(R.array.pls_playtypes);
          currentType = getString(R.string.pls_defaulttype);
          playMode = getStringArray(R.array.pls_playmodes);
          currentMode = getString(R.string.pls_defaultmode);
          allowAddTo = getBoolean(R.integer.pls_allowAdd);
          format = getBoolean(R.integer.pls_format);
          officialrule = R.string.pls_officialrule;
          prizeexplain = R.string.plw_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.pls_redpools);
     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.fc3d_redpools);
     }

     @Override
     public int[] getRandomRed() {
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 直选-复式
               int[] red = new int[3];
               for (int i = 0; i < red.length; i++) {
                    red[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
               }
               return red;
          case 1:// 直选-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 25);
          case 2:// 组三-复式
               return CalculatorUtils.getRandomArrayNumber(2, 0, 9);
          case 3:// 组三-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 25);
          case 4:// 组六-复式
               return CalculatorUtils.getRandomArrayNumber(3, 0, 9);
          case 5:// 组六-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 21);
          }
          return null;
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][3];
          for (int i = 0; i < n; i++) {
               result[i][0] = CalculatorUtils.getRandomNumber(0, 9);
               result[i][1] = CalculatorUtils.getRandomNumber(0, 9);
               result[i][2] = CalculatorUtils.getRandomNumber(0, 9);
          }

          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               for (int j = 0; j < 3; j++) {
                    sBuffer.append(CalculatorUtils.getRandomNumber(0, 9) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;
          if (red.length < redMin)
               return false;
          return true;
     }

     /** * 计算直选_和值情况下的注数 * * @param column * @param sum * @return */
     private int calculatorBoxes_zxhz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = 0; j < column; j++) {
                    for (int h = 0; h < column; h++) {
                         if (i + j + h == sum) {
                              count++;
                         }
                    }
               }
          }
          return count;

     }

     /** * 计算组三_和值情况下的注数 * * @param column * @param sum * @return */
     private int calculatorBoxes_zshz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = i; j < column; j++) {
                    if (j == i) {
                         continue;
                    }
                    if (2 * i + j == sum) {
                         count++;
                    }
                    if (2 * j + i == sum) {
                         count++;
                    }
               }
          }
          return count;

     }

     /** * 计算组六_和值情况下的注数 * * @param column * @param sum * @return */
     private int calculatorBoxes_zlhz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = i + 1; j < column; j++) {
                    for (int h = j + 1; h < column; h++) {
                         if (i + j + h == sum) {
                              count++;
                         }
                    }
               }
          }
          return count;

     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          switch (currentIndex) {
          case 0:// 直选-复式
               return CalculatorUtils.calculatorBoxs(red, getRedColumnCount());
          case 1:// 直选-和值
               return calculatorBoxes_zxhz(getRedColumnCount(), red[0] + 1);
          case 2:// 组三-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 3:// 组三-和值 组三最小{0,0,1} 为1
               return 2 * calculatorBoxes_zshz(getRedColumnCount(), red[0] + 1);
          case 4:// 组六-复式
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          case 5:// 组六-和值 组三最小{0,1,2} 为3
               return calculatorBoxes_zlhz(getRedColumnCount(), red[0] + 3);
          }
          return 0;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.pls_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          playMode = getPlayModes(R.array.pls_playmodes);
          currentMode = playMode[0];
          notifyPlayModeChanged();

     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.pls_playmodes);
          if (currentIndex == 3)
               currentIndex++;

          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];
          switch (currentIndex) {
          case 0:// 直选-单式
               redMin = 3;
               break;
          case 1:// 直选-和值
               redMin = 1;
               break;
          case 2:// 组三-复式
               redMin = 2;
               break;
          case 3:// 组三-和值
               redMin = 1;
               break;
          case 4:// 组六-复式
               redMin = 3;
               break;
          case 5:// 组六-和值
               redMin = 1;
               break;
          }

     }

     @Override
     public String canSelecteRed(int[] selected, int index) {
          return "yes";
     }

     public int[][] fushi(int[] a, int b) {
          int[][] state = new int[2][];
          int[] add = new int[] { b };
          int[] remove = null;
          state[0] = add;
          state[1] = remove;
          return state;
     }

     public int[][] hezhi(int[] a, int b) {
          int[][] state = new int[2][];
          int[] add = new int[] { b };
          int[] remove = a;
          state[0] = add;
          state[1] = remove;
          return state;
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          switch (currentIndex) {
          case 0:// 直选-复式
               return fushi(selected, index);
          case 1:// 直选-和值
               return hezhi(selected, index);
          case 2:// 组三-复式
               return fushi(selected, index);
          case 3:// 组三-和值
               return hezhi(selected, index);
          case 4:// 组六-复式
               return fushi(selected, index);
          case 5:// 组六-和值
               return hezhi(selected, index);
          }
          return null;
     }

     @Override
     public String formatSelectedRed(String[] text, int[] indexs) {
          switch (currentIndex) {
          case 0:// 直选-复式
               return format(text, indexs, 3);
          case 1:// 直选-和值
               return format(text, indexs);
          case 2:// 组三-复式
               return format(text, indexs);
          case 3:// 组三-和值
               return format(text, indexs);
          case 4:// 组六-复式
               return format(text, indexs);
          case 5:// 组六-和值
               return format(text, indexs);
          }
          return null;
     }

     // 与行号有关 格式化为{2 3 4,11 15}
     private String format(String[] text, int[] index, int count) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < count; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != count - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     // 与行号无关 格式化为{2,3,4,5,6}
     public String format(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < text.length; i++) {
               stringBuffer.append(text[i]);
               if (i < text.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          lotteryCartItem.number = redpool;
          lotteryCartItem.mode = currentMode;
          if (lotteryCartItem.mode.equals("复式")) {
               if (count == 1) {
                    lotteryCartItem.mode = "单式";
               }
          }
          lotteryCartItem.mode = currentType + lotteryCartItem.mode;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("直选单式".equals(mode)) {
               return 201;
          } else if ("直选复式".equals(mode)) {
               return 202;
          } else if ("直选和值".equals(mode)) {
               return 204;
          } else if ("组三复式".equals(mode)) {
               return 203;
          } else if ("组六单式".equals(mode)) {
               return 205;
          } else if ("组六复式".equals(mode)) {
               return 206;
          } else if ("组三和值".equals(mode)) {
               return 207;
          } else if ("组六和值".equals(mode)) {
               return 208;
          } else if (StringUtil.isEmpty(mode)) {
               return 201;
          }
          return 201;
     }

}

package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 排列五 */
public class LotteryPLW extends LotteryRed {
     public LotteryPLW() {
          icon = R.string.plw_icon;
          name = getString(R.string.plw_name);
          gameName = getString(R.string.plw_game_name);
          code = getString(R.string.plw_code);
          issue = getString(R.string.plw_issue);
          summary = getString(R.string.plw_summary);
          price = getInteger(R.integer.plw_price);
          deadLine = getString(R.string.plw_deadline);
          redTag = getString(R.string.plw_redtag);
          buleTag = getString(R.string.plw_bluetag);
          redMin = getInteger(R.integer.plw_redmin);
          blueMin = getInteger(R.integer.plw_bluemin);
          rules = getStringArray(R.array.plw_rules);
          notices = getStringArray(R.array.plw_notices);
          playType = getStringArray(R.array.plw_playtypes);
          currentType = getString(R.string.plw_defaulttype);
          playMode = getStringArray(R.array.plw_playmodes);
          currentMode = getString(R.string.plw_defaultmode);
          allowAddTo = getBoolean(R.integer.plw_allowAdd);
          format = getBoolean(R.integer.plw_format);
          officialrule = R.string.plw_officialrule;
          prizeexplain = R.string.plw_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          int column = getRedColumnCount();
          int m = 0;
          int n = 0;
          int k = 0;
          int j = 0;
          int l = 0;
          for (int i = 0; i < red.length; i++) {
               if (red[i] >= 0 && red[i] < column) {
                    m++;
               } else if (red[i] >= column && red[i] < 2 * column) {
                    n++;
               } else if (red[i] >= 2 * column && red[i] < 3 * column) {
                    k++;
               } else if (red[i] >= 3 * column && red[i] < 4 * column) {
                    j++;
               } else if (red[i] >= 4 * column && red[i] < 5 * column) {
                    l++;
               }
          }
          return m * n * k * j * l;
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][5];
          for (int i = 0; i < n; i++) {
               for (int j = 0; j < 5; j++) {
                    result[i][j] = CalculatorUtils.getRandomNumber(0, 9);
               }
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               for (int j = 0; j < 5; j++) {
                    sBuffer.append(CalculatorUtils.getRandomNumber(0, 9) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public int[] getRandomRed() {
          int column = getRedColumnCount();
          int[] red = new int[5];
          for (int i = 0; i < red.length; i++) {
               red[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
          }
          return red;
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.plw_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;
          if (red[red.length - 1] / getRedColumnCount() != 4)
               return false;
          return true;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.plw_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = 0;
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];

     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.plw_redpools);
     }

     @Override
     public String canSelecteRed(int[] a, int b) {
          return "yes";
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          state[0] = addballs;
          return state;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < 5; i++) {
               for (int j = 0; j < indexs.length; j++) {
                    if (indexs[j] / column == i) {
                         stringBuffer.append(texts[j]);
                    }
               }
               if (i != 5 - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          if (count == 1) {
               lotteryCartItem.mode = "单式";
          } else {
               lotteryCartItem.mode = "复式";
          }
          lotteryCartItem.number = redpool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";

          return lotteryCartItem;
     }
     @Override
     public int getTypeCodeByMode(String mode) {
          if ("单式".equals(mode)) {
               return 101;
          } else if ("复式".equals(mode)) {
               return 102;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}
package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 七乐彩 * * @author dzb * */
public class LotteryQLC extends LotteryRed {

     public LotteryQLC() {
          icon = R.string.qlc_icon;
          name = getString(R.string.qlc_name);
          gameName = getString(R.string.qlc_game_name);
          code = getString(R.string.qlc_code);
          issue = getString(R.string.qlc_issue);
          summary = getString(R.string.qlc_summary);
          price = getInteger(R.integer.qlc_price);
          deadLine = getString(R.string.qlc_deadline);
          redTag = getString(R.string.qlc_redtag);
          buleTag = getString(R.string.qlc_bluetag);
          redMin = getInteger(R.integer.qlc_redmin);
          blueMin = getInteger(R.integer.qlc_bluemin);
          rules = getStringArray(R.array.qlc_rules);
          notices = getStringArray(R.array.qlc_notices);
          playType = getStringArray(R.array.qlc_playtypes);
          currentType = getString(R.string.qlc_defaulttype);
          playMode = getStringArray(R.array.qlc_playmodes);
          currentMode = getString(R.string.qlc_defaultmode);
          allowAddTo = getBoolean(R.integer.qlc_allowAdd);
          format = getBoolean(R.integer.qlc_format);
          officialrule = R.string.qlc_officialrule;
          prizeexplain = R.string.qlc_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.qlc_redpools);
     }

     @Override
     public int[] getRandomRed() {
          return CalculatorUtils.getRandomArrayNumber(7, 0, 29);
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][7];
          for (int i = 0; i < n; i++) {
               result[i] = CalculatorUtils.getRandomArrayNumber(7, 1, 30);
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          int[] temp;
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               temp = CalculatorUtils.getRandomArrayNumber(7, 1, 30);
               for (int j = 0; j < 7; j++) {
                    sBuffer.append(StringUtil.format(temp[j]) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;
          if (red.length < redMin)
               return false;
          return true;
     }

     @Override
     public long calculatorBoxes(int[] red, int[] bule) {
          if (!isValid(red, bule))
               return -1;
          return CalculatorUtils.calculatorCombination(red.length, redMin);
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.qlc_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.qlc_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];
     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.qlc_redpools);
     }

     @Override
     public String canSelecteRed(int[] a, int b) {
          return "yes";
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          state[0] = addballs;
          return state;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < texts.length; i++) {
               stringBuffer.append(texts[i]);
               if (i != texts.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          if (count == 1) {
               lotteryCartItem.mode = "单式";
          } else {
               lotteryCartItem.mode = "复式";
          }
          lotteryCartItem.number = redpool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }
     @Override
     public int getTypeCodeByMode(String mode) {
          if ("单式".equals(mode)) {
               return 101;
          } else if ("复式".equals(mode)) {
               return 102;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}
package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 七星彩 */
public class LotteryQXC extends LotteryRed {
     public LotteryQXC() {
          icon = R.string.qxc_icon;
          name = getString(R.string.qxc_name);
          gameName = getString(R.string.qxc_game_name);
          code = getString(R.string.qxc_code);
          issue = getString(R.string.qxc_issue);
          summary = getString(R.string.qxc_summary);
          price = getInteger(R.integer.qxc_price);
          deadLine = getString(R.string.qxc_deadline);
          redTag = getString(R.string.qxc_redtag);
          buleTag = getString(R.string.qxc_bluetag);
          redMin = getInteger(R.integer.qxc_redmin);
          blueMin = getInteger(R.integer.qxc_bluemin);
          rules = getStringArray(R.array.qxc_rules);
          notices = getStringArray(R.array.qxc_notices);
          playType = getStringArray(R.array.qxc_playtypes);
          currentType = getString(R.string.qxc_defaulttype);
          playMode = getStringArray(R.array.qxc_playmodes);
          currentMode = getString(R.string.qxc_defaultmode);
          allowAddTo = getBoolean(R.integer.qxc_allowAdd);
          format = getBoolean(R.integer.qxc_format);
          officialrule = R.string.qxc_officialrule;
          prizeexplain = R.string.qxc_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          int column = getRedColumnCount();
          int m = 0;
          int n = 0;
          int k = 0;
          int j = 0;
          int l = 0;
          int a = 0;
          int b = 0;
          for (int i = 0; i < red.length; i++) {
               if (red[i] >= 0 && red[i] < column) {
                    m++;
               } else if (red[i] >= column && red[i] < 2 * column) {
                    n++;
               } else if (red[i] >= 2 * column && red[i] < 3 * column) {
                    k++;
               } else if (red[i] >= 3 * column && red[i] < 4 * column) {
                    j++;
               } else if (red[i] >= 4 * column && red[i] < 5 * column) {
                    l++;
               } else if (red[i] >= 5 * column && red[i] < 6 * column) {
                    a++;
               } else if (red[i] >= 6 * column && red[i] < 7 * column) {
                    b++;
               }
          }
          return m * n * k * j * l * a * b;
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][7];
          for (int i = 0; i < n; i++) {
               for (int j = 0; j < 7; j++) {
                    result[i][j] = CalculatorUtils.getRandomNumber(0, 9);
               }
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               for (int j = 0; j < 7; j++) {
                    sBuffer.append(CalculatorUtils.getRandomNumber(0, 9) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public int[] getRandomRed() {
          int column = getRedColumnCount();
          int[] red = new int[7];
          for (int i = 0; i < red.length; i++) {
               red[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
          }
          return red;
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.qxc_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;
          if (red[red.length - 1] / getRedColumnCount() != 6)
               return false;
          return true;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.qxc_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = 0;
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];

     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.qxc_redpools);
     }

     @Override
     public String canSelecteRed(int[] a, int b) {
          return "yes";
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          state[0] = addballs;
          return state;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < redMin; i++) {
               for (int j = 0; j < indexs.length; j++) {
                    if (indexs[j] / column == i) {
                         stringBuffer.append(texts[j]);
                    }
               }
               if (i != redMin - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          if (count == 1) {
               lotteryCartItem.mode = "单式";
          } else {
               lotteryCartItem.mode = "复式";
          }
          lotteryCartItem.number = redpool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("单式".equals(mode)) {
               return 101;
          } else if ("复式".equals(mode)) {
               return 102;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}
package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 时时乐 * * @author dzb * */
public class LotterySSL extends LotteryRed {

     public LotterySSL() {
          icon = R.string.ssl_icon;
          name = getString(R.string.ssl_name);
          gameName = getString(R.string.ssl_game_name);
          code = getString(R.string.ssl_code);
          issue = getString(R.string.ssl_issue);
          summary = getString(R.string.ssl_summary);
          price = getInteger(R.integer.ssl_price);
          deadLine = getString(R.string.ssl_deadline);
          redTag = getString(R.string.ssl_redtag);
          buleTag = getString(R.string.ssl_bluetag);
          redMin = getInteger(R.integer.ssl_redmin);
          blueMin = getInteger(R.integer.ssl_bluemin);
          rules = getStringArray(R.array.ssl_rules);
          notices = getStringArray(R.array.ssl_notices);
          playType = getStringArray(R.array.ssl_playtypes);
          currentType = getString(R.string.ssl_defaulttype);
          playMode = getStringArray(R.array.ssl_playmodes);
          currentMode = getString(R.string.ssl_defaultmode);
          allowAddTo = getBoolean(R.integer.ssl_allowAdd);
          format = getBoolean(R.integer.ssl_format);
          officialrule = R.string.ssl_officialrule;
          prizeexplain = R.string.ssl_prizeexplain;
          notifyPlayTypeChanged();
     }

     /** * 计算直选-和值可组合的注数 * * @param column * @param sum * @return */
     public int calculatorBoxes_zxhz(int column, int sum) {
          int count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = 0; j < column; j++) {
                    for (int h = 0; h < column; h++) {
                         if (i + j + h == sum) {
                              count++;
                         }
                    }

               }
          }
          return count;

     }

     /** * 计算组三-和值可组合的注数 * * @param column * @param sum * @return */
     public int calculatorBoxes_zshz(int column, int sum) {
          int count = 0;
          count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = 0; j < column; j++) {
                    if (i + i + j == sum) {
                         count++;
                    }

               }
          }
          return count;

     }

     /** * 计算组六-和值可组合的注数 * * @param column * @param sum * @return */
     public int calculatorBoxes_zlhz(int column, int sum) {
          int count = 0;
          count = 0;
          for (int i = 0; i < column; i++) {
               for (int j = 0; j < column; j++) {
                    for (int h = 0; h < column; h++) {
                         if (i + j + h == sum) {
                              count++;
                         }
                    }

               }
          }
          return count;

     }

     @Override
     public long calculatorBoxes(int[] red, int[] bule) {
          if (!isValid(red, bule))
               return -1;
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 直选-复式
               return CalculatorUtils.calculatorBoxs(red, column);
          case 1:// 直选-和值
               return calculatorBoxes_zxhz(column, red[0]);
          case 2:// 组三-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 3:// 组三-单式
               return 1;
          case 4:// 组三-和值
               return calculatorBoxes_zshz(column, red[0]+1);
          case 5:// 组六-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 6:// 组六-和值
               return calculatorBoxes_zlhz(column, red[0]+3);
          case 7:// 前二-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 8:// 后二-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 9:// 前一-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          case 10:// 后一-复式
               return 2 * CalculatorUtils
                         .calculatorCombination(red.length, redMin);
          }
          return 0;
     }

     @Override
     public int[][] getRandom(int n) {
          redMin = 3;
          int[][] result = new int[n][3];
          for (int i = 0; i < n; i++) {
               result[i][0] = CalculatorUtils.getRandomNumber(0, 9);
               result[i][1] = CalculatorUtils.getRandomNumber(0, 9);
               result[i][2] = CalculatorUtils.getRandomNumber(0, 9);
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               for (int j = 0; j < 3; j++) {
                    sBuffer.append(CalculatorUtils.getRandomNumber(0, 9) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public int[] getRandomRed() {
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 直选-复式
               int[] ball = new int[3];
               for (int i = 0; i < ball.length; i++) {
                    ball[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
               }
               return ball;
          case 1:// 直选-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 27);
          case 2:// 组三-复式
               return CalculatorUtils.getRandomArrayNumber(2, 0, 9);
          case 3:// 组三-单式
               ball = new int[3];
               ball[0] = CalculatorUtils.getRandomNumber(0, 9);
               ball[1] = ball[0] + column;
               do {
                    ball[2] = CalculatorUtils.getRandomNumber(0, 9);
               } while (ball[2] == ball[0]);
               ball[2] = ball[2] + 2 * column;
               return ball;
          case 4://组三-和值
               return CalculatorUtils.getRandomArrayNumber(1, 0, 25);
          case 5:// 组六-复式
               return CalculatorUtils.getRandomArrayNumber(3, 0, 9);
          case 6://组六-和值
          return CalculatorUtils.getRandomArrayNumber(1, 0, 21);
          case 7:// 前二-复式
               ball = new int[2];
               for (int i = 0; i < ball.length; i++) {
                    ball[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
               }
               return ball;
          case 8:// 后二-复式
               ball = new int[2];
               for (int i = 0; i < ball.length; i++) {
                    ball[i] = CalculatorUtils.getRandomNumber(0, 9) + i * column;
               }
               return ball;
          case 9:// 前一-复式
               return CalculatorUtils.getRandomArrayNumber(1, 0, 9);
          case 10:// 后一-复式
               return CalculatorUtils.getRandomArrayNumber(1, 0, 9);
          }
          return null;
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.ssl_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 直选-复式
               break;
          case 1:// 直选-和值
               break;
          case 2:// 组三-复式
               break;
          case 3:// 组三-单式
               if (red[red.length - 1] / column != 2)
                    return false;
          case 4:// 组三-和值
               break;
          case 5:// 组六-复式
               break;
          case 6:// 组六-和值
               break;
          case 7:// 前二-复式
               break;
          case 8:// 后二-复式
               break;
          case 9:// 前一-复式
               break;
          case 10:// 后一-复式
               break;
          }
          if (red.length < redMin)
               return false;
          return true;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.ssl_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          playMode = getPlayModes(R.array.ssl_playmodes);
          currentMode = playMode[0];
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.ssl_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];
          switch (currentIndex) {
          case 0:// 直选-复式
               redMin = 3;
               break;
          case 1:// 直选-和值
               redMin = 1;
               break;
          case 2:// 组三-复式
               redMin = 2;
               break;
          case 3:// 组三-单式
               redMin = 3;
               break;
          case 4:// 组三-和值
               redMin = 1;
               break;
          case 5:// 组六-复式
               redMin = 3;
               break;
          case 6:// 组六-和值
               redMin = 1;
               break;
          case 7:// 前二-复式
               redMin = 2;
          case 8:// 后二-复式
               redMin = 2;
               break;
          case 9:// 前一-复式
               redMin = 1;
               break;
          case 10:// 后一-复式
               redMin = 1;
               break;
          }

     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.ssl_redpools);
     }

     @Override
     public String canSelecteRed(int[] selected, int index) {
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 直选-复式
          case 1:// 直选-和值
          case 2:// 组三-复式
          case 3:// 组三-单式
               if (index >= 0 && index < 2 * column) {
                    if (selected.length == 3) {
                         if (selected[2] % column == index % column) {
                              return "不能重复选择";
                         }
                    }
               } else {
                    if (selected.length == 2 || selected.length == 3) {
                         if (selected[1] % column == index % column) {
                              return "不能重复选择";
                         }

                    }
               }
          case 4:// 组三-和值
          case 5:// 组六-复式
          case 6:// 组六-和值
          case 7:// 前二-复式
          case 8:// 后二-复式
          case 9:// 前一-复式
          case 10:// 后一-复式
          }
          return "yes";
     }

     // 复式
     public int[][] fushi(int[] a, int b) {
          int[][] state = new int[2][];
          int[] add = new int[] { b };
          int[] remove = null;
          state[0] = add;
          state[1] = remove;
          return state;
     }

     // 单式
     public int[][] danshi(int[] a, int b) {
          int[][] state = new int[2][];
          int column = getRedColumnCount();
          int index = b / column;
          int[] add = null;
          int[] remove = null;
          if (a.length == 0) {
               if (index == 0) {
                    add = new int[] { b, b + column };
                    remove = null;
               } else if (index == 1) {
                    add = new int[] { b, b - column };
                    remove = null;
               } else if (index == 2) {
                    add = new int[] { b };
                    remove = null;
               }
          } else if (a.length == 1) {
               if (index == 0) {
                    add = new int[] { b, b + column };
                    remove = null;
               } else if (index == 1) {
                    add = new int[] { b, b - column };
                    remove = null;
               } else if (index == 2) {
                    add = new int[] { b };
                    remove = a;
               }
          } else if (a.length == 2) {
               if (index == 0) {
                    add = new int[] { b, b + column };
                    remove = a;
               } else if (index == 1) {
                    add = new int[] { b, b - column };
                    remove = a;
               } else if (index == 2) {
                    add = new int[] { b };
                    remove = null;
               }

          } else if (a.length == 3) {
               if (index == 0) {
                    add = new int[] { b, b + column };
                    remove = new int[] { a[0], a[1] };
               } else if (index == 1) {
                    add = new int[] { b, b - column };
                    remove = new int[] { a[0], a[1] };
               } else if (index == 2) {
                    add = new int[] { b };
                    remove = new int[] { a[2] };
               }

          }
          state[0] = add;
          state[1] = remove;
          return state;
     }

     // 和值
     public int[][] hezhi(int[] a, int b) {
          int[][] state = new int[2][];
          int[] add = new int[] { b };
          int[] remove = a;
          state[0] = add;
          state[1] = remove;
          return state;
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          int column = getRedColumnCount();
          if (isCancel) {
               if (currentIndex == 3) {
                    if (index / column == 0) {
                         int[][] state = new int[2][];
                         int[] remove = new int[] { index, index + column };
                         int[] add = null;
                         state[0] = add;
                         state[1] = remove;
                         return state;
                    } else if (index / column == 1) {
                         int[][] state = new int[2][];
                         int[] remove = new int[] { index, index - column };
                         int[] add = null;
                         state[0] = add;
                         state[1] = remove;
                         return state;
                    }
               }
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;

          }
          switch (currentIndex) {
          case 0:// 直选-复式
               return fushi(selected, index);
          case 1:// 直选-和值
               return hezhi(selected, index);
          case 2:// 组三-复式
               return fushi(selected, index);
          case 3:// 组三-单式
               return danshi(selected, index);
          case 4:// 组三-和值
               return hezhi(selected, index);
          case 5:// 组六-复式
               return fushi(selected, index);
          case 6:// 组六-和值
               return hezhi(selected, index);
          case 7:// 前二-复式
               return fushi(selected, index);
          case 8:// 后二-复式
               return fushi(selected, index);
          case 9:// 前一-复式
               return fushi(selected, index);
          case 10:// 后一-复式
               return fushi(selected, index);
          }
          return null;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          switch (currentIndex) {
          case 0:// 直选-复式
               return format(texts, indexs, 3);
          case 1:// 直选-和值
               return format(texts, indexs);
          case 2:// 组三-复式
               return format(texts, indexs);
          case 3:// 组三-单式
               return format(texts, indexs);
          case 4:// 组三-和值
               return format(texts, indexs);
          case 5:// 组六-复式
               return format(texts, indexs);
          case 6:// 组六-和值
               return format(texts, indexs);
          case 7:// 前二-复式
               return format_qianer(texts, indexs);
          case 8:// 后二-复式
               return format_houer(texts, indexs);
          case 9:// 前一-复式
               return format_qianyi(texts, indexs);
          case 10:// 后一-复式
               return format_houyi(texts, indexs);
          }
          return null;
     }

     // 与行号有关 格式化为{2 3 4,11 15}
     private String format(String[] text, int[] index, int count) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < count; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != count - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     private String format_qianer(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < 2; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != 2 - 1)
                    stringBuffer.append(",");
          }
          stringBuffer.append(",_");
          return stringBuffer.toString();
     }

     private String format_houer(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          stringBuffer.append("_,");
          int column = getRedColumnCount();
          for (int i = 0; i < 2; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != 2 - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     private String format_houyi(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          stringBuffer.append("_,");
          stringBuffer.append("_,");
          int column = getRedColumnCount();
          for (int i = 0; i < 1; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != 1 - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     private String format_qianyi(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          int column = getRedColumnCount();
          for (int i = 0; i < 1; i++) {
               for (int j = 0; j < index.length; j++) {
                    if (index[j] / column == i) {
                         stringBuffer.append(text[j]);
                    }
               }
               if (i != 1 - 1)
                    stringBuffer.append(",");
          }
          stringBuffer.append(",_");
          stringBuffer.append(",_");
          return stringBuffer.toString();
     }

     // 与行号无关 格式化为{2,3,4,5,6}
     public String format(String[] text, int[] index) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < text.length; i++) {
               stringBuffer.append(text[i]);
               if (i < text.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name = gameName;
          lotteryCartItem.number = redpool;
          lotteryCartItem.mode = currentMode;
          if (lotteryCartItem.mode.equals("复式")) {
               if (count == 1) {
                    lotteryCartItem.mode = "单式";
               }
          }
          lotteryCartItem.mode = currentType + lotteryCartItem.mode;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("直选单式".equals(mode)) {
               return 101;
          } else if ("直选复式".equals(mode)) {
               return 102;
          } else if ("组三单式".equals(mode)) {
               return 103;
          } else if ("组三复式".equals(mode)) {
               return 104;
          } else if ("组三和值".equals(mode)) {
               return 105;
          } else if ("组六单式".equals(mode)) {
               return 106;
          } else if ("组六复式".equals(mode)) {
               return 107;
          } else if ("组六和值".equals(mode)) {
               return 108;
          } else if ("前一单式".equals(mode)) {
               return 109;
          } else if ("前一复式".equals(mode)) {
               return 110;
          } else if ("后一单式".equals(mode)) {
               return 111;
          } else if ("后一复式".equals(mode)) {
               return 112;
          } else if ("前二单式".equals(mode)) {
               return 113;
          } else if ("前二复式".equals(mode)) {
               return 114;
          } else if ("后二单式".equals(mode)) {
               return 115;
          } else if ("后二复式".equals(mode)) {
               return 116;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }

}
package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

/** * 双色球 */
public class LotterySSQ extends LotteryBase {
     public LotterySSQ() {
          icon = R.string.ssq_icon;
          name = getString(R.string.ssq_name);
          gameName = getString(R.string.ssq_game_name);
          code = getString(R.string.ssq_code);
          issue = getString(R.string.ssq_issue);
          summary = getString(R.string.ssq_summary);
          price = getInteger(R.integer.ssq_price);
          deadLine = getString(R.string.ssq_deadline);
          redTag = getString(R.string.ssq_redtag);
          buleTag = getString(R.string.ssq_bluetag);
          redMin = getInteger(R.integer.ssq_redmin);
          blueMin = getInteger(R.integer.ssq_bluemin);
          rules = getStringArray(R.array.ssq_rules);
          notices = getStringArray(R.array.ssq_notices);
          playType = getStringArray(R.array.ssq_playtypes);
          currentType = getString(R.string.ssq_defaulttype);
          playMode = getStringArray(R.array.ssq_playmodes);
          currentMode = getString(R.string.ssq_defaultmode);
          allowAddTo = getBoolean(R.integer.ssq_allowAdd);
          format = getBoolean(R.integer.ssq_format);
          officialrule = R.string.ssq_officialrule;
          prizeexplain = R.string.ssq_prizeexplain;
          notifyPlayTypeChanged();
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          long rednum = CalculatorUtils.calculatorCombination(red.length, redMin);
          long bluenum = CalculatorUtils.calculatorCombination(blue.length,
                    blueMin);
          return rednum * bluenum;
     }

     @Override
     public int[] getBluePool() {
          return super.getBluePool(R.array.ssq_bluepools);
     }

     @Override
     public int[][] getRandom(int n) {
          int[][] result = new int[n][7];
          int[] temp;
          for (int i = 0; i < n; i++) {
               temp = CalculatorUtils.getRandomArrayNumber(6, 1, 33);
               for (int j = 0; j < temp.length; j++) {
                    result[i][j] = temp[j];
               }
               result[i][6] = CalculatorUtils.getRandomNumber(1, 16);
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          int[] temp;
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               // 红球
               temp = CalculatorUtils.getRandomArrayNumber(6, 1, 33);
               for (int j = 0; j < 6; j++) {
                    sBuffer.append(StringUtil.format(temp[j]) + ",");
               }
               sBuffer.deleteCharAt(sBuffer.lastIndexOf(","));
               sBuffer.append("#");
               // 蓝球
               sBuffer.append(StringUtil.format(CalculatorUtils
                              .getRandomNumber(1, 16)) + "");
               result[i] = sBuffer.toString();
          }
          return result;
     }

     @Override
     public int[] getRandomBlue() {
          return CalculatorUtils.getRandomArrayNumber(blueMin, 0, 15);
     }

     @Override
     public int[] getRandomRed() {
          return CalculatorUtils.getRandomArrayNumber(redMin, 0, 32);
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.ssq_redpools);
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0 || bule.length == 0)
               return false;
          if (red.length >= redMin && bule.length >= blueMin) {
               return true;
          }
          return false;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.ssq_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.ssq_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[currentIndex];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[currentIndex];
     }

     @Override
     public int getRedColumnCount() {
          return super.getBlueColumnCount(R.array.ssq_redpools);
     }

     @Override
     public int getBlueColumnCount() {
          return super.getBlueColumnCount(R.array.ssq_bluepools);
     }

     @Override
     public String canSelecteRed(int[] a, int b) {
          return "yes";
     }

     @Override
     public String canSelecteBlue(int[] a, int b) {
          return "yes";
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          int[] remove = null;
          state[0] = addballs;
          state[1] = remove;
          return state;
     }

     @Override
     public int[][] newblueBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int[][] state = new int[2][];
          int[] addballs = new int[] { index };
          int[] remove = null;
          state[0] = addballs;
          state[1] = remove;
          return state;
     }

     @Override
     public String formatSelectedRed(String[] texts, int[] indexs) {
          StringBuffer stringBuffer = new StringBuffer();
          for (int i = 0; i < texts.length; i++) {
               stringBuffer.append(texts[i]);
               if (i != texts.length - 1)
                    stringBuffer.append(",");
          }
          return stringBuffer.toString();
     }

     @Override
     public String formatSelectedBlue(String[] texts, int[] indexs) {
          return formatSelectedRed(texts, indexs);
     }

     @Override
     public LotteryCartItem createLotteryCartItem(String redpool,
               String bluepool, String result, boolean zhuijia) {
          LotteryCartItem lotteryCartItem = new LotteryCartItem();
          int m = result.indexOf("注");
          int n = result.indexOf("元");
          long count = Long.parseLong(result.substring(0, m));
          long money = Long.parseLong(result.substring(m + 1, n));
          lotteryCartItem.count = count;
          lotteryCartItem.money = money;
          lotteryCartItem.isAddTo = zhuijia;
          lotteryCartItem.name =gameName;
          if (count == 1) {
               lotteryCartItem.mode = "单式";
          } else {
               lotteryCartItem.mode = "复式";
          }
          lotteryCartItem.number = redpool + "#" + bluepool;
          lotteryCartItem.type = getTypeCodeByMode(lotteryCartItem.mode) + "";
          return lotteryCartItem;
     }

     @Override
     public int getTypeCodeByMode(String mode) {
          if ("单式".equals(mode)) {
               return 101;
          } else if ("复式".equals(mode)) {
               return 102;
          } else if (StringUtil.isEmpty(mode)) {
               return 101;
          }
          return 101;
     }
}