From 134770f0cd68eaf0525e03bb6e6cfbd03153fdb7 Mon Sep 17 00:00:00 2001
From: Joe Zhao <ztuowen@gmail.com>
Date: Tue, 2 Dec 2014 21:40:36 +0800
Subject: Various UI Tested Read Card

---
 Main.java                    |  5 ++-
 aux/Hand.java                | 28 -----------------
 aux/set/Aside.java           | 41 ++++++++++++++++++++++++
 aux/set/CardSet.java         | 50 ++++++++++++++++++-----------
 aux/set/Hand.java            | 66 ++++++++++++++++++++++++++++++++++++--
 engine/Engine.java           | 18 +++++++++++
 player/GenericPlayer.java    | 33 +++++++++++++++++++
 player/ai/Values.java        | 25 +++++++++++++++
 player/human/LocalHuman.java | 75 ++++++++++++++++++++++++++++++++++++++++++++
 9 files changed, 291 insertions(+), 50 deletions(-)
 delete mode 100644 aux/Hand.java
 create mode 100644 aux/set/Aside.java
 create mode 100644 engine/Engine.java
 create mode 100644 player/GenericPlayer.java
 create mode 100644 player/ai/Values.java
 create mode 100644 player/human/LocalHuman.java

diff --git a/Main.java b/Main.java
index 6319ea6..e9cd950 100644
--- a/Main.java
+++ b/Main.java
@@ -2,6 +2,7 @@ package mahjong;
 
 import mahjong.aux.set.CardSet;
 import mahjong.aux.set.Set;
+import mahjong.player.human.LocalHuman;
 import mahjong.tools.Timer;
 
 public class Main {
@@ -32,8 +33,10 @@ public class Main {
             cardSet.add(hand,1);
             Timer timer=new Timer();
             timer.tick();
-            System.out.println(cardSet.ameliorate().size());
+            System.out.println(cardSet.ameliorate(0).size());
             timer.tock();
             System.out.println(timer.elapse());
+
+        LocalHuman local=new LocalHuman("Joe");
     }
 }
diff --git a/aux/Hand.java b/aux/Hand.java
deleted file mode 100644
index ef8da6c..0000000
--- a/aux/Hand.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package mahjong.aux;
-
-/**
- * Created by joe on 12/1/14.
- */
-
-public class Hand {
-    static final int total = 13;
-    Card[] cards = new Card[13];
-
-    // Constructors
-    Hand(){}
-    Hand(String[] cardNames)
-    {
-        for (int i = 0; i<total;++i)
-            cards[i] = new Card(cardNames[i]);
-    }
-    Hand(Card[] cards)
-    {
-        this.cards = cards;
-    }
-
-    // Some operation
-    int calTing()
-    {
-        return 0;
-    }
-}
diff --git a/aux/set/Aside.java b/aux/set/Aside.java
new file mode 100644
index 0000000..1503799
--- /dev/null
+++ b/aux/set/Aside.java
@@ -0,0 +1,41 @@
+package mahjong.aux.set;
+
+import mahjong.aux.Card;
+import mahjong.player.GenericPlayer;
+
+/**
+ * Created by joe on 12/2/14.
+ */
+public class Aside {
+    public enum Type {Chi,Peng,aGang,mGang,jGang};
+
+    private Type type;
+    private Card rep;
+    private int from;
+
+    public Aside(Card rep,Type type,int from)
+    {
+        this.rep=rep;
+        this.type=type;
+        this.from=from;
+    }
+
+    public Aside(Card rep,Type type)
+    {
+        this.rep=rep;
+        this.type=type;
+        this.from= 0;
+    }
+
+    public Card getRep() {
+        return rep;
+    }
+
+    public int getFrom() {
+        return from;
+    }
+
+    public Type getType() {
+        return type;
+    }
+}
diff --git a/aux/set/CardSet.java b/aux/set/CardSet.java
index 8df6055..56a998d 100644
--- a/aux/set/CardSet.java
+++ b/aux/set/CardSet.java
@@ -15,9 +15,9 @@ public class CardSet {
                     36, 38, 40, 42, 44, 46, 48, 50, 52,
                     68, 70, 72, 74, 76, 78, 80, 82, 84,
                     100,106,112,118,
-                    132,138,144,146
+                    132,138,144,148
             };
