private void button1_Click(object sender, EventArgs e)
{
EloProcessor ep = new EloProcessor();
ep.ProcessMatches(textBoxMatchLinks.Text, textBoxMapLinks.Text, textBoxAPIKey.Text);
SpreadsheetManager.UpdateSheet(ep.getPlayerList());
}
void Awake()
{
ConnectionCheck();
if (!_hasInternetConnection)
{
useGoogleSheets = false;
}
//For google play store release
useGoogleSheets = false;
if (!useGoogleSheets)
{
return;
}
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Enemies"), UpdateEnemies);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Stats", "A3", "B4", "A", 3), UpdatePlayer);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Stats", "A6", "D10", "A", 6), UpdatePlayerAbilities);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Trash", "A2", "A3", "A", 2), UpdateTower);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Trash", "A27", "C28", "A", 27), UpdateTower2);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Trash", "A27", "C28", "A", 27), UpdatePickUp);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Trash", "A6", "H16", "A", 6), UpdateTowerUpgrades);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Trash", "A23", "B24", "A", 23), UpdateTrashCans);
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, "Trash", "A19", "C20", "A", 19), UpdateBarricades);
}
void ExportSheet(string sheetId, string sheetName)
{
Debug.Log($"sheetName: {sheetName}");
EditorUtility.DisplayProgressBar("Reading From Google Sheet ", $"Sheet: {sheetName}", GetProcess());
var gstuSearch = new GSTU_Search(sheetId, sheetName, "A1", "Z10000");
SpreadsheetManager.Read(gstuSearch, ReadSheetCallback);
}
public Context()
{
SpreadsheetManager = new SpreadsheetManager(CardDataDirectory);
TemplateManager = new TemplateManager(TemplatesDirectory);
CardImageManager = new ImageManager(ImagesDirectory);
FormattingManager = new FormattingManager(this);
MacroManager = new MacroManager(this);
}
private void CreateWarehouseInfo(GstuSpreadSheet sheet)
{
SpreadsheetManager.Write(new GSTU_Search(associatedSheet, warehouseInfoWorksheet,
"A2"), new ValueRange(warehouseXDim.ToString()), null);
SpreadsheetManager.Write(new GSTU_Search(associatedSheet, warehouseInfoWorksheet,
"B2"), new ValueRange(warehouseYDim.ToString()), null);
}
private void UpdateRespectBuildings(Action onComplete)
{
SpreadsheetManager.Read(new GSTU_Search(m_sheetName, m_respectWorksheetName), sheet =>
{
SetData(sheet, m_respectConfigs, m_startRespectRow);
Debug.Log("[Balance Mapper] Respect Configs Updated");
UpdateDollarsBuildings(onComplete);
});
}
private void UpdateDollarsBuildings(Action onComplete)
{
SpreadsheetManager.Read(new GSTU_Search(m_sheetName, m_dollarsWorksheetName), sheet =>
{
SetData(sheet, m_dollarsConfigs, m_startDollarsRow);
Debug.Log("[Balance Mapper] Dollars Configs Updated");
onComplete?.Invoke();
});
}
private void ExportSheet(string sheetId, string sheetName, string startCell, string endCell, bool buildText)
{
isBuildText = buildText;
Debug.Log($"sheetName: {sheetName}");
EditorUtility.DisplayProgressBar("Reading From Google Sheet ", $"Sheet: {sheetName}", GetProcess());
var gstuSearch = new GSTU_Search(sheetId, sheetName, startCell, endCell);
SpreadsheetManager.Read(gstuSearch, ReadSheetCallback);
}
public void btn_LoadWarehouse()
{
DestroyAllWarehouseObjects();
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, warehouseItemsWorksheet), ImportWarehouseInventoryData);
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, warehouseInfoWorksheet), LoadWarehouseInfo);
AllCanvasTool.instance.EnableCanvas(defaultCanvasName, true);
}
// GET: Patient/Export
public FileStreamResult Export(string pid, string nhc, string nuhsa, string name, string surnames,
PatientStatus?patientStatus, string birthFrom, string birthTo, string sorting)
{
var patientData = _patientService.DeepSearch(pid, nhc, nuhsa, name, surnames,
patientStatus, birthFrom, birthTo, sorting, 1, ExportSize);
var dataStream = SpreadsheetManager.ExportPatientData(patientData);
return(File(dataStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", Strings.ExportedFileName + ".xlsx"));
}
public void ReadInstancesSheet(string googleKey, string sheet, bool isPrivate)
{
if (isPrivate)
{
SpreadsheetManager.Read(new GSTU_Search(googleKey, sheet), onSheetInstancesRead);
}
else
{
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(googleKey, sheet), onSheetInstancesRead);
}
}
/// <summary>
/// Adds the new animal to the spreadsheet online at the location defined as start cell, if no start cell defined will write from A1
/// </summary>
void WriteToSheet()
{
List <string> list = new List <string>();
list.Add(animal.name);
list.Add(animal.health.ToString());
list.Add(animal.attack.ToString());
list.Add(animal.defence.ToString());
SpreadsheetManager.Write(new GSTU_Search(animal.associatedSheet, animal.associatedWorksheet, "G10"), new ValueRange(list), null);
}
void UpdateStats()
{
if (sheetStatus == SheetStatus.PRIVATE)
{
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, associatedWorksheet), UpdateAllAnimals);
}
else if (sheetStatus == SheetStatus.PUBLIC)
{
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(associatedSheet, associatedWorksheet), UpdateAllAnimals);
}
}
/// <summary>
/// Appends the new animal to the spreadsheet online
/// </summary>
void AppendToSheet()
{
List <string> list = new List <string>()
{
animal.name,
animal.health.ToString(),
animal.attack.ToString(),
animal.defence.ToString()
};
SpreadsheetManager.Append(new GSTU_Search(animal.associatedSheet, animal.associatedWorksheet), new ValueRange(list), null);
}
public void DataDownload()
{
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(SheetID, "Scenario", "A1", "Z1000"), (x) => OnReceiveScenario(x));
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(SheetID, "Job", "A1", "Z1000"), (x) => OnReceiveJob(x));
//Scene
//Place
//Job
//Item
//Ability
//Event
//Enemy
}
public void btn_CreateNewWarehouse()
{
DestroyAllWarehouseObjects();
warehouseXDim = float.Parse(warehouseXDimInput.text);
warehouseYDim = float.Parse(warehouseYDimInput.text);
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, warehouseItemsWorksheet),
CreateWarehouseInfo);
CreateWarehouseBounds();
AllCanvasTool.instance.EnableCanvas(defaultCanvasName, true);
}
static void Main()
{
var spreadsheetManager = new SpreadsheetManager();
spreadsheetManager.Connect(ConfigurationManager.AppSettings["Google_UserName"], ConfigurationManager.AppSettings["Google_Password"], ConfigurationManager.AppSettings["DatabaseName"], 0);
var mainProducts = new List <MainProduct>();
foreach (ListEntry mainProductEntry in spreadsheetManager.GetAllRows().Entries)
{
if (mainProductEntry.Elements[0].Value != "Main")
{
continue;
}
if (mainProductEntry.Elements[1].Value == null || mainProductEntry.Elements[2].Value == null)
{
continue;
}
var mainProduct = new MainProduct
{
ID = mainProductEntry.Elements[1].Value,
Name = mainProductEntry.Elements[2].Value,
Description = mainProductEntry.Elements[3].Value
};
var query = "producttype = \"" + mainProduct.ID + "\"";
var subProductList = spreadsheetManager.Query(query);
foreach (ListEntry subproductEntry in subProductList.Entries)
{
mainProduct.SubProducts.Add(new SubProduct(subproductEntry.Elements[1].Value,
subproductEntry.Elements[2].Value, subproductEntry.Elements[4].Value,
subproductEntry.Elements[5].Value));
}
mainProduct.Initialize();
mainProducts.Add(mainProduct);
}
// Upload
foreach (var mainproduct in mainProducts)
{
Uploader.Upload(mainproduct);
}
}
// Fill our item list with data from Google Doc
private void FillItemList()
{
// Do not re-fill the item list if user is not loading data AND has the BossSync option turned off
if ((ProgramState.CurrentState != ProgramState.states.Drops) && !bool.Parse(ProgramControl.Options.GetOptionValue(BossSyncOption.Name())))
{
Debug.Log($"Not filling item list");
return;
}
Debug.Log("filling item list");
itemList.Clear();
itemList.haveRareDropsBeenAdded = false;
// Read in the spreadsheet with item data for the new boss
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search
(sheetID, (CacheManager.currentBoss.bossName + " " + ProgramControl.Options.GetOptionValue(RSVersionOption.Name()))), itemList.FillItemList);
}
static void Main()
{
var spreadsheetManager = new SpreadsheetManager();
spreadsheetManager.Connect(ConfigurationManager.AppSettings["Google_UserName"], ConfigurationManager.AppSettings["Google_Password"], ConfigurationManager.AppSettings["DatabaseName"], 0);
var mainProducts = new List<MainProduct>();
foreach (ListEntry mainProductEntry in spreadsheetManager.GetAllRows().Entries)
{
if (mainProductEntry.Elements[0].Value != "Main") continue;
if (mainProductEntry.Elements[1].Value == null || mainProductEntry.Elements[2].Value == null) continue;
var mainProduct = new MainProduct
{
ID = mainProductEntry.Elements[1].Value,
Name = mainProductEntry.Elements[2].Value,
Description = mainProductEntry.Elements[3].Value
};
var query = "producttype = \"" + mainProduct.ID + "\"";
var subProductList = spreadsheetManager.Query(query);
foreach (ListEntry subproductEntry in subProductList.Entries)
{
mainProduct.SubProducts.Add(new SubProduct(subproductEntry.Elements[1].Value,
subproductEntry.Elements[2].Value, subproductEntry.Elements[4].Value,
subproductEntry.Elements[5].Value));
}
mainProduct.Initialize();
mainProducts.Add(mainProduct);
}
// Upload
foreach (var mainproduct in mainProducts)
{
Uploader.Upload(mainproduct);
}
}
public void ChooseMessage()
{
if (Luck == true)
{
SpreadsheetManager.Read(new GSTU_Search(GSheet, "ManagersLuck"), UpdateText);
}
if (Cash == true)
{
SpreadsheetManager.Read(new GSTU_Search(GSheet, "Cash"), UpdateText);
}
if (Selection == true)
{
SpreadsheetManager.Read(new GSTU_Search(GSheet, "Selection"), UpdateText);
}
}
private void UpdateWarehouseData(GstuSpreadSheet sheet)
{
//Begin wiping old data--------------------------------------------------------------------------------------------------
BatchRequestBody updateRequest = new BatchRequestBody();
foreach (var warehouseUUID in sheet.columns["UUID"])
{
if (warehouseUUID.value != "UUID")
{
updateRequest.Add(sheet[warehouseUUID.value, "Box Dim"].AddCellToBatchUpdate(associatedSheet, warehouseItemsWorksheet,
""));
updateRequest.Add(sheet[warehouseUUID.value, "Position"].AddCellToBatchUpdate(associatedSheet, warehouseItemsWorksheet,
""));
updateRequest.Add(sheet[warehouseUUID.value, "UUID"].AddCellToBatchUpdate(associatedSheet, warehouseItemsWorksheet,
""));
}
}
updateRequest.Send(associatedSheet, warehouseItemsWorksheet, null);
//End wiping old data-------------------------------------------------------------------------------------------------------
//Begin importing new data--------------------------------------------------------------------------------------------------
List <List <string> > warehouseObjectImportList = new List <List <string> >();
foreach (KeyValuePair <string, WarehouseObject> pair in objectsInWarehouse)
{
List <string> temp = new List <string>()
{
pair.Value.UUID,
pair.Value.objTransform.localScale.ToString(),
pair.Value.objTransform.position.ToString()
};
warehouseObjectImportList.Add(temp);
}
SpreadsheetManager.Write(new GSTU_Search(associatedSheet,
warehouseItemsWorksheet, "A2"), new ValueRange(warehouseObjectImportList), null);
//End importing new data----------------------------------------------------------------------------------------------------
}
public void submit_information()
{
string time = System.DateTime.Now.ToString("h:mm:ss");
list.Add(time);
name_field = _name.text;
print(name_field);
lastName_field = lastName.text;
print(lastName_field);
mail_field = mail.text;
print(mail_field);
enterprise_field = enterprise.text;
print(enterprise_field);
list.Add(name_field);
list.Add(lastName_field);
list.Add(mail_field);
list.Add(enterprise_field);
SpreadsheetManager.Write(new GSTU_Search(associatedSheet, associatedWorkSheet, "A" + k), new ValueRange(list), null);
k++;
list.Clear();
SceneManager.LoadScene(1);
}
public void Sync()
{
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, associatedWorksheet), OnSheetLoaded);
}
void Awake()
{
SpreadsheetManager.Read(new GSTU_Search("1CN1DYKG_ZcYQxbzcMlCx-TCWbpGhlV8olewa0P106J4", "Monde2"), Bado);
DontDestroyOnLoad(gameObject);
}
public void btn_UpdateWarehouseInformation()
{
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, associatedWorksheet), UpdateWarehouseData);
}
// Combine all lists into a single dictionary<int itemID, SetupItem item>
public static void Setup(string sheetID)
{
// Load food
foreach (FoodSO foodData in items.foodList)
{
// Make sure this itemID isn't already taken; typos or mistakes in data entry
if (data.ContainsKey(foodData.itemID))
{
SetupItem item;
data.TryGetValue(foodData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {foodData.itemName}, ID: {foodData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
Food food = new Food(foodData);
foodList.Add(new SetupItemStruct(foodData.itemID, foodData.itemName));
data.Add(food.itemID, food);
}
// Load potions
foreach (PotionSO potionData in items.potionList)
{
if (data.ContainsKey(potionData.itemID))
{
SetupItem item;
data.TryGetValue(potionData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {potionData.itemName}, ID: {potionData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
Potion potion = new Potion(potionData);
potionList.Add(new SetupItemStruct(potionData.itemID, potionData.itemName));
data.Add(potion.itemID, potion);
}
// Load pouches
foreach (SummoningPouchSO pouchData in items.summoningPouchList)
{
if (data.ContainsKey(pouchData.itemID))
{
SetupItem item;
data.TryGetValue(pouchData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {pouchData.itemName}, ID: {pouchData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
SummoningPouch pouch = new SummoningPouch(pouchData);
pouchList.Add(new SetupItemStruct(pouchData.itemID, pouchData.itemName));
data.Add(pouch.itemID, pouch);
}
// Load scrolls
foreach (SummoningScrollSO scrollData in items.summoningScrollList)
{
if (data.ContainsKey(scrollData.itemID))
{
SetupItem item;
data.TryGetValue(scrollData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {scrollData.itemName}, ID: {scrollData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
SummoningScroll scroll = new SummoningScroll(scrollData);
scrollList.Add(new SetupItemStruct(scrollData.itemID, scrollData.itemName));
data.Add(scroll.itemID, scroll);
}
// Load nondegradeable armour
foreach (NondegradeArmourSO armourData in items.nondegradeArmourList)
{
if (data.ContainsKey(armourData.itemID))
{
SetupItem item;
data.TryGetValue(armourData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {armourData.itemName}, ID: {armourData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
NondegradableArmour armour = new NondegradableArmour(armourData);
data.Add(armour.itemID, armour);
AddToArmourList(new SetupItemStruct(armour.itemID, armour.itemName), armour.GetItemCategory());
}
// Load augmented armour
foreach (AugArmourSO armourData in items.augmentedArmourList)
{
if (data.ContainsKey(armourData.itemID))
{
SetupItem item;
data.TryGetValue(armourData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {armourData.itemName}, ID: {armourData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
AugmentedArmour armour = new AugmentedArmour(armourData);
data.Add(armour.itemID, armour);
AddToArmourList(new SetupItemStruct(armour.itemID, armour.itemName), armour.GetItemCategory());
}
// Load degradable armour
foreach (DegradableArmourSO armourData in items.degradableArmourList)
{
if (data.ContainsKey(armourData.itemID))
{
SetupItem item;
data.TryGetValue(armourData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {armourData.itemName}, ID: {armourData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
DegradableArmour armour = new DegradableArmour(armourData);
data.Add(armour.itemID, armour);
AddToArmourList(new SetupItemStruct(armour.itemID, armour.itemName), armour.GetItemCategory());
}
// Load time-degrade armour
foreach (TimeDegradeArmourSO armourData in items.timeDegradeArmourList)
{
if (data.ContainsKey(armourData.itemID))
{
SetupItem item;
data.TryGetValue(armourData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {armourData.itemName}, ID: {armourData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
//create and add armour
TimeDegradeArmour armour = new TimeDegradeArmour(armourData);
data.Add(armour.itemID, armour);
AddToArmourList(new SetupItemStruct(armour.itemID, armour.itemName), armour.GetItemCategory());
}
// Load nondegradable weapons
foreach (NondegradeWeaponSO weaponData in items.nondegradeWeaponList)
{
if (data.ContainsKey(weaponData.itemID))
{
SetupItem item;
data.TryGetValue(weaponData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {weaponData.itemName}, ID: {weaponData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
NondegradableWeapon weapon = new NondegradableWeapon(weaponData);
data.Add(weapon.itemID, weapon);
AddToWeaponList(new SetupItemStruct(weapon.itemID, weapon.itemName), weapon.GetItemCategory());
}
// Load augmented weapons
foreach (AugWeaponSO weaponData in items.augmentedWeaponList)
{
if (data.ContainsKey(weaponData.itemID))
{
SetupItem item;
data.TryGetValue(weaponData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {weaponData.itemName}, ID: {weaponData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
AugmentedWeapon weapon = new AugmentedWeapon(weaponData);
data.Add(weapon.itemID, weapon);
AddToWeaponList(new SetupItemStruct(weapon.itemID, weapon.itemName), weapon.GetItemCategory());
}
// Load degradable weapons
foreach (DegradableWeaponSO weaponData in items.degradableWeaponList)
{
if (data.ContainsKey(weaponData.itemID))
{
SetupItem item;
data.TryGetValue(weaponData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {weaponData.itemName}, ID: {weaponData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
DegradableWeapon weapon = new DegradableWeapon(weaponData);
data.Add(weapon.itemID, weapon);
AddToWeaponList(new SetupItemStruct(weapon.itemID, weapon.itemName), weapon.GetItemCategory());
}
// Load general items
foreach (GeneralItemSO generalItemData in items.generalItemList)
{
if (data.ContainsKey(generalItemData.itemID))
{
SetupItem item;
data.TryGetValue(generalItemData.itemID, out item);
Debug.Log($"Trying to add item [ Name: {generalItemData.itemName}, ID: {generalItemData.itemID} ] failed! Item [ Name: {item.itemName} ] with that ID already exists!");
continue;
}
General genItem = new General(generalItemData);
data.Add(genItem.itemID, genItem);
generalItemList.Add(new SetupItemStruct(genItem.itemID, genItem.itemName));
}
// Unload the ScriptableObjects collection
Resources.UnloadAsset(items);
// Sort each list alphabetically
foreach (List <SetupItemStruct> list in listSetupItemStructLists)
{
list.Sort();
}
// Load prices from GDoc
SpreadsheetManager.ReadPublicSpreadsheet(new GSTU_Search(sheetID, SHEETNAME, STARTCELL, ENDCELL), LoadPrices);
}
void UpdateStats(UnityAction <GstuSpreadSheet> callback, bool mergedCells = false)
{
SpreadsheetManager.Read(new GSTU_Search(animal.associatedSheet, animal.associatedWorksheet), callback, mergedCells);
}
private void Read()
{
SpreadsheetManager.Read(new GSTU_Search(sheetId, worksheetName), UpdateJson);
}
/// <summary>
/// Finds and updates the rows data based on an entry row data, in this example i am using the name as the unique id to find the starting cell for the row
/// If the spreadsheet is cashed then no need to do the read and can just pass into the update
/// </summary>
void UpdateAnimalInformationOnSheet()
{
SpreadsheetManager.Read(new GSTU_Search(animal.associatedSheet, animal.associatedWorksheet), UpdateAnimalInformation);
}
/// <summary>
/// Finds the cell we need to update and then updates the information
/// If the spreadsheet is cashed then no need to do the read and can just pass into the update
/// </summary>
private void UpdateAnimalHealth()
{
SpreadsheetManager.Read(new GSTU_Search(animal.associatedSheet, animal.associatedWorksheet), UpdateAnimalHealth);
}
void UpdateStats()
{
SpreadsheetManager spreadsheetManager = new SpreadsheetManager();
SpreadsheetManager.Read(new GSTU_Search(associatedSheet, associatedWorksheet), UpdateEverything, false);
}