Windward Reflexil patch for XP and Gold (rowneg@bk.ru). Tested on version 2015-12-30.0

WindwardHack.cs

// Windward Reflexil patch for XP and Gold (rowneg@bk.ru)
#region " Imports "
using System;
using System.Collections.Generic;
using System.Text;
using TNet;
#endregion 

#region " Referenced assemblies "
// - mscorlib v2.0.5.0
// - UnityEngine v0.0.0.0
// - System.Core v2.0.5.0
// - System v2.0.5.0
// - Assembly-UnityScript-firstpass v0.0.0.0
// - Mono.CSharp v2.1.0.0
// - UnityEngine.UI v1.0.0.0
// - Assembly-CSharp-firstpass v0.0.0.0
// - TouchScript v1.0.0.0
// - TouchScript.Windows v1.0.0.0
// - Assembly-CSharp v1.0.0.0
#endregion 

class GamePlayer
{
	// Limited support!
	// You can only reference methods or fields defined in the class (not in ancestors classes)
	// Fields and methods stubs are needed for compilation purposes only.
	// Reflexil will automaticaly map current type, fields or methods to original references.
public delegate void OnLoadCallback(DataNode node);

 

 

[TNet.RFC]
protected void OnXP(float xp)
{
    if (this.isMe)
    {
        MyPlayer.AwardXP(10000*xp);
	MyPlayer.ModifyResource("gold", 300000, true);
    }
    else
    {
        UnityEngine.Debug.LogError("OnXP called on the wrong player!");
    }
}

 

	#region " Methods stubs "
	// Do not add or update any method. If compilation fails because of a method declaration, comment it
	GamePlayer()
	{
	}
	
	static GamePlayer()
	{
	}
	
	TNet.DataNode get_shipItem()
	{
		return default(TNet.DataNode);
	}
	
	void set_shipItem(TNet.DataNode @value)
	{
	}
	
	int get_cargoSlots()
	{
		return default(int);
	}
	
	string get_shipPrefab()
	{
		return default(string);
	}
	
	string get_countryCode()
	{
		return default(string);
	}
	
	bool get_isObserver()
	{
		return default(bool);
	}
	
	int get_xp()
	{
		return default(int);
	}
	
	int get_gold()
	{
		return default(int);
	}
	
	int get_wood()
	{
		return default(int);
	}
	
	int get_stone()
	{
		return default(int);
	}
	
	int get_powder()
	{
		return default(int);
	}
	
	int GetResource(string name)
	{
		return default(int);
	}
	
	void SyncSteamData()
	{
	}
	
	void SetUserData(string a, string b, string c)
	{
	}
	
	void SetVAC(bool val)
	{
	}
	
	void SetShip(string shipType)
	{
	}
	

	
	TNet.DataNode get_data()
	{
		return default(TNet.DataNode);
	}
	
	TNet.DataNode get_worldData()
	{
		return default(TNet.DataNode);
	}
	
	GameTown get_respawnTown()
	{
		return default(GameTown);
	}
	
	UnityEngine.Vector3 get_respawnPos()
	{
		return default(UnityEngine.Vector3);
	}
	
	float get_respawnAngle()
	{
		return default(float);
	}
	
	int get_respawnSide()
	{
		return default(int);
	}
	
	int get_activeFaction()
	{
		return default(int);
	}
	
	int get_factionID()
	{
		return default(int);
	}
	
	int get_startingFaction()
	{
		return default(int);
	}
	
	void set_startingFaction(int @value)
	{
	}
	
	string get_name()
	{
		return default(string);
	}
	
	int get_talentPoints()
	{
		return default(int);
	}
	
	int get_uncappedTalentPoints()
	{
		return default(int);
	}
	
	int get_level()
	{
		return default(int);
	}
	
	bool get_isAnonymous()
	{
		return default(bool);
	}
	
	bool get_isAFK()
	{
		return default(bool);
	}
	
	void set_isAFK(bool @value)
	{
	}
	