-    private static final int[] id2OrdLut = new int[]
+    public static final int[] id2OrdLut = new int[]
             {
                    34, 34,  0,  1,  2,  3,  4,  5,  6,  7,  8, 34, 34, 34, 34, 34,
                    34, 34,  9,  10, 11, 12, 13, 14, 15, 16, 17,34, 34, 34, 34, 34,
@@ -49,11 +49,11 @@ public class CardSet {
         cardRem[getOrd(card.getStdId())]+=mult;
     }
 
-    protected int std2Id(int std)
+    public static int std2Id(int std)
     {
         return std>>1;
     }
-    protected int getOrd(int id)
+    public static int getOrd(int id)
     {
         return id2OrdLut[std2Id(id)];
     }
@@ -68,24 +68,36 @@ public class CardSet {
 
     private int cnt=0;
 
-    public int calTing()
+    public int calTing(int mian)
     {
         //cnt=0;
-        int res=calTing(0,cardRem[0],0,0,0);
+        int res=calTing(0,cardRem[0],0,0,mian);
         //System.out.println(cnt);
         return res;
     }
 
-    private int nextCardOrd(int i)
+    public static int nextCardOrd(int i)
     {
         return getOrd(deckIds[i]+2);
     }
 
-    private int next2CardOrd(int i)
+    public static int next2CardOrd(int i)
     {
         return nextCardOrd(nextCardOrd(i));
     }
 
+    public static int prevCardOrd(int i)
+    {
+        return getOrd(deckIds[i]-2);
+    }
+
+    public static int prev2CardOrd(int i)
+    {
+        return prevCardOrd(prevCardOrd(i));
+    }
+
+    public int cardLeft(int ord){ return cardRem[ord]; }
+
     private int calTing(int pos,int rems,int shoupai,int ting, int mian)
     {
         //++cnt;
@@ -141,17 +153,17 @@ public class CardSet {
         return Math.min(6-shoupai,res);
     }
 
-    public Vector<Card> jinZhang()
+    public Vector<Card> jinZhang(int mian)
     {
         Vector<Card> cards = new Vector<Card>();
         int res=0;
-        int ref=calTing();
+        int ref=calTing(mian);
         for (int i=0;i<cardTypeTotal;++i)
             if (cardRem[i]<3)
             {
                 Card card=new Card(deckIds[i]);
                 add(card,1);
-                if (calTing()<ref) {
+                if (calTing(mian)<ref) {
                     ++res;
                     cards.add(card);
                 }
@@ -160,19 +172,19 @@ public class CardSet {
         return cards;
     }
 
-    public Vector<Card> ameliorate()
+    public Vector<Card> ameliorate(int mian)
     {
         Vector<Card> cards = new Vector<Card>();
         int res=0;
-        int ref=calTing();
-        int jinref=jinZhang().size();
+        int ref=calTing(mian);
+        int jinref=jinZhang(mian).size();
         for (int i=0;i<cardTypeTotal;++i)
             if (cardRem[i]<3)
             {
                 Card card=new Card(deckIds[i]);
                 add(card,1);
-                if (calTing()==ref) {
-                    if (maxJinZhang(ref)>jinref) {
+                if (calTing(mian)==ref) {
+                    if (maxJinZhang(mian,ref)>jinref) {
                         ++res;
                         cards.add(card);
                         //System.out.println(card.getNormalName());
@@ -183,15 +195,15 @@ public class CardSet {
         return cards;
     }
 
-    public int maxJinZhang(int xt)
+    public int maxJinZhang(int mian,int xt)
     {
         int res=0;
         for (int i=0;i<cardTypeTotal;++i)
             if (cardRem[i]>0)
             {
                 --cardRem[i];
-                if (calTing()==xt)
-                    res=Math.max(res,jinZhang().size());
+                if (calTing(mian)==xt)
+                    res=Math.max(res,jinZhang(mian).size());
                 ++cardRem[i];
             }
         return res;
diff --git a/aux/set/Hand.java b/aux/set/Hand.java
index b715e54..cf5767e 100644
--- a/aux/set/Hand.java
+++ b/aux/set/Hand.java
@@ -2,10 +2,14 @@ package mahjong.aux.set;
 
 import mahjong.aux.Card;
 
+import java.util.Vector;
+
 /**
  * Created by joe on 12/1/14.
  */
 public class Hand extends Set {
+    private CardSet accountant = new CardSet(0);
+
     public Hand()
     {
         super();
@@ -19,8 +23,66 @@ public class Hand extends Set {
         super(cards);
     }
 
-    public Set[] generateEnds()
+    public Vector<Aside> asides = new Vector<Aside>();
+
+    public void init()
+    {
+        cards.clear();
+        asides.clear();
+    }
+
+    public boolean huAble(Card card)
+    {
+        boolean hu=false;
+        accountant.add(card,1);
+        if (accountant.calTing(asides.size())==0)
+            hu=true;
+        accountant.add(card,-1);
+        return hu;
+    }
+
+    public boolean chiAble(Card card)
+    {
+        if (accountant.cardLeft(CardSet.nextCardOrd(CardSet.std2Id(card.getStdId())))>0)
+            if (accountant.cardLeft(CardSet.prevCardOrd(CardSet.std2Id(card.getStdId())))>0
+                || accountant.cardLeft(CardSet.next2CardOrd(CardSet.std2Id(card.getStdId())))>0)
+                return true;
+        if (accountant.cardLeft(CardSet.prevCardOrd(CardSet.std2Id(card.getStdId())))>0
+            && accountant.cardLeft(CardSet.prev2CardOrd(CardSet.std2Id(card.getStdId())))>0)
+            return true;
+        return false;
+    }
+
+    public boolean pengAble(Card card)
+    {
+        if (accountant.cardLeft(CardSet.std2Id(card.getStdId()))>2)
+            return true;
+        return false;
+    }
+
+    public boolean gangAble(Card card)
+    {
+        if (accountant.cardLeft(CardSet.std2Id(card.getStdId()))>3)
+            return true;
+        return false;
+    }
+
+    public boolean jiaGangAble(Card card)
+    {
+        for (Aside i:asides)
+        if (i.getType()== Aside.Type.Peng && card.getStdId() == i.getRep().getStdId())
+            return true;
+        return false;
+    }
+
+    public boolean anGangAble(Card card)
     {
-        return null;
+        boolean gang=false;
+        accountant.add(card,1);
+        for (int i=0;i< CardSet.cardTypeTotal;++i)
+            if (accountant.cardLeft(i)>3)
+                gang=true;
+        accountant.add(card,-1);
+        return gang;
     }
 }
diff --git a/engine/Engine.java b/engine/Engine.java
new file mode 100644
index 0000000..b59035f
--- /dev/null
+++ b/engine/Engine.java
@@ -0,0 +1,18 @@
+package mahjong.engine;
+
+import mahjong.player.GenericPlayer;
+
+/**
+ * Created by joe on 12/2/14.
+ */
+public class Engine {
+    GenericPlayer[] players=new GenericPlayer[4];
+
+    public Engine(GenericPlayer player1,GenericPlayer player2,GenericPlayer player3,GenericPlayer player4)
+    {
+        players[0]=player1;
+        players[1]=player2;
+        players[2]=player3;
+        players[3]=player4;
+    }
+}
diff --git a/player/GenericPlayer.java b/player/GenericPlayer.java
new file mode 100644
index 0000000..bd53b8c
--- /dev/null
+++ b/player/GenericPlayer.java
@@ -0,0 +1,33 @@
+package mahjong.player;
+
+import mahjong.aux.Card;
+import mahjong.aux.set.Aside;
+import mahjong.aux.set.Hand;
+import mahjong.aux.set.Set;
+
+import java.io.IOException;
+
+/**
+ * Created by joe on 12/2/14.
+ */
+public abstract class GenericPlayer {
+    public Hand hand=new Hand();
+
+    protected String name;
+
+    public String getName() {
+        return name;
+    }
+
+    public abstract void stateUpdate(GenericPlayer player,Aside aside,Card card);
+    public abstract Card putCard();
+    public abstract void give(Card card);
+
+    public abstract Aside confirmPeng(Card card);
+    public abstract Aside confirmChi(Card card);
+    public abstract Aside confirmJiaAnGang(Card card);
+    public abstract Aside confirmMingGang(Card card);
+
+    public abstract boolean confirmHu();
+
+}
diff --git a/player/ai/Values.java b/player/ai/Values.java
new file mode 100644
index 0000000..ac3db75
--- /dev/null
+++ b/player/ai/Values.java
@@ -0,0 +1,25 @@
+package mahjong.player.ai;
+
+/**
+ * Created by joe on 12/2/14.
+ */
+public class Values {
+    public static final double[] valuesI = new double[]{};
+    public static final double[] deckValue = new double[]
+            {
+                    5,  8,  8,  8,  8,  8,  8,  8,  5,
+                    5,  8,  8,  8,  8,  8,  8,  8,  5,
+                    5,  8,  8,  8,  8,  8,  8,  8,  5,
+                    6,6,6,6,
+                    6,6,6,0
+            };
+    public static final double[] spitRate = new double[]
+            {
+                    0,6,4,3,4
+            };
+
+    public static double calCardSpitProb(int rems, int id)
+    {
+        return spitRate[rems]/deckValue[id];
+    }
+}
diff --git a/player/human/LocalHuman.java b/player/human/LocalHuman.java
new file mode 100644
index 0000000..4ae8bf7
--- /dev/null
+++ b/player/human/LocalHuman.java
@@ -0,0 +1,75 @@
+package mahjong.player.human;
+
+import mahjong.aux.Card;
+import mahjong.aux.set.Aside;
+import mahjong.aux.set.Hand;
+import mahjong.player.GenericPlayer;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+/**
+ * Created by joe on 12/2/14.
+ */
+public class LocalHuman extends GenericPlayer {
+
+    public LocalHuman(String name)
+    {
+        this.name=name;
+    }
+
+    @Override
+    public void stateUpdate(GenericPlayer player, Aside aside, Card card) {
+        if (aside!=null)
+            System.out.println(player.getName().concat(":\n\t").concat(aside.getType().name()).concat("\tStart with\t").concat(aside.getRep().getNormalName()));
+        if (card!=null)
+            System.out.println(player.getName().concat(":\n\t").concat("Putdown:\t").concat(card.getNormalName()));
+    }
+
+    @Override
+    public Card putCard(){
+        System.out.println("Your deck now:");
+        hand.print();
+        BufferedReader br = new BufferedReader(new
+                InputStreamReader(System.in));
+        String cardStr="Yi Wan";
+        try {
+            cardStr = br.readLine();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return new Card(cardStr);
+    }
+
+    @Override
+    public void give(Card card) {
+        System.out.println("You drew:\n\t".concat(card.getNormalName()));
+        hand.add(card);
+    }
+
+    @Override
+    public Aside confirmPeng(Card card) {
+        return null;
+    }
+
+    @Override
+    public Aside confirmChi(Card card) {
+        return null;
+    }
+
+    @Override
+    public Aside confirmJiaAnGang(Card card) {
+        return null;
+    }
+
+    @Override
+    public Aside confirmMingGang(Card card) {
+        return null;
+    }
+
+    @Override
+    public boolean confirmHu() {
+        return false;
+    }
+}
-- 
cgit v1.2.3-70-g09d2