// only used for deserializing
public XSID(InternalPlayer player, BinaryReader reader, EventList events)
: base()
{
this.events = events;
this.m_player = player;
LoadFromReader(player.m_scheduler, reader);
if (xsidEvent_id == -1)
{
xsidEvent = null;
}
else
{
xsidEvent = events.GetEventById(xsidEvent_id) as xSIDEvent;
#if DEBUG
if (xsidEvent == null)
{
throw new Exception("XSID: xSIDEvent not found");
}
#endif
}
}
public TwoPlayersTexasHoldemGame(IPlayer firstPlayer, IPlayer secondPlayer, int initialMoney = 1000)
{
if (firstPlayer == null)
{
throw new ArgumentNullException(nameof(firstPlayer));
}
if (secondPlayer == null)
{
throw new ArgumentNullException(nameof(secondPlayer));
}
if (initialMoney <= 0 || initialMoney > 200000)
{
throw new ArgumentOutOfRangeException(nameof(initialMoney), "Initial money should be greater than 0 and less than 200000");
}
// Ensure the players have unique names
if (firstPlayer.Name == secondPlayer.Name)
{
throw new ArgumentException($"Both players have the same name: \"{firstPlayer.Name}\"");
}
this.firstPlayer = new InternalPlayer(firstPlayer);
this.secondPlayer = new InternalPlayer(secondPlayer);
this.allPlayers = new List<InternalPlayer> { this.firstPlayer, this.secondPlayer };
this.initialMoney = initialMoney;
this.HandsPlayed = 0;
}
// only used for deserializing
public EventScheduler(InternalPlayer player, BinaryReader reader, int id)
: base(string.Empty)
{
m_id = id;
m_player = player;
LoadFromReader(reader);
}
public SID6526(InternalPlayer player)
{
m_player = player;
m_eventContext = m_player.m_scheduler;
m_phase = event_phase_t.EVENT_CLOCK_PHI1;
rnd = 0;
m_taEvent = new CiaEvent(this);
clock(0xffff);
reset(false);
}
public SID6510(EventScheduler context, InternalPlayer owner, BinaryReader reader, EventList events)
: base(context, owner, reader, events)
{
delayCycle.func = new ProcessorCycle.FunctionDelegate(sid_delay);
if (procCycle_id == 2)
{
procCycle = new ProcessorCycle[] { delayCycle };
}
}
public SID6510(EventScheduler context, InternalPlayer owner)
: base(context, owner)
{
m_mode = SID2Types.sid2_env_t.sid2_envR;
m_framelock = false;
// The hacks for de.quippy.sidplay.sidplay are done with overridden methods of MOS6510
// Used to insert busy delays into the CPU emulation
delayCycle.func = new ProcessorCycle.FunctionDelegate(sid_delay);
}
public void Dispose()
{
Stop();
if (_PlayBuffer != IntPtr.Zero)
{
Marshal.FreeHGlobal(_PlayBuffer);
_PlayBuffer = IntPtr.Zero;
}
_InternalPlayer = null;
}
/// <summary>
/// Start playing the tune with the selected song
/// </summary>
/// <param name="SongNumber">song id (1..count), 0 = default song</param>
public void Start(int SongNumber)
{
if (Stopping)
{
return;
}
if (_CurrentTune == null)
{
return;
}
_WavePlayer = new WaveOut();
WaveFormat fmt = new WaveFormat(_Frequency, 16, 2);
_BufferedWaveProvider = new BufferedWaveProvider(fmt);
_BufferedWaveProvider.BufferDuration = TimeSpan.FromSeconds(2); // allow us to get well ahead of ourselves
_WavePlayer.Init(_BufferedWaveProvider);
_InternalPlayer = new InternalPlayer();
sid2_config_t config = _InternalPlayer.config();
config.frequency = _Frequency;
config.playback = SID2Types.sid2_playback_t.sid2_mono;
config.optimisation = SID2Types.SID2_DEFAULT_OPTIMISATION;
config.sidModel = (SID2Types.sid2_model_t)_CurrentTune.Info.sidModel;
config.clockDefault = SID2Types.sid2_clock_t.SID2_CLOCK_CORRECT;
config.clockSpeed = SID2Types.sid2_clock_t.SID2_CLOCK_CORRECT;
config.clockForced = false;
config.environment = SID2Types.sid2_env_t.sid2_envR;
config.forceDualSids = false;
config.volume = 255;
config.sampleFormat = SID2Types.sid2_sample_t.SID2_LITTLE_SIGNED;
config.sidDefault = SID2Types.sid2_model_t.SID2_MODEL_CORRECT;
config.sidSamples = true;
config.precision = SID2Types.SID2_DEFAULT_PRECISION;
_InternalPlayer.config(config);
_CurrentTune.selectSong(SongNumber);
_InternalPlayer.load(_CurrentTune);
_IsStereo = _CurrentTune.isStereo;
_InternalPlayer.start();
_Thread = new Thread(new ThreadStart(ThreadProc));
_Thread.Start();
}
public XSID(InternalPlayer player, SIDEmu sid)
: base()
{
xsidEvent = new xSIDEvent(this);
ch4 = new Channel("CH4", player.m_scheduler, this);
ch5 = new Channel("CH5", player.m_scheduler, this);
muted = (false);
suppressed = (false);
wasRunning = (false);
sidSamples(true);
m_player = player;
m_sid = sid;
m_gain = 100;
}
// only used for deserializing
public SID6526(InternalPlayer player, BinaryReader reader, EventList events)
{
m_player = player;
m_eventContext = m_player.m_scheduler;
LoadFromReader(reader);
m_taEvent = events.GetEventById(m_taEvent_id) as CiaEvent;
m_taEvent.m_cia = this;
#if DEBUG
if (m_taEvent == null)
{
throw new Exception("SID6526: CiaEvent not found");
}
#endif
}
// Must lock the SID before using the standard functions
/// <summary>
/// Set execution environment and lock sid to it
/// </summary>
/// <param name="player"></param>
/// <returns></returns>
public bool _lock(InternalPlayer player)
{
if (player == null)
{
if (!m_locked)
{
return(false);
}
m_locked = false;
m_context = null;
}
else
{
if (m_locked)
{
return(false);
}
m_locked = true;
m_context = player.m_scheduler;
}
return(true);
}
private PlayerAction DoPlayerAction(InternalPlayer player, PlayerAction action, int maxMoneyPerPlayer)
{
if (action.Type == PlayerActionType.Raise)
{
player.Call(maxMoneyPerPlayer);
if (player.Money <= 0)
{
return PlayerAction.CheckOrCall();
}
foreach (var playerToUpdate in this.allPlayers)
{
playerToUpdate.ShouldPlayInRound = true;
}
// TODO: Min raise?
if (player.Money > action.Money)
{
player.PlaceMoney(action.Money);
}
else
{
// All-in
action.Money = player.Money;
player.PlaceMoney(action.Money);
}
}
else if (action.Type == PlayerActionType.CheckCall)
{
player.Call(maxMoneyPerPlayer);
}
else //// PlayerActionType.Fold
{
player.InHand = false;
}
return action;
}
// only used for deserializing
public C64VIC(InternalPlayer player, BinaryReader reader, int newid)
: base(player.m_scheduler, reader, newid)
{
m_player = player;
}
public C64VIC(InternalPlayer player)
: base(player.m_scheduler)
{
m_player = player;
}
// only used for deserializing
public C64cia1(InternalPlayer player, BinaryReader reader, EventList events)
: base(player.m_scheduler, reader, events)
{
m_player = player;
}
private void Bet(InternalPlayer player, int amount)
{
player.Bet(amount);
this.Pot += amount;
}
// deserializing
protected void LoadFromReader(InternalPlayer player, EventScheduler context, BinaryReader reader)
{
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
int id = reader.ReadInt32();
Event.EventType typ = (Event.EventType)reader.ReadInt16();
switch (typ)
{
case Event.EventType.ciaEvt:
this.Add(new CiaEvent(context, reader, id));
break;
case Event.EventType.cpuEvt:
this.Add(new CPUEvent(context, reader, id));
break;
case Event.EventType.GalwayEvt:
this.Add(new GalwayEvent(context, reader, id));
break;
case Event.EventType.mixerEvt:
this.Add(new EventMixer(player, context, reader, id));
break;
case Event.EventType.RtcEvt:
this.Add(new EventRTC(context, reader, id));
break;
case Event.EventType.SampleEvt:
this.Add(new SampleEvent(context, reader, id));
break;
case Event.EventType.TaEvt:
this.Add(new EventTa(context, reader, id));
break;
case Event.EventType.TbEvt:
this.Add(new EventTb(context, reader, id));
break;
case Event.EventType.TimeWarpEvt:
this.Add(new EventTimeWarp(context, reader, id));
break;
case Event.EventType.TodEvt:
this.Add(new EventTod(context, reader, id));
break;
case Event.EventType.vicEvt:
this.Add(new C64VIC(context.m_player, reader, id));
break;
case Event.EventType.xSidEvt:
this.Add(new xSIDEvent(context, reader, id));
break;
default:
#if DEBUG
throw new Exception("EventList.LoadFromReader: unknown Event id");
#else
break;
#endif
}
}
context.m_next = GetEventById(context.m_next_id);
context.m_prev = GetEventById(context.m_prev_id);
foreach (Event ev in this)
{
ev.m_next = GetEventById(ev.m_next_id, context);
ev.m_prev = GetEventById(ev.m_prev_id, context);
#if DEBUG
if (ev.m_next_id > -1 && ev.m_next == null)
{
throw new Exception("EventList.LoadFromReader: next Event id not found: " + ev.m_next_id.ToString());
}
if (ev.m_prev_id > -1 && ev.m_prev == null)
{
throw new Exception("EventList.LoadFromReader: prev Event id not found: " + ev.m_prev_id.ToString());
}
#endif
}
}
// only used for deserializing
public EventList(InternalPlayer player, EventScheduler context, BinaryReader reader)
: base()
{
LoadFromReader(player, context, reader);
}
// only used for deserializing
public EventMixer(InternalPlayer player, EventScheduler context, BinaryReader reader, int newId)
: base(context, reader, newId)
{
m_player = player;
}
public EventMixer(InternalPlayer player)
: base("Mixer")
{
m_player = player;
}
/// <summary>
/// Inject regular program and set start address
/// </summary>
/// <param name="HexData"></param>
/// <param name="DataStartAddress"></param>
/// <param name="InitialAddress"></param>
/// <returns></returns>
public bool PlayFromBinary(string HexData, int DataStartAddress, int InitialAddress)
{
Stop();
var byteData = StringToByteArrayFastest(HexData);
_CurrentTune = new SidTune();
_CurrentTune.info.loadAddr = DataStartAddress;
_CurrentTune.info.c64dataLen = byteData.Length;
_CurrentTune.info.initAddr = InitialAddress;
_CurrentTune.info.playAddr = InitialAddress;
_CurrentTune.info.compatibility = SidTune.SIDTUNE_COMPATIBILITY_R64;
_CurrentTune.InjectProgramInMemory(byteData, DataStartAddress);
_CurrentTune.status = true;
_WavePlayer = new WaveOut();
WaveFormat fmt = new WaveFormat(_Frequency, 16, 2);
_BufferedWaveProvider = new BufferedWaveProvider(fmt);
_BufferedWaveProvider.BufferDuration = TimeSpan.FromSeconds(2); // allow us to get well ahead of ourselves
_WavePlayer.Init(_BufferedWaveProvider);
_InternalPlayer = new InternalPlayer();
sid2_config_t config = _InternalPlayer.config();
config.frequency = _Frequency;
config.playback = SID2Types.sid2_playback_t.sid2_mono;
config.optimisation = SID2Types.SID2_DEFAULT_OPTIMISATION;
config.sidModel = (SID2Types.sid2_model_t)_CurrentTune.Info.sidModel;
config.clockDefault = SID2Types.sid2_clock_t.SID2_CLOCK_CORRECT;
config.clockSpeed = SID2Types.sid2_clock_t.SID2_CLOCK_CORRECT;
config.clockForced = false;
config.environment = SID2Types.sid2_env_t.sid2_envR;
config.forceDualSids = false;
config.volume = 255;
config.sampleFormat = SID2Types.sid2_sample_t.SID2_LITTLE_SIGNED;
config.sidDefault = SID2Types.sid2_model_t.SID2_MODEL_CORRECT;
config.sidSamples = true;
config.precision = SID2Types.SID2_DEFAULT_PRECISION;
config.environment = SID2Types.sid2_env_t.sid2_envR;
_InternalPlayer.load(_CurrentTune);
_InternalPlayer.config(config);
// inject code
for (int i = 0; i < byteData.Length; ++i)
{
_InternalPlayer.mem_writeMemByte(DataStartAddress + i, byteData[i]);
}
_InternalPlayer.SetCPUPos(InitialAddress);
_IsStereo = _CurrentTune.isStereo;
_InternalPlayer.start();
_Thread = new Thread(new ThreadStart(ThreadProc));
_Thread.Start();
return(true);
}
public C64cia1(InternalPlayer player)
: base(player.m_scheduler)
{
m_player = (player);
}