	void SetAFK(bool val)
	{
	}
	
	int get_specialization()
	{
		return default(int);
	}
	
	T Get<T>(string key)
	{
		return default(T);
	}
	
	T Get<T>(string key, T def)
	{
		return default(T);
	}
	
	bool GetOption(string name, bool defaultValue)
	{
		return default(bool);
	}
	
	TNet.DataNode get_inventory()
	{
		return default(TNet.DataNode);
	}
	
	TNet.DataNode get_equipment()
	{
		return default(TNet.DataNode);
	}
	
	bool get_hasInventorySpace()
	{
		return default(bool);
	}
	
	string get_adversaryName()
	{
		return default(string);
	}
	
	static int CountNonObservers()
	{
		return default(int);
	}
	
	bool HasResource(string name, int amount)
	{
		return default(bool);
	}
	
	void AwardXP(float xp)
	{
	}
	
	void AwardXP(float xp, string type)
	{
	}
	
	void Awake()
	{
	}
	
	bool get_shouldHaveIWIN()
	{
		return default(bool);
	}
	
	void set_shouldHaveIWIN(bool @value)
	{
	}
	
	void RecordCombatTime()
	{
	}
	
	void PeriodicSave()
	{
	}
	
	void PeriodicSync()
	{
	}
	
	void SyncPlayer(TNet.Player p)
	{
	}
	
	void OnEnable()
	{
	}
	
	void OnDisable()
	{
	}
	
	void OnDestroy()
	{
	}
	
	void IncreaseInfraction(string reason, bool isSerious, bool canBan)
	{
	}
	
	static TNet.List<int> CountFactions(bool ignorePirates)
	{
		return default(TNet.List<int>);
	}
	
	static TNet.List<int> Count(TNet.List<int> filter)
	{
		return default(TNet.List<int>);
	}
	
	static int GetUnderdogFaction(TNet.List<int> factions)
	{
		return default(int);
	}
	
	System.Collections.IEnumerator Start()
	{
		return default(System.Collections.IEnumerator);
	}
	
	void SetStartingFaction(int val)
	{
	}
	
	static GameTown FindPirateTown()
	{
		return default(GameTown);
	}
	
	System.Collections.IEnumerator FlipTown()
	{
		return default(System.Collections.IEnumerator);
	}
	
	System.Collections.IEnumerator InstanceOffer()
	{
		return default(System.Collections.IEnumerator);
	}
	
	void AdversaryCheck()
	{
	}
	
	void RenameSelf(string newName)
	{
	}
	
	bool HasItem(string itemName)
	{
		return default(bool);
	}
	
	bool HasItemQuest(string questName)
	{
		return default(bool);
	}
	
	void PeriodicPingUpdate()
	{
	}
	
	void OnSetPing(int val)
	{
	}
	
	void Update()
	{
	}
	
	void RespawnCheck()
	{
	}
	
	void RespawnStarted()
	{
	}
	
	void RespawnEnded()
	{
	}
	
	bool get_isReadyToRespawn()
	{
		return default(bool);
	}
	
	void set_isReadyToRespawn(bool @value)
	{
	}
	
	void SetShip(GameShip ship)
	{
	}
	
	void ReadyToRespawn(bool val, string country)
	{
	}
	
	static GameTown FindClosest(TNet.List<GameTown> towns, UnityEngine.Vector3 pos)
	{
		return default(GameTown);
	}
	
	void ChooseRespawn(UnityEngine.Vector3 pos, float angle)
	{
	}
	
	GameTown ChooseRespawn(TNet.List<GameTown> towns)
	{
		return default(GameTown);
	}
	
	void Respawn(int townID, UnityEngine.Vector3 pos, float angle, bool reset)
	{
	}
	
	static GamePlayer Find(int playerID)
	{
		return default(GamePlayer);
	}
	
	static GamePlayer Find(string playerName)
	{
		return default(GamePlayer);
	}
	
	static void Save(bool encoded)
	{
	}
	
