内容导航：
一、斗地主android棋牌
本文实现了android端单机版的斗地主, 一共三个玩家(一个地主，二个农民)
游戏进入后，针对上家出的牌，如果本家有大的牌，可以出牌，如果没有相应的牌，可以选择不要牌,
在组合牌型时，如果不符合斗地主的牌型要求，是不能出牌的，如果组合的牌型不能大过上家的牌，也是不能出牌的
本示例提供源码，需要源码的朋友可以下载
android开发环境配置 /Wisdom/resource/?resourceId=1028
本项目是一个单机的斗地主项目源码，不过这个项目的分辨率有点问题，我在真机和模拟器的480*800上无论是横屏还是竖屏游戏都只能显示一部分画面，可能项目是使用的更低分辨率创建的，不过我玩了玩这个项目的却比以前发的斗地主项目算法要好一些，分配地主发牌都是随机的，根据谁的牌数先为0就是谁赢，再根据他的Id判断他是农民还是地主，每个人自动生成3分，结束后赢家加分输家扣分源码有注释，编码GBK默认编译版本4.4.2，需要的朋友可以下载研究一下
源码介绍:
扑克牌
public class Card {
int value=``0``;
int pokeType=``0``;
int``[] pokes;
Bitmap pokeImage;
int personID;
public Card(``int``[] pokes,Bitmap pokeImage,``int id)
{
this``.personID=id;
this``.pokes=pokes;
this``.pokeImage=pokeImage;
pokeType=pe(pokes);
value=peValue(pokes, pokeType);
//显示的正确排列
// 如果有炸弹牌出现，分数翻倍
if``(pokeType==||pokeType==)
{
ore*=``2``;
}
}
public void paint(Canvas canvas,``int left,``int top,``int dir)
{
Rect src = ``new Rect();
Rect des = ``new Rect();
for (``int i = ``0``; i < ; i++) {
int row = ow(pokes[i]);
int col = ol(pokes[i]);
if (dir == ) {
row = ow(pokes[i]);
col = ol(pokes[i]);
(col * ``35``, row * ``52``, col * ``35 + ``35``, row * ``52 + ``52``);
(left, top + i * ``13``, left + ``35``, top + ``52 + i * ``13``);
} ``else {
row = ow(pokes[i]);
col = ol(pokes[i]);
int select = ``0``;
(col * ``35``, row * ``52``, col * ``35 + ``35``, row * ``52 + ``52``);
(left + i * ``13``, top - select, left + ``35 + i * ``13``, top
- select + ``52``);
}
p(pokeImage, src, des, ``null``);
}
}
}
牌桌:Desk
public class Desk {
public static int winId = -``1``;
Bitmap pokeImage;
Bitmap tishi;
Bitmap buyao;
Bitmap chupai;
public static int``[] personScore = ``new int``[``3``];
public static int threePokes[] = ``new int``[``3``];``// 三张底牌
private int threePokesPos[][] = ``new int``[][] { { ``170``, ``17 },
{ ``220``, ``17},
{ ``270``, ``17 } };
private int``[][] rolePos = { { ``60``, ``310 }, { ``63``, ``19 }, {
``396``, ``19}, };
public static Person[] persons = ``new Person[``3``];``// 三个玩家
public static int``[] deskPokes = ``new int``[``54``];``// 一副扑克牌
public static int currentScore = ``3``;``// 当前分数
public static int boss = ``0``;``// 地主
/**
* -2:发牌<br>
* -1:随机地主<br>
* 0:游戏中 <br>
* 1:游戏结束，重新来，活退出<br>
*/
private int op = -``1``;``// 游戏的进度控制
public static int currentPerson = ``0``;``// 当前操作的人
public static int currentCircle = ``0``;``// 本轮次数
public static Card currentCard = ``null``;``// 最新的一手牌
public int``[][] personPokes = ``new int``[``3``][``17``];
// gaming
private int timeLimite = ``310``;
private int``[][] timeLimitePos = { { ``130``, ``205 }, { ``118``, ``76}, { ``327``, ``76 } };
private int opPosX = ``240``;
private int opPosY = ``200``;
DDZ ddz;
public Desk(DDZ ddz) {
this``.ddz = ddz;
pokeImage = ource(ces(),
3552);
tishi = BitmapFactory
.decodeResource(ces(), 0);
buyao = BitmapFactory
.decodeResource(ces(), 1);
chupai = ource(ces(),
2);
// init();
}
public void gameLogic() {
switch (op) {
case -``2``:
break``;
case -``1``:
init();
op = ``0``;
break``;
case 0``:
gaming();
break``;
case 1``:
break``;
case 2``:
break``;
}
}
// 存储当前一句的胜负得分信息
int rs[] = ``new int``[``3``];
private void gaming() {
for (``int k = ``0``; k < ``3``; k++) {
// 当三个人中其中一个人牌的数量为0，则游戏结束
if (persons[k]. == ``0``) {
// 切换到游戏结束状态
op = ``1``;
// 得到最先出去的人的id
winId = k;
// 判断哪方获胜
if (boss == winId) {
// 地主方获胜后的积分操作
for (``int i = ``0``; i < ``3``; i++) {
if (i == boss) {
// 地主需要加两倍积分
rs[i] = currentScore * ``2``;
personScore[i] += currentScore * ``2``;
} ``else {
// 农民方需要减分
rs[i] = -currentScore;
personScore[i] -= currentScore;
}
}
} ``else {
// 如果农民方胜利
for (``int i = ``0``; i < ``3``; i++) {
if (i != boss) {
// 农民方加分
rs[i] = currentScore;
personScore[i] += currentScore;
} ``else {
// 地主方减分
rs[i] = -currentScore * ``2``;
personScore[i] -= currentScore * ``2``;
}
}
}
return``;
}
}
// 游戏没有结束，继续。
// 如果本家ID是NPC，则执行语句中的操作
if (currentPerson == ``1 || currentPerson == ``2``) {
if (timeLimite <= ``300``) {
// 获取手中的牌中能够打过当前手牌
Card tempcard = persons[currentPerson].chupaiAI(currentCard);
if (tempcard != ``null``) {
// 手中有大过的牌，则出
currentCircle++;
currentCard = tempcard;
nextPerson();
} ``else {
// 没有打过的牌，则不要
buyao();
}
}
}
// 时间倒计时
timeLimite -= ``2``;
}
public void init() {
deskPokes = ``new int``[``54``];
personPokes = ``new int``[``3``][``17``];
threePokes = ``new int``[``3``];
winId = -``1``;
currentScore = ``3``;
currentCard = ``null``;
currentCircle = ``0``;
currentPerson = ``0``;
for (``int i = ``0``; i < ; i++) {
deskPokes[i] = i;
}
(deskPokes);
fenpai(deskPokes);
randDZ();
(personPokes[``0``]);
(personPokes[``1``]);
(personPokes[``2``]);
persons[``0``] = ``new Person(personPokes[``0``], ``234``, ``96``, ,
``0``,
this``, ddz);
persons[``1``] = ``new Person(personPokes[``1``], ``54``, ``28``, , ``1``,
``this``,
ddz);
persons[``2``] = ``new Person(personPokes[``2``], ``54``, ``417``, ,
``2``,
this``, ddz);
persons[``0``].setPosition(persons[``1``], persons[``2``]);
persons[``1``].setPosition(persons[``2``], persons[``0``]);
persons[``2``].setPosition(persons[``0``], persons[``1``]);
AnalyzePoke ana = ce();
for (``int i = ``0``; i < ; i++) {
boolean b = ze(personPokes[i]);
if (!b) {
init();
(``"chongqinglaiguo"``);
break``;
}
}
for (``int i = ``0``; i < ``3``; i++) {
StringBuffer sb = ``new StringBuffer();
(``"chushipai---" + i + ``":"``);
for (``int j = ``0``; j < personPokes[i].length; j++) {
(personPokes[i][j] + ``","``);
}
(());
}
}
// 随机地主，将三张底牌给地主
private void randDZ() {
boss = ();
currentPerson = boss;
int``[] newPersonPokes = ``new int``[``20``];
for (``int i = ``0``; i < ``17``; i++) {
newPersonPokes[i] = personPokes[boss][i];
}
newPersonPokes[``17``] = threePokes[``0``];
newPersonPokes[``18``] = threePokes[``1``];
newPersonPokes[``19``] = threePokes[``2``];
personPokes[boss] = newPersonPokes;
}
public void fenpai(``int``[] pokes) {
for (``int i = ``0``; i < ``51``;) {
personPokes[i / ``17``][i % ``17``] = pokes[i++];
}
threePokes[``0``] = pokes[``51``];
threePokes[``1``] = pokes[``52``];
threePokes[``2``] = pokes[``53``];
}
public void result() {
}
public void paint(Canvas canvas) {
switch (op) {
case -``2``:
break``;
case -``1``:
break``;
case 0``:
paintGaming(canvas);
break``;
case 1``:
paintResult(canvas);
break``;
case 2``:
break``;
}
}
private void paintResult(Canvas canvas) {
Paint paint = ``new Paint();
();
ze(``20``);
(``"本局得分 总分 "``, ``110``, ``66``, paint);
for (``int i = ``0``; i < ``3``; i++) {
(i + ``":本局得分:" + rs[i] + ``" 总分：" + personScore[i],
110``, ``96 + i * ``30``, paint);
}
}
private void paintGaming(Canvas canvas) {
persons[``0``].paint(canvas);
persons[``1``].paint(canvas);
persons[``2``].paint(canvas);
paintThreePokes(canvas);
paintRoleAndScore(canvas);
if (currentPerson == ``0``) {
Rect src = ``new Rect();
Rect dst = ``new Rect();
(``0``, ``0``, (), ());
(opPosX, opPosY, opPosX + (), opPosY
+ ());
p(chupai, src, dst, ``null``);
if (currentCircle != ``0``) {
(``0``, ``0``, (), ());
(opPosX + ``40``, opPosY, opPosX + () + ``40``,
opPosY + ());
p(tishi, src, dst, ``null``);
(``0``, ``0``, (), ());
(opPosX - ``40``, opPosY, opPosX + () - ``40``,
opPosY + ());
p(buyao, src, dst, ``null``);
}
}
if (persons[``0``].card != ``null``) {
persons[``0``].(canvas, ``130``, ``140``, );
}
if (persons[``1``].card != ``null``) {
persons[``1``].(canvas, ``73``, ``56``, );
}
if (persons[``2``].card != ``null``) {
persons[``2``].(canvas, ``365``, ``56``, );
}
paintTimeLimite(canvas);
Paint paint = ``new Paint();
ign();
(_AND_STROKE);
ze(``14``);
(``"当前底分：" + currentScore, ``165``, ``308``, paint);
}
private void paintTimeLimite(Canvas canvas) {
Paint paint = ``new Paint();
();
ze(``16``);
for (``int i = ``0``; i < ``3``; i++) {
if (i == currentPerson) {
(``"" + (timeLimite / ``10``), timeLimitePos[i][``0``],
timeLimitePos[i][``1``], paint);
}
}
}
private void paintRoleAndScore(Canvas canvas) {
Paint paint = ``new Paint();
for (``int i = ``0``; i < ``3``; i++) {
if (boss == i) {
();
(``"地主(得分：" + personScore[i] + ``")"``, rolePos[i][``0``],
rolePos[i][``1``], paint);
} ``else {
();
(``"农民(得分：" + personScore[i] + ``")"``, rolePos[i][``0``],
rolePos[i][``1``], paint);
}
}
}
private void paintThreePokes(Canvas canvas) {
Rect src = ``new Rect();
Rect dst = ``new Rect();
for (``int i = ``0``; i < ``3``; i++) {
int row = ow(threePokes[i]);
int col = ol(threePokes[i]);
(col * ``35``, row * ``52``, col * ``35 + ``35``, row * ``52 + ``52``);
(threePokesPos[i][``0``], threePokesPos[i][``1``],
threePokesPos[i][``0``] + ``35``, threePokesPos[i][``1``] + ``52``);
p(pokeImage, src, dst, ``null``);
}
}
public void onTuch(View v, MotionEvent event) {
for (``int i = ``0``; i < ; i++) {
StringBuffer sb = ``new StringBuffer();
(i + ``" : "``);
for (``int j = ``0``; j < persons[i].; j++) {
(persons[i].pokes[j]
+ (persons[i].pokes[j] >= ``10 ? ``"" : ``" "``) + ``","``);
}
(());
}
if (op == ``1``) {
(``":" + );
init();
op = ``0``;
// Message();
}
if (currentPerson != ``0``) {
return``;
}
int x = (``int``) ();
int y = (``int``) ();
if ((x, y, opPosX, opPosY, ``38``, ``23``)) {
(``"chupai"``);
Card card = persons[``0``].chupai(currentCard);
if (card != ``null``) {
currentCard = card;
currentCircle++;
nextPerson();
}
}
if (currentCircle != ``0``) {
if ((x, y, opPosX - ``40``, opPosY, ``38``, ``23``)) {
(``"buyao"``);
buyao();
}
}
if ((x, y, opPosX + ``40``, opPosY, ``38``, ``23``)) {
(``"tishi"``);
tishi();
}
persons[``0``].onTuch(v, event);
}
private void tishi() {
}
//不要牌的操作
private void buyao() {
// 轮到下一个人
currentCircle++;
// 清空当前不要牌的人的最后一手牌
persons[currentPerson].card = ``null``;
// 定位下一个人的id
nextPerson();
// 如果已经转回来，则该人继续出牌，本轮清空，新一轮开始
if (currentCard != ``null && currentPerson == ) {
currentCircle = ``0``;
currentCard = ``null``;``// 转回到最大牌的那个人再出牌
persons[currentPerson].card = ``null``;
}
}
// 定位下一个人的id并重新倒计时
private void nextPerson() {
switch (currentPerson) {
case 0``:
currentPerson = ``2``;
break``;
case 1``:
currentPerson = ``0``;
break``;
case 2``:
currentPerson = ``1``;
break``;
}
timeLimite = ``310``;
}
}
胡牌分析器:AnalyzePoke
package ;
import ;
public class AnalyzePoke {
private int``[] pokes;
private int``[] countPokes = ``new int``[``12``];
private int count2;
private int countWang;
private Vector<``int``[]> card_zhadan = ``new Vector<``int``[]>(``3``);
private Vector<``int``[]> card_sanshun = ``new Vector<``int``[]>(``3``);
private Vector<``int``[]> card_shuangshun = ``newVector<``int``[]>(``3``);
private Vector<``int``[]> card_sanzhang = ``newVector<``int``[]>(``3``);
private Vector<``int``[]> card_danshun = ``new Vector<``int``[]>(``3``);
private Vector<``int``[]> card_duipai = ``new Vector<``int``[]>(``3``);
private Vector<``int``[]> card_danpai = ``new Vector<``int``[]>(``5``);
public int``[] getCountPokes() {
return countPokes;
}
public int getCount2() {
return count2;
}
public int getCountWang() {
return countWang;
}
public Vector<``int``[]> getCard_zhadan() {
return card_zhadan;
}
public Vector<``int``[]> getCard_sanshun() {
return card_sanshun;
}
public Vector<``int``[]> getCard_shuangshun() {
return card_shuangshun;
}
public Vector<``int``[]> getCard_sanzhang() {
return card_sanzhang;
}
public Vector<``int``[]> getCard_danshun() {
return card_danshun;
}
public Vector<``int``[]> getCard_duipai() {
return card_duipai;
}
public Vector<``int``[]> getCard_danpai() {
return card_danpai;
}
private AnalyzePoke() {
}
public static AnalyzePoke getInstance() {
// if (analyzePoke == null) {
// analyzePoke = new AnalyzePoke();
// }
// return analyzePoke;
return new AnalyzePoke();
}
private void init() {
for (``int i = ``0``; i < ; i++) {
countPokes[i] = ``0``;
}
count2 = ``0``;
countWang = ``0``;
card_();
card_();
card_();
card_();
card_();
card_();
card_();
}
public boolean lastCardTypeEq(``int pokeType) {
if (remainCount() > ``1``) {
return false``;
}
switch (pokeType) {
case :
return card_() == ``1``;
case :
return card_() == ``1``;
case :
return card_() == ``1``;
}
return false``;
}
public int``[] getPokes() {
return pokes;
}
public void setPokes(``int``[] pokes) {
(pokes);
this``.pokes = pokes;
try {
this``.analyze();
} ``catch (Exception e) {
kTrace();
}
}
public int remainCount() {
return card_() + card_()
+ card_() + card_()
+ card_() + card_() + card_();
}
public int``[] getMinType(Person last, Person next) {
AnalyzePoke lastAna = ce();
();
AnalyzePoke nextAna = ce();
();
int lastCount = nt();
int nextCount = nt();
int needSmart = -``1``;
if ( ==
|| ( != && != )) {
// 是对手
if ( <= ``2``) {
needSmart = ;
}
}
// TODO
int pokeType = -``1``;
int minValue = ``55``;
int pokeIdx = ``0``;
int size;
Vector<``int``[]> temp;
temp = card_sanshun;
size = ();
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (minValue > p[``0``]) {
pokeType = ;
minValue = p[``0``];
pokeIdx = i;
}
}
temp = card_shuangshun;
size = ();
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (minValue > p[``0``]) {
pokeType = n;
minValue = p[``0``];
pokeIdx = i;
}
}
temp = card_danshun;
size = ();
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (minValue > p[``0``]) {
pokeType = ;
minValue = p[``0``];
pokeIdx = i;
}
}
temp = card_sanzhang;
size = ();
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (minValue > p[``0``]) {
pokeType = ;
minValue = p[``0``];
pokeIdx = i;
}
}
if (needSmart == ``2``) {
if (pokeType != -``1``) {
return new int``[] { pokeType, pokeIdx };
} ``else {
temp = card_duipai;
size = ();
int min2 = -``1``;
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (min2 <= p[``0``]) {
pokeType = ;
minValue = p[``0``];
min2 = p[``0``];
pokeIdx = i;
}
}
}
} ``else {
temp = card_duipai;
size = ();
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (minValue > p[``0``]) {
pokeType = ;
minValue = p[``0``];
pokeIdx = i;
}
}
}
if (needSmart == ``1``) {
if (pokeType != -``1``) {
return new int``[] { pokeType, pokeIdx };
} ``else {
int min1 = -``1``;
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (min1 <= p[``0``]) {
pokeType = ;
minValue = p[``0``];
min1 = p[``0``];
pokeIdx = i;
}
}
}
} ``else {
temp = card_danpai;
size = ();
for (``int i = ``0``; i < size; i++) {
int``[] p = (i);
if (minValue > p[``0``]) {
pokeType = ;
minValue = p[``0``];
pokeIdx = i;
}
}
}
return new int``[] { pokeType, pokeIdx };
}
public boolean testAnalyze(``int pokes[]) {
try {
init();
for (``int i = ``0``; i < ; i++) {
int v = lue(pokes[i]);
if (v == ``16 || v == ``17``) {
countWang++;
} ``else if (v == ``15``) {
count2++;
} ``else {
countPokes[v - ``3``]++;
}
}
// (" analyze sanshun");
// 三顺
int start = -``1``;
int end = -``1``;
for (``int i = ``0``; i <= - ``1``; i++) {
if (countPokes[i] == ``3``) {
if (start == -``1``) {
start = i;
} ``else {
end = i;
}
} ``else {
if (end != -``1 && start != -``1``) {
int dur = end - start + ``1``;
int``[] ss = ``new int``[dur * ``3``];
int m = ``0``;
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v >= start && v <= end) {
ss[m++] = pokes[j];
}
}
if (m == dur * ``3 - ``1``) {
(``"sanshun is over!!!"``);
} ``else {
(``"sanshun error!!!"``);
}
card_t(ss);
for (``int s = start; s <= end; s++) {
countPokes[s] = -``1``;
}
start = end = -``1``;
continue``;
} ``else {
start = end = -``1``;
}
}
}
// (" analyze shuangshun");
// shuangshun
int sstart = -``1``;
int send = -``1``;
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``2``) {
if (sstart == -``1``) {
sstart = i;
} ``else {
send = i;
}
} ``else {
if (sstart != -``1 && send != -``1``) {
int dur = send - sstart + ``1``;
if (dur < ``3``) {
sstart = send = -``1``;
continue``;
} ``else {
int shuangshun[] = ``new int``[dur * ``2``];
int m = ``0``;
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v >= sstart && v <= send) {
shuangshun[m++] = pokes[j];
}
}
card_t(shuangshun);
for (``int s = sstart; s <= send; s++) {
countPokes[s] = -``1``;
}
sstart = send = -``1``;
continue``;
}
} ``else {
sstart = send = -``1``;
}
}
}
// (" analyze danshun");
// danshun
int dstart = -``1``;
int dend = -``1``;
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] >= ``1``) {
if (dstart == -``1``) {
dstart = i;
} ``else {
dend = i;
}
} ``else {
if (dstart != -``1 && dend != -``1``) {
int dur = dend - dstart + ``1``;
if (dur >= ``5``) {
int m = ``0``;
int``[] danshun = ``new int``[dur];
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == dend) {
danshun[m++] = pokes[j];
countPokes[dend]--;
dend--;
}
if (dend == dstart - ``1``) {
break``;
}
}
card_t(danshun);
}
dstart = dend = -``1``;
} ``else {
dstart = dend = -``1``;
}
}
}
// (" analyze sanzhang");
// sanzhang
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``3``) {
countPokes[i] = -``1``;
int``[] sanzhang = ``new int``[``3``];
int m = ``0``;
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == i) {
sanzhang[m++] = pokes[j];
}
}
card_t(sanzhang);
}
}
// (" analyze duipai");
// duipai
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``2``) {
int``[] duipai = ``new int``[``2``];
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == i) {
duipai[``0``] = pokes[j];
duipai[``1``] = pokes[j + ``1``];
card_t(duipai);
break``;
}
}
countPokes[i] = -``1``;
}
}
// (" analyze danpai");
// danpai
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``1``) {
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == i) {
card_t(``new int``[] { pokes[j] });
countPokes[i] = -``1``;
break``;
}
}
}
}
// (" analyze 2 ");
switch (count2) {
case 4``:
card_t(``new int``[] { pokes[countWang],
pokes[countWang + ``1``], pokes[countWang + ``2``],
pokes[countWang + ``3``] });
break``;
case 3``:
card_t(``new int``[] { pokes[countWang],
pokes[countWang + ``1``], pokes[countWang + ``2``] });
break``;
case 2``:
card_t(``new int``[] { pokes[countWang],
pokes[countWang + ``1``] });
break``;
case 1``:
card_t(``new int``[] { pokes[countWang] });
break``;
}
// (" analyze zhadan");
// 炸弹
for (``int i = ``0``; i < - ``1``; i++) {
if (countPokes[i] == ``4``) {
card_t(``new int``[] { i * ``4 + ``3``, i * ``4 + ``2``,
i * ``4 + ``1``, i * ``4 });
countPokes[i] = -``1``;
}
}
// (" analyze wang");
if (countWang == ``1``) {
card_t(``new int``[] { pokes[``0``] });
} ``else if (countWang == ``2``) {
card_t(``new int``[] { pokes[``0``], pokes[``1``] });
}
} ``catch (Exception e) {
kTrace();
return false``;
}
return true``;
}
// 分析几大主要牌型
private void analyze() {
// 初始化牌型容器
init();
// 分析王，2，普通牌的数量
for (``int i = ``0``; i < ; i++) {
int v = lue(pokes[i]);
if (v == ``16 || v == ``17``) {
countWang++;
} ``else if (v == ``15``) {
count2++;
} ``else {
countPokes[v - ``3``]++;
}
}
// 分析三顺牌型
int start = -``1``;
int end = -``1``;
for (``int i = ``0``; i <= - ``1``; i++) {
if (countPokes[i] == ``3``) {
if (start == -``1``) {
start = i;
} ``else {
end = i;
}
} ``else {
if (end != -``1 && start != -``1``) {
int dur = end - start + ``1``;
int``[] ss = ``new int``[dur * ``3``];
int m = ``0``;
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v >= start && v <= end) {
ss[m++] = pokes[j];
}
}
if (m == dur * ``3 - ``1``) {
(``"sanshun is over!!!"``);
} ``else {
(``"sanshun error!!!"``);
}
card_t(ss);
for (``int s = start; s <= end; s++) {
countPokes[s] = -``1``;
}
start = end = -``1``;
continue``;
} ``else {
start = end = -``1``;
}
}
}
// 分析双顺牌型
int sstart = -``1``;
int send = -``1``;
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``2``) {
if (sstart == -``1``) {
sstart = i;
} ``else {
send = i;
}
} ``else {
if (sstart != -``1 && send != -``1``) {
int dur = send - sstart + ``1``;
if (dur < ``3``) {
sstart = send = -``1``;
continue``;
} ``else {
int shuangshun[] = ``new int``[dur * ``2``];
int m = ``0``;
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v >= sstart && v <= send) {
shuangshun[m++] = pokes[j];
}
}
card_t(shuangshun);
for (``int s = sstart; s <= send; s++) {
countPokes[s] = -``1``;
}
sstart = send = -``1``;
continue``;
}
} ``else {
sstart = send = -``1``;
}
}
}
// 分析单顺牌型
int dstart = -``1``;
int dend = -``1``;
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] >= ``1``) {
if (dstart == -``1``) {
dstart = i;
} ``else {
dend = i;
}
} ``else {
if (dstart != -``1 && dend != -``1``) {
int dur = dend - dstart + ``1``;
if (dur >= ``5``) {
int m = ``0``;
int``[] danshun = ``new int``[dur];
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == dend) {
danshun[m++] = pokes[j];
countPokes[dend]--;
dend--;
}
if (dend == dstart - ``1``) {
break``;
}
}
card_t(danshun);
}
dstart = dend = -``1``;
} ``else {
dstart = dend = -``1``;
}
}
}
// 分析三张牌型
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``3``) {
countPokes[i] = -``1``;
int``[] sanzhang = ``new int``[``3``];
int m = ``0``;
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == i) {
sanzhang[m++] = pokes[j];
}
}
card_t(sanzhang);
}
}
// 分析对牌
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``2``) {
int``[] duipai = ``new int``[``2``];
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == i) {
duipai[``0``] = pokes[j];
duipai[``1``] = pokes[j + ``1``];
card_t(duipai);
break``;
}
}
countPokes[i] = -``1``;
}
}
// 分析单牌
for (``int i = ``0``; i < ; i++) {
if (countPokes[i] == ``1``) {
for (``int j = ``0``; j < ; j++) {
int v = lue(pokes[j]) - ``3``;
if (v == i) {
card_t(``new int``[] { pokes[j] });
countPokes[i] = -``1``;
break``;
}
}
}
}
// 根据2的数量进行分析
switch (count2) {
case 4``:
card_t(``new int``[] { pokes[countWang],
pokes[countWang + ``1``], pokes[countWang + ``2``],
pokes[countWang + ``3``] });
break``;
case 3``:
card_t(``new int``[] { pokes[countWang],
pokes[countWang + ``1``], pokes[countWang + ``2``] });
break``;
case 2``:
card_t(``new int``[] { pokes[countWang],
pokes[countWang + ``1``] });
break``;
case 1``:
card_t(``new int``[] { pokes[countWang] });
break``;
}
// 分析炸弹
for (``int i = ``0``; i < - ``1``; i++) {
if (countPokes[i] == ``4``) {
card_t(``new int``[] { i * ``4 + ``3``, i * ``4 + ``2``,
i * ``4 + ``1``, i * ``4 });
countPokes[i] = -``1``;
}
}
// 分析火箭
if (countWang == ``1``) {
card_t(``new int``[] { pokes[``0``] });
} ``else if (countWang == ``2``) {
card_t(``new int``[] { pokes[``0``], pokes[``1``] });
}
}
}
二、真人版积分斗地主我要下载
这个好玩啊！我知道一个
如果想玩游戏的话，这可以看看。
三、腾讯游戏光子工作室群欢乐游戏工作室技术副总监：斗地主小游戏该如何赚到钱
1月15日消息，微信公开课今日在广州举办。会上，腾讯游戏光子工作室群欢乐游戏工作室技术副总监马同星发表了题为“欢乐斗地主，无需下载的快乐”的演讲，从自己的思路来阐述斗地主小游戏如何赚到钱。
以下为演讲实录：
小游戏倡导的是 去中心化
的分发方式，过去严重依赖流量的平台会面临非常大的挑战，无论是公司还是个人开发者，只要你能够提供具有良好的社交体验的游戏，你就可以获得不错的流量。在风口来临的时候，非常紧张的是依赖流量平台的开发团队，真正有创意和高品质开发能力的团队和个人都有非常大的机会。
进入今天主要话题之前，讲一个小事情。前两天看到一个新闻，有一个朋友转了新闻过来，新闻上面讲小游戏开发团队负责人，他非常担心4兆小游戏包如何 实现变现
，如何才能形成一个良性循环的生态。我今天就试图以我们的思路来阐述一下，它如何赚到钱。
在此之前我们先看一下数据，这是小游戏从12月28日到第11天的时候，斗地主小游戏和斗地主H5的对比。
这张是流水，黄色是日流水。小游戏从发布开始，我每天都在刷在线数据，正如前面几位分享的同事讲的一样。它的用户新进和流水都是在持续增长的过程，我们也非常果断的，近期把H5游戏用户导入到小游戏，因为大家都知道基于社交传播的能量非常巨大。
小游戏的特点
我们团队首先会想小游戏是什么？非常简单，即点即玩，无需下载。除了这几点之外，它还有什么特点？我们想做商业变现的话，我们需要靠游戏吃饭的团队，我们需要考虑这几个方面。
首先小游戏一定是满足社交化、碎片的娱乐需求为切入点。另外，我们希望输出的小游戏能够接近原生游戏的品质，用户玩起来的时候，它的流畅感、界面的生动，它不能跟原生游戏有很大的区别。第三、我们希望这个游戏有充实的内容，但是第三点和我们通常的小游戏是有矛盾的，但又是非常碎片的东西。
满足碎片时间作为切入点，用户点开之后，就可以体验到一个非常优秀的有了过程，得到乐趣。这些用户通过社交的体验进入游戏，有重度用户会发掘更多的内容出来，这中间就会产生数据层面、用户层面，会自然促发他的再一次传播，会形成我们的闭环。这是我们构思这款小游戏的逻辑。
小游戏的内容板块
基于这个逻辑，我们看一下内容板块，主要是 三大板块 。
最左边这块是好友房，在线上大家可以随时和线上斗地主，好友对局里面有各种各样的互动。如果你进来的晚也没有关系，你可以以上帝视角观看另外三个人斗地主，上帝视角观看绝对有高高在上的乐趣。你会看到你的朋友打了一个臭拍，你丢一个番茄给他。
实时在线的社交有一个门槛，我们在工作的时候是没办法享用朋友打斗地主，我们会设置一个残局板块。这背后有很多AI的东西在里面，我们会提炼非常精妙的残局关卡，用户可以挑战，可以让好友解答这个难题。
第三、斗地主十年以来沉淀的各种各样的玩法，当你不想挑战AI，不想和朋友时时斗地主，你也可以一个人去斗地主。
构思这个大致的内容，作为开发者，今天跟大家简单讲一讲，开发这个小游戏的时候，到底要做什么事情。小游戏出来之后，很多专家都对小游戏的架构做了很多分析，今天也有同事讲过，所以这里我就稍微提两点，我觉得大家比较关注的。
微信小游戏运行在js虚拟机之上，但他不是浏览器。所以，没有浏览器的默认行为。如果熊H5游戏移植过来，需要注意这些兼容，工作量非常小。
我们对比原来做H5的结构，这里需要有一个大家关注的事情，就是适配器的问题。做H5的朋友都知道，我们要适配各种各样的浏览器，我们每天都去国外的浏览器系统里面去看。如果我们在微信小游戏里面开发，相当于已经有一个10亿量级统一标准的浏览器，这里的微信API，这样看来在微信里面开发小游戏的成本是远低于H5游戏的开发成本。
我们有非常充实的内容，在充实的内容下，我们又要满足用户的碎片化需求，即点即玩。这个卡片是微信群里面朋友们分享挑战残局的，另外一个是有人拉你去对战。当对战已经开始了，你可以从服务器获取对战面，整个过程跟传统游戏开发是完全不同的，它不需要经过一个又一个的登陆环节，验证面板、新手礼包，甚至连主界面都不需要加载。当切换到聊天，时间本身就是越来越碎片，他切换到聊天，再切换到游戏场景，那是同一个场景。我们采用的方式是把一个游戏内容做成非常多的切片，当用户在一个碎片游戏体验触达的时候，我们进行切入。
我们还有一个控制层，这个控制层，它用来运行游戏的状态。UI层可以脱离下面两层，基于这样的简单设计，当用户因为某一个场景来触达我要进入某一个游戏场景的时候，逻辑上把数据加载复用就可以了。
用户结束之后会用到的资源，我们会在用户网络处于WI-
FI的时候进行加载。二级资源每个都非常小，这些资源都是采用缓加载的方式。这样控制下来，每个游戏切片，用户只需要2兆的加载就可以了。这个加载还会缓存在用户的手机里面，这样每次我们只加载需要的文件，删除不需要加载的文件。
我们把一个内容充实、丰富的游戏呈现给用户，让用户触达，并且在游戏中留存下来。在小游戏开启这样一个巨大生态的当口，我们所做出的判断，或者是我们的想法，可能并不一定对。但是我们觉得在这里跟大家分享交流，也希望有更多的小游戏开发者一起加入到小游戏开发者阵营中，为用户带来更多、更好的小游戏，谢谢大家。
以上就是小编为大家整理的真人免费斗地主下载的内容，更多关于真人免费斗地主下载可以关注本站。
微信扫一扫 
支付宝扫一扫 
