package main import ( "errors" "log" "regexp" "strconv" "strings" "time" ) func getMsgParsingRule(m *ChatWarsMessage) (*MessageParsingRule, error) { var i int for i = 0; i < len(msgParsingRules); i++ { if msgParsingRules[i].re.FindStringSubmatch(m.Text) != nil { if (msgParsingRules[i].ChatID64 == 0 || msgParsingRules[i].ChatID64 == m.ChatID64) && (msgParsingRules[i].SenderUserID64 == 0 || msgParsingRules[i].SenderUserID64 == m.TGSenderUserID64) { break } } } if i == len(msgParsingRules) { return nil, errors.New("Can't find message type in rules.") } else { r := msgParsingRules[i] return &r, nil } } func parseSubTypeMessageInspectAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageInspectAck, error) { cwm := ChatWarsMessageInspectAck{} cwm.Name = r.ReplaceAllString(m.Text, "${Item}") log.Printf("parseSubTypeMessageInspectAck : Name : %s\n", cwm.Name) return &cwm, nil } func parseSubTypeMessageExchangeAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageExchangeAck, error) { cwm := ChatWarsMessageExchangeAck{} deals := []ChatWarsExchangeDeal{} log.Printf("parseSubTypeMessageExchangeAck : ActiveDeals : %s\n", r.ReplaceAllString(m.Text, "${ActiveDeals}")) log.Printf("parseSubTypeMessageExchangeAck : MaxDeals : %s\n", r.ReplaceAllString(m.Text, "${MaxDeals}")) cwm.ActiveDeals, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${ActiveDeals}"), 10, 64) cwm.MaxDeals, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${MaxDeals}"), 10, 64) if cwm.ActiveDeals > 0 { re := regexp.MustCompile(`([a-zA-Z ]+)\n([0-9]+) x ([0-9]+)πŸ’° \[(.*)\] (.*)\n`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Deals}"), -1) { i := getObjItemID(``, l[1]) q, _ := strconv.ParseInt(l[2], 10, 64) p, _ := strconv.ParseInt(l[3], 10, 64) l := l[4] if i != 0 { deal := ChatWarsExchangeDeal{ ItemID64: i, Quantity: q, Price: p, Link: l, } deals = append(deals, deal) } } } cwm.DealList = deals cwm.Msg = m return &cwm, nil } func parseSubTypeMessageQuestResult(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageQuestResult, error) { cwm := ChatWarsMessageQuestResult{} /* look for 351 go_quest_ack, etc .. */ cwm.Msg = m return &cwm, nil } func parseSubTypeMessageStockAnyAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageStockAnyAck, error) { cwm := ChatWarsMessageStockAnyAck{} items := []ChatWarsItems{} re := regexp.MustCompile(`(πŸ“ƒ){0,1}(['a-zA-Z ]+) \(([0-9]+)\)( /view_[a-z0-9]+){0,1}\n{0,1}`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Items}"), -1) { // fmt.Printf("parseSubTypeMessageStockAnyAck : %+q\n", l) i := getObjItemID(``, l[2]) q, _ := strconv.ParseInt(l[3], 10, 64) if i != 0 { item := ChatWarsItems{ ItemID64: i, Quantity: q, } items = append(items, item) } } cwm.Stock = items cwm.Msg = m return &cwm, nil } func parseSubTypeMessageGDepositReq(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageGDepositReq, error) { cwm := ChatWarsMessageGDepositReq{} cwm.ItemID64 = getObjItemID(r.ReplaceAllString(m.Text, "${Item}"), ``) // FIXME, handle uXXX items ? cwm.Quantity, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Quantity}"), 10, 64) cwm.Msg = m return &cwm, nil } func parseSubTypeMessageGDepositAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageGDepositAck, error) { cwm := ChatWarsMessageGDepositAck{} cwm.ItemID64 = getObjItemID(``, r.ReplaceAllString(m.Text, "${Item}")) cwm.Quantity, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Quantity}"), 10, 64) gDepositForwardMux.Lock() for i := range gDepositForwardMsg { msg, err := getObjMsg(gDepositForwardMsg[i]) logOnError(err, "parseSubTypeMessageGDepositAck : gDepositForwardMsg") if err == nil && m.TGUserID64 == msg.TGUserID64 { rule, err := getMsgParsingRule(msg) logOnError(err, "parseSubTypeMessageGDepositAck : getMsgParsingRule") cwmreq, err := parseSubTypeMessageGDepositReq(msg, rule.re) logOnError(err, "parseSubTypeMessageGDepositAck : parseSubTypeMessageGDepositReq") if err == nil && cwmreq.ItemID64 == cwm.ItemID64 && cwmreq.Quantity == cwm.Quantity { if m.Date.UTC().Before(msg.Date.UTC().Add(1 * time.Minute)) { clientFwdCWMsg(msg.TGUserID64, m.ID64, m.ChatID64, cfg.Bot.Depositchat) } gDepositForwardMsg[i] = gDepositForwardMsg[len(gDepositForwardMsg)-1] gDepositForwardMsg = gDepositForwardMsg[:len(gDepositForwardMsg)-1] break } } } gDepositForwardMux.Unlock() cwm.Msg = m return &cwm, nil } func parseSubTypeMessageStockAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageStockAck, error) { cwm := ChatWarsMessageStockAck{} items := []ChatWarsItems{} re := regexp.MustCompile(`\n([a-zA-Z ❄️]+) \(([0-9]+)\)`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Items}"), -1) { i := getObjItemID(``, l[1]) q, _ := strconv.ParseInt(l[2], 10, 64) if i != 0 { item := ChatWarsItems{ ItemID64: i, Quantity: q, } items = append(items, item) } } re = regexp.MustCompile(`\n\/sg_[0-9]+ ([^\(]+) \(([0-9]+)\)`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Items}"), -1) { i := getObjItemID(``, l[1]) q, _ := strconv.ParseInt(l[2], 10, 64) if i != 0 { item := ChatWarsItems{ ItemID64: i, Quantity: q, } items = append(items, item) } } cwm.Used, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Used}"), 10, 64) cwm.Available, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Available}"), 10, 64) cwm.Stock = items cwm.Msg = m return &cwm, nil } func parseSubTypeMessageReportAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageReportAck, error) { cwm := ChatWarsMessageReportAck{} /* log.Printf("parseSubTypeMessageReport : War report identified\n") log.Printf("parseSubTypeMessageReport : Castle : %s\n", r.ReplaceAllString(m.Text, "${Castle}")) log.Printf("parseSubTypeMessageReport : Guild : %s\n", r.ReplaceAllString(m.Text, "${Guild}")) log.Printf("parseSubTypeMessageReport : User : %s\n", r.ReplaceAllString(m.Text, "${User}")) log.Printf("parseSubTypeMessageReport : Attack : %s\n", r.ReplaceAllString(m.Text, "${Attack}")) log.Printf("parseSubTypeMessageReport : AttackMod : %s\n", r.ReplaceAllString(m.Text, "${AttackMod}")) log.Printf("parseSubTypeMessageReport : Defense : %s\n", r.ReplaceAllString(m.Text, "${Defense}")) log.Printf("parseSubTypeMessageReport : Level : %s\n", r.ReplaceAllString(m.Text, "${Level}")) log.Printf("parseSubTypeMessageReport : Exp : %s\n", r.ReplaceAllString(m.Text, "${Exp}")) log.Printf("parseSubTypeMessageReport : Gold : %s\n", r.ReplaceAllString(m.Text, "${Gold}")) log.Printf("parseSubTypeMessageReport : Stock : %s\n", r.ReplaceAllString(m.Text, "${Stock}")) log.Printf("parseSubTypeMessageReport : Stamina : %s\n", r.ReplaceAllString(m.Text, "${Stamina}")) log.Printf("parseSubTypeMessageReport : Crit : %s\n", r.ReplaceAllString(m.Text, "${Crit}")) */ return &cwm, nil } func parseSubTypeMessageOrderbookAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageOrderbookAck, error) { cwm := ChatWarsMessageOrderbookAck{} /* log.Printf("parseSubTypeMessageOrderbookAck : Orderbook identified\n") log.Printf("parseSubTypeMessageOrderbookAck : Name : %s\n", r.ReplaceAllString(m.Text, "${Name}")) log.Printf("parseSubTypeMessageOrderbookAck : Code : %s\n", r.ReplaceAllString(m.Text, "${Code}")) log.Printf("parseSubTypeMessageOrderbookAck : Qty : %s\n", r.ReplaceAllString(m.Text, "${Qty}")) log.Printf("parseSubTypeMessageOrderbookAck : Gold : %s\n", r.ReplaceAllString(m.Text, "${Gold}")) log.Printf("parseSubTypeMessageOrderbookAck : Qty1 : %s\n", r.ReplaceAllString(m.Text, "${Qty1}")) log.Printf("parseSubTypeMessageOrderbookAck : Price1 : %s\n", r.ReplaceAllString(m.Text, "${Price1}")) log.Printf("parseSubTypeMessageOrderbookAck : Qty2 : %s\n", r.ReplaceAllString(m.Text, "${Qty2}")) log.Printf("parseSubTypeMessageOrderbookAck : Price2 : %s\n", r.ReplaceAllString(m.Text, "${Price2}")) log.Printf("parseSubTypeMessageOrderbookAck : Qty3 : %s\n", r.ReplaceAllString(m.Text, "${Qty3}")) log.Printf("parseSubTypeMessageOrderbookAck : Price3 : %s\n", r.ReplaceAllString(m.Text, "${Price3}")) */ return &cwm, nil } func parseSubTypeMessageAuctionAnnounce(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageAuctionAnnounce, error) { cwm := ChatWarsMessageAuctionAnnounce{} l, _ := strconv.ParseInt(r.ReplaceAllString(m.Text, "${Lot}"), 10, 32) cwm.LotID = int32(l) cwm.ItemID64 = getObjItemID(``, r.ReplaceAllString(m.Text, "${Item}")) cwm.Cond = r.ReplaceAllString(m.Text, "${Cond}") cwm.Quality = r.ReplaceAllString(m.Text, "${Quality}") cwm.SellerUserID64 = getObjUserID(r.ReplaceAllString(m.Text, "${SellerUser}")) cwm.SellerGuildID64 = getObjGuildID(r.ReplaceAllString(m.Text, "${SellerGuild}")) cwm.SellerCastleID64 = getObjCastleID(r.ReplaceAllString(m.Text, "${SellerCastle}")) cwm.BuyerUserID64 = getObjUserID(r.ReplaceAllString(m.Text, "${BuyerUser}")) cwm.BuyerGuildID64 = getObjGuildID(r.ReplaceAllString(m.Text, "${BuyerGuild}")) cwm.BuyerCastleID64 = getObjCastleID(r.ReplaceAllString(m.Text, "${BuyerCastle}")) p, _ := strconv.ParseInt(r.ReplaceAllString(m.Text, "${Price}"), 10, 32) cwm.Price = int32(p) cwm.Status = r.ReplaceAllString(m.Text, "${Status}") cwm.End, _ = fromChatWarsDate(r.ReplaceAllString(m.Text, "${End}")) return &cwm, nil } func parseSubTypeMessageWithdrawRcv(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageWithdrawRcv, error) { cwm := ChatWarsMessageWithdrawRcv{} items := []ChatWarsItems{} re := regexp.MustCompile(`(.*) x (.*)`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Items}"), -1) { i := getObjItemID(``, l[1]) q, _ := strconv.ParseInt(l[2], 10, 64) if i != 0 { item := ChatWarsItems{ ItemID64: i, Quantity: q, } items = append(items, item) } } cwm.ItemList = items cwm.Msg = m return &cwm, nil } func parseSubTypeMessageGStockAnyAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageGStock, error) { cwm := ChatWarsMessageGStock{} stock := []ChatWarsItems{} re := regexp.MustCompile(`\n([0-9a-z]+) (.*) x ([0-9]+)`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Stock}"), -1) { i := getObjItemID(l[1], l[2]) q, _ := strconv.ParseInt(l[3], 10, 64) if i != 0 { item := ChatWarsItems{ Code: l[1], Name: l[2], ItemID64: i, Quantity: q, } stock = append(stock, item) } } cwm.Stock = stock cwm.Msg = m return &cwm, nil } func parseSubTypeMessageTributesStatsAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageTributesStatsAck, error) { cwm := ChatWarsMessageTributesStatsAck{} cwm.Msg = m tributes := []ChatWarsTribute{} re := regexp.MustCompile(`(\n(?P[1-9]{2} [a-zA-Z]+ [0-9]{4} [0-9]{2}:[0-9]{2}) - (?P[a-zA-Z]+) x (?P[0-9]+), (?P[0-9]+)πŸ”₯)`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Tributes}"), -1) { tribute := ChatWarsTribute{} d, err := fromChatWarsDate(re.ReplaceAllString(l[0], "${Date}")) logOnError(err, "parseSubTypeMessageTributesStatsAck : fromChatWarsDate") tribute.Date = d tribute.ItemID64 = getSilentObjItemID(``, re.ReplaceAllString(l[0], "${Item}")) tribute.Quantity, err = strconv.ParseInt(re.ReplaceAllString(l[0], "${Quantity}"), 10, 64) logOnError(err, "parseSubTypeMessageTributesStatsAck : ParseInt") tribute.Exp, err = strconv.ParseInt(re.ReplaceAllString(l[0], "${Exp}"), 10, 64) logOnError(err, "parseSubTypeMessageTributesStatsAck : ParseInt") tributes = append(tributes, tribute) } cwm.Tributes = tributes return &cwm, nil } func parseSubTypeMessageMeAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageMeAck, error) { var i int64 cwm := ChatWarsMessageMeAck{ CWUserID64: getObjUserID(r.ReplaceAllString(m.Text, "${Player}")), CWGuildID64: getObjGuildID(r.ReplaceAllString(m.Text, "${Guild}")), State: r.ReplaceAllString(m.Text, "${State}"), Class: r.ReplaceAllString(m.Text, "${Class}"), } i, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${ExpNow}"), 10, 64) cwm.ExpNow = i i, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${ExpLvl}"), 10, 64) cwm.ExpLvl = i i, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Level}"), 10, 64) cwm.Level = i /* log.Printf("parseSubTypeMessageMeAck : Me report identified\n") log.Printf("parseSubTypeMessageMeAck : Castle : %s\n", r.ReplaceAllString(m.Text, "${Castle}")) log.Printf("parseSubTypeMessageMeAck : Level : %s\n", r.ReplaceAllString(m.Text, "${Level}")) log.Printf("parseSubTypeMessageMeAck : Class : %s\n", cwm.Class) log.Printf("parseSubTypeMessageMeAck : Atk : %s\n", r.ReplaceAllString(m.Text, "${Atk}")) log.Printf("parseSubTypeMessageMeAck : Def : %s\n", r.ReplaceAllString(m.Text, "${Def}")) log.Printf("parseSubTypeMessageMeAck : ExpNow : %s\n", r.ReplaceAllString(m.Text, "${ExpNow}")) log.Printf("parseSubTypeMessageMeAck : ExpLvl : %s\n", r.ReplaceAllString(m.Text, "${ExpLvl}")) log.Printf("parseSubTypeMessageMeAck : StaminaNow : %s\n", r.ReplaceAllString(m.Text, "${StaminaNow}")) log.Printf("parseSubTypeMessageMeAck : StaminaMax : %s\n", r.ReplaceAllString(m.Text, "${StaminaMax}")) log.Printf("parseSubTypeMessageMeAck : Gold : %s\n", r.ReplaceAllString(m.Text, "${Gold}")) log.Printf("parseSubTypeMessageMeAck : Pogs : %s\n", r.ReplaceAllString(m.Text, "${Pogs}")) log.Printf("parseSubTypeMessageMeAck : Gems : %s\n", r.ReplaceAllString(m.Text, "${Gems}")) log.Printf("parseSubTypeMessageMeAck : AtkGear : %s\n", r.ReplaceAllString(m.Text, "${AtkGear}")) log.Printf("parseSubTypeMessageMeAck : DefGear : %s\n", r.ReplaceAllString(m.Text, "${DefGear}")) log.Printf("parseSubTypeMessageMeAck : BagUsed : %s\n", r.ReplaceAllString(m.Text, "${BagUsed}")) log.Printf("parseSubTypeMessageMeAck : BagDispo : %s\n", r.ReplaceAllString(m.Text, "${BagDispo}")) */ cwm.Msg = m return &cwm, nil } func parseSubTypeMessageGRolesAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageGRolesAck, error) { cwm := ChatWarsMessageGRolesAck{ Msg: m, } /* BartenderID64: getObjUserID(r.ReplaceAllString(m.Text, "${Bartender}")), CommanderID64: getObjUserID(r.ReplaceAllString(m.Text, "${Commander}")), SquireID64: getObjUserID(r.ReplaceAllString(m.Text, "${Squire}")), TreasurerID64: getObjUserID(r.ReplaceAllString(m.Text, "${Treasurer}")), */ if len(r.ReplaceAllString(m.Text, "${Bartender}")) > 0 { cwm.BartenderID64 = getObjUserID(r.ReplaceAllString(m.Text, "${Bartender}")) } else { cwm.BartenderID64 = 0 } if len(r.ReplaceAllString(m.Text, "${Commander}")) > 0 { cwm.CommanderID64 = getObjUserID(r.ReplaceAllString(m.Text, "${Commander}")) } else { cwm.CommanderID64 = 0 } if len(r.ReplaceAllString(m.Text, "${Squire}")) > 0 { cwm.SquireID64 = getObjUserID(r.ReplaceAllString(m.Text, "${Squire}")) } else { cwm.SquireID64 = 0 } if len(r.ReplaceAllString(m.Text, "${Treasurer}")) > 0 { cwm.TreasurerID64 = getObjUserID(r.ReplaceAllString(m.Text, "${Treasurer}")) } else { cwm.TreasurerID64 = 0 } /* log.Printf("parseSubTypeMessageGRolesAck : Guild roles Ack identified\n") log.Printf("parseSubTypeMessageGRolesAck : Bartender : %s\n", r.ReplaceAllString(m.Text, "${Bartender}")) log.Printf("parseSubTypeMessageGRolesAck : Commander : %s\n", r.ReplaceAllString(m.Text, "${Commander}")) log.Printf("parseSubTypeMessageGRolesAck : Squire : %s\n", r.ReplaceAllString(m.Text, "${Squire}")) log.Printf("parseSubTypeMessageGRolesAck : Treasurer : %s\n", r.ReplaceAllString(m.Text, "${Treasurer}")) log.Printf("cwm.BartenderID64 : %d\n", cwm.BartenderID64) log.Printf("cwm.CommanderID64 : %d\n", cwm.CommanderID64) log.Printf("cwm.SquireID64 : %d\n", cwm.SquireID64) log.Printf("cwm.TreasurerID64 : %d\n", cwm.TreasurerID64) */ cwm.Msg = m return &cwm, nil } func parseSubTypeMessageGoQuestAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageGoQuestAck, error) { cwm := ChatWarsMessageGoQuestAck{} /* log.Printf("parseSubTypeMessageGoQuestAck : Go Quest Ack report identified\n") log.Printf("parseSubTypeMessageGoQuestAck : Place : %s\n", r.ReplaceAllString(m.Text, "${Place}")) log.Printf("parseSubTypeMessageGoQuestAck : Time : %s\n", r.ReplaceAllString(m.Text, "${Time}")) */ switch quest := strings.ToLower(r.ReplaceAllString(m.Text, "${Place}")); quest { case "forest": cwm.QuestTypeID64 = cacheObjSubType[`quest_forest`] case "mountains": cwm.QuestTypeID64 = cacheObjSubType[`quest_mountains`] default: log.Printf("parseSubTypeMessageGoQuestAck : no reference for quest `%s`\n", quest) cwm.QuestTypeID64 = cacheObjSubType[`quest_forest`] } i, err := strconv.ParseInt(r.ReplaceAllString(m.Text, "${Time}"), 10, 64) if err == nil { cwm.Duration = time.Duration(i) * time.Minute } else { cwm.Duration = 0 * time.Minute } cwm.Msg = m return &cwm, nil } func parseSubTypeMessageUnionWar(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageUnionWar, error) { //re := regexp.MustCompile('^(🏠Trade union news:\\n)(?P(?s:[^(πŸŽͺState of exclusive rights)]*))(πŸŽͺState of exclusive rights:)(?P(?s:.*))$') /* "^(🏠Trade union news:\\n){0,1}` + `(((?P[A-Z][a-z]+ [A-Z][a-z]+) was (?P(easily defended|defended successfully|breached.|easily breached.|closely breached.))(Attackers have pillage union for (?[0-9]+) stock):\\n` + `(πŸŽ–Attack leaders: (?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}){0,1}(\\n){0,1}` + `(πŸŽ–Defense leaders: (?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}){0,1}(\\n){0,1})(\\n)*)*` + `(πŸŽͺState of exclusive rights:\\n){0,1}` + `(((?P[A-Z][a-z]+ [A-Z][a-z]+) (?P(was protected|belongs to)( (?P[A-Z][a-z]+ [A-Z][a-z]+):)\\n` + `(πŸŽ–Attack leaders: (?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}){0,1}(\\n){0,1}` + `(πŸŽ–Defense leaders: (?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}(,(?P[πŸ‰πŸ¦…πŸΊπŸ¦ˆπŸ¦ŒπŸ₯”πŸŒ‘])(?P[^,]+)){0,1}){0,1}(\\n){0,1})(\\n)*)*` + `$)" */ cwm := ChatWarsMessageUnionWar{} /* log.Printf("parseSubTypeMessageUnionWar : War report identified\n") log.Printf("parseSubTypeMessageUnionWar : Castle : %s\n", r.ReplaceAllString(m.Text, "${Castle}")) log.Printf("parseSubTypeMessageUnionWar : Guild : %s\n", r.ReplaceAllString(m.Text, "${Guild}")) log.Printf("parseSubTypeMessageUnionWar : User : %s\n", r.ReplaceAllString(m.Text, "${User}")) log.Printf("parseSubTypeMessageUnionWar : Attack : %s\n", r.ReplaceAllString(m.Text, "${Attack}")) log.Printf("parseSubTypeMessageUnionWar : AttackMod : %s\n", r.ReplaceAllString(m.Text, "${AttackMod}")) log.Printf("parseSubTypeMessageUnionWar : Defense : %s\n", r.ReplaceAllString(m.Text, "${Defense}")) log.Printf("parseSubTypeMessageUnionWar : Level : %s\n", r.ReplaceAllString(m.Text, "${Level}")) log.Printf("parseSubTypeMessageUnionWar : Exp : %s\n", r.ReplaceAllString(m.Text, "${Exp}")) log.Printf("parseSubTypeMessageUnionWar : Gold : %s\n", r.ReplaceAllString(m.Text, "${Gold}")) log.Printf("parseSubTypeMessageUnionWar : Stock : %s\n", r.ReplaceAllString(m.Text, "${Stock}")) log.Printf("parseSubTypeMessageUnionWar : Stamina : %s\n", r.ReplaceAllString(m.Text, "${Stamina}")) log.Printf("parseSubTypeMessageUnionWar : Crit : %s\n", r.ReplaceAllString(m.Text, "${Crit}")) */ return &cwm, nil } func parseSubTypeMessageDuelFight(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageDuelFight, error) { cwm := ChatWarsMessageDuelFight{} if r.ReplaceAllString(m.Text, "${Duelist1}") == r.ReplaceAllString(m.Text, "${WinDuelist}") { cwm.WinCastle = r.ReplaceAllString(m.Text, "${Castle1}") cwm.WinGuild = r.ReplaceAllString(m.Text, "${Guild1}") cwm.WinUser = r.ReplaceAllString(m.Text, "${Duelist1}") cwm.WinLife, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Life1}"), 10, 64) cwm.LossCastle = r.ReplaceAllString(m.Text, "${Castle2}") cwm.LossGuild = r.ReplaceAllString(m.Text, "${Guild2}") cwm.LossUser = r.ReplaceAllString(m.Text, "${Duelist2}") cwm.LossLife, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Life2}"), 10, 64) } else { cwm.LossCastle = r.ReplaceAllString(m.Text, "${Castle1}") cwm.LossGuild = r.ReplaceAllString(m.Text, "${Guild1}") cwm.LossUser = r.ReplaceAllString(m.Text, "${Duelist1}") cwm.LossLife, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Life1}"), 10, 64) cwm.WinCastle = r.ReplaceAllString(m.Text, "${Castle2}") cwm.WinGuild = r.ReplaceAllString(m.Text, "${Guild2}") cwm.WinUser = r.ReplaceAllString(m.Text, "${Duelist2}") cwm.WinLife, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Life2}"), 10, 64) } cwm.Weapon = r.ReplaceAllString(m.Text, "${Weapon}") return &cwm, nil } func parseSubTypeMessageTimeAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageTimeAck, error) { cwm := ChatWarsMessageTimeAck{} t, err := fromChatWarsDate(r.ReplaceAllString(m.Text, "${Day}") + " " + r.ReplaceAllString(m.Text, "${Month}") + " " + r.ReplaceAllString(m.Text, "${Year}") + " " + r.ReplaceAllString(m.Text, "${Hour}") + ":" + r.ReplaceAllString(m.Text, "${Minute}")) logOnError(err, "parseSubTypeMessageTimeAck : fromChatWarsDate") cwm.RealTime = t cwm.TimeOfDay = r.ReplaceAllString(m.Text, "${Time}") cwm.Hour, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Hour}"), 10, 64) cwm.Minute, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Minute}"), 10, 64) cwm.Day, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Day}"), 10, 64) cwm.Month = int64(chatWarsMonth[r.ReplaceAllString(m.Text, "${Month}")]) cwm.Year, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Year}"), 10, 64) cwm.Weather = r.ReplaceAllString(m.Text, "${Weather}") cwm.WeatherNext = r.ReplaceAllString(m.Text, "${WeatherNext}") return &cwm, nil } func parseSubTypeMessageQuestResultAmbush(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageQuestResultAmbush, error) { var lvlSum, qtySum int64 cwm := ChatWarsMessageQuestResultAmbush{} re := regexp.MustCompile(`([0-9]){0,1}( x ){0,1}([a-zA-Z ]*) lvl\.([0-9]*)`) for _, l := range re.FindAllStringSubmatch(r.ReplaceAllString(m.Text, "${Monsters}"), -1) { log.Printf("parseSubTypeMessageQuestResultAmbush : %s\n", l[1]) log.Printf("parseSubTypeMessageQuestResultAmbush : %s\n", l[2]) log.Printf("parseSubTypeMessageQuestResultAmbush : %s\n", l[3]) log.Printf("parseSubTypeMessageQuestResultAmbush : %s\n", l[4]) qty, _ := strconv.ParseInt(l[1], 10, 64) log.Printf("parseSubTypeMessageQuestResultAmbush : qty : %d\n", qty) if qty == 0 { qty = 1 } lvl, _ := strconv.ParseInt(l[4], 10, 64) log.Printf("parseSubTypeMessageQuestResultAmbush : lvl : %d\n", lvl) lvlSum = lvlSum + lvl qtySum = qtySum + qty } cwm.Level = lvlSum / qtySum cwm.Msg = m log.Printf("parseSubTypeMessageQuestResultAmbush : Level : %d\n", cwm.Level) return &cwm, nil } func parseSubTypeMessagePillageInc(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessagePillageInc, error) { cwm := ChatWarsMessagePillageInc{} cwm.Attacker = r.ReplaceAllString(m.Text, "${Attacker}") cwm.Castle = r.ReplaceAllString(m.Text, "${Castle}") cwm.Guild = r.ReplaceAllString(m.Text, "${Guild}") return &cwm, nil } func parseSubTypeMessageJobGWithdrawAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageJobGWithdrawAck, error) { cwm := ChatWarsMessageJobGWithdrawAck{} cwm.Ref = r.ReplaceAllString(m.Text, "${Ref}") cwm.Msg = m return &cwm, nil }