//TickWorker pushUpdate;
public SongChangedEvent(string sitePath, MainBot bot) : base(sitePath)
{
playMgr = bot.PlayManager;
audio = bot.PlayerConnection;
playListMgr = bot.PlaylistManager;
playMgr.AfterResourceStarted += Audio_OnResourceStarted;
//pushUpdate = TickPool.RegisterTick(InvokeEvent, TimeSpan.FromSeconds(5), true);
}
public void Dispose()
{
Log.Write(Log.Level.Info, "Closing Mediaplayer...");
if (playerConnection != null)
{
Stop(false);
playerConnection.Dispose();
playerConnection = null;
}
}
// Audioframework
/// <summary>Creates a new AudioFramework</summary>
/// <param name="afd">Required initialization data from a ConfigFile interpreter.</param>
public AudioFramework(AudioFrameworkData afd, IPlayerConnection audioBackEnd)
{
if (audioBackEnd == null)
{
throw new ArgumentNullException(nameof(audioBackEnd));
}
audioBackEnd.OnSongEnd += (s, e) => OnResourceEnd(true);
audioFrameworkData = afd;
playerConnection = audioBackEnd;
playerConnection.Initialize();
}
// Audioframework
/// <summary>Creates a new AudioFramework</summary>
/// <param name="afd">Required initialization data from a ConfigFile interpreter.</param>
internal AudioFramework(AudioFrameworkData afd, IPlayerConnection audioBackEnd, PlaylistManager playlistMgr)
{
if (audioBackEnd == null)
{
throw new ArgumentNullException(nameof(audioBackEnd));
}
if (audioBackEnd.SupportsEndCallback)
{
audioBackEnd.OnSongEnd += (s, e) => OnSongEnd();
}
else
{
waitEndTick = TickPool.RegisterTick(NotifyEnd, SongEndTimeoutInterval, false);
}
audioFrameworkData = afd;
playerConnection = audioBackEnd;
playerConnection.Initialize();
PlaylistManager = playlistMgr;
}
public static bool HandoverSlot(IPlayerConnection src, ClientConnection dst)
{
var conn = src as ClientConnection;
int id = conn.SlotIndex;
if (id < 0 || id > MAX_SLOTS)
{
return(false);
}
lock (syncRoot)
{
handovers[id] = dst;
// in case the connection dies during the operation
if (conn.SlotIndex != id)
{
handovers[id] = null;
return(false);
}
}
return(true);
}
public static bool HandoverSlot(IPlayerConnection src, ClientConnection dst)
{
var conn = src as ClientConnection;
int id = conn.SlotIndex;
if (id < 0 || id > MAX_SLOTS) return false;
lock (syncRoot)
{
handovers[id] = dst;
// in case the connection dies during the operation
if (conn.SlotIndex != id)
{
handovers[id] = null;
return false;
}
}
return true;
}
// Audioframework
/// <summary>Creates a new AudioFramework</summary>
/// <param name="afd">Required initialization data from a ConfigFile interpreter.</param>
internal AudioFramework(AudioFrameworkData afd, IPlayerConnection audioBackEnd, PlaylistManager playlistMgr)
{
if (audioBackEnd == null)
throw new ArgumentNullException(nameof(audioBackEnd));
if (audioBackEnd.SupportsEndCallback)
audioBackEnd.OnSongEnd += (s, e) => OnSongEnd();
else
waitEndTick = TickPool.RegisterTick(NotifyEnd, SongEndTimeoutInterval, false);
audioFrameworkData = afd;
playerConnection = audioBackEnd;
playerConnection.Initialize();
PlaylistManager = playlistMgr;
}
private void DoTradeAction(IPlayerConnection connection, bool isHasPrivilage, PlayerStatus status,
List<PlayerStatus> opponents, PlayerController controller)
{
var goodsForTrade = connection.SelectGoodsToTrade(isHasPrivilage, status, _mainBoardController.Status,
opponents);
if (goodsForTrade.HasValue)
{
controller.DoTradeAction(goodsForTrade.Value, isHasPrivilage);
}
}
private void DoBuilderAction(IPlayerConnection connection, bool isHasPrivilage, PlayerStatus status,
MainBoardStatus board, List<PlayerStatus> opponents, PlayerController controller)
{
var isSuccessfull = false;
IBuilding selectedBuilding = null;
while (!isSuccessfull)
{
var building = connection.SelectBuildingToBuild(isHasPrivilage, status, board,
opponents);
isSuccessfull = controller.DoSelectBuildingToBuild(building, isHasPrivilage);
if (isSuccessfull && building != null)
{
selectedBuilding = status.Board.Buildings.Single(x => x.GetType() == building.GetType());
}
}
if (selectedBuilding == null)
{
return;
}
var param = new BuilderParameters();
status.Board.Buildings.OfType<BuildingBase<BuilderParameters>>().Where(x=>x.IsActive).ToList().ForEach(x=>x.DoAction(ref param));
if (param.TakeAdditionalColonist && board.Colonists.CurrentColonistsCount > 0)
{
var isTakeAdditionalColonist = connection.IsTakeAdditionalColonist(isHasPrivilage, status, board,
opponents);
if (isTakeAdditionalColonist)
{
board.Colonists.Move(selectedBuilding);
}
}
}
private void DoMayorAction(bool isHasPrivilage, IPlayerConnection connection, PlayerStatus status,
List<PlayerStatus> opponents,
PlayerController controller)
{
if (isHasPrivilage)
{
var usePrivilage = connection.IsUsePrivilage(status, _mainBoardController.Status,
opponents);
controller.DoMayorActionTakeAdditionalColinists(usePrivilage);
}
Func<MoveDirection> moveDirectionAction =
() => connection.MoveColonist(isHasPrivilage, status, _mainBoardController.Status,
opponents);
var moveDirection = moveDirectionAction();
while (moveDirection != null)
{
controller.DoMoveColonistAction(moveDirection);
moveDirection = moveDirectionAction();
}
}
private void DoSettlerAction(IPlayerConnection connection, bool isHasPrivilage, PlayerStatus status,
List<PlayerStatus> opponents, PlayerController controller)
{
var islandObjects = connection.SelectISlandObjects(isHasPrivilage, status, _mainBoardController.Status,
opponents);
controller.DoSettlerAction(islandObjects.ToList(), isHasPrivilage);
}
private void DoCraftsmanAction(IPlayerConnection currentConnection, PlayerController currentPlayerController,
MainBoardStatus boardStatus, IEnumerable<PlayerStatus> currentOpponents, PlayerStatus currentPlayerStatus)
{
var players = GeneratePlayersOrder(_governor);
foreach (var player in players)
{
var status = _players[player].Status;
var param = new CraftsmanParameters();
status.Board.Buildings.OfType<GoodsFactoryBase>().ToList().ForEach(x => x.DoAction(ref param));
var plantations =
status.Board.Plantations.Where(x => x.IsActive).Select(x => x.Type).GroupBy(x => x);
var production = plantations.ToDictionary(plantation => plantation.Key,
plantation => Math.Min(plantation.Count(), param.GoodsProduction[plantation.Key]));
currentPlayerController.DoCraftsmanAction(production);
}
var additionalGoods = currentConnection.SelectAdditionalGoods(currentPlayerStatus, boardStatus,
currentOpponents);
currentPlayerController.DoCraftsmanActionReceiveAdditionalGoods(additionalGoods);
}
private void DoCaptainAction(PlayerStatus status, IPlayerConnection connection, PlayerController controller,
bool isHasPrivilage, List<PlayerStatus> opponents)
{
var goodsToShip = connection.SelectGoodsToShip(status, _mainBoardController.Status, opponents);
controller.DoCaptainAction(goodsToShip);
}
public Player(PlayerData data, IPlayerConnection connection)
{
PlayerData = data;
Connection = connection;
RoundStatus = new PlayerRoundStatus();
}
public E <string> InitializeBot()
{
Log.Info("Bot \"{0}\" connecting to \"{1}\"", config.Name, config.Connect.Address);
// Registering config changes
config.Language.Changed += (s, e) =>
{
var langResult = LocalizationManager.LoadLanguage(e.NewValue, true);
if (!langResult.Ok)
{
Log.Error("Failed to load language file ({0})", langResult.Error);
}
};
config.Events.IdleTime.Changed += (s, e) => EnableIdleTickWorker();
config.Events.OnIdle.Changed += (s, e) => EnableIdleTickWorker();
var builder = new DependencyBuilder(Injector);
builder.AddModule(this);
builder.AddModule(config);
builder.AddModule(Injector);
builder.AddModule(config.Playlists);
builder.RequestModule <PlaylistIO>();
builder.RequestModule <PlaylistManager>();
builder.AddModule(Id);
builder.AddModule(new Ts3FullClient());
builder.RequestModule <Ts3BaseFunctions, Ts3FullClient>();
builder.RequestModule <Ts3Client>();
builder.RequestModule <IPlayerConnection, Ts3Client>();
builder.RequestModule <SessionManager>();
if (config.History.Enabled)
{
builder.AddModule(config.History);
builder.RequestModule <HistoryManager>();
}
builder.RequestModule <PlayManager>();
if (!builder.Build())
{
Log.Error("Missing bot module dependency");
return("Could not load all bot modules");
}
tsFullClient = Injector.GetModule <Ts3FullClient>();
clientConnection = Injector.GetModule <Ts3Client>();
playerConnection = clientConnection;
Injector.AddModule <IVoiceTarget>(clientConnection.TargetPipe);
Injector.AddModule(tsFullClient.Book);
playManager = Injector.GetModule <PlayManager>();
targetManager = Injector.GetModule <IVoiceTarget>();
sessionManager = Injector.GetModule <SessionManager>();
playerConnection.OnSongEnd += playManager.SongStoppedEvent;
playerConnection.OnSongUpdated += (s, e) => playManager.Update(e);
// Update idle status events
playManager.BeforeResourceStarted += (s, e) => DisableIdleTickWorker();
playManager.AfterResourceStopped += (s, e) => EnableIdleTickWorker();
// Used for the voice_mode script
playManager.BeforeResourceStarted += BeforeResourceStarted;
// Update the own status text to the current song title
playManager.AfterResourceStarted += LoggedUpdateBotStatus;
playManager.AfterResourceStopped += LoggedUpdateBotStatus;
playManager.OnResourceUpdated += LoggedUpdateBotStatus;
// Log our resource in the history
if (Injector.TryGet <HistoryManager>(out var historyManager))
{
playManager.AfterResourceStarted += (s, e) => historyManager.LogAudioResource(new HistorySaveData(e.PlayResource.BaseData, e.Invoker.ClientUid));
}
// Update our thumbnail
playManager.AfterResourceStarted += GenerateStatusImage;
playManager.AfterResourceStopped += GenerateStatusImage;
// Register callback for all messages happening
clientConnection.OnMessageReceived += OnMessageReceived;
// Register callback to remove open private sessions, when user disconnects
tsFullClient.OnEachClientLeftView += OnClientLeftView;
clientConnection.OnBotConnected += OnBotConnected;
clientConnection.OnBotDisconnect += OnBotDisconnect;
// Restore all alias from the config
foreach (var alias in config.Commands.Alias.GetAllItems())
{
commandManager.RegisterAlias(alias.Key, alias.Value).UnwrapToLog(Log);
}
// Connect the query after everyting is set up
return(clientConnection.Connect());
}
public WebPlayControls(string sitePath, MainBot bot) : base(sitePath)
{
audio = bot.PlayerConnection;
playMgr = bot.PlayManager;
}
public Player(PlayerData data, IPlayerConnection connection)
{
PlayerData = data;
Connection = connection;
RoundStatus = new PlayerRoundStatus();
}
public void Dispose()
{
Log.Write(Log.Level.Info, "Closing Mediaplayer...");
Stop(false);
if (playerConnection != null)
{
playerConnection.Dispose();
playerConnection = null;
Log.Write(Log.Level.Debug, "AF playerConnection disposed");
}
}
