private void OnStreamEntryAdded(StreamEntry entry)
{
AllianceStreamEntryMessage allianceStreamEntryMessage = new AllianceStreamEntryMessage();
allianceStreamEntryMessage.SetStreamEntry(entry);
this.SendPiranhaMessage(allianceStreamEntryMessage, 1);
}
public static void Create(LogicLong ownerId, StreamEntry entry)
{
StreamDocument streamDocument = new StreamDocument(StreamManager.GetNextStreamId(), ownerId, entry);
StreamManager.m_allianceStreams.Add(streamDocument.Id, streamDocument);
StreamManager.Save(streamDocument);
}
internal void AddEntry(StreamEntry StreamEntry)
{
StreamEntry.LowId = Interlocked.Increment(ref this.Seed);
if (this.Slots.TryAdd(StreamEntry.StreamID, StreamEntry))
{
if (this.Slots.Count > 50)
{
if (this.Slots.TryRemove(this.Slots.Keys.First(), out StreamEntry Removed))
{
this.RemoveEntry(Removed);
}
}
foreach (Player Player in this.Alliance.Members.Connected.Values.ToArray())
{
if (Player.Connected)
{
new Alliance_Stream_Entry_Message(Player.Level.GameMode.Device, StreamEntry).Send();
}
else
{
this.Alliance.Members.Connected.TryRemove(Player.PlayerID, out _);
}
}
}
}
public byte[] GetResource(ResourceKey key)
{
if (this._Entries.ContainsKey(key) == false)
{
throw new KeyNotFoundException();
}
if (this._Entries[key] is StreamEntry)
{
StreamEntry entry = (StreamEntry)this._Entries[key];
this.Stream.Seek(this.BaseOffset + entry.Offset, SeekOrigin.Begin);
byte[] data;
if (entry.Compressed == true)
{
data = this.Stream.RefPackDecompress(entry.CompressedSize, entry.DecompressedSize);
}
else
{
data = new byte[entry.DecompressedSize];
this.Stream.Read(data, 0, data.Length);
}
return(data);
}
else if (this._Entries[key] is MemoryEntry)
{
return((byte[])(((MemoryEntry)this._Entries[key]).Data.Clone()));
}
else
{
throw new InvalidOperationException();
}
}
public static Event ToEvent(StreamEntry storeEvent)
{
var type = Type.GetType(storeEvent.Values.First(x => x.Name == "type").Value);
var json = Encoding.UTF8.GetString((byte[])storeEvent.Values.First(x => x.Name == "msg").Value);
return((Event)JsonConvert.DeserializeObject(json, type));
}
private async Task Handle(StreamEntry streamEntry, JobData jobData)
{
//JobData jobData = ParseJobData(streamEntry);
if (jobData == null)
{
return;
}
if (!string.IsNullOrEmpty(jobData.ErrorGroup) && _groupName != jobData.ErrorGroup) //是出错的任务需要重试，但不是该组的不处理
{
return;
}
var isSuccess = await HandleMessage(jobData);
if (!isSuccess && jobData.ErrorCount < _options.MaxErrorReTryCount) //需要重试
{
var delaySecond = GetDelaySecond(jobData.ErrorCount);
jobData.ErrorCount++;
jobData.ErrorGroup = _groupName;
await _redisStorage.EnqueueDealy(jobData, TimeSpan.FromSeconds(delaySecond));
_logger.LogInformation($"RedisMessageBus消费失败,topic:{jobData.Topic},{delaySecond}秒后将进行{jobData.ErrorCount }次重试");
}
}
private static void OnAllianceRequestAllianceUnitsMessageReceived(AllianceRequestAllianceUnitsMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.DONATE && streamEntry.GetSenderAvatarId().Equals(memberEntry.GetAvatarId()))
{
alliance.RemoveStreamEntry(streamEntry.GetId());
}
}
DonateStreamEntry donateStreamEntry = new DonateStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(donateStreamEntry, memberEntry);
string donateMessage = message.Message;
if (donateMessage.Length > 128)
{
donateMessage = donateMessage.Substring(0, 128);
}
donateStreamEntry.SetMessage(donateMessage);
donateStreamEntry.SetCasteLevel(message.CastleUpgradeLevel, message.CastleUsedCapacity, message.CastleSpellUsedCapacity, message.CastleTotalCapacity, message.CastleSpellTotalCapacity);
StreamManager.Create(alliance.Id, donateStreamEntry);
alliance.AddStreamEntry(donateStreamEntry);
AllianceManager.Save(alliance);
}
}
private void OnStartFriendlyChallengeSpectateMessageReceived(StartFriendlyChallengeSpectateMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicLong streamId = message.GetStreamId();
if (alliance.StreamEntryList.IndexOf(streamId) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE)
{
ChallengeStreamEntry challengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (challengeStreamEntry.IsStarted() && challengeStreamEntry.GetLiveReplayId() != null)
{
this.m_session.SendMessage(new GameSpectateLiveReplayMessage
{
LiveReplayId = challengeStreamEntry.GetLiveReplayId(),
IsEnemy = false
}, 9);
return;
}
}
}
}
LiveReplayFailedMessage liveReplayFailedMessage = new LiveReplayFailedMessage();
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(liveReplayFailedMessage, 1);
}
private void OnCancelChallengeMessageReceived(CancelChallengeMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
AllianceMemberEntry memberEntry = alliance.Members[this.m_session.AccountId];
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE && streamEntry.GetSenderAvatarId().Equals(memberEntry.GetAvatarId()))
{
ChallengeStreamEntry prevChallengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (prevChallengeStreamEntry.IsStarted())
{
return;
}
alliance.RemoveStreamEntry(streamEntry.GetId());
}
}
}
}
internal async void Process()
{
try
{
Alliance a = ObjectManager.GetAlliance(this.Device.Player.Avatar.AllianceId);
StreamEntry s = a.m_vChatMessages.Find(c => c.SenderID == this.Device.Player.Avatar.AllianceId && c.GetStreamEntryType() == 12);
if (s != null)
{
a.m_vChatMessages.RemoveAll(t => t == s);
foreach (AllianceMemberEntry op in a.GetAllianceMembers())
{
Level player = await ResourcesManager.GetPlayer(op.AvatarId);
if (player.Client != null)
{
new AllianceStreamEntryRemovedMessage(Device, s.ID).Send();
}
}
}
else
{
new OutOfSyncMessage(this.Device).Send();
}
} catch (Exception) { }
}
private void OnDonateAllianceUnitMessageReceived(DonateAllianceUnitMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicCombatItemData unitData = message.GetAllianceUnitData();
if (!unitData.IsDonationDisabled())
{
if (message.UseQuickDonate())
{
if (!LogicDataTables.GetGlobals().EnableQuickDonate() || this.m_session.LogicClientAvatar.GetDiamonds() < unitData.GetDonateCost())
{
return;
}
}
else
{
if (this.m_session.LogicClientAvatar.GetUnitCount(unitData) <= 0)
{
return;
}
}
if (alliance.StreamEntryList.IndexOf(message.GetStreamId()) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.DONATE)
{
DonateStreamEntry donateStreamEntry = (DonateStreamEntry)streamEntry;
if (donateStreamEntry.CanAddDonation(this.m_session.AccountId, message.GetAllianceUnitData(), alliance.Header.GetAllianceLevel()))
{
donateStreamEntry.AddDonation(this.m_session.AccountId, unitData, this.m_session.LogicClientAvatar.GetUnitUpgradeLevel(unitData));
donateStreamEntry.SetDonationPendingRequestCount(donateStreamEntry.GetDonationPendingRequestCount() + 1);
StreamManager.Save(donateStreamEntry);
alliance.UpdateStreamEntry(donateStreamEntry);
if (message.UseQuickDonate())
{
this.m_session.LogicClientAvatar.CommodityCountChangeHelper(0, unitData, -1);
}
LogicDonateAllianceUnitCommand logicDonateAllianceUnitCommand = new LogicDonateAllianceUnitCommand();
logicDonateAllianceUnitCommand.SetData(unitData, streamEntry.GetId(), message.UseQuickDonate());
ServerMessageManager.SendMessage(new GameAllowServerCommandMessage
{
AccountId = this.m_session.AccountId,
ServerCommand = logicDonateAllianceUnitCommand
}, 9);
}
}
}
}
}
}
public static void SetSenderInfo(StreamEntry entry, AllianceMemberEntry member)
{
entry.SetSenderAvatarId(member.GetAvatarId());
entry.SetSenderHomeId(member.GetHomeId());
entry.SetSenderName(member.GetName());
entry.SetSenderLevel(member.GetExpLevel());
entry.SetSenderLeagueType(member.GetLeagueType());
entry.SetSenderRole(member.GetAllianceRole());
}
static Event ToEvent(StreamEntry storeEvent)
{
var typeString = storeEvent.Values.First(x => x.Name == "type").Value;
var type = Type.GetType(typeString) ?? throw new InvalidCastException($"cannot convert message {typeString}");
var json = Encoding.UTF8.GetString(storeEvent.Values.First(x => x.Name == "msg").Value);
var evnt = JsonConvert.DeserializeObject(json, type) ?? throw new InvalidCastException($"cannot convert message {typeString}");
return((Event)evnt);
}
public StreamDocument(LogicLong id, LogicLong ownerId, StreamEntry entry) : base(id)
{
this.CreateTime = DateTime.UtcNow;
this.OwnerId = ownerId;
this.Type = StreamType.ALLIANCE;
this.Entry = entry;
entry.SetId(id);
}
internal void Remove(StreamEntry StreamEntry)
{
StreamEntry Removed;
if (this.Slots.TryRemove(StreamEntry.StreamId, out Removed))
{
this.RemoveEntry(Removed);
}
}
public static void SetSenderInfo(StreamEntry entry, LogicClientAvatar avatar)
{
entry.SetSenderAvatarId(avatar.GetId());
entry.SetSenderHomeId(avatar.GetCurrentHomeId());
entry.SetSenderName(avatar.GetName());
entry.SetSenderLevel(avatar.GetExpLevel());
entry.SetSenderLeagueType(avatar.GetLeagueType());
entry.SetSenderRole(avatar.GetAllianceRole());
}
internal async Task <EventData <T> > LoadAggregateEventAsync(StreamEntry entry)
{
var db = _connectionMultiplexer.GetDatabase();
string stream = entry.Values[0].Value;
string eventId = entry.Values[1].Value;
var events = await db.StreamRangeAsync(stream, eventId, eventId);
return(DeserializeEvent(eventId, events[0].Values[0].Value));
}
/// <summary>
/// Adds a new entry in the collection.
/// </summary>
public void AddEntry(StreamEntry Entry)
{
Entry.HighId = Config.ServerId;
Entry.LowId = Interlocked.Increment(ref this.Seed);
if (this.Entries.Count > Config.MaxChatEntries)
{
this.RemoveEntry(this.Entries.Values.First()); // TODO : Not wise, performance side
}
this.Entries.Add(Entry.StreamId, Entry);
}
internal async void Process()
{
try
{
if (this.Device.PlayerState == Logic.Enums.State.IN_BATTLE)
{
ResourcesManager.DisconnectClient(Device);
}
else
{
if (ID > 0)
{
this.Device.PlayerState = Logic.Enums.State.IN_BATTLE;
Alliance a = ObjectManager.GetAlliance(this.Device.Player.Avatar.AllianceId);
Level defender = await ResourcesManager.GetPlayer(a.m_vChatMessages.Find(c => c.ID == ID).SenderID);
if (defender != null)
{
defender.Tick();
new ChallangeAttackDataMessage(Device, defender).Send();
}
else
{
new OwnHomeDataMessage(Device, this.Device.Player).Send();
}
Alliance alliance = ObjectManager.GetAlliance(this.Device.Player.Avatar.AllianceId);
StreamEntry s = alliance.m_vChatMessages.Find(c => c.m_vType == 12);
if (s != null)
{
alliance.m_vChatMessages.RemoveAll(t => t == s);
foreach (AllianceMemberEntry op in alliance.GetAllianceMembers())
{
Level playera = await ResourcesManager.GetPlayer(op.AvatarId);
if (playera.Client != null)
{
new AllianceStreamEntryMessage(playera.Client)
{
StreamEntry = s
}.Send();
}
}
}
}
else
{
new OutOfSyncMessage(this.Device).Send();
}
}
} catch (Exception) { }
}
/// <summary>
/// Updates the specified entry.
/// </summary>
internal void UpdateEntry(StreamEntry Entry)
{
if (this.Slots.ContainsKey(Entry.StreamID))
{
foreach (Player Player in this.Alliance.Members.Connected.Values.ToArray())
{
if (Player.Connected)
{
// TODO Implement AllianceStreamEntryMessage().
}
}
}
}
public override void WriteJson(JsonWriter Writer, object Value, JsonSerializer Serializer)
{
StreamEntry StreamEntry = (StreamEntry)Value;
if (StreamEntry != null)
{
StreamEntry.Save().WriteTo(Writer);
}
else
{
Writer.WriteNull();
}
}
public override object ReadJson(JsonReader Reader, Type ObjectType, object ExistingValue, JsonSerializer Serializer)
{
JObject Json = JObject.Load(Reader);
if (JsonHelper.GetJsonNumber(Json, "type", out int Type))
{
StreamEntry Entry = StreamEntryFactory.CreateStreamEntryByType(Type);
Entry.Load(Json);
return(Entry);
}
return(null);
}
/// <summary>
/// Decodes this instance.
/// </summary>
public override void Decode()
{
this.Entries = new StreamEntry[this.Stream.ReadVInt()];
for (int i = 0; i < this.Entries.Length; i++)
{
int EntryType = this.Stream.ReadVInt();
StreamEntry Entry = new StreamEntry();
Entry.Decode(this.Stream);
this.Entries[i] = Entry;
}
}
protected sealed override void Save(LogicJSONObject jsonObject)
{
LogicJSONArray ownerIdArray = new LogicJSONArray(2);
ownerIdArray.Add(new LogicJSONNumber(this.OwnerId.GetHigherInt()));
ownerIdArray.Add(new LogicJSONNumber(this.OwnerId.GetLowerInt()));
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_OWNER_ID, ownerIdArray);
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_CREATE_TIME, new LogicJSONString(this.CreateTime.ToString("O")));
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_TYPE, new LogicJSONNumber((int)this.Type));
switch (this.Type)
{
case StreamType.ALLIANCE:
{
LogicJSONObject entryObject = new LogicJSONObject();
StreamEntry entry = (StreamEntry)this.Entry;
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_ENTRY_TYPE, new LogicJSONNumber((int)entry.GetStreamEntryType()));
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_ENTRY, entryObject);
entry.Save(entryObject);
break;
}
case StreamType.AVATAR:
{
LogicJSONObject entryObject = new LogicJSONObject();
AvatarStreamEntry entry = (AvatarStreamEntry)this.Entry;
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_ENTRY_TYPE, new LogicJSONNumber((int)entry.GetAvatarStreamEntryType()));
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_ENTRY, entryObject);
entry.Save(entryObject);
break;
}
case StreamType.REPLAY:
{
LogicJSONObject entryObject = new LogicJSONObject();
ReplayStreamEntry entry = (ReplayStreamEntry)this.Entry;
jsonObject.Put(StreamDocument.JSON_ATTRIBUTE_ENTRY, entryObject);
entry.Save(entryObject);
break;
}
}
}
private JobData ParseJobData(StreamEntry streamEntry)
{
JobData jobData = null;
try
{
jobData = JobData.ToJobData(streamEntry.Values);
}
catch (Exception ex)
{
_logger.LogError(ex, $"RedisMessageBus解析任务数据报错{_topic},{_groupName}");
}
return(jobData);
}
internal void RemoveEntry(StreamEntry StreamEntry)
{
foreach (Player Player in this.Alliance.Members.Connected.Values.ToArray())
{
if (Player.Connected)
{
new Alliance_Stream_Entry_Removed_Message(Player.Level.GameMode.Device, StreamEntry).Send();
}
else
{
this.Alliance.Members.Connected.TryRemove(Player.PlayerID, out _);
}
}
}
internal StreamInfo(int length,
int radixTreeKeys,
int radixTreeNodes,
int groups,
StreamEntry firstEntry,
StreamEntry lastEntry)
{
Length = length;
RadixTreeKeys = radixTreeKeys;
RadixTreeNodes = radixTreeNodes;
ConsumerGroupCount = groups;
FirstEntry = firstEntry;
LastEntry = lastEntry;
}
private async Task HandleWrap(StreamEntry streamEntry, JobData jobData)
{
try
{
await Handle(streamEntry, jobData);
}
catch (Exception ex)
{
_logger.LogError(ex, $"RedisMessageBus消费失败,topic:{_topic}，groupName:{_groupName}");
}
finally
{
await _database.StreamAcknowledgeAsync(_topic, _groupName, streamEntry.Id);
}
}
public void AddStreamEntry(StreamEntry entry)
{
if (entry.GetId().IsZero())
{
throw new Exception("Alliance.addStreamEntry: id should be set!");
}
while (this.StreamEntryList.Size() >= Alliance.MAX_STREAM_ENTRY_COUNT)
{
this.RemoveStreamEntry(this.StreamEntryList[0]);
}
this.StreamEntryList.Add(entry.GetId());
this.OnStreamEntryAdded(entry);
}
public byte[] GetRawResource(ResourceKey key)
{
if (this._Entries.ContainsKey(key) == false || !(this._Entries[key] is StreamEntry))
{
throw new KeyNotFoundException();
}
StreamEntry entry = (StreamEntry)this._Entries[key];
this.Stream.Seek(this.BaseOffset + entry.Offset, SeekOrigin.Begin);
byte[] data = new byte[entry.CompressedSize];
this.Stream.Read(data, 0, data.Length);
return(data);
}
