西游H5聊天修复

猪八戒

西游H5聊天修复：s1\server\lua\logic\modules\chat
ChatCenter.lua

1. local server = require "server"
   
2. local lua_app = require "lua_app"
   
3. local lua_shield = require "lua_shield"
   
4. local lua_util = require "lua_util"
   
5. local ChatConfig = require "resource.ChatConfig"
   
6. local RaidConfig = require "resource.RaidConfig"
   
7. local utf8 = require("lua_utf8")
   
8. local ChatCenter = {}
   
9. 
   
10. local _ChatType = ChatConfig.ChatType
    
11. local _LinkId = ChatConfig.LinkId
    
12. local _MaxPrivateRecord = 20
    
13. 
    
14. function ChatCenter:Init()
    
15.         self.record = server.baseRecord:Ins(server.baseRecord.RecordType.WorldChat, server.configCenter.ChatConstConfig.saveChatListSize, true)
    
16.         self.systemrecord = server.baseRecord:Ins(server.baseRecord.RecordType.System, server.configCenter.ChatConstConfig.saveSystemChatcount, true)
    
17.         self.playerlist = {}
    
18.         self.privateChatRecord = {}
    
19.         self.offlineChat = {}
    
20.         self.playershareinfo = {}
    
21.         self.chatrecordOfbanned = {}
    
22. end
    
23. 
    
24. function ChatCenter:onDayTimer(player)
    
25.         self.playerlist = {}
    
26. end
    
27. 
    
28. function ChatCenter:onInitClient(player)
    
29.         local worlddatas = self.record:SendRecord(player)
    
30.         local systemdatas = self.systemrecord:SendRecord(player)
    
31.         server.sendReq(player, "sc_chat_init_msg", {
    
32.                         chatDatas = self:FilteChat(worlddatas, systemdatas)
    
33.                 })
    
34.         self:PrivateOfflineChat(player)
    
35. end
    
36. 
    
37. --设置过滤名单
    
38. function ChatCenter:SetFilter(flag, playerid)
    
39.         if flag ~= 0 then
    
40.                 server.broadcastReq("sc_chat_filte_list", {
    
41.                                 filter = playerid,
    
42.                         })
    
43.         end
    
44. end
    
45. 
    
46. function ChatCenter:FilteChat(...)
    
47.         local arg = {...}
    
48.         local newchatdata = {}
    
49.         for __, chatdatas in ipairs(arg) do
    
50.                 for __, chat in ipairs(chatdatas) do
    
51.                         if self:CheckFilteChat(chat.id) then
    