	static System.Byte[] ChooseData(System.Byte[] a, System.Byte[] b)
	{
		return default(System.Byte[]);
	}
	
	static void Load(OnLoadCallback callback)
	{
	}
	
	static void OnLoadServerFile(string filename, System.Byte[] data)
	{
	}
	
	static void OnLoadFile(string filename, System.Byte[] data)
	{
	}
	
	static bool Contains(TNet.DataNode equipment, PlayerItem item)
	{
		return default(bool);
	}
	
	bool AttachScripts()
	{
		return default(bool);
	}
	
	void SafeRespawn()
	{
	}
	
	void GiveItem(PlayerItem item)
	{
	}
	
	void GiveItem(PlayerItem item, int source)
	{
	}
	
	void OnGive(PlayerItem item, int source)
	{
	}
	
	void AdjustReputation(int withFaction, int amount)
	{
	}
	
	void AddRep(int factionID, int amount)
	{
	}
	
	void ClearSummary()
	{
	}
	
	static bool get_keepRecords()
	{
		return default(bool);
	}
	
	int get_summaryDamage()
	{
		return default(int);
	}
	
	void set_summaryDamage(int @value)
	{
	}
	
	int get_summaryRepair()
	{
		return default(int);
	}
	
	void set_summaryRepair(int @value)
	{
	}
	
	int get_summaryCapture()
	{
		return default(int);
	}
	
	void set_summaryCapture(int @value)
	{
	}
	
	int get_summaryDefend()
	{
		return default(int);
	}
	
	void set_summaryDefend(int @value)
	{
	}
	
	int get_summaryKills()
	{
		return default(int);
	}
	
	void set_summaryKills(int @value)
	{
	}
	
	int get_summaryDeaths()
	{
		return default(int);
	}
	
	void set_summaryDeaths(int @value)
	{
	}
	
	int get_summaryRep()
	{
		return default(int);
	}
	
	void set_summaryRep(int @value)
	{
	}
	
	void RecordDamage(float val)
	{
	}
	
	void OnDMG(int intDmg)
	{
	}
	
	void RecordCapture()
	{
	}
	
	void RecordDefend()
	{
	}
	
	void OnCap()
	{
	}
	
	void OnDef()
	{
	}
	
	void PeriodicStatUpdate()
	{
	}
	
	void OnSS(int damage, int repair, int capture, int defended, int kills, int deaths, int rep)
	{
	}
	
	void OnNetworkPlayerLeave(TNet.Player p)
	{
	}
	
	void CheckStats(int requestingPlayer)
	{
	}
	
	void OnStats(System.Collections.Generic.List<NamedInt> stats)
	{
	}
	
	int GetCounter(string name)
	{
		return default(int);
	}
	
	float GetDamageMultiplier(string shipPrefab)
	{
		return default(float);
	}
	
public bool isMe
{
    get
    {
        return (this.netPlayer == TNManager.player);
    }
}
 

 


	#endregion 
	
	#region " Fields stubs "
	// Do not add or update any field. If compilation fails because of a field declaration, comment it
	static GamePlayer me;
	static TNet.List<GamePlayer> list;
	TNet.Player netPlayer;
	int ping;
	GameShip ship;
	string steamID;
	string steamUser;
	string ipAddress;
	bool isVACBanned;
	TNet.DataNode mShipItem;
	int mCargoSlots;
	string mPrefab;
	string mCountryCode;
	int mStartingFaction;
	bool mAFK;
	int mCombatSeconds;
	bool hasPing;
	bool mHasShip;
	bool mRespawnStarted;
	bool mReadyToRespawn;
	bool mRespawning;
	static OnLoadCallback mOnLoad;
	static bool mServerSide;
	static string mPlayerFile;
	static string mVaultFile;
	int mSumDamage;
	int mSumRepair;
	int mSumCap;
	int mSumDef;
	int mSumKill;
	int mSumDeath;
	int mSumRep;
	#endregion 

}