【算法】跑得快AI

已于 2022-07-15 11:32:41 修改
阅读量1.7k 收藏 3
点赞数 1
分类专栏： 算法 Lua 文章标签： lua 开发语言
于 2022-07-13 13:27:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q277055799/article/details/125761840
版权
Lua 同时被 2 个专栏收录
72 篇文章 2 订阅
订阅专栏
算法
54 篇文章 0 订阅
订阅专栏

代码不全，但是函数可以复用

--
-- Author: baiyufei
-- Date: 2022-07-13 
-- 跑得快AI
--
local commonfunc = require('lua.base.commonfunc')
require('lua.game.AI.dz')
require('lua.base.bit')

local Poker  = require('lua.game.paodekuai.poker')

local aipaodekuai = class("aipaodekuai")

local TIME_SPACE = 1
local OVER_TIME = 10
local TUO_GUANG_TIMES = 2  --超时进入托管次数

function aipaodekuai:ctor(Table)
    self.gameId = Table.mAction:getId()
	self.base_gameId = GET_BASE_GAMEID(self.gameId)
	self.Table = Table
	self.upTime = os.time() + 5
	self.stateTime = 0
    self.lastPlayer = 0
end

function aipaodekuai:run()
    local tmNow = os.time()
    if(tmNow < self.upTime)then
        return
    end
	local Table = self.Table
	local playerOperator = Table:getOperator()
	if(playerOperator and playerOperator:getRobot())then
		TIME_SPACE = math.random(1,2)
	else
		TIME_SPACE = 1
	end
    self.upTime = tmNow + TIME_SPACE
    --根据桌子的状态，判断机器人行为
    local state = self.Table.mState:getState().state
   
    print("-------j机器人----------- androidServiceMgr:run() --------- %, %, %, %", self.gameId, state, self.lastPlayer, self.stateTime)

    --如果卡住了，就强制结束吧

    if(Table.START <= state and playerOperator ~= nil)then
        if(self.lastPlayer == playerOperator:getId())then
            self.stateTime = self.stateTime + TIME_SPACE
        else
            self.stateTime = 0
            self.lastPlayer = playerOperator:getId()
        end
        if(60 <= self.stateTime)then
            --return Table:onFin()
        end
    end

    --准备阶段
    if(state == Table.START)then
        self:ready()
        return
    end
	
	if(not playerOperator or not self:checkAuto(playerOperator))then
		return
	end

	--托管时间随机延迟
	if not playerOperator:getRobot() and playerOperator:getTuoGuan() and self.stateTime < math.random(1,2) then
		return
	end

	--玩家打牌阶段
	if(state == Table.OPERATION)then
		self:OnOPERATION(playerOperator)
		return
	end

end

--托管超时判断
function aipaodekuai:playerOutTime(player)
    local Table = self.Table
    LOGD("player out times-----------------------------table[%] [%] [%] [%] [%]", Table:getOnlyIdStr(), player:getId(), player:getRobot(),  player:getTuoGuan(), self.stateTime)
    if not player:getRobot() and player:getTuoGuan() ~= true then
        if OVER_TIME <= self.stateTime then
            if(not player.tickOutTimes)then
				player.tickOutTimes = 1
			else
				player.tickOutTimes = player.tickOutTimes + 1
				if(TUO_GUANG_TIMES <= player.tickOutTimes)then
					self.Table:onChangeTuoGuanState(player:getSession(), {tuoGuan=true})
					player.tickOutTimes = 0
				end
			end
			LOGD("player out times-----------------------------table[%] [%] [%]", Table:getOnlyIdStr(), player:getId(), player.tickOutTimes)
			return true
        end
    end
	return false
end

function aipaodekuai:checkAuto(player)
	print("-------机器人直接代打-----aipaodekuai:checkAuto(player)-----%  % --------------",player:getSession(), player:getRobot())
	--机器人直接代打
	if(player:getRobot())then
		return true
	else
		if(player:getTuoGuan() == true or self:playerOutTime(player))then
			return true
		end
	end	
	return false
end