52.                                 newchatdata[#newchatdata + 1] = chat
    
53.                         end
    
54.                 end
    
55.         end
    
56.         return newchatdata
    
57. end
    
58. 
    
59. function ChatCenter:CheckFilteChat(dbid)
    
60.         if not dbid then return true end
    
61.         local player = server.playerCenter:DoGetPlayerByDBID(dbid)
    
62.         local status = player.cache.silent
    
63.         return status ~= -1 and status <= lua_app.now()
    
64. end
    
65. 
    
66. function ChatCenter:GetRecord(chattype)
    
67.         if chattype == server.baseRecord.RecordType.WorldChat or
    
68.                 chattype == server.baseRecord.RecordType.WorldShare then
    
69.                 return self.record
    
70.         else
    
71.                 return self.systemrecord
    
72.         end
    
73. end
    
74. 
    
75. local function _CheckChatCount(sender, count)
    
76.         local ChatLevelConfig = server.configCenter.ChatLevelConfig
    
77.         local powerValue = sender.cache.totalpower
    
78.         local index = #ChatLevelConfig
    
79.         for i = #ChatLevelConfig, 1, -1 do
    
80.                 local cfg = ChatLevelConfig[i]
    
81.                 if powerValue >= cfg.power then
    
82.                         index = i
    
83.                         if count < cfg.chatSize then
    
84.                                 return true
    
85.                         elseif not ChatLevelConfig[i + 1] then
    
86.                                 return false, cfg.errortips
    
87.                         else
    
88.                                 return false, string.format(cfg.errortips, ChatLevelConfig[i + 1].power)
    
89.                         end
    
90.                 end
    
91.         end
    
92.         return false, ChatLevelConfig[#ChatLevelConfig].errortips
    
93. end
    
94. 
    
95. function ChatCenter:CheckAddCount(sender)
    
96.         local playerinfo = self.playerlist[sender.dbid]
    
97.         if not playerinfo then
    
98.                 playerinfo = {
    
99.                         chatdaycount = 0,
    
100.                 }
     
101.                 self.playerlist[sender.dbid] = playerinfo
     
102.         end
     
103.         local nowtime = lua_app.now()
     
104.         local ChatConstConfig = server.configCenter.ChatConstConfig
     
105.         if not server.funcOpen:Check(sender, ChatConstConfig.openLevel) then
     
106.                 server.sendErr(sender, "等级不足，不能发言")
     
107.                 return false
     
108.         end
     
109.         local waittime = ChatConfig:GetWaitInterval("chat."..sender.dbid, ChatConstConfig.chatCd)
     
110.         if waittime > 0 then
     
111.                 server.sendErr(sender, "聊天cd中")
     
112.                 return false
     
113.         end
     
114.         local checkcountret, errmsg = _CheckChatCount(sender, playerinfo.chatdaycount)
     
115.         if not checkcountret then
     
116.                 server.sendErr(sender, errmsg)
     
117.                 return false
     
118.         end
     
119.         playerinfo.chatdaycount = playerinfo.chatdaycount + 1
     
120.         return true
     
121. end
     
122. 
     
123. local _Chatting = {}
     
124. _Chatting[_ChatType.WorldChat] = function(self, sender, str, recvId, pointId)        -- 世界聊天
     
125.         if not self:CheckAddCount(sender) then
     
126.                 return false
     
127.         end
     
128.         local data = {
     
129.                         type = _ChatType.WorldChat,
     
130.                         id = sender.dbid,
     
131.                         name = sender.cache.name,
     
132.                         vip = sender.cache.vip,
     
133.                         str = str,
     
134.                         job = sender.cache.job,
     
135.                         sex = sender.cache.sex,
     
136.                         headframe = sender.head:GetFrame(),
     
137.                         time = lua_app.now(),
     
138.                 }
     
139.         --禁言玩家消息只有自己能看到
     
140.         if not self:CheckFilteChat(sender.dbid) then
     
141.                 server.sendReq(sender, "sc_chat_new_msg", { chatData = data })
     
142.                 return true
     
143.         end
     
144. 
     
145.         self.record:AddRecord(data)
     
146.         server.broadcastReq("sc_chat_new_msg", { chatData = data })
     
147.         sender.task:onEventAdd(server.taskConfig.ConditionType.ChatWorld)
     
148.         return true
     
149. end
     
150. 
     
151. _Chatting[_ChatType.PrivateChat] = function(self, sender, str, recvId)        -- 私聊
     
152.         local ret = server.friendCenter:ChatCheck(sender, recvId)
     
153.         if ret == 1 then
     
154.                 server.sendErr(sender, "你屏蔽该玩家了")
     
155.                 return
     
156.         elseif ret == 2 then
     
157.                 server.sendErr(sender, "你被该玩家屏蔽了")
     
158.                 return
     
159.         end
     
160.         local data = {
     
161.                         type = _ChatType.PrivateChat,
     
162.                         id = sender.dbid,
     
163.                         name = sender.cache.name,
     
164.                         vip = sender.cache.vip,
     
165.                         str = str,
     
166.                         job = sender.cache.job,
     
167.                         sex = sender.cache.sex,
     
168.                         frame = sender.head:GetFrame(),
     
169.                         time = lua_app.now(),
     
170.                 }
     
171.         --禁言玩家消息只有自己能看到
     
172.         if not self:CheckFilteChat(sender.dbid) then
     
173.                 server.sendReq(sender, "sc_chat_private_new_msg", {
     
174.                         session = self:GetPrivateChatId(sender.dbid, recvId),
     
175.                         chatData = data,
     
176.                 })
     
177.                 return true
     
178.         end
     
179. 
     
180.         local receiver = server.playerCenter:DoGetPlayerByDBID(recvId)
     
181.         self:AddPrivateChatRecord(sender, receiver, data)
     
182.         return true
     
183. end
     
184. 
     
185. function _StrRepeatCount(src, cond)
     
186.         return select(2, string.gsub(src, string.format("%s[^|]*", cond), ""))
     
187. end
     
188. --禁言检测
     
189. function ChatCenter:CheckBanned(dbid, chatstr)
     
190.         local ChatshutupConfig = server.configCenter.ChatshutupConfig
     
191.         local record = self.chatrecordOfbanned[dbid]
     
192.         if not record then
     
193.                 record = { nextindex = 1 }
     
194.                 self.chatrecordOfbanned[dbid] = record
     
195.         end
     
196.         local text = table.concat(record, "|")
     
197.         for __, str in ipairs(ChatshutupConfig.jlibrary) do
     
198.                 if  _StrRepeatCount(text, str) > ChatshutupConfig.zicount then
     
199.                         return true
     
200.                 end
     
201.         end
     
202.         for __, str in ipairs(ChatshutupConfig.mlibrary) do
     
203.                 if  _StrRepeatCount(text, str) > ChatshutupConfig.shutupcount then
     
204.                         return true
     
205.                 end
     
206.         end
     
207.         local count = 0
     
208.         for w in string.gmatch(text, "[^|]+") do
     
209.                 if w == chatstr then
     
210.                         count = count + 1
     
211.                 end
     
212.                 if count > ChatshutupConfig.repeatcount then
     
213.                         return true
     
214.                 end
     
215.         end
     
216.         
     
217.         local len = utf8.len(chatstr)
     
218.         if len >= ChatshutupConfig.count then
     
219.                 record[record.nextindex] = chatstr
     
220.                 record.nextindex = record.nextindex % ChatshutupConfig.historycount + 1
     
221.         end
     
222.         return false
     
223. end
     
224. 
     
225. function ChatCenter:Chat(sender, type, str, recvId)
     
226.         local status = sender.cache.silent
     
227.         if status ~= -1 and self:CheckBanned(sender.dbid, str) then
     
228.                 sender.cache.silent = -1
     
229.                 self:SetFilter(-1, sender.dbid)
     
230.                 lua_app.log_info("CheckBanned:Prohibit players from chatting.", sender.dbid, sender.cache.name)
     
231.         end
     
232. 
     
233.         if status > lua_app.now() then
     
234.                 server.sendErr(sender, "您已经被禁言,剩余时间" .. (status - lua_app.now()) .. "秒")
     
235.                 return false
     
236.         end
     
237. 
     
238.         if string.len(str) >= server.configCenter.ChatConstConfig.chatLen then
     
239.                 server.sendErr(sender, "字节太长,超过160个字节")
     
240.                 return false
     
241.         end
     
242. 
     
243.         str = lua_shield:string(str)
     
244.         return _Chatting[type](self, sender, str, recvId)
     
245. end
     
246. 
     
247. local CheckLinkCondition = setmetatable({}, {__index = function()
     
248.         return function() return true end
     
249. end})
     
250. 
     
251. CheckLinkCondition[_LinkId.AssistPkBoss] = function(sender)
     
252.         local ChaptersCommonConfig = server.configCenter.ChaptersCommonConfig
     
253.         local appealtime = sender.cache.chapter.appealtime
     
254.         if appealtime >= ChaptersCommonConfig.appealtime then
     
255.                 server.sendErr(sender, "当日求助次数达到上限")
     
256.                 return false
     
257.         end
     
258.         return true
     
259. end
     
260. 
     
261. function ChatCenter:CheckChatLink(id, sender)
     
262.         if not CheckLinkCondition[id](sender) then
     
263.                 return false
     
264.         end
     
265.         local waittime = ChatConfig:GetWaitInterval("CheckChatLink."..sender.dbid)
     
266.         if waittime > 0 then
     
267.                 server.sendErr(sender, string.format("%d秒后才能发送", waittime))
     
268.                 return false
     
269.         end
     
270.         local tips = ChatConfig.LinkTips[id] or "发送成功"
     
271.         server.sendErr(sender, tips)
     
272.         return true
     
273. end
     
274. 
     
275. --param1 分享id， param2为玩家的id列表
     
276. function ChatCenter:ChatLink(shareid, sender, checkflag, ...)
     
277.         if checkflag then
     
278.                 if not self:CheckChatLink(shareid, sender) then
     
279.                         return
     
280.                 end
     
281.         end
     
282.         print("shareid", "--------------------------")
     
283.         local chatData = ChatConfig:PackLinkData(shareid, sender, ...)
     
284.         local record = self:GetRecord(chatData.type)
     
285.         record:AddRecord(chatData)
     
286.         server.broadcastReq("sc_chat_new_msg", {
     
287.                 chatData = chatData
     
288.                 })
     
289.         return true
     
290. end
     
291. 
     
292. --战斗通知
     
293. local _NoticeRaid = setmetatable({}, {__index = function() return function() end end})
     
294. 
     
295. _NoticeRaid[RaidConfig.type.GuildFb] = function(dbid, level)
     
296.         local GuildFubenConfig = server.configCenter.GuildFubenConfig[level]
     
297.         local player = server.playerCenter:DoGetPlayerByDBID(dbid)
     
298.         player.guild:ChatLink(11, 0, {ChatConfig.CollectType.Fb, level, RaidConfig.type.GuildFb}, player.cache.name, GuildFubenConfig.uititle)
     
299. end
     
300. 
     
301. _NoticeRaid[RaidConfig.type.CrossTeamFb] = function(dbid, level)
     
302.         local player = server.playerCenter:DoGetPlayerByDBID(dbid)
     
303.         server.chatCenter:ChatLink(14, player, nil, {ChatConfig.CollectType.Fb, level, RaidConfig.type.CrossTeamFb}, player.cache.name, level)
     
304. end
     
305. 
     
306. _NoticeRaid[RaidConfig.type.EightyOneHard] = function(dbid, level)
     
307.         local player = server.playerCenter:DoGetPlayerByDBID(dbid)
     
308.         local DisasterFbConfig = server.configCenter.DisasterFbConfig[level]
     
309.         server.chatCenter:ChatLink(15, player, nil, {ChatConfig.CollectType.Fb, level, RaidConfig.type.EightyOneHard}, player.cache.name, DisasterFbConfig.name)
     
310. end
     
311. 
     
312. _NoticeRaid[RaidConfig.type.GuildBoss] = function(dbid, level, guildid)
     
313.         local guild = server.guildCenter:GetGuild(guildid)
     
314.         if not guild then
     
315.                 return
     
316.         end
     
317.         local chatdata = server.chatConfig:PackLinkData(8)
     
318.         guild.guildRecord:AddGuildChat(chatdata.str, nil, chatdata.share)
     
319. end
     
320. 
     
321. _NoticeRaid[RaidConfig.type.FieldBoss] = function(dbid, level)
     
322.         server.chatCenter:ChatLink(13)
     
323. end
     
324. 
     
325. local _NoticeCheck = {}
     
326. function ChatCenter:NoticeFb(raidtype, dbid, level, ...)
     
327.         local recordkey = string.format("%s%s%s", raidtype, dbid, level)
     
328.         local waittime = ChatConfig:GetWaitInterval(recordkey)
     
329.         if waittime > 0 then return end
     
330.         _NoticeRaid[raidtype](dbid, level, ...)
     
331. end
     
332. 
     
333. function ChatCenter:EmitTeamRecruit(dbid)
     
334.          local waittime = ChatConfig:GetWaitInterval(dbid)
     
335.          if waittime > 0 then
     
336.                  server.sendErrByDBID(dbid, string.format("%d秒后才能招募", waittime))
     
337.         return false
     
338.     end
     
339.     server.sendErrByDBID(dbid, "招募成功")
     
340.     return true
     
341. end
     
342. 
     
343. function ChatCenter:AddPrivateChatRecord(sender, receiver, data)
     
344.         local session = self:GetPrivateChatId(sender.dbid, receiver.dbid)
     
345.         local records = self.privateChatRecord[session]
     
346.         if not records then
     
347.                 records = {}
     
348.                 self.privateChatRecord[session] = records
     
349.         end
     
350.         if #records > _MaxPrivateRecord then
     
351.                 table.remove(records, 1)
     
352.         end
     
353.         table.insert(records, data)
     
354.         server.sendReq(sender, "sc_chat_private_new_msg", {
     
355.                         session = session,
     
356.                         chatData = data,
     
357.                 })
     
358.         if receiver.isLogin then
     
359.                 server.sendReq(receiver, "sc_chat_private_new_msg", {
     
360.                                 session = session,
     
361.                                 chatData = data,
     
362.                         })
     
363.         else
     
364.                 local offlineChat = self.offlineChat[receiver.dbid]
     
365.                 if not offlineChat then
     
366.                         offlineChat = {}
     
367.                         self.offlineChat[receiver.dbid] = offlineChat
     
368.                 end
     
369.                 offlineChat[session] = true
     
370.         end
     
371. end
     
372. 
     
373. function ChatCenter:PrivateOfflineChat(player)
     
374.         local offlineChat = self.offlineChat[player.dbid]
     
375.         if not offlineChat then
     
376.                 return
     
377.         end
     
378.         for session,_ in pairs(offlineChat) do
     
379.                 local records = self.privateChatRecord[session]
     
380.                 server.sendReq(player, "sc_chat_private_init_msg", {
     
381.                         session = session,
     
382.                         chatData = records,
     
383.                 })
     
384.         end
     
385.         self.offlineChat[player.dbid] = nil
     
386. end
     
387. 
     
388. function ChatCenter:PrivateChatStart(sender, recvId)
     
389.         local session = self:GetPrivateChatId(sender.dbid, recvId)
     
390.         local records = self.privateChatRecord[session]
     
391.         if not records then
     
392.                 records = {}
     
393.                 self.privateChatRecord[session] = records
     
394.         end
     
395.         server.sendReq(sender, "sc_chat_private_init_msg", {
     
396.                         session = session,
     
397.                         chatData = records,
     
398.                 })
     
399. end
     
400. 
     
401. function ChatCenter:GetPrivateChatId(senderId, receiverId)
     
402.         return (senderId < receiverId and senderId ..":".. receiverId or receiverId ..":".. senderId)
     
403. end
     
404. 
     
405. function ChatCenter:ClearChat()
     
406.         self.record:ClearRecord()
     
407. end
     
408. 
     
409. function ChatCenter:ChatSysInfo(dbid, str)
     
410.         local player = server.playerCenter:DoGetPlayerByDBID(dbid)
     
411.         if player then
     
412.                 local data = {
     
413.                                 type = _ChatType.SysChat,
     
414.                                 id = dbid,
     
415.                                 name = player.cache.name,
     
416.                                 vip = player.cache.vip,
     
417.                                 str = str,
     
418.                                 job = player.cache.job,
     
419.                                 sex = player.cache.sex,
     
420.                                 time = lua_app.now(),
     
421.                         }
     
422.                 player:sendReq("sc_chat_new_msg", { chatData = data })
     
423.         end
     
424. end
     
425. 
     
426. function ChatCenter:BroadcastSysInfo(str)
     
427.         local data = {
     
428.                                 type = _ChatType.SysChat,
     
429.                                 id = 0,
     
430.                                 name = player.cache.name,
     
431.                                 vip = player.cache.vip,
     
432.                                 str = str,
     
433.                                 job = player.cache.job,
     
434.                                 sex = player.cache.sex,
     
435.                                 time = lua_app.now(),
     
436.                         }
     
437.         server.broadcastReq("sc_chat_new_msg", { chatData = data })
     
438. end
     
439. 
     
440. function ChatCenter:ResetServer()
     
441.         self.record:ClearRecord()
     
442.         self.systemrecord:ClearRecord()
     
443.         self.playerlist = {}
     
444.         self.privateChatRecord = {}
     
445.         self.offlineChat = {}
     
446. end
     
447. 
     
448. server.SetCenter(ChatCenter, "chatCenter")
     
449. return ChatCenter

复制代码