devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

麻将算法-支持单耗子-双耗子-多耗子_ifmj

作者：秋刀鱼在做梦 | 2024-08-05 04:31:35

赞

踩

ifmj
  1. # coding=utf-8
  2. import sys
  3. import math
  4. import codecs
  5. isDebug = False
  6. isTiaoShi = True
  7. isFengZui = True
  8. MAJONG = [
  9. 	101,102,103,104,105,106,107,108,109,
  10. 	101,102,103,104,105,106,107,108,109,
  11. 	101,102,103,104,105,106,107,108,109,
  12. 	101,102,103,104,105,106,107,108,109,
  13. 	201,202,203,204,205,206,207,208,209,
  14. 	201,202,203,204,205,206,207,208,209,
  15. 	201,202,203,204,205,206,207,208,209,
  16. 	201,202,203,204,205,206,207,208,209,
  17. 	301,302,303,304,305,306,307,308,309,
  18. 	301,302,303,304,305,306,307,308,309,
  19. 	301,302,303,304,305,306,307,308,309,
  20. 	301,302,303,304,305,306,307,308,309,
  21. 	401,402,403,404,405,406,407,
  22. 	401,402,403,404,405,406,407,
  23. 	401,402,403,404,405,406,407,
  24. 	401,402,403,404,405,406,407,
  25. ]
  26.  
  27. MAJIANG_TYPE = [
  28. 	101,102,103,104,105,106,107,108,109,
  29. 	201,202,203,204,205,206,207,208,209,
  30. 	301,302,303,304,305,306,307,308,309,
  31. 	401,402,403,404,405,406,407,
  32. ]
  33.  
  34. #将手里的耗子全部拿出来，并且对剩余的手牌排序
  35. #param mahjongList 手牌列表 haoziPai 耗子列表
  36. #return 自己所有的耗子列表
  37. def check_haozi_sort(mahjongList, haoziPaiList):
  38. 	printLog('当前的手牌为：',mahjongList)
  39. 	mahjongList.sort()
  40. 	printLog('排序完成之后手牌为：',mahjongList)
  41. 	haoziList = []
  42. 	for index in range(len(mahjongList)-1, -1, -1):
  43. 		for x in range(len(haoziPaiList)):
  44. 			if haoziPaiList[x] == mahjongList[index]:
  45. 				haoziList.append(mahjongList[index])
  46. 				mahjongList.pop(index)
  47. 				break
  48. 	printLog('移除耗子之后的手牌为：')
  49. 	printLog(mahjongList)
  50. 	printLog('手里的耗子列表：', haoziList)
  51. 	return haoziList
  52.  
  53. #将手牌分为万条筒、 字
  54. def split_list(mahjongList):
  55. 	wttList = []
  56. 	ziList = []
  57. 	for index in range(len(mahjongList)):
  58. 		mjType = mahjongList[index] // 100
  59. 		#万
  60. 		if mjType == 1 or mjType == 2 or mjType == 3:
  61. 			wttList.append(mahjongList[index])
  62. 		elif mjType == 4:
  63. 			ziList.append(mahjongList[index])
  64. 		else:
  65. 			printLog("没有这种麻将类型", mjType)
  66. 			sys.exit(0)
  67. 	return wttList, ziList
  68.  
  69. #检查组合 先检查刻，再检查顺
  70. #return 返回组成的刻，顺，以及检查完之后剩余的手牌列表
  71. def check_zuhe_ke_shun( mjList, isFeng=False):
  72. 	mjListCopy = mjList[:]
  73. 	shunziList = []
  74. 	keList = []
  75. 	#自己的数量 先判断能自然形成的，不加耗子的
  76. 	if len(mjListCopy) >= 3:
  77. 		keList = check_ke(mjListCopy)
  78. 	if len(mjListCopy) >= 3:
  79. 		#如果是字牌，并且是封嘴的时候，去检测一下风顺子
  80. 		if isFeng:
  81. 			if isFengZui:
  82. 				shunziList = check_shunzi(mjListCopy, isFeng)
  83. 		else:
  84. 			shunziList = check_shunzi(mjListCopy, isFeng)
  85. 	# #组成的刻子现在是这样的
  86. 	# if len(keList) > 0:
  87. 	# 	printLog('组成刻子：', keList)
  88. 	# if len(shunziList) > 0:
  89. 	# 	printLog('组成顺子：', shunziList)
  90. 	# #检测完之后的手牌为
  91. 	# if len(mjListCopy) > 0:
  92. 	# 	printLog('检测完之后的手牌', mjListCopy)
  93. 	return keList, shunziList, mjListCopy
  94.  
  95. #检查组合 先检查顺，再检查刻
  96. #return 返回组成的刻，顺，以及检查完之后剩余的手牌列表
  97. def check_zuhe_shun_ke( mjList, isFeng=False):
  98. 	mjListCopy = mjList[:]
  99. 	shunziList = []
  100. 	keList = []
  101. 	#自己的数量 先判断能自然形成的，不加耗子的
  102. 	if len(mjListCopy) >= 3:
  103. 		#如果是字牌，并且是封嘴的时候，去检测一下风顺子
  104. 		if isFeng:
  105. 			if isFengZui:
  106. 				shunziList = check_shunzi(mjListCopy, isFeng)
  107. 		else:
  108. 			shunziList = check_shunzi(mjListCopy, isFeng)
  109. 	if len(mjListCopy) >= 3:
  110. 		keList = check_ke(mjListCopy)
  111. 	
  112. 	# #组成的刻子现在是这样的
  113. 	# if len(keList) > 0:
  114. 	# 	printLog('组成刻子：', keList)
  115. 	# if len(shunziList) > 0:
  116. 	# 	printLog('组成顺子：', shunziList)
  117. 	# #检测完之后的手牌为
  118. 	# if len(mjListCopy) > 0:
  119. 	# 	printLog('检测完之后的手牌', mjListCopy)
  120. 	return keList, shunziList, mjListCopy
  121.  
  122. #mjList 风 给所有的风进行排序
  123. #return [[403,2],[402,1],[401,1]]
  124. def feng_sort(mjList):
  125. 	mjlsit_sort = []
  126. 	if len(mjList) == 0:
  127. 		return mjlsit_sort
  128. 	mjList.sort()
  129. 	mjlsit_sort = []
  130. 	count = 1
  131. 	curValue = mjList[0]
  132. 	for x in range(1, len(mjList)):
  133. 		if mjList[x] == curValue:
  134. 			count = count + 1
  135. 		else:
  136. 			tmpList = []
  137. 			tmpList.append(curValue)
  138. 			tmpList.append(count)
  139. 			mjlsit_sort.append(tmpList)
  140. 			curValue = mjList[x]
  141. 			count = 1
  142. 	tmpList = []
  143. 	tmpList.append(curValue)
  144. 	tmpList.append(count)
  145. 	mjlsit_sort.append(tmpList)
  146. 	printLog('排完前的数组为：',mjlsit_sort)
  147. 	mjlsit_sort.sort(key=takeSecond)
  148. 	mjlsit_sort.reverse()
  149. 	printLog('排完序的数组为：',mjlsit_sort)
  150. 	return mjlsit_sort
  151.  
  152. def takeSecond(elem):
  153. 	return elem[1]
  154.  
  155. #将手中的字牌去分成 [东南西北] ，[中发白]
  156. def split_feng_zi(mjList):
  157. 	fenglist = []
  158. 	ziList = []
  159. 	if len(mjList) == 0:
  160. 		return fenglist,ziList
  161. 	mjListCopy = mjList[:]
  162. 	mjListCopy.sort()
  163. 	for x in range(len(mjListCopy)):
  164. 		if mjListCopy[x] >= 405:
  165. 			ziList.append(mjListCopy[x])
  166. 		else:
  167. 			fenglist.append(mjListCopy[x])
  168. 	return fenglist,ziList
  169.  
  170. #检查风顺子 fengList 当前的[东南西北]或者[中发白]
  171. #mjList 这个参数的主要目的是再检查出自己牌型有风顺子之后， 将组合完成的从自己的手牌里面移除掉
  172. #return 返回的是组成的风顺子列表
  173. def chenck_feng_shun(fengList, mjList):
  174. 	fengListCopy = fengList[:]
  175. 	feng_shun_list = []
  176. 	if len(fengListCopy) >= 3:
  177. 		curIndex = 0
  178. 		for index in range(fengListCopy[0][1]):
  179. 			tmpList = []
  180. 			while curIndex < len(fengListCopy):
  181. 				curCount = fengListCopy[curIndex][1]
  182. 				if curCount > 0:
  183. 					tmpList.append(fengListCopy[curIndex][0])
  184. 					fengListCopy[curIndex][1] = curCount - 1
  185. 					if len(tmpList) == 3:
  186. 						curIndex = 0
  187. 						feng_shun_list.append(tmpList)
  188. 						break
  189. 					else:
  190. 						curIndex = curIndex + 1
  191. 						if curIndex >= len(fengListCopy):
  192. 							curIndex = 0
  193. 							break
  194. 				else:
  195. 					curIndex = curIndex + 1
  196. 					continue
  197. 	printLog('当前的风牌手牌', feng_shun_list)
  198. 	if len(feng_shun_list) > 0:
  199. 		for x in range(len(feng_shun_list)):
  200. 			mjList.pop(mjList.index(feng_shun_list[x][0]))
  201. 			mjList.pop(mjList.index(feng_shun_list[x][1]))
  202. 			mjList.pop(mjList.index(feng_shun_list[x][2]))
  203. 	return feng_shun_list		
  204.  
  205. #检查手牌里面的刻， 这个是不用耗子就能直接做刻子的
  206. def check_ke(mjList):
  207. 	mjListCopy = mjList[:]
  208. 	mjListCopy2 = mjList[:]
  209. 	keList = []
  210. 	for index in range(len(mjListCopy)):
  211. 		if len(mjList) < 3:
  212. 			break
  213. 		tmpValue = mjListCopy[index]
  214. 		try:
  215. 			#找到一个就移除一个，如果能找到最后面，说明是对的
  216. 			value0 = mjListCopy2.index(tmpValue)
  217. 			mjListCopy2.pop(mjListCopy2.index(tmpValue))
  218. 			value1 = mjListCopy2.index(tmpValue)
  219. 			mjListCopy2.pop(mjListCopy2.index(tmpValue))
  220. 			value2 = mjListCopy2.index(tmpValue)
  221. 			mjListCopy2.pop(mjListCopy2.index(tmpValue))
  222. 			tmpList = []
  223. 			tmpList.append(tmpValue)
  224. 			tmpList.append(tmpValue)
  225. 			tmpList.append(tmpValue)
  226. 			keList.append(tmpList)
  227. 		except ValueError, e:
  228. 			continue
  229. 	#所有的检测都检测完了，这个时候 要对真正的手牌进行移除了
  230. 	if len(keList) > 0:
  231. 		for index in range(len(keList)):
  232. 			mjList.pop(mjList.index(keList[index][0]))
  233. 			mjList.pop(mjList.index(keList[index][0]))
  234. 			mjList.pop(mjList.index(keList[index][0]))
  235. 		return keList
  236. 	else:
  237. 		return keList
  238.  
  239. #检查手牌里面的顺子， 这个是不用耗子就能直接做顺子的
  240. def check_shunzi(mjList, isFeng=False):
  241. 	shunziList = []
  242. 	mjListCopy = mjList[:]
  243. 	tmpIndex = 0
  244. 	if not isFeng:
  245. 		for index in range(len(mjListCopy)):
  246. 			#如果数组的长度小于3了就不用做检测了
  247. 			if len(mjList) < 3:
  248. 				break
  249. 			tmpValue = mjListCopy[index]
  250. 			try:
  251. 				#先检测一下这个顺子的有没有
  252. 				value0 = mjList.index(tmpValue)
  253. 				value1 = mjList.index(tmpValue+1)
  254. 				value2 = mjList.index(tmpValue+2)
  255. 				#上面检测成功了，说明有，现在要移除掉
  256. 				mjList.pop(mjList.index(tmpValue))
  257. 				mjList.pop(mjList.index(tmpValue+1))
  258. 				mjList.pop(mjList.index(tmpValue+2))
  259. 				tmpList = []
  260. 				tmpList.append(tmpValue)
  261. 				tmpList.append(tmpValue+1)
  262. 				tmpList.append(tmpValue+2)
  263. 				shunziList.append(tmpList)
  264. 			except ValueError, e:
  265. 				continue
  266. 		return shunziList
  267. 	else:
  268. 		#检测风顺子
  269. 		fengList, ziList = split_feng_zi(mjListCopy)
  270. 		feng_sort_list = feng_sort(fengList)
  271. 		zi_sort_list = feng_sort(ziList)
  272. 		feng_shun_list = chenck_feng_shun(feng_sort_list, mjList)
  273. 		zi_shun_list = chenck_feng_shun(zi_sort_list, mjList)
  274. 		feng_shun_list = feng_shun_list + zi_shun_list
  275. 		return feng_shun_list
  276.  
  277. #检测手里面有两张牌，加耗子之后组成刻子（只有耗子玩法才去调用这个方法）
  278. #return 返回刻子列表和需要的耗子数量
  279. def check_2n_ke(mjList, haoziId):
  280. 	mjListCopy = mjList[:]
  281. 	mjListCopy2 = mjList[:]
  282. 	keList = []
  283. 	needHaoziCount = 0
  284. 	for index in range(len(mjListCopy)):
  285. 		if len(mjList) < 2:
  286. 			break
  287. 		tmpValue = mjListCopy[index]
  288. 		try:
  289. 			#找到一个就移除一个，如果能找到最后面，说明是对的
  290. 			value0 = mjListCopy2.index(tmpValue)
  291. 			mjListCopy2.pop(mjListCopy2.index(tmpValue))
  292. 			value1 = mjListCopy2.index(tmpValue)
  293. 			mjListCopy2.pop(mjListCopy2.index(tmpValue))
  294. 			tmpList = []
  295. 			tmpList.append(haoziId)
  296. 			tmpList.append(tmpValue)
  297. 			tmpList.append(tmpValue)
  298. 			keList.append(tmpList)
  299. 			needHaoziCount = needHaoziCount + 1
  300. 		except ValueError, e:
  301. 			continue
  302. 	if len(keList) > 0:
  303. 		for index in range(len(keList)):
  304. 			mjList.pop(mjList.index(keList[index][1]))
  305. 			mjList.pop(mjList.index(keList[index][1]))
  306. 		return keList, needHaoziCount
  307. 	else:
  308. 		return keList,needHaoziCount
  309.  
  310. #检测手里面有两张牌，加耗子之后组成顺子（只有耗子玩法才去调用这个方法）
  311. #return 返回顺子列表和需要的耗子数量
  312. def check_2n_shun(mjList, haoziId, isFeng=False):
  313. 	mjListCopy = mjList[:]
  314. 	shunziList = []
  315. 	needHaoziCount = 0
  316. 	if not isFeng:
  317. 		for index in range(len(mjListCopy)):
  318. 			if len(mjList) < 2:
  319. 				break
  320. 			tmpValue = mjListCopy[index]
  321. 			#这个检测的是检测靠着
  322. 			try:
  323. 				#先检测一下这个顺子的有没有
  324. 				value0 = mjList.index(tmpValue)
  325. 				value1 = mjList.index(tmpValue + 1)
  326. 				#上面检测成功了，说明有，现在要移除掉
  327. 				mjList.pop(mjList.index(tmpValue))
  328. 				mjList.pop(mjList.index(tmpValue+1))
  329. 				tmpList = []
  330. 				tmpList.append(haoziId)
  331. 				tmpList.append(tmpValue)
  332. 				tmpList.append(tmpValue+1)
  333. 				needHaoziCount = needHaoziCount + 1
  334. 				shunziList.append(tmpList)
  335. 				continue
  336. 			except ValueError, e:
  337. 				pass
  338. 			#这个检测是间隔一个的
  339. 			try:
  340. 				#先检测一下这个顺子的有没有
  341. 				value0 = mjList.index(tmpValue)
  342. 				value1 = mjList.index(tmpValue + 2)
  343. 				#上面检测成功了，说明有，现在要移除掉
  344. 				mjList.pop(mjList.index(tmpValue))
  345. 				mjList.pop(mjList.index(tmpValue+2))
  346. 				tmpList = []
  347. 				tmpList.append(tmpValue)
  348. 				tmpList.append(haoziId)
  349. 				tmpList.append(tmpValue+2)
  350. 				needHaoziCount = needHaoziCount + 1
  351. 				shunziList.append(tmpList)
  352. 			except ValueError, e:
  353. 				continue
  354. 		return shunziList, needHaoziCount
  355. 	else:
  356. 		fengList, ziList = split_feng_zi(mjListCopy)
  357. 		feng_sort_list = feng_sort(fengList)
  358. 		zi_sort_list = feng_sort(ziList)
  359. 		feng_shun_list, needHaoziCount1 = check_2n_feng_shun(feng_sort_list,haoziId, mjList)
  360. 		zi_shun_list, needHaoziCount2 = check_2n_feng_shun(zi_sort_list, haoziId,mjList)
  361. 		feng_shun_list = feng_shun_list + zi_shun_list
  362. 		needHaoziCount = needHaoziCount1 + needHaoziCount2
  363. 		return feng_shun_list, needHaoziCount
  364.  
  365. #检测风顺子 
  366. def check_2n_feng_shun(fengList, haoziId, mjList):
  367. 	fengListCopy = fengList[:]
  368. 	feng_shun_list = []
  369. 	needHaoziCount = 0
  370. 	if len(fengListCopy) >= 2:
  371. 		curIndex = 0
  372. 		for index in range(fengListCopy[0][1]):
  373. 			tmpList = []
  374. 			while curIndex < len(fengListCopy):
  375. 				curCount = fengListCopy[curIndex][1]
  376. 				if curCount > 0:
  377. 					tmpList.append(fengListCopy[curIndex][0])
  378. 					fengListCopy[curIndex][1] = curCount - 1
  379. 					if len(tmpList) == 2:
  380. 						needHaoziCount = needHaoziCount + 1
  381. 						tmpList.append(haoziId)
  382. 						curIndex = 0
  383. 						feng_shun_list.append(tmpList)
  384. 						break
  385. 					else:
  386. 						curIndex = curIndex + 1
  387. 						if curIndex >= len(fengListCopy):
  388. 							curIndex = 0
  389. 							break
  390. 				else:
  391. 					curIndex = curIndex + 1
  392. 					continue
  393. 	if len(feng_shun_list) > 0:
  394. 		for x in range(len(feng_shun_list)):
  395. 			mjList.pop(mjList.index(feng_shun_list[x][0]))
  396. 			mjList.pop(mjList.index(feng_shun_list[x][1]))
  397. 	printLog('当前的风牌手牌', feng_shun_list)
  398. 	return feng_shun_list, needHaoziCount
  399.  
  400. def printLog(*args):
  401. 	if isDebug:
  402. 		for str in args:
  403. 			if isinstance(str, basestring):
  404. 				print(str.decode('UTF-8').encode('GBK'))
  405. 			else:
  406. 				print(str)
  407.  
  408. def printNow(*args):
  409. 	if isTiaoShi:
  410. 		for str in args:
  411. 			if isinstance(str, basestring):
  412. 				print(str.decode('UTF-8').encode('GBK'))
  413. 			else:
  414. 				print(str)
  415.  
  416. def has_object( objList, obj ):
  417. 	for x in range(len(objList)):
  418. 		if objList[x] == obj:
  419. 			return True
  420. 	return False
  421.  
  422. #去检测将
  423. def check_jiang(mjList, jiangType, haoziId, haoziList):
  424. 	mjListCopy = mjList[:]
  425. 	jiangList = []
  426. 	needHaoziCount = 0
  427. 	canjiang = False
  428. 	if has_object(mjListCopy, jiangType):
  429. 		mjListCopy.pop(mjListCopy.index(jiangType))
  430. 		if has_object(mjListCopy, jiangType):
  431. 			mjList.pop(mjList.index(jiangType))
  432. 			mjList.pop(mjList.index(jiangType))
  433. 			jiangList.append(jiangType)
  434. 			jiangList.append(jiangType)
  435. 			mjList = mjListCopy
  436. 			canjiang = True
  437. 			return canjiang, jiangList, needHaoziCount
  438. 		else:
  439. 			if haoziId != 0 and len(haoziList) >= 1:
  440. 				mjList.pop(mjList.index(jiangType))
  441. 				jiangList.append(jiangType)
  442. 				jiangList.append(haoziId)
  443. 				haoziList.pop(0)
  444. 				needHaoziCount = 1
  445. 				canjiang = True
  446. 				mjList = mjListCopy
  447. 				return canjiang, jiangList, needHaoziCount
  448. 			else:
  449. 				return canjiang, jiangList, needHaoziCount
  450.  
  451. def can_hu_ke_shun(mjList, haoziId, haoziList):
  452. 	#拆分万条筒风
  453. 	wttList, ziList = split_list(mjList)
  454. 	#检测 先不带耗子 万条筒风 刻 顺 剩余手牌 组合
  455. 	keList,shunziList,handCardList = check_zuhe_ke_shun(wttList)
  456.  
  457. 	zikList, zisList,ziHandCardList = check_zuhe_ke_shun(ziList, True)
  458.  
  459. 	#只有有耗子的时候才去检测添加耗子
  460. 	if haoziId != 0:
  461. 		printLog('带耗子检测：')
  462. 		allList = keList + shunziList + zikList + zisList
  463. 		#如果手里面的已经组成四副了 说明肯定能胡了
  464. 		if len(allList) >= 4:
  465. 			allHands = handCardList + ziHandCardList
  466. 			return True, allList, allHands
  467. 		else:
  468. 			haoziKeList, haoziCount1 = check_2n_ke(handCardList, haoziId)
  469. 			haoziShunList, haoziCount2 = check_2n_shun(handCardList, haoziId)
  470. 			
  471. 			zikeList,haoziCount3 = check_2n_ke(ziHandCardList, haoziId)
  472. 			zi_shun_list = []
  473. 			haoziCount4 = 0
  474. 			if isFengZui:
  475. 				zi_shun_list,haoziCount4 = check_2n_shun(ziHandCardList,haoziId, True)
  476. 			leftAllHand = ziHandCardList + handCardList
  477. 			needAllHaoziCount = haoziCount1 + haoziCount2 + haoziCount3 + haoziCount4 + len(leftAllHand) * 2
  478.  
  479. 			leftAllHandList = []
  480. 			for x in range(len(leftAllHand)):
  481. 				tmpList=[]
  482. 				tmpList.append(leftAllHand[x])
  483. 				tmpList.append(haoziId)
  484. 				tmpList.append(haoziId)
  485. 				leftAllHandList.append(tmpList)
  486. 			allList = allList + haoziKeList + haoziShunList + zikeList + zi_shun_list
  487. 			handCards = handCardList + ziHandCardList
  488. 			if needAllHaoziCount <= len(haoziList):
  489. 				return True, allList + leftAllHandList, []
  490. 			else:
  491. 				return False,allList, handCards
  492. 	else:
  493. 		printLog('不带耗子检测：')
  494. 		#组合完成了，没耗子的 这个时候就要判断生成的铺了，如果生成的铺是4个，并且手里面的剩余牌正好是一对，则说明能胡
  495. 		allList = keList + shunziList + zikList + zisList
  496. 		allHands = handCardList + ziHandCardList
  497. 		if len(allList) == 4:
  498. 			return True, allList, allHands
  499. 		else:
  500. 			if len(allHands) == 0:
  501. 				return True, allList, allHands
  502. 			else:
  503. 				return False,allList, allHands
  504.  
  505. def can_hu_shun_ke(mjList, haoziId, haoziList):
  506. 	#拆分万条筒风
  507. 	wttList, ziList = split_list(mjList)
  508. 	#检测 先不带耗子 万条筒风 刻 顺 剩余手牌 组合
  509. 	keList,shunziList,handCardList = check_zuhe_shun_ke(wttList)
  510. 	printLog('字')
  511. 	zikList, zisList,ziHandCardList = check_zuhe_shun_ke(ziList, True)
  512. 	#只有有耗子的时候才去检测添加耗子
  513. 	if haoziId != 0:
  514. 		printLog('带耗子检测：')
  515. 		allList = keList + shunziList + zikList + zisList
  516. 		#如果手里面的已经组成四副了， 说明肯定能胡了
  517. 		if len(allList) >= 4:
  518. 			allHands = handCardList + ziHandCardList
  519. 			return True, allList, allHands
  520. 		else:
  521. 			haoziKeList, haoziCount1 = check_2n_ke(handCardList, haoziId)
  522. 			haoziShunList, haoziCount2 = check_2n_shun(handCardList, haoziId)
  523. 			
  524. 			zikeList,haoziCount3 = check_2n_ke(ziHandCardList, haoziId)
  525. 			zi_shun_list = []
  526. 			haoziCount4 = 0
  527. 			if isFengZui:
  528. 				zi_shun_list,haoziCount4 = check_2n_shun(ziHandCardList,haoziId, True)
  529. 			leftAllHand = ziHandCardList + handCardList
  530. 			needAllHaoziCount = haoziCount1 + haoziCount2 + haoziCount3 + haoziCount4 + len(leftAllHand) * 2
  531.  
  532. 			leftAllHandList = []
  533. 			for x in range(len(leftAllHand)):
  534. 				tmpList=[]
  535. 				tmpList.append(leftAllHand[x])
  536. 				tmpList.append(haoziId)
  537. 				tmpList.append(haoziId)
  538. 				leftAllHandList.append(tmpList)
  539. 			allList = allList + haoziKeList + haoziShunList + zikeList + zi_shun_list
  540. 			handCards = handCardList + ziHandCardList
  541. 			if needAllHaoziCount <= len(haoziList):
  542. 				return True, allList+leftAllHandList, []
  543. 			else:
  544. 				return False,allList, handCards
  545. 	else:
  546. 		printLog('不带耗子检测：')
  547. 		#组合完成了，没耗子的 这个时候就要判断生成的铺了，如果生成的铺是4个，并且手里面的剩余牌正好是一对，则说明能胡
  548. 		allList = keList + shunziList + zikList + zisList
  549. 		allHands = handCardList + ziHandCardList
  550. 		if len(allList) == 4:
  551. 			return True, allList, allHands
  552. 		else:
  553. 			return False,allList, allHands
  554.  
  555. def check_ting(mjList, haoziId, haoziList):
  556. 	#检测听牌的话，就是将自己的手牌给移除一张，再加上一张任意牌，看看能不能胡
  557. 	#mjList 现在已经移除掉所有的耗子牌了，
  558. 	mjListCopy = mjList[:]
  559. 	ting_cards = []
  560. 	for index in range(len(mjListCopy)):
  561. 		mjListCopy2 = mjList[:]
  562. 		mjValue = mjListCopy2.pop(index)
  563. 		hu_cards = []
  564. 		for addMjIndex in range(len(MAJIANG_TYPE)):
  565. 			mjListCopy3 = mjListCopy2[:]
  566. 			mjListCopy3.append(MAJIANG_TYPE[addMjIndex])
  567. 			mjListCopy3.sort()
  568. 			for i in range(len(mjListCopy3)):
  569. 				mjListCopy4 = mjListCopy3[:]
  570. 				canjiang, jiangList, needHaoziCount = check_jiang(mjListCopy4, mjListCopy3[i], haoziId, haoziList)	
  571. 				if canjiang:
  572. 					canhu,allList, allHands = can_hu_ke_shun(mjListCopy4, haoziId, haoziList)
  573. 					if canhu:
  574. 						if needHaoziCount == 1:
  575. 							haoziList.append(haoziId)
  576. 						hu_cards.append(MAJIANG_TYPE[addMjIndex])
  577. 						break
  578. 					else:
  579. 						canhu, allList, allHands = can_hu_shun_ke(mjListCopy4, haoziId, haoziList)
  580. 						if canhu:
  581. 							if needHaoziCount == 1:
  582. 								haoziList.append(haoziId)
  583. 							hu_cards.append(MAJIANG_TYPE[addMjIndex])
  584. 							break
  585. 						else:
  586. 							if needHaoziCount == 1:
  587. 								haoziList.append(haoziId)
  588. 							continue
  589. 				else:
  590. 					continue
  591. 			
  592. 		if len(hu_cards) > 0:
  593. 			try:
  594. 				value = ting_cards.index(mjValue)
  595. 				ting_cards[value+1] = hu_cards
  596. 			except ValueError, e:
  597. 				ting_cards.append(mjValue)
  598. 				ting_cards.append(hu_cards)
  599. 			
  600. 	if len(ting_cards) > 0:
  601. 		printNow('当前的牌型可以听')
  602. 	for index in range(0, len(ting_cards) - 1, 2):
  603. 		printNow('打：', ting_cards[index])
  604. 		printNow('听：', ting_cards[index+1])
  605. 	return ting_cards
  606.  
  607. def check_hu(mjList, haoziId, haoziList):
  608. 	canhu = False
  609. 	allList = []
  610. 	allHands = []
  611. 	for i in range(len(mjList)):
  612. 		mjListCopy4 = mjList[:]
  613. 		canjiang, jiangList, needHaoziCount = check_jiang(mjListCopy4, mjList[i], haoziId, haoziList)	
  614. 		if canjiang:
  615. 			canhu,allList, allHands = can_hu_ke_shun(mjListCopy4, haoziId, haoziList)
  616. 			if canhu:
  617. 				allList.append(jiangList) 
  618. 				break
  619. 			else:
  620. 				canhu, allList, allHands = can_hu_shun_ke(mjListCopy4, haoziId, haoziList)
  621. 				if canhu:
  622. 					allList.append(jiangList)
  623. 					break
  624. 				else:
  625. 					if needHaoziCount == 1:
  626. 						haoziList.append(haoziId)
  627. 					continue
  628. 		else:
  629. 			continue
  630. 	return canhu, allList, allHands
  631.  
  632. def get_max_hu():
  633. 	pass
  634.  
  635. def init(mjList, modePai, haoziPaiList, isTestTing):
  636. 	canhu = False
  637. 	allList = []
  638. 	allHands = []
  639. 	mahjongList = mjList
  640. 	modePai = modePai
  641. 	mahjongList.append(modePai)
  642. 	haoziPaiList = haoziPaiList
  643. 	haoziPai = haoziPaiList[0]
  644. 	#将手牌里面的耗子牌移除掉，并且记录耗子的数量
  645. 	haoziList = check_haozi_sort(mahjongList,haoziPaiList)
  646. 	if isTestTing:
  647. 		tingCards = check_ting(mahjongList, haoziPai, haoziList)
  648. 		return canhu, allList, allHands
  649. 	else:
  650. 		canhu,allList,allHands = check_hu(mahjongList, haoziPai, haoziList)
  651. 		haoziSort = feng_sort(haoziList)
  652. 		if len(haoziPaiList) > 1:
  653. 			count = 0
  654. 			for index in range(len(haoziSort)):
  655. 				if haoziPai == haoziSort[index][0]:
  656. 					count = haoziSort[index][1]
  657.  
  658. 			curCount = 0
  659. 			for x in range(len(allList)):
  660. 				for y in range(len(allList[x])):
  661. 					if allList[x][y] == haoziPai:
  662. 						curCount = curCount + 1
  663. 						if curCount > count:
  664. 							allList[x][y] = haoziPaiList[1]
  665. 		printNow(canhu)
  666. 		return canhu,allList,allHands
  667.  
  668. def chenck_fengshun(mjList, haoziId):
  669. 	mjList.sort()
  670. 	allLenth = len(mjList)
  671. 	fengKeList = []
  672. 	fengShunList = []
  673. 	needHaoziCount = 0
  674. 	#数量能正好组成扑
  675. 	if allLenth % 3 == 0:
  676. 		mjListCopy = mjList[:]
  677. 		#拿出刻子
  678. 		fengKeList = check_ke(mjListCopy)
  679. 		fengSort = feng_sort(mjListCopy)
  680. 		#检测风顺子
  681. 		fengShunList = chenck_feng_shun(fengSort, mjListCopy)
  682. 		if len(mjListCopy) > 0: #说明刻子没拿完
  683. 			fengSort = feng_sort(mjListCopy)
  684. 			if len(fengSort) == 2:
  685. 				needHaoziCount = 3
  686. 				fengSort = feng_sort(mjList)
  687. 				fengShunList = chenck_feng_shun(fengSort, mjList)
  688. 				if len(mjList) == 0:
  689. 					needHaoziCount = 0
  690. 				else:
  691. 					needHaoziCount = 3
  692. 		else:
  693. 			needHaoziCount = 0
  694. 	else:
  695. 		fengKeList = check_ke(mjList)
  696. 		needHaoziCount = 3 - len(mjList) % 3
  697. 	printNow('需要的耗子数量为', needHaoziCount)
  698.  
  699.  
  700. mjList = [ 401,401,401,402,402,404]
  701. chenck_fengshun(mjList, 0)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/930824
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号