public static void GamerHitScreen(Vector3 position)
{
if (singleton == null)
{
Debug.LogError("Singleton = null");
return;
}
if (singleton._curGameMode == GameMode.netView)
{
return;
}
if (Physics.Raycast(Camera.main.ScreenPointToRay(position), out singleton.hit, 100f))
{
if (singleton.hit.collider.gameObject.layer == 8)
{
int hittedBubbleId = int.Parse(singleton.hit.collider.gameObject.name);
if (singleton.bubblesDict.ContainsKey(hittedBubbleId))
{
singleton.AddScore(singleton.bubblesDict[hittedBubbleId].GetBubbleSize());
singleton.bubblesDict[hittedBubbleId].GamerHitBubble();
UserDestroyBubbleProxy proxy = new UserDestroyBubbleProxy(hittedBubbleId, score);
NetController.SendMessage(NetMessageCode.UserDestroyBubble, proxy);
}
}
}
}
public void CmdTVServerExec(TVCommand cmd, ContentType type, string arg)
{
print("cmd=" + cmd + "type=" + type + "arg" + arg);
NetController ctrl = FindObjectOfType <NetController>();
if (ctrl != null)
{
if (cmd == TVCommand.StartGame)
{
ctrl.GameStart(type, arg);
}
else if (cmd == TVCommand.StopGame)
{
ctrl.GameStop(type, arg);
}
else if (cmd == TVCommand.ResetGame)
{
ctrl.GameReset(type, arg);
}
else if (cmd == TVCommand.BroadcastYes)
{
ctrl.ToggleBroadcast(true);
}
else if (cmd == TVCommand.BroadcastNo)
{
ctrl.ToggleBroadcast(false);
}
}
}
void FixedUpdate()
{
if (Input.GetButtonUp("Stop"))
{
Input.ResetInputAxes();
GetComponent <Rigidbody>().velocity = new Vector3();
}
else
{
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);
GetComponent <Rigidbody>().AddForce(movement * speed * Time.deltaTime);
}
float now = Time.fixedTime;
if ((now - lastPositionSend) > 0.03333)
{
lastPositionSend = now;
NetController.SendPosition(transform.position);
}
if (levelGate != null)
{
Vector3 distance = levelGate.transform.position - transform.position;
if (distance.magnitude > 1)
{
levelGate.transform.rotation = Quaternion.LookRotation(distance.normalized);
}
}
}
public static void Fullness(string command, string[] args)
{
if (!Context.IsWorldReady)
{
return;
}
if (Context.IsMultiplayer)
{
if (Context.IsMainPlayer)
{
if (args.Length > 0)
{
bool _player_check = false;
foreach (Farmer _farmer in Game1.getAllFarmers())
{
if (_farmer.displayName == args[0])
{
Data _data = ModEntry.instance.Helper.Data.ReadSaveData <Data>($"{_farmer.UniqueMultiplayerID}");
_data.actual_hunger = _data.max_hunger;
_data.actual_thirst = _data.max_thirst;
ModEntry.instance.Helper.Data.WriteSaveData($"{_farmer.UniqueMultiplayerID}", _data);
if (Context.IsMainPlayer)
{
ModEntry.data.actual_hunger = _data.max_hunger;
ModEntry.data.actual_thirst = _data.actual_thirst;
BarsUpdate.CalculatePercentage();
}
else
{
NetController.SyncSpecificPlayer(_farmer.UniqueMultiplayerID);
}
Debugger.Log($"Setting full status to the player {_farmer.displayName}.", "Info");
_player_check = true;
break;
}
}
if (!_player_check)
{
Debugger.Log(_error_player_not_found, "Error");
}
}
else
{
Debugger.Log($"{_error_command_wrong} 'help {command}'", "Error");
}
}
else
{
Debugger.Log(_error_permission, "Error");
}
}
else
{
ModEntry.data.actual_hunger = ModEntry.data.max_hunger;
ModEntry.data.actual_thirst = ModEntry.data.max_thirst;
Debugger.Log("Setting full status to the player.", "info");
}
}
static void Main(string[] args)
{
Logs.ConfigLogFile("TradeAge.log");
Logs.AddAppender(new ConsoleAppender());
controller = new GameController();
controller.Net.NetStateConnect += Net_NetStateConnect;
controller.Net.ConnectServer("127.0.0.1", 4530);
pink.Add(new SimulatorMove(controller));
GameServerService.StartTaskThread();
while (true)
{
if (Console.KeyAvailable)
{
var key = Console.ReadKey(false);
if (key.Key == ConsoleKey.Escape)
{
break;
}
}
Thread.Sleep(100);
pink.ForEach(o => o.RandMove());
}
NetController.CloseThread();
}
public ControllerPacketHandler(NetController net, BaseGameController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(2, OnSyncServerTime);
}
public ControllerPacketHandler(NetController net, BaseGameController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(2, OnSyncServerTime);
}
/// <summary>
/// 游戏控制器
/// </summary>
public GameController()
{
Net = new NetController();
Net.Tag = this;
Login = new LoginController(Net);
}
public static void StopGame()
{
singleton.StopAllCoroutines();
NetController.StopServer();
singleton.DestroyAllBubblesInDict();
singleton._curGameMode = GameMode.none;
}
private void OnTimeChanged(object sender, TimeChangedEventArgs e)
{
BarsUpdate.UpdateBarsInformation();
BarsUpdate.CalculatePercentage();
BarsWarnings.VerifyStatus();
Penalty.VerifyPenalty();
NetController.Sync();
}
public ControllerPacketHandler(NetController net, BaseLoginController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(1001, OnLoginServerResult);
PacketHandlerManager.Register(1003, OnCreatePlayerResult);
}
public ControllerPacketHandler(NetController net, BaseLoginController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(1001, OnLoginServerResult);
PacketHandlerManager.Register(1003, OnCreatePlayerResult);
}
public NetCore(string version, bool allowConnections)
{
if (version == null)
version = "";
if (Encoding.UTF8.GetByteCount(version) > NetConfig.MAX_VERSION_BYTES)
throw new ApplicationException("Version string too long");
this.controller = new NetController(version, allowConnections);
}
/// <summary>
/// 游戏控制器
/// </summary>
public GameController()
{
Net = new NetController();
Net.Tag = this;
Login = new LoginController(this, Net);
Game = new TradeAge.Client.Controller.Game.GameController(Net);
Scene = new SceneController(this, Net);
Model = new PlayerModel();
}
/// <summary>
/// 游戏控制器
/// </summary>
public GameController()
{
Net = new NetController();
Net.Tag = this;
Login = new LoginController(this, Net);
Game = new TradeAge.Client.Controller.Game.GameController(Net);
Scene = new SceneController(this, Net);
Model = new PlayerModel();
}
public ControllerPacketHandler(NetController net, BaseSceneController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(1101, OnEnterSceneInfo);
PacketHandlerManager.Register(1102, OnSpriteEnter);
PacketHandlerManager.Register(1103, OnSpriteMove);
PacketHandlerManager.Register(1104, OnSpriteLeave);
}
public ControllerPacketHandler(NetController net, BaseSceneController logic)
{
PacketHandlerManager = net.PacketHandlers;
module = logic;
PacketHandlerManager.Register(1101, OnEnterSceneInfo);
PacketHandlerManager.Register(1102, OnSpriteEnter);
PacketHandlerManager.Register(1103, OnSpriteMove);
PacketHandlerManager.Register(1104, OnSpriteLeave);
}
static void Main(string[] args)
{
NetController cont = new NetController();
cont.NewConnectionEvent += new NetEvent(cont_NewConnectionEvent);
cont.RecieveEvent += new NetEvent(cont_RecieveEvent);
cont.Start(51215, IPAddress.Any);
while (Console.Read() != 'q')
{
;
}
}
private void OnSaveLoaded(object sender, SaveLoadedEventArgs e)
{
if (!NetController.firstLoad)
{
NetController.Sync();
}
Interaction.Awake();
NetController.Sync();
BarsPosition.SetBarsPosition();
Interaction.ReceiveAwakeInfos();
BarsUpdate.CalculatePercentage();
BarsWarnings.VerifyStatus();
}
void InvokeUpdateHostIP()
{
NetController net = GameObject.FindObjectOfType <NetController>();
if (net != null && net.GetOneNetPlayer() != null)
{
foreach (int key in players.Keys)
{
net.GetOneNetPlayer().RpcUpdateHostIP(players[key]);
break;
}
}
}
public GameScene()
{
var server = ServerManager.GetServer();
Log.Print($"Address: {server.Item1}");
Log.Print($"Token: {server.Item2}");
netController = new NetController();
netController.Connect(server.Item1, server.Item2);
world = new World();
playerController = new InputController();
}
void Awake()
{
singleton = this;
if (ResourceManager.isResourcesLoaded)
{
OnResourasLoaded();
}
else
{
ResourceManager.OnAllResoucesLoadedEvent -= OnResourasLoaded;
ResourceManager.OnAllResoucesLoadedEvent += OnResourasLoaded;
}
myIp = NetController.GetLocalIpAddress();
}
public static void StartGame()
{
NetController.CreateServer();
singleton.DestroyAllBubblesInDict();
singleton._curGameMode = GameMode.single;
singleton._curLevel = 1;
singleton._score = 0;
ResourceManager.GenerateNewTexturesSet();
singleton.smallBubbleSpeed = ConfigDictionary.Config.baseSmallBubbleSpeed;
singleton.bigBubbleSpeed = ConfigDictionary.Config.baseBigBubbleSpeed;
singleton._levelTimer = ConfigDictionary.Config.levelTime;
singleton.bubbleGenerationDelay = ConfigDictionary.Config.baseBubbleGenerationDelay;
singleton.StartCoroutine(singleton.GenerateBubblesForSingleGame());
}
private void Awake()
{
//Check if instance already exists
if (Instance == null)
{
//if not, set instance to this
Instance = this;
}
//If instance already exists and it's not this:
else if (Instance != this)
{
//Then destroy this. This enforces our singleton pattern, meaning there can only ever be one instance of a GameManager.
Destroy(gameObject);
}
}
void Start()
{
_messageParser = new MessageParser();
_messageParser.RegisterProtocol(ProtocolEnum.MessageSecret, typeof(MessageSecret));
_messageParser.RegisterProtocol(ProtocolEnum.MessagePing, typeof(MessagePing));
_messageParser.RegisterProtocol(ProtocolEnum.MessageRegister, typeof(MessageRegister));
_messageParser.RegisterProtocol(ProtocolEnum.MessageLogin, typeof(MessageLogin));
_messageParser.RegisterProtocol(ProtocolEnum.MessageTest, typeof(MessageTest));
_netController = new NetController(_messageParser);
_protocolHandler = new ProtocolHandler(_netController);
_netController.RegisterNetEventListener(NetEvent.ConnectSuccess, Debug.Log);
_netController.RegisterNetEventListener(NetEvent.Close, Debug.Log);
_netController.Connect("127.0.0.1", 8011);
StartCoroutine(_netController.CheckNet());
}
public static void cm_OnChangeMultiplier(string command, string[] args)
{
if (!Context.IsWorldReady)
{
return;
}
if (Context.IsMultiplayer && Context.IsMainPlayer)
{
ModEntry.data.Multiplier = ModEntry.config.Multiplier = float.Parse(args[0]);
ModEntry.instance.Helper.Data.WriteJsonFile($"MultiplayerData/{Game1.player.farmName}_Farm_Data.json", ModEntry.data);
NetController.SyncAllPlayers();
ModEntry.instance.Monitor.Log($"Stamina multiplier changed to: {ModEntry.data.Multiplier}x", LogLevel.Info);
}
if (!Context.IsMultiplayer)
{
ModEntry.config.Multiplier = float.Parse(args[0]);
ModEntry.instance.Monitor.Log($"Stamina multiplier changed to: {ModEntry.config.Multiplier}x", LogLevel.Info);
}
}
public static void cm_OnChangeStanding(string command, string[] args)
{
if (!Context.IsWorldReady)
{
return;
}
if (Context.IsMultiplayer && Context.IsMainPlayer)
{
ModEntry.data.StandingVerification = ModEntry.config.StandingVerification = bool.Parse(args[0]);
ModEntry.instance.Helper.Data.WriteJsonFile($"MultiplayerData/{Game1.player.farmName}_Farm_Data.json", ModEntry.data);
NetController.SyncAllPlayers();
ModEntry.instance.Monitor.Log($"Standing verification changed to: {args[0]}", LogLevel.Info);
}
if (!Context.IsMultiplayer)
{
ModEntry.config.StandingVerification = bool.Parse(args[0]);
ModEntry.instance.Monitor.Log($"Standing verification changed to: {args[0]}", LogLevel.Info);
}
}
public static void VerifyPassOut()
{
if (Game1.player.health <= 0)
{
if (!alreadyCheckedFaint)
{
ModEntry.data.actual_hunger = ModEntry.data.max_hunger / 3;
ModEntry.data.actual_thirst = ModEntry.data.max_thirst / 2;
NetController.Sync();
alreadyCheckedFaint = true;
}
}
else
{
alreadyCheckedFaint = false;
}
}
private void DrawNetSetupGUI()
{
GUI.Label(ipRect, "Local ip:" + myIp);
GUI.Label(ipAddressNameRect, "Enter Ip:");
ipAddressInput = GUI.TextField(ipAddressRect, ipAddressInput, 12);
if (GUI.Button(connectRect, "Connect") && ipAddressInput != string.Empty)
{
Debug.Log("Begin connect");
NetController.ConnectToNetGame(ipAddressInput, ConfigDictionary.Config.socketConnectPort);
}
if (GUI.Button(backRect, "Back"))
{
ChangeUserInterfaceMode(InterfaceMode.MainMenu);
GameController.StopGame();
}
}
//-----------------------------------------------------------------------------------------------------------------------------
public FormMain()
{
InitializeComponent();
lvwColumnSorter = new ListViewColumnSorter();
this.listView1.ListViewItemSorter = lvwColumnSorter;
appSettings = new MySettings();
appSettings.Read();
dbMain = new DBController(appSettings);
FillListDevices();
ReadHosts();
GetArpTable2ListAndFillHosts();
if (dbMain.TestConnection())
{
tsslDBStatus.Text = "connected to " + appSettings.DBIP;
}
netHosts = new NetController();
//ReadFromXML();
}
public void CmdPlatformServerExec(PlatformCommand cmd, string arg)
{
NetController ctrl = FindObjectOfType <NetController>();
if (cmd == PlatformCommand.ContentStarted)
{
RpcGameAlreadyStart();
if (ctrl)
{
ctrl.GameAlreadyStarted();
}
}
else if (cmd == PlatformCommand.ContentStoped)
{
RpcGameAlreadyStop();
if (ctrl)
{
ctrl.GameAlreadyStoped();
}
}
}
// Use this for initialization
void Start()
{
// Network manager
_networkManagerGO = GameObject.FindGameObjectWithTag("NetworkManager");
// All the background cubes
_background = GameObject.FindGameObjectsWithTag("Background");
// NetworkController handles the communication between clients and the host. For single player games
// the SingleController is used instead with similar methods only without the Rpc and Cmd calls
_networkController = NetController.GetComponent <NetworkController>();
_networkManager = _networkManagerGO.GetComponent <NetworkManager>();
Requested = new Dictionary <string, float>();
_gameMode = new GameObject[0];
Selected = -1;
StartCounter = -1;
_oldTime = 0.0f;
_storeLoaded = false;
Started = false;
Chosen = false;
_running = false;
LoggedIn = false;
}
private void NextLevel()
{
_curLevel++;
ResourceManager.GenerateNewTexturesSet();
smallBubbleSpeed += ConfigDictionary.Config.nextLevelIncreaseBubbleSpeed;
bigBubbleSpeed += ConfigDictionary.Config.nextLevelIncreaseBubbleSpeed;
_levelTimer = ConfigDictionary.Config.levelTime;
bubbleGenerationDelay -= ConfigDictionary.Config.nextLevelIncreaseBubbleGenerationDelay;
bubbleGenerationDelay = Mathf.Clamp(bubbleGenerationDelay, 0.5f, 1000);
NewLevelProxy proxy = new NewLevelProxy();
proxy.score = score;
List <NewBubbleProxy> bubbles = new List <NewBubbleProxy>();
foreach (KeyValuePair <int, BubbleController> bubble in singleton.bubblesDict)
{
bubbles.Add(bubble.Value.GenerateNewBubbleProxy());
}
proxy.bubbles = bubbles.ToArray <NewBubbleProxy>();
NetController.SendMessage(NetMessageCode.NewLevel, proxy);
}
public GameController(ContentManager Content, GraphicsDevice graphicsDevice)
{
physicsController = new PhysicsController();
Body.SetPhysicsController(physicsController);
camera = new Camera(GUIController.screenSize);
particleSystem = new ParticleSystem(Content, camera, graphicsDevice);
ProjectilesController projectilesController = new ProjectilesController(Content, particleSystem);
LootController lootController = new LootController(Content);
GUIController = new GUIController(Content);
ShipsController shipsController = new ShipsController(Content, lootController, projectilesController, particleSystem, camera, GUIController.CreateJoysticks);
netController = new NetController(shipsController);
controllers = new IDrawablesController[]
{
shipsController,
projectilesController,
lootController
};
}
IEnumerator GenerateBubblesForSingleGame()
{
if (_levelTimer == 0)
{
NextLevel();
yield return(new WaitForSeconds(0.1f));
StartCoroutine(GenerateBubblesForSingleGame());
}
else
{
BubbleController newBubble = bubblesGenerator.GenerateNewBubble(smallBubbleSpeed, bigBubbleSpeed);
NetController.SendMessage(NetMessageCode.NewBubble, newBubble.GenerateNewBubbleProxy());
bubblesDict.Add(newBubble.id, newBubble);
float nextBubbleTimeDelay =
UnityEngine.Random.Range(bubbleGenerationDelay - ConfigDictionary.Config.bubbleGenerationDelayRandom,
bubbleGenerationDelay + ConfigDictionary.Config.bubbleGenerationDelayRandom);
yield return(new WaitForSeconds(nextBubbleTimeDelay));
StartCoroutine(GenerateBubblesForSingleGame());
}
}
public static void ForceSync(string command, string[] args)
{
if (!Context.IsWorldReady)
{
return;
}
if (Context.IsMultiplayer)
{
if (Context.IsMainPlayer)
{
NetController.SyncAllPlayers();
NetController.Sync();
Debugger.Log($"All players are now synchronized!", "Info");
}
else
{
Debugger.Log(_error_permission, "Error");
}
}
else
{
Debugger.Log(_error_multiplayer, "Info");
}
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <param name="nc"></param>
public SceneController(GameController gc, NetController nc)
: this(nc)
{
controller = gc;
}
public GameController()
{
Net = new NetController();
Login = new LoginController(Net);
Scene = new SceneController(Net);
}
public SceneController(NetController net)
{
nc = net;
new ControllerPacketHandler(net, this);
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <param name="nc"></param>
public LoginController(GameController gc, NetController nc)
: this(nc)
{
controller = gc;
}
