public void Mark(SlotState state)
{
if (slotState != SlotState.Empty)
{
return;
}
if (_lastSlotState == state) //can't mark if already played
{
return;
}
slotState = state;
_lastSlotState = state;
gameObject.SetActive(false);
_greenBlock.gameObject.SetActive(false);
if (slotState == SlotState.O)
{
GameObject obj = Instantiate(prefabO);
obj.transform.position = position;
}
else if (slotState == SlotState.X)
{
GameObject obj = Instantiate(prefabX);
obj.transform.position = position;
}
else
{
Debug.LogError("invalid slot value");
}
}
public void SetPowerUpPending()
{
lock (slotLocker)
{
slotState = SlotState.CardPowerUpPending;
}
}
public void Kick(string reason, bool announce = true)
{
if (kicking)
{
return;
}
state = SlotState.KICK;
if (announce)
{
if (assignedSlot >= 0)
{
ProgramLog.Log("{0} @ {1}: disconnecting for: {2}", RemoteAddress, assignedSlot, reason);
var player = Main.player[assignedSlot];
if (player != null)
{
player.DisconnectReason = reason;
}
}
else
{
ProgramLog.Log("{0}: disconnecting for: {1}", RemoteAddress, reason);
}
}
if (!kicking)
{
var msg = NewNetMessage.PrepareThreadInstance();
msg.Disconnect(reason);
KickAfter(msg.Output);
}
}
// Update is called once per frame
void Update()
{
if (isStart)
{
time += Time.deltaTime;
switch (slotState)
{
case SlotState.SpeedUp:
OnSpeedUp(ref time);
break;
case SlotState.Transition:
OnTransition(ref time);
break;
case SlotState.SlowDown:
OnSlowdown();
break;
case SlotState.Return:
break;
case SlotState.End:
isStart = false;
FinishSlotEvent?.Invoke(this);
slotState = SlotState.Default;
break;
}
}
}
/// <summary>
/// Called when the game is ready to start. Can be used to setup the initial game state
/// </summary>
/// <param name="message"></param>
void OnChallengeStarted(ChallengeStartedMessage message)
{
IsChallengeActive = true;
_challengeId = message.Challenge.ChallengeId;
OPlayerName = message.Challenge.Challenger.Name;
OPlayerId = message.Challenge.Challenger.Id;
XPlayerName = message.Challenge.Challenged.First().Name;
XPlayerId = message.Challenge.Challenged.First().Id;
CurrentPlayerId = message.Challenge.NextPlayer == OPlayerId ? OPlayerId: XPlayerId;
string chosenPlayerId = message.Challenge.ScriptData.GetString("chosenPlayerId"); //a player is randomly chosen to make the first move
string chosenPlayerBlock = message.Challenge.ScriptData.GetString("chosenBlockType"); //the block type (X,O) of the chosen player is randomly set
if (chosenPlayerId == UIManager.Instance.LocalPlayerId)
{
LocalSlotType = SlotStateFromString(chosenPlayerBlock);
}
else
{
SlotState chosenBlockState = SlotStateFromString(chosenPlayerBlock);
LocalSlotType = chosenBlockState == SlotState.O ? SlotState.X : SlotState.O;
}
OnChallengeStartedEvent.Invoke();
}
public PieceDestinationControllerImplementation()
{
EMPTY_STATE = new EmptyState();
MOVABLE_STATE = new MovableState();
FIXED_STATE = new FixedState();
SetFixed();
}
public void SetHolderState(int index, SlotState state)
{
Debug.Assert(index > -1 && index < _holderBtnArr.Count);
(_holderBtnArr[index] as HolderButton).State = state;
if (state == SlotState.extracted)
{
(_holderBtnArr[index] as HolderButton).SlotText = "";
_holderBtnArr[index].Text = "";
}
_indexBtn[index].State = state;
if (state == SlotState.extracted)
{
for (int i = index * CupNum; i < (index + 1) * CupNum; i++)
{
CupButton cup = (_cupBtnArr[i] as CupButton);
cup.IsSlotOn = false;
cup.Enabled = false;
cup.State = TestState.Idle;
}
}
else if (state == SlotState.inserted)
{
for (int i = index * CupNum; i < (index + 1) * CupNum; i++)
{
CupButton cup = (_cupBtnArr[i] as CupButton);
cup.IsSlotOn = true;
cup.Enabled = true;
}
}
this.Invalidate();
}
/// <summary>
/// Handles player's input
/// </summary>
private void OnMouseDown()
{
if (!boardManager.canPlay)
{
return;
}
if (currentState != SlotState.Free || boardManager.AIOnly)
{
return;
}
if ((int)boardManager.playersTurn != (int)boardManager.humanPlayer)
{
return;
}
currentState = boardManager.playersTurn == PlayersTurn.X ? SlotState.X : SlotState.O;
if (boardManager.playersTurn == PlayersTurn.O)
{
boardManager.slotsO++;
}
else
{
boardManager.slotsX++;
}
boardManager.SelectSlotHuman(gameObject);
}
// Remove all content from the slot
public void Clear()
{
Content = null;
image.sprite = null;
state = SlotState.Empty;
Refresh();
}
public void ClearSlot()
{
_status = SlotState.Empty;
unitDescription = null;
Destroy(child);
Destroy(classDisplay);
unitDescriptionDisplay.UnselectActualSlot();
}
public void PlaceItem(InventoryItem item)
{
item.transform.SetParent(itemHolder);
item.transform.localPosition = Vector3.zero;
item.transform.localScale = Vector3.one;
this._item = item;
_state = SlotState.Filled;
}
public PieceDestinationControllerImplementation(PieceTranslationController pieceTranslationController)
{
this.pieceTranslationController = pieceTranslationController;
NULL_TRANSLATION_CONTROLLER = new NullPieceTranslationController();
EMPTY_STATE = new EmptyState();
MOVABLE_STATE = new MovableState();
FIXED_STATE = new FixedState();
SetFixed();
}
// Lock the slot
public void Lock()
{
if (state == SlotState.Filled)
{
Clear();
}
state = SlotState.Locked;
Refresh();
}
public void NotifyRemove()
{
lock (slotLocker)
{
slotiInUse = false;
slotState = SlotState.CardAbsent;
}
StateChangedEvent.Set();
ExchangeDoneEvent.Set();
}
public void OnStart()
{
isStart = true;
time = 0;
moveCount = 0;
animationFinishTimes = 0;
tilePool.Reset();
slotState = SlotState.SpeedUp;
startSlotEvent?.Invoke();
}
public void NotifyInsert()
{
lock (slotLocker)
{
if (slotState < SlotState.CardNewlyInserted)
{
slotState = SlotState.CardNewlyInserted;
}
}
}
private bool checkWinSlotState(SlotState state)
{
return(slotStates[0] == slotStates[1] && slotStates[1] == slotStates[2] && slotStates[2] == state ||
slotStates[3] == slotStates[4] && slotStates[4] == slotStates[5] && slotStates[5] == state ||
slotStates[6] == slotStates[7] && slotStates[7] == slotStates[8] && slotStates[8] == state ||
slotStates[0] == slotStates[3] && slotStates[3] == slotStates[6] && slotStates[6] == state ||
slotStates[1] == slotStates[4] && slotStates[4] == slotStates[7] && slotStates[7] == state ||
slotStates[2] == slotStates[5] && slotStates[5] == slotStates[8] && slotStates[8] == state ||
slotStates[0] == slotStates[4] && slotStates[4] == slotStates[8] && slotStates[8] == state ||
slotStates[2] == slotStates[4] && slotStates[4] == slotStates[6] && slotStates[6] == state);
}
private void Awake()
{
if (startsLocked)
{
_status = SlotState.Locked;
lockedImage.gameObject.SetActive(true);
return;
}
Unlock();
}
void OnSpeedUp(ref float time)
{
speed = startAnimation.Evaluate(time);
MoveCell(speed);
Return();
if (time >= startTime)
{
time -= startTime;
slotState = SlotState.Transition;
}
}
public PieceDestinationControllerImplementation(PieceTranslationController pieceTranslationController, GridItemMover slotGridItemMover, WinController winController)
{
this.pieceTranslationController = pieceTranslationController;
this.slotGridItemMover = slotGridItemMover;
this.winController = winController;
//this.grid = grid;
NULL_TRANSLATION_CONTROLLER = new NullPieceTranslationController();
EMPTY_STATE = new EmptyState();
MOVABLE_STATE = new MovableState();
FIXED_STATE = new FixedState();
SetFixed();
}
public void setState(SlotState newState)
{
if (OnSlotStateChangeFrom != null)
{
OnSlotStateChangeFrom(state);
}
state = newState;
if (OnSlotStateChangeTo != null)
{
OnSlotStateChangeTo(newState);
}
}
void OnTransition(ref float time)
{
MoveCell(speed);
Return();
if (time >= transitionTime && isReceivedResult)
{
time -= transitionTime;
slotState = SlotState.SlowDown;
tilePool.RemoveReward();
slowDownEvent?.Invoke();
}
}
public void RemoveMoney()
{
if (slotstt == SlotState.HaveMoney)
{
pool.Despawn(moneys[numberOfMoney - 1], tray.transform);
numberOfMoney -= 1;
if (numberOfMoney == 0)
{
slotstt = SlotState.HaveNoMoney;
}
}
}
void FinishAnimation()
{
animationFinishTimes++;
if (animationFinishTimes == slotList.Count)
{
slotState = SlotState.End;
if (slotList[3].Tile != tilePool.RewardTiles[0] || slotList[4].Tile != tilePool.RewardTiles[1] || slotList[5].Tile != tilePool.RewardTiles[2])
{
Debug.LogError("roatate exception!!!");
}
}
}
// Assign content to the slot
public bool Assign(SlotContent content)
{
if (state == SlotState.Locked)
{
return(false);
}
Content = content;
state = SlotState.Filled;
Refresh();
return(true);
}
void Start()
{
moneyType = pairOnWallet.moneyType;
tray = Tray.Instance;
slotstt = SlotState.HaveNoMoney;
numberOfMoney = 0;
pool = PoolManager.Pools["TrayMoney"];
moneys = new Transform[5];
//InitializeMoney();
}
private void OnSlotStateChangeTo(SlotState state)
{
slot.log ("OnSlotStateChangeTo " + state);
switch (state)
{
case SlotState.playingwins:
break;
case SlotState.ready:
break;
case SlotState.snapping:
break;
case SlotState.spinning:
break;
}
}
public void UpdateState()
{
if (slot.obj == null)
{
state = SlotState.NotLoaded;
}
else if (!slot.boVisible)
{
state = SlotState.Masked;
}
else
{
state = SlotState.Displayed;
}
}
protected virtual void SetUp()
{
mySlotState = SlotState.CARD_SLOT;
rectTransform = GetComponent <RectTransform> ();
cardManager = GameObject.FindGameObjectWithTag("CardManager");
gameManager = GameObject.FindGameObjectWithTag("GameManager");
hud = gameManager.GetComponent <UI_MeterManager> ();
loader = cardManager.GetComponent <UI_CardLoader> ();
cardImage = GetComponent <Image> ();
}
public void RDR_to_PC(CCID.RDR_to_PC_Block block)
{
LastResponse = block;
Logger.Trace("RDR_to_PC>" + BinConvert.ToHex(block.Message) + " " + BinConvert.ToHex(block.Status) + " " + BinConvert.ToHex(block.Error) + " " + BinConvert.ToHex(block.Data));
SlotState localState;
lock (slotLocker)
{
localState = slotState;
}
switch (block.Status & 0x03)
{
case 0:
if ((localState == SlotState.CardPowerUpPending) && (block.Message == CCID.RDR_TO_PC_DATABLOCK))
{
cardAtr = block.Data;
Logger.Trace("Card ATR is " + BinConvert.ToHex(cardAtr));
localState = SlotState.CardPowered;
}
break;
case 1:
localState = SlotState.CardUnpowered;
break;
case 2:
localState = SlotState.CardAbsent;
break;
default:
break;
}
lock (slotLocker)
{
if (localState != slotState)
{
Logger.Trace("New state is " + localState.ToString());
slotState = localState;
}
}
ExchangeDoneEvent.Set();
}
void OnSlowdown()
{
// Move the result one by one to the list by three moves
if (moveCount < 3)
{
MoveCell(speed);
Return();
}
else
{
slotState = SlotState.Return;
foreach (var cell in slotList)
{
iTween.MoveTo(cell.gameObject, iTween.Hash("time", endTime, "position", targetPos[cell.Index], "easetype", easetype, "oncomplete", "FinishAnimation", "oncompletetarget", gameObject, "islocal", false));
}
}
}
public void Kick(string reason)
{
if (state == SlotState.VACANT) return;
Program.tConsole.WriteLine ("{0} @ {1}: disconnecting for: {2}", remoteAddress, whoAmI, reason);
if (state != SlotState.SHUTDOWN)
{
NetMessage.SendData (2, whoAmI, -1, reason);
state = SlotState.KICK;
}
}
public static void SetState(this Terraria.RemoteClient sock, SlotState state)
{
(sock as ServerSlot).state = state;
}
protected override void HandleClosure(SocketError err)
{
state = SlotState.SHUTDOWN;
var slot = Interlocked.Exchange (ref assignedSlot, -2);
if (slot >= 0)
{
ProgramLog.Users.Log ("{0} @ {1}: connection closed ({2}).", RemoteAddress, slot, err);
SlotManager.FreeSlot (slot);
//Netplay.slots[slot].Reset ();
}
else
{
SlotManager.RemoveFromQueues (this);
ProgramLog.Users.Log ("{0}: connection closed ({1}).", RemoteAddress, err);
}
var player = Player;
if (player != null)
{
player.Connection = null;
player.Active = false;
}
FreeSectionBuffer ();
lock (All)
{
if (indexInAll == All.Count - 1)
{
All.RemoveAt (All.Count - 1);
}
else if (indexInAll >= 0)
{
var other = All[All.Count - 1];
other.indexInAll = indexInAll;
All[indexInAll] = other;
All.RemoveAt (All.Count - 1);
indexInAll = -1;
}
}
}
public void Kick(string reason, bool announce = true)
{
if (kicking) return;
state = SlotState.KICK;
if (announce)
{
if (assignedSlot >= 0)
{
ProgramLog.Admin.Log ("{0} @ {1}: disconnecting for: {2}", RemoteAddress, assignedSlot, reason);
var player = Main.players[assignedSlot];
if (player != null) player.DisconnectReason = reason;
}
else
ProgramLog.Admin.Log ("{0}: disconnecting for: {1}", RemoteAddress, reason);
}
if (! kicking)
{
var msg = NetMessage.PrepareThreadInstance ();
msg.Disconnect (reason);
KickAfter (msg.Output);
}
}
public void UpdateState() {
if (slot.obj == null) {
state = SlotState.NotLoaded;
} else if (!slot.boVisible) {
state = SlotState.Masked;
} else {
state = SlotState.Displayed;
}
}
public void Reset()
{
this.writeQueue = new Queue<byte[]> ();
this.remoteAddress = "<unknown>";
for (int i = 0; i < Main.maxSectionsX; i++)
{
for (int j = 0; j < Main.maxSectionsY; j++)
{
this.tileSection[i, j] = false;
}
}
if (this.whoAmI < 255)
{
Main.players[this.whoAmI] = new Player();
}
this.timeOut = 0;
this.statusCount = 0;
this.statusMax = 0;
this.statusText2 = "";
this.statusText = "";
this.name = "Anonymous";
this.state = SlotState.VACANT;
this.SpamClear();
NetMessage.buffer[this.whoAmI].Reset();
socket.SafeClose ();
}
void Start() {
state = SlotState.ready;
}
public void setState(SlotState newState)
{
if (OnSlotStateChangeFrom != null)
OnSlotStateChangeFrom(state);
state = newState;
if (OnSlotStateChangeTo != null)
OnSlotStateChangeTo(newState);
}
public ServerSlot()
{
writeQueue = new Queue<byte[]> ();
writeSignal = new AutoResetEvent (false);
state = SlotState.VACANT;
}
void OnSlotGUI(SlotState state)
{
}
