private void Awake()
{
DontDestroyOnLoad(this);
_photonPlayer = photonView.owner;
_gamePlayer = GetComponent <NPlayer>();
//SceneManager.sceneLoaded += OnSceneFinishedLoading;
}
public void Initialize(NPlayer caller, NProperty property)
{
// set up the property card
if (property is NLand)
{
GameObject landCard = Instantiate(landCardPrefab, propertyCardPlaceholder, false);
landCard.transform.localScale = new Vector3(0.9f, 0.9f, 1);
landCard.transform.position = propertyCardPlaceholder.position;
landCard.GetComponent <NDetailedLandCard>().Initialize(property as NLand);
}
else if (property is NRailroad)
{
GameObject railroadCard = Instantiate(railroadCardPrefab, propertyCardPlaceholder, false);
railroadCard.transform.localScale = new Vector3(0.9f, 0.9f, 1);
railroadCard.transform.position = propertyCardPlaceholder.position;
railroadCard.GetComponent <NDetailedRailroadCard>().Initialize(property as NRailroad);
}
_isCaller = (caller == NPlayer.thisPlayer);
_currentBid = property.PurchasePrice;
bidInfoText.text = caller.photonView.owner.NickName + " has started the auction\n";
bidInput.text = _currentBid.ToString();
NAuctionManager.instance.Initialize(caller, property, this);
}
public void RPC_TradeProperty(PhotonPlayer trader, PhotonPlayer tradee, int[] propA, int[] propB, int moneyA, int moneyB)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NPlayer playerA = FindGamePlayer(trader);
NPlayer playerB = FindGamePlayer(tradee);
playerA.ChangeMoney(-moneyA);
playerA.ChangeMoney(moneyB);
playerB.ChangeMoney(moneyA);
playerB.ChangeMoney(-moneyB);
foreach (int propID in propB)
{
NProperty property = NBoardManager.instance.Properties[propID];
playerB.RemoveProperty(property);
playerA.AddProperty(property);
property.SoldTo(playerA);
photonView.RPC("RPC_SetPropertyOwnerMarker", PhotonTargets.All, propID, trader);
}
foreach (int propID in propA)
{
NProperty property = NBoardManager.instance.Properties[propID];
playerA.RemoveProperty(property);
playerB.AddProperty(property);
property.SoldTo(playerB);
photonView.RPC("RPC_SetPropertyOwnerMarker", PhotonTargets.All, propID, tradee);
}
}
public override void Update(Player player, ref int buffIndex)
{
NPlayer modPlayer = player.GetModPlayer <NPlayer>(mod);
if (player.ownedProjectileCounts[mod.ProjectileType("NMWisp")] > 0)
{
modPlayer.NMMinion = true;
}
if (!modPlayer.NMMinion)
{
player.DelBuff(buffIndex);
buffIndex--;
}
else
{
player.buffTime[buffIndex] = 18000;
}
}
public override void StepOn(NPlayer player)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
player.GoJail();
}
public override void StepOn(NPlayer player)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NChestChanceManager.instance.ExecuteRandomChance(player);
}
private void Start()
{
if (photonView.isMine)
{
thisPlayer = this;
}
_sr = GetComponentInChildren <SpriteRenderer>();
}
public override void StepOn(NPlayer player)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
player.ChangeMoney(-fee);
FindObjectOfType <NParking>().ReceiveFee(fee);
}
public void RPC_CreateAuctionDialog(PhotonPlayer caller, int propertyID, int viewID)
{
NPlayer callingPlayer = NPlayerController.FindGamePlayer(caller);
NProperty property = NBoardManager.instance.FindProperty(propertyID);
GameObject dialog = Instantiate(auctionDialogPrefab);
dialog.GetComponent <PhotonView>().viewID = viewID;
dialog.GetComponent <NAuctionDialog>().Initialize(callingPlayer, property);
}
public override void StepOn(NPlayer player)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
player.ChangeMoney(totalFee);
totalFee = 0;
// text.text = "";
}
public override void Initialize()
{
/* TODO: (low) Implement proper initializer for all the cards/decks
* Init the background
* Init two decks (Load an XML file with data on each card from folders "Decks\Player1" and "Decks\Player2")
* Init controls (buttons, etc)
* Init Labels (damage counters, energy card symbols, card zones, etc)
* Init starting gameplayStage
*/
interfaceSpriteBatch = new SpriteBatch(currentGame.GraphicsDevice);
finalSpriteBatch = new SpriteBatch(currentGame.GraphicsDevice);
Player1 = new NPlayer(1, currentGame);
Player2 = new NPlayer(2, currentGame);
// Build the players' decks
DeckBuilder builder = new DeckBuilder(GameConstants.PATH_PLAYER1DECK, currentGame);
builder.ImportDeck();
Player1.PlayerDeck = builder.ToDeck();
Player1.PlayerDeck.Position = new Vector2(1489, 607);
Player1.PlayerDeck.Shuffle();
builder.DeckPath = GameConstants.PATH_PLAYER2DECK;
builder.ImportDeck();
Player2.PlayerDeck = builder.ToDeck();
Player2.PlayerDeck.Position = new Vector2(30, 178);
Player2.PlayerDeck.Shuffle();
// Init the players' hands
Player1.PlayerHand.Position = new Vector2(15, 650);
Player2.PlayerHand.Position = new Vector2(850, 30);
// Init buttons
drawCardButtonP1 = new Button("DrawButton", new Vector2(1355, 632), true, currentGame);
chatBox = new TextBoxMulti("Enter chat", new Vector2((int)(GameConstants.SCREEN_WIDTH - (GameConstants.SCREEN_WIDTH * 0.005) - 450),
(int)(GameConstants.SCREEN_HEIGHT / 2) - 61), currentGame);
// Populate the OnScreenElements list
OnScreenElements = new List <IClickable>();
OnScreenElements.Add(drawCardButtonP1);
OnScreenElements.Add(chatBox);
foreach (Card c in Player1.PlayerDeck)
{
OnScreenElements.Add(c);
}
foreach (Card c in Player2.PlayerDeck)
{
OnScreenElements.Add(c);
}
currentInputEvent = InputEvent.None;
keyboardHandler = new KeyboardHandler(currentGame);
}
public void RPC_BailToGetOut(PhotonPlayer caller)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NPlayer player = FindGamePlayer(caller);
player.ChangeMoney(-100);
player.GetOutOfJail();
}
public void Initialize(NPlayer startingPlayer, NProperty property, NAuctionDialog auctionDialog)
{
_bidders = new List <NPlayer>(NGameplay.instance.Players);
_property = property;
_currentBidder = startingPlayer.Order;
_currentBid = property.PurchasePrice;
_auctionFinished = false;
_auctionDialog = auctionDialog;
StartCoroutine(Bidding());
}
public void Execute(int itemIndex)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
if (_invoker != null)
{
wheelItems[itemIndex](_invoker);
}
_invoker = null;
}
private void step2CreatePlayerTwo()
{
sampleIO.log("Step 2 : CreatePlayerTwo");
NPlayer player = new NPlayer();
player.setId("pid02");
player.setLogin("player2");
player.setPassword("p2");
gameApi.savePlayerRequest(player, (SavePlayerResponse response)=>
{
step3LoginPlayerOne();
});
}
public void InvokeWheel(NPlayer invoker)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
_invoker = invoker;
float angularSpeed = 260 + UnityEngine.Random.Range(-30f, 30f);
float angularAcceleration = 40f + UnityEngine.Random.Range(-5f, 5f);
photonView.RPC("RPC_InvokeWheel", PhotonTargets.All, angularSpeed, angularAcceleration);
}
public void SetNewOwnerMarker(NPlayer owner)
{
// remove old marker
if (OwnerMarkerSR != null)
{
Destroy(OwnerMarkerSR);
OwnerMarkerSR = null;
}
// add new markers
OwnerMarkerSR = Instantiate(owner.SR, OwnerMarkerPos, Quaternion.identity);
OwnerMarkerSR.transform.localScale = new Vector3(0.2f, 0.2f);
}
private void ServerPlayerInitializer(Message message, IClient sender)
{
using (DarkRiftReader reader = message.GetReader())
{
NPlayer player = reader.ReadSerializable <NPlayer>();
if (playerConnecting != null)
{
buffer.AddToBuffer(InitializePlayer, player, sender);
return;
}
pingSendTimer.Stop();
InitializePlayer(player, sender);
}
}
public void Initialize(NPlayer player)
{
_player = player;
moneyText.text = "$" + player.CurrentMoney;
nameText.text = player.photonView.owner.NickName;
playerAvatar.sprite = player.SR.sprite;
playerAvatar.color = player.SR.color;
normalColor = background.color;
highlightedColor = new Color(1.0f, 0.8f, 0.1f);
bankruptcyColor = new Color(1.0f, 0f, 0f);
player.OnMoneyChangedCallBack += UpdateMoney;
//player.OnPlayerBankruptyCallBack += PlayerBankrupt;
}
public override void run()
{
nuggetaPlug.setStartResponseHandler((StartResponse startresponse) =>
{
if (startresponse.getStartStatus() == StartStatus.READY) {
sampleIO.connected();
sampleIO.log("Hello NUGGETA!");
Player = startresponse.getPlayer();
}
else {
sampleIO.log("Nuggeta start failed");
}
});
nuggetaPlug.start();
}
private void step1LoginPlayer()
{
sampleIO.log("Step 1 : Login Player ");
gameApi.loginRequest("toto", "pwd123456", (LoginResponse response)=>
{
if (response.getLoginStatus() == LoginStatus.CONNECTED)
{
createdPlayer = response.getPlayer();
sampleIO.log("Step 1 : Login Player successfull\r\n");
} else
{
sampleIO.log("Step 1 : Fail to Login Player\r\n");
onExit();
}
});
}
public void RPC_DegradeLand(int propertyID, PhotonPlayer caller)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NLand landToDegrade = NBoardManager.instance.Properties[propertyID] as NLand;
NPlayer player = FindGamePlayer(caller);
if (landToDegrade.Degradable && landToDegrade.CurrentLevel > 0)
{
player.ChangeMoney(landToDegrade.UpgradePrice / 2);
landToDegrade.Degrade();
photonView.RPC("RPC_UpdateLandLevel", PhotonTargets.All, propertyID, landToDegrade.CurrentLevel);
}
}
// mode: 0.Trader 1.Tradee 2.Others
public void Initialize(PhotonPlayer trader, PhotonPlayer tradee, int mode)
{
if (mode == 0)
{
offerButton.gameObject.SetActive(true);
cancelButton.gameObject.SetActive(true);
moneySliderA.interactable = true;
moneyTextA.interactable = true;
moneySliderB.interactable = true;
moneyTextB.interactable = true;
}
else if (mode == 1)
{
offerButton.gameObject.SetActive(false);
cancelButton.gameObject.SetActive(false);
acceptButton.gameObject.SetActive(true);
declineButton.gameObject.SetActive(true);
}
playerA = NPlayerController.FindGamePlayer(trader);
playerB = NPlayerController.FindGamePlayer(tradee);
// set name texts
playerNameA.text = trader.NickName;
playerNameB.text = tradee.NickName;
// set money sliders
moneySliderA.maxValue = playerA.CurrentMoney;
moneySliderB.maxValue = playerB.CurrentMoney;
// set property list panels
for (int i = 0; i < playerA.Properties.Count; i++)
{
GameObject propertyMiniCard = Instantiate(propertyMiniCardPrefab);
propertyMiniCard.transform.SetParent(propertyListA, false);
propertyMiniCardsA.Add(propertyMiniCard.GetComponent <NPropertyMiniCard>());
propertyMiniCard.GetComponent <NPropertyMiniCard>().Initialize(playerA.Properties[i], 0, i, (mode == 0));
}
for (int i = 0; i < playerB.Properties.Count; i++)
{
GameObject propertyMiniCard = Instantiate(propertyMiniCardPrefab);
propertyMiniCard.transform.SetParent(propertyListB, false);
propertyMiniCardsB.Add(propertyMiniCard.GetComponent <NPropertyMiniCard>());
propertyMiniCard.GetComponent <NPropertyMiniCard>().Initialize(playerB.Properties[i], 1, i, (mode == 0));
}
}
public void RPC_PurchaseProperty(int propertyID, int purchasePrice, PhotonPlayer caller)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NPlayer player = FindGamePlayer(caller);
NProperty property = NBoardManager.instance.Properties[propertyID];
if (player.CurrentMoney >= purchasePrice)
{
player.ChangeMoney(-purchasePrice);
player.AddProperty(property);
property.SoldTo(player);
photonView.RPC("RPC_SetPropertyOwnerMarker", PhotonTargets.All, propertyID, caller);
}
}
public void RPC_RedeemProperty(int propertyID, PhotonPlayer caller)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NProperty property = NBoardManager.instance.Properties[propertyID];
NPlayer player = FindGamePlayer(caller);
if (property.IsMortgaged)
{
property.IsMortgaged = false;
player.ChangeMoney(-(int)(property.PurchasePrice / 2 * 1.1f));
photonView.RPC("RPC_TogglePropertyMortgagedBackground", PhotonTargets.All, propertyID, false);
}
}
private void step1SavePlayer()
{
sampleIO.log("Step 1 : Save Player");
NPlayer player = new NPlayer();
player.setLogin("player1");
player.setPassword("p1");
gameApi.savePlayerRequest(player, (SavePlayerResponse response)=>
{
if (response.getSavePlayerStatus() == SavePlayerStatus.SUCCESS)
{
createdPlayer = response.getPlayer();
sampleIO.log("Step 1 : Save Player successfull\r\n");
} else
{
sampleIO.log("Step 1 : Fail to Create Player\r\n");
onExit();
}
});
}
public override void CheckActive()
{
Player player = Main.player[projectile.owner];
NPlayer modPlayer = player.GetModPlayer <NPlayer>(mod);
if (player.dead)
{
modPlayer.NMMinion = false;
}
if (modPlayer.NMMinion)
{
projectile.timeLeft = 2;
}
}
public void RPC_RollDiceToGetOut(PhotonPlayer caller)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NPlayer player = FindGamePlayer(caller);
int dice1 = Random.Range(1, 7);
int dice2 = Random.Range(1, 7);
if (dice1 == dice2)
{
player.GetOutOfJail();
photonView.RPC("RPC_ReceiveDice", PhotonTargets.All, dice1, dice2, caller);
}
else
{
player.TurnsInJail++;
}
}
public override void StepOn(NPlayer player)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
if (_owner == null)
{
NDialogManager.instance.CallPropertyPurchaseDialog(_propertyID, player.photonView.owner);
}
else
{
if (_owner != player)
{
_owner.ChangeMoney(_currentRent);
player.ChangeMoney(-_currentRent);
Debug.Log(player.photonView.owner.NickName + " paid $" + _currentRent + " to " + _owner.photonView.owner.NickName);
}
}
}
// 8
void Wheel_receiveOneHundredFromOtherPlayer(NPlayer player)
{
NPlayer[] players = NGameplay.instance.Players;
int max = 0;
int id = 0;
for (int i = 0; i < players.Length; i++)
{
if (players[i] == player)
{
continue;
}
if (players[i].CurrentMoney > max)
{
max = players[i].CurrentMoney;
id = i;
}
}
players[id].ChangeMoney(-100);
player.ChangeMoney(100);
}
// 9
void Wheel_giveOneHundredToOtherPlayer(NPlayer player)
{
NPlayer[] players = NGameplay.instance.Players;
int min = 100000;
int id = 0;
for (int i = 0; i < players.Length; i++)
{
if (players[i] == player)
{
continue;
}
if (players[i].CurrentMoney < min)
{
min = players[i].CurrentMoney;
id = i;
}
}
players[id].ChangeMoney(100);
player.ChangeMoney(-100);
}
private void SpawnNetworkPlayer(Message message)
{
using (DarkRiftReader reader = message.GetReader())
{
while (reader.Position < reader.Length)
{
newPlayerConnecting = true;
NPlayer player = reader.ReadSerializable <NPlayer>();
if (player.Id != SingletonBehaviour <UnityClient> .Instance.ID)
{
Location playerPos = reader.ReadSerializable <Location>();
Main.Log($"[CLIENT] < PLAYER_SPAWN: Username: {player.Username} ");
Vector3 pos = playerPos.Position + WorldMover.currentMove;
pos = new Vector3(pos.x, pos.y + 1, pos.z);
Quaternion rotation = Quaternion.identity;
if (playerPos.Rotation.HasValue)
{
rotation = playerPos.Rotation.Value;
}
GameObject playerObject = GetNewPlayerObject(pos, rotation, player.Username);
WorldMover.Instance.AddObjectToMove(playerObject.transform);
NetworkPlayerSync playerSync = playerObject.GetComponent <NetworkPlayerSync>();
playerSync.Id = player.Id;
playerSync.Username = player.Username;
playerSync.Mods = player.Mods;
playerSync.IsLoaded = player.IsLoaded;
networkPlayers.Add(player.Id, playerObject);
allPlayers.Add(player.Id, playerObject);
if (!player.IsLoaded)
{
WaitForPlayerLoaded();
}
}
}
}
}
public void RPC_UpgradeLand(int propertyID, PhotonPlayer caller)
{
if (!PhotonNetwork.isMasterClient)
{
return;
}
NLand landToUpgrade = NBoardManager.instance.Properties[propertyID] as NLand;
NPlayer player = FindGamePlayer(caller);
//Debug.Log(caller.NickName + " wants to upgrade " + landToUpgrade.PropertyName);
if (player.CurrentMoney < landToUpgrade.UpgradePrice || landToUpgrade.IsMortgaged)
{
return;
}
if (landToUpgrade.Upgradable && landToUpgrade.CurrentLevel < NLand.maxLevel)
{
player.ChangeMoney(-landToUpgrade.UpgradePrice);
landToUpgrade.Upgrade();
photonView.RPC("RPC_UpdateLandLevel", PhotonTargets.All, propertyID, landToUpgrade.CurrentLevel);
}
}
public void UpdateGroupDegradeble(Color group)
{
List <NLand> lands = groups[group];
if (lands.Count == 0)
{
return;
}
NPlayer owner0 = lands[0].Owner;
foreach (NLand land in lands)
{
if (land.Owner == null || land.Owner != owner0)
{
return;
}
}
int maxLevel = lands[0].CurrentLevel;
foreach (NLand land in lands)
{
if (land.CurrentLevel > maxLevel)
{
maxLevel = land.CurrentLevel;
}
}
foreach (NLand land in lands)
{
if (land.CurrentLevel == maxLevel)
{
land.Degradable = true;
}
else
{
land.Degradable = false;
}
}
}
private void step4GetPlayerTwo()
{
sampleIO.log("Step 4 : GetPlayerTwo");
NuggetaQuery playersQuery = new NuggetaQuery();
playersQuery.setQuery("$WHERE Login = '******'");
gameApi.getPlayersRequest(playersQuery, (GetPlayersResponse getPlayersResponse)=>
{
if (GetPlayersStatus.SUCCESS == getPlayersResponse.getGetPlayersStatus())
{
List<NPlayer> players = getPlayersResponse.getPlayers();
if (players.Count == 1)
{
playerTwo = players[0];
step5AskForFriendPlayerTwo();
} else
{
sampleIO.log("Step 4 : GetPlayerTwo : retrieve more than one player !");
onExit();
}
} else
{
sampleIO.log("Step 4 : GetPlayerTwo failure " + getPlayersResponse.getGetPlayersStatus());
onExit();
}
});
}