--统计相同牌
function aipaodekuai:AnalysebCardData(cbCardData, AnalyseResult)
    local cbCardCount = #cbCardData
    local cbTempCardData = commonfunc.deepcopy2(cbCardData)
	--扑克分析
	for i=1, cbCardCount do
		local cbLogicValue = ddzGetCardValue(cbTempCardData[i])
		if(AnalyseResult[cbLogicValue] == nil)then
			AnalyseResult[cbLogicValue] = {}
		end
		table.insert(AnalyseResult[cbLogicValue], cbTempCardData[i])
	end
	print("--------------统计相同牌-----% % ------------", cbCardData, AnalyseResult)
end

--先手
function aipaodekuai:before(player, oPtion)
	--强调：炸弹永远不会成为第一手出牌选择，任何情况下，不拆除炸弹，只作为炸弹出牌
	print("主动出牌~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	local handCards = player:getCards()
	oPtion.op = Poker.OpOut
	oPtion.card = {handCards[#handCards]}

    local table = self.Table
	local cbHandCardData = commonfunc.deepcopy2(handCards)
	--若只有一手牌全出
	local cardType = table.mPoker:getCardsType(cbHandCardData)
	if cardType ~= Poker.ErrorType then
		oPtion.card = commonfunc.deepcopy2(cbHandCardData)
		return
	end

	local AnalyseResult = {}
	self:AnalysebCardData(cbHandCardData, AnalyseResult)

	--想出的牌，出牌后手数
	local outCards, minHands = {}, 100

	--如果没有单牌，或者单牌很大，打对子
	local minSingle ,minDouble = 100, 100
	for i = 3, 14 do
		local tmpOutCards = {}
		if  minDouble == 100 and AnalyseResult[i] and 2 == #AnalyseResult[i] then
			minDouble = AnalyseResult[i][1]
			tmpOutCards = AnalyseResult[i]
			local hands = self:getHands(handCards, tmpOutCards)
			if(hands < minHands)then
				minHands = hands
				outCards = tmpOutCards
				logd("---minDouble---outCards----%, %",minHands, outCards)
			end
		end
		if minSingle == 100 and AnalyseResult[i] and 1 == #AnalyseResult[i] then
			minSingle = AnalyseResult[i][1]
			tmpOutCards = AnalyseResult[i]
			local hands = self:getHands(handCards, tmpOutCards)
			if(hands <= minHands and minSingle < minDouble)then
				minHands = hands
				outCards = tmpOutCards
				logd("----minSingle--outCards----%, %",minHands, outCards)
			end
		end
	end		

	--iii.第三步：在不具明面统治牌权情况下，判断出牌一次性，一次能出最多张数的牌型
	--是否有顺子
	local first = 0 -- 顺子第一个位置
	local last = 0  -- 顺子最长位置
	for i = 3, 14 do
		if AnalyseResult[i] then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0  and 4 <= last - first then
				local tmpOutCards = {}
				for j = first, last  do
					--顺子最后一张是对子，不拆
					if(j == last and 2 <= #AnalyseResult[j] and 5 <= #tmpOutCards)then
						break
					end
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
				end
				local hands = self:getHands(handCards, tmpOutCards)
				if(hands <= minHands and #outCards < #tmpOutCards)then
					minHands = hands
					outCards = tmpOutCards
					logd("----顺子--outCards----%, %",minHands, outCards)
				end
				break
			end
			first = 0
			last = 0
		end
	end
	
	first = 0 
 	last = 0
	--是否有连队
	for i = 3, 14 do
		--不拆炸弹
		if AnalyseResult[i] and 2<= #AnalyseResult[i] and #AnalyseResult[i] <= 3 then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0  and 1 <= last - first then
				local tmpOutCards = {}
				for j = first, last  do
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][2]
				end
				local hands = self:getHands(handCards, tmpOutCards)
				if(hands <= minHands and #outCards < #tmpOutCards)then
					minHands = hands
					outCards = tmpOutCards
					logd("----连队--outCards----%, %",minHands, outCards)
				end
				break
			end
			first = 0
			last = 0
		end		
	end
	
	first = 0 
	last = 0
	--是否有飞机,是否有三代2
	for i = 3, 14 do
		--不拆炸弹
		if AnalyseResult[i] and #AnalyseResult[i] == 3 then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0 then
				local tmpOutCards = {}
				for j = first, last  do
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][2]
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][3]
				end
				local adds = {}
				local bAdd = self:getAdds(handCards, AnalyseResult, adds, last - first + 1)
				if(bAdd and adds)then
					commonfunc.copyAdd(tmpOutCards, adds)
					local hands = self:getHands(handCards, tmpOutCards)
					if(hands <= minHands and #outCards < #tmpOutCards)then
						minHands = hands
						outCards = tmpOutCards
						logd("----飞机--outCards----%, %",minHands, outCards)
					end
				end
				break	
			end
			first = 0
			last = 0
		end		
	end

	if(#outCards == 1)then
		--下家只有一张牌时，只能出最大的单排
		local opInfo = { uid = player:getId(), op = Poker.OpOut, opCards = oPtion.card }
		if table.show:checkIsNeedOutMaxValueCardAllCard(player,opInfo) then
			oPtion.card = {handCards[1]}
			return
		end
	end

	if(0 < #outCards)then
		oPtion.card = outCards
	end

	logd("-------------outCards--oPtion--------%, %", outCards, oPtion)
end

--计算手
function aipaodekuai:getHands(handCards, outCards)
	local cbHandCardData = commonfunc.deepcopy2(handCards)
	--先把要出的牌剔除
	for _, card in pairs(outCards) do
		for k, v in pairs(cbHandCardData) do
			if(card == v)then
				table.remove(cbHandCardData, k)
				break
			end
		end
	end

	--顺子也剔除
	local AnalyseResult = {}
	self:AnalysebCardData(cbHandCardData, AnalyseResult)
	local first = 0 -- 顺子第一个位置
	local last = 0  -- 顺子最长位置
	local tmpOutCards = {}
	for i = 3, 14 do
		if AnalyseResult[i] then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0  and 4 <= last - first then
				for j = first, last  do
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
				end
				break
			end
			first = 0
			last = 0
		end
	end
	for _, card in pairs(tmpOutCards) do
		for k, v in pairs(cbHandCardData) do
			if(card == v)then
				table.remove(cbHandCardData, k)
				break
			end
		end
	end

	AnalyseResult = {}
	self:AnalysebCardData(cbHandCardData, AnalyseResult)
	local hand = 0
	for k, v in pairs(AnalyseResult) do
		if(#v < 3)then
			hand = hand + 1
		end
	end
	return hand
end


--获得飞机的翅膀, 只能带2个单牌
function aipaodekuai:getAdds(handCards, AnalyseResult, cardsLlist, count)
	logd("----------------%,%,%,%",handCards, AnalyseResult, cardsLlist, count)
	--要获得多张单牌
	local singleList = {}
	for i = 3, 14 do
		if(AnalyseResult[i] and 1 == #AnalyseResult[i] and AnalyseResult[i][1])then
			table.insert(cardsLlist, AnalyseResult[i][1])
			if(count*2 <= #cardsLlist)then
				return true
			end
		end
	end
	logd("-----------cardsLlist----------%", cardsLlist)
	return false
end

--后手
function aipaodekuai:after(player, Table, oPtion, canOutCards)
	oPtion.op = Poker.OpOut 
	oPtion.card = canOutCards[1]
	--下家只有一张牌时，只能出最大的单排
	local opInfo = { uid = player:getId(), op = Poker.OpOut, opCards = oPtion.card }
	local handCards = player:getCards()
	if Table.show:checkIsNeedOutMaxValueCardAllCard(player,opInfo) then
		oPtion.op = Poker.OpOut 
		oPtion.card = {handCards[1]}
		return
	end

	--找一个出牌后手数最少的
	local index, minhand, count = 1, 100, 1
	for k, v in pairs(canOutCards) do
		local hand = aipaodekuai:getHands(handCards, v)
		if(hand < minhand)then
			minhand = hand
			count = #v
			index = k
		elseif(hand == minhand and count < #v)then	
			minhand = hand
			count = #v
			index = k
		end
	end

	--[[
	炸弹必炸	
	--单牌太多炸弹不拆
	local cardType = Table.mPoker:getCardsType(canOutCards[index])
	if cardType == Poker.ZhaDan then
		local hand = aipaodekuai:getHands(handCards, canOutCards[index])
		if(aipaodekuai:getHands(handCards, {}) + 2 <= hand)then
			oPtion.op = Poker.OpGiveUp 
			return
		end
	end
	]]
	oPtion.card = canOutCards[index]
	logd("-------oPtion---------%", oPtion)
end

--是否有方块3
function aipaodekuai:hasFangkuai3(cards)
	for k, card in pairs(cards) do
		if(card == 63)then
			return true
		end
	end
	return false
end

--第一次出牌
function aipaodekuai:onFirst(player, oPtion)
	--强调：炸弹永远不会成为第一手出牌选择，任何情况下，不拆除炸弹，只作为炸弹出牌
	print("主动出牌~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	local handCards = player:getCards()
    local table = self.Table
	local cbHandCardData = commonfunc.deepcopy2(handCards)
	--若只有一手牌全出
	local cardType = table.mPoker:getCardsType(cbHandCardData)
	if cardType ~= Poker.ErrorType then
		oPtion.card = commonfunc.deepcopy2(cbHandCardData)
		return
	end

	local AnalyseResult = {}
	self:AnalysebCardData(cbHandCardData, AnalyseResult)

	--想出的牌，出牌后手数
	local outCards, minHands = {}, 100

	--如果没有单牌，或者单牌很大，打对子
	local minSingle ,minDouble = 100, 100
	for i = 3, 14 do
		if(not AnalyseResult[3] or not self:hasFangkuai3(AnalyseResult[3]))then
			break
		end
		local tmpOutCards = {}
		if  minDouble == 100 and AnalyseResult[i] and 2 == #AnalyseResult[i] then
			minDouble = AnalyseResult[i][1]
			tmpOutCards = AnalyseResult[i]
			local hands = self:getHands(handCards, tmpOutCards)
			if(hands < minHands and self:hasFangkuai3(tmpOutCards))then
				minHands = hands
				outCards = tmpOutCards
				logd("---minDouble---outCards----%, %",minHands, outCards)
			end
		end
		if minSingle == 100 and AnalyseResult[i] and 1 == #AnalyseResult[i] then
			minSingle = AnalyseResult[i][1]
			tmpOutCards = AnalyseResult[i]
			local hands = self:getHands(handCards, tmpOutCards)
			if(hands <= minHands and minSingle < minDouble and self:hasFangkuai3(tmpOutCards))then
				minHands = hands
				outCards = tmpOutCards
				logd("----minSingle--outCards----%, %",minHands, outCards)
			end
		end
	end		

	--iii.第三步：在不具明面统治牌权情况下，判断出牌一次性，一次能出最多张数的牌型
	--是否有顺子
	local first = 0 -- 顺子第一个位置
	local last = 0  -- 顺子最长位置
	for i = 3, 14 do
		if(not AnalyseResult[3] or not self:hasFangkuai3(AnalyseResult[3]))then
			break
		end
		if AnalyseResult[i] then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0  and 4 <= last - first then
				local tmpOutCards = {}
				for j = first, last  do
					--顺子最后一张是对子，不拆
					if(j == last and 2 <= #AnalyseResult[j] and 5 <= #tmpOutCards)then
						break
					end
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
				end
				local hands = self:getHands(handCards, tmpOutCards)
				if(hands <= minHands and self:hasFangkuai3(tmpOutCards))then
					minHands = hands
					outCards = tmpOutCards
					logd("----顺子--outCards----%, %",minHands, outCards)
				end
				break
			end
			first = 0
			last = 0
		end
	end
	
	first = 0 
 	last = 0
	--是否有连队
	for i = 3, 14 do
		if(not AnalyseResult[3] or not self:hasFangkuai3(AnalyseResult[3]))then
			break
		end
		--不拆炸弹
		if AnalyseResult[i] and 2<= #AnalyseResult[i] and #AnalyseResult[i] <= 3 then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0  and 1 <= last - first then
				local tmpOutCards = {}
				for j = first, last  do
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][2]
				end
				local hands = self:getHands(handCards, tmpOutCards)
				if(hands < minHands and self:hasFangkuai3(tmpOutCards))then
					minHands = hands
					outCards = tmpOutCards
					logd("----连队--outCards----%, %",minHands, outCards)
				end
				break
			end
			first = 0
			last = 0
		end		
	end

	first = 0 
	last = 0
	--是否有飞机, 是否有三代2
	for i = 3, 14 do
		if(not AnalyseResult[3] or not self:hasFangkuai3(AnalyseResult[3]))then
			break
		end
		--不拆炸弹
		if AnalyseResult[i] and #AnalyseResult[i] == 3 then
			if first == 0 then 
				first = i 
			end
			last = i	
		else
			if first > 0 then
				local tmpOutCards = {}
				for j = first, last  do
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][1]
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][2]
					tmpOutCards[#tmpOutCards+1] = AnalyseResult[j][3]
				end
				local adds = {}
				local bAdd = self:getAdds(handCards, AnalyseResult, adds, last - first + 1)
				if(bAdd and adds)then
					commonfunc.copyAdd(tmpOutCards, adds)
					local hands = self:getHands(handCards, tmpOutCards)
					if(hands < minHands and self:hasFangkuai3(tmpOutCards))then
						minHands = hands
						outCards = tmpOutCards
						logd("----飞机--outCards----%, %",minHands, outCards)
					end
				end
				break	
			end
			first = 0
			last = 0
		end		
	end

	if(0 < #outCards)then
		oPtion.card = outCards
	end
end

--出牌
function aipaodekuai:OnOPERATION(player)

	local wMeChairID = player:getSeatId()
	local Table = self.Table
	--是否首次出牌
	local op = player.allowedOp.op
	print("AAAAAA getCircleCount=%  getCurrentSubCircleId=% op=%",Table.show:getCircleCount(),Table.show:getCurrentSubCircleId(),op)
	local oPtion = {op=op,card={}}
	if Table.show:getCurrentSubCircleId() == 1 and Table.show:getCircleCount() == 1 and  Table:getBanker():getId() == player:getId() then
		print("首次出牌```````````````````````````````````````````````")
		oPtion =  {op = op, card = {63}}
		self:onFirst(player, oPtion)
	else
		if btBit.AND(Poker.OpOut, op) ~= 0 then
			print("非首次出牌··········································")
			local circle = Table.show:getLastCircle()
			local canOutCards = player:getLargerWeightCardList2(circle.lastOutCards, circle.lastOutCardsType)
			print("canOutCards=============== %",canOutCards)
			if canOutCards[1] and circle.lastOutCardsType ~= Poker.ErrorType then
				self:after(player, Table, oPtion, canOutCards)
			else
				self:before(player, oPtion)
			end
		end
	end
	
	local bReslt = Table:onOperation(player:getSession(), oPtion, true)
    --LOGI("do auto card player[%] handcards[%] op[%] sub[%]", player:getId(), player:getCards(), player:getAllowedOp(), player:getSubmitOp())
    if(bReslt and 0 < bReslt)then
        LOGE("gameId=% oPtion=% ERROR,[%]", self.gameId, oPtion, debug.traceback())
        --player:clearAllowedOp()
        --Table:setOperator(Table:findNext(player))
        --Table.mState:change(Table.TURN)
        for _, p in pairs(self.Table:getPlayers()) do
            LOGE("EEEEEEEEEEEEEEEEEEEE  player[%] op[%] sub[%]", p:getId(), p.allowedOp, p.submitOp)
		end
	end
end

--自动准备
function aipaodekuai:ready()
    local Table = self.Table
    for _, player in pairs(Table:getPlayers()) do
        --不处理玩家操作
        if(player:getRobot() and not player:getReady() or OVER_TIME <= self.stateTime)then
            Table:UpdateDataOnTable(player:getSession(),"GoldCount",player:getGoldCount())
            Table:onReady(player:getSession())
            player:setTuoGuan(false)
            if(Table:isAllReady() == true)then
                Table.mState:change(Table.DEAL)
                break
            end
        end
    end
end

return aipaodekuai

利来利往
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
自动回邮算法，人工智能AI
02-25
自动回邮算法，人工智能AI
跑得快算法分析(多叉树深度递归)
月下独奏的博客
09-12 5675
由于跑得快牌数量较少，可以考虑使用枚举所有组合，并获取其最大权值出牌 基本思路： 类似于多叉树，每一个数节点为一个出牌组合，例如 3445566778，这种情况下最好的组合为34567 45678 较次一点为 44 55 66 77 3 8 在考虑生成子节点时，考虑 对子 顺子 连对 三带 剩下的则为单张，单张不能与其它牌组合， 由于跑得快第一要点为手上的牌越少越好，因此拿到出牌权限时因该先...
斗地主机器人智能算法深度研究
huangdecai2的专栏
04-23 5714
我从事棋牌开发工作已经6年了，我一直喜欢玩斗地主,腾讯上面的我经常玩，别人的也经常玩，对于斗地主机器人智能效果，一直都未发现那个平台做得比较令我满意，所谓的好，我觉得机器人常见牌要打得有点水准，拆牌，顶牌必须要有，还要比较接近人的出牌逻辑，这样玩家的体验感会好很多，我内心其实一直都有一个好的想法去实现更加智能斗地主机器人，趁着最近工作也比较空闲，为此对斗地主机器人算法进行深度研究，...
斗地主机器人AI算法和策略（个人思路总结）
qq_43998763的博客
12-23 8372
一、规则和权值定义 1、斗地主中存在很多种的牌型，比如：单张，对子，三带，顺子，连队，飞机，炸弹等 ，我的机器人主要根据权重去设计的，我给每一种牌型都制定了一个权重，比如3权重是多少，其他牌型的权重有时多少，定义了一个结构体如下： type CardGroup struct{ cgType PattenType //枚举类型 value int //牌的价值 count int //牌的个数 maxCard int
棋牌机器人设计总结
热门推荐
Fanrncho的博客
01-16 10万+
还记得第一次写机器人时内心的激动和忐忑，激动是源于对提升技术的渴求，当时觉得要是能写出机器人，自己的技术水平也就能再上一个台阶了，毕竟写机器人相比写玩法逻辑算法要难得多。忐忑是源于对未知事物的敬畏。 写的第一种机器人是麻将类的，麻将机器人相比斗地主和跑得快机器人要简单得多，虽然麻将和跑得快的玩家都是各自为营的玩法，但因为麻将的出牌并没有多种牌型的变化选择，用跑得快的牌型来解释的话，就是麻将的出牌...
Lua脚本的斗地主的提示出牌算法。
03-27
Lua脚本的斗地主的提示出牌算法。 包括： 查找某牌型的算法：查找所有的单牌，查找所有的对子，查找所有的三条，查找所有的单顺，双顺，飞机，飞机带单，飞机带双。 排序算法。 转成花色，转成点数， 比较算法等。
超强跑得快机器人智能算法深度研究与设计
huangdecai2的专栏
07-07 5135
上一篇斗地主机器人算法的设计是自主研究学习的，没有做细节上的优化，但最近公司刚好要上线跑得快，也需要我编写跑得快ai算法。于是我直接采用斗地主的算法框架来写这个ai，可以说主体设计没有变，但是呢细节上有重大改进，也是这些细节决定了整个ai的品质，经过一个多月与策划撕逼，测试争吵，最终出来的成果是，可以说在不作弊的情况下，90%的人都打不赢机器人，就连我本人都很难取胜，效果倍儿棒，整个设计和过程值得记录与分享。 斗地主的单牌分值设计是没有负分设计的，但策划弄了一套负分的设计，原理...
跑得快人工智能自动代打训练程序设计
huangdecai2的专栏
09-28 6312
最近得知快手开源了斗地主人工智能设计的源码，我迫不及待地下载观摩了他们的代码，去年我也想过用人工智能来实现斗地主的机器人算法，但阅读了一大堆资料之后，也是无从下手，没想到现在有人开了个好头，我怎能错过学习的机会。我测试过原来程序的斗地主的水平陪打还行，还有很大的提升空间，这个他们开源也是想各大高手加入研究，为此我萌生了一个把斗地主改成打跑得快的想法，因为我觉得跑得快相对斗地主简单很多，应该会效果更加好，为此我记录下我最近改造碰到的许多坑。 他这个是用了识别模块来进行界面截图识...
跑得快人工智能IA设计方案
weixin_46376011的博客
10-12 2522
游戏规则：略 结算规则：三家中先出完手里的牌的为赢，赢的数量为对手2家剩余牌张数相加，其中未出一张者数量翻倍 目标分解：赢更多的张数 （目标分解一定要正确，举例，围棋软件，绝艺的目标为赢，星阵的目标为赢更多，所以星阵不是绝艺的对手，星阵的目标分解错误是原因之一） 具体做法：建立模型 1、分牌模型，将自己手里16-2张数量的牌按出牌规则分类 2、概率模型，计算自己手里的牌被别人打起的概率 3、算牌模型，根据出牌规则、对手出牌、计算对手手里必有牌 4、出牌模型，选择自己手里的分类好了的牌的出牌顺序，计算最优选择
手机app跑得快游戏自动代打程序设计
huangdecai2的专栏
03-23 5063
自从上次写了一个h5版本的自动代打，识别准确度非常高，就有了想写一个手机app版本的试试，最近刚好碰上了疫情被困，闲来无事，ny就做出了一个跑得快自动代打程序，效果非常好，先睹为快。视频效果在这https://live.csdn.net/v/192063 说到自动代打就谈到图像识别问题，以前尝试过用按钮精灵进行图像识别处理，效果非常之差，首先就要用到蹩脚的易语言，识别的准确率就只有80%左右，准确率就算是90%对于代打程序来说都是致命的，没法使用。后来得知python的图像识别准...
非常优秀的棋牌类游戏源码，包含AI及机器人的难度调节算法
08-05
非常优秀的棋牌类游戏源码，包含AI及机器人的难度调节算法
人工智能快剪辑算法.zip
07-19
人工智能算法，免费智能算法剪辑
基于蒙特卡洛算法跑得快AI棋牌游戏源码(Java版本).zip
12-29
基于蒙特卡洛算法跑得快AI棋牌游戏源码(Java版本).zip 【备注】 1.项目代码均经过功能验证ok，确保稳定可靠运行。欢迎下载体验！ 2.主要针对各个计算机相关专业，包括计算机科学、信息安全、数据科学与大数据技术、...
31周AI人工智能算法工程师
最新发布
01-30
今天抽空跟大家讨论一下关于成为AI人工智能算法工程师的条件是什么？众所周知，AI人工智能是当前最热门的技术之一，那么需要掌握哪些技术才能胜任这一职位呢？我们今天就来唠一唠。 算法工程师是一个很高端的岗位，...
人工智能计算算法集合项目源代码.zip
06-10
人工智能计算算法集合项目源代码。包含：蚁群算法、粒子群算法、BP神经网络、高斯概率模型的分布估计算法、遗传算法、BP神经网络、贪婪算法。 人工智能计算算法集合项目源代码。包含：蚁群算法、粒子群算法、BP神经...
lua table to string,string to table
01-24 9915
--[[serialize.lua 声明序列化接口,并提供serialize和unserialize函数用于对Table对象进行序列化和反序列化操作 Exported API: Example: --]] require "base.interface" Serializable = interface(nil, "writeObject", "readObje
lua 获得系统时间
12-26 9633
系统到现在多少秒 local ntime = os.time print(ntime) 代码如下： function CallChannel()  local dateText = os.date("%c");  if dateText~="" then   channel.GetChild(0):SetText(dateText);  end end 其中的%c可以是以下的一
【Lua】LuaForWindows_v5.1.4-46安装失败解决方案
09-27 5330
下个补丁pc6-vcredist_x86
用遗传算法玩恐龙快跑
08-12
遗传算法是一种可以用来解决优化问题的算法，它模拟了生物进化的过程。在恐龙快跑游戏中，我们可以使用遗传算法来训练一个能够自动玩游戏的AI。下面是一个简单的步骤： 1. 确定基因表示：首先，我们需要确定一个适合的基因表示方式。在恐龙快跑游戏中，可以将恐龙的动作序列作为基因，比如跳跃和蹲下的动作组合。 2. 初始种群的生成：随机生成一组初始的个体，每个个体都由一组基因表示。 3. 评估适应度：根据个体在游戏中的表现，计算其适应度。可以根据游戏中跑过的距离、收集到的道具等指标来评估适应度。 4. 选择：根据适应度，选择一部分较好的个体作为父代。 5. 交叉：对选出的父代进行交叉操作，生成新的个体。 6. 变异：对新生成的个体进行变异操作，引入一些随机性。 7. 重复步骤3-6：重复进行评估适应度、选择、交叉和变异的步骤，直到达到终止条件（比如达到一定的迭代次数或者找到了满足要求的个体）。 8. 输出最优解：最终输出适应度最高的个体作为最优解。 通过不断迭代优化，可以让AI学会在恐龙快跑游戏中自动跳跃和蹲下，从而取得更好的成绩。当然，在实际应用中，还可以根据具体情况对算法进行调整和改进。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值